Sync the bundled nodes, workflows and docs with GitHub master (099a051)

The mirrored copy had drifted to roughly the 5f40849 era, before the all-in-one work existed. That left the all-in-one checkpoint in this repo unloadable by the code shipped next to it -- Krea2SVDQuantCheckpointLoader was not in it -- and kept the dynamic-VRAM pin that made iteration time jump to 30-100 s past ~12 GB.

Updates 12 files and adds 15, including build_all_in_one.py and the 12 workflow JSONs that were missing.

BENCHMARKS.md

@@ -4,6 +4,15 @@ Two independent tests on **Krea 2 Turbo**, all checkpoints produced by `quantize
 in this repo. Same seed across every checkpoint in a given test so images are directly
 comparable. RTX 3090, cu130 torch build.
 
+> **Which patcher these were measured on.** Every speed number here was taken while the
+> svdq loader still pinned the model to the classic `ModelPatcher` (`disable_dynamic=True`).
+> That pin is gone; the default is now ComfyUI's dynamic-VRAM patcher. On a card where the
+> model fits, the patcher is not on the hot path and the numbers should be unaffected — a
+> spot check at rank 256, 1024², under the dynamic patcher measured 0.794 s/step, which sits
+> in the same range as the table below. But that is one point, not a re-run: **these tables
+> have not been regenerated since the change.** `tools/speed_bench.py` produces them if you
+> want them re-measured.
+
 > **The quality scores in Tests 1 and 2 have been withdrawn (2026-07-27).** They came from
 > an LLM judge (Gemini 3.5 Flash Lite) that turned out to be saturated: 9 of the 12 rows in
 > the LoRA table scored a flat 10.00/10, and the whole t2i table spanned 0.46 points. An
@@ -267,7 +276,7 @@ configuration in which the plain objective is the better choice.
 
 ```bash
 python quantize_krea2.py turbo.safetensors --format svdq --rank 256 \
-  --act-stats krea2_act_stats.safetensors
+  --act-stats krea2_act_stats_turbo.safetensors
 ```
 
 Ruled out as confounds: `r256` and `r256-actaware` share source, rank, `refine_iters=100`,

README.md

@@ -1,122 +1,89 @@
----
-license: other
-license_name: krea-2-community-license
-license_link: https://www.krea.ai/krea-2-licensing
-library_name: diffusers
-tags:
-- image-generation
-- comfyui
-- quantization
-- int8
-- int4
-- svdquant
-- krea2
-- krea
-- diffusion
-- transformer
-- lowvram
-base_model: krea/krea-2
-pipeline_tag: text-to-image
----
+# Krea 2 SVDQuant & Native Quantization for ComfyUI
 
-# Krea 2 SVDQuant W4A4 for ComfyUI
+**Weights and all example images:**
+[huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI](https://huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI)
 
 Quantized **Krea 2** checkpoints for ComfyUI — about **2x faster** and **a third the size**
 of the usual FP8 version, with no calibration dataset needed, on both **Krea 2 Turbo**
-(distilled, 8 steps) and the **base** release. This repo holds the custom nodes and the
-`quantize_krea2.py` conversion script; the `.safetensors` files (7.5-9.1 GB each) live on
+(distilled, 8 steps) and the **base** release. This repo holds the custom nodes, the All-in-One
+builder, and the `quantize_krea2.py` conversion script; the `.safetensors` files live on
 Hugging Face.
 
 Works on **any modern NVIDIA GPU** — INT8/W4A4 tensor cores go back to Turing (RTX 20-series).
-Benchmarked on an RTX 3090 (Ampere), the case most Krea 2 quantization writeups skip, since
-that generation has no FP8 or NVFP4 tensor cores at all. Everything here was built from
-scratch against ComfyUI's own quantization backend and is reproducible: `quantize_krea2.py`
-regenerates any checkpoint from a BF16 source in 40-100 seconds, or ~6 minutes with the
-default low-rank refinement.
+Benchmarked on an RTX 3090 (Ampere). Everything here was built from scratch against ComfyUI's
+own quantization backend and is 100% reproducible.
 
 > **Requires a cu130 (CUDA 13) or newer PyTorch build.** ComfyUI disables `comfy_kitchen`'s
 > CUDA backend on older torch builds, which silently drops every quantized checkpoint onto a
 > pure-Python fallback that is *slower than bf16*. If these checkpoints are slower than FP8
-> for you, this is almost certainly why — see
-> [TROUBLESHOOTING.md](TROUBLESHOOTING.md#its-slower-than-fp8--slower-than-bf16).
-
-This is a community-produced modification of Krea 2, not an official Krea product — license
-and attribution are at the [bottom of this page](#attribution). Read them before using these
-weights, in particular the revenue threshold on commercial use.
+> for you, see [TROUBLESHOOTING.md](TROUBLESHOOTING.md#its-slower-than-fp8--slower-than-bf16).
 
-> **Moved 2026-07-27.** The checkpoints now live under `checkpoints/`, with superseded
-> builds in `checkpoints/legacy/`. Direct links to the old repository-root paths will 404 --
-> the root had ten loose 8 GB files with no indication which one to take.
+---
 
-## Which checkpoint to download
+## 🚀 Quick Start (Choose Your Setup)
 
-Everything lives under `checkpoints/` on Hugging Face.
+### Option 1: 🌟 1-Click All-in-One Checkpoint (Recommended)
+> **Zero extra downloads!** DiT model, 4-bit Qwen3-VL 4B text encoder, and VAE are combined into **a single 12.77 GB file**.
 
-| file | rank | size | when |
-|---|---|---|---|
-| **`Krea2-Turbo-SVDQuant-W4A4-rank256-actaware.safetensors`** | 256 | 9.10 GB | **Start here.** Closest to BF16 of anything measured, same speed as any other rank-256 build |
-| `Krea2-Turbo-SVDQuant-W4A4-rank256.safetensors` | 256 | 9.10 GB | The same without the activation weighting |
-| `Krea2-Turbo-SVDQuant-W4A4-rank64.safetensors` | 64 | 7.90 GB | 1.2 GB smaller, and identical to rank 256 *if you never load a LoRA* |
-| `Krea2-Turbo-W4A4-noLowRank.safetensors` | — | 7.50 GB | Smallest and ~9% faster per step; loads with the stock **UNETLoader** |
-| `Krea2-Base-SVDQuant-W4A4-rank256-actaware.safetensors` | 256 | 9.10 GB | The **base** (non-distilled) model, not turbo. 50 steps, cfg 3.5, real negative prompt |
-| `checkpoints/legacy/` | 16, 128 | — | Superseded, kept because BENCHMARKS.md cites measurements from them |
-
-The `actaware` file is the same format, size and speed as plain rank 256 — the low-rank branch
-was just fitted against measured per-channel activation energy instead of assuming it is
-uniform ([`--act-stats`](#activation-aware-branch---act-stats)). Without a LoRA that moves
-LPIPS-to-BF16 from 0.3378 to **0.2825** (t=4.68 over 32 paired cells); with a LoRA it measures
-no worse. There is no case where the plain build is the better pick. The calibration file it
-was built from is in `calibration/`, so the build is reproducible.
-
-The base file is the same recipe applied to `raw.safetensors`, built from its own calibration
-pass (`calibration/krea2_act_stats_base.safetensors`, 8 prompts on the BF16 base model at its
-own sampler settings). **It has not been through the paired benchmark yet** — the act-aware
-numbers below are turbo measurements and are not evidence about the base build. Treat it as
-"the base equivalent of the recommended turbo file", not as a measured improvement over
-`Krea2-Base-SVDQuant-W4A4-rank256`.
-
-**Rank only matters if you load LoRAs.** Without one, ranks 64 / 128 / 256 are statistically
-indistinguishable. With one, rank 256 wins clearly and rank 64 loses most of its advantage
-over having no branch at all
-([Test 3](BENCHMARKS.md#test-3--paired-lpips-fidelity-with-and-without-a-lora)).
-
-Every file records how it was built in its safetensors metadata, so you can check what you
-downloaded rather than trusting this table:
-
-```python
-from safetensors import safe_open
-with safe_open("Krea2-Turbo-SVDQuant-W4A4-rank256-actaware.safetensors", framework="pt") as f:
-    print(f.metadata())
-```
+1. **Install custom nodes:**
+   ```bash
+   git clone https://github.com/alperktt/Krea-2-SVDQuant-ComfyUI custom_nodes/krea-2-svdquant
+   ```
+2. **Download the unified checkpoint:**
+   - Download `Krea2-Turbo-AllInOne-SVDQuant-W4A4-rank256-actaware-TEW4A4.safetensors` (12.77 GB) from [Hugging Face](https://huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI).
+   - Place it in: `ComfyUI/models/checkpoints/`
+3. **Run in ComfyUI:**
+   - Drag [`workflows/krea2_turbo_all_in_one_t2i.json`](workflows/krea2_turbo_all_in_one_t2i.json) into your ComfyUI canvas.
+   - It uses the **Krea2 SVDQuant Checkpoint Loader** node to load everything in 1 click. Press **Queue Prompt**!
 
-> The test that matters is `f.metadata() is None`, not the date: an early batch (published
-> before 2026-07-26) was built without refinement and carries no metadata at all. If yours
-> returns `None`, re-download — the whole rank ladder is flat without refinement.
+---
 
-## Quick start
+### Option 2: 📦 Modular 3-File Setup
+> If you prefer downloading the DiT, Text Encoder, and VAE separately:
 
-1. **Install the nodes.** In your ComfyUI folder:
+1. **Install custom nodes:**
    ```bash
-   git clone https://github.com/alperktt/Krea-2-SVDQuant-ComfyUI custom_nodes/krea2-svdquant
+   git clone https://github.com/alperktt/Krea-2-SVDQuant-ComfyUI custom_nodes/krea-2-svdquant
    ```
-   (No git? Download the repo as a ZIP and unzip it into `ComfyUI/custom_nodes/`.) Restart
-   ComfyUI.
+2. **Download the 3 files:**
+   - **DiT Checkpoint** → `ComfyUI/models/diffusion_models/` (from [Hugging Face](https://huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI))
+   - **Text Encoder** → [`qwen3vl_4b_fp8_scaled.safetensors`](https://huggingface.co/Comfy-Org/Krea-2/resolve/main/text_encoders/qwen3vl_4b_fp8_scaled.safetensors) → `ComfyUI/models/text_encoders/`
+   - **VAE** → [`qwen_image_vae.safetensors`](https://huggingface.co/Comfy-Org/Krea-2/resolve/main/vae/qwen_image_vae.safetensors) → `ComfyUI/models/vae/`
+3. **Run in ComfyUI:**
+   - Drag [`workflows/krea2_turbo_svdquant_w4a4_t2i.json`](workflows/krea2_turbo_svdquant_w4a4_t2i.json) into canvas.
+
+---
+
+## 📥 Which Checkpoint to Download
 
-2. **Download one checkpoint** from `checkpoints/` on Hugging Face into
-   `ComfyUI/models/diffusion_models/`.
+| Checkpoint File | Format & Type | Size | Destination Folder | Loader Node | Recommended For |
+|---|---|---|---|---|---|
+| **`Krea2-Turbo-AllInOne-SVDQuant-W4A4-rank256-actaware-TEW4A4.safetensors`** | **All-in-One** (DiT + 4-bit TE + VAE, rank 256 act-aware) | **12.77 GB** | `models/checkpoints/` | **Krea2 SVDQuant Checkpoint Loader** | **Best for 1-click generation. Easiest setup, and the rank that holds up under a LoRA.** |
+| **`Krea2-Turbo-SVDQuant-W4A4-rank256-actaware.safetensors`** | Standalone DiT (svdq r256 actaware) | 9.10 GB | `models/diffusion_models/` | **Krea2 SVDQuant W4A4 Loader** | Best standalone DiT with LoRA support |
+| **`Krea2-Turbo-SVDQuant-W4A4-rank64.safetensors`** | Standalone DiT (svdq r64) | 7.90 GB | `models/diffusion_models/` | **Krea2 SVDQuant W4A4 Loader** | Smaller footprint without LoRA |
+| **`Krea2-Turbo-W4A4-noLowRank.safetensors`** | Standalone DiT (branchless w4a4) | 7.50 GB | `models/diffusion_models/` | Stock **UNETLoader** | Fastest (~9% faster per step) |
+| **`Krea2-Base-SVDQuant-W4A4-rank256-actaware.safetensors`** | Standalone DiT (Base release) | 9.10 GB | `models/diffusion_models/` | **Krea2 SVDQuant W4A4 Loader** | Base (50 steps, cfg 3.5, real negative) |
 
-3. **Download the text encoder and VAE** — the same ones any Krea 2 Turbo workflow needs:
-   - [`qwen3vl_4b_fp8_scaled.safetensors`](https://huggingface.co/Comfy-Org/Krea-2/resolve/main/text_encoders/qwen3vl_4b_fp8_scaled.safetensors) → `ComfyUI/models/text_encoders/`
-   - [`qwen_image_vae.safetensors`](https://huggingface.co/Comfy-Org/Krea-2/resolve/main/vae/qwen_image_vae.safetensors) → `ComfyUI/models/vae/`
+> 💡 **Folder Tip:**
+> - **All-in-One files** go into `ComfyUI/models/checkpoints/`.
+> - **Standalone DiT files** go into `ComfyUI/models/diffusion_models/`.
 
-4. **Drag in a workflow** from `workflows/`. Each opens with a **READ ME FIRST** note covering
-   the settings that matter.
-   - `krea2_turbo_svdquant_w4a4_t2i.json` → **Turbo**: 8 steps, `cfg 1.0`, zeroed negative.
-   - `krea2_base_svdquant_w4a4_t2i.json` → **base**: 50 steps, `cfg 3.5`, real negative prompt.
+---
+
+## 📑 Workflows Overview
+
+Eight ready-to-use workflows in [`workflows/`](workflows/):
 
-   Any `SVDQuant-W4A4-rank*` file needs the **Krea2 SVDQuant W4A4 Loader** node from this repo;
-   `noLowRank` uses the stock **UNETLoader**. The `*_api.json` files are for POSTing to
-   `/prompt` from a script — don't drag those in, they carry no layout.
+| Workflow File | Purpose | Setup Type |
+|---|---|---|
+| [`krea2_turbo_all_in_one_t2i.json`](workflows/krea2_turbo_all_in_one_t2i.json) | **1-Click Generation** (single 12.77 GB file) | All-in-One |
+| [`krea2_turbo_svdquant_w4a4_t2i.json`](workflows/krea2_turbo_svdquant_w4a4_t2i.json) | Standard Turbo text-to-image (8 steps, `cfg 1.0`) | 3-File Modular |
+| [`krea2_turbo_svdquant_w4a4_lora.json`](workflows/krea2_turbo_svdquant_w4a4_lora.json) | Turbo with LoRA/LoKr support (`bypass`, `svd delta`, `bake`) | 3-File Modular |
+| [`krea2_base_svdquant_w4a4_t2i.json`](workflows/krea2_base_svdquant_w4a4_t2i.json) | Base non-turbo model (50 steps, `cfg 3.5`) | 3-File Modular |
+| [`krea2_quantize_all_in_one.json`](workflows/krea2_quantize_all_in_one.json) | **Bake your own All-in-One checkpoint** in ComfyUI | Quantizer |
+| [`krea2_quantize.json`](workflows/krea2_quantize.json) | Quantize BF16 DiT to SVDQuant in ComfyUI | Quantizer |
+| [`krea2_quantize_calibrated.json`](workflows/krea2_quantize_calibrated.json) | Live activation capture + quantization | Quantizer |
+| [`krea2_svdquant_diagnostics.json`](workflows/krea2_svdquant_diagnostics.json) | Verify environment, CUDA kernel & memory stats | Diagnostics |
 
 ## See it
 
@@ -200,13 +167,15 @@ a calibration pass if you have one, but the default path needs nothing.
 
 ## The nodes
 
-Installing this adds seven nodes, all under **Krea2/SVDQuant**:
+Installing this adds nine nodes, all under **Krea2/SVDQuant**:
 
 | node | what it is for |
 |---|---|
-| **Krea2 SVDQuant W4A4 Loader** | Loads an `svdq` checkpoint. Its `status` output names the kernel that will actually run — read it first if generation is slow |
-| **Krea2 SVDQuant LoRA Loader** | LoRAs and LoKrs on quantized blocks — see [LoRA](#lora) |
-| **Krea2 SVDQuant Quantize** | Builds a quantized checkpoint without leaving ComfyUI. Blocks the queue (54 s to ~6 min) and writes ~8 GB |
+| **Krea2 SVDQuant W4A4 Loader** | Loads standalone `svdq` DiT diffusion models |
+| **Krea2 SVDQuant Checkpoint Loader** | Loads unified **All-in-One** checkpoints (DiT + 4-bit Qwen3-VL 4B TE + VAE) |
+| **Krea2 SVDQuant LoRA Loader** | LoRAs, LoKrs, and LoHas on quantized blocks — supports `bypass`, `svd delta`, and `bake` modes |
+| **Krea2 SVDQuant Quantize** | Builds a quantized DiT checkpoint without leaving ComfyUI |
+| **Krea2 SVDQuant Quantize All-in-One** | Bakes DiT, 4-bit text encoder, and VAE into a unified ~12 GB checkpoint directly from ComfyUI |
 | **Krea2 SVDQuant Diagnostics** | Backend dispatch, memory accounting, per-layer timings, profiler table |
 | **Krea2 SVDQuant Env Check** | Is the int4 kernel available at all? Needs no model, so you can ask before downloading 8 GB |
 | **Krea2 SVDQuant Capture Start** / **Capture Save** | Record activation statistics for an activation-aware build |
@@ -217,12 +186,13 @@ Installing this adds seven nodes, all under **Krea2/SVDQuant**:
 | file | what it is |
 |---|---|
 | `quantize_krea2.py` | Converts a BF16 Krea 2 checkpoint to int8, w4a4, or w4a4 + low-rank (svdq). Also the CLI |
-| `svdquant_w4a4.py` | The **W4A4 Loader** node — loads `--format svdq` checkpoints (self-contained, no base model needed) |
+| `svdquant_w4a4.py` | The **W4A4 Loader** & **Checkpoint Loader** nodes — loads standalone or All-In-One `--format svdq` checkpoints |
 | `svdquant_lora.py` | The **LoRA Loader** node — applies LoRAs as a parallel branch so the 4-bit weight is never dequantized |
 | `svdquant_quantize.py` | The **Quantize** node — the quantizer above, from inside ComfyUI |
 | `svdquant_capture.py` | The **Capture Start/Save** nodes — record per-channel activation RMS for `--act-stats` |
 | `svdquant_diag.py` | The **Diagnostics** and **Env Check** nodes |
 | `diagnose.py` | The same reports from a terminal, without starting ComfyUI (`--mode all` for everything) |
+| `tools/build_all_in_one.py` | Bakes DiT, 4-bit text encoder (Qwen3-VL 4B), and VAE into a single combined checkpoint (~12 GB) |
 | `tools/fidelity_bench.py` | Paired multi-seed multi-LoRA LPIPS harness. Every fidelity claim in this repo comes from it |
 | `tools/speed_bench.py` | Per-step speed, by timing each checkpoint at two step counts and taking the slope. Every s/step number in this repo comes from it |
 | `tools/contact_sheet.py` | Builds the contact sheets in [GALLERY.md](GALLERY.md) — for looking at, not scoring |
@@ -237,12 +207,37 @@ is **API format** (POST to `/prompt`, no layout). Both come out of `build_workfl
 
 ## Build your own checkpoint
 
+**Without a terminal.** Drag `workflows/krea2_quantize.json` in, point `source_model` at your
+BF16 checkpoint, press Queue. Every widget carries a tooltip and the note on the left covers
+the choices that matter (which format, which rank, how much disk).
+
+Fill in `act_stats` while you are there — it is the cheapest quality you will get here and you
+do not have to measure anything for it. Download the file matching your variant from
+[`calibration/`](https://huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI/tree/main/calibration)
+(6.67 MB) into `ComfyUI/output/` and type its name in: `krea2_act_stats_turbo.safetensors` for Turbo,
+`krea2_act_stats_base.safetensors` for base.
+
+**You only need to capture your own statistics for weights those files do not describe** — a
+finetune, a merge, anything that is not the released checkpoint. Activation statistics describe
+the weights they came from, and sharing an architecture is not enough: Turbo's file loads into a
+base build without complaint and then describes the wrong model. `check_act_stats_coverage`
+catches a genuinely foreign model before any GPU work, but it matches on layer *names*, which
+Turbo and base share — so it cannot catch that particular mistake for you. For that case,
+`workflows/krea2_quantize_calibrated.json` runs the capture and the quantize in one Queue press:
+the Capture Save node's `act_stats_path` output feeds the Quantize node, and that wire is also
+what guarantees the calibration runs *first* — without it ComfyUI is free to quantize before
+sampling and you get an uncalibrated file with no warning.
+
+Three things to know before you press Queue, in either graph: it blocks the queue for the
+whole run (54 s to ~6 min), it unloads any resident model to take the GPU, and it writes ~8 GB
+(refusing rather than overwriting unless you tick `overwrite`).
+
 From a terminal:
 
 ```bash
-cd ComfyUI/custom_nodes/krea2-svdquant
+cd ComfyUI/custom_nodes/krea-2-svdquant
 python quantize_krea2.py /path/to/krea2_bf16.safetensors --format svdq --rank 256 \
-  --act-stats krea2_act_stats.safetensors
+  --act-stats krea2_act_stats_turbo.safetensors
 ```
 
 `--format int8` and `--format w4a4` also work (`int8` is the most faithful option and still
@@ -251,9 +246,16 @@ python quantize_krea2.py /path/to/krea2_bf16.safetensors --format svdq --rank 25
 the metadata — it does not change the quantization, since layer selection keys off block
 naming that Turbo and base share.
 
-Or use the **Krea2 SVDQuant Quantize** node, which calls the same code. Three things first: it
-blocks the queue for the whole run, it unloads any resident model to take the GPU, and it
-writes ~8 GB (refusing rather than overwriting unless you tick `overwrite`).
+The **Krea2 SVDQuant Quantize** node calls this same function — the CLI and the graph are one
+quantizer, not two that drift.
+
+**Builds are reproducible, per device.** The low-rank split is a *randomized* SVD, so before
+`--seed` existed two runs of the same command on the same GPU produced different checkpoints —
+around 1e-4 per weight, which a sampler then compounds over 8–50 steps into a visibly different
+image. The seed defaults to `0`; pass `--seed -1` (or `-1` in the node) for the old behaviour.
+Across devices it still differs whatever the seed: CPU and CUDA neither draw the same numbers
+nor reduce their GEMMs in the same order. Both the seed and the build device are recorded in
+the checkpoint metadata (`krea2_svdquant_seed`, `krea2_svdquant_device`).
 
 **`rank` and `refine_iters` are one lever, not two.** With refinement off a rank sweep is flat
 — rank 16 and rank 256 land within noise of each other — so raising rank without
@@ -336,6 +338,25 @@ one that worked, and it optimises against something else.
 
 </details>
 
+### All-in-One Checkpoint (`tools/build_all_in_one.py`)
+
+Bake the diffusion model, text encoder, and VAE into a single file (~12 GB instead of 15.5 GB across three separate files):
+
+```bash
+python tools/build_all_in_one.py \
+    --dit  models/diffusion_models/Krea2-Turbo-SVDQuant-W4A4-rank64.safetensors \
+    --text-encoder models/text_encoders/qwen3vl_4b_bf16.safetensors \
+    --vae  models/vae/Krea2-HD-vae.safetensors \
+    --te-format w4a4 --variant turbo
+```
+
+* **Streaming Safetensors writer**: never holds the combined 12+ GB in memory simultaneously.
+* **Quantized Text Encoder**: quantizes the 252 linear projections of Qwen3-VL 4B (`self_attn.*_proj`, `mlp.*_proj`) to 4-bit (`convrot_w4a4` or `int8`) while leaving the vision tower and embeddings untouched.
+* **Loading**:
+  - `SVDQuant` all-in-one checkpoints load with the **Krea2 SVDQuant Checkpoint Loader** node.
+  - Branchless checkpoints (`--format w4a4` or `int8`) load with stock **CheckpointLoaderSimple**.
+* **Workflow**: drag `workflows/krea2_turbo_all_in_one_t2i.json` into ComfyUI for a streamlined 1-loader generation graph.
+
 ## What was measured
 
 Full tables, methodology and caveats: **[BENCHMARKS.md](BENCHMARKS.md)**. Images:
@@ -453,10 +474,12 @@ coverage.
 
 ## Troubleshooting
 
-**[TROUBLESHOOTING.md](TROUBLESHOOTING.md)** covers the five things that actually go wrong:
+**[TROUBLESHOOTING.md](TROUBLESHOOTING.md)** covers the things that actually go wrong:
 generation slower than FP8 (nearly always a pre-cu130 torch build), no speedup at all on
-RTX 20-series, `Pin error.` in the console, out-of-memory on a small card, and "left over keys
-in diffusion model" after re-saving.
+RTX 20-series, `Pin error.` in the console, iteration time jumping to 30-100 s past ~12 GB
+(fixed — update if you see it), **LoRA renders changing after this release** (measured, and
+the old behaviour was the unstable one), out-of-memory on a small card, LoRAs that match no
+layer, sage-attention artifacts, and "left over keys in diffusion model" after re-saving.
 
 Start with the **Krea2 SVDQuant Diagnostics** node between the loader and the KSampler, or:
 

ROADMAP.md

@@ -9,7 +9,78 @@ down gets run twice.
 
 ---
 
-## 1. Act-aware at ranks other than 256
+## 1. Let the svdq loader use ComfyUI's dynamic patcher
+
+**Status: done.** `disable_dynamic=True` is gone from both loaders; they default to whatever
+ComfyUI would do for any other model, which on an ordinary launch is `ModelPatcherDynamic`.
+The `vram_management` input (and `KREA2_DISABLE_DYNAMIC=1`) restores the pin.
+
+The pin was waiting on two conditions. Both hold on current ComfyUI, and both were
+measured, not argued from the source:
+
+1. **The branch buffers survive the streaming patcher.** `ModelPatcherDynamic.load()` ends
+   by walking `self.model.named_buffers(recurse=True)`, moving every buffer to the load
+   device with `set_attr_buffer` and stashing the original in `self.backup_buffers`. Unload
+   is symmetric: `partially_unload()` falls through to `restore_loaded_backups()`.
+
+   Measured on a 3090 with `--reserve-vram 15` (~7 GB usable against an 8.51 GiB model),
+   read from the diagnostics node *after* a render — which is the only time it means
+   anything, since both arms show `cpu` at load time:
+
+   | `vram_management` | factor devices | weight devices | lowvram |
+   |---|---|---|---|
+   | `auto` | **448 × `cuda:0`** | 224 × `cpu` | False |
+   | `classic` | 368 × `cpu`, 80 × `cuda:0` | 184 × `cpu`, 40 × `cuda:0` | True |
+
+   So `add_low_rank`'s `cast_to` really is a no-op under `auto` — the opposite of the
+   feared per-step multi-MB staging copy — and the division of labour is the one you would
+   pick by hand: the small branch every step needs stays resident, the 4-bit weights
+   stream.
+2. **`module_size()` still counts them.** `_load_list()` derives its per-module budget from
+   `comfy.model_management.module_size`, which sums `state_dict()` — exactly what
+   `_publish_in_state_dict` exists to feed. The 1.6 GiB at rank 256 is visible to the
+   budget.
+
+Two things that also had to be true and are:
+
+* The compile fast path self-disables rather than reading a stale weight. Under the dynamic
+  patcher the resident copy lives in `_v_weight`/`_prefetch` while `module.weight` stays on
+  the host, so `_install_custom_op`'s per-call `weight._qdata.device != x.device` check
+  sends the call to the stock forward. Correct, at the cost of the in-graph op — which only
+  matters under `TorchCompileModel`.
+* The LoRA node is unaffected: it works through `add_object_patch`, and
+  `ModelPatcherDynamic.patch_model` delegates object patches to `super()`.
+
+**What is still open:** the buffers are moved with a plain device copy, outside the dynamic
+allocator's `allocated_size` accounting. Real VRAM, invisible bookkeeping. That is why the
+escape hatch shipped with the fix rather than the fix shipping alone.
+
+## 1b. Decide which patcher renders a LoRA *correctly*
+
+**Status: open, and the only loose end left by the unpin.** Without a LoRA the two patchers
+are bit-identical. With one they are not, and `classic` is additionally not reproducible --
+its output moves with how much of the model was offloaded:
+
+| pair | PSNR | SSIM |
+|---|---|---|
+| `auto` vs `auto`, three runs across two VRAM budgets | ∞ | 1.000000 |
+| `classic` full-load vs `classic` under `--reserve-vram 15` | 17.86 dB | 0.712 |
+| `classic` vs `auto` | 15.4-15.9 dB | 0.61-0.65 |
+
+The branch bookkeeping is identical in both arms -- 224 quantized layers branched, 32
+patched normally, logged the same either way -- so this is not the node failing to attach
+something. The suspects are the 32 non-quantized layers, which go through ComfyUI's own
+`add_patches`, and the fact that the classic path has two ways of applying a patch (in place
+when resident, `LowVramPatch` at cast time when not) while the dynamic path has one.
+
+`auto` being invariant is a good sign and not a proof. **Nothing here establishes which
+image is the faithful one.** What would: apply the same LoRA to a BF16 Krea 2 and compare
+both arms against it with `tools/fidelity_bench.py` -- the harness already does paired
+LPIPS against a BF16 reference, so this is a run, not new machinery. Until that happens the
+honest statement is the one in TROUBLESHOOTING.md: the default changed, the output changed,
+and the new one is at least reproducible.
+
+## 2. Act-aware at ranks other than 256
 
 **Status:** never tried. `--act-stats` shipped after the rank sweep was run, and only a
 rank-256 build was ever made. So "is act-aware rank 64 as good as act-aware rank 256" is
@@ -37,7 +108,7 @@ that rank 256 is "~4% slower than rank 16" — it is 8.2%.)
 
 **Cost:** two builds (~14 min each) plus a `base`-arm fidelity run (~25 min).
 
-## 2. Make `TorchCompileModel` work on branchless checkpoints
+## 3. Make `TorchCompileModel` work on branchless checkpoints
 
 **Status:** open bug, one failed attempt.
 
@@ -67,49 +138,102 @@ see whether Dynamo honours an instance-level `forward` on a *child* module in th
 That separates "Dynamo ignores instance patches on children" from "something in ComfyUI
 replaces the module".
 
-## 3. Fold LoKr/LoHa/OFT deltas into the low-rank branch by SVD
+## 4. Fold LoKr/LoHa/OFT deltas into the low-rank branch by SVD
 
-**Status:** idea, not started. Would become a third value for the LoRA node's `adapters`
-input, alongside `bypass` and `bake`.
+**Status:** Completed in `experimental/all-in-one`. Added as the `svd delta` mode for `Krea2SVDQuantLoraLoader`, decomposing weight deltas at load time via `torch.svd_lowrank` and merging low-rank factors into the low-rank branch with zero per-step runtime overhead.
 
-**The problem it solves.** Today's two options both cost something:
-
-| mode | s/step (3090, 1440x1920, r256 + LoRA + LoKr + a `.diff`) | what it costs you |
-|---|---|---|
-| `bypass` (default) | 5.21 | exact, but the adapter runs every forward |
-| `bake` | 3.55 | fast, but the LoKr delta is requantized to **4 bits** |
-| stock loader | 3.22 | same, and the plain LoRA is requantized too |
-
-The bypass cost is inherent, not an implementation flaw — ComfyUI's `h()` already does the
-efficient nested contraction and never materialises the Kronecker product
-(`comfy/weight_adapter/lokr.py:146-163`). For a 6144→6144 layer with 4 groups it is ~38.7
-GMAC per layer in **bf16**, against the base layer's 154 GMAC in **int4**. A quarter of the
-arithmetic on hardware that is ~8x slower for it, which is why it roughly doubles the layer.
-
-**The idea.** At load time, extract the adapter's weight delta via ComfyUI's own
-`calculate_weight` (applied to a zero weight, so the result is the pure ΔW), take a truncated
-SVD with `torch.svd_lowrank`, and concatenate the factors onto the layer's existing
-`svdq_l1`/`svdq_l2`. Runtime cost then drops to *zero* beyond a slightly wider branch, and the
-delta is **truncated rather than quantized to 4 bits** — the same trade already accepted for
-the base weight, and a much gentler one than `bake` makes.
-
-**Open questions:** what rank the delta needs (a Kronecker product is not inherently
-low-rank, so this may need measuring per adapter); ~15 s of SVD at load across 224 layers;
-and whether the widened branch's VRAM is acceptable, given the branch is already 24% of a step
-at rank 256. Wants a fidelity run against `bypass` before it could become the default.
-
-## 4. Mixed precision: keep the first and last blocks at W8A8
+## 5. Mixed precision: keep the first and last blocks at W8A8
 
 **Status:** standard SVDQuant lever, never tried here. Costs file size, buys fidelity. No
 estimate — nothing has been measured, which is exactly why it is on this list rather than
 above the items that have been.
 
-## 5. Benchmark the base checkpoint
+## 6. Benchmark the base checkpoint
 
 `Krea2-Base-SVDQuant-W4A4-rank256-actaware` is published and has **never been through the
 paired benchmark** (README says so). `tools/fidelity_bench.py --variant base` already
 supports it. Not a quality lever — a claim with no evidence behind it.
 
+## 7. All-in-one checkpoint: diffusion + text encoder + VAE in one file
+
+**Status:** Completed in `experimental/all-in-one`.
+- Standalone builder: `tools/build_all_in_one.py` (streaming two-pass safetensors assembler).
+- In-Graph node: `Krea2SVDQuantQuantizeAllInOne` in `svdquant_quantize.py`.
+- Loader node: `Krea2SVDQuantCheckpointLoader` in `svdquant_w4a4.py`.
+- Workflows: `workflows/krea2_turbo_all_in_one_t2i.json` and `workflows/krea2_quantize_all_in_one.json`.
+- Quantizes the 252 language projections of Qwen3-VL 4B to 4-bit (`convrot_w4a4`, ~3.2 GB) while keeping the vision tower (315 tensors) and embeddings in native precision for 100% prompt fidelity. Total size: ~11.7–12.3 GB (down from 33.5 GB BF16 / 15.5 GB split).
+
+**ComfyUI already supports this, which is the surprise.** `class Krea2` in
+`comfy/supported_models.py` defines `vae_key_prefix = ["vae."]` and
+`text_encoder_key_prefix = ["text_encoders."]`, and its `clip_target()` runs `llama_detect`
+over `text_encoders.qwen3vl_4b.transformer.`, which resolves to
+`comfy.utils.detect_layer_quantization` — a check for `.comfy_quant` markers that is entirely
+format-agnostic. Any layer we quantize with the machinery already in `quantize_krea2.py`
+switches the encoder onto `mixed_ops` and loads. So a **branchless** all-in-one file
+(`--format w4a4` or `int8`) needs no ComfyUI change and no node from this repo: it loads with
+the stock `CheckpointLoaderSimple`.
+
+An **svdq** all-in-one does need a node, because the `svdq_l1`/`svdq_l2` buffers have to be
+popped and attached the way `load_svdquant_w4a4` does. That is a wrapper around
+`comfy.sd.load_state_dict_guess_config`, not new mechanism.
+
+### The size arithmetic
+
+Measured file sizes, not estimates, except where marked:
+
+| component | today | all-in-one target |
+|---|---|---|
+| diffusion | 9.78 GB (svdq rank 256) | 8.48 GB (rank 64) or 8.05 GB (noLowRank) |
+| text encoder | 5.24 GB (`qwen3vl_4b_fp8_scaled`) | ~3.3 GB at 4-bit *(estimated)* |
+| VAE | 0.51 GB | 0.51 GB, unquantized |
+| **total** | **15.5 GB across 3 files** | **~11.9–12.3 GB in 1 file** |
+
+The 4-bit encoder estimate scales the BF16 encoder (8.88 GB) by the ratio the diffusion model
+gets (24 GB → 8.05 GB, ~34%), and is the number most likely to be wrong: a 4B LLM spends a much
+larger share of itself on embeddings than a DiT does, and embeddings do not quantize here.
+
+Note what this does **not** buy: the text encoder and the diffusion model are never resident at
+the same time — ComfyUI encodes, unloads, then samples. So this is a disk, download and
+correctness win, and a VRAM win during the encode pass only. Sampling speed and sampling VRAM
+do not move. Worth saying out loud before anyone reads "12 GB instead of 15.5 GB" as a VRAM
+figure.
+
+### What has to be built
+
+1. **A second layer set.** `_QUANT_SUFFIXES` targets `blocks.N.{attn,mlp}.*`, which is the DiT.
+   The encoder is a Qwen3 LLM: `layers.N.self_attn.{q,k,v,o}_proj`,
+   `layers.N.mlp.{gate,up,down}_proj`. `is_target` has to take the set rather than close over
+   one.
+2. **Leave the vision tower alone**, at least at first. Qwen3-VL carries one, krea2edit's image
+   conditioning path may use it, and quantizing something to find out whether it is dead weight
+   is the wrong order of operations.
+3. **A combiner**, streaming three state dicts into one with the prefixes above. The BF16 source
+   is 24 GB and the encoder another 8.88 GB, so it has to stream the way `convert()` already
+   does rather than build the dict in memory.
+4. **An svdq checkpoint loader node**, if the svdq variant is wanted.
+
+### The risk, and how to measure it
+
+4-bit is a much bigger ask of an LLM than of this DiT. The DiT tolerates it because convrot
+spreads the outliers and the low-rank branch absorbs what is left; LLM activations have
+outlier channels severe enough that a whole literature (SmoothQuant, AWQ) exists about them.
+INT8 is not an alternative — it is the same byte count as the FP8 encoder we already ship, so
+4-bit is the only setting that changes the number.
+
+Failure will not look like noise. It will look like **prompt adherence quietly getting worse**:
+a dropped clause, a colour that drifts, a count that stops being respected. That is exactly the
+kind of regression the existing harness catches, because it is measured against a BF16
+reference at fixed seeds — hold the diffusion model constant, swap only the encoder, and run
+`tools/fidelity_bench.py`. The dense-text and counting prompts in the benchmark set are the
+ones to read first.
+
+Act-aware calibration on the encoder is the natural follow-up if plain 4-bit is close but not
+close enough. It needs its own capture: the hooks would ride on `CLIPTextEncode`, not on the
+sampler, so `svdquant_capture.py` needs a second pair of nodes rather than a flag. Do not build
+that before the plain 4-bit measurement says whether it is needed.
+
+---
+
 ---
 
 ## Measured and rejected — do not redo these

TROUBLESHOOTING.md

@@ -122,20 +122,109 @@ locked pages aggressively — `MAX_PINNED_MEMORY` there is 40% of system RAM —
 routinely with a model this size. It is not specific to `svdq`; INT8 checkpoints trigger it
 too. The diagnostics node prints your pinned-memory budget under `mode=env`.
 
+## Iteration time jumps to 30-100 s once VRAM passes ~12 GB (and FP8/INT8 do not)
+
+**Fixed.** If you are on a build that still does this, update.
+
+The `svdq` loader used to opt the model out of ComfyUI's dynamic VRAM management:
+`load_svdquant_w4a4` passed `disable_dynamic=True`, which pinned it to the classic
+`ModelPatcher`. The stock `UNETLoader` does not do that, so the FP8, INT8 and `noLowRank`
+checkpoints got the streaming patcher and the `svdq` ones did not. Past the point where the
+model no longer fits, the pinned path falls back to streaming weights per module per step,
+and a ~1 s iteration becomes 30-100 s. Nothing about the quantization was involved — it was
+which patcher the loader asked for.
+
+Both loaders now default to whatever ComfyUI would do for any other model, which on an
+ordinary launch is the dynamic patcher. The **status output** on the loader node says which
+one you got:
+
+```
+w4a4 + low-rank: attached 224 branches (rank 256, variant turbo), model_size 9.10 GiB,
+ModelPatcherDynamic (dynamic vram: on), compile: 224 layers in-graph via krea2::w4a4_linear
+```
+
+`ModelPatcher (dynamic vram: off)` there means you are on the old path — either you set
+`vram_management` to `classic`, or ComfyUI itself has dynamic VRAM off (`--highvram`,
+`--novram`, `--gpu-only`, `--cpu`, `--disable-dynamic-vram`, or no working `comfy-aimdo`
+install; the startup log says `DynamicVRAM support detected and enabled` when it is on).
+
+### If you need the old behaviour back
+
+One thing here is genuinely unmeasured: the streaming patcher moves the low-rank branch
+buffers with a plain device copy rather than through its own allocator, so at rank 256 there
+is 1.6 GiB of real VRAM its internal bookkeeping does not account for. If that turns out to
+bite on your card, set the loader's **`vram_management`** input to `classic`, or run the
+whole server with `KREA2_DISABLE_DYNAMIC=1`. Please open an issue if you have to — that is
+the case this escape hatch exists to hear about.
+
+### Still tight on a 12 GB card
+
+The branch is real memory on top of the checkpoint — measured off the published files,
+1.6 GiB at rank 256 and 0.4 GiB at rank 64 across the 224 blocks — and the rank-256 build is
+9.10 GB against 7.50 GB for `noLowRank`. So the older advice still holds as a *size*
+argument, just no longer as a workaround for a 30x slowdown:
+
+1. **`Krea2-Turbo-W4A4-noLowRank.safetensors`** (7.50 GB) is ~9% faster per step than any
+   rank, and gives up the low-rank branch's fidelity.
+2. **`Krea2-Turbo-SVDQuant-W4A4-rank64.safetensors`** (7.90 GB) is 1.2 GB smaller than rank
+   256 and statistically identical to it *as long as you never load a LoRA*.
+3. Watch the loader's `model_size` line — it reports the real number, branch included.
+
+## My LoRA renders changed after updating (and the image moves when VRAM gets tight)
+
+Measured, real, and only half explained. Read this before concluding a LoRA is broken.
+
+With **no LoRA loaded**, the two patchers are bit-identical — same seed, same graph, same
+pixels, verified at three different VRAM budgets. With a **LoRA loaded** they are not:
+
+| pair | PSNR | SSIM |
+|---|---|---|
+| `auto` vs `auto`, different VRAM budgets, three runs | ∞ | 1.000000 |
+| `classic` full-load vs `classic` under pressure | 17.86 dB | 0.712 |
+| `classic` vs `auto` | 15.4-15.9 dB | 0.61-0.65 |
+
+So the instability is on the `classic` side: it renders a LoRA differently depending on how
+much of the model got offloaded, because ComfyUI's classic path applies patches through
+`LowVramPatch` at cast time when a layer is not resident and in place when it is. The
+dynamic patcher has one path and uses it always, which is why all three `auto` runs agree
+to the bit.
+
+Until this release the loader pinned to `classic`, so **your previous LoRA output was the
+classic one** — and, if you were near your VRAM limit, not necessarily reproducible either.
+Now the default is `auto` and the result is stable. It is also a different image.
+
+**What has not been established: which one is numerically right.** Determinism is not
+correctness. Settling it needs the same LoRA applied to a reference the quantized path can
+be compared against, and that reference does not exist here yet — see
+[ROADMAP.md](ROADMAP.md). If you preferred the old look, `vram_management=classic` on the
+loader node reproduces it, with the pressure-dependence that comes with it.
+
 ## Out of memory on a small card (and int8 works fine)
 
 Fixed. The low-rank factors were attached as non-persistent buffers, which ComfyUI's
 `module_size()` — the basis of every VRAM decision, including the lowvram split — could
 not see, while `.to(device)` moved them anyway. Worse, the old branch cached its own
 device move back onto the module, so once ComfyUI offloaded a layer the factors quietly
-came back to the GPU and stayed there, outside all accounting. About 645 MB at rank 64,
-which is the difference between fitting and not on an 8 GB card. INT8 checkpoints carry no
-branch, so they were never affected.
+came back to the GPU and stayed there, outside all accounting. 0.4 GiB at rank 64 and
+1.6 GiB at rank 256, which is the difference between fitting and not on an 8 GB card. INT8
+checkpoints carry no branch, so they were never affected.
 
 They are now published into `state_dict()` under their own `svdq_l1` / `svdq_l2` keys and
 staged per call via `comfy.model_management.cast_to`, so they are budgeted and offloaded
-like any other weight. `mode=env` on the diagnostics node reports the factor devices — under
-lowvram they should sit on `cpu` between steps, not `cuda`.
+like any other weight.
+
+`mode=env` on the diagnostics node reports the factor devices, and **what you should see
+depends on which patcher you are on** — read it after a render, not before, because at load
+time both arms say `cpu`:
+
+| `vram_management` | healthy `factor devices` |
+|---|---|
+| `auto` (dynamic, the default) | all on `cuda:0` — 448 of them at rank 256 |
+| `classic` | mostly `cpu`, staged per call |
+
+`cuda` under `auto` is not the old bug coming back; it is the streaming patcher keeping the
+small always-needed branch resident and streaming the 4-bit weights instead, which is what
+makes it fast. Measured both ways on a 3090 under `--reserve-vram 15`.
 
 One gap remains and it is upstream, not here: `QuantizedTensor.nbytes` reports only the
 packed weight, so the W4A4 `weight_scale` (~3 MB/layer) is still invisible to ComfyUI's

__init__.py

@@ -1,27 +1,27 @@
-from .svdquant_capture import (
-    NODE_CLASS_MAPPINGS as _CAPTURE_NODES,
-    NODE_DISPLAY_NAME_MAPPINGS as _CAPTURE_NAMES,
-)
-from .svdquant_diag import (
-    NODE_CLASS_MAPPINGS as _DIAG_NODES,
-    NODE_DISPLAY_NAME_MAPPINGS as _DIAG_NAMES,
-)
-from .svdquant_lora import (
-    NODE_CLASS_MAPPINGS as _LORA_NODES,
-    NODE_DISPLAY_NAME_MAPPINGS as _LORA_NAMES,
-)
-from .svdquant_quantize import (
-    NODE_CLASS_MAPPINGS as _QUANT_NODES,
-    NODE_DISPLAY_NAME_MAPPINGS as _QUANT_NAMES,
-)
-from .svdquant_w4a4 import (
-    NODE_CLASS_MAPPINGS as _W4A4_NODES,
-    NODE_DISPLAY_NAME_MAPPINGS as _W4A4_NAMES,
-)
-
-NODE_CLASS_MAPPINGS = {**_LORA_NODES, **_W4A4_NODES, **_DIAG_NODES, **_QUANT_NODES,
-                       **_CAPTURE_NODES}
-NODE_DISPLAY_NAME_MAPPINGS = {**_LORA_NAMES, **_W4A4_NAMES, **_DIAG_NAMES, **_QUANT_NAMES,
-                              **_CAPTURE_NAMES}
-
-__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]
+from .svdquant_capture import (
+    NODE_CLASS_MAPPINGS as _CAPTURE_NODES,
+    NODE_DISPLAY_NAME_MAPPINGS as _CAPTURE_NAMES,
+)
+from .svdquant_diag import (
+    NODE_CLASS_MAPPINGS as _DIAG_NODES,
+    NODE_DISPLAY_NAME_MAPPINGS as _DIAG_NAMES,
+)
+from .svdquant_lora import (
+    NODE_CLASS_MAPPINGS as _LORA_NODES,
+    NODE_DISPLAY_NAME_MAPPINGS as _LORA_NAMES,
+)
+from .svdquant_quantize import (
+    NODE_CLASS_MAPPINGS as _QUANT_NODES,
+    NODE_DISPLAY_NAME_MAPPINGS as _QUANT_NAMES,
+)
+from .svdquant_w4a4 import (
+    NODE_CLASS_MAPPINGS as _W4A4_NODES,
+    NODE_DISPLAY_NAME_MAPPINGS as _W4A4_NAMES,
+)
+
+NODE_CLASS_MAPPINGS = {**_LORA_NODES, **_W4A4_NODES, **_DIAG_NODES, **_QUANT_NODES,
+                       **_CAPTURE_NODES}
+NODE_DISPLAY_NAME_MAPPINGS = {**_LORA_NAMES, **_W4A4_NAMES, **_DIAG_NAMES, **_QUANT_NAMES,
+                              **_CAPTURE_NAMES}
+
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

