youiyoux 0.1.10 → 0.1.13

package/dist/chunks/{chunk-6GITMASZ.js → chunk-ZOQW6LNH.js}

@@ -1,14 +1,20 @@
 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 {
+  INDEX_FILE,
+  defaultIndexPath,
+  nodeId,
+  openStore,
+  pageInteger,
+  searchTerms
+} from "./chunk-ZWVWENSB.js";
 import {
   LIBRARY_SOURCE_KINDS,
   LibraryEntry,
-  SHAPE_DIMENSIONS,
   copyleft,
   external_exports,
   sha256,
-  shortHash,
   writeFileAtomic
-} from "./chunk-DWYDHVLZ.js";
+} from "./chunk-NF4OJYKC.js";
 
 // ../discover/src/aliases.ts
 var CONCEPTS = [
@@ -372,852 +378,8 @@ function npmEntry(object, concepts, searchUrl, fetchedAt) {
 
 // ../discover/src/store.ts
 import { readFile, readdir, rm, stat } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
-
-// ../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`
-  ] }
-];
-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 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;
-  }
-  /* ----------------------------------------------------------------- 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);
-}
-
-// ../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();
-}
-
-// ../discover/src/store.ts
+import { join } from "node:path";
 var INDEX_FILE2 = "index.json";
 var ALL_INDEX_FILE = "index-all.json";
 var HEALTH_FILE = "health.json";
@@ -1227,12 +389,12 @@ var BODIES_DIR = "bodies";
 function discoverCacheDir(explicit, env = process.env) {
   if (explicit) return explicit;
   if (env.YOUI_DISCOVER_CACHE) return env.YOUI_DISCOVER_CACHE;
-  return join2(env.XDG_CACHE_HOME || join2(homedir2(), ".cache"), "youiyoux", "discover");
+  return join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "youiyoux", "discover");
 }
 function discoverIndexPath(explicit, env = process.env) {
-  if (explicit) return join2(explicit, INDEX_FILE);
+  if (explicit) return join(explicit, INDEX_FILE);
   if (env.YOUI_INDEX) return env.YOUI_INDEX;
-  if (env.YOUI_DISCOVER_CACHE) return join2(env.YOUI_DISCOVER_CACHE, INDEX_FILE);
+  if (env.YOUI_DISCOVER_CACHE) return join(env.YOUI_DISCOVER_CACHE, INDEX_FILE);
   return defaultIndexPath(env);
 }
 var Iso = external_exports.string().datetime({ offset: true });
@@ -1279,7 +441,7 @@ var MissingIndexError = class extends Error {
   }
 };
 async function readIndex(cacheDir) {
-  const raw = await readJson(join2(cacheDir, INDEX_FILE2));
+  const raw = await readJson(join(cacheDir, INDEX_FILE2));
   if (raw === null) return null;
   const modern = raw.format === 2;
   const index = DiscoverIndex.parse(modern ? raw : cleanData(raw));
@@ -1293,11 +455,11 @@ async function readIndex(cacheDir) {
 }
 var loaded = /* @__PURE__ */ new Map();
 async function readAllIndex(cacheDir) {
-  const raw = await readJson(join2(cacheDir, ALL_INDEX_FILE));
+  const raw = await readJson(join(cacheDir, ALL_INDEX_FILE));
   return raw === null ? null : DiscoverIndex.parse(cleanData(raw));
 }
 async function loadIndex(cacheDir) {
-  const file = join2(cacheDir, INDEX_FILE2);
+  const file = join(cacheDir, INDEX_FILE2);
   const mtimeMs = await stat(file).then((s) => s.mtimeMs, () => null);
   if (mtimeMs === null) throw new MissingIndexError(cacheDir);
   const hit = loaded.get(file);
@@ -1308,14 +470,14 @@ async function loadIndex(cacheDir) {
   return index;
 }
 async function readSignals(cacheDir) {
-  const raw = await readJson(join2(cacheDir, SIGNALS_FILE));
+  const raw = await readJson(join(cacheDir, SIGNALS_FILE));
   return { npm: { ...raw?.npm }, github: { ...raw?.github }, registryRepos: { ...raw?.registryRepos } };
 }
 async function readHttpCache(cacheDir) {
   const cache = /* @__PURE__ */ new Map();
-  const names = await readdir(join2(cacheDir, "listings")).catch(() => []);
+  const names = await readdir(join(cacheDir, "listings")).catch(() => []);
   await Promise.all(names.map(async (name) => {
-    const saved = await readJson(join2(cacheDir, "listings", name));
+    const saved = await readJson(join(cacheDir, "listings", name));
     if (saved?.version !== 2 || typeof saved.url !== "string" || saved.data === void 0) return;
     const body = JSON.stringify(saved.data);
     cache.set(saved.url, { ...saved, body, sha256: sha256(body) });
@@ -1374,26 +536,26 @@ async function writeHttpCache(cacheDir, cache) {
       continue;
     }
     keep.add(`${sha256(url)}.json`);
-    await writeJson(join2(cacheDir, "listings", `${sha256(url)}.json`), { version: 2, url, etag: entry.etag, lastModified: entry.lastModified, fetchedAt: entry.fetchedAt, data });
+    await writeJson(join(cacheDir, "listings", `${sha256(url)}.json`), { version: 2, url, etag: entry.etag, lastModified: entry.lastModified, fetchedAt: entry.fetchedAt, data });
   }
-  for (const name of await readdir(join2(cacheDir, "listings")).catch(() => [])) if (!keep.has(name)) await rm(join2(cacheDir, "listings", name), { force: true });
-  await rm(join2(cacheDir, BODIES_DIR), { recursive: true, force: true });
-  await rm(join2(cacheDir, HTTP_FILE), { force: true });
+  for (const name of await readdir(join(cacheDir, "listings")).catch(() => [])) if (!keep.has(name)) await rm(join(cacheDir, "listings", name), { force: true });
+  await rm(join(cacheDir, BODIES_DIR), { recursive: true, force: true });
+  await rm(join(cacheDir, HTTP_FILE), { force: true });
 }
 async function readSources(cacheDir) {
-  const value = await readJson(join2(cacheDir, "sources.json"));
+  const value = await readJson(join(cacheDir, "sources.json"));
   return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [...CURATED];
 }
 async function writeSources(cacheDir, names) {
-  await writeJson(join2(cacheDir, "sources.json"), [...new Set(names)].sort());
+  await writeJson(join(cacheDir, "sources.json"), [...new Set(names)].sort());
 }
 async function catalogBytes(cacheDir) {
   const files = await readdir(cacheDir, { recursive: true, withFileTypes: true });
-  const sizes = await Promise.all(files.filter((f) => f.isFile() && !f.parentPath.includes(join2(cacheDir, "source")) && !f.name.startsWith(INDEX_FILE)).map((f) => stat(join2(f.parentPath, f.name)).then((s) => s.size)));
+  const sizes = await Promise.all(files.filter((f) => f.isFile() && !f.parentPath.includes(join(cacheDir, "source")) && !f.name.startsWith(INDEX_FILE)).map((f) => stat(join(f.parentPath, f.name)).then((s) => s.size)));
   return sizes.reduce((a, b) => a + b, 0);
 }
 async function readHealth(cacheDir) {
-  return await readJson(join2(cacheDir, HEALTH_FILE));
+  return await readJson(join(cacheDir, HEALTH_FILE));
 }
 
 // ../discover/src/http.ts
@@ -2016,7 +1178,7 @@ function applySignals(entry, signals) {
 }
 
 // ../discover/src/sync.ts
-import { join as join3 } from "node:path";
+import { join as join2 } from "node:path";
 function status(id, url, result, items, health = null) {
   if (!result.ok) return { id, url, outcome: "failed", reason: result.reason === "http" ? result.message : `${result.reason}: ${result.message}`, httpStatus: result.status, items: 0, health };
   return { id, url, outcome: result.result.revalidated ? "revalidated" : "fetched", reason: null, httpStatus: result.result.status, items, health };
@@ -2120,7 +1282,7 @@ async function syncIndex(options) {
   } else sources.push(official.ok ? { id: "shadcn", url: SHADCN.registry, outcome: "failed", reason: "not a registry", httpStatus: official.result.status, items: 0, health: null } : status("shadcn", SHADCN.registry, official, 0));
   const listed = directory2.ok ? parseDirectory(directory2.value).registries : [];
   sources.push(status("directory", SHADCN.directory, directory2, listed.length));
-  await writeJson(join3(options.cacheDir, "directory.json"), listed);
+  await writeJson(join2(options.cacheDir, "directory.json"), listed);
   const selected = await readSources(options.cacheDir);
   const toFetch = [];
   const previousHealth = await readHealth(options.cacheDir);
@@ -2184,10 +1346,10 @@ async function syncIndex(options) {
   const { signals, report } = await refreshSignals(unique, homes, await readSignals(options.cacheDir), client, now(), { ...defaultBudgets(Boolean(options.token)), ...options.budgets });
   const final = unique.map((entry) => applySignals(entry, signals)).filter((entry) => LibraryEntry.safeParse(entry).success);
   const index = cleanData({ schema: "youi.discover-index/v1", format: 2, builtAt, sources, categories: Object.fromEntries(categories), entries: final });
-  await writeJson(join3(options.cacheDir, SIGNALS_FILE), signals);
-  await writeJson(join3(options.cacheDir, HEALTH_FILE), cleanData({ checkedAt: builtAt, sources }));
+  await writeJson(join2(options.cacheDir, SIGNALS_FILE), signals);
+  await writeJson(join2(options.cacheDir, HEALTH_FILE), cleanData({ checkedAt: builtAt, sources }));
   await writeHttpCache(options.cacheDir, client.cache);
-  await writeJson(join3(options.cacheDir, INDEX_FILE2), index);
+  await writeJson(join2(options.cacheDir, INDEX_FILE2), index);
   const registryStatuses = sources.filter((s) => s.health !== null);
   const known = final.filter((e) => e.license && e.license !== "unknown").length;
   return cleanData({
@@ -2211,9 +1373,9 @@ async function syncIndex(options) {
 
 // ../discover/src/on-demand.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join3 } from "node:path";
 async function directory(cacheDir) {
-  return JSON.parse(await readFile2(join4(cacheDir, "directory.json"), "utf8"));
+  return JSON.parse(await readFile2(join3(cacheDir, "directory.json"), "utf8"));
 }
 async function selectSources(cacheDir, action = "list", name) {
   const selected = await readSources(cacheDir);
@@ -2250,7 +1412,7 @@ async function expandAll(cacheDir, options = {}) {
   const entries = dedupe([...index.entries, ...extra.flat()]).entries.filter((e) => !chosen.has(e.id));
   const next = `${JSON.stringify(cleanData({ schema: index.schema, format: 2, builtAt: index.builtAt, sources: [], categories: index.categories, entries }))}
 `;
-  if (await readFile2(join4(cacheDir, ALL_INDEX_FILE), "utf8").catch(() => null) !== next) await writeFileAtomic(join4(cacheDir, ALL_INDEX_FILE), next);
+  if (await readFile2(join3(cacheDir, ALL_INDEX_FILE), "utf8").catch(() => null) !== next) await writeFileAtomic(join3(cacheDir, ALL_INDEX_FILE), next);
 }
 async function findListing(cacheDir, id) {
   try {
@@ -2275,7 +1437,7 @@ async function candidateSource(cacheDir, id, options = {}) {
   const template = registry === SHADCN.name ? "https://ui.shadcn.com/r/styles/new-york-v4/{name}.json" : (await directory(cacheDir)).find((r) => r.name === registry)?.template;
   if (!template) throw new Error("Registry URL is unavailable; run youiyoux discover sync");
   const url = registryUrl(template, name);
-  const file = join4(cacheDir, "source", `${sha256(url)}.json`);
+  const file = join3(cacheDir, "source", `${sha256(url)}.json`);
   try {
     return JSON.parse(await readFile2(file, "utf8"));
   } catch {
@@ -2292,7 +1454,7 @@ async function candidateSource(cacheDir, id, options = {}) {
 
 // ../discover/src/catalog.ts
 import { stat as stat2 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { join as join4 } from "node:path";
 var CANDIDATES_PER_CLASS = 400;
 var LINKS_PER_ROLE = 10;
 var FINGERPRINT = "discover.fingerprint";
@@ -2336,7 +1498,7 @@ function itemOf(entry, scope, builtAt) {
   };
 }
 async function fingerprint(cacheDir, file) {
-  const at = await stat2(join5(cacheDir, file)).then((s) => `${s.size}:${Math.round(s.mtimeMs)}`, () => "-");
+  const at = await stat2(join4(cacheDir, file)).then((s) => `${s.size}:${Math.round(s.mtimeMs)}`, () => "-");
   return JSON.stringify([cacheDir, at]);
 }
 function signalRows(signals) {
@@ -2382,7 +1544,7 @@ async function closeSharedStores() {
   await Promise.all(stores.map(async (s) => (await s.catch(() => null))?.close()));
 }
 async function openCatalog(cacheDir, path, env = process.env) {
-  if (!await stat2(join5(cacheDir, INDEX_FILE2)).then((s) => s.isFile(), () => false)) throw new MissingIndexError(cacheDir);
+  if (!await stat2(join4(cacheDir, INDEX_FILE2)).then((s) => s.isFile(), () => false)) throw new MissingIndexError(cacheDir);
   const store = await sharedStore(path, env);
   const key = `${path}\0${cacheDir}`;
   while (refreshing.has(key)) await refreshing.get(key);
@@ -2426,9 +1588,9 @@ function needTerms(need) {
   const read = readNeed(cleanText(need));
   const phrases = [...read.concepts.flatMap((c) => [...c.names, ...c.packages]), ...read.words].map(normalize);
   return searchTerms(phrases.flatMap((phrase) => {
-    const words2 = phrase.split(" ").filter(Boolean);
-    const specific = words2.filter((w) => !GENERIC.has(w));
-    return specific.length ? specific : words2;
+    const words = phrase.split(" ").filter(Boolean);
+    const specific = words.filter((w) => !GENERIC.has(w));
+    return specific.length ? specific : words;
   }));
 }
 async function searchCatalog(store, need, options = {}) {
@@ -2494,7 +1656,7 @@ async function linkCandidates(store) {
 
 // ../discover/src/preview.ts
 import { lstat, rm as rm2 } from "node:fs/promises";
-import { join as join6, posix } from "node:path";
+import { join as join5, posix } from "node:path";
 var PREVIEW_DIR = "preview";
 var MAX_FETCHED_PARTS = 3;
 function safeRelative(path) {
@@ -2508,7 +1670,7 @@ function safeRelative(path) {
 async function assertNoLinks(base, rel) {
   let at = base;
   for (const part of ["", ...rel.split("/")]) {
-    at = part ? join6(at, part) : at;
+    at = part ? join5(at, part) : at;
     const info = await lstat(at).catch(() => null);
     if (!info) return;
     if (info.isSymbolicLink()) throw new Error(`refused: ${rel} leads through a symlink in the preview cache`);
@@ -2519,8 +1681,8 @@ function exportNames(source) {
   for (const match of source.matchAll(/\bexport\s+(?:declare\s+)?(?:async\s+)?(?:function\*?|const|let|var|class)\s+([A-Za-z_$][\w$]*)/g)) names.add(match[1]);
   for (const match of source.matchAll(/\bexport\s+(?!type\b)\{([^}]*)\}(?!\s*from)/g)) {
     for (const item of match[1].split(",")) {
-      const words2 = item.trim().split(/\s+/).filter((w) => w !== "type");
-      const name = words2.length >= 3 && words2[1] === "as" ? words2[2] : words2[0];
+      const words = item.trim().split(/\s+/).filter((w) => w !== "type");
+      const name = words.length >= 3 && words[1] === "as" ? words[2] : words[0];
       if (name && /^[A-Za-z_$][\w$]*$/.test(name) && !/^type\s/.test(item.trim())) names.add(name);
     }
   }
@@ -2536,8 +1698,8 @@ function importedNames(source, spec) {
     if (/\*\s+as\s+/.test(clause)) names.push("*");
     const braces = /\{([^}]*)\}/.exec(clause);
     if (braces) for (const item of braces[1].split(",")) {
-      const words2 = item.trim().split(/\s+/).filter((w) => w && w !== "type");
-      if (words2[0]) names.push(words2[0]);
+      const words = item.trim().split(/\s+/).filter((w) => w && w !== "type");
+      if (words[0]) names.push(words[0]);
     }
     const head = clause.replace(/\{[^}]*\}/, "").replace(/\*\s+as\s+\w+/, "").replace(/,/g, " ").trim();
     if (head && head !== "type") names.push("default");
@@ -2559,8 +1721,8 @@ async function preparePreview(cacheDir, id, options = {}) {
   const registry = ref.slice(0, ref.indexOf("/"));
   const source = await candidateSource(cacheDir, id, options);
   const key = sha256(source.url).slice(0, 16);
-  const root = join6(cacheDir, PREVIEW_DIR);
-  const dir = join6(root, key);
+  const root = join5(cacheDir, PREVIEW_DIR);
+  const dir = join5(root, key);
   await assertNoLinks(cacheDir, `${PREVIEW_DIR}/${key}`);
   await rm2(dir, { recursive: true, force: true });
   const texts = /* @__PURE__ */ new Map();
@@ -2641,7 +1803,7 @@ async function preparePreview(cacheDir, id, options = {}) {
   }
   for (const [file, text] of rewritten) {
     await assertNoLinks(dir, file);
-    await writeFileAtomic(join6(dir, file), text);
+    await writeFileAtomic(join5(dir, file), text);
   }
   const packages = [...new Set([...rewritten.values()].flatMap((t) => importedPackages(t)))].sort();
   const declared = [...new Set([...source.dependencies ?? entry.install?.npm ?? [], ...partDeps].map(packageName))].sort();
@@ -2665,17 +1827,17 @@ async function preparePreview(cacheDir, id, options = {}) {
 
 // ../discover/src/gaps.ts
 import { existsSync, readFileSync } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join6 } from "node:path";
 var STANDARD_KIT = ["button", "input", "card", "badge", "dialog", "alert", "drawer", "menu", "popover", "tooltip", "tabs", "avatar", "accordion", "table", "carousel", "slider", "switch", "checkbox", "radio", "select", "otp", "progress", "skeleton", "spinner", "sidebar", "navigation", "breadcrumb", "pagination", "command", "toast", "date-picker", "combobox", "chart"];
 var ONLY_EXACT = /* @__PURE__ */ new Set(["hint", "tile", "range", "loading", "picker", "tree", "graph", "plot", "editor", "cta", "notice", "steps", "tag", "toggle", "meter", "command", "banner", "popup", "pager", "loader", "navigation", "chip", "pill"]);
 var ROLE_CONCEPT2 = { button: "button", "link-as-button": "button", input: "input", card: "card", badge: "badge", dialog: "dialog", tabs: "tabs" };
 var CANDIDATES = 3;
 var DEFINITIONS_SHOWN = 5;
 function conceptOfName(name) {
-  const words2 = normalize(name.replace(/\.[a-z]+$/, ""));
-  if (!words2) return void 0;
+  const words = normalize(name.replace(/\.[a-z]+$/, ""));
+  if (!words) return void 0;
   const phrases = CONCEPTS.flatMap((concept) => concept.names.map((n) => ({ concept, name: normalize(n) }))).sort((a, b) => b.name.length - a.name.length);
-  return phrases.find((p) => words2 === p.name || !ONLY_EXACT.has(p.name) && ` ${words2}`.endsWith(` ${p.name}`))?.concept;
+  return phrases.find((p) => words === p.name || !ONLY_EXACT.has(p.name) && ` ${words}`.endsWith(` ${p.name}`))?.concept;
 }
 function conceptOfPackage(pkg) {
   const listed = CONCEPTS.find((c) => c.packages.includes(pkg));
@@ -2686,7 +1848,7 @@ function conceptOfPackage(pkg) {
 function declaredPackages(roots) {
   const found = {};
   for (const [id, root] of roots) {
-    const file = join7(root, "package.json");
+    const file = join6(root, "package.json");
     if (!existsSync(file)) continue;
     try {
       const pkg = JSON.parse(readFileSync(file, "utf8"));
@@ -2827,12 +1989,6 @@ export {
   MIN_WEEKLY_DOWNLOADS,
   npmCandidates,
   npmEntry,
-  openSqlite,
-  checkpointSqlite,
-  indexHome,
-  storeLocation,
-  inventoryRun,
-  projectGraph,
   INDEX_FILE2 as INDEX_FILE,
   ALL_INDEX_FILE,
   HEALTH_FILE,