@designtools/manifest 0.0.0-stage → 0.2.0

package/dist/chunk-PQGMDEUF.js

@@ -0,0 +1,1950 @@
+// src/jsdoc.ts
+import ts from "typescript";
+var MANIFEST_TAGS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "category",
+  "example",
+  "see",
+  "deprecated",
+  "primitive",
+  "aria",
+  "nodocgen",
+  "status",
+  "use",
+  "avoid",
+  "instead",
+  "replaces",
+  "role",
+  "keyboard"
+]);
+var IGNORED_TAGS = /* @__PURE__ */ new Set([
+  "param",
+  "returns",
+  "return",
+  "default",
+  "defaultValue",
+  "remarks",
+  "internal",
+  "link",
+  "since",
+  "type",
+  "typedef",
+  "property",
+  "prop",
+  "template",
+  "throws",
+  "todo",
+  "public",
+  "private",
+  "beta",
+  "alpha",
+  "experimental",
+  "version",
+  "author"
+]);
+function isKnownTag(name) {
+  return MANIFEST_TAGS.has(name) || IGNORED_TAGS.has(name);
+}
+function leadingJSDoc(sf, node) {
+  const text2 = sf.getFullText();
+  const ranges = ts.getLeadingCommentRanges(text2, node.getFullStart()) ?? [];
+  const last = [...ranges].reverse().find((r) => text2.startsWith("/**", r.pos) && text2.slice(r.pos, r.end) !== "/**/");
+  if (!last) return void 0;
+  const parsed = parseJSDoc(text2.slice(last.pos, last.end));
+  return { ...parsed, line: sf.getLineAndCharacterOfPosition(last.pos).line + 1 };
+}
+function parseJSDoc(comment) {
+  const lines = comment.replace(/^\/\*\*/, "").replace(/\*\/$/, "").split("\n").map((l) => l.replace(/^\s*\* ?/, "").replace(/\s+$/, ""));
+  const description = [];
+  const tags2 = [];
+  let current;
+  const close = () => {
+    if (current) tags2.push({ name: current.name, text: trimBlock(current.lines) });
+    current = void 0;
+  };
+  for (const line of lines) {
+    const tag2 = /^\s*@([A-Za-z][\w-]*)(?=\s|$)\s?(.*)$/.exec(line);
+    if (tag2 && !(current?.name === "example" && !/^@/.test(line))) {
+      close();
+      current = { name: tag2[1], lines: [tag2[2]] };
+    } else if (current) {
+      current.lines.push(line);
+    } else {
+      description.push(line.trim());
+    }
+  }
+  close();
+  return { description: joinParagraphs(description), tags: tags2 };
+}
+function trimBlock(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && lines[start].trim() === "") start++;
+  while (end > start && lines[end - 1].trim() === "") end--;
+  return lines.slice(start, end).join("\n");
+}
+function joinParagraphs(lines) {
+  return lines.join("\n").split(/\n{2,}/).map((p) => p.split("\n").map((l) => l.trim()).filter(Boolean).join(" ")).filter(Boolean).join("\n\n");
+}
+function tag(doc, name) {
+  return doc?.tags.find((t) => t.name === name)?.text;
+}
+function tags(doc, name) {
+  return doc?.tags.filter((t) => t.name === name).map((t) => t.text) ?? [];
+}
+function hasTag(doc, name) {
+  return doc?.tags.some((t) => t.name === name) ?? false;
+}
+function describe(doc) {
+  if (!doc) return void 0;
+  const parts = [doc.description, ...tags(doc, "description").map((t) => joinParagraphs(t.split("\n")))].filter(
+    Boolean
+  );
+  return parts.length ? parts.join("\n\n") : void 0;
+}
+function checkTags(source, doc, owner, warn) {
+  for (const t of doc?.tags ?? []) {
+    if (isKnownTag(t.name)) continue;
+    const near = [...MANIFEST_TAGS].find((known) => distance(known, t.name) <= 2);
+    warn({
+      file: source,
+      line: doc?.line,
+      message: `unknown JSDoc tag @${t.name} on ${owner}${near ? ` (did you mean @${near}?)` : ""}`
+    });
+  }
+}
+function distance(a, b) {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 1; j <= b.length; j++) d[0][j] = j;
+  for (let i = 1; i <= a.length; i++)
+    for (let j = 1; j <= b.length; j++)
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+  return d[a.length][b.length];
+}
+
+// src/variants.ts
+import ts2 from "typescript";
+var LIBRARIES = {
+  "tailwind-variants": { tv: "tv", createTV: "tv" },
+  "class-variance-authority": { cva: "cva" },
+  cva: { cva: "cva" }
+};
+function variantCallees(sf) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (!ts2.isImportDeclaration(stmt) || !ts2.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const lib = LIBRARIES[stmt.moduleSpecifier.text];
+    const named = stmt.importClause?.namedBindings;
+    if (!lib || !named || !ts2.isNamedImports(named)) continue;
+    for (const el of named.elements) {
+      const imported = (el.propertyName ?? el.name).text;
+      if (lib[imported]) out.set(el.name.text, lib[imported]);
+    }
+  }
+  return out;
+}
+function findVariantConfigs(sf) {
+  const callees = variantCallees(sf);
+  if (callees.size === 0) return [];
+  const out = [];
+  const visit = (node) => {
+    if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.initializer && ts2.isCallExpression(node.initializer) && ts2.isIdentifier(node.initializer.expression) && callees.has(node.initializer.expression.text)) {
+      const kind = callees.get(node.initializer.expression.text);
+      const args = node.initializer.arguments;
+      const cfg = kind === "tv" || args.length === 1 && args[0] && ts2.isObjectLiteralExpression(args[0]) ? args[0] : args[1];
+      const extend = cfg && ts2.isObjectLiteralExpression(cfg) ? property(cfg, "extend") : void 0;
+      const statement = node.parent?.parent && ts2.isVariableStatement(node.parent.parent) ? node.parent.parent : node;
+      const doc = leadingJSDoc(sf, statement);
+      out.push({
+        name: node.name.text,
+        kind,
+        entry: readConfig(sf, kind, node.name.text, cfg),
+        ...extend && ts2.isIdentifier(extend) ? { extendsName: extend.text } : {},
+        doc,
+        description: describe(doc)
+      });
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(sf);
+  return out;
+}
+function readConfig(sf, kind, name, cfg) {
+  const entry = { from: kind, config: name, axes: [] };
+  if (!cfg || !ts2.isObjectLiteralExpression(cfg)) return entry;
+  const defaults = /* @__PURE__ */ new Map();
+  const defaultsNode = property(cfg, "defaultVariants");
+  if (defaultsNode && ts2.isObjectLiteralExpression(defaultsNode)) {
+    for (const p of defaultsNode.properties) {
+      const key = propertyName(p);
+      const value = ts2.isPropertyAssignment(p) ? literal(p.initializer) : void 0;
+      if (key && value !== void 0) defaults.set(key, value);
+    }
+  }
+  const variants = property(cfg, "variants");
+  if (variants && ts2.isObjectLiteralExpression(variants)) {
+    for (const axisNode of variants.properties) {
+      const axisName = propertyName(axisNode);
+      if (!axisName || !ts2.isPropertyAssignment(axisNode)) continue;
+      const axis = { name: axisName, options: [] };
+      if (ts2.isObjectLiteralExpression(axisNode.initializer)) {
+        for (const opt of axisNode.initializer.properties) {
+          const optName = propertyName(opt);
+          if (!optName) continue;
+          const description = describe(leadingJSDoc(sf, opt));
+          axis.options.push(description ? { name: optName, description } : { name: optName });
+        }
+      }
+      const d = defaults.get(axisName);
+      if (d !== void 0) axis.default = d;
+      entry.axes.push(axis);
+    }
+  }
+  const compound = property(cfg, "compoundVariants");
+  if (compound && ts2.isArrayLiteralExpression(compound)) {
+    const conditions = [];
+    for (const el of compound.elements) {
+      if (!ts2.isObjectLiteralExpression(el)) continue;
+      const condition = {};
+      for (const p of el.properties) {
+        const key = propertyName(p);
+        if (!key || key === "class" || key === "className" || !ts2.isPropertyAssignment(p)) continue;
+        if (ts2.isArrayLiteralExpression(p.initializer)) {
+          const values = p.initializer.elements.map(literal).filter((v) => v !== void 0);
+          condition[key] = values;
+        } else {
+          const value = literal(p.initializer);
+          if (value !== void 0) condition[key] = value;
+        }
+      }
+      if (Object.keys(condition).length) conditions.push(condition);
+    }
+    if (conditions.length) entry.compound = conditions;
+  }
+  if (kind === "tv") {
+    const slots = property(cfg, "slots");
+    if (slots && ts2.isObjectLiteralExpression(slots)) {
+      const parts = slots.properties.map(propertyName).filter((n) => !!n);
+      if (parts.length) entry.parts = parts;
+    }
+  }
+  return entry;
+}
+function property(obj, name) {
+  for (const p of obj.properties) {
+    if (propertyName(p) === name && ts2.isPropertyAssignment(p)) return p.initializer;
+  }
+  return void 0;
+}
+function propertyName(p) {
+  if (!p.name) return void 0;
+  if (ts2.isIdentifier(p.name) || ts2.isStringLiteral(p.name) || ts2.isNumericLiteral(p.name)) return p.name.text;
+  return void 0;
+}
+function literal(node) {
+  if (ts2.isStringLiteral(node) || ts2.isNoSubstitutionTemplateLiteral(node) || ts2.isNumericLiteral(node)) return node.text;
+  if (node.kind === ts2.SyntaxKind.TrueKeyword) return "true";
+  if (node.kind === ts2.SyntaxKind.FalseKeyword) return "false";
+  return void 0;
+}
+
+// src/examples.ts
+import { readFileSync } from "fs";
+import ts3 from "typescript";
+function readExampleFile(path, source, warn, owner = "example") {
+  const sf = ts3.createSourceFile(path, readFileSync(path, "utf8"), ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TSX);
+  const exports = [];
+  const first = sf.statements[0];
+  const doc = first && ts3.isImportDeclaration(first) ? leadingJSDoc(sf, first) : void 0;
+  for (const stmt of sf.statements) {
+    if (!ts3.canHaveModifiers(stmt) || !(ts3.getModifiers(stmt) ?? []).some((m) => m.kind === ts3.SyntaxKind.ExportKeyword)) continue;
+    const stmtDoc = leadingJSDoc(sf, stmt);
+    checkTags(source, stmtDoc, owner, warn);
+    const add = (name, body) => {
+      const ref = { name };
+      const description = describe(stmtDoc);
+      if (description) ref.description = description;
+      const code = body && jsxOf(sf, body);
+      if (code) ref.code = code;
+      exports.push(ref);
+    };
+    if (ts3.isFunctionDeclaration(stmt) && stmt.name) add(stmt.name.text, stmt.body);
+    if (ts3.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) if (ts3.isIdentifier(d.name)) add(d.name.text, d.initializer);
+    }
+  }
+  return { sf, doc, exports };
+}
+function classifyExamples(source, exports) {
+  const entry = { source, do: [], dont: [], other: [] };
+  for (const ex of exports) {
+    if (ex.name === "canonical") entry.canonical = ex;
+    else if (/^dont(?=[A-Z0-9_]|$)/.test(ex.name)) entry.dont.push(ex);
+    else if (/^do(?=[A-Z0-9_]|$)/.test(ex.name)) entry.do.push(ex);
+    else entry.other.push(ex);
+  }
+  return entry;
+}
+function jsxOf(sf, node) {
+  let expr;
+  if (ts3.isArrowFunction(node) || ts3.isFunctionExpression(node) || ts3.isFunctionDeclaration(node)) {
+    const body = node.body;
+    if (body && ts3.isBlock(body)) {
+      const ret = [...body.statements].reverse().find(ts3.isReturnStatement);
+      expr = ret?.expression;
+    } else expr = body;
+  } else if (ts3.isBlock(node)) {
+    expr = [...node.statements].reverse().find(ts3.isReturnStatement)?.expression;
+  } else {
+    expr = node;
+  }
+  while (expr && ts3.isParenthesizedExpression(expr)) expr = expr.expression;
+  if (!expr) return void 0;
+  return dedent(expr.getText(sf));
+}
+function dedent(text2) {
+  const lines = text2.split("\n");
+  const indents = lines.slice(1).filter((l) => l.trim()).map((l) => /^\s*/.exec(l)[0].length);
+  const cut = indents.length ? Math.min(...indents) : 0;
+  return [lines[0], ...lines.slice(1).map((l) => l.slice(Math.min(cut, /^\s*/.exec(l)[0].length)))].join("\n").trimEnd();
+}
+
+// src/components.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { basename, dirname, join, relative, resolve, sep } from "path";
+import ts4 from "typescript";
+import { createRequire } from "module";
+var docgen = createRequire(import.meta.url)("react-docgen-typescript");
+var parserProto = docgen.Parser.prototype;
+if (!parserProto.__designtoolsUncached) {
+  const getPropsInfo = parserProto.getPropsInfo;
+  parserProto.getPropsInfo = function(...args) {
+    this.propertiesOfPropsCache.clear();
+    return getPropsInfo.apply(this, args);
+  };
+  parserProto.__designtoolsUncached = true;
+}
+var SKIP_FILE = /\.(examples|pattern|test|spec|stories)\.tsx$|\.d\.ts$/;
+var SKIP_DIR = /* @__PURE__ */ new Set(["node_modules", ".next", "dist", "build", "coverage"]);
+var BASE_UI = /[\\/]@base-ui[\\/]react[\\/]/;
+function rel(root, file) {
+  return relative(root, file).split(sep).join("/");
+}
+function listComponentFiles(root, system, out) {
+  const start = resolve(root, system);
+  const skip = out ? resolve(root, out) : void 0;
+  const found = [];
+  const walk3 = (dir) => {
+    for (const name of readdirSync(dir).sort()) {
+      const path = join(dir, name);
+      if (statSync(path).isDirectory()) {
+        if (!SKIP_DIR.has(name) && !name.startsWith(".") && path !== skip) walk3(path);
+      } else if (name.endsWith(".tsx") && !SKIP_FILE.test(name)) {
+        found.push(path);
+      }
+    }
+  };
+  if (!existsSync(start)) throw new Error(`system folder not found: ${system}`);
+  walk3(start);
+  return found;
+}
+function compilerOptions(root, tsconfig) {
+  const path = tsconfig ? resolve(root, tsconfig) : ts4.findConfigFile(root, ts4.sys.fileExists, "tsconfig.json");
+  if (path && existsSync(path)) {
+    const parsed = ts4.getParsedCommandLineOfConfigFile(
+      path,
+      {},
+      { ...ts4.sys, onUnRecoverableConfigFileDiagnostic: () => {
+      } }
+    );
+    if (parsed) return { ...parsed.options, noEmit: true };
+  }
+  return {
+    jsx: ts4.JsxEmit.ReactJSX,
+    module: ts4.ModuleKind.ESNext,
+    moduleResolution: ts4.ModuleResolutionKind.Bundler,
+    target: ts4.ScriptTarget.ES2022,
+    strict: true,
+    esModuleInterop: true,
+    skipLibCheck: true,
+    noEmit: true
+  };
+}
+function readComponents(options, warn) {
+  const root = resolve(options.root);
+  const files = listComponentFiles(root, options.system, options.out);
+  if (files.length === 0) return [];
+  const compiler = compilerOptions(root, options.tsconfig);
+  const program = ts4.createProgram(files, compiler);
+  const parser = docgen.withCompilerOptions(compiler, {
+    savePropValueAsString: true,
+    shouldExtractLiteralValuesFromEnum: true,
+    shouldRemoveUndefinedFromOptional: true,
+    shouldIncludePropTagMap: true,
+    shouldSortUnions: false,
+    propFilter: () => true
+  });
+  const docs = parser.parseWithProgramProvider(files, () => program);
+  const unionOrder = unionOrderReader(program);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const doc of docs) {
+    if (!/^[A-Z]/.test(doc.displayName)) continue;
+    const key = resolve(doc.filePath);
+    byFile.set(key, [...byFile.get(key) ?? [], doc]);
+  }
+  const out = [];
+  for (const file of files) {
+    const found = byFile.get(file);
+    if (!found) continue;
+    const sf = program.getSourceFile(file);
+    if (!sf) continue;
+    const entries = readFile(root, sf, found, importedConfigs(program, compiler), unionOrder, warn);
+    attachExamples(root, file, entries, warn);
+    out.push(...entries.map((e) => e.entry));
+  }
+  for (const entry of out) {
+    const specifier = importSpecifier(root, entry.source, compiler);
+    if (specifier) entry.import = specifier;
+  }
+  return out.sort((a, b) => compare(a.name, b.name) || compare(a.source, b.source));
+}
+function importSpecifier(root, source, compiler) {
+  const paths = compiler.paths;
+  if (!paths) return void 0;
+  const base = compiler.pathsBasePath ?? compiler.baseUrl ?? root;
+  const file = resolve(root, source).replace(/\.(tsx?|jsx?|mts|cts)$/, "").replace(/\/index$/, "");
+  let best;
+  for (const [pattern, targets] of Object.entries(paths)) {
+    for (const target of targets) {
+      const star = target.indexOf("*");
+      const absolute = resolve(base, star === -1 ? target : target.slice(0, star));
+      if (star === -1) {
+        if (absolute.replace(/\.(tsx?|jsx?)$/, "").replace(/\/index$/, "") === file && !pattern.includes("*")) {
+          return pattern;
+        }
+        continue;
+      }
+      const prefix = target.slice(0, star).endsWith("/") ? `${absolute}/` : absolute;
+      const suffix = target.slice(star + 1).replace(/\.(tsx?|jsx?)$/, "");
+      if (!file.startsWith(prefix) || !file.endsWith(suffix)) continue;
+      const middle = file.slice(prefix.length, file.length - suffix.length);
+      if (!best || prefix.length > best.prefix) best = { specifier: pattern.replace("*", middle), prefix: prefix.length };
+    }
+  }
+  return best?.specifier;
+}
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function importedConfigs(program, compiler) {
+  const cache = /* @__PURE__ */ new Map();
+  const configsIn = (file) => {
+    if (!cache.has(file)) {
+      const sf = program.getSourceFile(file) ?? ts4.createSourceFile(file, readFileSync2(file, "utf8"), ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TSX);
+      cache.set(file, findVariantConfigs(sf));
+    }
+    return cache.get(file);
+  };
+  return (sf, localName) => {
+    const imported = namedImports(sf).get(localName);
+    if (!imported) return void 0;
+    const resolved = ts4.resolveModuleName(imported.from, sf.fileName, compiler, ts4.sys).resolvedModule?.resolvedFileName;
+    if (!resolved || /[\\/]node_modules[\\/]/.test(resolved) || resolved.endsWith(".d.ts")) return void 0;
+    return configsIn(resolved).find((c) => c.name === imported.name);
+  };
+}
+function namedImports(sf) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (!ts4.isImportDeclaration(stmt) || !ts4.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const named = stmt.importClause?.namedBindings;
+    if (!named || !ts4.isNamedImports(named)) continue;
+    for (const el of named.elements) {
+      out.set(el.name.text, { from: stmt.moduleSpecifier.text, name: (el.propertyName ?? el.name).text });
+    }
+  }
+  return out;
+}
+function readFile(root, sf, docs, imported, unionOrder, warn) {
+  const source = rel(root, sf.fileName);
+  const configs = findVariantConfigs(sf);
+  const resolveConfig = configResolver(sf, configs, imported);
+  const imports = importSources(sf);
+  const locals = localDeclarations(sf);
+  const out = [];
+  for (const config of configs) checkTags(source, config.doc, `variant config ${config.name}`, warn);
+  for (const doc of docs) {
+    const decl = findDeclaration(sf, doc.displayName);
+    const statement = decl && (ts4.isVariableDeclaration(decl) ? decl.parent.parent : decl);
+    const jsdoc = statement ? leadingJSDoc(sf, statement) : void 0;
+    if (hasTag(jsdoc, "nodocgen")) continue;
+    checkTags(source, jsdoc, doc.displayName, warn);
+    const paramTypes = decl ? parameterTypeText(sf, decl) : "";
+    const config = decl ? linkConfig(decl, paramTypes, resolveConfig) : void 0;
+    const axisNames = new Set(config?.entry.axes.map((a) => a.name) ?? []);
+    const props = readProps(doc, axisNames, unionOrder);
+    const entry = {
+      name: tag(jsdoc, "name") || doc.displayName,
+      export: doc.displayName,
+      source,
+      props: props.entries,
+      slots: decl ? [...slotsOf(decl, locals)].sort() : []
+    };
+    const description = describe(jsdoc) ?? config?.description;
+    if (description) entry.description = description;
+    const category = tag(jsdoc, "category");
+    if (category) entry.category = category;
+    readStatus(entry, jsdoc, source, warn);
+    const usage = {
+      use: tag(jsdoc, "use") || void 0,
+      avoid: tag(jsdoc, "avoid") || void 0,
+      instead: list(tags(jsdoc, "instead").join(","), /\s*,\s*/)
+    };
+    if (usage.use || usage.avoid || usage.instead.length) {
+      entry.usage = {
+        ...usage.use ? { use: oneLine(usage.use) } : {},
+        ...usage.avoid ? { avoid: oneLine(usage.avoid) } : {},
+        ...usage.instead.length ? { instead: usage.instead } : {}
+      };
+    }
+    const snippets = tags(jsdoc, "example").filter(Boolean);
+    if (snippets.length) entry.snippets = snippets;
+    const replaces = list(tags(jsdoc, "replaces").join(" "), /[\s,]+/);
+    if (replaces.length) entry.replaces = replaces;
+    const role = tag(jsdoc, "role");
+    const keyboard = list(tags(jsdoc, "keyboard").join(","), /\s*,\s*/);
+    if (role || keyboard.length) entry.a11y = { ...role ? { role: role.trim() } : {}, ...keyboard.length ? { keyboard } : {} };
+    const see = tags(jsdoc, "see").filter(Boolean);
+    if (see.length) entry.see = see;
+    const primitive = tag(jsdoc, "primitive");
+    if (primitive) entry.primitive = primitive;
+    const aria = tag(jsdoc, "aria");
+    if (aria) entry.aria = aria;
+    const inherits = inheritsFrom(paramTypes, imports);
+    if (inherits.length) entry.inherits = inherits;
+    const fromProps = () => variantsFromProps(props.order.filter((n) => props.own.has(n)), props.entries);
+    const fallback = config && config.entry.axes.length === 0 ? fromProps() : void 0;
+    const variants = fallback ? { ...fallback, ...config.entry.parts ? { parts: config.entry.parts } : {} } : config?.entry ?? fromProps();
+    if (variants) entry.variants = variants;
+    if (config) alignAxisProps(entry.props, config.entry);
+    out.push({ entry, position: decl?.getStart(sf) ?? Number.MAX_SAFE_INTEGER });
+  }
+  return out;
+}
+function findDeclaration(sf, name) {
+  for (const stmt of sf.statements) {
+    if (ts4.isFunctionDeclaration(stmt) && stmt.name?.text === name) return stmt;
+    if (ts4.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) {
+        if (ts4.isIdentifier(d.name) && d.name.text === name) return d;
+      }
+    }
+  }
+  return void 0;
+}
+function isExported(node) {
+  return ts4.canHaveModifiers(node) && (ts4.getModifiers(node) ?? []).some((m) => m.kind === ts4.SyntaxKind.ExportKeyword);
+}
+function localDeclarations(sf) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (isExported(stmt)) continue;
+    if (ts4.isFunctionDeclaration(stmt) && stmt.name) out.set(stmt.name.text, stmt);
+    if (ts4.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) if (ts4.isIdentifier(d.name)) out.set(d.name.text, d);
+    }
+  }
+  return out;
+}
+function importSources(sf) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (!ts4.isImportDeclaration(stmt) || !ts4.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const from = stmt.moduleSpecifier.text;
+    const clause = stmt.importClause;
+    if (clause?.name) out.set(clause.name.text, from);
+    const named = clause?.namedBindings;
+    if (named && ts4.isNamespaceImport(named)) out.set(named.name.text, from);
+    if (named && ts4.isNamedImports(named)) {
+      for (const el of named.elements) {
+        const imported = (el.propertyName ?? el.name).text;
+        out.set(el.name.text, imported === "default" ? from : `${from}:${imported}`);
+      }
+    }
+  }
+  return out;
+}
+function functionOf(decl) {
+  if (ts4.isFunctionDeclaration(decl)) return decl;
+  let init = decl.initializer;
+  while (init && ts4.isCallExpression(init)) {
+    init = init.arguments.find((a) => ts4.isArrowFunction(a) || ts4.isFunctionExpression(a) || ts4.isCallExpression(a));
+  }
+  if (init && (ts4.isArrowFunction(init) || ts4.isFunctionExpression(init))) return init;
+  return void 0;
+}
+function parameterTypeText(sf, decl) {
+  const fn = functionOf(decl);
+  const param = fn?.parameters[0];
+  let typeNode = param?.type;
+  if (!typeNode && ts4.isVariableDeclaration(decl) && decl.type && ts4.isTypeReferenceNode(decl.type)) {
+    typeNode = decl.type.typeArguments?.[0];
+  }
+  if (!typeNode && ts4.isVariableDeclaration(decl) && decl.initializer && ts4.isCallExpression(decl.initializer)) {
+    const args = decl.initializer.typeArguments;
+    typeNode = args?.[args.length - 1];
+  }
+  if (!typeNode) return "";
+  const localTypes = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (ts4.isInterfaceDeclaration(stmt) || ts4.isTypeAliasDeclaration(stmt)) localTypes.set(stmt.name.text, stmt);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  const expand = (node, depth) => {
+    parts.push(node.getText(sf));
+    if (depth >= 3) return;
+    const visit = (n) => {
+      if (ts4.isTypeReferenceNode(n) || ts4.isExpressionWithTypeArguments(n)) {
+        const name = ts4.isTypeReferenceNode(n) ? n.typeName.getText(sf) : n.expression.getText(sf);
+        const local = localTypes.get(name);
+        if (local && !seen.has(name)) {
+          seen.add(name);
+          expand(local, depth + 1);
+        }
+      }
+      ts4.forEachChild(n, visit);
+    };
+    visit(node);
+  };
+  expand(typeNode, 0);
+  return parts.join("\n");
+}
+function configResolver(sf, configs, imported) {
+  const local = new Map(configs.map((c) => [c.name, c]));
+  const resolve8 = (name) => local.get(name) ?? imported(sf, name);
+  const aliases = /* @__PURE__ */ new Map();
+  for (const stmt of sf.statements) {
+    if (!ts4.isVariableStatement(stmt)) continue;
+    for (const d of stmt.declarationList.declarations) {
+      if (ts4.isIdentifier(d.name) && d.initializer && ts4.isCallExpression(d.initializer) && ts4.isIdentifier(d.initializer.expression)) {
+        aliases.set(d.name.text, d.initializer.expression.text);
+      }
+    }
+  }
+  const find = (name) => resolve8(name) ?? (aliases.has(name) ? resolve8(aliases.get(name)) : void 0);
+  return (name) => {
+    const config = find(name);
+    return config && withBase(config, find, /* @__PURE__ */ new Set([config.name]));
+  };
+}
+function withBase(config, find, seen) {
+  if (!config.extendsName || seen.has(config.extendsName)) return config;
+  const found = find(config.extendsName);
+  if (!found) return config;
+  seen.add(found.name);
+  const base = withBase(found, find, seen);
+  const axes = base.entry.axes.map((a) => ({ ...a, options: [...a.options] }));
+  for (const local of config.entry.axes) {
+    const inherited = axes.find((a) => a.name === local.name);
+    if (!inherited) {
+      axes.push(local);
+      continue;
+    }
+    for (const o of local.options) {
+      const i = inherited.options.findIndex((x) => x.name === o.name);
+      if (i === -1) inherited.options.push(o);
+      else inherited.options[i] = o.description ? o : inherited.options[i];
+    }
+    if (local.default !== void 0) inherited.default = local.default;
+  }
+  const entry = { ...config.entry, axes };
+  const compound = [...base.entry.compound ?? [], ...config.entry.compound ?? []];
+  if (compound.length) entry.compound = compound;
+  const parts = [.../* @__PURE__ */ new Set([...base.entry.parts ?? [], ...config.entry.parts ?? []])];
+  if (parts.length) entry.parts = parts;
+  return { ...config, entry, description: config.description ?? base.description };
+}
+function linkConfig(decl, paramTypes, resolve8) {
+  for (const m of paramTypes.matchAll(/VariantProps\s*<\s*typeof\s+(\w+)\s*>/g)) {
+    const c = resolve8(m[1]);
+    if (c) return c;
+  }
+  let found;
+  const visit = (n) => {
+    if (found) return;
+    if (ts4.isCallExpression(n) && ts4.isIdentifier(n.expression)) found = resolve8(n.expression.text);
+    else if (ts4.isPropertyAccessExpression(n) && ts4.isIdentifier(n.expression)) found = resolve8(n.expression.text);
+    if (!found) ts4.forEachChild(n, visit);
+  };
+  visit(decl);
+  return found;
+}
+var ELEMENT_OF = {
+  Anchor: "a",
+  Div: "div",
+  Span: "span",
+  Paragraph: "p",
+  Heading: "h1",
+  UList: "ul",
+  OList: "ol",
+  LI: "li",
+  Image: "img",
+  TextArea: "textarea"
+};
+function inheritsFrom(paramTypes, imports) {
+  const found = /* @__PURE__ */ new Set();
+  for (const m of paramTypes.matchAll(/ComponentProps(?:WithRef|WithoutRef)?\s*<\s*["']([a-z][\w-]*)["']\s*>/g)) {
+    found.add(m[1]);
+  }
+  for (const m of paramTypes.matchAll(/ComponentProps(?:WithRef|WithoutRef)?\s*<\s*typeof\s+([\w.]+)\s*>/g)) {
+    const [head, ...rest] = m[1].split(".");
+    const from = imports.get(head);
+    if (!from) found.add(m[1]);
+    else if (from.includes(":")) found.add(rest.length ? `${from}.${rest.join(".")}` : from);
+    else found.add(rest.length ? `${from}:${rest.join(".")}` : from);
+  }
+  for (const m of paramTypes.matchAll(/\w*HTMLAttributes\s*<\s*HTML(\w*)Element\s*>/g)) {
+    const el = m[1];
+    found.add(el ? ELEMENT_OF[el] ?? el.toLowerCase() : "element");
+  }
+  return [...found].sort();
+}
+function slotsOf(decl, locals) {
+  const slots = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set([decl]);
+  const visit = (n) => {
+    if (ts4.isJsxAttribute(n) && n.name.getText() === "data-slot" && n.initializer) {
+      const init = n.initializer;
+      if (ts4.isStringLiteral(init)) slots.add(init.text);
+      else if (ts4.isJsxExpression(init) && init.expression && ts4.isStringLiteralLike(init.expression))
+        slots.add(init.expression.text);
+    } else if (ts4.isPropertyAssignment(n) && ts4.isStringLiteral(n.name) && n.name.text === "data-slot" && ts4.isStringLiteralLike(n.initializer)) {
+      slots.add(n.initializer.text);
+    } else if (ts4.isIdentifier(n)) {
+      const local = locals.get(n.text);
+      if (local && !seen.has(local)) {
+        seen.add(local);
+        visit(local);
+      }
+    }
+    ts4.forEachChild(n, visit);
+  };
+  visit(decl);
+  return slots;
+}
+function unionOrderReader(program) {
+  return (prop, values, componentFile) => {
+    const want = new Set(values);
+    const files = [.../* @__PURE__ */ new Set([...declarationsOf(prop).map((d) => d.fileName), componentFile])];
+    for (const file of files) {
+      const sf = program.getSourceFile(file);
+      if (!sf) continue;
+      const aliases = /* @__PURE__ */ new Map();
+      sf.forEachChild((n) => {
+        if (ts4.isTypeAliasDeclaration(n)) aliases.set(n.name.text, n.type);
+      });
+      let found;
+      const visit = (n) => {
+        if (found) return;
+        if ((ts4.isPropertySignature(n) || ts4.isPropertyDeclaration(n)) && n.name && ts4.isIdentifier(n.name) && n.name.text === prop.name && n.type) {
+          const order = literalsOf(n.type, aliases, 0);
+          if (order && order.length === want.size && order.every((v) => want.has(v))) found = order;
+        }
+        ts4.forEachChild(n, visit);
+      };
+      visit(sf);
+      if (found) return found;
+    }
+    return void 0;
+  };
+}
+function literalsOf(node, aliases, depth) {
+  if (depth > 4) return void 0;
+  if (ts4.isParenthesizedTypeNode(node)) return literalsOf(node.type, aliases, depth + 1);
+  if (ts4.isTypeReferenceNode(node) && ts4.isIdentifier(node.typeName) && aliases.has(node.typeName.text))
+    return literalsOf(aliases.get(node.typeName.text), aliases, depth + 1);
+  const members = ts4.isUnionTypeNode(node) ? node.types : [node];
+  const out = [];
+  for (const m of members) {
+    if (ts4.isLiteralTypeNode(m)) {
+      if (ts4.isStringLiteral(m.literal) || ts4.isNumericLiteral(m.literal)) out.push(m.literal.text);
+      else if (m.literal.kind === ts4.SyntaxKind.NullKeyword) continue;
+      else return void 0;
+    } else if (m.kind === ts4.SyntaxKind.UndefinedKeyword) {
+      continue;
+    } else {
+      const inner = literalsOf(m, aliases, depth + 1);
+      if (!inner) return void 0;
+      out.push(...inner);
+    }
+  }
+  return out;
+}
+function ordered(values, source) {
+  return source ?? [...values].sort(compare);
+}
+function unionText(type, values) {
+  const raw = type.name === "enum" && Array.isArray(type.value) ? type.value.map((v) => String(v.value)) : splitUnion(type.name) ?? [];
+  const quoted = new Map(raw.map((r) => [r.replace(/^(["'`])(.*)\1$/, "$2"), r]));
+  const parts = values.map((v) => quoted.get(v) ?? JSON.stringify(v));
+  if (raw.includes("null")) parts.push("null");
+  return parts.join(" | ");
+}
+function readProps(doc, axes, unionOrder) {
+  const entries = {};
+  const order = [];
+  const own = /* @__PURE__ */ new Set();
+  for (const [name, prop] of Object.entries(doc.props)) {
+    if (!keepProp(prop, axes)) continue;
+    if (declaredInProject(prop)) own.add(name);
+    const checked = literalValues(prop.type);
+    const values = checked && ordered(checked, unionOrder(prop, checked, doc.filePath));
+    const entry = {
+      type: values ? unionText(prop.type, values) : typeText(prop.type, void 0),
+      required: prop.required
+    };
+    if (values) entry.values = values;
+    const def = prop.defaultValue?.value;
+    if (def !== void 0 && def !== null && def !== "") entry.default = String(def);
+    if (prop.description) entry.description = prop.description.trim();
+    const propTags = prop.tags ?? {};
+    if ("deprecated" in propTags) entry.deprecated = propTags.deprecated ?? "";
+    if (!own.has(name)) {
+      const pkg = packageOf(declarationsOf(prop));
+      if (pkg) entry.from = pkg;
+    }
+    entries[name] = entry;
+    order.push(name);
+  }
+  return { entries, order, own };
+}
+function declarationsOf(prop) {
+  return prop.declarations ?? (prop.parent ? [prop.parent] : []);
+}
+function packageOf(decls) {
+  for (const d of decls) {
+    const parts = d.fileName.split(/[\\/]node_modules[\\/]/);
+    if (parts.length < 2) continue;
+    const tail = parts[parts.length - 1].split(/[\\/]/);
+    return tail[0].startsWith("@") ? `${tail[0]}/${tail[1]}` : tail[0];
+  }
+  return void 0;
+}
+function declaredInProject(prop) {
+  const decls = declarationsOf(prop);
+  return decls.length === 0 || decls.some((d) => !/[\\/]node_modules[\\/]/.test(d.fileName));
+}
+function keepProp(prop, axes) {
+  if (axes.has(prop.name)) return true;
+  const decls = declarationsOf(prop);
+  if (decls.length === 0) return true;
+  return decls.some((d) => !/[\\/]node_modules[\\/]/.test(d.fileName) || BASE_UI.test(d.fileName));
+}
+function literalValues(type) {
+  const raws = type.name === "enum" && Array.isArray(type.value) ? type.value.map((v) => String(v.value)) : splitUnion(type.name);
+  if (!raws || raws.length < 2) return void 0;
+  const values = [];
+  for (const raw of raws) {
+    if (raw === "null" || raw === "undefined") continue;
+    const str = /^(["'`])(.*)\1$/.exec(raw);
+    if (str) values.push(str[2]);
+    else if (/^-?\d+(\.\d+)?$/.test(raw)) values.push(raw);
+    else return void 0;
+  }
+  return values.length ? values : void 0;
+}
+function splitUnion(text2) {
+  if (!text2.includes("|") || /[(){}<>\[\]]/.test(text2.replace(/(["'`]).*?\1/g, ""))) return void 0;
+  return text2.split("|").map((p) => p.trim()).filter(Boolean);
+}
+function typeText(type, values) {
+  if (values && type.name === "enum" && type.value) return type.value.map((v) => v.value).join(" | ");
+  return (type.raw ?? type.name).replace(/\s+/g, " ").trim();
+}
+function alignAxisProps(props, variants) {
+  for (const axis of variants.axes) {
+    const prop = props[axis.name];
+    if (!prop) continue;
+    if (prop.values) {
+      const order = axis.options.map((o) => o.name);
+      prop.values = [...prop.values].sort((a, b) => rank(order, a) - rank(order, b));
+      const nullable = /\|\s*null\b/.test(prop.type);
+      prop.type = [...prop.values.map((v) => JSON.stringify(v)), ...nullable ? ["null"] : []].join(" | ");
+    }
+    if (prop.default === void 0 && axis.default !== void 0) prop.default = axis.default;
+  }
+}
+function rank(order, value) {
+  const i = order.indexOf(value);
+  return i === -1 ? order.length : i;
+}
+function variantsFromProps(order, props) {
+  const axes = [];
+  for (const name of order) {
+    const p = props[name];
+    if (!p.values || p.values.every((v) => v === "true" || v === "false")) continue;
+    if (!p.values.every((v) => !/^-?\d/.test(v))) continue;
+    const axis = { name, options: p.values.map((v) => ({ name: v })) };
+    if (p.default !== void 0) axis.default = p.default.replace(/^(["'`])(.*)\1$/, "$2");
+    axes.push(axis);
+  }
+  return axes.length ? { from: "props", axes } : void 0;
+}
+function attachExamples(root, file, components, warn) {
+  const path = join(dirname(file), basename(file, ".tsx") + ".examples.tsx");
+  if (!existsSync(path) || components.length === 0) return;
+  const source = rel(root, path);
+  const { exports } = readExampleFile(path, source, warn);
+  if (exports.length === 0) {
+    warn({ file: source, message: "examples file exports nothing: export canonical, do\u2026 and dont\u2026 examples" });
+    return;
+  }
+  const stem = basename(file, ".tsx").replace(/[-_]/g, "").toLowerCase();
+  const owner = components.find((c) => c.entry.export.toLowerCase() === stem) ?? [...components].sort((a, b) => a.position - b.position)[0];
+  const examples = classifyExamples(source, exports);
+  if (!examples.canonical) warn({ file: source, message: `no canonical example for ${owner.entry.name}: export const canonical` });
+  owner.entry.examples = examples;
+}
+var STATUSES = ["stable", "emerging", "deprecated"];
+function readStatus(entry, jsdoc, source, warn) {
+  const status = tag(jsdoc, "status");
+  if (status !== void 0) {
+    const [word, ...rest] = status.trim().split(/\s+/);
+    if (STATUSES.includes(word)) {
+      entry.status = word;
+      if (rest.length) entry.statusNote = oneLine(rest.join(" "));
+    } else {
+      warn({ file: source, line: jsdoc?.line, message: `@status "${word}" on ${entry.name} is not one of ${STATUSES.join(", ")}` });
+    }
+  }
+  if (hasTag(jsdoc, "deprecated")) {
+    entry.status = "deprecated";
+    const reason = tag(jsdoc, "deprecated");
+    if (reason) entry.statusNote = oneLine(reason);
+  }
+}
+function list(text2, separator) {
+  return text2.split(separator).map((x) => x.trim()).filter(Boolean);
+}
+function oneLine(text2) {
+  return text2.replace(/\s*\n\s*/g, " ").trim();
+}
+
+// src/guidance.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { basename as basename2, dirname as dirname2, join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+import ts5 from "typescript";
+var rel2 = (root, file) => relative2(root, file).split(sep2).join("/");
+function walk(dir, accept, skip) {
+  if (!existsSync2(dir)) return [];
+  const out = [];
+  for (const name of readdirSync2(dir).sort()) {
+    const path = join2(dir, name);
+    if (statSync2(path).isDirectory()) {
+      if (name !== "node_modules" && !name.startsWith(".") && path !== skip) out.push(...walk(path, accept, skip));
+    } else if (accept(name)) out.push(path);
+  }
+  return out;
+}
+function readJSON(path, source, warn) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch (e) {
+    warn({ file: source, message: `not valid JSON: ${e.message}` });
+    return void 0;
+  }
+}
+var strings = (x) => Array.isArray(x) && x.every((v) => typeof v === "string") && x.length ? x : void 0;
+var text = (x) => typeof x === "string" && x.trim() ? x.trim() : void 0;
+var RULE_FIELDS = /* @__PURE__ */ new Set([
+  "$schema",
+  "kind",
+  "title",
+  "statement",
+  "rationale",
+  "threshold",
+  "appliesTo",
+  "exceptions",
+  "tokens",
+  "status",
+  "check"
+]);
+function readRules(root, dir, warn) {
+  const out = [];
+  for (const path of walk(resolve2(root, dir), (n) => n.endsWith(".rule.json"))) {
+    const source = rel2(root, path);
+    const raw = readJSON(path, source, warn);
+    if (!raw || typeof raw !== "object") continue;
+    for (const key of Object.keys(raw)) if (!RULE_FIELDS.has(key)) warn({ file: source, message: `unknown rule field "${key}"` });
+    const statement = text(raw.statement);
+    const title = text(raw.title);
+    if (!statement || !title) {
+      warn({ file: source, message: "a rule needs a title and a statement; skipped" });
+      continue;
+    }
+    const kind = raw.kind === "brand" || raw.kind === "interface" ? raw.kind : void 0;
+    if (!kind) warn({ file: source, message: `kind must be "brand" or "interface"; read as "interface"` });
+    const status = raw.status === "confirmed" || raw.status === "assumption" ? raw.status : void 0;
+    if (!status) warn({ file: source, message: `status must be "confirmed" or "assumption"; read as "assumption" until someone confirms it` });
+    const rule = {
+      id: basename2(path, ".rule.json"),
+      kind: kind ?? "interface",
+      title,
+      statement,
+      status: status ?? "assumption",
+      source
+    };
+    const rationale = text(raw.rationale);
+    if (rationale) rule.rationale = rationale;
+    const threshold = text(raw.threshold);
+    if (threshold) rule.threshold = threshold;
+    const appliesTo = strings(raw.appliesTo);
+    if (appliesTo) rule.appliesTo = appliesTo;
+    const exceptions = strings(raw.exceptions);
+    if (exceptions) rule.exceptions = exceptions;
+    const tokens = strings(raw.tokens);
+    if (tokens) rule.tokens = tokens;
+    const check = raw.check;
+    if (check && typeof check === "object") {
+      const kinds = ["test", "lint", "audit", "manual"];
+      const k = kinds.find((x) => x === check.kind);
+      if (!k) warn({ file: source, message: `check.kind must be one of ${kinds.join(", ")}` });
+      else {
+        rule.check = { kind: k };
+        const ref = text(check.ref);
+        if (ref) rule.check.ref = ref;
+        const description = text(check.description);
+        if (description) rule.check.description = description;
+      }
+    }
+    out.push(rule);
+  }
+  return out.sort((a, b) => compare(a.id, b.id));
+}
+function readPatterns(root, system, components, compiler, warn, skip) {
+  const out = [];
+  const bySource = /* @__PURE__ */ new Map();
+  for (const c of components) bySource.set(c.source, [...bySource.get(c.source) ?? [], c]);
+  for (const path of walk(resolve2(root, system), (n) => n.endsWith(".pattern.tsx"), skip && resolve2(root, skip))) {
+    const source = rel2(root, path);
+    const { sf, doc, exports } = readExampleFile(path, source, warn, "pattern composition");
+    const id = basename2(path, ".pattern.tsx");
+    const used = /* @__PURE__ */ new Set();
+    for (const stmt of sf.statements) {
+      if (!ts5.isImportDeclaration(stmt) || !ts5.isStringLiteral(stmt.moduleSpecifier)) continue;
+      const resolved = ts5.resolveModuleName(stmt.moduleSpecifier.text, path, compiler, ts5.sys).resolvedModule?.resolvedFileName;
+      const candidates = resolved ? bySource.get(rel2(root, resolved)) : void 0;
+      const named = stmt.importClause?.namedBindings;
+      if (!candidates || !named || !ts5.isNamedImports(named)) continue;
+      for (const el of named.elements) {
+        const imported = (el.propertyName ?? el.name).text;
+        const c = candidates.find((x) => x.export === imported);
+        if (c) used.add(c.name);
+      }
+    }
+    if (exports.length === 0) warn({ file: source, message: "pattern exports no compositions" });
+    const pattern = {
+      id,
+      name: tag(doc, "name")?.trim() || titleCase(id),
+      components: [...used].sort(compare),
+      examples: exports,
+      source
+    };
+    const description = describe(doc);
+    if (description) pattern.description = description;
+    const status = tag(doc, "status")?.trim().split(/\s+/)[0];
+    if (status) {
+      if (["stable", "emerging", "deprecated"].includes(status)) pattern.status = status;
+      else warn({ file: source, message: `@status "${status}" is not one of stable, emerging, deprecated` });
+    }
+    out.push(pattern);
+  }
+  return out.sort((a, b) => compare(a.name, b.name));
+}
+function titleCase(id) {
+  const words = id.split(/[-_]+/).filter(Boolean);
+  return words.map((w, i) => i === 0 ? w[0].toUpperCase() + w.slice(1) : w).join(" ");
+}
+function buildTaxonomy(root, curatedPath, inputs, warn) {
+  const terms = /* @__PURE__ */ new Map();
+  const add = (term) => {
+    const key = term.name.toLowerCase();
+    if (!terms.has(key)) terms.set(key, term);
+  };
+  for (const c of inputs.components) add({ name: c.name, kind: "component", ref: c.source });
+  for (const p of inputs.patterns) add({ name: p.name, kind: "pattern", ref: p.source });
+  for (const r of inputs.rules) add({ name: r.title, kind: "rule", ref: r.id });
+  for (const t of inputs.tokens) {
+    if (t.tier === "color" && !t.name.startsWith("--color-")) add({ name: t.name.slice(2), kind: "token", ref: t.name });
+  }
+  const notVocabulary = /^(\d*x*[sl]|sm|md|lg|none|default|true|false|auto|full|\d+)$/;
+  for (const c of inputs.components) {
+    for (const axis of c.variants?.axes ?? []) {
+      add({ name: axis.name, kind: "variant", ref: c.name });
+      for (const o of axis.options) if (!notVocabulary.test(o.name)) add({ name: o.name, kind: "variant", ref: axis.name });
+    }
+  }
+  const path = resolve2(root, curatedPath);
+  if (existsSync2(path)) {
+    const source = rel2(root, path);
+    const raw = readJSON(path, source, warn);
+    for (const t of raw?.terms ?? []) {
+      const name = text(t.name);
+      if (!name) {
+        warn({ file: source, message: "a term needs a name" });
+        continue;
+      }
+      const wrong = strings(t.wrong);
+      const note = text(t.note);
+      const existing = terms.get(name.toLowerCase());
+      if (existing) {
+        if (wrong) existing.wrong = [.../* @__PURE__ */ new Set([...existing.wrong ?? [], ...wrong])];
+        if (note) existing.note = note;
+        continue;
+      }
+      if (t.kind !== void 0 && t.kind !== "product") {
+        warn({ file: source, message: `"${name}" is not a name in the system, so it is listed as a product term` });
+      }
+      terms.set(name.toLowerCase(), { name, kind: "product", ...wrong ? { wrong } : {}, ...note ? { note } : {} });
+    }
+  }
+  for (const t of terms.values()) {
+    for (const w of t.wrong ?? []) {
+      const clash = terms.get(w.toLowerCase());
+      if (clash && clash !== t) warn({ file: curatedPath, message: `"${w}" is listed as wrong for ${t.name}, but it is the ${clash.kind} ${clash.name}` });
+    }
+  }
+  return [...terms.values()].sort((a, b) => compare(a.name.toLowerCase(), b.name.toLowerCase()) || compare(a.kind, b.kind));
+}
+var ASSET_FILE = /\.(svg|png|jpe?g|webp|gif|avif)$/i;
+var ASSET_FIELDS = /* @__PURE__ */ new Set(["file", "kind", "name", "usage", "minSize", "clearSpace", "surfaces", "alt"]);
+function readAssets(root, brandDir, warn) {
+  const dir = resolve2(root, brandDir);
+  if (!existsSync2(dir)) return [];
+  const indexPath = join2(dir, "assets.json");
+  const notes = /* @__PURE__ */ new Map();
+  if (existsSync2(indexPath)) {
+    const raw = readJSON(indexPath, rel2(root, indexPath), warn);
+    for (const a of raw?.assets ?? []) {
+      const file = text(a.file);
+      if (!file) {
+        warn({ file: rel2(root, indexPath), message: "an asset needs a file" });
+        continue;
+      }
+      for (const key of Object.keys(a)) if (!ASSET_FIELDS.has(key)) warn({ file: rel2(root, indexPath), message: `unknown asset field "${key}" on ${file}` });
+      notes.set(rel2(root, resolve2(dir, file)), a);
+    }
+  }
+  const out = [];
+  const found = /* @__PURE__ */ new Set();
+  for (const path of walk(dir, (n) => ASSET_FILE.test(n))) {
+    const file = rel2(root, path);
+    found.add(file);
+    const note = notes.get(file);
+    if (!note) warn({ file, message: "brand asset has no entry in assets.json: say how to use it" });
+    const kinds = ["logo", "icon", "image", "other"];
+    const kind = kinds.find((k) => k === note?.kind) ?? kindFromFolder(rel2(dir, dirname2(path)));
+    const entry = { file, kind, name: text(note?.name) ?? basename2(path).replace(ASSET_FILE, "") };
+    for (const field of ["usage", "minSize", "clearSpace", "alt"]) {
+      const v = text(note?.[field]);
+      if (v) entry[field] = v;
+    }
+    const surfaces = strings(note?.surfaces);
+    if (surfaces) entry.surfaces = surfaces;
+    const size = intrinsicSize(path);
+    if (size) Object.assign(entry, size);
+    out.push(entry);
+  }
+  for (const file of notes.keys()) {
+    if (!found.has(file)) warn({ file: rel2(root, indexPath), message: `assets.json lists ${file}, which is not in the brand folder` });
+  }
+  const order = [...notes.keys()];
+  const rank2 = (file) => order.includes(file) ? order.indexOf(file) : order.length;
+  return out.sort((a, b) => rank2(a.file) - rank2(b.file) || compare(a.file, b.file));
+}
+function kindFromFolder(folder) {
+  const f = folder.toLowerCase();
+  if (/logo/.test(f)) return "logo";
+  if (/icon/.test(f)) return "icon";
+  if (/imag|photo|illustration/.test(f)) return "image";
+  return "other";
+}
+function intrinsicSize(path) {
+  if (/\.svg$/i.test(path)) {
+    const svg = readFileSync3(path, "utf8").slice(0, 4096);
+    const box = /viewBox\s*=\s*["']\s*[-\d.]+[\s,]+[-\d.]+[\s,]+([\d.]+)[\s,]+([\d.]+)/.exec(svg);
+    if (box) return { width: Number(box[1]), height: Number(box[2]) };
+    const w = /\swidth\s*=\s*["']([\d.]+)(px)?["']/.exec(svg);
+    const h = /\sheight\s*=\s*["']([\d.]+)(px)?["']/.exec(svg);
+    return w && h ? { width: Number(w[1]), height: Number(h[1]) } : void 0;
+  }
+  if (/\.png$/i.test(path)) {
+    const head = readFileSync3(path).subarray(0, 24);
+    if (head.length === 24 && head.toString("ascii", 12, 16) === "IHDR") return { width: head.readUInt32BE(16), height: head.readUInt32BE(20) };
+  }
+  return void 0;
+}
+
+// src/tokens.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve3 } from "path";
+import postcss from "postcss";
+function readTokens(root, sources, warn) {
+  const tokens = /* @__PURE__ */ new Map();
+  const fromMedia = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    let css;
+    try {
+      css = readFileSync4(resolve3(root, source), "utf8");
+    } catch {
+      warn({ file: source, message: "token stylesheet not found" });
+      continue;
+    }
+    const ast = postcss.parse(css, { from: source });
+    const walk3 = (container, chain) => {
+      let comment;
+      let fresh = false;
+      let previous;
+      for (const node of container.nodes ?? []) {
+        if (node.type === "comment" && previous && !/\n/.test(node.raws.before ?? "")) {
+          previous.description = cleanComment(node.text);
+          previous = void 0;
+          continue;
+        }
+        previous = void 0;
+        if (node.type === "comment") {
+          comment = cleanComment(node.text);
+          fresh = true;
+          continue;
+        }
+        if (node.type === "decl") {
+          if (!fresh && /\n[ \t]*\n/.test(node.raws.before ?? "")) comment = void 0;
+          fresh = false;
+          if (!node.prop.startsWith("--") || node.prop.includes("*")) continue;
+          const { key, media } = contextOf(chain);
+          const value = node.value.replace(/\s+/g, " ").trim();
+          let entry = tokens.get(node.prop);
+          if (!entry) {
+            entry = { name: node.prop, tier: "other", values: {}, source };
+            tokens.set(node.prop, entry);
+          }
+          const mediaKeys = fromMedia.get(node.prop) ?? /* @__PURE__ */ new Set();
+          fromMedia.set(node.prop, mediaKeys);
+          const existing = entry.values[key];
+          const explicitAlready = existing !== void 0 && !mediaKeys.has(key);
+          if (!(media && explicitAlready)) {
+            if (existing !== void 0 && existing !== value && source !== entry.source && !entry.overriddenIn?.includes(source)) {
+              entry.overriddenIn = [...entry.overriddenIn ?? [], source];
+            }
+            entry.values[key] = value;
+            if (media) mediaKeys.add(key);
+            else mediaKeys.delete(key);
+          }
+          if (comment && !entry.description) entry.description = comment;
+          previous = entry;
+          continue;
+        }
+        fresh = false;
+        comment = void 0;
+        visitContainer(node, chain, walk3);
+      }
+    };
+    walk3(ast, []);
+  }
+  return [...tokens.values()].map((t) => ({ ...t, tier: tierOf(t.name, t.values) }));
+}
+function visitContainer(node, chain, walk3) {
+  if (node.type === "rule") walk3(node, [...chain, { kind: "rule", name: "", value: node.selector }]);
+  else if (node.type === "atrule" && node.nodes) walk3(node, [...chain, { kind: "atrule", name: node.name, value: node.params }]);
+}
+function contextOf(chain) {
+  let mode;
+  let selector;
+  let p3 = false;
+  let media = false;
+  const conditions = [];
+  for (const frame of chain) {
+    if (frame.kind === "atrule") {
+      const params = frame.value.replace(/\s+/g, " ").trim();
+      if (frame.name === "theme" || frame.name === "layer") continue;
+      if (frame.name !== "media") {
+        conditions.push(`@${frame.name} ${params}`);
+        continue;
+      }
+      let known = false;
+      if (/color-gamut\s*:\s*p3/.test(params)) {
+        p3 = true;
+        known = true;
+      }
+      const scheme = /prefers-color-scheme\s*:\s*(dark|light)/.exec(params);
+      if (scheme) {
+        mode = scheme[1];
+        media = true;
+        known = true;
+      }
+      const rest = params.replace(/\(\s*color-gamut\s*:\s*p3\s*\)/g, "").replace(/\(\s*prefers-color-scheme\s*:\s*(dark|light)\s*\)/g, "").replace(/^\s*(and\s+)*|(\s+and)*\s*$/g, "").replace(/\s+and\s+and\s+/g, " and ").trim();
+      if (!known || rest) conditions.push(`@media ${known ? rest : params}`);
+      continue;
+    }
+    const sel = frame.value.replace(/\s+/g, " ").trim();
+    const positive = sel.replace(/:not\((?:[^()]|\([^()]*\))*\)/g, "");
+    if (/\[data-theme=["']?dark["']?\]|\.dark(?![\w-])/.test(positive)) mode = "dark";
+    else if (/\[data-theme=["']?light["']?\]|\.light(?![\w-])/.test(positive)) mode = "light";
+    else if (positive.split(",").every((s) => /^\s*(:root|html|\*)\s*$/.test(s))) {
+    } else selector = sel;
+  }
+  let key = selector ?? mode ?? "default";
+  if (p3) key = `p3:${key}`;
+  if (conditions.length) key = `${conditions.join(" ")}:${key}`;
+  return { key, media };
+}
+function cleanComment(text2) {
+  return text2.split(/\n\s*\n/).map(
+    (p) => p.split("\n").map((l) => l.replace(/^\s*\*?\s?/, "").trim()).filter(Boolean).join(" ")
+  ).filter(Boolean).join("\n\n");
+}
+var PREFIX_TIERS = [
+  [/^--color-/, "color"],
+  [/^--(inset-|drop-|text-)?shadow-/, "shadow"],
+  [/^--font-weight-/, "font-weight"],
+  [/^--font-/, "font"],
+  [/^--text-/, "text"],
+  [/^--leading-/, "leading"],
+  [/^--tracking-/, "tracking"],
+  [/^--spacing(-|$)/, "spacing"],
+  [/^--size-/, "size"],
+  [/^--radius(-|$)/, "radius"],
+  [/^--ease-/, "ease"],
+  [/^--(duration|animate)-/, "duration"],
+  [/^--motion-/, "motion"],
+  [/^--breakpoint-/, "breakpoint"],
+  [/^--container-/, "container"]
+];
+var COLOUR_VALUE = /^(#[0-9a-f]{3,8}\b|(oklch|oklab|lch|lab|rgba?|hsla?|hwb|color|color-mix|light-dark)\(|var\(--color-)/i;
+function tierOf(name, values) {
+  for (const [re, tier] of PREFIX_TIERS) if (re.test(name)) return tier;
+  const all = Object.values(values);
+  if (all.length && all.every((v) => COLOUR_VALUE.test(v) || /^var\(--[\w-]+\)$/.test(v)) && all.some((v) => COLOUR_VALUE.test(v)))
+    return "color";
+  return "other";
+}
+
+// src/types.ts
+var MANIFEST_SCHEMA = "designtools.manifest/1";
+
+// src/build.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/usage.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve4 } from "path";
+var STATUS = /^(success|warning|destructive)$|-subdued-foreground$/;
+function usageRules(root, file, warn) {
+  const path = resolve4(root, file);
+  if (!existsSync3(path)) {
+    warn({ file, message: "usage file not found: run @designtools/tokens with --usage" });
+    return [];
+  }
+  let usage;
+  try {
+    usage = JSON.parse(readFileSync5(path, "utf8"));
+  } catch (e) {
+    warn({ file, message: `usage file is not valid JSON: ${e.message}` });
+    return [];
+  }
+  if (usage.schema !== "designtools.usage/1") {
+    warn({ file, message: `usage file has schema ${usage.schema}; this manifest reads designtools.usage/1` });
+    return [];
+  }
+  const colours = [.../* @__PURE__ */ new Set([...Object.keys(usage.light), ...Object.keys(usage.dark)])].filter((c) => !STATUS.test(c)).sort(compare);
+  const rules = [];
+  for (const colour of colours) {
+    const by = { text: [], shape: [], none: [] };
+    let worst;
+    for (const mode of ["light", "dark"]) {
+      for (const [ground, { ratio, use }] of Object.entries(usage[mode][colour] ?? {})) {
+        by[use].push(`${ground} (${mode})`);
+        if (use !== "text" && (!worst || ratio < worst.ratio)) worst = { ratio, where: `${ground} in ${mode} mode` };
+      }
+    }
+    if (!by.shape.length && !by.none.length) continue;
+    const list2 = (xs) => xs.length > 1 ? `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}` : xs[0];
+    const parts = [
+      by.text.length ? `\`--${colour}\` reads as text on ${list2(by.text)}.` : `\`--${colour}\` is never text on these backgrounds.`,
+      by.shape.length ? `On ${list2(by.shape)} it is a shape only (an icon, a border, a meter), not text.` : "",
+      by.none.length ? `On ${list2(by.none)} it is neither${worst ? `, down to ${worst.ratio}:1 on ${worst.where}` : ""}: use it there only as a fill with its own label.` : ""
+    ].filter(Boolean);
+    rules.push({
+      id: `usage-${colour}`,
+      kind: "interface",
+      title: `Where ${colour} can go`,
+      statement: parts.join(" "),
+      rationale: "Measured from the generated tokens; it changes when they do. No palette makes every colour work on every background, so a brand colour's limits are a brand decision: confirm them as a brand rule.",
+      threshold: `${usage.floors.text}:1 as text, ${usage.floors.shape}:1 as a shape (WCAG 2.2 1.4.3 and 1.4.11)`,
+      appliesTo: [colour],
+      tokens: [`--${colour}`],
+      status: "measured",
+      check: { kind: "test", ref: "mxa-tests", description: "axe measures contrast on every rendered page; this says where to look first." },
+      source: file
+    });
+  }
+  return rules;
+}
+
+// src/build.ts
+var GENERATOR_NAME = "@designtools/manifest";
+var VERSION = (() => {
+  try {
+    const here = dirname3(fileURLToPath(import.meta.url));
+    return JSON.parse(readFileSync6(join3(here, "../package.json"), "utf8")).version;
+  } catch {
+    return "0.0.0";
+  }
+})();
+var GENERATOR = `${GENERATOR_NAME}@${VERSION}`;
+function outDir(config) {
+  return (config.out ?? `${config.system.replace(/\/+$/, "")}/manifest`).replace(/\/+$/, "");
+}
+function buildManifest(config) {
+  const warnings = [];
+  const warn = (w) => warnings.push(w);
+  const out = outDir(config);
+  const system = config.system.replace(/\/+$/, "");
+  const head = { generator: GENERATOR, schema: MANIFEST_SCHEMA };
+  const components = {
+    ...head,
+    system,
+    components: readComponents({ root: config.root, system: config.system, tsconfig: config.tsconfig, out }, warn)
+  };
+  const tokens = { ...head, sources: config.tokens, tokens: readTokens(config.root, config.tokens, warn) };
+  const rules = {
+    ...head,
+    rules: [...readRules(config.root, config.rules ?? `${system}/rules`, warn), ...config.usage ? usageRules(config.root, config.usage, warn) : []]
+  };
+  const patterns = {
+    ...head,
+    patterns: readPatterns(config.root, system, components.components, compilerOptions(config.root, config.tsconfig), warn, out)
+  };
+  const taxonomy = {
+    ...head,
+    terms: buildTaxonomy(
+      config.root,
+      config.taxonomy ?? `${system}/taxonomy.json`,
+      { components: components.components, tokens: tokens.tokens, patterns: patterns.patterns, rules: rules.rules },
+      warn
+    )
+  };
+  const assets = { ...head, assets: readAssets(config.root, config.brand ?? `${system}/brand`, warn) };
+  return {
+    components,
+    tokens,
+    rules,
+    patterns,
+    taxonomy,
+    assets,
+    files: {
+      [`${out}/components.json`]: serialise(components),
+      [`${out}/tokens.json`]: serialise(tokens),
+      [`${out}/rules.json`]: serialise(rules),
+      [`${out}/patterns.json`]: serialise(patterns),
+      [`${out}/taxonomy.json`]: serialise(taxonomy),
+      [`${out}/assets.json`]: serialise(assets)
+    },
+    warnings
+  };
+}
+function serialise(value) {
+  return JSON.stringify(sortKeys(value), null, 2) + "\n";
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const v = value[key];
+      if (v !== void 0) out[key] = sortKeys(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/agents.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve5 } from "path";
+var AGENTS_START = "<!-- designtools:start \xB7 generated by designtools-manifest agents; edit outside these markers -->";
+var AGENTS_END = "<!-- designtools:end -->";
+function agentsFile(root, given, configured) {
+  if (given) return given;
+  if (configured) return configured;
+  const claude = readIfExists(resolve5(root, "CLAUDE.md"));
+  if (claude === void 0) return "AGENTS.md";
+  if (/^\s*@AGENTS\.md\s*$/m.test(claude)) return "AGENTS.md";
+  return "CLAUDE.md";
+}
+function agentsSection(config) {
+  const out = outDir(config);
+  const lines = [
+    AGENTS_START,
+    "## Design system",
+    "",
+    `The design system in \`${config.system}\` is the source of truth for UI. Read it before building or changing a screen, and point at it rather than copying from it.`,
+    "",
+    `- Components: props, variants, usage, status and examples: \`${out}/components.json\``,
+    `- Tokens: colour, type, space, radius, shadow and motion: \`${out}/tokens.json\`${config.tokens.length ? `, from ${config.tokens.map((t) => `\`${t}\``).join(" and ")}` : ""}`,
+    `- Rules, brand and interface, each with its check: \`${out}/rules.json\``,
+    `- Patterns, the product's recurring screens: \`${out}/patterns.json\``,
+    `- Vocabulary, with the wrong forms to avoid: \`${out}/taxonomy.json\``,
+    `- Brand assets and how to use them: \`${out}/assets.json\``
+  ];
+  if (config.docs) lines.push(`- The docs and design language: ${config.docs} (add \`.md\` to any page for markdown)`);
+  lines.push(
+    "",
+    "When you build:",
+    "",
+    "- Start from a component's canonical example, and follow its do and don't examples.",
+    "- Change how a component looks with its variants, not a `className`.",
+    "- Use semantic tokens for colour in UI. Never a hex value or an arbitrary value. A ramp step (`--color-<name>-500`) is for charts, illustration and a decorative colour that has no semantic slot, never for text, surfaces or actions.",
+    "- Use the taxonomy's names, never its wrong forms, in code and in copy.",
+    "- Carry status when you quote: say when a component is emerging or deprecated, or a rule is still an assumption.",
+    AGENTS_END
+  );
+  return lines.join("\n") + "\n";
+}
+function withAgentsSection(existing, section) {
+  if (!existing) return section;
+  const start = existing.indexOf(AGENTS_START);
+  const end = existing.indexOf(AGENTS_END);
+  if (start !== -1 && end > start) {
+    const after = existing.slice(end + AGENTS_END.length).replace(/^\r?\n/, "");
+    return existing.slice(0, start) + section + after;
+  }
+  return existing.replace(/\s*$/, "\n\n") + section;
+}
+function readIfExists(path) {
+  return existsSync4(path) ? readFileSync7(path, "utf8") : void 0;
+}
+function provenance(root) {
+  let version = "unversioned";
+  try {
+    const pkg = JSON.parse(readFileSync7(resolve5(root, "package.json"), "utf8"));
+    version = `${pkg.name ?? "project"}@${pkg.version ?? "0.0.0"}`;
+  } catch {
+  }
+  const fromEnv = process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.GITHUB_SHA;
+  let commit = fromEnv ? fromEnv.slice(0, 7) : "uncommitted";
+  if (!fromEnv) {
+    try {
+      const git = (...args) => execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], env: { ...process.env, LC_ALL: "C" } }).trim();
+      commit = git("rev-parse", "--short=7", "HEAD");
+      if (git("status", "--porcelain")) commit += "-dirty";
+    } catch {
+    }
+  }
+  return { version, commit, line: `Generated from ${version} at ${commit}` };
+}
+
+// src/config.ts
+import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve6 } from "path";
+var CONFIG_FILE = "designtools.json";
+var PATH_FIELDS = ["tsconfig", "out", "rules", "taxonomy", "brand", "docs", "agents", "usage"];
+function loadConfig(flags) {
+  const root = resolve6(flags.root ?? ".");
+  const path = resolve6(root, CONFIG_FILE);
+  let file = {};
+  if (existsSync5(path)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync8(path, "utf8"));
+    } catch (e) {
+      throw new Error(`${CONFIG_FILE} is not valid JSON: ${e.message}`);
+    }
+    file = parsed.manifest ?? {};
+  }
+  const system = flags.system ?? file.system;
+  if (!system) {
+    throw new Error(
+      `no system folder. Pass --system <dir>, or add { "manifest": { "system": "src/ds" } } to ${CONFIG_FILE}.`
+    );
+  }
+  const tokens = flags.tokens?.length ? flags.tokens : file.tokens ?? [];
+  if (!Array.isArray(tokens) || tokens.some((t) => typeof t !== "string")) {
+    throw new Error(`manifest.tokens in ${CONFIG_FILE} must be a list of stylesheet paths`);
+  }
+  const config = { root, system, tokens };
+  if (file.prose !== void 0) {
+    if (!Array.isArray(file.prose) || file.prose.some((p) => typeof p !== "string")) {
+      throw new Error(`manifest.prose in ${CONFIG_FILE} must be a list of files or folders`);
+    }
+    config.prose = file.prose;
+  }
+  for (const field of PATH_FIELDS) {
+    const value = flags[field] ?? file[field];
+    if (value !== void 0) config[field] = value;
+  }
+  return config;
+}
+
+// src/diff.ts
+var CHANGE_CLASSES = ["breaking", "additive", "visual", "docs"];
+function diffManifests(before, after) {
+  const changes = [
+    ...diffComponents(before.components, after.components),
+    ...diffTokens(before.tokens?.tokens ?? [], after.tokens?.tokens ?? []),
+    ...diffRecords("rule", before.rules?.rules, after.rules?.rules, (r) => r.id),
+    ...diffRecords("pattern", before.patterns?.patterns, after.patterns?.patterns, (p) => p.id),
+    ...diffRecords("term", before.taxonomy?.terms, after.taxonomy?.terms, (t) => `${t.kind}:${t.name}`),
+    ...diffRecords("asset", before.assets?.assets, after.assets?.assets, (a) => a.file)
+  ];
+  const rank2 = (c) => CHANGE_CLASSES.indexOf(c);
+  return changes.sort((a, b) => rank2(a.class) - rank2(b.class) || compare(a.subject, b.subject) || compare(a.message, b.message));
+}
+function keyed(manifest) {
+  const out = /* @__PURE__ */ new Map();
+  if (!manifest) return out;
+  const prefix = manifest.system.replace(/\/+$/, "") + "/";
+  for (const c of manifest.components) {
+    const inner = c.source.startsWith(prefix) ? c.source.slice(prefix.length) : c.source;
+    out.set(`${inner}#${c.export}`, c);
+  }
+  return out;
+}
+function diffComponents(before, after) {
+  const a = keyed(before);
+  const b = keyed(after);
+  const out = [];
+  for (const [key, old] of a) {
+    const next = b.get(key);
+    if (!next) out.push({ class: "breaking", subject: old.name, message: `component removed (${old.source})` });
+    else out.push(...diffComponent(old, next));
+  }
+  for (const [key, next] of b) {
+    if (!a.has(key)) out.push({ class: "additive", subject: next.name, message: `new component (${next.source})` });
+  }
+  return out;
+}
+function diffComponent(a, b) {
+  const subject = b.name;
+  const out = [];
+  const add = (cls, message) => out.push({ class: cls, subject, message });
+  if (a.name !== b.name) add("docs", `display name changed from ${a.name} to ${b.name}`);
+  if ((a.status ?? "") !== (b.status ?? "")) {
+    add("docs", `status ${a.status ?? "unset"} \u2192 ${b.status ?? "unset"}${b.statusNote ? `: ${b.statusNote}` : ""}`);
+  }
+  for (const field of ["description", "category", "primitive", "aria"]) {
+    if ((a[field] ?? "") !== (b[field] ?? "")) add("docs", `${field} changed`);
+  }
+  for (const field of ["snippets", "see", "usage", "a11y", "replaces"]) {
+    if (JSON.stringify(a[field] ?? null) !== JSON.stringify(b[field] ?? null)) add("docs", `${field} changed`);
+  }
+  const [lost, gained] = setDiff(a.inherits ?? [], b.inherits ?? []);
+  for (const x of lost) add("breaking", `no longer accepts ${x} props`);
+  for (const x of gained) add("additive", `now accepts ${x} props`);
+  out.push(...diffProps(subject, a.props, b.props));
+  const axesA = new Map((a.variants?.axes ?? []).map((x) => [x.name, x]));
+  const axesB = new Map((b.variants?.axes ?? []).map((x) => [x.name, x]));
+  for (const [name, axis] of axesA) {
+    const next = axesB.get(name);
+    if (!next) {
+      add("breaking", `variant ${name} removed`);
+      continue;
+    }
+    const [gone, added] = setDiff(
+      axis.options.map((o) => o.name),
+      next.options.map((o) => o.name)
+    );
+    for (const o of gone) add("breaking", `variant option ${name}="${o}" removed`);
+    for (const o of added) add("additive", `variant option ${name}="${o}" added`);
+    if ((axis.default ?? "") !== (next.default ?? ""))
+      add("visual", `default ${name} changed from ${axis.default ?? "none"} to ${next.default ?? "none"}`);
+    const descA = new Map(axis.options.map((o) => [o.name, o.description ?? ""]));
+    for (const o of next.options) {
+      if (descA.has(o.name) && descA.get(o.name) !== (o.description ?? "")) add("docs", `variant option ${name}="${o.name}" description changed`);
+    }
+  }
+  for (const name of axesB.keys()) if (!axesA.has(name)) add("additive", `variant ${name} added`);
+  const [slotsGone, slotsAdded] = setDiff(a.slots, b.slots);
+  for (const s of slotsGone) add("breaking", `data-slot "${s}" removed`);
+  for (const s of slotsAdded) add("additive", `data-slot "${s}" added`);
+  const names = (c) => c.examples ? [c.examples.canonical, ...c.examples.do, ...c.examples.dont, ...c.examples.other].flatMap((x) => x ? [x.name] : []) : [];
+  const [examplesGone, examplesAdded] = setDiff(names(a), names(b));
+  for (const x of examplesGone) add("docs", `example ${x} removed`);
+  for (const x of examplesAdded) add("additive", `example ${x} added`);
+  return out;
+}
+function diffProps(subject, a, b) {
+  const out = [];
+  const add = (cls, message) => out.push({ class: cls, subject, message });
+  for (const [name, old] of Object.entries(a)) {
+    const next = b[name];
+    if (!next) {
+      add("breaking", `prop ${name} removed`);
+      continue;
+    }
+    if (!old.required && next.required) add("breaking", `prop ${name} is now required`);
+    if (old.required && !next.required) add("additive", `prop ${name} is now optional`);
+    if (old.values && next.values) {
+      const [gone, added] = setDiff(old.values, next.values);
+      for (const v of gone) add("breaking", `prop ${name} no longer accepts "${v}"`);
+      for (const v of added) add("additive", `prop ${name} accepts "${v}"`);
+    } else if (old.values && !next.values && widens(old.values, next.type)) {
+      add("additive", `prop ${name} widened from ${old.type} to ${next.type}`);
+    } else if (old.type !== next.type) {
+      add("breaking", `prop ${name} type changed from ${old.type} to ${next.type}`);
+    }
+    if ((old.default ?? "") !== (next.default ?? ""))
+      add("visual", `prop ${name} default changed from ${old.default ?? "none"} to ${next.default ?? "none"}`);
+    if ((old.description ?? "") !== (next.description ?? "")) add("docs", `prop ${name} description changed`);
+    if (old.deprecated === void 0 && next.deprecated !== void 0) add("docs", `prop ${name} deprecated`);
+  }
+  for (const [name, next] of Object.entries(b)) {
+    if (name in a) continue;
+    if (next.required) add("breaking", `new required prop ${name}`);
+    else add("additive", `new prop ${name}`);
+  }
+  return out;
+}
+function diffTokens(a, b) {
+  const out = [];
+  const before = new Map(a.map((t) => [t.name, t]));
+  const after = new Map(b.map((t) => [t.name, t]));
+  for (const [name, old] of before) {
+    const next = after.get(name);
+    if (!next) {
+      out.push({ class: "breaking", subject: name, message: "token removed" });
+      continue;
+    }
+    const contexts = [.../* @__PURE__ */ new Set([...Object.keys(old.values), ...Object.keys(next.values)])].sort(compare);
+    for (const ctx of contexts) {
+      const was = old.values[ctx];
+      const now = next.values[ctx];
+      if (was === now) continue;
+      const where = ctx === "default" ? "" : ` (${ctx})`;
+      out.push({
+        class: "visual",
+        subject: name,
+        message: was === void 0 ? `now set${where}: ${now}` : now === void 0 ? `no longer set${where}` : `changed${where} from ${was} to ${now}`
+      });
+    }
+    if ((old.description ?? "") !== (next.description ?? "")) out.push({ class: "docs", subject: name, message: "description changed" });
+  }
+  for (const name of after.keys()) {
+    if (!before.has(name)) out.push({ class: "additive", subject: name, message: "new token" });
+  }
+  return out;
+}
+function diffRecords(kind, before, after, key) {
+  const out = [];
+  const a = new Map((before ?? []).map((x) => [key(x), x]));
+  const b = new Map((after ?? []).map((x) => [key(x), x]));
+  for (const [k, old] of a) {
+    const next = b.get(k);
+    if (!next) out.push({ class: "docs", subject: k, message: `${kind} removed` });
+    else if (JSON.stringify(old) !== JSON.stringify(next)) out.push({ class: "docs", subject: k, message: `${kind} changed` });
+  }
+  for (const k of b.keys()) if (!a.has(k)) out.push({ class: "additive", subject: k, message: `new ${kind}` });
+  return out;
+}
+function widens(values, type) {
+  const members = type.split("|").map((t) => t.trim());
+  const numeric = (v) => /^-?\d+(\.\d+)?$/.test(v);
+  return values.every((v) => numeric(v) ? members.includes("number") : members.includes("string"));
+}
+function setDiff(a, b) {
+  const sa = new Set(a);
+  const sb = new Set(b);
+  return [a.filter((x) => !sb.has(x)), b.filter((x) => !sa.has(x))];
+}
+var HEADINGS = {
+  breaking: "Breaking",
+  additive: "Additive",
+  visual: "Visual",
+  docs: "Docs"
+};
+function formatReport(changes, base) {
+  const count = (c) => changes.filter((x) => x.class === c).length;
+  if (changes.length === 0) return `### Design system changes against \`${base}\`
+
+No changes to components or tokens.
+`;
+  const lines = [
+    `### Design system changes against \`${base}\``,
+    "",
+    CHANGE_CLASSES.map((c) => c === "breaking" && count(c) ? `**${count(c)} breaking**` : `${count(c)} ${c}`).join(" \xB7 ")
+  ];
+  for (const cls of CHANGE_CLASSES) {
+    const group = changes.filter((c) => c.class === cls);
+    if (!group.length) continue;
+    lines.push("", `#### ${HEADINGS[cls]}`, "");
+    for (const c of group) lines.push(`- \`${c.subject}\`: ${c.message}`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/prose.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
+import { join as join4, relative as relative3, resolve as resolve7, sep as sep3 } from "path";
+var NOT_SYSTEM = /* @__PURE__ */ new Set(["Fragment", "Suspense", "StrictMode", "Profiler", "Link", "Image", "Script", "Head", "Html", "Main", "NextScript", "Form"]);
+var LIST_COMPONENTS = 4;
+var LIST_TOKENS = 6;
+function defaultProseFiles(root, system, extra = []) {
+  const out = [];
+  for (const f of ["CLAUDE.md", "AGENTS.md"]) if (existsSync6(resolve7(root, f))) out.push(f);
+  for (const dir of [".claude", "docs", system]) out.push(...walk2(root, resolve7(root, dir)));
+  for (const p of extra) {
+    const path = resolve7(root, p);
+    if (!existsSync6(path)) continue;
+    if (statSync3(path).isDirectory()) out.push(...walk2(root, path, true));
+    else out.push(relative3(root, path).split(sep3).join("/"));
+  }
+  return [...new Set(out)];
+}
+function walk2(root, dir, content = false) {
+  if (!existsSync6(dir) || !statSync3(dir).isDirectory()) return [];
+  const out = [];
+  for (const name of readdirSync3(dir).sort()) {
+    const path = join4(dir, name);
+    if (statSync3(path).isDirectory()) {
+      if (name !== "node_modules" && name !== "manifest" && name !== ".next") out.push(...walk2(root, path, content));
+    } else if (/\.mdx?$/.test(name) || content && /content\.tsx?$/.test(name)) {
+      out.push(relative3(root, path).split(sep3).join("/"));
+    }
+  }
+  return out;
+}
+function checkProse(root, files, inputs) {
+  const components = new Set(inputs.components.flatMap((c) => [c.name, c.export]));
+  const patterns = new Set(inputs.patterns.map((p) => p.name));
+  const tokenNames = new Set(
+    inputs.tokens.filter((t) => t.tier === "color" && !t.name.startsWith("--color-")).flatMap((t) => [t.name, t.name.slice(2)])
+  );
+  const allTokens = new Set(inputs.tokens.map((t) => t.name));
+  const wrongComponent = /* @__PURE__ */ new Map();
+  const wrongCode = /* @__PURE__ */ new Map();
+  const wrongProse = [];
+  for (const t of inputs.terms) {
+    for (const w of t.wrong ?? []) {
+      if (t.kind === "component" || t.kind === "pattern") wrongComponent.set(w, t);
+      else if (t.kind === "product") wrongProse.push({ re: new RegExp(`(^|[^\\w-])${escape(w)}(?![\\w-])`, "i"), form: w, term: t });
+      else wrongCode.set(w, t);
+    }
+  }
+  const findings = [];
+  for (const file of files) {
+    const path = resolve7(root, file);
+    if (!existsSync6(path)) continue;
+    const lines = stripGenerated(readFileSync9(path, "utf8")).split(/\r?\n/);
+    const script = /\.[cm]?[jt]sx?$/.test(file);
+    let inFence = false;
+    let ignoring = false;
+    let skipNext = false;
+    let block;
+    const closeBlock = () => {
+      if (block && block.components.size >= LIST_COMPONENTS) {
+        findings.push({ file, line: block.start, message: `restates ${block.components.size} components; point at components.json instead of listing them` });
+      }
+      if (block && block.tokens.size >= LIST_TOKENS) {
+        findings.push({ file, line: block.start, message: `restates ${block.tokens.size} tokens; point at tokens.json instead of listing them` });
+      }
+      block = void 0;
+    };
+    lines.forEach((line, i) => {
+      const n = i + 1;
+      if (/prose-check-ignore-start/.test(line)) ignoring = true;
+      if (/prose-check-ignore-end/.test(line)) {
+        ignoring = false;
+        return;
+      }
+      const skip = ignoring || skipNext || /prose-check-ignore(?!-)/.test(line);
+      skipNext = /prose-check-ignore-next-line/.test(line);
+      if (skip) return;
+      if (script && /^\s*(import|export\s+(type|interface))\b/.test(line)) return;
+      if (!script && /^\s*(```|~~~)/.test(line)) inFence = !inFence;
+      if (!line.trim()) {
+        closeBlock();
+        return;
+      }
+      block ??= { start: n, components: /* @__PURE__ */ new Set(), tokens: /* @__PURE__ */ new Set() };
+      for (const m of line.matchAll(/<([A-Z][A-Za-z0-9]*)(?=[\s/>.])/g)) {
+        const name = m[1];
+        if (components.has(name) || patterns.has(name) || NOT_SYSTEM.has(name)) continue;
+        const wrong = wrongComponent.get(name);
+        findings.push({
+          file,
+          line: n,
+          message: wrong ? `<${name}>: the system calls this ${wrong.name}` : `<${name}> looks like a component, but the system has none by that name`
+        });
+      }
+      const code = inFence ? [line] : script ? [] : [...line.matchAll(/`([^`]+)`/g)].map((m) => m[1]);
+      for (const span of code) {
+        for (const word of span.match(/[A-Za-z][\w-]*/g) ?? []) {
+          if (components.has(word)) block.components.add(word);
+          if (tokenNames.has(word) || allTokens.has(`--${word}`) || allTokens.has(word)) block.tokens.add(word);
+          const asComponent = wrongComponent.get(word);
+          if (asComponent && !components.has(word) && !inFence) findings.push({ file, line: n, message: `\`${word}\`: the system calls this ${asComponent.name}` });
+          const asCode = wrongCode.get(word);
+          if (asCode) findings.push({ file, line: n, message: `\`${word}\`: the system calls this ${asCode.name}` });
+        }
+      }
+      if (!inFence) {
+        for (const word of (script ? line : line.replace(/`[^`]*`/g, " ")).match(/\b[A-Z][A-Za-z0-9]+\b/g) ?? []) if (components.has(word)) block.components.add(word);
+        for (const { re, form, term } of wrongProse) if (re.test(line)) findings.push({ file, line: n, message: `"${form}": the product says "${term.name}"` });
+      }
+    });
+    closeBlock();
+  }
+  return findings.sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : a.line - b.line || (a.message < b.message ? -1 : 1));
+}
+function stripGenerated(text2) {
+  const start = text2.indexOf(AGENTS_START);
+  const end = text2.indexOf(AGENTS_END);
+  if (start === -1 || end < start) return text2;
+  const blank = text2.slice(start, end + AGENTS_END.length).replace(/[^\n]/g, "");
+  return text2.slice(0, start) + blank + text2.slice(end + AGENTS_END.length);
+}
+function escape(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  MANIFEST_TAGS,
+  parseJSDoc,
+  findVariantConfigs,
+  readExampleFile,
+  classifyExamples,
+  listComponentFiles,
+  readComponents,
+  readRules,
+  readPatterns,
+  buildTaxonomy,
+  readAssets,
+  readTokens,
+  tierOf,
+  MANIFEST_SCHEMA,
+  GENERATOR_NAME,
+  VERSION,
+  GENERATOR,
+  outDir,
+  buildManifest,
+  serialise,
+  AGENTS_START,
+  AGENTS_END,
+  agentsFile,
+  agentsSection,
+  withAgentsSection,
+  readIfExists,
+  provenance,
+  CONFIG_FILE,
+  loadConfig,
+  CHANGE_CLASSES,
+  diffManifests,
+  formatReport,
+  defaultProseFiles,
+  checkProse
+};