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

{inline_core-1.2.3 → 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.3 → inline_core-1.2.6}/PKG-INFO

@@ -1,18 +1,28 @@
 Metadata-Version: 2.4
 Name: inline-core
-Version: 1.2.3
+Version: 1.2.6
 Summary: The generation engine behind Inline Studio.
+License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11
 Requires-Dist: numpy>=1.26
 Requires-Dist: psutil>=5.9
 Provides-Extra: all
 Requires-Dist: accelerate>=0.30; extra == 'all'
-Requires-Dist: diffusers>=0.36; 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'
@@ -27,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: diffusers>=0.36; 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'
@@ -38,6 +50,14 @@ Provides-Extra: server
 Requires-Dist: fastapi>=0.110; extra == 'server'
 Requires-Dist: imageio-ffmpeg>=0.4; extra == 'server'
 Requires-Dist: uvicorn[standard]>=0.29; extra == 'server'
+Provides-Extra: training
+Requires-Dist: bitsandbytes>=0.43; (platform_system != 'Darwin') and extra == 'training'
+Requires-Dist: einops>=0.7; extra == 'training'
+Requires-Dist: nvidia-ml-py>=12; extra == 'training'
+Requires-Dist: peft>=0.11; extra == 'training'
+Requires-Dist: pillow>=10; extra == 'training'
+Requires-Dist: psutil>=5.9; extra == 'training'
+Requires-Dist: timm>=1.0; extra == 'training'
 Description-Content-Type: text/markdown
 
 # Inline Core
@@ -47,8 +67,9 @@ The generation engine behind Inline. It takes a typed node graph (JSON) and retu
 low-VRAM laptops up to multi-GPU machines that split a single image's sampling across GPUs (via
 xDiT). It is Inline Studio's built-in render backend.
 
-First model: Z-Image (Alibaba Tongyi), a 6B rectified-flow diffusion transformer (and a model xDiT
-already supports, so the multi-GPU split works on it from the start).
+Models today: **Z-Image** (Alibaba Tongyi), a 6B rectified-flow diffusion transformer and the model
+xDiT already supports, so the multi-GPU split works on it from the start; and **Krea 2** (Krea AI),
+a 12.9B single-stream MMDiT released as an undistilled RAW base plus an 8-step distilled Turbo.
 
 > 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
@@ -80,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,
@@ -94,9 +120,13 @@ by category:
 
 ```
 models/
-  diffusion_models/   z_image_turbo_bf16.safetensors   <- the one file you need for Z-Image
-  vae/                ae.safetensors                   <- optional (see below)
-  text_encoders/      qwen/   (an HF-format folder: config + tokenizer + weights)  <- optional
+  diffusion_models/   z_image_turbo_bf16.safetensors        <- Z-Image
+                      krea2_turbo_bf16.safetensors          <- Krea 2 Turbo (generate)
+                      krea2_raw_bf16.safetensors            <- Krea 2 RAW (fine-tune)
+  vae/                ae.safetensors                        <- Z-Image
+                      qwen_image_vae_diffusers.safetensors  <- Krea 2
+  text_encoders/      qwen_3_4b.safetensors                 <- Z-Image
+                      qwen3vl_4b_bf16.safetensors           <- Krea 2
   loras/  controlnet/  checkpoints/  ...
 ```
 
@@ -115,8 +145,17 @@ paths:
    `models/`** (never the hidden HF cache) with visible progress.
 
 Override the diffusion source with `INLINE_ZIMAGE_MODEL` (a file or a diffusers dir), and the supporting
