@bridge-ds/cli 0.9.0 → 0.11.0

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
-import { isAbsolute, join as join6, relative as relative4, resolve as resolve5 } from "node:path";
+import { isAbsolute, join as join8, relative as relative5, resolve as resolve6 } from "node:path";
 
 // ../core/src/audit/types.ts
 var AUDIT_SCHEMA_VERSION = 1;
@@ -1798,8 +1798,8 @@ function scanMarkup(path, text, lang, ds) {
     out.themeRefs += r.themeRefs;
   }
   const scanExpr = (prefix, expr, offset, suffix, keepLookalikes = false) => {
-    const { line, column } = pos(offset);
-    const src = line >= 2 ? `${"\n".repeat(line - 2)}${prefix}
+    const { line: line2, column } = pos(offset);
+    const src = line2 >= 2 ? `${"\n".repeat(line2 - 2)}${prefix}
 ${" ".repeat(column - 1)}${expr}${suffix}` : `${prefix}${expr}${suffix}`;
     const c = scanCode(`${path}.tsx`, src, ds);
     merge({ ...c, components: keepLookalikes ? c.components.filter((x) => x.kind === "recreated" && x.name.startsWith(".")) : [], definitions: [], ds: {} });
@@ -2445,7 +2445,7 @@ var DEFAULT_GOVERNANCE = {
   owners: { design: [], tech: [] }
 };
 var FLAT_TOKEN_KEYS = ["primitives", "brands", "semantic", "base", "density", "components", "contrastChecks"];
-var CANONICAL_TOKEN_KEYS = ["root", "include", "exclude", "tiers", "layers"];
+var CANONICAL_TOKEN_KEYS = ["root", "include", "exclude", "tiers", "layers", "usage"];
 var FLAT_MODE_KEYS = ["brands", "themes", "densities", "defaults"];
 var AXIS_OF = { brands: "brand", themes: "theme", densities: "density" };
 var ConfigError = class extends Error {
@@ -2533,7 +2533,7 @@ function defineConfig(input) {
   const contrastFile = contrastPath ?? [root === "." ? "" : root, paths.contrastChecks].filter(Boolean).join("/");
   return {
     repo: parseRepoInput(input.repo, input.branch),
-    tokens: { ...paths, include: input.tokens?.include ?? ["**/*.tokens.json"], exclude: input.tokens?.exclude ?? [], tiers, layers },
+    tokens: { ...paths, include: input.tokens?.include ?? ["**/*.tokens.json"], exclude: input.tokens?.exclude ?? [], tiers, layers, ...t.usage ? { usage: trimSlashes(t.usage) } : {} },
     axes,
     modes,
     contrast: { path: contrastFile, modes: input.contrast?.modes },
@@ -2568,6 +2568,7 @@ function defineConfig(input) {
     products: input.products?.length ? input.products.map((p) => ({ ...p })) : DEFAULT_PRODUCTS.map((p) => ({ ...p })),
     changes: input.changes === "direct" ? "direct" : DEFAULT_CHANGES_MODE,
     ...input.storybook?.url ? { storybook: { url: input.storybook.url.trim().replace(/\/+$/, "") } } : {},
+    ...input.library?.public === true ? { library: { public: true } } : {},
     ...input.audit ? { audit: { ...input.audit } } : {},
     ...input.visualImpact ? { visualImpact: { mode: input.visualImpact.mode === "on-demand" ? "on-demand" : "auto" } } : {},
     ...input.integrations ? { integrations: { ...input.integrations } } : {},
@@ -2612,7 +2613,7 @@ function loadConfig(source) {
     if (!isObj(tokens2)) problems.push('"tokens" must be an object');
     else
       for (const [k, v] of Object.entries(tokens2)) {
-        if (FLAT_TOKEN_KEYS.includes(k) || k === "root") {
+        if (FLAT_TOKEN_KEYS.includes(k) || k === "root" || k === "usage") {
           if (!isStr(v)) problems.push(`"tokens.${k}" must be a non-empty string`);
         } else if (k === "include" || k === "exclude") {
           if (!isStrList(v)) problems.push(`"tokens.${k}" must be a list of globs`);
@@ -2698,6 +2699,14 @@ function loadConfig(source) {
     else if (!/^https:\/\/[^\s/]+/.test(sb.url.trim())) problems.push('"storybook.url" must start with https://, for example https://storybook.example.com');
     else for (const k of Object.keys(sb)) if (k !== "url") problems.push(`"storybook.${k}" is not a known key`);
   }
+  const lib = d.library;
+  if (lib !== void 0) {
+    if (!isObj(lib)) problems.push('"library" must be an object, for example { "public": true }');
+    else {
+      if (lib.public !== void 0 && typeof lib.public !== "boolean") problems.push('"library.public" must be true or false');
+      for (const k of Object.keys(lib)) if (k !== "public") problems.push(`"library.${k}" is not a known key`);
+    }
+  }
   problems.push(...productProblems(d.products));
   const audit2 = d.audit;
   if (audit2 !== void 0) {
@@ -2727,6 +2736,7 @@ function loadConfig(source) {
   if (problems.length) throw new ConfigError(problems);
   return defineConfig(d);
 }
+var tokensPath = (config, rel = "") => [config.tokens.root === "." ? "" : config.tokens.root, rel].filter(Boolean).join("/");
 
 // ../core/src/node/git-local.ts
 import { execFile } from "node:child_process";
@@ -2752,10 +2762,10 @@ function assertSafeBranch(branch, rules = {}) {
 
 // ../core/src/node/git-local.ts
 function git(root, args, opts = {}) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const child = execFile("git", args, { cwd: root, env: { ...process.env, ...opts.env }, maxBuffer: 32 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) reject(new Error(`git ${args.join(" ")}: ${stderr || err.message}`.trim()));
-      else resolve6(stdout);
+      else resolve7(stdout);
     });
     if (opts.input !== void 0) child.stdin.end(opts.input);
   });
@@ -3034,6 +3044,44 @@ function classifyAuth(status, detail, opts = {}) {
   }
   return {};
 }
+function memoryEtagStore(max = 500) {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const e = map.get(key);
+      if (e) {
+        map.delete(key);
+        map.set(key, e);
+      }
+      return e;
+    },
+    set(key, entry) {
+      map.delete(key);
+      map.set(key, entry);
+      while (map.size > max) map.delete(map.keys().next().value);
+    },
+    clear: () => map.clear()
+  };
+}
+var sharedEtags = memoryEtagStore();
+function tokenFingerprint(token) {
+  if (!token) return "anon";
+  let a = 2166136261;
+  let b = 16777619 ^ token.length;
+  for (let i = 0; i < token.length; i++) {
+    const c = token.charCodeAt(i);
+    a = Math.imul(a ^ c, 16777619) >>> 0;
+    b = Math.imul(b ^ c ^ i & 255, 1540483477) >>> 0;
+  }
+  return a.toString(16).padStart(8, "0") + b.toString(16).padStart(8, "0");
+}
+function installationFor(list2, owner) {
+  const inst = list2.find((i) => i.account?.login?.toLowerCase() === owner.toLowerCase());
+  if (!inst) return { reach: "no" };
+  const selection = inst.repositorySelection ?? inst.repository_selection;
+  return selection === "all" ? { reach: "yes", id: inst.id } : { reach: "check", id: inst.id };
+}
+var MAX_PAGES = 10;
 function rateLimitMessage(x) {
   const when = x.resetsAt ? ` It resets at ${x.resetsAt.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}.` : "";
   if (x.withToken) return `GitHub's hourly request limit for this token is used up.${when} Try again after that.`;
@@ -3041,8 +3089,11 @@ function rateLimitMessage(x) {
   return `GitHub's hourly limit for requests without a token (60 an hour) is used up.${when} To keep going now, ${hint}: a token gets 5,000 requests an hour.`;
 }
 var DEFAULT_RETRY = { attempts: 3, baseDelayMs: 600, sleep: (ms) => new Promise((r) => setTimeout(r, ms)) };
+var hourlyLimitErrors = /* @__PURE__ */ new WeakSet();
 var isTransient = (status, detail) => status === 0 || status >= 500 || status === 429 || status === 403 && /secondary rate limit/i.test(detail);
 var API = "https://api.github.com";
+var ACCEPT_JSON = "application/vnd.github+json";
+var ACCEPT_RAW = "application/vnd.github.raw";
 var RAW = "https://raw.githubusercontent.com";
 function parseRepo(repo) {
   const m = /^\s*(?:https?:\/\/github\.com\/|git@github\.com:)?([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?\s*$/.exec(repo);
@@ -3061,6 +3112,7 @@ function base64ToUtf8(b64) {
   for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
   return new TextDecoder("utf-8").decode(bytes);
 }
+var copy = (value) => value === null || typeof value !== "object" ? value : typeof structuredClone === "function" ? structuredClone(value) : JSON.parse(JSON.stringify(value));
 var encodeRef = (ref) => ref.split("/").map(encodeURIComponent).join("/");
 var GitHubClient = class _GitHubClient {
   constructor(repo, token, fetchImpl = (url, init2) => fetch(url, init2), retry = DEFAULT_RETRY, options = {}) {
@@ -3073,6 +3125,8 @@ var GitHubClient = class _GitHubClient {
     this.name = r.name;
     this.api = (options.apiUrl ?? API).replace(/\/$/, "");
     this.protectedBranches = options.protectedBranches ?? DEFAULT_PROTECTED_BRANCHES;
+    this.etags = options.etags === false ? void 0 : options.etags ?? sharedEtags;
+    this.etagScope = options.etagScope ?? tokenFingerprint(token);
   }
   token;
   fetchImpl;
@@ -3083,6 +3137,15 @@ var GitHubClient = class _GitHubClient {
   blobCache = /* @__PURE__ */ new Map();
   api;
   protectedBranches;
+  etags;
+  etagScope;
+  rate;
+  /** What the conditional request cache did for this client. */
+  etagStats = { conditional: 0, notModified: 0, stale: 0 };
+  /** GitHub's rate-limit headers from the last API response, or undefined before any response carried them. */
+  get rateLimit() {
+    return this.rate;
+  }
   /** "owner/name". */
   get fullName() {
     return `${this.owner}/${this.name}`;
@@ -3106,45 +3169,77 @@ var GitHubClient = class _GitHubClient {
   get repoPath() {
     return `/repos/${this.owner}/${this.name}`;
   }
-  async request(method, path, body, retryable = method === "GET") {
+  async request(method, path, body, retryable = method === "GET", opts = {}) {
     const attempts = retryable ? Math.max(1, this.retry.attempts) : 1;
     for (let attempt = 1; ; attempt++) {
       try {
-        return await this.once(method, path, body);
+        return await this.once(method, path, body, opts);
       } catch (err) {
         const e = err;
-        if (attempt >= attempts || !(e instanceof GitHubError) || !isTransient(e.status, e.detail ?? "")) throw err;
+        if (attempt >= attempts || !(e instanceof GitHubError) || hourlyLimitErrors.has(e) || !isTransient(e.status, e.detail ?? "")) throw err;
         await this.retry.sleep(this.retry.baseDelayMs * 2 ** (attempt - 1));
       }
     }
   }
-  async once(method, path, body) {
+  noteRateLimit(headers) {
+    const remaining = headers?.get("x-ratelimit-remaining");
+    if (remaining == null) return;
+    const limit = headers?.get("x-ratelimit-limit");
+    const reset = headers?.get("x-ratelimit-reset");
+    this.rate = {
+      limit: limit != null ? Number(limit) : void 0,
+      remaining: Number(remaining),
+      resetsAt: reset ? new Date(Number(reset) * 1e3) : void 0,
+      resource: headers?.get("x-ratelimit-resource") ?? void 0
+    };
+  }
+  async once(method, path, body, opts = {}) {
+    const accept = opts.accept ?? ACCEPT_JSON;
     const headers = {
-      Accept: "application/vnd.github+json",
+      Accept: accept,
       "X-GitHub-Api-Version": "2022-11-28"
     };
     if (this.token) headers.Authorization = `Bearer ${this.token}`;
     if (body !== void 0) headers["Content-Type"] = "application/json";
+    const key = method === "GET" && this.etags && opts.etag !== false ? `${this.etagScope} ${accept} ${this.api}${path}` : void 0;
+    const cached = key ? this.etags.get(key) : void 0;
+    if (cached && this.token) {
+      headers["If-None-Match"] = cached.etag;
+      this.etagStats.conditional++;
+    }
     let res;
     try {
       res = await this.fetchImpl(`${this.api}${path}`, { method, headers, ...body !== void 0 ? { body: JSON.stringify(body) } : {} });
     } catch (err) {
+      if (err instanceof GitHubError) throw err;
       throw new GitHubError(0, "Could not reach GitHub. Check your connection, then try again.", err.message);
     }
+    this.noteRateLimit(res.headers);
+    if (res.status === 304 && cached && key && this.token) {
+      this.etagStats.notModified++;
+      this.etags.set(key, { ...cached, at: Date.now() });
+      return copy(cached.body);
+    }
     if (res.status === 204) return void 0;
     if (!res.ok) {
       let detail = "";
       try {
-        const data = await res.json();
-        detail = [data.message, ...(data.errors ?? []).map((e) => typeof e === "string" ? e : e.message)].filter(Boolean).join(" ");
+        const data2 = await res.json();
+        detail = [data2.message, ...(data2.errors ?? []).map((e) => typeof e === "string" ? e : e.message)].filter(Boolean).join(" ");
       } catch {
         detail = "";
       }
       const remaining = res.headers?.get("x-ratelimit-remaining");
       const reset = res.headers?.get("x-ratelimit-reset");
       if ((res.status === 403 || res.status === 429) && remaining === "0") {
+        if (cached && this.options.serveStaleOnRateLimit) {
+          this.etagStats.stale++;
+          return copy(cached.body);
+        }
         const resetsAt = reset ? new Date(Number(reset) * 1e3) : void 0;
-        throw new GitHubError(429, rateLimitMessage({ withToken: Boolean(this.token), resetsAt, tokenHint: this.options.tokenHint }), detail);
+        const limited = new GitHubError(429, rateLimitMessage({ withToken: Boolean(this.token), resetsAt, tokenHint: this.options.tokenHint }), detail);
+        hourlyLimitErrors.add(limited);
+        throw limited;
       }
       const info = classifyAuth(res.status, detail, {
         path,
@@ -3153,7 +3248,24 @@ var GitHubClient = class _GitHubClient {
       });
       throw new GitHubError(res.status, friendlyMessage(res.status, detail, info), detail, info);
     }
-    return await res.json();
+    const data = opts.text ? await res.text() : await res.json();
+    const etag = key ? res.headers?.get("etag") : null;
+    if (key && etag) this.etags.set(key, { etag, body: copy(data), at: Date.now() });
+    return data;
+  }
+  /**
+   * Every item of a paged listing (`per_page=100`), at most 10 pages. `pick` takes the items out of one page (the
+   * installation endpoints wrap them in an object with `total_count`).
+   */
+  async paged(path, pick) {
+    const out = [];
+    const sep3 = path.includes("?") ? "&" : "?";
+    for (let page = 1; page <= MAX_PAGES; page++) {
+      const { items, total } = pick(await this.request("GET", `${path}${sep3}per_page=100&page=${page}`));
+      out.push(...items);
+      if (items.length < 100 || total !== void 0 && out.length >= total) break;
+    }
+    return out;
   }
   async getRepo() {
     const r = await this.request(
@@ -3536,6 +3648,14 @@ var GitHubClient = class _GitHubClient {
    */
   async readFile(path, ref) {
     if (this.token) return this.getFileText(path, ref);
+    return this.readRawFile(path, ref);
+  }
+  /**
+   * Text of a file from the raw host (raw.githubusercontent.com), sent without any header so the browser makes a
+   * simple CORS request (no preflight) and nothing counts against the API limit. Works for public repositories only:
+   * a private file answers 404 there, like a missing one. Undefined on 404.
+   */
+  async readRawFile(path, ref) {
     const url = `${(this.options.rawUrl ?? RAW).replace(/\/$/, "")}/${this.owner}/${this.name}/${encodeRef(ref)}/${encodeRef(path)}`;
     let res;
     try {
@@ -3547,6 +3667,76 @@ var GitHubClient = class _GitHubClient {
     if (!res.ok) throw new GitHubError(res.status, friendlyMessage(res.status, ""), `raw ${path}@${ref}`);
     return res.text();
   }
+  /**
+   * Text of a file at a ref through the contents API with the raw media type: the way to read a private file (the raw
+   * host cannot take the token without a preflight). Counts against the API limit; conditional when cached.
+   * Undefined when the file does not exist.
+   */
+  async getRawText(path, ref) {
+    try {
+      return await this.request("GET", `${this.repoPath}/contents/${encodeRef(path)}?ref=${encodeURIComponent(ref)}`, void 0, true, { accept: ACCEPT_RAW, text: true });
+    } catch (err) {
+      if (err instanceof GitHubError && err.status === 404) return void 0;
+      throw err;
+    }
+  }
+  /**
+   * Text of a blob by its sha through the git blobs API with the raw media type: how a signed-in reader loads a file
+   * listed by a tree (the raw host refuses any request that carries a token). A blob sha names its content, so the
+   * answer is cached for the client's life and never revalidated. Undefined on 404.
+   */
+  async getBlobRaw(sha) {
+    const cached = this.blobCache.get(sha);
+    if (cached !== void 0) return cached;
+    try {
+      const text = await this.request("GET", `${this.repoPath}/git/blobs/${encodeURIComponent(sha)}`, void 0, true, { accept: ACCEPT_RAW, text: true, etag: false });
+      this.blobCache.set(sha, text);
+      return text;
+    } catch (err) {
+      if (err instanceof GitHubError && err.status === 404) return void 0;
+      throw err;
+    }
+  }
+  // --- GitHub App installations (user-to-server tokens) ---------------------------------------
+  /**
+   * Installations of the signing-in GitHub App that the signed-in user can reach (GET /user/installations, every
+   * page). Needs a user-to-server token of that same App: a personal or OAuth token is refused (403), and each App
+   * sees only its own installations. GitHub lists only installations on accounts and repositories the user has
+   * explicit permission on: a public repository where the user is not a collaborator is never listed, installed or
+   * not. (GET /repos/{o}/{r}/installation would say, but it needs the App's private key, which Bridge never holds.)
+   */
+  async listUserInstallations() {
+    this.assertToken("Reading where Bridge is installed");
+    const list2 = await this.paged("/user/installations", (p) => ({ items: p.installations ?? [], total: p.total_count }));
+    return list2.map((i) => ({
+      id: i.id,
+      account: i.account?.login ? { login: i.account.login, type: i.account.type ?? "User" } : null,
+      repositorySelection: i.repository_selection ?? "selected",
+      appSlug: i.app_slug
+    }));
+  }
+  /** Repositories of one installation the signed-in user can reach (GET /user/installations/{id}/repositories, every page). */
+  async listInstallationRepos(installationId) {
+    this.assertToken("Reading where Bridge is installed");
+    const list2 = await this.paged(`/user/installations/${encodeURIComponent(String(installationId))}/repositories`, (p) => ({
+      items: p.repositories ?? [],
+      total: p.total_count
+    }));
+    return list2.map((r) => ({ owner: r.owner?.login ?? r.full_name.split("/")[0], name: r.name, fullName: r.full_name, private: Boolean(r.private) }));
+  }
+  /**
+   * The App installation that gives the signed-in user this repository (this client's by default): its id, or null
+   * when the App is not installed there or the user cannot reach it. One call when the installation covers all of
+   * the owner's repositories, two (paged) when it covers selected ones.
+   */
+  async findInstallation(owner = this.owner, repo = this.name) {
+    const found = installationFor(await this.listUserInstallations(), owner);
+    if (found.reach === "no") return null;
+    if (found.reach === "yes") return { id: found.id, selection: "all" };
+    const repos = await this.listInstallationRepos(found.id);
+    const hit = repos.some((r) => r.owner.toLowerCase() === owner.toLowerCase() && r.name.toLowerCase() === repo.toLowerCase());
+    return hit ? { id: found.id, selection: "selected" } : null;
+  }
   /** The repository's default branch. */
   async getDefaultBranch() {
     return (await this.getRepo()).defaultBranch;
@@ -3924,14 +4114,101 @@ var SUGGESTION_APPLY_EXIT = {
   refused: 1
 };
 
+// ../core/src/node/fs-source.ts
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// ../core/src/repo-source.ts
+function normalizeRepoPath(path) {
+  return path.replace(/\\/g, "/").split("/").filter((s) => s && s !== ".").join("/");
+}
+var parentDir = (path) => {
+  const p = normalizeRepoPath(path);
+  const i = p.lastIndexOf("/");
+  return i < 0 ? "" : p.slice(0, i);
+};
+async function readRepoTexts(source, paths, concurrency = 4, onError = (_path, err) => {
+  throw err;
+}, onProgress) {
+  const unique = [...new Set(paths)];
+  const out = /* @__PURE__ */ new Map();
+  onProgress?.(0, unique.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < unique.length) {
+      const path = unique[next++];
+      let body;
+      try {
+        body = await source.text(path);
+      } catch (err) {
+        body = onError(path, err);
+      }
+      out.set(path, body);
+      onProgress?.(out.size, unique.length);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(concurrency, unique.length)) }, worker));
+  return out;
+}
+
+// ../core/src/node/fs-source.ts
+var SKIP = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function gitOut(root, args) {
+  try {
+    return execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return "";
+  }
+}
+function localRepoRef(root) {
+  const origin = /github\.com[:/]([\w.-]+)\/([\w.-]+?)(\.git)?$/.exec(gitOut(root, ["remote", "get-url", "origin"]));
+  return { owner: origin?.[1] ?? "", repo: origin?.[2] ?? "", sha: gitOut(root, ["rev-parse", "HEAD"]) || "working-tree" };
+}
+function fsSource(root, ref = {}) {
+  let resolved;
+  const walk2 = (rel, out) => {
+    for (const entry of readdirSync2(join2(root, rel), { withFileTypes: true })) {
+      if (SKIP.has(entry.name)) continue;
+      const path = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) walk2(path, out);
+      else if (entry.isFile()) out.push(path);
+      else if (entry.isSymbolicLink() && statSync2(join2(root, path), { throwIfNoEntry: false })?.isFile()) out.push(path);
+    }
+  };
+  return {
+    get ref() {
+      resolved ??= { ...localRepoRef(root), ...Object.fromEntries(Object.entries(ref).filter(([, v]) => v !== void 0)) };
+      return resolved;
+    },
+    async list(prefix = "") {
+      const rel = normalizeRepoPath(prefix);
+      const abs = join2(root, rel);
+      if (!existsSync2(abs)) return [];
+      if (!statSync2(abs).isDirectory()) return [rel];
+      const out = [];
+      walk2(rel, out);
+      return out.sort();
+    },
+    async text(path) {
+      const abs = join2(root, normalizeRepoPath(path));
+      try {
+        return statSync2(abs).isFile() ? readFileSync2(abs, "utf8") : null;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
 // src/index.ts
 import { fileURLToPath } from "node:url";
 
 // ../visual/src/run.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile3, rm as rm2, unlink, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join4, relative as relative3, resolve as resolve2 } from "node:path";
+import { join as join5, relative as relative3, resolve as resolve2 } from "node:path";
 
 // ../core/src/protection.ts
 var PROTECTION_PARTS = ["review", "checks", "history", "deletion"];
@@ -4328,6 +4605,819 @@ function storybookIframeUrl(base, id, o = {}) {
   return url;
 }
 
+// ../core/src/token-rows.ts
+var FALLBACK_BRANDS = ["bridge", "ocean"];
+var FALLBACK_THEMES = ["light", "dark"];
+var FALLBACK_DENSITIES = ["comfortable", "compact"];
+function tokenRowAxes(config, readText = () => void 0) {
+  const brandAxis = config.axes.brand;
+  const brands = brandAxis?.values.length ? [...brandAxis.values] : [...FALLBACK_BRANDS];
+  const defaultBrand = brandAxis?.default ?? brands[0];
+  const themes = config.modes.themes.length ? [...config.modes.themes] : [...FALLBACK_THEMES];
+  const densities = config.modes.densities.length ? [...config.modes.densities] : [...FALLBACK_DENSITIES];
+  const files = tokenRowFiles(config);
+  const brandName = (b) => {
+    try {
+      const text = readText(files.brandFile(b));
+      const name = text ? JSON.parse(text).$extensions?.["dev.bridge.brand"]?.name : void 0;
+      if (typeof name === "string" && name) return name;
+    } catch {
+    }
+    return b.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  };
+  return {
+    brands,
+    defaultBrand,
+    brandLabels: Object.fromEntries(brands.map((b) => [b, brandName(b)])),
+    themes,
+    densities,
+    defaultDensity: config.modes.defaults.density ?? densities[0]
+  };
+}
+function tokenRowFiles(config) {
+  const t = config.tokens;
+  const at = (rel) => tokensPath(config, rel);
+  return {
+    primitivesDir: at(t.primitives),
+    semanticDir: at(t.semantic),
+    brandsDir: at(t.brands),
+    densityDir: at(t.density),
+    componentsDir: at(t.components),
+    baseFile: at(`${t.semantic}/${t.base}.tokens.json`),
+    semanticFile: (theme) => at(`${t.semantic}/${theme}.tokens.json`),
+    brandFile: (brand2) => at(`${t.brands}/${brand2}.tokens.json`),
+    overrideFile: (brand2, theme) => at(`${t.brands}/${brand2}.${theme}.tokens.json`),
+    densityFile: (density) => at(`${t.density}/${density}.tokens.json`)
+  };
+}
+function flattenTokenFile(node, file, path = [], inheritedType = "") {
+  const type = node.$type ?? inheritedType;
+  if ("$value" in node) {
+    return [
+      {
+        path,
+        type,
+        value: node.$value,
+        description: node.$description,
+        deprecated: node.$deprecated,
+        file
+      }
+    ];
+  }
+  const out = [];
+  for (const [key, child] of Object.entries(node)) {
+    if (key.startsWith("$") || typeof child !== "object" || child === null) continue;
+    out.push(...flattenTokenFile(child, file, [...path, key], type));
+  }
+  return out;
+}
+var toHex22 = (n) => Math.round(n * 255).toString(16).padStart(2, "0");
+function colorCss(c) {
+  if (typeof c === "string") return { css: c, hex: /^#[0-9a-f]{6}$/i.test(c) ? c.toLowerCase() : void 0 };
+  const v = c;
+  const [r = 0, g = 0, b = 0] = v.components;
+  const hex = (v.hex ?? `#${[r, g, b].map(toHex22).join("")}`).toLowerCase();
+  const alpha = v.alpha ?? 1;
+  if (alpha < 1) return { css: `rgb(${[r, g, b].map((x) => Math.round(x * 255)).join(" ")} / ${alpha})`, hex };
+  return { css: hex, hex };
+}
+var dimCss = (d) => typeof d === "object" && d !== null ? `${d.value}${d.unit}` : String(d);
+function shadowCss(s) {
+  if (typeof s === "string") return s;
+  const layers = Array.isArray(s) ? s : [s];
+  return layers.map((l) => [l.inset ? "inset" : "", dimCss(l.offsetX), dimCss(l.offsetY), dimCss(l.blur), dimCss(l.spread), colorCss(l.color).css].filter(Boolean).join(" ")).join(", ");
+}
+function tokenValueCss(type, value) {
+  switch (type) {
+    case "color":
+      return colorCss(value);
+    case "dimension":
+    case "duration":
+      return { css: dimCss(value) };
+    case "shadow":
+      return { css: shadowCss(value) };
+    case "cubicBezier":
+      return { css: Array.isArray(value) ? `cubic-bezier(${value.join(", ")})` : String(value) };
+    case "fontFamily":
+      return { css: Array.isArray(value) ? value.map((n) => /\s/.test(n) ? `"${n}"` : n).join(", ") : String(value) };
+    default:
+      return { css: String(value) };
+  }
+}
+var tokenRowCssVar = (segments) => `--${segments.join("-")}`;
+var tokenRowFigmaName = (segments) => segments.join("/");
+var isAlias2 = (v) => typeof v === "string" && /^\{[^}]+\}$/.test(v);
+function buildTokenRows(config, readText, listFiles) {
+  const axes = tokenRowAxes(config, readText);
+  const { brands: BRANDS2, defaultBrand: DEFAULT_BRAND, themes: MODES, densities: DENSITIES, defaultDensity: DEFAULT_DENSITY } = axes;
+  const files = tokenRowFiles(config);
+  const REF_THEME = MODES[0];
+  const jsonFiles = (dir) => listFiles(dir).filter((f) => f.endsWith(".tokens.json")).sort();
+  const flatCache = /* @__PURE__ */ new Map();
+  const flatFile = (f) => {
+    if (!flatCache.has(f)) {
+      const text = readText(f);
+      flatCache.set(f, text === void 0 ? [] : flattenTokenFile(JSON.parse(text), f));
+    }
+    return flatCache.get(f);
+  };
+  const byPathOf = (tokens2) => new Map(tokens2.map((t) => [t.path.join("."), t]));
+  const primitiveFiles = jsonFiles(files.primitivesDir);
+  const componentFiles = jsonFiles(files.componentsDir);
+  const sources = [
+    ...primitiveFiles,
+    ...jsonFiles(files.brandsDir),
+    ...MODES.map(files.semanticFile),
+    files.baseFile,
+    ...jsonFiles(files.densityDir),
+    ...componentFiles
+  ];
+  const primitives = primitiveFiles.flatMap((f) => flatFile(f)).map((t) => {
+    const { css, hex } = tokenValueCss(t.type, t.value);
+    return {
+      path: t.path.join("."),
+      segments: t.path,
+      type: t.type,
+      css,
+      hex,
+      cssVar: tokenRowCssVar(t.path),
+      figma: tokenRowFigmaName(t.path),
+      description: t.description,
+      deprecated: t.deprecated,
+      raw: t.value,
+      file: t.file
+    };
+  });
+  const primByPath = new Map(primitives.map((p) => [p.path, p]));
+  const brandRaw = Object.fromEntries(BRANDS2.map((b) => [b, flatFile(files.brandFile(b))]));
+  const themeRaw = Object.fromEntries(MODES.map((m) => [m, flatFile(files.semanticFile(m))]));
+  const baseRaw = flatFile(files.baseFile);
+  const densityRaw = Object.fromEntries(DENSITIES.map((d) => [d, flatFile(files.densityFile(d))]));
+  const componentRaw = componentFiles.flatMap((f) => flatFile(f));
+  const layerCache = /* @__PURE__ */ new Map();
+  const layers = (b, m, d) => {
+    const k = `${b}.${m}.${d}`;
+    if (!layerCache.has(k))
+      layerCache.set(k, [
+        byPathOf(flatFile(files.overrideFile(b, m))),
+        byPathOf(themeRaw[m] ?? []),
+        byPathOf(baseRaw),
+        byPathOf(densityRaw[d] ?? []),
+        byPathOf(componentRaw),
+        byPathOf(brandRaw[b] ?? [])
+      ]);
+    return layerCache.get(k);
+  };
+  const resolve7 = (b, m, d, value, type) => {
+    const chain = [];
+    let current = value;
+    let currentType = type;
+    let guard = 0;
+    while (isAlias2(current) && guard++ < 30) {
+      const target = current.slice(1, -1);
+      chain.push(target);
+      const prim = primByPath.get(target);
+      if (prim) return { alias: chain[0] ?? null, chain, css: prim.css, hex: prim.hex };
+      const hit = layers(b, m, d).map((l) => l.get(target)).find(Boolean);
+      if (!hit) throw new Error(`tokens: alias {${target}} does not resolve in ${b} ${m} ${d}`);
+      current = hit.value;
+      currentType = hit.type || currentType;
+    }
+    const { css, hex } = tokenValueCss(currentType, current);
+    return { alias: chain[0] ?? null, chain, css, hex };
+  };
+  const same2 = (a, c) => a.css === c.css && a.chain.join() === c.chain.join();
+  const build = (t, tier, valueFor) => {
+    const at = (b, m, d = DEFAULT_DENSITY) => {
+      const raw = valueFor(b, m, d) ?? t;
+      return resolve7(b, m, d, raw.value, raw.type || t.type);
+    };
+    const brands = Object.fromEntries(BRANDS2.map((b) => [b, Object.fromEntries(MODES.map((m) => [m, at(b, m)]))]));
+    return {
+      path: t.path.join("."),
+      segments: t.path,
+      type: t.type,
+      cssVar: tokenRowCssVar(t.path),
+      figma: tokenRowFigmaName(t.path),
+      description: t.description,
+      group: t.path[0] === "color" ? t.path.slice(0, 2).join(".") : t.path[0],
+      deprecated: t.deprecated,
+      tier,
+      file: t.file,
+      modes: brands[DEFAULT_BRAND],
+      brands,
+      densities: tier === "density" ? Object.fromEntries(DENSITIES.map((d) => [d, at(DEFAULT_BRAND, REF_THEME, d)])) : void 0,
+      brandSpecific: BRANDS2.some((b) => MODES.some((m) => !same2(brands[b][m], brands[DEFAULT_BRAND][m])))
+    };
+  };
+  const brand2 = (brandRaw[DEFAULT_BRAND] ?? []).map((t) => build(t, "brand", (b) => byPathOf(brandRaw[b] ?? []).get(t.path.join("."))));
+  const themedBy = Object.fromEntries(MODES.map((m) => [m, byPathOf(themeRaw[m] ?? [])]));
+  const themed = (themeRaw[REF_THEME] ?? []).map((t) => {
+    const path = t.path.join(".");
+    const others = MODES.slice(1).map((m) => {
+      const hit = themedBy[m].get(path);
+      if (!hit) throw new Error(`tokens: semantic token ${path} is missing in ${files.semanticFile(m)}`);
+      return hit;
+    });
+    const s = build(t, "semantic", (b, m) => byPathOf(flatFile(files.overrideFile(b, m))).get(path) ?? (m === REF_THEME ? t : themedBy[m].get(path)));
+    s.description = [t, ...others].map((x) => x.description).find((x) => x !== void 0);
+    s.deprecated = [t, ...others].map((x) => x.deprecated).find((x) => x !== void 0);
+    s.file = MODES.map(files.semanticFile).join(", ");
+    return s;
+  });
+  const base = baseRaw.map((t) => build(t, "semantic", () => t));
+  const semantic = [...themed, ...base];
+  const density = (densityRaw[DEFAULT_DENSITY] ?? []).map((t) => build(t, "density", (_b, _m, d) => byPathOf(densityRaw[d] ?? []).get(t.path.join("."))));
+  const component = componentRaw.map((t) => build(t, "component", () => t));
+  return { ...axes, primitives, semantic, brand: brand2, density, component, all: [...brand2, ...semantic, ...density, ...component], sources };
+}
+function tokenRowIndex(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const p of rows.primitives) map.set(p.cssVar, { path: p.path, kind: "primitive", type: p.type });
+  for (const s of rows.all) map.set(s.cssVar, { path: s.path, kind: s.tier, type: s.type });
+  return map;
+}
+
+// ../core/src/contrast-model.ts
+var CONTRAST_THRESHOLDS = { text: { aa: 4.5, aaa: 7 }, ui: { aa: 3, aaa: null } };
+var channel = (c) => {
+  const s = c / 255;
+  return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+};
+function hexLuminance(hex) {
+  const n = parseInt(hex.slice(1), 16);
+  return 0.2126 * channel(n >> 16 & 255) + 0.7152 * channel(n >> 8 & 255) + 0.0722 * channel(n & 255);
+}
+function hexContrastRatio(a, b) {
+  const [hi, lo] = [hexLuminance(a), hexLuminance(b)].sort((x, y) => y - x);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function parseContrastSpecs(text) {
+  if (!text) return [];
+  const data = JSON.parse(text);
+  return (data.pairs ?? []).map((p) => {
+    const [fg, bg, min] = Array.isArray(p) ? p : [p.fg, p.bg, p.min];
+    return { fg, bg, min, usage: min >= CONTRAST_THRESHOLDS.text.aa ? "text" : "ui" };
+  });
+}
+function evaluateContrastPairs(specs, rows) {
+  const byPath = new Map(rows.all.map((s) => [s.path, s]));
+  return specs.map((spec) => {
+    const fgToken = byPath.get(spec.fg);
+    const bgToken = byPath.get(spec.bg);
+    if (!fgToken || !bgToken) throw new Error(`contrast: pair ${spec.fg} on ${spec.bg} references a token that does not exist`);
+    const t = CONTRAST_THRESHOLDS[spec.usage];
+    const result = (b, m) => {
+      const fgHex = fgToken.brands[b][m].hex;
+      const bgHex = bgToken.brands[b][m].hex;
+      const r = hexContrastRatio(fgHex, bgHex);
+      return { fgHex, bgHex, ratio: Math.floor(r * 100) / 100, aa: r >= spec.min, aaa: t.aaa === null ? null : r >= t.aaa };
+    };
+    const brands = Object.fromEntries(rows.brands.map((b) => [b, Object.fromEntries(rows.themes.map((m) => [m, result(b, m)]))]));
+    return { ...spec, fgToken, bgToken, modes: brands[rows.defaultBrand], brands };
+  });
+}
+
+// ../core/src/component-scan.ts
+var componentSlug = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function parseComponentFamilies(indexSrc, componentsRel = "components") {
+  const out = [];
+  const exportRe = new RegExp(`export \\* from '\\./${escapeRe(componentsRel)}/(\\w+)'`);
+  for (const line2 of indexSrc.split("\n")) {
+    const head = line2.match(/^\/\/\s*([A-Z][\w ]+)$/);
+    if (head) out.push({ name: head[1].trim(), members: [] });
+    const exp = line2.match(exportRe);
+    if (exp && out.length) out[out.length - 1].members.push(exp[1]);
+  }
+  return out.filter((f) => f.members.length);
+}
+var NATIVE = {
+  HTMLButtonElement: "button",
+  HTMLInputElement: "input",
+  HTMLSpanElement: "span",
+  HTMLDivElement: "div",
+  HTMLAnchorElement: "a"
+};
+function parseExtends(clause) {
+  const el = clause.match(/<(HTML\w+Element)>/)?.[1];
+  const omitted = [...(clause.match(/Omit<[^,]+,\s*([^>]+)>/)?.[1] ?? "").matchAll(/'([^']+)'/g)].map((m) => m[1]);
+  return { inherits: el ? NATIVE[el] ?? el : void 0, omitted };
+}
+function parseComponentTsx(name, src) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const m of src.matchAll(/export type (\w+)\s*=\s*([^;]+);/g)) aliases.set(m[1], m[2].trim());
+  let props = [];
+  let inherits;
+  let omitted = [];
+  const iface = src.match(new RegExp(`export interface ${name}Props(?:\\s+extends\\s+([^{]+))?\\s*\\{([\\s\\S]*?)\\n\\}`));
+  if (iface) {
+    ({ inherits, omitted } = parseExtends(iface[1] ?? ""));
+    for (const m of iface[2].matchAll(/(?:\/\*\*([\s\S]*?)\*\/\s*)?(\w+)(\?)?:\s*([^;]+);/g)) {
+      const rawType = m[4].trim();
+      props.push({
+        name: m[2],
+        type: aliases.get(rawType) ?? rawType,
+        required: !m[3],
+        description: m[1]?.replace(/^\s*\*\s?/gm, "").replace(/\s+/g, " ").trim() || void 0
+      });
+    }
+  } else {
+    const alias = aliases.get(`${name}Props`);
+    if (alias) ({ inherits, omitted } = parseExtends(alias));
+  }
+  const sig = src.match(new RegExp(`function ${name}\\(\\s*\\{([^}]*)\\}`));
+  if (sig) {
+    for (const m of sig[1].matchAll(/(\w+)\s*=\s*('[^']*'|[\w.]+)/g)) {
+      const p = props.find((x) => x.name === m[1]);
+      if (p) p.defaultValue = m[2];
+    }
+  }
+  const docBefore = (re) => {
+    const idx = src.search(re);
+    if (idx < 0) return void 0;
+    const before = src.slice(0, idx).trimEnd();
+    if (!before.endsWith("*/")) return void 0;
+    const start = before.lastIndexOf("/*", before.length - 2);
+    if (start < 0 || before[start + 2] !== "*") return void 0;
+    return before.slice(start + 3, -2).replace(/^\s*\*\s?/gm, "").replace(/\s+/g, " ").trim();
+  };
+  const description = docBefore(new RegExp(`export (?:function|const) ${name}\\b`));
+  const subcomponents = [...src.matchAll(/export function (\w+)/g)].map((m) => m[1]).filter((n) => n !== name);
+  props = props.sort((a, b) => Number(b.required) - Number(a.required));
+  return { props, inherits, omitted, description, subcomponents };
+}
+var stateOf = (selector) => {
+  const states = [
+    [/:focus-visible/, "focus"],
+    [/:hover/, "hover"],
+    [/:disabled(?!,)|^[^(]*:disabled/, "disabled"],
+    [/\[data-loading\]/, "loading"],
+    [/::placeholder/, "placeholder"]
+  ];
+  const hit = states.filter(([re]) => re.test(selector)).map(([, s]) => s);
+  return hit.length ? `, ${hit.join(" + ")}` : "";
+};
+var BASE_UI_RUNTIME = /^--(_|accordion-panel-|collapsible-panel-|active-tab-|anchor-|available-|drawer-swipe-|toast-(frontmost-height|height|index|offset-y|swipe-)|transform-origin)/;
+function parseComponentCss(src, labels, describe) {
+  const clean = src.replace(/\/\*[\s\S]*?\*\//g, "");
+  const rules = [];
+  const walk2 = (text, prefix = "") => {
+    let i = 0;
+    let buf = "";
+    while (i < text.length) {
+      const ch = text[i];
+      if (ch === "{") {
+        const head = buf.trim();
+        buf = "";
+        let depth = 1;
+        const start = ++i;
+        while (i < text.length && depth > 0) {
+          if (text[i] === "{") depth++;
+          else if (text[i] === "}") depth--;
+          i++;
+        }
+        const inner = text.slice(start, i - 1);
+        if (head.startsWith("@keyframes")) continue;
+        if (head.startsWith("@")) {
+          walk2(inner, `${head} `);
+          continue;
+        }
+        const names = [...new Set([...inner.matchAll(/var\((--[\w-]+)/g)].map((m) => m[1]))].filter((n) => !BASE_UI_RUNTIME.test(n));
+        if (!names.length) continue;
+        const className = head.match(/\.([\w-]+)/)?.[1] ?? head;
+        rules.push({
+          selector: prefix + head.replace(/\s+/g, " "),
+          className,
+          label: (labels[className] ?? className) + stateOf(head),
+          vars: names.map((n) => {
+            const d = describe(n);
+            return { name: n, href: d?.href, known: !!d, path: d?.path, kind: d?.kind };
+          })
+        });
+      } else {
+        buf += ch;
+        i++;
+      }
+    }
+  };
+  walk2(clean);
+  return rules;
+}
+function parseComponentStories(src) {
+  const title = src.match(/title:\s*'([^']+)'/)?.[1];
+  if (!title) return [];
+  const base = title.split("/").map((s) => componentSlug(s.trim()).replace(/\s+/g, "-")).join("-");
+  return [...src.matchAll(/export const (\w+):\s*Story/g)].map((m) => ({ name: m[1], id: `${base}--${componentSlug(m[1])}` }));
+}
+function resolveInheritedTokens(list2) {
+  const byName = new Map(list2.map((c) => [c.name, c]));
+  for (const c of list2) {
+    const seen = /* @__PURE__ */ new Set([c.name]);
+    const queue = [...c.reuses ?? []];
+    const inherited = [];
+    const taken = new Set(c.tokenPaths);
+    while (queue.length) {
+      const from = byName.get(queue.shift());
+      if (!from || seen.has(from.name)) continue;
+      seen.add(from.name);
+      const paths = from.tokenPaths.filter((p) => !taken.has(p));
+      paths.forEach((p) => taken.add(p));
+      inherited.push({ from: from.name, slug: from.slug, paths });
+      queue.push(...from.reuses ?? []);
+    }
+    c.inherited = inherited;
+    c.allTokenPaths = [...taken].sort();
+  }
+  for (const c of list2) delete c.reuses;
+}
+function scanComponents(input) {
+  const { dir, readText, describeVar } = input;
+  const docsSuffix = input.docsSuffix ?? ".docs.json";
+  const styleSuffix = input.styleSuffix ?? ".module.css";
+  const fileSet = new Set(input.files);
+  const has8 = (p) => fileSet.has(p);
+  const fam = input.indexText === void 0 ? [] : parseComponentFamilies(input.indexText, input.indexRel ?? "components");
+  const familyOf = (name) => fam.find((f) => f.members.includes(name))?.name;
+  const names = [
+    ...new Set(
+      input.files.map((f) => f.startsWith(`${dir}/`) ? f.slice(dir.length + 1).split("/") : []).filter((parts) => parts.length === 2 && parts[1] === `${parts[0]}.tsx`).map((parts) => parts[0])
+    )
+  ].sort();
+  const reuseRe = new RegExp(`from\\s+'\\.\\.\\/(\\w+)\\/(\\w+)${escapeRe(styleSuffix)}'`, "g");
+  const result = names.map((name) => {
+    const folder = `${dir}/${name}`;
+    const files = { tsx: `${folder}/${name}.tsx`, css: `${folder}/${name}${styleSuffix}`, stories: `${folder}/${name}.stories.tsx`, docs: `${folder}/${name}${docsSuffix}` };
+    let docs = null;
+    if (has8(files.docs)) {
+      try {
+        docs = JSON.parse(readText(files.docs) ?? "");
+      } catch (err) {
+        input.problems?.push(`${files.docs}: ${err.message}`);
+      }
+    }
+    const tsxSrc = readText(files.tsx) ?? "";
+    const tsx = parseComponentTsx(name, tsxSrc);
+    const reuses = [...tsxSrc.matchAll(reuseRe)].filter((m) => m[1] === m[2] && m[1] !== name).map((m) => m[1]);
+    const cssText = has8(files.css) ? readText(files.css) : void 0;
+    const rules = cssText === void 0 ? [] : parseComponentCss(cssText, docs?.anatomy ?? {}, describeVar);
+    const used = [...new Set(rules.flatMap((r) => r.vars.map((v) => v.name)))].sort();
+    const storiesText = has8(files.stories) ? readText(files.stories) : void 0;
+    return {
+      name,
+      slug: componentSlug(name),
+      dir: folder,
+      files,
+      ...tsx,
+      rules,
+      tokensUsed: used.map((n) => {
+        const d = describeVar(n);
+        return { name: n, href: d?.href, known: !!d, kind: d?.kind };
+      }),
+      tokenPaths: [...new Set(used.flatMap((n) => describeVar(n)?.path ?? []))].sort(),
+      inherited: [],
+      allTokenPaths: [],
+      reuses,
+      stories: storiesText === void 0 ? [] : parseComponentStories(storiesText),
+      docs,
+      category: docs?.category ?? familyOf(name) ?? "Core"
+    };
+  });
+  const order = (c) => {
+    const i = fam.findIndex((f) => f.name === c.category);
+    return i < 0 ? fam.length : i;
+  };
+  result.sort((a, b) => order(a) - order(b) || a.name.localeCompare(b.name));
+  resolveInheritedTokens(result);
+  return result;
+}
+
+// ../core/src/repo-model.ts
+var REPO_MODEL_DEFAULTS = {
+  tokensRoot: "packages/tokens/src",
+  componentsDir: "packages/react/src/components",
+  componentSpecs: "packages/react/component-specs.json",
+  /** Optional token usage notes (group -> sentence), relative to tokens.root, when tokens.usage is not set. */
+  tokensUsage: "usage.json",
+  repo: { owner: "peterbono", repo: "ai-design-system-demo", defaultBranch: "main" }
+};
+function siteRepoFromConfig(config, raw, fallback = REPO_MODEL_DEFAULTS.repo) {
+  const legacy = raw && typeof raw === "object" ? raw : void 0;
+  const g = config.governance;
+  const legacyOwners = legacy?.governance?.owners === void 0 ? legacy?.owners : void 0;
+  return {
+    owner: typeof legacy?.owner === "string" && legacy.owner ? legacy.owner : config.repo?.owner ?? fallback.owner,
+    repo: config.repo?.name ?? fallback.repo,
+    defaultBranch: typeof legacy?.defaultBranch === "string" && legacy.defaultBranch ? legacy.defaultBranch : config.repo?.defaultBranch ?? fallback.defaultBranch,
+    owners: legacyOwners ? { design: legacyOwners.design ?? [], tech: legacyOwners.tech ?? [] } : { design: [...g.owners.design], tech: [...g.owners.tech] },
+    override: g.override ? { ...g.override } : { ...DEFAULT_OVERRIDE },
+    rights: g.rights ?? null,
+    soloOwnerCanApproveBoth: g.soloOwnerCanApproveBoth === true,
+    visualImpact: { mode: config.visualImpact?.mode === "on-demand" ? "on-demand" : "auto" },
+    tokensRoot: config.tokens.root,
+    integrations: config.integrations ?? {},
+    products: config.products.length ? config.products : DEFAULT_PRODUCTS.map((p) => ({ ...p })),
+    changes: config.changes ?? DEFAULT_CHANGES_MODE
+  };
+}
+function withModelDefaults(raw) {
+  const tokens2 = raw.tokens && typeof raw.tokens === "object" ? raw.tokens : {};
+  return {
+    ...raw,
+    tokens: { ...tokens2, root: tokens2.root ?? REPO_MODEL_DEFAULTS.tokensRoot },
+    components: raw.components ?? { dir: REPO_MODEL_DEFAULTS.componentsDir }
+  };
+}
+var defaultModelConfig = () => defineConfig(withModelDefaults({}));
+function parseModelConfig(text) {
+  if (text === null) return { config: defaultModelConfig(), raw: void 0, problems: [] };
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    return { config: defaultModelConfig(), raw: void 0, problems: [`${CONFIG_FILE} is not valid JSON (${err.message})`] };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { config: defaultModelConfig(), raw, problems: [`${CONFIG_FILE}: top level must be an object`] };
+  try {
+    return { config: loadConfig(withModelDefaults(raw)), raw, problems: [] };
+  } catch (err) {
+    const problems = err instanceof ConfigError ? err.problems.map((p) => `${CONFIG_FILE}: ${p}`) : [`${CONFIG_FILE}: ${err.message}`];
+    return { config: defaultModelConfig(), raw, problems };
+  }
+}
+var emptyRows = (config) => ({ ...tokenRowAxes(config), primitives: [], semantic: [], brand: [], density: [], component: [], all: [], sources: [] });
+async function loadRepoModel(source, options = {}) {
+  const concurrency = options.concurrency ?? 8;
+  const problems = [];
+  const tooLarge = (path, err) => {
+    if (err?.status !== 413) throw err;
+    problems.push(`${path}: ${err.message}`);
+    return null;
+  };
+  const configText = await source.text(CONFIG_FILE);
+  const parsed = parseModelConfig(configText);
+  const { config } = parsed;
+  problems.push(...parsed.problems);
+  const fallbackRepo = source.ref.owner && source.ref.repo ? { owner: source.ref.owner, repo: source.ref.repo, defaultBranch: REPO_MODEL_DEFAULTS.repo.defaultBranch } : REPO_MODEL_DEFAULTS.repo;
+  const site = siteRepoFromConfig(config, parsed.raw, fallbackRepo);
+  const root = config.tokens.root;
+  const underRoot = await source.list(root === "." ? "" : root);
+  const tokenRel = selectTokenFiles(config, underRoot);
+  const contrastPath = config.contrast?.path;
+  const usagePath = tokensPath(config, config.tokens.usage ?? REPO_MODEL_DEFAULTS.tokensUsage);
+  const tokenPaths = tokenRel.map((f) => tokensPath(config, f));
+  const tokenRead = [.../* @__PURE__ */ new Set([...tokenPaths, ...contrastPath ? [contrastPath] : [], usagePath])];
+  const comps = config.components ?? { dir: REPO_MODEL_DEFAULTS.componentsDir, docsSuffix: ".docs.json", styleSuffix: ".module.css" };
+  const specsPath = comps.specs ?? REPO_MODEL_DEFAULTS.componentSpecs;
+  const indexPath = comps.index ?? (parentDir(comps.dir) ? `${parentDir(comps.dir)}/index.ts` : "index.ts");
+  let compFiles = [];
+  const codeRead = [specsPath];
+  const docsRead = [];
+  if (options.components !== false) {
+    compFiles = await source.list(comps.dir);
+    for (const f of compFiles) {
+      const parts = f.slice(comps.dir.length + 1).split("/");
+      if (parts.length !== 2) continue;
+      const [n, file] = parts;
+      if (file === `${n}${comps.docsSuffix}`) docsRead.push(f);
+      else if ([`${n}.tsx`, `${n}${comps.styleSuffix}`, `${n}.stories.tsx`].includes(file)) codeRead.push(f);
+    }
+    codeRead.push(indexPath);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const fresh = (paths) => paths.filter((p) => {
+    if (seen.has(p)) return false;
+    seen.add(p);
+    return true;
+  });
+  const phases = [
+    ["tokens", fresh(tokenRead)],
+    ["components", fresh(codeRead)],
+    ["docs", fresh(docsRead)]
+  ];
+  const filesTotal = phases.reduce((n, [, paths]) => n + paths.length, 0);
+  let before = 0;
+  const readPhase = async (phase, paths) => {
+    const offset = before;
+    const out = await readRepoTexts(source, paths, concurrency, tooLarge, (done, total) => options.onProgress?.({ phase, done, total, filesDone: offset + done, filesTotal }));
+    before += paths.length;
+    return out;
+  };
+  const bodies = await readPhase("tokens", phases[0][1]);
+  const read = (p) => bodies.get(p) ?? void 0;
+  const files = {};
+  tokenRel.forEach((rel, i) => {
+    const body = read(tokenPaths[i]);
+    if (body !== void 0) files[rel] = body;
+  });
+  const listFiles = (dir) => underRoot.filter((p) => parentDir(p) === dir);
+  let rows;
+  try {
+    rows = buildTokenRows(config, read, listFiles);
+  } catch (err) {
+    problems.push(err.message);
+    rows = emptyRows(config);
+  }
+  let usage = null;
+  const usageText = read(usagePath);
+  if (usageText !== void 0) {
+    try {
+      usage = JSON.parse(usageText);
+    } catch (err) {
+      problems.push(`${usagePath}: ${err.message}`);
+    }
+  }
+  let specs = [];
+  let pairs3 = [];
+  try {
+    specs = parseContrastSpecs(contrastPath ? read(contrastPath) : void 0);
+    pairs3 = evaluateContrastPairs(specs, rows);
+  } catch (err) {
+    problems.push(err.message);
+  }
+  const index = tokenRowIndex(rows);
+  const describeVar = (cssVar) => {
+    const hit = index.get(cssVar);
+    return hit ? { path: hit.path, kind: hit.kind, href: options.href?.(cssVar, hit.type, hit.kind, hit.path) } : void 0;
+  };
+  let components = null;
+  const code = await readPhase("components", phases[1][1]);
+  const docs = await readPhase("docs", phases[2][1]);
+  const readMore = (p) => code.get(p) ?? docs.get(p) ?? bodies.get(p) ?? void 0;
+  if (options.components !== false) {
+    const indexText = readMore(indexPath);
+    const indexDir = parentDir(indexPath);
+    const indexRel = indexDir && comps.dir.startsWith(`${indexDir}/`) ? comps.dir.slice(indexDir.length + 1) : comps.dir;
+    const list2 = scanComponents({ dir: comps.dir, files: compFiles, readText: readMore, indexText, indexRel, docsSuffix: comps.docsSuffix, styleSuffix: comps.styleSuffix, describeVar, problems });
+    components = { dir: comps.dir, index: indexText === void 0 ? void 0 : indexPath, families: indexText === void 0 ? [] : parseComponentFamilies(indexText, indexRel), list: list2 };
+  }
+  const specsText = readMore(specsPath);
+  let specsFile = null;
+  let coverage = [];
+  if (specsText !== void 0) {
+    try {
+      specsFile = parseComponentSpecs(specsText);
+    } catch {
+    }
+    try {
+      coverage = JSON.parse(specsText).coverage ?? [];
+    } catch (err) {
+      problems.push(`${specsPath}: ${err.message}`);
+    }
+  }
+  return {
+    ref: source.ref,
+    configText,
+    config,
+    site,
+    problems,
+    tokens: { root, files, rows, usage },
+    contrast: { path: contrastPath, specs, pairs: pairs3 },
+    components,
+    specs: { path: specsPath, file: specsFile, coverage }
+  };
+}
+
+// ../core/src/snapshot.ts
+var SNAPSHOT_SCHEMA_VERSION = 1;
+var SNAPSHOT_BRANCH = "bridge-data";
+var SNAPSHOT_FILE = "snapshot.json";
+var SNAPSHOT_AUDITS_DIR = "audits";
+var SNAPSHOT_MAX_BYTES = 5e6;
+function recordingSource(source) {
+  const paths = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Map();
+  return {
+    paths,
+    files,
+    source: {
+      get ref() {
+        return source.ref;
+      },
+      async list(prefix) {
+        const out = await source.list(prefix);
+        for (const p of out) paths.add(p);
+        return out;
+      },
+      async text(path) {
+        const body = await source.text(path);
+        if (body !== null) files.set(normalizeRepoPath(path), body);
+        return body;
+      }
+    }
+  };
+}
+function snapshotAudit(id, report) {
+  return {
+    id,
+    path: `${SNAPSHOT_AUDITS_DIR}/${id}.json`,
+    ...report.label ? { label: report.label } : {},
+    generatedAt: report.generatedAt,
+    target: { path: report.target.path, files: report.target.files },
+    metrics: report.metrics
+  };
+}
+var auditId = (s) => s.toLowerCase().replace(/\.json$/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "audit";
+var pairResults = (p) => {
+  const brands = Object.values(p.brands);
+  return brands.length ? brands.flatMap((b) => Object.values(b)) : Object.values(p.modes);
+};
+function snapshotSummary(model) {
+  const results = model.contrast.pairs.flatMap((p) => pairResults(p).map((r) => r.ratio >= p.min));
+  const coverage = model.specs.coverage;
+  const visual = coverage.filter((c) => c.status !== "layout").length;
+  const inFigma = coverage.filter((c) => c.status === "generated" || c.status === "drafted").length;
+  return {
+    tokens: model.tokens.rows.all.length + model.tokens.rows.primitives.length,
+    components: model.components ? model.components.list.length : null,
+    contrast: { pairs: model.contrast.pairs.length, checks: results.length, failing: results.filter((ok) => !ok).length },
+    figma: coverage.length ? { inFigma, visual } : null
+  };
+}
+function buildSnapshot(input) {
+  const { model } = input;
+  const files = {};
+  const entries = input.files instanceof Map ? [...input.files] : Object.entries(input.files);
+  const specsPath = normalizeRepoPath(model.specs.path);
+  for (const [k, v] of entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    const p = normalizeRepoPath(k);
+    if (p !== specsPath) files[p] = v;
+  }
+  const hasSpecs = entries.some(([k]) => normalizeRepoPath(k) === specsPath);
+  return {
+    kind: "bridge-snapshot",
+    schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+    tool: { name: "bridge", version: input.version },
+    generatedAt: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    repo: { owner: model.ref.owner || model.site.owner, name: model.ref.repo || model.site.repo, branch: input.branch ?? model.site.defaultBranch },
+    sourceSha: model.ref.sha,
+    ...input.committedAt ? { committedAt: input.committedAt } : {},
+    paths: [...new Set([...input.paths].map(normalizeRepoPath))].filter((p) => p !== specsPath).sort(),
+    files,
+    figma: hasSpecs ? { path: specsPath, ...model.specs.file?.generated ? { generated: model.specs.file.generated } : {}, coverage: model.specs.coverage } : null,
+    summary: snapshotSummary(model),
+    contrast: { ...model.contrast.path ? { path: model.contrast.path } : {}, pairs: model.contrast.pairs.map(({ fgToken: _fg, bgToken: _bg, ...rest }) => rest) },
+    audits: input.audits ?? [],
+    problems: [...model.problems]
+  };
+}
+var SNAPSHOT_LLMS_FILE = "llms.txt";
+var LLMS_MAX_TOKENS = 600;
+var line = (text) => typeof text === "string" ? text.replace(/\s+/g, " ").trim() : "";
+var strings = (list2) => Array.isArray(list2) ? list2.map(line).filter(Boolean) : [];
+function snapshotLlmsTxt(model, snapshot) {
+  const { owner, name, branch } = snapshot.repo;
+  const date2 = (snapshot.committedAt ?? snapshot.generatedAt).slice(0, 10);
+  const rows = model.tokens.rows;
+  const tokens2 = rows.all.filter((t) => !t.deprecated);
+  const shown = tokens2.slice(0, LLMS_MAX_TOKENS);
+  const comps = model.components?.list ?? [];
+  const out = [
+    `# ${owner}/${name} design system`,
+    "",
+    `> Tokens, components and usage guidance of the design system in github.com/${owner}/${name}, read at ${snapshot.sourceSha.slice(0, 7)} on ${branch} (${date2}). Published by Bridge for AI agents and people.`,
+    "",
+    `- Source: https://github.com/${owner}/${name}/tree/${snapshot.sourceSha}`,
+    `- Every file Bridge read, as JSON: ${SNAPSHOT_FILE}, next to this file on the ${SNAPSHOT_BRANCH} branch.`,
+    `- Themes: ${rows.themes.join(", ") || "none"}. Brands: ${rows.brands.join(", ") || "none"}. Densities: ${rows.densities.join(", ") || "none"}.`,
+    "",
+    "## Tokens",
+    "",
+    `${tokens2.length} tokens (brand, semantic, density and component tiers) on top of ${rows.primitives.length} primitives. Use the semantic tokens in product code, never the primitives. Values are for the default brand${rows.defaultBrand ? ` (${rows.defaultBrand})` : ""}.`,
+    ""
+  ];
+  for (const t of shown) {
+    const values = Object.entries(t.modes).map(([theme, v]) => `${theme} ${line(v.css)}`).join(", ");
+    const note = line(t.description);
+    out.push(`- \`${t.path}\` (\`${t.cssVar}\`, ${t.tier} ${t.type}): ${values || "no value"}${note ? `. ${note}` : ""}`);
+  }
+  if (tokens2.length > shown.length) out.push("", `${tokens2.length - shown.length} more tokens are in ${SNAPSHOT_FILE}.`);
+  out.push("", "## Components", "");
+  if (!comps.length) out.push("No components were read (components.dir in bridge.config.json names the folder).");
+  for (const c of comps) {
+    const d = c.docs;
+    out.push(`### ${line(c.name)}`, "");
+    const summary = line(d?.summary) || line(c.description);
+    if (summary) out.push(summary, "");
+    out.push(`- Family: ${line(c.category)}${c.docs?.status && c.docs.status !== "stable" ? `, ${c.docs.status}` : ""}`);
+    if (c.allTokenPaths.length) out.push(`- Tokens: ${c.allTokenPaths.slice(0, 40).join(", ")}${c.allTokenPaths.length > 40 ? ", ..." : ""}`);
+    for (const [label, list2] of [
+      ["Use it for", strings(d?.whenToUse)],
+      ["Not for", strings(d?.whenNotToUse)],
+      ["Accessibility", strings(d?.accessibility)]
+    ]) {
+      if (list2.length) out.push(`- ${label}:`, ...list2.map((x) => `  - ${x}`));
+    }
+    const dos = Array.isArray(d?.dos) ? d.dos : [];
+    const donts = Array.isArray(d?.donts) ? d.donts : [];
+    for (const g of dos) if (line(g?.title)) out.push(`- Do: ${line(g.title)}${line(g.text) ? `. ${line(g.text)}` : ""}`);
+    for (const g of donts) if (line(g?.title)) out.push(`- Don't: ${line(g.title)}${line(g.text) ? `. ${line(g.text)}` : ""}`);
+    out.push("");
+  }
+  return `${out.join("\n").replace(/\n{3,}/g, "\n\n").trim()}
+`;
+}
+
 // ../visual/src/capture.ts
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
@@ -4425,15 +5515,15 @@ async function shoot(page, r) {
 }
 async function switchStory(page, storyId2) {
   const ok = await page.evaluate(
-    (id) => new Promise((resolve6) => {
+    (id) => new Promise((resolve7) => {
       const ch = window.__STORYBOOK_ADDONS_CHANNEL__;
-      if (!ch) return resolve6(false);
+      if (!ch) return resolve7(false);
       const events = ["storyRendered", "storyErrored", "storyThrewException", "storyMissing", "playFunctionThrewException"];
       const timer = setTimeout(() => done(), 15e3);
       function done() {
         clearTimeout(timer);
         for (const e of events) ch.off(e, done);
-        resolve6(true);
+        resolve7(true);
       }
       for (const e of events) ch.on(e, done);
       window.scrollTo(0, 0);
@@ -4804,9 +5894,9 @@ function storiesFromSource(files) {
 }
 
 // ../visual/src/serve.ts
-import { createReadStream, existsSync as existsSync2, statSync as statSync2 } from "node:fs";
+import { createReadStream, existsSync as existsSync3, statSync as statSync3 } from "node:fs";
 import { createServer } from "node:http";
-import { extname, join as join2, normalize, sep as sep2 } from "node:path";
+import { extname, join as join3, normalize, sep as sep2 } from "node:path";
 var TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -4830,50 +5920,50 @@ function serveDir(dir) {
   const root = normalize(dir);
   const server = createServer((req, res) => {
     const path = decodeURIComponent(new URL(req.url ?? "/", "http://x").pathname);
-    let file = normalize(join2(root, path));
+    let file = normalize(join3(root, path));
     if (!file.startsWith(root + sep2) && file !== root) {
       res.writeHead(403).end();
       return;
     }
-    if (existsSync2(file) && statSync2(file).isDirectory()) file = join2(file, "index.html");
-    if (!existsSync2(file)) {
+    if (existsSync3(file) && statSync3(file).isDirectory()) file = join3(file, "index.html");
+    if (!existsSync3(file)) {
       if (extname(path)) {
         res.writeHead(404).end();
         return;
       }
-      file = join2(root, "index.html");
+      file = join3(root, "index.html");
     }
     res.writeHead(200, { "content-type": TYPES[extname(file)] ?? "application/octet-stream", "cache-control": "no-store" });
     createReadStream(file).pipe(res);
   });
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
       const port = typeof addr === "object" && addr ? addr.port : 0;
-      resolve6({ url: `http://127.0.0.1:${port}`, close: () => new Promise((r) => server.close(() => r())) });
+      resolve7({ url: `http://127.0.0.1:${port}`, close: () => new Promise((r) => server.close(() => r())) });
     });
   });
 }
 
 // ../visual/src/workspace.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { lstat, mkdir as mkdir2, readdir, readFile as readFile2, realpath, rm, symlink } from "node:fs/promises";
-import { dirname as dirname3, join as join3, relative as relative2 } from "node:path";
+import { dirname as dirname3, join as join4, relative as relative2 } from "node:path";
 var PRIVATE = /* @__PURE__ */ new Set([".cache", ".vite", ".vite-temp", ".package-lock.json"]);
 async function workspaceDirs(root) {
-  const pkg = JSON.parse(await readFile2(join3(root, "package.json"), "utf8"));
+  const pkg = JSON.parse(await readFile2(join4(root, "package.json"), "utf8"));
   const pats = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages ?? [];
   const out = [];
   for (const p of pats) {
     if (!p.endsWith("/*")) {
-      if (existsSync3(join3(root, p, "package.json"))) out.push(p);
+      if (existsSync4(join4(root, p, "package.json"))) out.push(p);
       continue;
     }
     const parent = p.slice(0, -2);
-    if (!existsSync3(join3(root, parent))) continue;
-    for (const d of await readdir(join3(root, parent))) if (existsSync3(join3(root, parent, d, "package.json"))) out.push(`${parent}/${d}`);
+    if (!existsSync4(join4(root, parent))) continue;
+    for (const d of await readdir(join4(root, parent))) if (existsSync4(join4(root, parent, d, "package.json"))) out.push(`${parent}/${d}`);
   }
   return out;
 }
@@ -4882,30 +5972,30 @@ async function link(target, at) {
   await symlink(target, at);
 }
 async function linkNodeModules(src, dst) {
-  const srcNm = await realpath(join3(src, "node_modules"));
-  const dstNm = join3(dst, "node_modules");
-  if (existsSync3(dstNm)) return;
+  const srcNm = await realpath(join4(src, "node_modules"));
+  const dstNm = join4(dst, "node_modules");
+  if (existsSync4(dstNm)) return;
   const dirs = await workspaceDirs(dst);
   const names = /* @__PURE__ */ new Map();
   for (const d of dirs) {
-    const { name } = JSON.parse(await readFile2(join3(dst, d, "package.json"), "utf8"));
+    const { name } = JSON.parse(await readFile2(join4(dst, d, "package.json"), "utf8"));
     if (name) names.set(name, d);
   }
   await mkdir2(dstNm, { recursive: true });
   for (const e of await readdir(srcNm)) {
     if (PRIVATE.has(e)) continue;
     if (e.startsWith("@")) {
-      for (const c of await readdir(join3(srcNm, e))) if (!names.has(`${e}/${c}`)) await link(join3(srcNm, e, c), join3(dstNm, e, c));
-    } else if (!names.has(e)) await link(join3(srcNm, e), join3(dstNm, e));
+      for (const c of await readdir(join4(srcNm, e))) if (!names.has(`${e}/${c}`)) await link(join4(srcNm, e, c), join4(dstNm, e, c));
+    } else if (!names.has(e)) await link(join4(srcNm, e), join4(dstNm, e));
   }
   for (const [name, d] of names) {
-    const at = join3(dstNm, name);
+    const at = join4(dstNm, name);
     await rm(at, { force: true, recursive: false }).catch(() => void 0);
-    await link(relative2(dirname3(at), join3(dst, d)), at);
+    await link(relative2(dirname3(at), join4(dst, d)), at);
   }
   for (const d of dirs) {
-    const nested = join3(src, d, "node_modules");
-    if (existsSync3(nested) && !existsSync3(join3(dst, d, "node_modules"))) await link(await realpath(nested), join3(dst, d, "node_modules"));
+    const nested = join4(src, d, "node_modules");
+    if (existsSync4(nested) && !existsSync4(join4(dst, d, "node_modules"))) await link(await realpath(nested), join4(dst, d, "node_modules"));
   }
 }
 async function addWorktree(repo, sha, dir) {
@@ -4915,7 +6005,7 @@ async function addWorktree(repo, sha, dir) {
 }
 async function removeWorktree(repo, dir) {
   try {
-    await rm(join3(dir, "node_modules"), { recursive: true, force: true });
+    await rm(join4(dir, "node_modules"), { recursive: true, force: true });
     await git(repo, ["worktree", "remove", "--force", dir]);
   } catch {
     await rm(dir, { recursive: true, force: true });
@@ -4923,8 +6013,8 @@ async function removeWorktree(repo, dir) {
   await git(repo, ["worktree", "prune"]).catch(() => void 0);
 }
 function run(cmd, args, cwd, log, root = cwd, env = {}) {
-  return new Promise((resolve6, reject) => {
-    const bin = [.../* @__PURE__ */ new Set([join3(cwd, "node_modules", ".bin"), join3(root, "node_modules", ".bin")])].join(":");
+  return new Promise((resolve7, reject) => {
+    const bin = [.../* @__PURE__ */ new Set([join4(cwd, "node_modules", ".bin"), join4(root, "node_modules", ".bin")])].join(":");
     const child = spawn(cmd, args, {
       cwd,
       env: { ...process.env, PATH: `${bin}:${process.env.PATH}`, NODE_OPTIONS: process.env.NODE_OPTIONS ?? "--max-old-space-size=3072", STORYBOOK_DISABLE_TELEMETRY: "1", ...env },
@@ -4936,7 +6026,7 @@ function run(cmd, args, cwd, log, root = cwd, env = {}) {
     child.stderr.on("data", keep);
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) resolve6();
+      if (code === 0) resolve7();
       else {
         log(tail);
         reject(new Error(`${cmd} ${args.join(" ")} failed in ${cwd} (exit ${code})`));
@@ -4952,17 +6042,17 @@ var DEFAULT_BUILD = {
 var isDir = async (p) => (await lstat(p).catch(() => null))?.isDirectory() ?? false;
 async function buildRef(o) {
   const cfg = o.config ?? DEFAULT_BUILD;
-  const out = join3(o.cache, o.sha);
-  const sbOut = join3(out, "storybook");
-  const appOut = join3(out, "app");
-  const needSb = o.plan.storybook && !existsSync3(join3(sbOut, "index.json"));
-  const needApp = o.plan.app && !existsSync3(join3(appOut, "index.html"));
+  const out = join4(o.cache, o.sha);
+  const sbOut = join4(out, "storybook");
+  const appOut = join4(out, "app");
+  const needSb = o.plan.storybook && !existsSync4(join4(sbOut, "index.json"));
+  const needApp = o.plan.app && !existsSync4(join4(appOut, "index.html"));
   const built = { ...o.plan.storybook ? { storybook: sbOut } : {}, ...o.plan.app ? { app: appOut } : {} };
   if (!needSb && !needApp) {
     o.log(`  ${o.sha.slice(0, 7)}: builds cached`);
     return built;
   }
-  const dir = join3(o.work, `wt-${o.sha.slice(0, 12)}`);
+  const dir = join4(o.work, `wt-${o.sha.slice(0, 12)}`);
   o.log(`  ${o.sha.slice(0, 7)}: worktree ${dir}`);
   await addWorktree(o.repo, o.sha, dir);
   try {
@@ -4974,15 +6064,15 @@ async function buildRef(o) {
       await rm(sbOut, { recursive: true, force: true });
       await run("storybook", ["build", "-c", cfg.storybookConfigDir, "-o", sbOut, "--quiet", "--disable-telemetry"], dir, o.log);
     }
-    if (needApp && await isDir(join3(dir, cfg.appDir))) {
+    if (needApp && await isDir(join4(dir, cfg.appDir))) {
       o.log(`  ${o.sha.slice(0, 7)}: app build`);
       await rm(appOut, { recursive: true, force: true });
-      await run("vite", ["build", "--outDir", appOut, "--emptyOutDir", "--logLevel", "warn"], join3(dir, cfg.appDir), o.log, dir);
+      await run("vite", ["build", "--outDir", appOut, "--emptyOutDir", "--logLevel", "warn"], join4(dir, cfg.appDir), o.log, dir);
     }
   } finally {
     if (!o.keep) await removeWorktree(o.repo, dir);
   }
-  if (o.plan.app && !existsSync3(join3(appOut, "index.html"))) delete built.app;
+  if (o.plan.app && !existsSync4(join4(appOut, "index.html"))) delete built.app;
   return built;
 }
 
@@ -4990,7 +6080,7 @@ async function buildRef(o) {
 var STORY_READY = `document.body.classList.contains('sb-show-main') && (document.querySelector('#storybook-root')?.childElementCount > 0 || document.querySelector('[role="dialog"]')) || document.body.classList.contains('sb-show-errordisplay')`;
 var APP_READY = `document.querySelector('#root')?.childElementCount > 0 && !document.querySelector('[aria-busy="true"]')`;
 async function readConfig(root, sha) {
-  const text = await showFile(root, sha, "bridge.config.json") ?? (existsSync4(join4(root, "bridge.config.json")) ? await readFile3(join4(root, "bridge.config.json"), "utf8") : null);
+  const text = await showFile(root, sha, "bridge.config.json") ?? (existsSync5(join5(root, "bridge.config.json")) ? await readFile3(join5(root, "bridge.config.json"), "utf8") : null);
   if (!text) throw new Error("bridge.config.json not found: run `bridge init` first.");
   return loadConfig(text);
 }
@@ -5013,7 +6103,7 @@ function changedTokens(before, after) {
   return [...modes.entries()].map(([path, m]) => ({ path, kind: direct.has(path) ? "direct" : "alias", modes: m })).sort((a, b) => Number(a.kind === "alias") - Number(b.kind === "alias") || a.path.localeCompare(b.path));
 }
 async function readIndexJson(dir) {
-  const index = parseStorybookIndex(JSON.parse(await readFile3(join4(dir, "index.json"), "utf8")), "index.json");
+  const index = parseStorybookIndex(JSON.parse(await readFile3(join5(dir, "index.json"), "utf8")), "index.json");
   return index.entries.filter((e) => e.type === "story").map(({ id, title, name, importPath }) => ({ id, title, name, importPath }));
 }
 async function planImpact(o) {
@@ -5055,7 +6145,7 @@ async function runImpact(o) {
   const log = o.log ?? ((m) => process.stderr.write(`${m}
 `));
   const root = resolve2(o.root);
-  const outDir = resolve2(o.out ?? join4(root, "visual-impact"));
+  const outDir = resolve2(o.out ?? join5(root, "visual-impact"));
   const threshold = o.threshold ?? 0.03;
   const only = o.only?.length ? o.only : ["stories", "app"];
   const vp = { stories: o.viewport?.stories ?? { width: 1024, height: 768 }, app: o.viewport?.app ?? { width: 1280, height: 800 } };
@@ -5082,12 +6172,12 @@ async function runImpact(o) {
       shots: shots2
     };
     await mkdir3(outDir, { recursive: true });
-    const manifestPath = join4(outDir, "manifest.json");
+    const manifestPath = join5(outDir, "manifest.json");
     await writeFile3(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
     let commentPath;
     if (o.imageBase !== void 0 || o.artifactUrl) {
-      commentPath = join4(outDir, "comment.md");
+      commentPath = join5(outDir, "comment.md");
       await writeFile3(commentPath, renderComment(manifest, { ...o.imageBase ? { imageBase: o.imageBase } : {}, ...o.artifactUrl ? { artifactUrl: o.artifactUrl } : {} }));
     }
     return { manifest, outDir, manifestPath, ...commentPath ? { commentPath } : {}, summary: summaryLine(manifest) };
@@ -5099,8 +6189,8 @@ async function runImpact(o) {
     log("Nothing visual to capture.");
     return finish([]);
   }
-  const cache2 = resolve2(o.cacheDir ?? join4(root, "node_modules", ".cache", "bridge-visual"));
-  const work = resolve2(o.workDir ?? join4(tmpdir(), `bridge-visual-${process.pid}`));
+  const cache2 = resolve2(o.cacheDir ?? join5(root, "node_modules", ".cache", "bridge-visual"));
+  const work = resolve2(o.workDir ?? join5(tmpdir(), `bridge-visual-${process.pid}`));
   await mkdir3(work, { recursive: true });
   const builds = { base: {}, head: {} };
   try {
@@ -5129,7 +6219,7 @@ async function runImpact(o) {
   }
   const byId = /* @__PURE__ */ new Map();
   if (builds.head.storybook) for (const s of await readIndexJson(builds.head.storybook)) byId.set(s.id, s);
-  if (builds.base.storybook && existsSync4(join4(builds.base.storybook, "index.json"))) {
+  if (builds.base.storybook && existsSync5(join5(builds.base.storybook, "index.json"))) {
     for (const s of await readIndexJson(builds.base.storybook)) if (!byId.has(s.id)) byId.set(s.id, s);
   }
   const jobs = [];
@@ -5144,18 +6234,18 @@ async function runImpact(o) {
       for (const theme of THEMES)
         for (const r of routes) jobs.push({ key: shotKey("app", r.id, t.id, theme), kind: "route", label: r.label, route: r, tenant: t, brand: t.brand, theme });
   await rm2(outDir, { recursive: true, force: true });
-  for (const d of ["before", "after", "diff", "composite"]) await mkdir3(join4(outDir, d), { recursive: true });
+  for (const d of ["before", "after", "diff", "composite"]) await mkdir3(join5(outDir, d), { recursive: true });
   const errors = /* @__PURE__ */ new Map();
   for (const side of ["base", "head"]) {
     const b = builds[side];
     const served = [];
     const browser = await launch();
     try {
-      const sb = b.storybook && existsSync4(join4(b.storybook, "index.json")) ? await serveDir(b.storybook) : null;
-      const app = b.app && existsSync4(join4(b.app, "index.html")) ? await serveDir(b.app) : null;
+      const sb = b.storybook && existsSync5(join5(b.storybook, "index.json")) ? await serveDir(b.storybook) : null;
+      const app = b.app && existsSync5(join5(b.app, "index.html")) ? await serveDir(b.app) : null;
       if (sb) served.push(sb);
       if (app) served.push(app);
-      const dir = join4(outDir, side === "base" ? "before" : "after");
+      const dir = join5(outDir, side === "base" ? "before" : "after");
       const storyJobs = jobs.filter((j) => j.kind === "story");
       if (sb && storyJobs.length) {
         log(`Capturing ${storyJobs.length} story shots at ${side}`);
@@ -5170,7 +6260,7 @@ async function runImpact(o) {
               if (!known.has(j.storyId)) continue;
               const err = await shoot(page, {
                 url: storyUrl(sb.url, j.storyId, j.brand, j.theme),
-                file: join4(dir, `${j.key}.png`),
+                file: join5(dir, `${j.key}.png`),
                 fullPage: true,
                 readyFn: STORY_READY,
                 // Loading stories (Spinner, Skeleton) stay aria-busy on purpose: do not wait for them.
@@ -5196,7 +6286,7 @@ async function runImpact(o) {
             const ctx = await newContext(browser, vp.app);
             const page = await newPage(ctx);
             for (const j of routeJobs.filter((x) => x.tenant.id === t.id && x.theme === theme)) {
-              const err = await shoot(page, { url: routeUrl(app.url, j.route, t.id, theme), file: join4(dir, `${j.key}.png`), fullPage: false, readyFn: APP_READY, ...j.route.waitFor ? { waitFor: j.route.waitFor } : {}, mask: ["[data-visual-mask]", ...j.route.mask ?? []] });
+              const err = await shoot(page, { url: routeUrl(app.url, j.route, t.id, theme), file: join5(dir, `${j.key}.png`), fullPage: false, readyFn: APP_READY, ...j.route.waitFor ? { waitFor: j.route.waitFor } : {}, mask: ["[data-visual-mask]", ...j.route.mask ?? []] });
               if (err) errors.set(`${side}:${j.key}`, err);
             }
             await ctx.close();
@@ -5210,10 +6300,10 @@ async function runImpact(o) {
   log("Diffing");
   const shots = [];
   for (const j of jobs) {
-    const bf = join4(outDir, "before", `${j.key}.png`);
-    const af = join4(outDir, "after", `${j.key}.png`);
-    const hasB = existsSync4(bf);
-    const hasA = existsSync4(af);
+    const bf = join5(outDir, "before", `${j.key}.png`);
+    const af = join5(outDir, "after", `${j.key}.png`);
+    const hasB = existsSync5(bf);
+    const hasA = existsSync5(af);
     const base = {
       key: j.key,
       kind: j.kind,
@@ -5253,7 +6343,7 @@ async function runImpact(o) {
     if (changed || o.keepUnchanged) Object.assign(images, { before: `before/${j.key}.png`, after: `after/${j.key}.png` });
     else await Promise.all([unlink(bf), unlink(af)]);
     if (d.diff) {
-      await writeFile3(join4(outDir, "diff", `${j.key}.png`), encodePng(d.diff));
+      await writeFile3(join5(outDir, "diff", `${j.key}.png`), encodePng(d.diff));
       images.diff = `diff/${j.key}.png`;
     }
     shots.push({
@@ -5278,13 +6368,13 @@ async function runImpact(o) {
       for (const s of toComposite) {
         const w = Math.max(s.size.before?.width ?? 0, s.size.after?.width ?? 0);
         const h = Math.max(s.size.before?.height ?? 0, s.size.after?.height ?? 0);
-        const file = join4(outDir, "composite", `${s.key}.png`);
+        const file = join5(outDir, "composite", `${s.key}.png`);
         await composite(page, {
           title: s.label,
           subtitle: `${s.tenant ? `${DEFAULT_TENANTS.find((t) => t.id === s.tenant)?.name ?? s.tenant}, ` : ""}${s.brand}, ${s.theme} \xB7 ${s.status === "changed" ? `${s.percent.toFixed(2)}% changed` : s.status}`,
-          before: s.images.before ? join4(outDir, s.images.before) : null,
-          after: s.images.after ? join4(outDir, s.images.after) : null,
-          diff: s.images.diff ? join4(outDir, s.images.diff) : null,
+          before: s.images.before ? join5(outDir, s.images.before) : null,
+          after: s.images.after ? join5(outDir, s.images.after) : null,
+          diff: s.images.diff ? join5(outDir, s.images.diff) : null,
           width: w,
           height: h,
           boxes: s.boxes,
@@ -5303,16 +6393,16 @@ async function runImpact(o) {
 }
 
 // ../visual/src/references.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname4, join as join6 } from "node:path";
 async function captureFigmaReferences(o) {
   const log = o.log ?? (() => void 0);
   const scale = o.scale ?? 2;
   const brand2 = o.brand ?? "bridge";
   const theme = o.theme ?? "light";
-  if (!existsSync5(join5(o.storybook, "index.json"))) throw new Error(`No built Storybook in ${o.storybook}: run npm run build-storybook first.`);
-  const index = JSON.parse(await readFile4(join5(o.storybook, "index.json"), "utf8"));
+  if (!existsSync6(join6(o.storybook, "index.json"))) throw new Error(`No built Storybook in ${o.storybook}: run npm run build-storybook first.`);
+  const index = JSON.parse(await readFile4(join6(o.storybook, "index.json"), "utf8"));
   if (!index.entries[FIGMA_REFERENCE_STORY]) throw new Error(`The Storybook build has no ${FIGMA_REFERENCE_STORY} story (packages/react/src/stories/FigmaReference.stories.tsx).`);
   const specs = parseComponentSpecs(await readFile4(o.specs, "utf8"));
   const jobs = planReferences(specs).filter((j) => !o.only?.length || o.only.includes(j.component));
@@ -5347,12 +6437,12 @@ async function captureFigmaReferences(o) {
       }
       const plan = JSON.stringify(j.plan.render);
       await page.evaluate(
-        ({ id, plan: plan2 }) => new Promise((resolve6) => {
+        ({ id, plan: plan2 }) => new Promise((resolve7) => {
           const ch = window.__STORYBOOK_ADDONS_CHANNEL__;
           const done = () => {
             clearTimeout(timer);
             ch.off("storyRendered", done);
-            resolve6();
+            resolve7();
           };
           const timer = setTimeout(done, 1e4);
           ch.on("storyRendered", done);
@@ -5375,7 +6465,7 @@ async function captureFigmaReferences(o) {
         continue;
       }
       const file = referenceImagePath(j.component, j.key);
-      const path = join5(o.out, file);
+      const path = join6(o.out, file);
       await mkdir4(dirname4(path), { recursive: true });
       await target.screenshot({ path, omitBackground: true, animations: "disabled", caret: "hide", scale: "device" });
       const box = await target.boundingBox();
@@ -5388,7 +6478,7 @@ async function captureFigmaReferences(o) {
     await served.close();
   }
   await mkdir4(o.out, { recursive: true });
-  const manifestPath = join5(o.out, "manifest.json");
+  const manifestPath = join6(o.out, "manifest.json");
   await writeFile4(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
   log(`${captured} images, ${skipped} variants skipped. ${manifestPath}`);
@@ -5396,10 +6486,10 @@ async function captureFigmaReferences(o) {
 }
 
 // src/index.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 
 // src/request.ts
-import { execFileSync, spawnSync } from "node:child_process";
+import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
 import { readFile as readFile5 } from "node:fs/promises";
 import { BridgeContext as BridgeContext2, requests as requests2 } from "@bridge-ds/mcp";
 
@@ -5515,7 +6605,7 @@ var defaultIO = () => ({
   env: process.env,
   ghToken() {
     try {
-      return execFileSync("gh", ["auth", "token"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim() || void 0;
+      return execFileSync2("gh", ["auth", "token"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim() || void 0;
     } catch {
       return void 0;
     }
@@ -6312,7 +7402,7 @@ ${r.fixes.sample.map((s) => `  ${s}`).join("\n")}`);
 }
 
 // src/figma.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 import { BridgeContext as BridgeContext7, branches as branches3, figma } from "@bridge-ds/mcp";
 var FIGMA_HELP = `bridge figma: component changes sent from Figma
@@ -6379,7 +7469,7 @@ ${r.brief}`);
       if (!file) throw new RequestUsageError("Usage: bridge figma push <diff.json> [--dry-run]");
       let diff2;
       try {
-        diff2 = JSON.parse(readFileSync2(resolve4(root, file), "utf8"));
+        diff2 = JSON.parse(readFileSync3(resolve4(root, file), "utf8"));
       } catch (err) {
         throw new RequestUsageError(`${file} could not be read as JSON: ${err.message}`);
       }
@@ -6399,6 +7489,94 @@ ${r.brief}`);
   }
 }
 
+// src/snapshot.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync, readdirSync as readdirSync3, readFileSync as readFileSync4, rmSync, statSync as statSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename, join as join7, relative as relative4, resolve as resolve5 } from "node:path";
+var git2 = (root, args) => {
+  try {
+    return execFileSync3("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return "";
+  }
+};
+var isReport = (x) => {
+  const r = x;
+  return !!r && typeof r === "object" && r.schemaVersion === 1 && typeof r.generatedAt === "string" && !!r.metrics && Array.isArray(r.files);
+};
+function reportFiles(root, entry) {
+  const abs = resolve5(root, entry);
+  if (!existsSync7(abs)) throw new Error(`Audit report not found: ${entry}`);
+  if (!statSync4(abs).isDirectory()) return [abs];
+  return readdirSync3(abs).filter((n) => n.endsWith(".json")).sort().map((n) => join7(abs, n));
+}
+async function writeSnapshot(opts) {
+  const rec = recordingSource(fsSource(opts.root));
+  const model = await loadRepoModel(rec.source);
+  const audits = /* @__PURE__ */ new Map();
+  for (const entry of opts.auditReports ?? []) {
+    for (const file of reportFiles(opts.root, entry)) {
+      let data;
+      try {
+        data = JSON.parse(readFileSync4(file, "utf8"));
+      } catch (err) {
+        throw new Error(`${relative4(opts.root, file)} is not valid JSON (${err.message})`);
+      }
+      if (!isReport(data)) continue;
+      const id = auditId(basename(file));
+      audits.set(id, { summary: snapshotAudit(id, data), report: data });
+    }
+  }
+  for (const spec of opts.audit ?? []) {
+    const [path, label] = spec.split(/=(.*)/s, 2);
+    const abs = resolve5(opts.root, path);
+    if (!existsSync7(abs)) throw new Error(`No such file or folder to audit: ${path}`);
+    const report = runAudit(abs, { ds: opts.root, version: opts.version, ...label ? { label } : {} });
+    const id = auditId(label || relative4(opts.root, abs) || basename(abs));
+    audits.set(id, { summary: snapshotAudit(id, report), report });
+  }
+  const snapshot = buildSnapshot({
+    model,
+    paths: rec.paths,
+    files: rec.files,
+    version: opts.version,
+    ...opts.branch ? { branch: opts.branch } : {},
+    ...git2(opts.root, ["log", "-1", "--format=%cI"]) ? { committedAt: git2(opts.root, ["log", "-1", "--format=%cI"]) } : {},
+    ...opts.generatedAt ? { generatedAt: opts.generatedAt } : {},
+    audits: [...audits.values()].map((a) => a.summary)
+  });
+  const text = `${JSON.stringify(snapshot)}
+`;
+  const bytes = Buffer.byteLength(text);
+  if (bytes > SNAPSHOT_MAX_BYTES) throw new Error(`${SNAPSHOT_FILE} would be ${(bytes / 1e6).toFixed(1)} MB, over the ${SNAPSHOT_MAX_BYTES / 1e6} MB limit: is tokens.root or components.dir too wide in bridge.config.json?`);
+  rmSync(join7(opts.out, SNAPSHOT_AUDITS_DIR), { recursive: true, force: true });
+  mkdirSync(opts.out, { recursive: true });
+  writeFileSync2(join7(opts.out, SNAPSHOT_FILE), text);
+  writeFileSync2(join7(opts.out, SNAPSHOT_LLMS_FILE), snapshotLlmsTxt(model, snapshot));
+  const written = [SNAPSHOT_FILE, SNAPSHOT_LLMS_FILE];
+  if (audits.size) mkdirSync(join7(opts.out, SNAPSHOT_AUDITS_DIR), { recursive: true });
+  for (const { summary, report } of audits.values()) {
+    writeFileSync2(join7(opts.out, summary.path), `${JSON.stringify(report)}
+`);
+    written.push(summary.path);
+  }
+  return { snapshot, written, bytes };
+}
+function snapshotLines(r, out) {
+  const s = r.snapshot;
+  const c = s.summary.contrast;
+  const kb = Math.max(1, Math.round(r.bytes / 1024));
+  return [
+    `Wrote ${join7(out, SNAPSHOT_FILE)} (${kb} KB) for ${s.repo.owner}/${s.repo.name} at ${s.sourceSha.slice(0, 7)}.`,
+    `  tokens        ${s.summary.tokens}`,
+    `  components    ${s.summary.components ?? "not scanned"}`,
+    `  contrast      ${c.checks} checks over ${c.pairs} pairs, ${c.failing} failing`,
+    `  figma         ${s.summary.figma ? `${s.summary.figma.inFigma} of ${s.summary.figma.visual} visual components` : "no component-specs.json"}`,
+    `  audits        ${s.audits.length ? s.audits.map((a) => a.path).join(", ") : "none (--audit <path> or --audit-report <file|dir>)"}`,
+    ...s.problems.map((p) => `  problem       ${p}`)
+  ];
+}
+
 // src/protection.ts
 var UNKNOWN = { kind: "unknown", missing: ["review", "checks", "history", "deletion"] };
 async function protectionReport(opts) {
@@ -6491,6 +7669,13 @@ Usage:
                                       Exit 0 ok, 1 under --fail-under or regressed, 2 setup error
   bridge audit <path> --fix [--write] safe autofix: CSS values equal to a token become var(--token).
                                       Dry run unless --write
+  bridge snapshot [--out bridge-data] [--audit <path>[=label] ...] [--audit-report <file|dir> ...]
+                 [--branch main] [--json]
+                                      the repo model of this checkout for hosted Bridge (Studio and Library):
+                                      snapshot.json (token, contrast and component files, Figma coverage,
+                                      contrast results) plus audits/<id>.json. --audit runs bridge audit on a
+                                      product folder; --audit-report carries reports already written.
+                                      The bridge-data workflow publishes the folder to the bridge-data branch
   bridge docs draft <Component> [--json]
                                       docs.json pre-fill from the code (props, tokens, anatomy, contrast,
                                       changelog line, missing keys) and a prompt for Claude to write the
@@ -6579,9 +7764,9 @@ function printSent(r) {
   if (r.hint) print(String(r.hint));
 }
 async function init(a, root) {
-  const cfgPath = join6(root, CONFIG_FILE2);
+  const cfgPath = join8(root, CONFIG_FILE2);
   let config;
-  if (existsSync6(cfgPath) && !has7(a, "force")) {
+  if (existsSync8(cfgPath) && !has7(a, "force")) {
     print(`${CONFIG_FILE2} exists, keeping it (--force to regenerate).`);
     config = (await (await BridgeContext8.create({ root })).config()).config;
   } else {
@@ -6595,11 +7780,11 @@ async function init(a, root) {
     print("Check the layers order (lowest first) and the tiers; detection is a starting point.");
   }
   const serverJs = fileURLToPath(new URL("./index.js", import.meta.resolve("@bridge-ds/mcp")));
-  const relServer = relative4(root, serverJs);
+  const relServer = relative5(root, serverJs);
   const inRepo = !relServer.startsWith("..") && !isAbsolute(relServer);
   const server = (dir) => inRepo ? { command: "node", args: [relServer, "--root", dir] } : { command: "npx", args: ["-y", MCP_PACKAGE, "--root", dir] };
-  const mcpPath = join6(root, ".mcp.json");
-  const existing = existsSync6(mcpPath) ? JSON.parse(await readFile7(mcpPath, "utf8")) : {};
+  const mcpPath = join8(root, ".mcp.json");
+  const existing = existsSync8(mcpPath) ? JSON.parse(await readFile7(mcpPath, "utf8")) : {};
   existing.mcpServers = { ...existing.mcpServers ?? {}, bridge: server(".") };
   await writeFile5(mcpPath, `${JSON.stringify(existing, null, 2)}
 `);
@@ -6631,8 +7816,8 @@ async function check(a, root) {
     const tight = c.tightest?.[0];
     if (tight) print(`  tightest: ${tight.pair} [${tight.modes}] ${tight.ratio}:1 (min ${tight.min})`);
   } else print(`contrast: ${c.message}`);
-  for (const line of protection?.lines ?? []) print(line);
-  for (const line of roles?.lines ?? []) print(line);
+  for (const line2 of protection?.lines ?? []) print(line2);
+  for (const line2 of roles?.lines ?? []) print(line2);
   print(failed ? "FAIL" : "OK");
   return failed ? 1 : 0;
 }
@@ -6724,7 +7909,7 @@ async function propose(a, root) {
     edits.push({ op: "set", path: s.slice(0, i), value: s.slice(i + 1), ...file ? { file } : {}, ...mode2 ? { mode: mode2 } : {} });
   }
   const editsFile = flag5(a, "edits");
-  if (editsFile) edits.push(...JSON.parse(await readFile7(resolve5(editsFile), "utf8")));
+  if (editsFile) edits.push(...JSON.parse(await readFile7(resolve6(editsFile), "utf8")));
   if (!edits.length) throw new UsageError("Give at least one --set path=value or --edits file.json");
   const pr = flag5(a, "pr");
   const changes = changesFlag(a);
@@ -6810,19 +7995,19 @@ async function figmaReferences(a, root) {
   let sha = flag5(a, "sha");
   if (!sha) {
     try {
-      sha = execFileSync2("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim();
+      sha = execFileSync4("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim();
     } catch {
       sha = "unknown";
     }
   }
   const only = (flag5(a, "only") ?? "").split(",").filter(Boolean);
   const r = await captureFigmaReferences({
-    storybook: resolve5(root, flag5(a, "storybook") ?? "storybook-static"),
-    specs: resolve5(root, flag5(a, "specs") ?? "packages/react/component-specs.json"),
-    out: resolve5(root, flag5(a, "out") ?? "figma-references"),
+    storybook: resolve6(root, flag5(a, "storybook") ?? "storybook-static"),
+    specs: resolve6(root, flag5(a, "specs") ?? "packages/react/component-specs.json"),
+    out: resolve6(root, flag5(a, "out") ?? "figma-references"),
     sha,
     ...only.length ? { only } : {},
-    log: has7(a, "json") ? void 0 : (line) => print(line)
+    log: has7(a, "json") ? void 0 : (line2) => print(line2)
   });
   if (has7(a, "json")) print(JSON.stringify({ manifest: r.manifestPath, captured: r.captured, skipped: r.skipped }, null, 2));
   return 0;
@@ -6842,10 +8027,10 @@ async function impact(a, root) {
     root,
     base: flag5(a, "base") ?? "main",
     head: flag5(a, "head") ?? "HEAD",
-    ...out ? { out: resolve5(out) } : {},
+    ...out ? { out: resolve6(out) } : {},
     ...only.length ? { only } : {},
     ...threshold !== void 0 ? { threshold } : {},
-    ...cacheDir ? { cacheDir: resolve5(cacheDir) } : {},
+    ...cacheDir ? { cacheDir: resolve6(cacheDir) } : {},
     ...maxStories ? { maxStoriesPerComponent: maxStories } : {},
     ...imageBase !== void 0 ? { imageBase } : {},
     ...artifactUrl ? { artifactUrl } : {},
@@ -6937,8 +8122,8 @@ ${r.suggestion?.body ?? r.prBody}`);
 async function audit(a, root) {
   const target = a._[1];
   if (!target) throw new UsageError("bridge audit <path>   (a product folder or file that uses the design system)");
-  if (!existsSync6(target)) throw new UsageError(`No such file or folder: ${target}`);
-  const dsRoot = flag5(a, "ds") ? resolve5(flag5(a, "ds")) : existsSync6(join6(root, CONFIG_FILE2)) ? root : findDesignSystemRoot(root);
+  if (!existsSync8(target)) throw new UsageError(`No such file or folder: ${target}`);
+  const dsRoot = flag5(a, "ds") ? resolve6(flag5(a, "ds")) : existsSync8(join8(root, CONFIG_FILE2)) ? root : findDesignSystemRoot(root);
   if (!dsRoot) throw new UsageError(`No ${CONFIG_FILE2} found: run bridge audit from the design system repo or pass --ds <dir>.`);
   const ds = loadDesignSystem(dsRoot);
   if (has7(a, "fix")) {
@@ -6952,12 +8137,12 @@ async function audit(a, root) {
   const baselinePath = flag5(a, "baseline");
   let baseline;
   if (baselinePath) {
-    if (!existsSync6(baselinePath)) throw new UsageError(`Baseline not found: ${baselinePath}`);
+    if (!existsSync8(baselinePath)) throw new UsageError(`Baseline not found: ${baselinePath}`);
     baseline = JSON.parse(await readFile7(baselinePath, "utf8"));
   }
   const label = flag5(a, "label");
   const allowlistPath = flag5(a, "allowlist");
-  if (allowlistPath && !existsSync6(allowlistPath)) throw new UsageError(`Allowlist not found: ${allowlistPath}`);
+  if (allowlistPath && !existsSync8(allowlistPath)) throw new UsageError(`Allowlist not found: ${allowlistPath}`);
   let allowlist;
   try {
     allowlist = allowlistPath ? loadAllowlist(allowlistPath) : void 0;
@@ -7027,6 +8212,17 @@ async function audit(a, root) {
   }
   return code;
 }
+async function snapshotCmd(a, root) {
+  const out = resolve6(root, flag5(a, "out") ?? "bridge-data");
+  const branch = flag5(a, "branch");
+  const r = await writeSnapshot({ root, out, version: VERSION, audit: a.flags.audit ?? [], auditReports: a.flags["audit-report"] ?? [], ...branch ? { branch } : {} });
+  if (has7(a, "json")) print(JSON.stringify({ out, written: r.written, bytes: r.bytes, sourceSha: r.snapshot.sourceSha, summary: r.snapshot.summary, audits: r.snapshot.audits.map((x) => x.path), problems: r.snapshot.problems }, null, 2));
+  else {
+    const shown = relative5(process.cwd(), out);
+    for (const line2 of snapshotLines(r, shown.startsWith("..") || isAbsolute(shown) ? out : shown || ".")) print(line2);
+  }
+  return 0;
+}
 async function docsCmd(a, root) {
   const [, sub, name] = a._;
   if (sub !== "draft" || !name) throw new UsageError("Usage: bridge docs draft <Component> [--json]");
@@ -7063,7 +8259,7 @@ async function main() {
   const argv = process.argv.slice(2);
   const a = parse(argv);
   const cmd = a._[0];
-  const root = resolve5(flag5(a, "root") ?? process.cwd());
+  const root = resolve6(flag5(a, "root") ?? process.cwd());
   if (cmd === "request") return runRequest(a, root);
   if (cmd === "explore") return runExplore(a, root);
   if (cmd === "branch") return runBranch(a, root);
@@ -7106,6 +8302,8 @@ async function main() {
       return audit(a, root);
     case "docs":
       return docsCmd(a, root);
+    case "snapshot":
+      return snapshotCmd(a, root);
     case "mcp":
       await serveStdio(optionsFromArgv(argv.slice(1)));
       return -1;