youiyoux 0.1.4 → 0.1.6

package/dist/chunks/{chunk-52KOKYY6.js → chunk-RHXBYN4W.js}

@@ -17,7 +17,7 @@ import {
   sameColor,
   splitTopLevel,
   tailwindTheme
-} from "./chunk-YJ7WMBTT.js";
+} from "./chunk-VOSWAWKC.js";
 import {
   AST_GREP_LANGUAGES,
   BUILT_IN_CHECKS,
@@ -28,6 +28,7 @@ import {
   RuleSpec,
   SHAPE_DIMENSIONS,
   canMove,
+  expandGitSource,
   findFiles,
   getSystem,
   isFamilyId,
@@ -49,7 +50,7 @@ import {
   toPosix,
   unifiedDiff,
   writeFileAtomic
-} from "./chunk-NYDJYMID.js";
+} from "./chunk-DP54SKL4.js";
 
 // ../scanner/src/parse.ts
 import { Lang, parseAsync } from "@ast-grep/napi";
@@ -552,9 +553,9 @@ var siteKey = (f) => `${f.file}:${f.line}:${f.column}:${f.text}`;
 function compareWithPublished(project, scan, id, sites) {
   const published = project.system.rules.find((r) => r.id === id);
   if (!published) return null;
-  const run2 = scan.report.checks.find((c) => c.rule === id);
+  const run3 = scan.report.checks.find((c) => c.rule === id);
   const execution = ruleCapability(published).state;
-  if (run2?.state !== "ran") return { execution, findings: null, added: null, removed: null };
+  if (run3?.state !== "ran") return { execution, findings: null, added: null, removed: null };
   const before2 = new Set(scan.report.violations.filter((v) => v.rule === id).map(siteKey));
   const after = new Set(sites.map(siteKey));
   return { execution, findings: before2.size, added: [...after].filter((k) => !before2.has(k)).length, removed: [...before2].filter((k) => !after.has(k)).length };
@@ -575,8 +576,8 @@ function evaluateRule(project, scan, draft) {
   const runnable = ruleCapability(asOn);
   if (runnable.state !== "enforced") return { ok: true, rule: rule.id, execution: runnable, findings: null, snapshot };
   const result = runChecks(checkInputFor(project, scan, [asOn]));
-  const run2 = result.checks[0];
-  if (run2?.state !== "ran") return { ok: true, rule: rule.id, execution: { state: "unsupported", reason: run2?.reason ?? "the check did not run" }, findings: null, snapshot };
+  const run3 = result.checks[0];
+  if (run3?.state !== "ran") return { ok: true, rule: rule.id, execution: { state: "unsupported", reason: run3?.reason ?? "the check did not run" }, findings: null, snapshot };
   const sites = result.violations.map(({ rule: _rule, severity: _severity, ...finding }) => finding).sort((a, b) => siteKey(a).localeCompare(siteKey(b)));
   return {
     ok: true,
@@ -594,24 +595,177 @@ function evaluateRule(project, scan, draft) {
 }
 
 // ../scanner/src/project.ts
-import { stat } from "node:fs/promises";
-import { dirname as dirname2, join as join2, posix, resolve } from "node:path";
+import { stat as stat2 } from "node:fs/promises";
+import { dirname as dirname3, join as join3, posix, resolve as resolve2 } from "node:path";
+
+// ../scanner/src/design-source.ts
+import { execFile as execFile2 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readdir, readFile, readlink, realpath, rename, rm, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join2, relative, resolve } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var run2 = promisify2(execFile2);
+var LOCK_FILE = "youi.lock.json";
+var COMMIT = /^[0-9a-f]{40}$/;
+var systemsCacheDir = () => process.env.YOUI_SYSTEMS_CACHE || join2(process.env.XDG_CACHE_HOME || join2(homedir(), ".cache"), "youiyoux/systems");
+async function designRootOf(source, configFile, productRoot, options = {}) {
+  return (await locateDesign(source, configFile, productRoot, options)).root;
+}
+async function locateDesign(source, configFile, productRoot, options = {}) {
+  if ("path" in source) return { root: resolve(dirname2(configFile), source.path), commit: null };
+  if ("package" in source) {
+    for (let dir = resolve(productRoot); ; dir = dirname2(dir)) {
+      const candidate = join2(dir, "node_modules", ...source.package.split("/"));
+      if (await isDirectory(candidate)) return { root: await realpath(candidate), commit: null };
+      if (dirname2(dir) === dir) break;
+    }
+    throw new Error(`the design system package ${source.package} is not installed for ${productRoot} (config ${configFile}): add it as a dependency and install, or set source.path to its checkout`);
+  }
+  return gitCheckout(source.git, source.ref, { ...options, locked: await lockedCommit(productRoot) });
+}
+async function lockedCommit(productRoot) {
+  try {
+    const commit = JSON.parse(await readTextOrNull(join2(productRoot, LOCK_FILE)) ?? "{}").sourceCommit;
+    return typeof commit === "string" && COMMIT.test(commit) ? commit : null;
+  } catch {
+    return null;
+  }
+}
+async function gitCheckout(url, ref, options = {}) {
+  const remote = expandGitSource(url);
+  const base = join2(options.cacheDir ?? systemsCacheDir(), createHash("sha256").update(remote).digest("hex").slice(0, 16));
+  const bare = join2(base, "repo.git");
+  const refs = join2(base, "refs.json");
+  const recorded = options.refresh ? null : COMMIT.test(ref) ? ref : options.locked ?? (await readRefs(refs))[ref] ?? null;
+  if (recorded !== null && await isDirectory(join2(base, recorded))) return { root: await contained(join2(base, recorded), recorded), commit: recorded };
+  if (recorded === null || !await hasCommit(bare, recorded)) await fetchAll(bare, remote);
+  const commit = recorded ?? await revParse(bare, ref);
+  if (commit === null) throw new Error(`${withoutCredentials(url)} has no branch, tag or commit "${ref}"`);
+  if (recorded !== null && !await hasCommit(bare, commit)) throw new Error(`${withoutCredentials(url)} has no commit ${commit}, which youi.lock.json records: run youiyoux sync to resolve "${ref}" again`);
+  const tree = join2(base, commit);
+  if (!await isDirectory(tree)) await extract(bare, commit, tree);
+  await contained(tree, commit);
+  if (recorded === null) await writeFileAtomic(refs, `${JSON.stringify({ ...await readRefs(refs), [ref]: commit }, null, 2)}
+`);
+  return { root: tree, commit };
+}
+var GIT_ENV = { ...process.env, GIT_ALLOW_PROTOCOL: "https:ssh:file", GIT_TERMINAL_PROMPT: "0" };
+var git = (args) => run2("git", args, { env: GIT_ENV, maxBuffer: 16 * 1024 * 1024 });
+async function fetchAll(bare, remote) {
+  if (!await isDirectory(bare)) {
+    await mkdir(dirname2(bare), { recursive: true });
+    await git(["init", "--quiet", "--bare", bare]);
+  }
+  try {
+    await git(["--git-dir", bare, "fetch", "--quiet", "--force", "--prune", "--tags", "--", remote, "+refs/heads/*:refs/heads/*"]);
+  } catch (error) {
+    const detail = error.stderr?.trim().split("\n").pop() ?? (error instanceof Error ? error.message : String(error));
+    throw new Error(withoutCredentials(`could not fetch the design system from ${remote}: ${detail}`));
+  }
+}
+async function revParse(bare, ref) {
+  for (const name of [`refs/tags/${ref}`, `refs/heads/${ref}`, ref]) {
+    const commit = await git(["--git-dir", bare, "rev-parse", "--verify", "--quiet", `${name}^{commit}`]).then((r) => r.stdout.trim(), () => "");
+    if (COMMIT.test(commit)) return commit;
+  }
+  return null;
+}
+var hasCommit = (bare, commit) => git(["--git-dir", bare, "cat-file", "-e", `${commit}^{commit}`]).then(() => true, () => false);
+async function extract(bare, commit, tree) {
+  const temp = await mkdtemp(`${tree}.`);
+  try {
+    await git(["--git-dir", bare, "archive", "--format=tar", "-o", join2(temp, ".tree.tar"), commit]);
+    await run2("tar", ["-xf", join2(temp, ".tree.tar"), "-C", temp]);
+    await rm(join2(temp, ".tree.tar"));
+    await contained(temp, commit);
+    await rename(temp, tree).catch(async (error) => {
+      if (!await isDirectory(tree)) throw error;
+    });
+  } finally {
+    await rm(temp, { recursive: true, force: true });
+  }
+}
+var withoutCredentials = (text) => text.replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1***@");
+async function contained(tree, commit) {
+  const escaping = await linksLeaving(tree);
+  if (escaping.length > 0) throw new Error(`the design system at ${commit} has links that lead outside it (${escaping.slice(0, 3).join(", ")}): it was not used, since sync would copy what they point at`);
+  return tree;
+}
+async function linksLeaving(root) {
+  const leaving = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const dir = pending.pop();
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      const path = join2(dir, entry.name);
+      if (entry.isDirectory()) pending.push(path);
+      else if (entry.isSymbolicLink() && !within(root, resolve(dir, await readlink(path)))) leaving.push(relative(root, path));
+    }
+  }
+  return leaving.sort();
+}
+async function readRefs(file) {
+  try {
+    const refs = JSON.parse(await readFile(file, "utf8"));
+    return Object.fromEntries(Object.entries(refs).filter((e) => typeof e[1] === "string" && COMMIT.test(e[1])));
+  } catch {
+    return {};
+  }
+}
+var linksFile = () => process.env.YOUI_LINKS || join2(process.env.XDG_CONFIG_HOME || join2(homedir(), ".config"), "youiyoux/links.json");
+async function readLinks() {
+  try {
+    const links = JSON.parse(await readFile(linksFile(), "utf8"));
+    return Object.fromEntries(Object.entries(links).filter((e) => typeof e[1] === "string"));
+  } catch {
+    return {};
+  }
+}
+var productKey = async (productRoot) => realpath(productRoot).catch(() => resolve(productRoot));
+async function linkedDesign(productRoot) {
+  return (await readLinks())[await productKey(productRoot)] ?? null;
+}
+async function setLink(productRoot, design) {
+  const links = await readLinks();
+  const key = await productKey(productRoot);
+  if (design === null) delete links[key];
+  else links[key] = resolve(design);
+  await writeFileAtomic(linksFile(), `${JSON.stringify(links, null, 2)}
+`);
+}
+async function isDirectory(path) {
+  return (await stat(path).catch(() => null))?.isDirectory() ?? false;
+}
+
+// ../scanner/src/project.ts
 var PROJECT_FILE = "youi.project.json";
 var ProjectRootError = class extends Error {
 };
 var ROOT_HINT = 'set "root" in the config (relative to it, or absolute) or pass --root <dir>';
 async function loadProject(root, options = {}) {
-  const configFile = resolve(options.configPath ?? join2(resolve(root), PROJECT_FILE));
+  const configFile = resolve2(options.configPath ?? join3(resolve2(root), PROJECT_FILE));
   const config = normalizeProjectConfig(await readDefinition(configFile, ProjectConfig));
-  const fromConfig = (path) => resolve(dirname2(configFile), path);
-  const productRoot = options.productRoot !== void 0 ? resolve(options.productRoot || ".") : config.root ? fromConfig(config.root) : resolve(root);
-  if (!await isDirectory(productRoot)) throw new ProjectRootError(`product root ${productRoot} is not a directory (config ${configFile}); ${ROOT_HINT}`);
-  const designRoot = options.designRoot ? resolve(options.designRoot) : fromConfig(config.source.path);
-  const repo = await loadDesignRepo(designRoot);
-  return { root: productRoot, config, repo, system: getSystem(repo, config.system), configFile, designOverride: Boolean(options.designRoot), rootOverride: options.productRoot !== void 0 };
+  const fromConfig = (path) => resolve2(dirname3(configFile), path);
+  const productRoot = options.productRoot !== void 0 ? resolve2(options.productRoot || ".") : config.root ? fromConfig(config.root) : resolve2(root);
+  if (!await isDirectory2(productRoot)) throw new ProjectRootError(`product root ${productRoot} is not a directory (config ${configFile}); ${ROOT_HINT}`);
+  const linked = options.designRoot ? null : await linkedDesign(productRoot);
+  const located = options.designRoot || linked ? { root: resolve2(options.designRoot || linked), commit: null } : await locateDesign(config.source, configFile, productRoot, { refresh: options.refreshDesign });
+  const repo = await loadDesignRepo(located.root);
+  return {
+    root: productRoot,
+    config,
+    repo,
+    system: getSystem(repo, config.system),
+    configFile,
+    designOverride: Boolean(options.designRoot),
+    rootOverride: options.productRoot !== void 0,
+    ...linked ? { linked } : {},
+    ...located.commit ? { designCommit: located.commit } : {}
+  };
 }
-async function isDirectory(path) {
-  return (await stat(path).catch(() => null))?.isDirectory() ?? false;
+async function isDirectory2(path) {
+  return (await stat2(path).catch(() => null))?.isDirectory() ?? false;
 }
 function importSpecifier(config, fromFile) {
   if (config.importFrom) return config.importFrom;
@@ -621,7 +775,7 @@ function importSpecifier(config, fromFile) {
 }
 async function emptyRootProblem(project, matched) {
   if (matched > 0) return null;
-  const tsconfig = await stat(join2(project.root, project.config.tsconfig)).catch(() => null) ? "" : ` and no ${project.config.tsconfig}`;
+  const tsconfig = await stat2(join3(project.root, project.config.tsconfig)).catch(() => null) ? "" : ` and no ${project.config.tsconfig}`;
   return `product root ${project.root} has 0 files matching ${project.config.include.join(", ")}${tsconfig} (config ${project.configFile}); if the product lives elsewhere, ${ROOT_HINT}`;
 }
 
@@ -949,8 +1103,8 @@ function clusterShapes(shapes, linkage = "complete", tolerance = DEFAULT_TOLERAN
 }
 
 // ../scanner/src/inventory/theme.ts
-import { readFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 import { Lang as Lang3, parseAsync as parseAsync2 } from "@ast-grep/napi";
 var ROOT_FONT_SIZE = 16;
 var PILL = 9999;
@@ -1114,7 +1268,7 @@ async function readTailwindConfig(root) {
   const vars = /* @__PURE__ */ new Map();
   const warnings = [];
   for (const name of CONFIG_FILES) {
-    const source = await readFile(join3(root, name), "utf8").catch(() => null);
+    const source = await readFile2(join4(root, name), "utf8").catch(() => null);
     if (source === null) continue;
     const top = (await parseAsync2(Lang3.TypeScript, source)).root();
     const theme = top.findAll({ rule: { kind: "pair" } }).find((p) => keyText(p.field("key")) === "theme" && p.field("value")?.kind() === "object");
@@ -1780,8 +1934,8 @@ function buildElementIndex(project) {
 }
 
 // ../scanner/src/graph.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 var ModuleGraph = class {
   root;
   resolver;
@@ -1805,7 +1959,7 @@ var ModuleGraph = class {
     if (!loading) {
       loading = (async () => {
         try {
-          const source = this.overrides.get(file) ?? await readFile2(join4(this.root, file), "utf8");
+          const source = this.overrides.get(file) ?? await readFile3(join5(this.root, file), "utf8");
           const info = await this.parse(file, source);
           this.modules.set(file, info);
           return info;
@@ -1820,7 +1974,7 @@ var ModuleGraph = class {
   }
   /** Resolve an import specifier written in `fromFile`; files come back project-relative. */
   resolveSpecifier(specifier, fromFile) {
-    const result = this.resolver.resolve(specifier, join4(this.root, fromFile));
+    const result = this.resolver.resolve(specifier, join5(this.root, fromFile));
     if (result.kind === "file") return { kind: "file", file: relPath(this.root, result.file) };
     return result.kind === "external" ? result : { kind: "unresolved" };
   }
@@ -2048,8 +2202,8 @@ var RouteIndex = class _RouteIndex {
 };
 
 // ../scanner/src/scan.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 
 // ../scanner/src/usage.ts
 var MAX_DYNAMIC = 120;
@@ -2235,7 +2389,7 @@ async function parseAll(project, files, overrides, parse3) {
   await Promise.all(
     files.map(async (file) => {
       try {
-        const source = overrides[file] ?? await readFile3(join5(project.root, file), "utf8");
+        const source = overrides[file] ?? await readFile4(join6(project.root, file), "utf8");
         sources.set(file, source);
         const module = await parse3(file, source);
         modules.set(file, module);
@@ -2266,7 +2420,7 @@ async function scanProject(project, options = {}) {
     gitState(project.root),
     gitState(project.repo.root),
     changedFiles(project.root),
-    cache ? readTextOrNull(join5(project.root, project.config.tsconfig)) : Promise.resolve(null)
+    cache ? readTextOrNull(join6(project.root, project.config.tsconfig)) : Promise.resolve(null)
   ]);
   const definitions = definitionsDigest(project, build.tokens);
   cache?.useDefinitions(definitions);
@@ -2320,7 +2474,7 @@ async function scanProject(project, options = {}) {
 }
 
 // ../scanner/src/codemod.ts
-import { isAbsolute, join as join6, relative, resolve as resolve2 } from "node:path";
+import { isAbsolute, join as join7, relative as relative2, resolve as resolve3 } from "node:path";
 
 // ../scanner/src/export-origin.ts
 var ExportOrigins = class {
@@ -2388,8 +2542,8 @@ var ExportOrigins = class {
       const found = binding ? await follow(binding.specifier, binding.imported) : null;
       if (!found) return null;
       const change = this.changes.get(found.old);
-      const rename3 = change.renameBarrels || this.elements.isOwned(file) || this.elements.implementationFiles.has(file);
-      return { ...found, next: found.next === null ? null : rename3 && name === found.old ? change.to : name };
+      const rename4 = change.renameBarrels || this.elements.isOwned(file) || this.elements.implementationFiles.has(file);
+      return { ...found, next: found.next === null ? null : rename4 && name === found.old ? change.to : name };
     }
     for (const specifier of module.starExports) {
       const found = await follow(specifier, name);
@@ -2811,7 +2965,7 @@ async function verifyImports(migration, before2, after, target, outputs, residua
     const resolved = after.graph.resolveSpecifier(specifier, file);
     return resolved.kind === "file" ? { file: resolved.file, name } : resolved.kind === "external" ? { external: true } : null;
   };
-  const resolve9 = async (ref) => {
+  const resolve10 = async (ref) => {
     if (!ref) return false;
     if ("external" in ref || ref.name === "*") return true;
     return (await after.graph.resolveExport(ref.file, ref.name)).kind !== "unknown";
@@ -2862,7 +3016,7 @@ async function verifyImports(migration, before2, after, target, outputs, residua
       return base && !("external" in base) ? { file: base.file, name } : base;
     };
     const checkResolution = async (node2, ref) => {
-      if (rewritten && changedNode(node2) && !await resolve9(ref)) unresolved.add(at(node2));
+      if (rewritten && changedNode(node2) && !await resolve10(ref)) unresolved.add(at(node2));
     };
     for (const node2 of nodes) {
       if (ts.isImportSpecifier(node2) || ts.isImportClause(node2) && node2.name || ts.isNamespaceImport(node2)) {
@@ -3144,19 +3298,19 @@ async function runMigration(project, migration, options = {}) {
   return { ...base, status: !passed ? "rejected" : options.write ? "applied" : "dry-run", sitesAfter, gates };
 }
 async function writeChanges(project, changes) {
-  const outside = changes.filter((c) => isAbsolute(c.file) || relative(project.root, resolve2(project.root, c.file)).startsWith(".."));
+  const outside = changes.filter((c) => isAbsolute(c.file) || relative2(project.root, resolve3(project.root, c.file)).startsWith(".."));
   if (outside.length > 0) return { name: "sources-unchanged", ok: false, detail: `refusing to write outside the project: ${outside.map((c) => c.file).join(", ")}` };
   const moved = [];
-  for (const change of changes) if (await readTextOrNull(join6(project.root, change.file)) !== change.before) moved.push(change.file);
+  for (const change of changes) if (await readTextOrNull(join7(project.root, change.file)) !== change.before) moved.push(change.file);
   if (moved.length > 0) return { name: "sources-unchanged", ok: false, detail: `changed since the scan, nothing written: ${moved.join(", ")}` };
   const written = [];
   try {
     for (const change of changes) {
-      await writeFileAtomic(join6(project.root, change.file), change.after);
+      await writeFileAtomic(join7(project.root, change.file), change.after);
       written.push(change);
     }
   } catch (error) {
-    for (const change of written) await writeFileAtomic(join6(project.root, change.file), change.before);
+    for (const change of written) await writeFileAtomic(join7(project.root, change.file), change.before);
     return { name: "sources-unchanged", ok: false, detail: `write failed, ${written.length} file(s) restored: ${error instanceof Error ? error.message : String(error)}` };
   }
   return { name: "sources-unchanged", ok: true, detail: `${changes.length} file(s) written, each verified unchanged since the scan` };
@@ -3761,7 +3915,7 @@ function ruleRows(project) {
 // ../scanner/src/watch.ts
 import { existsSync, mkdtempSync, rmSync, watch, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname as dirname3, join as join7, relative as relative2, resolve as resolve3, sep } from "node:path";
+import { dirname as dirname4, join as join8, relative as relative3, resolve as resolve4, sep } from "node:path";
 var DEFAULT_DEBOUNCE_MS = 120;
 var LIVE_TIMEOUT_MS = 1e4;
 var PROBE_INTERVAL_MS = 50;
@@ -3793,7 +3947,7 @@ var ProjectWatcher = class _ProjectWatcher {
   closed = false;
   constructor(options) {
     this.options = options;
-    this.configFile = resolve3(options.load?.configPath ?? join7(options.root, PROJECT_FILE));
+    this.configFile = resolve4(options.load?.configPath ?? join8(options.root, PROJECT_FILE));
   }
   /** Run the job once, then again on every change until `close()`. */
   static async start(options) {
@@ -3848,7 +4002,7 @@ var ProjectWatcher = class _ProjectWatcher {
         await this.rewatch(this.project);
       }
       const project = this.project;
-      this.cache.forget(changed.filter((file) => !existsSync(join7(project.root, file))));
+      this.cache.forget(changed.filter((file) => !existsSync(join8(project.root, file))));
       const result = await this.options.job(project, this.cache, changed);
       if (!this.closed) this.options.onUpdate({ ...base(), status: "ok", result });
     } catch (error) {
@@ -3863,13 +4017,13 @@ var ProjectWatcher = class _ProjectWatcher {
     const watch2 = this.options.watch ?? defaultWatch;
     for (const w of this.watchers) w.close();
     const { root, config, repo, system } = project;
-    const sourceDirs = covering(config.include.map((g) => resolve3(root, staticBase(g))).filter((d) => existsSync(d)));
-    const definitionDirs = covering([dirname3(system.config.tokens), system.config.components, system.config.rules, ...system.config.design ? [dirname3(system.config.design)] : []].map((p) => resolve3(repo.root, p)).filter((d) => existsSync(d) && d !== repo.root));
-    const topLevel = [.../* @__PURE__ */ new Set([repo.root, dirname3(this.configFile), root])];
+    const sourceDirs = covering(config.include.map((g) => resolve4(root, staticBase(g))).filter((d) => existsSync(d)));
+    const definitionDirs = covering([dirname4(system.config.tokens), system.config.components, system.config.rules, ...system.config.design ? [dirname4(system.config.design)] : []].map((p) => resolve4(repo.root, p)).filter((d) => existsSync(d) && d !== repo.root));
+    const topLevel = [.../* @__PURE__ */ new Set([repo.root, dirname4(this.configFile), root])];
     this.watchers = [
-      ...sourceDirs.map((dir) => watch2(dir, { recursive: true }, (_event, name) => name && this.sourceChanged(project, join7(dir, name.toString())))),
+      ...sourceDirs.map((dir) => watch2(dir, { recursive: true }, (_event, name) => name && this.sourceChanged(project, join8(dir, name.toString())))),
       ...definitionDirs.map((dir) => watch2(dir, { recursive: true }, () => this.definitionsChanged())),
-      ...topLevel.map((dir) => watch2(dir, (_event, name) => name && this.topLevelChanged(project, join7(dir, name.toString()))))
+      ...topLevel.map((dir) => watch2(dir, (_event, name) => name && this.topLevelChanged(project, join8(dir, name.toString()))))
     ];
     for (const w of this.watchers) w.on("error", (error) => this.watcherFailed(error));
     await this.whenLive();
@@ -3877,7 +4031,7 @@ var ProjectWatcher = class _ProjectWatcher {
   watchConfigOnly() {
     const watch2 = this.options.watch ?? defaultWatch;
     for (const w of this.watchers) w.close();
-    this.watchers = [watch2(dirname3(this.configFile), { recursive: true }, () => this.definitionsChanged())];
+    this.watchers = [watch2(dirname4(this.configFile), { recursive: true }, () => this.definitionsChanged())];
     for (const w of this.watchers) w.on("error", (error) => this.watcherFailed(error));
     void this.whenLive();
   }
@@ -3895,8 +4049,8 @@ var ProjectWatcher = class _ProjectWatcher {
     const watch2 = this.options.watch ?? defaultWatch;
     this.stopProbing?.();
     if (this.closed) return Promise.resolve();
-    this.probeDir ??= mkdtempSync(join7(tmpdir(), "youi-watch-probe-"));
-    const probe = join7(this.probeDir, "probe");
+    this.probeDir ??= mkdtempSync(join8(tmpdir(), "youi-watch-probe-"));
+    const probe = join8(this.probeDir, "probe");
     return new Promise((done) => {
       let writes = 0;
       const stop = () => {
@@ -3924,7 +4078,7 @@ var ProjectWatcher = class _ProjectWatcher {
     if (!this.closed) this.options.onUpdate({ generation: this.generation, status: "failed", error: `file watcher: ${error.message}; changes may be missed until restart`, changed: [], reloaded: false, durationMs: 0 });
   }
   sourceChanged(project, absolute) {
-    const file = toPosix(relative2(project.root, absolute));
+    const file = toPosix(relative3(project.root, absolute));
     const { include, exclude, outputs } = project.config;
     if (file.startsWith("..") || file.startsWith(`${outputs.dir}/`) || matchesAny(file, [...IGNORED, ...exclude]) || !matchesAny(file, include)) return;
     this.pending.add(file);
@@ -3932,9 +4086,9 @@ var ProjectWatcher = class _ProjectWatcher {
   }
   topLevelChanged(project, absolute) {
     const { design } = project.system.config;
-    const definitions = [this.configFile, resolve3(project.repo.root, "youi.config.json"), ...design ? [resolve3(project.repo.root, design)] : []];
+    const definitions = [this.configFile, resolve4(project.repo.root, "youi.config.json"), ...design ? [resolve4(project.repo.root, design)] : []];
     if (definitions.includes(absolute)) this.definitionsChanged();
-    else if (absolute === resolve3(project.root, project.config.tsconfig)) {
+    else if (absolute === resolve4(project.root, project.config.tsconfig)) {
       this.pending.add(project.config.tsconfig);
       this.schedule();
     }
@@ -3946,11 +4100,11 @@ var ProjectWatcher = class _ProjectWatcher {
 };
 
 // ../scanner/src/inventory/inventory.ts
-import { relative as relative3 } from "node:path";
+import { relative as relative4 } from "node:path";
 
 // ../scanner/src/inventory/collect.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join9, posix as posix3 } from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import { join as join10, posix as posix3 } from "node:path";
 
 // ../scanner/src/inventory/astro.ts
 var RAW_TEXT = /* @__PURE__ */ new Set(["script", "style"]);
@@ -4301,8 +4455,8 @@ function roleOfComponent(name, props, firstChild) {
 }
 
 // ../scanner/src/inventory/stories.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join8, posix as posix2 } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join9, posix as posix2 } from "node:path";
 var STORY_FILE = /\.stories\.(?:tsx|ts|jsx|js|mjs)$/;
 var CONFIG_DIR = ".storybook";
 var MAIN = ["main.ts", "main.mts", "main.cts", "main.js", "main.mjs", "main.cjs"];
@@ -4310,9 +4464,9 @@ var PREVIEW = ["preview.tsx", "preview.ts", "preview.jsx", "preview.js", "previe
 var DEFAULT_SPECIFIER = { glob: "**/*.stories.{tsx,ts,jsx,js,mjs}", base: "", titlePrefix: "" };
 var GLOB = /[*?{}[\]()!]/;
 function specifierOf(glob, titlePrefix) {
-  const relative5 = posix2.normalize(posix2.join(CONFIG_DIR, glob.replace(/^\.\//, "")));
-  if (relative5.startsWith("../") || posix2.isAbsolute(relative5)) return null;
-  const normal = relative5.replace(/@\(([^()]*)\)/g, (_, alts) => `{${alts.split("|").join(",")}}`);
+  const relative6 = posix2.normalize(posix2.join(CONFIG_DIR, glob.replace(/^\.\//, "")));
+  if (relative6.startsWith("../") || posix2.isAbsolute(relative6)) return null;
+  const normal = relative6.replace(/@\(([^()]*)\)/g, (_, alts) => `{${alts.split("|").join(",")}}`);
   const segments = normal.split("/");
   const firstGlob = segments.findIndex((s) => GLOB.test(s));
   if (firstGlob === -1) return { glob: `${normal}/**/*.stories.{tsx,ts,jsx,js,mjs}`, base: normal, titlePrefix };
@@ -4348,7 +4502,7 @@ function autoTitle(file, specifier) {
 async function firstFile(root, names) {
   for (const name of names) {
     const file = posix2.join(CONFIG_DIR, name);
-    const source = await readFile4(join8(root, file), "utf8").catch(() => null);
+    const source = await readFile5(join9(root, file), "utf8").catch(() => null);
     if (source !== null) return { file, source };
   }
   return null;
@@ -4569,7 +4723,7 @@ var InventoryGraph = class extends ModuleGraph {
   }
 };
 async function pathAliases(root, tsconfig) {
-  const text = await readFile5(join9(root, tsconfig), "utf8").catch(() => null);
+  const text = await readFile6(join10(root, tsconfig), "utf8").catch(() => null);
   if (!text) return [];
   try {
     const json = JSON.parse(text.replace(/("(?:[^"\\\n]|\\.)*")|\/\*[\s\S]*?\*\/|\/\/.*$/gm, (_, string) => string ?? "").replace(/,(\s*[}\]])/g, "$1"));
@@ -4683,7 +4837,7 @@ var ProjectPass = class {
     await Promise.all(
       files.map(async (file) => {
         try {
-          const source = await readFile5(join9(root, file), "utf8");
+          const source = await readFile6(join10(root, file), "utf8");
           if (file.endsWith(".css")) this.sheets.push(await readStylesheet(file, source));
           const module = await this.parse(file, source);
           this.modules.set(file, module);
@@ -4699,7 +4853,7 @@ var ProjectPass = class {
     if (files.some((f) => /\.(tsx|jsx|ts)$/.test(f))) for (const problem of resolver.problems) this.failed.push({ file: tsconfig, reason: problem });
     this.graph = new InventoryGraph(root, resolver, this.modules, this.parse, await pathAliases(root, tsconfig), new Set(files));
     this.routes = RouteIndex.build(this.graph, this.modules, this.target.routes);
-    const pkg = JSON.parse(await readFile5(join9(root, "package.json"), "utf8").catch(() => "{}") || "{}");
+    const pkg = JSON.parse(await readFile6(join10(root, "package.json"), "utf8").catch(() => "{}") || "{}");
     const tailwindPackage = Boolean(pkg.dependencies?.tailwindcss ?? pkg.devDependencies?.tailwindcss);
     this.theme = await buildTheme(root, this.sheets, tailwindPackage);
     for (const sheet of this.sheets) this.globalRules.addSheet(sheet);
@@ -5165,7 +5319,7 @@ var ProjectPass = class {
     const stories = { files: files.length, read: 0, drawn: 0, skipped: [], notes: [...config.notes] };
     for (const { file, specifier } of files) {
       try {
-        const module = await parseModule(file, await readFile5(join9(root, file), "utf8"));
+        const module = await parseModule(file, await readFile6(join10(root, file), "utf8"));
         if (!module) continue;
         if (module.parseErrors > 0) {
           const error = module.root.root().find({ rule: { kind: "ERROR" } });
@@ -5251,16 +5405,16 @@ async function readProject(target, options = {}) {
 }
 async function collectProject(target, options = {}) {
   const pass = await readProject(target, options);
-  const git2 = await gitState(target.root);
+  const git3 = await gitState(target.root);
   const definitions = [...pass.definitions.values()].map((d) => d.entry).sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.name.localeCompare(b.name));
   const primitives = [...pass.primitives].map(([pkg, p]) => ({ package: pkg, project: target.id, exports: [...p.exports].sort(), count: p.count, sites: p.sites.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column) })).sort((a, b) => a.package.localeCompare(b.package));
   const looks = pass.looks.sort(byPosition);
-  return { id: target.id, target, commit: git2.commit, failed: pass.failed.sort((a, b) => a.file.localeCompare(b.file)), warnings: pass.theme.warnings, definitions, kits: pass.kits.sort((a, b) => a.id.localeCompare(b.id)), primitives, looks, kitImports: pass.kitImports, stories: pass.stories };
+  return { id: target.id, target, commit: git3.commit, failed: pass.failed.sort((a, b) => a.file.localeCompare(b.file)), warnings: pass.theme.warnings, definitions, kits: pass.kits.sort((a, b) => a.id.localeCompare(b.id)), primitives, looks, kitImports: pass.kitImports, stories: pass.stories };
 }
 
 // ../scanner/src/inventory/target.ts
-import { readFile as readFile6, stat as stat2 } from "node:fs/promises";
-import { basename as basename2, join as join10, resolve as resolve4 } from "node:path";
+import { readFile as readFile7, stat as stat3 } from "node:fs/promises";
+import { basename as basename2, join as join11, resolve as resolve5 } from "node:path";
 var DEFAULT_INCLUDE = ["**/*.{tsx,jsx,ts,js,mjs,astro,css}"];
 var DEFAULT_EXCLUDE = ["**/*.d.ts", "**/*.test.*", "**/*.spec.*", "**/*.stories.*", "**/.storybook/**", "**/.next/**", "**/.astro/**", "**/build/**", "**/out/**", "**/coverage/**", "**/*.config.*"];
 var STYLES = ["**/*.css"];
@@ -5271,7 +5425,7 @@ function idOf(name) {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await readFile6(file, "utf8"));
+    return JSON.parse(await readFile7(file, "utf8"));
   } catch {
     return null;
   }
@@ -5305,10 +5459,10 @@ function detectRoutes(files) {
   return { config: RouteConfig.parse({}), source: "none detected" };
 }
 async function loadInventoryTarget(dir, globs = {}) {
-  const root = resolve4(dir);
-  if (!(await stat2(root).catch(() => null))?.isDirectory()) throw new Error(`${dir} is not a directory`);
-  const config = await readJson(join10(root, PROJECT_FILE));
-  const pkg = await readJson(join10(root, "package.json"));
+  const root = resolve5(dir);
+  if (!(await stat3(root).catch(() => null))?.isDirectory()) throw new Error(`${dir} is not a directory`);
+  const config = await readJson(join11(root, PROJECT_FILE));
+  const pkg = await readJson(join11(root, "package.json"));
   const include = globs.include?.length ? [...globs.include, ...STYLES] : Array.isArray(config?.include) ? [...config.include, ...STYLES] : DEFAULT_INCLUDE;
   const exclude = [...Array.isArray(config?.exclude) ? config.exclude : DEFAULT_EXCLUDE, ...globs.exclude ?? []];
   const tsconfig = typeof config?.tsconfig === "string" ? normalizeRelPath(config.tsconfig) : "tsconfig.json";
@@ -5445,7 +5599,7 @@ async function buildInventory(dirs, options = {}) {
     let id = target.id;
     for (let n = 2; ids.has(id); n++) id = `${target.id}-${n}`;
     ids.add(id);
-    targets.push({ ...target, id, label: relative3(cwd, target.root) || "." });
+    targets.push({ ...target, id, label: relative4(cwd, target.root) || "." });
   }
   const projects = await Promise.all(targets.map((target) => collectProject(target, { definitionRoots: options.definitionRoots === true })));
   const looks = projects.flatMap((p) => p.looks);
@@ -5488,8 +5642,8 @@ async function buildInventory(dirs, options = {}) {
 }
 
 // ../scanner/src/inventory/components.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join11, posix as posix4 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join12, posix as posix4 } from "node:path";
 var SNIPPET_LINES = 6;
 var named = (node2) => node2.children().filter((c) => c.isNamed() && c.kind() !== "comment");
 function functionOf(declaration) {
@@ -5620,7 +5774,7 @@ async function classSites(pass, block) {
     const routes = pass.routes.of(module.file).routes;
     const astro = pass.astro.get(module.file);
     if (astro) {
-      const source = await readFile7(join11(pass.target.root, module.file), "utf8");
+      const source = await readFile8(join12(pass.target.root, module.file), "utf8");
       for (const tag of astro.tags) {
         const classes = [];
         for (const a of tag.attributes.filter((a2) => ["class", "className", "class:list"].includes(a2.name))) {
@@ -5730,9 +5884,9 @@ async function collectComponents(dir, globs = {}) {
     });
   }
   components.sort((a, b) => a.definition.file.localeCompare(b.definition.file) || a.definition.line - b.definition.line);
-  const pkg = await readJson(join11(target.root, "package.json"));
+  const pkg = await readJson(join12(target.root, "package.json"));
   const dependencies = [...new Set(["dependencies", "devDependencies"].flatMap((field) => Object.keys(pkg?.[field] ?? {})))].sort();
-  const ui = (await readJson(join11(target.root, "components.json")))?.aliases?.ui;
+  const ui = (await readJson(join12(target.root, "components.json")))?.aliases?.ui;
   const shadcnUi = typeof ui === "string" ? specifierToDir(ui, aliases) : null;
   const dirs = /* @__PURE__ */ new Map();
   for (const c of components) if (c.definition.kind !== "class" && !c.definition.file.startsWith(`${target.routes.strategy === "expo-router" ? target.routes.appDir : "app"}/`)) dirs.set(posix4.dirname(c.definition.file), (dirs.get(posix4.dirname(c.definition.file)) ?? 0) + 1);
@@ -5752,15 +5906,15 @@ function specifierToDir(specifier, aliases) {
 import { rmSync as rmSync2 } from "node:fs";
 
 // ../scanner/src/specimens/cache.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir } from "node:os";
-import { dirname as dirname4, join as join12 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname5, join as join13 } from "node:path";
 var SPECIMEN_FORMAT = "youiyoux.specimens/5";
 var newStats = () => ({ tailwindCompiles: 0, bundles: 0, hits: 0, misses: 0 });
 function defaultCacheDir(env = process.env) {
   if (env.YOUI_SPECIMEN_CACHE) return env.YOUI_SPECIMEN_CACHE;
-  return join12(env.XDG_CACHE_HOME || join12(homedir(), ".cache"), "youiyoux", "specimens");
+  return join13(env.XDG_CACHE_HOME || join13(homedir2(), ".cache"), "youiyoux", "specimens");
 }
 function versions(root) {
   return Object.fromEntries(
@@ -5768,7 +5922,7 @@ function versions(root) {
       const dir = packageUnderRoot(root, name);
       try {
         if (!dir) return [name, null];
-        return [name, JSON.parse(readFileSync(join12(dir, "package.json"), "utf8")).version];
+        return [name, JSON.parse(readFileSync(join13(dir, "package.json"), "utf8")).version];
       } catch {
         return [name, null];
       }
@@ -5778,17 +5932,17 @@ function versions(root) {
 var EXTRA_INPUTS = ["package.json", "tsconfig.json", "pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lockb"];
 var FONT_DIRS = ["public/fonts", "static/fonts"];
 function specimenKey(root, commit, files, recipes) {
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   hash.update(`${SPECIMEN_FORMAT}\0${commit ?? "no-commit"}\0${JSON.stringify(versions(root))}\0${JSON.stringify(recipes)}\0`);
   const fonts = FONT_DIRS.flatMap((dir) => {
     try {
-      return readdirSync(join12(root, dir)).map((f) => `${dir}/${f}`);
+      return readdirSync(join13(root, dir)).map((f) => `${dir}/${f}`);
     } catch {
       return [];
     }
   });
   for (const file of [.../* @__PURE__ */ new Set([...files, ...EXTRA_INPUTS, ...fonts])].sort()) {
-    const path = join12(root, file);
+    const path = join13(root, file);
     if (!existsSync2(path) || !statSync(path).isFile() || !within(root, path)) continue;
     hash.update(`${file}\0`);
     hash.update(readFileSync(path));
@@ -5797,7 +5951,7 @@ function specimenKey(root, commit, files, recipes) {
   return hash.digest("hex").slice(0, 24);
 }
 function writeJsonAtomic(file, value) {
-  mkdirSync(dirname4(file), { recursive: true });
+  mkdirSync(dirname5(file), { recursive: true });
   writeFileSync2(`${file}.${process.pid}.tmp`, JSON.stringify(value));
   renameSync(`${file}.${process.pid}.tmp`, file);
 }
@@ -5807,22 +5961,22 @@ var SpecimenCache = class {
     this.dir = dir;
   }
   entryDir(project, key) {
-    return join12(this.dir, `${project.replace(/[^a-z0-9-]+/gi, "-")}-${key}`);
+    return join13(this.dir, `${project.replace(/[^a-z0-9-]+/gi, "-")}-${key}`);
   }
   read(project, key) {
     try {
-      return JSON.parse(readFileSync(join12(this.entryDir(project, key), "entry.json"), "utf8"));
+      return JSON.parse(readFileSync(join13(this.entryDir(project, key), "entry.json"), "utf8"));
     } catch {
       return null;
     }
   }
   /** Written to a temporary name and renamed, so a reader never sees half an entry. */
   write(project, key, value) {
-    writeJsonAtomic(join12(this.entryDir(project, key), "entry.json"), value);
+    writeJsonAtomic(join13(this.entryDir(project, key), "entry.json"), value);
   }
   /** A scratch directory for one build (the bundle esbuild makes is evaluated from here). */
   scratch(project, key) {
-    const dir = join12(this.entryDir(project, key), "build");
+    const dir = join13(this.entryDir(project, key), "build");
     mkdirSync(dir, { recursive: true });
     return dir;
   }
@@ -5831,7 +5985,7 @@ var SpecimenCache = class {
 // ../scanner/src/specimens/css.ts
 import { createRequire as createRequire2 } from "node:module";
 import { existsSync as existsSync3, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { basename as basename3, dirname as dirname5, extname, join as join13, posix as posix5, resolve as resolve5 } from "node:path";
+import { basename as basename3, dirname as dirname6, extname, join as join14, posix as posix5, resolve as resolve6 } from "node:path";
 import { Worker } from "node:worker_threads";
 var SCHEMES = ["light", "dark"];
 var TAILWIND_TIMEOUT_MS = 3e4;
@@ -5851,7 +6005,7 @@ function readInside(root, rel) {
   const inside = relativeInside(root, rel);
   if (!("ok" in inside)) return null;
   try {
-    return readFileSync2(join13(root, inside.ok), "utf8");
+    return readFileSync2(join14(root, inside.ok), "utf8");
   } catch {
     return null;
   }
@@ -5866,7 +6020,7 @@ var isFile = (path) => {
 function resolveSheet(root, from, specifier, aliases) {
   let rel = null;
   if (specifier.startsWith(".") && !within(root, from)) {
-    const target = resolve5(dirname5(from), specifier);
+    const target = resolve6(dirname6(from), specifier);
     if (!inPackage(target)) return { refused: `"${specifier}" leaves the package ${displayPath(root, from)}` };
     return existsSync3(target) ? { path: target } : null;
   }
@@ -5878,11 +6032,11 @@ function resolveSheet(root, from, specifier, aliases) {
   if (rel !== null) {
     const inside = relativeInside(root, rel);
     if ("refused" in inside) return { refused: `"${specifier}" is outside the project root` };
-    return existsSync3(join13(root, inside.ok)) ? { path: join13(root, inside.ok) } : null;
+    return existsSync3(join14(root, inside.ok)) ? { path: join14(root, inside.ok) } : null;
   }
   if (!packageUnderRoot(root, specifier)) return packageName(specifier) ? { refused: `"${specifier}" is not a package in the project's node_modules` } : null;
   try {
-    return { path: createRequire2(join13(root, "package.json")).resolve(specifier) };
+    return { path: createRequire2(join14(root, "package.json")).resolve(specifier) };
   } catch {
     return null;
   }
@@ -5915,7 +6069,7 @@ function importedSheets(root, files, tsconfig, warnings) {
     if (source === null) continue;
     if (file.endsWith(".astro")) source = /^\s*---\r?\n([\s\S]*?)\r?\n---/.exec(source)?.[1] ?? "";
     for (const match of source.matchAll(CSS_IMPORT)) {
-      const sheet = resolveSheet(root, join13(root, file), match[1], aliases);
+      const sheet = resolveSheet(root, join14(root, file), match[1], aliases);
       if (sheet && "refused" in sheet) warnings.push(`${file}: refused import ${sheet.refused}`);
       else if (sheet && !found.some((f) => f.path === sheet.path)) found.push({ path: sheet.path, sheet: displayPath(root, sheet.path), via: `import in ${file}` });
     }
@@ -5959,13 +6113,13 @@ function sourceReadSheets(root, files, warnings) {
       for (const candidate of candidates) {
         const inside = relativeInside(root, candidate);
         if ("refused" in inside) refused ??= inside.refused;
-        else if (isFile(join13(root, inside.ok))) {
+        else if (isFile(join14(root, inside.ok))) {
           sheet = inside.ok;
           break;
         }
       }
       if (sheet !== null) {
-        if (!found.some((f) => realOf(f.path) === realOf(join13(root, sheet)))) found.push({ path: join13(root, sheet), sheet, via });
+        if (!found.some((f) => realOf(f.path) === realOf(join14(root, sheet)))) found.push({ path: join14(root, sheet), sheet, via });
       } else if (refused !== null) warnings.push(`${file}: refused ${call ?? (urlPath ? "new URL" : `?${query} import`)} of "${read.path}": ${refused}`);
     }
   }
@@ -5978,9 +6132,9 @@ function tailwindCliBuilds(root) {
   const scripts = readPackage(root).scripts ?? {};
   const builds = [];
   for (const [script, command] of Object.entries(scripts)) {
-    for (const run2 of command.split(/&&|\|\||[;&|]/)) {
-      if (!/(?:^|[\s/])(?:@tailwindcss\/cli|tailwindcss)(?:@[\w.^~-]+)?(?:\s|$)/.test(run2)) continue;
-      const arg = (short2, long) => new RegExp(`(?:\\s-${short2}|\\s--${long})(?:=|\\s+)["']?([^\\s"']+)`).exec(` ${run2}`)?.[1] ?? null;
+    for (const run3 of command.split(/&&|\|\||[;&|]/)) {
+      if (!/(?:^|[\s/])(?:@tailwindcss\/cli|tailwindcss)(?:@[\w.^~-]+)?(?:\s|$)/.test(run3)) continue;
+      const arg = (short2, long) => new RegExp(`(?:\\s-${short2}|\\s--${long})(?:=|\\s+)["']?([^\\s"']+)`).exec(` ${run3}`)?.[1] ?? null;
       const input = arg("i", "input");
       const output = arg("o", "output");
       if (input && output) builds.push({ script, input: posix5.normalize(input), output: posix5.normalize(output) });
@@ -6011,14 +6165,14 @@ function linkTarget(root, file, href, builds, entries) {
   if (built) {
     const input = relativeInside(root, built.input);
     if ("refused" in input) return { refused: `package.json "${built.script}" builds it from ${built.input}, outside the project root` };
-    if (isFile(join13(root, input.ok))) return { path: join13(root, input.ok), sheet: input.ok, via: `${where2}, built by package.json "${built.script}"` };
+    if (isFile(join14(root, input.ok))) return { path: join14(root, input.ok), sheet: input.ok, via: `${where2}, built by package.json "${built.script}"` };
   }
-  if (path.endsWith(".css") && isFile(join13(root, path))) return { path: join13(root, path), sheet: path, via: where2 };
+  if (path.endsWith(".css") && isFile(join14(root, path))) return { path: join14(root, path), sheet: path, via: where2 };
   const entry = entries.find((e) => basename3(e) === basename3(path));
-  if (entry) return { path: join13(root, entry), sheet: entry, via: `${where2}, the Tailwind entry of that name` };
+  if (entry) return { path: join14(root, entry), sheet: entry, via: `${where2}, the Tailwind entry of that name` };
   for (const dir of PUBLIC_DIRS) {
     const publicFile = relativeInside(root, `${dir}/${path}`);
-    if ("ok" in publicFile && isFile(join13(root, publicFile.ok))) return { path: join13(root, publicFile.ok), sheet: publicFile.ok, via: where2 };
+    if ("ok" in publicFile && isFile(join14(root, publicFile.ok))) return { path: join14(root, publicFile.ok), sheet: publicFile.ok, via: where2 };
   }
   return null;
 }
@@ -6042,15 +6196,15 @@ function findStylesheets(root, files, options = {}) {
     for (const entry of options.override) {
       const inside = relativeInside(root, entry);
       if ("refused" in inside) warnings.push(`${from} specimens.css: refused ${inside.refused}`);
-      else if (!isFile(join13(root, inside.ok))) warnings.push(`${from} specimens.css: ${entry} does not exist`);
-      else add({ path: join13(root, inside.ok), sheet: inside.ok, via: `specimens.css in ${from}` });
+      else if (!isFile(join14(root, inside.ok))) warnings.push(`${from} specimens.css: ${entry} does not exist`);
+      else add({ path: join14(root, inside.ok), sheet: inside.ok, via: `specimens.css in ${from}` });
     }
     return { found, remote, warnings, skipped };
   }
   for (const sheet of sourceReadSheets(root, files, warnings)) add(sheet);
   const builds = tailwindCliBuilds(root);
   const sheetsInProject = files.filter((f) => f.endsWith(".css"));
-  const entries = sheetsInProject.filter((f) => "ok" in relativeInside(root, f) && isTailwindEntry(join13(root, f)));
+  const entries = sheetsInProject.filter((f) => "ok" in relativeInside(root, f) && isTailwindEntry(join14(root, f)));
   const templates = [...options.templates ?? []].sort((a, b) => Number(b === "index.html") - Number(a === "index.html") || a.split("/").length - b.split("/").length || a.localeCompare(b));
   const modules = files.filter((f) => MODULE.test(f)).sort();
   for (const file of [...templates, ...modules]) {
@@ -6074,14 +6228,14 @@ function findStylesheets(root, files, options = {}) {
       if (target && "ok" in target) imported.add(target.ok);
     }
   }
-  const unreferenced = entries.filter((entry) => !imported.has(entry) && !found.some((f) => realOf(f.path) === realOf(join13(root, entry))));
+  const unreferenced = entries.filter((entry) => !imported.has(entry) && !found.some((f) => realOf(f.path) === realOf(join14(root, entry))));
   if (found.some((f) => isTailwindEntry(f.path))) skipped.push(...unreferenced);
-  else for (const entry of unreferenced) add({ path: join13(root, entry), sheet: entry, via: "a Tailwind entry no module imports" });
+  else for (const entry of unreferenced) add({ path: join14(root, entry), sheet: entry, via: "a Tailwind entry no module imports" });
   return { found, remote, warnings, skipped };
 }
 function readPackage(root) {
   try {
-    return JSON.parse(readFileSync2(join13(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync2(join14(root, "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -6091,10 +6245,10 @@ var majorOf = (range) => {
   return match && !/^(?:\*|latest|workspace:|link:|file:)/.test(range ?? "") ? Number(match[1]) : null;
 };
 function resolveFromProject(root, id) {
-  const bases = [join13(root, "package.json")];
+  const bases = [join14(root, "package.json")];
   for (const integration of ["@tailwindcss/vite", "@tailwindcss/postcss", "@tailwindcss/cli"]) {
     const dir = packageUnderRoot(root, integration);
-    if (dir) bases.push(join13(dir, "package.json"));
+    if (dir) bases.push(join14(dir, "package.json"));
   }
   for (const [i, base] of bases.entries()) {
     if (i === 0 && !packageUnderRoot(root, id)) continue;
@@ -6112,7 +6266,7 @@ function projectTailwind(root) {
   const dir = packageUnderRoot(root, "tailwindcss");
   try {
     if (!dir) throw new Error("not installed");
-    version = JSON.parse(readFileSync2(join13(dir, "package.json"), "utf8")).version;
+    version = JSON.parse(readFileSync2(join14(dir, "package.json"), "utf8")).version;
   } catch {
     return { version: null, node: null, oxide: null, note: declared ? `tailwindcss ${declared} is declared but not installed in the project's node_modules: run the project's install` : "no Tailwind" };
   }
@@ -6160,7 +6314,7 @@ function inlineFonts(root, css, warnings) {
     }
     const served = path.replace(/^\/+/, "");
     let refused = false;
-    const file = PUBLIC_DIRS.map((dir) => [join13(root, dir), join13(root, dir, served)]).find(([dir, candidate]) => {
+    const file = PUBLIC_DIRS.map((dir) => [join14(root, dir), join14(root, dir, served)]).find(([dir, candidate]) => {
       if (!existsSync3(candidate)) return false;
       if (within(root, candidate) && within(dir, candidate)) return true;
       refused = true;
@@ -6492,7 +6646,7 @@ ${STATES_MARKER}
 
 // ../scanner/src/specimens/render.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join14, posix as posix6, resolve as resolve6 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join15, posix as posix6, resolve as resolve7 } from "node:path";
 import { Worker as Worker2 } from "node:worker_threads";
 function withNamePlaceholders(job) {
   const names = /* @__PURE__ */ new Set(["id", "title", "aria-label", "alt", "children"]);
@@ -6634,7 +6788,7 @@ function checkedTsconfig(root, tsconfig) {
     seen.add(current);
     const inside = relativeInside(root, current);
     if ("refused" in inside) return { refused: `tsconfig ${current}: ${inside.refused}` };
-    const file = join14(root, inside.ok);
+    const file = join15(root, inside.ok);
     if (!existsSync4(file)) return first === null ? { path: null } : { refused: `tsconfig ${current} does not exist` };
     first ??= file;
     let extend;
@@ -6651,7 +6805,17 @@ function checkedTsconfig(root, tsconfig) {
   }
   return { path: first };
 }
+var SERVICE_GONE = /^The service (is no longer running|was stopped)/;
 async function bundleWithin(options, timeoutMs, signal) {
+  try {
+    return await bundleOnce(options, timeoutMs, signal);
+  } catch (error) {
+    if (!(error instanceof Error && SERVICE_GONE.test(error.message))) throw error;
+    await (await import("esbuild")).stop();
+    return await bundleOnce(options, timeoutMs, signal);
+  }
+}
+async function bundleOnce(options, timeoutMs, signal) {
   signal?.throwIfAborted();
   const esbuild = await import("esbuild");
   const context = await esbuild.context({ ...options, write: false });
@@ -6770,7 +6934,7 @@ async function renderComponents(root, tsconfig, jobs, scratch, stats, options =
         stdin: { contents: entry, resolveDir: root, loader: "tsx", sourcefile: "youi-specimens.tsx" },
         absWorkingDir: scratch,
         bundle: true,
-        outfile: join14(scratch, "bundle.cjs"),
+        outfile: join15(scratch, "bundle.cjs"),
         platform: "node",
         format: "cjs",
         jsx: "automatic",
@@ -6785,7 +6949,7 @@ async function renderComponents(root, tsconfig, jobs, scratch, stats, options =
     );
     for (const input of read) {
       if (/^[a-z-]+:/.test(input)) continue;
-      const inside = relativeInside(root, resolve6(scratch, input));
+      const inside = relativeInside(root, resolve7(scratch, input));
       if ("ok" in inside && !inside.ok.split("/").includes("node_modules")) inputs.add(inside.ok);
     }
     return text;
@@ -6826,7 +6990,7 @@ async function renderComponents(root, tsconfig, jobs, scratch, stats, options =
     else renderable.push(job);
   }
   if (code !== null && renderable.length > 0) {
-    const bundle = join14(scratch, "bundle.cjs");
+    const bundle = join15(scratch, "bundle.cjs");
     writeFileSync3(bundle, code);
     const results = await renderInWorkers(bundle, renderable, options.renderTimeoutMs ?? RENDER_TIMEOUT_MS, TOTAL_TIMEOUT_MS);
     for (const job of renderable) {
@@ -6842,7 +7006,7 @@ async function renderComponents(root, tsconfig, jobs, scratch, stats, options =
 
 // ../scanner/src/specimens/client.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 var ENTRY = "youi-try.js";
 var MAX_SIBLINGS = 6;
 var digestOf = (path) => {
@@ -6919,14 +7083,14 @@ async function bundleForBrowser(root, tsconfig, job, siblings = [], options = {}
     if (!packageUnderRoot(root, "react") || !packageUnderRoot(root, "react-dom")) return { error: "react and react-dom are not installed in the project's node_modules" };
     const looks = siblings.length > 0 ? siblings.slice(0, MAX_SIBLINGS) : [job];
     const wrappers = job.recipe.wrappers;
-    const relative5 = /* @__PURE__ */ new Map();
+    const relative6 = /* @__PURE__ */ new Map();
     for (const file of [...looks.map((l) => l.recipe.file), ...wrappers.map((w) => w.file)]) {
       const checked = relativeInside(root, file);
       if ("refused" in checked) return { error: `refused: ${checked.refused}` };
-      relative5.set(file, checked.ok);
+      relative6.set(file, checked.ok);
     }
-    const inside = (file) => relative5.get(file);
-    const files = [...new Set(relative5.values())];
+    const inside = (file) => relative6.get(file);
+    const files = [...new Set(relative6.values())];
     const config = checkedTsconfig(root, tsconfig);
     const refusals = /* @__PURE__ */ new Set();
     const entry = [
@@ -6972,7 +7136,7 @@ async function bundleForBrowser(root, tsconfig, job, siblings = [], options = {}
     const base = realOf(root);
     for (const input of built.inputs) {
       if (input === "<stdin>" || input === ENTRY || /^[\w-]+:/.test(input)) continue;
-      const path = resolve7(base, input);
+      const path = resolve8(base, input);
       inputs.push({ path, digest: digestOf(path) ?? "missing" });
     }
     return { hash: sha256(built.text).slice(0, 16), code: built.text, inputs };
@@ -7060,8 +7224,8 @@ var BrowserBundleCache = class {
 };
 
 // ../scanner/src/specimens/theme-fit.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 var SIZES = "xs|sm|base|lg|xl|[2-9]xl";
 var RADII = "none|xs|sm|md|lg|xl|2xl|3xl|4xl|full";
 var RADIUS_CLASS = new RegExp(`^rounded(?:-(?:t|r|b|l|s|e|tl|tr|br|bl|ss|se|es|ee))?(?:-(${RADII}|\\[[^\\]]+\\]))?$`);
@@ -7173,16 +7337,16 @@ function themeFit({ theme, item, project, cssVars }) {
 async function projectTheme(root) {
   const target = await loadInventoryTarget(root);
   const files = target.files.filter((f) => !("refused" in relativeInside(root, f)));
-  const sheets = await Promise.all(files.filter((f) => f.endsWith(".css")).map(async (f) => readStylesheet(f, await readFile8(join15(root, f), "utf8").catch(() => ""))));
-  const pkg = JSON.parse(await readFile8(join15(root, "package.json"), "utf8").catch(() => "{}"));
+  const sheets = await Promise.all(files.filter((f) => f.endsWith(".css")).map(async (f) => readStylesheet(f, await readFile9(join16(root, f), "utf8").catch(() => ""))));
+  const pkg = JSON.parse(await readFile9(join16(root, "package.json"), "utf8").catch(() => "{}"));
   const theme = await buildTheme(root, sheets, Boolean(pkg.dependencies?.tailwindcss ?? pkg.devDependencies?.tailwindcss));
-  const sources = await Promise.all(files.filter((f) => /\.(?:tsx|jsx)$/.test(f)).slice(0, 400).map((f) => readFile8(join15(root, f), "utf8").catch(() => "")));
+  const sources = await Promise.all(files.filter((f) => /\.(?:tsx|jsx)$/.test(f)).slice(0, 400).map((f) => readFile9(join16(root, f), "utf8").catch(() => "")));
   return { theme, sources };
 }
 
 // ../scanner/src/specimens/preview-bundle.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
-import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute3, join as join16, resolve as resolve8, sep as sep2 } from "node:path";
+import { basename as basename4, dirname as dirname7, isAbsolute as isAbsolute3, join as join17, resolve as resolve9, sep as sep2 } from "node:path";
 var NAMESPACE2 = "youi-preview";
 var GUARDED2 = "youiPreviewGuarded";
 var ENTRY2 = "youi-preview.js";
@@ -7341,7 +7505,7 @@ function projectCn(root, tsconfig) {
   for (const [prefix, target] of tsconfigAliases(root, tsconfig)) {
     if (prefix !== "@/" && prefix !== "~/") continue;
     for (const ext of [".ts", ".tsx", ".js"]) {
-      const file = join16(root, target, `lib/utils${ext}`);
+      const file = join17(root, target, `lib/utils${ext}`);
       if (existsSync5(file) && within(root, file) && /\bexport\s+(?:function|const|let)\s+cn\b|\bexport\s*\{[^}]*\bcn\b/.test(readFileSync5(file, "utf8"))) return file;
     }
   }
@@ -7351,7 +7515,7 @@ async function bundlePreview(job, options = {}) {
   const { root, dir, fallback = null } = job;
   try {
     if (!packageUnderRoot(root, "react") || !packageUnderRoot(root, "react-dom")) return { error: "react and react-dom are not installed in your project's node_modules, so nothing can be drawn" };
-    if (!existsSync5(join16(dir, job.main))) return { error: "the preview's files are missing; open it again" };
+    if (!existsSync5(join17(dir, job.main))) return { error: "the preview's files are missing; open it again" };
     const config = checkedTsconfig(root, job.tsconfig);
     const aliases = tsconfigAliases(root, job.tsconfig);
     const notes = /* @__PURE__ */ new Set();
@@ -7360,7 +7524,7 @@ async function bundlePreview(job, options = {}) {
     const radix = /* @__PURE__ */ new Map();
     const cnFile = projectCn(root, job.tsconfig);
     const partFiles = new Set((job.projectParts ?? []).filter((file) => within(root, file)).map(realOf));
-    const codeRoots = [dir, ...aliases.map(([, target]) => join16(root, target)), join16(root, "node_modules"), ...fallback ? [join16(fallback, "node_modules")] : []];
+    const codeRoots = [dir, ...aliases.map(([, target]) => join17(root, target)), join17(root, "node_modules"), ...fallback ? [join17(fallback, "node_modules")] : []];
     const previewRefusal = (spec, path) => {
       if (!PREVIEW_CODE.test(path)) return `a preview may import code only (.ts, .tsx, .js, .jsx, .mjs, .cjs, .css), not ${basename4(path)}`;
       const name = packageName(spec);
@@ -7418,7 +7582,7 @@ async function bundlePreview(job, options = {}) {
             const at = args.importer.lastIndexOf(`${sep2}node_modules${sep2}`) + `${sep2}node_modules${sep2}`.length;
             const rest = args.importer.slice(at).split(sep2);
             const base = args.importer.slice(0, at) + rest.slice(0, rest[0].startsWith("@") ? 2 : 1).join(sep2);
-            const target = resolve8(dirname6(args.importer), args.path);
+            const target = resolve9(dirname7(args.importer), args.path);
             if (target.startsWith(base + sep2)) return void 0;
           }
           const again = (path, resolveDir) => build.resolve(path, { importer: args.importer, resolveDir, kind: args.kind, pluginData: { [GUARDED2]: true }, with: args.with });
@@ -7428,7 +7592,7 @@ async function bundlePreview(job, options = {}) {
             const name = packageName(spec);
             const alias = aliases.find(([prefix]) => spec.startsWith(prefix) && prefix.endsWith("/"));
             if (alias) {
-              result = await again(join16(realOf(root), alias[1], spec.slice(alias[0].length)), realOf(root));
+              result = await again(join17(realOf(root), alias[1], spec.slice(alias[0].length)), realOf(root));
               if (result.errors.length > 0) {
                 refusals.add(`it needs ${spec}, which your project does not have`);
                 return { errors: [{ text: `missing ${spec}` }] };
@@ -7506,7 +7670,7 @@ async function bundlePreview(job, options = {}) {
     const inputs = [];
     for (const input of built.inputs) {
       if (input === "<stdin>" || input === ENTRY2 || /^[\w-]+:/.test(input)) continue;
-      const path = resolve8(realOf(dir), input);
+      const path = resolve9(realOf(dir), input);
       inputs.push({ path, digest: digestOf2(path) ?? "missing" });
     }
     return { hash: sha256(built.text).slice(0, 16), code: built.text, inputs, notes: [...notes] };
@@ -7591,12 +7755,12 @@ async function projectSpecimens(project, options = {}) {
 }
 
 // ../scanner/src/specimens/shots.ts
-import { execFile as execFile2 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { execFile as execFile3 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync6, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname7, extname as extname2, isAbsolute as isAbsolute4, join as join17, relative as relative4 } from "node:path";
-import { promisify as promisify2 } from "node:util";
+import { dirname as dirname8, extname as extname2, isAbsolute as isAbsolute4, join as join18, relative as relative5 } from "node:path";
+import { promisify as promisify3 } from "node:util";
 var SHOTS_FORMAT = "youiyoux.shots/4";
 var SHOT_WIDTHS = [1280, 390];
 var MAX_LOOKS = 8;
@@ -7607,15 +7771,15 @@ var newShotStats = () => ({ ...newStats(), renders: 0, baseRenders: 0, browsers:
 var RenderUnavailableError = class extends Error {
   name = "RenderUnavailableError";
 };
-var exec = promisify2(execFile2);
+var exec = promisify3(execFile3);
 var slug = (text) => `${text.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").slice(-48) || "component"}-${sha256(text).slice(0, 8)}`;
 var SOURCE = /\.(?:tsx|ts|jsx|js|mjs|cjs|mts|cts)$/;
 var PAGE_BACKGROUND = "html{background-color:Canvas;color:CanvasText}";
 var PAGE_CSS = `body{margin:0}.youi-shots{display:flex;flex-direction:column;align-items:flex-start;gap:20px;padding:24px;box-sizing:border-box;max-width:100%}.youi-look{max-width:100%}.youi-caption{margin:0 0 6px;font:12px/16px ui-monospace,SFMono-Regular,Menlo,monospace;color:#888}*,*::before,*::after{animation:none!important;transition:none!important;caret-color:transparent!important}`;
-async function git(root, args) {
+async function git2(root, args) {
   return (await exec("git", [...args], { cwd: root, maxBuffer: 64 * 1024 * 1024, encoding: "utf8" })).stdout;
 }
-var gitOr = (root, args) => git(root, args).catch(() => null);
+var gitOr = (root, args) => git2(root, args).catch(() => null);
 async function resolveBase(root, asked) {
   if ((await gitOr(root, ["rev-parse", "--is-inside-work-tree"]))?.trim() !== "true") return { none: "no base: not a git checkout" };
   if (asked !== void 0) {
@@ -7630,8 +7794,8 @@ async function resolveBase(root, asked) {
   return head ? { ref: "HEAD", commit: head } : { none: "no base: the repository has no commits yet" };
 }
 async function changedSince(root, commit) {
-  const tracked = await git(root, ["diff", "--name-only", "-z", "--relative", commit, "--"]);
-  const untracked = await git(root, ["ls-files", "--others", "--exclude-standard", "-z", "--", "."]);
+  const tracked = await git2(root, ["diff", "--name-only", "-z", "--relative", commit, "--"]);
+  const untracked = await git2(root, ["ls-files", "--others", "--exclude-standard", "-z", "--", "."]);
   return new Set([...tracked.split("\0"), ...untracked.split("\0")].filter(Boolean));
 }
 var atBase = (root, commit, file) => gitOr(root, ["show", `${commit}:./${file}`]);
@@ -7694,7 +7858,7 @@ function groupOf(root, rawLooks, target, file) {
     if (sited.length > 0) return { name: target, file, looks: distinct(sited.map((l) => ({ recipe: l.recipe, role: l.role }))), notes: [`no site renders a component defined in ${file}: drawn are the looks its own markup renders`] };
     let source = "";
     try {
-      source = SOURCE.test(file) ? readFileSync6(join17(root, file), "utf8") : "";
+      source = SOURCE.test(file) ? readFileSync6(join18(root, file), "utf8") : "";
     } catch {
     }
     const names = exportedComponents(source);
@@ -7754,7 +7918,7 @@ var Eyes = class {
   }
   async open() {
     if (this.browser) return this.browser;
-    const { launchBrowser } = await import("./src-VL2ZYO6X.js");
+    const { launchBrowser } = await import("./src-YYI52B5R.js");
     try {
       this.browser = await launchBrowser(this.options.executablePath, { purpose: { what: "youiyoux render", command: "youiyoux render" }, ...this.options.download === false ? { download: false } : {}, ...this.options.log ? { log: this.options.log } : {} });
     } catch (error) {
@@ -7781,7 +7945,7 @@ var Eyes = class {
         if (audit) await page.addScriptTag({ content: this.axeSource() });
         for (const width of SHOT_WIDTHS) {
           await page.setViewportSize({ width, height: VIEWPORT_HEIGHT });
-          const path = join17(dir, `${scheme}-${width}.png`);
+          const path = join18(dir, `${scheme}-${width}.png`);
           await page.screenshot({ path, fullPage: true, animations: "disabled", caret: "hide" });
           shots.push({ scheme, width, path });
           if (audit) {
@@ -7817,11 +7981,11 @@ var Eyes = class {
 };
 function issuesOf(runs, looks) {
   const entries = /* @__PURE__ */ new Map();
-  for (const run2 of runs) for (const v of run2.found) for (const node2 of v.nodes) {
+  for (const run3 of runs) for (const v of run3.found) for (const node2 of v.nodes) {
     const key = `${v.id}\0${node2.look}\0${node2.path}`;
     const entry = entries.get(key) ?? { v, node: node2, schemes: /* @__PURE__ */ new Set(), widths: /* @__PURE__ */ new Set() };
-    entry.schemes.add(run2.scheme);
-    entry.widths.add(run2.width);
+    entry.schemes.add(run3.scheme);
+    entry.widths.add(run3.width);
     entries.set(key, entry);
   }
   const order = ["critical", "serious", "moderate", "minor"];
@@ -7857,10 +8021,10 @@ function compareA11yIssues(after, before2) {
   return [...result, ...remaining.map((issue) => ({ ...issue, status: "fixed" }))];
 }
 function contentHash(root, files) {
-  const hash = createHash2("sha256");
+  const hash = createHash3("sha256");
   for (const file of [...new Set(files)].sort()) {
     hash.update(`${file}\0`);
-    const path = join17(root, file);
+    const path = join18(root, file);
     try {
       if (statSync3(path).isFile()) hash.update(readFileSync6(path));
     } catch {
@@ -7879,7 +8043,7 @@ function readManifest(file) {
   }
 }
 function prune(dir, prefix, keep) {
-  for (const name of existsSync6(dir) ? readdirSync2(dir) : []) if (name.startsWith(prefix) && name !== keep) rmSync3(join17(dir, name), { recursive: true, force: true });
+  for (const name of existsSync6(dir) ? readdirSync2(dir) : []) if (name.startsWith(prefix) && name !== keep) rmSync3(join18(dir, name), { recursive: true, force: true });
 }
 var allExist = (paths) => paths.every((p) => existsSync6(p));
 async function renderShots(rootDir, targets, options = {}) {
@@ -7890,7 +8054,7 @@ async function renderShots(rootDir, targets, options = {}) {
   const target = await loadInventoryTarget(root);
   const report = await buildInventory([root], { cwd: root });
   const project = report.projects[0]?.id ?? target.id;
-  const dir = join17(cache.dir, "shots", `${slug(project)}-${sha256(root).slice(0, 8)}`);
+  const dir = join18(cache.dir, "shots", `${slug(project)}-${sha256(root).slice(0, 8)}`);
   const notes = [];
   const base = await resolveBase(root, options.base);
   const baseNote = "none" in base ? base.none : null;
@@ -7900,21 +8064,21 @@ async function renderShots(rootDir, targets, options = {}) {
   const unchanged = [];
   if (targets.length > 0) {
     for (const asked of targets) {
-      const path = isAbsolute4(asked) ? asked : join17(root, asked);
+      const path = isAbsolute4(asked) ? asked : join18(root, asked);
       const fileLike = /[\\/]/.test(asked) || extname2(asked) !== "" || existsSync6(path);
       if (!fileLike) {
         groups.push(groupOf(root, sited, asked, null));
         continue;
       }
-      const inside = relativeInside(root, relative4(root, realOf(path)));
+      const inside = relativeInside(root, relative5(root, realOf(path)));
       if ("refused" in inside) groups.push({ name: asked, file: null, looks: [], notes: [`${asked}: ${inside.refused}; pass a file inside the project`] });
-      else if (!existsSync6(join17(root, inside.ok))) groups.push({ name: asked, file: null, looks: [], notes: [`${inside.ok} does not exist in the project`] });
+      else if (!existsSync6(join18(root, inside.ok))) groups.push({ name: asked, file: null, looks: [], notes: [`${inside.ok} does not exist in the project`] });
       else groups.push(groupOf(root, sited, inside.ok, inside.ok));
     }
   } else {
     if (baseNote) notes.push(`${baseNote}: with no target, nothing is known to have changed; pass a file or component name`);
     const files = [...new Set(sited.flatMap((l) => l.recipe?.kind === "component" ? [l.recipe.file] : []))].sort();
-    const saved = existsSync6(dir) ? readdirSync2(dir).map((name) => readManifest(join17(dir, name, "manifest.json"))).filter((m) => m !== null) : [];
+    const saved = existsSync6(dir) ? readdirSync2(dir).map((name) => readManifest(join18(dir, name, "manifest.json"))).filter((m) => m !== null) : [];
     const touched = (inputs) => inputs.some((f) => changed.has(f));
     for (const file of files) {
       const wrappersOf = sited.flatMap((l) => l.recipe?.kind === "component" && l.recipe.file === file ? l.recipe.wrappers.map((w) => w.file) : []);
@@ -7930,12 +8094,12 @@ async function renderShots(rootDir, targets, options = {}) {
   const components = [];
   const pending = [];
   for (const group of groups) {
-    const groupDir = join17(dir, slug(group.file ?? group.name));
+    const groupDir = join18(dir, slug(group.file ?? group.name));
     if (group.looks.length === 0) {
       components.push({ component: group.name, file: group.file, looks: [], shots: [], a11y: [], diff: { none: "nothing drawn" }, cached: false, notes: group.notes });
       continue;
     }
-    const manifest = readManifest(join17(groupDir, "manifest.json"));
+    const manifest = readManifest(join18(groupDir, "manifest.json"));
     if (manifest && manifest.key === keyOf2(group, manifest.inputs) && allExist([...manifest.result.shots.map((s) => s.path), ..."shots" in manifest.result.diff ? manifest.result.diff.shots.flatMap((d) => [d.before, d.after, d.diff]) : []])) {
       stats.hits++;
       components.push({ ...manifest.result, component: group.name, cached: true });
@@ -7953,13 +8117,13 @@ async function renderShots(rootDir, targets, options = {}) {
       if ("commit" in base) {
         const sources = [...changed].filter((f) => SOURCE.test(f)).sort();
         if (sources.length > MAX_OVERLAY) notes.push(`${sources.length} source files differ from ${base.ref}: the first ${MAX_OVERLAY} are drawn as they were there, the rest as they are now`);
-        baseSources = join17(dir, `base-${base.commit.slice(0, 12)}`);
+        baseSources = join18(dir, `base-${base.commit.slice(0, 12)}`);
         for (const file of sources.slice(0, MAX_OVERLAY)) {
           const contents = await atBase(root, base.commit, file);
-          for (const key of [join17(root, file), join17(rootDir, file)]) overlay.set(key, contents);
+          for (const key of [join18(root, file), join18(rootDir, file)]) overlay.set(key, contents);
           if (contents !== null) {
-            const copy = join17(baseSources, file);
-            mkdirSync2(dirname7(copy), { recursive: true });
+            const copy = join18(baseSources, file);
+            mkdirSync2(dirname8(copy), { recursive: true });
             writeFileSync4(copy, contents);
           }
         }
@@ -7977,7 +8141,7 @@ async function renderShots(rootDir, targets, options = {}) {
         }
         const namedJobs = jobs.map(withNamePlaceholders);
         const draw = async (side) => {
-          const scratch = join17(groupDir, `build-${side}`);
+          const scratch = join18(groupDir, `build-${side}`);
           mkdirSync2(scratch, { recursive: true });
           try {
             const rendered = await renderComponents(root, target.tsconfig, namedJobs, scratch, stats, side === "before" ? { overlay } : {});
@@ -7997,7 +8161,7 @@ async function renderShots(rootDir, targets, options = {}) {
         const inputs = [.../* @__PURE__ */ new Set([...after.inputs, ...group.file ? [group.file] : []])].sort();
         const key = keyOf2(group, inputs);
         const pages = (looks) => ({ light: pageHtml(group.name, sheetOf("light"), "light", looks), dark: pageHtml(group.name, sheetOf("dark"), "dark", looks) });
-        const afterDir = join17(groupDir, `after-${key}`);
+        const afterDir = join18(groupDir, `after-${key}`);
         const shot = await eyes.shoot(afterDir, pages(after.looks), true);
         stats.renders++;
         prune(groupDir, "after-", `after-${key}`);
@@ -8014,9 +8178,9 @@ async function renderShots(rootDir, targets, options = {}) {
         } else {
           const identity = group.looks.map((l) => l.recipe.kind === "component" ? [l.key, l.dynamic, l.namedAtEverySite, l.recipe.file, l.recipe.export, l.recipe.props, l.recipe.label, l.recipe.wrappers, l.role] : [l.recipe, l.role]);
           const beforeKey = sha256(`${common}\0${JSON.stringify(identity)}\0${JSON.stringify(inputs)}`).slice(0, 24);
-          const beforeDir = join17(groupDir, `before-${beforeKey}`);
-          let beforeShots = SCHEMES.flatMap((scheme) => SHOT_WIDTHS.map((width) => ({ scheme, width, path: join17(beforeDir, `${scheme}-${width}.png`) })));
-          const issuesFile = join17(beforeDir, "issues.json");
+          const beforeDir = join18(groupDir, `before-${beforeKey}`);
+          let beforeShots = SCHEMES.flatMap((scheme) => SHOT_WIDTHS.map((width) => ({ scheme, width, path: join18(beforeDir, `${scheme}-${width}.png`) })));
+          const issuesFile = join18(beforeDir, "issues.json");
           if (!allExist([...beforeShots.map((s) => s.path), issuesFile])) {
             const before2 = await draw("before");
             for (const look of before2.looks) if (look.failed && look.recipe.kind === "component") groupNotes.push(`before (${base.ref}): ${look.recipe.file}#${look.recipe.export} did not render (${look.failed})`);
@@ -8030,7 +8194,7 @@ async function renderShots(rootDir, targets, options = {}) {
           const shots = [];
           for (const s of shot.shots) {
             const b = beforeShots.find((x) => x.scheme === s.scheme && x.width === s.width);
-            const out = join17(afterDir, `diff-${s.scheme}-${s.width}.png`);
+            const out = join18(afterDir, `diff-${s.scheme}-${s.width}.png`);
             shots.push({ scheme: s.scheme, width: s.width, before: b.path, after: s.path, diff: out, changed: await eyes.diff(b.path, s.path, out) });
           }
           diff = { base: `${base.ref} (${base.commit.slice(0, 7)})`, shots };
@@ -8039,7 +8203,7 @@ async function renderShots(rootDir, targets, options = {}) {
         }
         if (changedSheets.length > 0 && "shots" in diff) groupNotes.push(`stylesheets changed since ${"commit" in base ? base.ref : "the base"} (${changedSheets.join(", ")}): both sides use today's CSS, so the diff shows component changes only`);
         const result = { component: group.name, file: group.file, looks: after.looks.map((l) => l.caption), shots: shot.shots, a11y, diff, cached: false, notes: groupNotes };
-        writeJsonAtomic(join17(groupDir, "manifest.json"), { format: SHOTS_FORMAT, name: group.name, file: group.file, key, inputs, result });
+        writeJsonAtomic(join18(groupDir, "manifest.json"), { format: SHOTS_FORMAT, name: group.name, file: group.file, key, inputs, result });
         components[index] = result;
       }
     } finally {
@@ -8083,7 +8247,7 @@ function shotsText(report, again = (t) => `run youiyoux render${t ? ` ${t}` : ""
       const moved = c.diff.shots.filter((d) => d.changed > 0);
       lines.push(moved.length === 0 ? `  before/after against ${c.diff.base}: no visible change` : `  before/after against ${c.diff.base}: pixels changed ${moved.map((d) => `${percent(d.changed)} in ${d.scheme} ${d.width}`).join(", ")}`);
       for (const d of moved) lines.push(`    diff ${d.scheme} ${d.width}: ${d.diff}`);
-      if (c.diff.shots[0]) lines.push(`    before images: ${dirname7(c.diff.shots[0].before)}`);
+      if (c.diff.shots[0]) lines.push(`    before images: ${dirname8(c.diff.shots[0].before)}`);
     } else lines.push(`  before/after: ${c.diff.none}`);
     if (c.a11y.length === 0) lines.push("  accessibility: no issues axe can find (WCAG 2.2 A and AA, both schemes and widths)");
     else {
@@ -8107,8 +8271,8 @@ function shotsText(report, again = (t) => `run youiyoux render${t ? ` ${t}` : ""
 
 // ../scanner/src/screens/capture.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { rename, writeFile } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { rename as rename2, writeFile } from "node:fs/promises";
+import { join as join19 } from "node:path";
 
 // ../scanner/src/screens/locate.ts
 import { realpathSync } from "node:fs";
@@ -8285,8 +8449,8 @@ function projectPath(source, moduleUrl, root) {
     if (path.startsWith(prefix)) return posix7.normalize(path.slice(prefix.length));
   }
   if (/^\/(?:Users|home|private|var|tmp|opt|mnt|[A-Za-z]:)\//.test(path)) return null;
-  const relative5 = posix7.normalize(path.replace(/^\/+/, ""));
-  return relative5.startsWith("..") || relative5 === "." ? null : relative5;
+  const relative6 = posix7.normalize(path.replace(/^\/+/, ""));
+  return relative6.startsWith("..") || relative6 === "." ? null : relative6;
 }
 function realOrSelf(path) {
   try {
@@ -8349,7 +8513,7 @@ function screenSlug(route) {
   return route.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "root";
 }
 function readScreensSpec(dir) {
-  const file = join18(dir, "screens.json");
+  const file = join19(dir, "screens.json");
   let value;
   try {
     value = JSON.parse(readFileSync7(file, "utf8"));
@@ -8371,7 +8535,7 @@ function readScreensSpec(dir) {
 async function writeBytes(file, bytes) {
   const temporary = `${file}.${process.pid}.tmp`;
   await writeFile(temporary, bytes);
-  await rename(temporary, file);
+  await rename2(temporary, file);
 }
 async function encode(page, png, scale) {
   const url = await page.evaluate(
@@ -8396,7 +8560,7 @@ var sentence = (error) => (error instanceof Error ? error.message : String(error
 async function captureScreens(dir, options) {
   const spec = readScreensSpec(dir);
   const unknown = (options.routes ?? []).filter((route) => !spec.screens.some((s) => s.route === route));
-  if (unknown.length) throw new Error(`${join18(dir, "screens.json")} has no route ${unknown.join(", ")}: it lists ${spec.screens.map((s) => s.route).join(", ")}`);
+  if (unknown.length) throw new Error(`${join19(dir, "screens.json")} has no route ${unknown.join(", ")}: it lists ${spec.screens.map((s) => s.route).join(", ")}`);
   const chosen = options.routes?.length ? spec.screens.filter((s) => options.routes.includes(s.route)) : spec.screens;
   const log = options.log ?? (() => void 0);
   const { width, height } = spec.viewport;
@@ -8427,8 +8591,8 @@ async function captureScreens(dir, options) {
           const pageHeight = located?.size.height ?? await page.evaluate(() => document.documentElement.scrollHeight);
           const clip = { x: 0, y: 0, width, height: Math.min(Math.max(pageHeight, height), height * MAX_VIEWPORTS) };
           const png = await page.screenshot({ fullPage: true, clip });
-          await writeBytes(join18(dir, `${slug2}.${scheme}.webp`), await encode(encoder, png, 1));
-          await writeBytes(join18(dir, `${slug2}.${scheme}.thumb.webp`), await encode(encoder, png, THUMB_SCALE / PICTURE_SCALE));
+          await writeBytes(join19(dir, `${slug2}.${scheme}.webp`), await encode(encoder, png, 1));
+          await writeBytes(join19(dir, `${slug2}.${scheme}.thumb.webp`), await encode(encoder, png, THUMB_SCALE / PICTURE_SCALE));
           if (located) {
             react ||= located.react;
             dev ||= located.dev;
@@ -8437,7 +8601,7 @@ async function captureScreens(dir, options) {
               return response?.ok ? response.text() : null;
             }, options.root ?? null, notes);
             const file = { schema: PLACES_SCHEMA, route: screen.route, path: screen.path, viewport: spec.viewport, size: { width, height: clip.height }, dev: located.dev, capped: located.capped, places: places.filter((p) => p.box.y < clip.height) };
-            await writeFileAtomic(join18(dir, `${slug2}.places.json`), `${JSON.stringify(file)}
+            await writeFileAtomic(join19(dir, `${slug2}.places.json`), `${JSON.stringify(file)}
 `);
             results.set(screen.route, { placed: file.places.length, lined: file.places.filter((p) => p.line !== null).length, error: null });
           }
@@ -8452,9 +8616,9 @@ async function captureScreens(dir, options) {
     }
   }
   const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
-  if (chosen === spec.screens) await writeFileAtomic(join18(dir, "screens.json"), `${JSON.stringify({ ...spec, capturedAt: now, base: options.base }, null, 2)}
+  if (chosen === spec.screens) await writeFileAtomic(join19(dir, "screens.json"), `${JSON.stringify({ ...spec, capturedAt: now, base: options.base }, null, 2)}
 `);
-  else if (spec.base !== options.base) await writeFileAtomic(join18(dir, "screens.json"), `${JSON.stringify({ ...spec, base: options.base }, null, 2)}
+  else if (spec.base !== options.base) await writeFileAtomic(join19(dir, "screens.json"), `${JSON.stringify({ ...spec, base: options.base }, null, 2)}
 `);
   const screens = chosen.map((s) => ({ route: s.route, path: s.path, ...results.get(s.route) ?? { placed: 0, lined: 0, error: "not captured" } }));
   const placed = screens.reduce((n, s) => n + s.placed, 0);
@@ -8476,9 +8640,9 @@ function captureText(report) {
 // ../scanner/src/screens/session.ts
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync7, realpathSync as realpathSync2 } from "node:fs";
-import { chmod, mkdir, rename as rename2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { basename as basename5, dirname as dirname8, join as join19 } from "node:path";
+import { chmod, mkdir as mkdir2, rename as rename3, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename5, dirname as dirname9, join as join20 } from "node:path";
 import { chromium } from "playwright-core";
 function sessionFile(root, env = process.env) {
   let real = root;
@@ -8488,7 +8652,7 @@ function sessionFile(root, env = process.env) {
   }
   const name = basename5(real).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "product";
   const hash = sha256(real).slice(0, 12);
-  return join19(env.XDG_CACHE_HOME || join19(homedir2(), ".cache"), "youiyoux", "sessions", `${name}-${hash}.json`);
+  return join20(env.XDG_CACHE_HOME || join20(homedir3(), ".cache"), "youiyoux", "sessions", `${name}-${hash}.json`);
 }
 function chosenSession(root, named2, env = process.env) {
   if (named2) return { file: named2, saved: false };
@@ -8496,14 +8660,14 @@ function chosenSession(root, named2, env = process.env) {
   return existsSync7(file) ? { file, saved: true } : null;
 }
 async function writePrivate(file, content) {
-  await mkdir(dirname8(file), { recursive: true, mode: 448 });
-  const temp = join19(dirname8(file), `.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+  await mkdir2(dirname9(file), { recursive: true, mode: 448 });
+  const temp = join20(dirname9(file), `.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     await writeFile2(temp, content, { encoding: "utf8", mode: 384 });
     await chmod(temp, 384);
-    await rename2(temp, file);
+    await rename3(temp, file);
   } finally {
-    await rm(temp, { force: true });
+    await rm2(temp, { force: true });
   }
 }
 function openLoginBrowser(executablePath) {
@@ -8553,6 +8717,14 @@ export {
   checkCapabilities,
   checkInputFor,
   evaluateRule,
+  systemsCacheDir,
+  designRootOf,
+  locateDesign,
+  gitCheckout,
+  withoutCredentials,
+  linksFile,
+  linkedDesign,
+  setLink,
   PROJECT_FILE,
   ProjectRootError,
   ROOT_HINT,