-components with `INLINE_ZIMAGE_VAE` / `INLINE_ZIMAGE_TEXT_ENCODER`. The engine scans the models dir on
-start; a node's model pickers list what is present.
+components with `INLINE_ZIMAGE_VAE` / `INLINE_ZIMAGE_TEXT_ENCODER`; Krea 2 has the same three under
+`INLINE_KREA2_*`. The engine scans the models dir on start; a node's model pickers list what is present.
+
+**Krea 2 loads from the same ComfyUI single files**, with two constraints worth knowing. Only the
+**bf16** builds in [`Comfy-Org/Krea-2`](https://huggingface.co/Comfy-Org/Krea-2) are loadable: the
+fp8/int8/nvfp4 variants carry ComfyUI-specific scale tensors, and the loader refuses them by name
+rather than failing mid-load. And the **VAE must be the diffusers-format** Qwen-Image file (the
+node's popup fetches it from `Qwen/Qwen-Image`), because ComfyUI's copy of the same weights uses a
+module layout diffusers has no converter for. `Krea2Transformer2DModel` has no `from_single_file`, so
+the transformer checkpoint is renamed into diffusers naming on load (`models/krea2/convert.py`) and
+streamed tensor by tensor onto the GPU.
 
 ## Nodes
 
@@ -124,8 +163,9 @@ start; a node's model pickers list what is present.
 renders any node generically - adding a node type needs no UI release.
 
 **High-level model nodes are what the user sees.** Generation is one-click: you drop a single
-**Z-Image Turbo** node, wire a Prompt into it, and hit Run. The node hooks up the diffusion model, VAE,
-and text-encoder behind the scenes - no loader/sampler wiring.
+**Z-Image Turbo**, **Krea 2 Turbo** or **Krea 2 RAW** node, wire a Prompt into it, and hit Run. The
+node hooks up the diffusion model, VAE, and text-encoder behind the scenes - no loader/sampler
+wiring.
 
 Underneath, a **low-level primitive vocabulary** exists (`load/diffusion-model`, `load/vae`,
 `load/text-encoder`, `encode/text`, `latent/empty`, `sample`, `vae/decode`, `vae/encode`) - the
@@ -207,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 zimage   # set up ./.venv with the Z-Image runtime, then exit
+./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.3 → inline_core-1.2.6}/README.md

@@ -5,8 +5,9 @@ The generation engine behind Inline. It takes a typed node graph (JSON) and retu
 low-VRAM laptops up to multi-GPU machines that split a single image's sampling across GPUs (via
 xDiT). It is Inline Studio's built-in render backend.
 
-First model: Z-Image (Alibaba Tongyi), a 6B rectified-flow diffusion transformer (and a model xDiT
-already supports, so the multi-GPU split works on it from the start).
+Models today: **Z-Image** (Alibaba Tongyi), a 6B rectified-flow diffusion transformer and the model
+xDiT already supports, so the multi-GPU split works on it from the start; and **Krea 2** (Krea AI),
+a 12.9B single-stream MMDiT released as an undistilled RAW base plus an 8-step distilled Turbo.
 
 > 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
@@ -38,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,
@@ -52,9 +58,13 @@ by category:
 
 ```
 models/
-  diffusion_models/   z_image_turbo_bf16.safetensors   <- the one file you need for Z-Image
-  vae/                ae.safetensors                   <- optional (see below)
-  text_encoders/      qwen/   (an HF-format folder: config + tokenizer + weights)  <- optional
+  diffusion_models/   z_image_turbo_bf16.safetensors        <- Z-Image
+                      krea2_turbo_bf16.safetensors          <- Krea 2 Turbo (generate)
+                      krea2_raw_bf16.safetensors            <- Krea 2 RAW (fine-tune)
+  vae/                ae.safetensors                        <- Z-Image
+                      qwen_image_vae_diffusers.safetensors  <- Krea 2
+  text_encoders/      qwen_3_4b.safetensors                 <- Z-Image
+                      qwen3vl_4b_bf16.safetensors           <- Krea 2
   loras/  controlnet/  checkpoints/  ...
 ```
 
@@ -73,8 +83,17 @@ paths:
    `models/`** (never the hidden HF cache) with visible progress.
 
 Override the diffusion source with `INLINE_ZIMAGE_MODEL` (a file or a diffusers dir), and the supporting
