@pandacss/config 1.11.3 → 2.0.0-beta.0

package/dist/index.js

@@ -1,1149 +1,540 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all2) => {
-  for (var name in all2)
-    __defProp(target, name, { get: all2[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  bundleConfig: () => bundleConfig,
-  convertTsPathsToRegexes: () => convertTsPathsToRegexes,
-  diffConfigs: () => diffConfigs,
-  findConfig: () => findConfig,
-  getConfigDependencies: () => getConfigDependencies,
-  getResolvedConfig: () => getResolvedConfig,
-  loadConfig: () => loadConfig,
-  mergeConfigs: () => mergeConfigs,
-  mergeHooks: () => mergeHooks,
-  resolveConfig: () => resolveConfig
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/bundle-config.ts
-var import_logger = require("@pandacss/logger");
-var import_shared2 = require("@pandacss/shared");
-
-// src/bundle-n-require.ts
-var import_node_fs = require("fs");
-var import_node_module = require("module");
-var import_node_path = require("path");
-var import_esbuild = require("esbuild");
-var ModuleInternals = import_node_module.Module;
-async function bundleConfigFile(file, cwd, options) {
-  const result = await (0, import_esbuild.build)({
+import {
+  PandaError,
+  isPlainObject,
+  mergeConfigs,
+  mergeConfigsWithSources
+} from "./chunk-LUSBBUHX.js";
+import {
+  collectPluginHookHandlers,
+  createConfigSnapshot,
+  normalizeHook
+} from "./chunk-VYX3JX5J.js";
+
+// src/load.ts
+import { applyConfigDefaults } from "@pandacss/compiler-shared";
+
+// src/bundle.ts
+import { parse } from "acorn";
+import { simple } from "acorn-walk";
+import MagicString from "magic-string";
+import { realpathSync } from "fs";
+import { builtinModules } from "module";
+import { isAbsolute, normalize, relative } from "path";
+import { pathToFileURL } from "url";
+import { rolldown } from "rolldown";
+var nodeBuiltins = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
+async function bundleConfig(filepath, cwd) {
+  const build = await rolldown({
+    input: filepath,
+    cwd,
     platform: "node",
-    format: "cjs",
-    mainFields: ["module", "main"],
-    ...options,
-    absWorkingDir: cwd,
-    entryPoints: [file],
-    outfile: "out.js",
-    write: false,
-    bundle: true,
-    sourcemap: false,
-    metafile: true
+    external: (id) => nodeBuiltins.has(id),
+    treeshake: false,
+    plugins: [importMetaUrlPlugin()]
   });
-  const { text } = result.outputFiles[0];
+  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} Config bundle did not produce an executable module.");
+  }
+  const dependencies = collectDependencies(chunks.output, filepath, cwd);
+  const mod = await importBundledConfig(output.code);
+  const hasDefaultExport = Object.prototype.hasOwnProperty.call(mod ?? {}, "default");
+  const exported = hasDefaultExport ? mod.default : mod;
+  const config = hasDefaultExport && isPromiseLike(exported) ? await exported : exported;
+  return { config, dependencies };
+}
+async function importBundledConfig(code) {
+  const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+  return import(
+    /* @vite-ignore */
+    dataUrl
+  );
+}
+function importMetaUrlPlugin() {
   return {
-    code: text,
-    dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
+    name: "panda-import-meta-url",
+    transform(code, id) {
+      if (!isAbsolute(id) || !code.includes("import.meta.url")) return;
+      const replacement = JSON.stringify(pathToFileURL(id).href);
+      const patched = replaceImportMetaUrl(code, replacement);
+      if (patched === code) return;
+      return { code: patched, map: null };
+    }
   };
 }
-function loadBundledFile(req, file, code) {
-  const extension = (0, import_node_path.extname)(file);
-  const realFileName = import_node_fs.realpathSync.native(file);
-  const loader = req.extensions[extension];
-  req.extensions[extension] = (mod, filename) => {
-    if (filename === realFileName) {
-      ;
-      mod._compile(code, filename);
-    } else {
-      loader?.(mod, filename);
+function replaceImportMetaUrl(code, replacement) {
+  const ast = parse(code, {
+    ecmaVersion: "latest",
+    sourceType: "module"
+  });
+  const output = new MagicString(code);
+  let changed = false;
+  simple(ast, {
+    MemberExpression(node) {
+      if (!isImportMetaUrl(node)) return;
+      output.overwrite(node.start, node.end, replacement);
+      changed = true;
     }
-  };
-  try {
-    delete req.cache[req.resolve(file)];
-    const raw = req(file);
-    return raw?.default ?? raw;
-  } finally {
-    if (loader) req.extensions[extension] = loader;
-    else delete req.extensions[extension];
-  }
+  });
+  return changed ? output.toString() : code;
+}
+function isImportMetaUrl(node) {
+  if (node.computed || !isIdentifier(node.property, "url")) return false;
+  const object = node.object;
+  return isNode(object, "MetaProperty") && isIdentifier(object.meta, "import") && isIdentifier(object.property, "meta");
 }
-function evalBundledFile(file, code) {
-  const mod = new import_node_module.Module(file);
-  mod.filename = file;
-  mod.paths = ModuleInternals._nodeModulePaths((0, import_node_path.dirname)(file));
-  mod._compile(code, file);
-  const raw = mod.exports;
-  return raw?.default ?? raw;
+function isIdentifier(value, name) {
+  return isNode(value, "Identifier") && value.name === name;
 }
-async function bundleNRequire(file, opts = {}) {
-  const { cwd = process.cwd() } = opts;
-  const req = (0, import_node_module.createRequire)((0, import_node_path.join)(cwd, "index.js"));
-  const absPath = req.resolve(file);
-  const { code, dependencies } = await bundleConfigFile(absPath, cwd);
-  let mod;
+function isNode(value, type) {
+  return !!value && typeof value === "object" && value.type === type;
+}
+function isPromiseLike(value) {
+  return value != null && typeof value === "object" && typeof value.then === "function";
+}
+function collectDependencies(output, entry, cwd) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const base = canonical(cwd);
+  const add = (id) => dependencies.add(normalize(relative(base, canonical(id))));
+  for (const item of output) {
+    if (item.type !== "chunk") continue;
+    Object.keys(item.modules ?? {}).forEach((id) => {
+      if (isAbsolute(id)) add(id);
+    });
+  }
+  if (isAbsolute(entry)) add(entry);
+  return Array.from(dependencies);
+}
+function canonical(filepath) {
   try {
-    mod = loadBundledFile(req, absPath, code);
+    return realpathSync(filepath);
   } catch {
-    mod = evalBundledFile(absPath, code);
+    return filepath;
   }
-  return { mod, code, dependencies };
 }
 
-// src/find-config.ts
-var import_shared = require("@pandacss/shared");
-var import_sync = __toESM(require("escalade/sync"));
-var import_path = require("path");
-
-// src/is-panda-config.ts
-var configName = "panda";
-var pandaConfigFiles = /* @__PURE__ */ new Set([
-  `${configName}.config.ts`,
-  `${configName}.config.js`,
-  `${configName}.config.mts`,
-  `${configName}.config.mjs`,
-  `${configName}.config.cts`,
-  `${configName}.config.cjs`
+// src/find.ts
+import { readdirSync } from "fs";
+import { dirname, resolve } from "path";
+var configFiles = /* @__PURE__ */ new Set([
+  "panda.config.ts",
+  "panda.config.js",
+  "panda.config.mts",
+  "panda.config.mjs",
+  "panda.config.cts",
+  "panda.config.cjs"
 ]);
-var isPandaConfig = (file) => pandaConfigFiles.has(file);
-
-// src/find-config.ts
+var isPandaConfig = (file) => configFiles.has(file);
+function findUp(cwd) {
+  let dir = resolve(cwd);
+  while (true) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      entries = [];
+    }
+    const match = entries.find(isPandaConfig);
+    if (match) return resolve(dir, match);
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
 function findConfig(options) {
-  const { cwd = process.cwd(), file } = options;
+  const { cwd, file } = options;
   if (file) {
-    return (0, import_path.resolve)(cwd, file);
+    return resolve(cwd, file);
   }
-  const configPath = (0, import_sync.default)(cwd, (_dir, paths) => paths.find(isPandaConfig));
+  const configPath = findUp(cwd);
   if (!configPath) {
-    throw new import_shared.PandaError(
+    throw new PandaError(
       "CONFIG_NOT_FOUND",
-      `Cannot find config file \`panda.config.{ts,js,mjs,mts}\`. Did you forget to run \`panda init\`?`
+      "Cannot find config file `panda.config.{ts,js,mjs,mts}`. Did you forget to run `panda init`?"
     );
   }
   return configPath;
 }
 
-// src/bundle-config.ts
-async function bundle(filepath, cwd) {
-  const { mod, dependencies } = await bundleNRequire(filepath, { cwd });
-  const config = mod?.default ?? mod;
-  return {
-    config,
-    dependencies
+// src/preset.ts
+import { normalize as normalize2, relative as relative2 } from "path";
+async function resolveAuthoredPresets(config, cwd, options = {}) {
+  const ctx = {
+    cwd,
+    configs: [],
+    dependencies: /* @__PURE__ */ new Set(),
+    presetResolvedHooks: [],
+    ...options.trackSources ? { sourcedConfigs: [] } : {}
   };
-}
-async function bundleConfig(options) {
-  const { cwd, file } = options;
-  const filePath = findConfig({ cwd, file });
-  import_logger.logger.debug("config:path", filePath);
-  const result = await bundle(filePath, cwd);
-  if (typeof result.config !== "object") {
-    throw new import_shared2.PandaError("CONFIG_ERROR", `\u{1F4A5} Config must export or return an object.`);
+  const rootSource = { kind: "config" };
+  if (options.configFile) rootSource.file = normalize2(relative2(cwd, options.configFile));
+  await collectConfigs(config, rootSource, ctx, /* @__PURE__ */ new WeakSet());
+  if (ctx.sourcedConfigs) {
+    const merged = mergeConfigsWithSources(ctx.sourcedConfigs);
+    if (options.preserveRuntimeHooks) attachRuntimeHooks(merged.config, ctx.configs);
+    return {
+      config: merged.config,
+      dependencies: Array.from(ctx.dependencies),
+      metadata: { sources: merged.sources }
+    };
   }
-  result.config.outdir ??= "styled-system";
-  result.config.validation ??= "warn";
   return {
-    ...result,
-    config: result.config,
-    path: filePath
+    config: options.preserveRuntimeHooks ? attachRuntimeHooks(mergeConfigs(ctx.configs), ctx.configs) : mergeConfigs(ctx.configs),
+    dependencies: Array.from(ctx.dependencies)
   };
 }
-
-// src/diff-config.ts
-var import_shared3 = require("@pandacss/shared");
-var import_microdiff = __toESM(require("microdiff"));
-
-// src/create-matcher.ts
-function createMatcher(id, patterns) {
-  if (!patterns?.length) return () => void 0;
-  const includePatterns = [];
-  const excludePatterns = [];
-  const deduped = new Set(patterns);
-  deduped.forEach((pattern) => {
-    const regexString = pattern.replace(/\*/g, ".*");
-    if (pattern.startsWith("!")) {
-      excludePatterns.push(regexString.slice(1));
-    } else {
-      includePatterns.push(regexString);
+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 ?? []];
   });
-  const include = new RegExp(includePatterns.join("|"));
-  const exclude = new RegExp(excludePatterns.join("|"));
-  return (path2) => {
-    if (excludePatterns.length && exclude.test(path2)) return;
-    return include.test(path2) ? id : void 0;
-  };
-}
-
-// src/config-deps.ts
-var all = [
-  "clean",
-  "cwd",
-  "eject",
-  "outdir",
-  "forceConsistentTypeExtension",
-  "outExtension",
-  "emitTokensOnly",
-  "presets",
-  "plugins",
-  "hooks"
-];
-var format = [
-  "syntax",
-  "hash",
-  "prefix",
-  "separator",
-  "strictTokens",
-  "strictPropertyValues",
-  "shorthands"
-];
-var tokens = [
-  "utilities",
-  "conditions",
-  "theme.tokens",
-  "theme.semanticTokens",
-  "theme.breakpoints",
-  "theme.containerNames",
-  "theme.containerSizes"
-];
-var jsx = ["jsxFramework", "jsxFactory", "jsxStyleProps", "syntax"];
-var common = tokens.concat(jsx, format);
-var artifactConfigDeps = {
-  helpers: ["syntax", "jsxFramework"],
-  keyframes: ["theme.keyframes", "layers"],
-  "design-tokens": ["layers", "!utilities.*.className"].concat(tokens),
-  types: ["!utilities.*.className"].concat(common),
-  "css-fn": common,
-  cva: ["syntax"],
-  sva: ["syntax"],
-  cx: [],
-  "create-recipe": ["separator", "prefix", "hash"],
-  "recipes-index": ["theme.recipes", "theme.slotRecipes"],
-  recipes: ["theme.recipes", "theme.slotRecipes"],
-  "patterns-index": ["syntax", "patterns"],
-  patterns: ["syntax", "patterns"],
-  "jsx-is-valid-prop": common,
-  "jsx-factory": jsx,
-  "jsx-helpers": jsx,
-  "jsx-patterns": jsx.concat("patterns"),
-  "jsx-patterns-index": jsx.concat("patterns"),
-  "jsx-create-style-context": jsx,
-  "css-index": ["syntax"],
-  "package.json": ["forceConsistentTypeExtension", "outExtension"],
-  "types-styles": ["shorthands"],
-  "types-conditions": ["conditions"],
-  "types-jsx": jsx,
-  "types-entry": [],
-  "types-gen": [],
-  "types-gen-system": [],
-  themes: ["themes"].concat(tokens),
-  // staticCss depends on tokens (for wildcards) and recipes (for recipe rules)
-  "static-css": ["staticCss", "patterns", "theme.recipes", "theme.slotRecipes"].concat(tokens),
-  // Split CSS artifacts (generated via cssgen --splitting)
-  styles: [],
-  "styles.css": []
-};
-var artifactMatchers = Object.entries(artifactConfigDeps).map(([key, paths]) => {
-  if (!paths.length) return () => void 0;
-  return createMatcher(key, paths.concat(all));
-});
-
-// src/diff-config.ts
-var runIfFn = (fn) => typeof fn === "function" ? fn() : fn;
-var hasRecipeStateTransition = (prevConfig, nextConfig) => {
-  const prevRecipes = prevConfig.theme?.recipes ?? {};
-  const prevSlotRecipes = prevConfig.theme?.slotRecipes ?? {};
-  const prevHasRecipes = Object.keys(prevRecipes).length > 0 || Object.keys(prevSlotRecipes).length > 0;
-  const nextRecipes = nextConfig.theme?.recipes ?? {};
-  const nextSlotRecipes = nextConfig.theme?.slotRecipes ?? {};
-  const nextHasRecipes = Object.keys(nextRecipes).length > 0 || Object.keys(nextSlotRecipes).length > 0;
-  return prevHasRecipes !== nextHasRecipes;
-};
-function diffConfigs(config, prevConfig) {
-  const affected = {
-    artifacts: /* @__PURE__ */ new Set(),
-    hasConfigChanged: false,
-    diffs: []
-  };
-  if (!prevConfig) {
-    affected.hasConfigChanged = true;
-    return affected;
-  }
-  const configDiff = (0, import_microdiff.default)(prevConfig, runIfFn(config));
-  if (!configDiff.length) {
-    return affected;
-  }
-  affected.hasConfigChanged = true;
-  affected.diffs = configDiff;
-  configDiff.forEach((change) => {
-    const changePath = change.path.join(".");
-    artifactMatchers.forEach((matcher) => {
-      const id = matcher(changePath);
-      if (!id) return;
-      if (id === "recipes") {
-        const name = (0, import_shared3.dashCase)(change.path.slice(1, 3).join("."));
-        affected.artifacts.add(name);
-      }
-      if (id === "patterns") {
-        const name = (0, import_shared3.dashCase)(change.path.slice(0, 2).join("."));
-        affected.artifacts.add(name);
-      }
-      affected.artifacts.add(id);
-    });
-  });
-  if (affected.artifacts.has("recipes") || affected.artifacts.has("recipes-index")) {
-    const nextConfig = runIfFn(config);
-    if (hasRecipeStateTransition(prevConfig, nextConfig)) {
-      affected.artifacts.add("create-recipe");
-    }
-  }
-  return affected;
-}
-
-// src/get-mod-deps.ts
-var import_fs = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
-var import_typescript = __toESM(require("typescript"));
-
-// src/resolve-ts-path-pattern.ts
-var import_path2 = require("path");
-var resolveTsPathPattern = (pathMappings, moduleSpecifier) => {
-  for (const mapping of pathMappings) {
-    const match = moduleSpecifier.match(mapping.pattern);
-    if (!match) {
-      continue;
-    }
-    for (const pathTemplate of mapping.paths) {
-      let starCount = 0;
-      const mappedId = pathTemplate.replace(/\*/g, () => {
-        const matchIndex = Math.min(++starCount, match.length - 1);
-        return match[matchIndex];
-      });
-      return mappedId.split(import_path2.sep).join(import_path2.posix.sep);
+  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`."
+      );
     }
   }
-};
-
-// src/ts-config-paths.ts
-var import_path3 = require("path");
-function convertTsPathsToRegexes(paths, baseUrl) {
-  const sortedPatterns = Object.keys(paths).sort((a, b) => getPrefixLength(b) - getPrefixLength(a));
-  const resolved = [];
-  for (let pattern of sortedPatterns) {
-    const relativePaths = paths[pattern];
-    pattern = escapeStringRegexp(pattern).replace(/\*/g, "(.+)");
-    resolved.push({
-      pattern: new RegExp("^" + pattern + "$"),
-      paths: relativePaths.map((relativePath) => (0, import_path3.resolve)(baseUrl, relativePath))
-    });
+  if (plugins.length > 0) {
+    config.plugins = plugins;
   }
-  return resolved;
+  return config;
 }
-function getPrefixLength(pattern) {
-  const prefixLength = pattern.indexOf("*");
-  return pattern.substr(0, prefixLength).length;
+async function collectConfigs(config, source, ctx, active) {
+  if (active.has(config)) {
+    throw new PandaError("CONFIG_ERROR", "\u{1F4A5} Circular preset dependency detected.");
+  }
+  active.add(config);
+  const hookCount = ctx.presetResolvedHooks.length;
+  ctx.presetResolvedHooks.push(...collectPresetResolvedHooks(config));
+  for (const preset of config.presets ?? []) {
+    const resolved = await resolvePreset(preset, ctx.cwd);
+    resolved.dependencies.forEach((dependency) => ctx.dependencies.add(dependency));
+    const config2 = await runPresetResolvedHooks(resolved.config, resolved.source, ctx.presetResolvedHooks);
+    await collectConfigs(config2, resolved.source, ctx, active);
+  }
+  ctx.configs.push(config);
+  ctx.sourcedConfigs?.push({ config, source });
+  ctx.presetResolvedHooks.length = hookCount;
+  active.delete(config);
 }
-function escapeStringRegexp(string) {
-  return string.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/-/g, "\\x2d");
+function collectPresetResolvedHooks(config) {
+  return collectPluginHookHandlers(config, "preset:resolved");
 }
-
-// src/get-mod-deps.ts
-var jsExtensions = [".js", ".cjs", ".mjs"];
-var jsResolutionOrder = ["", ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts", ".jsx", ".tsx"];
-var tsResolutionOrder = ["", ".ts", ".cts", ".mts", ".tsx", ".js", ".cjs", ".mjs", ".jsx"];
-function resolveWithExtension(file, extensions) {
-  for (const ext of extensions) {
-    const full = `${file}${ext}`;
-    if (import_fs.default.existsSync(full) && import_fs.default.statSync(full).isFile()) {
-      return full;
-    }
-  }
-  for (const ext of extensions) {
-    const full = `${file}/index${ext}`;
-    if (import_fs.default.existsSync(full)) {
-      return full;
+async function runPresetResolvedHooks(preset, source, hooks) {
+  let current = preset;
+  const name = source.name ?? source.specifier ?? presetName(current) ?? "unknown-preset";
+  for (const entry of hooks) {
+    const hook = normalizeHook(entry.value, "preset:resolved");
+    const next = await hook.handler({ preset: current, name });
+    if (next !== void 0) {
+      current = ensureConfigObject(next, name);
     }
   }
-  return null;
+  return current;
 }
-var importRegex = /import[\s\S]*?['"](.{3,}?)['"]/gi;
-var importFromRegex = /import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
-var requireRegex = /require\(['"`](.+)['"`]\)/gi;
-var exportRegex = /export[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
-function getDeps(opts, fromAlias) {
-  const { filename, seen } = opts;
-  const { moduleResolution: _, ...compilerOptions } = opts.compilerOptions ?? {};
-  const absoluteFile = resolveWithExtension(
-    import_path4.default.resolve(opts.cwd, filename),
-    jsExtensions.includes(opts.ext) ? jsResolutionOrder : tsResolutionOrder
-  );
-  if (absoluteFile === null) return;
-  if (fromAlias) {
-    opts.foundModuleAliases.set(fromAlias, absoluteFile);
-  }
-  if (seen.size > 1 && seen.has(absoluteFile)) return;
-  seen.add(absoluteFile);
-  const contents = import_fs.default.readFileSync(absoluteFile, "utf-8");
-  const fileDeps = [
-    ...contents.matchAll(importRegex),
-    ...contents.matchAll(importFromRegex),
-    ...contents.matchAll(requireRegex),
-    ...contents.matchAll(exportRegex)
-  ];
-  if (!fileDeps.length) return;
-  const nextOpts = {
-    // Resolve new base for new imports/requires
-    cwd: import_path4.default.dirname(absoluteFile),
-    ext: import_path4.default.extname(absoluteFile),
-    seen,
-    baseUrl: opts.baseUrl,
-    pathMappings: opts.pathMappings,
-    foundModuleAliases: opts.foundModuleAliases
-  };
-  fileDeps.forEach((match) => {
-    const mod = match[1];
-    if (mod[0] === ".") {
-      getDeps(Object.assign({}, nextOpts, { filename: mod }));
-      return;
-    }
+async function resolvePreset(preset, cwd) {
+  if (typeof preset === "string") {
     try {
-      const found = import_typescript.default.resolveModuleName(mod, absoluteFile, compilerOptions, import_typescript.default.sys).resolvedModule;
-      if (found && found.extension.endsWith("ts")) {
-        getDeps(Object.assign({}, nextOpts, { filename: found.resolvedFileName }));
-        return;
-      }
-      if (!opts.pathMappings) return;
-      const filename2 = resolveTsPathPattern(opts.pathMappings, mod);
-      if (!filename2) return;
-      getDeps(Object.assign({}, nextOpts, { filename: filename2 }), mod);
-    } catch {
+      const result = await bundleConfig(preset, cwd);
+      return {
+        config: ensureConfigObject(result.config, preset),
+        dependencies: result.dependencies,
+        source: presetSource(result.config, preset, result.dependencies[0])
+      };
+    } catch (error) {
+      if (error instanceof PandaError) throw error;
+      throw new PandaError(
+        "CONFIG_ERROR",
+        `\u{1F4A5} Failed to resolve preset ${JSON.stringify(preset)}: ${errorMessage(error)}`
+      );
     }
-  });
+  }
+  try {
+    const config = await preset;
+    return {
+      config: ensureConfigObject(config, config?.name ?? "unknown-preset"),
+      dependencies: [],
+      source: presetSource(config)
+    };
+  } catch (error) {
+    if (error instanceof PandaError) throw error;
+    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to resolve preset "unknown-preset": ${errorMessage(error)}`);
+  }
 }
-function getConfigDependencies(filePath, tsOptions = { pathMappings: [] }, compilerOptions) {
-  if (filePath === null) return { deps: /* @__PURE__ */ new Set(), aliases: /* @__PURE__ */ new Map() };
-  const foundModuleAliases = /* @__PURE__ */ new Map();
-  const deps = /* @__PURE__ */ new Set();
-  deps.add(filePath);
-  getDeps({
-    filename: filePath,
-    ext: import_path4.default.extname(filePath),
-    cwd: import_path4.default.dirname(filePath),
-    seen: deps,
-    baseUrl: tsOptions.baseUrl,
-    pathMappings: tsOptions.pathMappings ?? [],
-    foundModuleAliases,
-    compilerOptions
-  });
-  return { deps, aliases: foundModuleAliases };
+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.`);
 }
-
-// src/get-resolved-config.ts
-var import_shared6 = require("@pandacss/shared");
-
-// src/merge-config.ts
-var import_shared5 = require("@pandacss/shared");
-
-// src/merge-hooks.ts
-var import_logger2 = require("@pandacss/logger");
-var mergeHooks = (plugins) => {
-  const hooksFns = {};
-  plugins.forEach(({ name, hooks }) => {
-    Object.entries(hooks ?? {}).forEach(([key, value]) => {
-      if (!hooksFns[key]) {
-        hooksFns[key] = [];
-      }
-      hooksFns[key].push([name, value]);
-    });
-  });
-  const mergedHooks = Object.fromEntries(
-    Object.entries(hooksFns).map(([key, entries]) => {
-      const fns = entries.map(([name, fn]) => tryCatch(name, fn));
-      const reducer = key in reducers ? reducers[key] : void 0;
-      if (reducer) {
-        return [key, reducer(fns)];
-      }
-      return [key, syncHooks.includes(key) ? callAll(...fns) : callAllAsync(...fns)];
-    })
-  );
-  return mergedHooks;
-};
-var createReducer = (reducer) => reducer;
-var reducers = {
-  "config:resolved": createReducer((fns) => async (_args) => {
-    const args = Object.assign({}, _args);
-    const original = _args.config;
-    let config = args.config;
-    for (const hookFn of fns) {
-      const result = await hookFn(Object.assign(args, { config, original }));
-      if (result !== void 0) {
-        config = result;
-      }
-    }
-    return config;
-  }),
-  "parser:before": createReducer((fns) => (_args) => {
-    const args = Object.assign({}, _args);
-    const original = _args.content;
-    let content = args.content;
-    for (const hookFn of fns) {
-      const result = hookFn(Object.assign(args, { content, original }));
-      if (result !== void 0) {
-        content = result;
-      }
-    }
-    return content;
-  }),
-  "parser:preprocess": createReducer((fns) => (_args) => {
-    const args = Object.assign({}, _args);
-    const original = _args.data;
-    let data = args.data;
-    for (const hookFn of fns) {
-      const result = hookFn(Object.assign(args, { data, original }));
-      if (result !== void 0) {
-        data = result;
-      }
-    }
-    return data;
-  }),
-  "cssgen:done": createReducer((fns) => (_args) => {
-    const args = Object.assign({}, _args);
-    const original = _args.content;
-    let content = args.content;
-    for (const hookFn of fns) {
-      const result = hookFn(Object.assign(args, { content, original }));
-      if (result !== void 0) {
-        content = result;
-      }
-    }
-    return content;
-  }),
-  "codegen:prepare": createReducer((fns) => async (_args) => {
-    const args = Object.assign({}, _args);
-    const original = _args.artifacts;
-    let artifacts = args.artifacts;
-    for (const hookFn of fns) {
-      const result = await hookFn(Object.assign(args, { artifacts, original }));
-      if (result) {
-        artifacts = result;
-      }
-    }
-    return artifacts;
-  }),
-  "preset:resolved": createReducer((fns) => async (_args) => {
-    const args = Object.assign({}, _args);
-    const original = _args.preset;
-    let preset = args.preset;
-    for (const hookFn of fns) {
-      const result = await hookFn(Object.assign(args, { preset, original }));
-      if (result !== void 0) {
-        preset = result;
-      }
-    }
-    return preset;
-  }),
-  "css:optimize": createReducer((fns) => (_args) => {
-    const args = Object.assign({}, _args);
-    const original = _args.css;
-    let css = args.css;
-    for (const hookFn of fns) {
-      const result = hookFn(Object.assign(args, { css, original }));
-      if (result !== void 0) {
-        css = result;
-      }
-    }
-    return css;
-  })
-};
-var syncHooks = [
-  "context:created",
-  "parser:before",
-  "parser:preprocess",
-  "parser:after",
-  "cssgen:done",
-  "css:optimize"
-];
-var callAllAsync = (...fns) => async (...a) => {
-  for (const fn of fns) {
-    await fn?.(...a);
-  }
-};
-var callAll = (...fns) => (...a) => {
-  fns.forEach((fn) => fn?.(...a));
-};
-var tryCatch = (name, fn) => {
-  return (...args) => {
-    try {
-      return fn(...args);
-    } catch (e) {
-      import_logger2.logger.caughtError("hooks", `Error in plugin "${name}"`, e);
-    }
-  };
-};
-
-// src/validation/utils.ts
-var import_shared4 = require("@pandacss/shared");
-var REFERENCE_REGEX = /({([^}]*)})/g;
-var curlyBracketRegex = /[{}]/g;
-var isValidToken = (token) => (0, import_shared4.isObject)(token) && Object.hasOwnProperty.call(token, "value");
-var isTokenReference = (value) => typeof value === "string" && REFERENCE_REGEX.test(value);
-var formatPath = (path2) => path2;
-var SEP = ".";
-function getReferences(value) {
-  if (typeof value !== "string") return [];
-  const matches = value.match(REFERENCE_REGEX);
-  if (!matches) return [];
-  return matches.map((match) => match.replace(curlyBracketRegex, "")).map((value2) => {
-    return value2.trim().split("/")[0];
-  });
+function presetName(config) {
+  return isPlainObject(config) && typeof config.name === "string" ? config.name : void 0;
 }
-var serializeTokenValue = (value) => {
-  if ((0, import_shared4.isString)(value)) {
-    return value;
-  }
-  if ((0, import_shared4.isObject)(value)) {
-    return Object.values(value).map((v) => serializeTokenValue(v)).join(" ");
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => serializeTokenValue(v)).join(" ");
-  }
-  return value.toString();
-};
-
-// src/merge-config.ts
-function getExtends(items) {
-  return items.reduce((merged, { extend }) => {
-    if (!extend) return merged;
-    return (0, import_shared5.mergeWith)(merged, extend, (originalValue, newValue) => {
-      if (newValue === void 0) {
-        return originalValue ?? [];
-      }
-      if (originalValue === void 0) {
-        return [newValue];
-      }
-      if (Array.isArray(originalValue)) {
-        return [newValue, ...originalValue];
-      }
-      return [newValue, originalValue];
-    });
-  }, {});
+function presetSource(config, specifier, file) {
+  const source = { kind: "preset" };
+  const name = presetName(config);
+  if (name) source.name = name;
+  if (specifier) source.specifier = specifier;
+  if (file) source.file = file;
+  return source;
 }
-function mergeRecords(records) {
-  return {
-    ...records.reduce((acc, record) => (0, import_shared5.assign)(acc, record), {}),
-    extend: getExtends(records)
-  };
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-function mergeExtensions(records) {
-  const { extend = [], ...restProps } = mergeRecords(records);
-  return (0, import_shared5.mergeWith)(restProps, extend, (obj, extensions) => {
-    return (0, import_shared5.mergeAndConcat)({}, obj, ...extensions);
+
+// src/load.ts
+async function loadConfig(options) {
+  const { cwd, file } = options;
+  const path = findConfig({ cwd, file });
+  const { config, dependencies } = await bundleConfig(path, cwd);
+  if (!isPlainObject(config)) {
+    throw new PandaError("CONFIG_ERROR", "\u{1F4A5} Config must export or return an object.");
+  }
+  const authored = await resolveAuthoredPresets(config, cwd, {
+    configFile: path,
+    trackSources: options.trackSources,
+    preserveRuntimeHooks: true
   });
-}
-var isEmptyObject = (obj) => typeof obj === "object" && Object.keys(obj).length === 0;
-var compact = (obj) => {
-  return Object.keys(obj).reduce((acc, key) => {
-    if (obj[key] !== void 0 && !isEmptyObject(obj[key])) {
-      acc[key] = obj[key];
-    }
-    return acc;
-  }, {});
-};
-var tokenKeys = ["description", "extensions", "type", "value", "deprecated"];
-function mergeConfigs(configs) {
-  const userConfig = configs.at(-1);
-  const pluginHooks = userConfig.plugins ?? [];
-  if (userConfig.hooks) {
-    pluginHooks.push({ name: import_shared5.PANDA_CONFIG_NAME, hooks: userConfig.hooks });
-  }
-  const reversed = Array.from(configs).reverse();
-  const mergedResult = (0, import_shared5.assign)(
-    {
-      conditions: mergeExtensions(reversed.map((config) => config.conditions ?? {})),
-      theme: mergeExtensions(reversed.map((config) => config.theme ?? {})),
-      patterns: mergeExtensions(reversed.map((config) => config.patterns ?? {})),
-      utilities: mergeExtensions(reversed.map((config) => config.utilities ?? {})),
-      globalCss: mergeExtensions(reversed.map((config) => config.globalCss ?? {})),
-      globalVars: mergeExtensions(reversed.map((config) => config.globalVars ?? {})),
-      globalFontface: mergeExtensions(reversed.map((config) => config.globalFontface ?? {})),
-      globalPositionTry: mergeExtensions(reversed.map((config) => config.globalPositionTry ?? {})),
-      staticCss: mergeExtensions(reversed.map((config) => config.staticCss ?? {})),
-      themes: mergeExtensions(reversed.map((config) => config.themes ?? {})),
-      hooks: mergeHooks(pluginHooks)
-    },
-    ...reversed
+  const authoredDependencies = Array.from(
+    /* @__PURE__ */ new Set([...dependencies, ...authored.dependencies, ...authored.config.dependencies ?? []])
   );
-  const withoutEmpty = compact(mergedResult);
-  if (withoutEmpty.theme?.tokens) {
-    (0, import_shared5.walkObject)(withoutEmpty.theme.tokens, (args) => args, {
-      stop(token) {
-        if (!isValidToken(token)) return false;
-        const keys = Object.keys(token);
-        const nestedKeys = keys.filter((k) => !tokenKeys.includes(k));
-        const nested = nestedKeys.length > 0;
-        if (nested) {
-          token.DEFAULT ||= {};
-          tokenKeys.forEach((key) => {
-            if (token[key] == null) return;
-            token.DEFAULT[key] ||= token[key];
-            delete token[key];
-          });
-        }
-        return true;
-      }
-    });
-  }
-  return withoutEmpty;
+  const userConfig = await runConfigResolvedHooks(authored.config, path, authoredDependencies);
+  const resolved = applyConfigDefaults(userConfig, cwd);
+  const dependencyList = Array.from(
+    /* @__PURE__ */ new Set([...dependencies, ...authored.dependencies, ...resolved.dependencies ?? []])
+  );
+  const snapshot = createConfigSnapshot(resolved);
+  return {
+    path,
+    config: snapshot.config,
+    callbacks: snapshot.callbacks,
+    ...snapshot.hooks ? { hooks: snapshot.hooks } : {},
+    hostHooks: {
+      "codegen:prepare": collectPluginHookHandlers(resolved, "codegen:prepare"),
+      "codegen:done": collectPluginHookHandlers(resolved, "codegen:done")
+    },
+    dependencies: dependencyList,
+    ...authored.metadata ? { metadata: authored.metadata } : {}
+  };
 }
-
-// src/get-resolved-config.ts
-var hookUtils = {
-  omit: import_shared6.omit,
-  pick: import_shared6.pick,
-  traverse: import_shared6.traverse
-};
-async function getResolvedConfig(config, cwd, hooks) {
-  const stack = [config];
-  const configs = [];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    const subPresets = current.presets ?? [];
-    for (const subPreset of subPresets) {
-      let presetConfig;
-      let presetName;
-      if (typeof subPreset === "string") {
-        const presetModule = await bundle(subPreset, cwd);
-        presetConfig = presetModule.config;
-        presetName = subPreset;
-      } else {
-        presetConfig = await subPreset;
-        presetName = presetConfig.name || "unknown-preset";
-      }
-      if (hooks?.["preset:resolved"]) {
-        const resolvedPreset = await hooks["preset:resolved"]({
-          preset: presetConfig,
-          name: presetName,
-          utils: hookUtils
-        });
-        if (resolvedPreset !== void 0) {
-          presetConfig = resolvedPreset;
-        }
+async function runConfigResolvedHooks(config, path, dependencies) {
+  let current = config;
+  for (const entry of collectPluginHookHandlers(current, "config:resolved")) {
+    const hook = normalizeHook(entry.value, "config:resolved");
+    const next = await hook.handler({ config: current, path, dependencies, utils: configResolvedUtils });
+    if (next !== void 0) {
+      if (!isPlainObject(next)) {
+        throw new PandaError("CONFIG_ERROR", "\u{1F4A5} config:resolved hook must return a config object or undefined.");
       }
-      stack.push(presetConfig);
+      current = next;
     }
-    configs.unshift(current);
   }
-  const merged = mergeConfigs(configs);
-  merged.presets = configs.slice(0, -1);
-  return merged;
+  return current;
 }
-
-// src/resolve-config.ts
-var import_logger4 = require("@pandacss/logger");
-var import_shared11 = require("@pandacss/shared");
-
-// src/bundled-preset.ts
-var import_preset_base = require("@pandacss/preset-base");
-var import_preset_panda = require("@pandacss/preset-panda");
-var bundledPresets = {
-  "@pandacss/preset-base": import_preset_base.preset,
-  "@pandacss/preset-panda": import_preset_panda.preset,
-  "@pandacss/dev/presets": import_preset_panda.preset
-};
-var bundledPresetsNames = Object.keys(bundledPresets);
-var isBundledPreset = (preset) => bundledPresetsNames.includes(preset);
-var getBundledPreset = (preset) => {
-  return typeof preset === "string" && isBundledPreset(preset) ? bundledPresets[preset] : void 0;
-};
-
-// src/validate-config.ts
-var import_logger3 = require("@pandacss/logger");
-var import_shared10 = require("@pandacss/shared");
-
-// src/validation/validate-artifact.ts
-var validateArtifactNames = (names, addError) => {
-  names.recipes.forEach((recipeName) => {
-    if (names.slotRecipes.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`theme.slotRecipes\`: ${recipeName}`);
-    }
-    if (names.patterns.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`patterns\`: \`${recipeName}\``);
-    }
-  });
-  names.slotRecipes.forEach((recipeName) => {
-    if (names.patterns.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`patterns\`: ${recipeName}`);
+var configResolvedUtils = {
+  omit(obj, paths) {
+    const clone = cloneValue(obj);
+    for (const path of paths) {
+      deleteAtPath(clone, path);
+    }
+    return clone;
+  },
+  pick(obj, paths) {
+    const result = {};
+    for (const path of paths) {
+      const value = getAtPath(obj, path);
+      if (value !== void 0) {
+        setAtPath(result, path, value);
+      }
     }
-  });
-};
-
-// src/validation/validate-breakpoints.ts
-var import_shared7 = require("@pandacss/shared");
-var validateBreakpoints = (breakpoints, addError) => {
-  if (!breakpoints) return;
-  const units = /* @__PURE__ */ new Set();
-  const values = Object.values(breakpoints);
-  for (const value of values) {
-    const unit = (0, import_shared7.getUnit)(value) ?? "px";
-    units.add(unit);
-  }
-  if (units.size > 1) {
-    addError("breakpoints", `All breakpoints must use the same unit: \`${values.join(", ")}\``);
+    return result;
+  },
+  traverse(obj, callback, options = {}) {
+    traverseValue(obj, callback, options);
   }
 };
-
-// src/validation/validate-condition.ts
-var import_shared8 = require("@pandacss/shared");
-var validateObjectCondition = (obj, addError) => {
-  let hasSlot = false;
-  for (const [key, value] of Object.entries(obj)) {
-    if (!key.startsWith("@") && !key.includes("&")) {
-      addError("conditions", `Selectors should contain the \`&\` character: \`${key}\``);
-    }
-    if (value === "@slot") {
-      hasSlot = true;
-      continue;
-    }
-    if (typeof value === "string") {
-      addError(
-        "conditions",
-        `Object condition leaves must be the literal string \`'@slot'\`, got \`${JSON.stringify(value)}\` at \`${key}\``
-      );
-      continue;
-    }
-    if (typeof value === "object" && value !== null) {
-      const nested = validateObjectCondition(value, addError);
-      if (nested.hasSlot) hasSlot = true;
-    }
+function cloneValue(value) {
+  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
+  if (!isPlainObject(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, cloneValue(child)])
+  );
+}
+function pathParts(path) {
+  return path.split(".").filter(Boolean);
+}
+function getAtPath(value, path) {
+  let current = value;
+  for (const part of pathParts(path)) {
+    if (!isPlainObject(current) && !Array.isArray(current)) return void 0;
+    current = current[part];
   }
-  return { hasSlot };
-};
-var validateConditions = (conditions, addError) => {
-  if (!conditions) return;
-  Object.values(conditions).forEach((condition) => {
-    if ((0, import_shared8.isString)(condition)) {
-      if (!condition.startsWith("@") && !condition.includes("&")) {
-        addError("conditions", `Selectors should contain the \`&\` character: \`${condition}\``);
-      }
-      return;
-    }
-    if (Array.isArray(condition)) {
-      condition.forEach((c) => {
-        if (!c.startsWith("@") && !c.includes("&")) {
-          addError("conditions", `Selectors should contain the \`&\` character: \`${c}\``);
-        }
-      });
+  return current;
+}
+function setAtPath(target, path, value) {
+  const parts = pathParts(path);
+  let current = target;
+  parts.forEach((part, index) => {
+    if (index === parts.length - 1) {
+      current[part] = cloneValue(value);
       return;
     }
-    const { hasSlot } = validateObjectCondition(condition, addError);
-    if (!hasSlot) {
-      addError("conditions", `Object conditions must contain at least one \`'@slot'\` marker`);
+    const next = current[part];
+    if (!isPlainObject(next)) {
+      current[part] = {};
     }
+    current = current[part];
   });
-};
-
-// src/validation/validate-patterns.ts
-var validatePatterns = (patterns, names) => {
-  if (!patterns) return;
-  Object.keys(patterns).forEach((patternName) => {
-    names.patterns.add(patternName);
-  });
-};
-
-// src/validation/validate-recipes.ts
-var validateRecipes = (options) => {
-  const {
-    config: { theme },
-    artifacts
-  } = options;
-  if (!theme) return;
-  if (theme.recipes) {
-    Object.keys(theme.recipes).forEach((recipeName) => {
-      artifacts.recipes.add(recipeName);
-    });
-  }
-  if (theme.slotRecipes) {
-    Object.keys(theme.slotRecipes).forEach((recipeName) => {
-      artifacts.slotRecipes.add(recipeName);
-    });
+}
+function deleteAtPath(target, path) {
+  const parts = pathParts(path);
+  const key = parts.pop();
+  if (!key) return;
+  let current = target;
+  for (const part of parts) {
+    if (!isPlainObject(current) && !Array.isArray(current)) return;
+    current = current[part];
+  }
+  if (isPlainObject(current) || Array.isArray(current)) {
+    delete current[key];
   }
-  return artifacts;
-};
-
-// src/validation/validate-tokens.ts
-var import_shared9 = require("@pandacss/shared");
-
-// src/validation/validate-token-references.ts
-var validateTokenReferences = (props) => {
-  const { valueAtPath, refsByPath, addError, typeByPath } = props;
-  refsByPath.forEach((refs, path2) => {
-    if (refs.has(path2)) {
-      addError("tokens", `Self token reference: \`${path2}\``);
-    }
-    const stack = [path2];
-    while (stack.length > 0) {
-      let currentPath = stack.pop();
-      if (currentPath.includes("/")) {
-        const [tokenPath] = currentPath.split("/");
-        currentPath = tokenPath;
-      }
-      const value = valueAtPath.get(currentPath);
-      if (!value) {
-        const configKey = typeByPath.get(path2);
-        addError("tokens", `Missing token: \`${currentPath}\` used in \`theme.${configKey}.${path2}\``);
-      }
-      if (isTokenReference(value) && !refsByPath.has(value)) {
-        addError("tokens", `Unknown token reference: \`${currentPath}\` used in \`${value}\``);
-      }
-      const deps = refsByPath.get(currentPath);
-      if (!deps) continue;
-      for (const transitiveDep of deps) {
-        if (path2 === transitiveDep) {
-          addError(
-            "tokens",
-            `Circular token reference: \`${transitiveDep}\` -> \`${currentPath}\` -> ... -> \`${path2}\``
-          );
-          break;
-        }
-        stack.push(transitiveDep);
-      }
-    }
+}
+function traverseValue(value, callback, options, parent, key, path = "", depth = 0) {
+  if (parent && key !== void 0) {
+    callback({ value, path, depth, parent, key });
+  }
+  if (options.maxDepth !== void 0 && depth >= options.maxDepth) return;
+  if (!isPlainObject(value) && !Array.isArray(value)) return;
+  const separator = options.separator ?? ".";
+  const container = value;
+  Object.entries(value).forEach(([childKey, child]) => {
+    traverseValue(child, callback, options, container, childKey, joinPath(path, childKey, separator), depth + 1);
   });
-};
+}
+function joinPath(parent, key, separator) {
+  return parent ? `${parent}${separator}${key}` : key;
+}
 
-// src/validation/validate-tokens.ts
-var validateTokens = (options) => {
-  const {
-    config: { theme },
-    tokens: tokens2,
-    addError
-  } = options;
-  if (!theme) return;
-  const { tokenNames, semanticTokenNames, valueAtPath, refsByPath, typeByPath } = tokens2;
-  if (theme.tokens) {
-    const tokenPaths = /* @__PURE__ */ new Set();
-    (0, import_shared9.walkObject)(
-      theme.tokens,
-      (value, paths) => {
-        const path2 = paths.join(SEP);
-        tokenNames.add(path2);
-        tokenPaths.add(path2);
-        valueAtPath.set(path2, value);
-        if (path2.includes("DEFAULT")) {
-          valueAtPath.set(path2.replace(SEP + "DEFAULT", ""), value);
-        }
-      },
-      {
-        stop: isValidToken
-      }
-    );
-    tokenPaths.forEach((path2) => {
-      const itemValue = valueAtPath.get(path2);
-      const formattedPath = formatPath(path2);
-      typeByPath.set(formattedPath, "tokens");
-      if (!isValidToken(itemValue)) {
-        addError("tokens", `Token must contain 'value': \`theme.tokens.${formattedPath}\``);
-        return;
-      }
-      if (path2.includes(" ")) {
-        addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
-        return;
-      }
-      const valueStr = serializeTokenValue(itemValue.value || itemValue);
-      if (isTokenReference(valueStr)) {
-        refsByPath.set(formattedPath, /* @__PURE__ */ new Set([]));
-      }
-      const references = refsByPath.get(formattedPath);
-      if (!references) return;
-      getReferences(valueStr).forEach((reference) => {
-        references.add(reference);
-      });
-    });
-  }
-  if (theme.semanticTokens) {
-    const tokenPaths = /* @__PURE__ */ new Set();
-    (0, import_shared9.walkObject)(
-      theme.semanticTokens,
-      (value, paths) => {
-        const path2 = paths.join(SEP);
-        semanticTokenNames.add(path2);
-        valueAtPath.set(path2, value);
-        tokenPaths.add(path2);
-        if (path2.includes("DEFAULT")) {
-          valueAtPath.set(path2.replace(SEP + "DEFAULT", ""), value);
-        }
-        if (!isValidToken(value)) return;
-        (0, import_shared9.walkObject)(value, (itemValue, paths2) => {
-          const valuePath = paths2.join(SEP);
-          const formattedPath = formatPath(path2);
-          typeByPath.set(formattedPath, "semanticTokens");
-          const fullPath = formattedPath + "." + paths2.join(SEP);
-          if (valuePath.includes("value" + SEP + "value")) {
-            addError("tokens", `You used \`value\` twice resulting in an invalid token \`theme.tokens.${fullPath}\``);
-          }
-          const valueStr = serializeTokenValue(itemValue.value || itemValue);
-          if (isTokenReference(valueStr)) {
-            if (!refsByPath.has(formattedPath)) {
-              refsByPath.set(formattedPath, /* @__PURE__ */ new Set());
-            }
-            const references = refsByPath.get(formattedPath);
-            if (!references) return;
-            getReferences(valueStr).forEach((reference) => {
-              references.add(reference);
-            });
-          }
-        });
-      },
-      {
-        stop: isValidToken
-      }
-    );
-    tokenPaths.forEach((path2) => {
-      const formattedPath = formatPath(path2);
-      const value = valueAtPath.get(path2);
-      if (path2.includes(" ")) {
-        addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
-        return;
-      }
-      if (!(0, import_shared9.isObject)(value) && !path2.includes("value")) {
-        addError("tokens", `Token must contain 'value': \`theme.semanticTokens.${formattedPath}\``);
-      }
-    });
+// src/diff.ts
+import diff from "microdiff";
+var ALL_DEPENDENCIES = [
+  "outExtension",
+  "forceImportExtension",
+  "conditions",
+  "hash",
+  "jsxFactory",
+  "jsxFramework",
+  "jsxStyleProps",
+  "patterns",
+  "prefix",
+  "recipes",
+  "separator",
+  "syntax",
+  "themes",
+  "tokens",
+  "utilities"
+];
+function diffConfig(prev, next) {
+  if (!prev) {
+    return { hasChanged: true, dependencies: [...ALL_DEPENDENCIES], recipes: [], patterns: [], changes: [] };
+  }
+  const prevInput = diffInput(prev);
+  const nextInput = diffInput(next);
+  const changes = diff(prevInput, nextInput);
+  if (changes.length === 0) {
+    return { hasChanged: false, dependencies: [], recipes: [], patterns: [], changes };
+  }
+  const dependencies = /* @__PURE__ */ new Set();
+  const recipes = /* @__PURE__ */ new Set();
+  const patterns = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    const classified = classify(change.path.map(String));
+    classified.deps.forEach((dep) => dependencies.add(dep));
+    if (classified.recipe) recipes.add(classified.recipe);
+    if (classified.pattern) patterns.add(classified.pattern);
   }
-  validateTokenReferences({ valueAtPath, refsByPath, addError, typeByPath });
-};
-
-// src/validate-config.ts
-var validateConfig = (config) => {
-  if (config.validation === "none") return;
-  const warnings = /* @__PURE__ */ new Set();
-  const addError = (scope, message) => {
-    warnings.add(`[${scope}] ` + message);
-  };
-  validateBreakpoints(config.theme?.breakpoints, addError);
-  validateConditions(config.conditions, addError);
-  const artifacts = {
-    recipes: /* @__PURE__ */ new Set(),
-    slotRecipes: /* @__PURE__ */ new Set(),
-    patterns: /* @__PURE__ */ new Set()
-  };
-  const tokens2 = {
-    tokenNames: /* @__PURE__ */ new Set(),
-    semanticTokenNames: /* @__PURE__ */ new Set(),
-    valueAtPath: /* @__PURE__ */ new Map(),
-    refsByPath: /* @__PURE__ */ new Map(),
-    typeByPath: /* @__PURE__ */ new Map()
+  return {
+    hasChanged: true,
+    dependencies: [...dependencies],
+    recipes: [...recipes],
+    patterns: [...patterns],
+    changes
   };
-  if (config.theme) {
-    validateTokens({ config, tokens: tokens2, addError });
-    validateRecipes({ config, tokens: tokens2, artifacts, addError });
-  }
-  validatePatterns(config.patterns, artifacts);
-  validateArtifactNames(artifacts, addError);
-  if (warnings.size) {
-    const errors = `\u26A0\uFE0F Invalid config:
-${Array.from(warnings).map((err) => "- " + err).join("\n")}
-`;
-    if (config.validation === "error") {
-      throw new import_shared10.PandaError("CONFIG_ERROR", errors);
-    }
-    import_logger3.logger.warn("config", errors);
-    return warnings;
-  }
-};
-
-// src/resolve-config.ts
-var hookUtils2 = {
-  omit: import_shared11.omit,
-  pick: import_shared11.pick,
-  traverse: import_shared11.traverse
-};
-async function resolveConfig(result, cwd) {
-  const presets = /* @__PURE__ */ new Set();
-  if (!result.config.eject) {
-    presets.add(import_preset_base.preset);
-  }
-  if (result.config.presets) {
-    result.config.presets.forEach((preset) => {
-      presets.add(getBundledPreset(preset) ?? preset);
-    });
-  } else if (!result.config.eject) {
-    presets.add(import_preset_panda.preset);
-  }
-  result.config.presets = Array.from(presets);
-  const userConfig = result.config;
-  const pluginHooks = userConfig.plugins ?? [];
-  if (userConfig.hooks) {
-    pluginHooks.push({ name: import_shared11.PANDA_CONFIG_NAME, hooks: userConfig.hooks });
-  }
-  const earlyHooks = mergeHooks(pluginHooks);
-  const mergedConfig = await getResolvedConfig(result.config, cwd, earlyHooks);
-  const hooks = mergedConfig.hooks ?? {};
-  if (mergedConfig.logLevel) {
-    import_logger4.logger.level = mergedConfig.logLevel;
+}
+function classify(path) {
+  const [head, second, third] = path;
+  if (head === "config") return classify(path.slice(1));
+  if (head === "hooks") return { deps: [] };
+  if (head === "theme") {
+    if (second === "recipes" || second === "slotRecipes") {
+      return { deps: ["recipes"], recipe: third };
+    }
+    if (second === "containers" || second === "containerNames") {
+      return { deps: ["tokens", "conditions"] };
+    }
+    return { deps: ["tokens"] };
+  }
+  switch (head) {
+    case "conditions":
+      return { deps: ["conditions"] };
+    case "utilities":
+      return { deps: ["utilities"] };
+    case "patterns":
+      return { deps: ["patterns"], pattern: second };
+    case "themes":
+      return { deps: ["themes"] };
+    case "syntax":
+      return { deps: ["syntax"] };
+    case "hash":
+      return { deps: ["hash"] };
+    case "prefix":
+      return { deps: ["prefix"] };
+    case "separator":
+      return { deps: ["separator"] };
+    case "jsxFramework":
+      return { deps: ["jsxFramework"] };
+    case "jsxFactory":
+      return { deps: ["jsxFactory"] };
+    case "jsxStyleProps":
+      return { deps: ["jsxStyleProps"] };
+    case "outExtension":
+      return { deps: ["outExtension"] };
+    case "forceImportExtension":
+      return { deps: ["forceImportExtension"] };
+    case "shorthands":
+      return { deps: ["utilities"] };
+    case "strictTokens":
+    case "strictPropertyValues":
+      return { deps: ["outExtension"] };
+    default:
+      return { deps: [] };
   }
-  validateConfig(mergedConfig);
-  const loadConfigResult = {
-    ...result,
-    config: mergedConfig
-  };
-  if (hooks["config:resolved"]) {
-    const result2 = await hooks["config:resolved"]({
-      config: loadConfigResult.config,
-      path: loadConfigResult.path,
-      dependencies: loadConfigResult.dependencies,
-      utils: hookUtils2
-    });
-    if (result2) {
-      loadConfigResult.config = result2;
-    }
+}
+function diffInput(input) {
+  if (isConfigSnapshot(input)) {
+    return { config: input.config, ...input.hooks ? { hooks: input.hooks } : {} };
   }
-  const serialized = (0, import_shared11.stringifyJson)(Object.assign({}, loadConfigResult.config, { name: import_shared11.PANDA_CONFIG_NAME, presets: [] }));
-  const deserialize = () => (0, import_shared11.parseJson)(serialized);
-  return { ...loadConfigResult, serialized, deserialize, hooks };
+  return { config: input };
 }
-
-// src/load-config.ts
-async function loadConfig(options) {
-  const result = await bundleConfig(options);
-  return resolveConfig(result, options.cwd);
+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);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   bundleConfig,
-  convertTsPathsToRegexes,
-  diffConfigs,
+  createConfigSnapshot,
+  diffConfig,
   findConfig,
-  getConfigDependencies,
-  getResolvedConfig,
   loadConfig,
-  mergeConfigs,
-  mergeHooks,
-  resolveConfig
-});
+  mergeConfigs
+};