scenri 0.8.2 → 0.9.0

package/dist/chunk-OJAG3FRX.js

@@ -0,0 +1,1940 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import Database from 'better-sqlite3';
+import { randomUUID, createHash } from 'crypto';
+import { mkdirSync, existsSync, chmodSync, readFileSync, writeFileSync, readdirSync, rmSync } from 'fs';
+
+// ../core/src/index.ts
+
+// ../core/src/slug.ts
+var slugify = (s, fallback = "brand") => s.normalize("NFKD").replace(new RegExp("\\p{M}+", "gu"), "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 48).replace(/-+$/g, "") || fallback;
+var slugifyWithId = (s, id, fallback = "brand") => {
+  const base = slugify(s, fallback);
+  return base === fallback ? `${fallback}-${id.slice(0, 8)}` : base;
+};
+var RESERVED_SLUGS = /* @__PURE__ */ new Set(["api", "assets", "b", "setup"]);
+function firstFree(base, taken) {
+  for (let n = 1; ; n++) {
+    const candidate = n === 1 ? base : `${base}-${n}`;
+    if (!taken(candidate)) return candidate;
+  }
+}
+
+// ../core/src/db.ts
+var MIGRATIONS = `
+CREATE TABLE IF NOT EXISTS brands (
+  id TEXT PRIMARY KEY,
+  slug TEXT NOT NULL,
+  json TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  brand_id TEXT NOT NULL REFERENCES brands(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  slug TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS nodes (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  parent_id TEXT REFERENCES nodes(id),
+  kind TEXT NOT NULL CHECK (kind IN ('root','generation','edit')),
+  prompt TEXT NOT NULL DEFAULT '',
+  engine_id TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'running' CHECK (status IN ('running','done','error')),
+  images TEXT NOT NULL DEFAULT '[]',
+  cost_usd REAL NOT NULL DEFAULT 0,
+  kept INTEGER NOT NULL DEFAULT 0,
+  error TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
+CREATE TABLE IF NOT EXISTS sets (
+  id TEXT PRIMARY KEY,
+  brand_id TEXT NOT NULL REFERENCES brands(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  slug TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_sets_slug ON sets(brand_id, slug);
+CREATE TABLE IF NOT EXISTS set_nodes (
+  set_id TEXT NOT NULL REFERENCES sets(id) ON DELETE CASCADE,
+  node_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  added_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY (set_id, node_id)
+);
+CREATE INDEX IF NOT EXISTS idx_set_nodes_node ON set_nodes(node_id);
+CREATE TABLE IF NOT EXISTS cost_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  engine_id TEXT NOT NULL,
+  node_id TEXT,
+  cost_usd REAL NOT NULL,
+  ts TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS spend_caps (
+  engine_id TEXT PRIMARY KEY,
+  monthly_cap_usd REAL NOT NULL
+);
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS catalog_sources (
+  id TEXT PRIMARY KEY,
+  brand_id TEXT NOT NULL REFERENCES brands(id) ON DELETE CASCADE,
+  url TEXT NOT NULL,
+  platform TEXT NOT NULL DEFAULT 'unknown',
+  status TEXT NOT NULL DEFAULT 'idle',
+  last_import_at TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(brand_id, url)
+);
+CREATE TABLE IF NOT EXISTS catalog_products (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL REFERENCES catalog_sources(id) ON DELETE CASCADE,
+  brand_id TEXT NOT NULL REFERENCES brands(id) ON DELETE CASCADE,
+  external_key TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description_html TEXT,
+  url TEXT NOT NULL,
+  handle TEXT,
+  vendor TEXT,
+  product_type TEXT,
+  tags TEXT NOT NULL DEFAULT '[]',
+  category TEXT,
+  price REAL,
+  compare_at_price REAL,
+  currency TEXT,
+  available INTEGER,
+  status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active','unavailable')),
+  raw TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(source_id, external_key)
+);
+CREATE INDEX IF NOT EXISTS idx_catalog_products_brand ON catalog_products(brand_id);
+CREATE TABLE IF NOT EXISTS catalog_variants (
+  id TEXT PRIMARY KEY,
+  product_id TEXT NOT NULL REFERENCES catalog_products(id) ON DELETE CASCADE,
+  external_key TEXT NOT NULL,
+  title TEXT,
+  sku TEXT,
+  price REAL,
+  compare_at_price REAL,
+  currency TEXT,
+  available INTEGER,
+  options TEXT NOT NULL DEFAULT '{}'
+);
+CREATE TABLE IF NOT EXISTS catalog_images (
+  id TEXT PRIMARY KEY,
+  product_id TEXT NOT NULL REFERENCES catalog_products(id) ON DELETE CASCADE,
+  source_url TEXT NOT NULL,
+  asset_ref TEXT,
+  width INTEGER,
+  height INTEGER,
+  position INTEGER NOT NULL DEFAULT 0,
+  alt TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_catalog_images_product ON catalog_images(product_id);
+CREATE TABLE IF NOT EXISTS catalog_collections (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL REFERENCES catalog_sources(id) ON DELETE CASCADE,
+  external_key TEXT NOT NULL,
+  title TEXT NOT NULL,
+  url TEXT,
+  UNIQUE(source_id, external_key)
+);
+CREATE TABLE IF NOT EXISTS catalog_collection_products (
+  collection_id TEXT NOT NULL REFERENCES catalog_collections(id) ON DELETE CASCADE,
+  product_id TEXT NOT NULL REFERENCES catalog_products(id) ON DELETE CASCADE,
+  PRIMARY KEY (collection_id, product_id)
+);
+CREATE TABLE IF NOT EXISTS import_jobs (
+  id TEXT PRIMARY KEY,
+  brand_id TEXT NOT NULL REFERENCES brands(id) ON DELETE CASCADE,
+  source_id TEXT REFERENCES catalog_sources(id) ON DELETE SET NULL,
+  url TEXT NOT NULL,
+  platform TEXT NOT NULL DEFAULT 'unknown',
+  stage TEXT NOT NULL DEFAULT 'queued',
+  discovered INTEGER NOT NULL DEFAULT 0,
+  fetched INTEGER NOT NULL DEFAULT 0,
+  upserted INTEGER NOT NULL DEFAULT 0,
+  images_done INTEGER NOT NULL DEFAULT 0,
+  images_total INTEGER NOT NULL DEFAULT 0,
+  errors TEXT NOT NULL DEFAULT '[]',
+  warnings TEXT NOT NULL DEFAULT '[]',
+  message TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  finished_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_import_jobs_brand ON import_jobs(brand_id);
+`;
+function widenNodeStatusCheck(db) {
+  const row = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='nodes'").get();
+  if (!row || row.sql.includes("'cancelled'")) return;
+  db.pragma("foreign_keys = OFF");
+  db.transaction(() => {
+    db.exec(`
+      CREATE TABLE nodes_new (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        parent_id TEXT REFERENCES nodes_new(id),
+        kind TEXT NOT NULL CHECK (kind IN ('root','generation','edit')),
+        prompt TEXT NOT NULL DEFAULT '',
+        engine_id TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'running' CHECK (status IN ('running','done','error','cancelled')),
+        images TEXT NOT NULL DEFAULT '[]',
+        cost_usd REAL NOT NULL DEFAULT 0,
+        kept INTEGER NOT NULL DEFAULT 0,
+        error TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        overlays TEXT NOT NULL DEFAULT '{}',
+        brief TEXT,
+        archived INTEGER NOT NULL DEFAULT 0,
+        duration_ms INTEGER,
+        batch_id TEXT,
+        batch_index INTEGER NOT NULL DEFAULT 0
+      );
+      INSERT INTO nodes_new
+        SELECT id, project_id, parent_id, kind, prompt, engine_id, status, images, cost_usd, kept, error,
+               created_at, overlays, brief, archived, duration_ms, batch_id, batch_index
+        FROM nodes;
+      DROP TABLE nodes;
+      ALTER TABLE nodes_new RENAME TO nodes;
+      CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
+    `);
+  })();
+  db.pragma("foreign_keys = ON");
+}
+var SLUG_CHARS = /^[a-z0-9-]+$/;
+function backfillSlugs(db) {
+  const brands = db.prepare("SELECT id, slug, json FROM brands ORDER BY created_at, id").all();
+  const setBrand = db.prepare("UPDATE brands SET slug=? WHERE id=?");
+  const takenBrand = /* @__PURE__ */ new Set();
+  for (const b of brands) {
+    const needsRederiving = /^brand(-\d+)?$/.test(b.slug) || !SLUG_CHARS.test(b.slug);
+    let name;
+    if (needsRederiving) {
+      try {
+        name = JSON.parse(b.json)?.meta?.name;
+      } catch {
+      }
+    }
+    const wanted = needsRederiving && name ? slugifyWithId(name, b.id) : b.slug;
+    const slug = firstFree(wanted, (c) => RESERVED_SLUGS.has(c) || takenBrand.has(c));
+    takenBrand.add(slug);
+    if (slug !== b.slug) setBrand.run(slug, b.id);
+  }
+  db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_brands_slug ON brands(slug)");
+  const projects = db.prepare("SELECT id, brand_id, name, slug FROM projects ORDER BY created_at, id").all();
+  const setProject = db.prepare("UPDATE projects SET slug=? WHERE id=?");
+  const takenProject = /* @__PURE__ */ new Map();
+  for (const p of projects) {
+    const inBrand = takenProject.get(p.brand_id) ?? /* @__PURE__ */ new Set();
+    takenProject.set(p.brand_id, inBrand);
+    const current = p.slug && SLUG_CHARS.test(p.slug) ? p.slug : null;
+    const slug = firstFree(current || slugifyWithId(p.name, p.id, "project"), (c) => inBrand.has(c));
+    inBrand.add(slug);
+    if (slug !== p.slug) setProject.run(slug, p.id);
+  }
+  db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_projects_slug ON projects(brand_id, slug)");
+}
+function collapseProjects(db) {
+  const brands = db.prepare("SELECT id FROM brands").all();
+  const listProjects = db.prepare("SELECT id, name, slug FROM projects WHERE brand_id=? ORDER BY created_at, id");
+  const shotsIn = db.prepare("SELECT id FROM nodes WHERE project_id=? AND kind!='root' ORDER BY created_at, id");
+  const takenSlug = db.prepare("SELECT slug FROM sets WHERE brand_id=?");
+  const addSet = db.prepare("INSERT INTO sets (id, brand_id, name, slug) VALUES (?,?,?,?)");
+  const addMember = db.prepare("INSERT OR IGNORE INTO set_nodes (set_id, node_id) VALUES (?,?)");
+  for (const brand of brands) {
+    const projects = listProjects.all(brand.id);
+    if (projects.length <= 1) continue;
+    const workspace = projects[0];
+    db.transaction(() => {
+      const taken = new Set(takenSlug.all(brand.id).map((r) => r.slug));
+      for (const p of projects) {
+        const shots = shotsIn.all(p.id);
+        if (shots.length === 0) continue;
+        const setId = randomUUID();
+        const current = p.slug && SLUG_CHARS.test(p.slug) ? p.slug : null;
+        const slug = firstFree(current || slugifyWithId(p.name, setId, "set"), (c) => taken.has(c));
+        taken.add(slug);
+        addSet.run(setId, brand.id, p.name, slug);
+        for (const s of shots) addMember.run(setId, s.id);
+      }
+      db.prepare(
+        "UPDATE nodes SET project_id=? WHERE project_id IN (SELECT id FROM projects WHERE brand_id=? AND id!=?)"
+      ).run(workspace.id, brand.id, workspace.id);
+      const roots = db.prepare("SELECT id FROM nodes WHERE project_id=? AND kind='root' ORDER BY created_at, id").all(workspace.id);
+      const surplus = roots.slice(1).map((r) => r.id);
+      if (surplus.length > 0) {
+        const holes = surplus.map(() => "?").join(",");
+        db.prepare(`UPDATE nodes SET parent_id=NULL WHERE parent_id IN (${holes})`).run(...surplus);
+        db.prepare(`DELETE FROM nodes WHERE id IN (${holes})`).run(...surplus);
+      }
+      db.prepare("DELETE FROM projects WHERE brand_id=? AND id!=?").run(brand.id, workspace.id);
+    })();
+  }
+}
+var IMAGES_SPLIT_MARK = "v1";
+function splitMultiImageNodes(db) {
+  const done = db.prepare("SELECT value FROM settings WHERE key='images_split'").get()?.value;
+  if (done === IMAGES_SPLIT_MARK) return;
+  const mark = () => db.prepare(
+    "INSERT INTO settings (key, value) VALUES ('images_split', ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value"
+  ).run(IMAGES_SPLIT_MARK);
+  const rows = db.prepare("SELECT * FROM nodes WHERE images LIKE '%,%'").all();
+  const multi = rows.filter((r) => {
+    try {
+      return JSON.parse(r.images).length > 1;
+    } catch {
+      return false;
+    }
+  });
+  if (!multi.length) {
+    mark();
+    return;
+  }
+  const parse = (s) => {
+    if (!s) return null;
+    try {
+      return JSON.parse(s);
+    } catch {
+      return null;
+    }
+  };
+  const stampOf = (iso, minusMs) => {
+    const t = (/* @__PURE__ */ new Date(`${iso.replace(" ", "T")}Z`)).getTime() - minusMs;
+    const d = new Date(t);
+    const p = (n, w = 2) => String(n).padStart(w, "0");
+    return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())} ${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}.${p(d.getUTCMilliseconds(), 3)}`;
+  };
+  const updateOriginal = db.prepare(
+    "UPDATE nodes SET images=?, overlays=?, brief=?, batch_id=?, batch_index=0 WHERE id=?"
+  );
+  const insertSibling = db.prepare(
+    `INSERT INTO nodes (id, project_id, parent_id, kind, prompt, engine_id, status, images, cost_usd, kept,
+       error, created_at, overlays, brief, archived, duration_ms, batch_id, batch_index)
+     VALUES (?,?,?,?,?,?,?,?,0,?,?,?,?,?,?,NULL,?,?)`
+  );
+  const childrenOf = db.prepare("SELECT id, brief FROM nodes WHERE parent_id=?");
+  const repoint = db.prepare("UPDATE nodes SET parent_id=? WHERE id=?");
+  const setsOf = db.prepare("SELECT set_id FROM set_nodes WHERE node_id=?");
+  const addMember = db.prepare("INSERT OR IGNORE INTO set_nodes (set_id, node_id) VALUES (?,?)");
+  db.transaction(() => {
+    for (const r of multi) {
+      const images = JSON.parse(r.images);
+      const overlays = parse(r.overlays) ?? {};
+      const brief = parse(r.brief);
+      const sizes = Array.isArray(brief?.rendered?.sizes) ? brief.rendered.sizes : null;
+      const briefFor = (i) => {
+        if (!brief) return null;
+        const b = { ...brief, variants: images.length };
+        if (brief.rendered) {
+          const { requested: _req, variantIndexes: _vi, ...rendered } = brief.rendered;
+          b.rendered = { ...rendered, ...sizes ? { sizes: sizes[i] !== void 0 ? [sizes[i]] : [] } : {} };
+        }
+        return JSON.stringify(b);
+      };
+      const siblingIds = [r.id];
+      updateOriginal.run(
+        JSON.stringify([images[0]]),
+        JSON.stringify(overlays["0"] !== void 0 ? { "0": overlays["0"] } : {}),
+        briefFor(0),
+        r.id,
+        r.id
+      );
+      for (let i = 1; i < images.length; i++) {
+        const id = randomUUID();
+        siblingIds.push(id);
+        insertSibling.run(
+          id,
+          r.project_id,
+          r.parent_id,
+          r.kind,
+          r.prompt,
+          r.engine_id,
+          r.status,
+          JSON.stringify([images[i]]),
+          r.kept,
+          r.error,
+          stampOf(r.created_at, i),
+          JSON.stringify(overlays[String(i)] !== void 0 ? { "0": overlays[String(i)] } : {}),
+          briefFor(i),
+          r.archived,
+          r.id,
+          i
+        );
+      }
+      for (const child of childrenOf.all(r.id)) {
+        const src = parse(child.brief)?.sourceImage;
+        if (typeof src !== "string") continue;
+        const at = images.indexOf(src);
+        if (at > 0) repoint.run(siblingIds[at], child.id);
+      }
+      for (const s of setsOf.all(r.id)) {
+        for (let i = 1; i < siblingIds.length; i++) addMember.run(s.set_id, siblingIds[i]);
+      }
+    }
+  })();
+  mark();
+}
+function ensureIndexes(db) {
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_nodes_project_created ON nodes(project_id, created_at, id);
+    CREATE INDEX IF NOT EXISTS idx_nodes_project_kept ON nodes(project_id, kept, created_at, id);
+    CREATE INDEX IF NOT EXISTS idx_nodes_project_cost ON nodes(project_id, cost_usd, created_at, id);
+    CREATE INDEX IF NOT EXISTS idx_nodes_project_state ON nodes(project_id, kind, archived, kept);
+    DROP INDEX IF EXISTS idx_nodes_parent;
+    CREATE INDEX IF NOT EXISTS idx_nodes_parent_created ON nodes(parent_id, created_at, id);
+    CREATE INDEX IF NOT EXISTS idx_nodes_status ON nodes(status);
+    CREATE INDEX IF NOT EXISTS idx_catalog_variants_product ON catalog_variants(product_id);
+    CREATE INDEX IF NOT EXISTS idx_cost_events_engine_ts ON cost_events(engine_id, ts);
+  `);
+}
+function searchTextSql(alias) {
+  const brief = `CASE WHEN json_valid(${alias}.brief) THEN ${alias}.brief ELSE '{}' END`;
+  return `trim(coalesce(${alias}.prompt, '') || ' ' ||
+    coalesce((SELECT group_concat(je.value, ' ') FROM json_each(${brief}, '$.templateFields') AS je), '') || ' ' ||
+    coalesce((SELECT group_concat(coalesce(json_extract(je.value, '$.name'), '') || ' ' || coalesce(json_extract(je.value, '$.hex'), ''), ' ')
+                FROM json_each(${brief}, '$.tokens') AS je WHERE json_extract(je.value, '$.t') = 'color'), ''))`;
+}
+function tokenRowsSql(alias) {
+  const brief = `CASE WHEN json_valid(${alias}.brief) THEN ${alias}.brief ELSE '{}' END`;
+  return `SELECT ${alias}.id, json_extract(je.value, '$.t'), json_extract(je.value, '$.id')
+            FROM json_each(${brief}, '$.tokens') AS je
+           WHERE json_extract(je.value, '$.t') IN ('product', 'character', 'template')
+             AND json_extract(je.value, '$.id') IS NOT NULL
+          UNION ALL
+          SELECT ${alias}.id, 'template', json_extract(${brief}, '$.templateId')
+           WHERE json_extract(${brief}, '$.templateId') IS NOT NULL`;
+}
+function tokenRowsFromNodesSql() {
+  const brief = "CASE WHEN json_valid(n.brief) THEN n.brief ELSE '{}' END";
+  return `SELECT n.id, json_extract(je.value, '$.t'), json_extract(je.value, '$.id')
+            FROM nodes n, json_each(${brief}, '$.tokens') AS je
+           WHERE json_extract(je.value, '$.t') IN ('product', 'character', 'template')
+             AND json_extract(je.value, '$.id') IS NOT NULL
+          UNION ALL
+          SELECT n.id, 'template', json_extract(${brief}, '$.templateId')
+            FROM nodes n
+           WHERE json_extract(${brief}, '$.templateId') IS NOT NULL`;
+}
+var SEARCH_INDEX_VERSION = "v1";
+function ensureSearch(db) {
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(text, tokenize='trigram case_sensitive 0 remove_diacritics 1');
+    CREATE TABLE IF NOT EXISTS node_tokens (
+      node_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      token_id TEXT NOT NULL,
+      PRIMARY KEY (node_id, kind, token_id)
+    ) WITHOUT ROWID;
+    CREATE INDEX IF NOT EXISTS idx_node_tokens_token ON node_tokens(token_id, node_id);
+    CREATE TRIGGER IF NOT EXISTS nodes_search_ai AFTER INSERT ON nodes BEGIN
+      INSERT INTO nodes_fts(rowid, text) VALUES (new.rowid, ${searchTextSql("new")});
+      INSERT OR IGNORE INTO node_tokens(node_id, kind, token_id) ${tokenRowsSql("new")};
+    END;
+    CREATE TRIGGER IF NOT EXISTS nodes_search_au AFTER UPDATE OF prompt, brief ON nodes BEGIN
+      DELETE FROM nodes_fts WHERE rowid = old.rowid;
+      DELETE FROM node_tokens WHERE node_id = old.id;
+      INSERT INTO nodes_fts(rowid, text) VALUES (new.rowid, ${searchTextSql("new")});
+      INSERT OR IGNORE INTO node_tokens(node_id, kind, token_id) ${tokenRowsSql("new")};
+    END;
+    CREATE TRIGGER IF NOT EXISTS nodes_search_ad AFTER DELETE ON nodes BEGIN
+      DELETE FROM nodes_fts WHERE rowid = old.rowid;
+      DELETE FROM node_tokens WHERE node_id = old.id;
+    END;
+  `);
+  const marker = db.prepare("SELECT value FROM settings WHERE key='search_index'").get()?.value;
+  const bounds = db.prepare("SELECT min(rowid) AS lo, max(rowid) AS hi, count(*) AS c FROM nodes").get();
+  const indexed = (rowid) => rowid !== null && !!db.prepare("SELECT 1 FROM nodes_fts WHERE rowid = ?").get(rowid);
+  const whole = bounds.c === 0 || indexed(bounds.lo) && indexed(bounds.hi);
+  if (marker === SEARCH_INDEX_VERSION && whole) return;
+  db.transaction(() => {
+    db.exec("DELETE FROM nodes_fts");
+    db.exec("DELETE FROM node_tokens");
+    db.exec(`INSERT INTO nodes_fts(rowid, text) SELECT n.rowid, ${searchTextSql("n")} FROM nodes n`);
+    db.exec(`INSERT OR IGNORE INTO node_tokens(node_id, kind, token_id) ${tokenRowsFromNodesSql()}`);
+    db.prepare(
+      "INSERT INTO settings (key, value) VALUES ('search_index', ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value"
+    ).run(SEARCH_INDEX_VERSION);
+  })();
+}
+var SCHEMA_VERSION = 2;
+var SchemaTooNewError = class extends Error {
+  constructor(found, supported, backupsDir) {
+    super(
+      `This library was written by a newer Scenri (schema ${found}; this build understands ${supported}). Update and retry: npx scenri@latest` + (backupsDir ? ` (a pre-migration snapshot of the library is kept in ${backupsDir})` : "")
+    );
+    this.name = "SchemaTooNewError";
+  }
+};
+function backupBeforeMigration(db, homeDir, fromVersion) {
+  const dir = join(homeDir, "backups");
+  mkdirSync(dir, { recursive: true });
+  const d = /* @__PURE__ */ new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  const stamp = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+  db.pragma("wal_checkpoint(TRUNCATE)");
+  db.prepare("VACUUM INTO ?").run(join(dir, `scenri-v${fromVersion}-${stamp}.db`));
+  const old = readdirSync(dir).filter((f) => /^scenri-v\d+-\d{8}-\d{6}\.db$/.test(f)).sort((a, b) => a.slice(-18).localeCompare(b.slice(-18)));
+  for (const f of old.slice(0, Math.max(0, old.length - 3))) rmSync(join(dir, f));
+}
+function openDb(homeDir) {
+  mkdirSync(homeDir, { recursive: true, mode: 448 });
+  const dbPath = join(homeDir, "scenri.db");
+  const preExisting = existsSync(dbPath);
+  const db = new Database(dbPath);
+  try {
+    chmodSync(dbPath, 384);
+  } catch {
+  }
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  const found = db.pragma("user_version", { simple: true });
+  if (found > SCHEMA_VERSION) {
+    db.close();
+    throw new SchemaTooNewError(found, SCHEMA_VERSION, join(homeDir, "backups"));
+  }
+  if (preExisting && found < SCHEMA_VERSION) backupBeforeMigration(db, homeDir, found);
+  db.exec(MIGRATIONS);
+  const nodeCols = db.pragma("table_info(nodes)").map((c) => c.name);
+  if (!nodeCols.includes("overlays")) {
+    db.exec("ALTER TABLE nodes ADD COLUMN overlays TEXT NOT NULL DEFAULT '{}'");
+  }
+  if (!nodeCols.includes("brief")) {
+    db.exec("ALTER TABLE nodes ADD COLUMN brief TEXT");
+  }
+  if (!nodeCols.includes("archived")) {
+    db.exec("ALTER TABLE nodes ADD COLUMN archived INTEGER NOT NULL DEFAULT 0");
+  }
+  if (!nodeCols.includes("duration_ms")) {
+    db.exec("ALTER TABLE nodes ADD COLUMN duration_ms INTEGER");
+  }
+  if (!nodeCols.includes("batch_id")) {
+    db.exec("ALTER TABLE nodes ADD COLUMN batch_id TEXT");
+  }
+  if (!nodeCols.includes("batch_index")) {
+    db.exec("ALTER TABLE nodes ADD COLUMN batch_index INTEGER NOT NULL DEFAULT 0");
+  }
+  const projectCols = db.pragma("table_info(projects)").map((c) => c.name);
+  if (!projectCols.includes("slug")) {
+    db.exec("ALTER TABLE projects ADD COLUMN slug TEXT");
+  }
+  const catalogCols = db.pragma("table_info(catalog_products)").map((c) => c.name);
+  for (const col of ["variant", "material", "dimensions"]) {
+    if (!catalogCols.includes(col)) db.exec(`ALTER TABLE catalog_products ADD COLUMN ${col} TEXT`);
+  }
+  const catalogImgCols = db.pragma("table_info(catalog_images)").map((c) => c.name);
+  if (!catalogImgCols.includes("angle")) db.exec("ALTER TABLE catalog_images ADD COLUMN angle TEXT");
+  if (!catalogImgCols.includes("excluded")) {
+    db.exec("ALTER TABLE catalog_images ADD COLUMN excluded INTEGER NOT NULL DEFAULT 0");
+  }
+  widenNodeStatusCheck(db);
+  ensureIndexes(db);
+  backfillSlugs(db);
+  collapseProjects(db);
+  splitMultiImageNodes(db);
+  ensureSearch(db);
+  db.prepare(
+    "UPDATE nodes SET status='error', error='interrupted: server restarted mid-generation' WHERE status='running'"
+  ).run();
+  db.pragma(`user_version = ${SCHEMA_VERSION}`);
+  return db;
+}
+function createImageStore(homeDir) {
+  const dir = join(homeDir, "images");
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const fileFor = (hash) => join(dir, `${hash}.png`);
+  return {
+    save(buf) {
+      const hash = createHash("sha256").update(buf).digest("hex").slice(0, 32);
+      const file = fileFor(hash);
+      if (!existsSync(file)) writeFileSync(file, buf);
+      return hash;
+    },
+    pathFor(hash) {
+      if (!/^[a-f0-9]{32}$/.test(hash)) throw new Error("invalid image hash");
+      return fileFor(hash);
+    },
+    read(hash) {
+      return readFileSync(this.pathFor(hash));
+    },
+    has(hash) {
+      return /^[a-f0-9]{32}$/.test(hash) && existsSync(fileFor(hash));
+    }
+  };
+}
+
+// ../core/src/ledger.ts
+var SpendCapError = class extends Error {
+  constructor(engineId, cap, spent, estimate) {
+    super(
+      `Spend cap for ${engineId}: $${cap.toFixed(2)}/mo. Spent $${spent.toFixed(2)}, next ~$${estimate.toFixed(2)} would exceed it.`
+    );
+    this.name = "SpendCapError";
+  }
+};
+function createLedger(db) {
+  const monthStart = () => {
+    const d = /* @__PURE__ */ new Date();
+    return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-01`;
+  };
+  return {
+    recordCost(engineId, nodeId, usd) {
+      if (usd > 0)
+        db.prepare("INSERT INTO cost_events (engine_id, node_id, cost_usd) VALUES (?,?,?)").run(engineId, nodeId, usd);
+    },
+    monthlySpend(engineId) {
+      const row = db.prepare("SELECT COALESCE(SUM(cost_usd),0) s FROM cost_events WHERE engine_id=? AND ts >= ?").get(engineId, monthStart());
+      return row.s;
+    },
+    totalSpendByEngine() {
+      const rows = db.prepare("SELECT engine_id, COALESCE(SUM(cost_usd),0) s FROM cost_events WHERE ts >= ? GROUP BY engine_id").all(monthStart());
+      return Object.fromEntries(rows.map((r) => [r.engine_id, r.s]));
+    },
+    setCap(engineId, capUsd) {
+      if (capUsd === null) db.prepare("DELETE FROM spend_caps WHERE engine_id=?").run(engineId);
+      else
+        db.prepare(
+          "INSERT INTO spend_caps (engine_id, monthly_cap_usd) VALUES (?,?) ON CONFLICT(engine_id) DO UPDATE SET monthly_cap_usd=excluded.monthly_cap_usd"
+        ).run(engineId, capUsd);
+    },
+    capFor(engineId) {
+      const row = db.prepare("SELECT monthly_cap_usd c FROM spend_caps WHERE engine_id=?").get(engineId);
+      return row ? row.c : null;
+    },
+    caps() {
+      const rows = db.prepare("SELECT engine_id, monthly_cap_usd c FROM spend_caps").all();
+      return Object.fromEntries(rows.map((r) => [r.engine_id, r.c]));
+    },
+    assertUnderCap(engineId, nextEstimate) {
+      const cap = this.capFor(engineId);
+      if (cap === null) return;
+      const spent = this.monthlySpend(engineId);
+      if (spent + nextEstimate > cap) throw new SpendCapError(engineId, cap, spent, nextEstimate);
+    }
+  };
+}
+
+// ../core/src/searchRules.ts
+function fold(s) {
+  return s.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").replace(/[\u200e\u200f\u061c\u202a-\u202e\u2066-\u2069]/g, "").toLowerCase();
+}
+var STEM_MIN = 4;
+var TRIGRAM_MIN = 3;
+function searchTerms(q) {
+  return fold(q).trim().split(/\s+/).filter(Boolean).map((text) => ({
+    text,
+    stem: text.length >= STEM_MIN && text.endsWith("s") ? text.slice(0, -1) : null
+  }));
+}
+function termMatches(haystack, term) {
+  const h = fold(haystack);
+  return h.includes(term.text) || term.stem !== null && h.includes(term.stem);
+}
+function matchesQuery(haystack, q) {
+  const terms = searchTerms(q);
+  if (!terms.length) return true;
+  return terms.every((t) => termMatches(haystack, t));
+}
+var quote = (s) => `"${s.replace(/"/g, '""')}"`;
+function ftsMatch(term) {
+  if (term.text.length < TRIGRAM_MIN) return null;
+  return term.stem ? `(${quote(term.text)} OR ${quote(term.stem)})` : quote(term.text);
+}
+
+// ../core/src/store.ts
+var PROMPT_HEAD_CHARS = 240;
+function uniqueSlug(db, name, id) {
+  const stmt = db.prepare("SELECT 1 FROM brands WHERE slug=? AND id IS NOT ?");
+  return firstFree(slugifyWithId(name, id), (c) => RESERVED_SLUGS.has(c) || !!stmt.get(c, id));
+}
+function uniqueProjectSlug(db, brandId, name, id) {
+  const stmt = db.prepare("SELECT 1 FROM projects WHERE brand_id=? AND slug=?");
+  return firstFree(slugifyWithId(name, id, "project"), (c) => !!stmt.get(brandId, c));
+}
+function uniqueSetSlug(db, brandId, name, id) {
+  const stmt = db.prepare("SELECT 1 FROM sets WHERE brand_id=? AND slug=? AND id IS NOT ?");
+  return firstFree(slugifyWithId(name, id, "set"), (c) => !!stmt.get(brandId, c, id));
+}
+var SET_NAME_SEP = String.fromCharCode(31);
+function rowToSet(r) {
+  return {
+    id: r.id,
+    brandId: r.brand_id,
+    name: r.name,
+    slug: r.slug,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at
+  };
+}
+var headOf = (prompt) => Array.from(String(prompt ?? "")).slice(0, PROMPT_HEAD_CHARS).join("");
+var CHILD_COUNT_SQL = "(CASE WHEN n.kind = 'root' THEN 0 ELSE (SELECT count(*) FROM nodes c WHERE c.parent_id = n.id AND c.archived = 0) END)";
+var LINEAGE_SIBLINGS_RADIUS = 25;
+var LINEAGE_CHILDREN_MAX = 60;
+var LINEAGE_HISTORY_MAX = 60;
+var FEED_COLS = `n.id, n.project_id, n.parent_id, n.kind, substr(n.prompt, 1, ${PROMPT_HEAD_CHARS}) AS prompt_head,
+  n.engine_id, n.status, n.images, n.cost_usd, n.duration_ms, n.kept, n.error, n.created_at, n.brief, n.archived,
+  n.batch_id, n.batch_index, ${CHILD_COUNT_SQL} AS child_count`;
+function rowToFeedNode(r) {
+  return {
+    id: r.id,
+    projectId: r.project_id,
+    parentId: r.parent_id,
+    kind: r.kind,
+    promptHead: r.prompt_head ?? headOf(r.prompt),
+    engineId: r.engine_id,
+    status: r.status,
+    images: JSON.parse(r.images),
+    costUsd: r.cost_usd,
+    durationMs: r.duration_ms ?? null,
+    kept: !!r.kept,
+    error: r.error,
+    createdAt: r.created_at,
+    brief: r.brief ? JSON.parse(r.brief) : null,
+    archived: !!r.archived,
+    batchId: r.batch_id ?? null,
+    batchIndex: r.batch_index ?? 0,
+    childCount: r.child_count ?? 0
+  };
+}
+function rowToNode(r) {
+  return {
+    ...rowToFeedNode(r),
+    prompt: r.prompt,
+    overlays: JSON.parse(r.overlays ?? "{}")
+  };
+}
+var lastBatchStamp = 0;
+function batchStamps(count) {
+  const base = Math.max(Date.now(), lastBatchStamp + count);
+  lastBatchStamp = base;
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return Array.from({ length: count }, (_, i) => {
+    const d = new Date(base - i);
+    return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())} ${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}.${p(d.getUTCMilliseconds(), 3)}`;
+  });
+}
+var encodeCursor = (k) => Buffer.from(JSON.stringify(k)).toString("base64url");
+function decodeCursor(cursor) {
+  try {
+    const k = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (typeof k?.c === "string" && typeof k?.i === "string") return k;
+  } catch {
+  }
+  throw new Error("invalid cursor");
+}
+function filterSql(f, params, withLens) {
+  const where = ["n.kind != 'root'"];
+  if (withLens) {
+    if (f.lens === "archived") where.push("n.archived = 1");
+    else if (f.lens === "keepers") where.push("n.archived = 0 AND n.kept = 1");
+    else where.push("n.archived = 0");
+  }
+  if (f.lineage) {
+    params.lineage = f.lineage;
+    where.push(
+      "n.id IN (WITH RECURSIVE d(id) AS (SELECT @lineage UNION ALL SELECT c.id FROM nodes c JOIN d ON c.parent_id = d.id) SELECT id FROM d)"
+    );
+  } else if (f.set) {
+    params.set = f.set;
+    where.push("n.id IN (SELECT node_id FROM set_nodes WHERE set_id = @set)");
+  } else if (f.ungrouped) {
+    where.push("NOT EXISTS (SELECT 1 FROM set_nodes sn WHERE sn.node_id = n.id)");
+  }
+  if (f.tokens?.length) {
+    const names = f.tokens.map((t, i) => {
+      params[`tok${i}`] = t;
+      return `@tok${i}`;
+    });
+    where.push(`n.id IN (SELECT node_id FROM node_tokens WHERE token_id IN (${names.join(", ")}))`);
+  }
+  (f.terms ?? []).forEach((term, i) => {
+    const any = [];
+    const match = ftsMatch(term);
+    if (match) {
+      params[`m${i}`] = match;
+      any.push(`n.rowid IN (SELECT rowid FROM nodes_fts WHERE nodes_fts MATCH @m${i})`);
+    }
+    if (term.tokenIds.length) {
+      const names = term.tokenIds.map((t, j) => {
+        params[`t${i}_${j}`] = t;
+        return `@t${i}_${j}`;
+      });
+      any.push(`n.id IN (SELECT node_id FROM node_tokens WHERE token_id IN (${names.join(", ")}))`);
+    }
+    if (term.engineIds.length) {
+      const names = term.engineIds.map((e, j) => {
+        params[`e${i}_${j}`] = e;
+        return `@e${i}_${j}`;
+      });
+      any.push(`n.engine_id IN (${names.join(", ")})`);
+    }
+    if (any.length) where.push(`(${any.join(" OR ")})`);
+  });
+  return where;
+}
+function sortSql(sort, cursor, params) {
+  if (cursor) {
+    params.c = cursor.c;
+    params.i = cursor.i;
+    params.v = cursor.v ?? 0;
+  }
+  const newest = "(n.created_at < @c OR (n.created_at = @c AND n.id < @i))";
+  const oldest = "(n.created_at > @c OR (n.created_at = @c AND n.id > @i))";
+  switch (sort) {
+    case "oldest":
+      return { order: "n.created_at ASC, n.id ASC", after: cursor ? oldest : null };
+    case "cost":
+      return {
+        order: "n.cost_usd DESC, n.created_at DESC, n.id DESC",
+        after: cursor ? `(n.cost_usd < @v OR (n.cost_usd = @v AND ${newest}))` : null
+      };
+    case "keepers":
+      return {
+        order: "n.kept DESC, n.created_at DESC, n.id DESC",
+        after: cursor ? `(n.kept < @v OR (n.kept = @v AND ${newest}))` : null
+      };
+    default:
+      return { order: "n.created_at DESC, n.id DESC", after: cursor ? newest : null };
+  }
+}
+var keysetOf = (n, sort) => sort === "cost" ? { c: n.createdAt, i: n.id, v: n.costUsd } : sort === "keepers" ? { c: n.createdAt, i: n.id, v: n.kept ? 1 : 0 } : { c: n.createdAt, i: n.id };
+var FEED_PAGE_MAX = 200;
+function createStore(db) {
+  return {
+    // brands
+    createBrand(json) {
+      const id = randomUUID();
+      db.prepare("INSERT INTO brands (id, slug, json) VALUES (?,?,?)").run(
+        id,
+        uniqueSlug(db, json.meta.name, id),
+        JSON.stringify(json)
+      );
+      return this.getBrand(id);
+    },
+    getBrand(id) {
+      const r = db.prepare("SELECT * FROM brands WHERE id=?").get(id);
+      return r ? { id: r.id, slug: r.slug, json: JSON.parse(r.json), createdAt: r.created_at, updatedAt: r.updated_at } : null;
+    },
+    listBrands() {
+      return db.prepare("SELECT * FROM brands ORDER BY created_at").all().map((r) => ({
+        id: r.id,
+        slug: r.slug,
+        json: JSON.parse(r.json),
+        createdAt: r.created_at,
+        updatedAt: r.updated_at
+      }));
+    },
+    updateBrand(id, json) {
+      db.prepare("UPDATE brands SET json=?, slug=?, updated_at=datetime('now') WHERE id=?").run(
+        JSON.stringify(json),
+        uniqueSlug(db, json.meta.name, id),
+        id
+      );
+      return this.getBrand(id);
+    },
+    deleteBrand(id) {
+      db.prepare("DELETE FROM brands WHERE id=?").run(id);
+    },
+    // projects
+    createProject(brandId, name) {
+      const id = randomUUID();
+      db.prepare("INSERT INTO projects (id, brand_id, name, slug) VALUES (?,?,?,?)").run(
+        id,
+        brandId,
+        name,
+        uniqueProjectSlug(db, brandId, name, id)
+      );
+      const rootId = randomUUID();
+      db.prepare("INSERT INTO nodes (id, project_id, parent_id, kind, status) VALUES (?,?,NULL,'root','done')").run(
+        rootId,
+        id
+      );
+      return { project: this.getProject(id), root: this.getNode(rootId) };
+    },
+    deleteProject(id) {
+      db.prepare("DELETE FROM projects WHERE id=?").run(id);
+    },
+    getProject(id) {
+      const r = db.prepare("SELECT * FROM projects WHERE id=?").get(id);
+      return r ? { id: r.id, brandId: r.brand_id, name: r.name, slug: r.slug, createdAt: r.created_at } : null;
+    },
+    listProjects(brandId) {
+      return db.prepare("SELECT * FROM projects WHERE brand_id=? ORDER BY created_at").all(brandId).map(
+        (r) => ({
+          id: r.id,
+          brandId: r.brand_id,
+          name: r.name,
+          slug: r.slug,
+          createdAt: r.created_at
+        })
+      );
+    },
+    /**
+     * The brand's one project, made on demand.
+     *
+     * Every node still hangs from a project root, but that is plumbing now, not
+     * a place: nothing in the UI names it and nothing but this creates one. The
+     * five buttons that used to invent a project each call this instead, so a
+     * brand ends up with exactly one no matter which door you came through.
+     */
+    workspaceFor(brandId) {
+      return this.listProjects(brandId)[0] ?? this.createProject(brandId, "Workspace").project;
+    },
+    // sets
+    createSet(brandId, name) {
+      const id = randomUUID();
+      db.prepare("INSERT INTO sets (id, brand_id, name, slug) VALUES (?,?,?,?)").run(
+        id,
+        brandId,
+        name,
+        uniqueSetSlug(db, brandId, name, id)
+      );
+      return this.getSet(id);
+    },
+    getSet(id) {
+      const r = db.prepare("SELECT * FROM sets WHERE id=?").get(id);
+      return r ? rowToSet(r) : null;
+    },
+    /**
+     * Most recently touched first, everywhere. The old project lists each chose
+     * their own order — one ascending by creation, one descending, one capped
+     * before it sorted — so the same six names came back in three different
+     * sequences depending on which control you opened.
+     */
+    listSets(brandId) {
+      return db.prepare("SELECT * FROM sets WHERE brand_id=? ORDER BY updated_at DESC, created_at DESC").all(brandId).map(rowToSet);
+    },
+    renameSet(id, name) {
+      const current = this.getSet(id);
+      if (!current) return null;
+      db.prepare("UPDATE sets SET name=?, slug=?, updated_at=datetime('now') WHERE id=?").run(
+        name,
+        uniqueSetSlug(db, current.brandId, name, id),
+        id
+      );
+      return this.getSet(id);
+    },
+    /** The set goes; the shots do not. Membership is a label, never ownership. */
+    deleteSet(id) {
+      db.prepare("DELETE FROM sets WHERE id=?").run(id);
+    },
+    addToSet(setId, nodeIds) {
+      const add = db.prepare("INSERT OR IGNORE INTO set_nodes (set_id, node_id) VALUES (?,?)");
+      db.transaction(() => {
+        for (const nodeId of nodeIds) add.run(setId, nodeId);
+        db.prepare("UPDATE sets SET updated_at=datetime('now') WHERE id=?").run(setId);
+      })();
+    },
+    removeFromSet(setId, nodeId) {
+      db.transaction(() => {
+        db.prepare("DELETE FROM set_nodes WHERE set_id=? AND node_id=?").run(setId, nodeId);
+        db.prepare("UPDATE sets SET updated_at=datetime('now') WHERE id=?").run(setId);
+      })();
+    },
+    /**
+     * Every membership in the brand, keyed by set. One query rather than one
+     * per set, because the workspace screen filters on the client: the feed is
+     * already loaded, and a set is only a subset of it.
+     */
+    membershipFor(brandId) {
+      const rows = db.prepare(
+        `SELECT sn.set_id, sn.node_id
+             FROM set_nodes sn JOIN sets s ON s.id = sn.set_id
+            WHERE s.brand_id = ?
+            ORDER BY sn.added_at`
+      ).all(brandId);
+      const out = {};
+      for (const r of rows) {
+        if (!out[r.set_id]) out[r.set_id] = [];
+        out[r.set_id].push(r.node_id);
+      }
+      return out;
+    },
+    /** One set's members, in the order they were filed. */
+    membersOf(setId) {
+      return db.prepare("SELECT node_id FROM set_nodes WHERE set_id=? ORDER BY added_at, node_id").all(setId).map((r) => r.node_id);
+    },
+    // nodes / version tree
+    addNode(input) {
+      if (input.parentId) {
+        const parent = this.getNode(input.parentId);
+        if (!parent || parent.projectId !== input.projectId) throw new Error("parent node not found in project");
+      }
+      const id = randomUUID();
+      db.prepare(
+        "INSERT INTO nodes (id, project_id, parent_id, kind, prompt, engine_id, created_at) VALUES (?,?,?,?,?,?, strftime('%Y-%m-%d %H:%M:%f','now'))"
+      ).run(id, input.projectId, input.parentId, input.kind, input.prompt, input.engineId);
+      return this.getNode(id);
+    },
+    /**
+     * One multi-shot request, N first-class sibling nodes, one transaction.
+     * Slot 0 gets the newest stamp (see batchStamps) so the newest-first feed
+     * reads the batch in request order; batch_id is the first node's id, held
+     * by every sibling including the first, and stays null for a single send
+     * — one shot is not a batch.
+     */
+    addNodes(input) {
+      if (input.parentId) {
+        const parent = this.getNode(input.parentId);
+        if (!parent || parent.projectId !== input.projectId) throw new Error("parent node not found in project");
+      }
+      const count = Math.max(1, Math.floor(input.count));
+      const ids = Array.from({ length: count }, () => randomUUID());
+      const stamps = batchStamps(count);
+      const batchId = count > 1 ? ids[0] : null;
+      const insert = db.prepare(
+        "INSERT INTO nodes (id, project_id, parent_id, kind, prompt, engine_id, created_at, batch_id, batch_index) VALUES (?,?,?,?,?,?,?,?,?)"
+      );
+      db.transaction(() => {
+        for (let i = 0; i < count; i++) {
+          insert.run(
+            ids[i],
+            input.projectId,
+            input.parentId,
+            input.kind,
+            input.prompt,
+            input.engineId,
+            stamps[i],
+            batchId,
+            i
+          );
+        }
+      })();
+      return ids.map((id) => this.getNode(id));
+    },
+    completeNode(id, result) {
+      db.prepare("UPDATE nodes SET status='done', images=?, cost_usd=?, duration_ms=? WHERE id=?").run(
+        JSON.stringify(result.images),
+        result.costUsd,
+        result.durationMs ?? null,
+        id
+      );
+    },
+    /**
+     * The run's money, written once it is known. A batch's first sibling used
+     * to be charged inside completeNode, at the end of the whole call; a
+     * sibling now completes the moment its own image lands, and the cost is
+     * only known when the call resolves, so it is written afterwards, onto a
+     * node that finished. A failed or running node keeps 0, as before.
+     */
+    chargeNode(id, costUsd) {
+      db.prepare("UPDATE nodes SET cost_usd=? WHERE id=? AND status='done'").run(costUsd, id);
+    },
+    failNode(id, error) {
+      db.prepare("UPDATE nodes SET status='error', error=? WHERE id=?").run(error, id);
+    },
+    cancelNode(id) {
+      db.prepare("UPDATE nodes SET status='cancelled' WHERE id=?").run(id);
+    },
+    getNode(id) {
+      const r = db.prepare(`SELECT n.*, ${CHILD_COUNT_SQL} AS child_count FROM nodes n WHERE n.id=?`).get(id);
+      return r ? rowToNode(r) : null;
+    },
+    /** The list shape of one shot: what a keep or an archive answers with. */
+    getFeedNode(id) {
+      const r = db.prepare(`SELECT ${FEED_COLS} FROM nodes n WHERE n.id=?`).get(id);
+      return r ? rowToFeedNode(r) : null;
+    },
+    /** The project's root, by index, rather than the whole tree read to find it. */
+    rootFor(projectId) {
+      const rows = db.prepare(`SELECT n.*, ${CHILD_COUNT_SQL} AS child_count FROM nodes n WHERE n.project_id=? AND n.kind='root'`).all(projectId);
+      rows.sort(
+        (a, b) => String(a.created_at).localeCompare(String(b.created_at)) || String(a.id).localeCompare(String(b.id))
+      );
+      return rows.length ? rowToNode(rows[0]) : null;
+    },
+    treeFor(projectId) {
+      return db.prepare(
+        `SELECT n.*, ${CHILD_COUNT_SQL} AS child_count FROM nodes n WHERE n.project_id=? ORDER BY n.created_at, n.id`
+      ).all(projectId).map(rowToNode);
+    },
+    /**
+     * One page of a project's shots for a place, lens, search and sort.
+     *
+     * Keyset paging on the sort's own columns, never OFFSET: the cost of page
+     * forty is the cost of page one, and a shot landing between two pages
+     * shifts nothing already read. Every clause is served by an index or by
+     * the search index; the whole workspace is never read.
+     */
+    feedPage(projectId, q) {
+      const limit = Math.max(1, Math.min(FEED_PAGE_MAX, Math.floor(q.limit ?? 60)));
+      const sort = q.sort ?? "newest";
+      const params = { project: projectId, limit: limit + 1 };
+      const where = ["n.project_id = @project", ...filterSql(q, params, true)];
+      const { order, after } = sortSql(sort, q.cursor ? decodeCursor(q.cursor) : null, params);
+      if (after) where.push(after);
+      const rows = db.prepare(`SELECT ${FEED_COLS} FROM nodes n WHERE ${where.join(" AND ")} ORDER BY ${order} LIMIT @limit`).all(params);
+      const items = rows.slice(0, limit).map(rowToFeedNode);
+      const more = rows.length > limit;
+      return { items, next: more && items.length ? encodeCursor(keysetOf(items[items.length - 1], sort)) : null };
+    },
+    /**
+     * What each lens would show from a place and search, plus the two
+     * unscoped totals. The scoped sums and the total read the state index
+     * alone (project, kind, archived, kept: nothing that needs the row), and
+     * the grouped count walks the brand's memberships rather than asking
+     * every shot whether it is in a set.
+     */
+    feedCounts(projectId, f) {
+      const params = { project: projectId };
+      const where = ["n.project_id = @project", ...filterSql({ ...f, lens: void 0 }, params, false)];
+      const scoped = db.prepare(
+        `SELECT coalesce(sum(n.archived = 0), 0) AS live, coalesce(sum(n.archived = 0 AND n.kept = 1), 0) AS kept,
+                  coalesce(sum(n.archived = 1), 0) AS archived
+             FROM nodes n WHERE ${where.join(" AND ")}`
+      ).get(params);
+      const totals = db.prepare(
+        `SELECT count(*) AS total, coalesce(sum(n.archived = 0), 0) AS live
+             FROM nodes n WHERE n.project_id = ? AND n.kind != 'root'`
+      ).get(projectId);
+      const grouped = db.prepare(
+        `SELECT count(DISTINCT sn.node_id) AS c
+               FROM sets s
+               CROSS JOIN set_nodes sn ON sn.set_id = s.id
+               CROSS JOIN nodes n ON n.id = sn.node_id
+              WHERE s.brand_id = (SELECT brand_id FROM projects WHERE id = ?)
+                AND n.project_id = ? AND n.archived = 0`
+      ).get(projectId, projectId).c;
+      return {
+        total: totals.total,
+        all: scoped.live,
+        keepers: scoped.kept,
+        archived: scoped.archived,
+        ungrouped: totals.live - grouped
+      };
+    },
+    /**
+     * Where one shot sits in its tree, from the parent index: its ancestors
+     * up to (never including) the root, the siblings around it, and what
+     * hangs off it. Archived versions stay in the strip, as they did when the
+     * overlay walked the whole workspace.
+     *
+     * The siblings are a window: this shot, and up to twenty-five on either
+     * side in filing order. A top-level shot's siblings are every top-level
+     * shot in the brand, and the whole list was eighteen megabytes on a
+     * brand of twenty thousand; the overlay only ever steps to a neighbour,
+     * and each step asks again, so the window re-centres as it goes.
+     */
+    lineageOf(id) {
+      const node = this.getFeedNode(id);
+      if (!node) return null;
+      if (node.kind === "root") return { ancestors: [], siblings: [], children: [], history: [] };
+      const ancestors = [];
+      let cur = node.parentId ? this.getFeedNode(node.parentId) : null;
+      for (let hops = 0; cur && cur.kind !== "root" && hops < 64; hops++) {
+        ancestors.unshift(cur);
+        cur = cur.parentId ? this.getFeedNode(cur.parentId) : null;
+      }
+      const before = db.prepare(
+        `SELECT count(*) AS c FROM nodes n
+              WHERE n.parent_id IS ? AND (n.created_at < ? OR (n.created_at = ? AND n.id < ?))`
+      ).get(node.parentId, node.createdAt, node.createdAt, node.id).c;
+      const skip = Math.max(0, before - LINEAGE_SIBLINGS_RADIUS);
+      const take = before - skip + 1 + LINEAGE_SIBLINGS_RADIUS;
+      const siblings = db.prepare(
+        `SELECT ${FEED_COLS} FROM nodes n WHERE n.parent_id IS ?
+              ORDER BY n.created_at, n.id LIMIT ? OFFSET ?`
+      ).all(node.parentId, take, skip).map(rowToFeedNode);
+      const children = db.prepare(`SELECT ${FEED_COLS} FROM nodes n WHERE n.parent_id = ? ORDER BY n.created_at, n.id LIMIT ?`).all(node.id, LINEAGE_CHILDREN_MAX).map(rowToFeedNode);
+      const rootShot = ancestors[0] ?? node;
+      const history = db.prepare(
+        `WITH RECURSIVE d(id) AS (SELECT @root UNION ALL SELECT c.id FROM nodes c JOIN d ON c.parent_id = d.id)
+             SELECT ${FEED_COLS} FROM nodes n
+              WHERE n.id IN (SELECT id FROM d) AND (n.archived = 0 OR n.id = @self)
+              ORDER BY n.created_at, n.id LIMIT @limit`
+      ).all({ root: rootShot.id, self: node.id, limit: LINEAGE_HISTORY_MAX }).map(rowToFeedNode);
+      if (!history.some((n) => n.id === node.id)) {
+        history.pop();
+        history.push(node);
+      }
+      return { ancestors, siblings, children, history };
+    },
+    /** The newest finished shots, newest first, for the rail and the attach panel. */
+    recentShots(projectId, limit = 48) {
+      return db.prepare(
+        `SELECT ${FEED_COLS} FROM nodes n
+              WHERE n.project_id = ? AND n.kind != 'root' AND n.status = 'done' AND n.images != '[]'
+              ORDER BY n.created_at DESC, n.id DESC LIMIT ?`
+      ).all(projectId, Math.max(1, Math.min(FEED_PAGE_MAX, limit))).map(rowToFeedNode);
+    },
+    /** A year of runs by day, counted where the rows are. */
+    usageByDay(brandId) {
+      return db.prepare(
+        `SELECT substr(n.created_at, 1, 10) AS day,
+                    coalesce(sum(n.kind = 'generation'), 0) AS generations,
+                    coalesce(sum(n.kind = 'edit'), 0) AS edits
+               FROM nodes n JOIN projects p ON p.id = n.project_id
+              WHERE p.brand_id = ? AND n.kind != 'root' AND n.created_at >= date('now', '-400 days')
+              GROUP BY day ORDER BY day`
+      ).all(brandId).map((r) => ({ day: String(r.day), generations: Number(r.generations), edits: Number(r.edits) }));
+    },
+    /** The compiled prompt of the shot that produced an image, for a reference described in words. */
+    promptForImage(brandId, hash) {
+      const r = db.prepare(
+        `SELECT n.prompt FROM nodes n JOIN projects p ON p.id = n.project_id
+            WHERE p.brand_id = ? AND n.images LIKE ? ORDER BY n.created_at, n.id LIMIT 1`
+      ).get(brandId, `%"${hash}"%`);
+      return r?.prompt ?? null;
+    },
+    /**
+     * Every piece of work a brand has in flight, plus whatever finished lately,
+     * in one query. The bar outlives the project screen, so the thing that used
+     * to be answerable only by polling one tree at a time has to be answerable
+     * without knowing which project you are looking at.
+     *
+     * The cutoff is computed in SQL rather than passed in: created_at is
+     * SQLite's own datetime('now') text, and comparing that against a caller's
+     * ISO string is a silent, timezone-shaped mis-filter.
+     */
+    recentActivity(brandId, limit = 60) {
+      const cols = `${FEED_COLS}, (
+                    SELECT group_concat(s.name, char(31))
+                      FROM set_nodes sn JOIN sets s ON s.id = sn.set_id
+                     WHERE sn.node_id = n.id
+                  ) AS set_names`;
+      const inBrand = "n.project_id IN (SELECT id FROM projects WHERE brand_id = @brand)";
+      const rows = db.prepare(
+        `SELECT * FROM (
+             SELECT ${cols} FROM nodes n
+              WHERE ${inBrand} AND n.kind != 'root' AND n.status = 'running'
+             UNION ALL
+             SELECT ${cols} FROM nodes n
+              WHERE ${inBrand} AND n.kind != 'root' AND n.status != 'running'
+                AND n.created_at >= datetime('now', '-2 days')
+           )
+           ORDER BY created_at DESC, id DESC
+           LIMIT @limit`
+      ).all({ brand: brandId, limit });
+      return rows.map((r) => ({
+        ...rowToFeedNode(r),
+        setNames: r.set_names ? String(r.set_names).split(SET_NAME_SEP) : []
+      }));
+    },
+    setKept(id, kept) {
+      db.prepare("UPDATE nodes SET kept=? WHERE id=?").run(kept ? 1 : 0, id);
+    },
+    /**
+     * Archiving also clears the keeper mark.
+     *
+     * The two flags were independent, and the Keepers lens reads the live list,
+     * so archiving a keeper removed it from Keepers and from the Keepers count
+     * without saying anything: the star stayed lit on a shot that was no longer
+     * in the shortlist it claimed to be in. Keepers is a live shortlist and
+     * archive means put away, so one clears the other and the two can never
+     * disagree. Restoring does not re-star: the judgement was made once and
+     * putting the shot back is not the same as making it again.
+     */
+    setArchived(id, archived) {
+      if (archived) db.prepare("UPDATE nodes SET archived=1, kept=0 WHERE id=?").run(id);
+      else db.prepare("UPDATE nodes SET archived=0 WHERE id=?").run(id);
+    },
+    /** Permanent. Orphans any children rather than blocking or cascading —
+     * same technique collapseProjects already uses for a surplus root. */
+    deleteNode(id) {
+      db.prepare("UPDATE nodes SET parent_id=NULL WHERE parent_id=?").run(id);
+      db.prepare("DELETE FROM nodes WHERE id=?").run(id);
+    },
+    setBrief(id, brief) {
+      db.prepare("UPDATE nodes SET brief=? WHERE id=?").run(JSON.stringify(brief), id);
+    },
+    setOverlays(id, overlays) {
+      db.prepare("UPDATE nodes SET overlays=? WHERE id=?").run(JSON.stringify(overlays), id);
+    },
+    // settings
+    getSetting(key) {
+      const r = db.prepare("SELECT value FROM settings WHERE key=?").get(key);
+      return r ? r.value : null;
+    },
+    setSetting(key, value) {
+      db.prepare(
+        "INSERT INTO settings (key,value) VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value"
+      ).run(key, value);
+    },
+    allSettings() {
+      const rows = db.prepare("SELECT key, value FROM settings").all();
+      return Object.fromEntries(rows.map((r) => [r.key, r.value]));
+    }
+  };
+}
+
+// ../core/src/catalog/rows.ts
+function rowSource(r) {
+  return {
+    id: r.id,
+    brandId: r.brand_id,
+    url: r.url,
+    platform: r.platform,
+    status: r.status,
+    lastImportAt: r.last_import_at,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at
+  };
+}
+function rowProduct(r) {
+  return {
+    id: r.id,
+    sourceId: r.source_id,
+    brandId: r.brand_id,
+    externalKey: r.external_key,
+    title: r.title,
+    descriptionHtml: r.description_html,
+    url: r.url,
+    handle: r.handle,
+    vendor: r.vendor,
+    productType: r.product_type,
+    tags: JSON.parse(r.tags || "[]"),
+    category: r.category,
+    price: r.price,
+    compareAtPrice: r.compare_at_price,
+    currency: r.currency,
+    available: r.available == null ? null : !!r.available,
+    status: r.status,
+    raw: r.raw ? JSON.parse(r.raw) : null,
+    variant: r.variant ?? null,
+    material: r.material ?? null,
+    dimensions: r.dimensions ?? null,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at
+  };
+}
+function rowJob(r) {
+  return {
+    id: r.id,
+    brandId: r.brand_id,
+    sourceId: r.source_id,
+    url: r.url,
+    platform: r.platform,
+    stage: r.stage,
+    discovered: r.discovered,
+    fetched: r.fetched,
+    upserted: r.upserted,
+    imagesDone: r.images_done,
+    imagesTotal: r.images_total,
+    errors: JSON.parse(r.errors || "[]"),
+    warnings: JSON.parse(r.warnings || "[]"),
+    message: r.message,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    finishedAt: r.finished_at
+  };
+}
+var jobById = (db, id) => {
+  const r = db.prepare("SELECT * FROM import_jobs WHERE id=?").get(id);
+  return r ? rowJob(r) : null;
+};
+var productById = (db, id) => {
+  const r = db.prepare("SELECT * FROM catalog_products WHERE id=?").get(id);
+  return r ? rowProduct(r) : null;
+};
+var productsFor = (db, brandId) => db.prepare(
+  "SELECT * FROM catalog_products WHERE brand_id=? AND status!='unavailable' ORDER BY title COLLATE NOCASE"
+).all(brandId).map(rowProduct);
+var rowVariant = (r) => ({
+  id: r.id,
+  productId: r.product_id,
+  externalKey: r.external_key,
+  title: r.title,
+  sku: r.sku,
+  price: r.price,
+  compareAtPrice: r.compare_at_price,
+  currency: r.currency,
+  available: r.available == null ? null : !!r.available,
+  options: JSON.parse(r.options || "{}")
+});
+var rowImage = (r) => ({
+  id: r.id,
+  productId: r.product_id,
+  sourceUrl: r.source_url,
+  assetRef: r.asset_ref,
+  width: r.width,
+  height: r.height,
+  position: r.position,
+  alt: r.alt,
+  angle: r.angle ?? null,
+  excluded: !!r.excluded
+});
+var variantsForBrand = (db, brandId) => {
+  const out = /* @__PURE__ */ new Map();
+  const rows = db.prepare(
+    `SELECT v.* FROM catalog_variants v JOIN catalog_products p ON p.id = v.product_id
+        WHERE p.brand_id=? AND p.status!='unavailable' ORDER BY v.product_id, v.rowid`
+  ).all(brandId);
+  for (const r of rows) {
+    const list = out.get(r.product_id) ?? [];
+    list.push(rowVariant(r));
+    out.set(r.product_id, list);
+  }
+  return out;
+};
+var imagesForBrand = (db, brandId) => {
+  const out = /* @__PURE__ */ new Map();
+  const rows = db.prepare(
+    `SELECT i.* FROM catalog_images i JOIN catalog_products p ON p.id = i.product_id
+        WHERE p.brand_id=? AND p.status!='unavailable' ORDER BY i.product_id, i.position`
+  ).all(brandId);
+  for (const r of rows) {
+    const list = out.get(r.product_id) ?? [];
+    list.push(rowImage(r));
+    out.set(r.product_id, list);
+  }
+  return out;
+};
+var variantsFor = (db, productId) => db.prepare("SELECT * FROM catalog_variants WHERE product_id=?").all(productId).map((r) => ({
+  id: r.id,
+  productId: r.product_id,
+  externalKey: r.external_key,
+  title: r.title,
+  sku: r.sku,
+  price: r.price,
+  compareAtPrice: r.compare_at_price,
+  currency: r.currency,
+  available: r.available == null ? null : !!r.available,
+  options: JSON.parse(r.options || "{}")
+}));
+var imagesFor = (db, productId) => db.prepare("SELECT * FROM catalog_images WHERE product_id=? ORDER BY position").all(productId).map(
+  (r) => ({
+    id: r.id,
+    productId: r.product_id,
+    sourceUrl: r.source_url,
+    assetRef: r.asset_ref,
+    width: r.width,
+    height: r.height,
+    position: r.position,
+    alt: r.alt,
+    angle: r.angle ?? null,
+    excluded: !!r.excluded
+  })
+);
+
+// ../core/src/catalog/sources.ts
+function sourceMethods(db) {
+  return {
+    upsertSource(brandId, url, platform) {
+      const existing = db.prepare("SELECT * FROM catalog_sources WHERE brand_id=? AND url=?").get(brandId, url);
+      if (existing) {
+        db.prepare("UPDATE catalog_sources SET platform=?, updated_at=datetime('now') WHERE id=?").run(
+          platform,
+          existing.id
+        );
+        return rowSource(db.prepare("SELECT * FROM catalog_sources WHERE id=?").get(existing.id));
+      }
+      const id = randomUUID();
+      db.prepare("INSERT INTO catalog_sources (id, brand_id, url, platform, status) VALUES (?,?,?,?, 'idle')").run(
+        id,
+        brandId,
+        url,
+        platform
+      );
+      return rowSource(db.prepare("SELECT * FROM catalog_sources WHERE id=?").get(id));
+    },
+    getSourceForBrand(brandId) {
+      const r = db.prepare("SELECT * FROM catalog_sources WHERE brand_id=? ORDER BY updated_at DESC LIMIT 1").get(brandId);
+      return r ? rowSource(r) : null;
+    },
+    getSource(id) {
+      const r = db.prepare("SELECT * FROM catalog_sources WHERE id=?").get(id);
+      return r ? rowSource(r) : null;
+    },
+    setSourceStatus(id, status, touchImport = false) {
+      if (touchImport) {
+        db.prepare(
+          "UPDATE catalog_sources SET status=?, last_import_at=datetime('now'), updated_at=datetime('now') WHERE id=?"
+        ).run(status, id);
+      } else {
+        db.prepare("UPDATE catalog_sources SET status=?, updated_at=datetime('now') WHERE id=?").run(status, id);
+      }
+    }
+  };
+}
+function jobMethods(db) {
+  return {
+    createJob(input) {
+      const id = randomUUID();
+      db.prepare(
+        `INSERT INTO import_jobs (id, brand_id, source_id, url, platform, stage)
+         VALUES (?,?,?,?,?,'queued')`
+      ).run(id, input.brandId, input.sourceId ?? null, input.url, input.platform ?? "unknown");
+      return jobById(db, id);
+    },
+    getJob(id) {
+      const r = db.prepare("SELECT * FROM import_jobs WHERE id=?").get(id);
+      return r ? rowJob(r) : null;
+    },
+    listJobs(brandId) {
+      return db.prepare("SELECT * FROM import_jobs WHERE brand_id=? ORDER BY created_at DESC").all(brandId).map(rowJob);
+    },
+    updateJob(id, patch) {
+      const cur = jobById(db, id);
+      if (!cur) return null;
+      const stage = patch.stage ?? cur.stage;
+      const finished = patch.finished || stage === "completed" || stage === "partial" || stage === "failed";
+      db.prepare(
+        `UPDATE import_jobs SET
+          source_id=?, platform=?, stage=?, discovered=?, fetched=?, upserted=?,
+          images_done=?, images_total=?, errors=?, warnings=?, message=?,
+          updated_at=datetime('now'),
+          finished_at=CASE WHEN ? THEN COALESCE(finished_at, datetime('now')) ELSE finished_at END
+         WHERE id=?`
+      ).run(
+        patch.sourceId !== void 0 ? patch.sourceId : cur.sourceId,
+        patch.platform ?? cur.platform,
+        stage,
+        patch.discovered ?? cur.discovered,
+        patch.fetched ?? cur.fetched,
+        patch.upserted ?? cur.upserted,
+        patch.imagesDone ?? cur.imagesDone,
+        patch.imagesTotal ?? cur.imagesTotal,
+        JSON.stringify(patch.errors ?? cur.errors),
+        JSON.stringify(patch.warnings ?? cur.warnings),
+        patch.message !== void 0 ? patch.message : cur.message,
+        finished ? 1 : 0,
+        id
+      );
+      return jobById(db, id);
+    }
+  };
+}
+function productImportMethods(db) {
+  return {
+    upsertProduct(input) {
+      const existing = db.prepare("SELECT id FROM catalog_products WHERE source_id=? AND external_key=?").get(input.sourceId, input.externalKey);
+      const id = existing?.id ?? randomUUID();
+      if (existing) {
+        db.prepare(
+          // `category` is deliberately absent. The store's own taxonomy is
+          // `product_type`; `category` is this app's field, set by the user on
+          // the product page, and a re-import used to silently revert it.
+          `UPDATE catalog_products SET
+            title=?, description_html=?, url=?, handle=?, vendor=?, product_type=?, tags=?,
+            price=?, compare_at_price=?, currency=?, available=?, status='active', raw=?,
+            updated_at=datetime('now')
+           WHERE id=?`
+        ).run(
+          input.title,
+          input.descriptionHtml ?? null,
+          input.url,
+          input.handle ?? null,
+          input.vendor ?? null,
+          input.productType ?? null,
+          JSON.stringify(input.tags ?? []),
+          input.price ?? null,
+          input.compareAtPrice ?? null,
+          input.currency ?? null,
+          input.available == null ? null : input.available ? 1 : 0,
+          JSON.stringify(input.raw ?? null),
+          id
+        );
+      } else {
+        db.prepare(
+          `INSERT INTO catalog_products (
+            id, source_id, brand_id, external_key, title, description_html, url, handle, vendor,
+            product_type, tags, category, price, compare_at_price, currency, available, status, raw
+          ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?, 'active', ?)`
+        ).run(
+          id,
+          input.sourceId,
+          input.brandId,
+          input.externalKey,
+          input.title,
+          input.descriptionHtml ?? null,
+          input.url,
+          input.handle ?? null,
+          input.vendor ?? null,
+          input.productType ?? null,
+          JSON.stringify(input.tags ?? []),
+          input.category ?? null,
+          input.price ?? null,
+          input.compareAtPrice ?? null,
+          input.currency ?? null,
+          input.available == null ? null : input.available ? 1 : 0,
+          JSON.stringify(input.raw ?? null)
+        );
+      }
+      db.prepare("DELETE FROM catalog_variants WHERE product_id=?").run(id);
+      for (const v of input.variants ?? []) {
+        db.prepare(
+          `INSERT INTO catalog_variants (id, product_id, external_key, title, sku, price, compare_at_price, currency, available, options)
+           VALUES (?,?,?,?,?,?,?,?,?,?)`
+        ).run(
+          randomUUID(),
+          id,
+          v.externalKey,
+          v.title ?? null,
+          v.sku ?? null,
+          v.price ?? null,
+          v.compareAtPrice ?? null,
+          v.currency ?? null,
+          v.available == null ? null : v.available ? 1 : 0,
+          JSON.stringify(v.options ?? {})
+        );
+      }
+      const existingImgs = db.prepare("SELECT * FROM catalog_images WHERE product_id=?").all(id);
+      const byUrl = new Map(existingImgs.map((r) => [r.source_url, r]));
+      const maxPos = existingImgs.reduce((m, r) => Math.max(m, r.position ?? 0), -1);
+      const local = existingImgs.filter((r) => String(r.source_url ?? "").startsWith("local:"));
+      let appended = 0;
+      const merged = [
+        ...local.map((r) => ({
+          id: r.id,
+          sourceUrl: r.source_url,
+          assetRef: r.asset_ref,
+          width: r.width,
+          height: r.height,
+          alt: r.alt,
+          angle: r.angle ?? null,
+          excluded: r.excluded ?? 0,
+          sort: r.position ?? 0
+        })),
+        ...(input.images ?? []).map((img) => {
+          const prev = byUrl.get(img.sourceUrl);
+          return {
+            id: prev?.id ?? randomUUID(),
+            sourceUrl: img.sourceUrl,
+            assetRef: img.assetRef ?? prev?.asset_ref ?? null,
+            width: img.width ?? prev?.width ?? null,
+            height: img.height ?? prev?.height ?? null,
+            alt: img.alt ?? prev?.alt ?? null,
+            angle: prev?.angle ?? null,
+            // A crawl re-reporting an image is not the user changing their
+            // mind about it.
+            excluded: prev?.excluded ?? 0,
+            sort: prev ? prev.position ?? 0 : maxPos + 1 + appended++
+          };
+        })
+      ].sort((a, b) => a.sort - b.sort);
+      db.prepare("DELETE FROM catalog_images WHERE product_id=?").run(id);
+      merged.forEach((img, position) => {
+        db.prepare(
+          `INSERT INTO catalog_images (id, product_id, source_url, asset_ref, width, height, position, alt, angle, excluded)
+           VALUES (?,?,?,?,?,?,?,?,?,?)`
+        ).run(
+          img.id,
+          id,
+          img.sourceUrl,
+          img.assetRef,
+          img.width,
+          img.height,
+          position,
+          img.alt,
+          img.angle,
+          img.excluded
+        );
+      });
+      for (const col of input.collections ?? []) {
+        let colRow = db.prepare("SELECT id FROM catalog_collections WHERE source_id=? AND external_key=?").get(input.sourceId, col.externalKey);
+        if (!colRow) {
+          const colId = randomUUID();
+          db.prepare(
+            "INSERT INTO catalog_collections (id, source_id, external_key, title, url) VALUES (?,?,?,?,?)"
+          ).run(colId, input.sourceId, col.externalKey, col.title, col.url ?? null);
+          colRow = { id: colId };
+        } else {
+          db.prepare("UPDATE catalog_collections SET title=?, url=? WHERE id=?").run(
+            col.title,
+            col.url ?? null,
+            colRow.id
+          );
+        }
+        db.prepare("INSERT OR IGNORE INTO catalog_collection_products (collection_id, product_id) VALUES (?,?)").run(
+          colRow.id,
+          id
+        );
+      }
+      return productById(db, id);
+    },
+    setImageAsset(productId, sourceUrl, assetRef, meta) {
+      db.prepare(
+        `UPDATE catalog_images SET asset_ref=?, width=COALESCE(?, width), height=COALESCE(?, height)
+         WHERE product_id=? AND source_url=?`
+      ).run(assetRef, meta?.width ?? null, meta?.height ?? null, productId, sourceUrl);
+    },
+    listImagesNeedingAssets(brandId, limit = 500) {
+      return db.prepare(
+        `SELECT i.* FROM catalog_images i
+         JOIN catalog_products p ON p.id = i.product_id
+         WHERE p.brand_id=? AND (i.asset_ref IS NULL OR i.asset_ref='')
+         ORDER BY i.position ASC LIMIT ?`
+      ).all(brandId, limit).map((r) => ({
+        id: r.id,
+        productId: r.product_id,
+        sourceUrl: r.source_url,
+        assetRef: r.asset_ref,
+        width: r.width,
+        height: r.height,
+        position: r.position,
+        alt: r.alt,
+        angle: r.angle ?? null,
+        excluded: !!r.excluded
+      }));
+    },
+    markMissingUnavailable(sourceId, seenExternalKeys) {
+      if (!seenExternalKeys.length) {
+        const r2 = db.prepare(
+          "UPDATE catalog_products SET status='unavailable', updated_at=datetime('now') WHERE source_id=? AND status='active'"
+        ).run(sourceId);
+        return r2.changes;
+      }
+      const placeholders = seenExternalKeys.map(() => "?").join(",");
+      const r = db.prepare(
+        `UPDATE catalog_products SET status='unavailable', updated_at=datetime('now')
+         WHERE source_id=? AND status='active' AND external_key NOT IN (${placeholders})`
+      ).run(sourceId, ...seenExternalKeys);
+      return r.changes;
+    }
+  };
+}
+
+// ../core/src/catalog/reads.ts
+function readMethods(db) {
+  return {
+    getProduct(id) {
+      return productById(db, id);
+    },
+    getProductByLibraryId(libraryId) {
+      if (!libraryId.startsWith("cat-")) return null;
+      return productById(db, libraryId.slice(4));
+    },
+    listProducts(brandId) {
+      return productsFor(db, brandId);
+    },
+    listVariants(productId) {
+      return variantsFor(db, productId);
+    },
+    listImages(productId) {
+      return imagesFor(db, productId);
+    }
+  };
+}
+function mutationMethods(db) {
+  return {
+    deleteCatalogProduct(id) {
+      db.prepare("DELETE FROM catalog_products WHERE id=?").run(id);
+    },
+    /**
+     * The fields this app invents on top of an imported product. Everything a
+     * store supplies — title, price, vendor, variants — stays the store's and
+     * is refreshed by every import; these four have no counterpart there, so
+     * they are the user's and an import never touches them.
+     */
+    updateProduct(id, patch) {
+      const cols = ["category", "variant", "material", "dimensions"].filter((k) => k in patch);
+      if (cols.length) {
+        db.prepare(
+          `UPDATE catalog_products SET ${cols.map((c) => `${c}=?`).join(", ")}, updated_at=datetime('now') WHERE id=?`
+        ).run(...cols.map((c) => patch[c] ?? null), id);
+      }
+      return productById(db, id);
+    },
+    /**
+     * An angle the user shot themselves, added to an imported product. The
+     * `local:` prefix is what marks it as not-from-the-store, which is how the
+     * import merge knows to carry it across instead of deleting it.
+     */
+    addLocalImage(productId, assetRef, angle) {
+      const next = (db.prepare("SELECT MAX(position) AS p FROM catalog_images WHERE product_id=?").get(productId)?.p ?? -1) + 1;
+      db.prepare(
+        `INSERT INTO catalog_images (id, product_id, source_url, asset_ref, position, angle)
+         VALUES (?,?,?,?,?,?)`
+      ).run(randomUUID(), productId, `local:${assetRef}`, assetRef, next, angle ?? null);
+    },
+    /**
+     * Say which of a product's images make up its reference set, and in what
+     * order. `assetRefs` is the whole set: anything left out stops being used.
+     *
+     * An image the user uploaded here is theirs, so leaving it out deletes it.
+     * A store image is not — the next import would fetch it straight back — so
+     * leaving one out marks it excluded instead. That is the difference between
+     * a delete this can honour and one it cannot, and it is also what lets a
+     * store image be put back: pass it in again.
+     */
+    setImageOrder(productId, assetRefs) {
+      const rows = imagesFor(db, productId).filter((i) => i.assetRef);
+      const keep = new Set(assetRefs);
+      const ordered = assetRefs.map((ref) => rows.find((r) => r.assetRef === ref)).filter(Boolean);
+      const dropped = rows.filter((r) => !keep.has(r.assetRef));
+      const setAside = dropped.filter((r) => !String(r.sourceUrl).startsWith("local:"));
+      db.transaction(() => {
+        for (const r of dropped) {
+          if (String(r.sourceUrl).startsWith("local:")) db.prepare("DELETE FROM catalog_images WHERE id=?").run(r.id);
+        }
+        for (const r of setAside) db.prepare("UPDATE catalog_images SET excluded=1 WHERE id=?").run(r.id);
+        for (const r of ordered) db.prepare("UPDATE catalog_images SET excluded=0 WHERE id=?").run(r.id);
+        const tail = imagesFor(db, productId).filter((i) => !i.assetRef);
+        [...ordered, ...setAside, ...tail].forEach((r, i) => {
+          db.prepare("UPDATE catalog_images SET position=? WHERE id=?").run(i, r.id);
+        });
+      })();
+    }
+    /** Merge manual kit products + catalog into one library list. */
+  };
+}
+
+// ../core/src/catalog/library.ts
+function libraryMethods(db) {
+  return {
+    listLibraryProducts(brandId, brandJson) {
+      const manual = (brandJson?.products ?? []).map((p) => ({
+        id: p.id,
+        name: p.name,
+        origin: "manual",
+        category: p.category ?? null,
+        variant: p.variant ?? null,
+        material: p.material ?? null,
+        dimensions: p.dimensions ?? null,
+        shots: (p.shots ?? []).map((s) => ({
+          file: s.file,
+          locked: s.locked ?? true,
+          angle: s.angle ?? null,
+          alt: s.alt ?? s.angle ?? null
+        }))
+      }));
+      const imagesBy = imagesForBrand(db, brandId);
+      const variantsBy = variantsForBrand(db, brandId);
+      const catalog = productsFor(db, brandId).map((p) => {
+        const images = imagesBy.get(p.id) ?? [];
+        const shot = (i) => ({
+          file: i.assetRef,
+          locked: true,
+          angle: i.angle,
+          alt: i.alt,
+          local: String(i.sourceUrl).startsWith("local:")
+        });
+        const seen = /* @__PURE__ */ new Set();
+        const usable = images.filter((i) => i.assetRef && !seen.has(i.assetRef) && seen.add(i.assetRef));
+        const shots = usable.filter((i) => !i.excluded).map(shot);
+        const hiddenShots = usable.filter((i) => i.excluded).map(shot);
+        return {
+          id: `cat-${p.id}`,
+          name: p.title,
+          origin: "catalog",
+          url: p.url,
+          descriptionHtml: p.descriptionHtml,
+          vendor: p.vendor,
+          productType: p.productType,
+          tags: p.tags,
+          category: p.category,
+          variant: p.variant,
+          material: p.material,
+          dimensions: p.dimensions,
+          price: p.price,
+          compareAtPrice: p.compareAtPrice,
+          currency: p.currency,
+          available: p.available,
+          status: p.status,
+          shots,
+          hiddenShots,
+          variants: variantsBy.get(p.id) ?? []
+        };
+      });
+      return [...manual, ...catalog];
+    }
+  };
+}
+
+// ../core/src/catalogStore.ts
+function createCatalogStore(db) {
+  return {
+    ...sourceMethods(db),
+    ...jobMethods(db),
+    ...productImportMethods(db),
+    ...readMethods(db),
+    ...mutationMethods(db),
+    ...libraryMethods(db)
+  };
+}
+
+// ../core/src/engine.ts
+var REFERENCE_ROLE_DIRECTIVE = {
+  product: "the exact product \u2014 preserve its label, shape, colors and design faithfully; do not redesign it",
+  character: "the exact person \u2014 match their face, facial structure, skin, hair and build exactly; their clothing, pose and background are capture context, not styling to reproduce",
+  brand: "the brand's own mark \u2014 if the direction calls for the mark to appear, reproduce it exactly as drawn, same colours, letterforms and proportions, every character down to the smallest secondary lettering, in its original script and reading direction, never translated, transliterated or re-spelled; otherwise take only its colour and treatment, and never its subject, geometry or composition",
+  // Only a figure-led scene attaches one of these now, so this says what that
+  // case actually needs. It used to read "environment and light only - take no
+  // subject or person from it", which handed the model a photograph of a face
+  // treatment and told it to ignore the treatment. A hand-attached reference
+  // says "match ... treatment" and works; this now says the same thing, with the
+  // identity carve-out a scene needs and a lone reference does not. The tail
+  // names staged objects as stand-ins rather than just "no product": a bare
+  // prohibition still left the demo object in the frame, because the model had
+  // nowhere to put what the photograph so vividly showed.
+  //
+  // The carve-out leads. It used to sit forty words in, one subordinate
+  // clause after a paragraph of "match this" - and the tester case (a close
+  // portrait as the scene image beside a selected presenter) showed which
+  // half the model heard. Every treatment clause is retained word for word;
+  // only the order and the register of the identity refusal changed.
+  scene: "a reference for this world, never for a person: take no identity from the person in it \u2014 not their face, not their likeness \u2014 they are an anonymous stand-in whose place the attached subject takes. Match the environment, the light, and the material, density, scale, finish and spread of the treatment applied to the figure, including which parts of the form it covers and how far it reaches; treat any product, garment or prop staged in it as the same kind of stand-in, demonstrating placement and scale \u2014 never an object to reproduce",
+  composition: "a reference for framing, camera angle and pose only \u2014 take no subject, color, material or branding from it",
+  style: "a reference for overall treatment and mood only \u2014 take no composition, subject or product detail from it",
+  reference: "a reference to match in composition, lighting and treatment"
+};
+var EDIT_REFERENCE_ROLE_DIRECTIVE = {
+  product: "the exact product: keep or restore its label, shape and design faithfully",
+  character: "the exact person: keep their face, facial structure, skin, hair and build faithfully; take no clothing, pose or background from this reference, and keep the source image's existing outfit unless the instruction changes it",
+  brand: "the brand's own mark: reproduce it exactly as drawn wherever it appears \u2014 every character down to the smallest secondary lettering, in its original script and reading direction \u2014 never redrawn, re-lettered, translated or transliterated",
+  scene: "a reference for environment, light and treatment only \u2014 take no identity from any person in it",
+  composition: "a reference for framing and pose only",
+  style: "a reference for treatment and mood only",
+  reference: "a reference for composition, lighting and treatment only"
+};
+var BUDGET_EXHAUSTED = "scenri:budget-exhausted";
+var ASPECT_TOLERANCE = 0.15;
+var NAMED_RATIOS = [
+  ["1:1", 1],
+  ["4:5", 4 / 5],
+  ["5:4", 5 / 4],
+  ["2:3", 2 / 3],
+  ["3:2", 3 / 2],
+  ["3:4", 3 / 4],
+  ["4:3", 4 / 3],
+  ["9:16", 9 / 16],
+  ["16:9", 16 / 9],
+  ["2:1", 2],
+  ["1:2", 0.5]
+];
+function ratioLabel(width, height) {
+  const ratio = width / height;
+  for (const [label, value] of NAMED_RATIOS) {
+    if (Math.abs(ratio - value) / value < 0.02) return label;
+  }
+  const gcd = (a, b) => b ? gcd(b, a % b) : a;
+  const d = gcd(width, height) || 1;
+  return `${Math.round(width / d)}:${Math.round(height / d)}`;
+}
+function budgetSize(width, height, pixelBudget) {
+  const ratio = width / height;
+  if (!(ratio > 0) || !Number.isFinite(ratio) || !(pixelBudget > 0)) return { width, height };
+  return {
+    width: Math.round(Math.sqrt(pixelBudget * ratio)),
+    height: Math.round(Math.sqrt(pixelBudget / ratio))
+  };
+}
+
+// ../core/src/index.ts
+function defaultHome() {
+  return process.env.SCENRI_HOME || join(homedir(), ".scenri");
+}
+function createCore(homeDir = defaultHome()) {
+  const db = openDb(homeDir);
+  return {
+    home: homeDir,
+    store: createStore(db),
+    catalog: createCatalogStore(db),
+    images: createImageStore(homeDir),
+    ledger: createLedger(db),
+    close: () => db.close()
+  };
+}
+
+export { ASPECT_TOLERANCE, BUDGET_EXHAUSTED, EDIT_REFERENCE_ROLE_DIRECTIVE, REFERENCE_ROLE_DIRECTIVE, SCHEMA_VERSION, STEM_MIN, SchemaTooNewError, SpendCapError, TRIGRAM_MIN, budgetSize, createCatalogStore, createCore, createStore, defaultHome, fold, ftsMatch, matchesQuery, ratioLabel, searchTerms, termMatches, uniqueProjectSlug, uniqueSetSlug, uniqueSlug };
+//# sourceMappingURL=chunk-OJAG3FRX.js.map
+//# sourceMappingURL=chunk-OJAG3FRX.js.map