youiyoux 0.1.2 → 0.1.4

package/dist/hub-snapshot.js

@@ -0,0 +1,573 @@
+#!/usr/bin/env node
+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 {
+  loadPackage,
+  tryProject
+} from "./chunks/chunk-XAEMVEYX.js";
+import "./chunks/chunk-FVVL5JCY.js";
+import "./chunks/chunk-WNTS7ZO4.js";
+
+// ../../apps/web/scripts/snapshot.ts
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { parseArgs } from "node:util";
+
+// ../../apps/web/src/data/inventory.ts
+var ROLES = ["button", "link-as-button", "input", "card", "badge", "dialog", "tabs"];
+
+// ../../apps/web/src/data/inventory-split.ts
+var json = (value) => `${JSON.stringify(value)}
+`;
+var stemOf = (id) => id.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+function splitInventory(report, specimens, name) {
+  const files = [];
+  const add = (stem, ext, text) => {
+    const file = name(stem, ext, text);
+    files.push({ name: file, text });
+    return file;
+  };
+  const projects = report.projects.map((p) => {
+    const built = specimens[p.id];
+    const specimenCss = built?.css ? { light: add(`specimens.${stemOf(p.id)}.light`, "css", built.css.light), dark: add(`specimens.${stemOf(p.id)}.dark`, "css", built.css.dark) } : null;
+    return { id: p.id, root: p.root, commit: p.commit, status: p.status, files: p.files, routes: p.routes, failed: p.failed.length, warnings: p.warnings, specimenCss, specimenNotes: built?.notes ?? ["no specimens were built: looks show their shape"] };
+  });
+  const roles = ROLES.flatMap((role) => {
+    const all = report.looks.filter((l) => l.role === role);
+    if (all.length === 0) return [];
+    const looks = all.filter((l) => !l.story);
+    const families = report.families.filter((f) => f.role === role);
+    const cells = {};
+    const chunks = {};
+    for (const project of report.projects) {
+      const mine = all.filter((l) => l.project === project.id);
+      const used = mine.filter((l) => !l.story);
+      cells[project.id] = { families: new Set(mine.flatMap((l) => l.family ? [l.family] : [])).size, looks: used.length };
+      if (mine.length === 0) continue;
+      const built = specimens[project.id];
+      const drawn = {};
+      const chunkLooks = mine.map((l) => {
+        const id = built?.looks[l.id];
+        const specimen = id ? built.specimens[id] : void 0;
+        if (id && specimen) drawn[id] = specimen;
+        return { id: l.id, file: l.file, line: l.line, column: l.column, tag: l.tag, kit: l.kit, family: l.family, shape: l.shape, specimen: id && specimen ? id : null, ...l.story ? { story: l.story } : {} };
+      });
+      const chunk = { schema: "youiyoux.inventory-chunk/v1", project: project.id, role, families: families.filter((f) => f.projects.includes(project.id)), looks: chunkLooks, specimens: drawn };
+      chunks[project.id] = add(`inventory.${stemOf(project.id)}.${role}`, "json", json(chunk));
+    }
+    return [{ role, looks: looks.length, unshaped: looks.filter((l) => l.family === null).length, families: families.length, shared: families.filter((f) => f.nearDuplicate && f.projects.length > 1).length, cells, chunks }];
+  });
+  const extras = { schema: "youiyoux.inventory-extras/v1", kits: report.kits, primitives: report.primitives, flags: report.flags };
+  const index = {
+    schema: "youiyoux.inventory-index/v1",
+    scanner: report.scanner,
+    generatedAt: report.generatedAt,
+    tolerance: report.tolerance,
+    projects,
+    // Families only stories have are drawn, but not counted among the families built.
+    summary: { ...report.summary, families: report.families.filter((f) => !f.authored).length, nearDuplicates: report.families.filter((f) => f.nearDuplicate).length, flags: report.flags.length },
+    roles,
+    extras: add("inventory.extras", "json", json(extras))
+  };
+  return { index, files };
+}
+
+// ../../apps/web/src/data/usage.ts
+var EVERY_SCREEN = "*";
+var UNROUTED = "(no screen)";
+
+// ../../apps/web/src/data/screens.ts
+function screenSlug(route) {
+  if (route === EVERY_SCREEN) return "app-shell";
+  if (route === UNROUTED) return "unrouted";
+  const slug = route.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "root";
+}
+
+// ../../apps/web/scripts/snapshot.ts
+var APP = resolve(__youiDirname, "..");
+var TOOL = resolve(APP, "../..");
+var DEFAULT_OUT = join(APP, "snapshot");
+var DEMO_PROJECT = join(TOOL, "examples/demo-app");
+var DEMO_INVENTORY = ["console", "site"].map((name) => join(TOOL, "packages/scanner/test/fixtures/inventory", name));
+var STYLES_DIR = join(APP, "src/styles/generated");
+var HASH_LENGTH = 10;
+var HUB_PREFIX = "yx";
+var SCOPE = ".system-scope";
+var STAGE = ["color.paper", "color.surface", "color.background"];
+var INK = ["color.ink", "color.foreground", "color.text"];
+var HUB_TAILWIND_MAP = {
+  ...Object.fromEntries(["xs", "sm", "md", "lg", "xl", "full"].map((size) => [`radius-${size}`, `radius.${size}`])),
+  "font-sans": "font.sans",
+  "font-mono": "font.mono",
+  "ease-out": "easing.out"
+};
+var loadOptions = (values) => ({ ...values.config ? { configPath: resolve(values.config) } : {}, ...values.design ? { designRoot: resolve(values.design) } : {}, ...values.root !== void 0 ? { productRoot: resolve(values.root) } : {} });
+var hash = (content) => createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH);
+var json2 = (value) => `${JSON.stringify(value)}
+`;
+var generated = (what) => `/* @generated by apps/web/scripts/snapshot.ts from ${what}. Do not edit: run \`pnpm data\`. */
+`;
+function write(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content);
+}
+function definitionsCommit(root, paths) {
+  try {
+    const sha = execFileSync("git", ["-C", root, "log", "-1", "--format=%H", "--", ...paths], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return sha || null;
+  } catch {
+    return null;
+  }
+}
+function aliasChain(token, byId) {
+  const chain = [token.id];
+  let next = token.aliasOf;
+  while (next && !chain.includes(next)) {
+    chain.push(next);
+    next = byId.get(next)?.aliasOf;
+  }
+  return chain;
+}
+function catalogTokens(system, prefix, tokens, darkOwn, lib) {
+  const byId = new Map(tokens.map((t) => [t.id, t]));
+  const elementId = (path) => `youi:${system}/token/${path}`;
+  return tokens.map((token) => ({
+    id: elementId(token.id),
+    path: token.id,
+    group: token.id.split(".")[0],
+    type: token.type,
+    cssVar: `--${prefix}-${token.cssName}`,
+    light: lib.cssValue(token.type, token.light),
+    dark: lib.cssValue(token.type, token.dark),
+    ...token.type === "typography" ? { lightValue: token.light } : {},
+    aliasChain: aliasChain(token, byId).map(elementId),
+    ...token.description ? { description: token.description } : {},
+    // What the style editor starts from: the values as written (aliases kept) and whether dark has its own.
+    ...token.source ? { source: token.source } : {},
+    darkOwn: darkOwn.has(token.id)
+  }));
+}
+function darkOverrides(repoRoot, config, core, lib) {
+  if (!config.themeModifier) return /* @__PURE__ */ new Set();
+  const resolverFile = join(repoRoot, config.tokens);
+  const layout = lib.resolverLayout(JSON.parse(readFileSync(resolverFile, "utf8")), config.themeModifier);
+  const files = layout.contexts[config.themeModifier.dark] ?? [];
+  return new Set(files.flatMap((ref) => core.flattenTokens({ file: ref, document: JSON.parse(readFileSync(join(dirname(resolverFile), ref), "utf8")) }).map((t) => t.path)));
+}
+function componentFiles(componentsRoot, sourceFile, support) {
+  return [sourceFile, ...support].map((file) => ({ path: basename(file), code: readFileSync(join(componentsRoot, file), "utf8") }));
+}
+function systemCss(name, tokens, contracts, output, lib) {
+  const prefix = output.cssVarPrefix;
+  const byId = new Map(tokens.map((t) => [t.id, t]));
+  const variable = (paths) => {
+    const token = paths.map((p) => byId.get(p)).find(Boolean);
+    return token ? `var(--${prefix}-${token.cssName})` : null;
+  };
+  const ref = (path, suffix = "") => `var(--${prefix}-${byId.get(path)?.cssName ?? path.replace(/\./g, "-")}${suffix})`;
+  const decl = (scheme) => tokens.flatMap((t) => lib.tokenVariables(t.type, t.source?.[scheme] ?? t[scheme], ref).map(([suffix, css]) => `  --${prefix}-${t.cssName}${suffix}: ${css};`)).join("\n");
+  const states = lib.stateVariables(contracts, tokens, prefix).map(([property, css]) => `  ${property}: ${css};`).join("\n");
+  const stage = [variable(STAGE) && `  background: ${variable(STAGE)};`, variable(INK) && `  color: ${variable(INK)};`].filter(Boolean).join("\n");
+  const theme = lib.renderTailwind(tokens, output, "").trim();
+  return `${generated(`the ${name} tokens`)}@source "./components";
+
+${SCOPE} {
+  color-scheme: light;
+${decl("light")}
+${states ? `${states}
+` : ""}${stage}
+}
+
+${SCOPE}[data-scheme="dark"] {
+  color-scheme: dark;
+${decl("dark")}
+}
+
+${theme}
+`;
+}
+async function buildHubTokens(core, lib) {
+  const system = core.SystemConfig.parse({
+    id: "youiyoux",
+    name: "YouIyouX",
+    version: "0.1.0",
+    description: "The hub's own design language.",
+    tokens: "design/youiyoux.resolver.json",
+    themeModifier: { name: "theme", light: "light", dark: "dark" }
+  });
+  const output = core.OutputConfig.parse({ cssVarPrefix: HUB_PREFIX, targets: ["css-vars", "tailwind-v4"], tailwind: { includeAll: true, map: HUB_TAILWIND_MAP } });
+  const built = await lib.buildTokens(APP, system, output);
+  rmSync(STYLES_DIR, { recursive: true, force: true });
+  for (const file of built.files) write(join(STYLES_DIR, file.path), file.content);
+}
+function projectArg(values) {
+  if (values.project) return values.project;
+  if (values.config) return values.root !== void 0 ? dirname(resolve(values.config)) : void 0;
+  return values.design ? void 0 : DEMO_PROJECT;
+}
+async function readSource(values, core, scanner) {
+  const projectDir = projectArg(values);
+  if (projectDir) {
+    const project = await scanner.loadProject(projectDir, loadOptions(values));
+    const { report } = await scanner.scanProject(project);
+    return { designRoot: project.repo.root, projectDir: project.root, systemId: project.config.system, output: project.config.outputs, usage: core.ScanReport.parse(report) };
+  }
+  if (values.config) {
+    const configFile = resolve(values.config);
+    const config = core.ProjectConfig.parse(JSON.parse(readFileSync(configFile, "utf8")));
+    const designRoot = values.design ? resolve(values.design) : isAbsolute(config.source.path) ? config.source.path : resolve(dirname(configFile), config.source.path);
+    return { designRoot, systemId: config.system, output: config.outputs, usage: null };
+  }
+  return { designRoot: resolve(values.design), output: core.OutputConfig.parse({}), usage: null };
+}
+function writePreview(out, system, componentsRoot) {
+  const header = (from) => `// @generated from ${from} by apps/web/scripts/snapshot.ts. Do not edit.
+`;
+  const files = /* @__PURE__ */ new Set([...system.components.map((c) => c.contract.source.file), ...system.config.support]);
+  for (const file of files) write(join(out, "components", basename(file)), `${header(`components/${file}`)}${readFileSync(join(componentsRoot, file), "utf8")}`);
+  let demos = 0;
+  for (const { dir } of system.components) {
+    for (const name of readdirSync(dir).filter((f) => f.endsWith(".demo.tsx"))) {
+      write(join(out, "components", name), `${header(relative(componentsRoot, join(dir, name)))}${readFileSync(join(dir, name), "utf8")}`);
+      demos++;
+    }
+  }
+  return demos;
+}
+function readScreensFile(dir, project) {
+  const path = join(dir, "screens.json");
+  const value = JSON.parse(readFileSync(path, "utf8"));
+  const valid = value.schema === "youiyoux.screens/v1" && value.project === project && typeof value.source === "string" && typeof value.capturedAt === "string" && typeof value.viewport?.width === "number" && typeof value.viewport.height === "number" && Array.isArray(value.screens) && value.screens.every((s) => typeof s.route === "string" && typeof s.path === "string");
+  if (!valid) throw new Error(`${path} is not a youiyoux.screens/v1 document for ${project}`);
+  return value;
+}
+function copyShot(dir, dataDir, project, slug, variant) {
+  const source = join(dir, `${slug}.${variant}.webp`);
+  if (!existsSync(source)) return null;
+  const bytes = readFileSync(source);
+  const file = `${project}.screen.${hash(bytes)}.webp`;
+  write(join(dataDir, file), bytes);
+  return file;
+}
+function copyPlaces(dir, dataDir, project, slug) {
+  const source = join(dir, `${slug}.places.json`);
+  if (!existsSync(source)) return null;
+  const bytes = readFileSync(source);
+  try {
+    if (JSON.parse(bytes.toString("utf8")).schema !== "youiyoux.places/v1") return null;
+  } catch {
+    return null;
+  }
+  const file = `${project}.places.${hash(bytes)}.json`;
+  write(join(dataDir, file), bytes);
+  return file;
+}
+function writeScreens(dir, dataDir, project) {
+  const file = readScreensFile(dir, project);
+  const screens = file.screens.map((screen) => {
+    const slug = screenSlug(screen.route);
+    const schemes = Object.fromEntries(
+      ["light", "dark"].flatMap((scheme) => {
+        const full = copyShot(dir, dataDir, project, slug, scheme);
+        const thumb = copyShot(dir, dataDir, project, slug, `${scheme}.thumb`);
+        return full && thumb ? [[scheme, { full, thumb }]] : [];
+      })
+    );
+    const places = copyPlaces(dir, dataDir, project, slug);
+    return { route: screen.route, path: screen.path, ...screen.note ? { note: screen.note } : {}, ...schemes, ...places ? { places } : {} };
+  });
+  return { source: file.source, capturedAt: file.capturedAt, viewport: file.viewport, screens };
+}
+function screensDir(explicit, projectDir) {
+  if (explicit) return resolve(explicit);
+  const conventional = projectDir ? join(projectDir, ".youi/screens") : null;
+  return conventional && existsSync(join(conventional, "screens.json")) ? conventional : null;
+}
+function previousSystemId(dataDir) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(dataDir, "manifest.json"), "utf8"));
+    return manifest.systems?.[0]?.id;
+  } catch {
+    return void 0;
+  }
+}
+function dropPreviewsOfOtherSystem(out, previousId, systemId) {
+  if (previousId !== systemId) rmSync(join(out, "public/previews"), { recursive: true, force: true });
+}
+async function writeSystem(out, designRoot, systemId, output, commitOverride, { core, lib, scanner }) {
+  const repo = await core.loadDesignRepo(designRoot);
+  const system = core.getSystem(repo, systemId);
+  const { config } = system;
+  const built = await lib.buildTokens(repo.root, config, output);
+  const componentsRoot = join(repo.root, config.components);
+  const catalog = {
+    schema: "youiyoux.catalog/v1",
+    system: {
+      id: config.id,
+      name: config.name,
+      version: config.version,
+      description: config.description,
+      cssPrefix: output.cssVarPrefix,
+      design: config.design ? readFileSync(join(repo.root, config.design), "utf8") : ""
+    },
+    tokens: catalogTokens(config.id, output.cssVarPrefix, built.tokens, darkOverrides(repo.root, config, core, lib), lib),
+    components: system.components.map(({ contract }) => ({ contract, files: componentFiles(componentsRoot, contract.source.file, config.support) })),
+    // Each rule with how youiyoux check executes it, so the hub never shows an uncompilable rule as enforced.
+    rules: system.rules.map((rule) => ({ ...rule, execution: scanner.ruleCapability(rule) }))
+  };
+  const catalogText = json2(catalog);
+  const catalogFile = `${config.id}.catalog.${hash(catalogText)}.json`;
+  write(join(out, "public/data", catalogFile), catalogText);
+  const previewDir = join(out, "preview");
+  rmSync(previewDir, { recursive: true, force: true });
+  write(join(previewDir, "system.css"), systemCss(config.name, built.tokens, system.components.map((c) => c.contract), output, lib));
+  const demos = writePreview(previewDir, system, componentsRoot);
+  const commit = commitOverride ?? definitionsCommit(repo.root, ["youi.config.json", dirname(config.tokens), config.components, config.rules, ...config.design ? [config.design] : []]);
+  const summary = `${config.name} from ${repo.root} @ ${commit ?? "unknown"}: ${catalog.tokens.length} tokens, ${catalog.components.length} components (${demos} demos), ${catalog.rules.length} rules`;
+  return { id: config.id, name: config.name, components: system.components.map((c) => c.contract.name), catalogFile, commit, summary };
+}
+function writeUsage(dataDir, report, screens) {
+  const text = json2(report);
+  const file = `${report.project}.usage.${hash(text)}.json`;
+  write(join(dataDir, file), text);
+  return { project: report.project, file, ...screens ? { screens } : {} };
+}
+function writeInventory(dataDir, inventory, specimens = {}) {
+  const { index, files } = splitInventory(inventory, specimens, (stem, ext, text2) => `${stem}.${hash(text2)}.${ext}`);
+  for (const f of files) write(join(dataDir, f.name), f.text);
+  const text = json2(index);
+  const file = `inventory.${hash(text)}.json`;
+  write(join(dataDir, file), text);
+  return { file, files: files.map((f) => f.name) };
+}
+function inventoryRoots(inventory, path) {
+  const bases = path ? [process.cwd(), dirname(resolve(path))] : [TOOL];
+  const roots = /* @__PURE__ */ new Map();
+  for (const project of inventory.projects) {
+    const root = bases.map((base) => resolve(base, project.root)).find((dir) => existsSync(join(dir, "package.json")));
+    if (root) roots.set(project.id, root);
+  }
+  return roots;
+}
+function configuredSpecimenCss(values, core) {
+  if (!values.config) return null;
+  const configFile = resolve(values.config);
+  const config = core.ProjectConfig.parse(JSON.parse(readFileSync(configFile, "utf8")));
+  const sheets = config.specimens?.css;
+  if (!sheets?.length) return null;
+  const root = values.root !== void 0 ? resolve(values.root || ".") : config.root ? resolve(dirname(configFile), config.root) : dirname(configFile);
+  return { root, sheets, from: configFile };
+}
+var realOr = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+};
+function sheetReport(id, used, skipped = []) {
+  const left = skipped.map((line) => `  ${line}`);
+  if (used.length === 0) return [`specimens ${id}: no stylesheet`, ...left];
+  return [`specimens ${id}: ${used.length} stylesheet${used.length === 1 ? "" : "s"}, in page order`, ...used.map((line, i) => `  ${i + 1}. ${line}`), ...left];
+}
+async function buildSpecimens(inventory, roots, scanner, configured = null, log = (line) => process.stdout.write(`${line}
+`)) {
+  const out = {};
+  let matched = false;
+  for (const project of inventory.projects) {
+    const root = roots.get(project.id);
+    if (!root) {
+      out[project.id] = { css: null, specimens: {}, looks: {}, notes: [`${project.root} is not on this machine: looks show their shape`] };
+      continue;
+    }
+    const css = configured && realOr(configured.root) === realOr(root) ? { sheets: configured.sheets, from: configured.from } : null;
+    matched ||= css !== null;
+    try {
+      const built = await scanner.projectSpecimens({ id: project.id, root, commit: project.commit, looks: inventory.looks.filter((l) => l.project === project.id) }, css ? { css } : {});
+      out[project.id] = { css: built.css, specimens: built.specimens, looks: built.looks, notes: [`CSS: ${built.tailwind}`, ...built.used, ...built.skipped, ...built.warnings], try: { root, tsconfig: built.tsconfig } };
+      for (const line of sheetReport(project.id, built.used, built.skipped)) log(line);
+    } catch (error) {
+      out[project.id] = { css: null, specimens: {}, looks: {}, notes: [`specimens failed: ${error instanceof Error ? error.message : String(error)}`] };
+    }
+  }
+  if (configured && !matched) log(`specimens.css in ${configured.from}: its product ${configured.root} is not an inventoried project on this machine; not used`);
+  return out;
+}
+function tryIndex(out, inventory, specimens, scanner) {
+  const projects = {};
+  for (const project of inventory.projects) {
+    const built = specimens[project.id];
+    if (!built?.try) continue;
+    const looks = inventory.looks.filter((l) => l.project === project.id);
+    projects[project.id] = tryProject(relative(out, built.try.root) || ".", built.try.tsconfig, looks, built.looks, built.specimens, (recipe, role) => scanner.browserLookOf(recipe, role));
+  }
+  return { schema: "youiyoux.try/v1", projects };
+}
+async function writeInventoryWithSpecimens(out, inventory, path, libs, values) {
+  const specimens = await buildSpecimens(inventory, inventoryRoots(inventory, path), libs.scanner, configuredSpecimenCss(values, libs.core));
+  write(join(out, "try.json"), `${JSON.stringify(tryIndex(out, inventory, specimens, libs.scanner), null, 2)}
+`);
+  return writeInventory(join(out, "public/data"), inventory, specimens);
+}
+async function readInventory(path, isDefault, { core, scanner }) {
+  if (path) return core.parseDefinition(resolve(path), readFileSync(resolve(path), "utf8"), core.InventoryReport);
+  return isDefault ? core.InventoryReport.parse(await scanner.buildInventory(DEMO_INVENTORY, { cwd: TOOL })) : null;
+}
+function writeDetect(file, dataDir, core) {
+  const report = core.DetectReport.parse(JSON.parse(readFileSync(file, "utf8")));
+  const base = dirname(resolve(file));
+  const shots = [];
+  const elements = report.elements.map(({ screenshot, ...element }) => {
+    const source = screenshot ? join(base, screenshot) : null;
+    if (!source || !existsSync(source)) return element;
+    const bytes = readFileSync(source);
+    const name2 = `detect.shot.${hash(bytes)}.png`;
+    write(join(dataDir, name2), bytes);
+    shots.push(name2);
+    return { ...element, screenshot: name2 };
+  });
+  const text = json2({ ...report, elements });
+  const name = `detect.${hash(text)}.json`;
+  write(join(dataDir, name), text);
+  return { file: name, name: report.target.name, kind: report.target.kind, shots };
+}
+var DISCOVER_LISTINGS_MAX = 2e3;
+async function writeDiscover(dataDir, cacheDir, discover) {
+  const index = await discover.readIndex(cacheDir);
+  if (!index) return null;
+  const ordered = [...index.entries].sort((a, b) => Number(discover.sourceClassOf(b) === "official") - Number(discover.sourceClassOf(a) === "official") || (b.signals?.weeklyDownloads ?? b.signals?.via?.weeklyDownloads ?? -1) - (a.signals?.weeklyDownloads ?? a.signals?.via?.weeklyDownloads ?? -1) || a.id.localeCompare(b.id));
+  const card = (entry) => {
+    const { score: _score, why: _why, ...hit } = discover.hitOf(entry, 0, []);
+    return hit;
+  };
+  const entries = ordered.slice(0, DISCOVER_LISTINGS_MAX).map((entry) => ({ ...card(entry), registry: discover.registryName(entry), roles: discover.rolesOf(entry), style: discover.styleOf(entry), text: discover.searchTextOf(entry) }));
+  const text = json2({ schema: "youiyoux.discover-listings/v1", builtAt: index.builtAt, total: index.entries.length, capped: index.entries.length > entries.length, note: discover.DISCOVER_RULE, entries });
+  const file = `discover.${hash(text)}.json`;
+  write(join(dataDir, file), text);
+  return file;
+}
+function discoverCache(values, out, discover) {
+  if (values.discover) return resolve(values.discover);
+  if (out === DEFAULT_OUT) return null;
+  const dir = discover.discoverCacheDir();
+  return existsSync(join(dir, discover.INDEX_FILE)) ? dir : null;
+}
+async function writeGaps(dataDir, inventory, path, system, discoverDir, discoverArg, discover) {
+  const store = discoverDir ? await discover.readCatalog(discoverDir, discover.discoverIndexPath(discoverArg ? discoverDir : void 0)).catch(() => null) : null;
+  const report = await discover.buildGaps({ inventory, system: { name: system.name, components: system.components }, dependencies: discover.declaredPackages(inventoryRoots(inventory, path)), now: new Date(inventory.generatedAt) }, store);
+  const text = json2(report);
+  const file = `gaps.${hash(text)}.json`;
+  write(join(dataDir, file), text);
+  return file;
+}
+function usageFiles(usage) {
+  return usage.flatMap((u) => [u.file, ...(u.screens?.screens ?? []).flatMap((shot) => [...[shot.light, shot.dark].flatMap((f) => f ? [f.full, f.thumb] : []), ...shot.places ? [shot.places] : []])]);
+}
+function writeManifest(dataDir, system, usage, live, inventory, detect, discover, gaps) {
+  const manifest = { schema: "youiyoux.manifest/v1", source: { commit: system.commit }, systems: [{ id: system.id, catalog: system.catalogFile, usage }], ...inventory ? { inventory: inventory.file, inventoryFiles: inventory.files } : {}, ...detect ? { detect: { file: detect.file, name: detect.name, kind: detect.kind } } : {}, ...discover ? { discover } : {}, ...gaps ? { gaps } : {}, ...live ? { live } : {} };
+  const file = join(dataDir, "manifest.json");
+  write(`${file}.tmp`, `${JSON.stringify(manifest, null, 2)}
+`);
+  renameSync(`${file}.tmp`, file);
+}
+function pruneData(dataDir, keep) {
+  for (const name of readdirSync(dataDir)) if (name !== "manifest.json" && !keep.has(name)) rmSync(join(dataDir, name), { force: true });
+}
+async function watchSnapshot(values, out, libs) {
+  const dataDir = join(out, "public/data");
+  mkdirSync(dataDir, { recursive: true });
+  const read = await readInventory(values.inventory, false, libs);
+  const inventory = read ? await writeInventoryWithSpecimens(out, read, values.inventory, libs, values) : null;
+  const detect = values.detect ? writeDetect(values.detect, dataDir, libs.core) : null;
+  const discoverDir = discoverCache(values, out, libs.discover);
+  const discover = discoverDir ? await writeDiscover(dataDir, discoverDir, libs.discover) : null;
+  const root = projectArg(values) ?? (values.config ? dirname(resolve(values.config)) : DEMO_PROJECT);
+  let previousId = previousSystemId(dataDir);
+  let system = null;
+  let systemOf = null;
+  let usage = [];
+  let shots;
+  let previous = /* @__PURE__ */ new Set();
+  let gaps = null;
+  const stamp = () => (/* @__PURE__ */ new Date()).toISOString();
+  const watcher = await libs.scanner.ProjectWatcher.start({
+    root,
+    load: loadOptions(values),
+    job: async (project, cache) => {
+      if (project !== systemOf) {
+        system = await writeSystem(out, project.repo.root, project.config.system, project.config.outputs, values.commit, libs);
+        dropPreviewsOfOtherSystem(out, previousId, system.id);
+        previousId = system.id;
+        systemOf = project;
+        if (read) gaps = await writeGaps(dataDir, read, values.inventory, system, discoverDir, values.discover, libs.discover);
+      }
+      const scan = await libs.scanner.scanProject(project, { cache });
+      const report = libs.core.ScanReport.parse(scan.report);
+      return { report, rules: libs.scanner.describeIdentity(scan.identity) };
+    },
+    onUpdate: (update) => {
+      if (!system) return void process.stderr.write(`youiyoux ui: ${update.status === "failed" ? update.error : "no system"}
+`);
+      if (update.status === "ok") {
+        const { report } = update.result;
+        if (shots === void 0) {
+          const dir = screensDir(values.screens, systemOf?.root ?? resolve(root));
+          shots = dir ? writeScreens(dir, dataDir, report.project) : null;
+        }
+        usage = [writeUsage(dataDir, report, shots)];
+      }
+      const live = update.status === "ok" ? { generation: update.generation, status: update.result.report.status, updatedAt: stamp(), rules: update.result.rules } : { generation: update.generation, status: "failed", updatedAt: stamp(), message: update.error };
+      writeManifest(dataDir, system, usage, live, inventory, detect, discover, gaps);
+      const current = /* @__PURE__ */ new Set([system.catalogFile, ...usageFiles(usage), ...inventory ? [inventory.file, ...inventory.files] : [], ...detect ? [detect.file, ...detect.shots] : [], ...discover ? [discover] : [], ...gaps ? [gaps] : []]);
+      pruneData(dataDir, /* @__PURE__ */ new Set([...current, ...previous]));
+      previous = current;
+      process.stdout.write(`youiyoux ui: generation ${update.generation} ${live.status}${live.message ? `: ${live.message}` : ""}
+`);
+    }
+  });
+  const stop = () => {
+    watcher.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+}
+async function libraries() {
+  return { core: await loadPackage("core"), lib: await loadPackage("tokens"), scanner: await loadPackage("scanner"), discover: await loadPackage("discover") };
+}
+async function main() {
+  const { values } = parseArgs({ options: { design: { type: "string" }, project: { type: "string" }, config: { type: "string" }, root: { type: "string" }, out: { type: "string" }, commit: { type: "string" }, screens: { type: "string" }, inventory: { type: "string" }, detect: { type: "string" }, discover: { type: "string" }, watch: { type: "boolean", default: false } } });
+  const libs = await libraries();
+  const out = resolve(values.out ?? DEFAULT_OUT);
+  if (values.watch) {
+    if (out === DEFAULT_OUT) throw new Error("--watch writes a live snapshot; pass --out (the committed default snapshot is never watched)");
+    return watchSnapshot(values, out, libs);
+  }
+  if (values.detect && out === DEFAULT_OUT) throw new Error("--detect adds a report you ran; pass --out (the committed demo snapshot never holds one)");
+  const dataDir = join(out, "public/data");
+  const source = await readSource(values, libs.core, libs.scanner);
+  const previousId = previousSystemId(dataDir);
+  rmSync(dataDir, { recursive: true, force: true });
+  const system = await writeSystem(out, source.designRoot, source.systemId, source.output, values.commit, libs);
+  dropPreviewsOfOtherSystem(out, previousId, system.id);
+  const shotsDir = source.usage ? screensDir(values.screens, source.projectDir) : null;
+  const shots = source.usage && shotsDir ? writeScreens(shotsDir, dataDir, source.usage.project) : null;
+  const usage = source.usage ? [writeUsage(dataDir, source.usage, shots)] : [];
+  const read = await readInventory(values.inventory, out === DEFAULT_OUT, libs);
+  const inventory = read ? await writeInventoryWithSpecimens(out, read, values.inventory, libs, values) : null;
+  if (!read) rmSync(join(out, "try.json"), { force: true });
+  const detect = values.detect ? writeDetect(values.detect, dataDir, libs.core) : null;
+  const discoverDir = discoverCache(values, out, libs.discover);
+  const discover = discoverDir ? await writeDiscover(dataDir, discoverDir, libs.discover) : null;
+  const gaps = read ? await writeGaps(dataDir, read, values.inventory, system, discoverDir, values.discover, libs.discover) : null;
+  writeManifest(dataDir, system, usage, void 0, inventory, detect, discover, gaps);
+  if (out === DEFAULT_OUT) await buildHubTokens(libs.core, libs.lib);
+  process.stdout.write(`snapshot of ${system.summary}; ${usage.length ? `usage map of ${usage[0].project}${shots ? ` with ${shots.screens.length} screens` : ""}` : "no usage map"}${inventory ? `; ${inventory.file} (+${inventory.files.length} chunks and stylesheets)` : ""}${gaps ? `; ${gaps}` : ""}${detect ? `; detect report of ${detect.name} (${detect.shots.length} screenshots)` : ""}${discover ? `; Discover listings ${discover}` : ""} \u2192 ${relative(process.cwd(), out) || "."}
+`);
+}
+if (false) await main();
+
+// src/hub-snapshot.js
+await main();