@pandacss/config 2.0.0-beta.8 → 2.0.0

package/dist/index.js

@@ -1,37 +1,39 @@
 import {
-  PandaError,
-  createConfigDiagnostic,
-  createConfigError,
-  ensureConfigObject,
-  errorMessage,
-  isPlainObject,
   mergeConfigs,
   mergeConfigsWithSources
-} from "./chunk-YKIDLZNO.js";
+} from "./chunk-LDC4ZCDS.js";
 import {
   collectPluginHookHandlers,
   createConfigSnapshot,
   normalizeHook
-} from "./chunk-VYX3JX5J.js";
+} from "./chunk-Y642H6DU.js";
+import {
+  PandaError,
+  clone,
+  createConfigDiagnostic,
+  createConfigError,
+  ensureConfigObject,
+  errorMessage,
+  isPlainObject
+} 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 { rolldown } from "rolldown";
+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",
@@ -75,6 +77,7 @@ function isNode(value, type) {
 // src/bundle.ts
 var nodeBuiltins = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 async function bundleConfig(filepath, cwd) {
+  const { rolldown } = await import("rolldown");
   const build = await rolldown({
     input: filepath,
     cwd,
@@ -102,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 });
@@ -114,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)}`;
@@ -165,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",
@@ -210,11 +223,11 @@ function findConfig(options) {
 // src/hook-utils.ts
 var configResolvedUtils = {
   omit(obj, paths) {
-    const clone = cloneValue(obj);
+    const next = clone(obj);
     for (const path of paths) {
-      deleteAtPath(clone, path);
+      deleteAtPath(next, path);
     }
-    return clone;
+    return next;
   },
   pick(obj, paths) {
     const result = {};
@@ -230,23 +243,6 @@ var configResolvedUtils = {
     traverseValue(obj, callback, options);
   }
 };
-function cloneValue(value) {
-  if (Array.isArray(value)) {
-    const len = value.length;
-    const out2 = new Array(len);
-    for (let i = 0; i < len; i++) out2[i] = cloneValue(value[i]);
-    return out2;
-  }
-  if (!isPlainObject(value)) return value;
-  const source = value;
-  const out = {};
-  const keys = Object.keys(source);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    out[key] = cloneValue(source[key]);
-  }
-  return out;
-}
 function pathParts(path) {
   return path.split(".").filter(Boolean);
 }
@@ -263,7 +259,7 @@ function setAtPath(target, path, value) {
   let current = target;
   parts.forEach((part, index) => {
     if (index === parts.length - 1) {
-      current[part] = cloneValue(value);
+      current[part] = clone(value);
       return;
     }
     const next = current[part];
@@ -337,20 +333,121 @@ 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) {
+  return {
+    hash: normalizeHash(config.hash),
+    prefix: normalizePrefix(config.prefix),
+    separator: config.separator ?? "_"
+  };
+}
+function diffClassNameOptions(consumer, designSystem, scope) {
+  const normalized = normalizeClassNameOptions(consumer);
+  return CLASS_NAME_OPTION_KEYS.filter((key) => {
+    if (scope === "explicit" && consumer[key] === void 0) {
+      return false;
+    }
+    if (key === "separator") {
+      return normalized.separator !== designSystem.separator;
+    }
+    return normalized[key].cssVar !== designSystem[key].cssVar || normalized[key].className !== designSystem[key].className;
+  });
+}
+function normalizeHash(value) {
+  if (typeof value === "boolean") {
+    return { cssVar: value, className: value };
+  }
+  if (value && typeof value === "object") {
+    return { cssVar: value.cssVar === true, className: value.className === true };
+  }
+  return { cssVar: false, className: false };
+}
+function normalizePrefix(value) {
+  if (typeof value === "string") {
+    return { cssVar: value, className: value };
+  }
+  if (value && typeof value === "object") {
+    return { cssVar: value.cssVar ?? "", className: value.className ?? "" };
+  }
+  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 relative3 } from "path";
+import { normalize as normalize2, relative as relative5 } from "node:path";
 
-// src/design-system.ts
+// 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] });
@@ -360,14 +457,218 @@ function tryResolveFrom(request, fromDir) {
   }
 }
 function isResolveMiss(error) {
-  const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+  const code = errorCode(error);
   return code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
 }
+function resolveFrom(request, fromDir) {
+  try {
+    return { kind: "resolved", path: createRequire(resolve2(fromDir, "noop.js")).resolve(request, { paths: [fromDir] }) };
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return { kind: "not-exported" };
+    if (code === "MODULE_NOT_FOUND") return { kind: "not-installed" };
+    throw error;
+  }
+}
+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.ts
+// src/design-system/chain.ts
+var SPECIFIER_PROTOCOL = /^([a-z][a-z0-9+.-]*):/i;
 async function loadDesignSystemChain(spec, cwd, deps) {
   const levels = [];
   const seenAt = /* @__PURE__ */ new Map();
+  const seenNames = /* @__PURE__ */ new Map();
   let currentSpec = spec;
   let fromDir = cwd;
   let declaredBy;
@@ -383,10 +684,15 @@ async function loadDesignSystemChain(spec, cwd, deps) {
     seenAt.set(manifestPath, levels.length);
     deps.add(manifestPath);
     const { level, parent } = await loadManifestLevel(currentSpec, manifestPath, deps);
+    const priorPath = seenNames.get(level.info.name);
+    if (priorPath !== void 0 && priorPath !== manifestPath) {
+      throw duplicateNameError(level.info.name, priorPath, manifestPath);
+    }
+    seenNames.set(level.info.name, manifestPath);
     levels.push(level);
     if (parent === void 0) break;
     declaredBy = level.info.name;
-    fromDir = dirname3(manifestPath);
+    fromDir = dirname4(manifestPath);
     currentSpec = parent;
   }
   return levels.reverse();
@@ -398,43 +704,172 @@ 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 {
-    return tryResolveFrom(`${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)]);
   }
