inline-core 1.2.2__tar.gz → 1.2.3__tar.gz

{inline_core-1.2.2 → inline_core-1.2.3}/CLAUDE.md

@@ -82,8 +82,6 @@ HTTP/WS  →  server/app.py  →  RunManager  →  Executor  →  Registry (desc
 - **`runtime/`** - `context.py` (`ExecutionContext`, `CancelToken`), `run.py` (`RunState`),
   `progress.py` (events + emitters), `store.py` / `file_store.py` (`TakeStore`: owns take bytes/hash/
   uri).
-- **`importer/`** - `comfy.py`: best-effort ComfyUI-workflow → Inline-Core-graph mapping. All ComfyUI
-  format knowledge lives here.
 - **`config.py`** - all env config, small and explicit. **`takes.py`**, **`media.py`**, **`errors.py`**
   - domain primitives (`Take`/`AssetRef`, `MediaKind`, the error hierarchy).
 
@@ -200,13 +198,13 @@ real codec that moves tensors lives with the model runner.
   subpackages import torch/diffusers at module top **on purpose**: an absent extra makes the import
   raise, and `server/bootstrap.py` skips that model best-effort so a core install still boots and
   serves source nodes. Never import a heavy dep at package top level outside a runner subpackage.
-- **Engine isolation.** All ComfyUI-format knowledge lives in `importer/comfy.py`; all xDiT/worker
-  knowledge behind `parallel/` and the sampler seam. Don't scatter it.
+- **Engine isolation.** All xDiT/worker knowledge lives behind `parallel/` and the sampler seam.
+  Don't scatter it.
 - **Bring-your-own models.** Nothing is downloaded by the engine. The catalog scans; the user places
   files. A model picker is a `SELECT` param with `options_from="<category>"`.
 - **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,
-  the comfy importer, and each model runner (import-guarded, no GPU needed). See `tests/`.
+  and each model runner (import-guarded, no GPU needed). See `tests/`.
 - **Commits.** Conventional Commits (`feat:`, `fix:`, `chore:`), small and scoped.
 
 ## Commands
@@ -239,4 +237,3 @@ uv run pytest -q                          # tests (no GPU; model code is import-
   as `{error:{code,message}}` with the right status. Update the API list in `README.md`.
 - **New port/handle type** → `PortKind` in `graph/schema.py` (+ `port_satisfies` if it has coercions).
 - **New device/memory behaviour** → behind `DevicePolicy` in `device/`; never in a component.
-- **New ComfyUI import behaviour** → `importer/comfy.py` only.

{inline_core-1.2.2 → inline_core-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inline-core
-Version: 1.2.2
+Version: 1.2.3
 Summary: The generation engine behind Inline Studio.
 Requires-Python: >=3.11
 Requires-Dist: numpy>=1.26
@@ -53,7 +53,7 @@ already supports, so the multi-GPU split works on it from the start).
 > Status: early, and running end to end against a stub engine. In place and tested: the graph engine,
 > the typed `/v1` HTTP + websocket API (durable runs, streamed progress, coalescing), the model-dir
 > scan, the device + memory policy (profiles, dtype, offload, int8), the low-level primitive node
-> vocabulary, and a ComfyUI workflow importer. The Z-Image loader is written and validates on a GPU.
+> vocabulary. The Z-Image loader is written and validates on a GPU.
 > Cross-request batching, single-image multi-GPU (an xDiT worker group behind the sampler seam, with
 > the policy and IPC round-trip tested), and out-of-process custom nodes are built as seams but not
 > yet running on real hardware.
@@ -131,8 +131,7 @@ Underneath, a **low-level primitive vocabulary** exists (`load/diffusion-model`,
 `load/text-encoder`, `encode/text`, `latent/empty`, `sample`, `vae/decode`, `vae/encode`) - the
 ComfyUI-equivalent decomposed graph, kept for validation/execution - but these are marked **`hidden`**
 and never appear in the add-node menu. Engine handles (`model`, `vae`, `text-encoder`, `conditioning`,
-`latent`) are typed sockets between nodes; only media outputs become Frames with take history. A
-best-effort ComfyUI importer maps existing workflows onto the primitives.
+`latent`) are typed sockets between nodes; only media outputs become Frames with take history.
 
 ## Multi-GPU: split one image across GPUs
 

