@pandacss/config 2.0.0-beta.9 → 2.0.1

package/dist/index.js

@@ -1,12 +1,12 @@
 import {
   mergeConfigs,
   mergeConfigsWithSources
-} from "./chunk-PER4IFQZ.js";
+} from "./chunk-LDC4ZCDS.js";
 import {
   collectPluginHookHandlers,
   createConfigSnapshot,
   normalizeHook
-} from "./chunk-U6KCSKCU.js";
+} from "./chunk-Y642H6DU.js";
 import {
   PandaError,
   clone,
@@ -18,22 +18,22 @@ import {
 } from "./chunk-R4R5RHIS.js";
 
 // src/load.ts
-import { applyConfigDefaults } from "@pandacss/compiler-shared";
+import { applyConfigDefaults as applyConfigDefaults2 } from "@pandacss/compiler-shared";
 
 // src/bundle.ts
-import { existsSync, realpathSync } from "fs";
-import { mkdir, unlink, writeFile } from "fs/promises";
-import { builtinModules } from "module";
-import { tmpdir } from "os";
-import { dirname, isAbsolute as isAbsolute2, join, normalize, relative } from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
+import { existsSync, realpathSync } from "node:fs";
+import { mkdir, unlink, writeFile } from "node:fs/promises";
+import { builtinModules } from "node:module";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute as isAbsolute2, join, normalize, relative } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // src/bundle-plugins.ts
 import { parse } from "acorn";
 import { simple } from "acorn-walk";
 import MagicString from "magic-string";