+  if (outcome.kind === "resolved") return outcome.path;
+  if (outcome.kind === "not-exported") throw manifestNotExportedError(spec);
+  return void 0;
+}
+function manifestNotExportedError(spec) {
+  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/*\`.`
+    ])
+  ]);
 }
 async function loadManifestLevel(spec, manifestPath, deps) {
-  let manifest;
+  let parsed;
   try {
-    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
   } catch (error) {
-    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to read ${JSON.stringify(manifestPath)}: ${errorMessage(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, [
+      { ...createConfigDiagnostic("design_system_manifest_invalid", message), file: manifestPath }
+    ]);
   }
-  if (typeof manifest.preset !== "string") {
-    throw invalidManifestError(spec, "preset");
-  }
-  if (typeof manifest.buildInfo !== "string") {
-    throw invalidManifestError(spec, "buildInfo");
-  }
-  const presetPath = resolve3(dirname3(manifestPath), manifest.preset);
-  const buildInfoPath = resolve3(dirname3(manifestPath), manifest.buildInfo);
+  const manifest = validateManifest(spec, manifestPath, parsed);
+  const presetPath = resolve4(dirname4(manifestPath), manifest.preset);
+  const buildInfoPath = resolve4(dirname4(manifestPath), manifest.buildInfo);
   deps.add(presetPath);
   deps.add(buildInfoPath);
   let preset;
   try {
     const mod = await import(presetImportUrl(presetPath));
-    preset = ensureConfigObject(mod.default ?? mod, manifest.name ?? spec);
+    preset = ensureConfigObject("default" in mod ? mod.default : mod, manifest.name ?? spec);
   } catch (error) {
-    if (error instanceof PandaError) throw error;
-    throw new PandaError(
-      "CONFIG_ERROR",
-      `\u{1F4A5} Failed to load preset for designSystem ${JSON.stringify(spec)}: ${errorMessage(error)}`
-    );
+    if (error instanceof PandaError && error.diagnostics?.length) throw error;
+    const message = `Failed to load the preset for designSystem ${JSON.stringify(spec)} (${JSON.stringify(manifest.preset)}): ${errorMessage(error)}`;
+    throw createConfigError(message, [
+      createConfigDiagnostic("design_system_preset_load_failed", message, [
+        `Check that ${JSON.stringify(manifest.preset)} is valid and rebuild ${JSON.stringify(spec)} with \`panda lib\`.`
+      ])
+    ]);
   }
   const parent = typeof manifest.designSystem === "string" && manifest.designSystem.length > 0 ? manifest.designSystem : void 0;
+  const packageExports = readPackageExports(manifestPath);
   return {
     parent,
     level: {
@@ -447,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));
@@ -466,6 +917,53 @@ function designSystemImportMap(map, spec) {
     tokens: map.tokens ?? `${spec}/tokens`
   };
 }
+var IMPORT_MAP_FIELDS = ["css", "recipes", "patterns", "jsx", "tokens"];
+function validateManifest(spec, manifestPath, value) {
+  if (!isPlainObject(value)) {
+    throw invalidManifestError(spec, manifestPath, ["must contain a JSON object"]);
+  }
+  const issues = [];
+  requiredString(value, "name", issues);
+  requiredString(value, "panda", issues);
+  requiredString(value, "preset", issues);
+  requiredString(value, "buildInfo", issues);
+  if (!Number.isInteger(value.schemaVersion) || value.schemaVersion < 1) {
+    issues.push('must contain a positive integer "schemaVersion" entry');
+  }
+  if (value.version !== void 0 && typeof value.version !== "string") {
+    issues.push('has a "version" entry that must be a string');
+  }
+  if (value.designSystem !== void 0 && !isNonEmptyString(value.designSystem)) {
+    issues.push('has a "designSystem" entry that must be a non-empty string');
+  }
+  if (value.files !== void 0 && (!Array.isArray(value.files) || !value.files.every((file) => isNonEmptyString(file)))) {
+    issues.push('has a "files" entry that must be an array of non-empty strings');
+  }
+  if (value.importMap !== void 0) {
+    if (!isPlainObject(value.importMap)) {
+      issues.push('has an "importMap" entry that must be an object');
+    } else {
+      for (const field of IMPORT_MAP_FIELDS) {
+        const entry = value.importMap[field];
+        if (entry !== void 0 && !isNonEmptyString(entry)) {
+          issues.push(`has an "importMap.${field}" entry that must be a non-empty string`);
+        }
+      }
+    }
+  }
+  if (issues.length > 0) {
+    throw invalidManifestError(spec, manifestPath, issues);
+  }
+  return value;
+}
+function requiredString(value, field, issues) {
+  if (!isNonEmptyString(value[field])) {
+    issues.push(`is missing a "${field}" entry or it is empty`);
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
 function notResolvedError(spec) {
   const message = `designSystem ${JSON.stringify(spec)} could not be resolved. Install it, or \u2014 if it isn't a Panda design system \u2014 build it with \`panda lib\`.`;
   return createConfigError(message, [
@@ -486,22 +984,36 @@ function cycleError(cycle) {
   const message = `Design-system cycle: ${cycle.join(" \u2192 ")}. A design system can't depend on itself.`;
   return createConfigError(message, [createConfigDiagnostic("design_system_cycle", message)]);
 }
-function invalidManifestError(spec, field) {
-  const message = `${JSON.stringify(spec)} manifest is missing a "${field}" entry.`;
+function invalidManifestError(spec, manifestPath, issues) {
+  const message = `${JSON.stringify(spec)} manifest ${issues.join("; ")}.`;
   return createConfigError(message, [
-    createConfigDiagnostic("design_system_manifest_invalid", message, [
-      `Rebuild ${JSON.stringify(spec)} with \`panda lib\`.`
-    ])
+    {
+      ...createConfigDiagnostic("design_system_manifest_invalid", message, [
+        `Rebuild ${JSON.stringify(spec)} with \`panda lib\`.`
+      ]),
+      file: manifestPath
+    }
   ]);
 }
+function duplicateNameError(name, firstPath, secondPath) {
+  const message = `Two different packages in the design-system chain are both named ${JSON.stringify(name)} (${JSON.stringify(firstPath)} and ${JSON.stringify(secondPath)}). Their styles would overwrite each other; give each package a unique name.`;
+  return createConfigError(message, [createConfigDiagnostic("design_system_duplicate_name", message)]);
+}
+function specifierProtocol(spec) {
+  const match = spec.match(SPECIFIER_PROTOCOL);
+  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\`.`;
+  return createConfigError(message, [createConfigDiagnostic("design_system_unsupported_specifier", message)]);
+}
 
-// src/smart-include.ts
-import { existsSync as existsSync2 } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join2, relative as relative2, resolve as resolve4, sep } from "path";
+// 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;
-var PATH_SEPARATOR = /[\\/]/;
 function resolveSmartInclude(include, cwd, deps) {
   const offenders = [];
   const next = [];
@@ -516,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;
     }
@@ -525,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/**`);
@@ -548,11 +1060,11 @@ function mergeExcludes(existing, additions) {
   return [...existing ?? [], ...additions];
 }
 function isLocalPath(entry, cwd) {
-  return existsSync2(isAbsolute3(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);
 }
@@ -566,30 +1078,27 @@ function tryResolve(request, cwd) {
 }
 function isInsideCwd(relativePath) {
   if (relativePath === "" || relativePath === "..") return false;
-  if (isAbsolute3(relativePath)) return false;
+  if (isAbsolute4(relativePath)) return false;
   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 = relative2(cwd, packageDir);
+  const rel = relative4(cwd, packageDir);
   const base = isInsideCwd(rel) ? rel : packageDir;
-  return toPosix(base);
-}
-function toPosix(path) {
-  return path.split(PATH_SEPARATOR).join("/");
+  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(
@@ -602,18 +1111,46 @@ function inIncludeError(specs) {
   );
 }
 
-// src/token-paths.ts
+// src/design-system/token-paths.ts
+import { isDeepStrictEqual } from "node:util";
 function collectTokenPaths(config) {
-  if (!isPlainObject(config?.theme)) return [];
-  const paths = /* @__PURE__ */ new Set();
-  collect(config.theme.tokens, [], paths);
-  collect(config.theme.semanticTokens, [], paths);
+  return [...collectTokenEntries(config).keys()].sort();
+}
+function collectTokenEntries(config) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!isPlainObject(config?.theme)) {
+    return entries;
+  }
+  collect(config.theme.tokens, [], entries);
+  collect(config.theme.semanticTokens, [], entries);
+  return entries;
+}
+function resolveUserTokenPathsAfterHooks(userTokenPaths, beforeHooks, afterHooks) {
+  const paths = new Set(userTokenPaths);
+  const after = collectTokenEntries(afterHooks);
+  for (const path of paths) {
+    if (!after.has(path)) {
+      paths.delete(path);
+    }
+  }
+  for (const [path, values] of after) {
+    if (!beforeHooks.has(path) || !isDeepStrictEqual(beforeHooks.get(path), values)) {
+      paths.add(path);
+    }
+  }
   return [...paths].sort();
 }
 function collect(node, trail, out) {
-  if (!isPlainObject(node)) return;
+  if (!isPlainObject(node)) {
+    return;
+  }
   if ("value" in node) {
-    if (trail.length > 0) out.add(trail.join("."));
+    if (trail.length > 0) {
+      const path = trail.join(".");
+      const entries = out.get(path) ?? [];
+      entries.push(node.value);
+      out.set(path, entries);
+    }
     return;
   }
   for (const [key, child] of Object.entries(node)) {
@@ -621,59 +1158,115 @@ 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 resolveAuthoredPresets(config, cwd, options = {}) {
+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(relative3(cwd, options.configFile));
-  const designSystem = config.designSystem;
+  if (options.configFile) {
+    rootSource.file = normalize2(relative5(cwd, options.configFile));
+  }
   let dsChain = [];
-  if (typeof designSystem === "string" && designSystem.length > 0) {
+  const designSystemCompatibility = [];
+  if (hasDesignSystem) {
     dsChain = await loadDesignSystemChain(designSystem, cwd, ctx.dependencies);
     for (const level of dsChain) {
-      const block = await collectConfigBlock(
-        level.preset,
-        { kind: "preset", specifier: level.info.name },
-        cwd,
-        ctx.dependencies,
-        options.trackSources
-      );
-      level.info.tokenPaths = collectTokenPaths(block.resolved);
-      appendConfigBlock(ctx, block);
+      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)),
+        presetConfig: resolution.config
+      });
+    }
+  }
+  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");
+    if (mismatch.length > 0) {
+      designSystem2.optionMismatch = mismatch;
     }
   }
