@pandacss/config 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/index.js

@@ -1,17 +1,24 @@
 import {
-  PandaError,
-  isPlainObject,
   mergeConfigs,
   mergeConfigsWithSources
-} from "./chunk-LUSBBUHX.js";
+} from "./chunk-PER4IFQZ.js";
 import {
   collectPluginHookHandlers,
   createConfigSnapshot,
   normalizeHook
-} from "./chunk-VYX3JX5J.js";
+} from "./chunk-U6KCSKCU.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";
@@ -20,7 +27,6 @@ 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";
 
 // src/bundle-plugins.ts
 import { parse } from "acorn";
@@ -71,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,
@@ -206,11 +213,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 = {};
@@ -226,23 +233,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);
 }
@@ -259,7 +249,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];
@@ -307,56 +297,986 @@ function traverseValue(value, callback, options, parent, key, path = "", depth =
 function joinPath(parent, key, separator) {
   return parent ? `${parent}${separator}${key}` : key;
 }
+function attachRuntimeHooks(config, configs) {
+  const plugins = configs.flatMap((item) => {
+    if ("hooks" in item && item.hooks != null) {
+      const message = '`config.hooks` was removed in v2. Use `plugins: [{ name: "local", hooks: { ... } }]` instead.';
+      throw createConfigError(message, [
+        createConfigDiagnostic("config_hooks_removed", message, [
+          'Move root `hooks` into `plugins: [{ name: "local", hooks: { ... } }]`.'
+        ])
+      ]);
+    }
+    return [...item.plugins ?? [], ...item.extend?.plugins ?? []];
+  });
+  for (const plugin of plugins) {
+    if (!isPlainObject(plugin) || typeof plugin.name !== "string" || plugin.name.length === 0) {
+      throw new PandaError(
+        "CONFIG_ERROR",
+        "\u{1F4A5} Every plugin in `config.plugins` must be an object with a non-empty `name`."
+      );
+    }
+  }
+  if (plugins.length > 0) {
+    config.plugins = plugins;
+  }
+  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",
+  "syntax",
+  "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 relative5 } from "path";
+
+// src/design-system/chain.ts
+import {
+  outdirBasename
+} from "@pandacss/compiler-shared";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { dirname as dirname4, resolve as resolve4 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+
+// src/resolve.ts
+import { createRequire } from "module";
+import { resolve as resolve2 } from "path";
+function tryResolveFrom(request, fromDir) {
+  try {
+    return createRequire(resolve2(fromDir, "noop.js")).resolve(request, { paths: [fromDir] });
+  } catch (error) {
+    if (isResolveMiss(error)) return void 0;
+    throw error;
+  }
+}
+function isResolveMiss(error) {
+  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 "fs";
+import { dirname as dirname3, join as join2 } from "path";
+
+// src/design-system/publishable-files.ts
+import { relative as relative3, resolve as resolve3 } 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/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) {
+  const levels = [];
+  const seenAt = /* @__PURE__ */ new Map();
+  const seenNames = /* @__PURE__ */ new Map();
+  let currentSpec = spec;
+  let fromDir = cwd;
+  let declaredBy;
+  while (true) {
+    const manifestPath = resolveManifestPath(currentSpec, fromDir);
+    if (manifestPath === void 0) {
+      throw declaredBy === void 0 ? notResolvedError(currentSpec) : parentNotResolvedError(declaredBy, currentSpec);
+    }
+    const seen = seenAt.get(manifestPath);
+    if (seen !== void 0) {
+      throw cycleError([...levels.slice(seen).map((level2) => level2.info.name), levels[seen].info.name]);
+    }
+    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 = dirname4(manifestPath);
+    currentSpec = parent;
+  }
+  return levels.reverse();
+}
+function withDesignSystemImportMap(config, infos) {
+  const existing = config.importMap === void 0 ? [] : Array.isArray(config.importMap) ? config.importMap : [config.importMap];
+  const roots = infos.map(
+    (info) => info.importMap ? designSystemImportMap(info.importMap, info.specifier) : info.specifier
+  );
+  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);
+  } 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 parsed;
+  try {
+    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, [
+      { ...createConfigDiagnostic("design_system_manifest_invalid", message), file: manifestPath }
+    ]);
+  }
+  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("default" in mod ? mod.default : mod, manifest.name ?? spec);
+  } catch (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: {
+      preset,
+      info: {
+        name: manifest.name ?? spec,
+        specifier: spec,
+        manifest,
+        manifestPath,
+        buildInfoPath,
+        files: manifest.files ?? [],
+        tokenPaths: [],
+        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));
+  return url.href;
+}
+function designSystemImportMap(map, spec) {
+  return {
+    css: map.css ?? `${spec}/css`,
+    recipes: map.recipes ?? `${spec}/recipes`,
+    patterns: map.patterns ?? `${spec}/patterns`,
+    jsx: map.jsx ?? `${spec}/jsx`,
+    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, [
+    createConfigDiagnostic("design_system_manifest_not_found", message, [
+      `Install ${JSON.stringify(spec)}, or build it with \`panda lib\` if it is a Panda design system.`
+    ])
+  ]);
+}
+function parentNotResolvedError(child, parent) {
+  const message = `designSystem ${JSON.stringify(child)} extends ${JSON.stringify(parent)}, which isn't installed alongside it. Install it where ${JSON.stringify(child)} can resolve it, or rebuild that library with \`panda lib\`.`;
+  return createConfigError(message, [
+    createConfigDiagnostic("design_system_parent_not_found", message, [
+      `Install ${JSON.stringify(parent)} where ${JSON.stringify(child)} can resolve it, or rebuild ${JSON.stringify(child)} with \`panda lib\`.`
+    ])
+  ]);
+}
+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, 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\`.`
+      ]),
+      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/design-system/smart-include.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join3, relative as relative4, resolve as resolve5, sep } from "path";
+var SMART_INCLUDE_EXTENSIONS = ["js", "mjs", "cjs", "jsx", "ts", "cts", "mts", "tsx", "vue", "svelte", "astro"];
+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 = [];
+  const next = [];
+  const excludes = [];
+  let changed = false;
+  for (const entry of include) {
+    if (!PACKAGE_SPECIFIER.test(entry)) {
+      next.push(entry);
+      continue;
+    }
+    if (isLocalPath(entry, cwd)) {
+      next.push(entry);
+      continue;
+    }
+    if (tryResolveFrom(`${entry}/${MANIFEST_SUBPATH}`, cwd) !== void 0) {
+      offenders.push(entry);
+      continue;
+    }
+    const packageDir = resolvePackageDir(entry, cwd);
+    if (packageDir === void 0) {
+      next.push(entry);
+      continue;
+    }
+    if (existsSync3(join3(packageDir, ...MANIFEST_SUBPATH.split("/")))) {
+      offenders.push(entry);
+      continue;
+    }
+    deps.add(join3(packageDir, "package.json"));
+    const base = globBase(packageDir, cwd);
+    next.push(`${base}/**/*.{${SMART_INCLUDE_EXTENSIONS.join(",")}}`);
+    excludes.push(`${base}/**/node_modules/**`);
+    changed = true;
+  }
+  if (offenders.length > 0) throw inIncludeError(offenders);
+  return { include: changed ? next : include, excludes, changed };
+}
+function expandSmartInclude(config, cwd, deps) {
+  if (!config.include || config.include.length === 0) return config;
+  const resolved = resolveSmartInclude(config.include, cwd, deps);
+  if (!resolved.changed) return config;
+  return { ...config, include: resolved.include, exclude: mergeExcludes(config.exclude, resolved.excludes) };
+}
+function mergeExcludes(existing, additions) {
+  return [...existing ?? [], ...additions];
+}
+function isLocalPath(entry, cwd) {
+  return existsSync3(isAbsolute4(entry) ? entry : resolve5(cwd, entry));
+}
+function resolvePackageDir(spec, cwd) {
+  const fromPackageJson = tryResolve(`${spec}/package.json`, cwd);
+  if (fromPackageJson !== void 0) return dirname5(fromPackageJson);
+  const fromEntry = tryResolve(spec, cwd);
+  return fromEntry === void 0 ? void 0 : nearestPackageDir(fromEntry);
+}
+function tryResolve(request, cwd) {
+  try {
+    return tryResolveFrom(request, cwd);
+  } catch (error) {
+    const message = `Failed to resolve include package ${JSON.stringify(request)} from ${JSON.stringify(cwd)}: ${errorMessage(error)}`;
+    throw createConfigError(message, [createConfigDiagnostic("include_package_resolution_failed", message)]);
+  }
+}
+function isInsideCwd(relativePath) {
+  if (relativePath === "" || relativePath === "..") return false;
+  if (isAbsolute4(relativePath)) return false;
+  return !relativePath.startsWith(`..${sep}`);
+}
+function nearestPackageDir(from) {
+  let dir = dirname5(from);
+  while (true) {
+    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 = 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_SUBPATH}, so ${plural ? "they belong" : "it belongs"} in \`designSystem\`, not \`include\`. \`include\` is for files, not design systems.`;
+  return createConfigError(
+    message,
+    specs.map(
+      (spec) => createConfigDiagnostic(
+        "design_system_in_include",
+        `Design system ${JSON.stringify(spec)} is listed in \`include\`. Move it to \`designSystem\`; \`include\` is for files, not design systems.`,
+        [`Move ${JSON.stringify(spec)} to \`designSystem\`.`]
+      )
+    )
+  );
+}
+
+// src/design-system/token-paths.ts
+import { isDeepStrictEqual } from "util";
+function collectTokenPaths(config) {
+  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 ("value" in node) {
+    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)) {
+    collect(child, [...trail, key], 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
-import { normalize as normalize2, relative as relative2 } from "path";
-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(relative2(cwd, options.configFile));
-  await collectConfigs(config, rootSource, ctx, /* @__PURE__ */ new WeakSet());
+  if (options.configFile) {
+    rootSource.file = normalize2(relative5(cwd, options.configFile));
+  }
+  let dsChain = [];
+  const designSystemCompatibility = [];
+  if (hasDesignSystem) {
+    dsChain = await loadDesignSystemChain(designSystem, cwd, ctx.dependencies);
+    for (const level of dsChain) {
+      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 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 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: merged.config,
+      config: finalized2,
       dependencies: Array.from(ctx.dependencies),
-      metadata: { sources: merged.sources }
+      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: options.preserveRuntimeHooks ? attachRuntimeHooks(mergeConfigs(ctx.configs), ctx.configs) : mergeConfigs(ctx.configs),
-    dependencies: Array.from(ctx.dependencies)
+    config: finalized,
+    dependencies: Array.from(ctx.dependencies),
+    ...dsMetadata ? { metadata: dsMetadata } : {},
+    designSystemCompatibility
   };
 }
-function attachRuntimeHooks(config, configs) {
-  const plugins = configs.flatMap((item) => {
-    if ("hooks" in item && item.hooks != null) {
-      throw new PandaError(
-        "CONFIG_ERROR",
-        '\u{1F4A5} `config.hooks` was removed in v2. Use `plugins: [{ name: "local", hooks: { ... } }]` instead.'
-      );
-    }
-    return [...item.plugins ?? [], ...item.extend?.plugins ?? []];
-  });
-  for (const plugin of plugins) {
-    if (!isPlainObject(plugin) || typeof plugin.name !== "string" || plugin.name.length === 0) {
-      throw new PandaError(
-        "CONFIG_ERROR",
-        "\u{1F4A5} Every plugin in `config.plugins` must be an object with a non-empty `name`."
-      );
-    }
-  }
-  if (plugins.length > 0) {
-    config.plugins = plugins;
+async function resolveConfigEntry(config, source, cwd, dependencies, trackSources) {
+  const ctx = {
+    cwd,
+    configs: [],
+    dependencies,
+    presetResolvedHooks: [],
+    ...trackSources ? { sourcedConfigs: [] } : {}
+  };
+  await collectConfigs(config, source, ctx, /* @__PURE__ */ new WeakSet());
+  return {
+    configs: ctx.configs,
+    ...ctx.sourcedConfigs ? { sourcedConfigs: ctx.sourcedConfigs } : {},
+    config: mergeConfigs(ctx.configs)
+  };
+}
+function appendConfigResolution(ctx, resolution) {
+  ctx.configs.push(...resolution.configs);
+  if (ctx.sourcedConfigs && resolution.sourcedConfigs) {
+    ctx.sourcedConfigs.push(...resolution.sourcedConfigs);
   }
-  return config;
 }
 async function collectConfigs(config, source, ctx, active) {
   if (active.has(config)) {
@@ -402,10 +1322,7 @@ async function resolvePreset(preset, cwd) {
       };
     } catch (error) {
       if (error instanceof PandaError) throw error;
-      throw new PandaError(
-        "CONFIG_ERROR",
-        `\u{1F4A5} Failed to resolve preset ${JSON.stringify(preset)}: ${errorMessage(error)}`
-      );
+      throw presetResolutionError(JSON.stringify(preset), error);
     }
   }
   try {
@@ -417,12 +1334,12 @@ async function resolvePreset(preset, cwd) {
     };
   } catch (error) {
     if (error instanceof PandaError) throw error;
-    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to resolve preset "unknown-preset": ${errorMessage(error)}`);
+    throw presetResolutionError('"unknown-preset"', error);
   }
 }
-function ensureConfigObject(config, name) {
-  if (isPlainObject(config)) return config;
-  throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Preset ${JSON.stringify(name)} must resolve to an object.`);
+function presetResolutionError(name, error) {
+  const message = `Failed to resolve preset ${name}: ${errorMessage(error)}`;
+  return createConfigError(message, [createConfigDiagnostic("preset_resolution_failed", message)]);
 }
 function presetName(config) {
   return isPlainObject(config) && typeof config.name === "string" ? config.name : void 0;
@@ -435,9 +1352,6 @@ function presetSource(config, specifier, file) {
   if (file) source.file = file;
   return source;
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/load.ts
 async function loadConfig(options) {
@@ -447,7 +1361,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
@@ -455,8 +1369,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 ?? []])
   );
@@ -468,12 +1390,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")) {
@@ -593,11 +1543,118 @@ function diffInput(input) {
 function isConfigSnapshot(input) {
   return !!input && typeof input === "object" && !Array.isArray(input) && ("callbacks" in input || "hooks" in input) && "config" in input && !!input.config && typeof input.config === "object" && !Array.isArray(input.config);
 }
+
+// src/version.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname6, join as join4 } from "path";
+import { fileURLToPath } from "url";
+var MAJOR_VERSION_RE = /\d+/;
+var STAMPABLE_PANDA_RANGE_RE = /^[v=><~^]|^\d/;
+function readPandaVersion() {
+  try {
+    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";
+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 { rolldown } = await import("rolldown");
+  const build = await rolldown({
+    input: VIRTUAL_ENTRY,
+    cwd,
+    platform: "node",
+    external: (id) => nodeBuiltins2.has(id),
+    treeshake: true,
+    plugins: [importMetaUrlPlugin(), presetEntryPlugin(configPath)]
+  });
+  let chunks;
+  try {
+    chunks = await build.generate({ format: "esm", exports: "named", codeSplitting: false });
+  } finally {
+    await build.close?.();
+  }
+  const output = chunks.output.find((item) => item.type === "chunk");
+  if (!output || output.type !== "chunk") {
+    throw new PandaError("CONFIG_ERROR", "\u{1F4A5} Preset bundle did not produce an executable module.");
+  }
+  await validatePreset(output.code);
+  const dependencies = Object.keys(output.modules ?? {}).filter((id) => id !== VIRTUAL_ENTRY);
+  return { code: output.code, dependencies };
+}
+function presetEntryPlugin(configPath) {
+  return {
+    name: "panda-lib-preset-entry",
+    resolveId(id) {
+      return id === VIRTUAL_ENTRY ? VIRTUAL_ENTRY : null;
+    },
+    load(id) {
+      if (id !== VIRTUAL_ENTRY) return null;
+      const fields = APP_FIELDS.join(", ");
+      return `import __panda_lib_config from ${JSON.stringify(configPath)}
+const __panda_lib_resolved = await __panda_lib_config
+if (!${isPlainObjectSource()}(__panda_lib_resolved)) throw new Error('Config must export or return an object.')
+const { ${fields}, ...preset } = __panda_lib_resolved
+export default preset
+`;
+    }
+  };
+}
+function isPlainObjectSource() {
+  return `((value) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+})`;
+}
+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: ${errorMessage(error)}`);
+  }
+}
 export {
+  buildCodegenOverlay,
   bundleConfig,
+  collectArtifactConflicts,
+  collectExportMissingDiagnostics,
+  collectNameCollisionDiagnostics,
+  collectPatternNames,
+  collectRecipeNames,
+  collectTokenPaths,
+  compilePreset,
   createConfigSnapshot,
+  defaultImportMap,
   diffConfig,
+  filterPublishableLibFiles,
   findConfig,
+  getPandaMajorRange,
+  isStampablePandaRange,
   loadConfig,
-  mergeConfigs
+  mergeConfigs,
+  mergeExcludes,
+  readPackageIdentity,
+  readPandaVersion,
+  readPublishFilesField,
+  resolvePublishedPandaRange,
+  resolveSmartInclude,
+  syncExports,
+  toPosixPath,
+  toPosixRelative,
+  toRelativeKey
 };