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

{inline_core-1.2.65 → 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.65 → inline_core-1.2.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inline-core
-Version: 1.2.65
+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.65 → 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.65"
+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.65 → 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.65 → 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
@@ -205,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
@@ -237,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.65 → inline_core-1.2.66}/tests/test_minimaxh3_training.py

@@ -475,3 +475,15 @@ def test_clip_window_defaults_to_the_start(tmp_path) -> None:
     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.65 → 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)

{inline_core-1.2.65 → inline_core-1.2.66}/tests/test_webui_install.py

@@ -190,8 +190,10 @@ def test_blackwell_gets_an_index_that_has_sm_120_wheels(sandbox: Sandbox) -> Non
     assert done.returncode == 0, done.stderr
     install = sandbox.project_install()
     assert f"{_WHL}/cu130" in install
-    # Without this the pyproject pin wins and the detected index is silently ignored.
-    assert "--no-sources-package torch" in install
+    # Without this the pyproject pin wins and the detected index is silently ignored. The broad
+    # flag, not --no-sources-package torch: that one is too new for the uv versions people have and
+    # hard-errored their install. See test_every_uv_flag_the_launcher_passes_is_real.
+    assert "--no-sources" in install
 
 
 def test_older_cards_get_the_index_that_still_covers_them(sandbox: Sandbox) -> None:
@@ -336,3 +338,36 @@ def test_an_explicit_index_is_reported_as_an_override(sandbox: Sandbox) -> None:
     got = _decision(sandbox, "--torch-index", "cu126")
     assert got["torch-index"] == "cu126"
     assert got["reason"] == "override"
+
+
+# --- the flags we pass must exist in the uv we are talking to ------------------------------------
+
+
+def test_every_uv_flag_the_launcher_passes_is_real(sandbox: Sandbox) -> None:
+    """A stubbed uv accepts anything, so a flag that does not exist sails through every other test
+    here and hard-errors on a user's machine. `--no-sources-package torch` did exactly that: valid
+    in current uv, absent from the version people had, and the install died at the first command.
+
+    Checked against the real uv's help rather than a hardcoded list, so it tracks whatever is
+    installed.
+    """
+    uv = shutil.which("uv")
+    if uv is None:
+        pytest.skip("uv is not installed; nothing to validate the launcher's flags against")
+    help_text = subprocess.run(  # noqa: S603 - fixed argv
+        [uv, "pip", "install", "--help"], capture_output=True, text=True, check=True, timeout=60
+    ).stdout
+
+    sandbox.pretend_windows()
+    sandbox.pretend_nvidia_gpu("8.6", driver="580.82")
+    sandbox.run("--install", "--extra", "runtime")
+
+    passed = {
+        word
+        for call in sandbox.uv_calls()
+        for word in call.split()
+        if word.startswith("--")
+    }
+    assert passed, "the launcher ran no uv command, so this test proves nothing"
+    missing = sorted(flag for flag in passed if flag not in help_text)
+    assert not missing, f"webui.sh passes flags this uv does not have: {missing}"

{inline_core-1.2.65 → inline_core-1.2.66}/webui.bat

