youiyoux 0.1.10 → 0.1.13

package/dist/chunks/chunk-ZWVWENSB.js

@@ -0,0 +1,899 @@
+import { createRequire as __youiRequire } from "node:module"; import { dirname as __youiDir } from "node:path"; import { fileURLToPath as __youiPath } from "node:url"; const require = __youiRequire(import.meta.url); const __youiDirname = __youiDir(__youiPath(import.meta.url));
+import {
+  SHAPE_DIMENSIONS,
+  shortHash
+} from "./chunk-NF4OJYKC.js";
+
+// ../store/src/driver.ts
+function searchTerms(words2) {
+  const terms = words2.flatMap((w) => w.normalize("NFC").toLowerCase().split(/[^\p{L}\p{N}]+/u)).filter((w) => w.length > 0);
+  return [...new Set(terms)].slice(0, 64);
+}
+function numbered(sql) {
+  let n = 0;
+  return sql.replace(/\?/g, () => `$${++n}`);
+}
+var Lock = class {
+  tail = Promise.resolve();
+  run(fn) {
+    const next = this.tail.then(fn, fn);
+    this.tail = next.catch(() => {
+    });
+    return next;
+  }
+};
+function pageInteger(value, fallback, max = 500) {
+  if (value === void 0 || Number.isNaN(value)) return fallback;
+  const bounded = Math.max(0, Math.min(max, Math.floor(value)));
+  return Number.isSafeInteger(bounded) ? bounded : fallback;
+}
+
+// ../store/src/migrations.ts
+var MIGRATIONS = [
+  {
+    id: 1,
+    name: "base",
+    statements: ({ json: json2 }) => [
+      `CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+      // Discover listings: metadata only, never source. scope 'chosen' is the synced sources, 'all' what --all added.
+      `CREATE TABLE IF NOT EXISTS discover_items (
+        id TEXT PRIMARY KEY,
+        scope TEXT NOT NULL,
+        ref TEXT,
+        name TEXT NOT NULL,
+        title TEXT,
+        summary TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        source_kind TEXT,
+        source_class TEXT NOT NULL,
+        registry TEXT,
+        licence TEXT NOT NULL,
+        style TEXT NOT NULL,
+        downloads INTEGER,
+        stars INTEGER,
+        archived INTEGER NOT NULL,
+        search_text TEXT NOT NULL,
+        entry ${json2} NOT NULL,
+        built_at TEXT NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS discover_items_scope ON discover_items (scope, source_class)`,
+      `CREATE INDEX IF NOT EXISTS discover_items_ref ON discover_items (ref)`,
+      `CREATE TABLE IF NOT EXISTS discover_roles (item_id TEXT NOT NULL, role TEXT NOT NULL, PRIMARY KEY (item_id, role))`,
+      `CREATE INDEX IF NOT EXISTS discover_roles_role ON discover_roles (role)`,
+      `CREATE TABLE IF NOT EXISTS signals (key TEXT PRIMARY KEY, kind TEXT NOT NULL, data ${json2} NOT NULL, fetched_at TEXT)`,
+      `CREATE TABLE IF NOT EXISTS licences (item_id TEXT PRIMARY KEY, spdx TEXT NOT NULL, evidence_url TEXT, verified_at TEXT)`,
+      // Inventory history: one row per project per run.
+      `CREATE TABLE IF NOT EXISTS scans (
+        id TEXT PRIMARY KEY,
+        run TEXT NOT NULL,
+        source TEXT NOT NULL,
+        project TEXT NOT NULL,
+        root TEXT NOT NULL,
+        commit_sha TEXT,
+        scanned_at TEXT NOT NULL,
+        status TEXT NOT NULL,
+        files INTEGER NOT NULL,
+        looks INTEGER NOT NULL,
+        families INTEGER NOT NULL,
+        near_duplicates INTEGER NOT NULL,
+        roles ${json2} NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS scans_project ON scans (project, scanned_at)`,
+      `CREATE INDEX IF NOT EXISTS scans_run ON scans (run)`,
+      `CREATE TABLE IF NOT EXISTS families (
+        run TEXT NOT NULL,
+        id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        looks INTEGER NOT NULL,
+        near_duplicate INTEGER NOT NULL,
+        projects ${json2} NOT NULL,
+        kits ${json2} NOT NULL,
+        shape ${json2} NOT NULL,
+        PRIMARY KEY (run, id)
+      )`,
+      `CREATE TABLE IF NOT EXISTS looks (
+        run TEXT NOT NULL,
+        id TEXT NOT NULL,
+        project TEXT NOT NULL,
+        role TEXT NOT NULL,
+        file TEXT NOT NULL,
+        line INTEGER NOT NULL,
+        col INTEGER NOT NULL,
+        tag TEXT NOT NULL,
+        kit TEXT,
+        family TEXT,
+        routes ${json2} NOT NULL,
+        shape ${json2} NOT NULL,
+        PRIMARY KEY (run, id)
+      )`,
+      `CREATE INDEX IF NOT EXISTS looks_family ON looks (run, family)`,
+      // The graph: what uses what, read with recursive CTEs that are the same text on both engines.
+      `CREATE TABLE IF NOT EXISTS nodes (id TEXT PRIMARY KEY, kind TEXT NOT NULL, ref TEXT NOT NULL, source TEXT NOT NULL)`,
+      `CREATE INDEX IF NOT EXISTS nodes_ref ON nodes (kind, ref)`,
+      `CREATE TABLE IF NOT EXISTS edges ("from" TEXT NOT NULL, "to" TEXT NOT NULL, kind TEXT NOT NULL, source TEXT NOT NULL, PRIMARY KEY ("from", "to", kind))`,
+      `CREATE INDEX IF NOT EXISTS edges_to ON edges ("to", kind)`,
+      `CREATE INDEX IF NOT EXISTS edges_source ON edges (source)`
+    ]
+  },
+  { id: 2, name: "discover-search", statements: (dialect) => dialect.searchDdl },
+  { id: 3, name: "project-graph", statements: () => [
+    `ALTER TABLE nodes ADD COLUMN project TEXT`,
+    `CREATE INDEX nodes_project ON nodes (project, kind, ref)`,
+    `CREATE INDEX looks_project_family ON looks (run, project, family)`,
+    // Old graph ids cannot be assigned safely to a project; rebuild restores this cache.
+    `DELETE FROM edges`,
+    `DELETE FROM nodes`
+  ] },
+  // What CI sends a hosted hub (youi.record/v1, redacted, no code): not derived from git like the
+  // rest, so a rebuild (reset) keeps it; each repository's last 100 are kept.
+  { id: 4, name: "ci-records", statements: ({ json: json2 }) => [
+    `CREATE TABLE IF NOT EXISTS ci_records (id TEXT PRIMARY KEY, repo TEXT NOT NULL, commit_sha TEXT, ref TEXT, generated_at TEXT NOT NULL, received_at TEXT NOT NULL, record ${json2} NOT NULL)`,
+    `CREATE INDEX IF NOT EXISTS ci_records_repo ON ci_records (repo, generated_at)`
+  ] }
+];
+var SCHEMA_VERSION = Math.max(...MIGRATIONS.map((m) => m.id));
+
+// ../store/src/store.ts
+var TABLES = ["meta", "discover_items", "discover_roles", "signals", "licences", "scans", "families", "looks", "nodes", "edges"];
+var MAX_PARAMS = 3e4;
+var MAX_DEPTH = 6;
+var RECORDS_KEPT = 100;
+var SOURCE_CLASSES = ["official", "community", "npm", "other"];
+var json = (value) => JSON.stringify(value);
+var parse = (value) => typeof value === "string" ? JSON.parse(value) : value;
+var int = (value) => Number(value ?? 0);
+var marks = (n) => Array.from({ length: n }, () => "?").join(", ");
+var batches = (items) => Array.from({ length: Math.ceil(items.length / MAX_PARAMS) }, (_, i) => items.slice(i * MAX_PARAMS, (i + 1) * MAX_PARAMS));
+var SqlStore = class {
+  db;
+  lock = new Lock();
+  constructor(adapter) {
+    this.db = adapter;
+  }
+  get engine() {
+    return this.db.engine;
+  }
+  get location() {
+    return this.db.location;
+  }
+  async checkSchema() {
+    try {
+      const rows = await this.db.all(`SELECT MAX(id) AS id FROM migrations`);
+      if (int(rows[0]?.id) !== SCHEMA_VERSION) throw new Error("schema mismatch");
+    } catch {
+      throw new Error("Index schema is outdated: run youiyoux index rebuild");
+    }
+  }
+  /** Apply pending migrations, each in its own transaction. Safe to run on every open. */
+  async migrate() {
+    return this.lock.run(async () => {
+      await this.db.exec(`CREATE TABLE IF NOT EXISTS migrations (id INTEGER PRIMARY KEY, name TEXT NOT NULL, applied_at TEXT NOT NULL)`);
+      const done = new Set((await this.db.all(`SELECT id FROM migrations`)).map((r) => int(r.id)));
+      const applied = [];
+      for (const migration of MIGRATIONS) {
+        if (done.has(migration.id)) continue;
+        await this.db.exec(this.db.begin);
+        try {
+          for (const statement of migration.statements(this.db)) await this.db.exec(statement);
+          await this.db.run(`INSERT INTO migrations (id, name, applied_at) VALUES (?, ?, ?)`, [migration.id, migration.name, (/* @__PURE__ */ new Date()).toISOString()]);
+          await this.db.exec("COMMIT");
+        } catch (error) {
+          await this.db.exec("ROLLBACK");
+          throw error;
+        }
+        applied.push(migration.id);
+      }
+      for (const statement of this.db.optional ?? []) await this.db.exec(statement).catch(() => {
+      });
+      return applied;
+    });
+  }
+  write(fn) {
+    return this.lock.run(async () => {
+      await this.db.exec(this.db.begin);
+      try {
+        const result = await fn();
+        await this.db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        await this.db.exec("ROLLBACK").catch(() => {
+        });
+        throw error;
+      }
+    });
+  }
+  /** Rows in batches of one multi-row INSERT each. `columns` are SQL names (quote reserved ones). */
+  async insert(table, columns, rows, conflict) {
+    const size = Math.max(1, Math.floor(MAX_PARAMS / columns.length));
+    for (let i = 0; i < rows.length; i += size) {
+      const batch = rows.slice(i, i + size);
+      const values = batch.map(() => `(${marks(columns.length)})`).join(", ");
+      await this.db.run(`INSERT INTO ${table} (${columns.join(", ")}) VALUES ${values} ${conflict}`, batch.flat());
+    }
+  }
+  async close() {
+    await this.lock.run(() => this.db.close());
+  }
+  async reset() {
+    await this.write(async () => {
+      for (const table of TABLES) await this.db.run(`DELETE FROM ${table}`);
+    });
+  }
+  async stats() {
+    const tables = {};
+    for (const table of TABLES) tables[table] = int((await this.db.all(`SELECT CAST(COUNT(*) AS INTEGER) AS n FROM ${table}`))[0]?.n);
+    const schema = int((await this.db.all(`SELECT MAX(id) AS id FROM migrations`))[0]?.id);
+    return { engine: this.engine, location: this.location, schema: schema || SCHEMA_VERSION, generation: await this.meta("generation"), tables };
+  }
+  async meta(key) {
+    const row = (await this.db.all(`SELECT value FROM meta WHERE key = ?`, [key]))[0];
+    return row ? row.value : null;
+  }
+  async setMeta(key, value) {
+    await this.write(() => this.db.run(`INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value`, [key, value]));
+  }
+  /* ------------------------------------------------------------------ Discover */
+  async putItems(items) {
+    const columns = ["id", "scope", "ref", "name", "title", "summary", "kind", "source_kind", "source_class", "registry", "licence", "style", "downloads", "stars", "archived", "search_text", "entry", "built_at"];
+    const update = columns.slice(1).map((c) => `${c} = excluded.${c}`).join(", ");
+    await this.insert("discover_items", columns, items.map((i) => [i.id, i.scope, i.ref, i.name, i.title, i.summary, i.kind, i.sourceKind, i.sourceClass, i.registry, i.licence, i.style, i.downloads, i.stars, i.archived ? 1 : 0, i.searchText, json(i.entry), i.builtAt]), `ON CONFLICT (id) DO UPDATE SET ${update}`);
+    const ids = items.map((i) => i.id);
+    for (const batch of batches(ids)) await this.db.run(`DELETE FROM discover_roles WHERE item_id IN (${marks(batch.length)})`, batch);
+    await this.insert("discover_roles", ["item_id", "role"], items.flatMap((i) => [...new Set(i.roles)].map((role) => [i.id, role])), "ON CONFLICT (item_id, role) DO NOTHING");
+  }
+  async replaceDiscoverItems(scope, items) {
+    await this.write(async () => {
+      await this.db.run(`DELETE FROM discover_roles WHERE item_id IN (SELECT id FROM discover_items WHERE scope = ?)`, [scope]);
+      await this.db.run(`DELETE FROM discover_items WHERE scope = ?`, [scope]);
+      await this.putItems(items.map((i) => ({ ...i, scope })));
+    });
+  }
+  async upsertDiscoverItems(items) {
+    await this.write(() => this.putItems(items));
+  }
+  /** WHERE conditions for a filter, on discover_items aliased `d`. */
+  filterSql(filter) {
+    const parts = [];
+    const params = [];
+    const any = (column, values, lower = false) => {
+      if (!values?.length) return;
+      parts.push(`${lower ? `LOWER(${column})` : column} IN (${marks(values.length)})`);
+      params.push(...values.map((v) => lower ? v.toLowerCase() : v));
+    };
+    any("d.scope", filter.scopes.length ? filter.scopes : ["chosen"]);
+    any("d.source_kind", filter.sourceKinds);
+    any("d.source_class", filter.sourceClasses);
+    any("d.registry", filter.registries, true);
+    any("d.licence", filter.licences, true);
+    any("d.kind", filter.kinds);
+    any("d.style", filter.styles);
+    if (filter.roles?.length) {
+      parts.push(`d.id IN (SELECT item_id FROM discover_roles WHERE role IN (${marks(filter.roles.length)}))`);
+      params.push(...filter.roles);
+    }
+    return { sql: parts.join(" AND "), params };
+  }
+  async matchDiscover(query) {
+    if (query.terms.length === 0) return [];
+    const filtered = [query.roles, query.sourceKinds, query.sourceClasses, query.registries, query.licences, query.kinds, query.styles].some((v) => v?.length);
+    if (!filtered && this.db.top) {
+      const rows = await this.db.top(query.terms, query.scopes.length ? query.scopes : ["chosen"], SOURCE_CLASSES, pageInteger(query.perClass, 400, 1e4));
+      return rows.map((r) => ({ id: r.id, sourceClass: r.source_class, entry: parse(r.entry) }));
+    }
+    const match = this.db.match(query.terms);
+    const filter = this.filterSql(query);
+    const ranked = await this.db.all(
+      `SELECT id, source_class, r FROM (
+         SELECT id, source_class, r, ROW_NUMBER() OVER (PARTITION BY source_class ORDER BY r, id) AS n
+         FROM (SELECT d.id, d.source_class, ${match.rank} AS r FROM ${match.from} WHERE ${match.where} AND ${filter.sql}) matched
+       ) best WHERE n <= CAST(? AS INTEGER) ORDER BY r, id`,
+      [...match.rankParams, ...match.whereParams, ...filter.params, pageInteger(query.perClass, 400, 1e4)]
+    );
+    const entries = /* @__PURE__ */ new Map();
+    const ids = ranked.map((r) => r.id);
+    for (const batch of batches(ids)) {
+      for (const row of await this.db.all(`SELECT id, entry FROM discover_items WHERE id IN (${marks(batch.length)})`, batch)) entries.set(row.id, row.entry);
+    }
+    return ranked.map((r) => ({ id: r.id, sourceClass: r.source_class, entry: parse(entries.get(r.id)) }));
+  }
+  async listDiscover(filter, page = {}) {
+    const where = this.filterSql(filter);
+    const limit = pageInteger(page.limit, 20);
+    const offset = pageInteger(page.offset, 0, 2147483647);
+    const rows = await this.db.all(
+      `SELECT d.id, d.source_class, d.entry FROM discover_items d WHERE ${where.sql} ORDER BY CASE d.source_class WHEN 'official' THEN 0 ELSE 1 END, COALESCE(d.downloads, -1) DESC, d.id LIMIT ? OFFSET ?`,
+      [...where.params, limit, offset]
+    );
+    return { rows: rows.map((r) => ({ id: r.id, sourceClass: r.source_class, entry: parse(r.entry) })), total: await this.countDiscover(filter) };
+  }
+  async countDiscover(filter) {
+    const where = this.filterSql(filter);
+    return int((await this.db.all(`SELECT CAST(COUNT(*) AS INTEGER) AS n FROM discover_items d WHERE ${where.sql}`, where.params))[0]?.n);
+  }
+  async discoverFacets(filter) {
+    const where = this.filterSql(filter);
+    const group = async (column) => {
+      const rows = await this.db.all(`SELECT ${column} AS k, CAST(COUNT(*) AS INTEGER) AS n FROM discover_items d WHERE ${where.sql} GROUP BY ${column} ORDER BY n DESC, k`, where.params);
+      return Object.fromEntries(rows.map((r) => [r.k ?? "unknown", int(r.n)]));
+    };
+    const roles = await this.db.all(`SELECT r.role AS k, CAST(COUNT(*) AS INTEGER) AS n FROM discover_roles r JOIN discover_items d ON d.id = r.item_id WHERE ${where.sql} GROUP BY r.role ORDER BY n DESC, k`, where.params);
+    return { role: Object.fromEntries(roles.map((r) => [r.k, int(r.n)])), source: await group("COALESCE(d.registry, d.source_kind)"), licence: await group("d.licence"), style: await group("d.style") };
+  }
+  async getDiscoverItem(idOrRef, scopes) {
+    const scoped = scopes.length ? scopes : ["chosen"];
+    for (const column of ["id", "ref"]) {
+      const row = (await this.db.all(`SELECT id, source_class, entry FROM discover_items WHERE ${column} = ? AND scope IN (${marks(scoped.length)}) ORDER BY CASE scope WHEN 'chosen' THEN 0 ELSE 1 END, id LIMIT 1`, [idOrRef, ...scoped]))[0];
+      if (row) return { id: row.id, sourceClass: row.source_class, entry: parse(row.entry) };
+    }
+    return null;
+  }
+  async discoverRoles(itemIds) {
+    const out = {};
+    for (const batch of batches(itemIds)) {
+      for (const row of await this.db.all(`SELECT item_id, role FROM discover_roles WHERE item_id IN (${marks(batch.length)}) ORDER BY item_id, role`, batch)) (out[row.item_id] ??= []).push(row.role);
+    }
+    return out;
+  }
+  /* ------------------------------------------------------- signals and licences */
+  async replaceSignals(signals) {
+    await this.write(async () => {
+      await this.db.run(`DELETE FROM signals`);
+      await this.insert("signals", ["key", "kind", "data", "fetched_at"], signals.map((s) => [s.key, s.kind, json(s.data), s.fetchedAt]), "ON CONFLICT (key) DO UPDATE SET kind = excluded.kind, data = excluded.data, fetched_at = excluded.fetched_at");
+    });
+  }
+  async signal(key) {
+    const row = (await this.db.all(`SELECT key, kind, data, fetched_at FROM signals WHERE key = ?`, [key]))[0];
+    return row ? { key: row.key, kind: row.kind, data: parse(row.data), fetchedAt: row.fetched_at } : null;
+  }
+  async replaceLicences(licences) {
+    await this.write(async () => {
+      await this.db.run(`DELETE FROM licences`);
+      await this.insert("licences", ["item_id", "spdx", "evidence_url", "verified_at"], licences.map((l) => [l.itemId, l.spdx, l.evidenceUrl, l.verifiedAt]), "ON CONFLICT (item_id) DO UPDATE SET spdx = excluded.spdx, evidence_url = excluded.evidence_url, verified_at = excluded.verified_at");
+    });
+  }
+  async licence(itemId) {
+    const row = (await this.db.all(`SELECT item_id, spdx, evidence_url, verified_at FROM licences WHERE item_id = ?`, [itemId]))[0];
+    return row ? { itemId: row.item_id, spdx: row.spdx, evidenceUrl: row.evidence_url, verifiedAt: row.verified_at } : null;
+  }
+  /* ---------------------------------------------------------------- CI records */
+  async putRecord(record, receivedAt) {
+    await this.write(async () => {
+      const id = `${record.repo}@${record.commit ?? record.generatedAt}`;
+      await this.insert("ci_records", ["id", "repo", "commit_sha", "ref", "generated_at", "received_at", "record"], [[id, record.repo, record.commit, record.ref, record.generatedAt, receivedAt, json(record)]], "ON CONFLICT (id) DO UPDATE SET ref = excluded.ref, generated_at = excluded.generated_at, received_at = excluded.received_at, record = excluded.record");
+      await this.db.run(`DELETE FROM ci_records WHERE repo = ? AND id NOT IN (SELECT id FROM ci_records WHERE repo = ? ORDER BY generated_at DESC, received_at DESC LIMIT ${RECORDS_KEPT})`, [record.repo, record.repo]);
+    });
+  }
+  async latestRecords() {
+    const rows = await this.db.all(`SELECT record, received_at FROM (SELECT record, received_at, repo, ROW_NUMBER() OVER (PARTITION BY repo ORDER BY generated_at DESC, received_at DESC) AS n FROM ci_records) ranked WHERE n = 1 ORDER BY repo`);
+    return rows.map((r) => ({ record: parse(r.record), receivedAt: String(r.received_at) }));
+  }
+  /* ----------------------------------------------------------------- inventory */
+  async recordInventory(run) {
+    await this.write(async () => {
+      await this.insert(
+        "scans",
+        ["id", "run", "source", "project", "root", "commit_sha", "scanned_at", "status", "files", "looks", "families", "near_duplicates", "roles"],
+        run.projects.map((p) => [`${run.run}:${p.project}`, run.run, run.source, p.project, p.root, p.commit, run.scannedAt, p.status, p.files, p.looks, p.families, p.nearDuplicates, json(p.roles)]),
+        "ON CONFLICT (id) DO UPDATE SET commit_sha = excluded.commit_sha, scanned_at = excluded.scanned_at, status = excluded.status, files = excluded.files, looks = excluded.looks, families = excluded.families, near_duplicates = excluded.near_duplicates, roles = excluded.roles"
+      );
+      await this.db.run(`DELETE FROM families WHERE run = ?`, [run.run]);
+      await this.insert("families", ["run", "id", "role", "looks", "near_duplicate", "projects", "kits", "shape"], run.families.map((f) => [run.run, f.id, f.role, f.looks, f.nearDuplicate ? 1 : 0, json(f.projects), json(f.kits), json(f.shape)]), "ON CONFLICT (run, id) DO NOTHING");
+      const newest = (await this.db.all(`SELECT MAX(scanned_at) AS scanned_at FROM scans WHERE source = ?`, [run.source]))[0]?.scanned_at;
+      if (newest && newest > run.scannedAt) return;
+      await this.db.run(`DELETE FROM looks WHERE run IN (SELECT DISTINCT run FROM scans WHERE source = ?)`, [run.source]);
+      await this.insert("looks", ["run", "id", "project", "role", "file", "line", "col", "tag", "kit", "family", "routes", "shape"], run.looks.map((l) => [run.run, l.id, l.project, l.role, l.file, l.line, l.column, l.tag, l.kit, l.family, json(l.routes), json(l.shape)]), "ON CONFLICT (run, id) DO NOTHING");
+      await this.putGraph(run.source, run.graph);
+    });
+  }
+  async history(filter = {}) {
+    const where = filter.project ? `WHERE project = ?` : "";
+    const rows = await this.db.all(`SELECT * FROM scans ${where} ORDER BY scanned_at DESC, project LIMIT ? OFFSET ?`, [...filter.project ? [filter.project] : [], pageInteger(filter.limit, 20), pageInteger(filter.offset, 0, 2147483647)]);
+    return rows.map((r) => ({ id: String(r.id), run: String(r.run), source: String(r.source), project: String(r.project), root: String(r.root), commit: r.commit_sha ?? null, scannedAt: String(r.scanned_at), status: String(r.status), files: int(r.files), looks: int(r.looks), families: int(r.families), nearDuplicates: int(r.near_duplicates), roles: parse(r.roles) }));
+  }
+  async latestRun(source) {
+    const row = (await this.db.all(`SELECT run, source, scanned_at FROM scans ${source ? "WHERE source = ?" : ""} ORDER BY scanned_at DESC, run DESC LIMIT 1`, source ? [source] : []))[0];
+    return row ? { run: row.run, source: row.source, scannedAt: row.scanned_at } : null;
+  }
+  async families(filter = {}) {
+    const run = filter.run ?? (await this.latestRun())?.run ?? null;
+    if (!run) return { run: null, total: 0, rows: [] };
+    const where = `run = ?${filter.role ? " AND role = ?" : ""}`;
+    const params = [run, ...filter.role ? [filter.role] : []];
+    const total = int((await this.db.all(`SELECT CAST(COUNT(*) AS INTEGER) AS n FROM families WHERE ${where}`, params))[0]?.n);
+    const rows = await this.db.all(`SELECT * FROM families WHERE ${where} ORDER BY role, looks DESC, id LIMIT ? OFFSET ?`, [...params, pageInteger(filter.limit, 50), pageInteger(filter.offset, 0, 2147483647)]);
+    return { run, total, rows: rows.map((r) => ({ id: String(r.id), role: String(r.role), looks: int(r.looks), nearDuplicate: int(r.near_duplicate) === 1, projects: parse(r.projects), kits: parse(r.kits), shape: parse(r.shape) })) };
+  }
+  async looks(filter) {
+    const run = filter.run ?? (await this.latestRun())?.run ?? null;
+    if (!run) return { run: null, total: 0, rows: [] };
+    const where = `run = ?${filter.family ? " AND family = ?" : ""}${filter.role ? " AND role = ?" : ""}`;
+    const params = [run, ...filter.family ? [filter.family] : [], ...filter.role ? [filter.role] : []];
+    const total = int((await this.db.all(`SELECT CAST(COUNT(*) AS INTEGER) AS n FROM looks WHERE ${where}`, params))[0]?.n);
+    const rows = await this.db.all(`SELECT * FROM looks WHERE ${where} ORDER BY project, file, line, col, id LIMIT ? OFFSET ?`, [...params, pageInteger(filter.limit, 50), pageInteger(filter.offset, 0, 2147483647)]);
+    return { run, total, rows: rows.map((r) => ({ id: String(r.id), project: String(r.project), role: String(r.role), file: String(r.file), line: int(r.line), column: int(r.col), tag: String(r.tag), kit: r.kit ?? null, family: r.family ?? null, routes: parse(r.routes), shape: parse(r.shape) })) };
+  }
+  /* --------------------------------------------------------------------- graph */
+  async putGraph(source, graph) {
+    await this.db.run(`DELETE FROM edges WHERE source = ?`, [source]);
+    await this.db.run(`DELETE FROM nodes WHERE source = ? AND id NOT IN (SELECT "from" FROM edges) AND id NOT IN (SELECT "to" FROM edges)`, [source]);
+    const nodes = new Map(graph.nodes.map((n) => [n.id, n]));
+    await this.insert("nodes", ["id", "kind", "ref", "source", "project"], [...nodes.values()].map((n) => [n.id, n.kind, n.ref, source, n.project ?? null]), "ON CONFLICT (id) DO UPDATE SET kind = excluded.kind, ref = excluded.ref, project = excluded.project");
+    const edges = new Map(graph.edges.map((e) => [`${e.from}\0${e.to}\0${e.kind}`, e]));
+    await this.insert("edges", [`"from"`, `"to"`, "kind", "source"], [...edges.values()].map((e) => [e.from, e.to, e.kind, source]), `ON CONFLICT ("from", "to", kind) DO UPDATE SET source = excluded.source`);
+  }
+  async replaceGraph(source, graph) {
+    await this.write(() => this.putGraph(source, graph));
+  }
+  async reach(start, kinds, options = {}) {
+    if (start.length === 0 || kinds.length === 0) return [];
+    const [near, far] = options.reverse ? [`"to"`, `"from"`] : [`"from"`, `"to"`];
+    const depth = Math.max(0, Math.min(MAX_DEPTH, options.maxDepth ?? 3));
+    const rows = await this.db.all(
+      `WITH RECURSIVE reach(id, depth) AS (
+         SELECT id, 0 FROM nodes WHERE id IN (${marks(start.length)})
+         UNION
+         SELECT e.${far}, r.depth + 1 FROM edges e JOIN reach r ON e.${near} = r.id
+         WHERE e.kind IN (${marks(kinds.length)}) AND r.depth < CAST(? AS INTEGER)
+       )
+       SELECT n.id, n.kind, n.ref, MIN(r.depth) AS depth FROM reach r JOIN nodes n ON n.id = r.id
+       GROUP BY n.id, n.kind, n.ref ORDER BY MIN(r.depth), n.kind, n.ref`,
+      [...start, ...kinds, depth]
+    );
+    return rows.map((r) => ({ id: r.id, kind: r.kind, ref: r.ref, depth: int(r.depth) }));
+  }
+  async findNodes(kind, ref) {
+    return this.db.all(`SELECT id, kind, ref, source, project FROM nodes WHERE kind = ? AND (ref = ? OR id = ?) ORDER BY id`, [kind, ref, ref]);
+  }
+  async nodesOfKind(kind, source) {
+    return this.db.all(`SELECT id, kind, ref, source, project FROM nodes WHERE kind = ?${source ? " AND source = ?" : ""} ORDER BY id`, source ? [kind, source] : [kind]);
+  }
+  async resolveFamily(ref, project) {
+    const found = (await this.findNodes("family", ref)).filter((n) => project === void 0 || n.project === project);
+    return found.length > 1 ? { choices: found } : found[0] ?? null;
+  }
+  async resolveRule(ref, project) {
+    const escaped = ref.toLowerCase().replace(/[!%_]/g, "!$&");
+    const found = await this.db.all(
+      `SELECT id, kind, ref, source, project FROM nodes WHERE kind = 'rule' AND (LOWER(ref) = ? OR LOWER(id) = ? OR LOWER(ref) LIKE ? ESCAPE '!')${project === void 0 ? "" : " AND project = ?"} ORDER BY id`,
+      [ref.toLowerCase(), ref.toLowerCase(), `%/rule/${escaped}`, ...project === void 0 ? [] : [project]]
+    );
+    return found.length > 1 ? { choices: found } : found[0] ?? null;
+  }
+  async familyLooks(source, ids, project) {
+    const run = (await this.latestRun(source))?.run;
+    if (!run || ids.length === 0) return /* @__PURE__ */ new Map();
+    const rows = await this.db.all(`SELECT family AS id, COUNT(*) AS looks, MIN(role) AS role FROM looks WHERE run = ? AND family IN (${marks(ids.length)})${project == null ? "" : " AND project = ?"} GROUP BY family`, [run, ...ids, ...project == null ? [] : [project]]);
+    return new Map(rows.map((r) => [r.id, { looks: int(r.looks), role: r.role }]));
+  }
+  async whereUsed(family, options = {}) {
+    const node = await this.resolveFamily(family, options.project);
+    if (!node || "choices" in node) return node;
+    const used = await this.reach([node.id], ["used-in"], { maxDepth: 2 });
+    const near = await this.reach([node.id], ["near-duplicate-of"], { maxDepth: 1 });
+    const info = (await this.familyLooks(node.source, [node.ref], node.project)).get(node.ref);
+    return {
+      family: node.ref,
+      role: info?.role ?? null,
+      looks: info?.looks ?? 0,
+      files: used.filter((n) => n.kind === "file").map((n) => n.ref),
+      routes: used.filter((n) => n.kind === "route").map((n) => n.ref),
+      nearDuplicates: near.filter((n) => n.depth > 0 && n.kind === "family").map((n) => n.ref),
+      source: node.source
+    };
+  }
+  async swapImpact(candidate, family, options = {}) {
+    const node = await this.resolveFamily(family, options.project);
+    if (!node || "choices" in node) return node;
+    const cand = (await this.findNodes("candidate", candidate))[0];
+    const replaces = cand ? await this.reach([cand.id], ["could-replace"], { maxDepth: 1 }) : [];
+    const twins = (await this.reach([node.id], ["near-duplicate-of"], { maxDepth: 4 })).filter((n) => n.kind === "family");
+    const used = await this.reach(twins.map((t) => t.id), ["used-in"], { maxDepth: 2 });
+    const looks = await this.familyLooks(node.source, twins.map((t) => t.ref), node.project);
+    const others = await this.reach([node.id], ["could-replace"], { maxDepth: 1, reverse: true });
+    return {
+      candidate,
+      family: node.ref,
+      listed: replaces.some((n) => n.id === node.id),
+      families: twins.map((t) => ({ id: t.ref, looks: looks.get(t.ref)?.looks ?? 0, depth: t.depth })),
+      looks: twins.reduce((n, t) => n + (looks.get(t.ref)?.looks ?? 0), 0),
+      files: used.filter((n) => n.kind === "file").map((n) => n.ref),
+      routes: used.filter((n) => n.kind === "route").map((n) => n.ref),
+      otherCandidates: others.filter((n) => n.kind === "candidate" && n.ref !== candidate).map((n) => n.ref)
+    };
+  }
+  async ruleCovers(rule, options = {}) {
+    const node = await this.resolveRule(rule, options.project);
+    if (!node || "choices" in node) return node;
+    const reached = await this.reach([node.id], ["governs", "used-in"], { maxDepth: 3 });
+    return {
+      rule: node.ref,
+      components: reached.filter((n) => n.kind === "component").map((n) => n.ref),
+      files: reached.filter((n) => n.kind === "file").map((n) => n.ref),
+      routes: reached.filter((n) => n.kind === "route").map((n) => n.ref)
+    };
+  }
+};
+
+// ../store/src/sqlite.ts
+import { mkdirSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+var STATEMENT_CACHE = 200;
+var sqlite = null;
+function openDatabase(...args) {
+  sqlite ??= createRequire(import.meta.url)("node:sqlite");
+  return new sqlite.DatabaseSync(...args);
+}
+var words = (terms) => searchTerms(terms).map((t) => `"${t.replace(/"/g, "")}"`).join(" OR ");
+function sqliteAdapter(path, options = {}) {
+  if (!options.readOnly && path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+  const db = openDatabase(path, { timeout: 5e3, readOnly: options.readOnly ?? false });
+  if (!options.readOnly) db.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;");
+  const statements = /* @__PURE__ */ new Map();
+  const prepare = (sql) => {
+    let statement = statements.get(sql);
+    if (!statement) {
+      if (statements.size >= STATEMENT_CACHE) statements.delete(statements.keys().next().value);
+      statement = db.prepare(sql);
+      statements.set(sql, statement);
+    }
+    return statement;
+  };
+  const values = (params) => params;
+  return {
+    engine: "sqlite",
+    location: path,
+    json: "TEXT",
+    begin: "BEGIN IMMEDIATE",
+    searchDdl: [
+      // The listing's words, and its scope and source class as tag words (`schosen ccommunity`),
+      // so an unfiltered search ranks inside the index alone. Kept in step by rowid.
+      `CREATE VIRTUAL TABLE IF NOT EXISTS discover_fts USING fts5(search_text, tags, tokenize='porter unicode61')`,
+      `CREATE TRIGGER IF NOT EXISTS discover_items_ai AFTER INSERT ON discover_items BEGIN
+         INSERT INTO discover_fts (rowid, search_text, tags) VALUES (new.rowid, new.search_text, 's' || new.scope || ' c' || new.source_class);
+       END`,
+      `CREATE TRIGGER IF NOT EXISTS discover_items_ad AFTER DELETE ON discover_items BEGIN
+         DELETE FROM discover_fts WHERE rowid = old.rowid;
+       END`,
+      `CREATE TRIGGER IF NOT EXISTS discover_items_au AFTER UPDATE ON discover_items BEGIN
+         DELETE FROM discover_fts WHERE rowid = old.rowid;
+         INSERT INTO discover_fts (rowid, search_text, tags) VALUES (new.rowid, new.search_text, 's' || new.scope || ' c' || new.source_class);
+       END`
+    ],
+    match: (terms) => ({
+      from: `discover_fts JOIN discover_items d ON d.rowid = discover_fts.rowid`,
+      where: searchTerms(terms).length ? `discover_fts MATCH ?` : `0 = 1 AND ? = ?`,
+      whereParams: searchTerms(terms).length ? [`search_text : (${words(terms)})`] : [0, 1],
+      rank: `bm25(discover_fts)`,
+      rankParams: []
+    }),
+    // One query per source class: the tag words narrow it, bm25 ranks only that class's matches, LIMIT keeps the best.
+    top: async (terms, scopes, classes, perClass) => {
+      if (!searchTerms(terms).length) return [];
+      const statement = prepare(`SELECT d.id, d.source_class, d.entry FROM (SELECT rowid AS rid, bm25(discover_fts) AS r FROM discover_fts WHERE discover_fts MATCH ? ORDER BY r LIMIT ?) m JOIN discover_items d ON d.rowid = m.rid ORDER BY m.r, d.id`);
+      const scope = words(scopes.map((s) => `s${s}`));
+      return classes.flatMap((c) => statement.all(`search_text : (${words(terms)}) AND tags : (${scope}) AND tags : ${words([`c${c}`])}`, perClass));
+    },
+    all: async (sql, params = []) => prepare(sql).all(...values(params)),
+    run: async (sql, params = []) => {
+      prepare(sql).run(...values(params));
+    },
+    exec: async (script) => db.exec(script),
+    close: async () => {
+      statements.clear();
+      if (db.isOpen) db.close();
+    }
+  };
+}
+async function openSqlite(path, options = {}) {
+  const connect = async () => {
+    const store = new SqlStore(sqliteAdapter(path, options));
+    try {
+      if (options.readOnly) await store.checkSchema();
+      else await store.migrate();
+      return store;
+    } catch (error) {
+      await store.close();
+      throw error;
+    }
+  };
+  const identity = () => {
+    const s = statSync(path);
+    return `${s.dev}:${s.ino}`;
+  };
+  let inode = null;
+  if (path !== ":memory:") {
+    try {
+      inode = identity();
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  let current = await connect();
+  if (path === ":memory:") return current;
+  inode ??= identity();
+  let generation = await current.meta("generation");
+  let checked = Date.now();
+  let closed = false;
+  const lock = new Lock();
+  return new Proxy(current, {
+    get(_target, key) {
+      const value = Reflect.get(current, key);
+      if (typeof value !== "function") return value;
+      return (...args) => lock.run(async () => {
+        if (key === "close") {
+          closed = true;
+          return current.close();
+        }
+        if (closed) throw new Error("Store is closed");
+        const next = identity();
+        const now = Date.now();
+        const nextGeneration = next === inode && now - checked >= 100 ? await current.meta("generation") : generation;
+        if (next !== inode || nextGeneration !== generation) {
+          await current.close();
+          const openingInode = identity();
+          current = await connect();
+          inode = openingInode;
+          generation = await current.meta("generation");
+        }
+        if (now - checked >= 100) checked = now;
+        return Reflect.apply(Reflect.get(current, key), current, args);
+      });
+    }
+  });
+}
+function checkpointSqlite(path) {
+  const db = openDatabase(path);
+  try {
+    const result = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get();
+    if (Number(result?.busy ?? 0)) throw new Error("Index checkpoint is busy; retry rebuild");
+  } finally {
+    db.close();
+  }
+}
+
+// ../store/src/postgres.ts
+var TRIGRAM_TERMS = 8;
+function postgresAdapter(connection, location) {
+  const adapter = {
+    engine: "postgres",
+    location,
+    json: "JSONB",
+    begin: "BEGIN",
+    trigram: false,
+    searchDdl: [
+      // English stemming like FTS5's porter, but no stop-word list, so no asked-for word is ever dropped.
+      `DO $$ BEGIN
+         IF NOT EXISTS (SELECT 1 FROM pg_ts_dict WHERE dictname = 'youi_stem') THEN
+           CREATE TEXT SEARCH DICTIONARY youi_stem (TEMPLATE = snowball, Language = english);
+         END IF;
+         IF NOT EXISTS (SELECT 1 FROM pg_ts_config WHERE cfgname = 'youi') THEN
+           CREATE TEXT SEARCH CONFIGURATION youi (COPY = simple);
+           ALTER TEXT SEARCH CONFIGURATION youi ALTER MAPPING FOR asciiword, word, numword, asciihword, hword, numhword, hword_asciipart, hword_part, hword_numpart WITH youi_stem;
+         END IF;
+       END $$`,
+      `ALTER TABLE discover_items ADD COLUMN IF NOT EXISTS search_tsv tsvector GENERATED ALWAYS AS (to_tsvector('youi', search_text)) STORED`,
+      `CREATE INDEX IF NOT EXISTS discover_items_search ON discover_items USING GIN (search_tsv)`
+    ],
+    optional: [`CREATE EXTENSION IF NOT EXISTS pg_trgm`, `CREATE INDEX IF NOT EXISTS discover_items_name_trgm ON discover_items USING GIN (name gin_trgm_ops)`],
+    match(terms) {
+      terms = searchTerms(terms);
+      const query = terms.join(" | ");
+      const prefixes = adapter.trigram ? terms.slice(0, TRIGRAM_TERMS).map((t) => `${t}%`) : [];
+      return {
+        from: `discover_items d`,
+        where: prefixes.length ? `(d.search_tsv @@ to_tsquery('youi', ?) OR ${prefixes.map(() => "d.name ILIKE ? ESCAPE '!'").join(" OR ")})` : `d.search_tsv @@ to_tsquery('youi', ?)`,
+        whereParams: [query, ...prefixes],
+        rank: `-ts_rank(d.search_tsv, to_tsquery('youi', ?))`,
+        rankParams: [query]
+      };
+    },
+    all: async (sql, params = []) => (await connection.query(numbered(sql), [...params])).rows,
+    run: async (sql, params = []) => {
+      await connection.query(numbered(sql), [...params]);
+    },
+    exec: (script) => connection.exec(script),
+    close: () => connection.close()
+  };
+  return adapter;
+}
+async function openWith(connection, location, options = {}) {
+  const adapter = postgresAdapter(connection, location);
+  const store = new SqlStore(adapter);
+  try {
+    if (options.readOnly) {
+      await connection.exec("SET default_transaction_read_only = on");
+      await store.checkSchema();
+    } else await store.migrate();
+  } catch (error) {
+    await store.close();
+    throw error;
+  }
+  adapter.trigram = (await adapter.all(`SELECT 1 AS ok FROM pg_extension WHERE extname = 'pg_trgm'`)).length > 0;
+  return store;
+}
+function redactUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) parsed.password = "***";
+    return parsed.toString();
+  } catch {
+    return "postgres://\u2026";
+  }
+}
+async function openPostgres(url, options = {}) {
+  const { default: pg } = await import("pg");
+  const client = new pg.Client({ connectionString: url });
+  await client.connect();
+  return openWith({ query: (sql, params) => client.query(sql, params), exec: async (script) => void await client.query(script), close: () => client.end() }, redactUrl(url), options);
+}
+async function openPglite(dataDir, options = {}) {
+  const { PGlite } = await import("@electric-sql/pglite");
+  const db = dataDir ? new PGlite(dataDir) : new PGlite();
+  await db.waitReady;
+  return openWith({ query: (sql, params) => db.query(sql, params), exec: async (script) => void await db.exec(script), close: () => db.close() }, dataDir ? `pglite:${dataDir}` : "pglite:memory", options);
+}
+
+// ../store/src/open.ts
+import { homedir } from "node:os";
+import { dirname as dirname2, join } from "node:path";
+var INDEX_FILE = "index.db";
+function defaultIndexPath(env = process.env) {
+  if (env.YOUI_INDEX) return env.YOUI_INDEX;
+  return join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "youiyoux", INDEX_FILE);
+}
+function indexHome(path, env = process.env) {
+  return path === ":memory:" ? dirname2(defaultIndexPath(env)) : dirname2(path);
+}
+function storeLocation(options = {}) {
+  const env = options.env ?? process.env;
+  return env.DATABASE_URL ? redactUrl(env.DATABASE_URL) : options.path ?? defaultIndexPath(env);
+}
+async function openStore(options = {}) {
+  const env = options.env ?? process.env;
+  if (env.DATABASE_URL) return openPostgres(env.DATABASE_URL, options);
+  return openSqlite(options.path ?? defaultIndexPath(env), options);
+}
+
+// ../store/src/derive.ts
+var nodeId = {
+  family: (inventory, id, project = "") => `family:${shortHash(inventory)}/${encodeURIComponent(project)}/${id}`,
+  file: (project, file) => `file:${project}:${file}`,
+  route: (project, route) => `route:${project}:${route}`,
+  project: (id) => `project:${id}`,
+  library: (name) => `library:${name}`,
+  candidate: (id) => `candidate:${id}`,
+  rule: (id, project = "") => `rule:${encodeURIComponent(project)}:${id}`,
+  component: (id, project = "") => `component:${encodeURIComponent(project)}:${id}`
+};
+var GraphBuilder = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = /* @__PURE__ */ new Map();
+  node(node) {
+    if (!this.nodes.has(node.id)) this.nodes.set(node.id, node);
+    return node.id;
+  }
+  edge(from, to, kind) {
+    if (from !== to) this.edges.set(`${from}\0${to}\0${kind}`, { from, to, kind });
+  }
+  build() {
+    return { nodes: [...this.nodes.values()], edges: [...this.edges.values()] };
+  }
+};
+var TOLERANCE_KEY = { height: "height", paddingX: "padding", paddingY: "padding", radius: "radius", fontSize: "fontSize", fontWeight: "fontWeight" };
+function nearDuplicatePairs(families, tolerance) {
+  const pairs = [];
+  for (let i = 0; i < families.length; i++) {
+    for (let j = i + 1; j < families.length; j++) {
+      const a = families[i];
+      const b = families[j];
+      if (a.role !== b.role) continue;
+      if (a.kits.length > 0 && b.kits.length > 0 && a.kits.every((k) => b.kits.includes(k)) && b.kits.every((k) => a.kits.includes(k))) continue;
+      let compared = 0;
+      let close = true;
+      for (const dimension of SHAPE_DIMENSIONS) {
+        const x = a.shape[dimension];
+        const y = b.shape[dimension];
+        if (x === null || y === null) continue;
+        compared++;
+        if (Math.abs(x - y) > 2 * tolerance[TOLERANCE_KEY[dimension]]) close = false;
+      }
+      if (close && compared >= 2) pairs.push([a.id, b.id]);
+    }
+  }
+  return pairs;
+}
+function inventoryRun(report, source) {
+  const run = `${report.generatedAt}#${shortHash(`${source}\0${report.generatedAt}`).slice(0, 8)}`;
+  const g = new GraphBuilder();
+  const familyNode = (id, project) => g.node({ id: nodeId.family(source, id, project), kind: "family", ref: id, project });
+  for (const family of report.families) for (const project of family.projects) familyNode(family.id, project);
+  const uses = report.looks.filter((l) => !l.story);
+  for (const look of uses) {
+    if (!look.family) continue;
+    const file = g.node({ id: nodeId.file(look.project, look.file), kind: "file", ref: `${look.project}:${look.file}` });
+    g.edge(familyNode(look.family, look.project), file, "used-in");
+    for (const route of look.routes) g.edge(file, g.node({ id: nodeId.route(look.project, route), kind: "route", ref: `${look.project}:${route}` }), "used-in");
+  }
+  for (const [a, b] of nearDuplicatePairs(report.families, report.tolerance)) {
+    const projects = report.families.find((f) => f.id === a).projects.filter((p) => report.families.find((f) => f.id === b).projects.includes(p));
+    for (const project of projects) {
+      g.edge(familyNode(a, project), familyNode(b, project), "near-duplicate-of");
+      g.edge(familyNode(b, project), familyNode(a, project), "near-duplicate-of");
+    }
+  }
+  for (const primitive of report.primitives) g.edge(g.node({ id: nodeId.project(primitive.project), kind: "project", ref: primitive.project }), g.node({ id: nodeId.library(primitive.package), kind: "library", ref: primitive.package }), "uses-library");
+  for (const kit of report.kits) g.edge(g.node({ id: nodeId.project(kit.project), kind: "project", ref: kit.project }), g.node({ id: nodeId.library(kit.id), kind: "library", ref: kit.id }), "uses-library");
+  const roles = (project) => {
+    const counts = {};
+    for (const look of uses) if (look.project === project) counts[look.role] = (counts[look.role] ?? 0) + 1;
+    return counts;
+  };
+  return {
+    run,
+    source,
+    scannedAt: report.generatedAt,
+    projects: report.projects.map((p) => {
+      const families = report.families.filter((f) => f.projects.includes(p.id));
+      return { project: p.id, root: p.root, commit: p.commit, status: p.status, files: p.files, looks: uses.filter((l) => l.project === p.id).length, families: families.length, nearDuplicates: families.filter((f) => f.nearDuplicate).length, roles: roles(p.id) };
+    }),
+    families: report.families.map((f) => ({ id: f.id, role: f.role, looks: f.looks, nearDuplicate: f.nearDuplicate, projects: f.projects, kits: f.kits, shape: f.shape })),
+    looks: uses.map((l) => ({ id: l.id, project: l.project, role: l.role, file: l.file, line: l.line, column: l.column, tag: l.tag, kit: l.kit, family: l.family, routes: l.routes, shape: l.shape })),
+    graph: g.build()
+  };
+}
+function strings(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.flatMap(strings);
+  if (value && typeof value === "object") return Object.values(value).flatMap(strings);
+  return [];
+}
+function governedComponents(rule, components) {
+  if (rule.severity === "off") return [];
+  if (rule.check.engine === "youi" && (rule.check.id === "prop-values" || rule.check.id === "lookalike-component")) return components.map((c) => c.id);
+  const named = new Set(rule.check.engine === "youi" ? strings(rule.check.options) : []);
+  const words2 = `${rule.title} ${rule.statement} ${rule.agent}`;
+  return components.filter((c) => named.has(c.id) || new RegExp(`(?:^|[^A-Za-z0-9])<?${c.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:$|[^A-Za-z0-9])`).test(words2)).map((c) => c.id);
+}
+function projectGraph(input) {
+  const g = new GraphBuilder();
+  const names = new Map(input.components.map((c) => [c.id, c.name]));
+  const component = (id) => g.node({ id: nodeId.component(id, input.project), kind: "component", ref: names.get(id) ?? id, project: input.project });
+  for (const rule of input.rules) {
+    const node = g.node({ id: nodeId.rule(rule.id, input.project), kind: "rule", ref: rule.id, project: input.project });
+    for (const id of governedComponents(rule, input.components)) g.edge(node, component(id), "governs");
+  }
+  for (const site of input.usage?.usages ?? []) {
+    const file = g.node({ id: nodeId.file(input.project, site.file), kind: "file", ref: `${input.project}:${site.file}` });
+    g.edge(component(site.element), file, "used-in");
+    for (const route of site.routes) g.edge(file, g.node({ id: nodeId.route(input.project, route), kind: "route", ref: `${input.project}:${route}` }), "used-in");
+  }
+  return g.build();
+}
+
+export {
+  searchTerms,
+  numbered,
+  Lock,
+  pageInteger,
+  MIGRATIONS,
+  SCHEMA_VERSION,
+  SqlStore,
+  sqliteAdapter,
+  openSqlite,
+  checkpointSqlite,
+  postgresAdapter,
+  redactUrl,
+  openPostgres,
+  openPglite,
+  INDEX_FILE,
+  defaultIndexPath,
+  indexHome,
+  storeLocation,
+  openStore,
+  nodeId,
+  nearDuplicatePairs,
+  inventoryRun,
+  governedComponents,
+  projectGraph
+};