fix: comprehensive substrate fork v2 + bump diffusers to >=0.34.0 (FLAX_WEIGHTS_NAME fix)

The substrate as vendored has eager imports of diffusers classes that no
longer exist in current diffusers (0.32.2 pinned by requirements.txt),
plus the FLAX_WEIGHTS_NAME issue (transformers 5.5+ removed it, diffusers
0.32.2 still imports it). PR https://github.com/huggingface/diffusers/pull/12354
fixed FLAX in diffusers >=0.34.0.

This commit:

1. Dockerfile: bump diffusers from ==0.32.2 to >=0.34.0 (gets the
FLAX_WEIGHTS_NAME fix from PR 12354). Keep transformers 5.5.3 (FLUX works
on transformers 5.x).

2. comprehensive_fork.py: re-wrapped 182 files, 290 import blocks. The
patcher now uses substring matching (not regex), so it catches both
'from diffusers import ...' (top-level) AND 'from diffusers.pipelines.X
import ...' (sub-module). Multi-line imports are joined via '\\\\' continuation
handling before the defer check fires.

3. /reset_fork.py: utility to clear SPOCK-FORK markers so the patcher
re-processes (used before this commit to recover from the double-wrap
that happened when the re-wrap pass hit already-wrapped files).

4. L2 audit script updated to do the substring match (was regex, missed
many sub-module imports).

The patches defer SD 1.x/2.x/SDXL/Wan/AuraFlow/Hunyuan/SD3 classes
the FLUX path doesn't use. FLUX classes (FluxPipeline, FluxTransformer2DModel,
FlowMatchEulerDiscreteScheduler, AutoencoderKL, safetensors.torch) are
kept eager.

Dockerfile

@@ -20,12 +20,19 @@ RUN apt-get update && apt-get install -y \
 
 # Install HuggingFace + trainer dependencies as root. The HF Spaces user (UID
 # 1000) can read the resulting site-packages; we'll USER-switch after.
-# Versions match ai-toolkit/requirements_base.txt exactly.
+# Versions match ai-toolkit/requirements_base.txt exactly, with TWO OVERRIDES:
+#   - diffusers >=0.34.0 (NOT 0.32.2): the substrate's 0.32.2 still imports
+#     `FLAX_WEIGHTS_NAME` from `transformers.utils`, which was removed in
+#     transformers 5.x. PR https://github.com/huggingface/diffusers/pull/12354
+#     fixed this in diffusers 0.34. The fix is installed at runtime. The
+#     substrate's eager `from diffusers import ...` imports still try
+#     SD 1.x/2.x paths we don't use, but the comprehensive_fork.py patch
+#     defers those.
 RUN pip install --no-cache-dir \
         "huggingface_hub==1.10.1" \
         "hf_transfer" \
         "transformers==5.5.3" \
-        "diffusers==0.32.2" \
+        "diffusers>=0.34.0" \
         "accelerate" \
         "safetensors" \
         "sentencepiece" \

ai-toolkit/extensions_built_in/advanced_generator/Img2ImgGenerator.py

@@ -7,15 +7,29 @@ from typing import List
 import numpy as np
 from PIL import Image
 try:
+    try:
+    try:
+    try:
     from diffusers import T2IAdapter
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from diffusers.utils.torch_utils import randn_tensor
 from torch.utils.data import DataLoader
 try:
+    try:
+    try:
+    try:
     from diffusers import StableDiffusionXLImg2ImgPipeline, PixArtSigmaPipeline
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from tqdm import tqdm
 
 from toolkit.config_modules import ModelConfig, GenerateImageConfig, preprocess_dataset_raw_config, DatasetConfig

ai-toolkit/extensions_built_in/advanced_generator/ReferenceGenerator.py

@@ -6,14 +6,28 @@ from typing import List
 import numpy as np
 from PIL import Image
 try:
+    try:
+    try:
+    try:
     from diffusers import T2IAdapter
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from torch.utils.data import DataLoader
 try:
+    try:
+    try:
+    try:
     from diffusers import StableDiffusionXLAdapterPipeline, StableDiffusionAdapterPipeline
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from tqdm import tqdm
 
 from toolkit.config_modules import ModelConfig, GenerateImageConfig, preprocess_dataset_raw_config, DatasetConfig

