inline-core 1.2.71__tar.gz → 1.2.73__tar.gz

{inline_core-1.2.71 → inline_core-1.2.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inline-core
-Version: 1.2.71
+Version: 1.2.73
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11

{inline_core-1.2.71 → inline_core-1.2.73}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.71"
+version = "1.2.73"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{inline_core-1.2.71 → inline_core-1.2.73}/src/inline_core/models/checkpoint.py

@@ -34,6 +34,38 @@ _DTYPE_NAMES = {
 }
 
 
+#: Markers a checkpoint carries when it was already quantized by someone else. ``comfy_quant`` is
+#: ComfyUI's own tag; ``weight_scale`` is the per-tensor scale every fp8/int8 repack ships beside
+#: the packed weights. Never match a bare ``.scale``: real models carry RMSNorm weights so named.
+_QUANT_MARKERS = ("comfy_quant", "weight_scale", "scale_weight", "weight_scale_2")
+_QUANT_DTYPES = frozenset({"I8", "U8"})
+
+
+def prequantized_kind(path: str | Path) -> str | None:
+    """What quantization a checkpoint already carries, or None if it is plain weights.
+
+    Loading one of these into a stock model silently drops the scales as unexpected keys, leaving
+    packed tensors in layers sized for unpacked ones - which surfaces as a shape mismatch deep in a
+    matmul rather than as a load error. Quantizing it a second time compounds that.
+    """
+    file = Path(path)
+    if not file.is_file() or file.suffix.lower() not in (".safetensors", ".sft"):
+        return None
+    try:
+        reader = CheckpointReader(file)
+        dtypes = reader.dtypes()
+    except Exception:  # noqa: BLE001 - unreadable is not classifiable
+        return None
+    if any(any(m in key for m in _QUANT_MARKERS) for key in dtypes):
+        return "prequantized"
+    weights = {d for key, d in dtypes.items() if key.endswith(".weight")}
+    if any(d.startswith("F8_") for d in weights):
+        return "fp8"
+    if weights & _QUANT_DTYPES:
+        return "int8"
+    return None
+
+
 class CheckpointReader:
     """Random access to one safetensors file, one tensor at a time."""
 
@@ -64,6 +96,11 @@ class CheckpointReader:
         infer a checkpoint's architecture (layer counts, widths) before deciding how to load it."""
         return {key: list(entry.get("shape") or []) for key, entry in self._index.items()}
 
+    def dtypes(self) -> dict[str, str]:
+        """Every tensor's on-disk dtype name, header only. These are safetensors' own spellings
+        (``BF16``, ``F8_E4M3``, ...), not torch's, so a dtype we cannot load is still reportable."""
+        return {key: str(entry.get("dtype") or "") for key, entry in self._index.items()}
+
     def get_tensor(self, key: str, device: str | None = None) -> Any:
         """One tensor, read straight from its byte range into a fresh buffer."""
         import torch

{inline_core-1.2.71 → inline_core-1.2.73}/src/inline_core/models/flux2/requirements.py

@@ -15,6 +15,7 @@ lets a Z-Image, Krea 2 and FLUX.2 checkpoint share ``diffusion_models/`` safely.
 
 from __future__ import annotations
 
+import logging
 import os
 import re
 from pathlib import Path
@@ -24,6 +25,8 @@ from ..catalog import resolve_picked
 from ..requirements import ModelComponent
 from . import variants as V
 
+logger = logging.getLogger("inline_core.flux2")
+
 __all__ = [
     "DIFFUSION_FILE",
     "SPLIT_REPO",
@@ -65,10 +68,13 @@ _EXTRAS: tuple[tuple[str, str, str, str, str], ...] = (
     ),
     (
         "diffusion_klein_9b",
-        "Klein 9B (int8, needs ~12 GB VRAM)",
+        "Klein 9B (18 GB download, quantized on load)",
         "diffusion_models",
-        "Sakujo/FLUX.2-Klein-9B-INT8-ConvRot",
-        "flux-2-klein-9b-int8-ConvRot-comfyui.safetensors",
+        # BFL's own repo, because no ungated mirror carries the 9B transformer: Comfy-Org's
+        # flux2-klein-9B holds only the encoders and the VAE. The fp8 build is deliberately not
+        # used here - diffusers' single-file converter cannot read it (see loaders.py).
+        "black-forest-labs/FLUX.2-klein-9B",
+        "flux-2-klein-9b.safetensors",
     ),
     (
         "text_encoder_qwen3_8b",
@@ -205,7 +211,36 @@ def _folder_encoder_width(folder: Path) -> int | None:
 
 def flux2_checkpoints() -> list[Path]:
     """Every FLUX.2 checkpoint installed, identified by content rather than by name."""
-    return [p for p in _weight_files("diffusion_models") if _identify(p) is not None]
+    found: list[Path] = []
+    skipped: list[str] = []
+    for path in _weight_files("diffusion_models"):
+        if _identify(path) is not None:
+            found.append(path)
+        else:
+            skipped.append(f"{path.name} ({skip_reason(path)})")
+    # A file that cannot be identified is left out of the dropdown, which from the UI is
+    # indistinguishable from it not being there at all. Say so once per scan.
+    if skipped and skipped != _LAST_SKIPPED:
+        _LAST_SKIPPED[:] = skipped
+        logger.info("Not offered as FLUX.2 checkpoints: %s", ", ".join(sorted(skipped)))
+    return found
+
+
+#: Last reported skip list, so a rescan on every catalog bump does not repeat itself in the log.
+_LAST_SKIPPED: list[str] = []
+
+
+def skip_reason(path: Path) -> str:
+    """Why a file in ``diffusion_models/`` is not offered, in the words a user can act on."""
+    blocked = V.single_file_blocker(path)
+    if blocked is not None:
+        return f"{blocked}, so diffusers cannot convert it"
+    carried = V.quantization_of(path)
+    if carried is not None:
+        return f"a {carried} repack whose tensor names we do not recognise"
+    if path.suffix.lower() == ".gguf":
+        return "unrecognised GGUF build"
+    return "not a FLUX.2 checkpoint, or a repack whose tensor names we do not recognise"
 
 
 def flux2_encoders() -> list[Path]:

{inline_core-1.2.71 → inline_core-1.2.73}/src/inline_core/models/flux2/variants.py

@@ -25,6 +25,8 @@ __all__ = [
     "derive_transformer_config",
     "folder_config",
     "is_prequantized",
+    "quantization_of",
+    "single_file_blocker",
     "detect",
     "get",
     "text_encoder_kind",
@@ -270,24 +272,86 @@ def folder_config(path: str | Path) -> dict[str, object] | None:
     return {k: v for k, v in config.items() if not k.startswith("_")}
 
 
+#: Safetensors spells fp8 as ``F8_E4M3`` / ``F8_E5M2``. Never match on a ``.scale`` suffix alone:
+#: a plain FLUX.2 checkpoint carries 80 RMSNorm ``norm.query_norm.scale`` weights that are not
+#: quantization scales at all. Only a scale riding on a *fused qkv* is a repack artifact, and it is
+#: the one diffusers' converter chokes on.
+_FP8_PREFIX = "F8_"
+_INT_DTYPES = frozenset({"I8", "U8"})
+_QKV_SCALE_SUFFIXES = ("qkv.scale", "qkv.weight_scale", "qkv.scale_weight")
+
+
+def quantization_of(path: str | Path) -> str | None:
+    """The quantization a checkpoint already carries, or None if it is plain weights.
+
+    A folder declares it in ``config.json``. A single file does not, so it is sniffed from the
+    header: an fp8 dtype, or the per-tensor scale tensors every int8/fp8 repack ships alongside.
+    """
+    target = Path(path)
+    if target.is_dir():
+        try:
+            import json
+
+            config = json.loads((target / "config.json").read_text())
+        except (OSError, ValueError):
+            return None
+        if not isinstance(config, dict):
+            return None
+        declared = config.get("quantization_config")
+        if not isinstance(declared, dict):
+            return None
+        return str(declared.get("quant_method", "quantized"))
+
+    if not target.is_file() or target.suffix.lower() not in _WEIGHT_SUFFIXES:
+        return None
+    try:
+        from ..checkpoint import CheckpointReader
+
+        reader = CheckpointReader(target)
+        dtypes = reader.dtypes()
+    except Exception:  # noqa: BLE001 - unreadable means "not something we can classify"
+        return None
+    weights = {d for key, d in dtypes.items() if key.endswith(".weight")}
+    if any(d.startswith(_FP8_PREFIX) for d in weights):
+        return "fp8"
+    if weights & _INT_DTYPES:
+        return "int8"
+    if any(key.endswith(_QKV_SCALE_SUFFIXES) for key in dtypes):
+        return "quantized"
+    return None
+
+
+def single_file_blocker(path: str | Path) -> str | None:
+    """Why a failed single-file load probably failed, or None if this is not the known cause.
+
+    Diagnostic only, never a gate: nothing calls this to decide whether to attempt a load. The
+    converter maps a ``.scale`` key to a weight and chunks it into q/k/v, so a **per-tensor**
+    (0-dim) scale on a fused qkv dies deep inside diffusers without naming the file.
+    """
+    target = Path(path)
+    if not target.is_file() or target.suffix.lower() not in _WEIGHT_SUFFIXES:
+        return None
+    try:
+        from ..checkpoint import CheckpointReader
+
+        shapes = CheckpointReader(target).shapes()
+    except Exception:  # noqa: BLE001 - unreadable is not our call to make here
+        return None
+    scalar = [k for k, s in shapes.items() if k.endswith(_QKV_SCALE_SUFFIXES) and not s]
+    if not scalar:
+        return None
+    return f"it carries a single scale value on each of {len(scalar)} fused qkv tensors"
+
+
 def is_prequantized(path: str | Path) -> bool:
-    """Whether a checkpoint folder carries its own quantization (an NF4 dev build, say).
+    """Whether a checkpoint carries its own quantization (an NF4 dev folder, an fp8 single file).
 
     Such a checkpoint must not be quantized again: its on-disk size already is its resident size,
     and handing diffusers a second, different quantization config is a hard error. It also means the
     fit ladder's assumption - that on-disk size is bf16 and quantization can halve it - does not
     hold here, so the caller passes ``Quantization.NONE`` and loads the weights as they are.
     """
-    folder = Path(path)
-    if not folder.is_dir():
-        return False
-    try:
-        import json
-
-        config = json.loads((folder / "config.json").read_text())
-    except (OSError, ValueError):
-        return False
-    return isinstance(config, dict) and bool(config.get("quantization_config"))
+    return quantization_of(path) is not None
 
 
 def config_for(path: str | Path) -> dict[str, object] | None:

{inline_core-1.2.71 → inline_core-1.2.73}/src/inline_core/models/loaders.py

@@ -25,6 +25,7 @@ over it. Callers are the model-runner subpackages, which the server registers be
 from __future__ import annotations
 
 import hashlib
+import logging
 import os
 from collections.abc import Callable
 from dataclasses import dataclass
@@ -35,6 +36,9 @@ from typing import TYPE_CHECKING, Any
 from ..config import data_dir
 from ..device.policy import Quantization
 from ..errors import ComponentError
+from . import checkpoint
+
+logger = logging.getLogger("inline_core.loaders")
 
 if TYPE_CHECKING:
     from ..graph.loader_runners import LoraRef
@@ -663,14 +667,33 @@ def load_text_encoder(
         root = ensure_assets(arch)
         weights_dir = _staged_encoder_dir(arch, file)
         device_map = {"": device} if device else None
-        text_encoder = Qwen3Model.from_pretrained(
-            str(weights_dir),
-            torch_dtype=dtype,
-            low_cpu_mem_usage=True,
-            device_map=device_map,
-            local_files_only=True,
-            quantization_config=_quant_config(quant, framework="transformers"),
-        )
+        # A repack that already carries its own scales must not be quantized again, and transformers
+        # drops those scales as unexpected keys - leaving packed tensors in layers sized for
+        # unpacked ones, which surfaces as a matmul shape error rather than a load failure.
+        carried = checkpoint.prequantized_kind(file)
+        effective = Quantization.NONE if carried else quant
+        if carried:
+            logger.info(
+                "%s is a %s text encoder; loading it as-is rather than quantizing on top.",
+                Path(file).name, carried,
+            )
+        try:
+            text_encoder = Qwen3Model.from_pretrained(
+                str(weights_dir),
+                torch_dtype=dtype,
+                low_cpu_mem_usage=True,
+                device_map=device_map,
+                local_files_only=True,
+                quantization_config=_quant_config(effective, framework="transformers"),
+            )
+        except Exception as error:
+            if not carried:
+                raise
+            raise ComponentError(
+                f"{Path(file).name} is a {carried} text encoder, which this loader cannot read: "
+                "its scales are not part of the stock Qwen3 layout. Use the full-precision encoder "
+                "(qwen_3_8b.safetensors from Comfy-Org/flux2-klein-9B)."
+            ) from error
         tokenizer = AutoTokenizer.from_pretrained(str(root / "tokenizer"), local_files_only=True)
         return text_encoder, tokenizer
 
@@ -1108,15 +1131,30 @@ def load_flux2_transformer(
         kwargs: dict[str, Any] = {}
         if _is_gguf(file):
             kwargs["quantization_config"] = _gguf_config(dtype)
-        model = Flux2Transformer2DModel.from_single_file(
-            file,
-            config=str(root),
-            torch_dtype=dtype,
-            low_cpu_mem_usage=True,
-            device=device,
-            local_files_only=True,
-            **kwargs,
-        )
+        try:
+            model = Flux2Transformer2DModel.from_single_file(
+                file,
+                config=str(root),
+                torch_dtype=dtype,
+                low_cpu_mem_usage=True,
+                device=device,
+                local_files_only=True,
+                **kwargs,
+            )
+        except Exception as error:
+            # Every checkpoint gets attempted - a user's own file is never refused on suspicion.
+            # Explain afterwards instead, because diffusers' converter fails deep inside itself
+            # without naming the file (see flux2/variants.single_file_blocker).
+            from .flux2 import variants as flux2_variants
+
+            blocked = flux2_variants.single_file_blocker(file)
+            if blocked is None:
+                raise
+            raise ComponentError(
+                f"{Path(file).name} did not load: {blocked}, and diffusers splits those as if they "
+                "were weights. A full-precision or .gguf build of the same model will work, and "
+                "Inline Studio quantizes on load to fit your card either way."
+            ) from error
         if _is_gguf(file):
             if loras:
                 raise ComponentError(

{inline_core-1.2.71 → inline_core-1.2.73}/src/inline_core/studio/models.py

@@ -185,7 +185,17 @@ class ModelDownloads:
             if getattr(getattr(error, "response", None), "status_code", None) not in (401, 403):
                 raise
             shutil.rmtree(staging, ignore_errors=True)
-            path = _fetch(False)
+            try:
+                path = _fetch(False)
+            except HfHubHTTPError as anonymous:
+                # Hugging Face reports a gated or missing repo identically, as 404 "Repository Not
+                # Found", which reads as a broken link rather than a licence the user must accept.
+                raise RuntimeError(
+                    f"Could not download {comp.filename} from {comp.repo}. If that repository is "
+                    f"gated, open https://huggingface.co/{comp.repo} , accept the licence, then "
+                    "sign in with `hf auth login` (or set HF_TOKEN) and try again. If it is not "
+                    "gated, the repository has moved or been removed."
+                ) from anonymous
 
         category_dir.mkdir(parents=True, exist_ok=True)
         destination = category_dir / comp.filename

{inline_core-1.2.71 → inline_core-1.2.73}/src/inline_core/studio/training.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import re
 import shutil
 import sys
@@ -35,6 +36,8 @@ from .dataset_import import read_metadata
 
 _CAPTION_EXT = ".txt"
 
+logger = logging.getLogger("inline_core.training")
+
 
 def _preview_json(preview: Any) -> dict[str, Any]:
     return {
@@ -543,19 +546,25 @@ class Training:
         folder = self._run_dir(run_id) / "snapshots"
         if not folder.is_dir():
             return []
+        name = _safe(str((self._lookup(run_id) or {}).get("name") or run_id))
         out: list[dict[str, Any]] = []
         for file in sorted(folder.glob("step-*.safetensors")):
             digits = file.stem.removeprefix("step-")
+            step = int(digits) if digits.isdigit() else 0
             stat = file.stat()
-            out.append(
-                {
-                    "runId": run_id,
-                    "step": int(digits) if digits.isdigit() else 0,
-                    "path": self._relativize(str(file)),
-                    "sizeBytes": stat.st_size,
-                    "createdAt": int(stat.st_mtime * 1000),
-                }
-            )
+            row: dict[str, Any] = {
+                "runId": run_id,
+                "step": step,
+                "path": self._relativize(str(file)),
+                "sizeBytes": stat.st_size,
+                "createdAt": int(stat.st_mtime * 1000),
+            }
+            # Report the export if it is already there, or a reload offers "Add to models" on a
+            # snapshot that was auto-exported and makes a second copy under a -2 name.
+            exported = f"loras/{name}-step{step}.safetensors"
+            if (models_dir() / exported).is_file():
+                row["loraPath"] = exported
+            out.append(row)
         return out
 
     def export_snapshot(self, run_id: str, step: int) -> dict[str, Any]:
@@ -567,6 +576,10 @@ class Training:
         source = self._run_dir(run_id) / "snapshots" / f"step-{step:06d}.safetensors"
         if not source.is_file():
             raise ValueError(f"Run {run_id} has no snapshot at step {step}.")
+        return {"path": self._copy_to_loras(run_id, source, step)}
+
+    def _copy_to_loras(self, run_id: str, source: Path, step: int) -> str:
+        """Place one snapshot in ``models/loras/`` and make the picker aware of it."""
         run = self._lookup(run_id) or {}
         loras = models_dir() / "loras"
         loras.mkdir(parents=True, exist_ok=True)
@@ -576,7 +589,7 @@ class Training:
         # Same hook a finished run uses, so the new file bumps the registry and reaches the picker.
         if self._on_output is not None:
             self._on_output()
-        return {"path": rel}
+        return rel
 
     def cancel(self, run_id: str) -> None:
         proc = self._active.get(run_id)
@@ -642,16 +655,7 @@ class Training:
             elif kind == "checkpoint" and msg.get("path"):
                 self._persist(run_id, {"checkpointPath": msg["path"]})
             elif kind == "snapshot" and msg.get("path"):
-                # The trainer has emitted these all along; nothing listened, so a mid-run LoRA sat
-                # on disk with no way to reach it.
-                self._events.broadcast(
-                    "events:trainingSnapshot",
-                    {
-                        "runId": run_id,
-                        "step": int(msg.get("step", 0)),
-                        "path": self._relativize(msg["path"]),
-                    },
-                )
+                self._on_snapshot(run_id, msg)
             elif kind == "error" and msg.get("message"):
                 # A trainer-side failure: keep it in the run's log so the node shows why it died.
                 self._events.broadcast(
@@ -661,6 +665,31 @@ class Training:
                 saw_done = True
         return saw_done
 
+    def _on_snapshot(self, run_id: str, msg: dict[str, Any]) -> None:
+        """Place a mid-run snapshot where a picker can see it, then announce it.
+
+        Exported as it is written rather than when the run ends: the reason to snapshot at step 400
+        is to test it while step 800 is still training, and the project working dir is not scanned
+        by any model catalog.
+        """
+        step = int(msg.get("step", 0))
+        written = Path(msg["path"])
+        # A complete TrainingSnapshot, not a partial one: the panel renders size and time straight
+        # off the event, and a missing field shows as "NaN KB" until the next listing lands.
+        stat = written.stat() if written.is_file() else None
+        payload: dict[str, Any] = {
+            "runId": run_id,
+            "step": step,
+            "path": self._relativize(msg["path"]),
+            "sizeBytes": stat.st_size if stat else 0,
+            "createdAt": int(stat.st_mtime * 1000) if stat else 0,
+        }
+        try:
+            payload["loraPath"] = self._copy_to_loras(run_id, written, step)
+        except Exception as error:  # noqa: BLE001 - training is the expensive thing in flight
+            logger.warning("Could not export the snapshot at step %d: %s", step, error)
+        self._events.broadcast("events:trainingSnapshot", payload)
+
     def _on_progress(self, run_id: str, msg: dict[str, Any]) -> None:
         step = int(msg.get("step", 0))
         total = int(msg.get("total", 0)) or None

{inline_core-1.2.71 → inline_core-1.2.73}/tests/test_checkpoint.py

@@ -8,9 +8,14 @@ must agree with safetensors exactly.
 
 from __future__ import annotations
 
+import json
+import struct
+from pathlib import Path
+
 import pytest
 
 from inline_core.errors import ComponentError
+from inline_core.models import checkpoint
 from inline_core.models.checkpoint import CheckpointReader
 
 torch = pytest.importorskip("torch")
@@ -77,3 +82,62 @@ def test_a_non_checkpoint_file_is_a_clear_error(tmp_path) -> None:
 def test_a_missing_file_is_a_clear_error(tmp_path) -> None:
     with pytest.raises(ComponentError, match="Could not read checkpoint"):
         CheckpointReader(tmp_path / "absent.safetensors")
+
+
+# --- already-quantized checkpoints ---------------------------------------------------------------
+#
+# A ComfyUI-quantized text encoder loads into a stock Qwen3Model with its `comfy_quant` and
+# `weight_scale` keys dropped as unexpected, leaving packed tensors in layers sized for unpacked
+# ones. That surfaced as a matmul shape error deep inside torchao, after the pipeline had
+# already reported itself ready.
+
+
+def _write(path: Path, index: dict[str, object]) -> Path:
+    blob = json.dumps(index).encode()
+    path.write_bytes(struct.pack("<Q", len(blob)) + blob + b"\x00" * 64)
+    return path
+
+
+def _t(dtype: str, shape: list[int]) -> dict[str, object]:
+    return {"dtype": dtype, "shape": shape, "data_offsets": [0, 1]}
+
+
+def test_a_comfy_quantized_encoder_is_recognised(tmp_path: Path) -> None:
+    file = _write(
+        tmp_path / "qwen_3_8b_comfyquant.safetensors",
+        {
+            "model.layers.0.self_attn.k_proj.weight": _t("I8", [1024, 2048]),
+            "model.layers.0.self_attn.k_proj.weight_scale": _t("F32", [1024]),
+            "model.layers.0.self_attn.k_proj.comfy_quant": _t("I8", []),
+        },
+    )
+    assert checkpoint.prequantized_kind(file) == "prequantized"
+
+
+def test_an_fp8_checkpoint_is_recognised(tmp_path: Path) -> None:
+    file = _write(
+        tmp_path / "enc_fp8.safetensors",
+        {"model.layers.0.mlp.up_proj.weight": _t("F8_E4M3", [4096, 4096])},
+    )
+    assert checkpoint.prequantized_kind(file) == "fp8"
+
+
+def test_a_plain_checkpoint_is_not_flagged(tmp_path: Path) -> None:
+    """A false positive here refuses to quantize a model that needs it, so it must not fire on
+    ordinary weights or on the RMSNorm tensors every transformer carries."""
+    file = _write(
+        tmp_path / "qwen_3_8b.safetensors",
+        {
+            "model.layers.0.self_attn.k_proj.weight": _t("BF16", [1024, 4096]),
+            "model.layers.0.input_layernorm.weight": _t("BF16", [4096]),
+            "model.layers.0.self_attn.q_norm.scale": _t("BF16", [128]),
+        },
+    )
+    assert checkpoint.prequantized_kind(file) is None
+
+
+def test_an_unreadable_file_is_not_classified(tmp_path: Path) -> None:
+    junk = tmp_path / "junk.safetensors"
+    junk.write_bytes(b"\x00" * 32)
+    assert checkpoint.prequantized_kind(junk) is None
+    assert checkpoint.prequantized_kind(tmp_path / "missing.safetensors") is None

{inline_core-1.2.71 → inline_core-1.2.73}/tests/test_flux2_variants.py

@@ -127,3 +127,71 @@ def test_an_unreadable_file_is_simply_not_flux2(tmp_path: Path) -> None:
     junk.write_bytes(b"\x00" * 64)
     assert V.detect(junk) is None
     assert V.detect(tmp_path / "missing.safetensors") is None
+
+
+# --- prequantized single files --------------------------------------------------------------------
+#
+# diffusers' single-file converter admits `.scale` keys and then chunks them like a fused qkv
+# weight. A per-tensor scale is 0-dim, so the load dies inside diffusers with no mention of which
+# file caused it. Detecting the checkpoint up front is what turns that into a usable message.
+
+
+def _write_index(path: Path, index: dict[str, object]) -> Path:
+    blob = json.dumps(index).encode()
+    path.write_bytes(struct.pack("<Q", len(blob)) + blob + b"\x00" * 64)
+    return path
+
+
+def _tensor(dtype: str, shape: list[int]) -> dict[str, object]:
+    return {"dtype": dtype, "shape": shape, "data_offsets": [0, 1]}
+
+
+def test_fp8_and_int8_single_files_are_prequantized(tmp_path: Path) -> None:
+    fp8 = _write_index(
+        tmp_path / "fp8.safetensors",
+        {
+            "double_blocks.0.img_attn.qkv.weight": _tensor("F8_E4M3", [9216, 3072]),
+            "double_blocks.0.img_attn.qkv.scale": _tensor("F32", []),
+        },
+    )
+    int8 = _write_index(
+        tmp_path / "int8.safetensors",
+        {"double_blocks.0.img_mlp.0.weight": _tensor("I8", [12288, 3072])},
+    )
+    assert V.quantization_of(fp8) == "fp8"
+    assert V.quantization_of(int8) == "int8"
+    assert V.is_prequantized(fp8) and V.is_prequantized(int8)
+
+
+def test_a_scale_on_a_fused_qkv_is_a_repack_even_at_bf16(tmp_path: Path) -> None:
+    """The ConvRot-style repacks keep bf16 weights but add the scale that breaks the converter."""
+    repack = _write_index(
+        tmp_path / "convrot.safetensors",
+        {
+            "double_blocks.0.img_attn.qkv.weight": _tensor("BF16", [9216, 3072]),
+            "double_blocks.0.img_attn.qkv.scale": _tensor("F32", []),
+        },
+    )
+    assert V.quantization_of(repack) == "quantized"
+
+
+def test_rmsnorm_scales_do_not_make_a_plain_checkpoint_look_quantized(tmp_path: Path) -> None:
+    """Every plain FLUX.2 checkpoint carries 80 `norm.*.scale` weights. Matching on the `.scale`
+    suffix alone would refuse to load the one build that actually works."""
+    plain = _write_index(
+        tmp_path / "plain.safetensors",
+        {
+            "double_blocks.0.img_attn.qkv.weight": _tensor("BF16", [9216, 3072]),
+            "double_blocks.0.img_attn.norm.query_norm.scale": _tensor("BF16", [128]),
+            "double_blocks.0.img_attn.norm.key_norm.scale": _tensor("BF16", [128]),
+        },
+    )
+    assert V.quantization_of(plain) is None
+    assert not V.is_prequantized(plain)
+
+
+def test_a_non_checkpoint_is_not_classified(tmp_path: Path) -> None:
+    junk = tmp_path / "notamodel.safetensors"
+    junk.write_bytes(b"\x00" * 64)
+    assert V.quantization_of(junk) is None
+    assert V.quantization_of(tmp_path / "missing.safetensors") is None