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

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

@@ -1,27 +1,9 @@
-// src/error.ts
-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 } : {}
-  };
-}
+import {
+  PandaError,
+  clone,
+  isPlainObject,
+  omitKeys
+} from "./chunk-R4R5RHIS.js";
 
 // src/sources.ts
 var sectionKeySet = /* @__PURE__ */ new Set([
@@ -36,7 +18,6 @@ var sectionKeySet = /* @__PURE__ */ new Set([
   "staticCss",
   "themes"
 ]);
-var omitKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 var tokenKeys = /* @__PURE__ */ new Set(["description", "extensions", "type", "value", "deprecated"]);
 var directFieldSections = /* @__PURE__ */ new Set(["patterns", "utilities"]);
 var themeEntryKeys = /* @__PURE__ */ new Set([
@@ -115,37 +96,6 @@ function shouldTrackThemePath(rest, value, current) {
   if (key === "containerNames" || key === "colorPalette") return rest.length <= 2;
   return rest.length <= 2;
 }
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-// src/shared.ts
-var omitKeys2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function isPlainObject2(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function clone(value) {
-  if (Array.isArray(value)) return value.map((item) => clone(item));
-  if (isPlainObject2(value)) {
-    const result = {};
-    for (const [key, item] of Object.entries(value)) {
-      if (item !== void 0 && !omitKeys2.has(key)) result[key] = clone(item);
-    }
-    return result;
-  }
-  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 = [
@@ -175,13 +125,13 @@ function mergeConfigs(configs, tracker) {
     const config = tracker ? configs[index].config : configs[index];
     const context = tracker ? { tracker, sourceId: index, path: [] } : void 0;
     for (const [key, value] of Object.entries(config)) {
-      if (value === void 0 || sectionKeySet2.has(key) || runtimeOnlyKeys.has(key) || omitKeys2.has(key)) continue;
+      if (value === void 0 || sectionKeySet2.has(key) || runtimeOnlyKeys.has(key) || omitKeys.has(key)) continue;
       result[key] = clone(value);
       context?.tracker.record([key], context.sourceId, "replace");
     }
     for (const key of sectionKeys) {
       const section = config[key];
-      if (isPlainObject2(section)) mergeSectionInto(key, sections[key], section, context);
+      if (isPlainObject(section)) mergeSectionInto(key, sections[key], section, context);
     }
   }
   for (const key of sectionKeys) {
@@ -193,15 +143,15 @@ function mergeConfigs(configs, tracker) {
 function mergeSectionInto(sectionName, target, section, context) {
   const childContext = context && { ...context, path: [sectionName] };
   for (const [key, value] of Object.entries(section)) {
-    if (key === "extend" || value === void 0 || omitKeys2.has(key)) continue;
+    if (key === "extend" || value === void 0 || omitKeys.has(key)) continue;
     mergeValue(target, key, value, "replace", childContext);
   }
   if (section.extend === void 0) return;
-  if (!isPlainObject2(section.extend)) {
+  if (!isPlainObject(section.extend)) {
     throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Config section \`${sectionName}.extend\` must be an object.`);
   }
   for (const [key, value] of Object.entries(section.extend)) {
-    if (value === void 0 || omitKeys2.has(key)) continue;
+    if (value === void 0 || omitKeys.has(key)) continue;
     mergeValue(target, key, value, "concat", childContext);
   }
 }
@@ -213,11 +163,11 @@ function mergeValue(target, key, value, arrayMode, context) {
     recordSource(context, path, value, current, arrayMode === "concat" ? "append" : "replace");
     return;
   }
-  if (isPlainObject2(current) && isPlainObject2(value)) {
+  if (isPlainObject(current) && isPlainObject(value)) {
     recordSource(context, path, value, current, "append");
     const childContext = context && path ? { ...context, path } : void 0;
     for (const [childKey, childValue] of Object.entries(value)) {
-      if (childValue !== void 0 && !omitKeys2.has(childKey))
+      if (childValue !== void 0 && !omitKeys.has(childKey))
         mergeValue(current, childKey, childValue, arrayMode, childContext);
     }
     return;
@@ -231,7 +181,7 @@ function normalizeNestedTokens(tokens, tracker) {
   while (stack.length > 0) {
     const current = stack.pop();
     for (const [key, value] of Object.entries(current.value)) {
-      if (!isPlainObject2(value)) continue;
+      if (!isPlainObject(value)) continue;
       if (isValidToken(value)) {
         normalizeToken(value, tracker, current.path.concat(key));
       } else {
@@ -264,12 +214,6 @@ function isValidToken(token) {
 }
 
 export {
-  PandaError,
-  createConfigError,
-  createConfigDiagnostic,
-  isPlainObject2 as isPlainObject,
-  ensureConfigObject,
-  errorMessage,
   mergeConfigsWithSources,
   mergeConfigs
 };

package/dist/chunk-R4R5RHIS.js

@@ -0,0 +1,73 @@
+// src/error.ts
+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/shared.ts
+var omitKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function clone(value) {
+  if (Array.isArray(value)) {
+    const len = value.length;
+    const out2 = new Array(len);
+    for (let i = 0; i < len; i++) out2[i] = clone(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];
+    if (omitKeys.has(key)) continue;
+    const item = source[key];
+    if (item !== void 0) out[key] = clone(item);
+  }
+  return out;
+}
+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 errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, item]) => item !== void 0));
+}
+
+export {
+  PandaError,
+  createConfigError,
+  createConfigDiagnostic,
+  omitKeys,
+  isPlainObject,
+  clone,
+  ensureConfigObject,
+  errorMessage,
+  compact
+};

package/dist/{chunk-VYX3JX5J.js → chunk-U6KCSKCU.js}

@@ -1,3 +1,7 @@
+import {
+  compact
+} from "./chunk-R4R5RHIS.js";
+
 // src/serialize.ts
 import {
   normalizeImportMap
@@ -5,7 +9,6 @@ import {
 import { stringify } from "javascript-stringify";
 
 // src/hooks.ts
-var compact = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, item]) => item !== void 0));
 function serializeHooks(config, callbacks, sanitize2, hashCallbackSource2) {
   const parserBefore = collectPluginHookHandlers(config, "parser:before").map((entry, index) => {
     const hook = normalizeHook(entry.value, "parser:before");
@@ -47,7 +50,6 @@ function normalizeHook(value, name) {
 }
 
 // src/serialize.ts
-var compact2 = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, item]) => item !== void 0));
 var runtimeOnlyKeys = /* @__PURE__ */ new Set(["hooks", "plugins", "presets", "name"]);
 function createConfigSnapshot(config) {
   const callbacks = {};
@@ -94,7 +96,7 @@ function attachPatternCodegenSource(serialized, config) {
   if (!patterns || !serializedPatterns) return;
   for (const [name, pattern] of Object.entries(patterns)) {
     if (typeof pattern?.transform !== "function") continue;
-    const source = stringify(compact2({ transform: pattern.transform, defaultValues: pattern.defaultValues })) ?? "";
+    const source = stringify(compact({ transform: pattern.transform, defaultValues: pattern.defaultValues })) ?? "";
     if (serializedPatterns[name]) serializedPatterns[name].codegenSource = source;
   }
 }

package/dist/index.d.ts

@@ -13,6 +13,7 @@ interface PluginHookEntry<Name extends keyof HookRegistry> {
 type HostHooks = {
     'codegen:prepare'?: Array<PluginHookEntry<'codegen:prepare'>>;
     'codegen:done'?: Array<PluginHookEntry<'codegen:done'>>;
+    'cssgen:done'?: Array<PluginHookEntry<'cssgen:done'>>;
 };
 
 interface ResolvedDesignSystem {
@@ -24,6 +25,9 @@ interface ResolvedDesignSystem {
     files: string[];
     tokenPaths: string[];
     importMap?: DesignSystemManifest['importMap'];
+    /** Class-name options (`hash`/`prefix`/`separator`) the consumer overrode away
+     * from this design system's, which would break its prebuilt class names. */
+    optionMismatch?: string[];
 }
 
 interface LoadConfigOptions {
@@ -94,14 +98,6 @@ interface BundleConfigResult<T = Config> {
  */
 declare function bundleConfig<T extends Config = Config>(filepath: string, cwd: string): Promise<BundleConfigResult<T>>;
 
-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 {
@@ -119,22 +115,59 @@ interface PackageIdentity {
     version?: string;
     pandaPeer?: string;
     packagePath: string;
+    /** package.json `"files"` when it's a string array; used for lib fallback publish checks. */
+    publishFiles?: string[];
 }
+declare function resolvePublishedPandaRange(range: string | undefined, currentVersion: string | undefined): string;
 declare function readPackageIdentity(cwd: string): PackageIdentity;
 declare function defaultImportMap(name: string): DesignSystemManifestImportMap;
 interface SyncExportsResult {
     changed: boolean;
     json: string;
+    /** Existing subpaths whose value differed from the one Panda wrote (overwritten). */
+    conflicts: string[];
 }
 interface SyncExportsOptions {
     packageJson: string;
     entries: Record<string, string>;
 }
 declare function syncExports(options: SyncExportsOptions): SyncExportsResult;
+
+interface FilterPublishableLibFilesOptions {
+    /** Fallback paths relative to the lib outdir (same form as manifest `files`). */
+    files: string[];
+    packageRoot: string;
+    outRoot: string;
+    /** package.json `"files"`; omit when the whole package is packed. */
+    publishFiles?: string[];
+}
+interface FilterPublishableLibFilesResult {
+    files: string[];
+    unpublished: string[];
+}
+/**
+ * Drop inferred lib fallback paths that would not ship in the npm tarball when
+ * package.json `"files"` is set. Explicit `--files` should skip this filter.
+ *
+ * Runs once at `panda lib` time (not on consume/cssgen). Patterns are compiled
+ * once per call; the common `"files": ["dist"]` case is prefix-only.
+ */
+declare function filterPublishableLibFiles(options: FilterPublishableLibFilesOptions): FilterPublishableLibFilesResult;
+/** Read package.json `"files"` when it is a non-empty string array. */
+declare function readPublishFilesField(value: unknown): string[] | undefined;
+
+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 collectTokenPaths(config: Pick<UserConfig, 'theme'> | undefined): string[];
+
 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 };
+export { type BundleConfigResult, type CompilePresetOptions, type CompilePresetResult, ConfigSources, type FilterPublishableLibFilesOptions, type FilterPublishableLibFilesResult, type HostHooks, type LoadConfigOptions, type LoadConfigResult, type PackageIdentity, type SyncExportsOptions, type SyncExportsResult, bundleConfig, collectTokenPaths, compilePreset, defaultImportMap, diffConfig, filterPublishableLibFiles, findConfig, loadConfig, mergeExcludes, readPackageIdentity, readPandaVersion, readPublishFilesField, resolvePublishedPandaRange, resolveSmartInclude, syncExports, toPosixPath, toPosixRelative, toRelativeKey };

package/dist/index.js

@@ -1,18 +1,21 @@
 import {
-  PandaError,
-  createConfigDiagnostic,
-  createConfigError,
-  ensureConfigObject,
-  errorMessage,
-  isPlainObject,
   mergeConfigs,
   mergeConfigsWithSources
-} from "./chunk-YKIDLZNO.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";
@@ -24,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";
@@ -75,6 +77,7 @@ function isNode(value, type) {
 // src/bundle.ts
 var nodeBuiltins = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 async function bundleConfig(filepath, cwd) {
+  const { rolldown } = await import("rolldown");
   const build = await rolldown({
     input: filepath,
     cwd,
@@ -210,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 = {};
@@ -230,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);
 }
@@ -263,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];
@@ -337,10 +323,50 @@ function attachRuntimeHooks(config, configs) {
   return config;
 }
 
+// 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/preset.ts
-import { normalize as normalize2, relative as relative3 } from "path";
+import { normalize as normalize2, relative as relative4 } from "path";
 
-// src/design-system.ts
+// src/design-system/chain.ts
 import {
   outdirBasename
 } from "@pandacss/compiler-shared";
@@ -360,14 +386,29 @@ function tryResolveFrom(request, fromDir) {
   }
 }
 function isResolveMiss(error) {
-  const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+  const code = errorCode(error);
   return code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
 }
+function resolveFrom(request, fromDir) {
+  try {
+    return { kind: "resolved", path: createRequire(resolve2(fromDir, "noop.js")).resolve(request, { paths: [fromDir] }) };
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return { kind: "not-exported" };
+    if (code === "MODULE_NOT_FOUND") return { kind: "not-installed" };
+    throw error;
+  }
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
 
-// src/design-system.ts
+// src/design-system/chain.ts
+var SPECIFIER_PROTOCOL = /^([a-z][a-z0-9+.-]*):/i;
 async function loadDesignSystemChain(spec, cwd, deps) {
   const levels = [];
   const seenAt = /* @__PURE__ */ new Map();
+  const seenNames = /* @__PURE__ */ new Map();
   let currentSpec = spec;
   let fromDir = cwd;
   let declaredBy;
@@ -383,6 +424,11 @@ async function loadDesignSystemChain(spec, cwd, deps) {
     seenAt.set(manifestPath, levels.length);
     deps.add(manifestPath);
     const { level, parent } = await loadManifestLevel(currentSpec, manifestPath, deps);
+    const priorPath = seenNames.get(level.info.name);
+    if (priorPath !== void 0 && priorPath !== manifestPath) {
+      throw duplicateNameError(level.info.name, priorPath, manifestPath);
+    }
+    seenNames.set(level.info.name, manifestPath);
     levels.push(level);
     if (parent === void 0) break;
     declaredBy = level.info.name;
@@ -399,26 +445,38 @@ function withDesignSystemImportMap(config, infos) {
   return { ...config, importMap: [...roots, outdirBasename(config.outdir ?? "styled-system"), ...existing] };
 }
 function resolveManifestPath(spec, fromDir) {
+  const protocol = specifierProtocol(spec);
+  if (protocol) throw unsupportedSpecifierError(spec, protocol);
+  let outcome;
   try {
-    return tryResolveFrom(`${spec}/panda.lib.json`, fromDir);
+    outcome = resolveFrom(`${spec}/panda.lib.json`, fromDir);
   } catch (error) {
     const message = `Failed to resolve designSystem ${JSON.stringify(spec)} from ${JSON.stringify(fromDir)}: ${errorMessage(error)}`;
     throw createConfigError(message, [createConfigDiagnostic("design_system_resolve_failed", message)]);
   }
+  if (outcome.kind === "resolved") return outcome.path;
+  if (outcome.kind === "not-exported") throw manifestNotExportedError(spec);
+  return void 0;
+}
+function manifestNotExportedError(spec) {
+  const message = `designSystem ${JSON.stringify(spec)} is installed but doesn't expose \`./panda.lib.json\`. If it's a Panda design system, rebuild it with \`panda lib\`; otherwise it can't be consumed as a design system.`;
+  return createConfigError(message, [
+    createConfigDiagnostic("design_system_manifest_not_exported", message, [
+      `Rebuild ${JSON.stringify(spec)} with \`panda lib\`, or check its package.json \`exports\` includes \`./panda.lib.json\`.`
+    ])
+  ]);
 }
 async function loadManifestLevel(spec, manifestPath, deps) {
-  let manifest;
+  let parsed;
   try {
-    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    parsed = 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 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 = resolve3(dirname3(manifestPath), manifest.preset);
   const buildInfoPath = resolve3(dirname3(manifestPath), manifest.buildInfo);
   deps.add(presetPath);
@@ -426,13 +484,15 @@ async function loadManifestLevel(spec, manifestPath, deps) {
   let preset;
   try {
     const mod = await import(presetImportUrl(presetPath));
-    preset = ensureConfigObject(mod.default ?? mod, manifest.name ?? spec);
+    preset = ensureConfigObject("default" in mod ? mod.default : mod, manifest.name ?? spec);
   } catch (error) {
-    if (error instanceof PandaError) throw error;
-    throw new PandaError(
-      "CONFIG_ERROR",
-      `\u{1F4A5} Failed to load preset for designSystem ${JSON.stringify(spec)}: ${errorMessage(error)}`
-    );
+    if (error instanceof PandaError && error.diagnostics?.length) throw error;
+    const message = `Failed to load the preset for designSystem ${JSON.stringify(spec)} (${JSON.stringify(manifest.preset)}): ${errorMessage(error)}`;
+    throw createConfigError(message, [
+      createConfigDiagnostic("design_system_preset_load_failed", message, [
+        `Check that ${JSON.stringify(manifest.preset)} is valid and rebuild ${JSON.stringify(spec)} with \`panda lib\`.`
+      ])
+    ]);
   }
   const parent = typeof manifest.designSystem === "string" && manifest.designSystem.length > 0 ? manifest.designSystem : void 0;
   return {
@@ -466,6 +526,53 @@ function designSystemImportMap(map, spec) {
     tokens: map.tokens ?? `${spec}/tokens`
   };
 }
+var IMPORT_MAP_FIELDS = ["css", "recipes", "patterns", "jsx", "tokens"];
+function validateManifest(spec, manifestPath, value) {
+  if (!isPlainObject(value)) {
+    throw invalidManifestError(spec, manifestPath, ["must contain a JSON object"]);
+  }
+  const issues = [];
+  requiredString(value, "name", issues);
+  requiredString(value, "panda", issues);
+  requiredString(value, "preset", issues);
+  requiredString(value, "buildInfo", issues);
+  if (!Number.isInteger(value.schemaVersion) || value.schemaVersion < 1) {
+    issues.push('must contain a positive integer "schemaVersion" entry');
+  }
+  if (value.version !== void 0 && typeof value.version !== "string") {
+    issues.push('has a "version" entry that must be a string');
+  }
+  if (value.designSystem !== void 0 && !isNonEmptyString(value.designSystem)) {
+    issues.push('has a "designSystem" entry that must be a non-empty string');
+  }
+  if (value.files !== void 0 && (!Array.isArray(value.files) || !value.files.every((file) => isNonEmptyString(file)))) {
+    issues.push('has a "files" entry that must be an array of non-empty strings');
+  }
+  if (value.importMap !== void 0) {
+    if (!isPlainObject(value.importMap)) {
+      issues.push('has an "importMap" entry that must be an object');
+    } else {
+      for (const field of IMPORT_MAP_FIELDS) {
+        const entry = value.importMap[field];
+        if (entry !== void 0 && !isNonEmptyString(entry)) {
+          issues.push(`has an "importMap.${field}" entry that must be a non-empty string`);
+        }
+      }
+    }
+  }
+  if (issues.length > 0) {
+    throw invalidManifestError(spec, manifestPath, issues);
+  }
+  return value;
+}
+function requiredString(value, field, issues) {
+  if (!isNonEmptyString(value[field])) {
+    issues.push(`is missing a "${field}" entry or it is empty`);
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
 function notResolvedError(spec) {
   const message = `designSystem ${JSON.stringify(spec)} could not be resolved. Install it, or \u2014 if it isn't a Panda design system \u2014 build it with \`panda lib\`.`;
   return createConfigError(message, [
@@ -486,22 +593,51 @@ function cycleError(cycle) {
   const message = `Design-system cycle: ${cycle.join(" \u2192 ")}. A design system can't depend on itself.`;
   return createConfigError(message, [createConfigDiagnostic("design_system_cycle", message)]);
 }
-function invalidManifestError(spec, field) {
-  const message = `${JSON.stringify(spec)} manifest is missing a "${field}" entry.`;
+function invalidManifestError(spec, manifestPath, issues) {
+  const message = `${JSON.stringify(spec)} manifest ${issues.join("; ")}.`;
   return createConfigError(message, [
-    createConfigDiagnostic("design_system_manifest_invalid", message, [
-      `Rebuild ${JSON.stringify(spec)} with \`panda lib\`.`
-    ])
+    {
+      ...createConfigDiagnostic("design_system_manifest_invalid", message, [
+        `Rebuild ${JSON.stringify(spec)} with \`panda lib\`.`
+      ]),
+      file: manifestPath
+    }
   ]);
 }
+function duplicateNameError(name, firstPath, secondPath) {
+  const message = `Two different packages in the design-system chain are both named ${JSON.stringify(name)} (${JSON.stringify(firstPath)} and ${JSON.stringify(secondPath)}). Their styles would overwrite each other; give each package a unique name.`;
+  return createConfigError(message, [createConfigDiagnostic("design_system_duplicate_name", message)]);
+}
+function specifierProtocol(spec) {
+  const match = spec.match(SPECIFIER_PROTOCOL);
+  return match ? match[1] : void 0;
+}
+function unsupportedSpecifierError(spec, protocol) {
+  const message = `designSystem ${JSON.stringify(spec)} uses the "${protocol}:" protocol, which isn't supported. Use the published package name (e.g. "@acme/design-system") that resolves to its \`panda.lib.json\`.`;
+  return createConfigError(message, [createConfigDiagnostic("design_system_unsupported_specifier", message)]);
+}
 
-// src/smart-include.ts
+// src/design-system/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";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join2, relative as relative3, resolve as resolve4, sep } from "path";
+
+// src/paths.ts
+import { isAbsolute as isAbsolute3, relative as relative2 } from "path";
+function toPosixPath(path) {
+  return path.includes("\\") ? path.split("\\").join("/") : path;
+}
+function toPosixRelative(from, to) {
+  const rel = toPosixPath(relative2(from, to));
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function toRelativeKey(key, cwd) {
+  return toPosixPath(isAbsolute3(key) ? relative2(cwd, key) : key);
+}
+
+// src/design-system/smart-include.ts
 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 = [];
@@ -548,7 +684,7 @@ function mergeExcludes(existing, additions) {
   return [...existing ?? [], ...additions];
 }
 function isLocalPath(entry, cwd) {
-  return existsSync2(isAbsolute3(entry) ? entry : resolve4(cwd, entry));
+  return existsSync2(isAbsolute4(entry) ? entry : resolve4(cwd, entry));
 }
 function resolvePackageDir(spec, cwd) {
   const fromPackageJson = tryResolve(`${spec}/package.json`, cwd);
@@ -566,7 +702,7 @@ function tryResolve(request, cwd) {
 }
 function isInsideCwd(relativePath) {
   if (relativePath === "" || relativePath === "..") return false;
-  if (isAbsolute3(relativePath)) return false;
+  if (isAbsolute4(relativePath)) return false;
   return !relativePath.startsWith(`..${sep}`);
 }
 function nearestPackageDir(from) {
@@ -579,12 +715,9 @@ function nearestPackageDir(from) {
   }
 }
 function globBase(packageDir, cwd) {
-  const rel = relative2(cwd, packageDir);
+  const rel = relative3(cwd, packageDir);
   const base = isInsideCwd(rel) ? rel : packageDir;
-  return toPosix(base);
-}
-function toPosix(path) {
-  return path.split(PATH_SEPARATOR).join("/");
+  return toPosixPath(base);
 }
 function inIncludeError(specs) {
   const list = specs.map((spec) => JSON.stringify(spec)).join(", ");
@@ -602,18 +735,46 @@ function inIncludeError(specs) {
   );
 }
 
-// src/token-paths.ts
+// src/design-system/token-paths.ts
+import { isDeepStrictEqual } from "util";
 function collectTokenPaths(config) {
-  if (!isPlainObject(config?.theme)) return [];
-  const paths = /* @__PURE__ */ new Set();
-  collect(config.theme.tokens, [], paths);
-  collect(config.theme.semanticTokens, [], paths);
+  return [...collectTokenEntries(config).keys()].sort();
+}
+function collectTokenEntries(config) {
+  const entries = /* @__PURE__ */ new Map();
+  if (!isPlainObject(config?.theme)) {
+    return entries;
+  }
+  collect(config.theme.tokens, [], entries);
+  collect(config.theme.semanticTokens, [], entries);
+  return entries;
+}
+function resolveUserTokenPathsAfterHooks(userTokenPaths, beforeHooks, afterHooks) {
+  const paths = new Set(userTokenPaths);
+  const after = collectTokenEntries(afterHooks);
+  for (const path of paths) {
+    if (!after.has(path)) {
+      paths.delete(path);
+    }
+  }
+  for (const [path, values] of after) {
+    if (!beforeHooks.has(path) || !isDeepStrictEqual(beforeHooks.get(path), values)) {
+      paths.add(path);
+    }
+  }
   return [...paths].sort();
 }
 function collect(node, trail, out) {
-  if (!isPlainObject(node)) return;
+  if (!isPlainObject(node)) {
+    return;
+  }
   if ("value" in node) {
-    if (trail.length > 0) out.add(trail.join("."));
+    if (trail.length > 0) {
+      const path = trail.join(".");
+      const entries = out.get(path) ?? [];
+      entries.push(node.value);
+      out.set(path, entries);
+    }
     return;
   }
   for (const [key, child] of Object.entries(node)) {
@@ -622,7 +783,7 @@ function collect(node, trail, out) {
 }
 
 // src/preset.ts
-async function resolveAuthoredPresets(config, cwd, options = {}) {
+async function resolveAuthoredPresetsForLoad(config, cwd, options = {}) {
   const ctx = {
     cwd,
     configs: [],
@@ -631,38 +792,54 @@ async function resolveAuthoredPresets(config, cwd, options = {}) {
     ...options.trackSources ? { sourcedConfigs: [] } : {}
   };
   const rootSource = { kind: "config" };
-  if (options.configFile) rootSource.file = normalize2(relative3(cwd, options.configFile));
+  if (options.configFile) {
+    rootSource.file = normalize2(relative4(cwd, options.configFile));
+  }
   const designSystem = config.designSystem;
   let dsChain = [];
+  const designSystemCompatibility = [];
   if (typeof designSystem === "string" && designSystem.length > 0) {
     dsChain = await loadDesignSystemChain(designSystem, cwd, ctx.dependencies);
     for (const level of dsChain) {
-      const block = await collectConfigBlock(
+      const resolution = await resolveConfigEntry(
         level.preset,
         { kind: "preset", specifier: level.info.name },
         cwd,
         ctx.dependencies,
         options.trackSources
       );
-      level.info.tokenPaths = collectTokenPaths(block.resolved);
-      appendConfigBlock(ctx, block);
+      level.info.tokenPaths = collectTokenPaths(resolution.config);
+      appendConfigResolution(ctx, resolution);
+      designSystemCompatibility.push({
+        designSystem: level.info,
+        classNameOptions: normalizeClassNameOptions(mergeConfigs(ctx.configs))
+      });
+    }
+  }
+  const rootResolution = await resolveConfigEntry(config, rootSource, cwd, ctx.dependencies, options.trackSources);
+  appendConfigResolution(ctx, rootResolution);
+  for (const { designSystem: designSystem2, classNameOptions } of designSystemCompatibility) {
+    const mismatch = diffClassNameOptions(rootResolution.config, classNameOptions, "explicit");
+    if (mismatch.length > 0) {
+      designSystem2.optionMismatch = mismatch;
     }
   }
-  const rootBlock = await collectConfigBlock(config, rootSource, cwd, ctx.dependencies, options.trackSources);
-  appendConfigBlock(ctx, rootBlock);
   const dsInfos = dsChain.map((level) => level.info);
   const finalize = (resolved) => {
     const withImportMap = dsInfos.length > 0 ? withDesignSystemImportMap(resolved, dsInfos) : resolved;
     return expandSmartInclude(withImportMap, cwd, ctx.dependencies);
   };
-  const dsMetadata = dsInfos.length > 0 ? { designSystem: dsInfos, userTokenPaths: collectTokenPaths(rootBlock.resolved) } : void 0;
+  const dsMetadata = dsInfos.length > 0 ? { designSystem: dsInfos, userTokenPaths: collectTokenPaths(rootResolution.config) } : void 0;
   if (ctx.sourcedConfigs) {
     const merged = mergeConfigsWithSources(ctx.sourcedConfigs);
-    if (options.preserveRuntimeHooks) attachRuntimeHooks(merged.config, ctx.configs);
+    if (options.preserveRuntimeHooks) {
+      attachRuntimeHooks(merged.config, ctx.configs);
+    }
     return {
       config: finalize(merged.config),
       dependencies: Array.from(ctx.dependencies),
-      metadata: { sources: merged.sources, ...dsMetadata }
+      metadata: { sources: merged.sources, ...dsMetadata },
+      designSystemCompatibility
     };
   }
   return {
@@ -670,10 +847,11 @@ async function resolveAuthoredPresets(config, cwd, options = {}) {
       options.preserveRuntimeHooks ? attachRuntimeHooks(mergeConfigs(ctx.configs), ctx.configs) : mergeConfigs(ctx.configs)
     ),
     dependencies: Array.from(ctx.dependencies),
-    ...dsMetadata ? { metadata: dsMetadata } : {}
+    ...dsMetadata ? { metadata: dsMetadata } : {},
+    designSystemCompatibility
   };
 }
-async function collectConfigBlock(config, source, cwd, dependencies, trackSources) {
+async function resolveConfigEntry(config, source, cwd, dependencies, trackSources) {
   const ctx = {
     cwd,
     configs: [],
@@ -685,13 +863,13 @@ async function collectConfigBlock(config, source, cwd, dependencies, trackSource
   return {
     configs: ctx.configs,
     ...ctx.sourcedConfigs ? { sourcedConfigs: ctx.sourcedConfigs } : {},
-    resolved: mergeConfigs(ctx.configs)
+    config: mergeConfigs(ctx.configs)
   };
 }
-function appendConfigBlock(ctx, block) {
-  ctx.configs.push(...block.configs);
-  if (ctx.sourcedConfigs && block.sourcedConfigs) {
-    ctx.sourcedConfigs.push(...block.sourcedConfigs);
+function appendConfigResolution(ctx, resolution) {
+  ctx.configs.push(...resolution.configs);
+  if (ctx.sourcedConfigs && resolution.sourcedConfigs) {
+    ctx.sourcedConfigs.push(...resolution.sourcedConfigs);
   }
 }
 async function collectConfigs(config, source, ctx, active) {
@@ -777,7 +955,7 @@ async function loadConfig(options) {
   if (!isPlainObject(config)) {
     throw new PandaError("CONFIG_ERROR", "\u{1F4A5} Config must export or return an object.");
   }
-  const authored = await resolveAuthoredPresets(config, cwd, {
+  const authored = await resolveAuthoredPresetsForLoad(config, cwd, {
     configFile: path,
     trackSources: options.trackSources,
     preserveRuntimeHooks: true
@@ -785,7 +963,14 @@ 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);
+  refreshDesignSystemMetadata(
+    authored.metadata,
+    authored.designSystemCompatibility,
+    userConfig,
+    tokenEntriesBeforeHooks
+  );
   const resolved = applyConfigDefaults(userConfig, cwd);
   const dependencyList = Array.from(
     /* @__PURE__ */ new Set([...dependencies, ...authored.dependencies, ...resolved.dependencies ?? []])
@@ -798,12 +983,29 @@ 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) {
+  if (!metadata?.designSystem?.length) return;
+  metadata.userTokenPaths = resolveUserTokenPathsAfterHooks(
+    metadata.userTokenPaths ?? [],
+    tokenEntriesBeforeHooks,
+    config
+  );
+  for (const { designSystem, classNameOptions } of designSystemCompatibility) {
+    const mismatch = diffClassNameOptions(config, classNameOptions, "effective");
+    if (mismatch.length > 0) {
+      designSystem.optionMismatch = mismatch;
+    } else {
+      delete designSystem.optionMismatch;
+    }
+  }
+}
 async function runConfigResolvedHooks(config, path, dependencies) {
   let current = config;
   for (const entry of collectPluginHookHandlers(current, "config:resolved")) {
@@ -937,15 +1139,15 @@ function readPandaVersion() {
   }
 }
 
-// src/lib-preset.ts
+// src/design-system/compile-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({
+  const { rolldown } = await import("rolldown");
+  const build = await rolldown({
     input: VIRTUAL_ENTRY,
     cwd,
     platform: "node",
@@ -996,16 +1198,114 @@ 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)}`);
+    throw new PandaError("CONFIG_ERROR", `\u{1F4A5} Failed to compile design system preset: ${errorMessage(error)}`);
   }
 }
-function errorMessage2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
-// src/lib-manifest.ts
+// src/design-system/package.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";
+import { dirname as dirname6, join as join4 } from "path";
+
+// src/design-system/publishable-files.ts
+import { relative as relative5, resolve as resolve5 } from "path";
+var GLOB_START = /[*?{]/;
+var HAS_WILDCARD = /[*?]/;
+var TRAILING_SLASH = /\/$/;
+var REGEX_META = /[.+^${}()|[\]\\]/g;
+var GLOBSTAR = /\*\*/g;
+var GLOB_STAR = /\*/g;
+var GLOB_QMARK = /\?/g;
+var GLOBSTAR_TOKEN = /<<<DS>>>/g;
+function filterPublishableLibFiles(options) {
+  const { files, packageRoot, outRoot, publishFiles } = options;
+  if (!publishFiles?.length) {
+    return { files, unpublished: [] };
+  }
+  const rules = compilePackageFilesRules(publishFiles);
+  const kept = [];
+  const unpublished = [];
+  for (const file of files) {
+    const packageRelative = libFileToPackageRelative(file, packageRoot, outRoot);
+    if (packageRelative !== void 0 && matchesCompiledRules(packageRelative, rules)) {
+      kept.push(file);
+    } else {
+      unpublished.push(file);
+    }
+  }
+  return { files: kept, unpublished };
+}
+function readPublishFilesField(value) {
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  for (const entry of value) {
+    if (typeof entry !== "string") return void 0;
+  }
+  return value;
+}
+function libFileToPackageRelative(file, packageRoot, outRoot) {
+  const normalized = toPosixPath(file);
+  const withoutDot = normalized.startsWith("./") ? normalized.slice(2) : normalized;
+  const globAt = withoutDot.search(GLOB_START);
+  const literalPrefix = globAt === -1 ? withoutDot : withoutDot.slice(0, globAt);
+  const abs = resolve5(outRoot, literalPrefix || ".");
+  const rel = toPosixPath(relative5(packageRoot, abs));
+  if (rel === "") return "";
+  if (rel.startsWith("..")) return void 0;
+  return rel;
+}
+function compilePackageFilesRules(patterns) {
+  const rules = [];
+  for (const raw of patterns) {
+    const negated = raw.startsWith("!");
+    const pattern = toPosixPath(negated ? raw.slice(1) : raw);
+    const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
+    if (!normalized) continue;
+    if (!HAS_WILDCARD.test(normalized)) {
+      rules.push({ kind: "prefix", negated, value: normalized.replace(TRAILING_SLASH, "") });
+      continue;
+    }
+    const escaped = normalized.replace(REGEX_META, "\\$&").replace(GLOBSTAR, "<<<DS>>>").replace(GLOB_STAR, "[^/]*").replace(GLOB_QMARK, "[^/]").replace(GLOBSTAR_TOKEN, ".*");
+    rules.push({ kind: "regex", negated, value: new RegExp(`^${escaped}(?:/.*)?$`) });
+  }
+  return rules;
+}
+function matchesCompiledRules(packageRelativePath, rules) {
+  const path = packageRelativePath.startsWith("./") ? packageRelativePath.slice(2) : packageRelativePath;
+  let included = false;
+  for (const rule of rules) {
+    const hit = rule.kind === "prefix" ? path === rule.value || path.startsWith(`${rule.value}/`) : rule.value.test(path);
+    if (!hit) continue;
+    included = !rule.negated;
+  }
+  return included;
+}
+
+// src/design-system/package.ts
+var PACKAGE_MANAGER_RANGE_PATTERN = /^(?:workspace|catalog):/;
+var PORTABLE_WORKSPACE_RANGE_PATTERN = /^[~^]?\d/;
+var VERSION_CORE_PATTERN = /^(\d+)\.(\d+)\.(\d+)/;
+function resolvePublishedPandaRange(range, currentVersion) {
+  const authored = range?.trim();
+  if (!authored) return "*";
+  if (authored.startsWith("npm:")) {
+    return resolveNpmAliasRange(authored) ?? portableRangeFromInstalled(currentVersion, "^");
+  }
+  if (!PACKAGE_MANAGER_RANGE_PATTERN.test(authored)) return authored;
+  if (authored.startsWith("workspace:")) {
+    const workspaceRange = authored.slice("workspace:".length);
+    if (PORTABLE_WORKSPACE_RANGE_PATTERN.test(workspaceRange)) return workspaceRange;
+  }
+  const operator = authored === "workspace:~" ? "~" : "^";
+  return portableRangeFromInstalled(currentVersion, operator);
+}
+function resolveNpmAliasRange(spec) {
+  const at = spec.lastIndexOf("@");
+  if (at <= "npm:".length) return void 0;
+  return spec.slice(at + 1);
+}
+function portableRangeFromInstalled(currentVersion, operator) {
+  const core = currentVersion?.match(VERSION_CORE_PATTERN)?.[0];
+  return core ? `${operator}${core}` : "*";
+}
 function readPackageIdentity(cwd) {
   const packagePath = nearestPackageJson(cwd);
   if (packagePath === void 0) {
@@ -1021,7 +1321,8 @@ function readPackageIdentity(cwd) {
     name,
     version: typeof pkg.version === "string" ? pkg.version : void 0,
     pandaPeer: typeof peer === "string" ? peer : void 0,
-    packagePath
+    packagePath,
+    publishFiles: readPublishFilesField(pkg.files)
   };
 }
 function defaultImportMap(name) {
@@ -1038,29 +1339,23 @@ function syncExports(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 conflicts = [];
+  for (const [key, value] of Object.entries(entries)) {
+    if (key in existing && existing[key] !== value) {
+      conflicts.push(key);
+    }
+    merged[key] = value;
+  }
   const changed = JSON.stringify(pkg.exports) !== JSON.stringify(merged);
   const out = { ...pkg, exports: merged };
   return { changed, json: `${JSON.stringify(out, null, 2)}
-` };
-}
-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);
+`, conflicts };
 }
 function normalizeExports(exports) {
   if (exports === void 0) return {};
   if (typeof exports === "string") return { ".": exports };
-  if (!isPlainObject2(exports)) return {};
+  if (Array.isArray(exports)) return { ".": exports };
+  if (!isPlainObject(exports)) return {};
   if (isSubpathExportMap(exports)) return exports;
   return { ".": exports };
 }
@@ -1084,12 +1379,15 @@ export {
   createConfigSnapshot,
   defaultImportMap,
   diffConfig,
+  filterPublishableLibFiles,
   findConfig,
   loadConfig,
   mergeConfigs,
   mergeExcludes,
   readPackageIdentity,
   readPandaVersion,
+  readPublishFilesField,
+  resolvePublishedPandaRange,
   resolveSmartInclude,
   syncExports,
   toPosixPath,

package/dist/merge.js

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

package/dist/serialize.js

@@ -1,6 +1,7 @@
 import {
   createConfigSnapshot
-} from "./chunk-VYX3JX5J.js";
+} from "./chunk-U6KCSKCU.js";
+import "./chunk-R4R5RHIS.js";
 export {
   createConfigSnapshot
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pandacss/config",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.9",
   "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.7",
-    "@pandacss/types": "2.0.0-beta.7"
+    "@pandacss/compiler-shared": "2.0.0-beta.9",
+    "@pandacss/types": "2.0.0-beta.9"
   },
   "engines": {
     "node": ">=22"