@@ -162,12 +162,11 @@ if !CAP_MAJOR! GEQ 10 if !DRIVER_MAJOR! GTR 0 if !DRIVER_MAJOR! LSS 580 (
 if /i "!TORCH_CHOICE!"=="cpu" goto install_cpu_forced
 set "TORCH_URL=https://download.pytorch.org/whl/!TORCH_CHOICE!"
 if /i "!TORCH_CHOICE:~0,4!"=="http" set "TORCH_URL=!TORCH_CHOICE!"
-rem unsafe-best-match: torchao is on the CUDA index too, older there than our torchao>=0.14 pin on
-rem some indexes; without this uv's first-index rule stops at that older copy instead of finding a
-rem new enough one on PyPI. It also makes the +cuXXX local version outrank PyPI's plain one, which
-rem is what pulls the CUDA build in rather than the CPU-only wheel PyPI serves on Windows.
-rem no-sources-package: the pyproject pin names one fixed index, and the card decides here.
-set "TORCH_ARGS=--extra-index-url !TORCH_URL! --index-strategy unsafe-best-match --no-sources-package torch"
+rem unsafe-best-match: without it uv stops at the older torchao on the CUDA index, and PyPI's plain
+rem torch outranks the +cuXXX build on Windows.
+rem no-sources: the pyproject pin names one index, and the card decides here. The broad flag, not
+rem --no-sources-package, which needs uv 0.10+; torch is the only entry so they are equivalent.
+set "TORCH_ARGS=--extra-index-url !TORCH_URL! --index-strategy unsafe-best-match --no-sources"
 echo NVIDIA GPU detected - installing the CUDA build of PyTorch (!TORCH_CHOICE!).
 goto install_pkgs
 
@@ -213,10 +212,8 @@ if /i "!PROBE_STATUS!"=="uncovered" (
 :install_run
 echo + uv pip install --python "!TARGET_PY!" !TORCH_ARGS! -e ".[!EXTRAS!]"
 uv pip install --python "!TARGET_PY!" !TORCH_ARGS! -e ".[!EXTRAS!]" || goto fail
-rem Torch LAST, and through --index-url (exclusive), when the index was named or the installed wheel
-rem is wrong. It cannot ride on the project install: [tool.uv.sources] pins torch to the cu126 index
-rem on win32, and --extra-index-url with unsafe-best-match picks the highest version ACROSS indexes,
-rem which lands back on PyPI's CPU wheel whenever PyPI leads.
+rem Torch LAST and through --index-url (exclusive): [tool.uv.sources] pins it to cu126 on win32,
+rem and --extra-index-url picks the highest version ACROSS indexes, so PyPI's CPU wheel can win.
 if "!TORCH_FORCE!"=="1" if defined TORCH_CHOICE (
   set "TORCH_PINS=torch torchvision"
   rem cu128 is frozen, so the current pair does not exist there. Pin the last one it has.
@@ -240,18 +237,14 @@ echo          .\webui.bat --install --torch-index !TORCH_CHOICE! --recreate
 echo Installed extras: !EXTRAS!. Start with: .\webui.bat
 exit /b 0
 
-rem Reads compute_cap and driver_version in one query, keeping the highest capability seen.
-rem set /a rather than a findstr guard: an old driver answers an unknown query with an error string,
-rem and `if LSS` would STRING-compare it, so "Unknown" would rank above 10 and win. set /a reads a
-rem bare word as an undefined variable and yields 0, which is exactly what we want here, so do not
-rem "fix" it back into a guard later.
+rem One query for both, keeping the highest capability. set /a not a findstr guard: `if LSS` would
+rem string-compare an error string like "Unknown" above 10; set /a yields 0 for it, as intended.
 :read_gpu_probe
 set "CAP_MAJOR=0"
 set "DRIVER_MAJOR=0"
 set "GPU_PROBE_RAW="
-rem Split on the comma ONLY. Including "." here would cut "12.0, 610.88" into 12 / 0 / 610 / 88, so
-rem token 2 would be the capability's minor rather than the driver, and the R580 floor could never
-rem fire. The majors are taken off each field by the inner loops.
+rem Comma ONLY: adding "." would cut "12.0, 610.88" into 12/0/610/88, making token 2 the minor
+rem rather than the driver, so the R580 floor could never fire.
 for /f "usebackq tokens=1,2 delims=," %%c in (`nvidia-smi --query-gpu^=compute_cap^,driver_version --format^=csv^,noheader 2^>nul`) do (
   rem Reset every iteration: set /a errors on garbage and would otherwise leave the previous line's
   rem value in place, double-counting a good line followed by a bad one.

{inline_core-1.2.65 → inline_core-1.2.66}/webui.sh

@@ -200,17 +200,9 @@ read_gpu_probe() {
 #: | override | no-gpu.
 TORCH_INDEX_REASON="autodetect"
 
-# No single index covers every card: Blackwell (sm_100/sm_120) exists only from cu128 on, while cu126
-# is the last index still built for Maxwell..Volta (sm_50..sm_70). Unknown cards get cu126, the one
-# that covers the widest range of what people actually own.
-#
-# Verified 2026-02 and load-bearing: cu128 still SERVES but is frozen at torch 2.11.0, and it was the
-# first index with sm_120. So a Blackwell card on a pre-R580 driver (CUDA 13's floor) gets cu128
-# rather than an error, because it has exactly one workable choice. Re-check that ceiling before
-# trusting this comment in a year.
-# Assigns TORCH_CHOICE and TORCH_INDEX_REASON rather than printing them. It must NOT be called
-# through $(...): a command substitution is a subshell, so the probe globals and the reason would be
-# discarded and only the index would survive. That is what the tests caught.
+# cu126 is the last index built for Maxwell..Volta; sm_100/sm_120 need cu128 or newer. cu128 serves
+# but is frozen at torch 2.11 (checked 2026-02), so it is only for Blackwell below CUDA 13's R580.
+# Assigns rather than prints: through $(...) the probe globals would die in the subshell.
 pick_torch_index() {
   read_gpu_probe
   if [[ -z "$GPU_CAP_MAJOR" ]]; then TORCH_CHOICE="cu126"; return 0; fi
@@ -340,14 +332,12 @@ if [[ "$RUN_INSTALL" -eq 1 ]]; then
   elif [[ -z "$TORCH_CHOICE" ]]; then
     echo "NVIDIA GPU detected - installing the CUDA build of PyTorch."
   else
-    # unsafe-best-match: torchao is on the CUDA index too but older there than our torchao>=0.14 pin
-    # on some indexes; without this uv's first-index rule stops at that older copy instead of
-    # finding a new enough one on PyPI. It also makes the +cuXXX local version outrank PyPI's plain
-    # one, which is what pulls the CUDA build in on Windows.
-    # no-sources-package: the pyproject pin names one fixed index, and the whole point here is that
-    # the card decides.
+    # unsafe-best-match: without it uv stops at the older torchao on the CUDA index, and PyPI's
+    # plain torch outranks the +cuXXX build on Windows.
+    # no-sources: the pyproject pin names one index, and the card decides here. The broad flag, not
+    # --no-sources-package, which needs uv 0.10+; torch is the only entry so they are equivalent.
     TORCH_INDEX=(--extra-index-url "$(torch_index_url "$TORCH_CHOICE")" \
-      --index-strategy unsafe-best-match --no-sources-package torch)
+      --index-strategy unsafe-best-match --no-sources)
     echo "NVIDIA GPU detected - installing the CUDA build of PyTorch ($TORCH_CHOICE)."
   fi
   # A venv reused from a bad install keeps its torch: uv leaves a satisfying version alone, so
@@ -371,11 +361,8 @@ if [[ "$RUN_INSTALL" -eq 1 ]]; then
 
   echo "+ uv pip install --python $TARGET_PY ${TORCH_INDEX[*]} -e .[$EXTRAS]"
   uv pip install --python "$TARGET_PY" "${TORCH_INDEX[@]}" -e ".[$EXTRAS]"
-  # Torch LAST, and through --index-url (exclusive), when the index was named or the installed wheel
-  # is wrong. Two reasons it cannot ride on the project install: [tool.uv.sources] pins torch to the
-  # cu126 index on win32, and --extra-index-url with unsafe-best-match picks the highest version
-  # ACROSS indexes, which lands back on PyPI's CPU wheel whenever PyPI leads. Costs one possibly
-  # wasted download on a path that is rare and deliberate.
+  # Torch LAST and through --index-url (exclusive): [tool.uv.sources] pins it to cu126 on win32,
+  # and --extra-index-url picks the highest version ACROSS indexes, so PyPI's CPU wheel can win.
   if [[ "$TORCH_FORCE" -eq 1 && -n "$TORCH_CHOICE" ]]; then
     read -r -a TORCH_PINS <<<"$(torch_pins_for "$TORCH_CHOICE")"
     TORCH_URL="$(torch_index_url "$TORCH_CHOICE")"