build_all_in_one.py

@@ -0,0 +1,435 @@
+"""Bake the diffusion model, the text encoder and the VAE into one checkpoint.
+
+The mechanism. `tools/build_all_in_one.py` is the command-line front end for it and
+`Krea2SVDQuantQuantizeAllInOne` (svdquant_quantize.py) is the in-graph one; this module
+lives beside `quantize_krea2.py` rather than under `tools/` because `.comfyignore`
+keeps `tools/` out of the published package and the node has to be able to import it.
+
+    python tools/build_all_in_one.py \\
+        --dit  D:/ComfyUI/models/diffusion_models/turbo.safetensors \\
+        --text-encoder D:/ComfyUI/models/text_encoders/qwen3vl_4b_bf16.safetensors \\
+        --vae  D:/ComfyUI/models/vae/Krea2-HD-vae.safetensors \\
+        --format svdq --rank 64 --te-format w4a4 --variant turbo \\
+        --act-stats calibration/krea2_act_stats_turbo.safetensors
+
+Three downloads that have to match becomes one file. `--dry-run` does the whole key mapping
+and prints the size arithmetic without quantizing anything or touching the GPU, which is the
+right way to check the layout before spending ten minutes on a build.
+
+WHAT COMFYUI EXPECTS, AND WHY THIS IS MOSTLY A RENAMING PROBLEM
+
+`comfy/supported_models.py`'s `Krea2` already declares `vae_key_prefix = ["vae."]` and
+`text_encoder_key_prefix = ["text_encoders."]`, and its `clip_target()` runs
+`detect_layer_quantization` over the encoder prefix -- a format-agnostic scan for
+`.comfy_quant` markers. So a quantized text encoder inside a combined checkpoint is a case
+ComfyUI already handles; nothing upstream needs changing. The three maps:
+
+    diffusion  blocks.N...                ->  model.diffusion_model.blocks.N...
+    vae        conv1... / encoder...      ->  vae.conv1... / vae.encoder...
+    encoder    model.language_model.X     ->  text_encoders.qwen3vl_4b.transformer.model.X
+               model.visual.X             ->  text_encoders.qwen3vl_4b.transformer.visual.X
+               lm_head.X                  ->  text_encoders.qwen3vl_4b.transformer.model.lm_head.X
+
+The encoder map is not invented here: it is the same `state_dict_prefix_replace` call
+`comfy/sd.py` makes in `load_text_encoder_state_dicts` when you load that file through
+`CLIPLoader`. Standalone loading applies it at load time; a combined checkpoint has to carry
+the keys already converted, because `load_state_dict_guess_config` does not repeat it.
+
+WHICH FORMATS
+
+The diffusion side takes any `--format` `quantize_krea2.py` supports. `svdq` gives the best
+fidelity but the `svdq_l1`/`svdq_l2` buffers need this repo's loader to attach them, so an
+svdq all-in-one needs the Krea2 SVDQuant Checkpoint Loader node rather than the stock
+`CheckpointLoaderSimple`. Build with `--format w4a4` or `int8` for a file that loads with
+stock ComfyUI and no custom node at all.
+
+The text encoder takes `--te-format w4a4` or `int8` only, and never a low-rank branch. Not a
+limitation of the quantizer -- `load_state_dict_guess_config` builds the CLIP through
+ComfyUI's own path, which has nowhere to hang a branch. 4-bit is the only setting that
+changes the number worth changing: INT8 is one byte per weight, the same as the FP8 encoder
+already published.
+
+WHAT THIS DOES NOT BUY
+
+The text encoder and the diffusion model are never resident at the same time -- ComfyUI
+encodes the prompt, unloads, then samples. This is a disk, download and don't-mismatch-your-
+files win, plus a VRAM win during the encode pass. Sampling speed and sampling VRAM do not
+move at all.
+"""
+from __future__ import annotations
+
+import json
+import os
+import struct
+import time
+
+import torch
+from safetensors import safe_open
+
+# Relative when imported as part of the pack, absolute when `tools/build_all_in_one.py` runs
+# this as a plain script. The relative arm is the one that matters: importing
+# `quantize_krea2` absolutely from inside the package creates a *second* top-level copy of
+# it, with its own module-level state, alongside the pack's own `.quantize_krea2`.
+#
+# Branching on `__package__` rather than try/except ImportError so that a real failure
+# inside `quantize_krea2` -- a missing comfy, a broken quant backend -- surfaces as itself
+# instead of being retried down the other path and reported as the wrong problem.
+if __package__:
+    from .quantize_krea2 import (
+        DEFAULT_SEED,
+        REFINE_TOL,
+        __version__,
+        conf_tensor,
+        detect_prefix,
+        quantize_weight,
+        resolve_format,
+    )
+else:  # run outside the package by tools/build_all_in_one.py, which puts it on sys.path
+    from quantize_krea2 import (
+        DEFAULT_SEED,
+        REFINE_TOL,
+        __version__,
+        conf_tensor,
+        detect_prefix,
+        quantize_weight,
+        resolve_format,
+    )
+
+# `model.` here is the encoder's own `model.`, i.e. what `model.language_model.` becomes.
+TE_PREFIX = "text_encoders.qwen3vl_4b.transformer."
+DIT_PREFIX = "model.diffusion_model."
+VAE_PREFIX = "vae."
+
+# Exactly `comfy/sd.py`'s `load_text_encoder_state_dicts` mapping for a Qwen3-VL file. Order
+# matters: `model.language_model.` has to be tried before any shorter `model.` rule would be.
+TE_KEY_MAP = (
+    ("model.language_model.", "model."),
+    ("model.visual.", "visual."),
+    ("lm_head.", "model.lm_head."),
+)
+
+# The 7 projections in a Qwen3 decoder layer. Deliberately not the DiT's `_QUANT_SUFFIXES`:
+# different architecture, different names, and sharing one tuple between them would make a
+# typo in either silently quantize nothing in the other.
+TE_QUANT_SUFFIXES = ("self_attn.q_proj", "self_attn.k_proj", "self_attn.v_proj",
+                     "self_attn.o_proj", "mlp.gate_proj", "mlp.up_proj", "mlp.down_proj")
+TE_LAYERS = 36
+TE_EXPECTED = TE_LAYERS * len(TE_QUANT_SUFFIXES)
+
+# Formats with no low-rank branch. The text encoder loads through ComfyUI's own CLIP path,
+# which has nowhere to attach one.
+TE_FORMATS = {"w4a4": "convrot_w4a4", "int8": "int8_tensorwise"}
+
+
+def te_is_target(key: str) -> bool:
+    """True for a decoder-layer projection weight, in *converted* key space.
+
+    Converted, not raw: `model.visual.` becomes `visual.`, and the vision tower has layers
+    and projections of its own. Matching after the rename is what keeps them out -- Krea 2's
+    text encoder instantiates the vision tower (315 tensors, 0.83 GB) and krea2edit's image
+    conditioning may go through it, so it is carried unquantized rather than dropped.
+    """
+    if not key.startswith("model.layers.") or not key.endswith(".weight"):
+        return False
+    return key[: -len(".weight")].endswith(TE_QUANT_SUFFIXES)
+
+
+def remap_te_key(key: str) -> str:
+    for old, new in TE_KEY_MAP:
+        if key.startswith(old):
+            return new + key[len(old):]
+    return key
+
+
+_DTYPE_STR = {
+    torch.float32: "F32", torch.float16: "F16", torch.bfloat16: "BF16",
+    torch.float64: "F64", torch.int64: "I64", torch.int32: "I32", torch.int16: "I16",
+    torch.int8: "I8", torch.uint8: "U8", torch.bool: "BOOL",
+    torch.float8_e4m3fn: "F8_E4M3", torch.float8_e5m2: "F8_E5M2",
+}
+
+
+class StreamingWriter:
+    """A safetensors writer that never holds the whole checkpoint in memory.
+
+    `safetensors.torch.save_file` takes a dict, so writing a 12 GB combined checkpoint that
+    way needs 12 GB of RAM on top of whatever the quantizer is using. The format does not
+    require that: it is an 8-byte header length, a JSON header of name -> {dtype, shape,
+    offsets}, then the raw buffers back to back.
+
+    So this is two passes. `plan()` collects names, dtypes and shapes -- which are known
+    without materialising anything -- and `write()` streams the tensors past in the same
+    order. The cost is that every tensor is produced twice or held once; here the shapes come
+    from safetensors headers and quantizer outputs we already have, so it is neither.
+    """
+
+    def __init__(self, path: str, metadata: dict | None = None):
+        self.path = path
+        self.metadata = metadata or {}
+        self.entries = []          # (name, dtype_str, shape, nbytes)
+        self._names = set()
+
+    def plan(self, name: str, dtype, shape) -> None:
+        if name in self._names:
+            raise RuntimeError("duplicate key in the combined checkpoint: {}".format(name))
+        self._names.add(name)
+        dtype_str = _DTYPE_STR.get(dtype)
+        if dtype_str is None:
+            raise RuntimeError("no safetensors name for dtype {}".format(dtype))
+        nbytes = 1
+        for d in shape:
+            nbytes *= d
+        nbytes *= torch.empty((), dtype=dtype).element_size()
+        self.entries.append((name, dtype_str, list(shape), nbytes))
+
+    def header(self) -> bytes:
+        header, offset = {}, 0
+        for name, dtype_str, shape, nbytes in self.entries:
+            header[name] = {"dtype": dtype_str, "shape": shape,
+                            "data_offsets": [offset, offset + nbytes]}
+            offset += nbytes
+        if self.metadata:
+            header["__metadata__"] = {k: str(v) for k, v in self.metadata.items()}
+        blob = json.dumps(header, separators=(",", ":")).encode("utf-8")
+        # The spec wants the buffer 8-byte aligned; pad the header with spaces, which JSON
+        # ignores, rather than the buffer, whose offsets are already committed.
+        pad = (-len(blob)) % 8
+        return blob + b" " * pad
+
+    def __enter__(self):
+        self._blob = self.header()
+        self._fh = open(self.path, "wb")
+        self._fh.write(struct.pack("<Q", len(self._blob)))
+        self._fh.write(self._blob)
+        self._i = 0
+        return self
+
+    def write(self, name: str, tensor: torch.Tensor) -> None:
+        expected = self.entries[self._i]
+        if name != expected[0]:
+            raise RuntimeError("write order does not match the plan: expected {!r}, got {!r}"
+                               .format(expected[0], name))
+        t = tensor.contiguous().cpu()
+        # Shape and dtype, not just the byte count. The header is written from the *plan*,
+        # so a plan that disagrees with the tensor produces a file whose data is right and
+        # whose header lies -- and readers believe the header. A byte check does not catch
+        # it: [4096] and [4096, 1] are the same 16384 bytes, which is exactly how a
+        # text encoder shipped with its scales declared 2-D when convrot_w4a4 returns them
+        # 1-D, and failed only later, inside a kernel, as "scales: shape [4096, 1] fails:
+        # exactly 1D".
+        if list(t.shape) != expected[2]:
+            raise RuntimeError("{}: planned shape {}, got {}".format(
+                name, expected[2], list(t.shape)))
+        planned_dtype = _DTYPE_STR.get(t.dtype)
+        if planned_dtype != expected[1]:
+            raise RuntimeError("{}: planned dtype {}, got {}".format(
+                name, expected[1], planned_dtype))
+        buf = t.view(torch.uint8).reshape(-1) if t.dtype not in (torch.uint8,) else t.reshape(-1)
+        data = buf.numpy().tobytes()
+        if len(data) != expected[3]:
+            raise RuntimeError("{}: planned {} bytes, got {}".format(name, expected[3], len(data)))
+        self._fh.write(data)
+        self._i += 1
+
+    def __exit__(self, *exc):
+        self._fh.close()
+        if exc[0] is None and self._i != len(self.entries):
+            raise RuntimeError("planned {} tensors but wrote {}".format(len(self.entries), self._i))
+
+
+def plan_dit(handle, keys, prefix):
+    """(combined key, source key) for every diffusion tensor, already prefixed."""
+    for key in keys:
+        bare = key[len(prefix):] if prefix and key.startswith(prefix) else key
+        yield DIT_PREFIX + bare, key
+
+
+def plan_vae(keys):
+    for key in keys:
+        yield VAE_PREFIX + key, key
+
+
+def quantize_text_encoder(path: str, fmt: str, groupsize: int, device: str, writer,
+                          dry_run: bool):
+    """Plan (and on the second pass, write) the text encoder side.
+
+    Returns (planned entries, quantized layer count). The two passes run the same key walk so
+    the plan and the write cannot disagree about order -- which is the one way a streaming
+    writer produces a file that is subtly, unreadably wrong.
+    """
+    algo = TE_FORMATS[fmt]
+    quantized = 0
+    with safe_open(path, framework="pt", device="cpu") as handle:
+        keys = list(handle.keys())
+        for key in keys:
+            converted = remap_te_key(key)
+            out_key = TE_PREFIX + converted
+            if not te_is_target(converted):
+                if dry_run:
+                    slice_ = handle.get_slice(key)
+                    writer.plan(out_key, _slice_dtype(slice_), slice_.get_shape())
+                else:
+                    writer.write(out_key, handle.get_tensor(key))
+                continue
+
+            layer = out_key[: -len(".weight")]
+            if dry_run:
+                slice_ = handle.get_slice(key)
+                shape = slice_.get_shape()
+                # int4 packs two values per byte along the input dimension; int8 is 1:1.
+                packed = [shape[0], shape[1] // 2] if fmt == "w4a4" else list(shape)
+                writer.plan(out_key, torch.int8, packed)
+                writer.plan(layer + ".weight_scale", torch.float32,
+                            _scale_shape(algo, shape[0]))
+                writer.plan(layer + ".comfy_quant", torch.uint8, [_conf_len(algo, groupsize)])
+            else:
+                w = handle.get_tensor(key).to(device=device, dtype=torch.bfloat16)
+                qdata, scales, conf = quantize_weight(w, algo, groupsize)
+                writer.write(out_key, qdata)
+                for name, value in scales.items():
+                    writer.write("{}.{}".format(layer, name), value)
+                writer.write(layer + ".comfy_quant", conf_tensor(conf))
+                del w, qdata, scales
+                if quantized % 32 == 0:
+                    torch.cuda.empty_cache()
+            quantized += 1
+    return quantized
+
+
+def _slice_dtype(slice_):
+    return {"F32": torch.float32, "F16": torch.float16, "BF16": torch.bfloat16,
+            "I8": torch.int8, "U8": torch.uint8, "I64": torch.int64,
+            "F8_E4M3": torch.float8_e4m3fn}[slice_.get_dtype()]
+
+
+def _scale_shape(algo: str, out_features: int) -> list[int]:
+    """Shape of `weight_scale`, as the layout actually returns it, without quantizing.
+
+    Both algos carry one scale per output channel; they disagree only on the rank.
+    `convrot_w4a4` hands back a 1-D `[out_features]`, and its dequantize kernel constrains
+    the argument to exactly 1-D. `int8_tensorwise` hands back `[out_features, 1]`.
+
+    Hardcoded because the plan pass must not quantize anything -- that is what makes
+    `--dry-run` free and what keeps the two-pass writer honest. The risk of hardcoding is
+    that it drifts from what the layout does; `StreamingWriter.write` closes that by
+    comparing this against the real tensor, so a wrong entry here is a loud failure on the
+    first write rather than a quietly mis-headered checkpoint.
+    """
+    if algo == "convrot_w4a4":
+        return [out_features]
+    if algo == "int8_tensorwise":
+        return [out_features, 1]
+    raise ValueError("no known weight_scale shape for {!r}".format(algo))
+
+
+def _conf_len(algo: str, groupsize: int) -> int:
+    """Byte length of the comfy_quant marker, without quantizing a weight to find out."""
+    if algo == "convrot_w4a4":
+        conf = {"format": "convrot_w4a4", "convrot_groupsize": groupsize,
+                "linear_dtype": "int4"}
+    else:
+        conf = {"format": "int8_tensorwise", "convrot": True, "convrot_groupsize": groupsize}
+    return len(conf_tensor(conf))
+
+
+def build_all_in_one_checkpoint(dit_path: str, text_encoder_path: str, vae_path: str,
+                                out_path: str, fmt_name: str = "svdq", te_format: str = "w4a4",
+                                rank: int = 64, variant: str = "unknown", groupsize: int = 256,
+                                device: str = "cuda", dry_run: bool = False,
+                                progress_cb=None) -> str:
+    """Combine DiT, quantized text encoder, and VAE into a single checkpoint."""
+    fmt, rank = resolve_format(fmt_name, rank, rank_was_set=False)
+
+    with safe_open(dit_path, framework="pt", device="cpu") as handle:
+        dit_keys = list(handle.keys())
+    dit_prefix = detect_prefix(dit_keys, default="")
+    already = any(k.endswith(".comfy_quant") for k in dit_keys)
+
+    if not already and not dry_run:
+        raise RuntimeError(
+            "{} is a BF16 source. Quantize it first with quantize_krea2.py (or the "
+            "Quantize node) and pass the result as dit_path.".format(dit_path))
+
+    metadata = {
+        "krea2_svdquant_tool_version": __version__,
+        "krea2_allinone": "1",
+        "krea2_allinone_dit": os.path.basename(dit_path),
+        "krea2_allinone_te": os.path.basename(text_encoder_path),
+        "krea2_allinone_te_format": te_format,
+        "krea2_allinone_vae": os.path.basename(vae_path),
+        "krea2_svdquant_variant": variant,
+    }
+
+    writer = StreamingWriter(out_path, metadata)
+    with safe_open(dit_path, framework="pt", device="cpu") as dh:
+        for out_key, src in plan_dit(dh, dit_keys, dit_prefix):
+            s = dh.get_slice(src)
+            writer.plan(out_key, _slice_dtype(s), s.get_shape())
+    dit_planned = len(writer.entries)
+
+    with safe_open(vae_path, framework="pt", device="cpu") as vh:
+        for out_key, src in plan_vae(list(vh.keys())):
+            s = vh.get_slice(src)
+            writer.plan(out_key, _slice_dtype(s), s.get_shape())
+    vae_planned = len(writer.entries) - dit_planned
+
+    te_quantized = quantize_text_encoder(text_encoder_path, te_format, groupsize,
+                                         device, writer, dry_run=True)
+    te_planned = len(writer.entries) - dit_planned - vae_planned
+
+    if te_quantized != TE_EXPECTED:
+        raise RuntimeError(
+            "expected {} quantizable text-encoder linears ({} layers x {}), matched {}. "
+            "Layer naming in {} is not recognized.".format(
+                TE_EXPECTED, TE_LAYERS, len(TE_QUANT_SUFFIXES), te_quantized, text_encoder_path))
+
+    total = sum(e[3] for e in writer.entries)
+    by = lambda pred: sum(e[3] for e in writer.entries if pred(e[0])) / 1024 ** 3
+
+    stats = (
+        "planned {} tensors, {:.2f} GiB (diffusion: {:.2f} GiB, encoder: {:.2f} GiB [{} linears -> {}], vae: {:.2f} GiB)"
+        .format(len(writer.entries), total / 1024 ** 3, by(lambda k: k.startswith(DIT_PREFIX)),
+                by(lambda k: k.startswith(TE_PREFIX)), te_quantized, te_format,
+                by(lambda k: k.startswith(VAE_PREFIX)))
+    )
+
+    if dry_run:
+        return stats + "\n[dry-run: nothing written, GPU untouched]"
+
+    t0 = time.time()
+    total_steps = len(writer.entries)
+    step = 0
+
+    with writer as w:
+        with safe_open(dit_path, framework="pt", device="cpu") as dh:
+            for out_key, src in plan_dit(dh, dit_keys, dit_prefix):
+                w.write(out_key, dh.get_tensor(src))
+                step += 1
+                if progress_cb:
+                    progress_cb(step, total_steps, "Copying DiT")
+        with safe_open(vae_path, framework="pt", device="cpu") as vh:
+            for out_key, src in plan_vae(list(vh.keys())):
+                w.write(out_key, vh.get_tensor(src))
+                step += 1
+                if progress_cb:
+                    progress_cb(step, total_steps, "Copying VAE")
+        quantize_text_encoder(text_encoder_path, te_format, groupsize, device,
+                              w, dry_run=False)
+        if progress_cb:
+            progress_cb(total_steps, total_steps, "Complete")
+
+    elapsed = time.time() - t0
+    final_size = os.path.getsize(out_path) / 1024 ** 3
+    summary = (
+        "baked all-in-one checkpoint: {} ({:.2f} GiB, {:.0f}s)\n"
+        "  diffusion : {} (format {})\n"
+        "  encoder   : {} (quantized to {})\n"
+        "  vae       : {}\n"
+        "{}".format(
+            os.path.basename(out_path), final_size, elapsed,
+            os.path.basename(dit_path), fmt_name,
+            os.path.basename(text_encoder_path), te_format,
+            os.path.basename(vae_path), stats
+        )
+    )
+    return summary

quantize_krea2.py

@@ -1,844 +1,923 @@
-"""Quantize a BF16 Krea2 checkpoint into a ComfyUI-native quantized checkpoint.
-
-ComfyUI already ships native kernels for these formats via comfy_kitchen, so the output
-loads with a plain ``UNETLoader`` -- no custom node, and ordinary LoRA loaders work.
-
-Four targets:
-
-* ``int8``  -> ``int8_tensorwise`` with per-channel scales + convrot (W8A8).
-               Natively accelerated on Ampere INT8 tensor cores.
-* ``w4a4``  -> ``convrot_w4a4`` (W4A4), smaller and potentially faster, 4-bit quality.
-* ``svdq``  -> the same W4A4 residual plus an SVDQuant low-rank bf16 branch, which
-               absorbs the outlier directions 4 bits handle worst. Needs this repo's
-               loader node; a plain ``UNETLoader`` cannot see the branch.
-* ``fp8``   -> ``float8_e4m3fn``, a single per-tensor scale, no convrot, no calibration.
-               Lightest touch of the four -- best fidelity, smallest speedup, and the
-               only one that needs no rotation or outlier handling because 8-bit float
-               already has enough dynamic range for these weights.
-
-None of them need a calibration dataset: int8/w4a4/svdq spread outliers analytically via
-the convrot (group-wise Hadamard) rotation, and activations are quantized by the kernel at
-run time; fp8 just needs one abs-max scale per tensor.
-
-Only the 224 transformer-block linears are quantized, matching the layer set used by the
-reference ``krea2_raw_int8_convrot`` checkpoint. Norms, modulation, the text-fusion stack
-and the final layer stay in their original precision -- they are small and quantization
-noise there is disproportionately visible.
-
-The layer selection is variant-agnostic: Krea 2 Turbo and the base (non-distilled)
-release share the same block naming, so the same command converts either. What differs is
-how you sample afterwards, not how you quantize -- pass ``--variant`` so the output is
-named accordingly and the file records which one it came from.
-
-    python quantize_krea2.py <bf16-model.safetensors> [--format int8|w4a4|svdq|fp8]
-                             [--rank 64] [--variant turbo|base] [--out PATH]
-"""
-
-from __future__ import annotations
-
-import argparse
-import gc
-import importlib.util
-import json
-import math
-import os
-import sys
-import time
-
-__version__ = "0.2.0"
-
-import torch
-from safetensors import safe_open
-from safetensors.torch import save_file
-
-def _find_comfyui_root() -> str | None:
-    """Locate the ComfyUI root so `comfy.*` imports work regardless of cwd.
-
-    Preference order: $COMFYUI_PATH, then walking up from this file (this script
-    lives in ComfyUI/custom_nodes/<pkg>/, so comfy/ is two levels up). None if
-    neither resolves -- deliberately *not* cwd. This module is imported by the
-    Quantize node inside ComfyUI's own process, and putting cwd at sys.path[0]
-    there lets any file in the working directory shadow a real import.
-    """
-    env = os.environ.get("COMFYUI_PATH")
-    if env and os.path.isdir(os.path.join(env, "comfy")):
-        return env
-    here = os.path.dirname(os.path.abspath(__file__))
-    candidate = os.path.abspath(os.path.join(here, "..", ".."))
-    if os.path.isdir(os.path.join(candidate, "comfy")):
-        return candidate
-    return None
-
-
-# Running inside ComfyUI, `comfy` already imports and the path needs no help.
-if importlib.util.find_spec("comfy") is None:
-    _root = _find_comfyui_root()
-    if _root is not None:
-        sys.path.insert(0, _root)
-
-# Guarded because __init__.py imports this module transitively: an unguarded failure
-# here would deregister every node in the pack, including Env Check, whose whole job is
-# diagnosing a broken quantization backend. Degrade to "no formats available" instead.
-QUANT_UNAVAILABLE = ""
-try:
-    from comfy.quant_ops import QUANT_ALGOS, get_layout_class  # noqa: E402
-except Exception as exc:  # pragma: no cover - depends on the ComfyUI build
-    QUANT_ALGOS = {}
-    get_layout_class = None
-    QUANT_UNAVAILABLE = "{}: {}".format(type(exc).__name__, exc)
-
-# Relative improvement the refinement loop must keep making to earn another iteration. See
-# `svdquant_split` for the traced numbers this default comes from.
-REFINE_TOL = 0.001
-
-_QUANT_SUFFIXES = ("attn.wq", "attn.wk", "attn.wv", "attn.gate", "attn.wo",
-                   "mlp.gate", "mlp.up", "mlp.down")
-
-
-# Checkpoints ship either bare ("blocks.0...") or prefixed ("model.diffusion_model.blocks.0...").
-LAYER_PREFIXES = ("model.diffusion_model.", "diffusion_model.", "")
-
-# Formats we know how to reconstruct back to BF16 from disk alone. FP8 storage is one
-# byte per element with no packing or pre-rotation, so `qdata * scale` recovers the
-# original tensor exactly as it was cast -- no architecture knowledge needed beyond
-# what's already in the file. INT8/W4A4 sources pack multiple values per byte and are
-# rotated (convrot) before quantization; unpacking those correctly needs the exact
-# in/out feature counts from the live nn.Linear, which isn't recoverable from the
-# checkpoint alone, so those are rejected instead.
-_DEQUANTIZABLE_FORMATS = ("float8_e4m3fn", "float8_e5m2")
-
-
-def detect_prefix(keys, default: str | None = None) -> str:
-    """Return the prefix the transformer blocks live under.
-
-    Raises `RuntimeError` if no prefix matches and no `default` was given. Not
-    `SystemExit`: that is a `BaseException`, and `convert()` runs inside ComfyUI's
-    executor via the Quantize node, where a BaseException escapes error handling
-    entirely. `main()` catches RuntimeError and prints it as a clean CLI line.
-    """
-    for prefix in LAYER_PREFIXES:
-        if any(k.startswith("{}blocks.".format(prefix)) for k in keys):
-            return prefix
-    if default is not None:
-        return default
-    raise RuntimeError(
-        "Could not find transformer blocks in this checkpoint. Expected keys like\n"
-        "  blocks.0.attn.wq.weight  or  model.diffusion_model.blocks.0.attn.wq.weight\n"
-        "This does not look like a Krea 2 diffusion model."
-    )
-
-
-def check_requantizable(handle, keys, prefix: str) -> None:
-    """Make sure every target layer that's already quantized is something we can
-    dequantize back to BF16 (see `_DEQUANTIZABLE_FORMATS`). Anything else -- most
-    importantly INT8/W4A4 -- needs the original BF16 (or FP16) release instead.
-    """
-    for key in keys:
-        if not key.endswith(".comfy_quant"):
-            continue
-        layer = key[: -len(".comfy_quant")]
-        if not is_target(layer, prefix):
-            continue
-        conf = json.loads(bytes(handle.get_tensor(key).tolist()))
-        fmt = conf.get("format")
-        if fmt not in _DEQUANTIZABLE_FORMATS:
-            raise RuntimeError(
-                "Layer {} is already quantized as '{}'. Only FP8-quantized layers can be "
-                "automatically reconstructed and re-quantized; for INT8/W4A4 sources, use "
-                "the original BF16 (or FP16) release of the model instead.".format(layer, fmt)
-            )
-
-
-def dequantize_target_weight(handle, layer: str, device: str) -> torch.Tensor:
-    """Load a target layer's weight as BF16, dequantizing it first if it's FP8.
-
-    Scaled FP8 (has a `comfy_quant` marker + `weight_scale`): ``qdata.float() * scale``.
-    Unscaled FP8 (a bare ``.to(float8_e4m3fn)`` cast, no marker): ``qdata`` as-is.
-    Anything else is already ruled out by `check_requantizable`.
-    """
-    weight = handle.get_tensor("{}.weight".format(layer)).to(device=device)
-    conf_key = "{}.comfy_quant".format(layer)
-    if conf_key in handle.keys():
-        scale = handle.get_tensor("{}.weight_scale".format(layer)).to(device=device).float()
-        return (weight.to(torch.float32) * scale).to(torch.bfloat16)
-    return weight.to(torch.bfloat16)
-
-
-def is_target(layer: str, prefix: str) -> bool:
-    """Only the transformer blocks; txtfusion and friends stay high precision."""
-    if not layer.startswith("{}blocks.".format(prefix)):
-        return False
-    return any(layer.endswith(s) for s in _QUANT_SUFFIXES)
-
-
-def leaf_name(layer: str, prefix: str) -> str | None:
-    """``blocks.7.attn.wq`` -> ``attn.wq``. None if the layer is not inside a block.
-
-    Only used to make a "nothing matched" failure self-diagnosing: a Krea 2 variant that
-    keeps the ``blocks.`` container but renames its leaves would otherwise quantize zero
-    layers and still write a full-size file.
-    """
-    head = "{}blocks.".format(prefix)
-    if not layer.startswith(head):
-        return None
-    rest = layer[len(head):]
-    return rest.split(".", 1)[1] if "." in rest else None
-
-
-# Rank is bought in multiples of this, so a reallocated budget lands on the same grid the
-# `rank` widget and the CLI already use.
-_RANK_STEP = 8
-
-# Per-leaf rank multipliers, relative to a uniform budget.
-#
-# Uniform rank is the obvious default and the wrong one. Measured on Krea2 Turbo at rank 64,
-# error removed per million branch parameters spans 6.9x across the eight leaves:
-#
-#     attn.wk  0.0992   (1536x6144, branch 491K params, absorbs 30.1% of the error)
-#     attn.wv  0.0844   (1536x6144, 491K, 25.6%)
-#     attn.wq  0.0445   (6144x6144, 786K, 21.6%)
-#     attn.wo  0.0411   (6144x6144, 786K, 17.6%)
-#     attn.gate 0.0384  (6144x6144, 786K, 18.7%)
-#     mlp.down 0.0169   (6144x16384, 1.44M, 14.3%)
-#     mlp.gate 0.0155   (16384x6144, 1.44M, 13.8%)
-#     mlp.up   0.0143   (16384x6144, 1.44M, 12.7%)
-#
-# The cause is GQA: Krea 2 has 12 kv heads against 48 query heads, so wk/wv are 1536-wide and
-# their branch costs a third of an MLP branch -- while absorbing twice as much error. Uniform
-# rank therefore spends most of the budget on the layers that reward it least.
-#
-# These multipliers come from a greedy allocation under a fixed byte budget (branch cost is
-# exactly linear in rank, so scaling all of them preserves byte-neutrality at any base rank).
-# At base rank 64 they reproduce the solved table: wk 360, wv 256, wq 72, wo 64, gate 56,
-# mlp 8, and the checkpoint comes out 0.02% smaller than uniform rank 64.
-#
-# MEASURED, and it does not deliver. The greedy solve predicted 6% less mean layer weight
-# error; the images say otherwise. 10 prompts, seed 987654321, against the same BF16 reference:
-#
-#     uniform rank 64  LPIPS 0.3403 +-0.1019
-#     gqa     rank 64  LPIPS 0.3523 +-0.0473
-#
-# gqa is closer on 5 of 10 prompts, paired t = +0.55 on 9 df. No mean effect in either
-# direction. Two things did not survive scrutiny and are recorded so nobody re-derives them:
-# the -6% rests on an absorption ~ sqrt(rank) model fitted to nothing stronger than "returns
-# are sublinear", and the tempting pattern that gqa wins on the hard prompts is an artifact --
-# re-pairing the gqa scores at random reproduces the same -0.92 correlation, because the
-# baseline appears on both sides of the difference.
-#
-# What is left is real but narrow: the spread across prompts shrinks (variance ratio 4.64,
-# F-test p = 0.032) and the worst prompt improves, 0.4975 -> 0.4470. That is one nominally
-# significant result among several things tried on the same 10 images, so it is a lead for a
-# larger measurement, not a reason to change the default. `uniform` stays the default.
-#
-# The 6.9x spread itself is solid -- it is measured weight error over real shapes. The lesson
-# is that weight error is a poor proxy for image outcome, which is now the third time this
-# has held on this model (the refinement objective and the depth hypothesis were the others).
-_GQA_ALLOC = {
-    "attn.wk": 5.625, "attn.wv": 4.0, "attn.wq": 1.125, "attn.wo": 1.0, "attn.gate": 0.875,
-    "mlp.gate": 0.125, "mlp.up": 0.125, "mlp.down": 0.125,
-}
-
-RANK_ALLOCATIONS: dict[str, dict[str, float] | None] = {
-    "uniform": None,
-    "gqa": _GQA_ALLOC,
-}
-
-
-def leaf_ranks(rank: int, rank_alloc: str = "uniform") -> dict[str, int]:
-    """Expand a rank budget into a per-leaf rank, one entry per name in `_QUANT_SUFFIXES`.
-
-    `uniform` gives every leaf the same rank -- the historical behaviour. Other allocations
-    redistribute the same total branch bytes according to `RANK_ALLOCATIONS`.
-    """
-    if rank_alloc not in RANK_ALLOCATIONS:
-        raise RuntimeError("unknown rank allocation {!r}; expected one of {}".format(
-            rank_alloc, ", ".join(sorted(RANK_ALLOCATIONS))))
-    mults = RANK_ALLOCATIONS[rank_alloc]
-    if mults is None:
-        return {leaf: rank for leaf in _QUANT_SUFFIXES}
-
-    # Byte-neutrality is the whole point of a non-uniform allocation, and it only survives
-    # while every leaf can be expressed on the step-8 grid. Below that the smallest leaves get
-    # rounded *up* to the floor and the file grows: at budget 16 the MLP leaves want rank 2,
-    # take 8, and the checkpoint comes out 20% larger than uniform -- which would make any
-    # comparison against uniform meaningless. Refuse rather than quietly change the size.
-    smallest = min(mults.values())
-    minimum = int(math.ceil(_RANK_STEP / smallest / _RANK_STEP)) * _RANK_STEP
-    if rank < minimum:
-        raise RuntimeError(
-            "rank allocation {!r} needs a budget of at least {} (you asked for {}). Its "
-            "smallest leaf gets {}x the budget, which below that rounds up to the step-{} "
-            "floor and makes the checkpoint *larger* than uniform instead of the same size."
-            .format(rank_alloc, minimum, rank, smallest, _RANK_STEP))
-
-    out = {}
-    for leaf in _QUANT_SUFFIXES:
-        out[leaf] = int(round(rank * mults[leaf] / _RANK_STEP)) * _RANK_STEP
-    return out
-
-
-def rank_for_leaf(ranks: dict[str, int], leaf: str | None) -> int:
-    """The branch rank for a target layer, given its leaf name. 0 means "no branch".
-
-    Matches by suffix because `is_target` does. An exact-key lookup would disagree with it
-    on any variant that nested the leaves one level deeper (`blocks.0.wrapper.attn.wq`):
-    such a layer is a quantization target, so it would be quantized, but would find no rank
-    entry and be written without a low-rank branch -- an svdq checkpoint silently missing
-    branches on part of the network, which is the class of quiet wrongness the zero-layer
-    check below exists to prevent.
-    """
-    if not ranks or leaf is None:
-        return 0
-    if leaf in ranks:
-        return ranks[leaf]
-    for suffix, value in ranks.items():
-        if leaf.endswith(suffix):
-            return value
-    return 0
-
-
-def svd_lowrank(weight: torch.Tensor, rank: int, oversample: int = 16, niter: int = 2):
-    """Randomized truncated SVD: return (L1 [out, rank], L2 [rank, in]) with W ~ L1 @ L2.
-
-    Randomized rather than exact because these are 6144x16384 matrices and only the top
-    few dozen singular directions matter here; `oversample` extra probe columns plus a
-    couple of power iterations recover them to well past the precision 4-bit quantization
-    cares about.
-    """
-    w = weight.float()
-    min_dim = min(w.shape)
-    rank = max(1, min(int(rank), min_dim))
-    q = min(rank + max(0, int(oversample)), min_dim)
-
-    if min_dim <= max(q, 32):
-        u, s, vh = torch.linalg.svd(w, full_matrices=False)
-        u_r, s_r, vh_r = u[:, :rank], s[:rank], vh[:rank, :]
-    else:
-        u, s, v = torch.svd_lowrank(w, q=q, niter=max(0, int(niter)))
-        u_r, s_r, vh_r = u[:, :rank], s[:rank], v[:, :rank].transpose(-2, -1)
-
-    return (u_r * s_r.unsqueeze(0)).contiguous(), vh_r.contiguous()
-
-
-def _act_weighting(act_rms: torch.Tensor | None, in_features: int, device, floor: float = 0.05):
-    """Turn a captured activation RMS vector into the column weighting `d`, or None.
-
-    Normalised to mean 1 so the weighting only redistributes emphasis and never rescales the
-    problem -- otherwise the error metric would no longer be comparable across layers and the
-    refinement loop's stopping threshold would mean something different in each one.
-
-    The floor matters more than it looks. `l2` is recovered by dividing by `d`, so a channel
-    whose activation is ~0 would divide a finite number by ~0 and put an enormous row into the
-    branch -- a branch that then dominates the output for a channel the model never actually
-    drives. Clamping to 5% of the mean bounds that amplification at 20x.
-    """
-    if act_rms is None:
-        return None
-    d = act_rms.to(device=device, dtype=torch.float32).flatten()
-    if d.numel() != in_features:
-        raise RuntimeError("activation stats have {} channels but the weight has {}"
-                           .format(d.numel(), in_features))
-    mean = d.mean()
-    if not torch.isfinite(mean) or mean <= 0:
-        return None
-    d = d / mean
-    return d.clamp(min=floor)
-
-
-def svdquant_split(weight: torch.Tensor, rank: int, fmt: str, groupsize: int,
-                   refine_iters: int = 100, act_rms: torch.Tensor | None = None,
-                   refine_tol: float = REFINE_TOL):
-    """SVDQuant ordering: pull a low-rank bf16 branch out of W, quantize the residual.
-
-    The low-rank branch absorbs the outlier-heavy directions, so the part that has to
-    survive 4 bits is better conditioned.
-
-    A single SVD of W is only the first guess: it picks the directions that are largest
-    in W, which is not the same as the directions the quantizer handles worst. So this
-    iterates the way deepcompressor does -- re-fit the branch to whatever the quantizer
-    is *currently* getting wrong, requantize, repeat -- and keeps the best result. Pass
-    ``refine_iters=0`` for the plain single-shot split.
-
-    Iteration one is exactly that single-shot split and the best is kept, so refining
-    can only match or beat it. Measured on Krea2 Turbo, rank 64: ~10% less
-    reconstruction error, every layer improving.
-
-    `refine_tol` is what stops it, and it is *relative* for a reason. It used to be an
-    absolute `1e-6` against an error of order 1e-1, so the loop only stopped when an
-    iteration failed to improve by one part in a hundred thousand -- which measured at a mean
-    of **79.8 of the 100 iterations** across a sample of twelve layers at rank 256. What those
-    iterations buy, traced per iteration on the same layers:
-
-        stop at              iterations   reconstruction error
-        1e-6 absolute (old)     ~80        baseline
-        0.5% relative            ~9        +4.3%
-        0.1% relative (now)     ~22        +2.0%
-
-    Conversion goes from ~14 minutes to ~4. The 2% is reconstruction error, which this repo
-    has three times measured to be a poor predictor of image outcome (see `--rank-alloc` in
-    the README), so read it as a conversion-time change rather than a quality one.
-
-    The objective is weight reconstruction error, which needs no calibration data.
-    That is the true output error under the assumption that the input covariance is
-    identity -- and spreading outliers with the convrot rotation is what makes that
-    assumption a reasonable one. Closing the remaining gap to deepcompressor means
-    measuring the real covariance, which is what makes their conversion take hours.
-
-    Returns None for a degenerate weight (all-zero, or one that makes the error metric
-    non-finite); the caller quantizes those without a branch rather than aborting.
-    """
-    w = weight.float()
-    d = _act_weighting(act_rms, w.shape[1], w.device)
-    # With a weighting, both the SVD and the error metric work in the scaled space: minimising
-    # ||(W - W_hat) diag(d)|| approximates the error the layer's real inputs would produce,
-    # which is what actually reaches the image. Without one this is the identity and the whole
-    # function reduces to exactly the old behaviour.
-    w_norm = torch.linalg.matrix_norm(w if d is None else w * d).item()
-    if not math.isfinite(w_norm) or w_norm == 0.0:
-        return None
-    qw = torch.zeros((), device=w.device, dtype=torch.float32)
-
-    best = None
-    best_err = float("inf")
-    for _ in range(max(1, refine_iters)):
-        target = w - qw
-        if d is None:
-            l1, l2 = svd_lowrank(target, rank, oversample=16, niter=2)
-        else:
-            # Fit in the scaled space so the retained directions are the ones that matter
-            # once real activations hit them, then undo the scale on `l2` so `l1 @ l2` is
-            # still an approximation of the *unscaled* residual.
-            l1, l2s = svd_lowrank(target * d, rank, oversample=16, niter=2)
-            l2 = l2s / d
-            del l2s
-        l1 = l1.to(torch.bfloat16)
-        l2 = l2.to(torch.bfloat16)
-        lw = l1.float() @ l2.float()
-        # The quantizer must see the unscaled residual: the scale is an analysis device, and
-        # baking it into what gets written would change what the kernel reconstructs.
-        residual = (w - lw).to(torch.bfloat16)
-
-        qdata, params, layout, _ = _quantize_raw(residual, fmt, groupsize)
-        qw = layout.dequantize(qdata, params).float()
-        del qdata, params
-
-        left = w - (lw + qw)
-        err = (torch.linalg.matrix_norm(left if d is None else left * d) / w_norm).item()
-        del lw, left
-        # NaN fails every comparison, so without this the loop would neither break nor
-        # ever update `best` -- it would burn all `refine_iters` and return the last
-        # split rather than the best one.
-        if not math.isfinite(err):
-            break
-        if best is not None and err >= best_err * (1.0 - refine_tol):
-            break  # refinement has stopped paying off
-        best_err, best = err, (residual, l1, l2)
-
-    return best
-
-
-def _quantize_raw(weight: torch.Tensor, fmt: str, groupsize: int):
-    """Quantize to `fmt`, handing back the layout and params too.
-
-    Split out from `quantize_weight` so the refinement loop can round-trip a weight
-    (quantize then dequantize) to see what the quantizer is actually getting wrong.
-    """
-    layout = get_layout_class(QUANT_ALGOS[fmt]["comfy_tensor_layout"])
-    if fmt == "int8_tensorwise":
-        qdata, params = layout.quantize(
-            weight, is_weight=True, per_channel=True,
-            convrot=True, convrot_groupsize=groupsize,
-        )
-        conf = {"format": "int8_tensorwise", "convrot": True, "convrot_groupsize": groupsize}
-    elif fmt == "convrot_w4a4":
-        qdata, params = layout.quantize(weight, convrot_groupsize=groupsize)
-        conf = {"format": "convrot_w4a4", "convrot_groupsize": groupsize,
-                "linear_dtype": getattr(params, "linear_dtype", "int4")}
-    elif fmt == "float8_e4m3fn":
-        qdata, params = layout.quantize(weight, scale="recalculate")
-        conf = {"format": "float8_e4m3fn"}
-    else:
-        raise ValueError(fmt)
-    return qdata, params, layout, conf
-
-
-def quantize_weight(weight: torch.Tensor, fmt: str, groupsize: int):
-    qdata, params, _, conf = _quantize_raw(weight, fmt, groupsize)
-    return qdata, {"weight_scale": params.scale}, conf
-
-
-def conf_tensor(conf: dict) -> torch.Tensor:
-    return torch.tensor(list(json.dumps(conf).encode("utf-8")), dtype=torch.uint8)
-
-
-def load_act_stats(path: str) -> dict[str, torch.Tensor]:
-    """Read the file the capture nodes write: {layer name: per-input-channel RMS}."""
-    stats = {}
-    with safe_open(path, framework="pt", device="cpu") as handle:
-        for key in handle.keys():
-            stats[key] = handle.get_tensor(key)
-    if not stats:
-        raise RuntimeError("{} contains no activation statistics".format(path))
-    return stats
-
-
-def check_act_stats_coverage(stats: dict, keys, prefix: str, ranks: dict) -> None:
-    """Fail before any GPU work if the statistics don't cover every layer that will branch.
-
-    Partial statistics are the quiet-wrongness case: the covered layers would get an
-    activation-aware split and the rest a plain one, producing a checkpoint that is neither,
-    and no measurement of it would mean anything.
-
-    Deliberately key-only. Which layers branch depends on `is_target` plus a positive
-    `rank_for_leaf`, both of which read the layer *name*; the one weight-dependent step in
-    the loop (`min(wanted, min(w.shape))`) can only lower a rank, never raise a zero above
-    it, so this pre-pass sees exactly the set the loop will branch. Doing it here instead of
-    after the loop turns a ~6 minute mistake into a two-second one.
-    """
-    covered, missing = 0, []
-    for key in keys:
-        if not key.endswith(".weight"):
-            continue
-        layer = key[: -len(".weight")]
-        if not is_target(layer, prefix):
-            continue
-        if rank_for_leaf(ranks, leaf_name(layer, prefix)) <= 0:
-            continue
-        if stats.get(layer[len(prefix):] if prefix else layer) is None:
-            missing.append(layer)
-        else:
-            covered += 1
-    if missing:
-        raise RuntimeError(
-            "activation stats cover {} of {} branched layers; {} are missing, e.g. {}.\n"
-            "The capture run did not see every layer -- usually because sampling was "
-            "interrupted, or the statistics came from a different model. Re-capture rather "
-            "than building a checkpoint that is activation-aware in some layers and not "
-            "others.".format(covered, covered + len(missing), len(missing),
-                             ", ".join(missing[:3])))
-
-
-def convert(src: str, dst: str, fmt: str, groupsize: int, device: str = "cuda", rank: int = 0,
-            refine_iters: int = 100, variant: str = "unknown", progress_cb=None,
-            rank_alloc: str = "uniform", act_stats: str | None = None,
-            weight_patch=None, refine_tol: float = REFINE_TOL):
-    """Quantize `src` into `dst`. Returns the summary line it printed.
-
-    `rank` is a budget, `rank_alloc` decides how it is spread across the eight projection
-    types -- see `RANK_ALLOCATIONS`. Non-uniform allocations keep the same total branch bytes.
-
-    `weight_patch(key, tensor) -> tensor` runs on every tensor as it is read, before anything
-    is quantized. `tools/bake_adapter.py` uses it to add a LoRA delta into the high-precision
-    weight, so the low-rank branch is fitted against the *merged* weight rather than the LoRA
-    being requantized on top of a finished checkpoint. Streaming it here rather than writing a
-    merged source out first matters in practice: the bf16 source is 24 GB.
-
-    `progress_cb(done, total, message)` is called as layers complete, for callers with a
-    progress bar to drive (the ComfyUI node). Errors are `RuntimeError`, never `SystemExit`:
-    `SystemExit` derives from `BaseException`, so raising it from inside a node would slip
-    past ComfyUI's executor instead of being reported as a failed node. `main()` translates
-    them back for the CLI.
-    """
-    out: dict[str, torch.Tensor] = {}
-    quantized = 0
-    kept = 0
-    branched = 0
-    observed_leaves: set[str] = set()
-    ranks = leaf_ranks(rank, rank_alloc) if rank > 0 else {}
-    used_ranks: set[int] = set()
-    clamped: dict[str, int] = {}
-    stats = load_act_stats(act_stats) if act_stats else {}
-    t0 = time.time()
-
-    with safe_open(src, framework="pt", device="cpu") as handle:
-        keys = list(handle.keys())
-        prefix = detect_prefix(keys)
-        check_requantizable(handle, keys, prefix)
-        if stats:
-            check_act_stats_coverage(stats, keys, prefix, ranks)
-
-        # Companion keys (old scales/markers) for target layers get regenerated fresh
-        # when we process the ".weight" key below -- skip the stale copies on disk,
-        # otherwise they'd overwrite our new ones later in iteration order.
-        stale_companions = set()
-        for key in keys:
-            if key.endswith(".weight"):
-                layer = key[: -len(".weight")]
-                if is_target(layer, prefix):
-                    for suffix in ("weight_scale", "weight_scale_2", "input_scale", "comfy_quant"):
-                        stale_companions.add("{}.{}".format(layer, suffix))
-
-        for i, key in enumerate(keys):
-            if key.endswith(".weight"):
-                layer = key[: -len(".weight")]
-                leaf = leaf_name(layer, prefix)
-                if leaf is not None:
-                    observed_leaves.add(leaf)
-                if is_target(layer, prefix):
-                    w = dequantize_target_weight(handle, layer, device)
-                    if weight_patch is not None:
-                        w = weight_patch(key, w)
-                    # A reallocated budget can ask for more rank than the weight has singular
-                    # directions (attn.wk is only 1536 wide). `svd_lowrank` clamps internally,
-                    # but clamping here too keeps the reported rank honest.
-                    wanted = rank_for_leaf(ranks, leaf)
-                    leaf_rank = min(wanted, min(w.shape))
-                    if leaf and leaf_rank < wanted:
-                        clamped[leaf] = leaf_rank
-                    if leaf_rank > 0:
-                        # Stats are keyed by module path (`blocks.0.attn.wq`); checkpoint
-                        # keys may carry a prefix, so strip it to look them up.
-                        # Coverage was already proven complete before the loop started, so
-                        # a None here cannot happen for a branched layer.
-                        act = stats.get(layer[len(prefix):] if prefix else layer)
-                        split = svdquant_split(w, leaf_rank, fmt, groupsize, refine_iters,
-                                               act_rms=act, refine_tol=refine_tol)
-                        if split is None:
-                            print("  warning: {} is degenerate (zero or non-finite); "
-                                  "quantizing it without a low-rank branch".format(layer),
-                                  flush=True)
-                        else:
-                            w, l1, l2 = split
-                            out["{}.svdq_l1".format(layer)] = l1.cpu()
-                            out["{}.svdq_l2".format(layer)] = l2.cpu()
-                            branched += 1
-                            used_ranks.add(int(l1.shape[1]))
-                            del l1, l2
-                    qdata, scales, conf = quantize_weight(w, fmt, groupsize)
-                    out[key] = qdata.cpu()
-                    for name, value in scales.items():
-                        out["{}.{}".format(layer, name)] = value.cpu()
-                    out["{}.comfy_quant".format(layer)] = conf_tensor(conf)
-                    del w, qdata, scales
-                    quantized += 1
-                    if progress_cb is not None:
-                        progress_cb(quantized, _EXPECTED_LAYERS,
-                                    "quantized {} layers ({:.0f}s)".format(
-                                        quantized, time.time() - t0))
-                    if quantized % 32 == 0:
-                        torch.cuda.empty_cache()
-                        print(f"  [{i + 1}/{len(keys)}] quantized {quantized} layers "
-                              f"({time.time() - t0:.0f}s)", flush=True)
-                    continue
-            if key in stale_companions:
-                continue
-            value = handle.get_tensor(key)
-            # The non-quantized layers (txtfusion, embeddings) can carry a LoRA too, and they
-            # are the half a bake would otherwise silently drop.
-            out[key] = value if weight_patch is None else weight_patch(key, value)
-            kept += 1
-
-    gc.collect()
-    torch.cuda.empty_cache()
-
-    if quantized == 0:
-        raise RuntimeError(
-            "Found the transformer blocks but quantized nothing: no layer under "
-            "'{}blocks.' ends in one of the expected leaf names.\n"
-            "  expected: {}\n"
-            "  observed: {}\n"
-            "This is a Krea 2 variant with different layer naming; quantize_krea2.py "
-            "would otherwise have written a full-size file that does nothing."
-            .format(prefix, ", ".join(sorted(_QUANT_SUFFIXES)),
-                    ", ".join(sorted(observed_leaves)) or "none")
-        )
-
-    # A leaf can only be clamped when the allocation asked for more rank than the weight is
-    # wide, which means part of the budget went unspent and the file is *smaller* than the
-    # uniform one -- so a comparison against uniform at this budget is no longer like-for-like.
-    if clamped:
-        print("warning: rank allocation {!r} asked for more rank than these layers are wide, "
-              "so they were capped and part of the budget went unspent: {}. The checkpoint is "
-              "smaller than uniform rank {}, not the same size -- lower the budget to compare "
-              "them fairly.".format(
-                  rank_alloc, ", ".join("{}={}".format(k, v) for k, v in sorted(clamped.items())),
-                  rank), flush=True)
-
-    created = len(out) - kept - quantized
-    factors = "" if not rank else " + {} low-rank factors".format(branched * 2)
-    print(f"quantized {quantized} layers; {kept} tensors passed through; "
-          f"{created} tensors created (qdata/scale/marker{factors}); "
-          f"{len(out)} tensors total; writing {dst} ...", flush=True)
-
-    # Recorded so the loader (and anyone inspecting the file) can tell what produced it.
-    # safetensors metadata is str -> str only. The loader treats all of this as optional:
-    # checkpoints published before this existed still load, with the rank recovered from
-    # the svdq_l1 shape as before.
-    # The loader trusts the factor shapes over `krea2_svdquant_rank`, and under a non-uniform
-    # allocation no single number is the rank -- so record the budget, the allocation name and
-    # the full per-leaf map, and leave `rank` meaning "budget" for older loaders reading it.
-    metadata = {
-        "krea2_svdquant_tool_version": __version__,
-        "krea2_svdquant_format": fmt,
-        "krea2_svdquant_rank": str(rank),
-        "krea2_svdquant_rank_alloc": rank_alloc,
-        "krea2_svdquant_rank_map": json.dumps(ranks, sort_keys=True) if ranks else "",
-        "krea2_svdquant_groupsize": str(groupsize),
-        "krea2_svdquant_refine_iters": str(refine_iters if rank else 0),
-        "krea2_svdquant_variant": variant,
-        "krea2_svdquant_quantized_layers": str(quantized),
-        "krea2_svdquant_branched_layers": str(branched),
-        "krea2_svdquant_source_name": os.path.basename(src),
-        "krea2_svdquant_source_bytes": str(os.path.getsize(src)),
-        # Two checkpoints with identical rank/refine settings are still different models if
-        # one was activation-weighted, so this has to be recoverable from the file.
-        "krea2_svdquant_act_stats": os.path.basename(act_stats) if act_stats else "",
-    }
-    if progress_cb is not None:
-        progress_cb(quantized, _EXPECTED_LAYERS, "writing {:.2f} GB ...".format(
-            sum(t.numel() * t.element_size() for t in out.values()) / 1024 ** 3))
-    save_file(out, dst, metadata=metadata)
-    size = os.path.getsize(dst) / 1024 ** 3
-    rank_desc = ""
-    if used_ranks:
-        rank_desc = (" rank {}".format(next(iter(used_ranks))) if len(used_ranks) == 1
-                     else " rank {}-{} ({})".format(min(used_ranks), max(used_ranks),
-                                                    rank_alloc))
-    summary = ("quantized {} layers ({} branched{}) in {:.0f}s -> {}  ({:.2f} GB, source "
-               "{:.2f} GB)".format(quantized, branched, rank_desc, time.time() - t0, dst, size,
-                                   os.path.getsize(src) / 1024 ** 3))
-    print("done in {:.0f}s -> {}  ({:.2f} GB, source {:.2f} GB)".format(
-        time.time() - t0, dst, size, os.path.getsize(src) / 1024 ** 3))
-    return summary
-
-
-# The Krea 2 block count, used only to scale a progress bar. A variant with a different
-# depth still quantizes correctly; the bar is just less accurate.
-_EXPECTED_LAYERS = 28 * len(_QUANT_SUFFIXES)
-
-_FORMAT_ALIASES = {
-    "int8": "int8_tensorwise",
-    "w4a4": "convrot_w4a4",
-    "svdq": "convrot_w4a4",
-    "fp8": "float8_e4m3fn",
-}
-
-_GENERIC_STEMS = ("raw", "model", "diffusion_pytorch_model", "turbo")
-
-SAMPLER_HINTS = {
-    "base": ("Base (non-distilled) model: start from ~50 steps, cfg 3.5, euler/simple, and a "
-             "real negative prompt. See workflows/krea2_base_svdquant_w4a4_t2i.json."),
-    "turbo": ("Turbo (distilled) model: 8 steps, cfg 1.0, euler/simple. "
-              "See workflows/krea2_turbo_svdquant_w4a4_t2i.json."),
-}
-
-
-def resolve_format(fmt_name: str, rank: int, rank_was_set: bool = True) -> tuple[str, int]:
-    """Map a CLI/node format name to a comfy_kitchen format, validating the rank with it.
-
-    Shared by `main()` and the ComfyUI node so the two cannot drift apart on which
-    combinations are legal.
-    """
-    fmt = _FORMAT_ALIASES[fmt_name]
-    if fmt not in QUANT_ALGOS:
-        raise RuntimeError("{} is not available in this ComfyUI build".format(fmt))
-    # Silently zeroing the rank here used to make `--format w4a4 --rank 128` look like it had
-    # done something it had not.
-    if fmt_name != "svdq" and rank_was_set:
-        raise RuntimeError(
-            "rank only applies to format 'svdq' (you asked for '{}'). The low-rank branch is "
-            "what distinguishes svdq from plain w4a4.".format(fmt_name))
-    if fmt_name == "svdq" and rank <= 0:
-        raise RuntimeError("format 'svdq' needs rank > 0; use format 'w4a4' for no branch")
-    return fmt, (rank if fmt_name == "svdq" else 0)
-
-
-def derive_out_path(src: str, fmt_name: str, rank: int, variant: str,
-                    rank_alloc: str = "uniform", act_stats: str | None = None
-                    ) -> tuple[str, str | None]:
-    """The default output path, plus a note to show when the source name is uninformative."""
-    stem = os.path.splitext(os.path.basename(src))[0]
-    note = None
-    if variant != "unknown":
-        stem = "Krea2-{}".format(variant.capitalize())
-    elif stem.lower() in _GENERIC_STEMS:
-        note = ("note: '{}' is a generic filename. Set the variant (or an explicit output "
-                "name) to get a checkpoint name you will still recognise next month."
-                .format(stem))
-    # The allocation goes in the filename because two checkpoints with the same budget and
-    # different allocations are the same size -- nothing else would tell them apart.
-    alloc_tag = "" if rank_alloc == "uniform" else "-{}".format(rank_alloc)
-    # Same reasoning as alloc_tag: an activation-weighted build is byte-identical in shape to
-    # a plain one, so without a tag the two are indistinguishable on disk.
-    act_tag = "-actaware" if act_stats else ""
-    suffix = ("SVDQuant-W4A4-rank{}{}{}".format(rank, alloc_tag, act_tag) if rank else
-              ("{}-convrot".format(fmt_name.upper()) if fmt_name != "fp8" else "FP8"))
-    return os.path.join(os.path.dirname(src), "{}-{}.safetensors".format(stem, suffix)), note
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("src")
-    ap.add_argument("--format", choices=["int8", "w4a4", "svdq", "fp8"], default="int8",
-                    help="svdq = w4a4 residual + SVDQuant low-rank bf16 branch; "
-                         "fp8 = float8_e4m3fn, no convrot, no low-rank branch")
-    ap.add_argument("--groupsize", type=int, default=256, help="unused for fp8")
-    ap.add_argument("--rank", type=int, default=64, help="low-rank branch budget, svdq only")
-    ap.add_argument("--rank-alloc", choices=sorted(RANK_ALLOCATIONS), default="uniform",
-                    help="how to spread the rank budget across the eight projection types. "
-                         "uniform = same rank everywhere. gqa = byte-neutral reallocation "
-                         "towards the GQA kv projections, which absorb ~2x the error at a "
-                         "third of the branch cost (see RANK_ALLOCATIONS)")
-    ap.add_argument("--refine-iters", type=int, default=100,
-                    help="svdq only: refine the low-rank branch against the quantization "
-                         "error, keeping the best (0 = plain single-shot SVD, much faster "
-                         "but ~10%% more reconstruction error). This is a cap; --refine-tol "
-                         "is what usually stops the loop first")
-    ap.add_argument("--refine-tol", type=float, default=REFINE_TOL, metavar="FRACTION",
-                    help="svdq only: stop refining a layer once an iteration improves its "
-                         "reconstruction error by less than this fraction (default %(default)s "
-                         "= 0.1%%). Lower means more iterations for less return: 0.001 takes "
-                         "~22 iterations per layer, 0.005 takes ~9 for 2%% more error, and 0 "
-                         "restores the old behaviour of running nearly all --refine-iters")
-    ap.add_argument("--variant", choices=["turbo", "base", "unknown"], default="unknown",
-                    help="which Krea 2 release this is. Only affects the output filename "
-                         "and the recorded metadata -- quantization is identical for both, "
-                         "the difference is the sampler settings you run afterwards")
-    ap.add_argument("--act-stats", default=None, metavar="PATH",
-                    help="svdq only: activation statistics from the Krea2 SVDQuant Capture "
-                         "nodes. Weights the low-rank split by per-input-channel activation "
-                         "RMS, so the branch spends its capacity on the directions the model "
-                         "actually drives instead of on the largest weights. Costs nothing "
-                         "at runtime -- same rank, format, size and kernel")
-    ap.add_argument("--out", default=None)
-    ap.add_argument("--device", default="cuda")
-    args = ap.parse_args()
-
-    if args.act_stats:
-        if args.format != "svdq":
-            raise SystemExit("--act-stats only applies to format 'svdq': it weights the "
-                             "low-rank split, and the other formats have no branch")
-        if not os.path.exists(args.act_stats):
-            raise SystemExit("--act-stats file not found: {}".format(args.act_stats))
-
-    # RuntimeError is the shared failure type (see `convert`); the CLI wants SystemExit so it
-    # prints one clean line instead of a traceback.
-    try:
-        fmt, rank = resolve_format(args.format, args.rank,
-                                   rank_was_set=args.rank != ap.get_default("rank"))
-    except RuntimeError as exc:
-        raise SystemExit(str(exc)) from None
-
-    if args.rank_alloc != "uniform" and not rank:
-        raise SystemExit("--rank-alloc only applies to format 'svdq'")
-
-    out = args.out
-    if out is None:
-        out, note = derive_out_path(args.src, args.format, rank, args.variant, args.rank_alloc,
-                                    args.act_stats)
-        if note:
-            print(note, flush=True)
-    try:
-        convert(args.src, out, fmt, args.groupsize, args.device, rank, args.refine_iters,
-                variant=args.variant, rank_alloc=args.rank_alloc, act_stats=args.act_stats,
-                refine_tol=args.refine_tol)
-    except RuntimeError as exc:
-        raise SystemExit(str(exc)) from None
-
-    hint = SAMPLER_HINTS.get(args.variant)
-    if hint:
-        print("\n" + hint)
-
-
-if __name__ == "__main__":
-    main()
+"""Quantize a BF16 Krea2 checkpoint into a ComfyUI-native quantized checkpoint.
+
+ComfyUI already ships native kernels for these formats via comfy_kitchen, so the output
+loads with a plain ``UNETLoader`` -- no custom node, and ordinary LoRA loaders work.
+
+Four targets:
+
+* ``int8``  -> ``int8_tensorwise`` with per-channel scales + convrot (W8A8).
+               Natively accelerated on Ampere INT8 tensor cores.
+* ``w4a4``  -> ``convrot_w4a4`` (W4A4), smaller and potentially faster, 4-bit quality.
+* ``svdq``  -> the same W4A4 residual plus an SVDQuant low-rank bf16 branch, which
+               absorbs the outlier directions 4 bits handle worst. Needs this repo's
+               loader node; a plain ``UNETLoader`` cannot see the branch.
+* ``fp8``   -> ``float8_e4m3fn``, a single per-tensor scale, no convrot, no calibration.
+               Lightest touch of the four -- best fidelity, smallest speedup, and the
+               only one that needs no rotation or outlier handling because 8-bit float
+               already has enough dynamic range for these weights.
+
+None of them need a calibration dataset: int8/w4a4/svdq spread outliers analytically via
+the convrot (group-wise Hadamard) rotation, and activations are quantized by the kernel at
+run time; fp8 just needs one abs-max scale per tensor.
+
+Only the 224 transformer-block linears are quantized, matching the layer set used by the
+reference ``krea2_raw_int8_convrot`` checkpoint. Norms, modulation, the text-fusion stack
+and the final layer stay in their original precision -- they are small and quantization
+noise there is disproportionately visible.
+
+The layer selection is variant-agnostic: Krea 2 Turbo and the base (non-distilled)
+release share the same block naming, so the same command converts either. What differs is
+how you sample afterwards, not how you quantize -- pass ``--variant`` so the output is
+named accordingly and the file records which one it came from.
+
+    python quantize_krea2.py <bf16-model.safetensors> [--format int8|w4a4|svdq|fp8]
+                             [--rank 64] [--variant turbo|base] [--out PATH]
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import importlib.util
+import json
+import math
+import os
+import sys
+import time
+import zlib
+
+__version__ = "0.2.0"
+
+import torch
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+def _find_comfyui_root() -> str | None:
+    """Locate the ComfyUI root so `comfy.*` imports work regardless of cwd.
+
+    Preference order: $COMFYUI_PATH, then walking up from this file (this script
+    lives in ComfyUI/custom_nodes/<pkg>/, so comfy/ is two levels up). None if
+    neither resolves -- deliberately *not* cwd. This module is imported by the
+    Quantize node inside ComfyUI's own process, and putting cwd at sys.path[0]
+    there lets any file in the working directory shadow a real import.
+    """
+    env = os.environ.get("COMFYUI_PATH")
+    if env and os.path.isdir(os.path.join(env, "comfy")):
+        return env
+    here = os.path.dirname(os.path.abspath(__file__))
+    candidate = os.path.abspath(os.path.join(here, "..", ".."))
+    if os.path.isdir(os.path.join(candidate, "comfy")):
+        return candidate
+    for extra in ("D:/ComfyUI", "C:/ComfyUI", os.path.abspath(os.path.join(here, "..", "ComfyUI"))):
+        if os.path.isdir(os.path.join(extra, "comfy")):
+            return extra
+    return None
+
+
+# Running inside ComfyUI, `comfy` already imports and the path needs no help.
+if importlib.util.find_spec("comfy") is None:
+    _root = _find_comfyui_root()
+    if _root is not None:
+        sys.path.insert(0, _root)
+
+# Guarded because __init__.py imports this module transitively: an unguarded failure
+# here would deregister every node in the pack, including Env Check, whose whole job is
+# diagnosing a broken quantization backend. Degrade to "no formats available" instead.
+QUANT_UNAVAILABLE = ""
+try:
+    from comfy.quant_ops import QUANT_ALGOS, get_layout_class  # noqa: E402
+except Exception as exc:  # pragma: no cover - depends on the ComfyUI build
+    QUANT_ALGOS = {}
+    get_layout_class = None
+    QUANT_UNAVAILABLE = "{}: {}".format(type(exc).__name__, exc)
+
+# Relative improvement the refinement loop must keep making to earn another iteration. See
+# `svdquant_split` for the traced numbers this default comes from.
+REFINE_TOL = 0.001
+
+# Deterministic by default. The low-rank split is a *randomized* SVD, so an unseeded build is
+# irreproducible even on the same machine -- two files that differ by ~1e-4 per weight and by
+# a visibly different image after 8 steps of sampling. `None` restores the old ambient-RNG
+# behaviour for anyone who wants to sample the spread rather than pin it.
+DEFAULT_SEED = 0
+
+_QUANT_SUFFIXES = ("attn.wq", "attn.wk", "attn.wv", "attn.gate", "attn.wo",
+                   "mlp.gate", "mlp.up", "mlp.down")
+
+
+# Checkpoints ship either bare ("blocks.0...") or prefixed ("model.diffusion_model.blocks.0...").
+LAYER_PREFIXES = ("model.diffusion_model.", "diffusion_model.", "")
+
+# Formats we know how to reconstruct back to BF16 from disk alone. FP8 storage is one
+# byte per element with no packing or pre-rotation, so `qdata * scale` recovers the
+# original tensor exactly as it was cast -- no architecture knowledge needed beyond
+# what's already in the file. INT8/W4A4 sources pack multiple values per byte and are
+# rotated (convrot) before quantization; unpacking those correctly needs the exact
+# in/out feature counts from the live nn.Linear, which isn't recoverable from the
+# checkpoint alone, so those are rejected instead.
+_DEQUANTIZABLE_FORMATS = ("float8_e4m3fn", "float8_e5m2")
+
+
+def detect_prefix(keys, default: str | None = None) -> str:
+    """Return the prefix the transformer blocks live under.
+
+    Raises `RuntimeError` if no prefix matches and no `default` was given. Not
+    `SystemExit`: that is a `BaseException`, and `convert()` runs inside ComfyUI's
+    executor via the Quantize node, where a BaseException escapes error handling
+    entirely. `main()` catches RuntimeError and prints it as a clean CLI line.
+    """
+    for prefix in LAYER_PREFIXES:
+        if any(k.startswith("{}blocks.".format(prefix)) for k in keys):
+            return prefix
+    if default is not None:
+        return default
+    raise RuntimeError(
+        "Could not find transformer blocks in this checkpoint. Expected keys like\n"
+        "  blocks.0.attn.wq.weight  or  model.diffusion_model.blocks.0.attn.wq.weight\n"
+        "This does not look like a Krea 2 diffusion model."
+    )
+
+
+def check_requantizable(handle, keys, prefix: str) -> None:
+    """Make sure every target layer that's already quantized is something we can
+    dequantize back to BF16 (see `_DEQUANTIZABLE_FORMATS`). Anything else -- most
+    importantly INT8/W4A4 -- needs the original BF16 (or FP16) release instead.
+    """
+    for key in keys:
+        if not key.endswith(".comfy_quant"):
+            continue
+        layer = key[: -len(".comfy_quant")]
+        if not is_target(layer, prefix):
+            continue
+        conf = json.loads(bytes(handle.get_tensor(key).tolist()))
+        fmt = conf.get("format")
+        if fmt not in _DEQUANTIZABLE_FORMATS:
+            raise RuntimeError(
+                "Layer {} is already quantized as '{}'. Only FP8-quantized layers can be "
+                "automatically reconstructed and re-quantized; for INT8/W4A4 sources, use "
+                "the original BF16 (or FP16) release of the model instead.".format(layer, fmt)
+            )
+
+
+def dequantize_target_weight(handle, layer: str, device: str) -> torch.Tensor:
+    """Load a target layer's weight as BF16, dequantizing it first if it's FP8.
+
+    Scaled FP8 (has a `comfy_quant` marker + `weight_scale`): ``qdata.float() * scale``.
+    Unscaled FP8 (a bare ``.to(float8_e4m3fn)`` cast, no marker): ``qdata`` as-is.
+    Anything else is already ruled out by `check_requantizable`.
+    """
+    weight = handle.get_tensor("{}.weight".format(layer)).to(device=device)
+    conf_key = "{}.comfy_quant".format(layer)
+    if conf_key in handle.keys():
+        scale = handle.get_tensor("{}.weight_scale".format(layer)).to(device=device).float()
+        return (weight.to(torch.float32) * scale).to(torch.bfloat16)
+    return weight.to(torch.bfloat16)
+
+
+def is_target(layer: str, prefix: str) -> bool:
+    """Only the transformer blocks; txtfusion and friends stay high precision."""
+    if not layer.startswith("{}blocks.".format(prefix)):
+        return False
+    return any(layer.endswith(s) for s in _QUANT_SUFFIXES)
+
+
+def leaf_name(layer: str, prefix: str) -> str | None:
+    """``blocks.7.attn.wq`` -> ``attn.wq``. None if the layer is not inside a block.
+
+    Only used to make a "nothing matched" failure self-diagnosing: a Krea 2 variant that
+    keeps the ``blocks.`` container but renames its leaves would otherwise quantize zero
+    layers and still write a full-size file.
+    """
+    head = "{}blocks.".format(prefix)
+    if not layer.startswith(head):
+        return None
+    rest = layer[len(head):]
+    return rest.split(".", 1)[1] if "." in rest else None
+
+
+# Rank is bought in multiples of this, so a reallocated budget lands on the same grid the
+# `rank` widget and the CLI already use.
+_RANK_STEP = 8
+
+# Per-leaf rank multipliers, relative to a uniform budget.
+#
+# Uniform rank is the obvious default and the wrong one. Measured on Krea2 Turbo at rank 64,
+# error removed per million branch parameters spans 6.9x across the eight leaves:
+#
+#     attn.wk  0.0992   (1536x6144, branch 491K params, absorbs 30.1% of the error)
+#     attn.wv  0.0844   (1536x6144, 491K, 25.6%)
+#     attn.wq  0.0445   (6144x6144, 786K, 21.6%)
+#     attn.wo  0.0411   (6144x6144, 786K, 17.6%)
+#     attn.gate 0.0384  (6144x6144, 786K, 18.7%)
+#     mlp.down 0.0169   (6144x16384, 1.44M, 14.3%)
+#     mlp.gate 0.0155   (16384x6144, 1.44M, 13.8%)
+#     mlp.up   0.0143   (16384x6144, 1.44M, 12.7%)
+#
+# The cause is GQA: Krea 2 has 12 kv heads against 48 query heads, so wk/wv are 1536-wide and
+# their branch costs a third of an MLP branch -- while absorbing twice as much error. Uniform
+# rank therefore spends most of the budget on the layers that reward it least.
+#
+# These multipliers come from a greedy allocation under a fixed byte budget (branch cost is
+# exactly linear in rank, so scaling all of them preserves byte-neutrality at any base rank).
+# At base rank 64 they reproduce the solved table: wk 360, wv 256, wq 72, wo 64, gate 56,
+# mlp 8, and the checkpoint comes out 0.02% smaller than uniform rank 64.
+#
+# MEASURED, and it does not deliver. The greedy solve predicted 6% less mean layer weight
+# error; the images say otherwise. 10 prompts, seed 987654321, against the same BF16 reference:
+#
+#     uniform rank 64  LPIPS 0.3403 +-0.1019
+#     gqa     rank 64  LPIPS 0.3523 +-0.0473
+#
+# gqa is closer on 5 of 10 prompts, paired t = +0.55 on 9 df. No mean effect in either
+# direction. Two things did not survive scrutiny and are recorded so nobody re-derives them:
+# the -6% rests on an absorption ~ sqrt(rank) model fitted to nothing stronger than "returns
+# are sublinear", and the tempting pattern that gqa wins on the hard prompts is an artifact --
+# re-pairing the gqa scores at random reproduces the same -0.92 correlation, because the
+# baseline appears on both sides of the difference.
+#
+# What is left is real but narrow: the spread across prompts shrinks (variance ratio 4.64,
+# F-test p = 0.032) and the worst prompt improves, 0.4975 -> 0.4470. That is one nominally
+# significant result among several things tried on the same 10 images, so it is a lead for a
+# larger measurement, not a reason to change the default. `uniform` stays the default.
+#
+# The 6.9x spread itself is solid -- it is measured weight error over real shapes. The lesson
+# is that weight error is a poor proxy for image outcome, which is now the third time this
+# has held on this model (the refinement objective and the depth hypothesis were the others).
+_GQA_ALLOC = {
+    "attn.wk": 5.625, "attn.wv": 4.0, "attn.wq": 1.125, "attn.wo": 1.0, "attn.gate": 0.875,
+    "mlp.gate": 0.125, "mlp.up": 0.125, "mlp.down": 0.125,
+}
+
+RANK_ALLOCATIONS: dict[str, dict[str, float] | None] = {
+    "uniform": None,
+    "gqa": _GQA_ALLOC,
+}
+
+
+def leaf_ranks(rank: int, rank_alloc: str = "uniform") -> dict[str, int]:
+    """Expand a rank budget into a per-leaf rank, one entry per name in `_QUANT_SUFFIXES`.
+
+    `uniform` gives every leaf the same rank -- the historical behaviour. Other allocations
+    redistribute the same total branch bytes according to `RANK_ALLOCATIONS`.
+    """
+    if rank_alloc not in RANK_ALLOCATIONS:
+        raise RuntimeError("unknown rank allocation {!r}; expected one of {}".format(
+            rank_alloc, ", ".join(sorted(RANK_ALLOCATIONS))))
+    mults = RANK_ALLOCATIONS[rank_alloc]
+    if mults is None:
+        return {leaf: rank for leaf in _QUANT_SUFFIXES}
+
+    # Byte-neutrality is the whole point of a non-uniform allocation, and it only survives
+    # while every leaf can be expressed on the step-8 grid. Below that the smallest leaves get
+    # rounded *up* to the floor and the file grows: at budget 16 the MLP leaves want rank 2,
+    # take 8, and the checkpoint comes out 20% larger than uniform -- which would make any
+    # comparison against uniform meaningless. Refuse rather than quietly change the size.
+    smallest = min(mults.values())
+    minimum = int(math.ceil(_RANK_STEP / smallest / _RANK_STEP)) * _RANK_STEP
+    if rank < minimum:
+        raise RuntimeError(
+            "rank allocation {!r} needs a budget of at least {} (you asked for {}). Its "
+            "smallest leaf gets {}x the budget, which below that rounds up to the step-{} "
+            "floor and makes the checkpoint *larger* than uniform instead of the same size."
+            .format(rank_alloc, minimum, rank, smallest, _RANK_STEP))
+
+    out = {}
+    for leaf in _QUANT_SUFFIXES:
+        out[leaf] = int(round(rank * mults[leaf] / _RANK_STEP)) * _RANK_STEP
+    return out
+
+
+def rank_for_leaf(ranks: dict[str, int], leaf: str | None) -> int:
+    """The branch rank for a target layer, given its leaf name. 0 means "no branch".
+
+    Matches by suffix because `is_target` does. An exact-key lookup would disagree with it
+    on any variant that nested the leaves one level deeper (`blocks.0.wrapper.attn.wq`):
+    such a layer is a quantization target, so it would be quantized, but would find no rank
+    entry and be written without a low-rank branch -- an svdq checkpoint silently missing
+    branches on part of the network, which is the class of quiet wrongness the zero-layer
+    check below exists to prevent.
+    """
+    if not ranks or leaf is None:
+        return 0
+    if leaf in ranks:
+        return ranks[leaf]
+    for suffix, value in ranks.items():
+        if leaf.endswith(suffix):
+            return value
+    return 0
+
+
+def svd_lowrank(weight: torch.Tensor, rank: int, oversample: int = 16, niter: int = 2):
+    """Randomized truncated SVD: return (L1 [out, rank], L2 [rank, in]) with W ~ L1 @ L2.
+
+    Randomized rather than exact because these are 6144x16384 matrices and only the top
+    few dozen singular directions matter here; `oversample` extra probe columns plus a
+    couple of power iterations recover them to well past the precision 4-bit quantization
+    cares about.
+
+    "Randomized" is load-bearing for reproducibility: `torch.svd_lowrank` draws its probe
+    matrix from the *ambient* RNG, so seeding is the caller's job (`svdquant_split` does it
+    per layer). Left unseeded, two runs of this script on the same GPU with identical
+    arguments produce different checkpoints -- close, but not equal, and visibly so once a
+    sampler amplifies them.
+    """
+    w = weight.float()
+    min_dim = min(w.shape)
+    rank = max(1, min(int(rank), min_dim))
+    q = min(rank + max(0, int(oversample)), min_dim)
+
+    if min_dim <= max(q, 32):
+        u, s, vh = torch.linalg.svd(w, full_matrices=False)
+        u_r, s_r, vh_r = u[:, :rank], s[:rank], vh[:rank, :]
+    else:
+        u, s, v = torch.svd_lowrank(w, q=q, niter=max(0, int(niter)))
+        u_r, s_r, vh_r = u[:, :rank], s[:rank], v[:, :rank].transpose(-2, -1)
+
+    return (u_r * s_r.unsqueeze(0)).contiguous(), vh_r.contiguous()
+
+
+def _act_weighting(act_rms: torch.Tensor | None, in_features: int, device, floor: float = 0.05):
+    """Turn a captured activation RMS vector into the column weighting `d`, or None.
+
+    Normalised to mean 1 so the weighting only redistributes emphasis and never rescales the
+    problem -- otherwise the error metric would no longer be comparable across layers and the
+    refinement loop's stopping threshold would mean something different in each one.
+
+    The floor matters more than it looks. `l2` is recovered by dividing by `d`, so a channel
+    whose activation is ~0 would divide a finite number by ~0 and put an enormous row into the
+    branch -- a branch that then dominates the output for a channel the model never actually
+    drives. Clamping to 5% of the mean bounds that amplification at 20x.
+    """
+    if act_rms is None:
+        return None
+    d = act_rms.to(device=device, dtype=torch.float32).flatten()
+    if d.numel() != in_features:
+        raise RuntimeError("activation stats have {} channels but the weight has {}"
+                           .format(d.numel(), in_features))
+    mean = d.mean()
+    if not torch.isfinite(mean) or mean <= 0:
+        return None
+    d = d / mean
+    return d.clamp(min=floor)
+
+
+def svdquant_split(weight: torch.Tensor, rank: int, fmt: str, groupsize: int,
+                   refine_iters: int = 100, act_rms: torch.Tensor | None = None,
+                   refine_tol: float = REFINE_TOL, seed: int | None = None):
+    """SVDQuant ordering: pull a low-rank bf16 branch out of W, quantize the residual.
+
+    The low-rank branch absorbs the outlier-heavy directions, so the part that has to
+    survive 4 bits is better conditioned.
+
+    A single SVD of W is only the first guess: it picks the directions that are largest
+    in W, which is not the same as the directions the quantizer handles worst. So this
+    iterates the way deepcompressor does -- re-fit the branch to whatever the quantizer
+    is *currently* getting wrong, requantize, repeat -- and keeps the best result. Pass
+    ``refine_iters=0`` for the plain single-shot split.
+
+    Iteration one is exactly that single-shot split and the best is kept, so refining
+    can only match or beat it. Measured on Krea2 Turbo, rank 64: ~10% less
+    reconstruction error, every layer improving.
+
+    `refine_tol` is what stops it, and it is *relative* for a reason. It used to be an
+    absolute `1e-6` against an error of order 1e-1, so the loop only stopped when an
+    iteration failed to improve by one part in a hundred thousand -- which measured at a mean
+    of **79.8 of the 100 iterations** across a sample of twelve layers at rank 256. What those
+    iterations buy, traced per iteration on the same layers:
+
+        stop at              iterations   reconstruction error
+        1e-6 absolute (old)     ~80        baseline
+        0.5% relative            ~9        +4.3%
+        0.1% relative (now)     ~22        +2.0%
+
+    Conversion goes from ~14 minutes to ~4. The 2% is reconstruction error, which this repo
+    has three times measured to be a poor predictor of image outcome (see `--rank-alloc` in
+    the README), so read it as a conversion-time change rather than a quality one.
+
+    The objective is weight reconstruction error, which needs no calibration data.
+    That is the true output error under the assumption that the input covariance is
+    identity -- and spreading outliers with the convrot rotation is what makes that
+    assumption a reasonable one. Closing the remaining gap to deepcompressor means
+    measuring the real covariance, which is what makes their conversion take hours.
+
+    `seed` makes the run reproducible. The refinement draws a fresh random probe matrix on
+    every iteration through `svd_lowrank`, from the ambient RNG, so without this two builds
+    of the same checkpoint with the same arguments are merely *similar*: measured at ~1e-4
+    relative on the dequantized weights, which is small until a sampler spends 8-50 steps
+    compounding it and you get a visibly different image. Seeding once here rather than per
+    iteration is enough -- the whole sequence of draws then follows from one number. Pass
+    `None` for the old ambient-RNG behaviour.
+
+    Reproducibility is per device, not across devices: CPU and CUDA generate different
+    numbers from the same seed, and their GEMM reduction orders differ too, so a CPU build
+    and a GPU build of the same checkpoint will never be equal. `convert` records the device
+    in the metadata for that reason.
+
+    Returns None for a degenerate weight (all-zero, or one that makes the error metric
+    non-finite); the caller quantizes those without a branch rather than aborting.
+    """
+    if seed is not None:
+        # fork_rng so a caller's RNG state survives: this runs inside somebody else's
+        # process (ComfyUI), where silently reseeding the global generator would make every
+        # later sampler node in the same session reproduce a different image.
+        with torch.random.fork_rng(devices=_rng_devices(weight.device)):
+            torch.manual_seed(seed)
+            return _svdquant_split(weight, rank, fmt, groupsize, refine_iters, act_rms,
+                                   refine_tol)
+    return _svdquant_split(weight, rank, fmt, groupsize, refine_iters, act_rms, refine_tol)
+
+
+def _layer_seed(seed: int | None, layer: str) -> int | None:
+    """A per-layer seed derived from the run's seed and the layer name.
+
+    Per layer rather than one seed for the whole run so that the result does not depend on
+    the order layers happen to be visited in, nor on how many refinement iterations the
+    previous layer took before its tolerance stopped it. Either would make a rebuild with a
+    different `--refine-tol` diverge everywhere instead of only where it should.
+
+    `zlib.crc32` rather than `hash()`: Python randomises string hashing per process, so
+    `hash()` here would be reproducible within a run and useless across runs -- the exact
+    failure this is meant to fix, hidden one level deeper.
+    """
+    if seed is None:
+        return None
+    return (seed + zlib.crc32(layer.encode("utf-8"))) % (2 ** 63)
+
+
+def _rng_devices(device: torch.device) -> list:
+    """Which generators `fork_rng` has to save and restore for work on `device`."""
+    return [device] if device.type == "cuda" else []
+
+
+def _svdquant_split(weight: torch.Tensor, rank: int, fmt: str, groupsize: int,
+                    refine_iters: int, act_rms, refine_tol: float):
+    w = weight.float()
+    d = _act_weighting(act_rms, w.shape[1], w.device)
+    # With a weighting, both the SVD and the error metric work in the scaled space: minimising
+    # ||(W - W_hat) diag(d)|| approximates the error the layer's real inputs would produce,
+    # which is what actually reaches the image. Without one this is the identity and the whole
+    # function reduces to exactly the old behaviour.
+    w_norm = torch.linalg.matrix_norm(w if d is None else w * d).item()
+    if not math.isfinite(w_norm) or w_norm == 0.0:
+        return None
+    qw = torch.zeros((), device=w.device, dtype=torch.float32)
+
+    best = None
+    best_err = float("inf")
+    for _ in range(max(1, refine_iters)):
+        target = w - qw
+        if d is None:
+            l1, l2 = svd_lowrank(target, rank, oversample=16, niter=2)
+        else:
+            # Fit in the scaled space so the retained directions are the ones that matter
+            # once real activations hit them, then undo the scale on `l2` so `l1 @ l2` is
+            # still an approximation of the *unscaled* residual.
+            l1, l2s = svd_lowrank(target * d, rank, oversample=16, niter=2)
+            l2 = l2s / d
+            del l2s
+        l1 = l1.to(torch.bfloat16)
+        l2 = l2.to(torch.bfloat16)
+        lw = l1.float() @ l2.float()
+        # The quantizer must see the unscaled residual: the scale is an analysis device, and
+        # baking it into what gets written would change what the kernel reconstructs.
+        residual = (w - lw).to(torch.bfloat16)
+
+        qdata, params, layout, _ = _quantize_raw(residual, fmt, groupsize)
+        qw = layout.dequantize(qdata, params).float()
+        del qdata, params
+
+        left = w - (lw + qw)
+        err = (torch.linalg.matrix_norm(left if d is None else left * d) / w_norm).item()
+        del lw, left
+        # NaN fails every comparison, so without this the loop would neither break nor
+        # ever update `best` -- it would burn all `refine_iters` and return the last
+        # split rather than the best one.
+        if not math.isfinite(err):
+            break
+        if best is not None and err >= best_err * (1.0 - refine_tol):
+            break  # refinement has stopped paying off
+        best_err, best = err, (residual, l1, l2)
+
+    return best
+
+
+def _quantize_raw(weight: torch.Tensor, fmt: str, groupsize: int):
+    """Quantize to `fmt`, handing back the layout and params too.
+
+    Split out from `quantize_weight` so the refinement loop can round-trip a weight
+    (quantize then dequantize) to see what the quantizer is actually getting wrong.
+    """
+    layout = get_layout_class(QUANT_ALGOS[fmt]["comfy_tensor_layout"])
+    if fmt == "int8_tensorwise":
+        qdata, params = layout.quantize(
+            weight, is_weight=True, per_channel=True,
+            convrot=True, convrot_groupsize=groupsize,
+        )
+        conf = {"format": "int8_tensorwise", "convrot": True, "convrot_groupsize": groupsize}
+    elif fmt == "convrot_w4a4":
+        qdata, params = layout.quantize(weight, convrot_groupsize=groupsize)
+        conf = {"format": "convrot_w4a4", "convrot_groupsize": groupsize,
+                "linear_dtype": getattr(params, "linear_dtype", "int4")}
+    elif fmt == "float8_e4m3fn":
+        qdata, params = layout.quantize(weight, scale="recalculate")
+        conf = {"format": "float8_e4m3fn"}
+    else:
+        raise ValueError(fmt)
+    return qdata, params, layout, conf
+
+
+def quantize_weight(weight: torch.Tensor, fmt: str, groupsize: int):
+    qdata, params, _, conf = _quantize_raw(weight, fmt, groupsize)
+    return qdata, {"weight_scale": params.scale}, conf
+
+
+def conf_tensor(conf: dict) -> torch.Tensor:
+    return torch.tensor(list(json.dumps(conf).encode("utf-8")), dtype=torch.uint8)
+
+
+def load_act_stats(path: str) -> dict[str, torch.Tensor]:
+    """Read the file the capture nodes write: {layer name: per-input-channel RMS}."""
+    stats = {}
+    with safe_open(path, framework="pt", device="cpu") as handle:
+        for key in handle.keys():
+            stats[key] = handle.get_tensor(key)
+    if not stats:
+        raise RuntimeError("{} contains no activation statistics".format(path))
+    return stats
+
+
+def check_act_stats_coverage(stats: dict, keys, prefix: str, ranks: dict) -> None:
+    """Fail before any GPU work if the statistics don't cover every layer that will branch.
+
+    Partial statistics are the quiet-wrongness case: the covered layers would get an
+    activation-aware split and the rest a plain one, producing a checkpoint that is neither,
+    and no measurement of it would mean anything.
+
+    Deliberately key-only. Which layers branch depends on `is_target` plus a positive
+    `rank_for_leaf`, both of which read the layer *name*; the one weight-dependent step in
+    the loop (`min(wanted, min(w.shape))`) can only lower a rank, never raise a zero above
+    it, so this pre-pass sees exactly the set the loop will branch. Doing it here instead of
+    after the loop turns a ~6 minute mistake into a two-second one.
+    """
+    covered, missing = 0, []
+    for key in keys:
+        if not key.endswith(".weight"):
+            continue
+        layer = key[: -len(".weight")]
+        if not is_target(layer, prefix):
+            continue
+        if rank_for_leaf(ranks, leaf_name(layer, prefix)) <= 0:
+            continue
+        if stats.get(layer[len(prefix):] if prefix else layer) is None:
+            missing.append(layer)
+        else:
+            covered += 1
+    if missing:
+        raise RuntimeError(
+            "activation stats cover {} of {} branched layers; {} are missing, e.g. {}.\n"
+            "The capture run did not see every layer -- usually because sampling was "
+            "interrupted, or the statistics came from a different model. Re-capture rather "
+            "than building a checkpoint that is activation-aware in some layers and not "
+            "others.".format(covered, covered + len(missing), len(missing),
+                             ", ".join(missing[:3])))
+
+
+def convert(src: str, dst: str, fmt: str, groupsize: int, device: str = "cuda", rank: int = 0,
+            refine_iters: int = 100, variant: str = "unknown", progress_cb=None,
+            rank_alloc: str = "uniform", act_stats: str | None = None,
+            weight_patch=None, refine_tol: float = REFINE_TOL,
+            seed: int | None = DEFAULT_SEED):
+    """Quantize `src` into `dst`. Returns the summary line it printed.
+
+    `rank` is a budget, `rank_alloc` decides how it is spread across the eight projection
+    types -- see `RANK_ALLOCATIONS`. Non-uniform allocations keep the same total branch bytes.
+
+    `weight_patch(key, tensor) -> tensor` runs on every tensor as it is read, before anything
+    is quantized. `tools/bake_adapter.py` uses it to add a LoRA delta into the high-precision
+    weight, so the low-rank branch is fitted against the *merged* weight rather than the LoRA
+    being requantized on top of a finished checkpoint. Streaming it here rather than writing a
+    merged source out first matters in practice: the bf16 source is 24 GB.
+
+    `progress_cb(done, total, message)` is called as layers complete, for callers with a
+    progress bar to drive (the ComfyUI node). Errors are `RuntimeError`, never `SystemExit`:
+    `SystemExit` derives from `BaseException`, so raising it from inside a node would slip
+    past ComfyUI's executor instead of being reported as a failed node. `main()` translates
+    them back for the CLI.
+    """
+    out: dict[str, torch.Tensor] = {}
+    quantized = 0
+    kept = 0
+    branched = 0
+    observed_leaves: set[str] = set()
+    ranks = leaf_ranks(rank, rank_alloc) if rank > 0 else {}
+    used_ranks: set[int] = set()
+    clamped: dict[str, int] = {}
+    stats = load_act_stats(act_stats) if act_stats else {}
+    t0 = time.time()
+
+    with safe_open(src, framework="pt", device="cpu") as handle:
+        keys = list(handle.keys())
+        prefix = detect_prefix(keys)
+        check_requantizable(handle, keys, prefix)
+        if stats:
+            check_act_stats_coverage(stats, keys, prefix, ranks)
+
+        # Companion keys (old scales/markers) for target layers get regenerated fresh
+        # when we process the ".weight" key below -- skip the stale copies on disk,
+        # otherwise they'd overwrite our new ones later in iteration order.
+        stale_companions = set()
+        for key in keys:
+            if key.endswith(".weight"):
+                layer = key[: -len(".weight")]
+                if is_target(layer, prefix):
+                    for suffix in ("weight_scale", "weight_scale_2", "input_scale", "comfy_quant"):
+                        stale_companions.add("{}.{}".format(layer, suffix))
+
+        for i, key in enumerate(keys):
+            if key.endswith(".weight"):
+                layer = key[: -len(".weight")]
+                leaf = leaf_name(layer, prefix)
+                if leaf is not None:
+                    observed_leaves.add(leaf)
+                if is_target(layer, prefix):
+                    w = dequantize_target_weight(handle, layer, device)
+                    if weight_patch is not None:
+                        w = weight_patch(key, w)
+                    # A reallocated budget can ask for more rank than the weight has singular
+                    # directions (attn.wk is only 1536 wide). `svd_lowrank` clamps internally,
+                    # but clamping here too keeps the reported rank honest.
+                    wanted = rank_for_leaf(ranks, leaf)
+                    leaf_rank = min(wanted, min(w.shape))
+                    if leaf and leaf_rank < wanted:
+                        clamped[leaf] = leaf_rank
+                    if leaf_rank > 0:
+                        # Stats are keyed by module path (`blocks.0.attn.wq`); checkpoint
+                        # keys may carry a prefix, so strip it to look them up.
+                        # Coverage was already proven complete before the loop started, so
+                        # a None here cannot happen for a branched layer.
+                        act = stats.get(layer[len(prefix):] if prefix else layer)
+                        split = svdquant_split(w, leaf_rank, fmt, groupsize, refine_iters,
+                                               act_rms=act, refine_tol=refine_tol,
+                                               seed=_layer_seed(seed, layer))
+                        if split is None:
+                            print("  warning: {} is degenerate (zero or non-finite); "
+                                  "quantizing it without a low-rank branch".format(layer),
+                                  flush=True)
+                        else:
+                            w, l1, l2 = split
+                            out["{}.svdq_l1".format(layer)] = l1.cpu()
+                            out["{}.svdq_l2".format(layer)] = l2.cpu()
+                            branched += 1
+                            used_ranks.add(int(l1.shape[1]))
+                            del l1, l2
+                    qdata, scales, conf = quantize_weight(w, fmt, groupsize)
+                    out[key] = qdata.cpu()
+                    for name, value in scales.items():
+                        out["{}.{}".format(layer, name)] = value.cpu()
+                    out["{}.comfy_quant".format(layer)] = conf_tensor(conf)
+                    del w, qdata, scales
+                    quantized += 1
+                    if progress_cb is not None:
+                        progress_cb(quantized, _EXPECTED_LAYERS,
+                                    "quantized {} layers ({:.0f}s)".format(
+                                        quantized, time.time() - t0))
+                    if quantized % 32 == 0:
+                        torch.cuda.empty_cache()
+                        print(f"  [{i + 1}/{len(keys)}] quantized {quantized} layers "
+                              f"({time.time() - t0:.0f}s)", flush=True)
+                    continue
+            if key in stale_companions:
+                continue
+            value = handle.get_tensor(key)
+            # The non-quantized layers (txtfusion, embeddings) can carry a LoRA too, and they
+            # are the half a bake would otherwise silently drop.
+            out[key] = value if weight_patch is None else weight_patch(key, value)
+            kept += 1
+
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    if quantized == 0:
+        raise RuntimeError(
+            "Found the transformer blocks but quantized nothing: no layer under "
+            "'{}blocks.' ends in one of the expected leaf names.\n"
+            "  expected: {}\n"
+            "  observed: {}\n"
+            "This is a Krea 2 variant with different layer naming; quantize_krea2.py "
+            "would otherwise have written a full-size file that does nothing."
+            .format(prefix, ", ".join(sorted(_QUANT_SUFFIXES)),
+                    ", ".join(sorted(observed_leaves)) or "none")
+        )
+
+    # A leaf can only be clamped when the allocation asked for more rank than the weight is
+    # wide, which means part of the budget went unspent and the file is *smaller* than the
+    # uniform one -- so a comparison against uniform at this budget is no longer like-for-like.
+    if clamped:
+        print("warning: rank allocation {!r} asked for more rank than these layers are wide, "
+              "so they were capped and part of the budget went unspent: {}. The checkpoint is "
+              "smaller than uniform rank {}, not the same size -- lower the budget to compare "
+              "them fairly.".format(
+                  rank_alloc, ", ".join("{}={}".format(k, v) for k, v in sorted(clamped.items())),
+                  rank), flush=True)
+
+    created = len(out) - kept - quantized
+    factors = "" if not rank else " + {} low-rank factors".format(branched * 2)
+    print(f"quantized {quantized} layers; {kept} tensors passed through; "
+          f"{created} tensors created (qdata/scale/marker{factors}); "
+          f"{len(out)} tensors total; writing {dst} ...", flush=True)
+
+    # Recorded so the loader (and anyone inspecting the file) can tell what produced it.
+    # safetensors metadata is str -> str only. The loader treats all of this as optional:
+    # checkpoints published before this existed still load, with the rank recovered from
+    # the svdq_l1 shape as before.
+    # The loader trusts the factor shapes over `krea2_svdquant_rank`, and under a non-uniform
+    # allocation no single number is the rank -- so record the budget, the allocation name and
+    # the full per-leaf map, and leave `rank` meaning "budget" for older loaders reading it.
+    metadata = {
+        "krea2_svdquant_tool_version": __version__,
+        "krea2_svdquant_format": fmt,
+        "krea2_svdquant_rank": str(rank),
+        "krea2_svdquant_rank_alloc": rank_alloc,
+        "krea2_svdquant_rank_map": json.dumps(ranks, sort_keys=True) if ranks else "",
+        "krea2_svdquant_groupsize": str(groupsize),
+        "krea2_svdquant_refine_iters": str(refine_iters if rank else 0),
+        "krea2_svdquant_variant": variant,
+        "krea2_svdquant_quantized_layers": str(quantized),
+        "krea2_svdquant_branched_layers": str(branched),
+        "krea2_svdquant_source_name": os.path.basename(src),
+        "krea2_svdquant_source_bytes": str(os.path.getsize(src)),
+        # Two checkpoints with identical rank/refine settings are still different models if
+        # one was activation-weighted, so this has to be recoverable from the file.
+        "krea2_svdquant_act_stats": os.path.basename(act_stats) if act_stats else "",
+        # A build is reproducible only against the same seed AND the same device: the low-rank
+        # split draws a random probe matrix, and CPU and CUDA neither generate the same numbers
+        # from a seed nor reduce their GEMMs in the same order. Both go in the file so "why is
+        # my checkpoint not byte-identical to yours" is answerable from the file.
+        "krea2_svdquant_seed": "" if seed is None else str(seed),
+        "krea2_svdquant_device": str(device),
+    }
+    if progress_cb is not None:
+        progress_cb(quantized, _EXPECTED_LAYERS, "writing {:.2f} GB ...".format(
+            sum(t.numel() * t.element_size() for t in out.values()) / 1024 ** 3))
+    save_file(out, dst, metadata=metadata)
+    size = os.path.getsize(dst) / 1024 ** 3
+    rank_desc = ""
+    if used_ranks:
+        rank_desc = (" rank {}".format(next(iter(used_ranks))) if len(used_ranks) == 1
+                     else " rank {}-{} ({})".format(min(used_ranks), max(used_ranks),
+                                                    rank_alloc))
+    summary = ("quantized {} layers ({} branched{}) in {:.0f}s -> {}  ({:.2f} GB, source "
+               "{:.2f} GB)".format(quantized, branched, rank_desc, time.time() - t0, dst, size,
+                                   os.path.getsize(src) / 1024 ** 3))
+    print("done in {:.0f}s -> {}  ({:.2f} GB, source {:.2f} GB)".format(
+        time.time() - t0, dst, size, os.path.getsize(src) / 1024 ** 3))
+    return summary
+
+
+# The Krea 2 block count, used only to scale a progress bar. A variant with a different
+# depth still quantizes correctly; the bar is just less accurate.
+_EXPECTED_LAYERS = 28 * len(_QUANT_SUFFIXES)
+
+_FORMAT_ALIASES = {
+    "int8": "int8_tensorwise",
+    "w4a4": "convrot_w4a4",
+    "svdq": "convrot_w4a4",
+    "fp8": "float8_e4m3fn",
+}
+
+_GENERIC_STEMS = ("raw", "model", "diffusion_pytorch_model", "turbo")
+
+SAMPLER_HINTS = {
+    "base": ("Base (non-distilled) model: start from ~50 steps, cfg 3.5, euler/simple, and a "
+             "real negative prompt. See workflows/krea2_base_svdquant_w4a4_t2i.json."),
+    "turbo": ("Turbo (distilled) model: 8 steps, cfg 1.0, euler/simple. "
+              "See workflows/krea2_turbo_svdquant_w4a4_t2i.json."),
+}
+
+
+def resolve_format(fmt_name: str, rank: int, rank_was_set: bool = True) -> tuple[str, int]:
+    """Map a CLI/node format name to a comfy_kitchen format, validating the rank with it.
+
+    Shared by `main()` and the ComfyUI node so the two cannot drift apart on which
+    combinations are legal.
+    """
+    fmt = _FORMAT_ALIASES[fmt_name]
+    if fmt not in QUANT_ALGOS:
+        raise RuntimeError("{} is not available in this ComfyUI build".format(fmt))
+    # Silently zeroing the rank here used to make `--format w4a4 --rank 128` look like it had
+    # done something it had not.
+    if fmt_name != "svdq" and rank_was_set:
+        raise RuntimeError(
+            "rank only applies to format 'svdq' (you asked for '{}'). The low-rank branch is "
+            "what distinguishes svdq from plain w4a4.".format(fmt_name))
+    if fmt_name == "svdq" and rank <= 0:
+        raise RuntimeError("format 'svdq' needs rank > 0; use format 'w4a4' for no branch")
+    return fmt, (rank if fmt_name == "svdq" else 0)
+
+
+def derive_out_path(src: str, fmt_name: str, rank: int, variant: str,
+                    rank_alloc: str = "uniform", act_stats: str | None = None
+                    ) -> tuple[str, str | None]:
+    """The default output path, plus a note to show when the source name is uninformative."""
+    stem = os.path.splitext(os.path.basename(src))[0]
+    note = None
+    if variant != "unknown":
+        stem = "Krea2-{}".format(variant.capitalize())
+    elif stem.lower() in _GENERIC_STEMS:
+        note = ("note: '{}' is a generic filename. Set the variant (or an explicit output "
+                "name) to get a checkpoint name you will still recognise next month."
+                .format(stem))
+    # The allocation goes in the filename because two checkpoints with the same budget and
+    # different allocations are the same size -- nothing else would tell them apart.
+    alloc_tag = "" if rank_alloc == "uniform" else "-{}".format(rank_alloc)
+    # Same reasoning as alloc_tag: an activation-weighted build is byte-identical in shape to
+    # a plain one, so without a tag the two are indistinguishable on disk.
+    act_tag = "-actaware" if act_stats else ""
+    suffix = ("SVDQuant-W4A4-rank{}{}{}".format(rank, alloc_tag, act_tag) if rank else
+              ("{}-convrot".format(fmt_name.upper()) if fmt_name != "fp8" else "FP8"))
+    return os.path.join(os.path.dirname(src), "{}-{}.safetensors".format(stem, suffix)), note
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("src")
+    ap.add_argument("--format", choices=["int8", "w4a4", "svdq", "fp8"], default="int8",
+                    help="svdq = w4a4 residual + SVDQuant low-rank bf16 branch; "
+                         "fp8 = float8_e4m3fn, no convrot, no low-rank branch")
+    ap.add_argument("--groupsize", type=int, default=256, help="unused for fp8")
+    ap.add_argument("--rank", type=int, default=64, help="low-rank branch budget, svdq only")
+    ap.add_argument("--rank-alloc", choices=sorted(RANK_ALLOCATIONS), default="uniform",
+                    help="how to spread the rank budget across the eight projection types. "
+                         "uniform = same rank everywhere. gqa = byte-neutral reallocation "
+                         "towards the GQA kv projections, which absorb ~2x the error at a "
+                         "third of the branch cost (see RANK_ALLOCATIONS)")
+    ap.add_argument("--refine-iters", type=int, default=100,
+                    help="svdq only: refine the low-rank branch against the quantization "
+                         "error, keeping the best (0 = plain single-shot SVD, much faster "
+                         "but ~10%% more reconstruction error). This is a cap; --refine-tol "
+                         "is what usually stops the loop first")
+    ap.add_argument("--refine-tol", type=float, default=REFINE_TOL, metavar="FRACTION",
+                    help="svdq only: stop refining a layer once an iteration improves its "
+                         "reconstruction error by less than this fraction (default %(default)s "
+                         "= 0.1%%). Lower means more iterations for less return: 0.001 takes "
+                         "~22 iterations per layer, 0.005 takes ~9 for 2%% more error, and 0 "
+                         "restores the old behaviour of running nearly all --refine-iters")
+    ap.add_argument("--variant", choices=["turbo", "base", "unknown"], default="unknown",
+                    help="which Krea 2 release this is. Only affects the output filename "
+                         "and the recorded metadata -- quantization is identical for both, "
+                         "the difference is the sampler settings you run afterwards")
+    ap.add_argument("--act-stats", default=None, metavar="PATH",
+                    help="svdq only: activation statistics from the Krea2 SVDQuant Capture "
+                         "nodes. Weights the low-rank split by per-input-channel activation "
+                         "RMS, so the branch spends its capacity on the directions the model "
+                         "actually drives instead of on the largest weights. Costs nothing "
+                         "at runtime -- same rank, format, size and kernel")
+    ap.add_argument("--out", default=None)
+    ap.add_argument("--device", default="cuda")
+    ap.add_argument("--seed", type=int, default=DEFAULT_SEED,
+                    help="seed for the randomized low-rank SVD, so a build is reproducible "
+                         "(default %(default)s). Reproducible on the same device only -- a "
+                         "CPU build and a CUDA build of the same checkpoint differ by ~1e-4 "
+                         "per weight whatever the seed. Pass -1 for the old unseeded "
+                         "behaviour, where even two runs on one GPU differ")
+    args = ap.parse_args()
+
+    if args.act_stats:
+        if args.format != "svdq":
+            raise SystemExit("--act-stats only applies to format 'svdq': it weights the "
+                             "low-rank split, and the other formats have no branch")
+        if not os.path.exists(args.act_stats):
+            raise SystemExit("--act-stats file not found: {}".format(args.act_stats))
+
+    # RuntimeError is the shared failure type (see `convert`); the CLI wants SystemExit so it
+    # prints one clean line instead of a traceback.
+    try:
+        fmt, rank = resolve_format(args.format, args.rank,
+                                   rank_was_set=args.rank != ap.get_default("rank"))
+    except RuntimeError as exc:
+        raise SystemExit(str(exc)) from None
+
+    if args.rank_alloc != "uniform" and not rank:
+        raise SystemExit("--rank-alloc only applies to format 'svdq'")
+
+    out = args.out
+    if out is None:
+        out, note = derive_out_path(args.src, args.format, rank, args.variant, args.rank_alloc,
+                                    args.act_stats)
+        if note:
+            print(note, flush=True)
+    try:
+        convert(args.src, out, fmt, args.groupsize, args.device, rank, args.refine_iters,
+                variant=args.variant, rank_alloc=args.rank_alloc, act_stats=args.act_stats,
+                refine_tol=args.refine_tol,
+                seed=None if args.seed < 0 else args.seed)
+    except RuntimeError as exc:
+        raise SystemExit(str(exc)) from None
+
+    hint = SAMPLER_HINTS.get(args.variant)
+    if hint:
+        print("\n" + hint)
+
+
+if __name__ == "__main__":
+    main()

svdquant_capture.py

@@ -228,9 +228,14 @@ class Krea2SVDQuantCaptureSave:
             }
         }
 
-    RETURN_TYPES = ("LATENT", "STRING")
-    RETURN_NAMES = ("latent", "status")
-    OUTPUT_TOOLTIPS = ("Passed through unchanged.", "Where the file went and what is in it.")
+    # `act_stats_path` is appended rather than inserted so workflows saved against the
+    # two-output version keep their links: slot indices 0 and 1 still mean what they did.
+    RETURN_TYPES = ("LATENT", "STRING", "STRING")
+    RETURN_NAMES = ("latent", "status", "act_stats_path")
+    OUTPUT_TOOLTIPS = ("Passed through unchanged.", "Where the file went and what is in it.",
+                       "Absolute path of the file just written. Wire it into the Quantize "
+                       "node's act_stats: that is also what forces the quantizer to run "
+                       "after the calibration pass rather than before it.")
     OUTPUT_NODE = True
     FUNCTION = "save"
     CATEGORY = _CATEGORY
@@ -243,7 +248,24 @@ class Krea2SVDQuantCaptureSave:
         return float("nan")
 
     def save(self, latent, filename, keep_capturing):
-        path = os.path.join(folder_paths.get_output_directory(), filename)
+        # Relative to ComfyUI/output/, which is what the tooltip promises. `os.path.join`
+        # alone does not keep that promise: hand it an absolute path and it discards the
+        # first argument, and `write()` then happily creates whatever directory it names.
+        # The sibling Quantize node already resolves `act_stats` this way, so make the two
+        # agree about what a bare filename means.
+        filename = filename.strip()
+        if not filename:
+            raise ValueError("filename is empty")
+        if os.path.isabs(filename) or os.path.splitdrive(filename)[0]:
+            raise ValueError(
+                "filename must be relative to ComfyUI/output/, got an absolute path: {}"
+                .format(filename))
+        out_dir = folder_paths.get_output_directory()
+        path = os.path.normpath(os.path.join(out_dir, filename))
+        if os.path.commonpath([os.path.abspath(out_dir), os.path.abspath(path)]) != \
+                os.path.abspath(out_dir):
+            raise ValueError(
+                "filename must stay under ComfyUI/output/, got: {}".format(filename))
         info = write(path)
         if not keep_capturing:
             detach()
@@ -251,7 +273,7 @@ class Krea2SVDQuantCaptureSave:
                   "tokens per layer: {min_tokens}-{max_tokens}{more}").format(
             more="" if keep_capturing else "\nhooks detached", **info)
         logging.info("[krea2-svdquant] %s", status.replace("\n", "  "))
-        return {"ui": {"text": [status]}, "result": (latent, status)}
+        return {"ui": {"text": [status]}, "result": (latent, status, info["path"])}
 
 
 NODE_CLASS_MAPPINGS = {

svdquant_lora.py

@@ -54,12 +54,12 @@ from .svdquant_w4a4 import add_low_rank, has_branch
 _PREFIX = "diffusion_model."
 _ALT_PREFIX = "transformer."
 
-# What to do with an adapter that cannot fold into the low-rank branch (LoKr, LoHa, OFT).
-# `bypass` computes it every forward and never touches the 4-bit weight; `bake` hands it to
-# ComfyUI, which rewrites the weight once and pays nothing per step. Measured on a 3090 at
-# 1440x1920 with a LoKr on all 224 blocks: bypass costs +1.8 s per model call, bake costs
-# nothing and quantizes the delta to 4 bits along with the weight.
+# What to do with an adapter that cannot fold directly into the low-rank branch (LoKr, LoHa, OFT).
+# `bypass` computes it every forward and never touches the 4-bit weight; `svd delta` decomposes
+# the weight delta with torch.svd_lowrank and merges it into the low-rank branch (zero per-step
+# overhead); `bake` hands it to ComfyUI, which rewrites the weight once and pays nothing per step.
 ADAPTER_BYPASS = "bypass (exact, slower)"
+ADAPTER_SVD = "svd delta (fast, low-rank SVD, no per-step overhead)"
 ADAPTER_BAKE = "bake into the weight (fast, requantizes the delta)"
 
 # Reloading a 300 MB LoRA off disk on every graph execution is pure latency when the
@@ -135,6 +135,59 @@ def _plain_lora_factors(adapter, strength: float, device, dtype):
     return l1.contiguous(), l2.contiguous()
 
 
+def _svd_adapter_factors(adapter, strength: float, device, dtype, max_rank: int = 64):
+    """Decompose an arbitrary adapter's weight delta into low-rank factors (l1, l2) via SVD.
+
+    For LoKr, LoHa, OFT, GFS, etc. This extracts the weight delta, computes a
+    truncated SVD using torch.svd_lowrank, and produces (l1, l2) where l1 @ l2 ≈ delta * strength.
+    Running this in the low-rank branch completely eliminates the per-step runtime overhead
+    of complex adapter contractions while preserving 4-bit base weights untouched.
+    """
+    try:
+        delta = None
+        # Case 1: ComfyUI WeightAdapterBase with calculate_weight
+        if hasattr(adapter, "calculate_weight"):
+            shape = getattr(adapter, "shape", None)
+            if shape is not None and len(shape) == 2:
+                zeros = torch.zeros(shape, dtype=torch.float32, device="cpu")
+                delta = adapter.calculate_weight(zeros)
+        # Case 2: Tuple / Diff / weights directly
+        if delta is None and hasattr(adapter, "weights"):
+            weights = adapter.weights
+            if weights and isinstance(adapter, comfy.weight_adapter.DiffAdapter):
+                delta = weights[0]
+            elif isinstance(adapter, comfy.weight_adapter.LoKrAdapter) and len(weights) >= 2:
+                w1, w2 = weights[0], weights[1]
+                if w1 is not None and w2 is not None:
+                    delta = torch.kron(w1.to(torch.float32), w2.to(torch.float32))
+            elif isinstance(adapter, comfy.weight_adapter.LoHaAdapter) and len(weights) >= 4:
+                w1a, w1b, w2a, w2b = weights[:4]
+                if all(w is not None for w in (w1a, w1b, w2a, w2b)):
+                    delta = (w1a.to(torch.float32) @ w1b.to(torch.float32)) * (w2a.to(torch.float32) @ w2b.to(torch.float32))
+        elif isinstance(adapter, tuple) and len(adapter) >= 1 and torch.is_tensor(adapter[0]):
+            delta = adapter[0]
+
+        if delta is None or delta.ndim != 2:
+            return None
+
+        out_dim, in_dim = delta.shape
+        k = min(max_rank, min(out_dim, in_dim))
+        if k <= 0:
+            return None
+
+        delta_f32 = delta.to(device="cpu", dtype=torch.float32)
+        # SVD: delta_f32 ≈ U @ diag(S) @ V.T
+        U, S, V = torch.svd_lowrank(delta_f32, q=k)
+        sqrt_s = torch.sqrt(torch.clamp(S, min=0.0))
+        # l1 is (out_dim, k), l2 is (k, in_dim)
+        l1 = (U * sqrt_s.unsqueeze(0)).to(device=device, dtype=dtype)
+        l2 = (sqrt_s.unsqueeze(1) * V.T * strength).to(device=device, dtype=dtype)
+        return l1.contiguous(), l2.contiguous()
+    except Exception as exc:
+        logging.warning("[krea2-svdquant] SVD adapter decomposition skipped: %s", exc)
+        return None
+
+
 def _supports_bypass(adapter) -> bool:
     """True when the adapter can run without touching the base weight.
 
