inline-core 1.2.5__tar.gz → 1.2.6__tar.gz

{inline_core-1.2.5 → inline_core-1.2.6}/CLAUDE.md

@@ -95,7 +95,16 @@ HTTP/WS  →  server/app.py  →  RunManager  →  Executor  →  Registry (desc
   the ComfyUI-equivalent decomposed graph and the intended long-term surface. **Descriptor-only
   today - their runners land in C2.** A graph built from them validates and type-checks but raises
   `No runner registered` at execution.
-- **Model runners** (`models/<name>/`) - high-level single generation nodes. **`alibaba/z-image-turbo`
+- **Model runners** (`models/<name>/`) - high-level single generation nodes. **`black-forest-labs/flux-2`
+  (`models/flux2/`) is the reference for a _family_:** one node covers klein 4B/9B, their base builds,
+  the KV variant and dev, because the picked checkpoint is identified from its own tensor shapes
+  (`flux2/variants.py`) and everything else follows. Adding a checkpoint is a row in that table.
+  Two rules it establishes: **identify a checkpoint by content, never by filename** (`diffusion_models/`
+  is shared across architectures, and Qwen3-4B and Qwen3-VL-4B have byte-identical embedding shapes),
+  and **derive geometry from the checkpoint** rather than bundling a config per variant, so a future
+  build loads with no code change. A **diffusers folder** is a valid checkpoint too, which is the only
+  way a 32B model reaches a 24 GB card: its NF4 shards stream through `from_pretrained`, where
+  `from_single_file` cannot quantize at all. **`alibaba/z-image-turbo`
   (`models/zimage/`) is the one runnable generation path today** (prompt + optional image → one take,
   backed by diffusers' `ZImagePipeline`/`ZImageImg2ImgPipeline`). This is the "Z-Image pipeline that
   already works" - the primitives will reach parity in C2. It loads from a **single diffusion
@@ -143,6 +152,18 @@ between nodes and are never takes.
   (Turing/Volta - compute capability < 8.0, e.g. a T4): same footprint, but it uses the fp16 tensor
   cores instead of bf16's slow path. The **VAE stays upcast** (bf16, or fp32 when the denoiser is
   fp16) because fp16 VAE decode can overflow to black/NaN images (`_compute_dtype` in `device/`).
+- **Quantization rungs** - the fit ladder is full-precision resident → int8 resident → **NF4 resident**
+  → sequential offload → wont-fit. NF4 is what makes a 32B model viable on a 24 GB card. Note int8
+  forces bf16 (torchao's weight-only int8 silently no-ops under fp16) while NF4 does not, so a Turing
+  card keeps its fp16 tensor cores under NF4.
+- **Prequantized checkpoints must not be re-quantized.** A checkpoint that ships already quantized
+  (`flux2/variants.is_prequantized`) has an on-disk size that already _is_ its resident size, so the
+  ladder's assumption that quantization halves it does not hold, and handing diffusers a second,
+  different quantization config is a hard error. Pass `Quantization.NONE` for those.
+- **Staged loading** - when the text encoder and the transformer cannot be co-resident (dev is a
+  15 GB encoder beside an 18 GB transformer), the prompt is encoded first and the encoder freed before
+  the transformer loads. The decision has to be made _before_ the load: by the time an OOM fires there
+  is nothing left to free.
 - **Multi-GPU** - `INLINE_PARALLEL` (e.g. `pipefusion=2`, `pipefusion=2,ulysses=2`); degrees multiply
   to the world size, which must equal the GPU count.
 
@@ -202,6 +223,11 @@ real codec that moves tensors lives with the model runner.
   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>"`.
+- **Verify image models by rendering.** The FLUX.2 work shipped five bugs past a green test suite,
+  and every one produced a _wrong image rather than an error_: a mis-keyed checkpoint, a
+  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.
 - **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/`.
@@ -211,14 +237,17 @@ real codec that moves tensors lives with the model runner.
 
 ```
 uv venv                                   # create ./.venv
-uv pip install -e ".[server,dev]"         # engine + server + test tooling
-uv pip install -e ".[runtime]"            # + torch, diffusers, transformers (real generation)
-uv pip install -e ".[runtime,parallel]"   # + xfuser, for multi-GPU denoise (2+ GPUs)
+# --python pins the target: without it uv installs into an activated venv/conda env, not ./.venv
+uv pip install --python .venv/bin/python -e ".[server,dev]"   # engine + server + test tooling
+uv pip install --python .venv/bin/python -e ".[runtime]"      # + torch, diffusers, transformers
+uv pip install --python .venv/bin/python -e ".[runtime,parallel]"  # + xfuser, multi-GPU denoise
 
 ./webui.sh                                # run (loopback:8848); friendly flags → INLINE_* env
 ./webui.sh --listen --port 9000           # bind all interfaces
 ./webui.sh --lowvram                      # tight-VRAM profile
 ./webui.sh --install --extra runtime      # set up ./.venv with the model runtime, then exit
+                                          # (reuses an existing ./.venv; --recreate rebuilds it, and
+                                          #  an activated foreign env is reported, never modified)
 python -m inline_core.server              # run the server directly (INLINE_HOST / INLINE_PORT)
 
 ruff check .                              # lint (zero warnings)

{inline_core-1.2.5 → inline_core-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inline-core
-Version: 1.2.5
+Version: 1.2.6
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11
@@ -8,12 +8,21 @@ Requires-Dist: numpy>=1.26
 Requires-Dist: psutil>=5.9
 Provides-Extra: all
 Requires-Dist: accelerate>=0.30; extra == 'all'
+Requires-Dist: bitsandbytes>=0.43; (platform_system != 'Darwin') and extra == 'all'
+Requires-Dist: controlnet-aux>=0.0.7; extra == 'all'
 Requires-Dist: diffusers>=0.39; 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: imageio-ffmpeg>=0.4; extra == 'all'
+Requires-Dist: nvidia-ml-py>=12; extra == 'all'
+Requires-Dist: onnxruntime>=1.17; extra == 'all'
+Requires-Dist: peft>=0.11; extra == 'all'
+Requires-Dist: pillow>=10; extra == 'all'
+Requires-Dist: psutil>=5.9; extra == 'all'
 Requires-Dist: safetensors>=0.4; extra == 'all'
 Requires-Dist: scipy>=1.11; extra == 'all'
+Requires-Dist: timm>=1.0; extra == 'all'
 Requires-Dist: torch>=2.2; extra == 'all'
 Requires-Dist: torchao>=0.14; extra == 'all'
 Requires-Dist: transformers>=4.44; extra == 'all'
@@ -28,8 +37,10 @@ Requires-Dist: nvidia-ml-py>=12; extra == 'parallel'
 Requires-Dist: xfuser>=0.4; extra == 'parallel'
 Provides-Extra: runtime
 Requires-Dist: accelerate>=0.30; extra == 'runtime'
+Requires-Dist: controlnet-aux>=0.0.7; extra == 'runtime'
 Requires-Dist: diffusers>=0.39; extra == 'runtime'
 Requires-Dist: huggingface-hub>=0.23; extra == 'runtime'
+Requires-Dist: onnxruntime>=1.17; extra == 'runtime'
 Requires-Dist: safetensors>=0.4; extra == 'runtime'
 Requires-Dist: scipy>=1.11; extra == 'runtime'
 Requires-Dist: torch>=2.2; extra == 'runtime'
@@ -90,13 +101,18 @@ a 6 GB laptop, pure CPU, or split across several GPUs, without touching the grap
 
 Requires Python 3.11+ and [uv](https://docs.astral.sh/uv/).
 
+`--python` pins each install to `./.venv`; without it uv targets whatever venv or conda env is
+activated in your shell, and installs land there instead.
+
 ```
 uv venv
-uv pip install -e ".[server]"     # engine + HTTP/websocket API
-uv pip install -e ".[runtime]"    # + torch, diffusers, transformers (for real generation)
-uv pip install -e ".[runtime,parallel]"  # + xfuser, to split one image across GPUs (2+ GPUs)
+uv pip install --python .venv/bin/python -e ".[server]"    # engine + HTTP/websocket API
+uv pip install --python .venv/bin/python -e ".[runtime]"   # + torch, diffusers, transformers
+uv pip install --python .venv/bin/python -e ".[runtime,parallel]"  # + xfuser, 2+ GPUs
 ```
 
+Or let the launcher do it: `./webui.sh --install --extra runtime` (Windows: `.\webui.bat`).
+
 ## Models
 
 Drop files into the models dir (default `./models`, override with `INLINE_MODELS_DIR`), ComfyUI-style,
@@ -231,17 +247,18 @@ offload machinery, `--vram-budget GB` / `INLINE_VRAM_BUDGET_GB` to cap the assum
 
 ## Run
 
-The easy path is `webui.sh`, which maps friendly flags onto the engine's `INLINE_*` env knobs:
+The easy path is `webui.sh` (macOS/Linux) or `webui.bat` (Windows), which maps friendly flags onto the
+engine's `INLINE_*` env knobs. Windows must use `webui.bat` - `webui.sh` is a bash script:
 
 ```
-./webui.sh                            # loopback, port 8848
+./webui.sh                            # loopback, port 8848            (Windows: .\webui.bat)
 ./webui.sh --listen --port 9000       # bind all interfaces on 9000
 ./webui.sh --multi-gpu                # split one image across GPUs (auto with 2+ GPUs)
 ./webui.sh --lowvram                  # tight-VRAM profile
 ./webui.sh --install --extra runtime  # set up ./.venv with the model runtime, then exit
 ```
 
-`./webui.sh --help` lists every flag (networking, multi-GPU, device/memory profile, paths). The same
+`./webui.sh --help` (or `.\webui.bat --help`) lists every flag (networking, multi-GPU, device/memory profile, paths). The same
 flags are available on the Python entrypoint - `python main.py --help` - which is the dev path (it also
 takes `--front-end-root DIR` to serve a local SPA build). Or run the server module directly:
 

{inline_core-1.2.5 → inline_core-1.2.6}/README.md

@@ -39,13 +39,18 @@ a 6 GB laptop, pure CPU, or split across several GPUs, without touching the grap
 
 Requires Python 3.11+ and [uv](https://docs.astral.sh/uv/).
 
+`--python` pins each install to `./.venv`; without it uv targets whatever venv or conda env is
+activated in your shell, and installs land there instead.
+
 ```
 uv venv
-uv pip install -e ".[server]"     # engine + HTTP/websocket API
-uv pip install -e ".[runtime]"    # + torch, diffusers, transformers (for real generation)
-uv pip install -e ".[runtime,parallel]"  # + xfuser, to split one image across GPUs (2+ GPUs)
+uv pip install --python .venv/bin/python -e ".[server]"    # engine + HTTP/websocket API
+uv pip install --python .venv/bin/python -e ".[runtime]"   # + torch, diffusers, transformers
+uv pip install --python .venv/bin/python -e ".[runtime,parallel]"  # + xfuser, 2+ GPUs
 ```
 
+Or let the launcher do it: `./webui.sh --install --extra runtime` (Windows: `.\webui.bat`).
+
 ## Models
 
 Drop files into the models dir (default `./models`, override with `INLINE_MODELS_DIR`), ComfyUI-style,
@@ -180,17 +185,18 @@ offload machinery, `--vram-budget GB` / `INLINE_VRAM_BUDGET_GB` to cap the assum
 
 ## Run
 
-The easy path is `webui.sh`, which maps friendly flags onto the engine's `INLINE_*` env knobs:
+The easy path is `webui.sh` (macOS/Linux) or `webui.bat` (Windows), which maps friendly flags onto the
+engine's `INLINE_*` env knobs. Windows must use `webui.bat` - `webui.sh` is a bash script:
 
 ```
-./webui.sh                            # loopback, port 8848
+./webui.sh                            # loopback, port 8848            (Windows: .\webui.bat)
 ./webui.sh --listen --port 9000       # bind all interfaces on 9000
 ./webui.sh --multi-gpu                # split one image across GPUs (auto with 2+ GPUs)
 ./webui.sh --lowvram                  # tight-VRAM profile
 ./webui.sh --install --extra runtime  # set up ./.venv with the model runtime, then exit
 ```
 
-`./webui.sh --help` lists every flag (networking, multi-GPU, device/memory profile, paths). The same
+`./webui.sh --help` (or `.\webui.bat --help`) lists every flag (networking, multi-GPU, device/memory profile, paths). The same
 flags are available on the Python entrypoint - `python main.py --help` - which is the dev path (it also
 takes `--front-end-root DIR` to serve a local SPA build). Or run the server module directly:
 

{inline_core-1.2.5 → inline_core-1.2.6}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.5"
+version = "1.2.6"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -28,6 +28,10 @@ runtime = [
   "scipy>=1.11",
   # We call snapshot_download directly for the model popup, so pin it rather than rely on transit.
   "huggingface_hub>=0.23",
+  # 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",
+  "onnxruntime>=1.17",
 ]
 server = [
   "fastapi>=0.110",
@@ -60,8 +64,12 @@ dev = [
   "pyright>=1.1",
   "httpx>=0.27",
 ]
-# Everything needed to run locally. Lists concrete packages, never `inline-core[...]` self-refs.
+# Everything a local install needs in one extra: runtime + server + training (the LoRA trainer),
+# so `--install --extra all` is a single "install everything" command. Multi-GPU (xfuser, the
+# `parallel` extra) is left out on purpose - it is niche and can fail to build on many systems.
+# Lists concrete packages, never `inline-core[...]` self-refs.
 all = [
+  # runtime
   "torch>=2.2",
   "diffusers>=0.39",
   "transformers>=4.44",
@@ -70,9 +78,20 @@ all = [
   "torchao>=0.14",
   "scipy>=1.11",
   "huggingface_hub>=0.23",
+  "controlnet-aux>=0.0.7",
+  "onnxruntime>=1.17",
+  # server
   "fastapi>=0.110",
   "uvicorn[standard]>=0.29",
   "imageio-ffmpeg>=0.4",
+  # training (the Trainer tab)
+  "peft>=0.11",
+  "bitsandbytes>=0.43; platform_system != 'Darwin'",
+  "Pillow>=10",
+  "psutil>=5.9",
+  "nvidia-ml-py>=12",
+  "timm>=1.0",
+  "einops>=0.7",
 ]
 
 # PyPI ships CPU-only torch on Windows; pin the CUDA index there (pip: see requirements.txt).
@@ -108,4 +127,6 @@ typeCheckingMode = "strict"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-pythonpath = ["src"]
+# "." so `tests` imports as a package: several suites share fixtures via `from tests.x import y`,
+# and without it those modules fail to collect and silently stop running.
+pythonpath = ["src", "."]

inline_core-1.2.6/src/inline_core/__init__.py

@@ -0,0 +1,14 @@
+"""Inline Core: the generation engine behind Inline.
+
+Takes a typed node graph and returns immutable takes. See PLAN.md for the architecture and
+docs/contract.md for the Storyline API.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    #: Resolved from the installed package, so pyproject.toml stays the only place a release is
+    #: bumped. An editable install records this at install time; reinstall after bumping.
+    __version__ = version("inline-core")
+except PackageNotFoundError:  # a source tree that was never installed
+    __version__ = "0.0.0"

{inline_core-1.2.5 → inline_core-1.2.6}/src/inline_core/device/memory.py

@@ -47,6 +47,10 @@ _SMART_RESIDENT_MIN_VRAM_GB = 6.0
 # ~half the fp16 weight bytes. Deliberately generous so the estimate errs toward a lighter plan.
 _ACTIVATION_HEADROOM_GB = 2.5
 _INT8_FACTOR = 0.5
+# NF4 (bitsandbytes) stores 4-bit weights plus per-block scales, so ~0.55 bytes per parameter
+# against fp16's 2. The rung exists for the very large checkpoints (FLUX.2 dev and friends) that
+# int8 still cannot fit; it is CUDA-only and, like int8, never combined with CPU offload.
+_NF4_FACTOR = 0.28
 
 
 def _system_ram_gb() -> float | None:
@@ -202,9 +206,10 @@ class MemoryPolicy(DevicePolicy):
             return None
         cap = max(0.0, budget - _ACTIVATION_HEADROOM_GB)
         big = (fp.diffusion_bytes + fp.text_encoder_bytes) / 1e9
-        vae = fp.vae_bytes / 1e9
-        full = big + vae
-        int8 = big * _INT8_FACTOR + vae
+        # The VAE and a ControlNet are never quantized, so they cost the same under every plan.
+        fixed = (fp.vae_bytes + fp.controlnet_bytes) / 1e9
+        full = big + fixed
+        int8 = big * _INT8_FACTOR + fixed
         forced = _env_profile() is not None  # explicit --profile pins the profile; fit picks quant
 
         def prof(auto: Profile) -> Profile:
@@ -221,7 +226,14 @@ class MemoryPolicy(DevicePolicy):
                 int8, budget, True,
                 "Weights are int8-quantized to fit this GPU's VRAM.",
             )
-        # int8 still won't fit resident -> CPU-offload streaming. Only viable if the (unquantized)
+        nf4 = big * _NF4_FACTOR + fixed
+        if nf4 <= cap:
+            return FitEstimate(
+                "nf4", Quantization.NF4, OffloadMode.NONE, prof(Profile.LOWVRAM),
+                nf4, budget, True,
+                "Weights are 4-bit (NF4) quantized to fit this GPU's VRAM.",
+            )
+        # Even 4-bit won't fit resident -> CPU-offload streaming. Only viable if the (unquantized)
         # model fits in system RAM, since sequential offload holds the off-GPU weights there.
         ram = self._ram_gb
         if ram is not None and full > ram:

{inline_core-1.2.5 → inline_core-1.2.6}/src/inline_core/device/policy.py

@@ -87,10 +87,14 @@ class ModelFootprint:
     diffusion_bytes: int = 0
     text_encoder_bytes: int = 0
     vae_bytes: int = 0
+    #: A ControlNet loaded alongside the denoiser. Never quantized, so it counts full in every plan.
+    controlnet_bytes: int = 0
 
     @property
     def total_bytes(self) -> int:
-        return self.diffusion_bytes + self.text_encoder_bytes + self.vae_bytes
+        return (
+            self.diffusion_bytes + self.text_encoder_bytes + self.vae_bytes + self.controlnet_bytes
+        )
 
 
 @dataclass(frozen=True)

{inline_core-1.2.5 → inline_core-1.2.6}/src/inline_core/graph/cache.py

@@ -12,7 +12,7 @@ from typing import Any
 
 from ..takes import Take
 from .registry import Registry
-from .schema import Graph, Node
+from .schema import Graph, Node, PortKind
 
 
 class NodeCache(ABC):
@@ -40,8 +40,15 @@ def _canonical_params(node: Node, registry: Registry) -> dict[str, Any]:
 
 
 def is_cache_eligible(node: Node, registry: Registry) -> bool:
-    """False when any seed param resolves to a negative (random) value."""
+    """False when a control map is wired, or any seed param resolves to a negative (random) value.
+
+    A node driven by a control map re-runs every time: the user iterates on the pose/depth and
+    expects each run to apply the current control, so a cached take would read as "control not
+    taking effect" (even a re-render at the same seed must re-apply it)."""
     descriptor = registry.get(node.type)
+    for port in descriptor.inputs:
+        if port.kind is PortKind.CONTROL and node.inputs.get(port.id):
+            return False
     defaults = descriptor.defaults()
     for key in descriptor.seed_keys():
         value = node.params.get(key, defaults.get(key))
@@ -81,3 +88,29 @@ def node_cache_key(
     digest = hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode()).hexdigest()
     memo[node_id] = digest
     return digest
+
+
+def asset_content_hashes(graph: Graph) -> dict[str, str]:
+    """The byte hash of each file-backed source node's asset, keyed by node id. Feeds
+    ``node_cache_key`` so the cache invalidates when a file's *content* changes even though its path
+    did not (a re-rendered control map, an in-place-replaced input image). Only ``ref="path"`` refs
+    are hashable; a missing file is skipped - its path still keys the node through its params."""
+    import os
+
+    hashes: dict[str, str] = {}
+    for node in graph.nodes:
+        asset = node.params.get("asset")
+        if not isinstance(asset, dict) or asset.get("ref") != "path":
+            continue
+        path = asset.get("path")
+        if isinstance(path, str) and os.path.isfile(path):
+            hashes[node.id] = _file_hash(path)
+    return hashes
+
+
+def _file_hash(path: str) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()

{inline_core-1.2.5 → inline_core-1.2.6}/src/inline_core/graph/executor.py

@@ -6,6 +6,7 @@ It orchestrates cheap work inline. A model node's runner submits the denoise to
 
 from __future__ import annotations
 
+import logging
 from dataclasses import replace
 from typing import Any
 
@@ -13,12 +14,14 @@ from ..errors import CancelledError, GraphValidationError, InlineCoreError
 from ..runtime.context import ExecutionContext
 from ..runtime.progress import CancelledEvent, ErrorEvent, NodeDoneEvent, RunDoneEvent
 from ..runtime.run import NodeRuntimeState, RunState, RunStatus, StateTrackingEmitter
-from .cache import NodeCache, is_cache_eligible, node_cache_key
+from .cache import NodeCache, asset_content_hashes, is_cache_eligible, node_cache_key
 from .registry import Registry
 from .schema import Graph, Node
 from .topo import topo_sort, upstream_closure
 from .validate import validate
 
+logger = logging.getLogger(__name__)
+
 
 class Executor:
     def __init__(self, registry: Registry, cache: NodeCache) -> None:
@@ -33,10 +36,13 @@ class Executor:
             order = self._plan(graph, target, state)
             state.status = RunStatus.RUNNING
             outputs: dict[str, dict[str, Any]] = {}
+            # Hash the input files once so the node cache is content-addressed: a re-rendered
+            # control map (or any replaced input) invalidates even when its path is unchanged.
+            asset_hashes = asset_content_hashes(graph)
             for node_id in order:
                 if ctx.cancel.cancelled:
                     raise CancelledError("Run cancelled.")
-                self._run_node(graph, node_id, outputs, run_ctx)
+                self._run_node(graph, node_id, outputs, run_ctx, asset_hashes)
             emitter.emit(RunDoneEvent(run_id=ctx.run_id))
         except CancelledError:
             emitter.emit(CancelledEvent(run_id=ctx.run_id))
@@ -44,6 +50,12 @@ class Executor:
             emitter.emit(ErrorEvent(run_id=ctx.run_id, message=str(error), node_id=error.node_id))
         except InlineCoreError as error:
             emitter.emit(ErrorEvent(run_id=ctx.run_id, message=str(error)))
+        except Exception as error:  # noqa: BLE001
+            # A runner that raises a non-InlineCoreError (e.g. a diffusers/HF load error) must still
+            # terminate the run: otherwise it escapes to the worker thread, the terminal event is
+            # never sent, and the run wedges in "queued" while the UI hangs on "loading model".
+            logger.exception("Run %s failed with an unhandled error", ctx.run_id)
+            emitter.emit(ErrorEvent(run_id=ctx.run_id, message=str(error) or type(error).__name__))
 
     def _plan(self, graph: Graph, target: str, state: RunState) -> list[str]:
         validate(graph, target, self._registry)
@@ -59,6 +71,7 @@ class Executor:
         node_id: str,
         outputs: dict[str, dict[str, Any]],
         ctx: ExecutionContext,
+        asset_hashes: dict[str, str],
     ) -> None:
         node = graph.node(node_id)
         runner = self._registry.runner(node.type)
@@ -66,8 +79,7 @@ class Executor:
 
         key: str | None = None
         if runner.produces_takes and is_cache_eligible(node, self._registry):
-            # TODO(phase1): pass real asset content hashes so identity is content-addressed.
-            key = node_cache_key(graph, node_id, self._registry, asset_hashes={})
+            key = node_cache_key(graph, node_id, self._registry, asset_hashes=asset_hashes)
             cached = self._cache.get(key)
             if cached is not None:
                 ctx.emitter.emit(

{inline_core-1.2.5 → inline_core-1.2.6}/src/inline_core/graph/schema.py

@@ -26,6 +26,7 @@ class PortKind(str, Enum):
     LORA = "lora"
     CONDITIONING = "conditioning"
     LATENT = "latent"
+    CONTROL = "control"
 
 
 def port_satisfies(source: PortKind, target: PortKind) -> bool:
@@ -33,7 +34,10 @@ def port_satisfies(source: PortKind, target: PortKind) -> bool:
     if source == target:
         return True
     # a single image satisfies a list input (a one-element list)
-    return source is PortKind.IMAGE and target is PortKind.IMAGE_LIST
+    if source is PortKind.IMAGE and target is PortKind.IMAGE_LIST:
+        return True
+    # a control input accepts any image output (the control map is just an image)
+    return source is PortKind.IMAGE and target is PortKind.CONTROL
 
 
 @dataclass(frozen=True)

{inline_core-1.2.5 → inline_core-1.2.6}/src/inline_core/models/catalog.py

@@ -15,6 +15,8 @@ import hashlib
 import json
 from pathlib import Path
 
+from ..config import models_dir
+
 # Category subfolders scanned under the models root. These are the keys a param's `options_from`
 # may reference (see graph/primitives.py); ensure_dirs() creates them so drop-in is obvious.
 CATEGORIES: tuple[str, ...] = (
@@ -96,3 +98,22 @@ class ModelCatalog:
                 # A sharded model (config + shards) is one entry, named for its folder.
                 names.append(entry.name)
         return sorted(names)
+
+
+def resolve_picked(category: str, chosen: object) -> Path | None:
+    """A model dropdown's stored value, resolved to a file under ``category``.
+
+    The select serves bare filenames, but projects written before it did store the full relative
+    path, and joining one of those under the category doubles the prefix into a path that cannot
+    exist. So: try the value as given under the category, then its bare name there, then the value
+    as a path in its own right. Returns None when nothing matches, which callers must not stringify
+    (``str(None)`` reaching a loader reads as a corrupt file rather than a stale pick).
+    """
+    name = str(chosen or "").strip()
+    if not name:
+        return None
+    root = models_dir() / category
+    for candidate in (root / name, root / Path(name).name, Path(name)):
+        if candidate.exists():
+            return candidate
+    return None

{inline_core-1.2.5 → inline_core-1.2.6}/src/inline_core/models/checkpoint.py

@@ -59,6 +59,11 @@ class CheckpointReader:
     def keys(self) -> list[str]:
         return list(self._index)
 
+    def shapes(self) -> dict[str, list[int]]:
+        """Every tensor's shape, from the header alone - no torch, no tensor read. Lets a caller
+        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 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.6/src/inline_core/models/controlspace.py

@@ -0,0 +1,26 @@
+"""Requirements for the client-side "Control Space" node: just the suggested ControlNet model, so
+the node can offer a one-click download when ``models/controlnet/`` is empty. Torch-free (pure
+filesystem), so it registers even on a runtime-less install - a download only needs the models dir.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ..config import models_dir
+from .requirements import ModelComponent
+from .zimage.requirements import controlnet_component
+
+
+class ControlSpaceProvider:
+    """The ControlNet a Control Space render needs downstream - offered as a suggested download."""
+
+    def components(self, params: dict[str, object] | None = None) -> list[ModelComponent]:
+        return [controlnet_component()]
+
+    def download_target(self, component: ModelComponent) -> Path:
+        return models_dir() / component.category
+
+    def estimate(self, policy: Any) -> dict[str, Any] | None:
+        return None

inline_core-1.2.6/src/inline_core/models/flux2/__init__.py

@@ -0,0 +1 @@
+"""FLUX.2: one node over the whole checkpoint family (klein 4B/9B, their base builds, KV, dev)."""