{inline_core-1.2.2 → inline_core-1.2.3}/README.md

@@ -11,7 +11,7 @@ already supports, so the multi-GPU split works on it from the start).
 > Status: early, and running end to end against a stub engine. In place and tested: the graph engine,
 > the typed `/v1` HTTP + websocket API (durable runs, streamed progress, coalescing), the model-dir
 > scan, the device + memory policy (profiles, dtype, offload, int8), the low-level primitive node
-> vocabulary, and a ComfyUI workflow importer. The Z-Image loader is written and validates on a GPU.
+> vocabulary. The Z-Image loader is written and validates on a GPU.
 > Cross-request batching, single-image multi-GPU (an xDiT worker group behind the sampler seam, with
 > the policy and IPC round-trip tested), and out-of-process custom nodes are built as seams but not
 > yet running on real hardware.
@@ -89,8 +89,7 @@ Underneath, a **low-level primitive vocabulary** exists (`load/diffusion-model`,
 `load/text-encoder`, `encode/text`, `latent/empty`, `sample`, `vae/decode`, `vae/encode`) - the
 ComfyUI-equivalent decomposed graph, kept for validation/execution - but these are marked **`hidden`**
 and never appear in the add-node menu. Engine handles (`model`, `vae`, `text-encoder`, `conditioning`,
-`latent`) are typed sockets between nodes; only media outputs become Frames with take history. A
-best-effort ComfyUI importer maps existing workflows onto the primitives.
+`latent`) are typed sockets between nodes; only media outputs become Frames with take history.
 
 ## Multi-GPU: split one image across GPUs
 

{inline_core-1.2.2 → inline_core-1.2.3}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.2"
+version = "1.2.3"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 requires-python = ">=3.11"

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/extensions/fetch.py