@@ -244,6 +297,17 @@ def collect_svdquant_lora(patcher, lora_sd, strength: float, quant_layers: set[s
             # A plain LoRA folds into the branch for free in either mode -- one pair of
             # GEMMs for the whole stack -- so `bake` has nothing to win here.
             into_branch.setdefault(layer, []).append(factors)
+        elif adapter_mode == ADAPTER_SVD:
+            # Attempt SVD decomposition into low-rank factors
+            svd_factors = _svd_adapter_factors(patch, strength, device, dtype)
+            if svd_factors is not None:
+                into_branch.setdefault(layer, []).append(svd_factors)
+            elif isinstance(patch, comfy.weight_adapter.WeightAdapterBase) and _supports_bypass(patch):
+                into_adapters.setdefault(layer, []).append((patch, strength))
+            else:
+                leftover[model_key] = patch
+                dequantizing += 1
+                continue
         elif (adapter_mode == ADAPTER_BYPASS
               and isinstance(patch, comfy.weight_adapter.WeightAdapterBase)
               and _supports_bypass(patch)):
@@ -293,15 +357,14 @@ class Krea2SVDQuantLoraLoader:
                 }),
             },
             "optional": {
-                "adapters": ([ADAPTER_BYPASS, ADAPTER_BAKE], {
+                "adapters": ([ADAPTER_BYPASS, ADAPTER_SVD, ADAPTER_BAKE], {
                     "default": ADAPTER_BYPASS,
-                    "tooltip": "Only affects LoRAs that cannot fold into the low-rank branch "
-                               "(LoKr, LoHa, OFT); a plain LoRA is free either way. 'bypass' "
-                               "computes the adapter every forward and never touches the "
-                               "4-bit weight. 'bake' hands it to ComfyUI, which rewrites the "
-                               "weight once: no per-step cost, but the delta is quantized to "
-                               "4 bits with it. Measured with a LoKr at 1440x1920: bypass "
-                               "+1.8 s per model call, bake +0.",
+                    "tooltip": "Only affects LoRAs that cannot fold directly into the low-rank "
+                               "branch (LoKr, LoHa, OFT); a plain LoRA is free in all modes. "
+                               "'bypass' computes the adapter every forward without touching "
+                               "the 4-bit weight. 'svd delta' decomposes the delta into low-rank "
+                               "factors (zero per-step overhead). 'bake' rewrites the weight once: "
+                               "fast, but quantizes the delta to 4 bits.",
                 }),
             },
         }

svdquant_quantize.py

@@ -35,6 +35,13 @@ from .svdquant_diag import _CATEGORY
 # the ~8 GB output rather than exactly it.
 _MIN_FREE_BYTES = 12 * 1024 ** 3
 
+# All-in-one: the combined file is ~12 GB, and building one from a BF16 DiT writes an ~8 GB
+# intermediate first. Those two can land on different drives (the intermediate goes to
+# ComfyUI's temp directory), so they are checked separately rather than summed -- the old
+# single 15 GB check against the output drive was under the real peak either way.
+_MIN_FREE_ALLINONE = 15 * 1024 ** 3
+_MIN_FREE_INTERMEDIATE = 11 * 1024 ** 3
+
 
 def _free_bytes(path: str) -> int:
     return shutil.disk_usage(os.path.dirname(os.path.abspath(path))).free
@@ -116,9 +123,64 @@ class Krea2SVDQuantQuantize:
                                "inference and the best-measured setting here - LPIPS to BF16 "
                                "0.3378 to 0.2825 with no LoRA. Empty means the plain objective.",
                 }),
