@pandacss/compiler 2.0.0-beta.9 → 2.0.1

package/dist/{chunk-G4RVGB4O.js → chunk-CDATBPPB.js}

@@ -4,7 +4,6 @@ import {
   assertProjectCallbacks,
   BuildInfo as BuildInfo2,
   DesignSystem as DesignSystem2,
-  getTokenCategoryValues,
   inspectFile,
   inspectFiles,
   mergeCallbacks,
@@ -14,10 +13,10 @@ import {
 
 // src/callbacks.ts
 import {
-  createPatternHelpers,
-  createTransformArgs,
+  createTransformHelpers,
   getPatternDefaultValueRefsByTransformId,
-  mergePatternDefaultValues
+  mergePatternDefaultValues,
+  PATTERN_HELPERS
 } from "@pandacss/compiler-shared";
 function registerCallbacks(project, callbacks, hooks, tokenDictionary) {
   const utilityTransforms = callbacks["utility.transform"];
@@ -27,6 +26,7 @@ function registerCallbacks(project, callbacks, hooks, tokenDictionary) {
   const config = project.config();
   const patternDefaultValues = callbacks["pattern.defaultValues"];
   const patternDefaultValueRefs = config && patternDefaultValues ? getPatternDefaultValueRefsByTransformId(config) : /* @__PURE__ */ new Map();
+  const { token, utils } = createTransformHelpers(tokenDictionary);
   if (hasPatternTransforms && !project.registerPatternTransform) {
     throw new Error("Native project does not support pattern.transform callbacks");
   }
@@ -37,7 +37,7 @@ function registerCallbacks(project, callbacks, hooks, tokenDictionary) {
       project.registerPatternTransform(id, (props) => {
         const input = props;
         const nextProps = defaultValue ? mergePatternDefaultValues(defaultValue(input), input) : input;
-        return callback(nextProps, createPatternHelpers());
+        return callback(nextProps, PATTERN_HELPERS);
       });
     }
   }
@@ -47,7 +47,7 @@ function registerCallbacks(project, callbacks, hooks, tokenDictionary) {
   if (project.registerUtilityTransform && utilityTransforms) {
     for (const [id, callback] of Object.entries(utilityTransforms)) {
       project.registerUtilityTransform(id, (resolved, original) => {
-        return callback(resolved, createTransformArgs(original, tokenDictionary));
+        return callback(resolved, { raw: original, token, utils });
       });
     }
   }
@@ -159,11 +159,17 @@ var FallbackCompiler = class _FallbackCompiler {
   removeFile() {
     return false;
   }
+  affectedFiles() {
+    return [];
+  }
   clear() {
   }
   scan() {
     return [];
   }
+  designSystemImportSelections() {
+    return [];
+  }
   realpath(path) {
     return path;
   }
@@ -196,6 +202,9 @@ var FallbackCompiler = class _FallbackCompiler {
   hasLayerDeclaration() {
     return false;
   }
+  stripLayerOrderStatements(css) {
+    return css;
+  }
   spec() {
     return {
       conditions: { keys: [], breakpoints: [], containers: [] },
@@ -222,7 +231,7 @@ var FallbackCompiler = class _FallbackCompiler {
       bailed: false,
       diagnostics: [],
       dependencies: [],
-      helper: { needsCx: false, needsCva: false, needsSva: false }
+      helper: { needsCx: false, needsAttachRecipe: false, needsMemoRecipe: false }
     };
   }
   inspectFile(input) {
@@ -250,7 +259,7 @@ var FallbackCompiler = class _FallbackCompiler {
     return emptyWriteCssResult(options.outfile);
   }
   writeSplitCss(options) {
-    return emptyWriteFilesResult(options.outdir ?? "");
+    return emptyWriteSplitCssResult(options.outdir ?? "");
   }
   isEmpty() {
     return true;
@@ -285,8 +294,11 @@ var FallbackCompiler = class _FallbackCompiler {
   getLayerCss(_options) {
     return emptyCompileOutput();
   }
+  getKeyframeCss(_options) {
+    return emptyCompileOutput();
+  }
   getSplitCss(_options) {
-    return [];
+    return { files: [], diagnostics: [] };
   }
   buildInfo = fallbackBuildInfo;
   designSystem = fallbackDesignSystem;
@@ -353,21 +365,20 @@ function emptyWriteCssResult(path) {
     ...emptyCompileOutput()
   };
 }
-function emptyWriteFilesResult(root) {
+function emptyWriteSplitCssResult(root) {
   return {
     root,
     paths: [],
-    files: []
+    files: [],
+    diagnostics: []
   };
 }
 
 // src/load-binary.ts
-import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "fs";
-import { createRequire } from "module";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-var bindingUrl = new URL("../binding.cjs", import.meta.url);
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
 var webContainerWasiPackage = "@pandacss/compiler-wasm32-wasi";
 function loadNativeBinding() {
   const bindingPath = resolveBindingPath();
@@ -380,13 +391,21 @@ function loadNativeBinding() {
     return loadWebContainerBinding(require2, bindingPath, error);
   }
 }
-function resolveBindingPath() {
-  if (bindingUrl.protocol === "file:") {
-    const bindingPath = fileURLToPath(bindingUrl);
+function resolveBindingPath(referrer = import.meta.url) {
+  const packageRoot = resolvePackageRoot(referrer);
+  if (packageRoot) {
+    const bindingPath = join(packageRoot, "binding.cjs");
     if (existsSync(bindingPath)) return bindingPath;
   }
   return fallbackBindingPaths().find((path) => existsSync(path));
 }
+function resolvePackageRoot(referrer) {
+  try {
+    return dirname(createRequire(referrer).resolve("@pandacss/compiler/package.json"));
+  } catch {
+    return void 0;
+  }
+}
 function fallbackBindingPaths() {
   const cwd = process.cwd();
   const paths = [join(cwd, "packages/compiler/binding.cjs")];
@@ -460,9 +479,11 @@ import {
   BaseDriver,
   collectParseDiagnostics,
   diagnosticsPass,
+  fromCodegenPrepareArtifacts,
   normalizeDiagnostics
 } from "@pandacss/compiler-shared";
 import {
+  buildCodegenOverlay,
   compilePreset,
   defaultImportMap,
   diffConfig,
@@ -477,35 +498,144 @@ import {
   toPosixRelative,
   toRelativeKey
 } from "@pandacss/config";
-
-// src/tooling/create-project.ts
-import { defaultConfig } from "@pandacss/compiler-shared";
-import { loadConfig } from "@pandacss/config";
+import { statSync } from "node:fs";
+import { dirname as dirname2, resolve as resolvePath } from "node:path";
 
 // src/design-system.ts
 import "@pandacss/compiler-shared";
-import { readPandaVersion } from "@pandacss/config";
-function hydrateDesignSystem(compiler, chain, consumerTokenPaths = []) {
+import {
+  collectArtifactConflicts,
+  readPandaVersion
+} from "@pandacss/config";
+function artifactConflictDiagnostics(metadata) {
+  return collectArtifactConflicts(metadata).flatMap((conflict) => [
+    ...conflict.recipes.map((name) => artifactConflict("Recipe", name, conflict.name)),
+    ...conflict.patterns.map((name) => artifactConflict("Pattern", name, conflict.name))
+  ]);
+}
+function artifactConflict(kind, name, designSystem) {
+  return {
+    code: "design_system_artifact_conflict",
+    severity: "warning",
+    category: "designSystem",
+    message: `${kind} ${JSON.stringify(name)} is defined by both ${JSON.stringify(designSystem)} and this config; your definition is merged over the design system's.`
+  };
+}
+function hydrateDesignSystem(compiler, options) {
+  const { chain, consumerTokenPaths = [], treeshake, importSelections } = options;
   if (!chain || chain.length === 0) {
-    return [];
+    return { diagnostics: [], treeshakeKey: "" };
   }
   const pandaVersion = readPandaVersion();
   const diagnostics = [];
-  for (const ds of chain) {
-    diagnostics.push(...hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths));
+  const appSelections = treeshake ? importSelections ?? collectImportSelections(compiler, chain) : void 0;
+  const selections = appSelections && withDependencyImports(compiler, chain, appSelections);
+  for (let i = 0; i < chain.length; i++) {
+    const ds = chain[i];
+    const imports = selections ? selections[i] ?? void 0 : void 0;
+    diagnostics.push(...hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths, imports));
   }
-  return diagnostics;
+  return {
+    diagnostics,
+    treeshakeKey: treeshakeKeyFromSelections(chain, appSelections)
+  };
 }
-function hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths) {
+var ALL_MODULES = { kind: "all" };
+var NO_MODULES = { kind: "none" };
+function withDependencyImports(compiler, chain, appSelections) {
+  const selections = appSelections.map(selectionFromScan);
+  for (let i = chain.length - 1; i > 0; i--) {
+    const selected = selections[i];
+    if (selected.kind === "none") continue;
+    const info = readBuildInfo(compiler, chain[i]);
+    for (let ancestorIndex = 0; ancestorIndex < i; ancestorIndex++) {
+      const imported = info ? compiler.designSystem.dependencyImports(info, selectionToImports(selected), chain[ancestorIndex].name) : void 0;
+      selections[ancestorIndex] = mergeSelection(selections[ancestorIndex], selectionFromImports(imported));
+    }
+  }
+  return selections.map(selectionToScan);
+}
+function selectionFromScan(selection) {
+  if (selection == null) return ALL_MODULES;
+  return selection.length === 0 ? NO_MODULES : { kind: "names", names: selection };
+}
+function selectionFromImports(imports) {
+  if (imports === void 0) return ALL_MODULES;
+  return imports.length === 0 ? NO_MODULES : { kind: "names", names: imports };
+}
+function selectionToImports(selection) {
+  if (selection.kind === "all") return void 0;
+  return selection.kind === "none" ? [] : selection.names;
+}
+function selectionToScan(selection) {
+  if (selection.kind === "all") return null;
+  return selection.kind === "none" ? [] : selection.names;
+}
+function mergeSelection(current, added) {
+  if (current.kind === "all" || added.kind === "all") return ALL_MODULES;
+  if (current.kind === "none") return added;
+  if (added.kind === "none") return current;
+  return { kind: "names", names: [.../* @__PURE__ */ new Set([...current.names, ...added.names])] };
+}
+function readBuildInfo(compiler, ds) {
+  if (ds.optionMismatch?.length) return void 0;
+  try {
+    const content = compiler.fs.readFile(ds.buildInfoPath);
+    if (content == null) return void 0;
+    const info = JSON.parse(content);
+    return compiler.buildInfo.validate(info).ok ? info : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function designSystemDependencies(chain) {
+  return (chain ?? []).map((ds) => ({
+    name: ds.name,
+    packageRoots: getPackageRoots(ds),
+    excludeModules: getExcludedModules(ds)
+  }));
+}
+function collectImportSelections(compiler, chain) {
+  return compiler.designSystemImportSelections(
+    chain.map((ds) => ({
+      packageRoots: getPackageRoots(ds),
+      excludeModules: getExcludedModules(ds)
+    }))
+  );
+}
+function treeshakeKeyFromSelections(chain, selections) {
+  if (!selections?.length) return "";
+  return chain.map((ds, i) => `${ds.name}:${JSON.stringify(selections[i] ?? null)}`).join("|");
+}
+var STYLED_SYSTEM_SUBPATHS = ["css", "recipes", "patterns", "jsx", "tokens"];
+function getPackageRoots(ds) {
+  return [...new Set([ds.specifier, ds.name].filter((value) => Boolean(value)))];
+}
+function getExcludedModules(ds) {
+  const excluded = /* @__PURE__ */ new Set();
+  for (const root of getPackageRoots(ds)) {
+    for (const sub of STYLED_SYSTEM_SUBPATHS) {
+      excluded.add(`${root}/${sub}`);
+    }
+  }
+  const map = ds.importMap;
+  if (map) {
+    for (const value of [map.css, map.recipes, map.patterns, map.jsx, map.tokens]) {
+      if (typeof value === "string" && value.length > 0) excluded.add(value);
+    }
+  }
+  return [...excluded];
+}
+function hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths, imports) {
   const compat = compiler.designSystem.validate(ds.manifest, { pandaVersion });
   if (!compat.ok) {
     throw incompatibleManifestError(compiler, ds, compat.reason, pandaVersion);
   }
-  const diagnostics = hydrateArtifacts(compiler, ds, pandaVersion);
+  const diagnostics = hydrateArtifacts(compiler, ds, pandaVersion, imports);
   diagnostics.push(...tokenConflictDiagnostics(ds, consumerTokenPaths));
   return diagnostics;
 }
-function hydrateArtifacts(compiler, ds, pandaVersion) {
+function hydrateArtifacts(compiler, ds, pandaVersion, imports) {
   if (ds.optionMismatch && ds.optionMismatch.length > 0) {
     const diagnostic = recoverFromSources(
       compiler,
@@ -530,7 +660,11 @@ function hydrateArtifacts(compiler, ds, pandaVersion) {
     );
     return [diagnostic];
   }
-  const result = compiler.designSystem.load(ds.manifest, { buildInfo, pandaVersion });
+  const result = compiler.designSystem.load(ds.manifest, {
+    buildInfo,
+    pandaVersion,
+    ...imports !== void 0 ? { imports } : {}
+  });
   if (!result.ok) {
     const issue = result.reason === "schemaVersion" ? {
       kind: "schemaVersion",
@@ -560,7 +694,8 @@ function extractFallbackSources(compiler, ds) {
   if (ds.files.length === 0) {
     return [];
   }
-  return compiler.scan({ include: ds.files, cwd: compiler.path.dirname(ds.manifestPath) });
+  const filesCwd = compiler.path.resolve(compiler.path.join([compiler.path.dirname(ds.manifestPath), ".."]));
+  return compiler.scan({ include: ds.files, cwd: filesCwd });
 }
 function buildInfoDiagnostic(ds, issue, sourceCount, severity) {
   const reason = buildInfoIssueMessage(issue);
@@ -571,7 +706,7 @@ function buildInfoDiagnostic(ds, issue, sourceCount, severity) {
     category: "designSystem",
     file: ds.buildInfoPath,
     message: `${JSON.stringify(ds.name)} build info ${reason}.${outcome}`,
-    help: [`Run \`panda lib\` in ${JSON.stringify(ds.name)} to rebuild panda.buildinfo.json.`]
+    help: [`Run \`panda lib\` in ${JSON.stringify(ds.name)} to rebuild panda/buildinfo.json.`]
   };
 }
 function buildInfoIssueMessage(issue) {
@@ -623,7 +758,7 @@ function incompatibleManifestError(compiler, ds, reason, pandaVersion) {
       severity: "error",
       category: "designSystem",
       file: ds.manifestPath,
-      message: `${JSON.stringify(ds.name)} panda.lib.json uses schemaVersion ${ds.manifest.schemaVersion}; expected ${compiler.designSystem.schemaVersion}.`,
+      message: `${JSON.stringify(ds.name)} panda/lib.json uses schemaVersion ${ds.manifest.schemaVersion}; expected ${compiler.designSystem.schemaVersion}.`,
       help: [`Upgrade ${JSON.stringify(ds.name)}, or rebuild it with a compatible version of Panda.`]
     });
   }
@@ -650,23 +785,40 @@ function errorMessage(error) {
 }
 
 // src/tooling/create-project.ts
+import { defaultConfig } from "@pandacss/compiler-shared";
+import {
+  collectExportMissingDiagnostics,
+  collectNameCollisionDiagnostics,
+  loadConfig
+} from "@pandacss/config";
+function treeshakeDesignSystemEnabled(config) {
+  const optimize = config.optimize;
+  return optimize?.treeshakeDesignSystem === true;
+}
 function createProjectFromLoadedConfig(loaded) {
   const compiler = createCompilerFromSnapshot({
     config: loaded.config,
     callbacks: loaded.callbacks,
     hooks: loaded.hooks
   });
-  const designSystemDiagnostics = hydrateDesignSystem(
-    compiler,
-    loaded.metadata?.designSystem,
-    loaded.metadata?.userTokenPaths ?? []
-  );
+  const hydrated = hydrateDesignSystem(compiler, {
+    chain: loaded.metadata?.designSystem,
+    consumerTokenPaths: loaded.metadata?.userTokenPaths ?? [],
+    treeshake: treeshakeDesignSystemEnabled(loaded.config)
+  });
+  const designSystemDiagnostics = [
+    ...hydrated.diagnostics,
+    ...artifactConflictDiagnostics(loaded.metadata),
+    ...collectExportMissingDiagnostics(loaded.metadata),
+    ...collectNameCollisionDiagnostics(loaded.metadata)
+  ];
   return {
     compiler,
     configPath: loaded.path,
     dependencies: loaded.dependencies,
     outdir: loaded.config.outdir ?? defaultConfig.outdir,
-    designSystemDiagnostics
+    designSystemDiagnostics,
+    designSystemTreeshakeKey: hydrated.treeshakeKey
   };
 }
 
@@ -674,7 +826,7 @@ function createProjectFromLoadedConfig(loaded) {
 var DEFAULT_DESIGN_SYSTEM_LIB_OUTDIR = "dist";
 var DEFAULT_DESIGN_SYSTEM_LIB_FILES = ["./**/*.{js,mjs}"];
 async function createNodeDriver(options) {
-  const loaded = await loadConfig2({ cwd: options.cwd, file: options.configPath });
+  const loaded = await loadConfig2({ cwd: options.cwd, file: options.configPath, trackSources: options.trackSources });
   if (options.include?.length) applyIncludeOverride(loaded, options.cwd, options.include);
   return new NodeDriver(options, loaded);
 }
@@ -695,17 +847,35 @@ var NodeDriver = class extends BaseDriver {
   #designSystemPreset;
   #designSystemArtifactSnapshot;
   #designSystemWatchTargets;
+  #codegenOverlay;
+  #codegenOverlayResolved = false;
+  #designSystemTreeshakeKey;
+  #configFilePaths;
+  #designSystemFileKinds;
+  #sourceGeneration = 0;
+  #treeshakeSyncedGeneration = -1;
   constructor(options, loaded) {
     const built = createProjectFromLoadedConfig(loaded);
     super(built.compiler);
     this.#options = options;
     this.#loaded = loaded;
     this.#designSystemDiagnostics = built.designSystemDiagnostics;
-    this.#designSystemArtifactSnapshot = designSystemArtifactSnapshot(this.compiler, loaded);
+    this.#designSystemArtifactSnapshot = designSystemArtifactSnapshot(loaded);
+    this.#designSystemTreeshakeKey = built.designSystemTreeshakeKey ?? "";
   }
   get designSystemDiagnostics() {
     return this.#designSystemDiagnostics;
   }
+  configSources() {
+    return this.#loaded.metadata?.sources;
+  }
+  codegenOverlay() {
+    if (!this.#codegenOverlayResolved) {
+      this.#codegenOverlay = buildCodegenOverlay(this.#loaded.metadata);
+      this.#codegenOverlayResolved = true;
+    }
+    return this.#codegenOverlay;
+  }
   get config() {
     return this.#loaded.config;
   }
@@ -717,9 +887,10 @@ var NodeDriver = class extends BaseDriver {
   }
   designSystemWatchTargets() {
     return this.#designSystemWatchTargets ??= (this.#loaded.metadata?.designSystem ?? []).map((ds) => {
-      const base = this.compiler.path.dirname(ds.manifestPath);
-      const presetPath = realpathIfExists(this.compiler, this.compiler.path.resolve(ds.manifest.preset, base));
-      const sourceFiles = ds.files.length > 0 ? this.compiler.scan({ include: ds.files, cwd: base }).map((file) => realpathIfExists(this.compiler, file)) : [];
+      const manifestDir = this.compiler.path.dirname(ds.manifestPath);
+      const presetPath = realpathIfExists(this.compiler, this.compiler.path.resolve(ds.manifest.preset, manifestDir));
+      const filesCwd = designSystemFilesCwd(this.compiler, ds.manifestPath);
+      const sourceFiles = ds.files.length > 0 ? this.compiler.scan({ include: ds.files, cwd: filesCwd }).map((file) => realpathIfExists(this.compiler, file)) : [];
       return {
         name: ds.name,
         manifestPath: realpathIfExists(this.compiler, ds.manifestPath),
@@ -730,18 +901,20 @@ var NodeDriver = class extends BaseDriver {
     });
   }
   isDesignSystemFile(file) {
-    const target = this.compiler.path.realpath(file);
+    const kinds = this.#designSystemFileKinds ??= this.buildDesignSystemFileKinds();
+    return kinds.get(this.compiler.path.realpath(file)) ?? false;
+  }
+  buildDesignSystemFileKinds() {
+    const kinds = /* @__PURE__ */ new Map();
     for (const watchTarget of this.#designSystemWatchTargets ?? this.designSystemWatchTargets()) {
-      if ([watchTarget.manifestPath, watchTarget.buildInfoPath, watchTarget.presetPath].some(
-        (path) => this.compiler.path.realpath(path) === target
-      )) {
-        return "artifact";
+      for (const path of [watchTarget.manifestPath, watchTarget.buildInfoPath, watchTarget.presetPath]) {
+        kinds.set(this.compiler.path.realpath(path), "artifact");
       }
-      if (watchTarget.sourceFiles.some((path) => this.compiler.path.realpath(path) === target)) {
-        return "source";
+      for (const path of watchTarget.sourceFiles) {
+        kinds.set(this.compiler.path.realpath(path), "source");
       }
     }
-    return false;
+    return kinds;
   }
   async syncDesignSystemFileChange(change) {
     const kind = this.isDesignSystemFile(change.path);
@@ -750,7 +923,7 @@ var NodeDriver = class extends BaseDriver {
       if (diff.hasChanged) this.parseFiles();
       return diff.hasChanged;
     }
-    if (kind === "source") return this.applyChange(change);
+    if (kind === "source") return this.applySourceChange(change, "design-system");
     return false;
   }
   syncDesignSystemSources() {
@@ -768,10 +941,14 @@ var NodeDriver = class extends BaseDriver {
     return this.applyChanges(changes);
   }
   async reload() {
-    const next = await loadConfig2({ cwd: this.#options.cwd, file: this.#options.configPath });
+    const next = await loadConfig2({
+      cwd: this.#options.cwd,
+      file: this.#options.configPath,
+      trackSources: this.#options.trackSources
+    });
     if (this.#options.include?.length) applyIncludeOverride(next, this.#options.cwd, this.#options.include);
     const diff = diffConfig(this.#loaded, next);
-    const nextDesignSystemArtifactSnapshot = designSystemArtifactSnapshot(this.compiler, next);
+    const nextDesignSystemArtifactSnapshot = designSystemArtifactSnapshot(next);
     const designSystemArtifactsChanged = this.#designSystemArtifactSnapshot !== nextDesignSystemArtifactSnapshot;
     if (diff.hasChanged || designSystemArtifactsChanged) {
       this.#loaded = next;
@@ -781,30 +958,64 @@ var NodeDriver = class extends BaseDriver {
       this.#designSystemPreset = void 0;
       this.#designSystemArtifactSnapshot = nextDesignSystemArtifactSnapshot;
       this.#designSystemWatchTargets = void 0;
+      this.#codegenOverlay = void 0;
+      this.#codegenOverlayResolved = false;
+      this.#designSystemTreeshakeKey = built.designSystemTreeshakeKey ?? "";
+      this.#configFilePaths = void 0;
+      this.#designSystemFileKinds = void 0;
+      this.#sourceGeneration++;
+      this.#treeshakeSyncedGeneration = -1;
     }
     return designSystemArtifactsChanged && !diff.hasChanged ? { ...diff, hasChanged: true } : diff;
   }
+  /** Re-hydrate when treeshake import set changes. */
+  syncDesignSystemTreeShake() {
+    if (!treeshakeDesignSystemEnabled(this.#loaded.config)) return false;
+    const chain = this.#loaded.metadata?.designSystem;
+    if (!chain?.length) return false;
+    if (this.#treeshakeSyncedGeneration === this.#sourceGeneration) return false;
+    const selections = collectImportSelections(this.compiler, chain);
+    const nextKey = treeshakeKeyFromSelections(chain, selections);
+    this.#treeshakeSyncedGeneration = this.#sourceGeneration;
+    if (nextKey === this.#designSystemTreeshakeKey) return false;
+    const hydrated = hydrateDesignSystem(this.compiler, {
+      chain,
+      consumerTokenPaths: this.#loaded.metadata?.userTokenPaths ?? [],
+      treeshake: true,
+      importSelections: selections
+    });
+    this.#designSystemDiagnostics = hydrated.diagnostics;
+    this.#designSystemTreeshakeKey = hydrated.treeshakeKey;
+    return true;
+  }
+  prepareCssOutput() {
+    this.syncDesignSystemTreeShake();
+  }
   applyChange(change) {
-    if (change.kind === "unlink") {
-      return this.compiler.removeFile(change.path);
-    }
-    if (change.kind === "change") {
-      if (change.content == null) {
-        if (this.compiler.refreshFile(change.path)) return true;
-        this.compiler.parseFile(change.path);
-        return true;
-      }
-      if (this.compiler.refreshFileSource(change.path, change.content)) return true;
-      this.compiler.parseFileSource(change.path, change.content);
-      return true;
-    }
-    if (change.content == null) {
-      this.compiler.parseFile(change.path);
-      return true;
-    }
-    this.compiler.parseFileSource(change.path, change.content);
+    return this.applySourceChange(change, "project");
+  }
+  applySourceChange(change, admission) {
+    const changed = this.trackSourceChange(change, this.admitSourceChange(change, admission));
+    const refreshed = this.refreshAffectedFiles();
+    return this.recordSourceChange(changed || refreshed);
+  }
+  /** Known files always refresh; unknown project paths must match the source globs. */
+  admitSourceChange(change, admission) {
+    if (change.kind === "unlink") return this.compiler.removeFile(change.path);
+    const refreshed = change.content == null ? this.compiler.refreshFile(change.path) : this.compiler.refreshFileSource(change.path, change.content);
+    if (refreshed) return true;
+    if (admission === "project" && !this.isSourceFile(change.path)) return false;
+    if (change.content == null) this.compiler.parseFile(change.path);
+    else this.compiler.parseFileSource(change.path, change.content);
     return true;
   }
+  recordSourceChange(applied) {
+    if (applied) {
+      this.#sourceGeneration++;
+      this.#treeshakeSyncedGeneration = -1;
+    }
+    return applied;
+  }
   getOutdir(outdir) {
     return this.compiler.path.resolve(this.getConfiguredOutdir(outdir));
   }
@@ -893,7 +1104,8 @@ var NodeDriver = class extends BaseDriver {
     }
   }
   codegenWithPrepareHooks(hooks, outdir, cwd, options) {
-    let artifacts = this.compiler.generateArtifacts(toGenerateArtifactOptions(options));
+    const overlay = this.codegenOverlay();
+    let artifacts = this.compiler.generateArtifacts({ ...toGenerateArtifactOptions(options), overlay });
     for (const entry of hooks) {
       const handler = resolveHookHandler(entry.value, "codegen:prepare");
       const next = handler({ artifacts, outdir, cwd });
@@ -901,24 +1113,31 @@ var NodeDriver = class extends BaseDriver {
         if (!Array.isArray(next)) {
           throw new Error("Invalid codegen:prepare hook result. Expected an artifact array or undefined.");
         }
-        artifacts = next;
+        artifacts = fromCodegenPrepareArtifacts(next);
       }
     }
     return this.compiler.writeArtifacts({
       outdir,
       cwd,
       forceImportExtension: options?.forceImportExtension,
-      artifacts
+      artifacts,
+      overlay
     });
   }
   isConfigFile(file) {
-    const target = this.compiler.path.realpath(file);
-    const configPath = this.compiler.path.realpath(this.#loaded.path);
-    if (configPath === target) return true;
-    return this.#loaded.dependencies.some((dependency) => {
+    const paths = this.#configFilePaths ??= this.buildConfigFilePaths();
+    return paths.has(this.compiler.path.realpath(file));
+  }
+  buildConfigFilePaths() {
+    const paths = /* @__PURE__ */ new Set();
+    if (this.#loaded.path) {
+      paths.add(this.compiler.path.realpath(this.#loaded.path));
+    }
+    for (const dependency of this.#loaded.dependencies) {
       const dependencyPath = this.compiler.path.resolve(dependency, this.#options.cwd);
-      return this.compiler.path.realpath(dependencyPath) === target;
-    });
+      paths.add(this.compiler.path.realpath(dependencyPath));
+    }
+    return paths;
   }
   parseDesignSystemLib() {
     const parsed = this.parseFiles();
@@ -941,10 +1160,14 @@ var NodeDriver = class extends BaseDriver {
     const pandaRange = resolvePublishedPandaRange(options.panda ?? identity.pandaPeer, readPandaVersion2());
     const outdir = options.outdir ?? DEFAULT_DESIGN_SYSTEM_LIB_OUTDIR;
     const outRoot = this.compiler.path.resolve(outdir);
-    const manifestPath = this.compiler.path.join([outRoot, "panda.lib.json"]);
-    const buildInfoPath = this.compiler.path.join([outRoot, "panda.buildinfo.json"]);
-    const presetPath = this.compiler.path.join([outRoot, "panda.preset.mjs"]);
-    const info = this.compiler.buildInfo.create({ panda: pandaRange });
+    const pandaDir = this.compiler.path.join([outRoot, "panda"]);
+    const manifestPath = this.compiler.path.join([pandaDir, "lib.json"]);
+    const buildInfoPath = this.compiler.path.join([pandaDir, "buildinfo.json"]);
+    const presetPath = this.compiler.path.join([pandaDir, "preset.mjs"]);
+    const info = this.compiler.buildInfo.create({
+      panda: pandaRange,
+      designSystemDependencies: designSystemDependencies(this.#loaded.metadata?.designSystem)
+    });
     const buildInfo = this.compiler.buildInfo.normalize(info, {
       mapModuleKey: (key) => toRelativeKey(key, this.#options.cwd)
     });
@@ -952,18 +1175,28 @@ var NodeDriver = class extends BaseDriver {
       explicit: options.files,
       compiler: this.compiler,
       cwd: this.#options.cwd,
-      outRoot,
+      filesBase: outRoot,
       buildInfo,
       packageRoot: this.compiler.path.dirname(identity.packagePath),
       publishFiles: identity.publishFiles,
       packageName: identity.name
     });
+    const { spec, diagnostics: specDiagnostics } = resolvePublishableSpec({
+      spec: options.spec,
+      compiler: this.compiler,
+      outRoot,
+      pandaDir,
+      packageRoot: this.compiler.path.dirname(identity.packagePath),
+      publishFiles: identity.publishFiles,
+      packageName: identity.name
+    });
     const manifest = this.compiler.designSystem.create({
       name: identity.name,
       version: identity.version,
       panda: pandaRange,
-      preset: "./panda.preset.mjs",
-      buildInfo: "./panda.buildinfo.json",
+      preset: "./preset.mjs",
+      buildInfo: "./buildinfo.json",
+      spec,
       importMap: defaultImportMap(identity.name),
       designSystem: typeof this.config.designSystem === "string" ? this.config.designSystem : void 0,
       files: libFiles
@@ -976,18 +1209,18 @@ var NodeDriver = class extends BaseDriver {
           id: "design-system-lib",
           files: [
             {
-              path: "panda.lib.json",
+              path: "panda/lib.json",
               code: `${JSON.stringify(manifest, null, 2)}
 `,
               dependencies: []
             },
             {
-              path: "panda.buildinfo.json",
+              path: "panda/buildinfo.json",
               code: JSON.stringify(buildInfo, null, options.minify ? 0 : 2),
               dependencies: []
             },
             {
-              path: "panda.preset.mjs",
+              path: "panda/preset.mjs",
               code: preset.code,
               dependencies: []
             }
@@ -996,8 +1229,8 @@ var NodeDriver = class extends BaseDriver {
       ]
     });
     const { changed: exportsChanged, conflicts } = syncPackageExports(this.compiler, identity.packagePath, {
-      manifestPath,
-      presetPath
+      pandaDir,
+      styledDir: this.getOutdir()
     });
     return {
       manifestPath,
@@ -1005,19 +1238,46 @@ var NodeDriver = class extends BaseDriver {
       presetPath,
       exportsChanged,
       parsedFileCount: parsed.parsedFileCount,
-      diagnostics: [...parsed.diagnostics, ...filesDiagnostics, ...exportConflictDiagnostics(identity.name, conflicts)]
+      diagnostics: [
+        ...parsed.diagnostics,
+        ...filesDiagnostics,
+        ...specDiagnostics,
+        ...exportConflictDiagnostics(identity.name, conflicts)
+      ]
     };
   }
 };
+function resolvePublishableSpec(options) {
+  if (!options.spec) return { diagnostics: [] };
+  const absolute = options.compiler.path.resolve(options.spec);
+  const { unpublished } = filterPublishableLibFiles({
+    files: [toPosixRelative(options.outRoot, absolute)],
+    packageRoot: options.packageRoot,
+    outRoot: options.outRoot,
+    publishFiles: options.publishFiles
+  });
+  if (unpublished.length > 0) {
+    return { diagnostics: [specNotPublishableDiagnostic(options.packageName, unpublished[0])] };
+  }
+  return { spec: toPosixRelative(options.pandaDir, absolute), diagnostics: [] };
+}
+function specNotPublishableDiagnostic(name, spec) {
+  return {
+    code: "design_system_spec_not_publishable",
+    severity: "warning",
+    category: "designSystem",
+    message: `\`panda lib\` left the spec out of ${JSON.stringify(name)}'s manifest because package.json \`"files"\` would not publish ${JSON.stringify(spec)}. A bare \`--spec\` writes it beside preset.mjs, inside what you publish.`
+  };
+}
 function resolveDesignSystemLibFiles(options) {
   if (options.explicit) {
     return { files: options.explicit, diagnostics: [] };
   }
-  const inferred = inferDesignSystemLibFiles(options.compiler, options.cwd, options.outRoot, options.buildInfo);
+  const inferred = inferDesignSystemLibFiles(options.compiler, options.cwd, options.filesBase, options.buildInfo);
   const { files, unpublished } = filterPublishableLibFiles({
     files: inferred,
     packageRoot: options.packageRoot,
-    outRoot: options.outRoot,
+    outRoot: options.filesBase,
     publishFiles: options.publishFiles
   });
   if (unpublished.length === 0) {
@@ -1072,11 +1332,15 @@ function skippedDesignSystemLib(parsed) {
     diagnostics: parsed.diagnostics
   };
 }
+var STYLED_SYSTEM_CATEGORIES = ["css", "recipes", "patterns", "jsx", "tokens", "helpers"];
+var DEEP_IMPORT_CATEGORIES = /* @__PURE__ */ new Set(["css", "recipes", "patterns", "jsx"]);
+var SINGLE_FILE_CATEGORIES = /* @__PURE__ */ new Set(["helpers"]);
 function syncPackageExports(compiler, packagePath, paths) {
   const base = compiler.path.dirname(packagePath);
+  const pandaGlob = `${toPosixRelative(base, paths.pandaDir)}/*`;
   const entries = {
-    "./panda.lib.json": toPosixRelative(base, paths.manifestPath),
-    "./preset": toPosixRelative(base, paths.presetPath)
+    "./panda/*": pandaGlob,
+    ...styledSystemExports(compiler, base, paths.styledDir)
   };
   const packageJson = compiler.fs.readFile(packagePath);
   if (packageJson == null) {
@@ -1096,31 +1360,73 @@ function syncPackageExports(compiler, packagePath, paths) {
   }
   return { changed: result.changed, conflicts: result.conflicts };
 }
+function styledSystemExports(compiler, base, styledDir) {
+  const rel = (path) => toPosixRelative(base, path);
+  const find = (dir, names) => names.map((name) => compiler.path.join([dir, name])).find((path) => compiler.fs.readFile(path) != null);
+  const entries = {};
+  for (const category of STYLED_SYSTEM_CATEGORIES) {
+    if (SINGLE_FILE_CATEGORIES.has(category)) {
+      const runtime2 = find(styledDir, [`${category}.mjs`, `${category}.js`, `${category}.ts`]);
+      if (!runtime2) continue;
+      const types2 = find(styledDir, [`${category}.d.mts`, `${category}.d.ts`]);
+      entries[`./${category}`] = types2 ? { types: rel(types2), default: rel(runtime2) } : rel(runtime2);
+      continue;
+    }
+    const dir = compiler.path.join([styledDir, category]);
+    const runtime = find(dir, ["index.mjs", "index.js", "index.ts"]);
+    if (!runtime) continue;
+    const types = find(dir, ["index.d.mts", "index.d.ts"]);
+    entries[`./${category}`] = types ? { types: rel(types), default: rel(runtime) } : rel(runtime);
+    if (DEEP_IMPORT_CATEGORIES.has(category)) {
+      const runtimeExt = runtime.endsWith(".mjs") ? "mjs" : runtime.endsWith(".ts") ? "ts" : "js";
+      const runtimeGlob = `${rel(dir)}/*.${runtimeExt}`;
+      const typesGlob = types ? `${rel(dir)}/*.${types.endsWith(".d.mts") ? "d.mts" : "d.ts"}` : void 0;
+      entries[`./${category}/*`] = typesGlob ? { types: typesGlob, default: runtimeGlob } : runtimeGlob;
+    }
+  }
+  return entries;
+}
 function stabilizePath(cwd, file) {
   const relativePath = toRelativeKey(file, cwd);
   return relativePath && !relativePath.startsWith("..") ? relativePath : file;
 }
-function designSystemArtifactSnapshot(compiler, loaded) {
+function designSystemArtifactSnapshot(loaded) {
   return JSON.stringify(
-    loaded.metadata?.designSystem?.map((ds) => ({
-      name: ds.name,
-      specifier: ds.specifier,
-      manifest: ds.manifest,
-      manifestPath: ds.manifestPath,
-      buildInfoPath: ds.buildInfoPath,
-      buildInfo: compiler.fs.readFile(ds.buildInfoPath) ?? "",
-      files: ds.files,
-      tokenPaths: ds.tokenPaths
-    })) ?? []
+    loaded.metadata?.designSystem?.map((ds) => {
+      const presetPath = resolvePath(dirname2(ds.manifestPath), ds.manifest.preset);
+      return {
+        name: ds.name,
+        specifier: ds.specifier,
+        manifest: ds.manifest,
+        manifestPath: ds.manifestPath,
+        buildInfoPath: ds.buildInfoPath,
+        manifestStamp: diskFileStamp(ds.manifestPath),
+        buildInfoStamp: diskFileStamp(ds.buildInfoPath),
+        presetStamp: diskFileStamp(presetPath),
+        files: ds.files,
+        tokenPaths: ds.tokenPaths
+      };
+    }) ?? []
   );
 }
+function diskFileStamp(path) {
+  try {
+    const stat = statSync(path);
+    return `${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return "missing";
+  }
+}
 function realpathIfExists(compiler, path) {
   return compiler.fs.exists(path) ? compiler.path.realpath(path) : path;
 }
-function inferDesignSystemLibFiles(compiler, cwd, outRoot, buildInfo) {
+function designSystemFilesCwd(compiler, manifestPath) {
+  return compiler.path.resolve(compiler.path.join([compiler.path.dirname(manifestPath), ".."]));
+}
+function inferDesignSystemLibFiles(compiler, cwd, filesBase, buildInfo) {
   const files = Object.keys(buildInfo.modules).filter((key) => !key.startsWith("buildinfo:")).map((key) => {
     const file = compiler.path.resolve(key, cwd);
-    return toPosixRelative(outRoot, file);
+    return toPosixRelative(filesBase, file);
   });
   return files.length > 0 ? [...new Set(files)] : DEFAULT_DESIGN_SYSTEM_LIB_FILES;
 }
@@ -1159,15 +1465,27 @@ function getBindingInfo() {
     native: binding !== fallback
   };
 }
+function assertNativeBinding(callbacks, hooks) {
+  if (binding !== fallback) return;
+  const needed = ["pattern.transform", "utility.transform"].filter(
+    (key) => Object.keys(callbacks[key] ?? {}).length > 0
+  );
+  if (hooks?.["parser:before"]?.length) needed.push("parser:before");
+  if (needed.length === 0) return;
+  throw new Error(
+    `Could not load the native @pandacss/compiler binding for ${process.platform}-${process.arch}, which ${needed.join(", ")} callbacks require. Reinstall your dependencies to fetch the platform package, or open an issue if your platform is unsupported.`
+  );
+}
 function build(config, callbacks, options) {
   assertProjectCallbacks(config, callbacks);
   assertProjectHooks(options?.hooks, callbacks);
   if (!nativeCompilerFromConfig) {
     throw new Error("createCompiler is not available in this binding");
   }
+  assertNativeBinding(callbacks, options?.hooks);
   const prepared = prepareCompilerConfig(config);
   const compiler = nativeCompilerFromConfig(prepared, toNativeOptions(options), createUtilityValuesCallbacks(callbacks));
-  registerCallbacks(compiler, callbacks, options?.hooks, compiler.token_dictionary?.());
+  registerCallbacks(compiler, callbacks, options?.hooks, compiler.tokenDictionary?.());
   attachFileSystem(compiler);
   attachPathSystem(compiler);
   attachBuildInfo(compiler);
@@ -1252,12 +1570,7 @@ function toNativeOptions(options) {
 function createUtilityValuesCallbacks(callbacks) {
   const utilityValues = callbacks["utility.values"];
   if (!utilityValues || Object.keys(utilityValues).length === 0) return void 0;
-  return Object.fromEntries(
-    Object.entries(utilityValues).map(([id, callback]) => [
-      id,
-      (tokenDictionary) => callback((category) => getTokenCategoryValues(category, tokenDictionary))
-    ])
-  );
+  return utilityValues;
 }
 
 export {