pattern-dump 0.1.0-alpha.0

package/dist/pd.js

@@ -0,0 +1,4759 @@
+#!/usr/bin/env node
+
+// packages/discovery/src/index.ts
+import { readdir } from "node:fs/promises";
+import { join, basename, dirname, relative } from "node:path";
+function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*" && glob[i + 1] === "*") {
+      if (glob[i + 2] === "/") {
+        re += "(?:.*/)?";
+        i += 2;
+      } else {
+        re += ".*";
+        i += 1;
+      }
+    } else if (ch === "*") re += "[^/]*";
+    else if (ch === "?") re += "[^/]";
+    else re += /[.+^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+  }
+  return new RegExp(`^${re}$`);
+}
+function collapseComponentId(relNoExt) {
+  const stem = basename(relNoExt);
+  const parent = dirname(relNoExt);
+  return stem === basename(parent) ? parent : relNoExt;
+}
+function deriveHandle(id) {
+  const parts = id.split("/");
+  return `${parts[0]}-${parts[parts.length - 1]}`;
+}
+async function buildDiscoveryMap(roots) {
+  const rootList = typeof roots === "string" ? [{ dir: roots }] : roots;
+  const allHbsFiles = [];
+  const allVarJsonFiles = [];
+  const rootOf = /* @__PURE__ */ new Map();
+  for (const [index, root] of rootList.entries()) {
+    const excludes = (root.exclude ?? []).map(globToRegExp);
+    const excluded = (abs, isDir) => {
+      if (!excludes.length) return false;
+      const rel = relative(root.dir, abs).split("\\").join("/");
+      return excludes.some((re) => re.test(rel) || isDir && re.test(`${rel}/`));
+    };
+    const hbs = [];
+    const varJson = [];
+    const collectFiles = async (dir) => {
+      const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+      for (const e of entries) {
+        if (e.name.startsWith(".")) continue;
+        const full = join(dir, e.name);
+        if (excluded(full, e.isDirectory())) continue;
+        if (e.isDirectory()) {
+          await collectFiles(full);
+        } else if (e.name.endsWith(".hbs")) {
+          hbs.push(full);
+        } else if (e.name.includes("~") && e.name.endsWith(".json")) {
+          varJson.push(full);
+        }
+      }
+    };
+    const topEntries = await readdir(root.dir, { withFileTypes: true }).catch(() => []);
+    for (const e of topEntries) {
+      const full = join(root.dir, e.name);
+      if (e.isDirectory() && !e.name.startsWith(".") && !excluded(full, true)) await collectFiles(full);
+    }
+    hbs.sort();
+    varJson.sort();
+    for (const f of [...hbs, ...varJson]) rootOf.set(f, { root, index });
+    allHbsFiles.push(...hbs);
+    allVarJsonFiles.push(...varJson);
+  }
+  const rootDir = (abs) => rootOf.get(abs).root.dir;
+  const dirFileSets = /* @__PURE__ */ new Map();
+  const allDirs = new Set([...allHbsFiles, ...allVarJsonFiles].map((fp) => dirname(fp)));
+  await Promise.all([...allDirs].map(async (dir) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    dirFileSets.set(dir, new Set(entries.filter((e) => !e.isDirectory()).map((e) => e.name)));
+  }));
+  const discoveryMap = /* @__PURE__ */ new Map();
+  const handleMap = /* @__PURE__ */ new Map();
+  const collisions = [];
+  const overrides = [];
+  function deriveId(absPath) {
+    return collapseComponentId(relative(rootDir(absPath), absPath).replace(/\.hbs$/, ""));
+  }
+  function buildEntry(absPath) {
+    const dir = dirname(absPath);
+    const stem = basename(absPath, ".hbs");
+    const fileSet = dirFileSets.get(dir) ?? /* @__PURE__ */ new Set();
+    const source = rootOf.get(absPath)?.root.source;
+    return {
+      ...source ? { source } : {},
+      hbsPath: absPath,
+      jsonPath: fileSet.has(`${stem}.json`) ? join(dir, `${stem}.json`) : void 0,
+      mdPath: fileSet.has(`${stem}.md`) ? join(dir, `${stem}.md`) : void 0,
+      schemaPath: fileSet.has(`${stem}.schema.json`) ? join(dir, `${stem}.schema.json`) : void 0,
+      ownMarkup: true
+    };
+  }
+  function registerEntry(id, entry, absPath) {
+    const handle = deriveHandle(id);
+    if (handleMap.has(handle)) {
+      const incumbentId = handleMap.get(handle);
+      const incumbentPath = discoveryMap.get(incumbentId).hbsPath;
+      const incumbentRoot = rootOf.get(incumbentPath)?.index ?? 0;
+      const newcomerRoot = rootOf.get(absPath)?.index ?? 0;
+      if (newcomerRoot > incumbentRoot) {
+        overrides.push({
+          handle,
+          id: incumbentId,
+          path: incumbentPath,
+          shadowedPath: absPath,
+          shadowedSource: rootOf.get(absPath).root.source ?? ""
+        });
+        return;
+      }
+      collisions.push({ handle, incumbentId, incumbentPath, quarantinedPath: absPath, quarantinedId: id });
+      return;
+    }
+    discoveryMap.set(id, entry);
+    handleMap.set(handle, id);
+  }
+  for (const absPath of allHbsFiles) {
+    if (basename(absPath, ".hbs").includes("~")) continue;
+    registerEntry(deriveId(absPath), buildEntry(absPath), absPath);
+  }
+  const variantHbsByBase = /* @__PURE__ */ new Map();
+  for (const absPath of allHbsFiles) {
+    const stem = basename(absPath, ".hbs");
+    if (!stem.includes("~")) continue;
+    const dir = dirname(absPath);
+    const baseStem = stem.split("~")[0];
+    const relBase = relative(rootDir(absPath), join(dir, baseStem));
+    const parentRel = dirname(relBase);
+    const baseId = baseStem === basename(parentRel) ? parentRel : relBase;
+    const arr = variantHbsByBase.get(baseId) ?? [];
+    arr.push(absPath);
+    variantHbsByBase.set(baseId, arr);
+  }
+  for (const [baseId, varPaths] of variantHbsByBase) {
+    const hasBase = discoveryMap.has(baseId);
+    if (!hasBase) {
+      const variantTokens = varPaths.map((fp) => basename(fp, ".hbs").split("~")[1]);
+      const handle = deriveHandle(baseId);
+      if (!handleMap.has(handle)) {
+        const varDir = dirname(varPaths[0]);
+        const baseName = basename(varPaths[0], ".hbs").split("~")[0];
+        const fileSet = dirFileSets.get(varDir) ?? /* @__PURE__ */ new Set();
+        const mdPath = fileSet.has(`${baseName}.md`) ? join(varDir, `${baseName}.md`) : void 0;
+        const source = rootOf.get(varPaths[0])?.root.source;
+        discoveryMap.set(baseId, { ...source ? { source } : {}, hbsPath: "", ownMarkup: false, variants: variantTokens, mdPath });
+        handleMap.set(handle, baseId);
+      }
+    }
+    for (const absPath of varPaths) {
+      const stem = basename(absPath, ".hbs");
+      const variantToken = stem.split("~")[1];
+      const variantId = `${baseId}~${variantToken}`;
+      const variantHandle = `${deriveHandle(baseId)}~${variantToken}`;
+      if (!handleMap.has(variantHandle)) {
+        discoveryMap.set(variantId, buildEntry(absPath));
+        handleMap.set(variantHandle, variantId);
+      }
+    }
+  }
+  for (const jsonPath of allVarJsonFiles) {
+    const jsonStem = basename(jsonPath, ".json");
+    const parts = jsonStem.split("~");
+    const baseName = parts[0];
+    const variantToken = parts[1];
+    const dir = dirname(jsonPath);
+    const relBase = relative(rootDir(jsonPath), join(dir, baseName));
+    const parentRel = dirname(relBase);
+    const baseId = baseName === basename(parentRel) ? parentRel : relBase;
+    const variantId = `${baseId}~${variantToken}`;
+    if (discoveryMap.has(variantId)) continue;
+    const baseEntry = discoveryMap.get(baseId);
+    if (!baseEntry?.hbsPath) continue;
+    const variantHandle = `${deriveHandle(baseId)}~${variantToken}`;
+    if (!handleMap.has(variantHandle)) {
+      const source = rootOf.get(jsonPath)?.root.source;
+      discoveryMap.set(variantId, { ...source ? { source } : {}, hbsPath: baseEntry.hbsPath, jsonPath, ownMarkup: false });
+      handleMap.set(variantHandle, variantId);
+    }
+  }
+  const hbsPathToId = /* @__PURE__ */ new Map();
+  for (const [id, entry] of discoveryMap) {
+    if (entry.hbsPath) hbsPathToId.set(entry.hbsPath, id);
+  }
+  const quarantineMap = /* @__PURE__ */ new Map();
+  for (const col of collisions) {
+    quarantineMap.set(col.quarantinedId, col);
+  }
+  return { discoveryMap, handleMap, collisions, hbsPathToId, quarantineMap, overrides };
+}
+
+// packages/renderer/src/highlight.ts
+import { createHighlighter } from "shiki";
+import { transformerStyleToClass } from "@shikijs/transformers";
+
+// packages/renderer/src/themes/oklch.ts
+import { rgb, formatHex, inGamut, clampChroma } from "culori";
+var inRGB = inGamut("rgb");
+function oklchHex(i) {
+  const col = { mode: "oklch", l: i.l, c: i.c, h: i.h };
+  const ok = inRGB(rgb(col));
+  const hex = formatHex(clampChroma(col, "oklch", "rgb"));
+  return { hex, inGamut: ok };
+}
+function computePalette(themeName, intents) {
+  const out = {};
+  const bad = [];
+  for (const key of Object.keys(intents)) {
+    const e = oklchHex(intents[key]);
+    if (!e.inGamut) bad.push(`${key} (${e.hex})`);
+    out[key] = e.hex;
+  }
+  if (bad.length) {
+    throw new Error(
+      `[${themeName}] OKLCH tokens out of sRGB gamut (would clamp/lie): ${bad.join(", ")}`
+    );
+  }
+  return out;
+}
+
+// packages/renderer/src/themes/mcm-dark.ts
+var INTENTS = {
+  tag: { l: 0.76, c: 0.11, h: 190 },
+  // teal      — HTML tag names
+  keyword: { l: 0.78, c: 0.145, h: 78 },
+  // gold-amber — keywords/storage + Handlebars #each/#if/else
+  attr: { l: 0.72, c: 0.09, h: 100 },
+  // khaki     — attribute names (the quiet rung)
+  string: { l: 0.88, c: 0.15, h: 122 },
+  // olive     — strings (brightest, the CVD "up" rung)
+  hbExpr: { l: 0.68, c: 0.155, h: 48 },
+  // terracotta — {{expression}} identifier
+  constant: { l: 0.74, c: 0.1, h: 265 },
+  // periwinkle — constants/numbers (distinct cool rung)
+  comment: { l: 0.55, c: 0.025, h: 70 },
+  // warm-grey  — comments
+  base: { l: 0.86, c: 0.015, h: 80 }
+  // warm off-white — base fg / punctuation / muted
+};
+var c = computePalette("pd-mcm-dark", INTENTS);
+var mcmDark = {
+  name: "pd-mcm-dark",
+  type: "dark",
+  colors: {
+    "editor.background": "#22292E",
+    "editor.foreground": c.base
+  },
+  // Ordered least→most specific; Shiki resolves by longest matching scope, so the Handlebars
+  // overrides below win over the general `support.constant` / `variable` rules.
+  tokenColors: [
+    { scope: ["comment", "comment.block.handlebars", "punctuation.definition.comment"], settings: { foreground: c.comment } },
+    { scope: ["string", "punctuation.definition.string", "string.quoted"], settings: { foreground: c.string } },
+    { scope: ["keyword", "keyword.control", "storage", "storage.type", "storage.modifier"], settings: { foreground: c.keyword } },
+    { scope: ["constant", "constant.numeric", "constant.language", "support.constant", "variable.other.constant", "constant.character"], settings: { foreground: c.constant } },
+    { scope: ["entity.name.tag", "entity.name.tag.html", "entity.name.tag.block.any.html", "entity.name.tag.inline.any.html"], settings: { foreground: c.tag } },
+    { scope: ["entity.other.attribute-name", "entity.other.attribute-name.html"], settings: { foreground: c.attr } },
+    { scope: ["variable", "support.other.variable"], settings: { foreground: c.base } },
+    { scope: ["punctuation.definition.tag", "meta.tag", "keyword.operator", "punctuation.separator", "punctuation.terminator"], settings: { foreground: c.base } },
+    // Handlebars {{expression}} identifier — the terracotta token (more specific than `variable`).
+    { scope: ["variable.parameter.handlebars"], settings: { foreground: c.hbExpr } },
+    // Handlebars {{ }} delimiters — muted to base (more specific than `support.constant`).
+    { scope: ["support.constant.handlebars"], settings: { foreground: c.base } }
+  ]
+};
+
+// packages/renderer/src/themes/monokai-light.ts
+var CONTROLLED = {
+  varParam: { l: 0.74, c: 0.14, h: 58 },
+  // lightened args — breaks the deuteranopia collapse → #ec9247
+  hbExpr: { l: 0.62, c: 0.15, h: 48 }
+  // {{expression}} light terracotta → #cc6526
+};
+var c2 = computePalette("pd-monokai-light", CONTROLLED);
+var M = {
+  base: "#49483e",
+  // base/global fg + variables + punctuation + {{ }} delimiters
+  comment: "#75715E",
+  string: "#998f2f",
+  constant: "#684d99",
+  // numeric / language / other constants
+  keyword: "#f9005a",
+  // keyword / storage / tag (hot pink — loud, cool; flagged for warm-tune)
+  support: "#0089b3",
+  // storage.type / support.function/constant/type (teal-blue)
+  name: "#679c00"
+  // class/type/function names + attribute names (olive-green)
+};
+var monokaiLight = {
+  name: "pd-monokai-light",
+  type: "light",
+  colors: {
+    "editor.background": "#fafafa",
+    "editor.foreground": M.base
+  },
+  // Ordered least→most specific; the Handlebars overrides win by longest-scope match.
+  tokenColors: [
+    { scope: ["comment", "comment.block.handlebars", "punctuation.definition.comment"], settings: { foreground: M.comment } },
+    { scope: ["string", "punctuation.definition.string", "string.quoted"], settings: { foreground: M.string } },
+    { scope: ["keyword", "keyword.control", "storage", "storage.modifier", "entity.name.tag", "entity.name.tag.html", "entity.name.tag.block.any.html", "entity.name.tag.inline.any.html"], settings: { foreground: M.keyword } },
+    { scope: ["storage.type", "support", "support.function", "support.constant", "support.type", "support.class"], settings: { foreground: M.support } },
+    { scope: ["constant", "constant.numeric", "constant.language", "constant.character", "variable.other.constant"], settings: { foreground: M.constant } },
+    { scope: ["entity.name.class", "entity.name.type", "entity.name.function", "entity.other.attribute-name", "entity.other.attribute-name.html"], settings: { foreground: M.name } },
+    { scope: ["variable.parameter"], settings: { foreground: c2.varParam } },
+    // lightened (CVD)
+    { scope: ["variable", "support.other.variable"], settings: { foreground: M.base } },
+    { scope: ["punctuation.definition.tag", "meta.tag", "keyword.operator", "punctuation.separator", "punctuation.terminator"], settings: { foreground: M.base } },
+    // Handlebars {{expression}} identifier — light terracotta (more specific than variable.parameter).
+    { scope: ["variable.parameter.handlebars"], settings: { foreground: c2.hbExpr } },
+    // Handlebars {{ }} delimiters — muted to base (more specific than support.constant).
+    { scope: ["support.constant.handlebars"], settings: { foreground: M.base } }
+  ]
+};
+
+// packages/renderer/src/highlight.ts
+var SUPPORTED_LANGS = [
+  "handlebars",
+  "html",
+  "json",
+  "scss",
+  "css",
+  "typescript",
+  "javascript",
+  "markdown"
+];
+var LANG_ALIASES = {
+  hbs: "handlebars",
+  ts: "typescript",
+  js: "javascript",
+  md: "markdown"
+};
+var LANG_SET = /* @__PURE__ */ new Set([...SUPPORTED_LANGS, ...Object.keys(LANG_ALIASES)]);
+var _highlighter = null;
+var _transformer = transformerStyleToClass();
+async function initHighlighter() {
+  if (_highlighter) return;
+  _highlighter = await createHighlighter({
+    // Custom pair: light = Monokai-Light-derived, dark = warm MCM. Dual-variable output via
+    // defaultColor:false and the OS-bound @media switch are unchanged (drop-in theme objects).
+    themes: [monokaiLight, mcmDark],
+    langs: [...SUPPORTED_LANGS]
+  });
+  const WARMUP = {
+    handlebars: `{{> header}}
+<div class="{{mod}}">
+{{#each items}}<span data-id="{{id}}">{{title}}</span>{{/each}}
+{{#if ok}}yes{{else}}no{{/if}}
+</div>`,
+    typescript: `import { x } from "./y";
+// comment
+const s: string = "hi";
+type T = { n: number; ok: boolean };
+function f(a: number): T | null { return a > 0 ? { n: a, ok: true } : null; }`,
+    scss: `.a { color: #fff; font-size: 1rem; &:hover { background: var(--c); } }
+@mixin m($v: 0) { margin: $v; }
+@media (max-width: 768px) { .a { display: none; } }`,
+    json: `{"k":"v","n":42,"b":true,"x":null,"a":[1,"two",false]}`,
+    html: `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"></head><body class="c"><!-- note --><p data-x="1">hi</p></body></html>`
+  };
+  for (const [lang, code] of Object.entries(WARMUP)) {
+    _highlightRaw(code, lang);
+  }
+}
+function highlight(code, lang) {
+  return _highlightRaw(code, lang);
+}
+function getShikiCSS() {
+  const vars = _transformer.getCSS();
+  const base2 = [
+    ".shiki{background-color:var(--shiki-light-bg);overflow-x:auto}",
+    ".shiki code{display:block;padding:.75em 1em;font-family:monospace;font-size:1rem;line-height:1.6;white-space:pre;tab-size:2}",
+    ".shiki span{color:var(--shiki-light)}",
+    "@media(prefers-color-scheme:dark){",
+    ".shiki{background-color:var(--shiki-dark-bg)}",
+    ".shiki span{color:var(--shiki-dark)}",
+    "}"
+  ].join("");
+  return vars + base2;
+}
+function wrapWithCopyButton(highlightedHtml, rawCode) {
+  const escaped = rawCode.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  return `<div class="shiki-container" data-raw="${escaped}"><button class="copy-btn" type="button" aria-label="Copy source">Copy</button>${highlightedHtml}</div>`;
+}
+function _highlightRaw(code, lang) {
+  const h = _highlighter;
+  if (!h) return _plainPre(code);
+  const resolved = LANG_ALIASES[lang] ?? lang;
+  if (!LANG_SET.has(lang) && !LANG_SET.has(resolved)) {
+    return _plainPre(code);
+  }
+  try {
+    return h.codeToHtml(code, {
+      lang: resolved,
+      themes: { light: "pd-monokai-light", dark: "pd-mcm-dark" },
+      defaultColor: false,
+      transformers: [_transformer]
+    });
+  } catch {
+    return _plainPre(code);
+  }
+}
+function _plainPre(code) {
+  const esc = code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<pre class="shiki shiki-plain"><code>${esc}</code></pre>`;
+}
+
+// packages/renderer/src/index.ts
+import { HtmlValidate } from "html-validate";
+import Handlebars from "handlebars";
+import { readFile } from "node:fs/promises";
+var htmlValidator = new HtmlValidate({
+  rules: {
+    "element-permitted-content": "error",
+    "element-permitted-parent": "error"
+  }
+});
+function deepMerge(target, ...sources) {
+  for (const source of sources) {
+    if (!source) continue;
+    for (const [key, value] of Object.entries(source)) {
+      const targetVal = target[key];
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+        deepMerge(targetVal, value);
+      } else {
+        target[key] = value;
+      }
+    }
+  }
+  return target;
+}
+var safePart = (n) => n.replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
+function registerHelpers(env, mintId, getLastId, projectHelpers, helperRegistrars) {
+  env.registerHelper("id", (name) => mintId(name));
+  env.registerHelper("getId", (name) => mintId(name));
+  env.registerHelper("getLastId", () => getLastId());
+  env.registerHelper("getLastNumericId", () => {
+    const id = getLastId();
+    const m = id.match(/(\d+)$/);
+    return m ? m[1] : "0";
+  });
+  env.registerHelper("eq", (a, b) => a === b);
+  env.registerHelper("ne", (a, b) => a !== b);
+  env.registerHelper("lt", (a, b) => a < b);
+  env.registerHelper("gt", (a, b) => a > b);
+  env.registerHelper("lte", (a, b) => a <= b);
+  env.registerHelper("gte", (a, b) => a >= b);
+  env.registerHelper("and", (a, b) => Boolean(a) && Boolean(b));
+  env.registerHelper("or", (a, b) => Boolean(a) || Boolean(b));
+  env.registerHelper("not", (a) => !a);
+  env.registerHelper("isdefined", (v) => v !== void 0 && v !== null);
+  env.registerHelper(
+    "defaultValue",
+    (v, fallback) => v !== void 0 && v !== null ? v : fallback
+  );
+  env.registerHelper("ifCond", function(a, op, b, options) {
+    let result = false;
+    switch (op) {
+      case "==":
+      case "===":
+        result = a === b;
+        break;
+      case "!=":
+      case "!==":
+        result = a !== b;
+        break;
+      case "<":
+        result = a < b;
+        break;
+      case ">":
+        result = a > b;
+        break;
+      case "<=":
+        result = a <= b;
+        break;
+      case ">=":
+        result = a >= b;
+        break;
+      case "&&":
+        result = Boolean(a) && Boolean(b);
+        break;
+      case "||":
+        result = Boolean(a) || Boolean(b);
+        break;
+    }
+    return result ? options.fn(this) : options.inverse(this);
+  });
+  if (projectHelpers) {
+    for (const [name, fn] of Object.entries(projectHelpers)) {
+      env.registerHelper(name, fn);
+    }
+  }
+  if (helperRegistrars) {
+    for (const register of helperRegistrars) {
+      try {
+        register(env);
+      } catch (e) {
+        console.warn("[renderer] project helper registrar failed:", e);
+      }
+    }
+  }
+}
+var createRenderer = (options) => {
+  return async (input) => {
+    const { patternsDir } = options;
+    let discoveryMap = options.discoveryMap;
+    let handleMap = options.handleMap;
+    if (!discoveryMap || !handleMap) {
+      const maps = await buildDiscoveryMap(options.patternRoots ?? patternsDir);
+      discoveryMap ??= maps.discoveryMap;
+      handleMap ??= maps.handleMap;
+    }
+    const entry = discoveryMap.get(input.component);
+    if (!entry) throw new Error(`[renderer] Component not found: "${input.component}"`);
+    let templateHbsPath = entry.hbsPath;
+    let variantJsonPath;
+    if (input.variant) {
+      const variantEntry = discoveryMap.get(`${input.component}~${input.variant}`);
+      if (!variantEntry) throw new Error(`[renderer] Variant not found: "${input.component}~${input.variant}"`);
+      if (variantEntry.ownMarkup && variantEntry.hbsPath) {
+        templateHbsPath = variantEntry.hbsPath;
+      }
+      variantJsonPath = variantEntry.jsonPath;
+    }
+    const templateSrc = templateHbsPath ? await readFile(templateHbsPath, "utf-8") : "";
+    let defaultData = {};
+    if (entry.jsonPath) {
+      try {
+        defaultData = JSON.parse(await readFile(entry.jsonPath, "utf-8"));
+      } catch {
+      }
+    }
+    let variantData;
+    if (variantJsonPath) {
+      variantData = JSON.parse(await readFile(variantJsonPath, "utf-8"));
+    }
+    const data = deepMerge(
+      structuredClone(options.globalData ?? {}),
+      defaultData,
+      variantData,
+      input.data
+    );
+    const env = Handlebars.create();
+    const componentSlug = safePart(input.component.replace(/[\\/]/g, "-"));
+    let currentBase = `pd-${componentSlug}`;
+    const idCache = /* @__PURE__ */ new Map();
+    let lastMintedId = "";
+    const mintId = (name) => {
+      const key = `${currentBase}:${String(name)}`;
+      if (!idCache.has(key)) {
+        idCache.set(key, `${currentBase}-${safePart(String(name))}`);
+      }
+      const id = idCache.get(key);
+      lastMintedId = id;
+      return id;
+    };
+    const invocationCounters = /* @__PURE__ */ new Map();
+    registerHelpers(env, mintId, () => lastMintedId, options.helpers, options.helperRegistrars);
+    for (const [flatName, compId] of handleMap) {
+      const compEntry = discoveryMap.get(compId);
+      if (!compEntry?.hbsPath) continue;
+      try {
+        const partialSrc = await readFile(compEntry.hbsPath, "utf-8");
+        let childDefaults = {};
+        if (compEntry.jsonPath) {
+          try {
+            childDefaults = JSON.parse(await readFile(compEntry.jsonPath, "utf-8"));
+          } catch {
+          }
+        }
+        const childTemplate = env.compile(partialSrc);
+        const capturedDefaults = childDefaults;
+        const partialSlug = safePart(compId.replace(/[\\/]/g, "-"));
+        env.registerPartial(
+          flatName,
+          function(context, opts) {
+            const suppliedBase = opts?.hash?.base != null ? safePart(String(opts.hash.base)) : null;
+            let thisBase;
+            if (suppliedBase !== null) {
+              thisBase = suppliedBase;
+            } else {
+              const counterKey = `${flatName}:${currentBase}`;
+              const n = invocationCounters.get(counterKey) ?? 0;
+              invocationCounters.set(counterKey, n + 1);
+              thisBase = n === 0 ? currentBase : `pd-${partialSlug}-${n}`;
+            }
+            const savedBase = currentBase;
+            currentBase = thisBase;
+            const merged = deepMerge(
+              structuredClone(capturedDefaults),
+              context != null && typeof context === "object" && !Array.isArray(context) ? context : {}
+            );
+            const runtime = opts?.fn ? { partials: { ...env.partials, "@partial-block": opts.fn } } : void 0;
+            const result = childTemplate(merged, runtime);
+            currentBase = savedBase;
+            return result;
+          }
+        );
+      } catch {
+      }
+    }
+    const html = env.compile(templateSrc)(data, {
+      partials: { ...env.partials, "@partial-block": () => "" }
+    });
+    const diagnostics = [];
+    const htmlReport = htmlValidator.validateStringSync(html);
+    for (const result of htmlReport.results) {
+      for (const msg of result.messages) {
+        diagnostics.push({
+          kind: "HTML_INVALID",
+          severity: "warning",
+          source: "html",
+          message: msg.message,
+          // The specific html-validate rule (e.g. "element-permitted-content") — the granular rule id
+          // the diagnostics graph keys its rule nodes on, distinct from the coarse "HTML_INVALID" kind.
+          ...msg.ruleId ? { ruleId: msg.ruleId } : {},
+          ...msg.line != null ? { location: { line: msg.line, column: msg.column } } : {}
+        });
+      }
+    }
+    try {
+      if (!entry.schemaPath) throw new Error("no schema");
+      const schemaText = await readFile(entry.schemaPath, "utf-8");
+      const schema = JSON.parse(schemaText);
+      for (const key of schema.required ?? []) {
+        if (data[key] === void 0 || data[key] === null) {
+          diagnostics.push({
+            kind: "UNFILLED_REQUIRED",
+            severity: "error",
+            source: "schema",
+            message: `Required field "${key}" is absent in the merged data`,
+            path: `#/properties/${key}`
+          });
+        }
+      }
+      for (const [key, def] of Object.entries(schema.properties ?? {})) {
+        const val = data[key];
+        if (val === void 0 || val === null || !def.type) continue;
+        const types = Array.isArray(def.type) ? def.type : [def.type];
+        const jsType = typeof val;
+        const jsonType = jsType === "number" ? Number.isInteger(val) ? "integer" : "number" : jsType;
+        if (!types.includes(jsonType) && !types.includes(jsType)) {
+          diagnostics.push({
+            kind: "SHAPE_MISMATCH",
+            severity: "warning",
+            source: "schema",
+            message: `Field "${key}" expected ${types.join(" | ")} but got ${jsType}`,
+            path: `#/properties/${key}`
+          });
+        }
+      }
+    } catch {
+    }
+    const meta = diagnostics.length > 0 ? { componentId: input.component, variant: input.variant, diagnostics } : void 0;
+    return { html, document: buildDocument(html, options), ...meta ? { meta } : {} };
+  };
+};
+function buildDocument(html, options) {
+  const bodyAttr = options.defaultTheme ? ` data-theme="${options.defaultTheme}"` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body${bodyAttr}>
+${html}
+</body>
+</html>`;
+}
+
+// packages/build/src/index.ts
+import * as sass from "sass";
+import postcss from "postcss";
+import autoprefixer from "autoprefixer";
+import { build as esbuildBuild } from "esbuild";
+import { readdir as readdir2 } from "node:fs/promises";
+import { join as join2, extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+async function collectScssFiles(dir) {
+  const files = [];
+  async function walk(current) {
+    let entries;
+    try {
+      entries = await readdir2(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join2(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (extname(entry.name) === ".scss" && !entry.name.startsWith("_")) {
+        files.push(full);
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+async function compileSassFileWithDeps(filePath) {
+  const result = sass.compile(filePath);
+  const processed = await postcss([autoprefixer]).process(result.css, { from: void 0 });
+  const deps = result.loadedUrls.filter((u) => u.protocol === "file:").map((u) => fileURLToPath(u)).filter((p) => resolve(p) !== resolve(filePath));
+  return { css: processed.css, deps };
+}
+async function compileSassFile(filePath) {
+  const { css } = await compileSassFileWithDeps(filePath);
+  return css;
+}
+async function createSassDependencyTracker(dirs) {
+  const sourceFiles = [];
+  for (const dir of dirs) {
+    sourceFiles.push(...await collectScssFiles(dir));
+  }
+  const perFileCss = /* @__PURE__ */ new Map();
+  const reverseDeps = /* @__PURE__ */ new Map();
+  function addDeps(sourceFile, deps) {
+    for (const dep of deps) {
+      const abs = resolve(dep);
+      if (!reverseDeps.has(abs)) reverseDeps.set(abs, /* @__PURE__ */ new Set());
+      reverseDeps.get(abs).add(sourceFile);
+    }
+  }
+  function removeDeps(sourceFile) {
+    for (const dependents of reverseDeps.values()) {
+      dependents.delete(sourceFile);
+    }
+  }
+  for (const file of sourceFiles) {
+    try {
+      const { css, deps } = await compileSassFileWithDeps(file);
+      perFileCss.set(file, css);
+      addDeps(file, deps);
+    } catch (e) {
+      console.warn(`[build] SCSS compile error in ${file}:`, e);
+      perFileCss.set(file, "");
+    }
+  }
+  const combineCss = () => sourceFiles.map((f) => perFileCss.get(f) ?? "").join("\n");
+  return {
+    get css() {
+      return combineCss();
+    },
+    async update(changedFile) {
+      const abs = resolve(changedFile);
+      const filesToRecompile = /* @__PURE__ */ new Set();
+      if (perFileCss.has(abs)) filesToRecompile.add(abs);
+      const dependents = reverseDeps.get(abs);
+      if (dependents) {
+        for (const dep of dependents) filesToRecompile.add(dep);
+      }
+      const recompiledFiles = [];
+      const errors = [];
+      for (const file of filesToRecompile) {
+        try {
+          const { css, deps } = await compileSassFileWithDeps(file);
+          perFileCss.set(file, css);
+          removeDeps(file);
+          addDeps(file, deps);
+          recompiledFiles.push(file);
+        } catch (e) {
+          console.warn(`[build] SCSS compile error in ${file}:`, e);
+          errors.push({ file, message: e instanceof Error ? e.message : String(e) });
+        }
+      }
+      return { css: combineCss(), recompiledFiles, errors };
+    }
+  };
+}
+async function compileScriptFile(entryPoint) {
+  const result = await esbuildBuild({
+    entryPoints: [entryPoint],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    write: false,
+    sourcemap: false
+  });
+  return result.outputFiles[0].text;
+}
+
+// packages/hotreloader/src/index.ts
+import { WebSocket, WebSocketServer } from "ws";
+
+// packages/contracts/src/dev-protocol.ts
+var SCOPE_BOUNDARY = `## Scope \u2014 the boundary is part of the artifact
+
+**Covers** \u2014 machine-detectable, static, single-render (no browser layout):
+- **HTML content-model** (html-validate) \u2014 nesting/permitted-content violations.
+- **Structural a11y** (axe, alwaysOn tier) \u2014 labels, names, ARIA, roles, image-alt.
+- **Schema** \u2014 required/shape violations against \`component.schema.json\`.
+- **Render outcome** \u2014 blank / error / ok (metadata, never itself a defect).
+
+**Deliberately NOT covered \u2014 named boundaries, not misses:**
+- **Rendered-contrast (axe needsRendering tier)** \u2014 contrast, aria-hidden-focus, duplicate-id-aria.
+  These require real browser layout/paint; the static jsdom sweep cannot produce them. The
+  per-component panel shows them (live iframe); this aggregate does not. Fewer rule types here is a
+  scope boundary, not a gap.
+- **Structural/graph findings** \u2014 dead subtrees, a shared-base "component", flattened variant families.
+  Those are the style graph's lens, not this one.
+- **PD reporting gaps** \u2014 PD under-claiming (e.g. missing provenance) is not a subject defect.
+- **Interactive / behavioural** \u2014 focus traps, keyboard flow, escape handling. Single static render only.
+- **Data-masked** \u2014 a component that renders empty for want of data won't throw the violations it would
+  when populated; findings are annotated with render outcome wherever it is blank.
+
+A component with zero findings is **not "clean" \u2014 it is "clean of static machine-detectable defects."**
+That is the honest claim; never "clean".`;
+function buildAuditRollup(graph, opts = {}) {
+  const total = graph.components.length;
+  const affected = new Set(graph.occurrences.map((o) => o.component));
+  const cleanPct = total > 0 ? Math.round(100 * (total - affected.size) / total) : 100;
+  const outcomes = graph.components.reduce((a, c3) => {
+    a[c3.render] = (a[c3.render] ?? 0) + 1;
+    return a;
+  }, {});
+  const perRule = /* @__PURE__ */ new Map();
+  for (const o of graph.occurrences) {
+    const k = `${o.engine} ${o.ruleId}`;
+    const r = perRule.get(k) ?? { engine: o.engine, ruleId: o.ruleId, occ: 0, comps: /* @__PURE__ */ new Set(), tags: /* @__PURE__ */ new Set() };
+    r.occ += 1;
+    r.comps.add(o.component);
+    r.tags.add(o.tag);
+    perRule.set(k, r);
+  }
+  const rulesByBlast = [...perRule.values()].sort((a, b) => b.comps.size - a.comps.size || b.occ - a.occ || `${a.engine}:${a.ruleId}`.localeCompare(`${b.engine}:${b.ruleId}`)).map((r) => ({ engine: r.engine, ruleId: r.ruleId, components: r.comps.size, occurrences: r.occ, tags: [...r.tags].sort() }));
+  const occByComp = /* @__PURE__ */ new Map();
+  for (const o of graph.occurrences) {
+    const a = occByComp.get(o.component) ?? [];
+    a.push(o);
+    occByComp.set(o.component, a);
+  }
+  const perComponent = [];
+  for (const c3 of graph.components) {
+    const occ = occByComp.get(c3.id) ?? [];
+    if (occ.length === 0 && c3.render === "ok") continue;
+    perComponent.push({
+      id: c3.id,
+      render: c3.render,
+      occurrences: [...occ].sort((a, b) => `${a.engine}:${a.ruleId}`.localeCompare(`${b.engine}:${b.ruleId}`)).map((o) => ({ engine: o.engine, ruleId: o.ruleId, tag: o.tag, message: o.message, ...o.domPath ? { domPath: o.domPath } : {} }))
+    });
+  }
+  return {
+    ...opts.subjectSha ? { subjectSha: opts.subjectSha } : {},
+    headline: `${graph.occurrences.length} machine-detectable static defects across ${affected.size} of ${total} components \u2014 ${cleanPct}% clean of static machine-detectable defects.`,
+    totals: { components: total, affected: affected.size, cleanPct, defects: graph.occurrences.length },
+    renderOutcomes: { ok: outcomes["ok"] ?? 0, blank: outcomes["blank"] ?? 0, error: outcomes["error"] ?? 0 },
+    rulesByBlast,
+    perComponent,
+    scope: SCOPE_BOUNDARY
+  };
+}
+function previewUrl(id, variant, theme) {
+  const params = new URLSearchParams();
+  if (variant) params.set("variant", variant);
+  if (theme) params.set("theme", theme);
+  const q = params.toString() ? `?${params.toString()}` : "";
+  return `${PD_ROUTE_PREFIX.preview}${id}${q}`;
+}
+function renderedSourceUrl(id, variant) {
+  const q = variant ? `?variant=${encodeURIComponent(variant)}` : "";
+  return `${PD_ROUTE_PREFIX.source}${id}/rendered${q}`;
+}
+function dataSourceUrl(id, variant) {
+  const q = variant ? `?variant=${encodeURIComponent(variant)}` : "";
+  return `${PD_ROUTE_PREFIX.source}${id}/data${q}`;
+}
+function overviewUrl(path) {
+  return `${PD_ROUTE_PREFIX.overview}${path}`;
+}
+var PD_ROUTES = {
+  /** GET → ComponentTree */
+  tree: "/api/tree",
+  /** GET → AuditResponse (500 → ApiError) */
+  audit: "/api/audit",
+  /** GET → ThemeSummary[] */
+  themes: "/api/themes",
+  /** GET → VersionInfo */
+  version: "/api/version",
+  /** GET → ShellClientConfig */
+  config: "/api/config",
+  /** The shell bundle, stylesheet and vendored assets. */
+  mainJs: "/_pd/main.js",
+  mainCss: "/_pd/main.css",
+  axeCore: "/_pd/axe-core.js",
+  /** GET → RuleTiers */
+  ruleTiers: "/_pd/rule-tiers.json",
+  shikiCss: "/_pd/shiki.css",
+  /** Document-base layer (reset + font-face). */
+  baseCss: "/_pd/base.css"
+};
+var PD_ROUTE_PREFIX = {
+  component: "/api/component/",
+  overview: "/api/overview/",
+  preview: "/preview/",
+  source: "/source/",
+  componentCss: "/_pd/components/",
+  themeCss: "/_pd/themes/",
+  script: "/_pd/scripts/",
+  assets: "/assets/"
+};
+function componentUrl(id, variant) {
+  const q = variant ? `?variant=${encodeURIComponent(variant)}` : "";
+  return `${PD_ROUTE_PREFIX.component}${id}${q}`;
+}
+function componentCssUrl(id, version) {
+  const q = version !== void 0 ? `?v=${version}` : "";
+  return `${PD_ROUTE_PREFIX.componentCss}${id}.css${q}`;
+}
+function themeCssUrl(name) {
+  return `${PD_ROUTE_PREFIX.themeCss}${encodeURIComponent(name)}.css`;
+}
+function scriptUrl(id, version) {
+  const q = version !== void 0 ? `?v=${version}` : "";
+  return `${PD_ROUTE_PREFIX.script}${encodeURIComponent(id)}.js${q}`;
+}
+function normalizeBasePath(basePath) {
+  const trimmed = (basePath ?? "").trim().replace(/^\/+|\/+$/g, "");
+  return trimmed ? `/${trimmed}/` : "/";
+}
+function staticPathFor(liveUrl) {
+  const url = new URL(liveUrl, "http://pd.invalid");
+  const path = url.pathname;
+  const variant = url.searchParams.get("variant") || void 0;
+  const suffix = (ext) => variant ? `~${variant}${ext}` : `index${ext}`;
+  const under = (prefix) => path.slice(prefix.length);
+  if (path.startsWith(PD_ROUTE_PREFIX.component)) return `api/component/${under(PD_ROUTE_PREFIX.component)}/${suffix(".json")}`;
+  if (path.startsWith(PD_ROUTE_PREFIX.overview)) return `api/overview/${under(PD_ROUTE_PREFIX.overview)}/index.json`;
+  if (path.startsWith("/api/")) return `${path.slice(1)}.json`;
+  if (path.startsWith(PD_ROUTE_PREFIX.preview)) return `preview/${under(PD_ROUTE_PREFIX.preview)}/${suffix(".html")}`;
+  if (path.startsWith(PD_ROUTE_PREFIX.source)) {
+    const rest = under(PD_ROUTE_PREFIX.source);
+    const facet = rest.endsWith("/rendered") ? "rendered" : rest.endsWith("/data") ? "data" : null;
+    if (facet) {
+      const id = rest.slice(0, -(facet.length + 1));
+      return `source/${id}/${facet}${variant ? `~${variant}` : ""}.html`;
+    }
+  }
+  if (path.startsWith("/_pd/") || path.startsWith(PD_ROUTE_PREFIX.assets)) return path.slice(1);
+  const route = path.replace(/^\/+|\/+$/g, "");
+  return route ? `${route}/index.html` : "index.html";
+}
+var PD_PROTOCOL_VERSION = 1;
+var PD_PROTOCOL_HEADER = "X-PD-Protocol";
+
+// packages/hotreloader/src/index.ts
+function createHotReloader(port2 = Number(process.env["PD_WS_PORT"] ?? 4001)) {
+  const wss = new WebSocketServer({ port: port2 });
+  const clients = /* @__PURE__ */ new Set();
+  const listening = new Promise((resolve13, reject) => {
+    wss.once("listening", () => resolve13());
+    wss.once("error", reject);
+  });
+  listening.catch(() => {
+  });
+  wss.on("error", () => {
+  });
+  let retained = [];
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+    ws.on("close", () => clients.delete(ws));
+    ws.on("error", () => clients.delete(ws));
+    const hello = { type: "hello", protocol: PD_PROTOCOL_VERSION };
+    ws.send(JSON.stringify(hello));
+    for (const message of retained) ws.send(JSON.stringify(message));
+  });
+  return {
+    port: port2,
+    listening,
+    push(message) {
+      const data = JSON.stringify(message);
+      for (const client of clients) {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(data);
+        }
+      }
+    },
+    retain(messages) {
+      retained = [...messages];
+    },
+    close() {
+      return new Promise((resolve13, reject) => wss.close((err) => err ? reject(err) : resolve13()));
+    }
+  };
+}
+
+// packages/dev-server/src/index.ts
+import { createServer } from "node:http";
+import { stat as stat5 } from "node:fs/promises";
+import { join as join19 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+
+// packages/dev-server/src/composition.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// packages/dev-server/src/hbs-partials.ts
+function parsePartialsFromHbs(hbs) {
+  const partials = /* @__PURE__ */ new Set();
+  for (const [, name] of hbs.matchAll(/\{\{#?>\s*"([^"]+)"/g)) {
+    partials.add(name);
+  }
+  for (const [, name] of hbs.matchAll(/\{\{#?>\s*([a-zA-Z][a-zA-Z0-9-]*)/g)) {
+    partials.add(name);
+  }
+  return [...partials];
+}
+
+// packages/dev-server/src/composition.ts
+async function buildCompositionRegistry(patternsDir, flatNameToPath, discoveryMap) {
+  const uses = /* @__PURE__ */ new Map();
+  const usedBy = /* @__PURE__ */ new Map();
+  for (const id of flatNameToPath.values()) {
+    if (!uses.has(id)) uses.set(id, []);
+    if (!usedBy.has(id)) usedBy.set(id, []);
+  }
+  for (const componentId of flatNameToPath.values()) {
+    const hbsPath = discoveryMap.get(componentId)?.hbsPath ?? "";
+    let hbs = "";
+    try {
+      hbs = hbsPath ? await readFile2(hbsPath, "utf-8") : "";
+    } catch {
+    }
+    const partialNames = parsePartialsFromHbs(hbs);
+    const usedSet = /* @__PURE__ */ new Set();
+    for (const partialName of partialNames) {
+      const childId = flatNameToPath.get(partialName);
+      if (childId && childId !== componentId) {
+        usedSet.add(childId);
+        const arr = usedBy.get(childId) ?? [];
+        if (!arr.includes(componentId)) {
+          arr.push(componentId);
+          usedBy.set(childId, arr);
+        }
+      }
+    }
+    uses.set(componentId, [...usedSet].sort());
+  }
+  for (const [k, v] of usedBy) usedBy.set(k, [...new Set(v)].sort());
+  return { uses, usedBy };
+}
+
+// packages/dev-server/src/themes.ts
+import { readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import postcss2 from "postcss";
+async function discoverThemeFiles(themesDirs) {
+  const found = /* @__PURE__ */ new Map();
+  for (const dir of Array.isArray(themesDirs) ? themesDirs : [themesDirs]) {
+    const entries = await readdir3(dir, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+      if (e.isDirectory() || !e.name.endsWith(".theme.scss")) continue;
+      const name = e.name.slice(0, -".theme.scss".length);
+      if (!found.has(name)) found.set(name, dir);
+    }
+  }
+  return [...found].map(([name, dir]) => ({ name, dir }));
+}
+async function discoverThemes(themesDirs) {
+  return (await discoverThemeFiles(themesDirs)).map(({ name }) => ({ name }));
+}
+async function extractThemeTokens(name, compiledCss, slots, themesDir) {
+  const result = Object.fromEntries(slots.map((s) => [s, null]));
+  const jsonPath = join3(themesDir, `${name}.theme.json`);
+  try {
+    const raw = JSON.parse(await readFile3(jsonPath, "utf-8"));
+    for (const slot of slots) {
+      const key = slot.replace(/^--/, "");
+      if (key in raw) result[slot] = raw[key];
+    }
+    return result;
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.warn(`[pd] extractThemeTokens: failed to parse ${jsonPath}:`, err);
+    }
+  }
+  const wanted = `[data-theme=${name}]`;
+  const unquote2 = (selector) => selector.replace(/=\s*(["'])(.*?)\1\s*\]/g, "=$2]").replace(/\s+/g, "");
+  const root = postcss2.parse(compiledCss);
+  root.walkRules((rule) => {
+    if (!rule.selectors.some((sel) => unquote2(sel) === wanted)) return;
+    rule.walkDecls((decl) => {
+      if (slots.includes(decl.prop)) result[decl.prop] = decl.value;
+    });
+  });
+  return result;
+}
+
+// packages/dev-server/src/discovery-index.ts
+import { resolve as resolve2 } from "node:path";
+function baseComponentIds(dr) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of dr.discoveryMap.keys()) {
+    if (!id.includes("~")) ids.add(id);
+  }
+  return ids;
+}
+function resolveComponentForFile(filePath, dr) {
+  const absPath = resolve2(filePath);
+  const hbsId = dr.hbsPathToId.get(absPath);
+  if (hbsId !== void 0) return hbsId;
+  for (const [id, entry] of dr.discoveryMap) {
+    if (entry.jsonPath === absPath) {
+      return id.includes("~") ? id.split("~")[0] : id;
+    }
+  }
+  return null;
+}
+
+// packages/dev-server/src/project-loaders.ts
+import { readdir as readdir4, readFile as readFile4, stat } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { pathToFileURL } from "node:url";
+async function loadHelperRegistrars(helpersPath) {
+  const registrars = [];
+  let files = [];
+  try {
+    const st = await stat(helpersPath);
+    if (st.isDirectory()) {
+      const entries = await readdir4(helpersPath, { withFileTypes: true });
+      files = entries.filter((e) => e.isFile() && /\.(c?js|mjs)$/.test(e.name) && !e.name.startsWith(".")).map((e) => join4(helpersPath, e.name)).sort();
+    } else {
+      files = [helpersPath];
+    }
+  } catch {
+    console.warn(`[dev-server] helpers path not found: ${helpersPath}`);
+    return registrars;
+  }
+  for (const file of files) {
+    try {
+      const mod = await import(pathToFileURL(file).href);
+      const def = mod["default"] ?? mod;
+      if (typeof def === "function") {
+        registrars.push(def);
+      } else if (def && typeof def === "object") {
+        const named = Object.entries(def).filter(([, v]) => typeof v === "function");
+        if (named.length) {
+          registrars.push((hb) => {
+            const h = hb;
+            for (const [name, fn] of named) h.registerHelper(name, fn);
+          });
+        }
+      }
+    } catch (e) {
+      console.warn(`[dev-server] skipped helper module ${file}: ${oneLine(e)}`);
+    }
+  }
+  return registrars;
+}
+function oneLine(e) {
+  const message = e instanceof Error ? e.message : String(e);
+  return (message.split("\n")[0] ?? "").trim() || "unknown error";
+}
+async function loadGlobalData(dataDirs) {
+  const merged = {};
+  for (const dataDir of Array.isArray(dataDirs) ? dataDirs : [dataDirs]) {
+    let files = [];
+    try {
+      const entries = await readdir4(dataDir, { withFileTypes: true });
+      files = entries.filter((e) => e.isFile() && e.name.endsWith(".json") && !e.name.startsWith(".")).map((e) => e.name).sort();
+    } catch {
+      console.warn(`[dev-server] dataDir not found: ${dataDir}`);
+      continue;
+    }
+    for (const name of files) {
+      try {
+        const obj = JSON.parse(await readFile4(join4(dataDir, name), "utf-8"));
+        if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+          deepMerge(merged, obj);
+        }
+      } catch (e) {
+        const reason = e instanceof SyntaxError ? `invalid JSON (${oneLine(e)})` : oneLine(e);
+        console.warn(`[dev-server] skipped _data file ${name}: ${reason}`);
+      }
+    }
+  }
+  return merged;
+}
+
+// packages/dev-server/src/surfacing.ts
+import { mkdir, readFile as readFile5, writeFile } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// packages/dev-server/src/flattening.ts
+import { parse as parseHtml } from "node-html-parser";
+var isElement = (n) => n.nodeType === 1;
+function staticClassTokens(el) {
+  const raw = el.attributes?.class ?? "";
+  return raw.replace(/\{\{[^}]*\}\}/g, " ").split(/\s+/).map((t) => t.replace(/-+$/, "")).filter((t) => t && !t.includes("{") && !t.includes("}"));
+}
+function toSkelNode(el) {
+  const attrs = Object.keys(el.attributes ?? {}).sort();
+  const children = [];
+  for (const child of el.childNodes) {
+    if (isElement(child)) children.push(toSkelNode(child));
+  }
+  return { tag: el.tagName ? el.tagName.toLowerCase() : "", attrs, children };
+}
+function toPreorder(nodes, depth, out) {
+  for (const n of nodes) {
+    out.push(`${depth}<${n.tag}${n.attrs.length ? " " + n.attrs.join(",") : ""}>`);
+    toPreorder(n.children, depth + 1, out);
+  }
+}
+function stripHbsComments(hbs) {
+  return hbs.replace(/\{\{!--[\s\S]*?--\}\}/g, "").replace(/\{\{![\s\S]*?\}\}/g, "");
+}
+function deriveSkeleton(hbs) {
+  const doc = parseHtml(stripHbsComments(hbs));
+  const topElements = doc.childNodes.filter(isElement);
+  const tree = topElements.map(toSkelNode);
+  const preorder = [];
+  toPreorder(tree, 0, preorder);
+  const staticClasses = /* @__PURE__ */ new Set();
+  for (const el of doc.querySelectorAll("[class]")) {
+    for (const tok of staticClassTokens(el)) staticClasses.add(tok);
+  }
+  const root = topElements.length ? staticClassTokens(topElements[0])[0] ?? null : null;
+  return { tree, preorder, root, staticClasses: [...staticClasses] };
+}
+function shingles(tokens, k) {
+  const set = /* @__PURE__ */ new Set();
+  if (tokens.length < k) {
+    if (tokens.length) set.add(tokens.join("
"));
+    return set;
+  }
+  for (let i = 0; i + k <= tokens.length; i++) set.add(tokens.slice(i, i + k).join("
"));
+  return set;
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter++;
+  return inter / (a.size + b.size - inter);
+}
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function defaultMetric(shingleK = 2) {
+  return {
+    name: `jaccard(k=${shingleK})+levenshtein`,
+    prefilter: (a, b) => jaccard(shingles(a.preorder, shingleK), shingles(b.preorder, shingleK)),
+    confirm: (a, b) => {
+      const max = Math.max(a.preorder.length, b.preorder.length);
+      if (max === 0) return 1;
+      return 1 - levenshtein(a.preorder, b.preorder) / max;
+    }
+  };
+}
+var DEFAULTS = {
+  theta: 0.95,
+  // centre of the empty [0.89,1.0] score gap — see FlatteningOpts.theta
+  prefilterCutoff: 0.6,
+  shingleK: 2,
+  minClusterSize: 2,
+  rootMatch: "exact"
+  // full root-class match — emphasis families (hoo-button vs -primary) stay distinct
+};
+function rootKey(root, mode) {
+  if (mode === "exact") return root;
+  const i = root.lastIndexOf("-");
+  return i > 0 ? root.slice(0, i) : root;
+}
+var UnionFind = class {
+  parent = /* @__PURE__ */ new Map();
+  find(x) {
+    if (!this.parent.has(x)) this.parent.set(x, x);
+    let r = x;
+    while (this.parent.get(r) !== r) r = this.parent.get(r);
+    let c3 = x;
+    while (this.parent.get(c3) !== r) {
+      const nxt = this.parent.get(c3);
+      this.parent.set(c3, r);
+      c3 = nxt;
+    }
+    return r;
+  }
+  union(a, b) {
+    const ra = this.find(a), rb = this.find(b);
+    if (ra !== rb) this.parent.set(ra, rb);
+  }
+};
+function detectFlattening(inputs, opts = {}) {
+  const o = { ...DEFAULTS, ...opts };
+  const metric = opts.metric ?? defaultMetric(o.shingleK);
+  const hasEdge = opts.hasEdge ?? (() => false);
+  const sorted = [...inputs].sort((a, b) => a.id.localeCompare(b.id));
+  const skel = /* @__PURE__ */ new Map();
+  for (const { id, hbs } of sorted) skel.set(id, deriveSkeleton(hbs));
+  const buckets = /* @__PURE__ */ new Map();
+  for (const { id } of sorted) {
+    const s = skel.get(id);
+    if (!s.root) continue;
+    const key = rootKey(s.root, o.rootMatch);
+    (buckets.get(key) ?? buckets.set(key, []).get(key)).push(id);
+  }
+  const clusters = [];
+  for (const [, ids] of [...buckets].sort((a, b) => a[0].localeCompare(b[0]))) {
+    if (ids.length < o.minClusterSize) continue;
+    const uf = new UnionFind();
+    for (const id of ids) uf.find(id);
+    for (let i = 0; i < ids.length; i++) {
+      for (let j = i + 1; j < ids.length; j++) {
+        const a = ids[i], b = ids[j];
+        const sa = skel.get(a), sb = skel.get(b);
+        if (metric.prefilter(sa, sb) < o.prefilterCutoff) continue;
+        if (metric.confirm(sa, sb) < o.theta) continue;
+        if (hasEdge(a, b)) continue;
+        uf.union(a, b);
+      }
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const r = uf.find(id);
+      (groups.get(r) ?? groups.set(r, []).get(r)).push(id);
+    }
+    for (const members of groups.values()) {
+      if (members.length < o.minClusterSize) continue;
+      members.sort((a, b) => a.localeCompare(b));
+      clusters.push(buildCluster(members, skel));
+    }
+  }
+  clusters.sort((a, b) => a.root.localeCompare(b.root) || a.members[0].localeCompare(b.members[0]));
+  return clusters;
+}
+function buildCluster(members, skel) {
+  const memberClasses = {};
+  const freq = /* @__PURE__ */ new Map();
+  for (const id of members) {
+    const classes = [...skel.get(id).staticClasses].sort();
+    memberClasses[id] = classes;
+    for (const c3 of classes) freq.set(c3, (freq.get(c3) ?? 0) + 1);
+  }
+  const half = members.length / 2;
+  const modal = new Set([...freq].filter(([, n]) => n > half).map(([c3]) => c3));
+  const deltas = [];
+  for (const id of members) {
+    const mine = new Set(memberClasses[id]);
+    const extra = [...mine].filter((c3) => !modal.has(c3)).sort();
+    const missing = [...modal].filter((c3) => !mine.has(c3)).sort();
+    if (extra.length || missing.length) deltas.push({ id, extraClasses: extra, missingClasses: missing });
+  }
+  const root = skel.get(members[0]).root ?? "";
+  return { root, members, skeleton: skel.get(members[0]).preorder, memberClasses, deltas };
+}
+function renderFlatteningReport(clusters, meta = {}) {
+  const head = [
+    "# Flattened templates (structural)",
+    "",
+    "> **Scope:** this detects **structural flattening** \u2014 clusters of components that are near-duplicate copies of one template, flattened along a class-token. It is a separate corpus lens: **not** the diagnostics graph, **not** a11y, **not** HTML validation.",
+    ">",
+    "> Every finding is `[SUBJECT-DEBT]` \u2014 the subject flattened its own templates; PD reports the sprawl and grows no model to absorb it. One derived graph (composition) sharpens another (flattening): a wrapper that *includes* a base is excluded as legitimate composition, not a copy.",
+    ">",
+    "> **Boundary:** this catches **class-token** flattening \u2014 copies with identical structure that differ only in class values. A copy whose **markup** also drifted is not distinguishable from a genuinely-distinct sibling family by structural similarity alone; those need review, not a lower threshold. Absence of a cluster is not proof of no duplication.",
+    ">",
+    '> **Reading the count:** a component being *in a cluster* is not the same as a distinct flattening problem. With exact root-match, one logical family whose emphasis is baked into the root class (`hoo-button` vs `hoo-button-primary`) is reported as **separate clusters** \u2014 so the cluster count and the in-cluster percentage **over-count** distinct problems (the emphasis under-reporting). Read the number as "templates touched by flattening," never "N distinct defects."',
+    ""
+  ];
+  if (meta.subjectSha) head.push(`_subject: \`${meta.subjectSha}\`_`, "");
+  if (meta.generatedAt) head.push(`_generated: ${meta.generatedAt}_`, "");
+  if (clusters.length === 0) {
+    return [...head, "No flattened template clusters detected.", ""].join("\n");
+  }
+  const totalMembers = clusters.reduce((n, c3) => n + c3.members.length, 0);
+  head.push(
+    `${clusters.length} flattened cluster${clusters.length > 1 ? "s" : ""} detected across ${totalMembers} components.`,
+    ""
+  );
+  const body = clusters.flatMap((c3) => {
+    const lines = [
+      `## \`${c3.root}\` \u2014 ${c3.members.length} copies  \`[SUBJECT-DEBT]\``,
+      "",
+      "**Members:**",
+      ...c3.members.map((m) => `- \`${m}\``),
+      "",
+      "**Shared skeleton:**",
+      "",
+      "```",
+      ...c3.skeleton,
+      "```",
+      ""
+    ];
+    if (c3.deltas.length) {
+      lines.push("**Drift (per-member deltas from the cluster's modal class set):**");
+      for (const d of c3.deltas) {
+        const parts = [];
+        if (d.extraClasses.length) parts.push(`+ ${d.extraClasses.map((x) => `\`${x}\``).join(" ")}`);
+        if (d.missingClasses.length) parts.push(`\u2212 ${d.missingClasses.map((x) => `\`${x}\``).join(" ")}`);
+        lines.push(`- \`${d.id}\`: ${parts.join("  ")}`);
+      }
+      lines.push("");
+    } else {
+      lines.push("_No class-token drift between members (byte-clean copies)._", "");
+    }
+    return lines;
+  });
+  return [...head, ...body].join("\n");
+}
+
+// packages/dev-server/src/scratch.ts
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join as join5, resolve as resolve3 } from "node:path";
+function pdScratchDir(root) {
+  const key = createHash("sha1").update(resolve3(root)).digest("hex").slice(0, 16);
+  return join5(tmpdir(), "pattern-dump", key);
+}
+
+// packages/dev-server/src/surfacing.ts
+async function surfaceCollisions(collisions, cwd, hotreloader) {
+  const messages = collisions.map((col) => ({ type: "collision", handle: col.handle, incumbentPath: col.incumbentPath, quarantinedPath: col.quarantinedPath }));
+  hotreloader.retain(messages);
+  for (const [i, col] of collisions.entries()) {
+    hotreloader.push(messages[i]);
+    console.warn(`[dev-server] HANDLE_COLLISION: "${col.handle}" \u2014 incumbent: ${col.incumbentPath} \u2014 quarantined: ${col.quarantinedPath}`);
+  }
+  const md = collisions.length === 0 ? "# Conflicts\n\nNo handle collisions detected.\n" : [
+    "# Conflicts",
+    "",
+    `${collisions.length} handle collision${collisions.length > 1 ? "s" : ""} detected. Quarantined components are excluded from the tree until the collision is resolved.`,
+    "",
+    ...collisions.flatMap((c3) => [
+      `## \`${c3.handle}\``,
+      `- **incumbent**: \`${c3.incumbentPath}\``,
+      `- **quarantined**: \`${c3.quarantinedPath}\``,
+      ""
+    ])
+  ].join("\n");
+  try {
+    const dir = pdScratchDir(cwd);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join6(dir, "CONFLICTS.generated.md"), md, "utf-8");
+  } catch (e) {
+    console.warn("[dev-server] Could not write CONFLICTS.generated.md to scratch dir:", e);
+  }
+}
+async function surfaceFlattening(discoveryMap, registry, cwd) {
+  const inputs = [];
+  for (const [id, entry] of discoveryMap) {
+    if (id.includes("~")) continue;
+    if (entry.source) continue;
+    if (!entry.hbsPath) continue;
+    try {
+      inputs.push({ id, hbs: await readFile5(entry.hbsPath, "utf-8") });
+    } catch {
+    }
+  }
+  const hasEdge = (a, b) => (registry.uses.get(a)?.includes(b) ?? false) || (registry.uses.get(b)?.includes(a) ?? false);
+  const clusters = detectFlattening(inputs, { hasEdge });
+  const md = renderFlatteningReport(clusters);
+  if (clusters.length) {
+    const members = clusters.reduce((n, c3) => n + c3.members.length, 0);
+    console.warn(`[dev-server] FLATTENED: ${clusters.length} cluster(s) across ${members} components \u2014 see FLATTENED.generated.md`);
+  }
+  try {
+    const dir = pdScratchDir(cwd);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join6(dir, "FLATTENED.generated.md"), md, "utf-8");
+  } catch (e) {
+    console.warn("[dev-server] Could not write FLATTENED.generated.md to scratch dir:", e);
+  }
+}
+
+// packages/dev-server/src/diagnostics.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile6, writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+
+// packages/a11y/src/producer.ts
+import { createRequire } from "node:module";
+import { JSDOM } from "jsdom";
+
+// packages/a11y/src/rule-tiers.generated.json
+var rule_tiers_generated_default = {
+  _note: "Generated by packages/a11y/src/classifier.ts \u2014 do not hand-edit. Re-run: nx run a11y:classify",
+  generatedAt: "2026-06-08T12:39:19.990Z",
+  axeVersion: "4.11.4",
+  alwaysOn: [
+    "image-alt",
+    "label",
+    "button-name",
+    "link-name",
+    "aria-required-attr",
+    "aria-valid-attr",
+    "aria-valid-attr-value",
+    "autocomplete-valid",
+    "duplicate-id"
+  ],
+  needsRendering: [
+    "aria-hidden-focus",
+    "duplicate-id-aria",
+    "color-contrast"
+  ],
+  investigate: []
+};
+
+// packages/a11y/src/producer.ts
+var require2 = createRequire(import.meta.url);
+var axe = require2("axe-core");
+var SEVERITY_MAP = {
+  critical: "error",
+  serious: "error",
+  moderate: "warning",
+  minor: "warning"
+};
+async function runA11yProducer(html) {
+  const dom = new JSDOM(
+    `<!DOCTYPE html><html lang="en"><body><main>${html}</main></body></html>`,
+    { url: "http://localhost" }
+  );
+  const { violations } = await axe.run(
+    dom.window.document.querySelector("main"),
+    { runOnly: { type: "rule", values: rule_tiers_generated_default.alwaysOn } }
+  );
+  const diagnostics = [];
+  for (const v of violations) {
+    for (const node of v.nodes) {
+      diagnostics.push({
+        kind: "A11Y",
+        source: "axe",
+        severity: SEVERITY_MAP[v.impact ?? ""] ?? "warning",
+        message: node.failureSummary ?? v.description,
+        ruleId: v.id,
+        target: node.target.join(" > "),
+        nodeHtml: node.html,
+        help: v.help,
+        helpUrl: v.helpUrl
+      });
+    }
+  }
+  return diagnostics;
+}
+
+// packages/dev-server/src/diagnostics.ts
+async function checkComponent(componentId, variant, render, quarantineEntry) {
+  if (quarantineEntry) {
+    return {
+      previewHtml: "",
+      diagnostics: [{
+        kind: "HANDLE_COLLISION",
+        severity: "error",
+        source: "discovery",
+        message: `quarantined; handle \`${quarantineEntry.handle}\` is held by \`${quarantineEntry.incumbentId}\`; rename to resolve.`
+      }]
+    };
+  }
+  try {
+    const result = await render({ component: componentId, variant });
+    const previewHtml = result.html;
+    const renderDiags = result.meta?.diagnostics ?? [];
+    const a11yDiags = await runA11yProducer(previewHtml);
+    return { previewHtml, diagnostics: [...renderDiags, ...a11yDiags] };
+  } catch (e) {
+    return {
+      previewHtml: "",
+      diagnostics: [{
+        kind: "RENDER_ERROR",
+        severity: "error",
+        source: "render",
+        message: e instanceof Error ? e.message : String(e)
+      }]
+    };
+  }
+}
+function engineForDiagnostic(diag) {
+  switch (diag.source) {
+    case "axe":
+      return "axe";
+    case "html":
+      return "html-validate";
+    case "schema":
+      return "schema";
+    case "discovery":
+      return "discovery";
+    default:
+      return "render";
+  }
+}
+function ruleIdForDiagnostic(diag) {
+  return diag.ruleId ?? diag.kind;
+}
+var PD_GAP_SIGNATURES = [
+  // (none yet — add a predicate only when a specific finding is proven to be PD's own fault)
+];
+function tagForDiagnostic(diag) {
+  return PD_GAP_SIGNATURES.some((match) => match(diag)) ? "PD-GAP" : "SUBJECT-DEBT";
+}
+function renderOutcomeFor(previewHtml, diagnostics) {
+  if (diagnostics.some((d) => d.kind === "RENDER_ERROR")) return "error";
+  return previewHtml.trim() === "" ? "blank" : "ok";
+}
+async function auditComponent(id, render, quarantineEntry) {
+  const { previewHtml, diagnostics } = await checkComponent(id, void 0, render, quarantineEntry);
+  const occurrences = diagnostics.map((diag) => {
+    const domPath = diag.kind === "A11Y" ? diag.target : void 0;
+    return {
+      engine: engineForDiagnostic(diag),
+      ruleId: ruleIdForDiagnostic(diag),
+      component: id,
+      severity: diag.severity,
+      message: diag.message,
+      ...domPath ? { domPath } : {},
+      tag: tagForDiagnostic(diag)
+    };
+  });
+  return { node: { id, render: renderOutcomeFor(previewHtml, diagnostics) }, occurrences };
+}
+function assembleGraph(audits) {
+  const components = audits.map((a) => a.node).sort((a, b) => a.id.localeCompare(b.id));
+  const occurrences = audits.flatMap((a) => a.occurrences);
+  const ruleNodes = /* @__PURE__ */ new Map();
+  for (const o of occurrences) {
+    const key = `${o.engine} ${o.ruleId}`;
+    if (!ruleNodes.has(key)) ruleNodes.set(key, { engine: o.engine, ruleId: o.ruleId, displayKey: `${o.engine}:${o.ruleId}` });
+  }
+  const rules = [...ruleNodes.values()].sort((a, b) => a.engine === b.engine ? a.ruleId.localeCompare(b.ruleId) : a.engine.localeCompare(b.engine));
+  return { rules, components, occurrences };
+}
+var GRAPH_ARTIFACT_VERSION = 1;
+function graphArtifactPath(root) {
+  return join7(pdScratchDir(root), "diagnostics-graph.json");
+}
+async function readDiagnosticsArtifact(root) {
+  try {
+    const parsed = JSON.parse(await readFile6(graphArtifactPath(root), "utf-8"));
+    return parsed.version === GRAPH_ARTIFACT_VERSION ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function writeDiagnosticsArtifact(root, art) {
+  await mkdir2(pdScratchDir(root), { recursive: true });
+  await writeFile2(graphArtifactPath(root), JSON.stringify(art));
+}
+async function componentContentHash(id, discoveryMap, globalDataDigest) {
+  const entry = discoveryMap.get(id);
+  const hbs = entry?.hbsPath ? await readFile6(entry.hbsPath, "utf-8").catch(() => "") : "";
+  const json2 = entry?.jsonPath ? await readFile6(entry.jsonPath, "utf-8").catch(() => "") : "";
+  return createHash2("sha1").update(id).update(" ").update(hbs).update(" ").update(json2).update(" ").update(globalDataDigest).digest("hex");
+}
+async function refreshDiagnosticsGraph(root, componentIds, render, quarantineMap, discoveryMap, globalData) {
+  const prior = await readDiagnosticsArtifact(root);
+  const globalDataDigest = createHash2("sha1").update(JSON.stringify(globalData ?? {})).digest("hex");
+  const priorNodes = new Map((prior?.graph.components ?? []).map((c3) => [c3.id, c3]));
+  const priorOcc = /* @__PURE__ */ new Map();
+  for (const o of prior?.graph.occurrences ?? []) {
+    const arr = priorOcc.get(o.component) ?? [];
+    arr.push(o);
+    priorOcc.set(o.component, arr);
+  }
+  const slices = /* @__PURE__ */ new Map();
+  const hashes = {};
+  const reaudited = [];
+  for (const id of [...componentIds].sort()) {
+    const h = await componentContentHash(id, discoveryMap, globalDataDigest);
+    hashes[id] = h;
+    const priorNode = priorNodes.get(id);
+    if (prior && prior.hashes[id] === h && priorNode) {
+      slices.set(id, { node: priorNode, occurrences: priorOcc.get(id) ?? [] });
+    } else {
+      slices.set(id, await auditComponent(id, render, quarantineMap.get(id)));
+      reaudited.push(id);
+    }
+  }
+  const graph = assembleGraph([...slices.values()]);
+  await writeDiagnosticsArtifact(root, { version: GRAPH_ARTIFACT_VERSION, hashes, graph });
+  return { graph, slices, reaudited, reused: slices.size - reaudited.length };
+}
+async function persistSlices(root, slices, discoveryMap, globalData) {
+  const globalDataDigest = createHash2("sha1").update(JSON.stringify(globalData ?? {})).digest("hex");
+  const hashes = {};
+  for (const id of slices.keys()) hashes[id] = await componentContentHash(id, discoveryMap, globalDataDigest);
+  await writeDiagnosticsArtifact(root, { version: GRAPH_ARTIFACT_VERSION, hashes, graph: assembleGraph([...slices.values()]) });
+}
+
+// packages/dev-server/src/server-config.ts
+import { basename as basename2, join as join8, resolve as resolve4 } from "node:path";
+var DEFAULT_SWATCH_SLOTS = ["--bodyBackground", "--themePrimary", "--accent"];
+function resolveServerConfig(config, cwd, opts = {}, packages = []) {
+  const port2 = opts.port ?? Number(process.env["PD_PORT"] ?? 4e3);
+  const wsPort = opts.wsPort ?? Number(process.env["PD_WS_PORT"] ?? port2 + 1);
+  const patternsDir = resolve4(cwd, config.patternsDir);
+  const stylesDir = resolve4(cwd, config.styles.dir);
+  const stylesEntries = config.styles.entry ? (Array.isArray(config.styles.entry) ? config.styles.entry : [config.styles.entry]).map((e) => resolve4(stylesDir, e)) : void 0;
+  const inPackage = (p, rel) => join8(p.dir, rel);
+  const asList = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+  const patternRoots = [
+    { dir: patternsDir, ...config.exclude?.length ? { exclude: config.exclude } : {} },
+    ...packages.filter((p) => p.manifest.patterns).map((p) => ({
+      dir: inPackage(p, p.manifest.patterns),
+      source: p.name,
+      ...p.exclude.length ? { exclude: p.exclude } : {}
+    }))
+  ];
+  const styleRoots = [
+    { dir: stylesDir, entries: stylesEntries },
+    ...packages.filter((p) => p.manifest.styles).map((p) => {
+      const dir = inPackage(p, p.manifest.styles.dir);
+      const entries = asList(p.manifest.styles.entry).map((e) => resolve4(dir, e));
+      return { dir, entries: entries.length ? entries : void 0, source: p.name };
+    })
+  ];
+  const themePackages = packages.filter((p) => p.manifest.themes);
+  const themeDirs = [
+    ...config.themes ? [resolve4(cwd, config.themes.dir)] : [],
+    ...themePackages.map((p) => inPackage(p, p.manifest.themes.dir))
+  ];
+  const switches = [config.themes?.switch, ...themePackages.map((p) => p.manifest.themes.switch)];
+  const themeSwitch = switches.includes("stylesheet") ? "stylesheet" : "attribute";
+  const assetRoots = [
+    ...asList(config.assets?.dir).map((d) => resolve4(cwd, d)),
+    ...packages.flatMap((p) => (p.manifest.assets ?? []).map((a) => inPackage(p, a)))
+  ];
+  const globalScripts = [.../* @__PURE__ */ new Set([
+    ...packages.flatMap((p) => p.manifest.globalScripts ?? []),
+    ...config.globalScripts ?? []
+  ])];
+  const scriptsDirs = [
+    ...config.scriptsDir ? [resolve4(cwd, config.scriptsDir)] : [],
+    ...packages.filter((p) => p.manifest.scripts).map((p) => inPackage(p, p.manifest.scripts))
+  ];
+  const documentBaseEnabled = Array.isArray(config.documentBase) && config.documentBase.length > 0 || packages.some((p) => (p.manifest.styles?.documentBase?.length ?? 0) > 0);
+  return {
+    port: port2,
+    wsPort,
+    cwd,
+    config,
+    packages,
+    patternRoots,
+    patternDirs: patternRoots.map((r) => r.dir),
+    styleRoots,
+    dataDirs: [
+      ...packages.filter((p) => p.manifest.data).map((p) => inPackage(p, p.manifest.data)),
+      ...config.dataDir ? [resolve4(cwd, config.dataDir)] : []
+    ],
+    helperPaths: [
+      ...packages.filter((p) => p.manifest.helpers).map((p) => inPackage(p, p.manifest.helpers)),
+      ...config.helpers ? [resolve4(cwd, config.helpers)] : []
+    ],
+    scriptsDirs,
+    patternsDir,
+    stylesDir,
+    stylesEntries,
+    themeDirs,
+    themesDir: themeDirs[0] ?? null,
+    defaultTheme: config.themes?.default ?? themePackages[0]?.manifest.themes?.default,
+    assetRoots,
+    assetRootNames: assetRoots.map((r) => basename2(r)),
+    assetsDir: assetRoots[0] ?? null,
+    assetsCss: config.assets?.css ?? [],
+    scriptsDir: scriptsDirs[0] ?? null,
+    globalScripts,
+    withGlobalScripts: (own) => [.../* @__PURE__ */ new Set([...globalScripts, ...own ?? []])],
+    overviewsEnabled: config.overviews !== false,
+    documentBaseEnabled,
+    themeSwitch,
+    swatchSlots: config.themes?.swatch?.slots ?? DEFAULT_SWATCH_SLOTS,
+    packageSwatchSlots: DEFAULT_SWATCH_SLOTS
+  };
+}
+
+// packages/dev-server/src/packages.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname as dirname2, join as join9 } from "node:path";
+function findPackageDir(name, root) {
+  let dir = root;
+  for (; ; ) {
+    const candidate = join9(dir, "node_modules", name);
+    if (existsSync(join9(candidate, "package.json"))) return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadPatternPackages(references, root) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (name, extraExclude, direct, from) => {
+    if (seen.has(name)) return;
+    const dir = findPackageDir(name, from);
+    if (!dir) {
+      if (!direct) return;
+      throw new Error(`pattern package "${name}" is not installed \u2014 run: npm install --save-dev ${name}`);
+    }
+    const pkg = JSON.parse(readFileSync(join9(dir, "package.json"), "utf8"));
+    if (!pkg.patternDump) {
+      if (!direct) return;
+      throw new Error(
+        `"${name}" has no "patternDump" field in its package.json, so Pattern Dump cannot tell where its patterns, styles and themes are. See PackageManifest in @pattern-dump/contracts.`
+      );
+    }
+    seen.add(name);
+    out.push({
+      name,
+      version: pkg.version ?? "0.0.0",
+      dir,
+      manifest: pkg.patternDump,
+      exclude: [...pkg.patternDump.exclude ?? [], ...extraExclude],
+      direct
+    });
+    for (const peer of Object.keys(pkg.peerDependencies ?? {})) visit(peer, [], false, dir);
+  };
+  for (const ref of references ?? []) {
+    const { name, exclude } = typeof ref === "string" ? { name: ref, exclude: [] } : { name: ref.name, exclude: ref.exclude ?? [] };
+    visit(name, exclude, true, root);
+  }
+  return out;
+}
+
+// packages/dev-server/src/audit.ts
+async function runDiagnosticsAudit(config, cwd) {
+  const cfg = resolveServerConfig(config, cwd, {}, loadPatternPackages(config.packages, cwd));
+  const { patternsDir, patternRoots, patternDirs, themesDir, defaultTheme } = cfg;
+  const helperRegistrars = [];
+  for (const path of cfg.helperPaths) helperRegistrars.push(...await loadHelperRegistrars(path));
+  const globalData = cfg.dataDirs.length ? await loadGlobalData(cfg.dataDirs) : void 0;
+  const render = createRenderer({
+    patternsDir,
+    patternRoots,
+    themesDir: themesDir ?? void 0,
+    defaultTheme,
+    ...helperRegistrars.length ? { helperRegistrars } : {},
+    ...globalData ? { globalData } : {}
+  });
+  const discovery = await buildDiscoveryMap(patternRoots);
+  const { graph, reaudited, reused } = await refreshDiagnosticsGraph(
+    cwd,
+    baseComponentIds(discovery),
+    render,
+    discovery.quarantineMap,
+    discovery.discoveryMap,
+    globalData
+  );
+  const registry = await buildCompositionRegistry(patternDirs, discovery.handleMap, discovery.discoveryMap);
+  await surfaceFlattening(discovery.discoveryMap, registry, cwd);
+  return { graph, reaudited, reused, artifactPath: graphArtifactPath(cwd) };
+}
+
+// packages/dev-server/src/static-build.ts
+import { cp, mkdir as mkdir3, rm, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, join as join10, relative as relative2, resolve as resolve5, sep } from "node:path";
+
+// packages/dev-server/src/http-utils.ts
+import { readFile as readFile7 } from "node:fs/promises";
+function mimeType(ext) {
+  const map = {
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".html": "text/html",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm"
+  };
+  return map[ext.toLowerCase()] ?? "application/octet-stream";
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function json(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+async function serveFile(res, filePath, contentType) {
+  try {
+    const content = await readFile7(filePath);
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+  } catch {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not found");
+  }
+}
+function buildShellHtml(runtime) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Pattern Dump Dev</title>
+<link rel="stylesheet" href="${PD_ROUTES.mainCss}">
+<link rel="stylesheet" href="${PD_ROUTES.shikiCss}">
+</head>
+<body>
+<div id="app"></div>
+<script>window.__pd=${JSON.stringify(runtime).replace(/</g, "\\u003c")};</script>
+<script type="module" src="${PD_ROUTES.mainJs}"></script>
+</body>
+</html>`;
+}
+
+// packages/dev-server/src/static-build.ts
+var PD_PREFIXES = /(^|["'(\s,=])\/(_pd|api|preview|source|assets)\//g;
+function withBasePath(text, basePath) {
+  if (basePath === "/") return text;
+  return text.replace(PD_PREFIXES, (_m, lead, head) => `${lead}${basePath}${head}/`);
+}
+var isText = (contentType) => /\b(text\/html|text\/css|application\/json)\b/.test(contentType);
+function diskPath(outDir, urlPath) {
+  return join10(outDir, ...urlPath.split("/").map((seg) => decodeURIComponent(seg)));
+}
+async function buildStaticSite(config, root, opts) {
+  const started = performance.now();
+  const logLine = opts.log ?? (() => {
+  });
+  const log = (line) => logLine(`${line} (${((performance.now() - started) / 1e3).toFixed(1)}s)`);
+  const basePath = normalizeBasePath(opts.basePath ?? config.build?.basePath);
+  const includeAudit = opts.audit ?? config.build?.audit ?? true;
+  const outDir = resolve5(opts.outDir);
+  const cfg = resolveServerConfig(config, root, {}, loadPatternPackages(config.packages, root));
+  const inside = (child, parent) => {
+    const rel = relative2(parent, child);
+    return rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !/^[a-zA-Z]:/.test(rel);
+  };
+  const project = resolve5(root);
+  if (inside(project, outDir)) throw new Error(`pd build: --out ${outDir} would contain the project itself \u2014 choose a folder inside or beside it, like ./dist`);
+  for (const source of [cfg.patternsDir, cfg.stylesDir, ...cfg.themeDirs, ...cfg.assetRoots]) {
+    if (inside(outDir, source) || inside(source, outDir)) {
+      throw new Error(`pd build: --out ${outDir} overlaps ${source}, which Pattern Dump reads \u2014 choose another folder`);
+    }
+  }
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir3(outDir, { recursive: true });
+  const server = await startDevServer(config, root, { port: 0, live: false });
+  log("\u2026 server ready");
+  const origin = `http://127.0.0.1:${server.port}`;
+  const report = { outDir, basePath, files: 0, bytes: 0, components: 0, warnings: [], ms: 0 };
+  const done = /* @__PURE__ */ new Set();
+  async function capture(liveUrl, { optional = false } = {}) {
+    const file = staticPathFor(liveUrl);
+    if (done.has(file)) return null;
+    done.add(file);
+    const res = await fetch(`${origin}${liveUrl}`);
+    if (res.status !== 200) {
+      if (res.status >= 500 || !optional) {
+        const reason = res.status >= 500 ? `: ${((await res.text()).split("\n")[0] ?? "").slice(0, 160)}` : "";
+        report.warnings.push(`${res.status} ${liveUrl}${reason}`);
+      }
+      return null;
+    }
+    const type = res.headers.get("content-type") ?? "";
+    const target = diskPath(outDir, file);
+    await mkdir3(dirname3(target), { recursive: true });
+    if (isText(type)) {
+      const body = await res.text();
+      const out = withBasePath(body, basePath);
+      await writeFile3(target, out);
+      report.bytes += Buffer.byteLength(out);
+      report.files++;
+      return body;
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    await writeFile3(target, buffer);
+    report.bytes += buffer.length;
+    report.files++;
+    return /javascript/.test(type) ? buffer.toString("utf8") : null;
+  }
+  async function store(liveUrl, body) {
+    const file = staticPathFor(liveUrl);
+    if (done.has(file)) return;
+    done.add(file);
+    const target = diskPath(outDir, file);
+    await mkdir3(dirname3(target), { recursive: true });
+    const out = withBasePath(body, basePath);
+    await writeFile3(target, out);
+    report.bytes += Buffer.byteLength(out);
+    report.files++;
+  }
+  const referenced = (html) => [...html.matchAll(/(?:href|src)="(\/_pd\/(?:components|themes|scripts)\/[^"]+)"/g)].map((m) => m[1].replace(/&amp;/g, "&"));
+  try {
+    for (const url of [
+      PD_ROUTES.mainJs,
+      PD_ROUTES.mainCss,
+      PD_ROUTES.shikiCss,
+      PD_ROUTES.baseCss,
+      PD_ROUTES.axeCore,
+      PD_ROUTES.ruleTiers,
+      PD_ROUTES.config,
+      PD_ROUTES.version
+    ]) {
+      await capture(url);
+    }
+    const tree = JSON.parse(await capture(PD_ROUTES.tree));
+    const themes = JSON.parse(await capture(PD_ROUTES.themes));
+    for (const t of themes) await capture(themeCssUrl(t.name));
+    log(`\u2026 ${themes.length} themes`);
+    const components = [];
+    const folders = [];
+    const walk = (nodes) => nodes.forEach((n) => {
+      if (n.kind === "component") components.push(n.path);
+      if (n.children?.length) folders.push(n.path);
+      walk(n.children ?? []);
+    });
+    walk(tree.roots);
+    report.components = components.length;
+    const routes = /* @__PURE__ */ new Set(["/"]);
+    for (const id of components) {
+      routes.add(`/${id}`);
+      const baseText = await capture(componentUrl(id));
+      if (!baseText) continue;
+      const base2 = JSON.parse(baseText);
+      if (base2.variants.length) routes.add(`/${id}/variants`);
+      for (const variant of [void 0, ...base2.variants.map((v) => v.name)]) {
+        const detailText = variant ? await capture(componentUrl(id, variant)) : baseText;
+        if (detailText) {
+          const { document } = JSON.parse(detailText);
+          await store(previewUrl(id, variant), document);
+          for (const ref of referenced(document)) await capture(ref);
+        }
+        await capture(renderedSourceUrl(id, variant), { optional: true });
+        await capture(dataSourceUrl(id, variant), { optional: true });
+      }
+    }
+    log(`\u2026 ${components.length} components with their variants, previews and source views`);
+    for (const path of folders) {
+      routes.add(`/${path}`);
+      await capture(overviewUrl(path), { optional: true });
+    }
+    log(`\u2026 ${folders.length} folder overviews`);
+    if (includeAudit) {
+      await capture(PD_ROUTES.audit);
+      log("\u2026 corpus audit");
+    } else {
+      log("\u2026 corpus audit left out (build.audit: false / --no-audit)");
+    }
+    for (const [i, rootDir] of cfg.assetRoots.entries()) {
+      const exists = await stat2(rootDir).then((s) => s.isDirectory(), () => false);
+      if (!exists) continue;
+      await cp(rootDir, join10(outDir, "assets", cfg.assetRootNames[i]), { recursive: true });
+      if (cfg.assetRoots.length === 1) await cp(rootDir, join10(outDir, "assets"), { recursive: true, force: false });
+    }
+    const runtime = {
+      mode: "static",
+      basePath,
+      builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pdVersion: opts.pdVersion,
+      ...includeAudit ? {} : { audit: false }
+    };
+    const shell = withBasePath(buildShellHtml(runtime), basePath);
+    for (const route of routes) {
+      const target = diskPath(outDir, staticPathFor(route));
+      await mkdir3(dirname3(target), { recursive: true });
+      await writeFile3(target, shell);
+      report.files++;
+      report.bytes += Buffer.byteLength(shell);
+    }
+    await writeFile3(join10(outDir, ".nojekyll"), "");
+    report.files++;
+  } finally {
+    await server.close();
+  }
+  report.ms = Math.round(performance.now() - started);
+  return report;
+}
+
+// packages/dev-server/src/server-state.ts
+function createServerState() {
+  return {
+    lastComponentId: "",
+    scssModuleGraph: null,
+    classOwnerIndex: null,
+    baseProvenance: null,
+    scssGraphDirty: true,
+    perComponentCss: /* @__PURE__ */ new Map(),
+    baseCss: "",
+    compositionRegistry: null,
+    discoveryResult: null,
+    auditSlices: null,
+    liveReauditCount: 0,
+    themeCss: /* @__PURE__ */ new Map(),
+    themeTokens: /* @__PURE__ */ new Map(),
+    scriptCache: /* @__PURE__ */ new Map()
+  };
+}
+
+// packages/dev-server/src/routes.ts
+import { basename as basename4, extname as extname2, join as join17 } from "node:path";
+import { readFile as readFile15, stat as stat4 } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+
+// packages/dev-server/src/component-tree.ts
+import { readFile as readFile10 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+
+// packages/dev-server/src/layout-mode.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+
+// packages/dev-server/src/pattern-dirs.ts
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join11 } from "node:path";
+async function readFolderFile(dirs, rel) {
+  for (const dir of typeof dirs === "string" ? [dirs] : dirs) {
+    try {
+      return await readFile8(join11(dir, rel), "utf-8");
+    } catch {
+    }
+  }
+  return null;
+}
+
+// packages/dev-server/src/layout-mode.ts
+var FULL_CATEGORIES = /* @__PURE__ */ new Set(["pages", "templates"]);
+async function resolveLayoutMode(componentId, patternsDir, discoveryMap) {
+  const parts = componentId.split("/");
+  const category = parts[0];
+  let layout = FULL_CATEGORIES.has(category) ? "full" : "centered";
+  const categoryIndex = await readFolderFile(patternsDir, join12(category, "index.md"));
+  if (categoryIndex !== null) {
+    const m = categoryIndex.match(/^preview:\s*(centered|full)$/m);
+    if (m) layout = m[1];
+  }
+  const mdPath = discoveryMap?.get(componentId)?.mdPath;
+  if (mdPath) {
+    try {
+      const md = await readFile9(mdPath, "utf-8");
+      const m = md.match(/^preview:\s*(centered|full)$/m);
+      if (m) layout = m[1];
+    } catch {
+    }
+  }
+  return layout;
+}
+
+// packages/dev-server/src/frontmatter.ts
+var unquote = (s) => {
+  const t = s.trim();
+  return t.length >= 2 && (t[0] === '"' || t[0] === "'") && t.at(-1) === t[0] ? t.slice(1, -1) : t;
+};
+function readFrontmatter(md) {
+  const lines = md.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return {};
+  const end = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+  if (end < 0) return {};
+  const out = {};
+  let listKey = null;
+  for (const line of lines.slice(1, end)) {
+    const item = line.match(/^\s*-\s+(.*)$/);
+    if (item && listKey) {
+      out[listKey].push(unquote(item[1]));
+      continue;
+    }
+    const kv = line.match(/^([A-Za-z_][\w-]*):\s*(.*)$/);
+    if (!kv) {
+      listKey = null;
+      continue;
+    }
+    const [, key, raw] = kv;
+    const value = raw.trim();
+    if (value === "") {
+      out[key] = [];
+      listKey = key;
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      out[key] = value.slice(1, -1).split(",").map(unquote).filter(Boolean);
+      listKey = null;
+    } else {
+      out[key] = unquote(value);
+      listKey = null;
+    }
+  }
+  return out;
+}
+
+// packages/dev-server/src/tree-order.ts
+function parseOrder(value) {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value)) return { list: value };
+  if (/^-?\d+(\.\d+)?$/.test(value)) return { weight: Number(value) };
+  const list = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return list.length ? { list } : void 0;
+}
+var collator = new Intl.Collator("en", { numeric: true });
+var REST = "...";
+function orderSiblings(items, list) {
+  const position = /* @__PURE__ */ new Map();
+  list?.forEach((name, i) => {
+    if (!position.has(name)) position.set(name, i);
+  });
+  const restPosition = position.get(REST) ?? Infinity;
+  const positionOf = (item) => list ? position.get(item.segment) ?? restPosition : 0;
+  return [...items].sort((a, b) => {
+    const ra = a.weight ?? 0;
+    const rb = b.weight ?? 0;
+    if (ra !== rb) return ra - rb;
+    const pa = positionOf(a);
+    const pb = positionOf(b);
+    if (pa !== pb) return pa - pb;
+    return collator.compare(a.segment, b.segment) || (a.segment < b.segment ? -1 : a.segment > b.segment ? 1 : 0);
+  });
+}
+
+// packages/dev-server/src/component-tree.ts
+function directChildPaths(parentPath, allIds) {
+  const prefix = `${parentPath}/`;
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of allIds) {
+    if (id === parentPath || !id.startsWith(prefix)) continue;
+    const segment = id.slice(prefix.length).split("/")[0];
+    seen.add(`${parentPath}/${segment}`);
+  }
+  return [...seen];
+}
+function folderTitle(segment) {
+  const words = segment.split(/[-_\s]+/).filter(Boolean);
+  if (words.length === 0) return segment;
+  const text = words.join(" ");
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+var readText = (path) => readFile10(path, "utf-8").catch(() => null);
+function orderOf(md) {
+  return md === null ? void 0 : parseOrder(readFrontmatter(md)["order"]);
+}
+function hasPublicComponent(node) {
+  if (node.kind === "component" && node.visibility !== "private") return true;
+  return node.children?.some(hasPublicComponent) ?? false;
+}
+async function buildComponentTree(patternsDir, overviewsEnabled, discoveryMap) {
+  const baseIds = [...discoveryMap.keys()].filter((id) => !id.includes("~"));
+  const categories = [...new Set(baseIds.map((id) => id.split("/")[0]))];
+  const built = [];
+  for (const cat of categories) {
+    const catIds = baseIds.filter((id) => id === cat || id.startsWith(`${cat}/`));
+    const node = await buildTreeNodeFromMap(cat, catIds, patternsDir, overviewsEnabled, discoveryMap);
+    if (node) built.push(node);
+  }
+  const rootOrder = orderOf(await readFolderFile(patternsDir, "index.md"));
+  const list = rootOrder && "list" in rootOrder ? rootOrder.list : void 0;
+  return { roots: orderSiblings(built, list).map((b) => b.node) };
+}
+async function buildSubtree(folderPath, patternsDir, discoveryMap) {
+  const ids = [...discoveryMap.keys()].filter((id) => !id.includes("~") && (id === folderPath || id.startsWith(`${folderPath}/`)));
+  if (ids.length === 0) return null;
+  return (await buildTreeNodeFromMap(folderPath, ids, patternsDir, true, discoveryMap))?.node ?? null;
+}
+async function buildTreeNodeFromMap(nodePath, idsUnderPath, patternsDir, overviewsEnabled, discoveryMap) {
+  const name = nodePath.split("/").pop();
+  if (name.startsWith(".")) return null;
+  const entry = discoveryMap.get(nodePath);
+  const isComponent = entry !== void 0;
+  let title = name;
+  let status = "draft";
+  let visibility;
+  let weight;
+  if (isComponent && entry.mdPath) {
+    const md = await readText(entry.mdPath);
+    if (md !== null) {
+      const t = md.match(/^title:\s*(.+)$/m);
+      const s = md.match(/^status:\s*(.+)$/m);
+      const v = md.match(/^visibility:\s*(public|private)$/m);
+      if (t) title = t[1].trim();
+      if (s) {
+        const sv = s[1].trim();
+        if (sv === "stable" || sv === "deprecated" || sv === "draft") status = sv;
+      }
+      if (v) visibility = v[1];
+      const o = orderOf(md);
+      if (o && "weight" in o) weight = o.weight;
+    }
+  }
+  const indexMd = await readFolderFile(patternsDir, join13(nodePath, "index.md"));
+  const folderOrder = orderOf(indexMd);
+  const built = [];
+  for (const childPath of directChildPaths(nodePath, idsUnderPath)) {
+    const childIds = idsUnderPath.filter((id) => id === childPath || id.startsWith(`${childPath}/`));
+    const child = await buildTreeNodeFromMap(childPath, childIds, patternsDir, overviewsEnabled, discoveryMap);
+    if (child) built.push(child);
+  }
+  const children = orderSiblings(built, folderOrder && "list" in folderOrder ? folderOrder.list : void 0).map((b) => b.node);
+  const kind = isComponent ? "component" : "group";
+  let layout;
+  if (isComponent) layout = await resolveLayoutMode(nodePath, patternsDir, discoveryMap);
+  let hasOverview = false;
+  if (!isComponent) {
+    let titled = false;
+    if (indexMd !== null) {
+      const t = indexMd.match(/^title:\s*(.+)$/m);
+      if (t) {
+        title = t[1].trim();
+        titled = true;
+      }
+      if (!visibility) {
+        const v = indexMd.match(/^visibility:\s*(public|private)$/m);
+        if (v) visibility = v[1];
+      }
+      if (folderOrder && "weight" in folderOrder) weight = folderOrder.weight;
+    }
+    if (!titled) title = folderTitle(name);
+    const optedOut = indexMd !== null && /^overview:\s*false$/m.test(indexMd);
+    hasOverview = overviewsEnabled && !optedOut && children.some(hasPublicComponent);
+  }
+  const node = {
+    path: nodePath,
+    title,
+    kind,
+    hasOverview,
+    ...isComponent ? { status, layout } : {},
+    ...isComponent && entry.source ? { source: entry.source } : {},
+    ...visibility ? { visibility } : {},
+    ...children.length ? { children } : {}
+  };
+  return { node, segment: name, ...weight !== void 0 ? { weight } : {} };
+}
+
+// packages/dev-server/src/detail.ts
+import { readFile as readFile14 } from "node:fs/promises";
+
+// packages/dev-server/src/markdown.ts
+import { readFile as readFile11 } from "node:fs/promises";
+import MarkdownIt from "markdown-it";
+var _md = new MarkdownIt({ html: false, linkify: false });
+_md.validateLink = (url) => {
+  const t = url.trim();
+  return /^(https?|mailto|tel):/i.test(t) || /^[.#/]/.test(t) || t.startsWith("pattern:");
+};
+_md.renderer.rules["fence"] = (tokens, idx, _opts, env) => {
+  const map = env.resolvedFences;
+  return map?.get(idx) ?? _mdPlainPre(tokens[idx]?.content ?? "");
+};
+function _mdPlainPre(code) {
+  return `<pre><code>${escapeHtml(code)}</code></pre>`;
+}
+function _parsePatternSpec(spec) {
+  const tildeIdx = spec.indexOf("~");
+  return {
+    compId: tildeIdx >= 0 ? spec.slice(0, tildeIdx) : spec,
+    variant: tildeIdx >= 0 ? spec.slice(tildeIdx + 1) : void 0
+  };
+}
+function _resolvePatternLinks(tokens, discoveryMap) {
+  for (const blockTok of tokens) {
+    if (blockTok.type !== "inline" || !blockTok.children) continue;
+    for (const child of blockTok.children) {
+      if (child.type !== "link_open") continue;
+      const href = child.attrGet("href") ?? "";
+      if (!href.startsWith("pattern:")) continue;
+      const { compId, variant } = _parsePatternSpec(href.slice("pattern:".length));
+      const fullId = variant ? `${compId}~${variant}` : compId;
+      if (discoveryMap.has(fullId)) {
+        child.attrSet("href", "/" + compId + (variant ? "#" + variant : ""));
+        child.attrPush(["class", "pattern-link"]);
+        child.attrPush(["data-pattern-id", compId]);
+        if (variant) child.attrPush(["data-variant", variant]);
+      } else {
+        child.attrSet("href", "#");
+        child.attrPush(["class", "pattern-link--unresolved"]);
+        child.attrPush(["aria-disabled", "true"]);
+      }
+    }
+  }
+}
+async function renderDoc(body, renderComponent, discoveryMap) {
+  const tokens = _md.parse(body, {});
+  _resolvePatternLinks(tokens, discoveryMap);
+  const resolvedFences = /* @__PURE__ */ new Map();
+  await Promise.all(
+    tokens.flatMap(
+      (tok, idx) => tok.type === "fence" ? [_resolveFence(tok.info, tok.content, idx, renderComponent, resolvedFences, discoveryMap)] : []
+    )
+  );
+  return _md.renderer.render(tokens, _md.options, { resolvedFences });
+}
+function _isRendererNotFound(e) {
+  return e instanceof Error && e.message.startsWith("[renderer]") && e.message.includes("not found");
+}
+async function _resolveFence(info, content, idx, renderComponent, out, discoveryMap) {
+  const lang = info.trim();
+  const code = content;
+  if (lang === "pattern" || lang.startsWith("pattern ")) {
+    const spec = lang.startsWith("pattern ") ? lang.slice("pattern ".length).trim() : code.split("\n")[0]?.trim() ?? "";
+    if (!spec) {
+      out.set(idx, `<pre><code></code></pre>`);
+      return;
+    }
+    const { compId, variant } = _parsePatternSpec(spec);
+    try {
+      const html = await renderComponent(compId, variant);
+      out.set(idx, `<div class="doc-example">${html}</div>`);
+    } catch (e) {
+      if (!_isRendererNotFound(e)) console.warn(`[dev-server] Pattern block render error [${spec}]:`, e);
+      out.set(idx, `<p class="doc-error">[pattern: ${escapeHtml(spec)} \u2014 render error]</p>`);
+    }
+    return;
+  }
+  if (lang === "src-template" || lang.startsWith("src-template ")) {
+    const spec = lang.startsWith("src-template ") ? lang.slice("src-template ".length).trim() : code.split("\n")[0]?.trim() ?? "";
+    if (!spec) {
+      out.set(idx, _mdPlainPre(""));
+      return;
+    }
+    const { compId } = _parsePatternSpec(spec);
+    const entry = discoveryMap.get(compId);
+    if (!entry?.hbsPath) {
+      out.set(idx, `<p class="doc-error">[src-template: ${escapeHtml(spec)} \u2014 no template file]</p>`);
+      return;
+    }
+    try {
+      const src = await readFile11(entry.hbsPath, "utf-8");
+      out.set(idx, wrapWithCopyButton(highlight(src, "handlebars"), src));
+    } catch (e) {
+      console.warn(`[dev-server] src-template read error [${spec}]:`, e);
+      out.set(idx, `<p class="doc-error">[src-template: ${escapeHtml(spec)} \u2014 read error]</p>`);
+    }
+    return;
+  }
+  if (lang === "src-data" || lang.startsWith("src-data ")) {
+    const spec = lang.startsWith("src-data ") ? lang.slice("src-data ".length).trim() : code.split("\n")[0]?.trim() ?? "";
+    if (!spec) {
+      out.set(idx, _mdPlainPre(""));
+      return;
+    }
+    const { compId, variant } = _parsePatternSpec(spec);
+    const lookupId = variant ? `${compId}~${variant}` : compId;
+    try {
+      if (variant) {
+        const variantEntry = discoveryMap.get(lookupId);
+        if (!variantEntry) {
+          out.set(idx, `<p class="doc-error">[src-data: ${escapeHtml(spec)} \u2014 unknown variant]</p>`);
+          return;
+        }
+        const baseJsonPath = discoveryMap.get(compId)?.jsonPath;
+        const variantJsonPath = variantEntry.jsonPath;
+        const baseData = baseJsonPath ? JSON.parse(await readFile11(baseJsonPath, "utf-8")) : {};
+        const variantData = variantJsonPath ? JSON.parse(await readFile11(variantJsonPath, "utf-8")) : {};
+        const merged = deepMerge(structuredClone(baseData), variantData);
+        const src = JSON.stringify(merged, null, 2);
+        out.set(idx, wrapWithCopyButton(highlight(src, "json"), src));
+      } else {
+        const jsonPath = discoveryMap.get(compId)?.jsonPath;
+        if (!jsonPath) {
+          out.set(idx, `<p class="doc-error">[src-data: ${escapeHtml(spec)} \u2014 no data file]</p>`);
+          return;
+        }
+        const src = await readFile11(jsonPath, "utf-8");
+        out.set(idx, wrapWithCopyButton(highlight(src, "json"), src));
+      }
+    } catch (e) {
+      console.warn(`[dev-server] src-data read error [${spec}]:`, e);
+      out.set(idx, `<p class="doc-error">[src-data: ${escapeHtml(spec)} \u2014 read error]</p>`);
+    }
+    return;
+  }
+  if (lang === "src-html" || lang.startsWith("src-html ")) {
+    const spec = lang.startsWith("src-html ") ? lang.slice("src-html ".length).trim() : code.split("\n")[0]?.trim() ?? "";
+    if (!spec) {
+      out.set(idx, _mdPlainPre(""));
+      return;
+    }
+    const { compId, variant } = _parsePatternSpec(spec);
+    try {
+      const html = await renderComponent(compId, variant);
+      out.set(idx, wrapWithCopyButton(highlight(html, "html"), html));
+    } catch (e) {
+      if (!_isRendererNotFound(e)) console.warn(`[dev-server] src-html render error [${spec}]:`, e);
+      out.set(idx, `<p class="doc-error">[src-html: ${escapeHtml(spec)} \u2014 render error]</p>`);
+    }
+    return;
+  }
+  const highlighted = highlight(code, lang);
+  out.set(idx, wrapWithCopyButton(highlighted, code));
+}
+
+// packages/dev-server/src/css-closure.ts
+import { readFile as readFile12 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve7 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import postcss4 from "postcss";
+import * as sass3 from "sass";
+import { SourceMapConsumer as SourceMapConsumer2 } from "source-map";
+import { parse as parseHtml2 } from "node-html-parser";
+
+// packages/dev-server/src/style-index.ts
+import { dirname as dirname4, relative as relative3, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import postcss3 from "postcss";
+import { SourceMapConsumer } from "source-map";
+import * as sass2 from "sass";
+
+// packages/dev-server/src/timing.ts
+var verboseTiming = !!process.env["PD_VERBOSE_TIMING"];
+
+// packages/dev-server/src/style-index.ts
+function resolveScssToComponent(absPath, stylesDir, componentIds) {
+  const rel = relative3(stylesDir, absPath);
+  let normalized = rel.replace(/\.scss$/, "").split("/").map((seg) => seg.replace(/^\d+[-_]/, "").replace(/^_/, "")).join("/");
+  if (normalized.endsWith("/index")) normalized = normalized.slice(0, -6);
+  const id = collapseComponentId(normalized);
+  return componentIds.has(id) ? id : null;
+}
+function resolveSharedModulePath(absPath, stylesDir, keepBarrel = false) {
+  const rel = relative3(stylesDir, absPath);
+  if (rel.startsWith("..")) return null;
+  const parts = rel.replace(/\.scss$/, "").split("/");
+  const normalized = parts.map(
+    (seg, i) => i === parts.length - 1 ? seg.replace(/^_/, "") : seg
+  );
+  if (!keepBarrel && normalized[normalized.length - 1] === "index") return null;
+  return normalized.join("/");
+}
+function extractClassesFromCompiled(consumer, root, entryFile, stylesDir, componentIds) {
+  const classMap = /* @__PURE__ */ new Map();
+  const baseModules = /* @__PURE__ */ new Map();
+  root.walkRules((rule) => {
+    const classMatches = rule.selector.match(/\.([\w-]+)/g);
+    if (!classMatches) return;
+    const pos = rule.source?.start;
+    if (!pos) return;
+    const original = consumer.originalPositionFor({ line: pos.line, column: pos.column - 1 });
+    if (!original.source) return;
+    const originPath = original.source.startsWith("file://") ? fileURLToPath2(original.source) : resolve6(dirname4(entryFile), original.source);
+    const resolved = resolveScssToComponent(originPath, stylesDir, componentIds);
+    const owner = resolved ?? "__base__";
+    const modulePath = resolved === null ? resolveSharedModulePath(originPath, stylesDir, true) : null;
+    for (const cls of classMatches) {
+      const name = cls.slice(1);
+      if (!classMap.has(name)) classMap.set(name, owner);
+      if (modulePath && classMap.get(name) === "__base__" && !baseModules.has(name)) {
+        baseModules.set(name, modulePath);
+      }
+    }
+  });
+  return { classMap, baseModules };
+}
+async function attributeClassesFromFile(entryFile, stylesDir, componentIds) {
+  try {
+    const compiled = sass2.compile(entryFile, { sourceMap: true });
+    if (!compiled.sourceMap) return null;
+    const consumer = new SourceMapConsumer(compiled.sourceMap);
+    const root = postcss3.parse(compiled.css);
+    const { classMap } = extractClassesFromCompiled(consumer, root, entryFile, stylesDir, componentIds);
+    return classMap;
+  } catch {
+    return null;
+  }
+}
+async function patchClassOwnerIndex(entryFile, changedCompId, stylesDir, componentIds, index) {
+  for (const [cls, owner] of index) {
+    if (owner === changedCompId) index.delete(cls);
+  }
+  const fresh = await attributeClassesFromFile(entryFile, stylesDir, componentIds);
+  if (!fresh) return false;
+  for (const [name, owner] of fresh) {
+    if (owner === changedCompId && !index.has(name)) index.set(name, owner);
+  }
+  return true;
+}
+async function buildAllStyleData(roots, componentIds, entryOverride) {
+  if (verboseTiming) console.time("[dev-server:timing] full classOwnerIndex build");
+  const styleUsesModules = /* @__PURE__ */ new Map();
+  const classIndex = /* @__PURE__ */ new Map();
+  const baseProvenance = /* @__PURE__ */ new Map();
+  const componentCssBuckets = /* @__PURE__ */ new Map();
+  const baseCssByRoot = [];
+  for (const id of componentIds) styleUsesModules.set(id, []);
+  const rootList = typeof roots === "string" ? [{ dir: roots, ...entryOverride ? { entries: entryOverride } : {} }] : roots;
+  for (const styleRoot of rootList) {
+    const stylesDir = styleRoot.dir;
+    const baseCssBucket = /* @__PURE__ */ new Set();
+    baseCssByRoot.push([]);
+    let entryFiles = [];
+    if (styleRoot.entries && styleRoot.entries.length > 0) {
+      entryFiles = [...styleRoot.entries];
+    } else {
+      try {
+        entryFiles = await collectScssFiles(stylesDir);
+      } catch {
+        entryFiles = [];
+      }
+    }
+    entryFiles.sort();
+    for (const entryFile of entryFiles) {
+      let originOwnerFor2 = function(node) {
+        const pos = node.source?.start;
+        if (!pos) return null;
+        const original = consumer.originalPositionFor({
+          line: pos.line,
+          column: pos.column - 1
+        });
+        if (!original.source) return null;
+        const originPath = original.source.startsWith("file://") ? fileURLToPath2(original.source) : resolve6(dirname4(entryFile), original.source);
+        const originComp = resolveScssToComponent(originPath, stylesDir, componentIds);
+        return originComp ?? "__base__";
+      };
+      var originOwnerFor = originOwnerFor2;
+      const compOwner = resolveScssToComponent(entryFile, stylesDir, componentIds);
+      let compiled;
+      try {
+        compiled = sass2.compile(entryFile, { sourceMap: true });
+      } catch {
+        continue;
+      }
+      if (compOwner) {
+        const deps = compiled.loadedUrls.filter((u) => u.protocol === "file:").map((u) => fileURLToPath2(u)).filter((p) => resolve6(p) !== resolve6(entryFile));
+        for (const dep of deps) {
+          const depComp = resolveScssToComponent(dep, stylesDir, componentIds);
+          if (depComp !== null && depComp !== compOwner) {
+            const rawRel = relative3(stylesDir, dep).replace(/\.scss$/, "");
+            const modPath = rawRel.endsWith("/_index") ? rawRel.slice(0, -7) : rawRel;
+            if (modPath) {
+              const mArr = styleUsesModules.get(compOwner) ?? [];
+              if (!mArr.includes(modPath)) {
+                mArr.push(modPath);
+                styleUsesModules.set(compOwner, mArr);
+              }
+            }
+          } else if (depComp === null) {
+            const modPath = resolveSharedModulePath(dep, stylesDir);
+            if (modPath) {
+              const mArr = styleUsesModules.get(compOwner) ?? [];
+              if (!mArr.includes(modPath)) {
+                mArr.push(modPath);
+                styleUsesModules.set(compOwner, mArr);
+              }
+            }
+          }
+        }
+      }
+      const rawMap = compiled.sourceMap;
+      if (!rawMap) continue;
+      const consumer = new SourceMapConsumer(rawMap);
+      const root = postcss3.parse(compiled.css);
+      root.each((node) => {
+        const owner = originOwnerFor2(node);
+        if (owner === null) return;
+        const nodeText = node.toString();
+        if (owner === "__base__") {
+          baseCssBucket.add(nodeText);
+        } else {
+          const bucket = componentCssBuckets.get(owner) ?? /* @__PURE__ */ new Set();
+          bucket.add(nodeText);
+          componentCssBuckets.set(owner, bucket);
+        }
+      });
+      const { classMap: perFileClasses, baseModules: perFileBaseModules } = extractClassesFromCompiled(consumer, root, entryFile, stylesDir, componentIds);
+      for (const [name, owner] of perFileClasses) {
+        if (!classIndex.has(name)) classIndex.set(name, owner);
+      }
+      for (const [name, mod] of perFileBaseModules) {
+        if (!baseProvenance.has(name)) baseProvenance.set(name, mod);
+      }
+    }
+    baseCssByRoot[baseCssByRoot.length - 1] = [...baseCssBucket];
+  }
+  for (const [k, v] of styleUsesModules) styleUsesModules.set(k, [...new Set(v)].sort());
+  const componentCssMap = /* @__PURE__ */ new Map();
+  for (const [id, bucket] of componentCssBuckets) {
+    componentCssMap.set(id, [...bucket].join("\n"));
+  }
+  if (verboseTiming) console.timeEnd("[dev-server:timing] full classOwnerIndex build");
+  return {
+    scssModuleGraph: { styleUsesModules },
+    classOwnerIndex: classIndex,
+    baseProvenance,
+    componentCssMap,
+    // Packages' base rules first (later roots), the project's last — its own base wins the cascade.
+    baseCss: [...baseCssByRoot].reverse().flat().join("\n")
+  };
+}
+
+// packages/dev-server/src/css-closure.ts
+async function recomputeComponentCss(entryFile, compId, stylesDir, componentIds) {
+  try {
+    const compiled = sass3.compile(entryFile, { sourceMap: true });
+    const rawMap = compiled.sourceMap;
+    if (!rawMap) return null;
+    const consumer = new SourceMapConsumer2(rawMap);
+    const root = postcss4.parse(compiled.css);
+    const bucket = /* @__PURE__ */ new Set();
+    root.each((node) => {
+      const pos = node.source?.start;
+      if (!pos) return;
+      const original = consumer.originalPositionFor({ line: pos.line, column: pos.column - 1 });
+      if (!original.source) return;
+      const originPath = original.source.startsWith("file://") ? fileURLToPath3(original.source) : resolve7(dirname5(entryFile), original.source);
+      const originComp = resolveScssToComponent(originPath, stylesDir, componentIds);
+      if (originComp === compId) bucket.add(node.toString());
+    });
+    return [...bucket].join("\n");
+  } catch {
+    return null;
+  }
+}
+async function computeCssClosure(componentId, compReg, patternsDir, classOwnerIndex, discoveryMap) {
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  async function dfs(id) {
+    if (visited.has(id)) return;
+    visited.add(id);
+    const compUses = compReg.uses.get(id) ?? [];
+    const hbsPath = discoveryMap.get(id)?.hbsPath ?? "";
+    let hbs = "";
+    try {
+      hbs = hbsPath ? await readFile12(hbsPath, "utf-8") : "";
+    } catch {
+    }
+    const { styleUses } = deriveClassBorrowingFields(hbs, id, classOwnerIndex);
+    for (const dep of [.../* @__PURE__ */ new Set([...compUses, ...styleUses])]) {
+      await dfs(dep);
+    }
+    result.push(id);
+  }
+  await dfs(componentId);
+  return result;
+}
+function withRenderedClassOwners(closureIds, renderedHtml, classOwnerIndex) {
+  if (closureIds.length === 0) return closureIds;
+  const present = new Set(closureIds);
+  const extra = /* @__PURE__ */ new Set();
+  for (const cls of extractUsedClasses(renderedHtml)) {
+    const owner = classOwnerIndex.get(cls);
+    if (owner && owner !== "__base__" && !present.has(owner)) extra.add(owner);
+  }
+  if (extra.size === 0) return closureIds;
+  const self = closureIds[closureIds.length - 1];
+  return [...closureIds.slice(0, -1), ...[...extra].sort(), self];
+}
+function extractUsedClasses(hbsSource) {
+  const root = parseHtml2(hbsSource);
+  const classes = /* @__PURE__ */ new Set();
+  for (const el of root.querySelectorAll("[class]")) {
+    const raw = el.getAttribute("class") ?? "";
+    for (const token of raw.split(/\s+/)) {
+      if (token && !token.includes("{{") && !token.includes("}}")) {
+        classes.add(token);
+      }
+    }
+  }
+  return [...classes];
+}
+function deriveClassBorrowingFields(hbsSource, componentId, classOwnerIndex, baseProvenance) {
+  const usedClasses = extractUsedClasses(hbsSource);
+  const styleUses = [...new Set(
+    usedClasses.map((cls) => classOwnerIndex.get(cls)).filter((id) => id !== void 0 && id !== componentId && id !== "__base__")
+  )].sort();
+  const styleModules = baseProvenance ? [...new Set(
+    usedClasses.filter((cls) => classOwnerIndex.get(cls) === "__base__").map((cls) => baseProvenance.get(cls)).filter((m) => m !== void 0)
+  )].sort() : [];
+  const unattributedClasses = [...new Set(
+    usedClasses.filter((cls) => !classOwnerIndex.has(cls))
+  )].sort();
+  const utilityClasses = false;
+  const inlineStyles = /style\s*=|<style[\s>]/i.test(hbsSource);
+  return { styleUses, styleModules, inlineStyles, utilityClasses, unattributedClasses };
+}
+function linkableClosure(closureIds, perComponentCss) {
+  return closureIds.filter((id) => !!perComponentCss.get(id));
+}
+
+// packages/dev-server/src/requires.ts
+import { readFile as readFile13 } from "node:fs/promises";
+import { join as join14, basename as basename3 } from "node:path";
+function normalizeScriptId(raw) {
+  let s = raw.trim().replace(/^\[(.+)\]$/, "$1").trim();
+  s = basename3(s);
+  s = s.replace(/\.(ts|js)$/, "");
+  return s;
+}
+function parseFrontmatterList(md, key) {
+  const values = [];
+  const re = new RegExp(`^${key}:\\s*(.+)$`, "mg");
+  for (const [, val] of md.matchAll(re)) {
+    values.push(val.trim());
+  }
+  return values;
+}
+async function aggregateRequires(componentId, patternsDir, flatNameToPath, discoveryMap, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(componentId)) return { scripts: [], assets: [] };
+  visited.add(componentId);
+  const entry = discoveryMap.get(componentId);
+  let ownScripts = [];
+  let ownAssets = [];
+  if (entry?.mdPath) {
+    try {
+      const md = await readFile13(entry.mdPath, "utf-8");
+      ownScripts = parseFrontmatterList(md, "requireScript").map(normalizeScriptId);
+      ownAssets = parseFrontmatterList(md, "requireAssets").map((v) => v.trim().replace(/^\[(.+)\]$/, "$1").trim());
+    } catch {
+    }
+  }
+  const allScripts = [...ownScripts];
+  const allAssets = [...ownAssets];
+  const hbsPath = entry?.hbsPath ?? "";
+  let hbs = "";
+  try {
+    hbs = hbsPath ? await readFile13(hbsPath, "utf-8") : "";
+  } catch {
+  }
+  for (const flatName of parsePartialsFromHbs(hbs)) {
+    const childPath = flatNameToPath.get(flatName);
+    if (childPath) {
+      const child = await aggregateRequires(childPath, patternsDir, flatNameToPath, discoveryMap, visited);
+      allScripts.push(...child.scripts);
+      allAssets.push(...child.assets);
+    }
+  }
+  return {
+    scripts: [...new Set(allScripts)],
+    assets: [...new Set(allAssets)]
+  };
+}
+async function loadSvgAssets(ids, assetsDir) {
+  const contents = [];
+  for (const id of ids) {
+    for (const candidate of [`${id}.svg`, `images/${id}.svg`]) {
+      try {
+        const raw = await readFile13(join14(assetsDir, candidate), "utf-8");
+        contents.push(hideSvg(raw));
+        break;
+      } catch {
+      }
+    }
+  }
+  return contents;
+}
+function hideSvg(svg) {
+  return svg.replace(/<svg(\s|>)/, '<svg$1style="display:none;position:absolute" aria-hidden="true" ');
+}
+
+// packages/dev-server/src/detail.ts
+async function buildComponentDetail(componentId, patternsDir, renderFn, tracker, defaultTheme, flatNameToPath, compositionReg, scssGraph, classOwnerIndex, discoveryMap, baseProvenance) {
+  const parts = componentId.split("/");
+  const name = parts[parts.length - 1];
+  const category = parts[0];
+  const entry = discoveryMap?.get(componentId);
+  let title = name;
+  let description = "";
+  let status = "draft";
+  let deprecatedUse;
+  let rawMd = "";
+  if (entry?.mdPath) {
+    try {
+      rawMd = await readFile14(entry.mdPath, "utf-8");
+      const t = rawMd.match(/^title:\s*(.+)$/m);
+      const d = rawMd.match(/^description:\s*(.+)$/m);
+      const s = rawMd.match(/^status:\s*(.+)$/m);
+      const u = rawMd.match(/^deprecated-use:\s*(.+)$/m);
+      if (t) title = t[1].trim();
+      if (d) description = d[1].trim();
+      if (s) {
+        const sv = s[1].trim();
+        if (sv === "stable" || sv === "deprecated" || sv === "draft") status = sv;
+      }
+      if (u) deprecatedUse = u[1].trim();
+    } catch {
+    }
+  }
+  if (!rawMd && componentId.includes("~")) {
+    const baseId = componentId.split("~")[0];
+    const baseEntry = discoveryMap?.get(baseId);
+    if (baseEntry?.mdPath) {
+      try {
+        rawMd = await readFile14(baseEntry.mdPath, "utf-8");
+      } catch {
+      }
+    }
+  }
+  const layout = await resolveLayoutMode(componentId, patternsDir, discoveryMap);
+  const variantPrefix = `${componentId}~`;
+  const variants = discoveryMap ? [...discoveryMap.keys()].filter((id) => id.startsWith(variantPrefix)).map((id) => {
+    const variantToken = id.slice(variantPrefix.length);
+    return { name: variantToken };
+  }).sort((a, b) => a.name.localeCompare(b.name)) : [];
+  const hbsPath = entry?.hbsPath ?? "";
+  let hbs = "";
+  try {
+    hbs = hbsPath ? await readFile14(hbsPath, "utf-8") : "";
+  } catch {
+  }
+  const hbsHighlighted = wrapWithCopyButton(highlight(hbs, "handlebars"), hbs);
+  let jsonStr;
+  let jsonHighlighted;
+  if (entry?.jsonPath) {
+    try {
+      jsonStr = await readFile14(entry.jsonPath, "utf-8");
+      jsonHighlighted = wrapWithCopyButton(highlight(jsonStr, "json"), jsonStr);
+    } catch {
+    }
+  }
+  let schemaStr;
+  let schemaHighlighted;
+  if (entry?.schemaPath) {
+    try {
+      schemaStr = await readFile14(entry.schemaPath, "utf-8");
+      schemaHighlighted = wrapWithCopyButton(highlight(schemaStr, "json"), schemaStr);
+    } catch {
+    }
+  }
+  const source = {
+    hbs,
+    hbsHighlighted,
+    ...jsonStr !== void 0 ? { json: jsonStr, jsonHighlighted } : {},
+    ...schemaStr !== void 0 ? { schema: schemaStr, schemaHighlighted } : {},
+    ...rawMd ? { md: rawMd } : {}
+  };
+  const stripFrontmatter = rawMd.replace(/^---[\s\S]*?---\n?/, "").trim();
+  const doc = stripFrontmatter ? await renderDoc(
+    stripFrontmatter,
+    (id, variant) => renderFn({ component: id, variant }).then((r) => r.html),
+    discoveryMap ?? /* @__PURE__ */ new Map()
+  ) : void 0;
+  let requireScripts;
+  let requireAssets;
+  if (flatNameToPath && discoveryMap) {
+    const requires = await aggregateRequires(componentId, patternsDir, flatNameToPath, discoveryMap);
+    if (requires.scripts.length) requireScripts = requires.scripts;
+    if (requires.assets.length) requireAssets = requires.assets;
+  }
+  const classBorrowing = classOwnerIndex ? deriveClassBorrowingFields(hbs, componentId, classOwnerIndex, baseProvenance) : { styleUses: [], styleModules: [], inlineStyles: false, utilityClasses: false, unattributedClasses: [] };
+  const relationships = {
+    available: true,
+    uses: compositionReg?.uses.get(componentId) ?? [],
+    usedBy: compositionReg?.usedBy.get(componentId) ?? [],
+    styleUses: classBorrowing.styleUses,
+    styleUsesModules: scssGraph?.styleUsesModules.get(componentId) ?? [],
+    styleModules: classBorrowing.styleModules,
+    inlineStyles: classBorrowing.inlineStyles,
+    utilityClasses: classBorrowing.utilityClasses,
+    unattributedClasses: classBorrowing.unattributedClasses
+  };
+  return {
+    id: componentId,
+    title,
+    description,
+    category,
+    status,
+    layout,
+    ...deprecatedUse ? { deprecatedUse } : {},
+    variants,
+    source,
+    doc,
+    ...requireScripts ? { requireScripts } : {},
+    ...requireAssets ? { requireAssets } : {},
+    relationships,
+    diagnostics: []
+    // populated by the HTTP handler after render()
+  };
+}
+
+// packages/dev-server/src/overview.ts
+import { join as join15 } from "node:path";
+async function buildFolderOverview(folderPath, patternsDir, renderFn, discoveryMap) {
+  const category = folderPath.split("/")[0];
+  let folderLayout = FULL_CATEGORIES.has(category) ? "full" : "centered";
+  let doc;
+  try {
+    const rawIndex = await readFolderFile(patternsDir, join15(folderPath, "index.md"));
+    if (rawIndex === null) throw new Error("no index.md");
+    const m = rawIndex.match(/^preview:\s*(centered|full)$/m);
+    if (m) folderLayout = m[1];
+    const stripped = rawIndex.replace(/^---[\s\S]*?---\n?/, "").trim();
+    if (stripped) {
+      doc = await renderDoc(
+        stripped,
+        (id, variant) => renderFn({ component: id, variant }).then((r) => r.html),
+        discoveryMap
+      );
+    }
+  } catch {
+  }
+  const components = await collectPublicLeaves(folderPath, patternsDir, discoveryMap);
+  return { path: folderPath, doc, layout: folderLayout, components };
+}
+async function collectPublicLeaves(folderPath, patternsDir, discoveryMap) {
+  const root = await buildSubtree(folderPath, patternsDir, discoveryMap);
+  const items = [];
+  const walk = (node) => {
+    if (node.kind === "component" && node.visibility !== "private") {
+      items.push({
+        id: node.path,
+        title: node.title,
+        status: node.status ?? "draft",
+        layout: node.layout ?? "centered",
+        ...node.source ? { source: node.source } : {}
+      });
+    }
+    node.children?.forEach(walk);
+  };
+  if (root) walk(root);
+  return items;
+}
+
+// packages/dev-server/src/preview-document.ts
+import { stat as stat3 } from "node:fs/promises";
+import { join as join16 } from "node:path";
+async function buildScriptVersions(ids, dirs) {
+  const map = /* @__PURE__ */ new Map();
+  await Promise.all(ids.map(async (id) => {
+    for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
+      try {
+        const { mtimeMs } = await stat3(join16(dir, `${id}.ts`));
+        map.set(id, mtimeMs);
+        return;
+      } catch {
+      }
+    }
+  }));
+  return map;
+}
+function buildPreviewDocument(html, closureIds, layout, themeNames, defaultTheme, requireScripts, svgContents, assetsCss, componentId, baseHref, scriptVersions, linkBase = false, themeSwitch = "attribute") {
+  const bodyAttr = defaultTheme ? ` data-theme="${escapeAttr(defaultTheme)}"` : "";
+  const layoutClass = layout === "full" ? "layout-full" : "layout-centered";
+  const widthPost = layout === "centered" ? `window.parent.postMessage({type:'pd-width',width:(function(){var m=document.querySelector('main')||document.body,cs=getComputedStyle(document.body);return Math.ceil(m.scrollWidth+(parseFloat(cs.marginLeft)||0)+(parseFloat(cs.marginRight)||0));}())},'*');` : "";
+  const heightMeasure = `document.documentElement.scrollHeight`;
+  const resizeScript = layout === "centered" || layout === "full" ? `<script>(function(){var _t;new ResizeObserver(function(){clearTimeout(_t);_t=setTimeout(function(){window.parent.postMessage({type:'pd-height',height:${heightMeasure}},'*');${widthPost}},50);}).observe(document.body);})();</script>` : "";
+  const baseTag = baseHref ? `<base href="${escapeAttr(baseHref)}">` : "";
+  const baseLink = linkBase ? `<link rel="stylesheet" href="${PD_ROUTES.baseCss}">` : "";
+  const assetCssLinks = (assetsCss ?? []).map((p) => `<link rel="stylesheet" href="/assets/${p}">`).join("\n");
+  const themeLinks = themeSwitch === "stylesheet" ? defaultTheme ? `<link rel="stylesheet" href="${themeCssUrl(defaultTheme)}" data-pd-theme="${escapeAttr(defaultTheme)}">` : "" : themeNames.map((n) => `<link rel="stylesheet" href="${themeCssUrl(n)}">`).join("\n");
+  const closureLinks = closureIds.map((id) => `<link rel="stylesheet" href="${componentCssUrl(id)}" data-pd-comp="${escapeAttr(id)}">`).join("\n");
+  const symbolSets = (svgContents ?? []).join("\n");
+  const scriptTags = (requireScripts ?? []).map((src) => {
+    if (src.includes("://")) return `<script type="module" src="${src}"></script>`;
+    const v = scriptVersions?.get(src);
+    return `<script type="module" src="${scriptUrl(src, v ?? void 0)}"></script>`;
+  }).join("\n");
+  const componentAttr = componentId ? ` data-component-id="${escapeAttr(componentId)}"` : "";
+  const layoutStyle = layout === "full" ? ' style="width:100%;max-width:none"' : ' style="max-width:max-content;margin-inline:auto"';
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+${baseTag}${baseLink}
+${assetCssLinks}
+${themeLinks}
+${closureLinks}
+</head>
+<body${bodyAttr}>
+${symbolSets}
+<main class="${layoutClass}"${layoutStyle}${componentAttr}>${html}</main>
+${resizeScript}
+${scriptTags}
+</body>
+</html>`;
+}
+function normalizeAssetRefs(html, rootNames) {
+  if (rootNames.length === 0) return html;
+  const alt = rootNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return html.replace(new RegExp(`(?:\\.\\.?/)+(${alt})/`, "g"), "/assets/$1/");
+}
+
+// packages/dev-server/src/assets.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+function resolveDevUiDist(moduleUrl, exists = existsSync2) {
+  const packaged = fileURLToPath4(new URL("./dev-ui/", moduleUrl));
+  if (exists(`${packaged}main.js`)) return packaged;
+  return fileURLToPath4(new URL("../../../apps/dev-ui/dist/", moduleUrl));
+}
+function resolveAxeCore(moduleUrl) {
+  return createRequire2(moduleUrl).resolve("axe-core/axe.min.js");
+}
+
+// packages/dev-server/src/routes.ts
+async function handleRequest(req, res, ctx) {
+  const { cfg, state, render, tracker, globalData, devUiDist: devUiDist2 } = ctx;
+  const {
+    patternRoots,
+    patternDirs,
+    styleRoots,
+    themesDir,
+    defaultTheme,
+    assetRoots,
+    assetRootNames,
+    assetsDir,
+    assetsCss,
+    scriptsDirs,
+    withGlobalScripts,
+    overviewsEnabled,
+    documentBaseEnabled,
+    themeSwitch,
+    config,
+    cwd,
+    wsPort
+  } = cfg;
+  res.setHeader(PD_PROTOCOL_HEADER, String(PD_PROTOCOL_VERSION));
+  try {
+    const url = new URL(req.url ?? "/", "http://x");
+    const pathname = url.pathname;
+    if (pathname === PD_ROUTES.mainJs) {
+      return await serveFile(res, join17(devUiDist2, "main.js"), "application/javascript");
+    }
+    if (pathname === PD_ROUTES.mainCss) {
+      return await serveFile(res, join17(devUiDist2, "main.css"), "text/css");
+    }
+    if (pathname === PD_ROUTES.axeCore) {
+      return await serveFile(res, resolveAxeCore(import.meta.url), "application/javascript");
+    }
+    if (pathname === PD_ROUTES.ruleTiers) {
+      json(res, 200, rule_tiers_generated_default);
+      return;
+    }
+    if (pathname === PD_ROUTES.shikiCss) {
+      const css = getShikiCSS();
+      res.writeHead(200, { "Content-Type": "text/css" });
+      res.end(css);
+      return;
+    }
+    if (pathname === PD_ROUTES.baseCss) {
+      res.writeHead(200, { "Content-Type": "text/css" });
+      res.end(state.baseCss);
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.componentCss) && pathname.endsWith(".css")) {
+      const componentId = pathname.slice(PD_ROUTE_PREFIX.componentCss.length, -".css".length);
+      const css = state.perComponentCss.get(componentId) ?? "";
+      res.writeHead(200, { "Content-Type": "text/css" });
+      res.end(css);
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.themeCss) && pathname.endsWith(".css")) {
+      if (!themesDir) {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const themeName = decodeURIComponent(
+        basename4(pathname, ".css")
+      );
+      if (state.themeCss.has(themeName)) {
+        res.writeHead(200, { "Content-Type": "text/css" });
+        res.end(state.themeCss.get(themeName));
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Theme not found");
+      }
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.script) && pathname.endsWith(".js")) {
+      if (scriptsDirs.length === 0) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("No scriptsDir configured");
+        return;
+      }
+      const scriptId = normalizeScriptId(decodeURIComponent(basename4(pathname, ".js")));
+      try {
+        if (!state.scriptCache.has(scriptId)) {
+          const entryPoint = scriptsDirs.map((d) => join17(d, `${scriptId}.ts`)).find((f) => existsSync3(f)) ?? join17(scriptsDirs[0], `${scriptId}.ts`);
+          const js = await compileScriptFile(entryPoint);
+          state.scriptCache.set(scriptId, js);
+        }
+        res.writeHead(200, { "Content-Type": "application/javascript" });
+        res.end(state.scriptCache.get(scriptId));
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end(`Script compile error: ${String(e)}`);
+      }
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.assets) && assetRoots.length > 0) {
+      const tail = decodeURIComponent(pathname.slice(PD_ROUTE_PREFIX.assets.length));
+      const firstSeg = tail.split("/")[0];
+      const namedIdx = assetRootNames.indexOf(firstSeg);
+      const assetPath = namedIdx >= 0 ? join17(assetRoots[namedIdx], tail.slice(firstSeg.length + 1)) : join17(assetRoots[0], tail);
+      try {
+        await stat4(assetPath);
+        return await serveFile(res, assetPath, mimeType(extname2(assetPath)));
+      } catch {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Asset not found");
+        return;
+      }
+    }
+    if (pathname === PD_ROUTES.tree) {
+      if (!state.discoveryResult) state.discoveryResult = await buildDiscoveryMap(patternRoots);
+      const tree = await buildComponentTree(patternDirs, overviewsEnabled, state.discoveryResult.discoveryMap);
+      json(res, 200, tree);
+      return;
+    }
+    if (pathname === PD_ROUTES.audit) {
+      try {
+        if (!state.discoveryResult) state.discoveryResult = await buildDiscoveryMap(patternRoots);
+        const discoveryMap = state.discoveryResult.discoveryMap;
+        let graph;
+        if (!state.auditSlices) {
+          if (verboseTiming) console.time("[dev-server:timing] diagnostics seed");
+          const r = await refreshDiagnosticsGraph(
+            cwd,
+            baseComponentIds(state.discoveryResult),
+            render,
+            state.discoveryResult.quarantineMap,
+            discoveryMap,
+            globalData
+          );
+          state.auditSlices = r.slices;
+          graph = r.graph;
+          if (verboseTiming) {
+            console.timeEnd("[dev-server:timing] diagnostics seed");
+            console.log(`[dev-server:timing] diagnostics seed: re-audited ${r.reaudited.length}, reused ${r.reused} (of ${state.auditSlices.size})`);
+          }
+        } else {
+          graph = assembleGraph([...state.auditSlices.values()]);
+          await persistSlices(cwd, state.auditSlices, discoveryMap, globalData);
+        }
+        json(res, 200, { ...graph, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), _liveReaudits: state.liveReauditCount });
+      } catch (e) {
+        json(res, 500, { error: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.component)) {
+      const componentId = pathname.slice(PD_ROUTE_PREFIX.component.length);
+      const variant = url.searchParams.get("variant") ?? void 0;
+      state.lastComponentId = componentId;
+      try {
+        if (!state.discoveryResult) state.discoveryResult = await buildDiscoveryMap(patternRoots);
+        const { handleMap } = state.discoveryResult;
+        if (state.scssGraphDirty) {
+          const ids = baseComponentIds(state.discoveryResult);
+          const styleData = await buildAllStyleData(styleRoots, ids);
+          state.scssModuleGraph = styleData.scssModuleGraph;
+          state.classOwnerIndex = styleData.classOwnerIndex;
+          state.baseProvenance = styleData.baseProvenance;
+          state.perComponentCss = styleData.componentCssMap;
+          state.baseCss = styleData.baseCss;
+          state.scssGraphDirty = false;
+        }
+        if (!state.compositionRegistry) {
+          state.compositionRegistry = await buildCompositionRegistry(patternDirs, handleMap, state.discoveryResult.discoveryMap);
+        }
+        const compReg = state.compositionRegistry;
+        const detail = await buildComponentDetail(
+          componentId,
+          patternDirs,
+          render,
+          tracker,
+          defaultTheme,
+          handleMap,
+          compReg,
+          state.scssModuleGraph ?? void 0,
+          state.classOwnerIndex ?? void 0,
+          state.discoveryResult.discoveryMap,
+          state.baseProvenance ?? void 0
+        );
+        const quarantineEntry = state.discoveryResult.quarantineMap.get(componentId);
+        const { previewHtml, diagnostics } = await checkComponent(componentId, variant, render, quarantineEntry);
+        const themeNames = themesDir ? [...state.themeCss.keys()] : [];
+        const svgContents = detail.requireAssets && assetsDir ? await loadSvgAssets(detail.requireAssets, assetsDir) : [];
+        const closureIds = withRenderedClassOwners(await computeCssClosure(
+          componentId,
+          compReg,
+          patternDirs,
+          state.classOwnerIndex ?? /* @__PURE__ */ new Map(),
+          state.discoveryResult.discoveryMap
+        ), previewHtml, state.classOwnerIndex ?? /* @__PURE__ */ new Map());
+        const previewScripts = withGlobalScripts(detail.requireScripts);
+        const scriptVersions = scriptsDirs.length && previewScripts.length ? await buildScriptVersions(previewScripts, scriptsDirs) : void 0;
+        const previewDoc = buildPreviewDocument(
+          normalizeAssetRefs(previewHtml, assetRootNames),
+          linkableClosure(closureIds, state.perComponentCss),
+          detail.layout,
+          themeNames,
+          defaultTheme,
+          previewScripts,
+          svgContents,
+          assetsCss,
+          componentId,
+          void 0,
+          scriptVersions,
+          documentBaseEnabled,
+          themeSwitch
+        );
+        json(res, 200, { ...detail, document: previewDoc, diagnostics });
+      } catch (e) {
+        json(res, 404, { error: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.overview)) {
+      const folderPath = pathname.slice(PD_ROUTE_PREFIX.overview.length);
+      try {
+        if (!state.discoveryResult) state.discoveryResult = await buildDiscoveryMap(patternRoots);
+        const overview = await buildFolderOverview(folderPath, patternDirs, render, state.discoveryResult.discoveryMap);
+        json(res, 200, overview);
+      } catch (e) {
+        json(res, 404, { error: e instanceof Error ? e.message : String(e) });
+      }
+      return;
+    }
+    if (pathname === PD_ROUTES.themes) {
+      const themes = cfg.themeDirs.length ? await discoverThemes(cfg.themeDirs) : [];
+      const enriched = themes.map((t) => ({
+        ...t,
+        tokens: state.themeTokens.get(t.name)
+      }));
+      json(res, 200, enriched);
+      return;
+    }
+    if (pathname === PD_ROUTES.version) {
+      json(res, 200, {
+        startedAt: ctx.boot.startedAt,
+        serverBundleMtime: ctx.boot.serverBundleMtime,
+        protocol: PD_PROTOCOL_VERSION
+      });
+      return;
+    }
+    if (pathname === PD_ROUTES.config) {
+      json(res, 200, { shell: config.shell ?? null, themeSwitch, defaultTheme: defaultTheme ?? "" });
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.preview)) {
+      const componentId = pathname.slice(PD_ROUTE_PREFIX.preview.length);
+      const variant = url.searchParams.get("variant") ?? void 0;
+      const themeParam = url.searchParams.get("theme") ?? void 0;
+      const knownThemes = themesDir ? [...state.themeCss.keys()] : [];
+      const effectiveTheme = themeParam && knownThemes.includes(themeParam) ? themeParam : defaultTheme;
+      try {
+        if (!state.discoveryResult) state.discoveryResult = await buildDiscoveryMap(patternRoots);
+        const { handleMap: previewHandleMap, discoveryMap: previewDiscoveryMap } = state.discoveryResult;
+        const [{ html }, layout] = await Promise.all([
+          render({ component: componentId, variant }),
+          resolveLayoutMode(componentId, patternDirs, previewDiscoveryMap)
+        ]);
+        const themeNames = themesDir ? [...state.themeCss.keys()] : [];
+        if (!state.compositionRegistry) {
+          state.compositionRegistry = await buildCompositionRegistry(patternDirs, previewHandleMap, previewDiscoveryMap);
+        }
+        const requires = await aggregateRequires(componentId, patternDirs, previewHandleMap, previewDiscoveryMap);
+        const svgContents = assetsDir ? await loadSvgAssets(requires.assets, assetsDir) : [];
+        const closureIds = withRenderedClassOwners(await computeCssClosure(
+          componentId,
+          state.compositionRegistry,
+          patternDirs,
+          state.classOwnerIndex ?? /* @__PURE__ */ new Map(),
+          previewDiscoveryMap
+        ), html, state.classOwnerIndex ?? /* @__PURE__ */ new Map());
+        const previewScripts = withGlobalScripts(requires.scripts);
+        const scriptVersions = scriptsDirs.length && previewScripts.length ? await buildScriptVersions(previewScripts, scriptsDirs) : void 0;
+        const doc = buildPreviewDocument(
+          normalizeAssetRefs(html, assetRootNames),
+          linkableClosure(closureIds, state.perComponentCss),
+          layout,
+          themeNames,
+          effectiveTheme,
+          previewScripts,
+          svgContents,
+          assetsCss,
+          componentId,
+          void 0,
+          scriptVersions,
+          documentBaseEnabled,
+          themeSwitch
+        );
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(doc);
+      } catch (e) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end(`Render error: ${String(e)}`);
+      }
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.source) && pathname.endsWith("/rendered")) {
+      const componentId = pathname.slice(PD_ROUTE_PREFIX.source.length, -"/rendered".length);
+      const variant = url.searchParams.get("variant") ?? void 0;
+      try {
+        const { html } = await render({ component: componentId, variant });
+        const highlighted = wrapWithCopyButton(highlight(html, "html"), html);
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(highlighted);
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end(`Render error: ${String(e)}`);
+      }
+      return;
+    }
+    if (pathname.startsWith(PD_ROUTE_PREFIX.source) && pathname.endsWith("/data")) {
+      const componentId = pathname.slice(PD_ROUTE_PREFIX.source.length, -"/data".length);
+      const variant = url.searchParams.get("variant") ?? void 0;
+      try {
+        if (!state.discoveryResult) state.discoveryResult = await buildDiscoveryMap(patternRoots);
+        const lookupId = variant ? `${componentId}~${variant}` : componentId;
+        const jsonFile = state.discoveryResult.discoveryMap.get(lookupId)?.jsonPath;
+        if (!jsonFile) throw new Error(`No data file for ${lookupId}`);
+        const jsonStr = await readFile15(jsonFile, "utf-8");
+        const highlighted = wrapWithCopyButton(highlight(jsonStr, "json"), jsonStr);
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(highlighted);
+      } catch (e) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end(`Data file not found: ${String(e)}`);
+      }
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(buildShellHtml({ mode: "live", wsPort }));
+  } catch (e) {
+    console.error("[dev-server] Unhandled request error:", e);
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end("Internal Server Error");
+  }
+}
+
+// packages/dev-server/src/ports.ts
+var PortInUseError = class extends Error {
+  constructor(port2, message) {
+    super(message);
+    this.port = port2;
+    this.name = "PortInUseError";
+  }
+  port;
+  code = "EADDRINUSE";
+};
+var isAddressInUse = (e) => typeof e === "object" && e !== null && e.code === "EADDRINUSE";
+function describeBindError(e, port2, role, ports) {
+  if (!isAddressInUse(e)) return e;
+  const what = role === "workbench" ? "the workbench" : "live reload";
+  const advice = role === "live reload" && ports.wsChosen ? "pd dev --ws-port <a free port>" : `pd dev --port ${ports.http + 100}   (live reload then uses ${ports.http + 101})`;
+  return new PortInUseError(
+    port2,
+    `Port ${port2} is already in use, so ${what} cannot start. Another \`pd dev\` is probably still running \u2014 stop it, or start this one on other ports:
+  ${advice}`
+  );
+}
+
+// packages/dev-server/src/watch.ts
+import { basename as basename5, extname as extname3, relative as relative4, resolve as resolve8 } from "node:path";
+import chokidar from "chokidar";
+function startWatching(ctx) {
+  const { cfg, state, render, tracker, hotreloader } = ctx;
+  const { patternsDir, stylesDir, patternRoots, patternDirs, swatchSlots, cwd } = cfg;
+  const themesDir = cfg.config.themes ? cfg.themesDir : null;
+  const scriptsDir = cfg.config.scriptsDir ? cfg.scriptsDirs[0] ?? null : null;
+  const watchDirs = [patternsDir, stylesDir, ...themesDir ? [themesDir] : [], ...scriptsDir ? [scriptsDir] : []];
+  const watcher = chokidar.watch(watchDirs, { ignoreInitial: true, persistent: true });
+  async function handleComponentScss(filePath) {
+    let recompiledFiles;
+    let compileErrors;
+    try {
+      ({ recompiledFiles, errors: compileErrors } = await tracker.update(filePath));
+    } catch (e) {
+      hotreloader.push({ type: "error", scope: "build", message: `SCSS error: ${String(e)}` });
+      console.error("[dev-server] SCSS error:", e);
+      return;
+    }
+    for (const { file, message } of compileErrors) {
+      hotreloader.push({
+        type: "error",
+        scope: "build",
+        message: `SCSS ${basename5(file)} \u2014 ${message.split("\n")[0]}`
+      });
+    }
+    state.scssGraphDirty = true;
+    if (!state.discoveryResult) state.discoveryResult = await buildDiscoveryMap(patternRoots);
+    const allIds = baseComponentIds(state.discoveryResult);
+    const timestamp = Date.now();
+    const effectiveFiles = recompiledFiles.length > 0 ? recompiledFiles : [resolve8(filePath)];
+    const pending = [];
+    for (const recompiledFile of effectiveFiles) {
+      const compId = resolveScssToComponent(resolve8(recompiledFile), stylesDir, allIds);
+      if (compId) {
+        const newCss = await recomputeComponentCss(recompiledFile, compId, stylesDir, allIds);
+        if (newCss !== null) {
+          state.perComponentCss.set(compId, newCss);
+          pending.push({
+            type: "css-link-swap",
+            componentId: compId,
+            href: componentCssUrl(compId, timestamp)
+          });
+        }
+      }
+    }
+    if (state.classOwnerIndex) {
+      if (verboseTiming) console.time("[dev-server:timing] classOwnerIndex patch");
+      for (const recompiledFile of effectiveFiles) {
+        const compId = resolveScssToComponent(resolve8(recompiledFile), stylesDir, allIds);
+        if (compId) {
+          await patchClassOwnerIndex(
+            resolve8(recompiledFile),
+            compId,
+            stylesDir,
+            allIds,
+            state.classOwnerIndex
+          );
+        }
+      }
+      if (verboseTiming) console.timeEnd("[dev-server:timing] classOwnerIndex patch");
+    }
+    let orderedHrefs;
+    if (state.lastComponentId && state.discoveryResult && state.compositionRegistry) {
+      const staticClosure = await computeCssClosure(
+        state.lastComponentId,
+        state.compositionRegistry,
+        patternDirs,
+        state.classOwnerIndex ?? /* @__PURE__ */ new Map(),
+        state.discoveryResult.discoveryMap
+      );
+      const renderedHtml = await render({ component: state.lastComponentId }).then((r) => r.html, () => "");
+      const closureIds = withRenderedClassOwners(staticClosure, renderedHtml, state.classOwnerIndex ?? /* @__PURE__ */ new Map());
+      orderedHrefs = linkableClosure(closureIds, state.perComponentCss).map((id) => componentCssUrl(id, timestamp));
+    }
+    for (const m of pending) hotreloader.push({ ...m, orderedHrefs });
+    console.log(`[dev-server] CSS updated (recompiled: ${effectiveFiles.map((f) => basename5(f)).join(", ")})`);
+  }
+  async function handleMarkdown(filePath, event) {
+    const abs = resolve8(filePath);
+    const ownerIn = (dr) => {
+      for (const [id, entry] of dr?.discoveryMap ?? []) {
+        if (entry.mdPath && resolve8(entry.mdPath) === abs) return id.split("~")[0];
+      }
+      return void 0;
+    };
+    const rel = relative4(patternsDir, filePath);
+    if (event === "change") state.discoveryResult ??= await buildDiscoveryMap(patternRoots);
+    let owner = ownerIn(state.discoveryResult);
+    if (event === "change") {
+      hotreloader.push({ type: "tree-changed" });
+      console.log(`[dev-server] Docs changed: ${rel} \u2192 tree-changed`);
+    } else {
+      await rebuildAndSignalTree(`Docs ${event === "add" ? "added" : "removed"}: ${rel}`);
+      owner ??= ownerIn(state.discoveryResult);
+    }
+    for (const componentId of /* @__PURE__ */ new Set([owner, state.lastComponentId])) {
+      if (componentId) hotreloader.push({ type: "content-swap", componentId });
+    }
+  }
+  watcher.on("change", async (filePath) => {
+    const ext = extname3(filePath);
+    if (ext === ".md" && filePath.startsWith(patternsDir)) {
+      await handleMarkdown(filePath, "change");
+      return;
+    }
+    if (ext === ".scss") {
+      if (themesDir && filePath.startsWith(themesDir)) {
+        const themeName = basename5(filePath, ".theme.scss");
+        try {
+          const css = await compileSassFile(filePath);
+          state.themeCss.set(themeName, css);
+          state.themeTokens.set(themeName, await extractThemeTokens(themeName, css, swatchSlots, themesDir));
+          hotreloader.push({ type: "content-swap", componentId: state.lastComponentId });
+          console.log(`[dev-server] Theme CSS updated: ${themeName}`);
+        } catch (e) {
+          hotreloader.push({ type: "error", scope: "build", message: `SCSS error: ${String(e)}` });
+        }
+      } else {
+        await handleComponentScss(filePath);
+      }
+    } else if (ext === ".hbs" || ext === ".json") {
+      const componentId = state.discoveryResult ? resolveComponentForFile(filePath, state.discoveryResult) : null;
+      state.discoveryResult = null;
+      state.compositionRegistry = null;
+      if (!componentId) {
+        console.warn(`[dev-server] Could not resolve component for: ${filePath}`);
+        return;
+      }
+      try {
+        await render({ component: componentId });
+        hotreloader.push({ type: "content-swap", componentId });
+        console.log(`[dev-server] Component changed: ${componentId}`);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        hotreloader.push({ type: "error", scope: "render", componentId, message: msg });
+        console.error(`[dev-server] Render error [${componentId}]:`, msg);
+      }
+      if (state.auditSlices) {
+        state.auditSlices.set(componentId, await auditComponent(componentId, render, void 0));
+        state.liveReauditCount += 1;
+        if (verboseTiming) console.log(`[dev-server:timing] diagnostics: live re-audit ${componentId} (1 component; total ${state.liveReauditCount})`);
+      }
+    } else if (ext === ".ts" && scriptsDir && filePath.startsWith(scriptsDir)) {
+      const scriptId = basename5(filePath, ".ts");
+      state.scriptCache.delete(scriptId);
+      if (state.lastComponentId) {
+        hotreloader.push({ type: "content-swap", componentId: state.lastComponentId });
+      }
+      console.log(`[dev-server] Script changed: ${scriptId} \u2192 srcdoc reload dispatched`);
+    }
+  });
+  async function rebuildAndSignalTree(label) {
+    const dr = await buildDiscoveryMap(patternRoots);
+    state.discoveryResult = dr;
+    state.compositionRegistry = null;
+    state.auditSlices = null;
+    await surfaceCollisions(dr.collisions, cwd, hotreloader);
+    const reg = await buildCompositionRegistry(patternDirs, dr.handleMap, dr.discoveryMap);
+    await surfaceFlattening(dr.discoveryMap, reg, cwd);
+    hotreloader.push({ type: "tree-changed" });
+    console.log(`[dev-server] ${label} \u2192 tree-changed`);
+  }
+  watcher.on("add", async (filePath) => {
+    const ext = extname3(filePath);
+    if (ext === ".scss" && !(themesDir && filePath.startsWith(themesDir))) {
+      await handleComponentScss(filePath);
+    } else if (ext === ".hbs" && filePath.startsWith(patternsDir)) {
+      await rebuildAndSignalTree(`Pattern added: ${relative4(patternsDir, filePath)}`);
+    } else if (ext === ".md" && filePath.startsWith(patternsDir)) {
+      await handleMarkdown(filePath, "add");
+    }
+  });
+  watcher.on("unlink", async (filePath) => {
+    if (extname3(filePath) === ".hbs" && filePath.startsWith(patternsDir)) {
+      await rebuildAndSignalTree(`Pattern removed: ${relative4(patternsDir, filePath)}`);
+    } else if (extname3(filePath) === ".md" && filePath.startsWith(patternsDir)) {
+      await handleMarkdown(filePath, "unlink");
+    }
+  });
+  watcher.on("unlinkDir", async (dirPath) => {
+    if (dirPath.startsWith(patternsDir) && dirPath !== patternsDir) {
+      await rebuildAndSignalTree(`Pattern dir removed: ${relative4(patternsDir, dirPath)}`);
+    }
+  });
+  return watcher;
+}
+
+// packages/dev-server/src/export-io.ts
+import { readFile as readFile16, writeFile as writeFile4, mkdir as mkdir4 } from "node:fs/promises";
+import { dirname as dirname6, join as join18, relative as relative5, resolve as resolve9 } from "node:path";
+
+// packages/dev-server/src/export.ts
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var idFolder = (id) => {
+  const i = id.lastIndexOf("/");
+  return i < 0 ? "" : id.slice(0, i);
+};
+var idStem = (id) => {
+  const i = id.lastIndexOf("/");
+  return i < 0 ? id : id.slice(i + 1);
+};
+function deriveFamilyNaming(members) {
+  const folders = new Set(members.map((m) => idFolder(m.relPath)));
+  if (folders.size !== 1) return null;
+  const folder = [...folders][0];
+  const stems = members.map((m) => idStem(m.relPath));
+  let lcp = stems[0];
+  for (const s of stems.slice(1)) {
+    let i = 0;
+    while (i < lcp.length && i < s.length && lcp[i] === s[i]) i++;
+    lcp = lcp.slice(0, i);
+  }
+  const dash = lcp.lastIndexOf("-");
+  const baseStem = dash > 0 ? lcp.slice(0, dash) : lcp;
+  const tokens = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    const stem = idStem(m.relPath);
+    const rest = stem === baseStem ? "" : stem.slice(baseStem.length).replace(/^-/, "");
+    tokens.set(m.id, rest);
+  }
+  const folderBase = idStem(folder);
+  const baseId = folder === "" ? baseStem : folderBase === baseStem ? folder : `${folder}/${baseStem}`;
+  return { baseId, tokens };
+}
+function analyzeRootClass(hbs, root) {
+  const m = hbs.match(new RegExp(`class="([^"]*\\b${escapeRe(root)}\\b[^"]*)"`));
+  if (!m) return null;
+  const value = m[1];
+  const hbsTail = (value.match(/\{\{[^}]*\}\}/g) ?? []).join("");
+  const staticMods = value.replace(/\{\{[^}]*\}\}/g, " ").split(/\s+/).filter(Boolean).filter((t) => t !== root);
+  return { attr: m[0], staticMods, hbsTail };
+}
+function collapseFamily(cluster, members) {
+  const naming = deriveFamilyNaming(members);
+  if (!naming) return { skip: "cross-folder" };
+  const root = cluster.root;
+  const byId = new Map(members.map((m) => [m.id, m.hbs]));
+  const analyses = /* @__PURE__ */ new Map();
+  let tail0 = null;
+  for (const id of cluster.members) {
+    const hbs = byId.get(id) ?? "";
+    const a = analyzeRootClass(hbs, root);
+    if (!a) return { skip: "not-lossless-shape-a" };
+    if (tail0 === null) tail0 = a.hbsTail;
+    else if (a.hbsTail !== tail0) return { skip: "not-lossless-shape-a" };
+    const normalized = hbs.replace(a.attr, `class="${root}${a.hbsTail}"`);
+    analyses.set(id, { staticMods: a.staticMods, hbsTail: a.hbsTail, normalized });
+  }
+  const normSet = new Set([...analyses.values()].map((v) => v.normalized));
+  if (normSet.size !== 1) return { skip: "not-lossless-shape-a" };
+  const base0 = byId.get(cluster.members[0]) ?? "";
+  const a0 = analyzeRootClass(base0, root);
+  const baseHbs = base0.replace(a0.attr, `class="${root}{{ modifier }}${a0.hbsTail}"`);
+  const dataById = new Map(members.map((m) => [m.id, parseData(m.dataJson)]));
+  const baseDefaultId = cluster.members.find((id) => (naming.tokens.get(id) ?? "") === "");
+  const baseData = baseDefaultId ? dataById.get(baseDefaultId) : {};
+  const variants = cluster.members.map((id) => {
+    const mods = analyses.get(id).staticMods;
+    const token = naming.tokens.get(id) ?? "";
+    const delta = token === "" ? {} : topLevelDelta(dataById.get(id), baseData);
+    return {
+      token,
+      sourceId: id,
+      modifier: mods.length ? " " + mods.join(" ") : "",
+      ...Object.keys(delta).length ? { data: delta } : {}
+    };
+  });
+  return { family: { baseId: naming.baseId, root, baseHbs, ...Object.keys(baseData).length ? { baseData } : {}, variants } };
+}
+function buildRewriteMap(families) {
+  const map = /* @__PURE__ */ new Map();
+  for (const fam of families) {
+    const baseHandle = deriveHandle(fam.baseId);
+    for (const v of fam.variants) {
+      map.set(deriveHandle(v.sourceId), { baseHandle, modifier: v.modifier });
+    }
+  }
+  return map;
+}
+function rewriteIncludes(hbs, map) {
+  let rewrites = 0;
+  const blockRenames = /* @__PURE__ */ new Map();
+  let out = hbs.replace(
+    /(\{\{~?)(#?)>(\s*)("[^"]+"|[^\s}"]+)([\s\S]*?)(~?\}\})/g,
+    (full, open, hash, _ws, rawName, rest, close) => {
+      const bare = rawName.replace(/^"|"$/g, "");
+      const hit = map.get(bare);
+      if (!hit) return full;
+      rewrites++;
+      if (hash === "#") blockRenames.set(bare, hit.baseHandle);
+      const existing = rest.trim();
+      const merged = [existing, `modifier="${hit.modifier}"`].filter(Boolean).join(" ");
+      return `${open}${hash}> ${hit.baseHandle} ${merged}${close}`;
+    }
+  );
+  if (blockRenames.size) {
+    out = out.replace(
+      /(\{\{~?)\/(\s*)("[^"]+"|[^\s}"]+)(\s*~?\}\})/g,
+      (full, open, _ws, rawName, close) => {
+        const bare = rawName.replace(/^"|"$/g, "");
+        const base2 = blockRenames.get(bare);
+        return base2 ? `${open}/${base2}${close}` : full;
+      }
+    );
+  }
+  return { hbs: out, rewrites };
+}
+function parseData(raw) {
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function topLevelDelta(variant, base2) {
+  const out = {};
+  for (const [k, v] of Object.entries(variant)) {
+    if (JSON.stringify(v) !== JSON.stringify(base2[k])) out[k] = v;
+  }
+  return out;
+}
+
+// packages/dev-server/src/export-io.ts
+async function planExport(config, cwd) {
+  const patternsDir = resolve9(cwd, config.patternsDir);
+  const discovery = await buildDiscoveryMap(patternsDir);
+  const registry = await buildCompositionRegistry(patternsDir, discovery.handleMap, discovery.discoveryMap);
+  const inputs = [];
+  const hbsById = /* @__PURE__ */ new Map();
+  const relPathById = /* @__PURE__ */ new Map();
+  const dataJsonById = /* @__PURE__ */ new Map();
+  for (const [id, entry] of discovery.discoveryMap) {
+    if (id.includes("~")) continue;
+    if (!entry.hbsPath) continue;
+    try {
+      const hbs = await readFile16(entry.hbsPath, "utf-8");
+      inputs.push({ id, hbs });
+      hbsById.set(id, hbs);
+      relPathById.set(id, relative5(patternsDir, entry.hbsPath).replace(/\.hbs$/, ""));
+      if (entry.jsonPath) {
+        try {
+          dataJsonById.set(id, await readFile16(entry.jsonPath, "utf-8"));
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const hasEdge = (a, b) => (registry.uses.get(a)?.includes(b) ?? false) || (registry.uses.get(b)?.includes(a) ?? false);
+  const clusters = detectFlattening(inputs, { hasEdge });
+  const collapse = [];
+  const threaded = [];
+  const deferred = [];
+  const skipped = [];
+  for (const cluster of clusters) {
+    const hazardSites = {};
+    for (const m of cluster.members) {
+      const sites = registry.usedBy.get(m) ?? [];
+      if (sites.length) hazardSites[m] = sites;
+    }
+    const members = cluster.members.map((id) => ({
+      id,
+      relPath: relPathById.get(id) ?? id,
+      hbs: hbsById.get(id) ?? "",
+      ...dataJsonById.has(id) ? { dataJson: dataJsonById.get(id) } : {}
+    }));
+    const result = collapseFamily(cluster, members);
+    if (Object.keys(hazardSites).length) {
+      if (result.family) threaded.push({ family: result.family, hazardSites });
+      else deferred.push({ members: cluster.members, hazardSites });
+      continue;
+    }
+    if (result.family) collapse.push(result.family);
+    else skipped.push({ members: cluster.members, reason: result.skip });
+  }
+  return { collapse, threaded, deferred, skipped };
+}
+async function writeExport(families, sink) {
+  const files = [];
+  for (const family of families) {
+    const baseRel = `${family.baseId}.hbs`;
+    const basePath = join18(sink, baseRel);
+    await mkdir4(dirname6(basePath), { recursive: true });
+    await writeFile4(basePath, family.baseHbs, "utf-8");
+    files.push(baseRel);
+    if (family.baseData) {
+      const dataRel = `${family.baseId}.json`;
+      await writeFile4(join18(sink, dataRel), JSON.stringify(family.baseData, null, 2) + "\n", "utf-8");
+      files.push(dataRel);
+    }
+    for (const v of family.variants) {
+      if (v.token === "") continue;
+      const overlayRel = `${family.baseId}~${v.token}.json`;
+      const overlay = { modifier: v.modifier, ...v.data ?? {} };
+      await writeFile4(join18(sink, overlayRel), JSON.stringify(overlay, null, 2) + "\n", "utf-8");
+      files.push(overlayRel);
+    }
+  }
+  files.sort();
+  return { files };
+}
+async function writeThreadedIncluders(threaded, patternsDir, sink) {
+  if (!threaded.length) return { files: [], rewrites: 0 };
+  const { discoveryMap } = await buildDiscoveryMap(patternsDir);
+  const map = buildRewriteMap(threaded.map((t) => t.family));
+  const includerIds = /* @__PURE__ */ new Set();
+  for (const t of threaded) {
+    for (const sites of Object.values(t.hazardSites)) {
+      for (const s of sites) includerIds.add(s);
+    }
+  }
+  const files = [];
+  let rewrites = 0;
+  for (const id of [...includerIds].sort()) {
+    const hbsPath = discoveryMap.get(id)?.hbsPath;
+    if (!hbsPath) continue;
+    let src = "";
+    try {
+      src = await readFile16(hbsPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const res = rewriteIncludes(src, map);
+    if (res.rewrites === 0) continue;
+    rewrites += res.rewrites;
+    const rel = relative5(patternsDir, hbsPath);
+    const outPath = join18(sink, rel);
+    await mkdir4(dirname6(outPath), { recursive: true });
+    await writeFile4(outPath, res.hbs, "utf-8");
+    files.push(rel);
+  }
+  files.sort();
+  return { files, rewrites };
+}
+
+// packages/dev-server/src/audit-format.ts
+function renderAuditMarkdown(r) {
+  const lines = [];
+  lines.push(`# Diagnostics audit${r.subjectSha ? ` \u2014 ${r.subjectSha}` : ""}`);
+  lines.push("");
+  lines.push(`**${r.headline}**`);
+  lines.push("");
+  lines.push(`Render outcomes: ${r.renderOutcomes.ok} ok, ${r.renderOutcomes.blank} blank, ${r.renderOutcomes.error} error.`);
+  lines.push("");
+  lines.push("## Rules by blast radius (components affected; occurrences secondary)");
+  lines.push("");
+  lines.push("| rule | components | occurrences | tag |");
+  lines.push("| --- | ---: | ---: | --- |");
+  for (const rule of r.rulesByBlast) {
+    lines.push(`| \`${rule.engine}:${rule.ruleId}\` | ${rule.components} | ${rule.occurrences} | ${rule.tags.join(", ")} |`);
+  }
+  lines.push("");
+  lines.push("## Per component");
+  lines.push("");
+  for (const c3 of r.perComponent) {
+    lines.push(`### ${c3.id}  _(render: ${c3.render})_`);
+    if (c3.occurrences.length === 0) lines.push("- (no defects; render outcome noted above)");
+    for (const o of c3.occurrences) {
+      lines.push(`- \`${o.engine}:${o.ruleId}\` **[${o.tag}]** ${o.message}${o.domPath ? ` \u2014 \`${o.domPath}\`` : ""}`);
+    }
+    lines.push("");
+  }
+  lines.push(SCOPE_BOUNDARY);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderAuditText(r) {
+  const lines = [];
+  lines.push(`Diagnostics audit${r.subjectSha ? ` \u2014 ${r.subjectSha}` : ""}`);
+  lines.push("");
+  lines.push(r.headline);
+  lines.push("");
+  lines.push(`Render outcomes: ${r.renderOutcomes.ok} ok, ${r.renderOutcomes.blank} blank, ${r.renderOutcomes.error} error.`);
+  lines.push("");
+  lines.push("Rules by blast radius (components affected; occurrences secondary):");
+  if (r.rulesByBlast.length === 0) lines.push("  (none)");
+  for (const rule of r.rulesByBlast) {
+    lines.push(`  ${rule.engine}:${rule.ruleId} \u2014 components ${rule.components}, occurrences ${rule.occurrences} [${rule.tags.join(", ")}]`);
+  }
+  lines.push("");
+  lines.push("Per component:");
+  if (r.perComponent.length === 0) lines.push("  (no components with findings or non-ok render)");
+  for (const c3 of r.perComponent) {
+    lines.push(`  ${c3.id} (render: ${c3.render})`);
+    if (c3.occurrences.length === 0) lines.push("    (no defects; render outcome noted above)");
+    for (const o of c3.occurrences) {
+      lines.push(`    ${o.engine}:${o.ruleId} [${o.tag}] ${o.message}${o.domPath ? ` \u2014 ${o.domPath}` : ""}`);
+    }
+  }
+  lines.push("");
+  lines.push(r.scope);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderAuditJson(r) {
+  return JSON.stringify(r, null, 2);
+}
+function formatAudit(graph, format = "md", opts = {}) {
+  const rollup = buildAuditRollup(graph, opts);
+  return format === "json" ? renderAuditJson(rollup) : format === "text" ? renderAuditText(rollup) : renderAuditMarkdown(rollup);
+}
+
+// packages/dev-server/src/index.ts
+var SILENT_RELOADER = {
+  port: 0,
+  listening: Promise.resolve(),
+  push() {
+  },
+  retain() {
+  },
+  close: async () => {
+  }
+};
+var devUiDist = resolveDevUiDist(import.meta.url);
+async function startDevServer(config, cwd, opts = {}) {
+  const startTime = performance.now();
+  const cfg = resolveServerConfig(config, cwd, opts, loadPatternPackages(config.packages, cwd));
+  const {
+    port: port2,
+    wsPort,
+    patternsDir,
+    stylesDir,
+    patternRoots,
+    styleRoots,
+    themesDir,
+    defaultTheme,
+    swatchSlots
+  } = cfg;
+  for (const p of cfg.packages) {
+    console.log(`[dev-server] pattern package ${p.name}@${p.version}${p.direct ? "" : " (peer)"}`);
+  }
+  await initHighlighter();
+  const helperRegistrars = [];
+  for (const path of cfg.helperPaths) helperRegistrars.push(...await loadHelperRegistrars(path));
+  const globalData = cfg.dataDirs.length ? await loadGlobalData(cfg.dataDirs) : void 0;
+  const render = createRenderer({
+    patternsDir,
+    patternRoots,
+    themesDir: themesDir ?? void 0,
+    defaultTheme,
+    ...helperRegistrars && helperRegistrars.length ? { helperRegistrars } : {},
+    ...globalData ? { globalData } : {}
+  });
+  const live = opts.live !== false;
+  const hotreloader = live ? createHotReloader(wsPort) : SILENT_RELOADER;
+  const wsPortChosen = opts.wsPort !== void 0 || process.env["PD_WS_PORT"] !== void 0;
+  await hotreloader.listening.catch((e) => {
+    throw describeBindError(e, wsPort, "live reload", { http: port2, wsChosen: wsPortChosen });
+  });
+  const tracker = await createSassDependencyTracker([stylesDir]);
+  console.log("[dev-server] SCSS compiled (dependency tracker ready)");
+  const state = createServerState();
+  if (cfg.themeDirs.length) {
+    for (const { name, dir } of await discoverThemeFiles(cfg.themeDirs)) {
+      try {
+        const css = await compileSassFile(join19(dir, `${name}.theme.scss`));
+        state.themeCss.set(name, css);
+        const slots = config.themes && dir === cfg.themeDirs[0] ? swatchSlots : cfg.packageSwatchSlots;
+        state.themeTokens.set(name, await extractThemeTokens(name, css, slots, dir));
+      } catch (e) {
+        console.warn(`[dev-server] Theme compile error (${name}):`, e);
+        state.themeCss.set(name, "");
+        state.themeTokens.set(name, Object.fromEntries(swatchSlots.map((s) => [s, null])));
+      }
+    }
+  }
+  {
+    const dr = await buildDiscoveryMap(patternRoots);
+    state.discoveryResult = dr;
+    await surfaceCollisions(dr.collisions, cwd, hotreloader);
+    for (const o of dr.overrides) {
+      console.log(`[dev-server] ${o.id} overrides ${o.shadowedSource}'s component of the same handle ("${o.handle}")`);
+    }
+    state.compositionRegistry = await buildCompositionRegistry(patternsDir, dr.handleMap, dr.discoveryMap);
+    await surfaceFlattening(dr.discoveryMap, state.compositionRegistry, cwd);
+    const allComponentIds = baseComponentIds(dr);
+    const styleData = await buildAllStyleData(styleRoots, allComponentIds);
+    state.scssModuleGraph = styleData.scssModuleGraph;
+    state.classOwnerIndex = styleData.classOwnerIndex;
+    state.baseProvenance = styleData.baseProvenance;
+    state.perComponentCss = styleData.componentCssMap;
+    state.baseCss = styleData.baseCss;
+    state.scssGraphDirty = false;
+  }
+  const boot = {
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    serverBundleMtime: await stat5(fileURLToPath5(import.meta.url)).then((st) => st.mtimeMs).catch(() => null)
+  };
+  const routeCtx = { cfg, state, render, tracker, globalData, devUiDist, boot };
+  const httpServer = createServer((req, res) => {
+    void handleRequest(req, res, routeCtx);
+  });
+  await new Promise((resolve13, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(port2, "127.0.0.1", () => {
+      httpServer.off("error", reject);
+      resolve13();
+    });
+  }).catch(async (e) => {
+    await hotreloader.close().catch(() => {
+    });
+    throw describeBindError(e, port2, "workbench", { http: port2, wsChosen: wsPortChosen });
+  });
+  const actualPort = httpServer.address().port;
+  console.log(`[dev-server] Listening at http://127.0.0.1:${actualPort}`);
+  const componentCount = state.discoveryResult ? [...state.discoveryResult.discoveryMap.keys()].filter((id) => !id.includes("~")).length : 0;
+  console.log(`[dev-server] Ready in ${Math.round(performance.now() - startTime)}ms \u2014 ${componentCount} components`);
+  const watcher = live ? startWatching({ cfg, state, render, tracker, hotreloader }) : null;
+  if (watcher) await new Promise((resolve13) => watcher.once("ready", () => resolve13()));
+  return {
+    port: actualPort,
+    async close() {
+      await watcher?.close();
+      await hotreloader.close();
+      await new Promise(
+        (res, rej) => httpServer.close((err) => err ? rej(err) : res())
+      );
+    }
+  };
+}
+
+// packages/core/src/index.ts
+import { build as esbuild } from "esbuild";
+import { existsSync as existsSync4 } from "node:fs";
+import { readFile as readFile17, writeFile as writeFile5, unlink, mkdir as mkdir5 } from "node:fs/promises";
+import { join as join20, dirname as dirname7, resolve as resolve10, relative as relative6, isAbsolute } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+import { createHash as createHash3 } from "node:crypto";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+async function runDev(root, opts, configPath) {
+  const config = await loadConfig(root, configPath);
+  await startDevServer(config, root, opts);
+}
+async function runBuild(root, configPath, options) {
+  const config = await loadConfig(root, configPath);
+  const outDir = resolve10(root, options.out ?? config.build?.outDir ?? config.outDir ?? "dist");
+  const report = await buildStaticSite(config, root, {
+    outDir,
+    ...options.base !== void 0 ? { basePath: options.base } : {},
+    ...options.audit !== void 0 ? { audit: options.audit } : {},
+    pdVersion: options.pdVersion,
+    log: (line) => console.log(`[pd build] ${line}`)
+  });
+  const mb = (report.bytes / 1024 / 1024).toFixed(1);
+  console.log(`[pd build] ${report.components} components \u2192 ${report.files} files, ${mb} MB in ${report.ms} ms`);
+  console.log(`[pd build] ${report.outDir}  (served from ${report.basePath})`);
+  for (const w of report.warnings) console.log(`[pd build]   not built: ${w}`);
+}
+async function runAudit(root, configPath, format = "md") {
+  const config = await loadConfig(root, configPath);
+  const { graph, reaudited, reused, artifactPath } = await runDiagnosticsAudit(config, root);
+  const report = formatAudit(graph, format);
+  const ext = format === "json" ? "json" : format === "text" ? "txt" : "md";
+  const reportPath = join20(dirname7(artifactPath), `diagnostics-report.${ext}`);
+  await writeFile5(reportPath, report, "utf-8");
+  console.log(report);
+  const affected = new Set(graph.occurrences.map((o) => o.component)).size;
+  const meta = format === "json" ? console.error : console.log;
+  meta(`${format === "json" ? "" : "\n"}[pd audit] re-audited ${reaudited.length}, reused ${reused} (of ${graph.components.length}).`);
+  meta(`[pd audit] serialized graph: ${artifactPath}`);
+  meta(`[pd audit] report: ${reportPath}`);
+  meta(`[pd audit] ${graph.occurrences.length} defects across ${affected}/${graph.components.length} components.`);
+}
+function defaultExportDir(root) {
+  const key = createHash3("sha1").update(resolve10(root)).digest("hex").slice(0, 16);
+  return join20(tmpdir2(), "pattern-dump", key, "export");
+}
+function assertOutsideRoot(outDir, root) {
+  const rel = relative6(resolve10(root), resolve10(outDir));
+  const inside = rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  if (inside) {
+    throw new Error(
+      `--out must be outside --root (the root is read-only; export writes the corrected form elsewhere).
+  root: ${resolve10(root)}
+  out:  ${resolve10(outDir)}`
+    );
+  }
+}
+async function runExport(root, configPath, outDir) {
+  const config = await loadConfig(root, configPath);
+  const patternsDir = resolve10(root, config.patternsDir);
+  const sink = outDir ? resolve10(process.cwd(), outDir) : defaultExportDir(root);
+  assertOutsideRoot(sink, root);
+  const plan = await planExport(config, root);
+  await mkdir5(sink, { recursive: true });
+  const threadedFamilies = plan.threaded.map((t) => t.family);
+  const { files } = await writeExport([...plan.collapse, ...threadedFamilies], sink);
+  const { files: includerFiles, rewrites } = await writeThreadedIncluders(plan.threaded, patternsDir, sink);
+  console.log(`[pd export] patterns: ${patternsDir}`);
+  console.log(`[pd export] sink: ${sink}${outDir ? "" : " (default \u2014 pass --out <dir> for a durable target)"}`);
+  console.log(`[pd export] ${plan.collapse.length} family(ies) collapse (leaf, shape (a)); ${plan.threaded.length} threaded (include-consumed shape (a) \u2014 slice 2); ${plan.deferred.length} deferred (\xA77 hazard, not shape (a) \u2014 slice 3 / shape-(c) track); ${plan.skipped.length} skipped (leaf but not lossless shape (a)).`);
+  console.log(`[pd export] wrote ${files.length} collapsed file(s) + ${includerFiles.length} rewritten includer(s) (${rewrites} include site(s) threaded):`);
+  for (const f of files) console.log(`    ${f}`);
+  for (const f of includerFiles) console.log(`    ${f}  (includer, rewritten)`);
+  for (const family of plan.collapse) {
+    console.log(`
+[pd export] COLLAPSE ${family.baseId}  (root .${family.root}, ${family.variants.length} variants)`);
+    for (const v of family.variants) {
+      console.log(`    ~${v.token || "(base-default)"}  modifier="${v.modifier}"  \u2190 ${v.sourceId}`);
+    }
+  }
+  for (const t of plan.threaded) {
+    const family = t.family;
+    console.log(`
+[pd export] THREADED ${family.baseId}  (root .${family.root}, ${family.variants.length} variants)`);
+    for (const v of family.variants) {
+      console.log(`    ~${v.token || "(base-default)"}  modifier="${v.modifier}"  \u2190 ${v.sourceId}`);
+    }
+  }
+  const rewriteMap = buildRewriteMap(threadedFamilies);
+  if (rewriteMap.size) {
+    const sitesByHandle = /* @__PURE__ */ new Map();
+    for (const t of plan.threaded) {
+      for (const [memberId, sites] of Object.entries(t.hazardSites)) {
+        const set = sitesByHandle.get(deriveHandle(memberId)) ?? /* @__PURE__ */ new Set();
+        for (const s of sites) set.add(s);
+        sitesByHandle.set(deriveHandle(memberId), set);
+      }
+    }
+    console.log(`
+[pd export] REWRITE MAP (${rewriteMap.size} flat handle(s) \u2192 collapsed base + threaded modifier):`);
+    for (const [oldHandle, { baseHandle, modifier }] of [...rewriteMap].sort((a, b) => a[0].localeCompare(b[0]))) {
+      const sites = [...sitesByHandle.get(oldHandle) ?? []].sort();
+      const sitesNote = sites.length ? `  used-by: [${sites.join(", ")}]` : "  (no include site \u2014 free member)";
+      console.log(`    {{> ${oldHandle}}}  \u2192  {{> ${baseHandle} modifier="${modifier}"}}${sitesNote}`);
+    }
+  }
+  for (const d of plan.deferred) {
+    const sites = Object.entries(d.hazardSites).map(([m, s]) => `${m}\u2192[${s.join(", ")}]`).join("; ");
+    console.log(`
+[pd export] DEFERRED (${d.members.length} members; \xA77 hazard: ${sites})`);
+  }
+  for (const s of plan.skipped) {
+    console.log(`
+[pd export] SKIPPED [${s.reason}] (${s.members.length} members: ${s.members.join(", ")})`);
+  }
+}
+async function loadConfig(root, configPath) {
+  if (configPath) {
+    if (!existsSync4(configPath)) {
+      throw new Error(`--config file not found: ${configPath}`);
+    }
+    return configPath.endsWith(".json") ? JSON.parse(await readFile17(configPath, "utf-8")) : loadTsConfig(configPath);
+  }
+  const tsPath = join20(root, "pattern-dump.config.ts");
+  const jsonPath = join20(root, "pattern-dump.config.json");
+  if (existsSync4(tsPath)) return loadTsConfig(tsPath);
+  if (existsSync4(jsonPath)) {
+    return JSON.parse(await readFile17(jsonPath, "utf-8"));
+  }
+  throw new Error(
+    `No pattern-dump.config.ts or pattern-dump.config.json found in ${root} (and no --config given)`
+  );
+}
+async function loadTsConfig(tsPath) {
+  const tmp = join20(tmpdir2(), `pd-config-${Date.now()}.mjs`);
+  try {
+    await esbuild({
+      entryPoints: [tsPath],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      // No packages:"external" — the temp file runs from /tmp so we must inline deps.
+      outfile: tmp
+    });
+    const { default: cfg } = await import(pathToFileURL2(tmp).href);
+    return cfg;
+  } finally {
+    await unlink(tmp).catch(() => {
+    });
+  }
+}
+
+// packages/cli/src/index.ts
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
+
+// packages/cli/src/args.ts
+import { resolve as resolve11 } from "node:path";
+import { parseArgs } from "node:util";
+var COMMANDS = ["init", "dev", "audit", "build", "export"];
+var rootAndConfig = {
+  root: { type: "string" },
+  config: { type: "string" },
+  help: { type: "boolean", short: "h" }
+};
+function port(value, flag) {
+  if (value === void 0) return void 0;
+  const n = Number(value);
+  return Number.isInteger(n) && n >= 0 && n <= 65535 ? n : new Error(`${flag} must be a port number (got "${value}")`);
+}
+function parseCommand(argv, cwd) {
+  const [cmd, ...rest] = argv;
+  if (cmd === void 0 || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    return { kind: "help", ...rest[0] ? { topic: rest[0] } : {} };
+  }
+  if (!COMMANDS.includes(cmd)) {
+    return { kind: "error", message: `unknown command "${cmd}"` };
+  }
+  try {
+    if (cmd === "init") return parseInit(rest, cwd);
+    if (cmd === "dev") {
+      const { values: values2 } = parseArgs({
+        args: rest,
+        strict: true,
+        allowPositionals: false,
+        options: { ...rootAndConfig, port: { type: "string" }, "ws-port": { type: "string" } }
+      });
+      if (values2.help) return { kind: "help", topic: cmd };
+      const p = port(values2.port, "--port");
+      const ws = port(values2["ws-port"], "--ws-port");
+      if (p instanceof Error) return { kind: "error", message: p.message };
+      if (ws instanceof Error) return { kind: "error", message: ws.message };
+      return {
+        kind: "dev",
+        ...base(values2, cwd),
+        ...p !== void 0 ? { port: p } : {},
+        ...ws !== void 0 ? { wsPort: ws } : {}
+      };
+    }
+    if (cmd === "audit") {
+      const { values: values2 } = parseArgs({
+        args: rest,
+        strict: true,
+        allowPositionals: false,
+        options: { ...rootAndConfig, format: { type: "string" } }
+      });
+      if (values2.help) return { kind: "help", topic: cmd };
+      const format = values2.format ?? "md";
+      if (format !== "md" && format !== "text" && format !== "json") {
+        return { kind: "error", message: `--format must be one of md|text|json (got "${format}")` };
+      }
+      return { kind: "audit", ...base(values2, cwd), format };
+    }
+    if (cmd === "build") {
+      const { values: values2 } = parseArgs({
+        args: rest,
+        strict: true,
+        allowPositionals: false,
+        options: {
+          ...rootAndConfig,
+          out: { type: "string" },
+          base: { type: "string" },
+          audit: { type: "boolean" },
+          "no-audit": { type: "boolean" }
+        }
+      });
+      if (values2.help) return { kind: "help", topic: cmd };
+      const audit = toggle(values2, "audit");
+      if (audit instanceof Error) return { kind: "error", message: audit.message };
+      return {
+        kind: "build",
+        ...base(values2, cwd),
+        ...values2.out !== void 0 ? { out: values2.out } : {},
+        ...values2.base !== void 0 ? { base: values2.base } : {},
+        ...audit !== void 0 ? { audit } : {}
+      };
+    }
+    const { values } = parseArgs({
+      args: rest,
+      strict: true,
+      allowPositionals: false,
+      options: { ...rootAndConfig, out: { type: "string" } }
+    });
+    if (values.help) return { kind: "help", topic: cmd };
+    return { kind: "export", ...base(values, cwd), ...values.out !== void 0 ? { out: values.out } : {} };
+  } catch (e) {
+    return { kind: "error", message: e instanceof Error ? e.message : String(e) };
+  }
+}
+function toggle(values, name) {
+  const on = values[name] === true;
+  const off = values[`no-${name}`] === true;
+  if (on && off) return new Error(`--${name} and --no-${name} cannot both be given`);
+  return on ? true : off ? false : void 0;
+}
+function parseInit(rest, cwd) {
+  const { values, positionals } = parseArgs({
+    args: rest,
+    strict: true,
+    allowPositionals: true,
+    options: {
+      name: { type: "string" },
+      brand: { type: "string" },
+      examples: { type: "boolean" },
+      "no-examples": { type: "boolean" },
+      install: { type: "boolean" },
+      "no-install": { type: "boolean" },
+      git: { type: "boolean" },
+      "no-git": { type: "boolean" },
+      "pd-source": { type: "string" },
+      yes: { type: "boolean", short: "y" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) return { kind: "help", topic: "init" };
+  if (positionals.length > 1) return { kind: "error", message: `init takes one folder (got ${positionals.join(", ")})` };
+  const toggles = { examples: void 0, install: void 0, git: void 0 };
+  for (const name of ["examples", "install", "git"]) {
+    const t = toggle(values, name);
+    if (t instanceof Error) return { kind: "error", message: t.message };
+    toggles[name] = t;
+  }
+  return {
+    kind: "init",
+    target: resolve11(cwd, positionals[0] ?? "."),
+    yes: values.yes === true,
+    ...values.name !== void 0 ? { name: values.name } : {},
+    ...values.brand !== void 0 ? { brand: values.brand } : {},
+    ...toggles.examples !== void 0 ? { examples: toggles.examples } : {},
+    ...toggles.install !== void 0 ? { install: toggles.install } : {},
+    ...toggles.git !== void 0 ? { git: toggles.git } : {},
+    ...values["pd-source"] !== void 0 ? { pdSource: values["pd-source"] } : {}
+  };
+}
+function base(values, cwd) {
+  return {
+    root: values.root ? resolve11(cwd, values.root) : cwd,
+    ...values.config ? { configPath: resolve11(cwd, values.config) } : {}
+  };
+}
+var USAGE = `Usage: pd <command> [options]
+
+  init [dir]   Set up a new Pattern Dump project (default: the current folder)
+    --name <name>      Package name (default: the folder name)
+    --brand <title>    Title shown in the Nav Rail (default: the name)
+    --no-examples      Structure, config and themes only \u2014 no starter components
+    --no-install       Skip npm install
+    --git / --no-git   Run git init (default: yes, unless already inside a repository)
+    --pd-source <src>  Where to install Pattern Dump from: a .tgz file or an npm spec
+    -y, --yes          Accept every default without asking
+
+  dev      Start the local dev server
+    --root <path>      Open a specific project root (default: current directory)
+    --config <path>    Use a config file outside the root (paths resolve against --root)
+    --port <n>         HTTP port (default 4000, env: PD_PORT)
+    --ws-port <n>      WebSocket port (default port+1, env: PD_WS_PORT)
+
+  audit    Build the diagnostics graph and emit the report + serialized JSON
+    --root <path>      Audit a specific project root
+    --config <path>    Use a config file outside the root
+    --format <fmt>     Report format: md (default) | text | json (json \u2192 stdout only)
+
+  build    Write a static snapshot of the workbench \u2014 plain files for any static host
+    --root <path>      Build a specific project root
+    --config <path>    Use a config file outside the root
+    --out <dir>        Output folder, relative to the root (default: build.outDir, outDir, or dist)
+    --base <path>      Where it will be hosted: / (default) or a subpath such as /docs/
+    --no-audit         Leave the corpus audit out: it is not run, and the site has no Audit tab
+                       (default: build.audit in the config; --audit forces it back in)
+
+  export   Write the subject's flattened families back out in corrected form
+    --root <path>      Export a specific project root (read-only)
+    --out <dir>        Durable output sink (must be outside --root)
+    --config <path>    Use a config file outside the root
+
+  help [command]   Show this help`;
+
+// packages/cli/src/init/run.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { readFile as readFile19 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname9, join as join22, relative as relative8, resolve as resolve12 } from "node:path";
+
+// packages/cli/package.json
+var package_default = {
+  name: "@pattern-dump/cli",
+  version: "0.1.0-alpha.0",
+  private: true,
+  description: "The pd command and the published pattern-dump package.",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    pd: "./dist/index.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  dependencies: {
+    "@pattern-dump/core": "*"
+  },
+  scripts: {
+    build: "esbuild src/index.ts --bundle --platform=node --format=esm --packages=external --external:@pattern-dump/* --outfile=dist/index.js",
+    test: "vitest run --passWithNoTests",
+    typecheck: "tsc --noEmit",
+    lint: "eslint src"
+  },
+  devDependencies: {
+    "@pattern-dump/contracts": "*",
+    "@pattern-dump/dev-server": "*"
+  }
+};
+
+// packages/cli/src/distribution.ts
+var PD_PACKAGE_NAME = "pattern-dump";
+var PD_VERSION = package_default.version;
+
+// packages/cli/src/init/files.ts
+import { mkdir as mkdir6, readdir as readdir5, readFile as readFile18, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname8, join as join21, relative as relative7, sep as sep2 } from "node:path";
+async function readTemplateDir(dir) {
+  const out = [];
+  async function walk(current) {
+    for (const entry of await readdir5(current, { withFileTypes: true })) {
+      const full = join21(current, entry.name);
+      if (entry.isDirectory()) await walk(full);
+      else out.push({ path: relative7(dir, full).split(sep2).join("/"), content: await readFile18(full, "utf8") });
+    }
+  }
+  await walk(dir);
+  return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function readTemplates(templatesDir) {
+  const [base2, examples] = await Promise.all([
+    readTemplateDir(join21(templatesDir, "base")),
+    readTemplateDir(join21(templatesDir, "examples"))
+  ]);
+  return { base: base2, examples };
+}
+async function applyPlan(target, plan) {
+  await mkdir6(target, { recursive: true });
+  for (const file of plan.writes) {
+    const abs = join21(target, file.path);
+    await mkdir6(dirname8(abs), { recursive: true });
+    await writeFile6(abs, file.content, { flag: "wx" });
+  }
+  await writeFile6(join21(target, "package.json"), plan.packageJson.content);
+  for (const dir of ["assets", "src/patterns"]) await mkdir6(join21(target, dir), { recursive: true });
+}
+
+// packages/cli/src/init/plan.ts
+var CONFIG_FILES = ["pattern-dump.config.ts", "pattern-dump.config.json"];
+var RENAMES = { _gitignore: ".gitignore" };
+function toPackageName(input) {
+  const slug = input.toLowerCase().replace(/[^a-z0-9._~-]+/g, "-").replace(/^[-._]+|[-._]+$/g, "");
+  return slug || "design-system";
+}
+function planInit(templates, answers, existing, packageName) {
+  const existingConfig = CONFIG_FILES.find((f) => existing.exists(f));
+  if (existingConfig) {
+    return { ok: false, reason: `${existingConfig} already exists \u2014 this folder is already a Pattern Dump project` };
+  }
+  const substitute = (text) => text.replaceAll("__PD_PACKAGE__", packageName).replaceAll("__PD_NAME__", answers.name).replaceAll("__PD_BRAND_JSON__", JSON.stringify(answers.brand));
+  const writes = [];
+  const skipped = [];
+  const files = [...templates.base, ...answers.examples ? templates.examples : []];
+  for (const file of files) {
+    const path = renamed(file.path);
+    if (existing.exists(path)) {
+      skipped.push({ path, reason: "already exists \u2014 left untouched" });
+      continue;
+    }
+    writes.push({ path, content: substitute(file.content) });
+  }
+  return { ok: true, plan: { writes, skipped, packageJson: mergePackageJson(existing.packageJson, answers, packageName) } };
+}
+function renamed(path) {
+  const parts = path.split("/");
+  const last = parts.pop();
+  return [...parts, RENAMES[last] ?? last].join("/");
+}
+var SCRIPTS = {
+  dev: "pd dev",
+  audit: "pd audit",
+  typecheck: "tsc --noEmit",
+  "build:scripts": "tsc"
+};
+var TYPESCRIPT_RANGE = "^5.9.0";
+function mergePackageJson(current, answers, packageName) {
+  const notes = [];
+  const created = current === null;
+  const pkg = created ? { name: toPackageName(answers.name), version: "0.1.0", private: true, type: "module" } : structuredClone(current);
+  const scripts = { ...pkg.scripts };
+  for (const [name, command2] of Object.entries(SCRIPTS)) {
+    if (scripts[name] === void 0) {
+      scripts[name] = command2;
+    } else if (scripts[name] !== command2) {
+      const alt = `pd:${name}`;
+      if (scripts[alt] === void 0) scripts[alt] = command2;
+      notes.push(`script "${name}" already exists \u2014 added "${alt}" instead`);
+    }
+  }
+  pkg.scripts = scripts;
+  const deps = pkg.dependencies;
+  const devDeps = { ...pkg.devDependencies };
+  if (deps?.[packageName] !== void 0) {
+    notes.push(`${packageName} is already a dependency \u2014 left as is`);
+  } else if (devDeps[packageName] !== void 0 && devDeps[packageName] !== answers.dependency) {
+    notes.push(`${packageName} is already a devDependency (${devDeps[packageName]}) \u2014 left as is`);
+  } else {
+    devDeps[packageName] = answers.dependency;
+  }
+  const existingTs = deps?.typescript ?? devDeps.typescript;
+  if (existingTs === void 0) {
+    devDeps.typescript = TYPESCRIPT_RANGE;
+  } else if (existingTs !== TYPESCRIPT_RANGE) {
+    notes.push(`typescript is already a dependency (${existingTs}) \u2014 left as is; the starter scripts expect ${TYPESCRIPT_RANGE}`);
+  }
+  pkg.devDependencies = devDeps;
+  return { content: JSON.stringify(pkg, null, 2) + "\n", created, notes };
+}
+
+// packages/cli/src/init/run.ts
+function dependencySpec(pdSource, cwd) {
+  if (pdSource === void 0) return `^${PD_VERSION}`;
+  const asPath = resolve12(cwd, pdSource);
+  if (existsSync5(asPath)) return `file:${asPath}`;
+  return pdSource.startsWith(`${PD_PACKAGE_NAME}@`) ? pdSource.slice(PD_PACKAGE_NAME.length + 1) : pdSource;
+}
+async function insideGitRepo(target, io) {
+  let dir = target;
+  while (!existsSync5(dir) && dirname9(dir) !== dir) dir = dirname9(dir);
+  return await io.run("git", ["rev-parse", "--is-inside-work-tree"], dir) === 0;
+}
+async function runInit(cmd, io) {
+  const target = cmd.target;
+  let dependency;
+  if (cmd.pdSource !== void 0) {
+    dependency = dependencySpec(cmd.pdSource, io.cwd);
+  } else if (io.localBuild) {
+    if (!io.localBuild.tarball) {
+      io.log("\u2717 This pd runs from a Pattern Dump source checkout, and there is no packed build to install.");
+      io.log(`  Pack one first:  (cd ${io.localBuild.repo} && npm run pack:pd)`);
+      io.log("  or pass --pd-source <tarball or npm spec>. Nothing was written.");
+      return 1;
+    }
+    dependency = `file:${io.localBuild.tarball}`;
+    io.log(`\xB7 Installing Pattern Dump from the local build ${io.localBuild.tarball}`);
+    if (io.localBuild.stale) {
+      io.log(`  ! It is older than your latest build. For recent changes: (cd ${io.localBuild.repo} && npm run pack:pd)`);
+    }
+  } else {
+    dependency = dependencySpec(void 0, io.cwd);
+  }
+  const pkgPath = join22(target, "package.json");
+  let packageJson = null;
+  if (existsSync5(pkgPath)) {
+    try {
+      packageJson = JSON.parse(await readFile19(pkgPath, "utf8"));
+    } catch (e) {
+      io.log(`\u2717 ${pkgPath} is not valid JSON \u2014 fix it and run pd init again (${e instanceof Error ? e.message : e})`);
+      return 1;
+    }
+  }
+  const prompt = io.interactive && !cmd.yes;
+  const existingName = typeof packageJson?.name === "string" ? packageJson.name : void 0;
+  const name = cmd.name ?? (prompt ? await io.ask("Project name", existingName ?? toPackageName(basename6(target))) : existingName ?? toPackageName(basename6(target)));
+  const brand = cmd.brand ?? (prompt ? await io.ask("Title in the Nav Rail", name) : name);
+  const examples = cmd.examples ?? (prompt ? await io.confirm("Include starter components", true) : true);
+  const gitDefault = !await insideGitRepo(target, io);
+  const git = cmd.git ?? (prompt && gitDefault ? await io.confirm("Initialise a git repository", true) : gitDefault);
+  const install = cmd.install ?? (prompt ? await io.confirm("Run npm install", true) : true);
+  const answers = { name, brand, examples, dependency };
+  const templates = await readTemplates(io.templatesDir);
+  const result = planInit(templates, answers, { packageJson, exists: (p) => existsSync5(join22(target, p)) }, PD_PACKAGE_NAME);
+  if (!result.ok) {
+    io.log(`\u2717 ${result.reason}`);
+    return 1;
+  }
+  const { plan } = result;
+  await applyPlan(target, plan);
+  const where = relative8(io.cwd, target) || ".";
+  io.log(`\u2713 ${plan.writes.length} files written to ${where}`);
+  io.log(`\u2713 package.json ${plan.packageJson.created ? "created" : "updated"} \u2014 ${PD_PACKAGE_NAME} ${answers.dependency}`);
+  for (const note of plan.packageJson.notes) io.log(`  \xB7 ${note}`);
+  for (const s of plan.skipped) io.log(`  \xB7 ${s.path}: ${s.reason}`);
+  if (git) {
+    const code = await io.run("git", ["init", "-q"], target);
+    io.log(code === 0 ? "\u2713 git repository initialised" : "\u2717 git init failed \u2014 is git installed? (the project is set up regardless)");
+  }
+  if (install) {
+    io.log("\u2026 npm install");
+    const code = await io.run("npm", ["install"], target);
+    if (code !== 0) {
+      io.log("\u2717 npm install failed. The project files are in place.");
+      if (dependency.startsWith("^")) {
+        io.log(`  ${PD_PACKAGE_NAME} may not be published yet. Install a local build into the project:`);
+        io.log(`    ${where === "." ? "" : `cd ${where} && `}npm install --save-dev <path to ${PD_PACKAGE_NAME}-${PD_VERSION}.tgz>`);
+        io.log("  (build one in the Pattern Dump repo with: npm run pack:pd)");
+      } else {
+        io.log(`  Fix the error above, then run npm install${where === "." ? "" : ` in ${where}`}.`);
+      }
+      return 1;
+    }
+  }
+  io.log("");
+  io.log("Next:");
+  if (where !== ".") io.log(`  cd ${where}`);
+  if (!install) io.log("  npm install");
+  io.log(`  npm run ${JSON.parse(plan.packageJson.content).scripts["pd:dev"] ? "pd:dev" : "dev"}      # http://localhost:4000`);
+  return 0;
+}
+
+// packages/cli/src/init/local-build.ts
+import { existsSync as existsSync6, statSync } from "node:fs";
+import { join as join23 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+var BUILT = [
+  "packages/cli/dist/index.js",
+  "packages/core/dist/index.js",
+  "packages/dev-server/dist/index.js",
+  "packages/renderer/dist/index.js",
+  "apps/dev-ui/dist/main.js"
+];
+var mtime = (path) => {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+};
+function detectLocalBuild(moduleUrl, packageName, version) {
+  const repo = fileURLToPath6(new URL("../../../", moduleUrl)).replace(/[\\/]$/, "");
+  if (!existsSync6(join23(repo, "packages/cli/src/distribution.ts"))) return null;
+  const tarball = join23(repo, ".pd-pack", `${packageName}-${version}.tgz`);
+  if (!existsSync6(tarball)) return { repo, tarball: null, stale: false };
+  const newestBuild = Math.max(...BUILT.map((p) => mtime(join23(repo, p))));
+  return { repo, tarball, stale: newestBuild > mtime(tarball) };
+}
+
+// packages/cli/src/index.ts
+var command = parseCommand(process.argv.slice(2), process.cwd());
+switch (command.kind) {
+  case "init": {
+    const rl = process.stdin.isTTY ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+    runInit(command, {
+      cwd: process.cwd(),
+      // templates/ ships beside dist/ — the same relative position in this repo and in the package.
+      templatesDir: fileURLToPath7(new URL("../templates/", import.meta.url)),
+      interactive: rl !== null,
+      localBuild: detectLocalBuild(import.meta.url, PD_PACKAGE_NAME, PD_VERSION),
+      async ask(question, fallback) {
+        const answer = (await rl.question(`${question} (${fallback}): `)).trim();
+        return answer || fallback;
+      },
+      async confirm(question, fallback) {
+        const answer = (await rl.question(`${question} (${fallback ? "Y/n" : "y/N"}): `)).trim().toLowerCase();
+        return answer === "" ? fallback : answer.startsWith("y");
+      },
+      log: (message) => console.log(message),
+      run: (cmd, args, cwd) => new Promise((resolve13) => {
+        const quiet = cmd === "git" && args[0] === "rev-parse";
+        const child = spawn(cmd, args, { cwd, stdio: quiet ? "ignore" : "inherit", shell: process.platform === "win32" });
+        child.on("error", () => resolve13(null));
+        child.on("close", (code) => resolve13(code));
+      })
+    }).then((code) => {
+      rl?.close();
+      process.exitCode = code;
+    }).catch((e) => {
+      rl?.close();
+      console.error("[pd] Error:", e);
+      process.exitCode = 1;
+    });
+    break;
+  }
+  case "dev":
+    runDev(command.root, {
+      ...command.port !== void 0 ? { port: command.port } : {},
+      ...command.wsPort !== void 0 ? { wsPort: command.wsPort } : {}
+    }, command.configPath).catch((e) => {
+      if (typeof e === "object" && e !== null && e.code === "EADDRINUSE" && e instanceof Error) {
+        console.error(`[pd] ${e.message}`);
+      } else {
+        console.error("[pd] Error:", e);
+      }
+      process.exit(1);
+    });
+    break;
+  case "audit":
+    runAudit(command.root, command.configPath, command.format).then(() => process.stdout.write("", () => process.exit(0))).catch((e) => {
+      console.error("[pd] Error:", e);
+      process.exit(1);
+    });
+    break;
+  case "build":
+    runBuild(command.root, command.configPath, {
+      ...command.out !== void 0 ? { out: command.out } : {},
+      ...command.base !== void 0 ? { base: command.base } : {},
+      ...command.audit !== void 0 ? { audit: command.audit } : {},
+      pdVersion: PD_VERSION
+    }).then(() => process.stdout.write("", () => process.exit(0))).catch((e) => {
+      console.error("[pd] Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    });
+    break;
+  case "export":
+    runExport(command.root, command.configPath, command.out).then(() => {
+      process.exitCode = 0;
+    }).catch((e) => {
+      console.error("[pd] Error:", e);
+      process.exitCode = 1;
+    });
+    break;
+  case "help":
+    console.log(USAGE);
+    break;
+  case "error":
+    console.error(`[pd] Error: ${command.message}
+`);
+    console.error(USAGE);
+    process.exit(1);
+    break;
+  default: {
+    const unhandled = command;
+    void unhandled;
+  }
+}