+                # Appended after act_stats rather than inserted among the required inputs:
+                # ComfyUI matches widgets_values positionally, so anywhere else would shift
+                # every value in a workflow saved before this input existed.
+                "seed": ("INT", {
+                    "default": 0, "min": -1, "max": 0xFFFFFFFF,
+                    "tooltip": "svdq only: seed for the randomized low-rank SVD. Quantizing "
+                               "twice with the same seed on the same GPU now gives identical "
+                               "files; -1 restores the old unseeded behaviour, where it did "
+                               "not. The same seed on a different device still differs (~1e-4 "
+                               "per weight) - CPU and CUDA do not draw the same numbers.",
+                }),
             },
         }
 
+    @classmethod
+    def VALIDATE_INPUTS(cls, source_model, format, variant, rank, rank_alloc, output_name,
+                        overwrite):
+        """Refuse the obviously-doomed run before the graph starts, not after.
+
+        Everything checked here is a widget, so ComfyUI has it at validation time. That
+        matters most in the calibrated graph, where this node sits behind a full sampling
+        pass: without this, "that file already exists" arrives several minutes after you
+        pressed Queue, having burned the calibration run to tell you.
+
+        Deliberately not checked here: `act_stats`, which can be wired from the Capture Save
+        node and therefore has no value yet at validation time. Its checks stay in `run`.
+        """
+        try:
+            src = folder_paths.get_full_path_or_raise("diffusion_models", source_model)
+        except Exception as exc:
+            return str(exc)
+        try:
+            _, rank = resolve_format(format, rank, rank_was_set=False)
+        except Exception as exc:
+            return str(exc)
+
+        if output_name.strip():
+            name = output_name.strip()
+            if not name.endswith(".safetensors"):
+                name += ".safetensors"
+            dst = os.path.join(os.path.dirname(src), name)
+        else:
+            # An act-aware build lands on a different filename, and act_stats is unknowable
+            # here. Pass None and the check is against the un-tagged name: it can miss a
+            # collision, never invent one, which is the right way for a pre-flight check to
+            # be wrong.
+            dst, _note = derive_out_path(src, format, rank, variant, rank_alloc, None)
+
+        if os.path.exists(dst) and not overwrite:
+            return ("{} already exists. Enable 'overwrite', or set a different output_name."
+                    .format(dst))
+        free = _free_bytes(dst)
+        if free < _MIN_FREE_BYTES:
+            return ("only {:.1f} GB free on the drive holding {}; quantizing needs roughly "
+                    "{:.0f} GB of headroom.".format(free / 1024 ** 3, os.path.dirname(dst),
+                                                    _MIN_FREE_BYTES / 1024 ** 3))
+        return True
+
     @classmethod
     def IS_CHANGED(cls, *args, **kwargs):
         # Writes an ~8 GB file as its side effect, so a cached summary would claim a file
