inline-core 1.2.52__tar.gz → 1.2.53__tar.gz

{inline_core-1.2.52 → inline_core-1.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inline-core
-Version: 1.2.52
+Version: 1.2.53
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11
@@ -9,12 +9,14 @@ 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'
@@ -35,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'

{inline_core-1.2.52 → inline_core-1.2.53}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.52"
+version = "1.2.53"
 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",
@@ -74,6 +78,8 @@ 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",

inline_core-1.2.53/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.52 → inline_core-1.2.53}/src/inline_core/device/memory.py

@@ -202,9 +202,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:

{inline_core-1.2.52 → inline_core-1.2.53}/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.52 → inline_core-1.2.53}/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.52 → inline_core-1.2.53}/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.52 → inline_core-1.2.53}/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.53/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.53/src/inline_core/models/krea2/depth_control.py

@@ -0,0 +1,149 @@
+"""Krea 2 depth control: the public ``Patil/Krea-2-depth-controlnet`` control-LoRA, ported onto the
+diffusers ``Krea2Transformer2DModel``.
+
+The adapter is a rank-64 LoRA on every transformer block **plus a full replacement input
+projection** (``first.weight [6144, 128]``): the base projection takes 64 packed latent channels,
+expanded to 128 so a VAE-encoded depth latent rides alongside the noisy latent, concatenated on the
+channel dim. The base stays frozen and the depth latent is constant across the whole denoise.
+
+The checkpoint uses the reference krea-2 names (``blocks.N.attn.wq``, ``first``); ``convert_key``
+already remaps those to diffusers names (``transformer_blocks.N.attn.to_q``, ``img_in``), the same
+rename the base checkpoint needs. Wrapping ``img_in`` lets the depth concat happen transparently
+inside the pipeline's own denoise loop - no fork of ``Krea2Pipeline.__call__``. Reference:
+github.com/Tanmaypatil123/Krea-2-controlnet.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ...errors import ComponentError
+from .convert import convert_key
+from .img2img import encode_image
+
+
+class LoRALinear(nn.Module):
+    """``y = W x + scale * (x A^T) B^T``. Base frozen; ``scale`` is the live control strength."""
+
+    def __init__(self, base: nn.Linear, rank: int, scale: float = 1.0) -> None:
+        super().__init__()
+        self.base = base
+        self.scale = scale
+        self.A = nn.Parameter(torch.zeros(rank, base.in_features, dtype=torch.float32))
+        self.B = nn.Parameter(torch.zeros(base.out_features, rank, dtype=torch.float32))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        lora = (x @ self.A.T.to(x.dtype)) @ self.B.T.to(x.dtype)
+        return self.base(x) + lora * self.scale
+
+
+class ControlInputLayer(nn.Module):
+    """Replaces ``img_in``: input width doubled (64 -> 128) to accept
+    ``[noisy latent ; depth latent]`` concatenated on the channel dim. The depth latent is stashed
+    on ``self.ctrl`` once per run and broadcast over the batch (so CFG's doubled batch lines up)."""
+
+    def __init__(self, pretrained: nn.Linear) -> None:
+        super().__init__()
+        self._in = pretrained.in_features
+        # The checkpoint always carries the full trained input projection (both the base and depth
+        # halves), so zeros are enough here - and this avoids dequantizing a possibly-int8 base.
+        self.weight = nn.Parameter(torch.zeros(pretrained.out_features, self._in * 2))
+        self.bias = nn.Parameter(torch.zeros(pretrained.out_features))
+        self.ctrl: torch.Tensor | None = None
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.ctrl is None:  # a control pipe always has ctrl set before a run; zeros = no depth
+            ctrl = x.new_zeros((*x.shape[:-1], self._in))
+        else:
+            ctrl = self.ctrl.to(device=x.device, dtype=x.dtype)
+            if ctrl.shape[0] != x.shape[0]:
+                ctrl = ctrl.expand(x.shape[0], -1, -1)
+        combined = torch.cat([x, ctrl], dim=-1)
+        return F.linear(combined, self.weight.to(x.dtype), self.bias.to(x.dtype))
+
+
+def _get(root: Any, path: str) -> Any:
+    for part in path.split("."):
+        root = root[int(part)] if part.isdigit() else getattr(root, part)
+    return root
+
+
+def _set(root: Any, path: str, value: Any) -> None:
+    parts = path.split(".")
+    parent = _get(root, ".".join(parts[:-1])) if len(parts) > 1 else root
+    last = parts[-1]
+    if last.isdigit():
+        parent[int(last)] = value
+    else:
+        setattr(parent, last, value)
+
+
+def _module_paths(state: dict[str, torch.Tensor]) -> list[str]:
+    """The block-linear module paths the adapter references (``img_in`` handled separately)."""
+    paths: list[str] = []
+    for key in state:
+        if key.startswith("img_in."):
+            continue
+        stem = key.rsplit(".", 1)[0]  # drop the trailing .A / .B
+        if stem not in paths:
+            paths.append(stem)
+    return paths
+
+
+def install_depth_control(transformer: Any, lora_file: str) -> None:
+    """Wrap ``img_in`` + every block linear the LoRA touches, then load the trained weights in.
+
+    Idempotent per pipeline: only called on a cache miss, so a cached control pipe keeps its work.
+    ``set_control`` / ``set_control_strength`` are the per-run knobs on top of it.
+    """
+    import safetensors.torch
+
+    st: Any = safetensors.torch
+    raw: dict[str, Any] = st.load_file(lora_file)
+    state = {convert_key(k): v for k, v in raw.items()}
+    a_shapes = [t.shape[0] for k, t in state.items() if k.endswith(".A")]
+    if not a_shapes:
+        raise ComponentError("Krea 2 depth control file has no LoRA tensors; not the adapter.")
+    rank = a_shapes[0]
+
+    device = next(transformer.parameters()).device
+    transformer.img_in = ControlInputLayer(transformer.img_in).to(device)
+    for path in _module_paths(state):
+        _set(transformer, path, LoRALinear(_get(transformer, path), rank).to(device))
+
+    missing, unexpected = transformer.load_state_dict(state, strict=False)
+    if unexpected:
+        raise ComponentError(
+            f"Krea 2 depth control-LoRA has {len(unexpected)} tensors that do not map onto the "
+            f"model (e.g. {', '.join(unexpected[:3])}). It may be for a different Krea 2 build."
+        )
+    # The expanded input projection is zero-initialised, so it MUST come from the checkpoint.
+    if "img_in.weight" in missing or "img_in.bias" in missing:
+        raise ComponentError(
+            "Krea 2 depth control-LoRA is missing its input projection (img_in); not the adapter."
+        )
+
+
+def set_control_strength(transformer: Any, scale: float) -> None:
+    """Dial the block LoRA delta (the depth ``img_in`` expansion always applies). No rebuild."""
+    for module in transformer.modules():
+        if isinstance(module, LoRALinear):
+            module.scale = scale
+
+
+def set_control(transformer: Any, ctrl_latent: torch.Tensor | None) -> None:
+    img_in = transformer.img_in
+    if isinstance(img_in, ControlInputLayer):
+        img_in.ctrl = ctrl_latent
+
+
+def encode_depth_latent(
+    pipe: Any, depth_image: Any, *, width: int, height: int, device: str, generator: Any
+) -> torch.Tensor:
+    """The depth map as a packed Krea 2 latent, ready to concat onto the noisy latent - the same VAE
+    encode + pack the img2img path uses, so the two latents share a layout."""
+    return encode_image(pipe, depth_image, width, height, device, generator)

{inline_core-1.2.52 → inline_core-1.2.53}/src/inline_core/models/krea2/img2img.py

@@ -54,14 +54,14 @@ def img2img_kwargs(
     schedule.set_timesteps(sigmas=raw, mu=mu, device=device)
     sigma = schedule.sigmas[start].to(device)
 
-    latents = _encode_image(pipe, image, width, height, device, generator)
+    latents = encode_image(pipe, image, width, height, device, generator)
     noise = torch.randn(
         latents.shape, generator=generator, device=latents.device, dtype=latents.dtype
     )
     return {"latents": (1.0 - sigma) * latents + sigma * noise, "sigmas": raw[start:].tolist()}
 
 
-def _encode_image(
+def encode_image(
     pipe: Any, image: Any, width: int, height: int, device: str, generator: Any
 ) -> Any:
     """The input image as packed, normalized Krea 2 latents. The Qwen-Image VAE is a video codec, so

{inline_core-1.2.52 → inline_core-1.2.53}/src/inline_core/models/krea2/requirements.py

@@ -27,6 +27,11 @@ VAE_FILE = "qwen_image_vae_diffusers.safetensors"
 VAE_REPO_FILE = "vae/diffusion_pytorch_model.safetensors"
 TEXT_ENCODER_FILE = "qwen3vl_4b_bf16.safetensors"
 
+#: The public Krea 2 depth control-LoRA (rank-64 + expanded input projection). It lands in
+#: ``controlnet/`` alongside any Z-Image controlnet; resolution is name-scoped so the two never mix.
+DEPTH_CONTROL_REPO = "Patil/Krea-2-depth-controlnet"
+DEPTH_CONTROL_FILE = "depth-control-lora.safetensors"
+
 #: variant -> the file the popup downloads for that node.
 DIFFUSION_FILES = {
     "turbo": "krea2_turbo_bf16.safetensors",
@@ -61,6 +66,18 @@ def _env_path(kind: str) -> Path | None:
     return path if path.exists() else None
 
 
+def foreign_model_message(path: str) -> str | None:
+    """A clear error when a diffusion file plainly belongs to another architecture (a Z-Image file
+    picked for a Krea 2 node) - name-based, best-effort, to avoid silently distorted output."""
+    name = Path(path).name.lower()
+    if ("z_image" in name or "z-image" in name) and "krea" not in name:
+        return (
+            f"'{Path(path).name}' is a Z-Image model, but this is a Krea 2 node. Pick a "
+            "krea2_*.safetensors in the Diffusion file dropdown (or clear it to auto-select)."
+        )
+    return None
+
+
 def resolve_diffusion(variant: str, params: dict[str, object] | None = None) -> Path | None:
     """The Krea 2 transformer file for this node: the dropdown pick, the env override, the exact
     recommended file, else any krea2 file matching the variant. A user holding both RAW and Turbo
@@ -86,6 +103,57 @@ def resolve_diffusion(variant: str, params: dict[str, object] | None = None) ->
     return krea[0] if krea else None
 
 
+def resolve_depth_control(params: dict[str, object] | None = None) -> Path | None:
+    """The depth control-LoRA file, or None. Opt-in like Z-Image control: resolves only from
+    ``INLINE_KREA2_CONTROL`` or an explicit ``depth_controlnet`` dropdown pick (never auto)."""
+    env = os.environ.get("INLINE_KREA2_CONTROL", "").strip()
+    if env:
+        path = Path(env)
+        return path if path.exists() else None
+    chosen = str((params or {}).get("depth_controlnet") or "").strip()
+    if not chosen:
+        return None
+    picked = models_dir() / "controlnet" / chosen
+    return picked if picked.is_file() else None
+
+
+def auto_depth_control() -> Path | None:
+    """The depth control-LoRA to use when a control map is wired but none was picked - the exact
+    downloaded file, else a krea+depth-named weight. None if absent. Only consulted when a control
+    input is actually connected, so depth control stays opt-in and never touches a plain run."""
+    root = models_dir() / "controlnet"
+    if not root.is_dir():
+        return None
+    exact = root / DEPTH_CONTROL_FILE
+    if exact.is_file():
+        return exact
+    for path in sorted(root.iterdir()):
+        name = path.name.lower()
+        if path.is_file() and path.suffix.lower() in _WEIGHT_SUFFIXES:
+            if "krea" in name and "depth" in name:
+                return path
+    return None
+
+
+def depth_control_present() -> bool:
+    return auto_depth_control() is not None
+
+
+def depth_control_component() -> ModelComponent:
+    """The suggested depth control-LoRA download, offered on both Krea 2 nodes. Optional: it never
+    blocks a plain run."""
+    return ModelComponent(
+        id="depth_controlnet",
+        label="Depth control-LoRA",
+        category="controlnet",
+        present=depth_control_present(),
+        filename=DEPTH_CONTROL_FILE,
+        repo=DEPTH_CONTROL_REPO,
+        repo_file=DEPTH_CONTROL_FILE,
+        optional=True,
+    )
+
+
 def resolve_vae(params: dict[str, object] | None = None) -> Path | None:
     return _resolve_shared("vae", "vae", VAE_FILE, params)
 
@@ -148,6 +216,8 @@ def krea2_requirements(
             repo=VAE_REPO,
             repo_file=VAE_REPO_FILE,
         ),
+        # Suggested, not required: offered in the popup so a depth map has an adapter to run with.
+        depth_control_component(),
     ]
 
 
@@ -170,11 +240,15 @@ def _file_bytes(path: object) -> int:
 
 
 def footprint_bytes(
-    diffusion: object = None, vae: object = None, text_encoder: object = None
+    diffusion: object = None,
+    vae: object = None,
+    text_encoder: object = None,
+    controlnet: object = None,
 ) -> dict[str, int]:
     """On-disk sizes keyed to match ``ModelFootprint``. Torch-free (a plain ``stat``)."""
     return {
         "diffusion_bytes": _file_bytes(diffusion),
         "text_encoder_bytes": _file_bytes(text_encoder),
         "vae_bytes": _file_bytes(vae),
+        "controlnet_bytes": _file_bytes(controlnet),
     }