pattern-dump 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/pd.js

@@ -2,7 +2,7 @@
 import {
   ConfigError,
   validateConfig
-} from "./chunks/chunk-3WZHFYHZ.js";
+} from "./chunks/chunk-NXGPZL5L.js";
 
 // packages/discovery/src/index.ts
 import { readdir } from "node:fs/promises";
@@ -30,10 +30,12 @@ function collapseComponentId(relNoExt) {
   const parent = dirname(relNoExt);
   return stem === basename(parent) ? parent : relNoExt;
 }
+function stripOrderPrefixes(path) {
+  return path.split("/").map((seg) => seg.replace(/^\d+[-_]/, "")).join("/");
+}
 function deriveHandle(id) {
-  const parts = id.split("/");
-  const unnumbered = (seg) => seg.replace(/^\d+[-_]/, "");
-  return `${unnumbered(parts[0])}-${unnumbered(parts[parts.length - 1])}`;
+  const parts = stripOrderPrefixes(id).split("/");
+  return `${parts[0]}-${parts[parts.length - 1]}`;
 }
 async function buildDiscoveryMap(roots) {
   const rootList = typeof roots === "string" ? [{ dir: roots }] : roots;
@@ -418,6 +420,7 @@ function _plainPre(code) {
 import { HtmlValidate } from "html-validate";
 import Handlebars from "handlebars";
 import { readFile } from "node:fs/promises";
+import { basename as basename2 } from "node:path";
 var htmlValidator = new HtmlValidate({
   rules: {
     "element-permitted-content": "error",
@@ -439,6 +442,36 @@ function deepMerge(target, ...sources) {
   return target;
 }
 var safePart = (n) => n.replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
+function jsonErrorPosition(reason, text) {
+  const lineColumn = /line (\d+) column (\d+)/.exec(reason);
+  if (lineColumn) return { line: Number(lineColumn[1]), column: Number(lineColumn[2]) };
+  const position = /position (\d+)/.exec(reason);
+  if (!position) return {};
+  const lines = text.slice(0, Number(position[1])).split("\n");
+  return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+}
+async function readDataFile(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf-8");
+  } catch {
+    return {};
+  }
+  try {
+    return { data: JSON.parse(text) };
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    return {
+      diagnostic: {
+        kind: "DATA_INVALID",
+        source: "render",
+        severity: "error",
+        message: `${basename2(path)} is not valid JSON (${reason}); its data was not used`,
+        location: { file: path, ...jsonErrorPosition(reason, text) }
+      }
+    };
+  }
+}
 function registerHelpers(env, mintId, getLastId, projectHelpers, helperRegistrars) {
   env.registerHelper("id", (name) => mintId(name));
   env.registerHelper("getId", (name) => mintId(name));
@@ -519,30 +552,34 @@ var createRenderer = (options) => {
       discoveryMap ??= maps.discoveryMap;
       handleMap ??= maps.handleMap;
     }
-    const entry = discoveryMap.get(input.component);
-    if (!entry) throw new Error(`[renderer] Component not found: "${input.component}"`);
+    let componentId = input.component;
+    let variant = input.variant;
+    const tilde = componentId.indexOf("~");
+    if (tilde > 0 && !variant && discoveryMap.has(componentId.slice(0, tilde))) {
+      variant = componentId.slice(tilde + 1);
+      componentId = componentId.slice(0, tilde);
+    }
+    const entry = discoveryMap.get(componentId);
+    if (!entry) throw new Error(`[renderer] Component not found: "${componentId}"`);
     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 (variant) {
+      const variantEntry = discoveryMap.get(`${componentId}~${variant}`);
+      if (!variantEntry) throw new Error(`[renderer] Variant not found: "${componentId}~${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 dataDiagnostics = /* @__PURE__ */ new Map();
+    const readData = async (path) => {
+      const { data: data2, diagnostic } = await readDataFile(path);
+      if (diagnostic) dataDiagnostics.set(path, diagnostic);
+      return data2;
+    };
+    const defaultData = (entry.jsonPath ? await readData(entry.jsonPath) : void 0) ?? {};
+    const variantData = variantJsonPath ? await readData(variantJsonPath) : void 0;
     const data = deepMerge(
       structuredClone(options.globalData ?? {}),
       defaultData,
@@ -550,7 +587,7 @@ var createRenderer = (options) => {
       input.data
     );
     const env = Handlebars.create();
-    const componentSlug = safePart(input.component.replace(/[\\/]/g, "-"));
+    const componentSlug = safePart(componentId.replace(/[\\/]/g, "-"));
     let currentBase = `pd-${componentSlug}`;
     const idCache = /* @__PURE__ */ new Map();
     let lastMintedId = "";
@@ -570,13 +607,12 @@ var createRenderer = (options) => {
       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 childData = compEntry.jsonPath ? await readDataFile(compEntry.jsonPath) : {};
+        const childDataPath = compEntry.jsonPath;
+        const variantTilde = compId.indexOf("~");
+        const baseJsonPath = variantTilde > 0 ? discoveryMap.get(compId.slice(0, variantTilde))?.jsonPath : void 0;
+        const baseData = baseJsonPath ? await readDataFile(baseJsonPath) : {};
+        const childDefaults = deepMerge(structuredClone(baseData.data ?? {}), childData.data);
         const childTemplate = env.compile(partialSrc);
         const capturedDefaults = childDefaults;
         const partialSlug = safePart(compId.replace(/[\\/]/g, "-"));
@@ -593,13 +629,16 @@ var createRenderer = (options) => {
               invocationCounters.set(counterKey, n + 1);
               thisBase = n === 0 ? currentBase : `pd-${partialSlug}-${n}`;
             }
+            if (childData.diagnostic && childDataPath) dataDiagnostics.set(childDataPath, childData.diagnostic);
+            if (baseData.diagnostic && baseJsonPath) dataDiagnostics.set(baseJsonPath, baseData.diagnostic);
             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 data2 = { ...opts?.data, ...opts?.fn ? { "partial-block": opts.fn } : {} };
+            const runtime = opts?.fn ? { data: data2, partials: { ...env.partials, "@partial-block": opts.fn } } : { data: data2 };
             const result = childTemplate(merged, runtime);
             currentBase = savedBase;
             return result;
@@ -611,7 +650,7 @@ var createRenderer = (options) => {
     const html = env.compile(templateSrc)(data, {
       partials: { ...env.partials, "@partial-block": () => "" }
     });
-    const diagnostics = [];
+    const diagnostics = [...dataDiagnostics.values()];
     const htmlReport = htmlValidator.validateStringSync(html);
     for (const result of htmlReport.results) {
       for (const msg of result.messages) {
@@ -660,7 +699,7 @@ var createRenderer = (options) => {
       }
     } catch {
     }
-    const meta = diagnostics.length > 0 ? { componentId: input.component, variant: input.variant, diagnostics } : void 0;
+    const meta = diagnostics.length > 0 ? { componentId, variant, diagnostics } : void 0;
     return { html, document: buildDocument(html, options), ...meta ? { meta } : {} };
   };
 };
@@ -683,9 +722,26 @@ import * as sass from "sass";
 import postcss from "postcss";
 import autoprefixer from "autoprefixer";
 import { build as esbuildBuild } from "esbuild";
+import { existsSync } from "node:fs";
 import { readdir as readdir2 } from "node:fs/promises";
-import { join as join2, extname, resolve } from "node:path";
+import { dirname as dirname2, join as join2, extname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+var packageOptionsCache = /* @__PURE__ */ new Map();
+function sassPackageOptions(entryFile) {
+  const start = dirname2(resolve(entryFile));
+  let options = packageOptionsCache.get(start);
+  if (!options) {
+    const loadPaths = [];
+    for (let dir = start; ; dir = dirname2(dir)) {
+      const modules = join2(dir, "node_modules");
+      if (existsSync(modules)) loadPaths.push(modules);
+      if (dirname2(dir) === dir) break;
+    }
+    options = { loadPaths, importers: [new sass.NodePackageImporter(start)] };
+    packageOptionsCache.set(start, options);
+  }
+  return options;
+}
 async function collectScssFiles(dir) {
   const files = [];
   async function walk(current) {
@@ -708,7 +764,7 @@ async function collectScssFiles(dir) {
   return files;
 }
 async function compileSassFileWithDeps(filePath) {
-  const result = sass.compile(filePath);
+  const result = sass.compile(filePath, sassPackageOptions(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 };
@@ -1180,7 +1236,7 @@ async function loadGlobalData(dataDirs) {
 
 // packages/dev-server/src/surfacing.ts
 import { mkdir, readFile as readFile5, writeFile } from "node:fs/promises";
-import { join as join7, relative as relative3 } from "node:path";
+import { join as join8, relative as relative3 } from "node:path";
 
 // packages/dev-server/src/flattening.ts
 import { parse as parseHtml } from "node-html-parser";
@@ -1426,11 +1482,108 @@ function pdScratchDir(root) {
   return join5(tmpdir(), "pattern-dump", key);
 }
 
+// packages/dev-server/src/server-config.ts
+import { basename as basename3, join as join6, resolve as resolve4 } from "node:path";
+function shadowedAssetRoots(assetRoots) {
+  const first = /* @__PURE__ */ new Map();
+  const shadowed = [];
+  for (const root of assetRoots) {
+    const by = first.get(basename3(root));
+    if (by === void 0) first.set(basename3(root), root);
+    else if (by !== root) shadowed.push({ root, by });
+  }
+  return shadowed;
+}
+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) => join6(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, base: config.documentBase },
+    ...packages.filter((p) => p.manifest.styles && p.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, base: p.manifest.styles.documentBase };
+    })
+  ];
+  const themePackages = packages.filter((p) => p.manifest.themes);
+  const themeDirs = [
+    ...config.themes?.dir ? [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.styles && (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) => basename3(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/style-index.ts
-import { dirname as dirname2, join as join6, relative as relative2, resolve as resolve4 } from "node:path";
-import { existsSync } from "node:fs";
+import { dirname as dirname3, join as join7, relative as relative2, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import postcss3 from "postcss";
+import selectorParser from "postcss-selector-parser";
 import { SourceMapConsumer } from "source-map";
 import * as sass2 from "sass";
 
@@ -1442,6 +1595,10 @@ function cssNodeText(node) {
   const text = node.toString();
   return node.type === "atrule" && !node.nodes ? `${text};` : text;
 }
+function addLastOccurrence(bucket, chunk) {
+  bucket.delete(chunk);
+  bucket.add(chunk);
+}
 function joinCssChunks(chunks) {
   const charset = [];
   const imports = [];
@@ -1453,7 +1610,33 @@ function joinCssChunks(chunks) {
   }
   return [...charset.slice(0, 1), ...imports, ...rest].join("\n");
 }
-var stripOrderPrefixes = (path) => path.split("/").map((seg) => seg.replace(/^\d+[-_]/, "")).join("/");
+var selectorClassCache = /* @__PURE__ */ new Map();
+function selectorClasses(selector) {
+  const cached = selectorClassCache.get(selector);
+  if (cached) return cached;
+  const defines = /* @__PURE__ */ new Set();
+  const mentions = /* @__PURE__ */ new Set();
+  try {
+    selectorParser((list) => {
+      list.each((complex) => {
+        const contextFree = !complex.some((node) => node.type === "combinator");
+        complex.walkClasses((cls) => {
+          (contextFree && cls.parent === complex ? defines : mentions).add(cls.value);
+        });
+      });
+    }).processSync(selector);
+  } catch {
+    for (const m of selector.matchAll(/\.([\w-]+)/g)) defines.add(m[1]);
+  }
+  for (const name of defines) mentions.delete(name);
+  const result = { defines: [...defines], mentions: [...mentions] };
+  selectorClassCache.set(selector, result);
+  return result;
+}
+function claimRank(owner, defines) {
+  return (defines ? 2 : 0) + (owner === "__base__" ? 0 : 1);
+}
+var indexRanks = /* @__PURE__ */ new WeakMap();
 var strippedIdCache = /* @__PURE__ */ new WeakMap();
 function strippedIds(componentIds) {
   let map = strippedIdCache.get(componentIds);
@@ -1506,55 +1689,72 @@ function missingDocumentBase(stylesDir, base2) {
   return (base2 ?? []).filter((entry) => {
     const e = normalizeBaseEntry(entry);
     if (e === "") return false;
-    const dir = dirname2(join6(stylesDir, e));
+    const dir = dirname3(join7(stylesDir, e));
     const name = e.split("/").pop();
-    return ![join6(stylesDir, e), join6(dir, `${name}.scss`), join6(dir, `_${name}.scss`)].some(existsSync);
+    return ![join7(stylesDir, e), join7(dir, `${name}.scss`), join7(dir, `_${name}.scss`)].some(existsSync2);
   });
 }
 function extractClassesFromCompiled(consumer, root, entryFile, stylesDir, componentIds) {
   const classMap = /* @__PURE__ */ new Map();
   const baseModules = /* @__PURE__ */ new Map();
+  const ranks = /* @__PURE__ */ new Map();
   root.walkRules((rule) => {
-    const classMatches = rule.selector.match(/\.([\w-]+)/g);
-    if (!classMatches) return;
+    const { defines, mentions } = selectorClasses(rule.selector);
+    if (defines.length === 0 && mentions.length === 0) 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) : resolve4(dirname2(entryFile), original.source);
+    const originPath = original.source.startsWith("file://") ? fileURLToPath2(original.source) : resolve5(dirname3(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)) {
+    const claim = (name, rank) => {
+      const prev = ranks.get(name);
+      if (prev === void 0 || rank > prev) {
+        classMap.set(name, owner);
+        ranks.set(name, rank);
+        if (modulePath && owner === "__base__") baseModules.set(name, modulePath);
+        else baseModules.delete(name);
+      } else if (modulePath && owner === "__base__" && classMap.get(name) === "__base__" && !baseModules.has(name)) {
         baseModules.set(name, modulePath);
       }
-    }
+    };
+    for (const name of defines) claim(name, claimRank(owner, true));
+    for (const name of mentions) claim(name, claimRank(owner, false));
   });
-  return { classMap, baseModules };
+  return { classMap, baseModules, ranks };
 }
 async function attributeClassesFromFile(entryFile, stylesDir, componentIds) {
   try {
-    const compiled = sass2.compile(entryFile, { sourceMap: true });
+    const compiled = sass2.compile(entryFile, { sourceMap: true, ...sassPackageOptions(entryFile) });
     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;
+    const { classMap, ranks } = extractClassesFromCompiled(consumer, root, entryFile, stylesDir, componentIds);
+    return { classMap, ranks };
   } catch {
     return null;
   }
 }
 async function patchClassOwnerIndex(entryFile, changedCompId, stylesDir, componentIds, index) {
+  const ranks = indexRanks.get(index);
   for (const [cls, owner] of index) {
-    if (owner === changedCompId) index.delete(cls);
+    if (owner === changedCompId) {
+      index.delete(cls);
+      ranks?.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);
+  for (const [name, owner] of fresh.classMap) {
+    if (owner !== changedCompId) continue;
+    const rank = fresh.ranks.get(name) ?? 0;
+    const prev = ranks?.get(name);
+    if (!index.has(name) || prev !== void 0 && rank > prev) {
+      index.set(name, owner);
+      ranks?.set(name, rank);
+    }
   }
   return true;
 }
@@ -1562,6 +1762,8 @@ 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 classRanks = /* @__PURE__ */ new Map();
+  indexRanks.set(classIndex, classRanks);
   const baseProvenance = /* @__PURE__ */ new Map();
   const componentCssBuckets = /* @__PURE__ */ new Map();
   const baseCssByRoot = [];
@@ -1579,12 +1781,11 @@ async function buildAllStyleData(roots, componentIds, entryOverride) {
       entryFiles = [...styleRoot.entries];
     } else {
       try {
-        entryFiles = await collectScssFiles(stylesDir);
+        entryFiles = (await collectScssFiles(stylesDir)).sort();
       } catch {
         entryFiles = [];
       }
     }
-    entryFiles.sort();
     for (const entryFile of entryFiles) {
       let originPathFor2 = function(node) {
         const pos = node.source?.start;
@@ -1594,18 +1795,18 @@ async function buildAllStyleData(roots, componentIds, entryOverride) {
           column: pos.column - 1
         });
         if (!original.source) return null;
-        return original.source.startsWith("file://") ? fileURLToPath2(original.source) : resolve4(dirname2(entryFile), original.source);
+        return original.source.startsWith("file://") ? fileURLToPath2(original.source) : resolve5(dirname3(entryFile), original.source);
       };
       var originPathFor = originPathFor2;
       const compOwner = resolveScssToComponent(entryFile, stylesDir, componentIds);
       let compiled;
       try {
-        compiled = sass2.compile(entryFile, { sourceMap: true });
+        compiled = sass2.compile(entryFile, { sourceMap: true, ...sassPackageOptions(entryFile) });
       } catch {
         continue;
       }
       if (compOwner) {
-        const deps = compiled.loadedUrls.filter((u) => u.protocol === "file:").map((u) => fileURLToPath2(u)).filter((p) => resolve4(p) !== resolve4(entryFile));
+        const deps = compiled.loadedUrls.filter((u) => u.protocol === "file:").map((u) => fileURLToPath2(u)).filter((p) => resolve5(p) !== resolve5(entryFile));
         for (const dep of deps) {
           const depComp = resolveScssToComponent(dep, stylesDir, componentIds);
           if (depComp !== null && depComp !== compOwner) {
@@ -1640,7 +1841,7 @@ async function buildAllStyleData(roots, componentIds, entryOverride) {
         const nodeText = cssNodeText(node);
         const owner = inBase(originPath) ? "__base__" : resolveScssToComponent(originPath, stylesDir, componentIds) ?? "__base__";
         if (owner === "__base__") {
-          baseCssBucket.add(nodeText);
+          addLastOccurrence(baseCssBucket, nodeText);
           if (reportOutside && !inBase(originPath)) {
             const seen = outsideRules.get(originPath) ?? /* @__PURE__ */ new Set();
             seen.add(nodeText);
@@ -1648,16 +1849,23 @@ async function buildAllStyleData(roots, componentIds, entryOverride) {
           }
         } else {
           const bucket = componentCssBuckets.get(owner) ?? /* @__PURE__ */ new Set();
-          bucket.add(nodeText);
+          addLastOccurrence(bucket, nodeText);
           componentCssBuckets.set(owner, bucket);
         }
       });
-      const { classMap: perFileClasses, baseModules: perFileBaseModules } = extractClassesFromCompiled(consumer, root, entryFile, stylesDir, componentIds);
+      const { classMap: perFileClasses, baseModules: perFileBaseModules, ranks: perFileRanks } = 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);
+        const rank = perFileRanks.get(name) ?? 0;
+        const prev = classRanks.get(name);
+        const mod = perFileBaseModules.get(name);
+        if (prev === void 0 || rank > prev) {
+          classIndex.set(name, owner);
+          classRanks.set(name, rank);
+          if (mod) baseProvenance.set(name, mod);
+          else baseProvenance.delete(name);
+        } else if (mod && classIndex.get(name) === "__base__" && !baseProvenance.has(name)) {
+          baseProvenance.set(name, mod);
+        }
       }
     }
     baseCssByRoot[baseCssByRoot.length - 1] = [...baseCssBucket];
@@ -1687,7 +1895,7 @@ async function surfaceCollisions(collisions, cwd, hotreloader) {
     hotreloader.push(messages[i]);
     console.warn(`[dev-server] HANDLE_COLLISION: "${col.handle}" \u2014 incumbent: ${col.incumbentPath} \u2014 quarantined: ${col.quarantinedPath}`);
   }
-  if (collisions.length > 0) console.warn(`[dev-server] collisions listed in ${join7(pdScratchDir(cwd), "CONFLICTS.generated.md")}`);
+  if (collisions.length > 0) console.warn(`[dev-server] collisions listed in ${join8(pdScratchDir(cwd), "CONFLICTS.generated.md")}`);
   const md = collisions.length === 0 ? "# Conflicts\n\nNo handle collisions detected.\n" : [
     "# Conflicts",
     "",
@@ -1703,7 +1911,7 @@ async function surfaceCollisions(collisions, cwd, hotreloader) {
   try {
     const dir = pdScratchDir(cwd);
     await mkdir(dir, { recursive: true });
-    await writeFile(join7(dir, "CONFLICTS.generated.md"), md, "utf-8");
+    await writeFile(join8(dir, "CONFLICTS.generated.md"), md, "utf-8");
   } catch (e) {
     console.warn("[dev-server] Could not write CONFLICTS.generated.md to scratch dir:", e);
   }
@@ -1724,12 +1932,12 @@ async function surfaceFlattening(discoveryMap, registry, cwd) {
   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 ${join7(pdScratchDir(cwd), "FLATTENED.generated.md")}`);
+    console.warn(`[dev-server] FLATTENED: ${clusters.length} cluster(s) across ${members} components \u2014 see ${join8(pdScratchDir(cwd), "FLATTENED.generated.md")}`);
   }
   try {
     const dir = pdScratchDir(cwd);
     await mkdir(dir, { recursive: true });
-    await writeFile(join7(dir, "FLATTENED.generated.md"), md, "utf-8");
+    await writeFile(join8(dir, "FLATTENED.generated.md"), md, "utf-8");
   } catch (e) {
     console.warn("[dev-server] Could not write FLATTENED.generated.md to scratch dir:", e);
   }
@@ -1746,11 +1954,21 @@ function surfaceDocumentBase(roots, outsideList, cwd) {
   const examples = files.slice(0, 3).map(([path]) => relative3(cwd, path)).join(", ");
   console.log(`[dev-server] base layer: ${rules} rule(s) from ${files.length} file(s) that no component owns and documentBase does not list, e.g. ${examples}`);
 }
+function surfaceAssetRoots(assetRoots, cwd) {
+  for (const { root, by } of shadowedAssetRoots(assetRoots)) {
+    console.warn(`[dev-server] assets: ${relative3(cwd, root)} is hidden by ${relative3(cwd, by) || "."}, which has the same folder name; its files are not served`);
+  }
+}
+function surfaceDefaultTheme(defaultTheme, themeNames) {
+  if (!defaultTheme || themeNames.includes(defaultTheme)) return;
+  const available = themeNames.length ? `available: ${[...themeNames].sort().join(", ")}` : "no theme folder is configured or provided by a package";
+  console.warn(`[dev-server] themes.default "${defaultTheme}" matches no theme; ${available}`);
+}
 
 // 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 join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // packages/a11y/src/producer.ts
 import { createRequire } from "node:module";
@@ -1904,7 +2122,7 @@ function assembleGraph(audits) {
 }
 var GRAPH_ARTIFACT_VERSION = 1;
 function graphArtifactPath(root) {
-  return join8(pdScratchDir(root), "diagnostics-graph.json");
+  return join9(pdScratchDir(root), "diagnostics-graph.json");
 }
 async function readDiagnosticsArtifact(root) {
   try {
@@ -1959,101 +2177,15 @@ async function persistSlices(root, slices, discoveryMap, globalData) {
   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 join9, resolve as resolve5 } 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 = resolve5(cwd, config.patternsDir);
-  const stylesDir = resolve5(cwd, config.styles.dir);
-  const stylesEntries = config.styles.entry ? (Array.isArray(config.styles.entry) ? config.styles.entry : [config.styles.entry]).map((e) => resolve5(stylesDir, e)) : void 0;
-  const inPackage = (p, rel) => join9(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, base: config.documentBase },
-    ...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) => resolve5(dir, e));
-      return { dir, entries: entries.length ? entries : void 0, source: p.name, base: p.manifest.styles.documentBase };
-    })
-  ];
-  const themePackages = packages.filter((p) => p.manifest.themes);
-  const themeDirs = [
-    ...config.themes ? [resolve5(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) => resolve5(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 ? [resolve5(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 ? [resolve5(cwd, config.dataDir)] : []
-    ],
-    helperPaths: [
-      ...packages.filter((p) => p.manifest.helpers).map((p) => inPackage(p, p.manifest.helpers)),
-      ...config.helpers ? [resolve5(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 as existsSync2, readFileSync } from "node:fs";
-import { dirname as dirname3, join as join10 } from "node:path";
+import { existsSync as existsSync3, readFileSync } from "node:fs";
+import { dirname as dirname4, join as join10 } from "node:path";
 function findPackageDir(name, root) {
   let dir = root;
   for (; ; ) {
     const candidate = join10(dir, "node_modules", name);
-    if (existsSync2(join10(candidate, "package.json"))) return candidate;
-    const parent = dirname3(dir);
+    if (existsSync3(join10(candidate, "package.json"))) return candidate;
+    const parent = dirname4(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -2061,7 +2193,7 @@ function findPackageDir(name, root) {
 function loadPatternPackages(references, root) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const visit = (name, extraExclude, direct, from) => {
+  const visit = (name, direct, from) => {
     if (seen.has(name)) return;
     const dir = findPackageDir(name, from);
     if (!dir) {
@@ -2081,14 +2213,16 @@ function loadPatternPackages(references, root) {
       version: pkg.version ?? "0.0.0",
       dir,
       manifest: pkg.patternDump,
-      exclude: [...pkg.patternDump.exclude ?? [], ...extraExclude],
-      direct
+      exclude: [...pkg.patternDump.exclude ?? [], ...options.get(name)?.exclude ?? []],
+      direct,
+      styles: options.get(name)?.styles ?? true
     });
-    for (const peer of Object.keys(pkg.peerDependencies ?? {})) visit(peer, [], false, dir);
+    for (const peer of Object.keys(pkg.peerDependencies ?? {})) visit(peer, false, dir);
   };
+  const options = /* @__PURE__ */ new Map();
+  for (const ref of references ?? []) if (typeof ref !== "string") options.set(ref.name, ref);
   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);
+    visit(typeof ref === "string" ? ref : ref.name, true, root);
   }
   return out;
 }
@@ -2124,7 +2258,7 @@ async function runDiagnosticsAudit(config, 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 dirname4, join as join11, relative as relative4, resolve as resolve6, sep } from "node:path";
+import { dirname as dirname5, join as join11, relative as relative4, resolve as resolve6, sep } from "node:path";
 
 // packages/dev-server/src/http-utils.ts
 import { readFile as readFile7 } from "node:fs/promises";
@@ -2245,7 +2379,7 @@ async function buildStaticSite(config, root, opts) {
     }
     const type = res.headers.get("content-type") ?? "";
     const target = diskPath(outDir, file);
-    await mkdir3(dirname4(target), { recursive: true });
+    await mkdir3(dirname5(target), { recursive: true });
     if (isText(type)) {
       const body = await res.text();
       const out = withBasePath(body, basePath);
@@ -2265,7 +2399,7 @@ async function buildStaticSite(config, root, opts) {
     if (done.has(file)) return;
     done.add(file);
     const target = diskPath(outDir, file);
-    await mkdir3(dirname4(target), { recursive: true });
+    await mkdir3(dirname5(target), { recursive: true });
     const out = withBasePath(body, basePath);
     await writeFile3(target, out);
     report.bytes += Buffer.byteLength(out);
@@ -2328,7 +2462,13 @@ async function buildStaticSite(config, root, opts) {
     } else {
       log("\u2026 corpus audit left out (build.audit: false / --no-audit)");
     }
+    const shadowed = new Map(shadowedAssetRoots(cfg.assetRoots).map((s) => [s.root, s.by]));
     for (const [i, rootDir] of cfg.assetRoots.entries()) {
+      const by = shadowed.get(rootDir);
+      if (by !== void 0) {
+        report.warnings.push(`assets: ${relative4(root, rootDir)} is hidden by ${relative4(root, by) || "."}, which has the same folder name; left out`);
+        continue;
+      }
       const exists = await stat2(rootDir).then((s) => s.isDirectory(), () => false);
       if (!exists) continue;
       await cp(rootDir, join11(outDir, "assets", cfg.assetRootNames[i]), { recursive: true });
@@ -2344,7 +2484,7 @@ async function buildStaticSite(config, root, opts) {
     const shell = withBasePath(buildShellHtml(runtime), basePath);
     for (const route of routes) {
       const target = diskPath(outDir, staticPathFor(route));
-      await mkdir3(dirname4(target), { recursive: true });
+      await mkdir3(dirname5(target), { recursive: true });
       await writeFile3(target, shell);
       report.files++;
       report.bytes += Buffer.byteLength(shell);
@@ -2358,6 +2498,99 @@ async function buildStaticSite(config, root, opts) {
   return report;
 }
 
+// packages/dev-server/src/requires.ts
+import { readFile as readFile8 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { basename as basename4, join as join12, relative as relative5 } from "node:path";
+function normalizeScriptId(raw) {
+  let s = raw.trim().replace(/^\[(.+)\]$/, "$1").trim();
+  s = basename4(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 readFile8(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 readFile8(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 readFile8(join12(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" ');
+}
+async function reportUnresolvableScripts(discoveryMap, scriptsDirs, globalScripts, cwd) {
+  const resolves = (id) => scriptsDirs.some((d) => existsSync4(join12(d, `${id}.ts`)));
+  const where = scriptsDirs.length ? scriptsDirs.map((d) => relative5(cwd, d) || d).join(" or ") : "no scriptsDir configured";
+  for (const id of globalScripts) {
+    if (id.includes("://") || resolves(normalizeScriptId(id))) continue;
+    console.warn(`[dev-server] globalScripts "${id}": no ${normalizeScriptId(id)}.ts in ${where}`);
+  }
+  for (const [componentId, entry] of discoveryMap) {
+    if (!entry.mdPath) continue;
+    let md;
+    try {
+      md = await readFile8(entry.mdPath, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const raw of parseFrontmatterList(md, "requireScript")) {
+      const id = normalizeScriptId(raw);
+      if (resolves(id)) continue;
+      console.warn(`[dev-server] requireScript "${raw}" on ${componentId}: no ${id}.ts in ${where}`);
+    }
+  }
+}
+
 // packages/dev-server/src/server-state.ts
 function createServerState() {
   return {
@@ -2399,25 +2632,25 @@ function applyStyleData(state, data) {
 }
 
 // packages/dev-server/src/routes.ts
-import { basename as basename4, extname as extname2, join as join18 } from "node:path";
+import { basename as basename5, extname as extname2, join as join18, relative as relative6 } from "node:path";
 import { readFile as readFile15, stat as stat4 } from "node:fs/promises";
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 
 // packages/dev-server/src/component-tree.ts
+import { readFile as readFile11 } from "node:fs/promises";
+import { join as join15 } from "node:path";
+
+// packages/dev-server/src/layout-mode.ts
 import { readFile as readFile10 } from "node:fs/promises";
 import { join as join14 } from "node:path";
 
-// packages/dev-server/src/layout-mode.ts
+// packages/dev-server/src/pattern-dirs.ts
 import { readFile as readFile9 } from "node:fs/promises";
 import { join as join13 } from "node:path";
-
-// packages/dev-server/src/pattern-dirs.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import { join as join12 } from "node:path";
 async function readFolderFile(dirs, rel) {
   for (const dir of typeof dirs === "string" ? [dirs] : dirs) {
     try {
-      return await readFile8(join12(dir, rel), "utf-8");
+      return await readFile9(join13(dir, rel), "utf-8");
     } catch {
     }
   }
@@ -2429,8 +2662,8 @@ 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, join13(category, "index.md"));
+  let layout = FULL_CATEGORIES.has(stripOrderPrefixes(category)) ? "full" : "centered";
+  const categoryIndex = await readFolderFile(patternsDir, join14(category, "index.md"));
   if (categoryIndex !== null) {
     const m = categoryIndex.match(/^preview:\s*(centered|full)$/m);
     if (m) layout = m[1];
@@ -2438,7 +2671,7 @@ async function resolveLayoutMode(componentId, patternsDir, discoveryMap) {
   const mdPath = discoveryMap?.get(componentId)?.mdPath;
   if (mdPath) {
     try {
-      const md = await readFile9(mdPath, "utf-8");
+      const md = await readFile10(mdPath, "utf-8");
       const m = md.match(/^preview:\s*(centered|full)$/m);
       if (m) layout = m[1];
     } catch {
@@ -2531,7 +2764,7 @@ function folderTitle(segment) {
   const text = words.join(" ");
   return text.charAt(0).toUpperCase() + text.slice(1);
 }
-var readText = (path) => readFile10(path, "utf-8").catch(() => null);
+var readText = (path) => readFile11(path, "utf-8").catch(() => null);
 function orderOf(md) {
   return md === null ? void 0 : parseOrder(readFrontmatter(md)["order"]);
 }
@@ -2582,7 +2815,7 @@ async function buildTreeNodeFromMap(nodePath, idsUnderPath, patternsDir, overvie
       if (o && "weight" in o) weight = o.weight;
     }
   }
-  const indexMd = await readFolderFile(patternsDir, join14(nodePath, "index.md"));
+  const indexMd = await readFolderFile(patternsDir, join15(nodePath, "index.md"));
   const folderOrder = orderOf(indexMd);
   const built = [];
   for (const childPath of directChildPaths(nodePath, idsUnderPath)) {
@@ -2630,7 +2863,7 @@ async function buildTreeNodeFromMap(nodePath, idsUnderPath, patternsDir, overvie
 import { readFile as readFile14 } from "node:fs/promises";
 
 // packages/dev-server/src/markdown.ts
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 import MarkdownIt from "markdown-it";
 var _md = new MarkdownIt({ html: false, linkify: false });
 _md.validateLink = (url) => {
@@ -2719,7 +2952,7 @@ async function _resolveFence(info, content, idx, renderComponent, out, discovery
       return;
     }
     try {
-      const src = await readFile11(entry.hbsPath, "utf-8");
+      const src = await readFile12(entry.hbsPath, "utf-8");
       out.set(idx, wrapWithCopyButton(highlight(src, "handlebars"), src));
     } catch (e) {
       console.warn(`[dev-server] src-template read error [${spec}]:`, e);
@@ -2744,8 +2977,8 @@ async function _resolveFence(info, content, idx, renderComponent, out, discovery
         }
         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 baseData = baseJsonPath ? JSON.parse(await readFile12(baseJsonPath, "utf-8")) : {};
+        const variantData = variantJsonPath ? JSON.parse(await readFile12(variantJsonPath, "utf-8")) : {};
         const merged = deepMerge(structuredClone(baseData), variantData);
         const src = JSON.stringify(merged, null, 2);
         out.set(idx, wrapWithCopyButton(highlight(src, "json"), src));
@@ -2755,7 +2988,7 @@ async function _resolveFence(info, content, idx, renderComponent, out, discovery
           out.set(idx, `<p class="doc-error">[src-data: ${escapeHtml(spec)} \u2014 no data file]</p>`);
           return;
         }
-        const src = await readFile11(jsonPath, "utf-8");
+        const src = await readFile12(jsonPath, "utf-8");
         out.set(idx, wrapWithCopyButton(highlight(src, "json"), src));
       }
     } catch (e) {
@@ -2785,8 +3018,8 @@ async function _resolveFence(info, content, idx, renderComponent, out, discovery
 }
 
 // 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 { readFile as readFile13 } from "node:fs/promises";
+import { dirname as dirname6, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import postcss4 from "postcss";
 import * as sass3 from "sass";
@@ -2794,7 +3027,7 @@ import { SourceMapConsumer as SourceMapConsumer2 } from "source-map";
 import { parse as parseHtml2 } from "node-html-parser";
 async function recomputeComponentCss(entryFile, compId, stylesDir, componentIds, inBase = () => false) {
   try {
-    const compiled = sass3.compile(entryFile, { sourceMap: true });
+    const compiled = sass3.compile(entryFile, { sourceMap: true, ...sassPackageOptions(entryFile) });
     const rawMap = compiled.sourceMap;
     if (!rawMap) return null;
     const consumer = new SourceMapConsumer2(rawMap);
@@ -2805,10 +3038,10 @@ async function recomputeComponentCss(entryFile, compId, stylesDir, componentIds,
       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 originPath = original.source.startsWith("file://") ? fileURLToPath3(original.source) : resolve7(dirname6(entryFile), original.source);
       if (inBase(originPath)) return;
       const originComp = resolveScssToComponent(originPath, stylesDir, componentIds);
-      if (originComp === compId) bucket.add(cssNodeText(node));
+      if (originComp === compId) addLastOccurrence(bucket, cssNodeText(node));
     });
     return joinCssChunks(bucket);
   } catch {
@@ -2825,7 +3058,7 @@ async function computeCssClosure(componentId, compReg, patternsDir, classOwnerIn
     const hbsPath = discoveryMap.get(id)?.hbsPath ?? "";
     let hbs = "";
     try {
-      hbs = hbsPath ? await readFile12(hbsPath, "utf-8") : "";
+      hbs = hbsPath ? await readFile13(hbsPath, "utf-8") : "";
     } catch {
     }
     const { styleUses } = deriveClassBorrowingFields(hbs, id, classOwnerIndex);
@@ -2881,76 +3114,6 @@ 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 join15, 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(join15(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("/");
@@ -3075,7 +3238,7 @@ async function buildComponentDetail(componentId, patternsDir, renderFn, tracker,
 import { join as join16 } from "node:path";
 async function buildFolderOverview(folderPath, patternsDir, renderFn, discoveryMap) {
   const category = folderPath.split("/")[0];
-  let folderLayout = FULL_CATEGORIES.has(category) ? "full" : "centered";
+  let folderLayout = FULL_CATEGORIES.has(stripOrderPrefixes(category)) ? "full" : "centered";
   let doc;
   try {
     const rawIndex = await readFolderFile(patternsDir, join16(folderPath, "index.md"));
@@ -3214,10 +3377,10 @@ function normalizeAssetRefs(text, rootNames) {
 }
 
 // packages/dev-server/src/assets.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-function resolveDevUiDist(moduleUrl, exists = existsSync3) {
+function resolveDevUiDist(moduleUrl, exists = existsSync5) {
   const packaged = fileURLToPath4(new URL("./dev-ui/", moduleUrl));
   if (exists(`${packaged}main.js`)) return packaged;
   return fileURLToPath4(new URL("../../../apps/dev-ui/dist/", moduleUrl));
@@ -3290,7 +3453,7 @@ async function handleRequest(req, res, ctx) {
         return;
       }
       const themeName = decodeURIComponent(
-        basename4(pathname, ".css")
+        basename5(pathname, ".css")
       );
       if (state.themeCss.has(themeName)) {
         res.writeHead(200, { "Content-Type": "text/css" });
@@ -3307,10 +3470,15 @@ async function handleRequest(req, res, ctx) {
         res.end("No scriptsDir configured");
         return;
       }
-      const scriptId = normalizeScriptId(decodeURIComponent(basename4(pathname, ".js")));
+      const scriptId = normalizeScriptId(decodeURIComponent(basename5(pathname, ".js")));
       try {
         if (!state.scriptCache.has(scriptId)) {
-          const entryPoint = scriptsDirs.map((d) => join18(d, `${scriptId}.ts`)).find((f) => existsSync4(f)) ?? join18(scriptsDirs[0], `${scriptId}.ts`);
+          const entryPoint = scriptsDirs.map((d) => join18(d, `${scriptId}.ts`)).find((f) => existsSync6(f));
+          if (entryPoint === void 0) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end(`No script "${scriptId}": scripts are TypeScript, so ${scriptId}.ts is expected in ` + scriptsDirs.map((d) => relative6(cwd, d) || d).join(" or "));
+            return;
+          }
           const js = await compileScriptFile(entryPoint);
           state.scriptCache.set(scriptId, js);
         }
@@ -3594,12 +3762,12 @@ function describeBindError(e, port2, role, ports) {
 }
 
 // packages/dev-server/src/watch.ts
-import { basename as basename5, extname as extname3, relative as relative5, resolve as resolve8 } from "node:path";
+import { basename as basename6, extname as extname3, relative as relative7, resolve as resolve8 } from "node:path";
 import chokidar from "chokidar";
 function startWatching(ctx) {
   const { cfg, state, render, tracker, hotreloader } = ctx;
   const { patternsDir, stylesDir, styleRoots, patternRoots, patternDirs, swatchSlots, cwd } = cfg;
-  const themesDir = cfg.config.themes ? cfg.themesDir : null;
+  const themesDir = cfg.config.themes?.dir ? cfg.themesDir : null;
   const scriptsDir = cfg.config.scriptsDir ? cfg.scriptsDirs[0] ?? null : null;
   const inProjectBase = documentBaseMatcher(stylesDir, cfg.config.documentBase);
   const watchDirs = [patternsDir, stylesDir, ...themesDir ? [themesDir] : [], ...scriptsDir ? [scriptsDir] : []];
@@ -3618,7 +3786,7 @@ function startWatching(ctx) {
       hotreloader.push({
         type: "error",
         scope: "build",
-        message: `SCSS ${basename5(file)} \u2014 ${message.split("\n")[0]}`
+        message: `SCSS ${basename6(file)} \u2014 ${message.split("\n")[0]}`
       });
     }
     state.scssGraphDirty = true;
@@ -3663,10 +3831,10 @@ function startWatching(ctx) {
     }
     const orderedHrefs = await closureHrefs(timestamp);
     for (const m of pending) hotreloader.push({ ...m, orderedHrefs });
-    console.log(`[dev-server] CSS updated (recompiled: ${effectiveFiles.map((f) => basename5(f)).join(", ")})`);
+    console.log(`[dev-server] CSS updated (recompiled: ${effectiveFiles.map((f) => basename6(f)).join(", ")})`);
   }
   async function restyleAll(allIds, timestamp, files, hadCompileErrors) {
-    const names = files.map((f) => basename5(f)).join(", ");
+    const names = files.map((f) => basename6(f)).join(", ");
     if (hadCompileErrors) {
       console.warn(`[dev-server] CSS not updated \u2014 compile errors (recompiled: ${names})`);
       return;
@@ -3706,7 +3874,7 @@ function startWatching(ctx) {
       }
       return void 0;
     };
-    const rel = relative5(patternsDir, filePath);
+    const rel = relative7(patternsDir, filePath);
     if (event === "change") state.discoveryResult ??= await buildDiscoveryMap(patternRoots);
     let owner = ownerIn(state.discoveryResult);
     if (event === "change") {
@@ -3728,7 +3896,7 @@ function startWatching(ctx) {
     }
     if (ext === ".scss") {
       if (themesDir && filePath.startsWith(themesDir)) {
-        const themeName = basename5(filePath, ".theme.scss");
+        const themeName = basename6(filePath, ".theme.scss");
         try {
           const css = await compileSassFile(filePath);
           state.themeCss.set(themeName, css);
@@ -3764,7 +3932,7 @@ function startWatching(ctx) {
         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");
+      const scriptId = basename6(filePath, ".ts");
       state.scriptCache.delete(scriptId);
       if (state.lastComponentId) {
         hotreloader.push({ type: "content-swap", componentId: state.lastComponentId });
@@ -3788,21 +3956,21 @@ function startWatching(ctx) {
     if (ext === ".scss" && !(themesDir && filePath.startsWith(themesDir))) {
       await handleComponentScss(filePath);
     } else if (ext === ".hbs" && filePath.startsWith(patternsDir)) {
-      await rebuildAndSignalTree(`Pattern added: ${relative5(patternsDir, filePath)}`);
+      await rebuildAndSignalTree(`Pattern added: ${relative7(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: ${relative5(patternsDir, filePath)}`);
+      await rebuildAndSignalTree(`Pattern removed: ${relative7(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: ${relative5(patternsDir, dirPath)}`);
+      await rebuildAndSignalTree(`Pattern dir removed: ${relative7(patternsDir, dirPath)}`);
     }
   });
   return watcher;
@@ -3810,7 +3978,7 @@ function startWatching(ctx) {
 
 // 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 join19, relative as relative6, resolve as resolve9 } from "node:path";
+import { dirname as dirname7, join as join19, relative as relative8, resolve as resolve9 } from "node:path";
 
 // packages/dev-server/src/export.ts
 var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -3960,7 +4128,7 @@ async function planExport(config, cwd) {
       const hbs = await readFile16(entry.hbsPath, "utf-8");
       inputs.push({ id, hbs });
       hbsById.set(id, hbs);
-      relPathById.set(id, relative6(patternsDir, entry.hbsPath).replace(/\.hbs$/, ""));
+      relPathById.set(id, relative8(patternsDir, entry.hbsPath).replace(/\.hbs$/, ""));
       if (entry.jsonPath) {
         try {
           dataJsonById.set(id, await readFile16(entry.jsonPath, "utf-8"));
@@ -4004,7 +4172,7 @@ async function writeExport(families, sink) {
   for (const family of families) {
     const baseRel = `${family.baseId}.hbs`;
     const basePath = join19(sink, baseRel);
-    await mkdir4(dirname6(basePath), { recursive: true });
+    await mkdir4(dirname7(basePath), { recursive: true });
     await writeFile4(basePath, family.baseHbs, "utf-8");
     files.push(baseRel);
     if (family.baseData) {
@@ -4047,9 +4215,9 @@ async function writeThreadedIncluders(threaded, patternsDir, sink) {
     const res = rewriteIncludes(src, map);
     if (res.rewrites === 0) continue;
     rewrites += res.rewrites;
-    const rel = relative6(patternsDir, hbsPath);
+    const rel = relative8(patternsDir, hbsPath);
     const outPath = join19(sink, rel);
-    await mkdir4(dirname6(outPath), { recursive: true });
+    await mkdir4(dirname7(outPath), { recursive: true });
     await writeFile4(outPath, res.hbs, "utf-8");
     files.push(rel);
   }
@@ -4209,7 +4377,7 @@ async function startDevServer(config, cwd, opts = {}) {
       try {
         const css = await compileSassFile(join20(dir, `${name}.theme.scss`));
         state.themeCss.set(name, css);
-        const slots = config.themes && dir === cfg.themeDirs[0] ? swatchSlots : cfg.packageSwatchSlots;
+        const slots = config.themes?.dir && 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);
@@ -4218,6 +4386,7 @@ async function startDevServer(config, cwd, opts = {}) {
       }
     }
   }
+  surfaceDefaultTheme(cfg.defaultTheme, [...state.themeCss.keys()]);
   {
     const dr = await buildDiscoveryMap(patternRoots);
     state.discoveryResult = dr;
@@ -4231,6 +4400,8 @@ async function startDevServer(config, cwd, opts = {}) {
     const styleData = await buildAllStyleData(styleRoots, allComponentIds);
     applyStyleData(state, styleData);
     surfaceDocumentBase(styleRoots, styleData.baseOutsideList, cwd);
+    surfaceAssetRoots(cfg.assetRoots, cwd);
+    await reportUnresolvableScripts(dr.discoveryMap, cfg.scriptsDirs, cfg.globalScripts, cwd);
   }
   const boot = {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4271,9 +4442,9 @@ async function startDevServer(config, cwd, opts = {}) {
 
 // packages/core/src/index.ts
 import { build as esbuild } from "esbuild";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { readFile as readFile17, writeFile as writeFile5, unlink, mkdir as mkdir5 } from "node:fs/promises";
-import { join as join21, dirname as dirname7, resolve as resolve10, relative as relative7, isAbsolute } from "node:path";
+import { join as join21, dirname as dirname8, resolve as resolve10, relative as relative9, 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";
@@ -4301,7 +4472,7 @@ async function runAudit(root, configPath, format = "md") {
   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 = join21(dirname7(artifactPath), `diagnostics-report.${ext}`);
+  const reportPath = join21(dirname8(artifactPath), `diagnostics-report.${ext}`);
   await writeFile5(reportPath, report, "utf-8");
   console.log(report);
   const affected = new Set(graph.occurrences.map((o) => o.component)).size;
@@ -4316,7 +4487,7 @@ function defaultExportDir(root) {
   return join21(tmpdir2(), "pattern-dump", key, "export");
 }
 function assertOutsideRoot(outDir, root) {
-  const rel = relative7(resolve10(root), resolve10(outDir));
+  const rel = relative9(resolve10(root), resolve10(outDir));
   const inside = rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
   if (inside) {
     throw new Error(
@@ -4387,14 +4558,14 @@ async function runExport(root, configPath, outDir) {
 }
 async function loadConfig(root, configPath) {
   if (configPath) {
-    if (!existsSync5(configPath)) {
+    if (!existsSync7(configPath)) {
       throw new ConfigError(`--config file not found: ${configPath}`);
     }
     return validateConfig(await readConfigFile(configPath), configPath);
   }
   for (const name of ["pattern-dump.config.ts", "pattern-dump.config.json"]) {
     const path = join21(root, name);
-    if (existsSync5(path)) return validateConfig(await readConfigFile(path), name);
+    if (existsSync7(path)) return validateConfig(await readConfigFile(path), name);
   }
   throw new ConfigError(
     `No pattern-dump.config.ts or pattern-dump.config.json found in ${root} (and no --config given)`
@@ -4609,14 +4780,14 @@ var USAGE = `Usage: pd <command> [options]
   help [command]   Show this help`;
 
 // packages/cli/src/init/run.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { readFile as readFile19 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname9, join as join23, relative as relative9, resolve as resolve12 } from "node:path";
+import { basename as basename7, dirname as dirname10, join as join23, relative as relative11, resolve as resolve12 } from "node:path";
 
 // packages/cli/package.json
 var package_default = {
   name: "@pattern-dump/cli",
-  version: "0.1.0-alpha.2",
+  version: "0.1.0-alpha.4",
   private: true,
   description: "The pd command and the published pattern-dump package.",
   type: "module",
@@ -4652,14 +4823,14 @@ 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 join22, relative as relative8, sep as sep2 } from "node:path";
+import { dirname as dirname9, join as join22, relative as relative10, 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 = join22(current, entry.name);
       if (entry.isDirectory()) await walk(full);
-      else out.push({ path: relative8(dir, full).split(sep2).join("/"), content: await readFile18(full, "utf8") });
+      else out.push({ path: relative10(dir, full).split(sep2).join("/"), content: await readFile18(full, "utf8") });
     }
   }
   await walk(dir);
@@ -4676,7 +4847,7 @@ async function applyPlan(target, plan) {
   await mkdir6(target, { recursive: true });
   for (const file of plan.writes) {
     const abs = join22(target, file.path);
-    await mkdir6(dirname8(abs), { recursive: true });
+    await mkdir6(dirname9(abs), { recursive: true });
     await writeFile6(abs, file.content, { flag: "wx" });
   }
   await writeFile6(join22(target, "package.json"), plan.packageJson.content);
@@ -4759,12 +4930,12 @@ function mergePackageJson(current, answers, packageName) {
 function dependencySpec(pdSource, cwd) {
   if (pdSource === void 0) return `^${PD_VERSION}`;
   const asPath = resolve12(cwd, pdSource);
-  if (existsSync6(asPath)) return `file:${asPath}`;
+  if (existsSync8(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 (!existsSync6(dir) && dirname9(dir) !== dir) dir = dirname9(dir);
+  while (!existsSync8(dir) && dirname10(dir) !== dir) dir = dirname10(dir);
   return await io.run("git", ["rev-parse", "--is-inside-work-tree"], dir) === 0;
 }
 async function runInit(cmd, io) {
@@ -4789,7 +4960,7 @@ async function runInit(cmd, io) {
   }
   const pkgPath = join23(target, "package.json");
   let packageJson = null;
-  if (existsSync6(pkgPath)) {
+  if (existsSync8(pkgPath)) {
     try {
       packageJson = JSON.parse(await readFile19(pkgPath, "utf8"));
     } catch (e) {
@@ -4799,7 +4970,7 @@ async function runInit(cmd, io) {
   }
   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 name = cmd.name ?? (prompt ? await io.ask("Project name", existingName ?? toPackageName(basename7(target))) : existingName ?? toPackageName(basename7(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);
@@ -4807,14 +4978,14 @@ async function runInit(cmd, io) {
   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) => existsSync6(join23(target, p)) }, PD_PACKAGE_NAME);
+  const result = planInit(templates, answers, { packageJson, exists: (p) => existsSync8(join23(target, p)) }, PD_PACKAGE_NAME);
   if (!result.ok) {
     io.log(`\u2717 ${result.reason}`);
     return 1;
   }
   const { plan } = result;
   await applyPlan(target, plan);
-  const where = relative9(io.cwd, target) || ".";
+  const where = relative11(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}`);
@@ -4847,7 +5018,7 @@ async function runInit(cmd, io) {
 }
 
 // packages/cli/src/init/local-build.ts
-import { existsSync as existsSync7, statSync } from "node:fs";
+import { existsSync as existsSync9, statSync } from "node:fs";
 import { join as join24 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 var BUILT = [
@@ -4866,9 +5037,9 @@ var mtime = (path) => {
 };
 function detectLocalBuild(moduleUrl, packageName, version) {
   const repo = fileURLToPath6(new URL("../../../", moduleUrl)).replace(/[\\/]$/, "");
-  if (!existsSync7(join24(repo, "packages/cli/src/distribution.ts"))) return null;
+  if (!existsSync9(join24(repo, "packages/cli/src/distribution.ts"))) return null;
   const tarball = join24(repo, ".pd-pack", `${packageName}-${version}.tgz`);
-  if (!existsSync7(tarball)) return { repo, tarball: null, stale: false };
+  if (!existsSync9(tarball)) return { repo, tarball: null, stale: false };
   const newestBuild = Math.max(...BUILT.map((p) => mtime(join24(repo, p))));
   return { repo, tarball, stale: newestBuild > mtime(tarball) };
 }