@@ -139,7 +201,7 @@ class Krea2SVDQuantQuantize:
                    "Krea2 SVDQuant W4A4 Loader (svdq) or the stock UNETLoader (w4a4/int8/fp8).")
 
     def run(self, source_model, format, rank, rank_alloc, refine_iters, groupsize, variant,
-            output_name, overwrite, act_stats=""):
+            output_name, overwrite, act_stats="", seed=0):
         src = folder_paths.get_full_path_or_raise("diffusion_models", source_model)
 
         # `rank` always carries a value from the widget, so "was it set?" cannot be inferred
@@ -196,12 +258,13 @@ class Krea2SVDQuantQuantize:
             pbar.update_absolute(done, total)
 
         logging.info("[krea2-svdquant] quantizing %s -> %s (format %s, rank %s/%s, "
-                     "refine_iters %s, act_stats %s)", src, dst, fmt, rank, rank_alloc,
-                     refine_iters if rank else 0, stats_path or "none")
+                     "refine_iters %s, act_stats %s, seed %s)", src, dst, fmt, rank,
+                     rank_alloc, refine_iters if rank else 0, stats_path or "none",
+                     "unseeded" if seed < 0 else seed)
         summary = convert(src, dst, fmt, groupsize, "cuda", rank, refine_iters,
                           variant=variant, progress_cb=progress,
                           rank_alloc=rank_alloc if rank else "uniform",
-                          act_stats=stats_path)
+                          act_stats=stats_path, seed=None if seed < 0 else int(seed))
 
         hint = SAMPLER_HINTS.get(variant)
         loader = ("Krea2 SVDQuant W4A4 Loader" if rank else "the stock UNETLoader")
@@ -211,5 +274,246 @@ class Krea2SVDQuantQuantize:
         return {"ui": {"text": [text]}, "result": (text,)}
 
 
-NODE_CLASS_MAPPINGS = {"Krea2SVDQuantQuantize": Krea2SVDQuantQuantize}
-NODE_DISPLAY_NAME_MAPPINGS = {"Krea2SVDQuantQuantize": "Krea2 SVDQuant Quantize"}
+class Krea2SVDQuantQuantizeAllInOne:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "source_dit": (folder_paths.get_filename_list("diffusion_models"), {
+                    "tooltip": "The Krea 2 DiT model: either a BF16 source (~24 GB, will be "
+                               "quantized first) or an already-quantized SVDQuant/W4A4/INT8 file.",
+                }),
+                "text_encoder": (folder_paths.get_filename_list("text_encoders"), {
+                    "tooltip": "The Qwen3-VL 4B BF16 text encoder safetensors (~8.88 GB). "
+                               "Its 252 linear projections will be quantized to te_format, "
+                               "reducing it to ~3.2 GB without losing the vision tower.",
+                }),
+                "vae": (folder_paths.get_filename_list("vae"), {
+                    "tooltip": "The Krea 2 VAE (~0.51 GB, kept unquantized).",
+                }),
+                "format": (["svdq", "w4a4", "int8", "fp8"], {
+                    "default": "svdq",
+                    "tooltip": "Diffusion model format. svdq: 4-bit weights and activations "
+                               "plus a low-rank bf16 correction branch.",
+                }),
+                "te_format": (["w4a4", "int8"], {
+                    "default": "w4a4",
+                    "tooltip": "Text encoder format: w4a4 (convrot_w4a4, ~3.2 GB) or int8 "
+                               "(int8_tensorwise, ~5.2 GB).",
+                }),
+                "rank": ("INT", {
+                    "default": 64, "min": 8, "max": 1024, "step": 8,
+                    "tooltip": "svdq only: size of the low-rank branch on the diffusion model.",
+                }),
+                "refine_iters": ("INT", {
+                    "default": 100, "min": 0, "max": 200,
+                    "tooltip": "svdq only (if source_dit is BF16). Refines the branch against "
+                               "quantization error. Ignored if source_dit is already quantized.",
+                }),
+                "groupsize": ("INT", {
+                    "default": 256, "min": 32, "max": 1024, "step": 32,
+                    "tooltip": "convrot rotation group size.",
+                }),
+                "variant": (["turbo", "base", "unknown"], {
+                    "default": "turbo",
+                    "tooltip": "Which Krea 2 release this is.",
+                }),
+                "output_name": ("STRING", {
+                    "default": "",
+                    "tooltip": "Filename in models/checkpoints/. Leave empty to derive automatically.",
+                }),
+                "overwrite": ("BOOLEAN", {
+                    "default": False,
+                    "tooltip": "Allow overwriting existing output checkpoint.",
+                }),
+            },
+            "optional": {
+                "act_stats": ("STRING", {
+                    "default": "",
+                    "tooltip": "svdq only (if source_dit is BF16): activation statistics file.",
+                }),
+                "seed": ("INT", {
+                    "default": 0, "min": -1, "max": 0xFFFFFFFF,
+                    "tooltip": "Random seed for reproducible SVD.",
+                }),
+            },
+        }
+
+    @staticmethod
+    def _out_path(output_name, variant, format, rank, te_format) -> str:
+        """Where this run will write. Shared, so validation checks the path `run` will use."""
+        ckpt_dir = folder_paths.get_folder_paths("checkpoints")[0]
+        if output_name.strip():
+            name = output_name.strip()
+            if not name.endswith(".safetensors"):
+                name += ".safetensors"
+            return os.path.join(ckpt_dir, name)
+        stem = "Krea2-{}".format(variant.capitalize()) if variant != "unknown" else "Krea2"
+        tag = "SVDQuant-W4A4-rank{}".format(rank) if rank else format.upper()
+        return os.path.join(ckpt_dir, "{}-AllInOne-{}-TE{}.safetensors".format(
+            stem, tag, te_format.upper()))
+
+    @classmethod
+    def VALIDATE_INPUTS(cls, source_dit, text_encoder, vae, output_name, overwrite,
+                        variant, format, te_format, rank):
+        """Same pre-flight as the sibling node, for the same reason.
+
+        This one writes ~12 GB and, from a BF16 source, spends ten minutes quantizing a DiT
+        before it reaches the combiner -- so "that file already exists" has to arrive at
+        Queue time rather than after the expensive part.
+        """
+        for folder, name in (("diffusion_models", source_dit),
+                             ("text_encoders", text_encoder), ("vae", vae)):
+            try:
+                folder_paths.get_full_path_or_raise(folder, name)
+            except Exception as exc:
+                return str(exc)
+        try:
+            _, rank = resolve_format(format, rank, rank_was_set=False)
+        except Exception as exc:
+            return str(exc)
+
+        dst = cls._out_path(output_name, variant, format, rank, te_format)
+        if os.path.exists(dst) and not overwrite:
+            return ("{} already exists. Enable 'overwrite', or set a different output_name."
+                    .format(dst))
+        free = _free_bytes(dst)
+        if free < _MIN_FREE_ALLINONE:
+            return ("only {:.1f} GB free on the drive holding {}; the combined checkpoint "
+                    "needs roughly {:.0f} GB.".format(free / 1024 ** 3, os.path.dirname(dst),
+                                                      _MIN_FREE_ALLINONE / 1024 ** 3))
+        return True
+
+    @classmethod
+    def IS_CHANGED(cls, *args, **kwargs):
+        # ~12 GB written as a side effect. Same reasoning as the sibling node: a cached
+        # summary claims a file exists that the user may since have deleted.
+        return float("nan")
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("summary",)
+    OUTPUT_TOOLTIPS = ("Size, tensor counts and loader instructions for the baked checkpoint.",)
+    OUTPUT_NODE = True
+    FUNCTION = "run"
+    CATEGORY = _CATEGORY
+    TITLE = "Krea2 SVDQuant Quantize All-in-One"
+    DESCRIPTION = ("Bakes DiT, 4-bit quantized Qwen3-VL 4B text encoder, and VAE into a single "
+                   "combined checkpoint in ComfyUI/models/checkpoints/ (~12 GB instead of 15.5 GB "
+                   "across three files).")
+
+    def run(self, source_dit, text_encoder, vae, format, te_format, rank, refine_iters,
+            groupsize, variant, output_name, overwrite, act_stats="", seed=0):
+        from safetensors import safe_open
+        # `.build_all_in_one`, not `.tools.build_all_in_one`: `.comfyignore` keeps `tools/`
+        # out of the published package, so the old import raised ImportError for every
+        # Registry/Manager install and worked only for a git clone.
+        from .build_all_in_one import build_all_in_one_checkpoint
+
+        dit_src = folder_paths.get_full_path_or_raise("diffusion_models", source_dit)
+        te_src = folder_paths.get_full_path_or_raise("text_encoders", text_encoder)
+        vae_src = folder_paths.get_full_path_or_raise("vae", vae)
+
+        fmt, rank = resolve_format(format, rank, rank_was_set=False)
+
+        os.makedirs(folder_paths.get_folder_paths("checkpoints")[0], exist_ok=True)
+        dst = self._out_path(output_name, variant, format, rank, te_format)
+
+        if os.path.exists(dst) and not overwrite:
+            raise RuntimeError(
+                "{} already exists. Enable 'overwrite', or set a different output_name."
+                .format(dst))
+
+        free = _free_bytes(dst)
+        if free < _MIN_FREE_ALLINONE:
+            raise RuntimeError(
+                "only {:.1f} GB free on the drive holding {}; baking all-in-one needs "
+                "roughly {:.0f} GB headroom.".format(
+                    free / 1024 ** 3, dst, _MIN_FREE_ALLINONE / 1024 ** 3))
+
+        comfy.model_management.unload_all_models()
+        comfy.model_management.soft_empty_cache()
+
+        # Check if DiT is already quantized or needs quantization
+        with safe_open(dit_src, framework="pt", device="cpu") as handle:
+            keys = list(handle.keys())
+        already_quantized = any(k.endswith(".comfy_quant") for k in keys)
+        temp_dit = None
+
+        if not already_quantized:
+            stats_path = act_stats.strip() or None
+            if stats_path is not None and not os.path.isabs(stats_path):
+                stats_path = os.path.join(folder_paths.get_output_directory(), stats_path)
+            # ComfyUI's temp directory rather than models/checkpoints/: a run killed
+            # mid-quantize leaves this ~8 GB file behind -- the `finally` below only covers
+            # a clean unwind -- and beside the real checkpoints it shows up in every loader
+            # dropdown as something that looks loadable and is not.
+            temp_dir = folder_paths.get_temp_directory()
+            os.makedirs(temp_dir, exist_ok=True)
+            temp_dit = os.path.join(temp_dir,
+                                    os.path.basename(dst) + ".tmp_dit.safetensors")
+            temp_free = _free_bytes(temp_dit)
+            if temp_free < _MIN_FREE_INTERMEDIATE:
+                raise RuntimeError(
+                    "only {:.1f} GB free on the drive holding {}; quantizing the DiT first "
+                    "writes an intermediate of roughly {:.0f} GB there.".format(
+                        temp_free / 1024 ** 3, temp_dir,
+                        _MIN_FREE_INTERMEDIATE / 1024 ** 3))
+            logging.info("[krea2-svdquant] quantizing DiT first: %s -> %s", dit_src, temp_dit)
+            convert(dit_src, temp_dit, fmt, groupsize, "cuda", rank, refine_iters,
+                    variant=variant, rank_alloc="uniform", act_stats=stats_path,
+                    seed=None if seed < 0 else int(seed))
+            active_dit = temp_dit
+        else:
+            active_dit = dit_src
+
+        pbar = comfy.utils.ProgressBar(1)
+        state = {"total": 0}
+
+        def progress(done, total, message):
+            if total != state["total"]:
+                state["total"] = total
+                pbar.total = total
+            pbar.update_absolute(done, total)
+
+        try:
+            summary = build_all_in_one_checkpoint(
+                dit_path=active_dit,
+                text_encoder_path=te_src,
+                vae_path=vae_src,
+                out_path=dst,
+                fmt_name=format,
+                te_format=te_format,
+                rank=rank,
+                variant=variant,
+                groupsize=groupsize,
+                device="cuda",
+                progress_cb=progress,
+            )
+        finally:
+            if temp_dit and os.path.exists(temp_dit):
+                try:
+                    os.remove(temp_dit)
+                except Exception:
+                    # Not worth failing the run over -- the checkpoint is already written --
+                    # but ~8 GB staying behind in the temp directory is worth one line,
+                    # because nothing else will ever mention it.
+                    logging.warning(
+                        "[krea2-svdquant] could not delete the intermediate %s; roughly "
+                        "8 GB is still there", temp_dit, exc_info=True)
+
+        hint = SAMPLER_HINTS.get(variant)
+        loader = ("Krea2 SVDQuant Checkpoint Loader" if rank else "CheckpointLoaderSimple")
+        text = "\n".join(x for x in (
+            summary, "Load it with {}.".format(loader), hint) if x)
+        logging.info("[krea2-svdquant] %s", text)
+        return {"ui": {"text": [text]}, "result": (text,)}
+
+
+NODE_CLASS_MAPPINGS = {
+    "Krea2SVDQuantQuantize": Krea2SVDQuantQuantize,
+    "Krea2SVDQuantQuantizeAllInOne": Krea2SVDQuantQuantizeAllInOne,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Krea2SVDQuantQuantize": "Krea2 SVDQuant Quantize",
+    "Krea2SVDQuantQuantizeAllInOne": "Krea2 SVDQuant Quantize All-in-One",
+}

svdquant_w4a4.py

@@ -33,6 +33,64 @@ from .svdquant_diag import BUF_L1, BUF_L2, _CATEGORY, branch_factors, log_dispat
 _L1 = "." + BUF_L1
 _L2 = "." + BUF_L2
 
+# How the two loaders answer `disable_dynamic=` when they build the patcher.
+VRAM_MANAGEMENT = ["auto", "classic"]
+
+# Both loaders offer the same choice, so the wording lives in one place. Long, because the
+# question it answers -- "why is this suddenly 30 s an iteration" -- is one nobody arrives
+# at the tooltip already understanding.
+VRAM_TOOLTIP = (
+    'Leave on "auto" unless something is wrong. "auto" lets ComfyUI manage this model the '
+    "way it manages any other, which on an ordinary launch means the dynamic-VRAM "
+    "streaming patcher -- that is what keeps iteration time flat once the model stops "
+    'fitting in VRAM. "classic" pins it to the older patcher, where a model that no longer '
+    "fits falls back to streaming weights per module per step and an iteration goes from "
+    "~1 s to 30-100 s. KREA2_DISABLE_DYNAMIC=1 forces classic for a whole server run."
+)
+
+
+def _disable_dynamic(mode: str = "auto") -> bool:
+    """Whether to pin this model to the classic `ModelPatcher`.
+
+    `auto` means "whatever ComfyUI would do for a stock UNETLoader", which since the
+    dynamic-VRAM work means the streaming `ModelPatcherDynamic` on any ordinary launch
+    (`main.py` swaps `CoreModelPatcher` for it unless --highvram/--novram/--gpu-only/--cpu
+    or --disable-dynamic-vram is set). This loader used to hardcode the pin, and that is
+    the whole reason an svdq checkpoint fell to per-module weight streaming past the point
+    where it stopped fitting -- 30-100 s an iteration -- while the same-size FP8/INT8/
+    noLowRank files, which go through the stock loader, did not.
+
+    Both conditions the pin was waiting on hold on current ComfyUI, and both were
+    measured rather than argued from the source:
+
+    * the branch buffers survive the streaming patcher. Its `load()` walks
+      `named_buffers()`, moves every one to the load device and backs up the original.
+      Read off the diagnostics node after a render, under enough pressure to force
+      offloading: all 448 factors on `cuda:0` while all 224 quantized weights sit on `cpu`
+      and stream. So `add_low_rank`'s `cast_to` is a no-op, and the split is the one you
+      would choose -- the small branch every step needs stays resident, the big weights do
+      not. The same reading under `classic` is 368 factors on `cpu`, i.e. staged per call.
+    * `module_size()` still counts them, because `_load_list` derives its per-module
+      budget from `model_management.module_size`, which sums `state_dict()` -- exactly
+      what `_publish_in_state_dict` exists to feed.
+
+    `classic` restores the old behaviour. It is kept because one thing here *is*
+    unmeasured: the streaming patcher moves those buffers with a plain `.to()` rather than
+    through its own allocator, so 1.6 GiB at rank 256 is real VRAM its `allocated_size`
+    bookkeeping does not see. If that turns out to matter on some card, the way back should
+    be a dropdown, not a downgrade.
+
+    The env var is the same escape hatch `KREA2_W4A4_OP=0` is, and for the same reason:
+    the choice is made once per load, so A/B-ing it means two server runs that differ by
+    exactly this.
+    """
+    if mode == "classic":
+        return True
+    if mode != "auto":
+        raise ValueError("vram_management must be one of {}, got {!r}".format(
+            VRAM_MANAGEMENT, mode))
+    return os.environ.get("KREA2_DISABLE_DYNAMIC") == "1"
+
 
 def has_branch(module: torch.nn.Module) -> bool:
     """True once this module carries a low-rank branch (i.e. it is a quantized linear)."""