-  const rootBlock = await collectConfigBlock(config, rootSource, cwd, ctx.dependencies, options.trackSources);
-  appendConfigBlock(ctx, rootBlock);
   const dsInfos = dsChain.map((level) => level.info);
   const finalize = (resolved) => {
     const withImportMap = dsInfos.length > 0 ? withDesignSystemImportMap(resolved, dsInfos) : resolved;
     return expandSmartInclude(withImportMap, cwd, ctx.dependencies);
   };
-  const dsMetadata = dsInfos.length > 0 ? { designSystem: dsInfos, userTokenPaths: collectTokenPaths(rootBlock.resolved) } : void 0;
+  const leafCompatibility = designSystemCompatibility[designSystemCompatibility.length - 1];
   if (ctx.sourcedConfigs) {
     const merged = mergeConfigsWithSources(ctx.sourcedConfigs);
-    if (options.preserveRuntimeHooks) attachRuntimeHooks(merged.config, ctx.configs);
+    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 } : {}
+    ...dsMetadata ? { metadata: dsMetadata } : {},
+    designSystemCompatibility
   };
 }
-async function collectConfigBlock(config, source, cwd, dependencies, trackSources) {
+async function resolveConfigEntry(config, source, cwd, dependencies, trackSources) {
   const ctx = {
     cwd,
     configs: [],
@@ -685,13 +1278,13 @@ async function collectConfigBlock(config, source, cwd, dependencies, trackSource
   return {
     configs: ctx.configs,
     ...ctx.sourcedConfigs ? { sourcedConfigs: ctx.sourcedConfigs } : {},
-    resolved: mergeConfigs(ctx.configs)
+    config: mergeConfigs(ctx.configs)
   };
 }
-function appendConfigBlock(ctx, block) {
-  ctx.configs.push(...block.configs);
-  if (ctx.sourcedConfigs && block.sourcedConfigs) {
-    ctx.sourcedConfigs.push(...block.sourcedConfigs);
+function appendConfigResolution(ctx, resolution) {
+  ctx.configs.push(...resolution.configs);
+  if (ctx.sourcedConfigs && resolution.sourcedConfigs) {
+    ctx.sourcedConfigs.push(...resolution.sourcedConfigs);
   }
 }
 async function collectConfigs(config, source, ctx, active) {
@@ -777,7 +1370,7 @@ async function loadConfig(options) {
   if (!isPlainObject(config)) {
     throw new PandaError("CONFIG_ERROR", "\u{1F4A5} Config must export or return an object.");
   }
-  const authored = await resolveAuthoredPresets(config, cwd, {
+  const authored = await resolveAuthoredPresetsForLoad(config, cwd, {
     configFile: path,
     trackSources: options.trackSources,
     preserveRuntimeHooks: true
@@ -785,8 +1378,16 @@ async function loadConfig(options) {
   const authoredDependencies = Array.from(
     /* @__PURE__ */ new Set([...dependencies, ...authored.dependencies, ...authored.config.dependencies ?? []])
   );
+  const tokenEntriesBeforeHooks = collectTokenEntries(authored.config);
   const userConfig = await runConfigResolvedHooks(authored.config, path, authoredDependencies);
-  const resolved = applyConfigDefaults(userConfig, cwd);
+  const resolved = applyConfigDefaults2(userConfig, cwd);
+  refreshDesignSystemMetadata(
+    authored.metadata,
+    authored.designSystemCompatibility,
+    resolved,
+    tokenEntriesBeforeHooks,
+    cwd
+  );
   const dependencyList = Array.from(
     /* @__PURE__ */ new Set([...dependencies, ...authored.dependencies, ...resolved.dependencies ?? []])
   );
@@ -798,12 +1399,40 @@ async function loadConfig(options) {
     ...snapshot.hooks ? { hooks: snapshot.hooks } : {},
     hostHooks: {
       "codegen:prepare": collectPluginHookHandlers(resolved, "codegen:prepare"),
-      "codegen:done": collectPluginHookHandlers(resolved, "codegen:done")
+      "codegen:done": collectPluginHookHandlers(resolved, "codegen:done"),
+      "cssgen:done": collectPluginHookHandlers(resolved, "cssgen:done")
     },
     dependencies: dependencyList,
     ...authored.metadata ? { metadata: authored.metadata } : {}
   };
 }
+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) {
+      designSystem.optionMismatch = mismatch;
+    } else {
+      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;
   for (const entry of collectPluginHookHandlers(current, "config:resolved")) {
@@ -833,7 +1462,6 @@ var ALL_DEPENDENCIES = [
   "prefix",
   "recipes",
   "separator",
-  "syntax",
   "themes",
   "tokens",
   "utilities"
@@ -887,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":
@@ -925,27 +1551,36 @@ 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/lib-preset.ts
-import { builtinModules as builtinModules2 } from "module";
-import { rolldown as rolldown2 } from "rolldown";
+// src/design-system/compile-preset.ts
+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}`)]);
 async function compilePreset(options) {
   const { configPath, cwd } = options;
-  const build = await rolldown2({
+  const { rolldown } = await import("rolldown");
+  const build = await rolldown({
     input: VIRTUAL_ENTRY,
     cwd,
     platform: "node",
@@ -996,100 +1631,33 @@ async function validatePreset(code) {
   try {
     await import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`);
   } catch (error) {
-    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to compile design system preset: ${errorMessage2(error)}`);
-  }
-}
-function errorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/lib-manifest.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join4, relative as relative4 } from "path";
-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
-  };
-}
-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 };
-  for (const [key, value] of Object.entries(entries)) 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)}
-` };
-}
-function toPosixPath(path) {
-  return path.split("\\").join("/");
-}
-function toPosixRelative(from, to) {
-  const rel = toPosixPath(relative4(from, to));
-  return rel.startsWith(".") ? rel : `./${rel}`;
-}
-function toRelativeKey(key, cwd) {
-  return toPosixPath(isAbsolute4(key) ? relative4(cwd, key) : key);
-}
-function isPlainObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeExports(exports) {
-  if (exports === void 0) return {};
-  if (typeof exports === "string") return { ".": exports };
-  if (!isPlainObject2(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;
+    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to compile design system preset: ${errorMessage(error)}`);
   }
 }
 export {
+  buildCodegenOverlay,
   bundleConfig,
+  collectArtifactConflicts,
+  collectExportMissingDiagnostics,
+  collectNameCollisionDiagnostics,
+  collectPatternNames,
+  collectRecipeNames,
   collectTokenPaths,
   compilePreset,
   createConfigSnapshot,
   defaultImportMap,
   diffConfig,
+  filterPublishableLibFiles,
   findConfig,
+  getPandaMajorRange,
+  isStampablePandaRange,
   loadConfig,
   mergeConfigs,
   mergeExcludes,
   readPackageIdentity,
   readPandaVersion,
+  readPublishFilesField,
+  resolvePublishedPandaRange,
   resolveSmartInclude,
   syncExports,
   toPosixPath,