-components with `INLINE_ZIMAGE_VAE` / `INLINE_ZIMAGE_TEXT_ENCODER`. The engine scans the models dir on
-start; a node's model pickers list what is present.
+components with `INLINE_ZIMAGE_VAE` / `INLINE_ZIMAGE_TEXT_ENCODER`; Krea 2 has the same three under
+`INLINE_KREA2_*`. The engine scans the models dir on start; a node's model pickers list what is present.
+
+**Krea 2 loads from the same ComfyUI single files**, with two constraints worth knowing. Only the
+**bf16** builds in [`Comfy-Org/Krea-2`](https://huggingface.co/Comfy-Org/Krea-2) are loadable: the
+fp8/int8/nvfp4 variants carry ComfyUI-specific scale tensors, and the loader refuses them by name
+rather than failing mid-load. And the **VAE must be the diffusers-format** Qwen-Image file (the
+node's popup fetches it from `Qwen/Qwen-Image`), because ComfyUI's copy of the same weights uses a
+module layout diffusers has no converter for. `Krea2Transformer2DModel` has no `from_single_file`, so
+the transformer checkpoint is renamed into diffusers naming on load (`models/krea2/convert.py`) and
+streamed tensor by tensor onto the GPU.
 
 ## Nodes
 
@@ -82,8 +101,9 @@ start; a node's model pickers list what is present.
 renders any node generically - adding a node type needs no UI release.
 
 **High-level model nodes are what the user sees.** Generation is one-click: you drop a single
-**Z-Image Turbo** node, wire a Prompt into it, and hit Run. The node hooks up the diffusion model, VAE,
-and text-encoder behind the scenes - no loader/sampler wiring.
+**Z-Image Turbo**, **Krea 2 Turbo** or **Krea 2 RAW** node, wire a Prompt into it, and hit Run. The
+node hooks up the diffusion model, VAE, and text-encoder behind the scenes - no loader/sampler
+wiring.
 
 Underneath, a **low-level primitive vocabulary** exists (`load/diffusion-model`, `load/vae`,
 `load/text-encoder`, `encode/text`, `latent/empty`, `sample`, `vae/decode`, `vae/encode`) - the
@@ -165,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 zimage   # set up ./.venv with the Z-Image runtime, then exit
+./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.3 → inline_core-1.2.6}/pyproject.toml

@@ -1,9 +1,10 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.3"
+version = "1.2.6"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
+license = "GPL-3.0-or-later"
 requires-python = ">=3.11"
 # Deliberately torch-free so the engine boots and serves source nodes with no ML stack installed.
 dependencies = [
@@ -16,8 +17,8 @@ dependencies = [
 runtime = [
   # A bare `torch` is CPU-only on Windows; see [tool.uv] below and requirements.txt.
   "torch>=2.2",
-  # Z-Image needs diffusers >= 0.36 (ZImagePipeline).
-  "diffusers>=0.36",
+  # Krea 2 needs diffusers >= 0.39 (Krea2Pipeline); Z-Image needs >= 0.36 (ZImagePipeline).
+  "diffusers>=0.39",
   "transformers>=4.44",
   "accelerate>=0.30",
   "safetensors>=0.4",
@@ -27,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",
@@ -39,25 +44,54 @@ parallel = [
   "xfuser>=0.4",
   "nvidia-ml-py>=12",
 ]
+# LoRA training (the Trainer tab): PEFT adapter training + local auto-caption + host/GPU telemetry.
+# Install alongside `runtime`: `.[runtime,training]`. Reuses runtime's torch/diffusers/accelerate.
+training = [
+  "peft>=0.11",
+  # 8-bit Adam keeps optimizer state small; no macOS wheels, so skip it there (AdamW fallback).
+  "bitsandbytes>=0.43; platform_system != 'Darwin'",
+  "Pillow>=10",
+  # Telemetry (CPU/RAM + per-GPU NVML) for the Trainer tab.
+  "psutil>=5.9",
+  "nvidia-ml-py>=12",
+  # Florence-2 auto-captioner is loaded via trust_remote_code and needs these.
+  "timm>=1.0",
+  "einops>=0.7",
+]
 dev = [
   "pytest>=8",
   "ruff>=0.6",
   "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.36",
+  "diffusers>=0.39",
   "transformers>=4.44",
   "accelerate>=0.30",
   "safetensors>=0.4",
   "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).
@@ -93,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.3 → 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.3 → 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.6/src/inline_core/ffmpeg.py

@@ -0,0 +1,30 @@
+"""Locate the ffmpeg/ffprobe binaries. Prefers a bundled ``imageio-ffmpeg``, else PATH.
+
+Lives at the top level rather than under ``studio/`` because both the timeline (studio) and the
+take store (runtime) need it, and runtime must not import studio.
+"""
+
+from __future__ import annotations
+
+import shutil
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def ffmpeg_exe() -> str | None:
+    try:
+        import imageio_ffmpeg
+
+        return imageio_ffmpeg.get_ffmpeg_exe()
+    except Exception:  # noqa: BLE001
+        return shutil.which("ffmpeg")
+
+
+@lru_cache(maxsize=1)
+def ffprobe_exe() -> str | None:
+    """PATH only - imageio bundles ffmpeg alone, so probing degrades gracefully when absent."""
+    return shutil.which("ffprobe")
+
+
+def ffmpeg_available() -> bool:
+    return ffmpeg_exe() is not None

{inline_core-1.2.3 → 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()