@pandacss/config 2.0.0-beta.5 → 2.0.0-beta.7

package/dist/{chunk-LUSBBUHX.js → chunk-YKIDLZNO.js}

@@ -2,12 +2,26 @@
 var PandaError = class extends Error {
   code;
   hint;
+  diagnostics;
   constructor(code, message, opts) {
     super(message, { cause: opts?.cause });
     this.code = `ERR_PANDA_${code}`;
     this.hint = opts?.hint;
+    this.diagnostics = opts?.diagnostics;
   }
 };
+function createConfigError(message, diagnostics) {
+  return new PandaError("CONFIG_ERROR", `\u{1F4A5} ${message}`, { diagnostics });
+}
+function createConfigDiagnostic(code, message, help) {
+  return {
+    code,
+    message,
+    severity: "error",
+    category: "config",
+    ...help ? { help } : {}
+  };
+}
 
 // src/sources.ts
 var sectionKeySet = /* @__PURE__ */ new Set([
@@ -125,6 +139,13 @@ function clone(value) {
   }
   return value;
 }
+function ensureConfigObject(config, name) {
+  if (isPlainObject2(config)) return config;
+  throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Preset ${JSON.stringify(name)} must resolve to an object.`);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/merge.ts
 var sectionKeys = [
@@ -244,7 +265,11 @@ function isValidToken(token) {
 
 export {
   PandaError,
+  createConfigError,
+  createConfigDiagnostic,
   isPlainObject2 as isPlainObject,
+  ensureConfigObject,
+  errorMessage,
   mergeConfigsWithSources,
   mergeConfigs
 };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { SerializedConfig, ProjectCallbacks, ProjectHooks, ConfigSnapshot, DiffConfigResult } from '@pandacss/compiler-shared';
+import { DesignSystemManifest, SerializedConfig, ProjectCallbacks, ProjectHooks, ConfigSnapshot, DiffConfigResult, DesignSystemManifestImportMap } from '@pandacss/compiler-shared';
 export { DiffConfigResult } from '@pandacss/compiler-shared';
-import { HookRegistry, Config } from '@pandacss/types';
-import { C as ConfigSources } from './merge-Bt4BM1CH.js';
-export { a as ConfigSourceEntry, m as mergeConfigs } from './merge-Bt4BM1CH.js';
+import { HookRegistry, Config, UserConfig } from '@pandacss/types';
+import { C as ConfigSources } from './merge-DiBpncUC.js';
+export { a as ConfigSourceEntry, m as mergeConfigs } from './merge-DiBpncUC.js';
 export { ConfigSnapshot, createConfigSnapshot } from './serialize.js';
 
 interface PluginHookEntry<Name extends keyof HookRegistry> {
@@ -15,6 +15,17 @@ type HostHooks = {
     'codegen:done'?: Array<PluginHookEntry<'codegen:done'>>;
 };
 
+interface ResolvedDesignSystem {
+    name: string;
+    specifier: string;
+    manifest: DesignSystemManifest;
+    manifestPath: string;
+    buildInfoPath: string;
+    files: string[];
+    tokenPaths: string[];
+    importMap?: DesignSystemManifest['importMap'];
+}
+
 interface LoadConfigOptions {
     cwd: string;
     /** Explicit config file path (relative to `cwd`); otherwise discovered upward. */
@@ -37,6 +48,8 @@ interface LoadConfigResult {
     dependencies: string[];
     metadata?: {
         sources?: ConfigSources;
+        designSystem?: ResolvedDesignSystem[];
+        userTokenPaths?: string[];
     };
 }
 
@@ -81,4 +94,47 @@ interface BundleConfigResult<T = Config> {
  */
 declare function bundleConfig<T extends Config = Config>(filepath: string, cwd: string): Promise<BundleConfigResult<T>>;
 
-export { type BundleConfigResult, ConfigSources, type HostHooks, type LoadConfigOptions, type LoadConfigResult, bundleConfig, diffConfig, findConfig, loadConfig };
+interface SmartIncludeResult {
+    include: string[];
+    excludes: string[];
+    changed: boolean;
+}
+declare function resolveSmartInclude(include: string[], cwd: string, deps: Set<string>): SmartIncludeResult;
+declare function mergeExcludes(existing: string[] | undefined, additions: string[]): string[];
+
+declare function readPandaVersion(): string | undefined;
+
+interface CompilePresetResult {
+    code: string;
+    dependencies: string[];
+}
+interface CompilePresetOptions {
+    configPath: string;
+    cwd: string;
+}
+declare function compilePreset(options: CompilePresetOptions): Promise<CompilePresetResult>;
+
+interface PackageIdentity {
+    name: string;
+    version?: string;
+    pandaPeer?: string;
+    packagePath: string;
+}
+declare function readPackageIdentity(cwd: string): PackageIdentity;
+declare function defaultImportMap(name: string): DesignSystemManifestImportMap;
+interface SyncExportsResult {
+    changed: boolean;
+    json: string;
+}
+interface SyncExportsOptions {
+    packageJson: string;
+    entries: Record<string, string>;
+}
+declare function syncExports(options: SyncExportsOptions): SyncExportsResult;
+declare function toPosixPath(path: string): string;
+declare function toPosixRelative(from: string, to: string): string;
+declare function toRelativeKey(key: string, cwd: string): string;
+
+declare function collectTokenPaths(config: Pick<UserConfig, 'theme'> | undefined): string[];
+
+export { type BundleConfigResult, type CompilePresetOptions, type CompilePresetResult, ConfigSources, type HostHooks, type LoadConfigOptions, type LoadConfigResult, type PackageIdentity, type SyncExportsOptions, type SyncExportsResult, bundleConfig, collectTokenPaths, compilePreset, defaultImportMap, diffConfig, findConfig, loadConfig, mergeExcludes, readPackageIdentity, readPandaVersion, resolveSmartInclude, syncExports, toPosixPath, toPosixRelative, toRelativeKey };

package/dist/index.js

@@ -1,9 +1,13 @@
 import {
   PandaError,
+  createConfigDiagnostic,
+  createConfigError,
+  ensureConfigObject,
+  errorMessage,
   isPlainObject,
   mergeConfigs,
   mergeConfigsWithSources
-} from "./chunk-LUSBBUHX.js";
+} from "./chunk-YKIDLZNO.js";
 import {
   collectPluginHookHandlers,
   createConfigSnapshot,
@@ -307,9 +311,317 @@ 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/preset.ts
+import { normalize as normalize2, relative as relative3 } from "path";
+
+// src/design-system.ts
+import {
+  outdirBasename
+} from "@pandacss/compiler-shared";
+import { readFileSync, statSync } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+
+// 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 = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+  return code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
+}
+
+// src/design-system.ts
+async function loadDesignSystemChain(spec, cwd, deps) {
+  const levels = [];
+  const seenAt = /* @__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);
+    levels.push(level);
+    if (parent === void 0) break;
+    declaredBy = level.info.name;
+    fromDir = dirname3(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 resolveManifestPath(spec, fromDir) {
+  try {
+    return tryResolveFrom(`${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)]);
+  }
+}
+async function loadManifestLevel(spec, manifestPath, deps) {
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch (error) {
+    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to read ${JSON.stringify(manifestPath)}: ${errorMessage(error)}`);
+  }
+  if (typeof manifest.preset !== "string") {
+    throw invalidManifestError(spec, "preset");
+  }
+  if (typeof manifest.buildInfo !== "string") {
+    throw invalidManifestError(spec, "buildInfo");
+  }
+  const presetPath = resolve3(dirname3(manifestPath), manifest.preset);
+  const buildInfoPath = resolve3(dirname3(manifestPath), manifest.buildInfo);
+  deps.add(presetPath);
+  deps.add(buildInfoPath);
+  let preset;
+  try {
+    const mod = await import(presetImportUrl(presetPath));
+    preset = ensureConfigObject(mod.default ?? mod, manifest.name ?? spec);
+  } catch (error) {
+    if (error instanceof PandaError) throw error;
+    throw new PandaError(
+      "CONFIG_ERROR",
+      `\u{1F4A5} Failed to load preset for designSystem ${JSON.stringify(spec)}: ${errorMessage(error)}`
+    );
+  }
+  const parent = typeof manifest.designSystem === "string" && manifest.designSystem.length > 0 ? manifest.designSystem : void 0;
+  return {
+    parent,
+    level: {
+      preset,
+      info: {
+        name: manifest.name ?? spec,
+        specifier: spec,
+        manifest,
+        manifestPath,
+        buildInfoPath,
+        files: manifest.files ?? [],
+        tokenPaths: [],
+        ...manifest.importMap ? { importMap: manifest.importMap } : {}
+      }
+    }
+  };
+}
+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`
+  };
+}
+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, field) {
+  const message = `${JSON.stringify(spec)} manifest is missing a "${field}" entry.`;
+  return createConfigError(message, [
+    createConfigDiagnostic("design_system_manifest_invalid", message, [
+      `Rebuild ${JSON.stringify(spec)} with \`panda lib\`.`
+    ])
+  ]);
+}
+
+// src/smart-include.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join2, relative as relative2, resolve as resolve4, sep } from "path";
+var SMART_INCLUDE_EXTENSIONS = ["js", "mjs", "cjs", "jsx", "ts", "cts", "mts", "tsx", "vue", "svelte", "astro"];
+var MANIFEST = "panda.lib.json";
+var PACKAGE_SPECIFIER = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
+var PATH_SEPARATOR = /[\\/]/;
+function resolveSmartInclude(include, cwd, deps) {
+  const offenders = [];
+  const next = [];
+  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}`, cwd) !== void 0) {
+      offenders.push(entry);
+      continue;
+    }
+    const packageDir = resolvePackageDir(entry, cwd);
+    if (packageDir === void 0) {
+      next.push(entry);
+      continue;
+    }
+    if (existsSync2(join2(packageDir, MANIFEST))) {
+      offenders.push(entry);
+      continue;
+    }
+    deps.add(join2(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 existsSync2(isAbsolute3(entry) ? entry : resolve4(cwd, entry));
+}
+function resolvePackageDir(spec, cwd) {
+  const fromPackageJson = tryResolve(`${spec}/package.json`, cwd);
+  if (fromPackageJson !== void 0) return dirname4(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 (isAbsolute3(relativePath)) return false;
+  return !relativePath.startsWith(`..${sep}`);
+}
+function nearestPackageDir(from) {
+  let dir = dirname4(from);
+  while (true) {
+    if (existsSync2(join2(dir, "package.json"))) return dir;
+    const parent = dirname4(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function globBase(packageDir, cwd) {
+  const rel = relative2(cwd, packageDir);
+  const base = isInsideCwd(rel) ? rel : packageDir;
+  return toPosix(base);
+}
+function toPosix(path) {
+  return path.split(PATH_SEPARATOR).join("/");
+}
+function inIncludeError(specs) {
+  const list = specs.map((spec) => JSON.stringify(spec)).join(", ");
+  const plural = specs.length > 1;
+  const message = `Design system${plural ? "s" : ""} in \`include\`: ${list}. ${plural ? "They each ship" : "It ships"} a ${MANIFEST}, so ${plural ? "they belong" : "it belongs"} in \`designSystem\`, not \`include\`. \`include\` is for files, not design systems.`;
+  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/token-paths.ts
+function collectTokenPaths(config) {
+  if (!isPlainObject(config?.theme)) return [];
+  const paths = /* @__PURE__ */ new Set();
+  collect(config.theme.tokens, [], paths);
+  collect(config.theme.semanticTokens, [], paths);
+  return [...paths].sort();
+}
+function collect(node, trail, out) {
+  if (!isPlainObject(node)) return;
+  if ("value" in node) {
+    if (trail.length > 0) out.add(trail.join("."));
+    return;
+  }
+  for (const [key, child] of Object.entries(node)) {
+    collect(child, [...trail, key], out);
+  }
+}
 
 // src/preset.ts
