inline-core 1.2.64__tar.gz → 1.2.66__tar.gz

{inline_core-1.2.64 → inline_core-1.2.66}/CLAUDE.md

@@ -126,6 +126,8 @@ between nodes and are never takes.
   every stop/start**, taking the models and leaving dangling symlinks in `models/`. This has cost two
   full re-downloads of MiniMax H3 at ~130 GB each. Weights go on the persistent root volume, or on an
   attached volume that survives a restart. Scratch is fine for logs and temporary output only.
+- **`huggingface_hub>=0.32`** - below it `hf_xet` is only an extra, and files over ~50GB (every
+  H3 transformer) refuse to download at all.
 - **Models root** - `INLINE_MODELS_DIR`, else `./models`. **Bring your own weights; nothing is
   downloaded.** ComfyUI-style category subfolders (`diffusion_models/`, `vae/`, `text_encoders/`,
   `loras/`, `controlnet/`, `checkpoints/`, `clip_vision/`, `upscale_models/`, `embeddings/`). The
@@ -233,6 +235,20 @@ real codec that moves tensors lives with the model runner.
   vision-language encoder loaded in place of a text one, an unnormalized latent, and a control context
   cast to a quantized weight's `uint8` storage dtype. A unit test cannot see a plausible-but-wrong
   image. Render something and look at it.
+- **Launchers are twins.** `webui.sh` and `webui.bat` change together; only the `launcher` CI job
+  can prove the `.bat`, since it cannot run on a dev box.
+- **Match CUDA arches by within-major compatibility, never exactly.** An `sm_8x` cubin runs on any
+  `sm_8y` where `y >= x`, so `sm_86` covers Ada's `sm_89`.
+- **Pass the widest `uv` flag that works.** `--no-sources-package` needs uv 0.10+; `--no-sources`
+  works back to 0.4 and means the same while torch is the only `[tool.uv.sources]` entry.
+- **An explicit user setting beats a heuristic.** Test `on`/`off` before any auto rule, or the
+  control is silently dead for whichever arch the rule excludes.
+- **Report a phase before the slow work, not after.** Progress emitted only on completion makes a
+  slow step look like a hung previous phase.
+- **In a `.bat`, `call` anything that might be a `.bat`.** `nvidia-smi` is sometimes a shim, and
+  without `call` it takes over the script and never returns.
+- **Log allocated AND reserved VRAM.** `nvidia-smi` shows only reserved, so allocator cache and a
+  leaked reference look identical from outside.
 - **Tests (pytest).** Cover the logic that matters: graph validate/topo/executor/cache, the catalog
   scan, the run store + server contract, the device/memory policy, the parallel group + xfuser seam,
   and each model runner (import-guarded, no GPU needed). See `tests/`.