@@ -49,12 +49,18 @@ def remote_sha(url: str, ref: str) -> str | None:
     an update check must never fail the dialog."""
     try:
         _validate(url, ref)
-        done = _git("ls-remote", url, ref, check=False)
+        # Also request the peeled ref: an exact-match pattern alone won't return the `^{}` line.
+        done = _git("ls-remote", url, ref, f"{ref}^{{}}", check=False)
     except (FetchError, OSError, subprocess.SubprocessError):
         return None
     if done.returncode != 0:
         return None
-    line = done.stdout.strip().split("\n")[0]
+    lines = [ln for ln in done.stdout.splitlines() if ln.strip()]
+    # An annotated tag lists its own object sha first and the commit it points to on a `^{}` line.
+    # Prefer the peeled commit, since the installed sha is a commit (`_resolve` uses `^{commit}`) -
+    # otherwise every annotated-tag release reads as perpetually "update available".
+    peeled = next((ln for ln in lines if ln.rstrip().endswith("^{}")), None)
+    line = peeled or (lines[0] if lines else "")
     sha = line.split()[0] if line else ""
     return sha or None
 

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/server/__main__.py

@@ -10,6 +10,12 @@ import os as _os
 # `python -m inline_core.server`. A user-set value always wins.
 _os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
 
+# XET download acceleration tracks its bytes internally, so a model download reports no per-chunk
+# progress - the popup's bar would sit at 0% then snap to done. The plain HTTP path streams a real
+# fraction (and still resumes). huggingface_hub reads this at import, so it must be set before then.
+# A user-set value always wins.
+_os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
+
 import uvicorn
 
 from ..config import data_dir, server_host, server_port
@@ -60,7 +66,6 @@ def main() -> None:
     store = StudioStore(
         studio_config.data_dir(),
         studio_config.workspace_dir(),
-        default_comfy_url=studio_config.DEFAULT_COMFY_URL,
         default_core_url=studio_config.DEFAULT_CORE_URL,
     )
     print(f"Studio data: {studio_config.data_dir()}  |  workspace: {studio_config.workspace_dir()}")

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/studio/config.py

@@ -12,7 +12,6 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
-DEFAULT_COMFY_URL = os.environ.get("COMFYUI_URL") or "http://127.0.0.1:8188"
 DEFAULT_CORE_URL = os.environ.get("INLINE_CORE_URL") or "http://127.0.0.1:8848"
 
 

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/studio/frames.py

@@ -43,8 +43,8 @@ def _parse_params(raw: str | None) -> dict[str, Any]:
 
 
 def _row_to_frame(row: sqlite3.Row) -> dict[str, Any]:
-    provider = row["provider"]
-    provider = provider if provider in ("fal", "unset", "core") else "comfy"
+    # A legacy 'comfy' row (ComfyUI removed) passes through unchanged; the UI renders it as a plain
+    # viewer. NULL/empty defaults to 'unset'.
     return {
         "id": row["id"],
         "sequenceId": row["sequence_id"],
@@ -53,12 +53,10 @@ def _row_to_frame(row: sqlite3.Row) -> dict[str, Any]:
         "position": row["position"],
         "inputAssetId": row["input_asset_id"],
         "heroTakeId": row["hero_take_id"],
-        "provider": provider,
+        "provider": row["provider"] or "unset",
         "modelId": row["model_id"],
         "params": _parse_params(row["params"]),
         "workflowTemplateId": row["workflow_template_id"],
-        "comfyWorkflowName": row["comfy_workflow_name"],
-        "comfyWorkflowReady": row["comfy_workflow_ready"] == 1,
         "createdAt": row["created_at"],
         "updatedAt": row["updated_at"],
     }
@@ -231,23 +229,12 @@ def set_provider(
         )
     else:
         conn.execute(
-            "UPDATE frames SET provider = 'comfy', model_id = NULL, updated_at = ? WHERE id = ?",
+            "UPDATE frames SET provider = 'unset', model_id = NULL, updated_at = ? WHERE id = ?",
             (now, frame_id),
         )
     return get_frame(conn, frame_id)
 
 
-def unlink_workflow(conn: sqlite3.Connection, frame_id: str) -> dict[str, Any]:
-    """Detach a frame's ComfyUI workflow link (desktop legacy; a reset on the web path)."""
-    get_frame(conn, frame_id)
-    conn.execute(
-        "UPDATE frames SET comfy_workflow_name = NULL, comfy_workflow_ready = 0, "
-        "updated_at = ? WHERE id = ?",
-        (_now(), frame_id),
-    )
-    return get_frame(conn, frame_id)
-
-
 def set_fal_params(
     conn: sqlite3.Connection, frame_id: str, params: dict[str, Any]
 ) -> dict[str, Any]:

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/studio/graph_build.py

@@ -26,8 +26,8 @@ from . import moodboard as mb
 def _source_output_port(source: dict[str, Any] | None, source_handle: str | None) -> str:
     if source and source["type"] == "prompt":
         return "text"
-    # An asset or a rendered frame both become an ``input/image`` source node (output port "image").
-    if source and source["type"] in ("asset", "frame"):
+    # An asset, a rendered frame, or a Load Assets loader all become an ``input/image`` source node.
+    if source and source["type"] in ("asset", "frame", "loader"):
         return "image"
     return source_handle or "out"  # a 'core' item's handles already are Core port ids
 
@@ -75,6 +75,17 @@ def _item_to_node(
             "type": "input/image",
             "params": {"asset": {"ref": "path", "path": path}},
         }
+    # A Load Assets loader feeds its hero (first) asset as a frozen image source.
+    if item["type"] == "loader":
+        asset_ids = data.get("assetIds") or []
+        path = resolve_asset_path(asset_ids[0]) if asset_ids else None
+        if not path:
+            return None
+        return {
+            "id": item["id"],
+            "type": "input/image",
+            "params": {"asset": {"ref": "path", "path": path}},
+        }
     # A rendered frame wired into a Core node feeds its output image as a frozen source (its hero
     # take), so nothing upstream of the frame is recomputed.
     if item["type"] == "frame" and item.get("frameId"):

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/studio/handlers.py

