Upload 7 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: MiniMax-H3 Studio · AI Scenes & Turbo
+title: MiniMax-H3 Studio · Simple & Efficient
 emoji: 🎬
 colorFrom: blue
 colorTo: indigo
@@ -7,7 +7,7 @@ sdk: gradio
 sdk_version: 6.24.0
 app_file: app.py
 pinned: true
-short_description: 'AI scenes, CPU identity, looping LoRAs & Turbo presets'
+short_description: 'Simple video, smart scenes, identity & efficient Turbo'
 suggested_hardware: zero-a10g
 tags:
   - not-for-all-audiences
@@ -22,21 +22,25 @@ tags:
 
 # MiniMax-H3 Studio
 
-**One image. One idea. A planned scene with sound.**
+**One image. One idea. Video with sound — with fewer controls in your way.**
 
-Choose **Simple** for guided creation or **Everything** for all controls. Describe the actions once,
-review the proposed clips and timings, then generate the scene one stage at a time.
+In **Simple**, upload a picture, describe the shot, choose its length and press **Generate**.
+**Balanced** is selected for you. Optional tools stay in closed sections; **Everything** reveals the
+manual settings. For several actions, open the scene planner and review the proposed clips and timings.
 
-**🆕 AI Scene Planner · 🔒 CPU Identity Lock · 🔄 LoRA Refresh · ⚡ Turbo · 🔊 Soundtrack mixer**
+**🆕 Simple quality presets · 📐 Auto picture shape · 🎬 AI Scene Planner · 🔒 Identity Lock · 🔄 Looping LoRA Refresh · 🔊 Soundtrack mixer**
 
 ## Start here
 
-1. Upload a starting image. The default setup is **Turbo v4 EMA, 8 steps, 3 seconds**, on the fast
-   960×544 canvas. Turbo is actually loaded in the first adapter slot, not merely selected in a menu.
-2. Write the shot and press **Do all of it** to use the optional writing Space and H3's structured
-   prompt builder. Leave the writing Space blank to build locally from your words.
-3. For several actions, describe **The whole scene** and press **Split into clips**.
-4. Press **Make the whole scene and join it**, or **Generate** for one clip.
+1. Upload your picture and describe the action, sounds and any dialogue.
+2. Keep **Balanced** for six real denoising steps. Choose **Draft** for four or **Quality** for eight.
+   The default length is three seconds; changing quality keeps your chosen length and custom effects.
+3. Press **Generate**. The Auto canvas follows the picture's proportions using a supported size.
+4. For several actions, open **AI Scene Planner**, describe the scene, split it, review it and generate.
+
+One Turbo adapter is already active. Prompt writing, scene planning and prompt rewriting are optional;
+ordinary Generate does not automatically call the writing model. More references, Identity Lock,
+LoRA tools, profiles and finishing controls remain available in closed sections.
 
 The supplied `h3_quick_test.json` is a small, one-clip setup. Import it under Profiles and upload your
 own image. Importing a profile never starts inference.
@@ -101,7 +105,7 @@ your original wording is preserved. Missing trigger metadata is not proof that a
 
 **Preparation finishes before the video GPU request:**
 
-- Default limit: **1024 MiB per source/converted file**, **2048 MiB across selected adapters**. Turbo
+- Default limit: **1536 MiB per source/converted file**, **2048 MiB across selected adapters**. Turbo
   counts too; a zero-strength adapter does not download or load. These are practical size guards,
   not guarantees of memory fit or model compatibility.
 - Oversized files are hidden from automatic suggestions. Manual selections pass the same checks.
@@ -115,30 +119,60 @@ your original wording is preserved. Missing trigger metadata is not proof that a
 Use `.safetensors` adapters for this `transformer_ref` pipeline. Arbitrary `.pt`/`.bin` checkpoints are
 not accepted by the new bounded safetensors preparation path. WAN/LTX weights are not H3 adapters.
 