@@ -61,9 +119,10 @@ def _publish_in_state_dict(module: torch.nn.Module) -> None:
     emits weight/scale/marker/bias and nothing else -- buffers never reach it. That
     matters because ``model_management.module_size()`` sums ``state_dict()``, and every
     per-module VRAM decision ComfyUI makes (the lowvram split in particular) is derived
-    from that number. Left alone, ~2.9 MB per layer and ~645 MB across the 224 blocks
-    would sit on the GPU while the budget believed it was free -- which is exactly how an
-    8 GB card OOMs on this checkpoint but not on the branch-free int8 one.
+    from that number. Left alone, 3.75-11 MiB per layer and 1.6 GiB across the 224 blocks
+    (measured off a rank-256 file; 0.4 GiB at rank 64) would sit on the GPU while the budget
+    believed it was free -- which is exactly how an 8 GB card OOMs on this checkpoint but
+    not on the branch-free int8 one.
 
     Emitting them under their own names also means a model saved out of ComfyUI carries
     the same ``<layer>.svdq_l1`` keys quantize_krea2.py writes, so it round-trips.
@@ -97,9 +156,9 @@ def attach_branch(module: torch.nn.Module, l1: torch.Tensor, l2: torch.Tensor,
     by `_publish_in_state_dict` -- on these modules persistence alone is not enough, see
     that function for why. Both steps are needed to get them counted by
     ``model_management.module_size()``, which is what every VRAM decision (full load, the
-    lowvram split, how much to free) is derived from. Uncounted, they are roughly 2.9 MB
-    per layer and 645 MB across the 224 blocks: the difference between fitting and OOMing
-    on an 8 GB card.
+    lowvram split, how much to free) is derived from. Uncounted, they are 3.75-11 MiB per
+    layer and 1.6 GiB across the 224 blocks at rank 256 (0.4 GiB at rank 64): the difference
+    between fitting and OOMing on an 8 GB card.
 
     `scale` is folded into l2 at attach time rather than applied to the output every step:
     l2 is [rank, in_features] while the output is [tokens, out_features], so this is about
@@ -339,39 +398,25 @@ def _install_custom_op(module: torch.nn.Module) -> bool:
     return True
 
 
-def load_svdquant_w4a4(path: str, model_options: dict | None = None,
-                       compile_safe: bool = True):
-    sd, metadata = comfy.utils.load_torch_file(path, return_metadata=True)
-    # `comfy.sd.load_diffusion_model_state_dict` strips this prefix internally when it builds
-    # the module tree, but we walk that tree ourselves to attach branches, so we strip it too.
-    # `default=""` rather than raising: a loader must not blow up on a checkpoint with no
-    # blocks, and the "found no branches" error below says far more about what went wrong.
-    layer_prefix = detect_prefix(sd.keys(), default="")
+def _patcher_desc(patcher) -> str:
+    """Which patcher this model got, for the load summary.
 
-    branches: dict[str, dict[str, torch.Tensor]] = {}
-    for key in list(sd.keys()):
-        for suffix, slot in ((_L1, "l1"), (_L2, "l2")):
-            if key.endswith(suffix):
-                branches.setdefault(key[: -len(suffix)], {})[slot] = sd.pop(key)
-                break
-    if not branches:
-        raise ValueError(
-            "{} carries no svdq_l1/svdq_l2 tensors - it is a plain quantized checkpoint, "
-            "load it with UNETLoader instead".format(path)
-        )
+    Worth stating on every load rather than only when something goes wrong: "dynamic" and
+    "pinned" are the difference between a 1 s iteration and a 30 s one once the model stops
+    fitting, and the status output is the one place a user is told to look when generation
+    is slow. `is_dynamic` is wrapped because it is a newer ComfyUI API and a loader must not
+    fail to load a checkpoint over a status string.
+    """
+    try:
+        return "{} (dynamic vram: {})".format(
+            type(patcher).__name__, "on" if patcher.is_dynamic() else "off")
+    except Exception:
+        return type(patcher).__name__
 
-    # `disable_dynamic=True` pins this to the classic ModelPatcher. On current ComfyUI
-    # that is a no-op (`CoreModelPatcher is ModelPatcher`), but when upstream flips it to
-    # ModelPatcherDynamic the streaming patcher takes ownership of the weights via
-    # `load_model_weights(..., assign=patcher.is_dynamic())`, which we have not validated
-    # against the branch buffers. Keep it pinned until that path is tested; the
-    # diagnostics node reports which patcher is actually in use.
-    patcher = comfy.sd.load_diffusion_model_state_dict(
-        sd, model_options=model_options or {}, metadata=metadata, disable_dynamic=True
-    )
-    if patcher is None:
-        raise RuntimeError("could not detect a model in {}".format(path))
 
+def _attach_svdq_branches(patcher, branches: dict[str, dict[str, torch.Tensor]],
+                         layer_prefix: str, metadata: dict | None, path: str,
+                         compile_safe: bool = True) -> str:
     diffusion_model = patcher.model.diffusion_model
     model_dtype = patcher.model.get_dtype()
     attached = 0
@@ -453,9 +498,9 @@ def load_svdquant_w4a4(path: str, model_options: dict | None = None,
         compile_desc = "compile: all {} layers are graph breaks{}".format(
             attached, " ({})".format(_W4A4_OP_ERROR) if _W4A4_OP_ERROR else "")
     summary = ("w4a4 + low-rank: attached {} branches (rank {}, variant {}), "
-               "model_size {:.2f} GiB, {}".format(
+               "model_size {:.2f} GiB, {}, {}".format(
                    attached, rank_desc, variant, patcher.model_size() / 1024 ** 3,
-                   compile_desc))
+                   _patcher_desc(patcher), compile_desc))
     logging.info("[krea2-svdquant] %s", summary)
 
     dispatch = log_dispatch(diffusion_model)
@@ -465,9 +510,95 @@ def load_svdquant_w4a4(path: str, model_options: dict | None = None,
     # matters most for the dispatch warning: buried in the console, the people who most need
     # to read it are exactly the ones who never see it.
     patcher.krea2_load_summary = "\n".join(x for x in (summary, dispatch) if x)
+    return patcher.krea2_load_summary
+
+
+def load_svdquant_w4a4(path: str, model_options: dict | None = None,
+                       compile_safe: bool = True, vram_management: str = "auto"):
+    sd, metadata = comfy.utils.load_torch_file(path, return_metadata=True)
+    # `comfy.sd.load_diffusion_model_state_dict` strips this prefix internally when it builds
+    # the module tree, but we walk that tree ourselves to attach branches, so we strip it too.
+    # `default=""` rather than raising: a loader must not blow up on a checkpoint with no
+    # blocks, and the "found no branches" error below says far more about what went wrong.
+    layer_prefix = detect_prefix(sd.keys(), default="")
+
+    branches: dict[str, dict[str, torch.Tensor]] = {}
+    for key in list(sd.keys()):
+        for suffix, slot in ((_L1, "l1"), (_L2, "l2")):
+            if key.endswith(suffix):
+                branches.setdefault(key[: -len(suffix)], {})[slot] = sd.pop(key)
+                break
+    if not branches:
+        raise ValueError(
+            "{} carries no svdq_l1/svdq_l2 tensors - it is a plain quantized checkpoint, "
+            "load it with UNETLoader instead".format(path)
+        )
+
+    # See `_disable_dynamic` for why this is no longer hardcoded to True. The diagnostics
+    # node and the load summary both report which patcher the model actually got.
+    patcher = comfy.sd.load_diffusion_model_state_dict(
+        sd, model_options=model_options or {}, metadata=metadata,
+        disable_dynamic=_disable_dynamic(vram_management)
+    )
+    if patcher is None:
+        raise RuntimeError("could not detect a model in {}".format(path))
+
+    _attach_svdq_branches(patcher, branches, layer_prefix, metadata, path, compile_safe)
     return patcher
 
 
+def load_svdquant_checkpoint(path: str, output_vae: bool = True, output_clip: bool = True,
+                            model_options: dict | None = None,
+                            te_model_options: dict | None = None,
+                            compile_safe: bool = True, vram_management: str = "auto"):
+    """Load an all-in-one Krea 2 checkpoint (diffusion model + text encoder + VAE).
+
+    If the checkpoint carries SVDQuant branches (model.diffusion_model.blocks.N.*.svdq_l1/l2),
+    they are extracted, the model is built via ComfyUI's load_state_dict_guess_config, and
+    the low-rank branches are attached. If the checkpoint is branchless (e.g. w4a4 or int8),
+    it is loaded cleanly without branches.
+    """
+    sd, metadata = comfy.utils.load_torch_file(path, return_metadata=True)
+
+    branches: dict[str, dict[str, torch.Tensor]] = {}
+    for key in list(sd.keys()):
+        for suffix, slot in ((_L1, "l1"), (_L2, "l2")):
+            if key.endswith(suffix):
+                branches.setdefault(key[: -len(suffix)], {})[slot] = sd.pop(key)
+                break
+
+    out = comfy.sd.load_state_dict_guess_config(
+        sd,
+        output_vae=output_vae,
+        output_clip=output_clip,
+        output_clipvision=False,
+        embedding_directory=folder_paths.get_folder_paths("embeddings"),
+        model_options=model_options or {},
+        te_model_options=te_model_options or {},
+        metadata=metadata,
+        disable_dynamic=_disable_dynamic(vram_management),
+    )
+    if out is None:
+        raise RuntimeError("could not detect a valid checkpoint in {}".format(path))
+
+    patcher, clip, vae, _ = out
+
+    if branches:
+        layer_prefix = detect_prefix(branches.keys(), default="")
+        _attach_svdq_branches(patcher, branches, layer_prefix, metadata, path, compile_safe)
+    else:
+        diffusion_model = patcher.model.diffusion_model
+        install_mask_guard(patcher)
+        dispatch = log_dispatch(diffusion_model)
+        summary = "all-in-one checkpoint (branchless): model_size {:.2f} GiB, {}".format(
+            patcher.model_size() / 1024 ** 3, _patcher_desc(patcher))
+        logging.info("[krea2-svdquant] %s", summary)
+        patcher.krea2_load_summary = "\n".join(x for x in (summary, dispatch) if x)
+
+    status = getattr(patcher, "krea2_load_summary", "")
+    return patcher, clip, vae, status
+
+
 class Krea2SVDQuantW4A4Loader:
     @classmethod
     def INPUT_TYPES(cls):
@@ -479,7 +610,16 @@ class Krea2SVDQuantW4A4Loader:
                                "checkpoints have no branch and load with the stock UNETLoader "
                                "instead.",
                 }),
-            }
+            },
+            # Optional and appended last: ComfyUI matches `widgets_values` positionally, so
+            # inserting a widget anywhere else shifts every value in a workflow saved
+            # before this input existed.
+            "optional": {
+                "vram_management": (VRAM_MANAGEMENT, {
+                    "default": "auto",
+                    "tooltip": VRAM_TOOLTIP,
+                }),
+            },
         }
 
     RETURN_TYPES = ("MODEL", "STRING")
@@ -495,12 +635,59 @@ class Krea2SVDQuantW4A4Loader:
                    "no separate base model needed. The status output tells you whether the "
                    "fast int4 kernel is in play.")
 
-    def load(self, model_name):
+    def load(self, model_name, vram_management="auto"):
         path = folder_paths.get_full_path_or_raise("diffusion_models", model_name)
-        patcher = load_svdquant_w4a4(path)
+        patcher = load_svdquant_w4a4(path, vram_management=vram_management)
         status = getattr(patcher, "krea2_load_summary", "")
         return {"ui": {"text": [status]}, "result": (patcher, status)}
 
 
-NODE_CLASS_MAPPINGS = {"Krea2SVDQuantW4A4Loader": Krea2SVDQuantW4A4Loader}
-NODE_DISPLAY_NAME_MAPPINGS = {"Krea2SVDQuantW4A4Loader": "Krea2 SVDQuant W4A4 Loader"}
+class Krea2SVDQuantCheckpointLoader:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "ckpt_name": (folder_paths.get_filename_list("checkpoints"), {
+                    "tooltip": "An all-in-one Krea2 checkpoint containing diffusion model, "
+                               "quantized text encoder, and VAE. If it carries SVDQuant "
+                               "branches (*.svdq_l1/*.svdq_l2), they will be attached automatically.",
+                }),
+            },
+            # See the sibling loader: appended last, for the same positional reason.
+            "optional": {
+                "vram_management": (VRAM_MANAGEMENT, {
+                    "default": "auto",
+                    "tooltip": VRAM_TOOLTIP,
+                }),
+            },
+        }
+
+    RETURN_TYPES = ("MODEL", "CLIP", "VAE", "STRING")
+    RETURN_NAMES = ("model", "clip", "vae", "status")
+    OUTPUT_TOOLTIPS = ("Wire this to a KSampler.",
+                       "Wire this to CLIPTextEncode.",
+                       "Wire this to VAEDecode.",
+                       "Rank, variant, size and which kernel the quantized layers will "
+                       "actually dispatch to.")
+    OUTPUT_NODE = True
+    FUNCTION = "load"
+    CATEGORY = _CATEGORY
+    TITLE = "Krea2 SVDQuant Checkpoint Loader"
+    DESCRIPTION = ("Loads an all-in-one Krea2 checkpoint containing diffusion model, text encoder, "
+                   "and VAE in a single file. Attaches low-rank SVDQuant branches if present.")
+
+    def load(self, ckpt_name, vram_management="auto"):
+        path = folder_paths.get_full_path_or_raise("checkpoints", ckpt_name)
+        patcher, clip, vae, status = load_svdquant_checkpoint(
+            path, vram_management=vram_management)
+        return {"ui": {"text": [status]}, "result": (patcher, clip, vae, status)}
+
+
+NODE_CLASS_MAPPINGS = {
+    "Krea2SVDQuantW4A4Loader": Krea2SVDQuantW4A4Loader,
+    "Krea2SVDQuantCheckpointLoader": Krea2SVDQuantCheckpointLoader,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Krea2SVDQuantW4A4Loader": "Krea2 SVDQuant W4A4 Loader",
+    "Krea2SVDQuantCheckpointLoader": "Krea2 SVDQuant Checkpoint Loader",
+}

tools/bake_adapter.py

@@ -28,14 +28,15 @@ import sys
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, os.path.dirname(HERE))                 # the node package
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(HERE))))  # ComfyUI root
 
 import torch  # noqa: E402
 