@@ -4,8 +4,7 @@ backend is Core (Python), not the legacy Node server.
 
 Channel args arrive as a positional list (the ``{channel, args}`` wire shape). Each handler unpacks
 them and returns the value to wrap in Ok. Not-yet-ported surfaces (generation, timeline,
-export, embedded ComfyUI) register clear stubs so the UI degrades gracefully instead of a
-"no handler".
+export) register clear stubs so the UI degrades gracefully instead of a "no handler".
 """
 
 from __future__ import annotations
@@ -73,7 +72,6 @@ def register_studio_handlers(
     reg("dialog:pickDirectory", lambda *_: str(cfg.workspace_dir()))
     reg("app:version", lambda: app_version)
     reg("settings:get", store.get_settings)
-    reg("settings:setComfyUrl", store.set_comfy_url)
     reg("settings:setCoreUrl", store.set_core_url)
     reg("core:status", core_status)
     reg("core:models", core_models)
@@ -117,7 +115,6 @@ def register_studio_handlers(
     reg("frames:rename", lambda fid, name: fr.rename_frame(conn(), fid, name))
     reg("frames:reorder", lambda ids: fr.reorder_frames(conn(), ids))
     reg("frames:clone", lambda fid: fr.clone_frame(conn(), fid))
-    reg("frames:unlink", lambda fid: fr.unlink_workflow(conn(), fid))
     reg("frames:setHero", lambda fid, take_id: fr.set_hero(conn(), fid, take_id))
     reg("frames:listTakes", lambda fid: fr.list_takes(conn(), fid))
     reg("frames:heroTakes", lambda: fr.hero_takes(conn()))
@@ -168,6 +165,7 @@ def register_studio_handlers(
     reg("moodboard:addLayer", lambda x, y: mb.add_layer(conn(), x, y))
     reg("moodboard:addDirector", lambda x, y: mb.add_director(conn(), x, y))
     reg("moodboard:addTrim", lambda x, y: mb.add_trim(conn(), x, y))
+    reg("moodboard:addLoader", lambda x, y: mb.add_loader(conn(), x, y))
     reg("moodboard:addPrompt", lambda x, y: mb.add_prompt(conn(), x, y))
     reg("moodboard:addCoreNode", lambda t, x, y: mb.add_core_node(conn(), t, x, y))
     reg(
@@ -213,10 +211,6 @@ def register_studio_handlers(
     reg("falSettings:status", store.fal_status)
     reg("falSettings:setApiKey", store.set_fal_key)
     reg("falSettings:clearApiKey", store.clear_fal_key)
-    reg("comfy:status", lambda: {"reachable": False, "url": ""})
-    for ch in ("linkFrame", "uploadInputs", "pullWorkflow", "saveLiveWorkflow", "pushWorkflow",
-               "pullLatest", "latestRun", "captureOutput"):
-        reg(f"comfy:{ch}", not_wired("Embedded ComfyUI"))
     # --- timeline (director/trim/export via ffmpeg) + folder export -----------------------------
     if timeline is not None:
         from .timeline.render import export_frames

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/studio/models.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 
 import asyncio
 import shutil
-import threading
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -138,45 +137,40 @@ class ModelDownloads:
     ) -> None:
         """Fetch a component's single file from its repo into ``models/<category>/`` (flat, so the
         node's dropdown lists it). Downloads into a ``.part`` staging dir first, then moves the file
-        into place under its basename, so a half-finished download never looks installed."""
-        from huggingface_hub import HfApi, hf_hub_download
+        into place under its basename, so a half-finished download never looks installed.
+
+        Progress comes from huggingface_hub's own download counter via ``tqdm_class`` - real
+        per-chunk motion, and it still resumes a partial file. (XET is disabled at process start so
+        the plain HTTP path is used; XET reports nothing to tqdm.)"""
+        from huggingface_hub import hf_hub_download
+        from huggingface_hub.utils import HfHubHTTPError
 
         category_dir: Path = provider.download_target(comp)
         staging = category_dir / (comp.filename + ".part")