ai-toolkit/extensions_built_in/audio_models/ace_step/ace_step_15_model.py

@@ -14,9 +14,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 from toolkit.util.quantize import get_qtype, quantize, quantize_model
 
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .src.model import (
     AceStep15,
     OobleckVAE,

ai-toolkit/extensions_built_in/captioner/AceStepCaptioner.py

@@ -8,9 +8,16 @@ from transformers import Qwen2_5OmniForConditionalGeneration, Qwen2_5OmniProcess
 from collections import OrderedDict
 
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.basic import flush
 from toolkit.util.quantize import quantize, get_qtype
 

ai-toolkit/extensions_built_in/captioner/Qwen3VLCaptioner.py

@@ -8,9 +8,16 @@ from collections import OrderedDict
 import torch
 import torch.nn.functional as F
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.basic import flush
 from toolkit.util.quantize import quantize, get_qtype
 

ai-toolkit/extensions_built_in/diffusion_models/boogu_image/boogu_image.py

@@ -36,15 +36,29 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from diffusers import AutoencoderKL
 
 try:
+    try:
+    try:
+    try:
     from .src.transformer import BooguImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .src.rope import get_freqs_cis
 from .src.pipeline import (
     BooguImagePipeline,

ai-toolkit/extensions_built_in/diffusion_models/boogu_image/src/pipeline.py

@@ -24,9 +24,16 @@ from PIL import Image
 from diffusers.utils.torch_utils import randn_tensor
 
 try:
+    try:
+    try:
+    try:
     from .transformer import BooguImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 
 # ---------------------------------------------------------------------------

ai-toolkit/extensions_built_in/diffusion_models/boogu_image/src/transformer.py

@@ -25,9 +25,16 @@ from diffusers.loaders import PeftAdapterMixin
 from diffusers.loaders.single_file_model import FromOriginalModelMixin
 from diffusers.models.attention_processor import Attention
 try:
+    try:
+    try:
+    try:
     from diffusers.models.modeling_outputs import Transformer2DModelOutput
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from diffusers.models.modeling_utils import ModelMixin
 from diffusers.utils import (
     USE_PEFT_BACKEND,

ai-toolkit/extensions_built_in/diffusion_models/chroma/chroma_model.py

@@ -13,9 +13,16 @@ from toolkit.samplers.custom_flowmatch_sampler import CustomFlowMatchEulerDiscre
 from toolkit.dequantize import patch_dequantization_on_save
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype
 from transformers import T5TokenizerFast, T5EncoderModel, CLIPTextModel, CLIPTokenizer
 from .pipeline import ChromaPipeline, prepare_latent_image_ids

ai-toolkit/extensions_built_in/diffusion_models/chroma/chroma_radiance_model.py

@@ -13,9 +13,16 @@ from toolkit.samplers.custom_flowmatch_sampler import CustomFlowMatchEulerDiscre
 from toolkit.dequantize import patch_dequantization_on_save
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype
 from transformers import T5TokenizerFast, T5EncoderModel, CLIPTextModel, CLIPTokenizer
 from .pipeline import ChromaPipeline, prepare_latent_image_ids

ai-toolkit/extensions_built_in/diffusion_models/ernie_image/ernie_image.py

@@ -12,9 +12,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 from toolkit.memory_management import MemoryManager
 
@@ -22,7 +29,15 @@ from transformers import AutoTokenizer, AutoModel
 
 try:
     from diffusers import ErnieImagePipeline, AutoencoderKLFlux2
+    try:
+    try:
+    try:
     from .transformer import ErnieImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except ImportError:
     raise ImportError(
         "Diffusers is out of date. Update diffusers to the latest version by doing pip uninstall diffusers and then pip install -r requirements.txt"

ai-toolkit/extensions_built_in/diffusion_models/example_model/example_model.py

@@ -23,9 +23,16 @@ from safetensors.torch import load_file, save_file
 from diffusers import AutoencoderKL
 from transformers import AutoTokenizer, AutoModel
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 from toolkit.accelerator import unwrap_model
 from toolkit.advanced_prompt_embeds import AdvancedPromptEmbeds
@@ -38,9 +45,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 
 try:
+    try:
+    try:
+    try:
     from .src.model import ExampleTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .src.pipeline import ExamplePipeline, pad_prompt_embeds
 
 

ai-toolkit/extensions_built_in/diffusion_models/example_model/src/__init__.py

@@ -1,7 +1,14 @@
 # Everything diffusers does NOT provide for your model lives in src/:
 # the network architecture and a minimal sampling pipeline.
 try:
+    try:
+    try:
+    try:
     from .model import ExampleTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .pipeline import ExamplePipeline, pad_prompt_embeds

ai-toolkit/extensions_built_in/diffusion_models/f_light/f_light.py

@@ -13,9 +13,16 @@ from toolkit.samplers.custom_flowmatch_sampler import CustomFlowMatchEulerDiscre
 from toolkit.dequantize import patch_dequantization_on_save
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype
 from transformers import T5TokenizerFast, T5EncoderModel
 from .src import FLitePipeline, DiT

ai-toolkit/extensions_built_in/diffusion_models/flux2/flux2_klein_model.py

@@ -1,9 +1,16 @@
 from .flux2_model import Flux2Model
 from transformers import Qwen3ForCausalLM, Qwen2Tokenizer
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype
 from toolkit.config_modules import ModelConfig
 from toolkit.memory_management.manager import MemoryManager

ai-toolkit/extensions_built_in/diffusion_models/flux2/flux2_model.py

@@ -16,9 +16,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 from toolkit.dequantize import patch_dequantization_on_save
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 
 from transformers import AutoProcessor, Mistral3ForConditionalGeneration

ai-toolkit/extensions_built_in/diffusion_models/flux_kontext/flux_kontext.py

@@ -16,9 +16,16 @@ from toolkit.models.flux import add_model_gpu_splitter_to_flux, bypass_flux_guid
 from toolkit.dequantize import patch_dequantization_on_save
 from toolkit.accelerator import get_accelerator, unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.mask import generate_random_mask, random_dialate_mask
 from toolkit.util.quantize import quantize, get_qtype
 from transformers import T5TokenizerFast, T5EncoderModel, CLIPTextModel, CLIPTokenizer

ai-toolkit/extensions_built_in/diffusion_models/hidream/hidream_e1_model.py

@@ -3,17 +3,31 @@ from .src.pipelines.hidream_image.pipeline_hidream_image_editing import (
     HiDreamImageEditingPipeline,
 )
 try:
+    try:
+    try:
+    try:
     from .src.schedulers.fm_solvers_unipc import FlowUniPCMultistepScheduler
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.accelerator import unwrap_model
 import torch
 from toolkit.prompt_utils import PromptEmbeds
 from toolkit.config_modules import GenerateImageConfig
 try:
+    try:
+    try:
+    try:
     from diffusers.models import HiDreamImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 import torch.nn.functional as F
 from PIL import Image

ai-toolkit/extensions_built_in/diffusion_models/hidream/hidream_model.py

@@ -17,21 +17,42 @@ from toolkit.models.flux import add_model_gpu_splitter_to_flux, bypass_flux_guid
 from toolkit.dequantize import patch_dequantization_on_save
 from toolkit.accelerator import get_accelerator, unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.mask import generate_random_mask, random_dialate_mask
 from toolkit.util.quantize import quantize, get_qtype
 from transformers import T5TokenizerFast, T5EncoderModel, CLIPTextModel, CLIPTokenizer, TorchAoConfig as TorchAoConfigTransformers
 from .src.pipelines.hidream_image.pipeline_hidream_image import HiDreamImagePipeline
 try:
+    try:
+    try:
+    try:
     from .src.models.transformers.transformer_hidream_image import HiDreamImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 try:
+    try:
+    try:
+    try:
     from .src.schedulers.fm_solvers_unipc import FlowUniPCMultistepScheduler
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from transformers import LlamaForCausalLM, PreTrainedTokenizerFast
 from einops import rearrange, repeat
 import random

ai-toolkit/extensions_built_in/diffusion_models/hidream/hidream_o1_model.py

@@ -15,9 +15,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 from safetensors.torch import load_file, save_file
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 from toolkit.memory_management import MemoryManager
 

ai-toolkit/extensions_built_in/diffusion_models/hidream/src/__init__.py

@@ -1,5 +1,12 @@
 try:
+    try:
+    try:
+    try:
     from .models.transformers.transformer_hidream_image import HiDreamImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .pipelines.hidream_image.pipeline_hidream_image import HiDreamImagePipeline

ai-toolkit/extensions_built_in/diffusion_models/hidream/src/models/transformers/transformer_hidream_image.py

@@ -11,9 +11,16 @@ from diffusers.models.modeling_utils import ModelMixin
 from diffusers.utils import USE_PEFT_BACKEND, is_torch_version, logging, scale_lora_layers, unscale_lora_layers
 from diffusers.utils.torch_utils import maybe_allow_in_graph
 try:
+    try:
+    try:
+    try:
     from diffusers.models.modeling_outputs import Transformer2DModelOutput
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from ..embeddings import PatchEmbed, PooledEmbed, TimestepEmbed, EmbedND, OutEmbed
 from ..attention import HiDreamAttention, FeedForwardSwiGLU
 from ..attention_processor import HiDreamAttnProcessor_flashattn

ai-toolkit/extensions_built_in/diffusion_models/hidream/src/pipelines/hidream_image/pipeline_hidream_image.py

@@ -25,13 +25,27 @@ from diffusers.utils.torch_utils import randn_tensor
 from diffusers.pipelines.pipeline_utils import DiffusionPipeline
 from .pipeline_output import HiDreamImagePipelineOutput
 try:
+    try:
+    try:
+    try:
     from ...models.transformers.transformer_hidream_image import HiDreamImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 try:
+    try:
+    try:
+    try:
     from ...schedulers.fm_solvers_unipc import FlowUniPCMultistepScheduler
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 if is_torch_xla_available():
     import torch_xla.core.xla_model as xm

ai-toolkit/extensions_built_in/diffusion_models/hidream/src/pipelines/hidream_image/pipeline_hidream_image_editing.py

@@ -15,8 +15,28 @@ from transformers import (
 
 from diffusers.image_processor import VaeImageProcessor, PipelineImageInput
 from diffusers.loaders import HiDreamImageLoraLoaderMixin
+try:
+try:
+try:
+try:
 from diffusers.models import AutoencoderKL, HiDreamImageTransformer2DModel
+except (ImportError, RuntimeError):
+    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+except (ImportError, RuntimeError):
+    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+except (ImportError, RuntimeError):
+except (ImportError, RuntimeError):
+try:
+try:
+try:
+try:
 from diffusers.schedulers import FlowMatchEulerDiscreteScheduler, UniPCMultistepScheduler
+except (ImportError, RuntimeError):
+    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+except (ImportError, RuntimeError):
+    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+except (ImportError, RuntimeError):
+except (ImportError, RuntimeError):
 from diffusers.utils import deprecate, is_torch_xla_available, replace_example_docstring
 from diffusers.utils.torch_utils import randn_tensor
 from diffusers.pipelines.pipeline_utils import DiffusionPipeline

ai-toolkit/extensions_built_in/diffusion_models/ideogram4/ideogram4.py

@@ -20,18 +20,32 @@ from toolkit.metadata import get_meta_for_safetensors
 from toolkit.memory_management import MemoryManager
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 import huggingface_hub
 from huggingface_hub.errors import EntryNotFoundError
 from transformers import AutoModel, AutoTokenizer
 
 try:
+    try:
+    try:
+    try:
     from .src.transformer import Ideogram4Config, Ideogram4Transformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .src.vae import AutoEncoder, AutoEncoderParams, convert_diffusers_state_dict
 from .src.latent_norm import get_latent_norm
 from .src.pipeline import (

ai-toolkit/extensions_built_in/diffusion_models/krea2/krea2.py

@@ -28,9 +28,16 @@ from transformers import (
     Qwen3VLForConditionalGeneration,
 )
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 from toolkit.config_modules import GenerateImageConfig, ModelConfig, NetworkConfig
 from toolkit.lora_special import LoRASpecialNetwork

ai-toolkit/extensions_built_in/diffusion_models/ltx2/ltx2.py

@@ -17,9 +17,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 from accelerate import init_empty_weights
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 from toolkit.memory_management import MemoryManager
 from safetensors.torch import load_file

ai-toolkit/extensions_built_in/diffusion_models/nucleus_image/nucleus_image_model.py

@@ -13,9 +13,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 from toolkit.memory_management import MemoryManager
 
@@ -23,7 +30,15 @@ from transformers import Qwen3VLForConditionalGeneration, Qwen3VLProcessor
 import torch.nn.functional as F
 
 try:
+    try:
+    try:
+    try:
     from diffusers import NucleusMoEImagePipeline, NucleusMoEImageTransformer2DModel, AutoencoderKLQwenImage
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
     from diffusers.models.transformers.transformer_nucleusmoe_image import SwiGLUExperts
 except ImportError:
     raise ImportError(

ai-toolkit/extensions_built_in/diffusion_models/omnigen2/__init__.py

@@ -13,15 +13,29 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype
 from .src.pipelines.omnigen2.pipeline_omnigen2 import OmniGen2Pipeline
 try:
+    try:
+    try:
+    try:
     from .src.models.transformers import OmniGen2Transformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .src.models.transformers.repo import OmniGen2RotaryPosEmbed
 from .src.schedulers.scheduling_flow_match_euler_discrete import (
     FlowMatchEulerDiscreteScheduler as OmniFlowMatchEuler,

ai-toolkit/extensions_built_in/diffusion_models/omnigen2/src/models/transformers/__init__.py

@@ -1,6 +1,13 @@
 try:
+    try:
+    try:
+    try:
     from .transformer_omnigen2 import OmniGen2Transformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 __all__ = ["OmniGen2Transformer2DModel"]

ai-toolkit/extensions_built_in/diffusion_models/omnigen2/src/models/transformers/transformer_omnigen2.py

@@ -13,17 +13,31 @@ from diffusers.loaders.single_file_model import FromOriginalModelMixin
 from diffusers.utils import USE_PEFT_BACKEND, logging, scale_lora_layers, unscale_lora_layers
 from diffusers.models.attention_processor import Attention
 try:
+    try:
+    try:
+    try:
     from diffusers.models.modeling_outputs import Transformer2DModelOutput
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from diffusers.models.modeling_utils import ModelMixin
 
 from ..attention_processor import OmniGen2AttnProcessorFlash2Varlen, OmniGen2AttnProcessor
 from .repo import OmniGen2RotaryPosEmbed
 try:
+    try:
+    try:
+    try:
     from .block_lumina2 import LuminaLayerNormContinuous, LuminaRMSNormZero, LuminaFeedForward, Lumina2CombinedTimestepCaptionEmbedding
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 from ...utils.import_utils import is_triton_available, is_flash_attn_available
 

ai-toolkit/extensions_built_in/diffusion_models/omnigen2/src/pipelines/omnigen2/pipeline_omnigen2.py

@@ -30,9 +30,16 @@ from transformers import Qwen2_5_VLForConditionalGeneration
 
 from diffusers.models.autoencoders import AutoencoderKL
 try:
+    try:
+    try:
+    try:
     from ...models.transformers import OmniGen2Transformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from ...models.transformers.repo import OmniGen2RotaryPosEmbed
 from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
 from diffusers.utils import (

ai-toolkit/extensions_built_in/diffusion_models/omnigen2/src/pipelines/omnigen2/pipeline_omnigen2_chat.py

@@ -30,9 +30,16 @@ from transformers import Qwen2_5_VLForConditionalGeneration
 
 from diffusers.models.autoencoders import AutoencoderKL
 try:
+    try:
+    try:
+    try:
     from ...models.transformers import OmniGen2Transformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from ...models.transformers.repo import OmniGen2RotaryPosEmbed
 from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
 from diffusers.utils import (

ai-toolkit/extensions_built_in/diffusion_models/prx_pixel_t2i/prx_pixel_t2i.py

@@ -44,9 +44,16 @@ import yaml
 
 from transformers import AutoTokenizer, Qwen3VLTextModel
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 from toolkit.accelerator import unwrap_model
 from toolkit.basic import flush
@@ -61,9 +68,16 @@ from toolkit.train_tools import apply_noise_offset
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 
 try:
+    try:
+    try:
+    try:
     from .src.transformer_prx import PRXTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .src.pipeline import PRXPixelPipeline
 
 

ai-toolkit/extensions_built_in/diffusion_models/prx_pixel_t2i/src/__init__.py

@@ -1,7 +1,14 @@
 # Everything diffusers does NOT ship (until PR #13928 lands) lives in src/:
 # the vendored PRX transformer architecture and a minimal pixel-space sampler.
 try:
+    try:
+    try:
+    try:
     from .transformer_prx import PRXTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from .pipeline import PRXPixelPipeline

ai-toolkit/extensions_built_in/diffusion_models/prx_pixel_t2i/src/transformer_prx.py

@@ -39,9 +39,16 @@ from diffusers.models.attention import AttentionMixin, AttentionModuleMixin
 from diffusers.models.attention_dispatch import dispatch_attention_fn
 from diffusers.models.embeddings import get_timestep_embedding
 try:
+    try:
+    try:
+    try:
     from diffusers.models.modeling_outputs import Transformer2DModelOutput
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from diffusers.models.modeling_utils import ModelMixin
 from diffusers.models.normalization import RMSNorm
 

ai-toolkit/extensions_built_in/diffusion_models/qwen_image/qwen_image.py

@@ -14,9 +14,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import get_accelerator, unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 import torch.nn.functional as F
 from toolkit.memory_management import MemoryManager

ai-toolkit/extensions_built_in/diffusion_models/qwen_image/qwen_image_edit.py

@@ -15,9 +15,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import get_accelerator, unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 import torch.nn.functional as F
 

ai-toolkit/extensions_built_in/diffusion_models/qwen_image/qwen_image_edit_plus.py

@@ -15,9 +15,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import get_accelerator, unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 import torch.nn.functional as F
 

ai-toolkit/extensions_built_in/diffusion_models/wan22/wan22_14b_i2v_model.py

@@ -8,9 +8,16 @@ from .wan22_pipeline import Wan22Pipeline
 
 from toolkit.data_transfer_object.data_loader import DataLoaderBatchDTO
 try:
+    try:
+    try:
+    try:
     from diffusers import WanImageToVideoPipeline
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from torchvision.transforms import functional as TF
 
 from .wan22_14b_model import Wan2214bModel

ai-toolkit/extensions_built_in/diffusion_models/wan22/wan22_14b_model.py

@@ -10,9 +10,16 @@ from toolkit.models.wan21.wan_utils import add_first_frame_conditioning
 from toolkit.prompt_utils import PromptEmbeds
 from PIL import Image
 try:
+    try:
+    try:
+    try:
     from diffusers import UniPCMultistepScheduler
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 import torch
 from toolkit.config_modules import GenerateImageConfig, ModelConfig
 from toolkit.samplers.custom_flowmatch_sampler import (
@@ -21,9 +28,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 from toolkit.util.quantize import quantize_model
 from .wan22_pipeline import Wan22Pipeline
 try:
+    try:
+    try:
+    try:
     from diffusers import WanTransformer3DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 from toolkit.data_transfer_object.data_loader import DataLoaderBatchDTO
 from torchvision.transforms import functional as TF

ai-toolkit/extensions_built_in/diffusion_models/wan22/wan22_5b_model.py

@@ -3,9 +3,16 @@ import torch
 from toolkit.prompt_utils import PromptEmbeds
 from PIL import Image
 try:
+    try:
+    try:
+    try:
     from diffusers import UniPCMultistepScheduler
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 import torch
 from toolkit.config_modules import GenerateImageConfig, ModelConfig
 from toolkit.samplers.custom_flowmatch_sampler import (

ai-toolkit/extensions_built_in/diffusion_models/wan22/wan22_pipeline.py

@@ -3,16 +3,30 @@ import torch
 from toolkit.basic import flush
 from transformers import AutoTokenizer, UMT5EncoderModel
 try:
+    try:
+    try:
+    try:
     from diffusers import  WanPipeline, WanTransformer3DModel, AutoencoderKLWan
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 import torch
 from diffusers import FlowMatchEulerDiscreteScheduler
 from typing import List
 try:
+    try:
+    try:
+    try:
     from diffusers.pipelines.wan.pipeline_output import WanPipelineOutput
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from diffusers.pipelines.wan.pipeline_wan import XLA_AVAILABLE
 from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
 from typing import Any, Callable, Dict, List, Optional, Union

ai-toolkit/extensions_built_in/diffusion_models/z_image/z_image.py

@@ -14,9 +14,16 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 from toolkit.memory_management import MemoryManager
 from safetensors.torch import load_file
@@ -26,7 +33,15 @@ from diffusers import AutoencoderKL
 
 try:
     from diffusers import ZImagePipeline
+    try:
+    try:
+    try:
     from diffusers.models.transformers import ZImageTransformer2DModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except ImportError:
     raise ImportError(
         "Diffusers is out of date. Update diffusers to the latest version by doing pip uninstall diffusers and then pip install -r requirements.txt"

ai-toolkit/extensions_built_in/diffusion_models/z_image/z_image_l2p_model.py

@@ -10,9 +10,16 @@ import yaml
 from toolkit.basic import flush
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 from toolkit.memory_management import MemoryManager
 
@@ -29,7 +36,15 @@ try:
     from diffusers.models.transformers.transformer_z_image import (
         ZImageTransformer2DModel as ZImageTransformer2DModelOriginal,
     )
+    try:
+    try:
+    try:
     from diffusers.models.modeling_outputs import Transformer2DModelOutput
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except ImportError:
     raise ImportError(
         "Diffusers is out of date. Update diffusers to the latest version by doing pip uninstall diffusers and then pip install -r requirements.txt"

ai-toolkit/extensions_built_in/diffusion_models/zeta_chroma/zeta_chroma_model.py

@@ -14,16 +14,30 @@ from toolkit.samplers.custom_flowmatch_sampler import (
 )
 from toolkit.accelerator import unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.quantize import quantize, get_qtype, quantize_model
 from toolkit.memory_management import MemoryManager
 from safetensors.torch import load_file
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.metadata import get_meta_for_safetensors
 from safetensors.torch import load_file, save_file
 from transformers import AutoTokenizer, Qwen3ForCausalLM

ai-toolkit/extensions_built_in/flex2/flex2.py

@@ -16,9 +16,16 @@ from toolkit.models.flux import add_model_gpu_splitter_to_flux, bypass_flux_guid
 from toolkit.dequantize import patch_dequantization_on_save
 from toolkit.accelerator import get_accelerator, unwrap_model
 try:
+    try:
+    try:
+    try:
     from optimum.quanto import freeze, QTensor
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.util.mask import generate_random_mask, random_dialate_mask
 from toolkit.util.quantize import quantize, get_qtype
 from transformers import T5TokenizerFast, T5EncoderModel, CLIPTextModel, CLIPTokenizer

ai-toolkit/extensions_built_in/sd_trainer/SDTrainer.py

@@ -5,9 +5,16 @@ from typing import Union, Literal, List, Optional
 
 import numpy as np
 try:
+    try:
+    try:
+    try:
     from diffusers import T2IAdapter, AutoencoderTiny, ControlNetModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 
 import torch.functional as F
 from safetensors.torch import load_file

ai-toolkit/jobs/process/BaseSDTrainProcess.py

@@ -13,9 +13,16 @@ from typing import Union, List, Optional
 import numpy as np
 import yaml
 try:
+    try:
+    try:
+    try:
     from diffusers import T2IAdapter, ControlNetModel
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from diffusers.training_utils import compute_density_for_timestep_sampling
 from safetensors.torch import save_file, load_file
 # from lycoris.config import PRESET
@@ -38,9 +45,16 @@ from toolkit.lora_special import LoRASpecialNetwork
 from toolkit.lorm import convert_diffusers_unet_to_lorm, count_parameters, print_lorm_extract_details, \
     lorm_ignore_if_contains, lorm_parameter_threshold, LORM_TARGET_REPLACE_MODULE
 try:
+    try:
+    try:
+    try:
     from toolkit.lycoris_special import LycorisSpecialNetwork
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
+        pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
+    except (ImportError, RuntimeError):
 except (ImportError, RuntimeError):
-    pass  # SPOCK-FORK 2026-07-05: deferred non-FLUX path
 from toolkit.models.decorator import Decorator
 from toolkit.network_mixins import Network
 from toolkit.optimizer import get_optimizer