-import comfy.lora  # noqa: E402
-import comfy.utils  # noqa: E402
-import comfy.weight_adapter  # noqa: E402
-
+# `quantize_krea2` before `comfy.*`, and that order is the point. It runs
+# `_find_comfyui_root()` at import -- $COMFYUI_PATH, then two levels up from itself, then a
+# couple of fallbacks -- so importing it is what puts ComfyUI on the path. This file used to
+# do that itself with a bare `dirname(dirname(dirname(HERE)))`, which is correct only when
+# the pack sits in `ComfyUI/custom_nodes/`: from a working copy anywhere else, even `--help`
+# died on `No module named 'comfy'` with nothing to say about why.
 from quantize_krea2 import (  # noqa: E402
     LAYER_PREFIXES,
     convert,
@@ -44,6 +45,10 @@ from quantize_krea2 import (  # noqa: E402
     resolve_format,
 )
 
+import comfy.lora  # noqa: E402
+import comfy.utils  # noqa: E402
+import comfy.weight_adapter  # noqa: E402
+
 _PREFIX = "diffusion_model."
 _ALT_PREFIX = "transformer."
 

tools/build_all_in_one.py

@@ -0,0 +1,100 @@
+"""Command-line front end for `build_all_in_one.py`.
+
+The mechanism lives one directory up, beside `quantize_krea2.py`, because `.comfyignore`
+keeps `tools/` out of the published package and the in-graph quantize node imports it.
+This file is the part a terminal needs: the sys.path bootstrap that makes the package
+importable when it is run as a plain script, and the argument parsing.
+
+    python tools/build_all_in_one.py --dit ... --text-encoder ... --vae ... --format svdq
+
+Run `--help` for the full set. `--dry-run` does the whole key mapping and prints the size
+arithmetic without quantizing anything or touching the GPU.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+# The package directory, so `import build_all_in_one` resolves to the module beside
+# `quantize_krea2.py`. It in turn finds ComfyUI itself (`quantize_krea2._find_comfyui_root`),
+# so there is nothing else to bootstrap here.
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from build_all_in_one import TE_FORMATS, build_all_in_one_checkpoint  # noqa: E402
+from quantize_krea2 import DEFAULT_SEED, REFINE_TOL, resolve_format  # noqa: E402
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--dit", required=True,
+                    help="the diffusion model: a BF16 source, or one this tool already "
+                         "quantized (detected, and passed through untouched)")
+    ap.add_argument("--text-encoder", required=True, help="qwen3vl_4b BF16 safetensors")
+    ap.add_argument("--vae", required=True)
+    ap.add_argument("--format", choices=["int8", "w4a4", "svdq", "fp8"], default="svdq",
+                    help="diffusion side. svdq needs this repo's checkpoint loader node; "
+                         "w4a4/int8 load with the stock CheckpointLoaderSimple")
+    ap.add_argument("--te-format", choices=sorted(TE_FORMATS), default="w4a4",
+                    help="text encoder side. No low-rank branch either way")
+    ap.add_argument("--rank", type=int, default=64, help="diffusion side, svdq only")
+    ap.add_argument("--rank-alloc", default="uniform")
+    ap.add_argument("--refine-iters", type=int, default=100)
+    ap.add_argument("--refine-tol", type=float, default=REFINE_TOL)
+    ap.add_argument("--groupsize", type=int, default=256)
+    ap.add_argument("--act-stats", default=None, help="diffusion side only")
+    ap.add_argument("--variant", choices=["turbo", "base", "unknown"], default="unknown")
+    ap.add_argument("--seed", type=int, default=DEFAULT_SEED)
+    ap.add_argument("--device", default="cuda")
+    ap.add_argument("--out", default=None)
+    ap.add_argument("--keep-dit-temp", action="store_true",
+                    help="do not delete the intermediate quantized diffusion file")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="map every key and print the size arithmetic. Quantizes nothing, "
+                         "allocates nothing, never touches the GPU")
+    args = ap.parse_args()
+
+    fmt, rank = resolve_format(args.format, args.rank, rank_was_set=True)
+
+    out = args.out
+    if out is None:
+        stem = "Krea2-{}".format(args.variant.capitalize()) if args.variant != "unknown" \
+            else "Krea2"
+        tag = "SVDQuant-W4A4-rank{}".format(rank) if rank else args.format.upper()
+        dit_dir = os.path.dirname(os.path.abspath(args.dit))
+        ckpt_dir = os.path.join(os.path.dirname(dit_dir), "checkpoints")
+        target_dir = ckpt_dir if os.path.isdir(ckpt_dir) else dit_dir
+        out = os.path.join(target_dir,
+                           "{}-AllInOne-{}-TE{}.safetensors".format(
+                               stem, tag, args.te_format.upper()))
+
+    print("diffusion : {}".format(os.path.basename(args.dit)))
+    print("encoder   : {} -> {}".format(os.path.basename(args.text_encoder), args.te_format))
+    print("vae       : {} (unquantized)".format(os.path.basename(args.vae)))
+    print("out       : {}".format(out))
+
+    summary = build_all_in_one_checkpoint(
+        dit_path=args.dit,
+        text_encoder_path=args.text_encoder,
+        vae_path=args.vae,
+        out_path=out,
+        fmt_name=args.format,
+        te_format=args.te_format,
+        rank=rank,
+        variant=args.variant,
+        groupsize=args.groupsize,
+        device=args.device,
+        dry_run=args.dry_run,
+    )
+    print("\n" + summary)
+    if not args.dry_run:
+        if rank:
+            print("svdq checkpoint: load it with the Krea2 SVDQuant Checkpoint Loader node, "
+                  "not CheckpointLoaderSimple -- the low-rank branch needs attaching.")
+        else:
+            print("branchless: loads with the stock CheckpointLoaderSimple.")
+
+
+if __name__ == "__main__":
+    main()

tools/build_workflows.py

@@ -37,7 +37,12 @@ ROW = 200          # vertical gap between rows
 TEAL = ("#233", "#355")        # loaders
 GREEN = ("#232", "#353")       # prompts
 PURPLE = ("#323", "#535")      # sampling
-YELLOW = ("#432", "#653")      # notes / read me first
+YELLOW = ("#432", "#653")      # notes / read me first / diagnostics
+ORANGE = ("#653", "#874")      # LoRA
+
+# Mirrors svdquant_lora.ADAPTER_BYPASS. Not imported: this script must run without ComfyUI
+# on sys.path, and the loader module imports comfy at module level. Asserted in main().
+ADAPTER_BYPASS = "bypass (exact, slower)"
 
 
 class Graph:
@@ -56,7 +61,7 @@ class Graph:
         self._api = {}     # node_id -> what the API dialect needs about that node
 
     def add(self, class_type, col, row, inputs=None, outputs=None, widgets=None,
-            title=None, colour=None, size=None, api=True):
+            title=None, colour=None, size=None, api=True, mode=0, widget_inputs=()):
         """`widgets` is a list of (input_name, value).
 
         The name is what the API dialect needs and the UI dialect ignores; `None` marks a
@@ -66,7 +71,17 @@ class Graph:
 
         `api=False` drops the node from the API output: Notes and the optional Diagnostics
         node are editor furniture with nothing to execute.
+
+        `mode=4` mutes the node in the editor. A muted node must also be `api=False` -- the
+        API dialect has no mute flag, so leaving it in would execute something the editor
+        shows as off.
+
+        `widget_inputs` names inputs that are widgets on the node class but are being wired
+        from another node instead. LiteGraph needs the `widget` key on the slot or the editor
+        draws a plain input the frontend then refuses to reconnect to its widget.
         """
+        if mode == 4 and api:
+            raise ValueError("a muted node must be api=False: {}".format(class_type))
         nid = self._next_node
         self._next_node += 1
         inputs = inputs or []
@@ -83,8 +98,10 @@ class Graph:
             "size": size or [380, 100],
             "flags": {},
             "order": self._next_node - 2,
-            "mode": 0,
-            "inputs": [{"name": n, "type": t, "link": None} for n, t in inputs],
+            "mode": mode,
+            "inputs": [dict({"name": n, "type": t, "link": None},
+                            **({"widget": {"name": n}} if n in widget_inputs else {}))
+                       for n, t in inputs],
             "outputs": [{"name": n, "type": t, "links": [], "slot_index": i}
                         for i, (n, t) in enumerate(outputs)],
             "properties": {"Node name for S&R": class_type},
@@ -191,6 +208,23 @@ TURBO_NOTE = """KREA 2 TURBO - SVDQuant W4A4
 5. LoRA: use the Krea2 SVDQuant LoRA Loader, not the stock one. The
    stock loader cannot patch a quantized weight and skips the blocks."""
 
+ALL_IN_ONE_TURBO_NOTE = """KREA 2 TURBO - ALL-IN-ONE CHECKPOINT
+
+1. Checkpoint goes in ComfyUI/models/checkpoints/.
+   This file is fully self-contained: it combines the diffusion model,
+   the 4-bit quantized text encoder (Qwen3-VL 4B), and the VAE into a
+   single safetensors file (~12 GB instead of 15.5 GB across 3 files).
+
+2. SVDQuant checkpoints (carrying low-rank factors) load with the
+   "Krea2 SVDQuant Checkpoint Loader" node. Branchless checkpoints
+   (--format w4a4 or int8) also load with stock CheckpointLoaderSimple.
+
+3. cfg MUST be 1.0. Krea 2 Turbo is cfg-distilled, so the negative
+   prompt is zeroed out (ConditioningZeroOut) rather than encoded.
+   8 steps with euler / simple scheduler is what the model was distilled for.
+
+4. 1024x1024 native resolution. Latent size MUST be multiples of 16."""
+
 BASE_NOTE = """KREA 2 BASE (non-turbo) - SVDQuant W4A4
 
 The loader node will be outlined in RED when you open this. That is
@@ -221,6 +255,68 @@ checkpoint, then reselect it in the loader.
    Same slow-generation checklist too: read the loader's status
    output first."""
 
+LORA_NOTE = """KREA 2 TURBO + LoRA - SVDQuant W4A4
+
+Same graph as the plain Turbo one, with LoRA loaders inserted between
+the checkpoint loader and the sampler.
+
+1. USE THIS NODE, NOT THE STOCK ONE. On a quantized checkpoint the
+   stock LoraLoaderModelOnly has to dequantize the 4-bit weight, add
+   the LoRA, and requantize it -- which throws away the format and
+   quantizes the LoRA delta to 4 bits along with it. This node
+   attaches the LoRA as a parallel branch instead:
+   (W + BA)x == Wx + B(Ax), so the quantized weight is never touched.
+
+2. CHECK THE CONSOLE. The node prints what it matched, e.g.
+     224 quantized layers, 32 normal layers
+   If it says 0 quantized layers, the LoRA does not target this model
+   and nothing will change. That line is the first thing to look at
+   when a LoRA "does nothing".
+
+3. STACKING. Chain more of these nodes, one per LoRA. The whole stack
+   is refolded each time, so strengths stay exact no matter how many
+   you chain, and the cost stays one pair of GEMMs. The second loader
+   here is bypassed (ctrl-B) -- unmute it to use it.
+
+4. RANK MATTERS HERE. Without a LoRA, branch ranks 64/128/256 measure
+   the same. With one, rank 256 wins clearly and rank 64 loses most of
+   its advantage. If you use LoRAs, download rank 256.
+
+5. adapters INPUT. Only affects LoKr / LoHa / OFT, which cannot fold
+   into the branch. "bypass" is exact and costs ~1.8s per model call
+   at 1440x1920; "bake" is free per-step but requantizes the delta.
+   A plain up/down LoRA ignores this setting entirely."""
+
+DIAG_NOTE = """KREA 2 SVDQUANT - DIAGNOSTICS
+
+Run this before reporting a bug, and before downloading 8 GB.
+Nothing here generates an image.
+
+ENV CHECK (left, no model needed)
+   Answers the single most common report: "the quantized checkpoint
+   is slower than fp8". Almost always the cause is that ComfyUI
+   disabled comfy_kitchen's CUDA backend because torch was built
+   against CUDA < 13, and the fallback dequantizes int4 in Python --
+   slower than bf16, not faster. Needs no model, so run it first.
+
+DIAGNOSTICS (right, needs a checkpoint) - the mode widget:
+   dispatch  which kernel actually runs. START HERE.
+   env       versions + memory accounting, including where the
+             low-rank factors currently live. Under lowvram they
+             should read cpu between steps, not cuda.
+   bench     quantized vs bf16 timing per layer.
+   profile   torch.profiler table.
+   compile   graph breaks a TorchCompileModel run would pay.
+
+   tokens = sequence length. 4096 is 1024x1024. Kernel selection is
+   shape-dependent, so match your real resolution.
+
+WHAT TO PASTE INTO AN ISSUE
+   Your GPU, the checkpoint filename, and the report output of both
+   nodes. Both are OUTPUT_NODEs, so the text shows in the node itself
+   and in the console. Neither is cached -- they re-measure the live
+   process every run, which is the point."""
+
 PROMPT = ("A cluttered antique clockmaker's workshop seen through a cracked magnifying "
           "glass, brass gears laid out in a spiral on the workbench, a ginger cat asleep "
           "on a stack of leather-bound books, warm afternoon light with visible dust "
@@ -296,6 +392,66 @@ def build_turbo():
     return g.serialize(groups), g.serialize_api()
 
 
+def build_all_in_one_turbo():
+    g = Graph()
+    g.note(ALL_IN_ONE_TURBO_NOTE, 0, 0, size=(400, 620), title="READ ME FIRST")
+
+    loader = g.add("Krea2SVDQuantCheckpointLoader", 1, 0,
+                   outputs=[("MODEL", "MODEL"), ("CLIP", "CLIP"), ("VAE", "VAE"), ("STRING", "STRING")],
+                   widgets=[("ckpt_name", "Krea2-Turbo-AllInOne-SVDQuant-W4A4-rank256-actaware-TEW4A4.safetensors")],
+                   title="Krea2 SVDQuant Checkpoint Loader", colour=TEAL, size=[400, 140])
+
+    pos = g.add("CLIPTextEncode", 2, 0, inputs=[("clip", "CLIP")],
+                outputs=[("CONDITIONING", "CONDITIONING")], widgets=[("text", PROMPT)],
+                title="Prompt", colour=GREEN, size=[400, 220])
+    neg = g.add("ConditioningZeroOut", 2, 1.4, inputs=[("conditioning", "CONDITIONING")],
+                outputs=[("CONDITIONING", "CONDITIONING")],
+                title="Negative (zeroed - required at cfg 1.0)", colour=GREEN,
+                size=[400, 60])
+    latent = g.add("EmptySD3LatentImage", 2, 2.2, outputs=[("LATENT", "LATENT")],
+                   widgets=[("width", 1024), ("height", 1024), ("batch_size", 1)],
+                   title="Latent 1024x1024", colour=GREEN,
+                   size=[400, 120])
+
+    sampler = g.add("KSampler", 3, 0,
+                    inputs=[("model", "MODEL"), ("positive", "CONDITIONING"),
+                            ("negative", "CONDITIONING"), ("latent_image", "LATENT")],
+                    outputs=[("LATENT", "LATENT")],
+                    widgets=[("seed", 987654321), (None, "randomize"), ("steps", 8), ("cfg", 1.0),
+                             ("sampler_name", "euler"), ("scheduler", "simple"),
+                             ("denoise", 1.0)],
+                    title="KSampler - 8 steps, cfg 1.0", colour=PURPLE, size=[400, 280])
+    decode = g.add("VAEDecode", 4, 0, inputs=[("samples", "LATENT"), ("vae", "VAE")],
+                   outputs=[("IMAGE", "IMAGE")], title="VAE Decode", colour=PURPLE,
+                   size=[300, 60])
+    save = g.add("SaveImage", 4, 0.7, inputs=[("images", "IMAGE")],
+                 widgets=[("filename_prefix", "krea2_turbo_aio_svdq")], title="Save", colour=PURPLE, size=[400, 300])
+
+    diag = g.add("Krea2SVDQuantDiagnostics", 3, 2.4, inputs=[("model", "MODEL")],
+                 outputs=[("MODEL", "MODEL"), ("STRING", "STRING")],
+                 widgets=[("mode", "dispatch"), ("tokens", 4096)],
+                 title="Diagnostics (optional - run if slow)", colour=YELLOW,
+                 size=[400, 130], api=False)
+
+    g.link(loader, "MODEL", sampler, "model")
+    g.link(loader, "CLIP", pos, "clip")
+    g.link(pos, "CONDITIONING", neg, "conditioning")
+    g.link(pos, "CONDITIONING", sampler, "positive")
+    g.link(neg, "CONDITIONING", sampler, "negative")
+    g.link(latent, "LATENT", sampler, "latent_image")
+    g.link(sampler, "LATENT", decode, "samples")
+    g.link(loader, "VAE", decode, "vae")
+    g.link(decode, "IMAGE", save, "images")
+    g.link(loader, "MODEL", diag, "model")
+
+    groups = [
+        g.group("Load All-in-One", (500, 20, 420, 280)),
+        g.group("Prompt", (940, 20, 420, 620)),
+        g.group("Sample", (1360, 20, 420, 640), colour="#8a4"),
+    ]
+    return g.serialize(groups), g.serialize_api()
+
+
 def build_base():
     g = Graph()
     g.note(BASE_NOTE, 0, 0, size=(400, 560), title="READ ME FIRST")
@@ -356,6 +512,399 @@ def build_base():
     return g.serialize(groups), g.serialize_api()
 
 
+def build_lora():
+    """The Turbo graph with two LoRA loaders spliced in, the second one muted.
+
+    Two rather than one because stacking is the question people actually ask, and a muted
+    second node shows the answer (chain them) without changing what the graph does on first
+    run.
+    """
+    g = Graph()
+    g.note(LORA_NOTE, 0, 0, size=(400, 720), title="READ ME FIRST")
+
+    loader = g.add("Krea2SVDQuantW4A4Loader", 1, 0,
+                   outputs=[("MODEL", "MODEL"), ("STRING", "STRING")],
+                   widgets=[("model_name", "Krea2-Turbo-SVDQuant-W4A4-rank256.safetensors")],
+                   title="Krea2 SVDQuant W4A4 Loader (rank 256 for LoRAs)", colour=TEAL,
+                   size=[400, 120])
+    clip = g.add("CLIPLoader", 1, 1, outputs=[("CLIP", "CLIP")],
+                 widgets=[("clip_name", "qwen3vl_4b_fp8_scaled.safetensors"), ("type", "krea2"),
+                          ("device", "default")],
+                 title="Text encoder (Qwen3-VL 4B)", colour=TEAL, size=[400, 120])
+    vae = g.add("VAELoader", 1, 2, outputs=[("VAE", "VAE")],
+                widgets=[("vae_name", "qwen_image_vae.safetensors")], title="VAE", colour=TEAL,
+                size=[400, 80])
+
+    lora1 = g.add("Krea2SVDQuantLoraLoader", 2, 0, inputs=[("model", "MODEL")],
+                  outputs=[("model", "MODEL")],
+                  widgets=[("lora_name", "your_krea2_lora.safetensors"), ("strength", 1.0),
+                           ("adapters", ADAPTER_BYPASS)],
+                  title="Krea2 SVDQuant LoRA Loader", colour=ORANGE, size=[400, 140])
+    lora2 = g.add("Krea2SVDQuantLoraLoader", 2, 1, inputs=[("model", "MODEL")],
+                  outputs=[("model", "MODEL")],
+                  widgets=[("lora_name", "your_krea2_lora.safetensors"), ("strength", 0.6),
+                           ("adapters", ADAPTER_BYPASS)],
+                  title="Second LoRA (muted - ctrl-B to enable)", colour=ORANGE,
+                  size=[400, 140], mode=4, api=False)
+
+    pos = g.add("CLIPTextEncode", 3, 0, inputs=[("clip", "CLIP")],
+                outputs=[("CONDITIONING", "CONDITIONING")], widgets=[("text", PROMPT)],
+                title="Prompt (add your LoRA trigger words)", colour=GREEN, size=[400, 220])
+    neg = g.add("ConditioningZeroOut", 3, 1.4, inputs=[("conditioning", "CONDITIONING")],
+                outputs=[("CONDITIONING", "CONDITIONING")],
+                title="Negative (zeroed - required at cfg 1.0)", colour=GREEN, size=[400, 60])
+    latent = g.add("EmptySD3LatentImage", 3, 2.2, outputs=[("LATENT", "LATENT")],
+                   widgets=[("width", 1024), ("height", 1024), ("batch_size", 1)],
+                   title="Latent 1024x1024", colour=GREEN, size=[400, 120])
+
+    sampler = g.add("KSampler", 4, 0,
+                    inputs=[("model", "MODEL"), ("positive", "CONDITIONING"),
+                            ("negative", "CONDITIONING"), ("latent_image", "LATENT")],
+                    outputs=[("LATENT", "LATENT")],
+                    widgets=[("seed", 987654321), (None, "randomize"), ("steps", 8), ("cfg", 1.0),
+                             ("sampler_name", "euler"), ("scheduler", "simple"), ("denoise", 1.0)],
+                    title="KSampler - 8 steps, cfg 1.0", colour=PURPLE, size=[400, 280])
+    decode = g.add("VAEDecode", 5, 0, inputs=[("samples", "LATENT"), ("vae", "VAE")],
+                   outputs=[("IMAGE", "IMAGE")], title="VAE Decode", colour=PURPLE, size=[300, 60])
+    save = g.add("SaveImage", 5, 0.7, inputs=[("images", "IMAGE")],
+                 widgets=[("filename_prefix", "krea2_turbo_lora")], title="Save", colour=PURPLE,
+                 size=[400, 300])
+
+    g.link(loader, "MODEL", lora1, "model")
+    g.link(lora1, "model", lora2, "model")
+    g.link(lora1, "model", sampler, "model")
+    g.link(clip, "CLIP", pos, "clip")
+    g.link(pos, "CONDITIONING", neg, "conditioning")
+    g.link(pos, "CONDITIONING", sampler, "positive")
+    g.link(neg, "CONDITIONING", sampler, "negative")
+    g.link(latent, "LATENT", sampler, "latent_image")
+    g.link(sampler, "LATENT", decode, "samples")
+    g.link(vae, "VAE", decode, "vae")
+    g.link(decode, "IMAGE", save, "images")
+
+    groups = [
+        g.group("Load", (500, 20, 420, 620)),
+        g.group("LoRA - chain one node per LoRA", (940, 20, 420, 420), colour="#a85"),
+        g.group("Prompt", (1360, 20, 420, 620)),
+        g.group("Sample", (1780, 20, 420, 640), colour="#8a4"),
+    ]
+    return g.serialize(groups), g.serialize_api()
+
+
+def build_diagnostics():
+    """Env Check + Diagnostics. No sampler: nothing here generates an image."""
+    g = Graph()
+    g.note(DIAG_NOTE, 0, 0, size=(430, 700), title="READ ME FIRST")
+
+    env = g.add("Krea2SVDQuantEnvCheck", 1, 0, outputs=[("report", "STRING")],
+                title="1. Env Check - no model needed, run this first", colour=YELLOW,
+                size=[400, 80])
+    env_view = g.add("PreviewAny", 1, 0.6, inputs=[("source", "*")],
+                     title="Env Check report", colour=YELLOW, size=[400, 300])
+
+    loader = g.add("Krea2SVDQuantW4A4Loader", 2, 0,
+                   outputs=[("MODEL", "MODEL"), ("STRING", "STRING")],
+                   widgets=[("model_name", "Krea2-Turbo-SVDQuant-W4A4-rank256-actaware.safetensors")],
+                   title="2. Load the checkpoint you are diagnosing", colour=TEAL,
+                   size=[400, 120])
+    loader_view = g.add("PreviewAny", 2, 0.7, inputs=[("source", "*")],
+                        title="Loader status - names the kernel that will run", colour=TEAL,
+                        size=[400, 200])
+
+    diag = g.add("Krea2SVDQuantDiagnostics", 3, 0, inputs=[("model", "MODEL")],
+                 outputs=[("model", "MODEL"), ("report", "STRING")],
+                 widgets=[("mode", "dispatch"), ("tokens", 4096)],
+                 title="3. Diagnostics - start with mode=dispatch", colour=YELLOW,
+                 size=[400, 130])
+    diag_view = g.add("PreviewAny", 3, 0.8, inputs=[("source", "*")],
+                      title="Diagnostics report - paste this into an issue", colour=YELLOW,
+                      size=[400, 400])
+
+    g.link(env, "report", env_view, "source")
+    g.link(loader, "STRING", loader_view, "source")
+    g.link(loader, "MODEL", diag, "model")
+    g.link(diag, "report", diag_view, "source")
+
+    groups = [
+        g.group("Step 1 - does the int4 kernel exist at all?", (500, 20, 420, 480),
+                colour="#a85"),
+        g.group("Step 2 - load it", (940, 20, 420, 480)),
+        g.group("Step 3 - what actually runs", (1360, 20, 420, 620), colour="#8a4"),
+    ]
+    return g.serialize(groups), g.serialize_api()
+
+
+def _check_adapter_constant():
+    """The `adapters` widget value must match svdquant_lora.ADAPTER_BYPASS exactly.
+
+    ComfyUI matches combo widgets by string. A drifted copy here would write a workflow whose
+    dropdown silently falls back to the first option, so read it out of the source rather than
+    trusting that two literals stayed equal.
+    """
+    src = os.path.join(os.path.dirname(HERE), "svdquant_lora.py")
+    with open(src, encoding="utf-8") as fh:
+        for line in fh:
+            if line.startswith("ADAPTER_BYPASS"):
+                actual = line.split("=", 1)[1].strip().strip('"')
+                if actual != ADAPTER_BYPASS:
+                    raise SystemExit(
+                        "ADAPTER_BYPASS drifted: svdquant_lora.py has {!r}, this script has "
+                        "{!r}".format(actual, ADAPTER_BYPASS))
+                return
+    raise SystemExit("could not find ADAPTER_BYPASS in " + src)
+
+
+QUANTIZE_NOTE = """MAKE YOUR OWN QUANTIZED CHECKPOINT - no terminal needed
+
+This graph is the whole quantizer. Set the widgets, press Queue,
+wait. It does exactly what `python quantize_krea2.py` does (same
+function, not a copy), and writes the result next to the source in
+ComfyUI/models/diffusion_models/.
+
+BEFORE YOU START
+- You need the BF16 Krea 2 checkpoint (~24 GB) in
+  ComfyUI/models/diffusion_models/. FP8 also works as a source; any
+  other already-quantized file does not.
+- ~12 GB free on that drive. The output is ~8 GB.
+- Run the Env Check node first (it needs nothing wired). If it says
+  the cuda backend is not live, the file you are about to build will
+  run SLOWER than fp8 - fix torch before spending the disk.
+
+WHICH FORMAT
+  svdq  4-bit + a low-rank bf16 correction branch. Best quality of
+        the 4-bit options. Loads with the Krea2 SVDQuant W4A4 Loader.
+  w4a4  same without the branch. Smaller, ~9% faster per step.
+  int8  most faithful, still ~2x fp8 on Ampere. Stock UNETLoader.
+  fp8   storage only, no speedup here.
+  w4a4 / int8 / fp8 ignore rank, rank_alloc and refine_iters.
+
+WHICH RANK (svdq only)
+  No LoRA planned -> 64. 128 and 256 measured the same.
+  LoRAs planned  -> 256. It wins clearly there; 64 loses most of
+                    its advantage once a LoRA is patched in.
+  Keep refine_iters at 100. At 0 the split is single-shot (~54s
+  instead of ~5.7min) and raising rank then buys nothing.
+
+WHAT TO EXPECT WHILE IT RUNS
+- The queue is BLOCKED. Nothing else generates. 54s to ~6 min.
+- Every loaded model is unloaded first, so your next generation
+  pays a reload. This is deliberate: the dequantize step needs the
+  card to itself or it OOMs.
+- overwrite is off on purpose. An existing file of the same name is
+  an error, not 8 GB written over last night's run.
+
+The summary appears on the node when it finishes, and says which
+loader to use and what sampler settings that variant wants.
+
+FREE QUALITY: FILL IN act_stats (svdq only)
+Download the calibration file for your variant from
+huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI/tree/main/calibration
+into ComfyUI/output/, then type its name into act_stats:
+
+  Turbo -> krea2_act_stats_turbo.safetensors
+  base  -> krea2_act_stats_base.safetensors
+
+6.67 MB each. They fit the low-rank branch against activations
+measured from a real sampling pass instead of assuming every input
+channel matters equally. LPIPS to BF16 0.3378 -> 0.2825 at rank 64.
+Same rank, same file size, same kernel, same speed. There is no
+reason to skip this.
+
+Take the file that matches the model you are quantizing. A mismatch
+is caught before any GPU work only if the layer NAMES differ, and
+Turbo and base share their names - so the check will not save you
+from feeding Turbo's statistics to a base build. Read the filename.
+
+If you are quantizing a finetune, a merge, or anything these two
+files do not describe, capture your own:
+workflows/krea2_quantize_calibrated.json does the capture and the
+quantize in one Queue press."""
+
+CALIB_NOTE = """CALIBRATED QUANTIZE - measure your own activations
+
+YOU PROBABLY DO NOT NEED THIS GRAPH.
+Calibration files for stock Krea 2 Turbo and base are published at
+huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI/tree/main/calibration
+- 6.67 MB each. Download the one matching your variant, drop it in
+ComfyUI/output/, name it in the act_stats box of the plain
+krea2_quantize.json graph, and you get the identical quality lever
+without running a sampling pass.
+
+This graph is for the case those files do not cover: a finetune, a
+merge, a model whose weights are not the released ones. Activation
+statistics describe the WEIGHTS they were captured from. Same
+architecture is not the same model - Turbo's file loads cleanly into
+a base build and quietly describes the wrong thing.
+
+WHAT IT BUYS
+The low-rank branch is fitted against activations measured from a
+real sampling pass instead of assuming every input channel matters
+equally. Measured, no LoRA, rank 64: LPIPS to BF16 0.3378 -> 0.2825.
+Same rank, same file size, same kernel, same speed.
+
+WHAT RUNS, IN ORDER
+1. The BF16 model is loaded with the stock UNETLoader and sampled
+   once. Capture Start hooks every layer that will be quantized and
+   records the RMS of its inputs; Capture Save writes them out.
+2. Capture Save's act_stats_path feeds the Quantize node. That wire
+   is not cosmetic - it is what stops ComfyUI running the quantizer
+   first, which would silently produce an uncalibrated file.
+
+So one Queue press does calibration AND quantization. Expect the
+sampling pass plus 54s-6min of quantizing, with the queue blocked.
+
+SET THIS BEFORE YOU RUN
+- UNETLoader: the BF16 checkpoint. Statistics from an already
+  quantized model describe the wrong thing.
+- Quantize node: the SAME file as source_model. It is a separate
+  dropdown, and no, it cannot be wired - the loader hands over a
+  MODEL object, not a filename.
+- variant: turbo or base, so the output gets the right name.
+- KSampler: 20 steps / cfg 3.5 suits base. For Turbo use 8 steps
+  and cfg 1.0, and swap the negative prompt for ConditioningZeroOut.
+
+CALIBRATING ON SEVERAL PROMPTS (better, optional)
+The defaults calibrate on one prompt, which is enough to beat no
+calibration. To use more: set keep_capturing = true on Capture Save,
+mute the Quantize node (select it, Ctrl+M), queue as many prompts as
+you like with reset = false on Capture Start after the first, then
+unmute Quantize and queue once more. Prompts should look like what
+you actually generate.
+
+Only svdq uses act_stats. The other formats have no branch to fit,
+and wiring act_stats into them is an error rather than a no-op."""
+
+
+def build_quantize():
+    g = Graph()
+    g.note(QUANTIZE_NOTE, 0, 0, size=(460, 1360), title="READ ME FIRST")
+
+    g.add("Krea2SVDQuantEnvCheck", 1, 0, outputs=[("report", "STRING")],
+          title="1. Env Check - run this first, it needs nothing", colour=YELLOW,
+          size=[420, 120])
+    g.add("Krea2SVDQuantQuantize", 1, 0.9,
+                  outputs=[("summary", "STRING")],
+                  widgets=[("source_model", "krea2_bf16.safetensors"), ("format", "svdq"),
+                           ("rank", 64), ("rank_alloc", "uniform"), ("refine_iters", 100),
+                           ("groupsize", 256), ("variant", "turbo"), ("output_name", ""),
+                           ("overwrite", False), ("act_stats", ""), ("seed", 0)],
+          title="2. Quantize - set source_model and act_stats, then Queue", colour=TEAL,
+          size=[420, 460])
+
+    groups = [g.group("Quantize", (500, 20, 460, 640), colour="#8a4")]
+    return g.serialize(groups), g.serialize_api()
+
+
+def build_quantize_all_in_one():
+    g = Graph()
+    note = """QUANTIZE ALL-IN-ONE - Bake DiT + Text Encoder + VAE
+
+This graph bakes three files into one unified checkpoint in models/checkpoints/:
+1. source_dit (in models/diffusion_models/): BF16 or already quantized.
+2. text_encoder (in models/text_encoders/): Qwen3-VL 4B BF16 (~8.88 GB -> ~3.2 GB W4A4).
+3. vae (in models/vae/): Krea2 VAE (~0.51 GB unquantized).
+
+Resulting file: ~12 GB in models/checkpoints/, loaded with Krea2 SVDQuant Checkpoint Loader."""
+    g.note(note, 0, 0, size=(460, 600), title="READ ME FIRST")
+
+    g.add("Krea2SVDQuantEnvCheck", 1, 0, outputs=[("report", "STRING")],
+          title="1. Env Check - verify CUDA kernel", colour=YELLOW,
+          size=[420, 120])
+    g.add("Krea2SVDQuantQuantizeAllInOne", 1, 0.9,
+          outputs=[("summary", "STRING")],
+          widgets=[("source_dit", "turbo.safetensors"),
+                   ("text_encoder", "qwen3vl_4b_bf16.safetensors"),
+                   ("vae", "Krea2-HD-vae.safetensors"),
+                   ("format", "svdq"),
+                   ("te_format", "w4a4"),
+                   ("rank", 64),
+                   ("refine_iters", 100),
+                   ("groupsize", 256),
+                   ("variant", "turbo"),
+                   ("output_name", ""),
+                   ("overwrite", False),
+                   ("act_stats", "krea2_act_stats_turbo.safetensors"),
+                   ("seed", 0)],
+          title="2. Quantize & Bake All-in-One Checkpoint", colour=TEAL,
+          size=[420, 520])
+
+    groups = [g.group("All-in-One Baker", (500, 20, 460, 700), colour="#8a4")]
+    return g.serialize(groups), g.serialize_api()
+
+
+def build_quantize_calibrated():
+    g = Graph()
+    g.note(CALIB_NOTE, 0, 0, size=(460, 1420), title="READ ME FIRST")
+
+    unet = g.add("UNETLoader", 1, 0, outputs=[("MODEL", "MODEL")],
+                 widgets=[("unet_name", "krea2_bf16.safetensors"),
+                          ("weight_dtype", "default")],
+                 title="BF16 source (stock loader)", colour=TEAL, size=[400, 120])
+    clip = g.add("CLIPLoader", 1, 1, outputs=[("CLIP", "CLIP")],
+                 widgets=[("clip_name", "qwen3vl_4b_fp8_scaled.safetensors"), ("type", "krea2"),
+                          ("device", "default")],
+                 title="Text encoder (Qwen3-VL 4B)", colour=TEAL, size=[400, 120])
+
+    start = g.add("Krea2SVDQuantCaptureStart", 2, 0, inputs=[("model", "MODEL")],
+                  outputs=[("model", "MODEL"), ("status", "STRING")],
+                  widgets=[("reset", True)],
+                  title="Capture Start - before the sampler", colour=GREEN, size=[400, 100])
+    pos = g.add("CLIPTextEncode", 2, 0.8, inputs=[("clip", "CLIP")],
+                outputs=[("CONDITIONING", "CONDITIONING")], widgets=[("text", PROMPT)],
+                title="Calibration prompt", colour=GREEN, size=[400, 200])
+    neg = g.add("CLIPTextEncode", 2, 2.0, inputs=[("clip", "CLIP")],
+                outputs=[("CONDITIONING", "CONDITIONING")], widgets=[("text", NEGATIVE)],
+                title="Negative (Turbo: replace with ConditioningZeroOut)", colour=GREEN,
+                size=[400, 140])
+    latent = g.add("EmptySD3LatentImage", 2, 3.0, outputs=[("LATENT", "LATENT")],
+                   widgets=[("width", 1024), ("height", 1024), ("batch_size", 1)],
+                   title="Latent 1024x1024", colour=GREEN, size=[400, 120])
+
+    sampler = g.add("KSampler", 3, 0,
+                    inputs=[("model", "MODEL"), ("positive", "CONDITIONING"),
+                            ("negative", "CONDITIONING"), ("latent_image", "LATENT")],
+                    outputs=[("LATENT", "LATENT")],
+                    widgets=[("seed", 987654321), (None, "randomize"), ("steps", 20),
+                             ("cfg", 3.5), ("sampler_name", "euler"), ("scheduler", "simple"),
+                             ("denoise", 1.0)],
+                    title="Calibration pass - base 20/3.5, Turbo 8/1.0", colour=PURPLE,
+                    size=[400, 280])
+
+    save = g.add("Krea2SVDQuantCaptureSave", 4, 0, inputs=[("latent", "LATENT")],
+                 outputs=[("latent", "LATENT"), ("status", "STRING"),
+                          ("act_stats_path", "STRING")],
+                 widgets=[("filename", "krea2_act_stats.safetensors"),
+                          ("keep_capturing", False)],
+                 title="Capture Save - after the sampler", colour=GREEN, size=[400, 120])
+
+    quant = g.add("Krea2SVDQuantQuantize", 5, 0,
+                  inputs=[("act_stats", "STRING")],
+                  outputs=[("summary", "STRING")],
+                  widgets=[("source_model", "krea2_bf16.safetensors"), ("format", "svdq"),
+                           ("rank", 64), ("rank_alloc", "uniform"), ("refine_iters", 100),
+                           ("groupsize", 256), ("variant", "turbo"), ("output_name", ""),
+                           ("overwrite", False), ("act_stats", ""), ("seed", 0)],
+                  title="Quantize - source_model must match the loader above", colour=TEAL,
+                  size=[420, 440], widget_inputs=("act_stats",))
+
+    g.link(unet, "MODEL", start, "model")
+    g.link(start, "model", sampler, "model")
+    g.link(clip, "CLIP", pos, "clip")
+    g.link(clip, "CLIP", neg, "clip")
+    g.link(pos, "CONDITIONING", sampler, "positive")
+    g.link(neg, "CONDITIONING", sampler, "negative")
+    g.link(latent, "LATENT", sampler, "latent_image")
+    g.link(sampler, "LATENT", save, "latent")
+    g.link(save, "act_stats_path", quant, "act_stats")
+
+    groups = [
+        g.group("Load BF16", (500, 20, 420, 420)),
+        g.group("Calibration pass", (940, 20, 420, 800)),
+        g.group("Quantize", (2200, 20, 460, 520), colour="#8a4"),
+    ]
+    return g.serialize(groups), g.serialize_api()
+
+
 def _write(path, payload):
     with open(path, "w", encoding="utf-8", newline="\n") as fh:
         json.dump(payload, fh, indent=2, ensure_ascii=False)
@@ -363,9 +912,16 @@ def _write(path, payload):
 
 
 def main():
+    _check_adapter_constant()
     os.makedirs(OUT_DIR, exist_ok=True)
     for name, build in (("krea2_turbo_svdquant_w4a4_t2i", build_turbo),
-                        ("krea2_base_svdquant_w4a4_t2i", build_base)):
+                        ("krea2_turbo_all_in_one_t2i", build_all_in_one_turbo),
+                        ("krea2_base_svdquant_w4a4_t2i", build_base),
+                        ("krea2_turbo_svdquant_w4a4_lora", build_lora),
+                        ("krea2_svdquant_diagnostics", build_diagnostics),
+                        ("krea2_quantize", build_quantize),
+                        ("krea2_quantize_all_in_one", build_quantize_all_in_one),
+                        ("krea2_quantize_calibrated", build_quantize_calibrated)):
         graph, api = build()
         ui_path = os.path.join(OUT_DIR, name + ".json")
         api_path = os.path.join(OUT_DIR, name + "_api.json")

workflows/README.md

@@ -0,0 +1,209 @@
+Eight graphs. Drag the plain `.json` into the ComfyUI canvas — each opens with a **READ ME
+FIRST** note carrying the settings that matter. The `*_api.json` twins are for POSTing to
+`/prompt` from a script; they carry no layout, so don't drag those in.
+
+| file | what it's for |
+|---|---|
+| `krea2_svdquant_diagnostics.json` | **Start here if anything is wrong.** No sampler, generates no image |
+| `krea2_turbo_svdquant_w4a4_t2i.json` | Krea 2 **Turbo**, 8 steps, cfg 1.0 (3 separate files) |
+| `krea2_turbo_all_in_one_t2i.json` | Krea 2 **Turbo All-in-One**, 8 steps, cfg 1.0 (single ~12 GB checkpoint) |
+| `krea2_turbo_svdquant_w4a4_lora.json` | Turbo **with LoRAs**, chained through this repo's LoRA node |
+| `krea2_base_svdquant_w4a4_t2i.json` | Krea 2 **base** (non-turbo), 50 steps, cfg 3.5 |
+| `krea2_quantize.json` | **Build your own quantized DiT checkpoint** from a BF16 one, no terminal |
+| `krea2_quantize_all_in_one.json` | **Build your own All-in-One checkpoint** (DiT + 4-bit TE + VAE), no terminal |
+| `krea2_quantize_calibrated.json` | The same, preceded by an activation-calibration pass |
+
+Everything under `workflows/` is generated by [`tools/build_workflows.py`](../tools/build_workflows.py).
+Edit that script, not the JSON.
+
+## What every graph needs
+
+For standard workflows, three files:
+
+1. **A checkpoint** in `ComfyUI/models/diffusion_models/`, from
+   [Hugging Face](https://huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI).
+2. **Text encoder** `qwen3vl_4b_fp8_scaled.safetensors` in `ComfyUI/models/text_encoders/`,
+   loaded with `CLIPLoader` type `krea2`.
+3. **VAE** `qwen_image_vae.safetensors` in `ComfyUI/models/vae/`.
+
+For **All-in-One** checkpoints, only **1 file** in `ComfyUI/models/checkpoints/`:
+- Combines the quantized DiT, 4-bit quantized text encoder (Qwen3-VL 4B), and VAE into one ~12 GB file.
+
+**Which loader node** depends on which checkpoint you downloaded:
+
+| checkpoint | loader node |
+|---|---|
+| `Krea2-Turbo-W4A4-noLowRank` | the **stock UNETLoader** |
+| any `SVDQuant-W4A4-rank*` | **Krea2 SVDQuant W4A4 Loader** (this repo) |
+| All-in-One `SVDQuant-*-AllInOne-*` | **Krea2 SVDQuant Checkpoint Loader** (this repo) |
+| All-in-One branchless (`W4A4` / `INT8`) | **CheckpointLoaderSimple** (stock) or **Krea2 SVDQuant Checkpoint Loader** |
+
+The `svdq` files carry extra `*.svdq_l1` / `*.svdq_l2` tensors that the stock loader does not
+know about, which is why they need their own node.
+
+A **red outline** on a loader means ComfyUI cannot find the filename in the dropdown — the
+graph ships a suggested name, and yours may differ. Click the widget and pick your file.
+
+## Diagnostics — run this before reporting anything
+
+`krea2_svdquant_diagnostics.json`. Three steps, left to right, and the first one needs no
+model at all so you can run it *before* downloading 8 GB.
+
+**1. Env Check.** Answers the single most common report against this pack: *"the quantized
+checkpoint is slower than fp8"*. Almost always the cause is that ComfyUI disabled
+`comfy_kitchen`'s CUDA backend because torch was built against CUDA < 13 — and the fallback
+dequantizes int4 in Python, so the checkpoint ends up slower than bf16, not faster. You want
+to see:
+
+```
+cuda backend is live -- the int4 tensor-core kernel is available.
+```
+
+If you don't, install a **cu130 (CUDA 13) or newer** PyTorch build. Nothing else in this repo
+will behave until that line is green.
+
+**2. Load the checkpoint** you're diagnosing. Its `status` output names the kernel that will
+actually run.
+
+**3. Diagnostics**, `mode` widget:
+
+| mode | what it tells you |
+|---|---|
+| `dispatch` | which kernel actually runs, per weight shape. **Start here** |
+| `env` | versions and memory accounting, including where the low-rank factors currently live — under lowvram they should read `cpu` between steps, not `cuda` |
+| `bench` | quantized vs bf16 timing per layer |
+| `profile` | a `torch.profiler` table |
+| `compile` | graph breaks a `TorchCompileModel` run would pay |
+
+`tokens` is the sequence length to probe with — 4096 is 1024x1024. Kernel selection is
+shape-dependent, so match your real resolution.
+
+Neither node is cached: they re-measure the live process every run, which is the entire
+point. **Paste both reports, your GPU, and the checkpoint filename into any bug report.**
+
+## LoRAs
+
+`krea2_turbo_svdquant_w4a4_lora.json`.
+
+**Use Krea2 SVDQuant LoRA Loader, not the stock `LoraLoaderModelOnly`.** On a quantized
+checkpoint the stock loader has to dequantize the 4-bit weight, add the LoRA, and requantize
+it — which discards the format and quantizes the LoRA delta to 4 bits along with it. This
+node attaches the LoRA as a parallel branch instead: `(W + BA)x == Wx + B(Ax)` is exact for a
+linear layer, and the quantized weight is never touched.
+
+**If a LoRA seems to do nothing, read the console.** The node prints what it matched:
+
+```
+224 quantized layers, 32 normal layers
+```
+
+`0 quantized layers` means the LoRA does not target this model, and nothing will change no
+matter what strength you set. That line is the first thing to check.
+
+**Stacking.** Chain one node per LoRA — the shipped graph has a second one muted, press
+`ctrl-B` on it to enable. The whole stack is refolded on each node, so strengths stay exact
+however many you chain, and the runtime cost stays one pair of GEMMs rather than one per LoRA.
+
+**Download rank 256 if you use LoRAs.** Without a LoRA, branch ranks 64 / 128 / 256 are
+statistically indistinguishable. With one, rank 256 wins clearly and rank 64 loses most of its
+advantage over having no branch at all — measured over 16 prompts x 2 seeds x 4 adapters in
+[BENCHMARKS.md](../BENCHMARKS.md#test-3--paired-lpips-fidelity-with-and-without-a-lora).
+
+**The `adapters` input** only affects LoRAs that cannot fold into the branch — LoKr, LoHa,
+OFT. A plain up/down LoRA ignores it.
+
+| value | cost | what happens |
+|---|---|---|
+| `bypass` (default) | ~1.8 s per model call at 1440x1920 | exact; the 4-bit weight is never touched |
+| `bake` | none per step | ComfyUI rewrites the weight once and the adapter delta is quantized to 4 bits with it |
+
+## Building your own checkpoint
+
+`krea2_quantize.json` is the whole quantizer as a graph: point `source_model` at a BF16 Krea 2
+checkpoint, pick a format and a rank, press Queue. It calls the same `convert()` function
+`quantize_krea2.py` does, so there is one quantizer and not two that drift.
+
+It blocks the queue for the whole run (54 s to ~6 min), unloads any resident model to take the
+GPU, and writes ~8 GB. `overwrite` is off by default, so an existing file of the same name is
+an error rather than 8 GB written over your last run.
+
+**Fill in `act_stats`.** It is the largest fidelity gain in this repo that costs nothing at
+runtime — same rank, same file size, same kernel, same speed — and for the released weights you
+do not have to measure anything. Download the file for your variant from
+[`calibration/`](https://huggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI/tree/main/calibration)
+(6.67 MB) into `ComfyUI/output/` and type its name:
+
+| you are quantizing | act_stats file |
+|---|---|
+| stock Krea 2 **Turbo** | `krea2_act_stats_turbo.safetensors` |
+| stock Krea 2 **base** | `krea2_act_stats_base.safetensors` |
+| a finetune, a merge, anything else | capture your own — see below |
+
+`krea2_act_stats_turbo_lora_bloomgirls.safetensors` is also published. Do **not** reach for it because you use
+LoRAs: it is the capture from the `bloomgirls` arm of
+[Test 5](../BENCHMARKS.md), kept so that experiment is reproducible. Calibrating with an
+adapter loaded measured marginally *worse* than calibrating without one, and the recommendation
+is the plain file whether or not you load LoRAs.
+
+## Capturing your own activation statistics
+
+Only needed for weights the published files do not describe — a finetune, a merge, a model
+whose weights are not the released ones. Activation statistics describe the **weights** they
+were captured from, and sharing an architecture is not enough: Turbo's file loads into a base
+build without a word of complaint and then describes the wrong model. The coverage check that
+runs before quantizing matches on layer *names*, which Turbo and base share, so it cannot catch
+that for you.
+
+`krea2_quantize_calibrated.json` does it in one Queue press:
+
+```
+UNETLoader (BF16) → Capture Start → KSampler → Capture Save → Quantize
+```
+
+* **Capture Start** goes *before* the sampler. It hooks all 224 linears that will be quantized
+  and records the RMS of their inputs. Feed it the **BF16** model — statistics taken from an
+  already-quantized model describe the thing being corrected.
+* **Capture Save** goes *after* the sampler. It takes the sampler's `LATENT`, which is what
+  forces it to run after denoising rather than before it; if it is not downstream of the
+  sampler, ComfyUI is free to execute it first and you get an empty capture.
+* Its **`act_stats_path`** output feeds the Quantize node. That wire is not cosmetic — it is
+  what stops ComfyUI quantizing before the calibration pass has run and handing back an
+  uncalibrated file with no warning.
+* Set the Quantize node's `source_model` to the **same file** the UNETLoader has. It is a
+  separate dropdown and cannot be wired: the loader hands over a MODEL object, not a filename.
+
+**Calibrating on several prompts** (better, and what the published files did — 8 prompts each):
+
+1. Set `keep_capturing` = true on Capture Save.
+2. Mute the Quantize node (select it, Ctrl+M).
+3. Queue your first prompt with `reset` = true on Capture Start.
+4. Queue more prompts with `reset` = **false**. Use prompts that look like what you actually
+   generate, and *not* the ones you plan to judge the checkpoint with.
+5. Unmute Quantize, set `keep_capturing` = false, queue once more.
+
+Watch the Capture Save status: a clean run ends with every layer on the same token count (ours
+was 264200/264200 across 224 layers). A spread means the hooks stayed live through something
+other than your calibration run — usually a graph that errored between Start and Save — and the
+statistics now describe more than you meant. Re-run with `reset` = true.
+
+**One LoRA at a time is not a thing to calibrate for.** The statistics are per model, not per
+LoRA: capture from the BF16 weights you are about to quantize, with no adapter loaded, and use
+the result for every LoRA you later run on top of it. That is not a shortcut — it measured
+better than capturing with the adapter loaded.
+
+## Turbo vs base
+
+**Turbo** is cfg-distilled: `cfg` **must** be 1.0 and the negative prompt is zeroed
+(`ConditioningZeroOut`) rather than encoded. Raising cfg degrades the image, it does not
+sharpen it. 8 steps is what the checkpoint was distilled for.
+
+**Base** is not distilled, so it uses real classifier-free guidance — cfg 3.5, a real negative
+prompt through a second `CLIPTextEncode`, ~50 steps. There is no pre-built base checkpoint to
+download; build one:
+
+```bash
+python quantize_krea2.py raw.safetensors --format svdq --rank 256 --variant base
+```
+
+That is roughly 12x the sampling work of the 8-step Turbo graph. Every benchmark number in
+the README is Turbo at 8 steps — the ratios carry over, the absolute seconds do not.

workflows/krea2_quantize.json

@@ -0,0 +1,126 @@
+{
+  "id": "00000000-0000-4000-8000-000000000000",
+  "revision": 0,
+  "last_node_id": 3,
+  "last_link_id": 0,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Note",
+      "pos": [
+        60,
+        60
+      ],
+      "size": [
+        460,
+        1360
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "MAKE YOUR OWN QUANTIZED CHECKPOINT - no terminal needed\n\nThis graph is the whole quantizer. Set the widgets, press Queue,\nwait. It does exactly what `python quantize_krea2.py` does (same\nfunction, not a copy), and writes the result next to the source in\nComfyUI/models/diffusion_models/.\n\nBEFORE YOU START\n- You need the BF16 Krea 2 checkpoint (~24 GB) in\n  ComfyUI/models/diffusion_models/. FP8 also works as a source; any\n  other already-quantized file does not.\n- ~12 GB free on that drive. The output is ~8 GB.\n- Run the Env Check node first (it needs nothing wired). If it says\n  the cuda backend is not live, the file you are about to build will\n  run SLOWER than fp8 - fix torch before spending the disk.\n\nWHICH FORMAT\n  svdq  4-bit + a low-rank bf16 correction branch. Best quality of\n        the 4-bit options. Loads with the Krea2 SVDQuant W4A4 Loader.\n  w4a4  same without the branch. Smaller, ~9% faster per step.\n  int8  most faithful, still ~2x fp8 on Ampere. Stock UNETLoader.\n  fp8   storage only, no speedup here.\n  w4a4 / int8 / fp8 ignore rank, rank_alloc and refine_iters.\n\nWHICH RANK (svdq only)\n  No LoRA planned -> 64. 128 and 256 measured the same.\n  LoRAs planned  -> 256. It wins clearly there; 64 loses most of\n                    its advantage once a LoRA is patched in.\n  Keep refine_iters at 100. At 0 the split is single-shot (~54s\n  instead of ~5.7min) and raising rank then buys nothing.\n\nWHAT TO EXPECT WHILE IT RUNS\n- The queue is BLOCKED. Nothing else generates. 54s to ~6 min.\n- Every loaded model is unloaded first, so your next generation\n  pays a reload. This is deliberate: the dequantize step needs the\n  card to itself or it OOMs.\n- overwrite is off on purpose. An existing file of the same name is\n  an error, not 8 GB written over last night's run.\n\nThe summary appears on the node when it finishes, and says which\nloader to use and what sampler settings that variant wants.\n\nFREE QUALITY: FILL IN act_stats (svdq only)\nDownload the calibration file for your variant from\nhuggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI/tree/main/calibration\ninto ComfyUI/output/, then type its name into act_stats:\n\n  Turbo -> krea2_act_stats_turbo.safetensors\n  base  -> krea2_act_stats_base.safetensors\n\n6.67 MB each. They fit the low-rank branch against activations\nmeasured from a real sampling pass instead of assuming every input\nchannel matters equally. LPIPS to BF16 0.3378 -> 0.2825 at rank 64.\nSame rank, same file size, same kernel, same speed. There is no\nreason to skip this.\n\nTake the file that matches the model you are quantizing. A mismatch\nis caught before any GPU work only if the layer NAMES differ, and\nTurbo and base share their names - so the check will not save you\nfrom feeding Turbo's statistics to a base build. Read the filename.\n\nIf you are quantizing a finetune, a merge, or anything these two\nfiles do not describe, capture your own:\nworkflows/krea2_quantize_calibrated.json does the capture and the\nquantize in one Queue press."
+      ],
+      "title": "READ ME FIRST",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 2,
+      "type": "Krea2SVDQuantEnvCheck",
+      "pos": [
+        480,
+        60
+      ],
+      "size": [
+        420,
+        120
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "report",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantEnvCheck"
+      },
+      "widgets_values": [],
+      "title": "1. Env Check - run this first, it needs nothing",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 3,
+      "type": "Krea2SVDQuantQuantize",
+      "pos": [
+        480,
+        240.0
+      ],
+      "size": [
+        420,
+        460
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "summary",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantQuantize"
+      },
+      "widgets_values": [
+        "krea2_bf16.safetensors",
+        "svdq",
+        64,
+        "uniform",
+        100,
+        256,
+        "turbo",
+        "",
+        false,
+        "",
+        0
+      ],
+      "title": "2. Quantize - set source_model and act_stats, then Queue",
+      "color": "#233",
+      "bgcolor": "#355"
+    }
+  ],
+  "links": [],
+  "groups": [
+    {
+      "title": "Quantize",
+      "bounding": [
+        500,
+        20,
+        460,
+        640
+      ],
+      "color": "#8a4",
+      "font_size": 24,
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

workflows/krea2_quantize_all_in_one.json

@@ -0,0 +1,128 @@
+{
+  "id": "00000000-0000-4000-8000-000000000000",
+  "revision": 0,
+  "last_node_id": 3,
+  "last_link_id": 0,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Note",
+      "pos": [
+        60,
+        60
+      ],
+      "size": [
+        460,
+        600
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "QUANTIZE ALL-IN-ONE - Bake DiT + Text Encoder + VAE\n\nThis graph bakes three files into one unified checkpoint in models/checkpoints/:\n1. source_dit (in models/diffusion_models/): BF16 or already quantized.\n2. text_encoder (in models/text_encoders/): Qwen3-VL 4B BF16 (~8.88 GB -> ~3.2 GB W4A4).\n3. vae (in models/vae/): Krea2 VAE (~0.51 GB unquantized).\n\nResulting file: ~12 GB in models/checkpoints/, loaded with Krea2 SVDQuant Checkpoint Loader."
+      ],
+      "title": "READ ME FIRST",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 2,
+      "type": "Krea2SVDQuantEnvCheck",
+      "pos": [
+        480,
+        60
+      ],
+      "size": [
+        420,
+        120
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "report",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantEnvCheck"
+      },
+      "widgets_values": [],
+      "title": "1. Env Check - verify CUDA kernel",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 3,
+      "type": "Krea2SVDQuantQuantizeAllInOne",
+      "pos": [
+        480,
+        240.0
+      ],
+      "size": [
+        420,
+        520
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "summary",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantQuantizeAllInOne"
+      },
+      "widgets_values": [
+        "turbo.safetensors",
+        "qwen3vl_4b_bf16.safetensors",
+        "Krea2-HD-vae.safetensors",
+        "svdq",
+        "w4a4",
+        64,
+        100,
+        256,
+        "turbo",
+        "",
+        false,
+        "krea2_act_stats_turbo.safetensors",
+        0
+      ],
+      "title": "2. Quantize & Bake All-in-One Checkpoint",
+      "color": "#233",
+      "bgcolor": "#355"
+    }
+  ],
+  "links": [],
+  "groups": [
+    {
+      "title": "All-in-One Baker",
+      "bounding": [
+        500,
+        20,
+        460,
+        700
+      ],
+      "color": "#8a4",
+      "font_size": 24,
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

workflows/krea2_quantize_all_in_one_api.json

@@ -0,0 +1,30 @@
+{
+  "1": {
+    "class_type": "Krea2SVDQuantEnvCheck",
+    "inputs": {},
+    "_meta": {
+      "title": "1. Env Check - verify CUDA kernel"
+    }
+  },
+  "2": {
+    "class_type": "Krea2SVDQuantQuantizeAllInOne",
+    "inputs": {
+      "source_dit": "turbo.safetensors",
+      "text_encoder": "qwen3vl_4b_bf16.safetensors",
+      "vae": "Krea2-HD-vae.safetensors",
+      "format": "svdq",
+      "te_format": "w4a4",
+      "rank": 64,
+      "refine_iters": 100,
+      "groupsize": 256,
+      "variant": "turbo",
+      "output_name": "",
+      "overwrite": false,
+      "act_stats": "krea2_act_stats_turbo.safetensors",
+      "seed": 0
+    },
+    "_meta": {
+      "title": "2. Quantize & Bake All-in-One Checkpoint"
+    }
+  }
+}

workflows/krea2_quantize_api.json

@@ -0,0 +1,28 @@
+{
+  "1": {
+    "class_type": "Krea2SVDQuantEnvCheck",
+    "inputs": {},
+    "_meta": {
+      "title": "1. Env Check - run this first, it needs nothing"
+    }
+  },
+  "2": {
+    "class_type": "Krea2SVDQuantQuantize",
+    "inputs": {
+      "source_model": "krea2_bf16.safetensors",
+      "format": "svdq",
+      "rank": 64,
+      "rank_alloc": "uniform",
+      "refine_iters": 100,
+      "groupsize": 256,
+      "variant": "turbo",
+      "output_name": "",
+      "overwrite": false,
+      "act_stats": "",
+      "seed": 0
+    },
+    "_meta": {
+      "title": "2. Quantize - set source_model and act_stats, then Queue"
+    }
+  }
+}

workflows/krea2_quantize_calibrated.json

@@ -0,0 +1,557 @@
+{
+  "id": "00000000-0000-4000-8000-000000000000",
+  "revision": 0,
+  "last_node_id": 10,
+  "last_link_id": 9,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Note",
+      "pos": [
+        60,
+        60
+      ],
+      "size": [
+        460,
+        1420
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "CALIBRATED QUANTIZE - measure your own activations\n\nYOU PROBABLY DO NOT NEED THIS GRAPH.\nCalibration files for stock Krea 2 Turbo and base are published at\nhuggingface.co/AlperKTS/Krea-2-SVDQuant-ComfyUI/tree/main/calibration\n- 6.67 MB each. Download the one matching your variant, drop it in\nComfyUI/output/, name it in the act_stats box of the plain\nkrea2_quantize.json graph, and you get the identical quality lever\nwithout running a sampling pass.\n\nThis graph is for the case those files do not cover: a finetune, a\nmerge, a model whose weights are not the released ones. Activation\nstatistics describe the WEIGHTS they were captured from. Same\narchitecture is not the same model - Turbo's file loads cleanly into\na base build and quietly describes the wrong thing.\n\nWHAT IT BUYS\nThe low-rank branch is fitted against activations measured from a\nreal sampling pass instead of assuming every input channel matters\nequally. Measured, no LoRA, rank 64: LPIPS to BF16 0.3378 -> 0.2825.\nSame rank, same file size, same kernel, same speed.\n\nWHAT RUNS, IN ORDER\n1. The BF16 model is loaded with the stock UNETLoader and sampled\n   once. Capture Start hooks every layer that will be quantized and\n   records the RMS of its inputs; Capture Save writes them out.\n2. Capture Save's act_stats_path feeds the Quantize node. That wire\n   is not cosmetic - it is what stops ComfyUI running the quantizer\n   first, which would silently produce an uncalibrated file.\n\nSo one Queue press does calibration AND quantization. Expect the\nsampling pass plus 54s-6min of quantizing, with the queue blocked.\n\nSET THIS BEFORE YOU RUN\n- UNETLoader: the BF16 checkpoint. Statistics from an already\n  quantized model describe the wrong thing.\n- Quantize node: the SAME file as source_model. It is a separate\n  dropdown, and no, it cannot be wired - the loader hands over a\n  MODEL object, not a filename.\n- variant: turbo or base, so the output gets the right name.\n- KSampler: 20 steps / cfg 3.5 suits base. For Turbo use 8 steps\n  and cfg 1.0, and swap the negative prompt for ConditioningZeroOut.\n\nCALIBRATING ON SEVERAL PROMPTS (better, optional)\nThe defaults calibrate on one prompt, which is enough to beat no\ncalibration. To use more: set keep_capturing = true on Capture Save,\nmute the Quantize node (select it, Ctrl+M), queue as many prompts as\nyou like with reset = false on Capture Start after the first, then\nunmute Quantize and queue once more. Prompts should look like what\nyou actually generate.\n\nOnly svdq uses act_stats. The other formats have no branch to fit,\nand wiring act_stats into them is an error rather than a no-op."
+      ],
+      "title": "READ ME FIRST",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 2,
+      "type": "UNETLoader",
+      "pos": [
+        480,
+        60
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "UNETLoader"
+      },
+      "widgets_values": [
+        "krea2_bf16.safetensors",
+        "default"
+      ],
+      "title": "BF16 source (stock loader)",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 3,
+      "type": "CLIPLoader",
+      "pos": [
+        480,
+        260
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            3,
+            4
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPLoader"
+      },
+      "widgets_values": [
+        "qwen3vl_4b_fp8_scaled.safetensors",
+        "krea2",
+        "default"
+      ],
+      "title": "Text encoder (Qwen3-VL 4B)",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 4,
+      "type": "Krea2SVDQuantCaptureStart",
+      "pos": [
+        900,
+        60
+      ],
+      "size": [
+        400,
+        100
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "status",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantCaptureStart"
+      },
+      "widgets_values": [
+        true
+      ],
+      "title": "Capture Start - before the sampler",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 5,
+      "type": "CLIPTextEncode",
+      "pos": [
+        900,
+        220.0
+      ],
+      "size": [
+        400,
+        200
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            5
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "A cluttered antique clockmaker's workshop seen through a cracked magnifying glass, brass gears laid out in a spiral on the workbench, a ginger cat asleep on a stack of leather-bound books, warm afternoon light with visible dust motes, photorealistic, 85mm lens, shallow depth of field"
+      ],
+      "title": "Calibration prompt",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 6,
+      "type": "CLIPTextEncode",
+      "pos": [
+        900,
+        460.0
+      ],
+      "size": [
+        400,
+        140
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "blurry, low resolution, jpeg artifacts, watermark, deformed, extra limbs"
+      ],
+      "title": "Negative (Turbo: replace with ConditioningZeroOut)",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 7,
+      "type": "EmptySD3LatentImage",
+      "pos": [
+        900,
+        660.0
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptySD3LatentImage"
+      },
+      "widgets_values": [
+        1024,
+        1024,
+        1
+      ],
+      "title": "Latent 1024x1024",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 8,
+      "type": "KSampler",
+      "pos": [
+        1320,
+        60
+      ],
+      "size": [
+        400,
+        280
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 2
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 5
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 6
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            8
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        987654321,
+        "randomize",
+        20,
+        3.5,
+        "euler",
+        "simple",
+        1.0
+      ],
+      "title": "Calibration pass - base 20/3.5, Turbo 8/1.0",
+      "color": "#323",
+      "bgcolor": "#535"
+    },
+    {
+      "id": 9,
+      "type": "Krea2SVDQuantCaptureSave",
+      "pos": [
+        1740,
+        60
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "links": [],
+          "slot_index": 0
+        },
+        {
+          "name": "status",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 1
+        },
+        {
+          "name": "act_stats_path",
+          "type": "STRING",
+          "links": [
+            9
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantCaptureSave"
+      },
+      "widgets_values": [
+        "krea2_act_stats.safetensors",
+        false
+      ],
+      "title": "Capture Save - after the sampler",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 10,
+      "type": "Krea2SVDQuantQuantize",
+      "pos": [
+        2160,
+        60
+      ],
+      "size": [
+        420,
+        440
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "act_stats",
+          "type": "STRING",
+          "link": 9,
+          "widget": {
+            "name": "act_stats"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "summary",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantQuantize"
+      },
+      "widgets_values": [
+        "krea2_bf16.safetensors",
+        "svdq",
+        64,
+        "uniform",
+        100,
+        256,
+        "turbo",
+        "",
+        false,
+        "",
+        0
+      ],
+      "title": "Quantize - source_model must match the loader above",
+      "color": "#233",
+      "bgcolor": "#355"
+    }
+  ],
+  "links": [
+    [
+      1,
+      2,
+      0,
+      4,
+      0,
+      "MODEL"
+    ],
+    [
+      2,
+      4,
+      0,
+      8,
+      0,
+      "MODEL"
+    ],
+    [
+      3,
+      3,
+      0,
+      5,
+      0,
+      "CLIP"
+    ],
+    [
+      4,
+      3,
+      0,
+      6,
+      0,
+      "CLIP"
+    ],
+    [
+      5,
+      5,
+      0,
+      8,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      6,
+      6,
+      0,
+      8,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      7,
+      7,
+      0,
+      8,
+      3,
+      "LATENT"
+    ],
+    [
+      8,
+      8,
+      0,
+      9,
+      0,
+      "LATENT"
+    ],
+    [
+      9,
+      9,
+      2,
+      10,
+      0,
+      "STRING"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Load BF16",
+      "bounding": [
+        500,
+        20,
+        420,
+        420
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Calibration pass",
+      "bounding": [
+        940,
+        20,
+        420,
+        800
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Quantize",
+      "bounding": [
+        2200,
+        20,
+        460,
+        520
+      ],
+      "color": "#8a4",
+      "font_size": 24,
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

workflows/krea2_quantize_calibrated_api.json

@@ -0,0 +1,139 @@
+{
+  "1": {
+    "class_type": "UNETLoader",
+    "inputs": {
+      "unet_name": "krea2_bf16.safetensors",
+      "weight_dtype": "default"
+    },
+    "_meta": {
+      "title": "BF16 source (stock loader)"
+    }
+  },
+  "2": {
+    "class_type": "CLIPLoader",
+    "inputs": {
+      "clip_name": "qwen3vl_4b_fp8_scaled.safetensors",
+      "type": "krea2",
+      "device": "default"
+    },
+    "_meta": {
+      "title": "Text encoder (Qwen3-VL 4B)"
+    }
+  },
+  "3": {
+    "class_type": "Krea2SVDQuantCaptureStart",
+    "inputs": {
+      "reset": true,
+      "model": [
+        "1",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Capture Start - before the sampler"
+    }
+  },
+  "4": {
+    "class_type": "CLIPTextEncode",
+    "inputs": {
+      "text": "A cluttered antique clockmaker's workshop seen through a cracked magnifying glass, brass gears laid out in a spiral on the workbench, a ginger cat asleep on a stack of leather-bound books, warm afternoon light with visible dust motes, photorealistic, 85mm lens, shallow depth of field",
+      "clip": [
+        "2",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Calibration prompt"
+    }
+  },
+  "5": {
+    "class_type": "CLIPTextEncode",
+    "inputs": {
+      "text": "blurry, low resolution, jpeg artifacts, watermark, deformed, extra limbs",
+      "clip": [
+        "2",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Negative (Turbo: replace with ConditioningZeroOut)"
+    }
+  },
+  "6": {
+    "class_type": "EmptySD3LatentImage",
+    "inputs": {
+      "width": 1024,
+      "height": 1024,
+      "batch_size": 1
+    },
+    "_meta": {
+      "title": "Latent 1024x1024"
+    }
+  },
+  "7": {
+    "class_type": "KSampler",
+    "inputs": {
+      "seed": 987654321,
+      "steps": 20,
+      "cfg": 3.5,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1.0,
+      "model": [
+        "3",
+        0
+      ],
+      "positive": [
+        "4",
+        0
+      ],
+      "negative": [
+        "5",
+        0
+      ],
+      "latent_image": [
+        "6",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Calibration pass - base 20/3.5, Turbo 8/1.0"
+    }
+  },
+  "8": {
+    "class_type": "Krea2SVDQuantCaptureSave",
+    "inputs": {
+      "filename": "krea2_act_stats.safetensors",
+      "keep_capturing": false,
+      "latent": [
+        "7",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Capture Save - after the sampler"
+    }
+  },
+  "9": {
+    "class_type": "Krea2SVDQuantQuantize",
+    "inputs": {
+      "source_model": "krea2_bf16.safetensors",
+      "format": "svdq",
+      "rank": 64,
+      "rank_alloc": "uniform",
+      "refine_iters": 100,
+      "groupsize": 256,
+      "variant": "turbo",
+      "output_name": "",
+      "overwrite": false,
+      "act_stats": [
+        "8",
+        2
+      ],
+      "seed": 0
+    },
+    "_meta": {
+      "title": "Quantize - source_model must match the loader above"
+    }
+  }
+}

workflows/krea2_svdquant_diagnostics.json

@@ -0,0 +1,323 @@
+{
+  "id": "00000000-0000-4000-8000-000000000000",
+  "revision": 0,
+  "last_node_id": 7,
+  "last_link_id": 4,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Note",
+      "pos": [
+        60,
+        60
+      ],
+      "size": [
+        430,
+        700
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "KREA 2 SVDQUANT - DIAGNOSTICS\n\nRun this before reporting a bug, and before downloading 8 GB.\nNothing here generates an image.\n\nENV CHECK (left, no model needed)\n   Answers the single most common report: \"the quantized checkpoint\n   is slower than fp8\". Almost always the cause is that ComfyUI\n   disabled comfy_kitchen's CUDA backend because torch was built\n   against CUDA < 13, and the fallback dequantizes int4 in Python --\n   slower than bf16, not faster. Needs no model, so run it first.\n\nDIAGNOSTICS (right, needs a checkpoint) - the mode widget:\n   dispatch  which kernel actually runs. START HERE.\n   env       versions + memory accounting, including where the\n             low-rank factors currently live. Under lowvram they\n             should read cpu between steps, not cuda.\n   bench     quantized vs bf16 timing per layer.\n   profile   torch.profiler table.\n   compile   graph breaks a TorchCompileModel run would pay.\n\n   tokens = sequence length. 4096 is 1024x1024. Kernel selection is\n   shape-dependent, so match your real resolution.\n\nWHAT TO PASTE INTO AN ISSUE\n   Your GPU, the checkpoint filename, and the report output of both\n   nodes. Both are OUTPUT_NODEs, so the text shows in the node itself\n   and in the console. Neither is cached -- they re-measure the live\n   process every run, which is the point."
+      ],
+      "title": "READ ME FIRST",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 2,
+      "type": "Krea2SVDQuantEnvCheck",
+      "pos": [
+        480,
+        60
+      ],
+      "size": [
+        400,
+        80
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "report",
+          "type": "STRING",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantEnvCheck"
+      },
+      "widgets_values": [],
+      "title": "1. Env Check - no model needed, run this first",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 3,
+      "type": "PreviewAny",
+      "pos": [
+        480,
+        180.0
+      ],
+      "size": [
+        400,
+        300
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 1
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      },
+      "widgets_values": [],
+      "title": "Env Check report",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 4,
+      "type": "Krea2SVDQuantW4A4Loader",
+      "pos": [
+        900,
+        60
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            3
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [
+            2
+          ],
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantW4A4Loader"
+      },
+      "widgets_values": [
+        "Krea2-Turbo-SVDQuant-W4A4-rank256-actaware.safetensors"
+      ],
+      "title": "2. Load the checkpoint you are diagnosing",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 5,
+      "type": "PreviewAny",
+      "pos": [
+        900,
+        200.0
+      ],
+      "size": [
+        400,
+        200
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 2
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      },
+      "widgets_values": [],
+      "title": "Loader status - names the kernel that will run",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 6,
+      "type": "Krea2SVDQuantDiagnostics",
+      "pos": [
+        1320,
+        60
+      ],
+      "size": [
+        400,
+        130
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "links": [],
+          "slot_index": 0
+        },
+        {
+          "name": "report",
+          "type": "STRING",
+          "links": [
+            4
+          ],
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantDiagnostics"
+      },
+      "widgets_values": [
+        "dispatch",
+        4096
+      ],
+      "title": "3. Diagnostics - start with mode=dispatch",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 7,
+      "type": "PreviewAny",
+      "pos": [
+        1320,
+        220.0
+      ],
+      "size": [
+        400,
+        400
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "source",
+          "type": "*",
+          "link": 4
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "PreviewAny"
+      },
+      "widgets_values": [],
+      "title": "Diagnostics report - paste this into an issue",
+      "color": "#432",
+      "bgcolor": "#653"
+    }
+  ],
+  "links": [
+    [
+      1,
+      2,
+      0,
+      3,
+      0,
+      "STRING"
+    ],
+    [
+      2,
+      4,
+      1,
+      5,
+      0,
+      "STRING"
+    ],
+    [
+      3,
+      4,
+      0,
+      6,
+      0,
+      "MODEL"
+    ],
+    [
+      4,
+      6,
+      1,
+      7,
+      0,
+      "STRING"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Step 1 - does the int4 kernel exist at all?",
+      "bounding": [
+        500,
+        20,
+        420,
+        480
+      ],
+      "color": "#a85",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Step 2 - load it",
+      "bounding": [
+        940,
+        20,
+        420,
+        480
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Step 3 - what actually runs",
+      "bounding": [
+        1360,
+        20,
+        420,
+        620
+      ],
+      "color": "#8a4",
+      "font_size": 24,
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

workflows/krea2_svdquant_diagnostics_api.json

@@ -0,0 +1,68 @@
+{
+  "1": {
+    "class_type": "Krea2SVDQuantEnvCheck",
+    "inputs": {},
+    "_meta": {
+      "title": "1. Env Check - no model needed, run this first"
+    }
+  },
+  "2": {
+    "class_type": "PreviewAny",
+    "inputs": {
+      "source": [
+        "1",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Env Check report"
+    }
+  },
+  "3": {
+    "class_type": "Krea2SVDQuantW4A4Loader",
+    "inputs": {
+      "model_name": "Krea2-Turbo-SVDQuant-W4A4-rank256-actaware.safetensors"
+    },
+    "_meta": {
+      "title": "2. Load the checkpoint you are diagnosing"
+    }
+  },
+  "4": {
+    "class_type": "PreviewAny",
+    "inputs": {
+      "source": [
+        "3",
+        1
+      ]
+    },
+    "_meta": {
+      "title": "Loader status - names the kernel that will run"
+    }
+  },
+  "5": {
+    "class_type": "Krea2SVDQuantDiagnostics",
+    "inputs": {
+      "mode": "dispatch",
+      "tokens": 4096,
+      "model": [
+        "3",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "3. Diagnostics - start with mode=dispatch"
+    }
+  },
+  "6": {
+    "class_type": "PreviewAny",
+    "inputs": {
+      "source": [
+        "5",
+        1
+      ]
+    },
+    "_meta": {
+      "title": "Diagnostics report - paste this into an issue"
+    }
+  }
+}

workflows/krea2_turbo_all_in_one_t2i.json

@@ -0,0 +1,517 @@
+{
+  "id": "00000000-0000-4000-8000-000000000000",
+  "revision": 0,
+  "last_node_id": 9,
+  "last_link_id": 10,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Note",
+      "pos": [
+        60,
+        60
+      ],
+      "size": [
+        400,
+        620
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "KREA 2 TURBO - ALL-IN-ONE CHECKPOINT\n\n1. Checkpoint goes in ComfyUI/models/checkpoints/.\n   This file is fully self-contained: it combines the diffusion model,\n   the 4-bit quantized text encoder (Qwen3-VL 4B), and the VAE into a\n   single safetensors file (~12 GB instead of 15.5 GB across 3 files).\n\n2. SVDQuant checkpoints (carrying low-rank factors) load with the\n   \"Krea2 SVDQuant Checkpoint Loader\" node. Branchless checkpoints\n   (--format w4a4 or int8) also load with stock CheckpointLoaderSimple.\n\n3. cfg MUST be 1.0. Krea 2 Turbo is cfg-distilled, so the negative\n   prompt is zeroed out (ConditioningZeroOut) rather than encoded.\n   8 steps with euler / simple scheduler is what the model was distilled for.\n\n4. 1024x1024 native resolution. Latent size MUST be multiples of 16."
+      ],
+      "title": "READ ME FIRST",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 2,
+      "type": "Krea2SVDQuantCheckpointLoader",
+      "pos": [
+        480,
+        60
+      ],
+      "size": [
+        400,
+        140
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1,
+            10
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            2
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 2
+        },
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantCheckpointLoader"
+      },
+      "widgets_values": [
+        "Krea2-Turbo-AllInOne-SVDQuant-W4A4-rank256-actaware-TEW4A4.safetensors"
+      ],
+      "title": "Krea2 SVDQuant Checkpoint Loader",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 3,
+      "type": "CLIPTextEncode",
+      "pos": [
+        900,
+        60
+      ],
+      "size": [
+        400,
+        220
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            3,
+            4
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "A cluttered antique clockmaker's workshop seen through a cracked magnifying glass, brass gears laid out in a spiral on the workbench, a ginger cat asleep on a stack of leather-bound books, warm afternoon light with visible dust motes, photorealistic, 85mm lens, shallow depth of field"
+      ],
+      "title": "Prompt",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 4,
+      "type": "ConditioningZeroOut",
+      "pos": [
+        900,
+        340.0
+      ],
+      "size": [
+        400,
+        60
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            5
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConditioningZeroOut"
+      },
+      "widgets_values": [],
+      "title": "Negative (zeroed - required at cfg 1.0)",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 5,
+      "type": "EmptySD3LatentImage",
+      "pos": [
+        900,
+        500.00000000000006
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptySD3LatentImage"
+      },
+      "widgets_values": [
+        1024,
+        1024,
+        1
+      ],
+      "title": "Latent 1024x1024",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 6,
+      "type": "KSampler",
+      "pos": [
+        1320,
+        60
+      ],
+      "size": [
+        400,
+        280
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 4
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 5
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 6
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        987654321,
+        "randomize",
+        8,
+        1.0,
+        "euler",
+        "simple",
+        1.0
+      ],
+      "title": "KSampler - 8 steps, cfg 1.0",
+      "color": "#323",
+      "bgcolor": "#535"
+    },
+    {
+      "id": 7,
+      "type": "VAEDecode",
+      "pos": [
+        1740,
+        60
+      ],
+      "size": [
+        300,
+        60
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            9
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      },
+      "widgets_values": [],
+      "title": "VAE Decode",
+      "color": "#323",
+      "bgcolor": "#535"
+    },
+    {
+      "id": 8,
+      "type": "SaveImage",
+      "pos": [
+        1740,
+        200.0
+      ],
+      "size": [
+        400,
+        300
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 9
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "SaveImage"
+      },
+      "widgets_values": [
+        "krea2_turbo_aio_svdq"
+      ],
+      "title": "Save",
+      "color": "#323",
+      "bgcolor": "#535"
+    },
+    {
+      "id": 9,
+      "type": "Krea2SVDQuantDiagnostics",
+      "pos": [
+        1320,
+        540.0
+      ],
+      "size": [
+        400,
+        130
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 10
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [],
+          "slot_index": 0
+        },
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantDiagnostics"
+      },
+      "widgets_values": [
+        "dispatch",
+        4096
+      ],
+      "title": "Diagnostics (optional - run if slow)",
+      "color": "#432",
+      "bgcolor": "#653"
+    }
+  ],
+  "links": [
+    [
+      1,
+      2,
+      0,
+      6,
+      0,
+      "MODEL"
+    ],
+    [
+      2,
+      2,
+      1,
+      3,
+      0,
+      "CLIP"
+    ],
+    [
+      3,
+      3,
+      0,
+      4,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      4,
+      3,
+      0,
+      6,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      5,
+      4,
+      0,
+      6,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      6,
+      5,
+      0,
+      6,
+      3,
+      "LATENT"
+    ],
+    [
+      7,
+      6,
+      0,
+      7,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      2,
+      2,
+      7,
+      1,
+      "VAE"
+    ],
+    [
+      9,
+      7,
+      0,
+      8,
+      0,
+      "IMAGE"
+    ],
+    [
+      10,
+      2,
+      0,
+      9,
+      0,
+      "MODEL"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Load All-in-One",
+      "bounding": [
+        500,
+        20,
+        420,
+        280
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Prompt",
+      "bounding": [
+        940,
+        20,
+        420,
+        620
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Sample",
+      "bounding": [
+        1360,
+        20,
+        420,
+        640
+      ],
+      "color": "#8a4",
+      "font_size": 24,
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

workflows/krea2_turbo_all_in_one_t2i_api.json

@@ -0,0 +1,106 @@
+{
+  "1": {
+    "class_type": "Krea2SVDQuantCheckpointLoader",
+    "inputs": {
+      "ckpt_name": "Krea2-Turbo-AllInOne-SVDQuant-W4A4-rank256-actaware-TEW4A4.safetensors"
+    },
+    "_meta": {
+      "title": "Krea2 SVDQuant Checkpoint Loader"
+    }
+  },
+  "2": {
+    "class_type": "CLIPTextEncode",
+    "inputs": {
+      "text": "A cluttered antique clockmaker's workshop seen through a cracked magnifying glass, brass gears laid out in a spiral on the workbench, a ginger cat asleep on a stack of leather-bound books, warm afternoon light with visible dust motes, photorealistic, 85mm lens, shallow depth of field",
+      "clip": [
+        "1",
+        1
+      ]
+    },
+    "_meta": {
+      "title": "Prompt"
+    }
+  },
+  "3": {
+    "class_type": "ConditioningZeroOut",
+    "inputs": {
+      "conditioning": [
+        "2",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Negative (zeroed - required at cfg 1.0)"
+    }
+  },
+  "4": {
+    "class_type": "EmptySD3LatentImage",
+    "inputs": {
+      "width": 1024,
+      "height": 1024,
+      "batch_size": 1
+    },
+    "_meta": {
+      "title": "Latent 1024x1024"
+    }
+  },
+  "5": {
+    "class_type": "KSampler",
+    "inputs": {
+      "seed": 987654321,
+      "steps": 8,
+      "cfg": 1.0,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1.0,
+      "model": [
+        "1",
+        0
+      ],
+      "positive": [
+        "2",
+        0
+      ],
+      "negative": [
+        "3",
+        0
+      ],
+      "latent_image": [
+        "4",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "KSampler - 8 steps, cfg 1.0"
+    }
+  },
+  "6": {
+    "class_type": "VAEDecode",
+    "inputs": {
+      "samples": [
+        "5",
+        0
+      ],
+      "vae": [
+        "1",
+        2
+      ]
+    },
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "7": {
+    "class_type": "SaveImage",
+    "inputs": {
+      "filename_prefix": "krea2_turbo_aio_svdq",
+      "images": [
+        "6",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Save"
+    }
+  }
+}

workflows/krea2_turbo_svdquant_w4a4_lora.json

@@ -0,0 +1,631 @@
+{
+  "id": "00000000-0000-4000-8000-000000000000",
+  "revision": 0,
+  "last_node_id": 12,
+  "last_link_id": 11,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "Note",
+      "pos": [
+        60,
+        60
+      ],
+      "size": [
+        400,
+        720
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "Note"
+      },
+      "widgets_values": [
+        "KREA 2 TURBO + LoRA - SVDQuant W4A4\n\nSame graph as the plain Turbo one, with LoRA loaders inserted between\nthe checkpoint loader and the sampler.\n\n1. USE THIS NODE, NOT THE STOCK ONE. On a quantized checkpoint the\n   stock LoraLoaderModelOnly has to dequantize the 4-bit weight, add\n   the LoRA, and requantize it -- which throws away the format and\n   quantizes the LoRA delta to 4 bits along with it. This node\n   attaches the LoRA as a parallel branch instead:\n   (W + BA)x == Wx + B(Ax), so the quantized weight is never touched.\n\n2. CHECK THE CONSOLE. The node prints what it matched, e.g.\n     224 quantized layers, 32 normal layers\n   If it says 0 quantized layers, the LoRA does not target this model\n   and nothing will change. That line is the first thing to look at\n   when a LoRA \"does nothing\".\n\n3. STACKING. Chain more of these nodes, one per LoRA. The whole stack\n   is refolded each time, so strengths stay exact no matter how many\n   you chain, and the cost stays one pair of GEMMs. The second loader\n   here is bypassed (ctrl-B) -- unmute it to use it.\n\n4. RANK MATTERS HERE. Without a LoRA, branch ranks 64/128/256 measure\n   the same. With one, rank 256 wins clearly and rank 64 loses most of\n   its advantage. If you use LoRAs, download rank 256.\n\n5. adapters INPUT. Only affects LoKr / LoHa / OFT, which cannot fold\n   into the branch. \"bypass\" is exact and costs ~1.8s per model call\n   at 1440x1920; \"bake\" is free per-step but requantizes the delta.\n   A plain up/down LoRA ignores this setting entirely."
+      ],
+      "title": "READ ME FIRST",
+      "color": "#432",
+      "bgcolor": "#653"
+    },
+    {
+      "id": 2,
+      "type": "Krea2SVDQuantW4A4Loader",
+      "pos": [
+        480,
+        60
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": [],
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantW4A4Loader"
+      },
+      "widgets_values": [
+        "Krea2-Turbo-SVDQuant-W4A4-rank256.safetensors"
+      ],
+      "title": "Krea2 SVDQuant W4A4 Loader (rank 256 for LoRAs)",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 3,
+      "type": "CLIPLoader",
+      "pos": [
+        480,
+        260
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            4
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPLoader"
+      },
+      "widgets_values": [
+        "qwen3vl_4b_fp8_scaled.safetensors",
+        "krea2",
+        "default"
+      ],
+      "title": "Text encoder (Qwen3-VL 4B)",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 4,
+      "type": "VAELoader",
+      "pos": [
+        480,
+        460
+      ],
+      "size": [
+        400,
+        80
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            10
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAELoader"
+      },
+      "widgets_values": [
+        "qwen_image_vae.safetensors"
+      ],
+      "title": "VAE",
+      "color": "#233",
+      "bgcolor": "#355"
+    },
+    {
+      "id": 5,
+      "type": "Krea2SVDQuantLoraLoader",
+      "pos": [
+        900,
+        60
+      ],
+      "size": [
+        400,
+        140
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "links": [
+            2,
+            3
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantLoraLoader"
+      },
+      "widgets_values": [
+        "your_krea2_lora.safetensors",
+        1.0,
+        "bypass (exact, slower)"
+      ],
+      "title": "Krea2 SVDQuant LoRA Loader",
+      "color": "#653",
+      "bgcolor": "#874"
+    },
+    {
+      "id": 6,
+      "type": "Krea2SVDQuantLoraLoader",
+      "pos": [
+        900,
+        260
+      ],
+      "size": [
+        400,
+        140
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 4,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "links": [],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Krea2SVDQuantLoraLoader"
+      },
+      "widgets_values": [
+        "your_krea2_lora.safetensors",
+        0.6,
+        "bypass (exact, slower)"
+      ],
+      "title": "Second LoRA (muted - ctrl-B to enable)",
+      "color": "#653",
+      "bgcolor": "#874"
+    },
+    {
+      "id": 7,
+      "type": "CLIPTextEncode",
+      "pos": [
+        1320,
+        60
+      ],
+      "size": [
+        400,
+        220
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            5,
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "A cluttered antique clockmaker's workshop seen through a cracked magnifying glass, brass gears laid out in a spiral on the workbench, a ginger cat asleep on a stack of leather-bound books, warm afternoon light with visible dust motes, photorealistic, 85mm lens, shallow depth of field"
+      ],
+      "title": "Prompt (add your LoRA trigger words)",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 8,
+      "type": "ConditioningZeroOut",
+      "pos": [
+        1320,
+        340.0
+      ],
+      "size": [
+        400,
+        60
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "conditioning",
+          "type": "CONDITIONING",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ConditioningZeroOut"
+      },
+      "widgets_values": [],
+      "title": "Negative (zeroed - required at cfg 1.0)",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 9,
+      "type": "EmptySD3LatentImage",
+      "pos": [
+        1320,
+        500.00000000000006
+      ],
+      "size": [
+        400,
+        120
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            8
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptySD3LatentImage"
+      },
+      "widgets_values": [
+        1024,
+        1024,
+        1
+      ],
+      "title": "Latent 1024x1024",
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 10,
+      "type": "KSampler",
+      "pos": [
+        1740,
+        60
+      ],
+      "size": [
+        400,
+        280
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 3
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 6
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 7
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            9
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        987654321,
+        "randomize",
+        8,
+        1.0,
+        "euler",
+        "simple",
+        1.0
+      ],
+      "title": "KSampler - 8 steps, cfg 1.0",
+      "color": "#323",
+      "bgcolor": "#535"
+    },
+    {
+      "id": 11,
+      "type": "VAEDecode",
+      "pos": [
+        2160,
+        60
+      ],
+      "size": [
+        300,
+        60
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 9
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 10
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            11
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      },
+      "widgets_values": [],
+      "title": "VAE Decode",
+      "color": "#323",
+      "bgcolor": "#535"
+    },
+    {
+      "id": 12,
+      "type": "SaveImage",
+      "pos": [
+        2160,
+        200.0
+      ],
+      "size": [
+        400,
+        300
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 11
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "SaveImage"
+      },
+      "widgets_values": [
+        "krea2_turbo_lora"
+      ],
+      "title": "Save",
+      "color": "#323",
+      "bgcolor": "#535"
+    }
+  ],
+  "links": [
+    [
+      1,
+      2,
+      0,
+      5,
+      0,
+      "MODEL"
+    ],
+    [
+      2,
+      5,
+      0,
+      6,
+      0,
+      "MODEL"
+    ],
+    [
+      3,
+      5,
+      0,
+      10,
+      0,
+      "MODEL"
+    ],
+    [
+      4,
+      3,
+      0,
+      7,
+      0,
+      "CLIP"
+    ],
+    [
+      5,
+      7,
+      0,
+      8,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      6,
+      7,
+      0,
+      10,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      7,
+      8,
+      0,
+      10,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      8,
+      9,
+      0,
+      10,
+      3,
+      "LATENT"
+    ],
+    [
+      9,
+      10,
+      0,
+      11,
+      0,
+      "LATENT"
+    ],
+    [
+      10,
+      4,
+      0,
+      11,
+      1,
+      "VAE"
+    ],
+    [
+      11,
+      11,
+      0,
+      12,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Load",
+      "bounding": [
+        500,
+        20,
+        420,
+        620
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "LoRA - chain one node per LoRA",
+      "bounding": [
+        940,
+        20,
+        420,
+        420
+      ],
+      "color": "#a85",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Prompt",
+      "bounding": [
+        1360,
+        20,
+        420,
+        620
+      ],
+      "color": "#3f789e",
+      "font_size": 24,
+      "flags": {}
+    },
+    {
+      "title": "Sample",
+      "bounding": [
+        1780,
+        20,
+        420,
+        640
+      ],
+      "color": "#8a4",
+      "font_size": 24,
+      "flags": {}
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

workflows/krea2_turbo_svdquant_w4a4_lora_api.json

@@ -0,0 +1,141 @@
+{
+  "1": {
+    "class_type": "Krea2SVDQuantW4A4Loader",
+    "inputs": {
+      "model_name": "Krea2-Turbo-SVDQuant-W4A4-rank256.safetensors"
+    },
+    "_meta": {
+      "title": "Krea2 SVDQuant W4A4 Loader (rank 256 for LoRAs)"
+    }
+  },
+  "2": {
+    "class_type": "CLIPLoader",
+    "inputs": {
+      "clip_name": "qwen3vl_4b_fp8_scaled.safetensors",
+      "type": "krea2",
+      "device": "default"
+    },
+    "_meta": {
+      "title": "Text encoder (Qwen3-VL 4B)"
+    }
+  },
+  "3": {
+    "class_type": "VAELoader",
+    "inputs": {
+      "vae_name": "qwen_image_vae.safetensors"
+    },
+    "_meta": {
+      "title": "VAE"
+    }
+  },
+  "4": {
+    "class_type": "Krea2SVDQuantLoraLoader",
+    "inputs": {
+      "lora_name": "your_krea2_lora.safetensors",
+      "strength": 1.0,
+      "adapters": "bypass (exact, slower)",
+      "model": [
+        "1",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Krea2 SVDQuant LoRA Loader"
+    }
+  },
+  "5": {
+    "class_type": "CLIPTextEncode",
+    "inputs": {
+      "text": "A cluttered antique clockmaker's workshop seen through a cracked magnifying glass, brass gears laid out in a spiral on the workbench, a ginger cat asleep on a stack of leather-bound books, warm afternoon light with visible dust motes, photorealistic, 85mm lens, shallow depth of field",
+      "clip": [
+        "2",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Prompt (add your LoRA trigger words)"
+    }
+  },
+  "6": {
+    "class_type": "ConditioningZeroOut",
+    "inputs": {
+      "conditioning": [
+        "5",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Negative (zeroed - required at cfg 1.0)"
+    }
+  },
+  "7": {
+    "class_type": "EmptySD3LatentImage",
+    "inputs": {
+      "width": 1024,
+      "height": 1024,
+      "batch_size": 1
+    },
+    "_meta": {
+      "title": "Latent 1024x1024"
+    }
+  },
+  "8": {
+    "class_type": "KSampler",
+    "inputs": {
+      "seed": 987654321,
+      "steps": 8,
+      "cfg": 1.0,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1.0,
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "5",
+        0
+      ],
+      "negative": [
+        "6",
+        0
+      ],
+      "latent_image": [
+        "7",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "KSampler - 8 steps, cfg 1.0"
+    }
+  },
+  "9": {
+    "class_type": "VAEDecode",
+    "inputs": {
+      "samples": [
+        "8",
+        0
+      ],
+      "vae": [
+        "3",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "10": {
+    "class_type": "SaveImage",
+    "inputs": {
+      "filename_prefix": "krea2_turbo_lora",
+      "images": [
+        "9",
+        0
+      ]
+    },
+    "_meta": {
+      "title": "Save"
+    }
+  }
+}