-        shutil.rmtree(staging, ignore_errors=True)
-
-        files = _wanted_files(HfApi(), comp)
-        total = sum(size for _, size in files)
         on_progress(0.0, f"Downloading {comp.label}…")
+        tqdm_class = _progress_tqdm(on_progress, comp.label)
+
+        def _fetch(token: bool | None) -> str:
+            return hf_hub_download(
+                comp.repo,
+                comp.repo_file,
+                local_dir=str(staging),
+                token=token,
+                tqdm_class=tqdm_class,
+            )
 
-        # ``hf_hub_download`` blocks for the whole (multi-GB) file with no per-byte callback, so a
-        # naive "emit after each file" jumps 0 → 99%. Instead, a watcher thread polls the staging
-        # tree's byte size while the download runs and streams a real fraction. It only reports a
-        # fraction when the repo metadata gave us a real total; otherwise size is unknown and we
-        # leave the 0 → 1 endpoints (the status text still shows activity).
-        stop = threading.Event()
-
-        def _watch() -> None:
-            while not stop.wait(0.5):
-                if total <= 0:
-                    continue
-                got = _dir_size(staging)
-                if got > 0:
-                    on_progress(min(0.98, got / total), f"Downloading {comp.label}…")
-
-        watcher = threading.Thread(target=_watch, name="model-download-progress", daemon=True)
-        watcher.start()
         try:
-            for rfilename, _size in files:
-                hf_hub_download(comp.repo, rfilename, local_dir=str(staging))
-        finally:
-            stop.set()
-            watcher.join(timeout=1.0)
+            path = _fetch(None)  # ambient token, e.g. for a gated repo the user has access to
+        except HfHubHTTPError as error:
+            # A stale/invalid cached HF token 401s even on a public repo (HF masks it as "not
+            # found"). Retry anonymously so a bad token never blocks a public model download.
+            if getattr(getattr(error, "response", None), "status_code", None) not in (401, 403):
+                raise
+            shutil.rmtree(staging, ignore_errors=True)
+            path = _fetch(False)
 
         category_dir.mkdir(parents=True, exist_ok=True)
-        for rfilename, _ in files:
-            dest = category_dir / Path(rfilename).name
-            shutil.move(str(staging / rfilename), str(dest))
+        shutil.move(path, str(category_dir / comp.filename))
         shutil.rmtree(staging, ignore_errors=True)
         on_progress(1.0, f"{comp.label} ready")
 
@@ -210,30 +204,19 @@ def _source_label(component: Any) -> str:
     return component.repo
 
 
-def _dir_size(path: Path) -> int:
-    """Total bytes under ``path`` (recursively), for live download progress. Counts Hugging Face's
-    ``.incomplete`` temp file as it grows, so the fraction advances during the blocking fetch.
-    Best-effort: a file vanishing mid-walk (the final rename) is ignored."""
-    total = 0
-    try:
-        for child in path.rglob("*"):
-            try:
-                if child.is_file():
-                    total += child.stat().st_size
-            except OSError:
-                continue
-    except OSError:
-        return total
-    return total
-
-
-def _wanted_files(api: Any, comp: Any) -> list[tuple[str, int]]:
-    """(rfilename, size) for the single file this component pulls, sized from the repo metadata.
-
-    Falls back to size 0 (progress by count) if the file isn't in the listing - the download still
-    proceeds; ``hf_hub_download`` is the source of truth for whether the path exists."""
-    info = api.model_info(comp.repo, files_metadata=True)
-    for sibling in info.siblings:
-        if sibling.rfilename == comp.repo_file:
-            return [(comp.repo_file, int(sibling.size or 0))]
-    return [(comp.repo_file, 0)]
+def _progress_tqdm(on_progress: Callable[[float, str], None], label: str) -> Any:
+    """A tqdm subclass handed to ``hf_hub_download`` as ``tqdm_class``; it forwards the download
+    counter to ``on_progress``. It sums ``n`` itself because ``tqdm.update`` short-circuits (never
+    touching ``self.n``) when its bar is disabled - which it is on a headless server. The 0.99 cap
+    leaves the final 1.0 for the post-move ``ready``."""
+    from tqdm.auto import tqdm
+
+    class _Tqdm(tqdm):
+        def update(self, n: float | None = 1) -> Any:
+            done = super().update(n)
+            self._forwarded = getattr(self, "_forwarded", 0.0) + (n or 0.0)
+            if self.total:
+                on_progress(min(0.99, self._forwarded / self.total), f"Downloading {label}…")
+            return done
+
+    return _Tqdm

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/studio/moodboard.py

