inline-core 1.2.31__tar.gz → 1.2.41__tar.gz

{inline_core-1.2.31 → inline_core-1.2.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inline-core
-Version: 1.2.31
+Version: 1.2.41
 Summary: The generation engine behind Inline Studio.
 Requires-Python: >=3.11
 Requires-Dist: numpy>=1.26
@@ -38,6 +38,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

{inline_core-1.2.31 → inline_core-1.2.41}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.31"
+version = "1.2.41"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -39,6 +39,20 @@ 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",

{inline_core-1.2.31 → inline_core-1.2.41}/src/inline_core/server/app.py

@@ -29,6 +29,7 @@ from ..graph.schema import SCHEMA_VERSION, parse_graph
 from ..models.catalog import ModelCatalog
 from ..models.requirements import RequirementsRegistry
 from ..runtime.file_store import FileTakeStore
+from ..studio.system_stats import SystemStats
 from .assets import AssetStore
 from .manager import RunConflict, RunManager
 from .rpc import EventBroadcaster, RpcRouter
@@ -139,13 +140,19 @@ def create_app(
     manager = RunManager(registry, cache, policy, store=run_store, takes=FileTakeStore(takes_root))
     rpc = rpc or RpcRouter()
     events = events or EventBroadcaster()
+    # Host/GPU telemetry for the Trainer tab; only meaningful with the SPA (studio) backend wired.
+    stats = SystemStats(events) if studio_store is not None else None
 
     @asynccontextmanager
     async def lifespan(app: FastAPI):  # noqa: ANN202
         manager.bind_loop(asyncio.get_running_loop())
         catalog.ensure_dirs()
         catalog.scan()
+        if stats is not None:
+            stats.start()
         yield
+        if stats is not None:
+            stats.stop()
         manager.shutdown()
 
     app = FastAPI(title="Inline Core", version="0.0.0", lifespan=lifespan)
@@ -298,6 +305,7 @@ def create_app(
         from ..studio.handlers import register_studio_handlers
         from ..studio.models import ModelDownloads
         from ..studio.timeline.render import Timeline
+        from ..studio.training import Training
 
         def core_models() -> dict[str, Any]:
             return {
@@ -316,6 +324,7 @@ def create_app(
             generation=CoreGeneration(studio_store, manager, events),
             fal_generation=FalGeneration(studio_store, events),
             timeline=Timeline(studio_store, events),
+            training=Training(studio_store, events, on_output=catalog.rescan),
             # Explicit model downloads write into models/; rescan so new files bump the registry.
             # The policy lets the requirements popup show a memory fit estimate before a load;
             # the requirements registry says which node types have models at all.

{inline_core-1.2.31 → inline_core-1.2.41}/src/inline_core/server/rpc.py

@@ -56,6 +56,11 @@ class EventBroadcaster:
     def __init__(self) -> None:
         self._subscribers: set[asyncio.Queue[dict[str, Any]]] = set()
 
+    @property
+    def subscriber_count(self) -> int:
+        """Open ``/events`` sockets - lets pollers (telemetry) skip work when nobody listens."""
+        return len(self._subscribers)
+
     def add(self) -> asyncio.Queue[dict[str, Any]]:
         queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
         self._subscribers.add(queue)

{inline_core-1.2.31 → inline_core-1.2.41}/src/inline_core/studio/handlers.py

@@ -39,6 +39,7 @@ def register_studio_handlers(
     generation: Any = None,
     fal_generation: Any = None,
     timeline: Any = None,
+    training: Any = None,
     model_downloads: Any = None,
     app_version: str = "1.0.0",
 ) -> None:
@@ -155,7 +156,9 @@ def register_studio_handlers(
     reg("frames:deleteTake", delete_take)
 
     # --- moodboard ------------------------------------------------------------------------------
-    reg("moodboard:list", lambda: mb.list_board(conn()))
+    # `surface` defaults to the Studio moodboard so existing callers are unchanged; the Trainer tab
+    # passes "trainer" to get its own isolated canvas out of the same tables.
+    reg("moodboard:list", lambda surface=mb.STUDIO_SURFACE: mb.list_board(conn(), surface))
     reg("moodboard:addAsset", lambda aid, x, y: mb.add_asset(conn(), aid, x, y))
     reg("moodboard:addText", lambda x, y: mb.add_text(conn(), x, y))
     reg("moodboard:addFrameFromAsset", lambda aid, x, y: mb.add_frame_from_asset(conn(), aid, x, y))
@@ -183,7 +186,18 @@ def register_studio_handlers(
     reg("moodboard:setConnectorVolume", lambda cid, vol: mb.set_connector_volume(conn(), cid, vol))
     reg(
         "moodboard:replaceBoard",
-        lambda items, connectors: mb.replace_board(conn(), items, connectors),
+        lambda items, connectors, surface=mb.STUDIO_SURFACE: mb.replace_board(
+            conn(), items, connectors, surface
+        ),
+    )
+    # Trainer-canvas nodes (plus the shared read-only resource node, which either canvas can host).
+    reg("moodboard:addTrainDataset", lambda x, y: mb.add_train_dataset(conn(), x, y))
+    reg("moodboard:addCaption", lambda x, y: mb.add_caption(conn(), x, y))
+    reg("moodboard:addTrainer", lambda x, y: mb.add_trainer(conn(), x, y))
+    reg("moodboard:addLossGraph", lambda x, y: mb.add_loss_graph(conn(), x, y))
+    reg(
+        "moodboard:addResource",
+        lambda x, y, surface=mb.STUDIO_SURFACE: mb.add_resource(conn(), x, y, surface),
     )
 
     # --- generation -----------------------------------------------------------------------------
@@ -207,6 +221,25 @@ def register_studio_handlers(
     reg("generation:cancel", cancel_generation)
     reg("generation:resumePending", lambda: None)
 
+    # --- LoRA training (dataset CRUD + the training run subprocess) ------------------------------
+    if training is not None:
+        reg("training:listDatasets", lambda: training.list_datasets())
+        reg("training:createDataset", lambda inp: training.create_dataset(inp))
+        reg("training:listItems", lambda did: training.list_items(did))
+        reg("training:addItems", lambda did, aids: training.add_items(did, aids))
+        reg("training:removeItem", lambda iid: training.remove_item(iid))
+        reg("training:setCaption", lambda iid, cap: training.set_caption(iid, cap))
+        reg("training:autoCaption", lambda did, overwrite: training.auto_caption(did, overwrite))
+        reg("training:listRuns", lambda: training.list_runs())
+        reg("training:start", lambda did, hp: training.start(did, hp))
+        reg("training:resume", lambda rid: training.resume(rid))
+        reg("training:cancel", lambda rid: training.cancel(rid))
+        reg("training:status", lambda rid: training.status(rid))
+    else:
+        for ch in ("listDatasets", "createDataset", "listItems", "addItems", "removeItem",
+                   "setCaption", "autoCaption", "listRuns", "start", "resume", "cancel", "status"):
+            reg(f"training:{ch}", not_wired("LoRA training"))
+
     # --- fal settings (key stored server-side) --------------------------------------------------
     reg("falSettings:status", store.fal_status)
     reg("falSettings:setApiKey", store.set_fal_key)

{inline_core-1.2.31 → inline_core-1.2.41}/src/inline_core/studio/moodboard.py

@@ -17,10 +17,13 @@ from typing import Any
 from . import frames as fr
 
 _ITEM_COLUMNS = (
-    "id, project_id, type, asset_id, frame_id, parent_id, data, x, y, width, height, rotation, "
-    "z_index, created_at, updated_at"
+    "id, project_id, surface, type, asset_id, frame_id, parent_id, data, x, y, width, height, "
+    "rotation, z_index, created_at, updated_at"
 )
 
+#: The Studio moodboard; the Trainer tab's graph is the other surface (see schema `surface`).
+STUDIO_SURFACE = "studio"
+
 _DEFAULT_SIZE = {"image": (320, 180), "video": (360, 203), "audio": (320, 80)}
 
 _DEFAULT_TEXT = {
@@ -63,6 +66,7 @@ def _row_to_item(row: sqlite3.Row) -> dict[str, Any]:
     return {
         "id": row["id"],
         "projectId": row["project_id"],
+        "surface": row["surface"],
         "type": row["type"],
         "assetId": row["asset_id"],
         "frameId": row["frame_id"],
@@ -83,6 +87,7 @@ def _row_to_connector(row: sqlite3.Row) -> dict[str, Any]:
     return {
         "id": row["id"],
         "projectId": row["project_id"],
+        "surface": row["surface"],
         "fromItemId": row["from_item_id"],
         "toItemId": row["to_item_id"],
         "label": row["label"],
@@ -103,16 +108,28 @@ def list_items(conn: sqlite3.Connection) -> list[dict[str, Any]]:
     return [_row_to_item(r) for r in rows]
 
 
-def list_board(conn: sqlite3.Connection) -> dict[str, Any]:
-    items = [_row_to_item(r) for r in conn.execute("SELECT * FROM moodboard_items").fetchall()]
+def list_board(conn: sqlite3.Connection, surface: str = STUDIO_SURFACE) -> dict[str, Any]:
+    """One canvas's items + connectors. Surfaces are isolated: the Trainer graph never leaks into
+    the Studio moodboard (and vice versa)."""
+    items = [
+        _row_to_item(r)
+        for r in conn.execute(
+            "SELECT * FROM moodboard_items WHERE surface = ?", (surface,)
+        ).fetchall()
+    ]
     connectors = [
-        _row_to_connector(r) for r in conn.execute("SELECT * FROM moodboard_connectors").fetchall()
+        _row_to_connector(r)
+        for r in conn.execute(
+            "SELECT * FROM moodboard_connectors WHERE surface = ?", (surface,)
+        ).fetchall()
     ]
     return {"items": items, "connectors": connectors}
 
 
-def _next_z(conn: sqlite3.Connection) -> int:
-    row = conn.execute("SELECT MAX(z_index) AS z FROM moodboard_items").fetchone()
+def _next_z(conn: sqlite3.Connection, surface: str = STUDIO_SURFACE) -> int:
+    row = conn.execute(
+        "SELECT MAX(z_index) AS z FROM moodboard_items WHERE surface = ?", (surface,)
+    ).fetchone()
     return (row["z"] or 0) + 1
 
 
@@ -128,11 +145,13 @@ def _insert_item(
     asset_id: str | None = None,
     frame_id: str | None = None,
     z_index: int | None = None,
+    surface: str = STUDIO_SURFACE,
 ) -> dict[str, Any]:
     now = _now()
     item = {
         "id": _uuid(),
         "project_id": _project_id(conn),
+        "surface": surface,
         "type": item_type,
         "asset_id": asset_id,
         "frame_id": frame_id,
@@ -143,14 +162,14 @@ def _insert_item(
         "width": width,
         "height": height,
         "rotation": 0,
-        "z_index": z_index if z_index is not None else _next_z(conn),
+        "z_index": z_index if z_index is not None else _next_z(conn, surface),
         "created_at": now,
         "updated_at": now,
     }
     conn.execute(
         f"INSERT INTO moodboard_items ({_ITEM_COLUMNS}) VALUES "
-        "(:id, :project_id, :type, :asset_id, :frame_id, :parent_id, :data, :x, :y, :width, "
-        ":height, :rotation, :z_index, :created_at, :updated_at)",
+        "(:id, :project_id, :surface, :type, :asset_id, :frame_id, :parent_id, :data, :x, :y, "
+        ":width, :height, :rotation, :z_index, :created_at, :updated_at)",
         item,
     )
     return get_item(conn, item["id"])
@@ -209,6 +228,57 @@ def add_gen_node(
     )
 
 
+#: Trainer-canvas nodes. They only ever exist on the `trainer` surface (the Trainer tab's graph);
+#: `resource` is the exception - a read-only telemetry node usable on either canvas.
+TRAINER_SURFACE = "trainer"
+
+
+def add_train_dataset(
+    conn: sqlite3.Connection, x: float, y: float, surface: str = TRAINER_SURFACE
+) -> dict[str, Any]:
+    return _insert_item(
+        conn, item_type="trainDataset", x=x, y=y, width=280, height=240,
+        data={"datasetId": None}, surface=surface,
+    )
+
+
+def add_caption(
+    conn: sqlite3.Connection, x: float, y: float, surface: str = TRAINER_SURFACE
+) -> dict[str, Any]:
+    return _insert_item(
+        conn, item_type="caption", x=x, y=y, width=280, height=200,
+        data={"datasetId": None, "overwrite": False}, surface=surface,
+    )
+
+
+def add_trainer(
+    conn: sqlite3.Connection, x: float, y: float, surface: str = TRAINER_SURFACE
+) -> dict[str, Any]:
+    return _insert_item(
+        # Roomier than the other nodes on purpose: the body is a live log tail.
+        conn, item_type="trainer", x=x, y=y, width=420, height=340,
+        # `runId` is persisted so the node rebinds to its run after a reload and can still Resume.
+        data={"datasetId": None, "runId": None, "hyperparams": {}}, surface=surface,
+    )
+
+
+def add_loss_graph(
+    conn: sqlite3.Connection, x: float, y: float, surface: str = TRAINER_SURFACE
+) -> dict[str, Any]:
+    return _insert_item(
+        conn, item_type="lossGraph", x=x, y=y, width=320, height=220,
+        data={"runId": None}, surface=surface,
+    )
+
+
+def add_resource(
+    conn: sqlite3.Connection, x: float, y: float, surface: str = STUDIO_SURFACE
+) -> dict[str, Any]:
+    return _insert_item(
+        conn, item_type="resource", x=x, y=y, width=280, height=170, data={}, surface=surface
+    )
+
+
 def add_layer(conn: sqlite3.Connection, x: float, y: float) -> dict[str, Any]:
     return _insert_item(
         conn, item_type="layer", x=x, y=y, width=420, height=300, data={"name": "Layer"}, z_index=0
@@ -306,20 +376,29 @@ def delete_item(conn: sqlite3.Connection, item_id: str) -> None:
 
 
 def replace_board(
-    conn: sqlite3.Connection, items: list[dict[str, Any]], connectors: list[dict[str, Any]]
+    conn: sqlite3.Connection,
+    items: list[dict[str, Any]],
+    connectors: list[dict[str, Any]],
+    surface: str = STUDIO_SURFACE,
 ) -> None:
-    """Replace the whole board (undo/redo restore), preserving ids, in one transaction."""
+    """Replace ONE surface's board (undo/redo restore), preserving ids, in one transaction. Scoped
+    by surface so a Studio undo never wipes the Trainer canvas (they share the table)."""
     pid = _project_id(conn)
-    conn.execute("DELETE FROM moodboard_connectors WHERE project_id = ?", (pid,))
-    conn.execute("DELETE FROM moodboard_items WHERE project_id = ?", (pid,))
+    conn.execute(
+        "DELETE FROM moodboard_connectors WHERE project_id = ? AND surface = ?", (pid, surface)
+    )
+    conn.execute(
+        "DELETE FROM moodboard_items WHERE project_id = ? AND surface = ?", (pid, surface)
+    )
     for it in items:
         conn.execute(
             f"INSERT INTO moodboard_items ({_ITEM_COLUMNS}) VALUES "
-            "(:id, :project_id, :type, :asset_id, :frame_id, :parent_id, :data, :x, :y, :width, "
-            ":height, :rotation, :z_index, :created_at, :updated_at)",
+            "(:id, :project_id, :surface, :type, :asset_id, :frame_id, :parent_id, :data, :x, :y, "
+            ":width, :height, :rotation, :z_index, :created_at, :updated_at)",
             {
                 "id": it["id"],
                 "project_id": pid,
+                "surface": surface,
                 "type": it["type"],
                 "asset_id": it.get("assetId"),
                 "frame_id": it.get("frameId"),
@@ -338,11 +417,12 @@ def replace_board(
     for c in connectors:
         conn.execute(
             "INSERT INTO moodboard_connectors "
-            "(id, project_id, from_item_id, to_item_id, label, data, created_at) "
-            "VALUES (:id, :project_id, :from_item_id, :to_item_id, :label, :data, :created_at)",
+            "(id, project_id, surface, from_item_id, to_item_id, label, data, created_at) VALUES "
+            "(:id, :project_id, :surface, :from_item_id, :to_item_id, :label, :data, :created_at)",
             {
                 "id": c["id"],
                 "project_id": pid,
+                "surface": surface,
                 "from_item_id": c["fromItemId"],
                 "to_item_id": c["toItemId"],
                 "label": c.get("label"),
@@ -359,11 +439,14 @@ def create_connector(
     source_handle: str | None = None,
     target_handle: str | None = None,
 ) -> dict[str, Any]:
-    get_item(conn, from_item_id)
+    source = get_item(conn, from_item_id)
     get_item(conn, to_item_id)
     connector = {
         "id": _uuid(),
         "projectId": _project_id(conn),
+        # A connector lives on the same canvas as the nodes it joins, so it's derived rather than
+        # passed in - the caller never has to know which surface it's drawing on.
+        "surface": source["surface"],
         "fromItemId": from_item_id,
         "toItemId": to_item_id,
         "label": None,
@@ -372,11 +455,11 @@ def create_connector(
     }
     conn.execute(
         "INSERT INTO moodboard_connectors "
-        "(id, project_id, from_item_id, to_item_id, label, data, created_at) "
-        "VALUES (?, ?, ?, ?, ?, ?, ?)",
+        "(id, project_id, surface, from_item_id, to_item_id, label, data, created_at) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
         (
-            connector["id"], connector["projectId"], from_item_id, to_item_id, None,
-            json.dumps(connector["data"]), connector["createdAt"],
+            connector["id"], connector["projectId"], connector["surface"], from_item_id,
+            to_item_id, None, json.dumps(connector["data"]), connector["createdAt"],
         ),
     )
     return connector

{inline_core-1.2.31 → inline_core-1.2.41}/src/inline_core/studio/schema.py

@@ -1,16 +1,18 @@
 """SQLite schema for a project's ``project.db`` - a faithful port of the Studio TypeScript
-``electron/main/db/schema.ts`` (SCHEMA_VERSION 14). The DB is the source of truth for a project;
-"save" is implicit. Bumping ``SCHEMA_VERSION`` + adding a migration is how the schema evolves.
+``electron/main/db/schema.ts`` (ported at SCHEMA_VERSION 14). The DB is the source of truth for a
+project; "save" is implicit. Bump ``SCHEMA_VERSION`` + add a migration to evolve the schema.
 
 Kept byte-compatible with the Node schema so Core can open existing ``.inlinestudio`` projects: same
 tables, same column names, same ``user_version`` stamping, and the same additive/rename migrations.
+v15 adds the Core-only LoRA training tables (``training_datasets``/``_dataset_items``/``_runs``);
+they are purely additive, so an older project gains them on next open.
 """
 
 from __future__ import annotations
 
 import sqlite3
 
-SCHEMA_VERSION = 14
+SCHEMA_VERSION = 16
 
 SCHEMA_SQL = """
 CREATE TABLE IF NOT EXISTS project (
@@ -86,6 +88,9 @@ CREATE TABLE IF NOT EXISTS assets (
 CREATE TABLE IF NOT EXISTS moodboard_items (
   id          TEXT PRIMARY KEY,
   project_id  TEXT NOT NULL,
+  -- Which canvas the item lives on: the Studio moodboard or the Trainer tab's graph. One table,
+  -- two surfaces, so both canvases reuse the same item/connector plumbing.
+  surface     TEXT NOT NULL DEFAULT 'studio',
   type        TEXT NOT NULL DEFAULT 'asset',
   asset_id    TEXT,
   frame_id     TEXT,
@@ -104,6 +109,7 @@ CREATE TABLE IF NOT EXISTS moodboard_items (
 CREATE TABLE IF NOT EXISTS moodboard_connectors (
   id           TEXT PRIMARY KEY,
   project_id   TEXT NOT NULL,
+  surface      TEXT NOT NULL DEFAULT 'studio',
   from_item_id TEXT NOT NULL,
   to_item_id   TEXT NOT NULL,
   label        TEXT,
@@ -137,8 +143,50 @@ CREATE INDEX IF NOT EXISTS idx_frame_inputs_frame ON frame_inputs(frame_id);
 CREATE INDEX IF NOT EXISTS idx_assets_project ON assets(project_id);
 CREATE INDEX IF NOT EXISTS idx_assets_folder ON assets(folder_id);
 CREATE INDEX IF NOT EXISTS idx_asset_folders_parent ON asset_folders(parent_id);
+CREATE TABLE IF NOT EXISTS training_datasets (
+  id           TEXT PRIMARY KEY,
+  project_id   TEXT NOT NULL,
+  name         TEXT NOT NULL,
+  trigger_word TEXT NOT NULL DEFAULT '',
+  created_at   INTEGER NOT NULL,
+  updated_at   INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS training_dataset_items (
+  id          TEXT PRIMARY KEY,
+  dataset_id  TEXT NOT NULL,
+  asset_id    TEXT NOT NULL,
+  caption     TEXT NOT NULL DEFAULT '',
+  position    INTEGER NOT NULL,
+  created_at  INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS training_runs (
+  id                TEXT PRIMARY KEY,
+  project_id        TEXT NOT NULL,
+  dataset_id        TEXT NOT NULL,
+  name              TEXT NOT NULL,
+  status            TEXT NOT NULL DEFAULT 'queued',
+  base_mode         TEXT NOT NULL DEFAULT 'turbo_adapter',
+  hyperparams       TEXT NOT NULL DEFAULT '{}',
+  output_lora_path  TEXT,
+  progress_fraction REAL NOT NULL DEFAULT 0,
+  progress_status   TEXT,
+  step              INTEGER NOT NULL DEFAULT 0,
+  total_steps       INTEGER NOT NULL DEFAULT 0,
+  checkpoint_path   TEXT,
+  gpu_ids           TEXT NOT NULL DEFAULT '[]',
+  error             TEXT,
+  created_at        INTEGER NOT NULL,
+  updated_at        INTEGER NOT NULL
+);
+
 CREATE INDEX IF NOT EXISTS idx_moodboard_items_project ON moodboard_items(project_id);
 CREATE INDEX IF NOT EXISTS idx_moodboard_connectors_project ON moodboard_connectors(project_id);
+CREATE INDEX IF NOT EXISTS idx_training_datasets_project ON training_datasets(project_id);
+CREATE INDEX IF NOT EXISTS idx_training_dataset_items_dataset ON training_dataset_items(dataset_id);
+CREATE INDEX IF NOT EXISTS idx_training_runs_project ON training_runs(project_id);
+CREATE INDEX IF NOT EXISTS idx_training_runs_dataset ON training_runs(dataset_id);
 """
 
 
@@ -187,6 +235,14 @@ def _migrate_columns(conn: sqlite3.Connection) -> None:
 
     _add_column_if_missing(conn, "moodboard_items", "frame_id", "TEXT")
     _add_column_if_missing(conn, "moodboard_items", "parent_id", "TEXT")
+
+    # v15 -> v16: the Trainer tab gets its own canvas; existing items stay on the Studio surface.
+    _add_column_if_missing(
+        conn, "moodboard_items", "surface", "TEXT NOT NULL DEFAULT 'studio'"
+    )
+    _add_column_if_missing(
+        conn, "moodboard_connectors", "surface", "TEXT NOT NULL DEFAULT 'studio'"
+    )
     _add_column_if_missing(conn, "frame_inputs", "source_frame_id", "TEXT")
 
     _relax_frame_inputs_asset_id(conn)  # v8 -> v9: asset_id must be nullable

inline_core-1.2.41/src/inline_core/studio/system_stats.py

@@ -0,0 +1,92 @@
+"""Periodic host + GPU telemetry, broadcast on ``events:systemStats`` for the Trainer tab.
+
+Samples CPU/RAM (psutil) and per-GPU utilization/VRAM/temp (pynvml) about once a second and fans it
+out to every ``/events`` subscriber. Skips sampling entirely when nobody is listening, so it costs
+nothing with no client connected. GPU stats are NVIDIA-only; an MPS/CPU host reports host metrics
+with an empty ``gpus`` list. Missing psutil/pynvml degrade to zeros rather than erroring.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+_INTERVAL_SECONDS = 1.5
+
+
+class SystemStats:
+    """A background poller that broadcasts ``SystemStatsEvent`` frames while clients connect."""
+
+    def __init__(self, events: Any) -> None:
+        self._events = events
+        self._task: asyncio.Task[None] | None = None
+        self._nvml_ready = False
+
+    def start(self) -> None:
+        if self._task is None:
+            self._task = asyncio.create_task(self._loop())
+
+    def stop(self) -> None:
+        if self._task is not None:
+            self._task.cancel()
+            self._task = None
+
+    async def _loop(self) -> None:
+        try:
+            while True:
+                await asyncio.sleep(_INTERVAL_SECONDS)
+                if self._events.subscriber_count == 0:
+                    continue  # nobody watching - don't spend a sample
+                stats = await asyncio.to_thread(self._sample)
+                self._events.broadcast("events:systemStats", stats)
+        except asyncio.CancelledError:
+            pass
+
+    def _sample(self) -> dict[str, Any]:
+        cpu, ram_used, ram_total = self._host()
+        return {"cpu": cpu, "ramUsed": ram_used, "ramTotal": ram_total, "gpus": self._gpus()}
+
+    def _host(self) -> tuple[float, int, int]:
+        try:
+            import psutil
+
+            vm = psutil.virtual_memory()
+            return float(psutil.cpu_percent()), int(vm.used), int(vm.total)
+        except Exception:  # noqa: BLE001 - psutil optional; telemetry degrades to zeros
+            return 0.0, 0, 0
+
+    def _gpus(self) -> list[dict[str, Any]]:
+        try:
+            import pynvml
+        except Exception:  # noqa: BLE001 - no NVML (non-NVIDIA or extra not installed)
+            return []
+        try:
+            if not self._nvml_ready:
+                pynvml.nvmlInit()
+                self._nvml_ready = True
+            out: list[dict[str, Any]] = []
+            for i in range(pynvml.nvmlDeviceGetCount()):
+                handle = pynvml.nvmlDeviceGetHandleByIndex(i)
+                mem = pynvml.nvmlDeviceGetMemoryInfo(handle)
+                util = pynvml.nvmlDeviceGetUtilizationRates(handle)
+                name = pynvml.nvmlDeviceGetName(handle)
+                out.append(
+                    {
+                        "index": i,
+                        "name": name.decode() if isinstance(name, bytes) else name,
+                        "utilization": float(util.gpu),
+                        "memoryUsed": int(mem.used),
+                        "memoryTotal": int(mem.total),
+                        "temperature": _temperature(pynvml, handle),
+                    }
+                )
+            return out
+        except Exception:  # noqa: BLE001 - any NVML hiccup: report no GPUs rather than crash
+            return []
+
+
+def _temperature(pynvml: Any, handle: Any) -> float | None:
+    try:
+        return float(pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU))
+    except Exception:  # noqa: BLE001
+        return None