-## Less avoidable compute
-
-**Balanced Turbo** uses 8 steps; **Draft Turbo** uses 4 steps and the 544×544 canvas. Both start at
-3 seconds. **Original quality** restores 28 steps and removes known Turbo presets while keeping
-other adapters. Draft can lose motion or audio quality. The
-[Turbo model card](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora) recommends 6–8 steps for v4
-when fast motion at four steps causes smearing. This Space retains its diffusers sampler; it does
-not reproduce the separate ComfyUI Turbo sampler's dual-schedule implementation.
-
-Other savings are behavioral: adapter conversion moves off GPU, failed OOM/kernel runs are not
-repeated automatically, and identical conditioning inputs can reuse a **session-scoped cache**.
-Changing only seed or inference steps can reuse that cache; changing prompt, references, canvas,
-frame count, rewriting mode, session or conditioner invalidates it. It holds up to eight entries for
-30 minutes, with at most 256 MiB per entry, and disappears when the app restarts. It never shares
-cached private inputs across session keys.
-
-The heavy unquantized model and the separate conditioner remain. No model quantization, precision
-change or unmeasured reduction of the cold-worker allowance is included. Fewer denoising steps do
-not imply the same percentage reduction in total GPU usage.
-
-The estimate distinguishes **video GPU reservation** and **quota-seconds**, including the xlarge
-multiplier. Conditioner and writer requests are additional and are not included in that number.
-Actual billing and remaining allowance are governed by
-[Hugging Face ZeroGPU](https://huggingface.co/docs/hub/spaces-zerogpu); a reservation estimate is not a bill.
+## Lower compute without complicating Simple
+
+| Quality | Real denoising evaluations | Intended use |
+| --- | ---: | --- |
+| Draft | 4 | Short tests and simple motion |
+| Balanced — default | 6 | Everyday starting point |
+| Quality | 8 | More demanding motion; costs more |
+
+The default adapter remains Larry v4 step600 EMA. Its
+[model card](https://huggingface.co/larryvrh/MiniMax-H3-Turbo-Lora) recommends six to eight steps when
+fast motion smears at four. Quality is a setting, not a guarantee for every scene.
+
+**Correct step accounting:** the pinned scheduler counts its terminal zero as a schedule point. The
+app now passes `N + 1` points for `N` real evaluations, matching the
+[Turbo inference implementation](https://github.com/ModelTC/Minimax-H3-Turbo/blob/main/inference_minimax_h3.py).
+Thus an older “8 steps” actually performed seven evaluations; the new Balanced performs six. Keeping
+an old numeric step value now performs one more evaluation. Exported profiles use version 3.
+
+**Smaller reference processing — requires the companion conditioner update.** With the new endpoint,
+both the Qwen encoder and H3 reference encoder use the same source-preserving policy. A small image
+is no longer enlarged to a 2048-pixel short edge; large images are limited to the output canvas area
+and aligned to the model's 32-pixel grid. For a 512×768 picture and a 512×768 canvas, reference image
+rows drop from 6,144 to 384. That is **16× fewer image-reference rows**, not 16× faster video generation.
+Target video, text, audio, model placement and decoding still cost compute. Smaller references can
+lose fine detail; Everything retains larger output canvases for comparison.
+
+The policy is inspired by the Turbo project's
+[reference-resizing guidance](https://github.com/ModelTC/Minimax-H3-Turbo#note-on-reference-image-resizing).
+This package keeps the Ref2VA model and native separate video/audio schedulers. It does not load
+FL2VA weights or apply a second audio shift.
+
+The generator discovers the companion's versioned endpoint from public API metadata, validates the
+returned plan and tensor metadata, and uses matching dimensions in both halves. With the old public
+conditioner it retains the old resize policy and canvas table. **Uploading the generator alone does
+not enable the full reference reduction.** A failed efficient request is not silently retried.
+
+Other savings: CPU LoRA download/conversion/cache before GPU allocation, one speed adapter when
+switching presets, and a session-scoped conditioning cache. Identical conditioning inputs can reuse
+it when only seed or steps change. Prompt, references, resolved dimensions, frame count, rewriting,
+session, endpoint or resize policy changes invalidate it. The cache holds eight entries for 30 minutes,
+at most 256 MiB each. A changed quality preset may select a different Auto canvas and require encoding.
+
+An optional **LightX Ref2VA 4-step** adapter appears in Everything for comparison. It is about 1.29 GiB;
+its CPU download and the total LoRA limit still apply. It is not activated by default and is not stacked
+with another known speed preset. Native sparse attention, a second LTX pass, upscaling and interpolation
+are not added to default generation.
+
+**INT8 is an owner opt-in experiment**, described below. The default stays BF16 on xlarge. No GPU
+quality, memory or speed benchmark has been run for this update, and no fixed percentage saving is
+promised. Lower step counts do not translate proportionally to total request time.
+
+The estimate includes the video GPU allocation multiplier. Conditioner and optional writer requests
+are additional. A reservation estimate is not a bill; actual usage is governed by
+[Hugging Face ZeroGPU](https://huggingface.co/docs/hub/spaces-zerogpu).
 
 ## Audio, motion and finished-video tools
 
@@ -175,9 +209,23 @@ history and caches are temporary in this build; download a report before a resta
 
 ## Owner setup and token policy
 
-Replace **app.py**, **requirements.txt** and **README.md** in the existing MiniMax-H3 Space. Keep
-`h3_split_blocks.py`, `h3_aoti.py`, `lora_library.py` and the existing model/runtime files. This package
-is an update to that Space, not a standalone copy of its repository.
+Upload the **contents of `generator/`** to the root of the existing MiniMax-H3 Space. In addition to
+`app.py`, `requirements.txt` and `README.md`, the new `h3_efficiency.py` is required; include
+`h3_quantization.py` and the optional dependency file too. Keep `h3_split_blocks.py`, `h3_aoti.py`,
+`lora_library.py` and the existing runtime files. The generator folder is an update, not a full repository.
+
+To enable efficient reference processing:
+
+1. Duplicate the public `multimodalart/qwen3vl-conditioner` Space under your account and select ZeroGPU.
+2. Upload the **contents of `conditioner/`** to that Space's root. Its README selects Gradio 6.24.0.
+3. Wait for it to be ready, then set the generator's `H3_CONDITIONER` variable to the new public
+   `your-account/your-conditioner-space` ID. It must be publicly callable without an owner token.
+4. Restart the generator after the conditioner is ready. Capability discovery is cached until restart.
+
+Both copies of `h3_efficiency.py` must be identical. The conditioner's old endpoints remain available.
+The companion loads the original Qwen conditioner; it is not a paid MiniMax API. It still uses ZeroGPU
+quota, and hosting eligibility/limits are set by Hugging Face. If you cannot host the companion, the
+updated generator can keep using the public legacy conditioner with reduced reference savings.
 
 The dependency file is based on the matching live Space and preserves its torch/diffusers pins; it
 adds OpenCV and filelock. Gradio is selected by `sdk_version` above, not by a second requirements pin.
@@ -197,20 +245,49 @@ of unlimited free compute or proof of the origin of any previous account charges
 | `H3_GPU_SIZE` | `xlarge` | Existing large model allocation |
 | `H3_GPU_DURATION_MIN` / `H3_GPU_DURATION_MAX` | `120` / `1500` | Existing reservation bounds |
 | `H3_PLACEMENT_ALLOWANCE` | `90` | Existing cold-worker allowance; not silently lowered |
-| `H3_PLACEMENT` | `lazy` | Existing lazy placement or optional `offload` |
+| `H3_PLACEMENT` | `lazy` for BF16; `offload` for INT8 | Placement; offload reserves 10 GB for working memory |
+| `H3_QUANTIZATION` | `bf16` | `int8` is an optional, unbenchmarked owner experiment |
 | `H3_ATTENTION` | `_native_cudnn` | Base attention; adapter runs use `native` |
 | `H3_AOTI` | `0` | Existing compilation option; cannot be combined with LoRAs |
 | `H3_LOKR_RANK` | `32` | CPU LoKr conversion target rank; an approximation when truncated |
-| `H3_LORA_MAX_FILE_MB` / `H3_LORA_MAX_RUN_MB` | `1024` / `2048` | LoRA limits in MiB |
+| `H3_LORA_MAX_FILE_MB` / `H3_LORA_MAX_RUN_MB` | `1536` / `2048` | LoRA limits in MiB |
 | `H3_LORA_DOWNLOAD_SECONDS` | `600` | Bounded streamed direct download; HF native retries remain separate |
 | `HF_TOKEN` | unset | Model downloads and existing library/storage access only |
 | `CIVITAI_TOKEN` | unset | Model downloads and CivitAI metadata/search |
 | `LORA_LIBRARY_BUCKET` / `LORA_LIBRARY_DIR` | existing configuration | Preserve the shared library location |
 | `CIVITAI_API_HOST` | unset | Existing search host override |
 
+## Optional INT8 / large trial — owner only
+
+The helper follows the official
+[Diffusers MiniMax-H3 INT8 recipe](https://huggingface.co/docs/diffusers/main/en/api/pipelines/minimax_h3):
+INT8 weight-only transformer, protected input/output/timing modules, and the existing float32 VAEs.
+Quantization runs at startup, outside the request's GPU job. It still needs host RAM and disk for the
+original checkpoint and conversion. No pre-quantized checkpoint is downloaded automatically.
+
+To opt in, append `-r requirements-int8.txt` to the generator's `requirements.txt` and set:
+
+```text
+H3_QUANTIZATION=int8
+H3_PLACEMENT=offload
+H3_GPU_SIZE=large
+H3_AOTI=0
+```
+
+`requirements-int8.txt` pins torchao 0.17.0 for the existing PyTorch 2.11 build. Test this configuration
+on your own small clip before offering it publicly: TorchAO/PEFT adapters, ZeroGPU workers, total
+memory and performance have not been validated on a real GPU here. The 48 GB large allocation has a
+lower quota multiplier, but slower kernels/offloading could offset that benefit. The conditioner
+still uses xlarge; this switch affects only the generator. BF16 plus large is rejected at startup.
+
+Rollback: set `H3_QUANTIZATION=bf16`, `H3_GPU_SIZE=xlarge`, `H3_PLACEMENT=lazy` and restart. There is no
+automatic GPU fallback, extra retry or silent switch to a larger allocation.
+
 ## Validation and attribution
 
-Offline checks cover Gradio construction and request injection, planner JSON and timing, LoRA rotation
+39 offline tests passed. Checks cover both Gradio interfaces and their API schemas, exact scheduler
+point counts, shared reference resizing, metadata agreement, quality presets, Simple visibility,
+and the previous Gradio construction and request injection, planner JSON and timing, LoRA rotation
 and trigger preservation, token isolation, conditioner cache separation, early rejection before
 compute, no GPU retry, adapter cleanup, Stop/Resume and real ffmpeg joins, mixing and looping.
 No production GPU generation or paid inference was run. Model quality, actual GPU runtime and the

app.py

@@ -1,6 +1,6 @@
 """MiniMax-H3 `ref2va`, split deployment — the denoising half.
 
-This Space holds the `transformer_ref` partition and the two autoencoders, unquantized bfloat16. Text encoding runs in
+This Space holds `transformer_ref` (bfloat16 by default) and both autoencoders. Text encoding runs in
 [`qwen3vl-conditioner`](https://huggingface.co/spaces/multimodalart/qwen3vl-conditioner), which this one calls over the
 gradio API for every request; `reference_encoder` stays here, next to the autoencoders it runs.
 """
@@ -29,12 +29,14 @@ import spaces
 import gradio as gr
 
 import lora_library
+from h3_efficiency import (PROTOCOL, efficient_blocks, reference_size, scheduler_points, validate_resize_mode)
 
 MODEL_REPO = os.environ.get("H3_MODEL_REPO", "MiniMaxAI/MiniMax-H3")
 CONDITIONER_SPACE = os.environ.get("H3_CONDITIONER", "multimodalart/qwen3vl-conditioner")
 # `lazy` moves all 72.16 GiB onto the card on the first GPU call and leaves it there; `offload` hands placement to
 # `ComponentsManager.enable_auto_cpu_offload`. Startup placement is not an option here — see `load_models`.
-PLACEMENT = os.environ.get("H3_PLACEMENT", "lazy").lower()
+QUANTIZATION = os.environ.get("H3_QUANTIZATION", "bf16").lower()
+PLACEMENT = os.environ.get("H3_PLACEMENT", "offload" if QUANTIZATION == "int8" else "lazy").lower()
 # cuDNN's fused attention is 10-20% faster than the SDPA default on this pool and needs nothing installed.
 # flash-attention 3 is sm90-only and this card is sm120 (the `zero-a10g` flavour name is legacy).
 ATTENTION = os.environ.get("H3_ATTENTION", "_native_cudnn").lower()
@@ -46,7 +48,7 @@ MAX_GPU_DURATION = int(os.environ.get("H3_GPU_DURATION_MAX", "1500"))
 # Ceiling on the packed sequence. Above it the card dies inside the rotary embeddings with
 # `NVML_SUCCESS == r INTERNAL ASSERT FAILED` - not a bug in the code, just out of memory.
 # 74k rows go through; 165k kill the worker.
-MAX_SEQUENCE = int(os.environ.get("H3_MAX_SEQUENCE", "90000"))
+MAX_SEQUENCE = int(os.environ.get("H3_MAX_SEQUENCE", "45000" if GPU_SIZE == "large" else "90000"))
 # An attached adapter adds its own layers and their activations to the same card, so the ceiling above is not the
 # ceiling any more. Refusing a request that is over the reduced one is a sentence on screen; letting it through is a
 # dead worker and a bare "runtime error".
@@ -83,7 +85,15 @@ CANVASES = {
     "1152x512 · 21:9 fast": (512, 1152),
     "1536x672 · 21:9 full": (672, 1536),
 }
-DEFAULT_CANVAS = "960x544 · 16:9 fast"
+LEGACY_CANVASES = dict(CANVASES)
+AUTO_CANVAS = "Auto · match my picture"
+CANVASES = {AUTO_CANVAS: (544, 960), **CANVASES,
+    "736x416 · 16:9 draft": (416, 736), "416x736 · 9:16 draft": (736, 416),
+    "864x480 · 16:9 balanced": (480, 864), "480x864 · 9:16 balanced": (864, 480),
+    "512x768 · 2:3 balanced": (768, 512), "768x512 · 3:2 balanced": (512, 768),
+    "448x672 · 2:3 draft": (672, 448), "672x448 · 3:2 draft": (448, 672),
+    "704x1056 · 2:3 quality": (1056, 704), "1056x704 · 3:2 quality": (704, 1056)}
+DEFAULT_CANVAS = AUTO_CANVAS
 FPS, FRAMES_PER_CHUNK, LATENTS_PER_CHUNK = 24, 17, 5
 # It is the *snapped* frame count the ceiling has to hold for: 15 s is 360 frames, which rounds up to 362, i.e.
 # 15.083 s, and is refused. 14 is the last whole second that survives the snap.
@@ -93,7 +103,7 @@ MIN_DURATION = 2
 MIN_REFERENCE_VIDEO, MAX_REFERENCE_VIDEO = 2.0, 15.0
 # `MINIMAX_H3_MAX_REFERENCE_IMAGES`. The slots are built up front and revealed one at a time, because a demo asking
 # for two subjects should not open with nine boxes.
-MAX_IMAGE_SLOTS, OPEN_IMAGE_SLOTS = 9, 2
+MAX_IMAGE_SLOTS, OPEN_IMAGE_SLOTS = 9, 1
 
 # How many LoRA slots the UI offers, and the range each strength slider covers. Everything else -
 # the UI loop, the settings keys, the preset filler, `generate`'s `*lora_fields` tail - is built from
@@ -140,9 +150,12 @@ LORA_PRESETS = {
     ),
 }
 
-# Every Turbo build tunes the *video* trajectory. The soundtrack has its own (flow shift 12 for video against 3 for
-# audio), which Larryvrh's ComfyUI Turbo *sampler* handles and this diffusers Space does not have - so at 4 steps the
-# audio can come out distorted even when the picture is fine. Raise the steps if it does.
+LORA_PRESETS["LightX Ref2VA Turbo · 4 real steps · 1.29 GiB"] = (
+    "lightx2v/Minimax-h3-Turbo/minimax_h3_ref2v_turbo_4step_v0.1_bf16.safetensors",
+    4, "A reference-specific distilled adapter. Use four real evaluations and the match reference policy. Compare quality with the default before switching your usual setup.", 1.0)
+
+# H3 already steps video and audio on separate schedules. UI steps below mean
+# actual transformer evaluations; scheduler_points() adds the terminal sigma point.
 
 # The lowest step count the model's own schedulers accept; the Turbo LoRAs are tuned for 4.
 MIN_STEPS = 4
@@ -186,10 +199,10 @@ def target_rows(height: int, width: int, num_frames: int) -> int:
     return video + round(num_frames / FPS * AUDIO_LATENTS_PER_SECOND) * AUDIO_CHANNELS
 
 
-def reference_rows(references: list[tuple[str, str]], num_frames: int) -> int:
+def reference_rows(references: list[tuple[str, str]], num_frames: int, height=544, width=960, reference_resize_mode="legacy") -> int:
     """The rows the reference blocks add, from metadata alone — no decode.
 
-    An image is resized to a 2048 pixel short edge and encoded as a single frame; a video is put on the canvas *its
+    An image follows the negotiated reference policy and is encoded as a single frame; a video is put on the canvas *its
     own* aspect ratio resolves to, truncated to the generated frame count and snapped **down** to a `17 * n + 5` the
     VAE encodes without padding; a soundtrack contributes two rows per 1/40 s.
     """
@@ -197,16 +210,14 @@ def reference_rows(references: list[tuple[str, str]], num_frames: int) -> int:
 
     from diffusers.modular_pipelines.minimax_h3.modular_pipeline import resolve_canvas_size
 
+    canvas_size = (width, height)
     rows = 0
     for kind, path in references:
         if kind == "image":
-            width, height = Image.open(path).size
-            scale = REFERENCE_IMAGE_SHORT_EDGE / min(width, height)
-            resolved = [
-                max(CANVAS_MULTIPLE, round(edge * scale / CANVAS_MULTIPLE) * CANVAS_MULTIPLE)
-                for edge in (height, width)
-            ]
-            rows += (resolved[0] // CANVAS_MULTIPLE) * (resolved[1] // CANVAS_MULTIPLE)
+            with Image.open(path) as picture:
+                source_size = picture.size
+            resolved_width, resolved_height = reference_size(source_size, canvas_size, reference_resize_mode)
+            rows += (resolved_height // CANVAS_MULTIPLE) * (resolved_width // CANVAS_MULTIPLE)
             continue
 
         video_seconds, audio_seconds = probe(path)
@@ -231,17 +242,17 @@ def reference_rows(references: list[tuple[str, str]], num_frames: int) -> int:
 
 
 def get_duration(
-    prompt_embeds, text_token_tags, references, height, width, num_frames, steps, seed, loras=(), **_
+    prompt_embeds, text_token_tags, references, height, width, num_frames, steps, seed, loras=(), reference_resize_mode="legacy", **_
 ):
     """Seconds of GPU to reserve for one request. Takes the arguments of the `@spaces.GPU` function it decorates, and
     tolerates the `gr.Progress` `spaces` injects."""
-    sequence = int(text_token_tags.shape[0]) + reference_rows(references, num_frames) + target_rows(
+    sequence = int(text_token_tags.shape[0]) + reference_rows(references, num_frames, height, width, reference_resize_mode) + target_rows(
         height, width, num_frames
     )
     denoise = int(steps) * (STEP_LINEAR * sequence + STEP_QUADRATIC * sequence**2) * SAFETY
     # The two reference encoders ahead of the loop, and the two decoders plus the mux after it. Both scale with what
     # they are handed rather than with the step count.
-    encode = 5 + reference_rows(references, num_frames) * 1e-3
+    encode = 5 + reference_rows(references, num_frames, height, width, reference_resize_mode) * 1e-3
     decode = DECODE_BASE + DECODE_PER_DEFAULT_CANVAS * (height * width * num_frames) / DEFAULT_CANVAS_PIXELS
     total = PLACEMENT_ALLOWANCE + encode + denoise + decode + 10 + LORA_ALLOWANCE * len(loras or ())
     duration = max(MIN_GPU_DURATION, min(MAX_GPU_DURATION, math.ceil(total)))
@@ -249,20 +260,20 @@ def get_duration(
     return duration
 
 
-def budget(text_tokens, references, height, width, num_frames, steps, loras=()):
+def budget(text_tokens, references, height, width, num_frames, steps, loras=(), reference_resize_mode="legacy"):
     """`(rows, GPU seconds)` for one request, by the same formula as `get_duration`."""
-    sequence = int(text_tokens) + reference_rows(references, num_frames) + target_rows(height, width, num_frames)
+    sequence = int(text_tokens) + reference_rows(references, num_frames, height, width, reference_resize_mode) + target_rows(height, width, num_frames)
     per_step = (STEP_LINEAR * sequence + STEP_QUADRATIC * sequence**2) * SAFETY
-    encode = 5 + reference_rows(references, num_frames) * 1e-3
+    encode = 5 + reference_rows(references, num_frames, height, width, reference_resize_mode) * 1e-3
     decode = DECODE_BASE + DECODE_PER_DEFAULT_CANVAS * (height * width * num_frames) / DEFAULT_CANVAS_PIXELS
     overhead = PLACEMENT_ALLOWANCE + encode + decode + 10 + LORA_ALLOWANCE * len(loras or ())
     return sequence, overhead + int(steps) * per_step, per_step, overhead
 
 
-def fits(text_tokens, references, height, width, num_frames, steps, loras=()):
+def fits(text_tokens, references, height, width, num_frames, steps, loras=(), reference_resize_mode="legacy"):
     """Stops a request the card or the reservation cannot take, before any GPU time is spent."""
     sequence, total, per_step, overhead = budget(
-        text_tokens, references, height, width, num_frames, steps, loras
+        text_tokens, references, height, width, num_frames, steps, loras, reference_resize_mode
     )
     ceiling = sequence_ceiling(loras)
     if sequence <= ceiling and total <= MAX_GPU_DURATION:
@@ -319,9 +330,16 @@ def load_models() -> str | None:
 
         lower_duration_floor()
         manager = ComponentsManager()
-        blocks = MiniMaxH3Ref2VAGeneratorBlocks()
+        blocks = efficient_blocks(MiniMaxH3Ref2VAGeneratorBlocks)()
         print(f"[ref2va] loading {[c.name for c in blocks.expected_components]} from {MODEL_REPO} ...", flush=True)
         pipe = blocks.init_pipeline(MODEL_REPO, components_manager=manager, collection="h3")
+        if QUANTIZATION not in ("bf16", "int8"):
+            raise ValueError("H3_QUANTIZATION must be bf16 or int8.")
+        if GPU_SIZE == "large" and QUANTIZATION != "int8":
+            raise ValueError("The unquantized H3 transformer cannot fit large. Use xlarge, or explicitly enable experimental int8.")
+        if QUANTIZATION == "int8":
+            from h3_quantization import load_int8_transformer
+            pipe.update_components(transformer_ref=load_int8_transformer(MODEL_REPO))
         pipe.load_components(dtype=torch.bfloat16)
 
         # Both VAEs first, and explicitly. `set_attention_backend` also sets the registry's *global* backend, which
@@ -337,10 +355,13 @@ def load_models() -> str | None:
         # are identical field for field and the compiled code carries no weights of either.
         import h3_aoti
 
-        h3_aoti.maybe_load(pipe.transformer_ref)
+        if QUANTIZATION == "bf16":
+            h3_aoti.maybe_load(pipe.transformer_ref)
+        elif os.environ.get("H3_AOTI", "0") == "1":
+            raise ValueError("The existing AoTI artifact does not support the experimental INT8 transformer.")
 
         if PLACEMENT == "offload":
-            manager.enable_auto_cpu_offload(device="cuda")
+            manager.enable_auto_cpu_offload(device="cuda", memory_reserve_margin="10GB")
             _arm_decode_hooks(pipe)
 
         PIPE, MANAGER = pipe, manager
@@ -1022,7 +1043,7 @@ def generate(
     image_9=None,
     match=True,
     duration=5,
-    steps=28,
+    steps=6,
     seed=42,
     upsample=False,
     *lora_fields,
@@ -1072,6 +1093,10 @@ def generate(
     requested = 0 if (match and derivable) else snap_frames(duration)
 
     loras, lora_labels = collect_loras(lora_fields, progress)
+    efficient = _efficient_conditioner_available()
+    reference_resize_mode = "match" if efficient else "legacy"
+    canvas = _resolve_canvas(canvas, images[0], steps, efficient)
+    progress(0, desc="Preparing compact references" if efficient else "Preparing references with the existing conditioner")
 
     # Before the conditioner spends GPU time: the canvas from the table, worst case for the frame count.
     planned_height, planned_width = CANVASES.get(canvas, CANVASES[DEFAULT_CANVAS])
@@ -1082,7 +1107,7 @@ def generate(
         planned_width,
         requested or snap_frames(min(audio_bearing(references)[0][1], MAX_REFERENCE_VIDEO)),
         steps,
-        loras,
+        loras, reference_resize_mode,
     )
 
     _runtime_event("conditioner_begin")
@@ -1090,7 +1115,7 @@ def generate(
     conditioned = time.time()
     try:
         prompt_embeds, text_token_tags, metadata, plan = encode_remote(
-            prompt, references, canvas, requested, rewrite_prompt=upsample, session_id=session_id
+            prompt, references, canvas, requested, rewrite_prompt=upsample, session_id=session_id, reference_resize_mode=reference_resize_mode
         )
     except gr.Error:
         raise
@@ -1107,13 +1132,13 @@ def generate(
     refined = plan.get("refined_prompt") or ""
 
     # Again, with the exact numbers the conditioner returned.
-    fits(int(text_token_tags.shape[0]), references, height, width, num_frames, steps, loras)
+    fits(int(text_token_tags.shape[0]), references, height, width, num_frames, steps, loras, reference_resize_mode)
 
     progress(0.1, desc=f"Generating {num_frames / FPS:.1f} s at {width}x{height} ...")
     _runtime_event("gpu_request", frames=num_frames, steps=int(steps))
     started = time.time()
     frames, audio, sampling_rate = _generate(
-        prompt_embeds, text_token_tags, references, height, width, num_frames, steps, seed, loras
+        prompt_embeds, text_token_tags, references, height, width, num_frames, steps, seed, loras, reference_resize_mode
     )
     generate_seconds = time.time() - started
 
@@ -1188,7 +1213,7 @@ def generate_with_identity(
 # themselves are deliberately left out: gradio hands them over as paths into a per-session temporary directory that
 # is gone by the next visit, so a saved path would restore as a dead file rather than as the image.
 
-SETTINGS_VERSION = 2
+SETTINGS_VERSION = 3
 SETTINGS_KEYS = (
     ["prompt", "upsample", "canvas", "match", "duration", "steps", "seed"]
     + [f"lora_{slot + 1}" for slot in range(LORA_SLOTS)]
@@ -1595,24 +1620,18 @@ def _fill_lora_slots(files, *current):
     return [gr.update(value=value) for value in slots]
 
 
-def _add_preset_lora(preset, *current):
-    """Fill the first free LoRA slot with a preset adapter, set its strength to 1.0 and move the steps slider to the
-    preset's recommended count.
+def _add_preset_lora(preset,*current):
+    """One acceleration adapter at a time; preserve unrelated effect slots."""
+    reference,steps,_,strength=LORA_PRESETS[preset]
+    slots=list(current[:LORA_SLOTS]);scales=list(current[LORA_SLOTS:])
+    speed_refs={value[0] for value in LORA_PRESETS.values()}
+    for i,value in enumerate(slots):
+        if str(value or '').strip() in speed_refs:slots[i]=''
+    try:index=next(i for i,value in enumerate(slots) if not str(value or '').strip())
+    except StopIteration:raise gr.Error('Free one effect slot before choosing a speed adapter. Your settings were kept.')
+    slots[index]=reference;scales[index]=strength
+    return [*slots,*scales,steps]
 
-    The Turbo presets are tuned for a specific step range, so the steps slider is moved along with the slot — it is the
-    one output beyond the LoRA fields. A slot already holding the same reference is a no-op, so the button can be
-    pressed twice without duplicating, and a full set of slots is left untouched.
-    """
-    reference, steps, _, strength = LORA_PRESETS[preset]
-    slots = list(current[:LORA_SLOTS])
-    scales = list(current[LORA_SLOTS:])
-    if reference not in [(value or "").strip() for value in slots]:
-        for index, value in enumerate(slots):
-            if not (value or "").strip():
-                slots[index] = reference
-                scales[index] = strength
-                break
-    return [*slots, *scales, steps]
 
 
 load_models()
@@ -1922,7 +1941,7 @@ HERO = """
   <a href="https://www.minimax.io/blog/minimax-h3" target="_blank" rel="noopener">blog</a> &middot;
   <a href="https://huggingface.co/spaces/multimodalart/minimax-h3" target="_blank" rel="noopener">text / image to video</a></p>
   <div class="pills">
-    <span>33B</span><span>joint video + audio</span><span>Turbo lora: 4&ndash;8 steps</span>
+    <span>33B</span><span>joint video + audio</span><span>Turbo: 4&ndash;8 real steps</span>
     <span>ComfyUI lora accepted</span><span>up to 9 references</span><span>5 custom lora slots</span><span>shared lora library</span><span>trigger words in the prompt</span><span>structured prompt builder</span><span>named profiles</span><span>CivitAI search + links</span><span>scene continuation</span><span>🔒 identity lock</span><span>kohya + LoKr auto-convert</span><span>GPU cost estimate</span><span>clip stitching with audio</span>
   </div>
 </div>
@@ -1955,13 +1974,9 @@ diffusers' order, `alpha` is folded into the weights, and `.pt` files are read a
 to be converted by hand first.
 """
 
-TURBO_HELP = """A few-step distillation that renders joint video + soundtrack in **4–8 steps** instead of the usual
-~28 (a ~5× speedup). Pick one and press **add** — it fills a free slot at that build's own strength and moves the
-steps slider to the count it was trained for.
-
-Larryvrh documents strength `1.0` for every build, and that is what the **v4** entries are filled at. The older **v1**
-line is the one people report over-sharpening and plastic skin on at `1.0`, so those are filled at `0.7` instead. Both
-are starting points, not rules — if a clip smears, raise it; if it looks over-sharp or plastic, lower it.
+TURBO_HELP = """Steps count actual model evaluations. Balanced uses **6**, Draft **4**, and Quality **8**.
+Video and audio keep their own schedules. Model transfer, conditioning and decoding also take time.
+One speed LoRA is enough; changing a quality preset replaces only known speed adapters.
 """
 
 PROFILE_HELP = """Profiles keep the prompt, the canvas, the sliders and the lora slots — everything typed rather than
@@ -3368,7 +3383,7 @@ def _download_lora_source(source, progress=None):
         return _download_lora_source_unlocked(source, progress)
 
 
-LORA_MAX_FILE_BYTES = _lora_limit("H3_LORA_MAX_FILE_MB", 1024, 16384) * 1048576
+LORA_MAX_FILE_BYTES = _lora_limit("H3_LORA_MAX_FILE_MB", 1536, 16384) * 1048576
 LORA_MAX_RUN_BYTES = _lora_limit("H3_LORA_MAX_RUN_MB", 2048, 32768) * 1048576
 LORA_DOWNLOAD_SECONDS = _lora_limit("H3_LORA_DOWNLOAD_SECONDS", 600, 1800)
 def _pick_label(index, item):
@@ -4250,7 +4265,38 @@ def scene_step(state,request:gr.Request=None,progress=gr.Progress(track_tqdm=Tru
                values[_SCENE_INDEX['seed']],state['values'][_SCENE_INDEX['image']],min(total,state['index']+1))
 
 
-def _condition_key(session,prompt,references,canvas,frames,rewrite):
+_CONDITIONER_EFFICIENT = None
+
+
+def _efficient_conditioner_available(cached_only=False):
+    global _CONDITIONER_EFFICIENT
+    if _CONDITIONER_EFFICIENT is not None:return _CONDITIONER_EFFICIENT
+    if cached_only:return False
+    # Client construction reads public configuration only; it starts no compute.
+    client=conditioner()
+    config=getattr(client,'config',{}) or {}
+    _CONDITIONER_EFFICIENT=any(str(d.get('api_name','')).lstrip('/')=='encode_ref2va_efficient'
+                             for d in config.get('dependencies',[]))
+    return _CONDITIONER_EFFICIENT
+
+
+def _resolve_canvas(canvas,image,steps,efficient=False):
+    choices={k:v for k,v in (CANVASES if efficient else LEGACY_CANVASES).items() if k!=AUTO_CANVAS}
+    if canvas!=AUTO_CANVAS:
+        if canvas not in choices:
+            raise gr.Error('This canvas needs the included efficient conditioner. Select Auto or a legacy canvas.')
+        return canvas
+    ratio=16/9
+    if image:
+        with Image.open(image) as im:
+            im=ImageOps.exif_transpose(im);ratio=im.width/im.height
+    area=300000 if int(steps)<=4 else (700000 if int(steps)>=8 else 450000)
+    # Aspect ratio dominates; area selects the quality level within that family.
+    return min(choices,key=lambda k:4*abs(math.log((choices[k][1]/choices[k][0])/ratio))
+               +abs(math.log((choices[k][0]*choices[k][1])/area)))
+
+
+def _condition_key(session,prompt,references,canvas,frames,rewrite,reference_resize_mode="legacy"):
     if not session:return None
     files=[]
     for kind,path in references:
@@ -4258,17 +4304,29 @@ def _condition_key(session,prompt,references,canvas,frames,rewrite):
         identity=(hashlib.sha256(Path(path).read_bytes()).hexdigest() if kind=='image'
                   else [os.path.realpath(path),stat.st_size,stat.st_mtime_ns])
         files.append([kind,identity])
-    return hashlib.sha256(json.dumps([session,CONDITIONER_SPACE,prompt,files,canvas,frames,bool(rewrite)],
+    return hashlib.sha256(json.dumps([session,CONDITIONER_SPACE,PROTOCOL,reference_resize_mode,prompt,files,canvas,frames,bool(rewrite)],
                                     ensure_ascii=False).encode()).hexdigest()
 
 
-def encode_remote(prompt,references,canvas,num_frames,rewrite_prompt=False,session_id=''):
+def encode_remote(prompt,references,canvas,num_frames,rewrite_prompt=False,session_id='',reference_resize_mode='legacy'):
     from gradio_client import handle_file
     from safetensors import safe_open
-    key=_condition_key(session_id,prompt,references,canvas,num_frames,rewrite_prompt)
+    key=_condition_key(session_id,prompt,references,canvas,num_frames,rewrite_prompt,reference_resize_mode)
+    validate_resize_mode(reference_resize_mode)
     def read(path,plan):
+        if reference_resize_mode == 'match':
+            if plan.get('reference_protocol') != PROTOCOL or plan.get('reference_resize_mode') != 'match':
+                raise gr.Error('Conditioner returned an incompatible reference plan. No video GPU request was sent.')
+            if (int(plan.get('height', 0)), int(plan.get('width', 0))) != CANVASES[canvas]:
+                raise gr.Error('Conditioner changed the requested canvas. No video GPU request was sent.')
         with safe_open(path,framework='pt') as handle:
-            return handle.get_tensor('prompt_embeds'),handle.get_tensor('text_token_tags'),handle.metadata(),dict(plan)
+            metadata=handle.metadata() or {}
+            if reference_resize_mode=='match':
+                expected={'reference_protocol':PROTOCOL,'reference_resize_mode':'match',
+                          'height':str(plan['height']),'width':str(plan['width']),'num_frames':str(plan['num_frames'])}
+                if any(str(metadata.get(k,''))!=str(v) for k,v in expected.items()):
+                    raise gr.Error('Conditioning file metadata does not match its reference plan. No video GPU request was sent.')
+            return handle.get_tensor('prompt_embeds'),handle.get_tensor('text_token_tags'),metadata,dict(plan)
     with _CONDITION_LOCK:
         now=time.monotonic()
         for k,record in list(_CONDITION_CACHE.items()):
@@ -4283,9 +4341,14 @@ def encode_remote(prompt,references,canvas,num_frames,rewrite_prompt=False,sessi
                 _CONDITION_CACHE.pop(key,None)
     job=None
     try:
-        job=conditioner().submit(prompt=prompt,media=[handle_file(p) for _,p in references],
-            kinds=','.join(k for k,_ in references),canvas=canvas,num_frames=num_frames,
-            rewrite_prompt=bool(rewrite_prompt),api_name='/encode_ref2va')
+        fields=dict(prompt=prompt,media=[handle_file(p) for _,p in references],
+            kinds=','.join(k for k,_ in references),num_frames=num_frames,rewrite_prompt=bool(rewrite_prompt))
+        if reference_resize_mode == 'match':
+            fields.update(height=CANVASES[canvas][0],width=CANVASES[canvas][1],reference_resize_mode='match',
+                          api_name='/encode_ref2va_efficient')
+        else:
+            fields.update(canvas=canvas,api_name='/encode_ref2va')
+        job=conditioner().submit(**fields)
         path,plan=job.result(timeout=300)
         result=read(path,plan)
     except Exception as error:
@@ -4310,7 +4373,7 @@ def encode_remote(prompt,references,canvas,num_frames,rewrite_prompt=False,sessi
 
 
 @spaces.GPU(duration=get_duration,size=GPU_SIZE)
-def _generate(prompt_embeds,text_token_tags,references,height,width,num_frames,steps,seed,loras=()):
+def _generate(prompt_embeds,text_token_tags,references,height,width,num_frames,steps,seed,loras=(),reference_resize_mode="legacy"):
     import torch
     state=None;attached=[]
     started=time.perf_counter()
@@ -4322,7 +4385,8 @@ def _generate(prompt_embeds,text_token_tags,references,height,width,num_frames,s
         _runtime_event('denoising',adapter_files=len(attached))
         state=PIPE(prompt_embeds=prompt_embeds.to('cuda'),text_token_tags=text_token_tags,
             references=build_references(references),height=height,width=width,num_frames=num_frames,
-            num_inference_steps=int(steps),generator=torch.Generator('cpu').manual_seed(int(seed)))
+            num_inference_steps=scheduler_points(steps),reference_resize_mode=reference_resize_mode,
+            generator=torch.Generator('cpu').manual_seed(int(seed)))
         return state.get('videos')[0],state.get('audio')[0].cpu(),state.get('sampling_rate')
     except RuntimeError as error:
         _runtime_event('gpu_failed',error_type=type(error).__name__)
@@ -4396,39 +4460,57 @@ def gpu_estimate_studio(canvas,duration,steps,match,audio,video,identity,mode,st
     active=[ref for ref,scale in zip(refs,scales) if ref and float(scale or 0)!=0]
     if mode=='Extra H3 reference' and identity and float(strength)>0 and identity not in images:images.append(identity)
     try:
-        references=collect(images,audio,video);height,width=CANVASES[canvas]
+        references=collect(images,audio,video)
+        efficient = _efficient_conditioner_available(cached_only=True)
+        policy = 'match' if efficient else 'legacy'
+        canvas = _resolve_canvas(canvas, images[0] if images else None, steps, efficient)
+        height,width=CANVASES[canvas]
         seconds=float(duration)
         carried=audio_bearing(references)
         if match and len(carried)==1:seconds=carried[0][1]
         frames=snap_frames(seconds)
-        rows,total,_,_=budget(TEXT_TOKEN_ALLOWANCE,references,height,width,frames,steps,active)
+        rows,total,_,_=budget(TEXT_TOKEN_ALLOWANCE,references,height,width,frames,steps,active,policy)
         if rows>sequence_ceiling(active):return '🚫 Too large for this model. Shorten the clip, choose a smaller canvas or remove a reference.'
         if total>MAX_GPU_DURATION:return '🚫 This request exceeds the configured runtime limit. Lower steps, duration or canvas size.'
         durations=_scene_durations(timing,_scene_count(count),duration)
-        reservations=[max(MIN_GPU_DURATION,min(MAX_GPU_DURATION,math.ceil(budget(TEXT_TOKEN_ALLOWANCE,references,height,width,snap_frames(d),steps,active)[1]))) for d in durations]
+        reservations=[max(MIN_GPU_DURATION,min(MAX_GPU_DURATION,math.ceil(budget(TEXT_TOKEN_ALLOWANCE,references,height,width,snap_frames(d),steps,active,policy)[1]))) for d in durations]
         reservation=max(MIN_GPU_DURATION,min(MAX_GPU_DURATION,math.ceil(total)))
         factor=2 if GPU_SIZE=='xlarge' else 1
-        return (f'**Video GPU reservation: ~{reservation} s** · {GPU_SIZE} · ~{reservation*factor} quota-seconds\n\n'
+        return (f'**Estimated allowance for one clip: ~{reservation*factor} seconds** · {width}×{height} · {int(steps)} real steps\n\n'
                 f'Scene estimate: ~{sum(reservations)*factor} quota-seconds for {len(durations)} clips. '
                 'The remote conditioner and optional AI writer are additional requests; their quota is not included. '
-                'This is an estimate, not a bill. Identical inputs in the same session can reuse conditioning. '
+                f'This is an estimate, not a bill. Reference preparation: {policy}. Identical inputs can reuse conditioning. '
                 'References for later clips may change the estimate.')
     except Exception as e:return f'Estimate unavailable ({type(e).__name__}); check uploads and per-clip timings.'
 
 
+def quality_indicator(steps,*fields):
+    refs=list(fields[:LORA_SLOTS]);scales=list(fields[LORA_SLOTS:])
+    presets=list(LORA_PRESETS.values())
+    known={preset[0] for preset in presets}
+    active=[(ref,float(scale or 0)) for ref,scale in zip(refs,scales) if ref in known and float(scale or 0)!=0]
+    label={4:'Draft · quickest',6:'Balanced · recommended',8:'Quality · more detail'}.get(float(steps))
+    if active!=[(presets[0][0],1.0)]:label=None
+    note=f'{int(steps)} real steps. ' + ('Custom settings are active.' if label is None else 'Quality preset active; your length and custom effects are kept.')
+    return gr.update(value=label,label='Quality' if label else 'Quality · custom settings'),note
+
+
 def budget_recipe(recipe,*fields):
+    if not recipe:
+        return (*[gr.update() for _ in range(3+2*LORA_SLOTS)],'Custom settings kept.')
     refs=list(fields[:LORA_SLOTS]);scales=list(fields[LORA_SLOTS:]);presets=list(LORA_PRESETS.values())
     turbo_urls={p[0] for p in presets}
     for i,ref in enumerate(refs):
         if ref in turbo_urls:refs[i]=''
     if recipe=='Original quality · 28 steps':
-        return (DEFAULT_CANVAS,5,28,*refs,*scales,'Original quality: no Turbo adapter; more denoising work.')
+        return (gr.update(),gr.update(),28,*refs,*scales,'Original model: 28 real evaluations.')
     try:i=refs.index('')
-    except ValueError:raise gr.Error('The speed preset needs a free LoRA slot; your current slots were kept.')
-    fast=recipe.startswith('Draft')
+    except ValueError:raise gr.Error('The quality preset needs a free LoRA slot; your settings were kept.')
+    fast=recipe.startswith('Draft');quality=recipe.startswith('Quality')
+    count=4 if fast else (8 if quality else 6)
     refs[i]=presets[0][0];scales[i]=1.0
-    return ('544x544 · 1:1 fast' if fast else DEFAULT_CANVAS,3,4 if fast else 8,*refs,*scales,
-            'Draft is cheaper but may reduce motion/audio quality.' if fast else 'Balanced Turbo: 8 steps, 3 seconds. Shorten only when it fits the action.')
+    return (gr.update(),gr.update(),count,*refs,*scales,
+            f'{count} real steps. Auto canvas follows your picture. Duration and custom effects are kept.')
 
 
 def _profile_updates(payload):
@@ -4566,7 +4648,7 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
     gr.HTML("""<div class="studio-hero"><small>MINIMAX-H3 · IMAGE + MOTION + SOUND</small>
 <h1>MiniMax-H3 Studio</h1><p>One idea → a planned scene, made one clip at a time.</p>
 <div class="studio-features"><span>🆕 AI Scene Planner · 64 clips</span><span>🔒 CPU Identity Lock</span>
-<span>⚡ Turbo presets</span><span>🔄 LoRA Refresh + trigger sync</span><span>🔊 Native audio + soundtrack mixer</span></div>
+<span>⚡ Balanced 6-step presets</span><span>🔄 LoRA Refresh + trigger sync</span><span>🔊 Native audio + soundtrack mixer</span></div>
 <p>Simple for quick creation. Pro for all controls. Downloads and LoRA conversion finish before GPU generation.</p></div>""")
     with gr.Accordion("Runtime diagnostics", open=False):
         diagnostics_button = gr.Button("Check runtime / download report")
@@ -4593,7 +4675,7 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
                 )
                 upsample = gr.Checkbox(label="✨ Upsample prompt", value=False, visible=False)
 
-                with gr.Group(elem_classes="panel") as basic_panel:
+                with gr.Accordion("✨ Help with the prompt & effects", open=False) as basic_panel:
                     gr.Markdown(
                         "**Picture in, a few words above, one press.** The description is "
                         "written from your first reference picture, wrapped in the labelled "
@@ -4602,12 +4684,12 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
                         "changed with a tick."
                     )
                     basic_space = gr.Textbox(
-                        value=REMOTE_SPACE, label="🛰️ Big model Space", lines=1,
+                        value=REMOTE_SPACE, label="🛰️ Writing Space", lines=1, visible=False,
                         placeholder="owner/space-name",
                         info="A chat Space of your own, shown your first picture. Empty it "
                              "and only the structured builder runs, on your own words.",
                     )
-                    basic_btn = gr.Button("✨ Do all of it", variant="primary",
+                    basic_btn = gr.Button("✨ Improve my description", variant="secondary",
                                           elem_id="ir-btn")
                     basic_status = gr.Markdown("Nothing done yet.")
                     basic_pick = gr.CheckboxGroup(
@@ -4625,7 +4707,7 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
                     gr.Markdown(
                         "H3 was trained on the output of a preprocessor that rewrites a request into labelled "
                         "sections, and MiniMax call that structure *critical to the quality of the final output*. "
-                        "Nothing here adds it on its own — your text reaches the model as typed. Describe the shot "
+                        "Generate automatically adds the required structure. Describe the shot "
                         "in the prompt box above, set the pieces below, and press **Build**.\n\n"
                         "**Dialogue has to be verbatim.** Speech is generated together with the picture, so naming "
                         "that someone speaks without giving the words produces correct mouth shapes with nothing in "
@@ -4656,180 +4738,155 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
                     with gr.Row(elem_classes="chip-row"):
                         chip_buttons_b = [gr.Button(text, size="sm", variant="secondary") for text in CHIPS[4:]]
 
-            # ---------------- references ----------------
+            # One picture is the complete default reference UI.
             with gr.Group(elem_classes="panel"):
-                # One tab per modality, in the order the model reads them. A reference left in a tab that is not the
-                # open one is still part of the request.
-                with gr.Tabs():
-                    with gr.Tab("🖼️ Images"):
-                        # One `gr.Row`, so gradio splits the width evenly and wraps at `min_width` rather than leaving
-                        # a hole where a hidden slot used to be.
-                        gr.Markdown(
-                            "Upload only photographs of yourself, or of people who have agreed to this. Sexual "
-                        "imagery of a real person made without their consent breaks Hugging Face's "
-                        "content policy and is not welcome here.",
-                            elem_classes="consent-note",
-                        )
-                        with gr.Row():
-                            images = [
-                                gr.Image(
-                                    label="Subject, style or scene",
-                                    type="filepath",
-                                    min_width=180,
-                                    # Fixed, so a row that wraps to a single slot stays the size of a full one.
-                                    height=210,
-                                    visible=index < OPEN_IMAGE_SLOTS,
-                                )
-                                for index in range(MAX_IMAGE_SLOTS)
-                            ]
-                        add_image = gr.Button("+ Add another image", size="sm", variant="secondary")
-                        identity_ref = gr.Image(
-                            label="🔒 identity face (optional)",
-                            type="filepath",
-                            height=160,
-                        )
-                        identity_mode = gr.Radio(["Off", "CPU face protection", "Extra H3 reference"],
-                            value="CPU face protection", label="Identity Lock method")
-                        identity_strength = gr.Slider(0, 1, value=.65, step=.05, label="Face correction strength",
-                            info="0 disables it. CPU mode protects the starting frame without an extra H3 reference.")
-                        gr.Markdown(
-                            "<sub>The identity portrait stays fixed across continuation clips. It remains the original "
-                            "portrait across clips. CPU mode corrects an aligned face gently; it does not lock every generated frame. "
-                            "Extra H3 reference adds GPU work. Leave the portrait empty to use the original scene image.</sub>",
-                            elem_classes="turbo-blurb",
-                        )
-                    with gr.Tab("🔊 Audio"):
-                        audio = gr.Audio(label="A voice or a piece of music", type="filepath")
-                    with gr.Tab("🎥 Video"):
-                        video = gr.Video(label="Motion & camera, 2–15 s. Its soundtrack comes along.")
+                images = [gr.Image(label="🖼️ Your picture", type="filepath", height=260)]
+                with gr.Accordion("More references & Identity Lock", open=False) as extra_references:
+                    gr.Markdown("The first picture supplies identity for the scene. Add more media only when it helps your shot.")
+                    with gr.Tabs():
+                        with gr.Tab("Pictures & identity"):
+                            with gr.Row():
+                                images.extend(gr.Image(label=f"Reference {index+1}",type="filepath",height=180,
+                                    min_width=160,visible=False) for index in range(1,MAX_IMAGE_SLOTS))
+                            add_image=gr.Button("+ Add another picture",size="sm")
+                            identity_ref=gr.Image(label="Identity portrait (optional)",type="filepath",height=160)
+                            identity_mode=gr.Radio(["Off","CPU face protection","Extra H3 reference"],
+                                value="CPU face protection",label="Identity method",visible=False)
+                            identity_strength=gr.Slider(0,1,value=.65,step=.05,label="Face correction strength",visible=False)
+                            gr.Markdown("Leave the portrait empty to use the scene’s original picture. CPU protection guides continuation frames; it cannot guarantee identity in every frame.")
+                        with gr.Tab("Audio reference"):
+                            audio=gr.Audio(label="Voice or music",type="filepath")
+                        with gr.Tab("Motion reference"):
+                            video=gr.Video(label="Motion or camera reference, 2–15 seconds")
+                duration=gr.Slider(label="Clip length (seconds)",minimum=MIN_DURATION,maximum=MAX_UI_DURATION,
+                                   step=.1,value=3)
 
             # ---------------- speed ----------------
             with gr.Group(elem_classes="panel"):
                 gr.Markdown("### ⚡ Speed & cost")
-                budget_choice = gr.Dropdown(["Balanced Turbo · 8 steps", "Draft Turbo · 4 steps", "Original quality · 28 steps"],
-                    value="Balanced Turbo · 8 steps", label="Ready-made setup")
-                budget_button = gr.Button("Apply setup", variant="secondary")
-                budget_status = gr.Markdown("Default: Turbo v4 EMA · 8 steps · 3 seconds. Native audio is generated with the video.")
-                gr.Markdown(TURBO_HELP, elem_classes="turbo-blurb")
-                with gr.Row():
-                    lora_preset = gr.Dropdown(
-                        label="Preset",
-                        choices=list(LORA_PRESETS),
-                        value=list(LORA_PRESETS)[0],
-                        scale=4,
+                budget_choice = gr.Dropdown(["Balanced · recommended", "Draft · quickest", "Quality · more detail"],
+                    value="Balanced · recommended", label="Quality")
+                budget_button = gr.Button("Reapply quality preset", variant="secondary", visible=False)
+                budget_status = gr.Markdown("Balanced uses 6 real steps. Picture shape is automatic; sound is generated with the video.")
+                with gr.Group(visible=False) as pro_speed:
+                    gr.Markdown(TURBO_HELP, elem_classes="turbo-blurb")
+                    with gr.Row():
+                        lora_preset = gr.Dropdown(
+                            label="Preset",
+                            choices=list(LORA_PRESETS),
+                            value=list(LORA_PRESETS)[0],
+                            scale=4,
+                        )
+                        lora_preset_add = gr.Button("⚡ Use this speed adapter", variant="secondary", scale=1,
+                                                    elem_id="turbo-btn")
+                    turbo_blurb = gr.Markdown(
+                        LORA_PRESETS[list(LORA_PRESETS)[0]][2], elem_classes="turbo-blurb"
                     )
-                    lora_preset_add = gr.Button("⚡ add to a free slot", variant="secondary", scale=1,
-                                                elem_id="turbo-btn")
-                turbo_blurb = gr.Markdown(
-                    LORA_PRESETS[list(LORA_PRESETS)[0]][2], elem_classes="turbo-blurb"
-                )
 
-            # ---------------- the rest, in tabs ----------------
-            with gr.Tabs():
-                with gr.Tab(f"⭐ Custom lora ({LORA_SLOTS} slots)", visible=False) as pro_loratab:
-                    gr.Markdown(LORA_HELP)
-                    with gr.Accordion("🔍 Search CivitAI", open=False):
-                        gr.Markdown(
-                            "Search CivitAI without leaving the Space, then drop a result straight into a slot. "
-                            "Each hit shows its size, downloads and trigger words."
-                        )
-                        with gr.Row():
-                            search_query = gr.Textbox(label="Search", placeholder="e.g. dance, rain, camera move",
-                                                      scale=3)
-                            search_base = gr.Dropdown(H3_BASE_MODELS, value=H3_BASE_MODELS[0], label="Base model",
-                                                      allow_custom_value=True, scale=2)
-                        with gr.Row():
-                            search_nsfw = gr.Checkbox(value=True, label="Include NSFW results")
-                            search_btn = gr.Button("🔍 Search", variant="secondary", elem_id="search-btn")
-                        search_pick = gr.Dropdown(choices=[], label="Pick a file")
-                        with gr.Row():
-                            search_slot = gr.Dropdown([f"lora {i}" for i in range(1, LORA_SLOTS + 1)],
-                                                      value="lora 1", label="Into slot", scale=2)
-                            search_put_btn = gr.Button("⬇️ Put it in", variant="primary", scale=1,
-                                                       elem_id="search-put")
-                        # Below the picker on purpose: a wall of results above it would push the
-                        # controls off the screen, which is exactly what happened the first time.
-                        with gr.Accordion("📋 The results", open=False):
-                            search_results = gr.Markdown("No search yet.")
-                        search_state = gr.State({})
-
-                    lora_references, lora_scales = [], []
-                    for slot in range(LORA_SLOTS):
-                        with gr.Row():
-                            lora_references.append(
-                                gr.Textbox(label=f"lora {slot + 1}", placeholder="owner/repo", scale=3, value=list(LORA_PRESETS.values())[0][0] if slot == 0 else "")
+            with gr.Accordion("LoRA library, profiles & output settings", open=False) as studio_tools:
+                # ---------------- the rest, in tabs ----------------
+                with gr.Tabs():
+                    with gr.Tab(f"⭐ Custom lora ({LORA_SLOTS} slots)", visible=False) as pro_loratab:
+                        gr.Markdown(LORA_HELP)
+                        with gr.Accordion("🔍 Search CivitAI", open=False):
+                            gr.Markdown(
+                                "Search CivitAI without leaving the Space, then drop a result straight into a slot. "
+                                "Each hit shows its size, downloads and trigger words."
                             )
-                            lora_scales.append(
-                                gr.Slider(
-                                    label="Strength",
-                                    minimum=LORA_MIN_SCALE,
-                                    maximum=LORA_MAX_SCALE,
-                                    step=0.05,
-                                    # Most H3 adapters on CivitAI are written up for 0.5, so an empty slot starts
-                                    # there rather than at 1.0. A Turbo preset overwrites it with its own number.
-                                    value=1.0 if slot == 0 else DEFAULT_LORA_SCALE,
-                                    scale=2,
+                            with gr.Row():
+                                search_query = gr.Textbox(label="Search", placeholder="e.g. dance, rain, camera move",
+                                                          scale=3)
+                                search_base = gr.Dropdown(H3_BASE_MODELS, value=H3_BASE_MODELS[0], label="Base model",
+                                                          allow_custom_value=True, scale=2)
+                            with gr.Row():
+                                search_nsfw = gr.Checkbox(value=True, label="Include NSFW results")
+                                search_btn = gr.Button("🔍 Search", variant="secondary", elem_id="search-btn")
+                            search_pick = gr.Dropdown(choices=[], label="Pick a file")
+                            with gr.Row():
+                                search_slot = gr.Dropdown([f"lora {i}" for i in range(1, LORA_SLOTS + 1)],
+                                                          value="lora 1", label="Into slot", scale=2)
+                                search_put_btn = gr.Button("⬇️ Put it in", variant="primary", scale=1,
+                                                           elem_id="search-put")
+                            # Below the picker on purpose: a wall of results above it would push the
+                            # controls off the screen, which is exactly what happened the first time.
+                            with gr.Accordion("📋 The results", open=False):
+                                search_results = gr.Markdown("No search yet.")
+                            search_state = gr.State({})
+
+                        lora_references, lora_scales = [], []
+                        for slot in range(LORA_SLOTS):
+                            with gr.Row():
+                                lora_references.append(
+                                    gr.Textbox(label=f"lora {slot + 1}", placeholder="owner/repo", scale=3, value=list(LORA_PRESETS.values())[0][0] if slot == 0 else "")
                                 )
-                            )
-                    with gr.Row():
-                        lora_identify_btn = gr.Button("🔎 name the links", variant="secondary",
-                                                      elem_id="lora-identify")
-                    with gr.Accordion("📋 The named links", open=False):
-                        lora_names = gr.Markdown("Nothing in the slots yet.", elem_classes="turbo-blurb")
-                    lora_upload = gr.File(
-                        label="Drop .safetensors here to fill the slots",
-                        file_count="multiple",
-                        file_types=[".safetensors"],
-                        type="filepath",
-                    )
-
-                lora_library.library_tab(lora_slots=lora_references, scale_slots=lora_scales,
-                                         prompt_box=prompt)
-
-                with gr.Tab("🎛️ Output"):
-                    canvas = gr.Dropdown(label="Canvas", choices=list(CANVASES), value=DEFAULT_CANVAS)
-                    match = gr.Checkbox(label="Match the reference soundtrack", value=True, visible=False)
-                    duration = gr.Slider(
-                        label="Duration (s)", minimum=MIN_DURATION, maximum=MAX_UI_DURATION, step=0.1, value=3
-                    )
-                    steps = gr.Slider(label="Steps", minimum=MIN_STEPS, maximum=40, step=1,
-                                      value=8, visible=False)
-                    with gr.Row(visible=False) as pro_seed:
-                        seed = gr.Number(label="Seed", value=42, precision=0, scale=3)
-                        seed_dice = gr.Button("🎲 roll", variant="secondary", scale=1, elem_id="seed-dice")
-                    randomize_seed = gr.Checkbox(
-                        label="🎲 Randomize seed on every run",
-                        value=True,
-                        visible=False,
-                        info="A new seed is drawn each time Generate is pressed, and lands in the box above.",
-                    )
+                                lora_scales.append(
+                                    gr.Slider(
+                                        label="Strength",
+                                        minimum=LORA_MIN_SCALE,
+                                        maximum=LORA_MAX_SCALE,
+                                        step=0.05,
+                                        # Most H3 adapters on CivitAI are written up for 0.5, so an empty slot starts
+                                        # there rather than at 1.0. A Turbo preset overwrites it with its own number.
+                                        value=1.0 if slot == 0 else DEFAULT_LORA_SCALE,
+                                        scale=2,
+                                    )
+                                )
+                        with gr.Row():
+                            lora_identify_btn = gr.Button("🔎 name the links", variant="secondary",
+                                                          elem_id="lora-identify")
+                        with gr.Accordion("📋 The named links", open=False):
+                            lora_names = gr.Markdown("Nothing in the slots yet.", elem_classes="turbo-blurb")
+                        lora_upload = gr.File(
+                            label="Drop .safetensors here to fill the slots",
+                            file_count="multiple",
+                            file_types=[".safetensors"],
+                            type="filepath",
+                        )
 
-                with gr.Tab("💾 Profiles", visible=False) as pro_profiles:
-                    gr.Markdown(PROFILE_HELP)
-                    with gr.Row():
-                        profile_picker = gr.Dropdown(
-                            label="Saved profiles",
-                            choices=[NO_PROFILE, *list_profiles()],
-                            value=NO_PROFILE,
-                            scale=3,
+                    lora_library.library_tab(lora_slots=lora_references, scale_slots=lora_scales,
+                                             prompt_box=prompt)
+
+                    with gr.Tab("🎛️ Output"):
+                        canvas = gr.Dropdown(label="Canvas", choices=list(CANVASES), value=DEFAULT_CANVAS)
+                        match = gr.Checkbox(label="Match the reference soundtrack", value=True, visible=False)
+                        steps = gr.Slider(label="Steps", minimum=MIN_STEPS, maximum=40, step=1,
+                                          value=6, visible=False)
+                        with gr.Row(visible=False) as pro_seed:
+                            seed = gr.Number(label="Seed", value=42, precision=0, scale=3)
+                            seed_dice = gr.Button("🎲 roll", variant="secondary", scale=1, elem_id="seed-dice")
+                        randomize_seed = gr.Checkbox(
+                            label="🎲 Randomize seed on every run",
+                            value=True,
+                            visible=False,
+                            info="A new seed is drawn each time Generate is pressed, and lands in the box above.",
                         )
-                        profile_load = gr.Button("📂 load", variant="secondary", scale=1, elem_id="profile-load")
-                        profile_refresh = gr.Button("🔄", variant="secondary", scale=1, min_width=60, elem_id="profile-refresh")
-                    with gr.Row():
-                        profile_name = gr.Textbox(
-                            label="Save as", placeholder="e.g. neon street, turbo 8 steps", max_lines=1, scale=3
+
+                    with gr.Tab("💾 Profiles", visible=False) as pro_profiles:
+                        gr.Markdown(PROFILE_HELP)
+                        with gr.Row():
+                            profile_picker = gr.Dropdown(
+                                label="Saved profiles",
+                                choices=[NO_PROFILE, *list_profiles()],
+                                value=NO_PROFILE,
+                                scale=3,
+                            )
+                            profile_load = gr.Button("📂 load", variant="secondary", scale=1, elem_id="profile-load")
+                            profile_refresh = gr.Button("🔄", variant="secondary", scale=1, min_width=60, elem_id="profile-refresh")
+                        with gr.Row():
+                            profile_name = gr.Textbox(
+                                label="Save as", placeholder="e.g. neon street, turbo 8 steps", max_lines=1, scale=3
+                            )
+                            profile_save = gr.Button("💾 save", variant="primary", scale=1, elem_id="profile-save")
+                        profile_delete = gr.Button("🗑️ delete the selected profile", variant="secondary",
+                                                   elem_id="profile-delete")
+                        profile_status = gr.Markdown("")
+                        gr.Markdown("---")
+                        gr.Markdown("**Take it with you (.json file)**")
+                        save = gr.Button("⬇️ export the current settings to .json", size="sm")
+                        settings_download = gr.File(label="Your settings", visible=False, interactive=False)
+                        settings_upload = gr.File(
+                            label="📤 import a settings .json", file_types=[".json"], type="filepath"
                         )
-                        profile_save = gr.Button("💾 save", variant="primary", scale=1, elem_id="profile-save")
-                    profile_delete = gr.Button("🗑️ delete the selected profile", variant="secondary",
-                                               elem_id="profile-delete")
-                    profile_status = gr.Markdown("")
-                    gr.Markdown("---")
-                    gr.Markdown("**Take it with you (.json file)**")
-                    save = gr.Button("⬇️ export the current settings to .json", size="sm")
-                    settings_download = gr.File(label="Your settings", visible=False, interactive=False)
-                    settings_upload = gr.File(
-                        label="📤 import a settings .json", file_types=[".json"], type="filepath"
-                    )
 
         # ---------------- output ----------------
         with gr.Column(scale=6):
@@ -4843,58 +4900,60 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
             with gr.Group(elem_classes="panel"):
                 scene_progress = gr.HTML(_scene_progress(0, 1, phase="ready"))
                 result = gr.Video(label="🎞️ Video + soundtrack", height=560)
-                gr.Markdown("### 🆕 AI Scene Planner")
-                scene_idea = gr.Textbox(label="The whole scene", lines=3,
-                    placeholder="The character turns, crouches, then claps while crouching.")
-                with gr.Row():
-                    auto_count = gr.Checkbox(value=True, label="Choose clip count automatically")
-                    auto_seconds = gr.Checkbox(value=True, label="Choose each clip’s duration automatically")
-                planner_button = gr.Button("🪄 Split into clips", variant="primary")
-                planner_status = gr.HTML("Describe the actions; planning is a separate optional writer request.")
-                scene_pick = gr.CheckboxGroup(choices=[], value=[], visible=False, label="Scene LoRAs · shared with prompt")
-                scene_pick_note = gr.Markdown("")
-                scene_links = gr.Markdown("")
-                scene_refresh = gr.Button("🔄 Refresh relevant LoRAs ↻")
-                chain_count = gr.Slider(
-                    1, 64, value=3, step=1, label="How many clips in a row",
-                    info="1–64 clips; each is a separate generation request.",
-                )
-                with gr.Accordion("Review or edit the clip prompts and timings", open=False) as pro_perclip:
-                    scene_prompts = gr.Textbox(
-                        label="One line per clip", lines=6, max_lines=64,
-                        placeholder=("line 1 = clip 1, line 2 = clip 2, and so on\n"
-                                     "she turns toward the window\n"
-                                     "she smiles and looks down\n"
-                                     "…"),
-                        info="Leave a line empty — or the whole box — and that clip uses the "
-                             "main prompt, unchanged.",
+                with gr.Accordion("🆕 Make a longer scene · AI planner", open=False) as scene_tools:
+                    gr.Markdown("### 🆕 AI Scene Planner")
+                    scene_idea = gr.Textbox(label="The whole scene", lines=3,
+                        placeholder="The character turns, crouches, then claps while crouching.")
+                    with gr.Row():
+                        auto_count = gr.Checkbox(value=True, label="Choose clip count automatically", visible=False)
+                        auto_seconds = gr.Checkbox(value=True, label="Choose each clip’s duration automatically", visible=False)
+                    planner_button = gr.Button("🪄 Split into clips", variant="primary")
+                    planner_status = gr.HTML("Describe the actions; planning is a separate optional writer request.")
+                    scene_pick = gr.CheckboxGroup(choices=[], value=[], visible=False, label="Scene LoRAs · shared with prompt")
+                    scene_pick_note = gr.Markdown("")
+                    scene_links = gr.Markdown("")
+                    scene_refresh = gr.Button("🔄 Refresh relevant LoRAs ↻")
+                    chain_count = gr.Slider(
+                        1, 64, value=3, step=1, label="How many clips in a row", visible=False,
+                        info="1–64 clips; each is a separate generation request.",
                     )
-                    scene_seconds = gr.Textbox(label="Seconds per clip", placeholder="3, 2.33, 3.75",
-                        info="One number per clip; blank uses the main duration. Times follow H3’s supported frame grid.")
-                plan_preview = gr.HTML("")
-                with gr.Row():
-                    chain_btn = gr.Button("🎬 Make the whole scene and join it",
-                                          variant="primary", elem_id="extend-btn")
-                    chain_stop_btn = gr.Button("⏹ Stop", variant="stop")
-                chain_from = gr.Number(
-                    value=1, precision=0, minimum=1, maximum=64, label="Start at clip",
-                    info="Leave it at 1. After a stop it points at the clip that did not get "
-                         "made, so pressing 🎬 again carries on with the right prompt "
-                         "line instead of starting the sheet over.",
-                )
-                extend_btn = gr.Button("➕ Just one more clip", variant="secondary")
-                gr.Markdown(
-                    "Press 🎬 once and leave it. Each clip starts on the last frame of the one "
-                    "before it. Completed clips stay queued; joining runs once at the end with sound. "
-                    "Stop keeps finished clips. Identity Lock can reduce drift; it cannot guarantee an identical face.  \n"
-                    "➕ does the same thing one clip at a time, for when you want to change "
-                    "something in between.",
-                    elem_classes="turbo-blurb",
-                )
+                    with gr.Accordion("Review or edit the clip prompts and timings", open=False) as pro_perclip:
+                        scene_prompts = gr.Textbox(
+                            label="One line per clip", lines=6, max_lines=64,
+                            placeholder=("line 1 = clip 1, line 2 = clip 2, and so on\n"
+                                         "she turns toward the window\n"
+                                         "she smiles and looks down\n"
+                                         "…"),
+                            info="Leave a line empty — or the whole box — and that clip uses the "
+                                 "main prompt, unchanged.",
+                        )
+                        scene_seconds = gr.Textbox(label="Seconds per clip", placeholder="3, 2.33, 3.75",
+                            info="One number per clip; blank uses the main duration. Times follow H3’s supported frame grid.")
+                    plan_preview = gr.HTML("")
+                    with gr.Row():
+                        chain_btn = gr.Button("🎬 Make the whole scene and join it",
+                                              variant="primary", elem_id="extend-btn")
+                        chain_stop_btn = gr.Button("⏹ Stop", variant="stop")
+                    chain_from = gr.Number(
+                        value=1, precision=0, minimum=1, maximum=64, label="Start at clip", visible=False,
+                        info="Leave it at 1. After a stop it points at the clip that did not get "
+                             "made, so pressing 🎬 again carries on with the right prompt "
+                             "line instead of starting the sheet over.",
+                    )
+                    extend_btn = gr.Button("➕ Just one more clip", variant="secondary")
+                    gr.Markdown(
+                        "Press 🎬 once and leave it. Each clip starts on the last frame of the one "
+                        "before it. Completed clips stay queued; joining runs once at the end with sound. "
+                        "Stop keeps finished clips. Identity Lock can reduce drift; it cannot guarantee an identical face.  \n"
+                        "➕ does the same thing one clip at a time, for when you want to change "
+                        "something in between.",
+                        elem_classes="turbo-blurb",
+                    )
+
             # An output, so it can be revealed only for a request that asked for a rewrite.
             with gr.Accordion("Upsampled prompt", open=False, visible=False) as upsampled_panel:
                 upsampled = gr.Textbox(show_label=False, lines=8, interactive=False)
-            with gr.Accordion("🎞️ The joined video (no GPU used)", open=True):
+            with gr.Accordion("🎞️ Joined scene & finished clips", open=False):
                 gr.Markdown(
                     "Add clips to a queue and they are joined into a single file, **soundtrack "
                     "included**. Three clips make one long video for no extra GPU time. Everything "
@@ -5040,8 +5099,13 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
         [edited_video, edited_file], api_name=False, concurrency_id="h3-heavy", concurrency_limit=1)
     loop_button.click(loop_finished, [result, merged_video, edit_target, loop_count], [edited_video, edited_file],
         api_name=False, concurrency_id="h3-heavy", concurrency_limit=1)
+    budget_choice.input(budget_recipe, [budget_choice, *lora_references, *lora_scales],
+        [canvas, duration, steps, *lora_references, *lora_scales, budget_status], api_name=False)
     budget_button.click(budget_recipe, [budget_choice, *lora_references, *lora_scales],
         [canvas, duration, steps, *lora_references, *lora_scales, budget_status], api_name=False)
+    for field in (steps, *lora_references, *lora_scales):
+        field.change(quality_indicator, [steps, *lora_references, *lora_scales],
+            [budget_choice, budget_status], queue=False, show_progress='hidden', api_name=False)
 
     # Searching CivitAI, and dropping a result into a slot.
     search_btn.click(
@@ -5140,11 +5204,12 @@ with gr.Blocks(title="MiniMax-H3 Studio · AI Scenes · Identity · Turbo", dele
     _planned.success(_picker_refresh, _PICK_INPUTS, _PICK_OUTPUTS, api_name=False)
 
     _PRO_ONLY = [pro_builder, pro_chips, upsample, pro_loratab, pro_profiles,
-                 steps, pro_seed, randomize_seed]
+                 steps, pro_seed, randomize_seed, basic_space, pro_speed, budget_button,
+                 identity_mode, identity_strength, auto_count, auto_seconds, chain_count, chain_from]
 
     def _switch_mode(mode):
         pro = str(mode) == "pro"
-        return [gr.update(visible=pro) for _ in _PRO_ONLY] + [gr.update(visible=not pro)]
+        return [gr.update(visible=pro) for _ in _PRO_ONLY] + [gr.update(visible=True)]
 
     ui_mode.change(_switch_mode, [ui_mode], _PRO_ONLY + [basic_panel], api_name=False)
 

h3_efficiency.py

@@ -0,0 +1,97 @@
+"""Shared CPU policy for the H3 generator and its optional efficient conditioner.
+
+No model loads, networking, CUDA initialization or monkey-patches at import.
+The setup extension uses the pinned Diffusers validation and media normalization.
+"""
+from __future__ import annotations
+
+import math
+from PIL import Image
+
+PROTOCOL = "h3-reference-budget-v1"
+RESIZE_MODES = ("legacy", "match")
+
+
+def validate_resize_mode(mode):
+    if mode not in RESIZE_MODES:
+        raise ValueError("Unsupported H3 reference resize policy.")
+    return mode
+
+
+def scheduler_points(evaluations):
+    n = float(evaluations)
+    if not math.isfinite(n) or not n.is_integer() or not 4 <= n <= 40:
+        raise ValueError("H3 steps must be an integer from 4 to 40.")
+    # The pinned MiniMaxH3Scheduler includes terminal zero in the point count.
+    return int(n) + 1
+
+
+def reference_size(size, canvas, mode="match", multiple=32):
+    validate_resize_mode(mode)
+    width, height = map(int, size)
+    target_width, target_height = map(int, canvas)
+    if min(width, height, target_width, target_height) <= 0:
+        raise ValueError("Image and canvas dimensions must be positive.")
+    if max(width / height, height / width) > 4:
+        raise ValueError("H3 image references must have an aspect ratio between 1:4 and 4:1.")
+    if mode == "legacy":
+        scale = 2048 / min(width, height)
+        return tuple(max(multiple, round(edge * scale / multiple) * multiple) for edge in (width, height))
+    scale = min(1.0, math.sqrt(target_width * target_height / (width * height)))
+    # Floor rather than round: the policy never exceeds its source or area cap,
+    # except the mandatory minimum cell for tiny (<32 px) images.
+    return tuple(max(multiple, int(edge * scale) // multiple * multiple) for edge in (width, height))
+
+
+def resize_reference(image, canvas, mode="match"):
+    size = reference_size(image.size, canvas, mode)
+    return image if image.size == size else image.resize(size, Image.Resampling.LANCZOS)
+
+
+def efficient_blocks(original_blocks_type):
+    """Create a local block class; never mutate the upstream or global pipeline."""
+    from diffusers.modular_pipelines.minimax_h3.before_encoder import MiniMaxH3Ref2VASetupStep
+    from diffusers.modular_pipelines.modular_pipeline_utils import InputParam
+    from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3ImageReference
+
+    class BudgetReferenceSetup(MiniMaxH3Ref2VASetupStep):
+        @property
+        def inputs(self):
+            return [*super().inputs, InputParam(
+                name="reference_resize_mode", type_hint=str, default="legacy",
+                description="Negotiated reference policy; must match the conditioning encoder.")]
+
+        def __call__(self, components, state):
+            # Preserve all upstream validation, audio handling and frame-grid rules.
+            # Its image enlargement is CPU-only; the replacement below occurs
+            # before either the Qwen encoder or the video VAE consumes the images.
+            mode = validate_resize_mode(self.get_block_state(state).reference_resize_mode)
+            components, state = super().__call__(components, state)
+            if mode == "match":
+                block = self.get_block_state(state)
+                canvas = (block.width, block.height)
+                block.normalized_references = [
+                    MiniMaxH3ImageReference(image=resize_reference(original.image, canvas, mode))
+                    if original.kind == "image" else normalized
+                    for original, normalized in zip(block.references, block.normalized_references)
+                ]
+                self.set_block_state(state, block)
+            return components, state
+
+    class EfficientBlocks(original_blocks_type):
+        block_classes = [BudgetReferenceSetup if cls is MiniMaxH3Ref2VASetupStep else cls
+                         for cls in original_blocks_type.block_classes]
+
+    return EfficientBlocks
+
+
+def validate_canvas(height, width):
+    raw = (float(height), float(width))
+    if any(not math.isfinite(x) or not x.is_integer() for x in raw):
+        raise ValueError("Canvas dimensions must be whole numbers.")
+    height, width = map(int, raw)
+    if min(height, width) < 256 or max(height, width) > 1536 or height % 32 or width % 32:
+        raise ValueError("H3 canvas must use multiples of 32, between 256 and 1536 pixels.")
+    if height * width > 1_200_000 or max(height / width, width / height) > 4:
+        raise ValueError("Canvas exceeds the supported area or aspect ratio.")
+    return height, width

h3_quantization.py

@@ -0,0 +1,30 @@
+"""Owner-opt-in INT8 loading. Conversion is at startup, never inside a GPU job.
+
+Based on the official MiniMax-H3 Diffusers memory recipe. Kept separate because
+GPU/PEFT/ZeroGPU compatibility must be measured on the owner's actual runtime.
+"""
+
+
+def load_int8_transformer(repo):
+    import torch
+    try:
+        from diffusers import MiniMaxH3Transformer3DModel, TorchAoConfig
+        from torchao.quantization import Int8WeightOnlyConfig
+    except ImportError as error:
+        raise RuntimeError(
+            "INT8 needs the optional requirements-int8.txt dependencies. "
+            "Use H3_QUANTIZATION=bf16 for the existing supported path."
+        ) from error
+    model = MiniMaxH3Transformer3DModel.from_pretrained(
+        repo, subfolder="transformer_ref", dtype=torch.bfloat16,
+        quantization_config=TorchAoConfig(
+            Int8WeightOnlyConfig(version=2),
+            modules_to_not_convert=[
+                "proj_in", "audio_proj_in", "context_embedder", "time_embedder", "time_proj",
+                "token_refiner", "norm_out", "proj_out", "audio_proj_out",
+            ],
+        ),
+        low_cpu_mem_usage=False,
+    )
+    model.requires_grad_(False)
+    return model

h3_quick_test.json

@@ -0,0 +1,30 @@
+{
+  "version": 3,
+  "prompt": "The same subject gently turns their head toward the camera, then holds a relaxed expression. Keep the same clothing and background. Quiet room ambience, no speech or music.",
+  "upsample": false,
+  "canvas": "Auto \u00b7 match my picture",
+  "match": false,
+  "duration": 2,
+  "steps": 4,
+  "seed": 42,
+  "randomize_seed": false,
+  "scene_idea": "",
+  "scene_prompts": "",
+  "scene_seconds": "",
+  "clip_count": 1,
+  "auto_count": false,
+  "auto_seconds": false,
+  "identity_mode": "CPU face protection",
+  "identity_strength": 0.65,
+  "dialogue_language": "English",
+  "lora_1": "larryvrh/MiniMax-H3-Turbo-Lora/minimax_h3_turbo_v4_step600_ema.safetensors",
+  "lora_1_scale": 1,
+  "lora_2": "",
+  "lora_2_scale": 0.5,
+  "lora_3": "",
+  "lora_3_scale": 0.5,
+  "lora_4": "",
+  "lora_4_scale": 0.5,
+  "lora_5": "",
+  "lora_5_scale": 0.5
+}

requirements-int8.txt

@@ -0,0 +1,3 @@
+# Optional owner experiment; torch 2.11 compatibility per pytorch/ao#2919.
+# Add -r requirements-int8.txt to requirements.txt only when enabling INT8.
+torchao==0.17.0