-import { isAbsolute } from "path";
-import { pathToFileURL } from "url";
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
 function importMetaUrlPlugin() {
   return {
     name: "panda-import-meta-url",
@@ -105,6 +105,7 @@ async function bundleConfig(filepath, cwd) {
 }
 async function loadBundledModule(filepath, code) {
   const target = tempTargetFor(filepath);
+  let evalError;
   if (target) {
     try {
       await mkdir(dirname(target), { recursive: true });
@@ -117,14 +118,23 @@ async function loadBundledModule(filepath, code) {
       } finally {
         void unlink(target).catch(() => void 0);
       }
-    } catch {
+    } catch (error) {
+      if (!isUnresolvedTempModule(error, target)) evalError = error;
     }
   }
   const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
-  return await import(
-    /* @vite-ignore */
-    dataUrl
-  );
+  try {
+    return await import(
+      /* @vite-ignore */
+      dataUrl
+    );
+  } catch (error) {
+    throw evalError ?? error;
+  }
+}
+function isUnresolvedTempModule(error, target) {
+  const message = error instanceof Error ? error.message : "";
+  return message.includes("Cannot find module") && message.includes(basename(target));
 }
 function tempTargetFor(filepath) {
   const unique = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
@@ -168,8 +178,8 @@ function canonical(filepath) {
 }
 
 // src/find.ts
-import { readdirSync } from "fs";
-import { dirname as dirname2, resolve } from "path";
+import { readdirSync } from "node:fs";
+import { dirname as dirname2, resolve } from "node:path";
 var configFiles = /* @__PURE__ */ new Set([
   "panda.config.ts",
   "panda.config.js",
@@ -323,6 +333,9 @@ function attachRuntimeHooks(config, configs) {
   return config;
 }
 
+// src/design-system/overlay-input.ts
+import { applyConfigDefaults } from "@pandacss/compiler-shared";
+
 // src/normalize.ts
 var CLASS_NAME_OPTION_KEYS = ["hash", "prefix", "separator"];
 function normalizeClassNameOptions(config) {
@@ -363,20 +376,78 @@ function normalizePrefix(value) {
   return { cssVar: "", className: "" };
 }
 
+// src/design-system/overlay-input.ts
+var CLASS_NAME_OPTION_KEYS2 = ["hash", "prefix", "separator"];
+var RUNTIME_OPTION_KEYS = [
+  ...CLASS_NAME_OPTION_KEYS2,
+  "jsxFramework",
+  "jsxFactory",
+  "jsxStyleProps",
+  "strictTokens",
+  "strictPropertyValues",
+  "shorthands"
+];
+function designSystemSourceIds(chain) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const ds of chain) {
+    ids.add(ds.name);
+    ids.add(ds.specifier);
+  }
+  return ids;
+}
+function authoredByApp(sources, prefix, dsIds) {
+  return Object.entries(sources.paths).some(([path, ids]) => {
+    if (path !== prefix && !path.startsWith(`${prefix}.`)) return false;
+    const idList = Array.isArray(ids) ? ids : [ids];
+    return idList.some((id) => isAppSource(sources.entries[id], dsIds));
+  });
+}
+function isAppSource(entry, dsIds) {
+  if (!entry) return false;
+  if (entry.kind === "config") return true;
+  if (entry.kind !== "preset") return false;
+  return entry.specifier === void 0 || !dsIds.has(entry.specifier);
+}
+function buildOverlayInput(sources, appConfig, chain, leafPreset, cwd) {
+  const dsIds = designSystemSourceIds(chain);
+  const authored = {
+    conditions: authoredByApp(sources, "conditions", dsIds),
+    breakpoints: authoredByApp(sources, "theme.breakpoints", dsIds),
+    utilities: authoredByApp(sources, "utilities", dsIds),
+    tokens: authoredByApp(sources, "theme.tokens", dsIds) || authoredByApp(sources, "theme.semanticTokens", dsIds)
+  };
+  const mismatches = diffRuntimeOptions(appConfig, leafPreset, sources, dsIds, cwd);
+  return { authored, compatible: mismatches.length === 0 };
+}
+function diffRuntimeOptions(appConfig, leafPreset, sources, dsIds, cwd) {
+  const app = applyConfigDefaults({ ...appConfig }, cwd);
+  const ds = applyConfigDefaults({ ...leafPreset }, cwd);
+  const appClass = normalizeClassNameOptions(app);
+  const dsClass = normalizeClassNameOptions(ds);
+  return RUNTIME_OPTION_KEYS.filter((key) => {
+    if (!authoredByApp(sources, key, dsIds)) return false;
+    if (key === "hash" || key === "prefix" || key === "separator") {
+      if (key === "separator") return appClass.separator !== dsClass.separator;
+      return appClass[key].cssVar !== dsClass[key].cssVar || appClass[key].className !== dsClass[key].className;
+    }
+    return JSON.stringify(app[key]) !== JSON.stringify(ds[key]);
+  });
+}
+
 // src/preset.ts
-import { normalize as normalize2, relative as relative4 } from "path";
+import { normalize as normalize2, relative as relative5 } from "node:path";
 
 // src/design-system/chain.ts
 import {
   outdirBasename
 } from "@pandacss/compiler-shared";
-import { readFileSync, statSync } from "fs";
-import { dirname as dirname3, resolve as resolve3 } from "path";
-import { pathToFileURL as pathToFileURL3 } from "url";
+import { readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/resolve.ts
-import { createRequire } from "module";
-import { resolve as resolve2 } from "path";
+import { createRequire } from "node:module";
+import { resolve as resolve2 } from "node:path";
 function tryResolveFrom(request, fromDir) {
   try {
     return createRequire(resolve2(fromDir, "noop.js")).resolve(request, { paths: [fromDir] });
@@ -403,6 +474,195 @@ function errorCode(error) {
   return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
 }
 
+// src/design-system/package.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
+
+// src/design-system/publishable-files.ts
+import { relative as relative3, resolve as resolve3 } from "node:path";
+
+// src/paths.ts
+import { isAbsolute as isAbsolute3, relative as relative2 } from "node:path";
+function toPosixPath(path) {
+  return path.includes("\\") ? path.split("\\").join("/") : path;
+}
+function toPosixRelative(from, to) {
+  const rel = toPosixPath(relative2(from, to));
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function toRelativeKey(key, cwd) {
+  return toPosixPath(isAbsolute3(key) ? relative2(cwd, key) : key);
+}
+
+// src/design-system/publishable-files.ts
+var GLOB_START = /[*?{]/;
+var HAS_WILDCARD = /[*?]/;
+var TRAILING_SLASH = /\/$/;
+var REGEX_META = /[.+^${}()|[\]\\]/g;
+var GLOBSTAR = /\*\*/g;
+var GLOB_STAR = /\*/g;
+var GLOB_QMARK = /\?/g;
+var GLOBSTAR_TOKEN = /<<<DS>>>/g;
+function filterPublishableLibFiles(options) {
+  const { files, packageRoot, outRoot, publishFiles } = options;
+  if (!publishFiles?.length) {
+    return { files, unpublished: [] };
+  }
+  const rules = compilePackageFilesRules(publishFiles);
+  const kept = [];
+  const unpublished = [];
+  for (const file of files) {
+    const packageRelative = libFileToPackageRelative(file, packageRoot, outRoot);
+    if (packageRelative !== void 0 && matchesCompiledRules(packageRelative, rules)) {
+      kept.push(file);
+    } else {
+      unpublished.push(file);
+    }
+  }
+  return { files: kept, unpublished };
+}
+function readPublishFilesField(value) {
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  for (const entry of value) {
+    if (typeof entry !== "string") return void 0;
+  }
+  return value;
+}
+function libFileToPackageRelative(file, packageRoot, outRoot) {
+  const normalized = toPosixPath(file);
+  const withoutDot = normalized.startsWith("./") ? normalized.slice(2) : normalized;
+  const globAt = withoutDot.search(GLOB_START);
+  const literalPrefix = globAt === -1 ? withoutDot : withoutDot.slice(0, globAt);
+  const abs = resolve3(outRoot, literalPrefix || ".");
+  const rel = toPosixPath(relative3(packageRoot, abs));
+  if (rel === "") return "";
+  if (rel.startsWith("..")) return void 0;
+  return rel;
+}
+function compilePackageFilesRules(patterns) {
+  const rules = [];
+  for (const raw of patterns) {
+    const negated = raw.startsWith("!");
+    const pattern = toPosixPath(negated ? raw.slice(1) : raw);
+    const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
+    if (!normalized) continue;
+    if (!HAS_WILDCARD.test(normalized)) {
+      rules.push({ kind: "prefix", negated, value: normalized.replace(TRAILING_SLASH, "") });
+      continue;
+    }
+    const escaped = normalized.replace(REGEX_META, "\\$&").replace(GLOBSTAR, "<<<DS>>>").replace(GLOB_STAR, "[^/]*").replace(GLOB_QMARK, "[^/]").replace(GLOBSTAR_TOKEN, ".*");
+    rules.push({ kind: "regex", negated, value: new RegExp(`^${escaped}(?:/.*)?$`) });
+  }
+  return rules;
+}
+function matchesCompiledRules(packageRelativePath, rules) {
+  const path = packageRelativePath.startsWith("./") ? packageRelativePath.slice(2) : packageRelativePath;
+  let included = false;
+  for (const rule of rules) {
+    const hit = rule.kind === "prefix" ? path === rule.value || path.startsWith(`${rule.value}/`) : rule.value.test(path);
+    if (!hit) continue;
+    included = !rule.negated;
+  }
+  return included;
+}
+
+// src/design-system/package.ts
+var PACKAGE_MANAGER_RANGE_PATTERN = /^(?:workspace|catalog):/;
+var PORTABLE_WORKSPACE_RANGE_PATTERN = /^[~^]?\d/;
+var VERSION_CORE_PATTERN = /^(\d+)\.(\d+)\.(\d+)/;
+function resolvePublishedPandaRange(range, currentVersion) {
+  const authored = range?.trim();
+  if (!authored) return "*";
+  if (authored.startsWith("npm:")) {
+    return resolveNpmAliasRange(authored) ?? portableRangeFromInstalled(currentVersion, "^");
+  }
+  if (!PACKAGE_MANAGER_RANGE_PATTERN.test(authored)) return authored;
+  if (authored.startsWith("workspace:")) {
+    const workspaceRange = authored.slice("workspace:".length);
+    if (PORTABLE_WORKSPACE_RANGE_PATTERN.test(workspaceRange)) return workspaceRange;
+  }
+  const operator = authored === "workspace:~" ? "~" : "^";
+  return portableRangeFromInstalled(currentVersion, operator);
+}
+function resolveNpmAliasRange(spec) {
+  const at = spec.lastIndexOf("@");
+  if (at <= "npm:".length) return void 0;
+  return spec.slice(at + 1);
+}
+function portableRangeFromInstalled(currentVersion, operator) {
+  const core = currentVersion?.match(VERSION_CORE_PATTERN)?.[0];
+  return core ? `${operator}${core}` : "*";
+}
+function readPackageIdentity(cwd) {
+  const packagePath = nearestPackageJson(cwd);
+  if (packagePath === void 0) {
+    throw new Error(`Could not find a package.json from ${JSON.stringify(cwd)} to build the design system manifest.`);
+  }
+  const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+  const name = pkg.name;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`${JSON.stringify(packagePath)} has no "name"; a design system must be a named package.`);
+  }
+  const peer = pkg.peerDependencies?.["@pandacss/dev"];
+  return {
+    name,
+    version: typeof pkg.version === "string" ? pkg.version : void 0,
+    pandaPeer: typeof peer === "string" ? peer : void 0,
+    packagePath,
+    publishFiles: readPublishFilesField(pkg.files)
+  };
+}
+function defaultImportMap(name) {
+  return {
+    css: `${name}/css`,
+    recipes: `${name}/recipes`,
+    patterns: `${name}/patterns`,
+    jsx: `${name}/jsx`,
+    tokens: `${name}/tokens`
+  };
+}
+function syncExports(options) {
+  const { packageJson, entries } = options;
+  const pkg = JSON.parse(packageJson);
+  const existing = normalizeExports(pkg.exports);
+  const merged = { ...existing };
+  const conflicts = [];
+  for (const [key, value] of Object.entries(entries)) {
+    if (key in merged && !exportsValueEqual(merged[key], value)) {
+      conflicts.push(key);
+    }
+    merged[key] = value;
+  }
+  const changed = JSON.stringify(pkg.exports) !== JSON.stringify(merged);
+  const out = { ...pkg, exports: merged };
+  return { changed, json: `${JSON.stringify(out, null, 2)}
+`, conflicts };
+}
+function exportsValueEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function normalizeExports(exports) {
+  if (exports === void 0) return {};
+  if (typeof exports === "string") return { ".": exports };
+  if (Array.isArray(exports)) return { ".": exports };
+  if (!isPlainObject(exports)) return {};
+  if (isSubpathExportMap(exports)) return exports;
+  return { ".": exports };
+}
+function isSubpathExportMap(exports) {
+  return Object.keys(exports).some((key) => key === "." || key.startsWith("./"));
+}
+function nearestPackageJson(start) {
+  let current = start;
+  while (true) {
+    const candidate = join2(current, "package.json");
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname3(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+
 // src/design-system/chain.ts
 var SPECIFIER_PROTOCOL = /^([a-z][a-z0-9+.-]*):/i;
 async function loadDesignSystemChain(spec, cwd, deps) {
@@ -432,7 +692,7 @@ async function loadDesignSystemChain(spec, cwd, deps) {
     levels.push(level);
     if (parent === void 0) break;
     declaredBy = level.info.name;
-    fromDir = dirname3(manifestPath);
+    fromDir = dirname4(manifestPath);
     currentSpec = parent;
   }
   return levels.reverse();
@@ -444,12 +704,126 @@ function withDesignSystemImportMap(config, infos) {
   );
   return { ...config, importMap: [...roots, outdirBasename(config.outdir ?? "styled-system"), ...existing] };
 }
+function buildCodegenOverlay(metadata) {
+  const chain = metadata?.designSystem;
+  if (!chain || chain.length !== 1) return void 0;
+  if (metadata?.overlayInput && !metadata.overlayInput.compatible) return void 0;
+  const [ds] = chain;
+  const appRecipes = new Set(metadata?.userRecipeNames ?? []);
+  const appPatterns = new Set(metadata?.userPatternNames ?? []);
+  const authored = metadata?.overlayInput?.authored;
+  const runtimeDirty = !!(authored?.conditions || authored?.breakpoints || authored?.utilities || authored?.tokens);
+  return {
+    ...overlayRoots(ds),
+    ownedRecipes: ds.recipeNames.filter((name) => !appRecipes.has(name)),
+    ownedPatterns: ds.patternNames.filter((name) => !appPatterns.has(name)),
+    virtualizeHelpers: true,
+    virtualizeCss: !runtimeDirty
+  };
+}
+function collectArtifactConflicts(metadata) {
+  const appRecipes = new Set(metadata?.userRecipeNames ?? []);
+  const appPatterns = new Set(metadata?.userPatternNames ?? []);
+  return (metadata?.designSystem ?? []).map((ds) => ({
+    name: ds.name,
+    recipes: ds.recipeNames.filter((name) => appRecipes.has(name)),
+    patterns: ds.patternNames.filter((name) => appPatterns.has(name))
+  })).filter((entry) => entry.recipes.length > 0 || entry.patterns.length > 0);
+}
+function collectExportMissingDiagnostics(metadata) {
+  const overlay = buildCodegenOverlay(metadata);
+  if (!overlay) return [];
+  const [ds] = metadata.designSystem;
+  const required = [];
+  if (overlay.virtualizeHelpers) required.push("./helpers");
+  if (overlay.virtualizeCss) {
+    required.push("./css", "./css/*");
+  }
+  if (overlay.ownedRecipes.length > 0) {
+    required.push("./recipes", "./recipes/*");
+  }
+  if (overlay.ownedPatterns.length > 0) {
+    required.push("./patterns", "./patterns/*");
+  }
+  const appPatterns = metadata?.userPatternNames?.length ?? 0;
+  const dsPatterns = ds.patternNames?.length ?? 0;
+  if (overlay.ownedPatterns.length > 0 || overlay.virtualizeCss && (appPatterns > 0 || dsPatterns > 0)) {
+    required.push("./jsx", "./jsx/*");
+  }
+  return required.filter((subpath) => !hasExport(ds.packageExports, subpath)).map((subpath) => exportMissingDiagnostic(ds.name, subpath));
+}
+function collectNameCollisionDiagnostics(metadata) {
+  const overlay = buildCodegenOverlay(metadata);
+  if (!overlay) return [];
+  return [
+    ...identCollisions("recipe", [...overlay.ownedRecipes, ...metadata?.userRecipeNames ?? []]),
+    ...identCollisions("pattern", [...overlay.ownedPatterns, ...metadata?.userPatternNames ?? []])
+  ];
+}
+function jsIdent(value) {
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    const isIdent = code === 36 || // $
+    code === 95 || // _
+    code >= 48 && code <= 57 || // 0-9
+    code >= 65 && code <= 90 || // A-Z
+    code >= 97 && code <= 122;
+    if (isIdent) {
+      if (i === 0 && code >= 48 && code <= 57) out += "_";
+      out += value[i];
+    } else {
+      out += "_";
+    }
+  }
+  return out === "" ? "_" : out;
+}
+function identCollisions(kind, names) {
+  const byIdent = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const ident = jsIdent(name);
+    const set = byIdent.get(ident) ?? /* @__PURE__ */ new Set();
+    set.add(name);
+    byIdent.set(ident, set);
+  }
+  const collisions = [];
+  for (const [ident, raw] of byIdent) {
+    if (raw.size < 2) continue;
+    const list = [...raw].map((name) => JSON.stringify(name)).join(", ");
+    const message = `${kind} names ${list} both generate the export ${JSON.stringify(ident)}; one would overwrite the other in the generated barrel. Rename one so they produce distinct identifiers.`;
+    collisions.push(createConfigDiagnostic("design_system_name_collision", message));
+  }
+  return collisions;
+}
+function hasExport(packageExports, subpath) {
+  return packageExports != null && Object.prototype.hasOwnProperty.call(packageExports, subpath);
+}
+function exportMissingDiagnostic(dsName, subpath) {
+  const message = `designSystem ${JSON.stringify(dsName)} doesn't export ${JSON.stringify(subpath)}, which this app's codegen needs. Rebuild it with \`panda lib\`.`;
+  return createConfigDiagnostic("design_system_export_missing", message, [
+    `Rebuild ${JSON.stringify(dsName)} with \`panda lib\` to add the ${JSON.stringify(subpath)} export.`
+  ]);
+}
+function overlayRoots(ds) {
+  const map = ds.importMap;
+  const root = (value, subpath) => {
+    const resolved = Array.isArray(value) ? value[0] : value;
+    return resolved ?? `${ds.specifier}/${subpath}`;
+  };
+  return {
+    jsx: root(map?.jsx, "jsx"),
+    recipes: root(map?.recipes, "recipes"),
+    patterns: root(map?.patterns, "patterns"),
+    css: root(map?.css, "css"),
+    helpers: `${ds.specifier}/helpers`
+  };
+}
 function resolveManifestPath(spec, fromDir) {
   const protocol = specifierProtocol(spec);
   if (protocol) throw unsupportedSpecifierError(spec, protocol);
   let outcome;
   try {
-    outcome = resolveFrom(`${spec}/panda.lib.json`, fromDir);
+    outcome = resolveFrom(`${spec}/panda/lib.json`, fromDir);
   } catch (error) {
     const message = `Failed to resolve designSystem ${JSON.stringify(spec)} from ${JSON.stringify(fromDir)}: ${errorMessage(error)}`;
     throw createConfigError(message, [createConfigDiagnostic("design_system_resolve_failed", message)]);
@@ -459,17 +833,17 @@ function resolveManifestPath(spec, fromDir) {
   return void 0;
 }
 function manifestNotExportedError(spec) {
-  const message = `designSystem ${JSON.stringify(spec)} is installed but doesn't expose \`./panda.lib.json\`. If it's a Panda design system, rebuild it with \`panda lib\`; otherwise it can't be consumed as a design system.`;
+  const message = `designSystem ${JSON.stringify(spec)} is installed but doesn't expose \`./panda/*\` (missing \`panda/lib.json\`). If it's a Panda design system, rebuild it with \`panda lib\`; otherwise it can't be consumed as a design system.`;
   return createConfigError(message, [
     createConfigDiagnostic("design_system_manifest_not_exported", message, [
-      `Rebuild ${JSON.stringify(spec)} with \`panda lib\`, or check its package.json \`exports\` includes \`./panda.lib.json\`.`
+      `Rebuild ${JSON.stringify(spec)} with \`panda lib\`, or check its package.json \`exports\` includes \`./panda/*\`.`
     ])
   ]);
 }
 async function loadManifestLevel(spec, manifestPath, deps) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
   } catch (error) {
     const message = `Failed to parse ${JSON.stringify(manifestPath)} as JSON: ${errorMessage(error)}. This file must be generated by \`panda lib\`, not hand-written or added to \`include\`.`;
     throw createConfigError(message, [
@@ -477,8 +851,8 @@ async function loadManifestLevel(spec, manifestPath, deps) {
     ]);
   }
   const manifest = validateManifest(spec, manifestPath, parsed);
-  const presetPath = resolve3(dirname3(manifestPath), manifest.preset);
-  const buildInfoPath = resolve3(dirname3(manifestPath), manifest.buildInfo);
+  const presetPath = resolve4(dirname4(manifestPath), manifest.preset);
+  const buildInfoPath = resolve4(dirname4(manifestPath), manifest.buildInfo);
   deps.add(presetPath);
   deps.add(buildInfoPath);
   let preset;
@@ -495,6 +869,7 @@ async function loadManifestLevel(spec, manifestPath, deps) {
     ]);
   }
   const parent = typeof manifest.designSystem === "string" && manifest.designSystem.length > 0 ? manifest.designSystem : void 0;
+  const packageExports = readPackageExports(manifestPath);
   return {
     parent,
     level: {
@@ -507,11 +882,27 @@ async function loadManifestLevel(spec, manifestPath, deps) {
         buildInfoPath,
         files: manifest.files ?? [],
         tokenPaths: [],
-        ...manifest.importMap ? { importMap: manifest.importMap } : {}
+        recipeNames: [],
+        patternNames: [],
+        ...manifest.importMap ? { importMap: manifest.importMap } : {},
+        ...packageExports ? { packageExports } : {}
       }
     }
   };
 }
+function readPackageExports(manifestPath) {
+  try {
+    const packageJsonPath = nearestPackageJson(dirname4(manifestPath));
+    if (packageJsonPath === void 0) return void 0;
+    const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+    return isExportsMap(pkg.exports) ? pkg.exports : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isExportsMap(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function presetImportUrl(path) {
   const url = pathToFileURL3(path);
   url.searchParams.set("mtime", String(statSync(path).mtimeMs));
@@ -613,30 +1004,15 @@ function specifierProtocol(spec) {
   return match ? match[1] : void 0;
 }
 function unsupportedSpecifierError(spec, protocol) {
-  const message = `designSystem ${JSON.stringify(spec)} uses the "${protocol}:" protocol, which isn't supported. Use the published package name (e.g. "@acme/design-system") that resolves to its \`panda.lib.json\`.`;
+  const message = `designSystem ${JSON.stringify(spec)} uses the "${protocol}:" protocol, which isn't supported. Use the published package name (e.g. "@acme/design-system") that resolves to its \`panda/lib.json\`.`;
   return createConfigError(message, [createConfigDiagnostic("design_system_unsupported_specifier", message)]);
 }
 
 // src/design-system/smart-include.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join2, relative as relative3, resolve as resolve4, sep } from "path";
-
-// src/paths.ts
-import { isAbsolute as isAbsolute3, relative as relative2 } from "path";
-function toPosixPath(path) {
-  return path.includes("\\") ? path.split("\\").join("/") : path;
-}
-function toPosixRelative(from, to) {
-  const rel = toPosixPath(relative2(from, to));
-  return rel.startsWith(".") ? rel : `./${rel}`;
-}
-function toRelativeKey(key, cwd) {
-  return toPosixPath(isAbsolute3(key) ? relative2(cwd, key) : key);
-}
-
-// src/design-system/smart-include.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join3, relative as relative4, resolve as resolve5, sep } from "node:path";
 var SMART_INCLUDE_EXTENSIONS = ["js", "mjs", "cjs", "jsx", "ts", "cts", "mts", "tsx", "vue", "svelte", "astro"];
-var MANIFEST = "panda.lib.json";
+var MANIFEST_SUBPATH = "panda/lib.json";
 var PACKAGE_SPECIFIER = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
 function resolveSmartInclude(include, cwd, deps) {
   const offenders = [];
@@ -652,7 +1028,7 @@ function resolveSmartInclude(include, cwd, deps) {
       next.push(entry);
       continue;
     }
-    if (tryResolveFrom(`${entry}/${MANIFEST}`, cwd) !== void 0) {
+    if (tryResolveFrom(`${entry}/${MANIFEST_SUBPATH}`, cwd) !== void 0) {
       offenders.push(entry);
       continue;
     }
@@ -661,11 +1037,11 @@ function resolveSmartInclude(include, cwd, deps) {
       next.push(entry);
       continue;
     }
-    if (existsSync2(join2(packageDir, MANIFEST))) {
+    if (existsSync3(join3(packageDir, ...MANIFEST_SUBPATH.split("/")))) {
       offenders.push(entry);
       continue;
     }
-    deps.add(join2(packageDir, "package.json"));
+    deps.add(join3(packageDir, "package.json"));
     const base = globBase(packageDir, cwd);
     next.push(`${base}/**/*.{${SMART_INCLUDE_EXTENSIONS.join(",")}}`);
     excludes.push(`${base}/**/node_modules/**`);
@@ -684,11 +1060,11 @@ function mergeExcludes(existing, additions) {
   return [...existing ?? [], ...additions];
 }
 function isLocalPath(entry, cwd) {
-  return existsSync2(isAbsolute4(entry) ? entry : resolve4(cwd, entry));
+  return existsSync3(isAbsolute4(entry) ? entry : resolve5(cwd, entry));
 }
 function resolvePackageDir(spec, cwd) {
   const fromPackageJson = tryResolve(`${spec}/package.json`, cwd);
-  if (fromPackageJson !== void 0) return dirname4(fromPackageJson);
+  if (fromPackageJson !== void 0) return dirname5(fromPackageJson);
   const fromEntry = tryResolve(spec, cwd);
   return fromEntry === void 0 ? void 0 : nearestPackageDir(fromEntry);
 }
@@ -706,23 +1082,23 @@ function isInsideCwd(relativePath) {
   return !relativePath.startsWith(`..${sep}`);
 }
 function nearestPackageDir(from) {
-  let dir = dirname4(from);
+  let dir = dirname5(from);
   while (true) {
-    if (existsSync2(join2(dir, "package.json"))) return dir;
-    const parent = dirname4(dir);
+    if (existsSync3(join3(dir, "package.json"))) return dir;
+    const parent = dirname5(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 function globBase(packageDir, cwd) {
-  const rel = relative3(cwd, packageDir);
+  const rel = relative4(cwd, packageDir);
   const base = isInsideCwd(rel) ? rel : packageDir;
   return toPosixPath(base);
 }
 function inIncludeError(specs) {
   const list = specs.map((spec) => JSON.stringify(spec)).join(", ");
   const plural = specs.length > 1;
-  const message = `Design system${plural ? "s" : ""} in \`include\`: ${list}. ${plural ? "They each ship" : "It ships"} a ${MANIFEST}, so ${plural ? "they belong" : "it belongs"} in \`designSystem\`, not \`include\`. \`include\` is for files, not design systems.`;
+  const message = `Design system${plural ? "s" : ""} in \`include\`: ${list}. ${plural ? "They each ship" : "It ships"} a ${MANIFEST_SUBPATH}, so ${plural ? "they belong" : "it belongs"} in \`designSystem\`, not \`include\`. \`include\` is for files, not design systems.`;
   return createConfigError(
     message,
     specs.map(
@@ -736,7 +1112,7 @@ function inIncludeError(specs) {
 }
 
 // src/design-system/token-paths.ts
-import { isDeepStrictEqual } from "util";
+import { isDeepStrictEqual } from "node:util";
 function collectTokenPaths(config) {
   return [...collectTokenEntries(config).keys()].sort();
 }
@@ -782,41 +1158,57 @@ function collect(node, trail, out) {
   }
 }
 
+// src/artifact-names.ts
+function collectRecipeNames(config) {
+  const theme = config?.theme;
+  if (!theme) return [];
+  const names = /* @__PURE__ */ new Set([...Object.keys(theme.recipes ?? {}), ...Object.keys(theme.slotRecipes ?? {})]);
+  return [...names].sort();
+}
+function collectPatternNames(config) {
+  return Object.keys(config?.patterns ?? {}).sort();
+}
+
 // src/preset.ts
 async function resolveAuthoredPresetsForLoad(config, cwd, options = {}) {
+  const designSystem = config.designSystem;
+  const hasDesignSystem = typeof designSystem === "string" && designSystem.length > 0;
+  const trackSources = options.trackSources ?? hasDesignSystem;
   const ctx = {
     cwd,
     configs: [],
     dependencies: /* @__PURE__ */ new Set(),
     presetResolvedHooks: [],
-    ...options.trackSources ? { sourcedConfigs: [] } : {}
+    ...trackSources ? { sourcedConfigs: [] } : {}
   };
   const rootSource = { kind: "config" };
   if (options.configFile) {
-    rootSource.file = normalize2(relative4(cwd, options.configFile));
+    rootSource.file = normalize2(relative5(cwd, options.configFile));
   }
-  const designSystem = config.designSystem;
   let dsChain = [];
   const designSystemCompatibility = [];
-  if (typeof designSystem === "string" && designSystem.length > 0) {
+  if (hasDesignSystem) {
     dsChain = await loadDesignSystemChain(designSystem, cwd, ctx.dependencies);
     for (const level of dsChain) {
-      const resolution = await resolveConfigEntry(
-        level.preset,
-        { kind: "preset", specifier: level.info.name },
-        cwd,
-        ctx.dependencies,
-        options.trackSources
-      );
+      const dsSource = { kind: "preset", specifier: level.info.name, name: level.info.name };
+      const resolution = await resolveConfigEntry(level.preset, dsSource, cwd, ctx.dependencies, trackSources);
+      if (resolution.sourcedConfigs) {
+        for (const sourced of resolution.sourcedConfigs) {
+          sourced.source = dsSource;
+        }
+      }
       level.info.tokenPaths = collectTokenPaths(resolution.config);
+      level.info.recipeNames = collectRecipeNames(resolution.config);
+      level.info.patternNames = collectPatternNames(resolution.config);
       appendConfigResolution(ctx, resolution);
       designSystemCompatibility.push({
         designSystem: level.info,
-        classNameOptions: normalizeClassNameOptions(mergeConfigs(ctx.configs))
+        classNameOptions: normalizeClassNameOptions(mergeConfigs(ctx.configs)),
+        presetConfig: resolution.config
       });
     }
   }
-  const rootResolution = await resolveConfigEntry(config, rootSource, cwd, ctx.dependencies, options.trackSources);
+  const rootResolution = await resolveConfigEntry(config, rootSource, cwd, ctx.dependencies, trackSources);
   appendConfigResolution(ctx, rootResolution);
   for (const { designSystem: designSystem2, classNameOptions } of designSystemCompatibility) {
     const mismatch = diffClassNameOptions(rootResolution.config, classNameOptions, "explicit");
@@ -829,23 +1221,46 @@ async function resolveAuthoredPresetsForLoad(config, cwd, options = {}) {
     const withImportMap = dsInfos.length > 0 ? withDesignSystemImportMap(resolved, dsInfos) : resolved;
     return expandSmartInclude(withImportMap, cwd, ctx.dependencies);
   };
-  const dsMetadata = dsInfos.length > 0 ? { designSystem: dsInfos, userTokenPaths: collectTokenPaths(rootResolution.config) } : void 0;
+  const leafCompatibility = designSystemCompatibility[designSystemCompatibility.length - 1];
   if (ctx.sourcedConfigs) {
     const merged = mergeConfigsWithSources(ctx.sourcedConfigs);
     if (options.preserveRuntimeHooks) {
       attachRuntimeHooks(merged.config, ctx.configs);
     }
+    const finalized2 = finalize(merged.config);
+    let overlayInput;
+    if (leafCompatibility) {
+      const input = buildOverlayInput(merged.sources, finalized2, dsInfos, leafCompatibility.presetConfig, cwd);
+      const leafClassMismatch = leafCompatibility.designSystem.optionMismatch ?? [];
+      overlayInput = {
+        authored: input.authored,
+        compatible: input.compatible && leafClassMismatch.length === 0
+      };
+    }
+    const dsMetadata2 = dsInfos.length > 0 ? {
+      designSystem: dsInfos,
+      userTokenPaths: collectTokenPaths(rootResolution.config),
+      userRecipeNames: collectRecipeNames(rootResolution.config),
+      userPatternNames: collectPatternNames(rootResolution.config),
+      ...overlayInput ? { overlayInput } : {}
+    } : void 0;
     return {
-      config: finalize(merged.config),
+      config: finalized2,
       dependencies: Array.from(ctx.dependencies),
-      metadata: { sources: merged.sources, ...dsMetadata },
+      metadata: { sources: merged.sources, ...dsMetadata2 },
       designSystemCompatibility
     };
   }
+  const mergedConfig = options.preserveRuntimeHooks ? attachRuntimeHooks(mergeConfigs(ctx.configs), ctx.configs) : mergeConfigs(ctx.configs);
+  const finalized = finalize(mergedConfig);
+  const dsMetadata = dsInfos.length > 0 ? {
+    designSystem: dsInfos,
+    userTokenPaths: collectTokenPaths(rootResolution.config),
+    userRecipeNames: collectRecipeNames(rootResolution.config),
+    userPatternNames: collectPatternNames(rootResolution.config)
+  } : void 0;
   return {
-    config: finalize(
-      options.preserveRuntimeHooks ? attachRuntimeHooks(mergeConfigs(ctx.configs), ctx.configs) : mergeConfigs(ctx.configs)
-    ),
+    config: finalized,
     dependencies: Array.from(ctx.dependencies),
     ...dsMetadata ? { metadata: dsMetadata } : {},
     designSystemCompatibility
@@ -965,13 +1380,14 @@ async function loadConfig(options) {
   );
   const tokenEntriesBeforeHooks = collectTokenEntries(authored.config);
   const userConfig = await runConfigResolvedHooks(authored.config, path, authoredDependencies);
+  const resolved = applyConfigDefaults2(userConfig, cwd);
   refreshDesignSystemMetadata(
     authored.metadata,
     authored.designSystemCompatibility,
-    userConfig,
-    tokenEntriesBeforeHooks
+    resolved,
+    tokenEntriesBeforeHooks,
+    cwd
   );
-  const resolved = applyConfigDefaults(userConfig, cwd);
   const dependencyList = Array.from(
     /* @__PURE__ */ new Set([...dependencies, ...authored.dependencies, ...resolved.dependencies ?? []])
   );
@@ -990,13 +1406,16 @@ async function loadConfig(options) {
     ...authored.metadata ? { metadata: authored.metadata } : {}
   };
 }
-function refreshDesignSystemMetadata(metadata, designSystemCompatibility, config, tokenEntriesBeforeHooks) {
+function refreshDesignSystemMetadata(metadata, designSystemCompatibility, config, tokenEntriesBeforeHooks, cwd) {
   if (!metadata?.designSystem?.length) return;
   metadata.userTokenPaths = resolveUserTokenPathsAfterHooks(
     metadata.userTokenPaths ?? [],
     tokenEntriesBeforeHooks,
     config
   );
+  const chain = metadata.designSystem;
+  const sources = metadata.sources;
+  const leaf = designSystemCompatibility[designSystemCompatibility.length - 1];
   for (const { designSystem, classNameOptions } of designSystemCompatibility) {
     const mismatch = diffClassNameOptions(config, classNameOptions, "effective");
     if (mismatch.length > 0) {
@@ -1005,6 +1424,14 @@ function refreshDesignSystemMetadata(metadata, designSystemCompatibility, config
       delete designSystem.optionMismatch;
     }
   }
+  if (sources && leaf) {
+    const input = buildOverlayInput(sources, config, chain, leaf.presetConfig, cwd);
+    const leafClassMismatch = leaf.designSystem.optionMismatch ?? [];
+    metadata.overlayInput = {
+      authored: input.authored,
+      compatible: input.compatible && leafClassMismatch.length === 0
+    };
+  }
 }
 async function runConfigResolvedHooks(config, path, dependencies) {
   let current = config;
@@ -1035,7 +1462,6 @@ var ALL_DEPENDENCIES = [
   "prefix",
   "recipes",
   "separator",
-  "syntax",
   "themes",
   "tokens",
   "utilities"
@@ -1089,8 +1515,6 @@ function classify(path) {
       return { deps: ["patterns"], pattern: second };
     case "themes":
       return { deps: ["themes"] };
-    case "syntax":
-      return { deps: ["syntax"] };
     case "hash":
       return { deps: ["hash"] };
     case "prefix":
@@ -1127,20 +1551,29 @@ function isConfigSnapshot(input) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname5, join as join3 } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname6, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+var MAJOR_VERSION_RE = /\d+/;
+var STAMPABLE_PANDA_RANGE_RE = /^[v=><~^]|^\d/;
 function readPandaVersion() {
   try {
-    const pkgPath = join3(dirname5(fileURLToPath(import.meta.url)), "../package.json");
-    return JSON.parse(readFileSync2(pkgPath, "utf8")).version;
+    const pkgPath = join4(dirname6(fileURLToPath(import.meta.url)), "../package.json");
+    return JSON.parse(readFileSync3(pkgPath, "utf8")).version;
   } catch {
     return void 0;
   }
 }
+function getPandaMajorRange() {
+  const match = readPandaVersion()?.match(MAJOR_VERSION_RE);
+  return match ? `^${match[0]}.0.0` : void 0;
+}
+function isStampablePandaRange(range) {
+  return range !== void 0 && STAMPABLE_PANDA_RANGE_RE.test(range.trim());
+}
 
 // src/design-system/compile-preset.ts
-import { builtinModules as builtinModules2 } from "module";
+import { builtinModules as builtinModules2 } from "node:module";
 var APP_FIELDS = ["designSystem", "include", "exclude", "outdir", "cwd", "watch", "clean", "gitignore", "importMap"];
 var VIRTUAL_ENTRY = "\0panda-lib-preset-entry";
 var nodeBuiltins2 = /* @__PURE__ */ new Set([...builtinModules2, ...builtinModules2.map((mod) => `node:${mod}`)]);
@@ -1201,179 +1634,14 @@ async function validatePreset(code) {
     throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to compile design system preset: ${errorMessage(error)}`);
   }
 }
-
-// src/design-system/package.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname6, join as join4 } from "path";
-
-// src/design-system/publishable-files.ts
-import { relative as relative5, resolve as resolve5 } from "path";
-var GLOB_START = /[*?{]/;
-var HAS_WILDCARD = /[*?]/;
-var TRAILING_SLASH = /\/$/;
-var REGEX_META = /[.+^${}()|[\]\\]/g;
-var GLOBSTAR = /\*\*/g;
-var GLOB_STAR = /\*/g;
-var GLOB_QMARK = /\?/g;
-var GLOBSTAR_TOKEN = /<<<DS>>>/g;
-function filterPublishableLibFiles(options) {
-  const { files, packageRoot, outRoot, publishFiles } = options;
-  if (!publishFiles?.length) {
-    return { files, unpublished: [] };
-  }
-  const rules = compilePackageFilesRules(publishFiles);
-  const kept = [];
-  const unpublished = [];
-  for (const file of files) {
-    const packageRelative = libFileToPackageRelative(file, packageRoot, outRoot);
-    if (packageRelative !== void 0 && matchesCompiledRules(packageRelative, rules)) {
-      kept.push(file);
-    } else {
-      unpublished.push(file);
-    }
-  }
-  return { files: kept, unpublished };
-}
-function readPublishFilesField(value) {
-  if (!Array.isArray(value) || value.length === 0) return void 0;
-  for (const entry of value) {
-    if (typeof entry !== "string") return void 0;
-  }
-  return value;
-}
-function libFileToPackageRelative(file, packageRoot, outRoot) {
-  const normalized = toPosixPath(file);
-  const withoutDot = normalized.startsWith("./") ? normalized.slice(2) : normalized;
-  const globAt = withoutDot.search(GLOB_START);
-  const literalPrefix = globAt === -1 ? withoutDot : withoutDot.slice(0, globAt);
-  const abs = resolve5(outRoot, literalPrefix || ".");
-  const rel = toPosixPath(relative5(packageRoot, abs));
-  if (rel === "") return "";
-  if (rel.startsWith("..")) return void 0;
-  return rel;
-}
-function compilePackageFilesRules(patterns) {
-  const rules = [];
-  for (const raw of patterns) {
-    const negated = raw.startsWith("!");
-    const pattern = toPosixPath(negated ? raw.slice(1) : raw);
-    const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
-    if (!normalized) continue;
-    if (!HAS_WILDCARD.test(normalized)) {
-      rules.push({ kind: "prefix", negated, value: normalized.replace(TRAILING_SLASH, "") });
-      continue;
-    }
-    const escaped = normalized.replace(REGEX_META, "\\$&").replace(GLOBSTAR, "<<<DS>>>").replace(GLOB_STAR, "[^/]*").replace(GLOB_QMARK, "[^/]").replace(GLOBSTAR_TOKEN, ".*");
-    rules.push({ kind: "regex", negated, value: new RegExp(`^${escaped}(?:/.*)?$`) });
-  }
-  return rules;
-}
-function matchesCompiledRules(packageRelativePath, rules) {
-  const path = packageRelativePath.startsWith("./") ? packageRelativePath.slice(2) : packageRelativePath;
-  let included = false;
-  for (const rule of rules) {
-    const hit = rule.kind === "prefix" ? path === rule.value || path.startsWith(`${rule.value}/`) : rule.value.test(path);
-    if (!hit) continue;
-    included = !rule.negated;
-  }
-  return included;
-}
-
-// src/design-system/package.ts
-var PACKAGE_MANAGER_RANGE_PATTERN = /^(?:workspace|catalog):/;
-var PORTABLE_WORKSPACE_RANGE_PATTERN = /^[~^]?\d/;
-var VERSION_CORE_PATTERN = /^(\d+)\.(\d+)\.(\d+)/;
-function resolvePublishedPandaRange(range, currentVersion) {
-  const authored = range?.trim();
-  if (!authored) return "*";
-  if (authored.startsWith("npm:")) {
-    return resolveNpmAliasRange(authored) ?? portableRangeFromInstalled(currentVersion, "^");
-  }
-  if (!PACKAGE_MANAGER_RANGE_PATTERN.test(authored)) return authored;
-  if (authored.startsWith("workspace:")) {
-    const workspaceRange = authored.slice("workspace:".length);
-    if (PORTABLE_WORKSPACE_RANGE_PATTERN.test(workspaceRange)) return workspaceRange;
-  }
-  const operator = authored === "workspace:~" ? "~" : "^";
-  return portableRangeFromInstalled(currentVersion, operator);
-}
-function resolveNpmAliasRange(spec) {
-  const at = spec.lastIndexOf("@");
-  if (at <= "npm:".length) return void 0;
-  return spec.slice(at + 1);
-}
-function portableRangeFromInstalled(currentVersion, operator) {
-  const core = currentVersion?.match(VERSION_CORE_PATTERN)?.[0];
-  return core ? `${operator}${core}` : "*";
-}
-function readPackageIdentity(cwd) {
-  const packagePath = nearestPackageJson(cwd);
-  if (packagePath === void 0) {
-    throw new Error(`Could not find a package.json from ${JSON.stringify(cwd)} to build the design system manifest.`);
-  }
-  const pkg = JSON.parse(readFileSync3(packagePath, "utf8"));
-  const name = pkg.name;
-  if (typeof name !== "string" || name.length === 0) {
-    throw new Error(`${JSON.stringify(packagePath)} has no "name"; a design system must be a named package.`);
-  }
-  const peer = pkg.peerDependencies?.["@pandacss/dev"];
-  return {
-    name,
-    version: typeof pkg.version === "string" ? pkg.version : void 0,
-    pandaPeer: typeof peer === "string" ? peer : void 0,
-    packagePath,
-    publishFiles: readPublishFilesField(pkg.files)
-  };
-}
-function defaultImportMap(name) {
-  return {
-    css: `${name}/css`,
-    recipes: `${name}/recipes`,
-    patterns: `${name}/patterns`,
-    jsx: `${name}/jsx`,
-    tokens: `${name}/tokens`
-  };
-}
-function syncExports(options) {
-  const { packageJson, entries } = options;
-  const pkg = JSON.parse(packageJson);
-  const existing = normalizeExports(pkg.exports);
-  const merged = { ...existing };
-  const conflicts = [];
-  for (const [key, value] of Object.entries(entries)) {
-    if (key in existing && existing[key] !== value) {
-      conflicts.push(key);
-    }
-    merged[key] = value;
-  }
-  const changed = JSON.stringify(pkg.exports) !== JSON.stringify(merged);
-  const out = { ...pkg, exports: merged };
-  return { changed, json: `${JSON.stringify(out, null, 2)}
-`, conflicts };
-}
-function normalizeExports(exports) {
-  if (exports === void 0) return {};
-  if (typeof exports === "string") return { ".": exports };
-  if (Array.isArray(exports)) return { ".": exports };
-  if (!isPlainObject(exports)) return {};
-  if (isSubpathExportMap(exports)) return exports;
-  return { ".": exports };
-}
-function isSubpathExportMap(exports) {
-  return Object.keys(exports).some((key) => key === "." || key.startsWith("./"));
-}
-function nearestPackageJson(start) {
-  let current = start;
-  while (true) {
-    const candidate = join4(current, "package.json");
-    if (existsSync3(candidate)) return candidate;
-    const parent = dirname6(current);
-    if (parent === current) return void 0;
-    current = parent;
-  }
-}
 export {
+  buildCodegenOverlay,
   bundleConfig,
+  collectArtifactConflicts,
+  collectExportMissingDiagnostics,
+  collectNameCollisionDiagnostics,
+  collectPatternNames,
+  collectRecipeNames,
   collectTokenPaths,
   compilePreset,
   createConfigSnapshot,
@@ -1381,6 +1649,8 @@ export {
   diffConfig,
   filterPublishableLibFiles,
   findConfig,
+  getPandaMajorRange,
+  isStampablePandaRange,
   loadConfig,
   mergeConfigs,
   mergeExcludes,