-import { normalize as normalize2, relative as relative2 } from "path";
 async function resolveAuthoredPresets(config, cwd, options = {}) {
   const ctx = {
     cwd,
@@ -319,44 +631,68 @@ async function resolveAuthoredPresets(config, cwd, options = {}) {
     ...options.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(relative3(cwd, options.configFile));
+  const designSystem = config.designSystem;
+  let dsChain = [];
+  if (typeof designSystem === "string" && designSystem.length > 0) {
+    dsChain = await loadDesignSystemChain(designSystem, cwd, ctx.dependencies);
+    for (const level of dsChain) {
+      const block = await collectConfigBlock(
+        level.preset,
+        { kind: "preset", specifier: level.info.name },
+        cwd,
+        ctx.dependencies,
+        options.trackSources
+      );
+      level.info.tokenPaths = collectTokenPaths(block.resolved);
+      appendConfigBlock(ctx, block);
+    }
+  }
+  const rootBlock = await collectConfigBlock(config, rootSource, cwd, ctx.dependencies, options.trackSources);
+  appendConfigBlock(ctx, rootBlock);
+  const dsInfos = dsChain.map((level) => level.info);
+  const finalize = (resolved) => {
+    const withImportMap = dsInfos.length > 0 ? withDesignSystemImportMap(resolved, dsInfos) : resolved;
+    return expandSmartInclude(withImportMap, cwd, ctx.dependencies);
+  };
+  const dsMetadata = dsInfos.length > 0 ? { designSystem: dsInfos, userTokenPaths: collectTokenPaths(rootBlock.resolved) } : void 0;
   if (ctx.sourcedConfigs) {
     const merged = mergeConfigsWithSources(ctx.sourcedConfigs);
     if (options.preserveRuntimeHooks) attachRuntimeHooks(merged.config, ctx.configs);
     return {
-      config: merged.config,
+      config: finalize(merged.config),
       dependencies: Array.from(ctx.dependencies),
-      metadata: { sources: merged.sources }
+      metadata: { sources: merged.sources, ...dsMetadata }
     };
   }
   return {
-    config: options.preserveRuntimeHooks ? attachRuntimeHooks(mergeConfigs(ctx.configs), ctx.configs) : mergeConfigs(ctx.configs),
-    dependencies: Array.from(ctx.dependencies)
+    config: finalize(
+      options.preserveRuntimeHooks ? attachRuntimeHooks(mergeConfigs(ctx.configs), ctx.configs) : mergeConfigs(ctx.configs)
+    ),
+    dependencies: Array.from(ctx.dependencies),
+    ...dsMetadata ? { metadata: dsMetadata } : {}
   };
 }
-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 collectConfigBlock(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 } : {},
+    resolved: mergeConfigs(ctx.configs)
+  };
+}
+function appendConfigBlock(ctx, block) {
+  ctx.configs.push(...block.configs);
+  if (ctx.sourcedConfigs && block.sourcedConfigs) {
+    ctx.sourcedConfigs.push(...block.sourcedConfigs);
   }
-  return config;
 }
 async function collectConfigs(config, source, ctx, active) {
   if (active.has(config)) {
@@ -402,10 +738,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 +750,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 +768,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) {
@@ -593,11 +923,176 @@ 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 readFileSync2 } from "fs";
+import { dirname as dirname5, join as join3 } from "path";
+import { fileURLToPath } from "url";
+function readPandaVersion() {
+  try {
+    const pkgPath = join3(dirname5(fileURLToPath(import.meta.url)), "../package.json");
+    return JSON.parse(readFileSync2(pkgPath, "utf8")).version;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib-preset.ts
+import { builtinModules as builtinModules2 } from "module";
+import { rolldown as rolldown2 } from "rolldown";
+var APP_FIELDS = ["designSystem", "include", "exclude", "outdir", "cwd", "watch", "clean", "gitignore", "importMap"];
+var VIRTUAL_ENTRY = "\0panda-lib-preset-entry";
+var nodeBuiltins2 = /* @__PURE__ */ new Set([...builtinModules2, ...builtinModules2.map((mod) => `node:${mod}`)]);
+async function compilePreset(options) {
+  const { configPath, cwd } = options;
+  const build = await rolldown2({
+    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: ${errorMessage2(error)}`);
+  }
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/lib-manifest.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname6, isAbsolute as isAbsolute4, join as join4, relative as relative4 } from "path";
+function readPackageIdentity(cwd) {
+  const packagePath = nearestPackageJson(cwd);
+  if (packagePath === void 0) {
+    throw new Error(`Could not find a package.json from ${JSON.stringify(cwd)} to build the design system manifest.`);
+  }
+  const pkg = JSON.parse(readFileSync3(packagePath, "utf8"));
+  const name = pkg.name;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`${JSON.stringify(packagePath)} has no "name"; a design system must be a named package.`);
+  }
+  const peer = pkg.peerDependencies?.["@pandacss/dev"];
+  return {
+    name,
+    version: typeof pkg.version === "string" ? pkg.version : void 0,
+    pandaPeer: typeof peer === "string" ? peer : void 0,
+    packagePath
+  };
+}
+function defaultImportMap(name) {
+  return {
+    css: `${name}/css`,
+    recipes: `${name}/recipes`,
+    patterns: `${name}/patterns`,
+    jsx: `${name}/jsx`,
+    tokens: `${name}/tokens`
+  };
+}
+function syncExports(options) {
+  const { packageJson, entries } = options;
+  const pkg = JSON.parse(packageJson);
+  const existing = normalizeExports(pkg.exports);
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(entries)) merged[key] = value;
+  const changed = JSON.stringify(pkg.exports) !== JSON.stringify(merged);
+  const out = { ...pkg, exports: merged };
+  return { changed, json: `${JSON.stringify(out, null, 2)}
+` };
+}
+function toPosixPath(path) {
+  return path.split("\\").join("/");
+}
+function toPosixRelative(from, to) {
+  const rel = toPosixPath(relative4(from, to));
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function toRelativeKey(key, cwd) {
+  return toPosixPath(isAbsolute4(key) ? relative4(cwd, key) : key);
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeExports(exports) {
+  if (exports === void 0) return {};
+  if (typeof exports === "string") return { ".": exports };
+  if (!isPlainObject2(exports)) return {};
+  if (isSubpathExportMap(exports)) return exports;
+  return { ".": exports };
+}
+function isSubpathExportMap(exports) {
+  return Object.keys(exports).some((key) => key === "." || key.startsWith("./"));
+}
+function nearestPackageJson(start) {
+  let current = start;
+  while (true) {
+    const candidate = join4(current, "package.json");
+    if (existsSync3(candidate)) return candidate;
+    const parent = dirname6(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
 export {
   bundleConfig,
+  collectTokenPaths,
+  compilePreset,
   createConfigSnapshot,
+  defaultImportMap,
   diffConfig,
   findConfig,
   loadConfig,
-  mergeConfigs
+  mergeConfigs,
+  mergeExcludes,
+  readPackageIdentity,
+  readPandaVersion,
+  resolveSmartInclude,
+  syncExports,
+  toPosixPath,
+  toPosixRelative,
+  toRelativeKey
 };

package/dist/merge.d.ts

@@ -1,2 +1,2 @@
-export { S as SourcedConfig, m as mergeConfigs, b as mergeConfigsWithSources } from './merge-Bt4BM1CH.js';
+export { S as SourcedConfig, m as mergeConfigs, b as mergeConfigsWithSources } from './merge-DiBpncUC.js';
 import '@pandacss/types';

package/dist/merge.js

@@ -1,7 +1,7 @@
 import {
   mergeConfigs,
   mergeConfigsWithSources
-} from "./chunk-LUSBBUHX.js";
+} from "./chunk-YKIDLZNO.js";
 export {
   mergeConfigs,
   mergeConfigsWithSources

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pandacss/config",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0-beta.7",
   "description": "Self-contained loader that bundles and serializes a Panda config for the Rust compiler",
   "type": "module",
   "main": "./dist/index.js",
@@ -45,8 +45,8 @@
     "magic-string": "^0.30.21",
     "microdiff": "1.5.0",
     "rolldown": "1.0.0-rc.17",
-    "@pandacss/compiler-shared": "2.0.0-beta.5",
-    "@pandacss/types": "2.0.0-beta.5"
+    "@pandacss/compiler-shared": "2.0.0-beta.7",
+    "@pandacss/types": "2.0.0-beta.7"
   },
   "engines": {
     "node": ">=22"

package/dist/{merge-Bt4BM1CH.d.ts → merge-DiBpncUC.d.ts}

@@ -1,5 +1,11 @@
 import { Config } from '@pandacss/types';
 
+type Dict = Record<string, any>;
+type Extendable<T> = T & {
+    extend?: T;
+};
+type ExtendableConfig = Extendable<Config>;
+
 interface ConfigSourceEntry {
     kind: 'config' | 'preset';
     name?: string;
@@ -19,12 +25,6 @@ declare class SourceTracker {
     delete(path: string[]): void;
 }
 
-type Dict = Record<string, any>;
-type Extendable<T> = T & {
-    extend?: T;
-};
-type ExtendableConfig = Extendable<Config>;
-
 interface SourcedConfig {
     config: ExtendableConfig;
     source: ConfigSourceEntry;