@@ -233,6 +233,14 @@ def add_trim(conn: sqlite3.Connection, x: float, y: float) -> dict[str, Any]:
     )
 
 
+def add_loader(conn: sqlite3.Connection, x: float, y: float) -> dict[str, Any]:
+    # A "Load Assets" node holds library asset refs in its data (no frame, no frame_inputs) and
+    # feeds its hero (first) asset downstream via graph_build.
+    return _insert_item(
+        conn, item_type="loader", x=x, y=y, width=220, height=200, data={"assetIds": []}
+    )
+
+
 def add_prompt(conn: sqlite3.Connection, x: float, y: float) -> dict[str, Any]:
     return _insert_item(
         conn, item_type="prompt", x=x, y=y, width=240, height=120, data={"promptText": ""}

{inline_core-1.2.2 → inline_core-1.2.3}/src/inline_core/studio/store.py

@@ -53,14 +53,12 @@ class StudioStore:
         app_data_dir: str | Path,
         workspace_dir: str | Path,
         *,
-        default_comfy_url: str = "http://127.0.0.1:8188",
         default_core_url: str = "http://127.0.0.1:8848",
     ) -> None:
         self._app_data = Path(app_data_dir)
         self._workspace = Path(workspace_dir)
         self._app_data.mkdir(parents=True, exist_ok=True)
         self._workspace.mkdir(parents=True, exist_ok=True)
-        self._default_comfy_url = default_comfy_url
         self._default_core_url = default_core_url
         self._conn: sqlite3.Connection | None = None
         self._folder: Path | None = None
@@ -237,7 +235,6 @@ class StudioStore:
     def get_settings(self) -> dict[str, str]:
         saved = self._read_settings()
         return {
-            "comfyUrl": self._non_empty(saved.get("comfyUrl")) or self._default_comfy_url,
             "coreUrl": self._non_empty(saved.get("coreUrl")) or self._default_core_url,
         }
 
@@ -245,11 +242,6 @@ class StudioStore:
         self._settings_file().write_text(json.dumps(settings, indent=2), encoding="utf-8")
         return settings
 
-    def set_comfy_url(self, url: str) -> dict[str, str]:
-        settings = self.get_settings()
-        settings["comfyUrl"] = url.strip() or self._default_comfy_url
-        return self._save_settings(settings)
-
     def set_core_url(self, url: str) -> dict[str, str]:
         settings = self.get_settings()
         settings["coreUrl"] = url.strip() or self._default_core_url

{inline_core-1.2.2 → inline_core-1.2.3}/tests/test_extension_install.py