{inline_core-1.2.64 → inline_core-1.2.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inline-core
-Version: 1.2.64
+Version: 1.2.66
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11
@@ -14,7 +14,7 @@ Requires-Dist: controlnet-aux>=0.0.7; extra == 'all'
 Requires-Dist: diffusers==0.39.0; extra == 'all'
 Requires-Dist: einops>=0.7; extra == 'all'
 Requires-Dist: fastapi>=0.110; extra == 'all'
-Requires-Dist: huggingface-hub>=0.23; extra == 'all'
+Requires-Dist: huggingface-hub>=0.32; extra == 'all'
 Requires-Dist: imageio-ffmpeg>=0.4; extra == 'all'
 Requires-Dist: nvidia-ml-py>=12; extra == 'all'
 Requires-Dist: onnxruntime>=1.17; extra == 'all'
@@ -41,7 +41,7 @@ Requires-Dist: accelerate>=0.30; extra == 'runtime'
 Requires-Dist: av>=12; extra == 'runtime'
 Requires-Dist: controlnet-aux>=0.0.7; extra == 'runtime'
 Requires-Dist: diffusers==0.39.0; extra == 'runtime'
-Requires-Dist: huggingface-hub>=0.23; extra == 'runtime'
+Requires-Dist: huggingface-hub>=0.32; extra == 'runtime'
 Requires-Dist: onnxruntime>=1.17; extra == 'runtime'
 Requires-Dist: safetensors>=0.4; extra == 'runtime'
 Requires-Dist: scipy>=1.11; extra == 'runtime'

{inline_core-1.2.64 → inline_core-1.2.66}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.64"
+version = "1.2.66"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -29,7 +29,10 @@ runtime = [
   # Backs the Beta sigma schedule (diffusers gates use_beta_sigmas on scipy).
   "scipy>=1.11",
   # We call snapshot_download directly for the model popup, so pin it rather than rely on transit.
-  "huggingface_hub>=0.23",
+  # 0.32 is where hf_xet became a hard dependency rather than an extra. Below it, Hugging Face
+  # refuses the largest files outright ("too large to be downloaded using the regular download
+  # method"), which is every H3 transformer at 66GB.
+  "huggingface_hub>=0.32",
   # ControlNet preprocessors (the Apply ControlNet node): OpenPose/DWPose, MiDaS/Zoe depth, canny,
   # HED, lineart, MLSD, scribble, normal. DWPose runs its detector on ONNX Runtime.
   "controlnet-aux>=0.0.7",
@@ -85,7 +88,10 @@ all = [
   # Clip decode for MiniMax H3 LoRA training, and H3's reference node.
   "av>=12",
   "scipy>=1.11",
-  "huggingface_hub>=0.23",
+  # 0.32 is where hf_xet became a hard dependency rather than an extra. Below it, Hugging Face
+  # refuses the largest files outright ("too large to be downloaded using the regular download
+  # method"), which is every H3 transformer at 66GB.
+  "huggingface_hub>=0.32",
   "controlnet-aux>=0.0.7",
   "onnxruntime>=1.17",
   # server
@@ -111,8 +117,10 @@ name = "pytorch-cu126"
 url = "https://download.pytorch.org/whl/cu126"
 explicit = true
 
-# Launcher installs pass `--no-sources-package torch` so their detected index wins over this pin;
-# anything else added to this table would still apply to them.
+# Launcher installs pass `--no-sources` so their detected index wins over this pin. That flag is
+# broad rather than per-package because the per-package form is too new for the uv versions people
+# have. torch being the ONLY entry here is what makes that equivalent: adding another would silently
+# start ignoring it on launcher installs too.
 [tool.uv.sources]
 torch = [{ index = "pytorch-cu126", marker = "sys_platform == 'win32'" }]
 

{inline_core-1.2.64 → inline_core-1.2.66}/src/inline_core/device/detect.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable
+from string import ascii_letters
+
 from .types import Device, DeviceKind
 
 
@@ -80,6 +83,37 @@ def cpu_only_torch_warning() -> str | None:
     )
 
 
+def _parse_arch(arch: str) -> tuple[int, int] | None:
+    """``sm_120`` to ``(12, 0)``.
+
+    The minor is the **last digit** and the major is everything before it, so ``sm_100`` is (10, 0).
+    Reading left to right instead gives (1, 20) and puts the bug precisely on the Blackwell parts.
+    Tuned variants (``sm_90a``) drop their trailing letters.
+    """
+    digits = arch[3:].rstrip(ascii_letters)
+    if len(digits) < 2 or not digits.isdigit():
+        return None
+    return int(digits[:-1]), int(digits[-1])
+
+
+def arch_list_covers(arches: Iterable[str], major: int, minor: int) -> bool:
+    """Whether a wheel's arch list has kernels that will run on a ``(major, minor)`` device.
+
+    CUDA binary compatibility runs **upward within one major only**: an ``sm_8x`` cubin executes on
+    any ``sm_8y`` where ``y >= x``. So ``sm_86`` covers an sm_89 Ada card, which is why exact
+    matching told every RTX 40-series owner their install was broken. Crossing a major never works,
+    so ``sm_90`` does not cover sm_120 and the Blackwell warning stays correct.
+
+    PTX entries (``compute_90``) JIT forward but are not matched here: they do not start with
+    ``sm_``, so a PTX-carrying wheel still warns. Rare, and warning is the safe way to be wrong.
+    """
+    for arch in arches:
+        parsed = _parse_arch(arch)
+        if parsed is not None and parsed[0] == major and parsed[1] <= minor:
+            return True
+    return False
+
+
 def unsupported_arch_warning() -> str | None:
     """A warning when the installed torch has no kernels for the GPU it is about to run on.
 
@@ -105,16 +139,15 @@ def unsupported_arch_warning() -> str | None:
             return None  # a CPU-only build; cpu_only_torch_warning owns that case
         major, minor = get_capability(0)
         target = f"sm_{major}{minor}"
-        # startswith, because a wheel lists tuned variants like sm_90a for the same architecture.
-        if any(arch.startswith(target) for arch in arches):
+        if arch_list_covers(arches, major, minor):
             return None
         name = _device_name(torch) or "The detected NVIDIA GPU"
         return (
             f"{name} is compute capability {target}, but this install's PyTorch only has kernels "
             f"for {' '.join(arches)}. Generation will fail or fall back to the CPU. Re-run "
             "`webui.sh --install` (Windows: `.\\webui.bat --install`) to pick the wheel index that "
-            "matches the card, or force one with `--torch-index cu130` - `cu128` if the driver "
-            "predates CUDA 13."
+            "matches the card, or force one with `--torch-index cu130`. On a Blackwell card whose "
+            "driver predates R580, use `cu128`, which still has sm_120 but is frozen at torch 2.11."
         )
     except Exception:  # noqa: BLE001 - a diagnostic must never break startup
         return None

inline_core-1.2.66/src/inline_core/device/probe.py

@@ -0,0 +1,76 @@
+"""Install-time probe: which torch is installed, and does it have kernels for this card?
+
+Run as ``python -m inline_core.device.probe`` by both launchers. They cannot share the
+compatibility rule any other way, and restating it in bash and batch is how the two drift.
+
+Always prints one JSON object and always exits 0, so a shell branches on ``status`` rather than
+parsing stderr. A **nonzero exit means the probe itself failed**, which callers must treat as
+unknown and never as covered.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from typing import Any
+
+from .detect import arch_list_covers
+
+#: A local version tag we recognise as a pytorch.org build, e.g. ``2.13.0+cu130`` or ``2.9.0+cpu``.
+#: Only these are safe to replace automatically: a ROCm build, a nightly or a hand-built wheel will
+#: also fail the arch check, and silently reinstalling over someone's deliberate choice is worse
+#: than the wrong wheel.
+_REPLACEABLE_LOCAL = re.compile(r"\+(?:cpu|cu\d+)$")
+
+
+def probe() -> dict[str, Any]:
+    """What the launcher needs to decide whether to replace torch. Never raises."""
+    out: dict[str, Any] = {
+        "status": "unknown",
+        "torch": None,
+        "cuda": None,
+        "archList": [],
+        "capability": None,
+        "replaceable": False,
+    }
+    try:
+        import torch
+    except Exception:  # noqa: BLE001 - no torch yet is a normal first install
+        out["status"] = "no-torch"
+        return out
+
+    try:
+        out["torch"] = str(torch.__version__)
+        out["cuda"] = getattr(torch.version, "cuda", None)
+        out["replaceable"] = bool(_REPLACEABLE_LOCAL.search(out["torch"]))
+        # HIP reports gfx arches through the sm_ call, so the rule does not apply. Never
+        # auto-replace a ROCm build.
+        if getattr(torch.version, "hip", None):
+            out["status"] = "rocm"
+            out["replaceable"] = False
+            return out
+        arches = [str(a) for a in torch.cuda.get_arch_list() if str(a).startswith("sm_")]
+        out["archList"] = arches
+        if not arches:
+            out["status"] = "cpu-only"
+            return out
+        if torch.cuda.device_count() < 1:
+            out["status"] = "no-gpu"
+            return out
+        major, minor = torch.cuda.get_device_capability(0)
+        out["capability"] = [major, minor]
+        out["status"] = "covered" if arch_list_covers(arches, major, minor) else "uncovered"
+    except Exception:  # noqa: BLE001 - a broken torch is exactly what we are here to detect
+        out["status"] = "unknown"
+    return out
+
+
+def main() -> int:
+    json.dump(probe(), sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{inline_core-1.2.64 → inline_core-1.2.66}/src/inline_core/models/minimaxh3/load.py

@@ -157,6 +157,14 @@ def load_transformer(
 
     if lora_plan:
         _finish_fuse(model, lora_plan, fused)
+        # Announced because a fused LoRA is otherwise invisible: it changes the weights and nothing
+        # else, so a run with no adapter and a run with one that never arrived look identical in
+        # the log, and the only way to tell them apart was to render twice and compare.
+        logger.info(
+            "MiniMax H3: fused %d LoRA layer(s) from %s",
+            len(lora_plan),
+            ", ".join(f"{Path(ref.file).name}@{ref.strength:g}" for ref in loras),
+        )
     _assert_nothing_left_on_meta(model, filled)
     model.eval()
     return model

{inline_core-1.2.64 → inline_core-1.2.66}/src/inline_core/training/cache.py

@@ -30,6 +30,7 @@ def build(
     flip: bool = False,
     dropout: float = 0.0,
     clip_frames: int = 1,
+    clip_window: str = "start",
     on_status: Callable[[str], None] | None = None,
 ) -> tuple[list[dict[str, Any]], dict[str, Any] | None, float]:
     """Return ``(items, unconditional, shift)``, all as CPU tensors, with the encoders freed.
@@ -43,7 +44,7 @@ def build(
 
         items, unconditional = h3.precache(
             dataset_dir, models_dir, device, dtype, resolution, flip, dropout > 0, clip_frames,
-            on_status=on_status,
+            clip_window=clip_window, on_status=on_status,
         )
         return items, unconditional, _H3_SHIFT
 

{inline_core-1.2.64 → inline_core-1.2.66}/src/inline_core/training/h3.py

@@ -44,6 +44,7 @@ def precache(
     flip: bool,
     want_unconditional: bool,
     clip_frames: int = 1,
+    clip_window: str = "start",
     on_status: Callable[[str], None] | None = None,
 ) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
     """Every image as a latent and every caption as conditioning, as CPU tensors."""
@@ -57,7 +58,9 @@ def precache(
     root = Path(models_dir)
     # Only the clips that survived encoding carry captions, or every caption after the first skip
     # would be paired with the wrong latent.
-    latents, kept = _encode_pixels(root, pairs, device, resolution, flip, clip_frames, say)
+    latents, kept = _encode_pixels(
+        root, pairs, device, resolution, flip, clip_frames, say, clip_window
+    )
     if not kept:
         raise RuntimeError(
             f"None of the {len(pairs)} dataset items could be encoded. For clips, each must be at "
@@ -89,6 +92,7 @@ def precache(
 def _encode_pixels(
     root: Path, pairs: list[tuple[Path, str]], device: str, resolution: int, flip: bool,
     clip_frames: int = 1, say: Callable[[str], None] = lambda _text: None,
+    clip_window: str = "start",
 ) -> tuple[list[Any], list[tuple[Path, str]]]:
     """Pass one: the video VAE, then dropped. Returns the latents and the pairs they came from."""
     import numpy
@@ -114,7 +118,9 @@ def _encode_pixels(
         for index, (path, _caption) in enumerate(pairs, start=1):
             clip = ds.is_video(path)
             try:
-                frames = _clip_frames(path, clip_frames) if clip else [Image.open(path)]
+                frames = (
+                    _clip_frames(path, clip_frames, clip_window) if clip else [Image.open(path)]
+                )
             except ShortClipError as exc:
                 skipped.append(path.name)
                 say(f"skipped {exc}")
@@ -151,11 +157,14 @@ class ShortClipError(RuntimeError):
     not throw away a precache that takes many minutes."""
 
 
-def _clip_frames(path: Path, clip_frames: int) -> list[Any]:
-    """A clip as PIL frames on H3's 24fps, 17n+5 grid, taken from the start.
+def _clip_frames(path: Path, clip_frames: int, window: str = "start") -> list[Any]:
+    """A clip as PIL frames on H3's 24fps, 17n+5 grid.
 
     Trimmed rather than sampled: a fixed window keeps the precache to one encode per clip, and
     re-encoding a different window every step would defeat caching the latents at all.
+
+    The grid only snaps **down**, so some of every clip is always dropped. ``window="end"`` takes
+    the tail instead of the head, for footage whose action is at the finish.
     """
     from PIL import Image
 
@@ -173,7 +182,8 @@ def _clip_frames(path: Path, clip_frames: int) -> list[Any]:
             f"{path.name} is {frames.shape[0]} frames once resampled to {_H3_FPS}fps, below H3's "
             f"{keep}-frame minimum ({keep / _H3_FPS:.2f}s). Skipped."
         )
-    return [Image.fromarray(frame) for frame in frames[:keep]]
+    kept = frames[-keep:] if window == "end" else frames[:keep]
+    return [Image.fromarray(frame) for frame in kept]
 
 
 def _encode_captions(

{inline_core-1.2.64 → inline_core-1.2.66}/src/inline_core/training/models.py

@@ -325,20 +325,23 @@ def resolve_offload(
 ) -> bool:
     """Whether to stream saved activations to host RAM this run.
 
-    Only meaningful for a full-precision (bf16) base: the point is to keep the 26GB Krea 2 base
-    resident and fit the ~21GB of 1024 activations elsewhere, rather than dropping the frozen base
-    to NF4. A quantized base already fits, so offload just adds PCIe traffic for nothing. ``auto``
-    turns it on exactly when the bf16 plan would otherwise not fit VRAM; ``on``/``off`` force it."""
+    ``auto`` was written for a full-precision base: keep the 26GB Krea 2 base resident and put the
+    ~21GB of 1024 activations elsewhere, rather than dropping the frozen base to NF4. Under a
+    quantized base ``auto`` stays off, because there the base is the whole story and offload would
+    buy PCIe traffic for nothing.
+
+    ``on``/``off`` are tested before the quant rule, or the control is dead for MiniMax H3 (always
+    4-bit), whose base is small and whose clip activations are what overflow the card."""
     from ..device.policy import Quantization
 
     if pref == "off":
         return False
-    if quant is not Quantization.NONE:
-        return False  # a quantized base already fits; offload would only slow it down
     if pref == "on":
         return True
     if pref not in ("auto", ""):
         raise RuntimeError(f"Unknown offload preference {pref!r}.")
+    if quant is not Quantization.NONE:
+        return False  # auto only: a quantized base already fits, so do not pay for offload
 
     import torch
 

{inline_core-1.2.64 → inline_core-1.2.66}/src/inline_core/training/trainer.py

@@ -119,6 +119,20 @@ def _peak_vram_gb() -> float | None:
     return round(torch.cuda.max_memory_allocated() / 1e9, 2)
 
 
+def _vram_note(label: str) -> str:
+    """Both numbers: nvidia-smi shows only reserved, so allocator cache and a leaked reference look
+    identical from outside."""
+    import torch
+
+    if not torch.cuda.is_available():
+        return label
+    gb = 1e9
+    return (
+        f"{label}: allocated {torch.cuda.memory_allocated() / gb:.1f}GB, "
+        f"reserved {torch.cuda.memory_reserved() / gb:.1f}GB"
+    )
+
+
 def _activation_offload(enabled: bool) -> Any:
     """A context that streams saved activations to host RAM (pinned) for the forward, pulling them
     back on backward. Keeps a full-precision base resident on a card that could not otherwise hold
@@ -184,6 +198,7 @@ def train(manifest: dict[str, Any]) -> str | None:
         manifest["datasetDir"], manifest["modelsDir"], arch.key, str(device), dtype, resolution,
         flip=bool(hp.get("flipAugment")), dropout=dropout,
         clip_frames=archs.clip_frames(arch, hp.get("clipSeconds")),
+        clip_window=str(hp.get("clipWindow") or "start"),
         on_status=lambda text: protocol.progress(0, steps, status=text),
     )
 
@@ -204,9 +219,11 @@ def train(manifest: dict[str, Any]) -> str | None:
     )
     plan = quant.value + (" + cpu offload" if offload else "")
     protocol.progress(0, steps, status=f"loading model ({plan})")
+    print(_vram_note("VRAM after caching, before the base loads"), flush=True)
     transformer = models.load_transformer(
         manifest["modelsDir"], arch.key, manifest["baseMode"], str(device), dtype, quant
     )
+    print(_vram_note("VRAM after the base loaded"), flush=True)
     transformer.requires_grad_(False)
     # PEFT picks its bitsandbytes-aware LoRA layer off this one attribute. Without it, and because
     # bnb's Linear4bit subclasses nn.Linear, the generic dispatcher matches instead: grads still
@@ -236,6 +253,10 @@ def train(manifest: dict[str, Any]) -> str | None:
     signal.signal(signal.SIGTERM, stop)
 
     transformer.train()
+    # Before the first step, not after: emitting only on completion makes a slow step one look like
+    # the loader is still running.
+    print(_vram_note("VRAM entering the training loop"), flush=True)
+    protocol.progress(start, steps, status="training")
     for step in range(start, steps):
         if stop.flagged:
             break

{inline_core-1.2.64 → inline_core-1.2.66}/tests/test_device_detect.py

@@ -192,3 +192,132 @@ def test_silent_without_torch(monkeypatch) -> None:
     monkeypatch.setattr(builtins, "__import__", _no_torch)
     monkeypatch.delitem(__import__("sys").modules, "torch", raising=False)
     assert detect.cpu_only_torch_warning() is None
+
+
+# --- CUDA within-major binary compatibility -----------------------------------------------------
+#
+# A cubin built for sm_8x runs on any sm_8y where y >= x, so sm_86 covers an sm_89 Ada card. Exact
+# per-minor matching told every RTX 40-series owner their install was broken.
+
+_CU130_ARCHES = ["sm_75", "sm_80", "sm_86", "sm_90", "sm_100", "sm_120"]
+
+
+def test_arch_parse_reads_the_minor_as_the_last_digit() -> None:
+    """sm_120 is (12, 0), not (1, 20). Left-to-right puts the bug on the Blackwell parts."""
+    assert detect._parse_arch("sm_120") == (12, 0)
+    assert detect._parse_arch("sm_100") == (10, 0)
+    assert detect._parse_arch("sm_90a") == (9, 0)  # tuned variant
+    assert detect._parse_arch("compute_90") is None
+
+
+def test_ada_is_covered_by_ampere_kernels(monkeypatch) -> None:
+    """The RTX 4080 false positive: sm_89 against a wheel whose newest 8.x is sm_86."""
+    monkeypatch.setitem(
+        __import__("sys").modules,
+        "torch",
+        _fake_arch_torch(capability=(8, 9), arches=_CU124_ARCHES),
+    )
+    assert detect.unsupported_arch_warning() is None
+
+
+def test_compatibility_runs_upward_only(monkeypatch) -> None:
+    """An sm_86 cubin does NOT run on an sm_80 A100, so that must still warn."""
+    monkeypatch.setitem(
+        __import__("sys").modules,
+        "torch",
+        _fake_arch_torch(capability=(8, 0), arches=["sm_86"]),
+    )
+    assert detect.unsupported_arch_warning() is not None
+
+
+def test_a_dropped_architecture_still_warns(monkeypatch) -> None:
+    """cu130 dropped Volta; sm_70 has no same-major kernel at or below it."""
+    monkeypatch.setitem(
+        __import__("sys").modules,
+        "torch",
+        _fake_arch_torch(capability=(7, 0), arches=_CU130_ARCHES),
+    )
+    assert detect.unsupported_arch_warning() is not None
+
+
+def test_blackwell_majors_do_not_cover_each_other() -> None:
+    """sm_100 and sm_120 are both Blackwell but different majors, so neither covers the other."""
+    assert detect.arch_list_covers(["sm_100"], 12, 0) is False
+    assert detect.arch_list_covers(["sm_120"], 10, 0) is False
+    assert detect.arch_list_covers(_CU130_ARCHES, 10, 0) is True
+    assert detect.arch_list_covers(_CU130_ARCHES, 12, 0) is True
+
+
+# --- the install-time probe --------------------------------------------------------------------
+
+
+def _fake_probe_torch(
+    *, version: str, arches: list[str], capability: tuple[int, int] | None = (12, 0),
+    hip: str | None = None, devices: int = 1,
+) -> types.SimpleNamespace:
+    return types.SimpleNamespace(
+        __version__=version,
+        version=types.SimpleNamespace(cuda=None if "+cpu" in version else "12.8", hip=hip),
+        cuda=types.SimpleNamespace(
+            device_count=lambda: devices,
+            get_arch_list=lambda: arches,
+            get_device_capability=lambda i=0: capability,
+        ),
+    )
+
+
+def _probe_with(monkeypatch, torch_stub) -> dict:
+    from inline_core.device import probe as probe_mod
+
+    monkeypatch.setitem(__import__("sys").modules, "torch", torch_stub)
+    return probe_mod.probe()
+
+
+def test_probe_reports_an_uncovered_wheel_as_replaceable(monkeypatch) -> None:
+    """The 5060 Ti case: a cu126 wheel on sm_120, and the +cuXXX tag makes it safe to replace."""
+    got = _probe_with(
+        monkeypatch, _fake_probe_torch(version="2.9.0+cu126", arches=_CU124_ARCHES)
+    )
+    assert got["status"] == "uncovered"
+    assert got["replaceable"] is True
+
+
+def test_probe_reports_ada_as_covered(monkeypatch) -> None:
+    got = _probe_with(
+        monkeypatch,
+        _fake_probe_torch(version="2.13.0+cu130", arches=_CU130_ARCHES, capability=(8, 9)),
+    )
+    assert got["status"] == "covered"
+
+
+def test_probe_never_offers_to_replace_a_rocm_build(monkeypatch) -> None:
+    """The safety gate. A ROCm build fails the sm_ rule too, and reinstalling over someone's
+    deliberate choice is worse than the wrong wheel."""
+    got = _probe_with(
+        monkeypatch,
+        _fake_probe_torch(version="2.9.0+rocm6.2", arches=[], hip="6.2.0"),
+    )
+    assert got["status"] == "rocm"
+    assert got["replaceable"] is False
+
+
+def test_probe_never_offers_to_replace_an_untagged_build(monkeypatch) -> None:
+    """A nightly or hand-built wheel carries no +cpu/+cuXXX tag, so leave it alone."""
+    got = _probe_with(
+        monkeypatch, _fake_probe_torch(version="2.14.0.dev20260101", arches=_CU124_ARCHES)
+    )
+    assert got["status"] == "uncovered"
+    assert got["replaceable"] is False
+
+
+def test_probe_survives_a_broken_torch(monkeypatch) -> None:
+    """Never covered on uncertainty: a torch that raises must read as unknown."""
+    class Boom:
+        __version__ = "2.13.0+cu130"
+
+        def __getattr__(self, _name: str):
+            raise RuntimeError("broken install")
+
+    got = _probe_with(monkeypatch, Boom())
+    assert got["status"] == "unknown"
+    assert got["status"] != "covered"

{inline_core-1.2.64 → inline_core-1.2.66}/tests/test_minimaxh3_training.py

@@ -452,3 +452,38 @@ def test_long_enough_clip_encodes_on_the_frame_grid(tmp_path) -> None:
     frames = h3._clip_frames(clip, clip_frames=24)
     # Snapped down onto H3's 17n+5 grid rather than taking all 40.
     assert len(frames) == 22
+
+
+def test_clip_window_takes_the_tail_when_asked(tmp_path) -> None:
+    """The 17n+5 grid only snaps down, so part of every clip is dropped. A user whose action sits in
+    the last half second needs the tail rather than the head."""
+    from inline_core.training import h3
+
+    clip = _write_clip(tmp_path / "ramp.mp4", frames=40)
+    head = h3._clip_frames(clip, clip_frames=24, window="start")
+    tail = h3._clip_frames(clip, clip_frames=24, window="end")
+
+    assert len(head) == len(tail) == 22
+    # The fixture ramps brightness per frame, so the two windows cannot be the same footage.
+    assert head[0].getpixel((0, 0)) != tail[0].getpixel((0, 0))
+
+
+def test_clip_window_defaults_to_the_start(tmp_path) -> None:
+    from inline_core.training import h3
+
+    clip = _write_clip(tmp_path / "ramp2.mp4", frames=40)
+    assert h3._clip_frames(clip, clip_frames=24)[0].getpixel((0, 0)) == (
+        h3._clip_frames(clip, clip_frames=24, window="start")[0].getpixel((0, 0))
+    )
+
+
+def test_the_loop_reports_training_before_the_first_step(monkeypatch) -> None:
+    """Emitted only on completion, a slow step one reads as a hung loader."""
+    import inspect
+
+    from inline_core.training import trainer
+
+    source = inspect.getsource(trainer.train)
+    enters_loop = source.index("for step in range(start, steps):")
+    announces = source.index('status="training"')
+    assert announces < enters_loop, "the training status must be sent before the loop, not after"

{inline_core-1.2.64 → inline_core-1.2.66}/tests/test_training_models.py

@@ -97,8 +97,8 @@ def test_auto_quantization_accounts_for_resolution(monkeypatch, tmp_path) -> Non
 
 def test_offload_fits_a_bf16_base_that_would_not_otherwise(monkeypatch, tmp_path) -> None:
     """bf16 1024 on a 45GB card: base (26GB) + activations (~21GB) overflow, so auto-offload turns
-    on to keep the base full precision rather than dropping it to NF4. A quantized base already
-    fits, so offload stays off there no matter the preference."""
+    on to keep the base full precision rather than dropping it to NF4. Under a quantized base AUTO
+    stays off, but an explicit on/off is the user's answer and wins."""
     root = tmp_path / "models"
     (root / "diffusion_models").mkdir(parents=True)
     (root / "diffusion_models" / "krea2_raw_bf16.safetensors").write_bytes(b"")
@@ -120,8 +120,10 @@ def test_offload_fits_a_bf16_base_that_would_not_otherwise(monkeypatch, tmp_path
     assert off("auto", Quantization.NONE, str(root), archs.KREA2, "raw", 512) is False
     assert off("on", Quantization.NONE, str(root), archs.KREA2, "raw", 512) is True
     assert off("off", Quantization.NONE, str(root), archs.KREA2, "raw", 1024) is False
-    # A quantized base already fits, so offload would only add PCIe traffic - never on.
-    assert off("on", Quantization.NF4, str(root), archs.KREA2, "raw", 1024) is False
+    # Auto stays off under a quantized base; an explicit choice wins.
+    assert off("auto", Quantization.NF4, str(root), archs.KREA2, "raw", 1024) is False
+    assert off("on", Quantization.NF4, str(root), archs.KREA2, "raw", 1024) is True
+    assert off("off", Quantization.NF4, str(root), archs.KREA2, "raw", 1024) is False
 
 
 def test_zimage_has_no_four_bit_path_and_says_so(tmp_path) -> None:
@@ -198,3 +200,26 @@ def test_fails_open_when_the_machine_cannot_be_read(monkeypatch) -> None:
     _fake_env(monkeypatch, mode=0, ram_gib=30, size_gib=62)
     monkeypatch.setattr(models, "_base_size", lambda *a: 0)
     models.check_base_mappable("/m", "minimax-h3", "raw")
+
+
+def test_an_explicit_offload_choice_beats_the_quant_heuristic(monkeypatch, tmp_path) -> None:
+    """Dead for H3, always 4-bit, whose clip activations are what overflow the card."""
+    from inline_core.device.policy import Quantization
+
+    root = tmp_path / "models"
+    (root / "diffusion_models").mkdir(parents=True)
+    monkeypatch.setattr(models, "_base_size", lambda *a: 12 * 1024**3)
+    off = models.resolve_offload
+
+    assert off("on", Quantization.NF4, str(root), archs.MINIMAX_H3, "raw", 512) is True
+    assert off("off", Quantization.NF4, str(root), archs.MINIMAX_H3, "raw", 512) is False
+    assert off("auto", Quantization.NF4, str(root), archs.MINIMAX_H3, "raw", 512) is False
+
+
+def test_an_unknown_offload_preference_still_raises(monkeypatch, tmp_path) -> None:
+    """The reorder must not let a typo fall through to the auto path and silently mean 'off'."""
+    from inline_core.device.policy import Quantization
+
+    monkeypatch.setattr(models, "_base_size", lambda *a: 12 * 1024**3)
+    with pytest.raises(RuntimeError):
+        models.resolve_offload("yes", Quantization.NF4, str(tmp_path), archs.MINIMAX_H3, "raw", 512)