@pandacss/compiler 2.0.0-beta.9 → 2.0.0

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import * as _pandacss_compiler_shared from '@pandacss/compiler-shared';
-import { BaseDriver, Diagnostic, DesignSystemWatchTarget, DesignSystemWatchFileKind, SourceChange, DiffConfigResult, CodegenOptions, CompileOptions, CompileOutput, WriteCssOptions, WriteCssResult, WriteLayerCssOptions, WriteSplitCssOptions, WriteFilesResult, SerializedConfig, CompilerOptions, ConfigSnapshot } from '@pandacss/compiler-shared';
+import { BaseDriver, Diagnostic, CodegenOverlay, DesignSystemWatchTarget, DesignSystemWatchFileKind, SourceChange, DiffConfigResult, CodegenOptions, CompileOptions, CompileOutput, WriteCssOptions, WriteCssResult, WriteLayerCssOptions, WriteSplitCssOptions, WriteSplitCssResult, SerializedConfig, CompilerOptions, ConfigSnapshot } from '@pandacss/compiler-shared';
 export * from '@pandacss/compiler-shared';
 export { NativeSourceTransformer, NativeTransformSourceInput, TransformSourceOptions, TransformSourceResult, createUsageReport } from '@pandacss/compiler-shared';
-import { C as CompileInput, T as TraceOptions, N as NativeCompiler } from './types-DsStlLvF.js';
-export { o as CompilerConstructor, e as CssSyntax, j as ExtractDebugResult, E as ExtractedCallsResult, i as ExtractedJsxResult, k as ExtractorSession, l as ExtractorSessionConstructor, b as ImportKind, c as ImportRecord, d as ImportScanResult, a as ImportSpecifier, I as ImportSpecifierKind, J as JsxFramework, h as MatchedImport, M as Matcher, f as Matchers, p as NativeBinding, m as NativeCompilerOptions, n as RawCompiler, R as RawSourceTransformBinding, g as TokenDictionary } from './types-DsStlLvF.js';
+import { C as CompileInput, T as TraceOptions, N as NativeCompiler } from './types-CxQirxMo.js';
+export { n as CompilerConstructor, i as ExtractDebugResult, E as ExtractedCallsResult, h as ExtractedJsxResult, j as ExtractorSession, k as ExtractorSessionConstructor, b as ImportKind, c as ImportRecord, d as ImportScanResult, a as ImportSpecifier, I as ImportSpecifierKind, J as JsxFramework, g as MatchedImport, M as Matcher, e as Matchers, o as NativeBinding, l as NativeCompilerOptions, m as RawCompiler, R as RawSourceTransformBinding, f as TokenDictionary } from './types-CxQirxMo.js';
+import * as _pandacss_config from '@pandacss/config';
 import { LoadConfigResult } from '@pandacss/config';
 
 interface NodeDriverOptions {
@@ -12,6 +13,8 @@ interface NodeDriverOptions {
     configPath?: string;
     /** Override the config's `include` globs (e.g. CLI `--include`). Empty/omitted keeps the config value. */
     include?: string[];
+    /** Record which config or preset defined each entry, for `spec()` provenance. */
+    trackSources?: boolean;
 }
 interface WriteDesignSystemLibOptions {
     outdir?: string;
@@ -19,6 +22,8 @@ interface WriteDesignSystemLibOptions {
     panda?: string;
     minify?: boolean;
     maxWarnings?: number | string;
+    /** An already-written spec file; recorded in lib.json relative to the manifest. */
+    spec?: string;
 }
 interface WriteDesignSystemLibResult {
     manifestPath: string;
@@ -37,25 +42,36 @@ declare class NodeDriver extends BaseDriver {
     #private;
     constructor(options: NodeDriverOptions, loaded: LoadConfigResult);
     get designSystemDiagnostics(): Diagnostic[];
+    protected configSources(): _pandacss_config.ConfigSources | undefined;
+    protected codegenOverlay(): CodegenOverlay | undefined;
     get config(): _pandacss_compiler_shared.SerializedConfig;
     get configPath(): string;
     get configDependencies(): string[];
     designSystemWatchTargets(): DesignSystemWatchTarget[];
     isDesignSystemFile(file: string): DesignSystemWatchFileKind | false;
+    private buildDesignSystemFileKinds;
     syncDesignSystemFileChange(change: SourceChange): Promise<boolean>;
     syncDesignSystemSources(): boolean[];
     reload(): Promise<DiffConfigResult>;
+    /** Re-hydrate when treeshake import set changes. */
+    syncDesignSystemTreeShake(): boolean;
+    protected prepareCssOutput(): void;
     applyChange(change: SourceChange): boolean;
+    private applySourceChange;
+    /** Known files always refresh; unknown project paths must match the source globs. */
+    private admitSourceChange;
+    private recordSourceChange;
     getOutdir(outdir?: string): string;
     writeDesignSystemLib(options?: WriteDesignSystemLibOptions): Promise<WriteDesignSystemLibResult>;
     codegen(options?: CodegenOptions): string[];
     cssgen(options?: CompileOptions): CompileOutput;
     writeCss(options: WriteCssOptions): WriteCssResult;
     writeLayerCss(options: WriteLayerCssOptions): WriteCssResult;
-    writeSplitCss(options?: WriteSplitCssOptions): WriteFilesResult;
+    writeSplitCss(options?: WriteSplitCssOptions): WriteSplitCssResult;
     private runCssgenDone;
     private codegenWithPrepareHooks;
     isConfigFile(file: string): boolean;
+    private buildConfigFilePaths;
     private parseDesignSystemLib;
     private compileDesignSystemPreset;
     private writeDesignSystemLibArtifacts;

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   shutdownTracing,
   startTracing,
   takeTimingsJson
-} from "./chunk-G4RVGB4O.js";
+} from "./chunk-CDATBPPB.js";
 export {
   NodeDriver,
   compile,

package/dist/loader.d.ts

@@ -1,7 +1,7 @@
 import { CompilerOptions } from '@pandacss/compiler-shared';
 import { LoadConfigOptions } from '@pandacss/config';
 export { LoadConfigOptions, LoadConfigResult } from '@pandacss/config';
-import { N as NativeCompiler } from './types-DsStlLvF.js';
+import { N as NativeCompiler } from './types-CxQirxMo.js';
 
 interface LoadCompilerResult {
     /** The compiler built from the loaded config snapshot. */

package/dist/loader.js

@@ -1,6 +1,6 @@
 import {
   createCompilerFromSnapshot
-} from "./chunk-G4RVGB4O.js";
+} from "./chunk-CDATBPPB.js";
 
 // src/loader.ts
 import { loadConfig } from "@pandacss/config";

package/dist/tooling/index.d.ts

@@ -1,5 +1,6 @@
-import { Compiler, Diagnostic, FileInspectionResult, Spec, Deprecation, ImportMapOutput } from '@pandacss/compiler-shared';
+import { Compiler, Diagnostic, FileInspectionResult, Spec, Deprecation } from '@pandacss/compiler-shared';
 import { LoadConfigResult } from '@pandacss/config';
+import { ImportMapOutput } from '@pandacss/types';
 
 interface NativeCompiler extends Compiler {
 }
@@ -16,6 +17,8 @@ interface Project {
     outdir: string;
     /** Non-fatal issues surfaced while hydrating a consumed design-system package. */
     designSystemDiagnostics: Diagnostic[];
+    /** Treeshake import fingerprint (watch sync). */
+    designSystemTreeshakeKey?: string;
 }
 declare function createProjectFromLoadedConfig(loaded: LoadConfigResult): Project;
 declare function createProjectFromConfig(key: ProjectKey): Promise<Project>;

package/dist/tooling/index.js

@@ -1,31 +1,139 @@
 // src/tooling/create-project.ts
 import { defaultConfig } from "@pandacss/compiler-shared";
-import { loadConfig } from "@pandacss/config";
+import {
+  collectExportMissingDiagnostics,
+  collectNameCollisionDiagnostics,
+  loadConfig
+} from "@pandacss/config";
 
 // 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)
+  };
+}
+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 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) {
+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,
@@ -50,7 +158,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",
@@ -80,7 +192,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);
@@ -91,7 +204,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) {
@@ -143,7 +256,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.`]
     });
   }
@@ -175,7 +288,6 @@ import {
   assertProjectCallbacks,
   BuildInfo as BuildInfo2,
   DesignSystem as DesignSystem2,
-  getTokenCategoryValues,
   inspectFile,
   inspectFiles,
   mergeCallbacks,
@@ -185,10 +297,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"];
@@ -198,6 +310,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");
   }
@@ -208,7 +321,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);
       });
     }
   }
@@ -218,7 +331,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 });
       });
     }
   }
@@ -330,11 +443,17 @@ var FallbackCompiler = class _FallbackCompiler {
   removeFile() {
     return false;
   }
+  affectedFiles() {
+    return [];
+  }
   clear() {
   }
   scan() {
     return [];
   }
+  designSystemImportSelections() {
+    return [];
+  }
   realpath(path) {
     return path;
   }
@@ -367,6 +486,9 @@ var FallbackCompiler = class _FallbackCompiler {
   hasLayerDeclaration() {
     return false;
   }
+  stripLayerOrderStatements(css) {
+    return css;
+  }
   spec() {
     return {
       conditions: { keys: [], breakpoints: [], containers: [] },
@@ -393,7 +515,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) {
@@ -421,7 +543,7 @@ var FallbackCompiler = class _FallbackCompiler {
     return emptyWriteCssResult(options.outfile);
   }
   writeSplitCss(options) {
-    return emptyWriteFilesResult(options.outdir ?? "");
+    return emptyWriteSplitCssResult(options.outdir ?? "");
   }
   isEmpty() {
     return true;
@@ -456,8 +578,11 @@ var FallbackCompiler = class _FallbackCompiler {
   getLayerCss(_options) {
     return emptyCompileOutput();
   }
+  getKeyframeCss(_options) {
+    return emptyCompileOutput();
+  }
   getSplitCss(_options) {
-    return [];
+    return { files: [], diagnostics: [] };
   }
   buildInfo = fallbackBuildInfo;
   designSystem = fallbackDesignSystem;
@@ -524,21 +649,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();
@@ -551,13 +675,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")];
@@ -632,15 +764,27 @@ function createCompilerFromSnapshot(snapshot, options) {
   const hooks = mergeHooks(snapshot.hooks, options?.hooks);
   return build(snapshot.config, callbacks, { ...options, hooks });
 }
+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);
@@ -725,32 +869,38 @@ 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;
 }
 
 // src/tooling/create-project.ts
+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
   };
 }
 async function createProjectFromConfig(key) {
@@ -792,12 +942,16 @@ function sourceCacheKey(source) {
 }
 
 // src/tooling/registry.ts
-import { watch } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { realpathSync, unwatchFile, watch, watchFile } from "node:fs";
+import { dirname as dirname2, isAbsolute, join as join2, resolve } from "node:path";
 import { findConfig } from "@pandacss/config";
+var FILE_POLL_INTERVAL_MS = 1e3;
 var ProjectRegistry = class {
   #projects = /* @__PURE__ */ new Map();
   #watchers = /* @__PURE__ */ new Map();
+  #watchedDirs = /* @__PURE__ */ new Map();
+  /** path → listener so `unwatchFile` doesn't clear other registries. */
+  #polledFiles = /* @__PURE__ */ new Map();
   #createProject;
   constructor(options = {}) {
     this.#createProject = options.createProject ?? ((key) => createProjectFromConfig(key));
@@ -807,12 +961,12 @@ var ProjectRegistry = class {
     const cacheKey = resolvedPath ?? syntheticKey(key);
     const cached = this.#projects.get(cacheKey);
     if (cached) return cached;
-    if (resolvedPath) this.#watch(cacheKey, [resolvedPath]);
+    if (resolvedPath) this.#watch(cacheKey, key.cwd, [resolvedPath]);
     const project = this.#createProject(key);
     project.then(
       (resolved) => {
         if (resolvedPath && this.#projects.get(cacheKey) === project) {
-          this.#watch(cacheKey, [resolvedPath, ...resolved.dependencies]);
+          this.#watch(cacheKey, key.cwd, [resolvedPath, ...resolved.dependencies]);
         }
       },
       () => this.#evict(cacheKey)
@@ -820,49 +974,84 @@ var ProjectRegistry = class {
     this.#projects.set(cacheKey, project);
     return project;
   }
-  // Coarse: wipes the whole cache regardless of which paths changed.
   invalidate(_changedPaths = []) {
-    for (const watchers of this.#watchers.values()) {
-      for (const watcher of watchers) watcher.close();
+    for (const cacheKey of [...this.#watchers.keys(), ...this.#polledFiles.keys()]) {
+      this.#closeWatchers(cacheKey);
     }
     this.#watchers.clear();
+    this.#watchedDirs.clear();
+    this.#polledFiles.clear();
     this.#projects.clear();
   }
-  // Watches directories (not individual files) — editors that save via atomic
-  // rename/replace can otherwise silently stop notifying a file-level watcher.
-  #watch(cacheKey, paths) {
-    this.#closeWatchers(cacheKey);
+  // Dir watch + `watchFile` poll; deps are cwd-relative like the driver.
+  #watch(cacheKey, cwd, paths) {
     const filesByDir = /* @__PURE__ */ new Map();
     for (const path of new Set(paths)) {
-      const dir = dirname2(path);
+      const absolute = isAbsolute(path) ? path : resolve(cwd, path);
+      const normalized = canonicalPath(absolute);
+      const dir = dirname2(normalized);
       if (!filesByDir.has(dir)) filesByDir.set(dir, /* @__PURE__ */ new Set());
-      filesByDir.get(dir)?.add(path);
+      filesByDir.get(dir)?.add(normalized);
     }
-    const watchers = [];
+    const watched = this.#watchedDirs.get(cacheKey) ?? /* @__PURE__ */ new Map();
+    const watchers = this.#watchers.get(cacheKey) ?? [];
     for (const [dir, filesInDir] of filesByDir) {
+      const existing = watched.get(dir);
+      if (existing) {
+        for (const file of filesInDir) {
+          if (existing.has(file)) continue;
+          existing.add(file);
+          this.#pollFile(cacheKey, file);
+        }
+        continue;
+      }
+      const tracked = new Set(filesInDir);
       try {
         watchers.push(
           watch(dir, (_event, filename) => {
-            if (filename && filesInDir.has(join2(dir, filename))) this.#evict(cacheKey);
+            if (!filename || tracked.has(join2(dir, filename))) this.#evict(cacheKey);
           })
         );
+        watched.set(dir, tracked);
       } catch {
       }
+      for (const file of tracked) this.#pollFile(cacheKey, file);
     }
+    this.#watchedDirs.set(cacheKey, watched);
     this.#watchers.set(cacheKey, watchers);
   }
+  #pollFile(cacheKey, file) {
+    const polled = this.#polledFiles.get(cacheKey) ?? /* @__PURE__ */ new Map();
+    if (polled.has(file)) return;
+    const listener = () => this.#evict(cacheKey);
+    polled.set(file, listener);
+    this.#polledFiles.set(cacheKey, polled);
+    watchFile(file, { interval: FILE_POLL_INTERVAL_MS }, listener);
+  }
   #closeWatchers(cacheKey) {
     for (const watcher of this.#watchers.get(cacheKey) ?? []) watcher.close();
+    for (const [file, listener] of this.#polledFiles.get(cacheKey) ?? []) {
+      unwatchFile(file, listener);
+    }
+    this.#polledFiles.delete(cacheKey);
   }
   #evict(cacheKey) {
     this.#closeWatchers(cacheKey);
     this.#watchers.delete(cacheKey);
+    this.#watchedDirs.delete(cacheKey);
     this.#projects.delete(cacheKey);
   }
 };
+function canonicalPath(filepath) {
+  try {
+    return realpathSync(filepath);
+  } catch {
+    return filepath;
+  }
+}
 function resolveConfigPath(key) {
   try {
-    return findConfig({ cwd: key.cwd, file: key.configPath });
+    return canonicalPath(findConfig({ cwd: key.cwd, file: key.configPath }));
   } catch {
     return void 0;
   }