@@ -388,6 +388,33 @@ def test_reinstall_recovers_from_a_corrupt_cached_mirror(
     assert (mirror / "HEAD").is_file()
 
 
+def test_remote_sha_peels_an_annotated_tag_to_its_commit(tmp_path: Path) -> None:
+    """An annotated tag's ls-remote lists the tag object first and the commit on a `^{}` line. The
+    update check compares against the installed *commit*, so remote_sha must peel - otherwise every
+    annotated-tag release reads as perpetually 'update available'."""
+    from inline_core.extensions.fetch import remote_sha
+
+    repo = tmp_path / "annotated-repo"
+    repo.mkdir()
+    _git("init", "-q", "-b", "main", cwd=repo)
+    _git("config", "user.email", "test@example.com", cwd=repo)
+    _git("config", "user.name", "Test", cwd=repo)
+    (repo / "file.txt").write_text("hi", encoding="utf-8")
+    _git("add", "-A", cwd=repo)
+    _git("commit", "-q", "-m", "initial", cwd=repo)
+    _git("tag", "-a", "v1.0.0", "-m", "release", cwd=repo)  # annotated, not lightweight
+
+    commit = subprocess.run(
+        ["git", "rev-parse", "v1.0.0^{commit}"],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+    assert remote_sha(f"file://{repo}", "v1.0.0") == commit
+
+
 def test_switching_to_an_uninstalled_version_is_refused(
     installer: Installer, tmp_path: Path
 ) -> None:

{inline_core-1.2.2 → inline_core-1.2.3}/tests/test_studio_frames.py

@@ -62,8 +62,9 @@ def test_set_model_and_provider(conn) -> None:
     swapped = fr.set_model(conn, frame["id"], "m/2", "video", {"b": 2})
     assert swapped["modelId"] == "m/2" and swapped["kind"] == "video"
     assert swapped["params"] == {"b": 2}
-    to_comfy = fr.set_provider(conn, frame["id"], "comfy")
-    assert to_comfy["provider"] == "comfy" and to_comfy["modelId"] is None
+    # A non-fal set_provider resets the frame to 'unset' (the neutral, engine-less state).
+    reset = fr.set_provider(conn, frame["id"], "unset")
+    assert reset["provider"] == "unset" and reset["modelId"] is None
 
 
 def test_rename_reorder_delete(conn) -> None:

{inline_core-1.2.2 → inline_core-1.2.3}/tests/test_studio_generation.py

@@ -35,7 +35,7 @@ def test_build_workflow_graph_prompt_into_zimage(tmp_path) -> None:
 
 def test_build_workflow_graph_frame_output_into_zimage_image(tmp_path) -> None:
     """A rendered frame wired into Z-Image's image port becomes an input/image source node pointing
-    at the frame's hero take - no dangling edge to a non-emitted node (the old "No node with id")."""
+    at the frame's hero take - no dangling edge to a non-emitted node."""
     store = _store(tmp_path)
     conn = store.conn()
     z = mb.add_core_node(conn, "alibaba/z-image-turbo", 400, 200)
@@ -55,6 +55,30 @@ def test_build_workflow_graph_frame_output_into_zimage_image(tmp_path) -> None:
     assert take["id"]  # hero take exists
 
 
+def test_build_workflow_graph_loader_into_zimage_image(tmp_path) -> None:
+    """A standalone Load Assets loader (its hero asset) wired into Z-Image becomes an input/image
+    source node - no frame involved."""
+    store = _store(tmp_path)
+    conn = store.conn()
+    conn.execute(
+        "INSERT INTO assets (id, project_id, name, file_path, kind, created_at) "
+        "VALUES ('a1', ?, 'a', 'assets/a.png', 'image', 0)",
+        (mb._project_id(conn),),
+    )
+    z = mb.add_core_node(conn, "alibaba/z-image-turbo", 400, 200)
+    loader = mb.add_loader(conn, 80, 200)
+    assert loader["type"] == "loader" and loader["data"]["assetIds"] == []
+    mb.update_item(conn, loader["id"], {"data": {"assetIds": ["a1"]}})
+    mb.create_connector(conn, loader["id"], z["id"], "out", "image")
+
+    graph, _ = build_workflow_graph(conn, store.folder(), z["id"])
+    by_id = {n["id"]: n for n in graph["nodes"]}
+    loader_node = by_id[loader["id"]]
+    assert loader_node["type"] == "input/image"
+    assert loader_node["params"]["asset"]["path"] == str(store.folder() / "assets/a.png")
+    assert by_id[z["id"]]["inputs"]["image"] == {"from": loader["id"], "output": "image"}
+
+
 class _Events:
     def __init__(self) -> None:
         self.sent: list[tuple[str, dict]] = []

inline_core-1.2.3/tests/test_studio_models.py

@@ -0,0 +1,90 @@
+"""The explicit model-download backend (studio/models.py) - the torch-free bits: which repo file a
+component pulls and the requirements view for unknown node types. The Hugging Face download itself
+is not exercised here (no network); the runner/requirements tests cover presence logic."""
+
+from __future__ import annotations
+
+import types
+from pathlib import Path
+
+import pytest
+
+from inline_core.studio.models import (
+    ModelDownloads,
+    _component_json,
+    _progress_tqdm,
+)
+
+
+def test_progress_tqdm_forwards_the_download_fraction():
+    """The tqdm subclass handed to hf_hub_download must turn its byte counter into a 0..0.99
+    fraction on our callback."""
+    pytest.importorskip("tqdm")
+    seen: list[float] = []
+    cls = _progress_tqdm(lambda frac, status: seen.append(frac), "VAE")
+    bar = cls(total=100, disable=True)
+    bar.update(50)
+    bar.update(50)  # reaches total, but the cap keeps 1.0 for the post-move "ready"
+    assert seen == [0.5, 0.99]
+
+
+def test_requirements_empty_for_unknown_node_type():
+    downloads = ModelDownloads(events=None)
+    assert downloads.requirements("no/such-node") == {
+        "components": [],
+        "allPresent": True,
+        "estimate": None,  # no requirements + no policy -> no fit estimate
+    }
+
+
+def test_download_retries_anonymously_when_a_cached_token_is_invalid(tmp_path, monkeypatch):
+    """A stale/invalid cached HF token 401s even on a public repo (masked as "not found"). The
+    download must drop the token and retry anonymously, not fail."""
+    hub = pytest.importorskip("huggingface_hub")
+    from huggingface_hub.utils import HfHubHTTPError
+
+    tokens_seen: list[object] = []
+
+    def fake_download(repo, rfilename, local_dir, token=None, tqdm_class=None):
+        tokens_seen.append(token)
+        if token is not False:  # ambient (stale) token -> 401 the way HF does
+            response = types.SimpleNamespace(status_code=401, headers={}, request=None)
+            raise HfHubHTTPError("401 Client Error. Repository Not Found", response=response)
+        dest = Path(local_dir) / rfilename
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_bytes(b"data")
+        return str(dest)
+
+    monkeypatch.setattr(hub, "hf_hub_download", fake_download)
+
+    downloads = ModelDownloads(events=None)
+    comp = types.SimpleNamespace(repo="lokCX/4x-Ultrasharp", repo_file="w.pth", filename="w.pth",
+                                 label="4x UltraSharp")
+    provider = types.SimpleNamespace(download_target=lambda c: tmp_path)
+    downloads._download_component(provider, comp, lambda frac, status: None)
+
+    assert (tmp_path / "w.pth").read_bytes() == b"data"
+    assert tokens_seen == [None, False]  # tried the ambient token, then fell back to anonymous
+
+
+def test_component_json_shape():
+    comp = types.SimpleNamespace(
+        id="vae",
+        label="VAE",
+        category="vae",
+        present=False,
+        local_path="vae/ae.safetensors",
+        repo="Comfy-Org/z_image",
+        filename="ae.safetensors",
+        repo_file="split_files/vae/ae.safetensors",
+    )
+    assert _component_json(comp) == {
+        "id": "vae",
+        "label": "VAE",
+        "category": "vae",
+        "present": False,
+        "localPath": "vae/ae.safetensors",
+        "repo": "Comfy-Org/z_image",
+        # "which model" is the repo + the exact file this component pulls.
+        "source": "Comfy-Org/z_image/ae.safetensors",
+    }

{inline_core-1.2.2 → inline_core-1.2.3}/tests/test_studio_rpc.py

@@ -97,9 +97,6 @@ def test_asset_upload_and_media_serving(client) -> None:
 
 def test_unported_channels_degrade_gracefully(client) -> None:
     rpc(client, "project:create", {"name": "P", "parentDir": None})
-    # Embedded ComfyUI is desktop-only - a clear error, not a crash.
-    cf = rpc(client, "comfy:linkFrame", "frame-x")
-    assert cf["ok"] is False and "comfyui" in cf["error"].lower()
     # Cancel is a safe no-op.
     assert rpc(client, "generation:cancel")["ok"] is True