@pandacss/compiler 2.0.0-beta.8 → 2.0.0

package/dist/chunk-CDATBPPB.js

@@ -0,0 +1,1588 @@
+// src/index.ts
+import {
+  assertProjectHooks,
+  assertProjectCallbacks,
+  BuildInfo as BuildInfo2,
+  DesignSystem as DesignSystem2,
+  inspectFile,
+  inspectFiles,
+  mergeCallbacks,
+  mergeHooks,
+  prepareCompilerConfig
+} from "@pandacss/compiler-shared";
+
+// src/callbacks.ts
+import {
+  createTransformHelpers,
+  getPatternDefaultValueRefsByTransformId,
+  mergePatternDefaultValues,
+  PATTERN_HELPERS
+} from "@pandacss/compiler-shared";
+function registerCallbacks(project, callbacks, hooks, tokenDictionary) {
+  const utilityTransforms = callbacks["utility.transform"];
+  const hasUtilityTransforms = !!utilityTransforms && Object.keys(utilityTransforms).length > 0;
+  const patternTransforms = callbacks["pattern.transform"];
+  const hasPatternTransforms = !!patternTransforms && Object.keys(patternTransforms).length > 0;
+  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");
+  }
+  if (project.registerPatternTransform && patternTransforms) {
+    for (const [id, callback] of Object.entries(patternTransforms)) {
+      const defaultValueId = patternDefaultValueRefs.get(id);
+      const defaultValue = defaultValueId ? patternDefaultValues?.[defaultValueId] : void 0;
+      project.registerPatternTransform(id, (props) => {
+        const input = props;
+        const nextProps = defaultValue ? mergePatternDefaultValues(defaultValue(input), input) : input;
+        return callback(nextProps, PATTERN_HELPERS);
+      });
+    }
+  }
+  if (hasUtilityTransforms && !project.registerUtilityTransform) {
+    throw new Error("Native project does not support utility.transform callbacks");
+  }
+  if (project.registerUtilityTransform && utilityTransforms) {
+    for (const [id, callback] of Object.entries(utilityTransforms)) {
+      project.registerUtilityTransform(id, (resolved, original) => {
+        return callback(resolved, { raw: original, token, utils });
+      });
+    }
+  }
+  const sourceTransforms = hooks?.["parser:before"];
+  if (sourceTransforms?.length && !project.registerSourceTransform) {
+    throw new Error("Native project does not support parser:before callbacks");
+  }
+  if (project.registerSourceTransform && sourceTransforms) {
+    for (const hook of sourceTransforms) {
+      const callback = callbacks["parser:before"]?.[hook.id];
+      if (!callback) continue;
+      project.registerSourceTransform(hook.id, hook.filter, (filePath, content) => {
+        const result = callback({ filePath: String(filePath), content: String(content), original: String(content) });
+        if (isPromiseLike(result)) {
+          throw new Error(`parser:before callback \`${hook.id}\` must be synchronous`);
+        }
+        return typeof result === "string" ? result : void 0;
+      });
+    }
+  }
+}
+function isPromiseLike(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+
+// src/fallback.ts
+import { BuildInfo, DesignSystem } from "@pandacss/compiler-shared";
+var fallbackBuildInfo = new BuildInfo({
+  serializeBuildInfo: () => ({
+    schemaVersion: -1,
+    panda: "",
+    configFingerprint: "",
+    strings: [],
+    atoms: [],
+    modules: {}
+  }),
+  applyBuildInfo: () => false,
+  buildInfoSchemaVersion: () => -1,
+  configFingerprint: () => ""
+});
+var fallbackDesignSystem = new DesignSystem(
+  {
+    createManifest: (input) => ({ ...input, schemaVersion: -1 }),
+    manifestSchemaVersion: () => -1
+  },
+  fallbackBuildInfo
+);
+var FallbackExtractor = class {
+  extract() {
+    return { calls: [], jsx: [], diagnostics: [] };
+  }
+  extractDebug() {
+    return { imports: [], matched: [], calls: [], jsx: [], diagnostics: [] };
+  }
+  matchImports() {
+    return [];
+  }
+};
+var FallbackCompiler = class _FallbackCompiler {
+  fs = {
+    readFile: (_path) => void 0,
+    exists: (_path) => false
+  };
+  path = {
+    realpath: (path) => path,
+    resolve: (path, cwd) => this.resolvePath(path, cwd),
+    join: (parts) => this.joinPath(parts),
+    dirname: (path) => this.dirname(path)
+  };
+  static fromConfig() {
+    return new _FallbackCompiler();
+  }
+  serializeBuildInfo() {
+    return fallbackBuildInfo.create({ panda: "" });
+  }
+  applyBuildInfo() {
+    return false;
+  }
+  buildInfoSchemaVersion() {
+    return -1;
+  }
+  configFingerprint() {
+    return "";
+  }
+  createDesignSystemManifest(input) {
+    return { ...input, schemaVersion: -1 };
+  }
+  designSystemManifestSchemaVersion() {
+    return -1;
+  }
+  config() {
+    return {};
+  }
+  extractFileSource() {
+    return { calls: [], jsx: [], diagnostics: [] };
+  }
+  parseFile(path) {
+    return { path, cssCalls: 0, cvaCalls: 0, svaCalls: 0, jsxUsages: 0, diagnostics: [] };
+  }
+  parseFileSource(path) {
+    return { path, cssCalls: 0, cvaCalls: 0, svaCalls: 0, jsxUsages: 0, diagnostics: [] };
+  }
+  refreshFile() {
+    return false;
+  }
+  refreshFileSource() {
+    return false;
+  }
+  removeFile() {
+    return false;
+  }
+  affectedFiles() {
+    return [];
+  }
+  clear() {
+  }
+  scan() {
+    return [];
+  }
+  designSystemImportSelections() {
+    return [];
+  }
+  realpath(path) {
+    return path;
+  }
+  readFile(_path) {
+    return void 0;
+  }
+  exists(_path) {
+    return false;
+  }
+  resolvePath(path, cwd) {
+    if (!cwd || path.startsWith("/")) return path;
+    return `${cwd.replace(/\/$/, "")}/${path}`;
+  }
+  joinPath(parts) {
+    return parts.filter(Boolean).join("/");
+  }
+  dirname(path) {
+    const index = path.lastIndexOf("/");
+    return index <= 0 ? "" : path.slice(0, index);
+  }
+  isSourceFile() {
+    return false;
+  }
+  parseFiles(_paths) {
+    return [];
+  }
+  layers() {
+    return { reset: "reset", base: "base", tokens: "tokens", recipes: "recipes", utilities: "utilities" };
+  }
+  hasLayerDeclaration() {
+    return false;
+  }
+  stripLayerOrderStatements(css) {
+    return css;
+  }
+  spec() {
+    return {
+      conditions: { keys: [], breakpoints: [], containers: [] },
+      tokens: { categories: {}, colorPalettes: [], values: {}, deprecated: {} },
+      utilities: { properties: {}, shorthands: {}, deprecated: {} },
+      keyframes: { keys: [] },
+      patterns: {},
+      recipes: {},
+      slotRecipes: {},
+      propertyOrder: []
+    };
+  }
+  sources() {
+    return [];
+  }
+  inspectFileSource(_path, _source) {
+    return { usages: [], diagnostics: [], calls: [], jsx: [], tokenRefs: [], componentEntries: [], styleEntries: [] };
+  }
+  transformSource(input) {
+    return {
+      code: input.source,
+      map: null,
+      changed: false,
+      bailed: false,
+      diagnostics: [],
+      dependencies: [],
+      helper: { needsCx: false, needsAttachRecipe: false, needsMemoRecipe: false }
+    };
+  }
+  inspectFile(input) {
+    return { ...this.inspectFileSource(input.path, input.source), path: input.path };
+  }
+  inspectFiles(files) {
+    return { sourceCount: files.length, files: files.map((file) => this.inspectFile(file)) };
+  }
+  resolveUtilityValue() {
+    return null;
+  }
+  suggestTokens() {
+    return [];
+  }
+  suggestSemanticTokens() {
+    return [];
+  }
+  writeArtifacts(_options) {
+    return [];
+  }
+  writeCss(options) {
+    return emptyWriteCssResult(options.outfile);
+  }
+  writeLayerCss(options) {
+    return emptyWriteCssResult(options.outfile);
+  }
+  writeSplitCss(options) {
+    return emptyWriteSplitCssResult(options.outdir ?? "");
+  }
+  isEmpty() {
+    return true;
+  }
+  atoms() {
+    return [];
+  }
+  recipes() {
+    return [];
+  }
+  slotRecipes() {
+    return [];
+  }
+  encodedRecipes() {
+    return { base: [], variants: [], atomic: [] };
+  }
+  staticPatternAtoms() {
+    return { atoms: [], diagnostics: [] };
+  }
+  getFile() {
+    return null;
+  }
+  fileManifest() {
+    return [];
+  }
+  summary() {
+    return { filesProcessed: 0, atomCount: 0, recipeCount: 0, slotRecipeCount: 0 };
+  }
+  compile() {
+    return emptyCompileOutput();
+  }
+  getLayerCss(_options) {
+    return emptyCompileOutput();
+  }
+  getKeyframeCss(_options) {
+    return emptyCompileOutput();
+  }
+  getSplitCss(_options) {
+    return { files: [], diagnostics: [] };
+  }
+  buildInfo = fallbackBuildInfo;
+  designSystem = fallbackDesignSystem;
+  generateArtifacts() {
+    return [];
+  }
+  generateArtifact() {
+    return void 0;
+  }
+  generateAffectedArtifacts() {
+    return [];
+  }
+  diagnostics() {
+    return [];
+  }
+};
+var fallback = {
+  startTracing() {
+    return false;
+  },
+  flushTracing() {
+  },
+  takeTimingsJson() {
+    return void 0;
+  },
+  shutdownTracing() {
+    return false;
+  },
+  compile() {
+    return emptyCompileOutput();
+  },
+  scanImports() {
+    return { imports: [], diagnostics: [] };
+  },
+  matchImports() {
+    return [];
+  },
+  extractCalls() {
+    return { calls: [], diagnostics: [] };
+  },
+  extractJsx() {
+    return { jsx: [], diagnostics: [] };
+  },
+  extract() {
+    return { calls: [], jsx: [], diagnostics: [] };
+  },
+  extractDebug() {
+    return { imports: [], matched: [], calls: [], jsx: [], diagnostics: [] };
+  },
+  Extractor: FallbackExtractor,
+  Compiler: FallbackCompiler
+};
+function emptyCompileOutput() {
+  return {
+    css: "",
+    manifest: { files: [], tokens: [] },
+    layerRanges: {},
+    diagnostics: []
+  };
+}
+function emptyWriteCssResult(path) {
+  return {
+    path,
+    ...emptyCompileOutput()
+  };
+}
+function emptyWriteSplitCssResult(root) {
+  return {
+    root,
+    paths: [],
+    files: [],
+    diagnostics: []
+  };
+}
+
+// src/load-binary.ts
+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();
+  if (!bindingPath) return void 0;
+  const require2 = createRequire(bindingPath);
+  try {
+    return require2(bindingPath);
+  } catch (error) {
+    if (!isWebContainer()) throw error;
+    return loadWebContainerBinding(require2, bindingPath, error);
+  }
+}
+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")];
+  if (isCompilerPackageRoot(cwd)) {
+    paths.unshift(join(cwd, "binding.cjs"));
+  }
+  return paths;
+}
+function isCompilerPackageRoot(cwd) {
+  try {
+    const packageJson = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    return packageJson.name === "@pandacss/compiler";
+  } catch {
+    return false;
+  }
+}
+function isWebContainer() {
+  const versions = process.versions;
+  return Boolean(versions.webcontainer);
+}
+function resolveWebContainerBinding(version, root = "/tmp") {
+  const baseDir = join(root, `pandacss-compiler-${version}`);
+  return {
+    baseDir,
+    bindingPackage: `${webContainerWasiPackage}@${version}`,
+    bindingEntry: join(baseDir, "node_modules", webContainerWasiPackage, "compiler.wasi.cjs")
+  };
+}
+function loadWebContainerBinding(require2, bindingPath, nativeError) {
+  const version = readCompilerVersion(require2, dirname(bindingPath));
+  const { baseDir, bindingPackage, bindingEntry } = resolveWebContainerBinding(version);
+  if (!existsSync(bindingEntry)) {
+    rmSync(baseDir, { recursive: true, force: true });
+    mkdirSync(baseDir, { recursive: true });
+    execFileSync("pnpm", ["i", bindingPackage], {
+      cwd: baseDir,
+      stdio: "inherit"
+    });
+  }
+  try {
+    return require2(bindingEntry);
+  } catch (fallbackError) {
+    throw new Error("Failed to load @pandacss/compiler WebContainer WASI fallback", {
+      cause: chainError(nativeError, fallbackError)
+    });
+  }
+}
+function readCompilerVersion(require2, packageRoot) {
+  try {
+    const packageJsonPath = require2.resolve("@pandacss/compiler/package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson.version;
+  } catch {
+    const packageJson = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+    return packageJson.version;
+  }
+}
+function chainError(primary, cause) {
+  if (primary instanceof Error) {
+    primary.cause = cause;
+    return primary;
+  }
+  return cause;
+}
+
+// src/index.ts
+import { createUsageReport } from "@pandacss/compiler-shared";
+
+// src/driver.ts
+import {
+  BaseDriver,
+  collectParseDiagnostics,
+  diagnosticsPass,
+  fromCodegenPrepareArtifacts,
+  normalizeDiagnostics
+} from "@pandacss/compiler-shared";
+import {
+  buildCodegenOverlay,
+  compilePreset,
+  defaultImportMap,
+  diffConfig,
+  filterPublishableLibFiles,
+  loadConfig as loadConfig2,
+  mergeExcludes,
+  readPackageIdentity,
+  readPandaVersion as readPandaVersion2,
+  resolvePublishedPandaRange,
+  resolveSmartInclude,
+  syncExports,
+  toPosixRelative,
+  toRelativeKey
+} 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 {
+  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 { diagnostics: [], treeshakeKey: "" };
+  }
+  const pandaVersion = readPandaVersion();
+  const diagnostics = [];
+  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,
+    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 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, imports);
+  diagnostics.push(...tokenConflictDiagnostics(ds, consumerTokenPaths));
+  return diagnostics;
+}
+function hydrateArtifacts(compiler, ds, pandaVersion, imports) {
+  if (ds.optionMismatch && ds.optionMismatch.length > 0) {
+    const diagnostic = recoverFromSources(
+      compiler,
+      ds,
+      (sourceCount, severity) => optionMismatchDiagnostic(ds, sourceCount, severity)
+    );
+    return [diagnostic];
+  }
+  let buildInfo;
+  try {
+    const content = compiler.fs.readFile(ds.buildInfoPath);
+    if (content == null) {
+      throw new Error("file not found");
+    }
+    buildInfo = JSON.parse(content);
+  } catch (error) {
+    const issue = { kind: "read", detail: errorMessage(error) };
+    const diagnostic = recoverFromSources(
+      compiler,
+      ds,
+      (sourceCount, severity) => buildInfoDiagnostic(ds, issue, sourceCount, severity)
+    );
+    return [diagnostic];
+  }
+  const result = compiler.designSystem.load(ds.manifest, {
+    buildInfo,
+    pandaVersion,
+    ...imports !== void 0 ? { imports } : {}
+  });
+  if (!result.ok) {
+    const issue = result.reason === "schemaVersion" ? {
+      kind: "schemaVersion",
+      received: buildInfo.schemaVersion,
+      expected: compiler.buildInfo.schemaVersion
+    } : { kind: "corrupt" };
+    const diagnostic = recoverFromSources(
+      compiler,
+      ds,
+      (sourceCount, severity) => buildInfoDiagnostic(ds, issue, sourceCount, severity)
+    );
+    return [diagnostic];
+  }
+  return [];
+}
+function recoverFromSources(compiler, ds, createDiagnostic) {
+  const sources = extractFallbackSources(compiler, ds);
+  const severity = sources.length === 0 ? "error" : "warning";
+  const diagnostic = createDiagnostic(sources.length, severity);
+  if (sources.length === 0) {
+    throw diagnosticError(diagnostic);
+  }
+  compiler.parseFiles(sources);
+  return diagnostic;
+}
+function extractFallbackSources(compiler, ds) {
+  if (ds.files.length === 0) {
+    return [];
+  }
+  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);
+  const outcome = sourceCount > 0 ? ` Re-extracted ${sourceCount} source ${sourceCount === 1 ? "file" : "files"}.` : " No fallback source files were available.";
+  return {
+    code: "design_system_buildinfo_stale",
+    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.`]
+  };
+}
+function buildInfoIssueMessage(issue) {
+  if (issue.kind === "schemaVersion") {
+    return `uses schemaVersion ${formatValue(issue.received)}; expected ${issue.expected}`;
+  }
+  if (issue.kind === "read") {
+    return `could not be read: ${issue.detail}`;
+  }
+  return "is malformed or corrupt";
+}
+function optionMismatchDiagnostic(ds, sourceCount, severity) {
+  const options = ds.optionMismatch?.join(", ") ?? "class-name options";
+  const outcome = sourceCount > 0 ? ` Re-extracted ${sourceCount} source ${sourceCount === 1 ? "file" : "files"} with the consumer options.` : " No fallback source files were available, so the prebuilt class names cannot be used safely.";
+  return {
+    code: "design_system_option_mismatch",
+    severity,
+    category: "designSystem",
+    file: ds.manifestPath,
+    message: `${JSON.stringify(ds.name)} was built with different ${options}.${outcome}`,
+    help: [`Match ${options} with ${JSON.stringify(ds.name)}, or rebuild it with \`panda lib\`.`]
+  };
+}
+function tokenConflictDiagnostics(ds, consumerTokenPaths) {
+  if (consumerTokenPaths.length === 0 || ds.tokenPaths.length === 0) {
+    return [];
+  }
+  const designSystemTokenPaths = new Set(ds.tokenPaths);
+  const conflicts = [...new Set(consumerTokenPaths.filter((path) => designSystemTokenPaths.has(path)))].sort();
+  if (conflicts.length === 0) {
+    return [];
+  }
+  const preview = conflicts.slice(0, 3).map((path) => JSON.stringify(path)).join(", ");
+  const remainder = conflicts.length > 3 ? ` and ${conflicts.length - 3} more` : "";
+  return [
+    {
+      code: "design_system_token_conflict",
+      severity: "info",
+      category: "designSystem",
+      file: ds.manifestPath,
+      message: `${conflicts.length} token ${conflicts.length === 1 ? "path is" : "paths are"} defined by both ${JSON.stringify(ds.name)} and this config (${preview}${remainder}); the local values win.`
+    }
+  ];
+}
+function incompatibleManifestError(compiler, ds, reason, pandaVersion) {
+  if (reason === "schemaVersion") {
+    return diagnosticError({
+      code: "design_system_version_mismatch",
+      severity: "error",
+      category: "designSystem",
+      file: ds.manifestPath,
+      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.`]
+    });
+  }
+  const running = pandaVersion ? `; the consumer uses ${pandaVersion}` : "";
+  return diagnosticError({
+    code: "design_system_peer_range_unsatisfied",
+    severity: "error",
+    category: "designSystem",
+    file: ds.manifestPath,
+    message: `${JSON.stringify(ds.name)} requires Panda ${ds.manifest.panda}${running}.`,
+    help: [`Install a compatible Panda version or update ${JSON.stringify(ds.name)}.`]
+  });
+}
+function diagnosticError(diagnostic) {
+  const error = new Error(diagnostic.message);
+  error.diagnostics = [diagnostic];
+  return error;
+}
+function formatValue(value) {
+  return typeof value === "number" || typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(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 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,
+    designSystemTreeshakeKey: hydrated.treeshakeKey
+  };
+}
+
+// src/driver.ts
+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, trackSources: options.trackSources });
+  if (options.include?.length) applyIncludeOverride(loaded, options.cwd, options.include);
+  return new NodeDriver(options, loaded);
+}
+function applyIncludeOverride(loaded, cwd, include) {
+  const deps = new Set(loaded.dependencies);
+  const resolved = resolveSmartInclude(include, cwd, deps);
+  loaded.config.include = resolved.include;
+  if (resolved.excludes.length > 0) {
+    const existing = Array.isArray(loaded.config.exclude) ? loaded.config.exclude : void 0;
+    loaded.config.exclude = mergeExcludes(existing, resolved.excludes);
+  }
+  loaded.dependencies = Array.from(deps);
+}
+var NodeDriver = class extends BaseDriver {
+  #options;
+  #loaded;
+  #designSystemDiagnostics;
+  #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(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;
+  }
+  get configPath() {
+    return this.#loaded.path;
+  }
+  get configDependencies() {
+    return this.#loaded.dependencies;
+  }
+  designSystemWatchTargets() {
+    return this.#designSystemWatchTargets ??= (this.#loaded.metadata?.designSystem ?? []).map((ds) => {
+      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),
+        buildInfoPath: realpathIfExists(this.compiler, ds.buildInfoPath),
+        presetPath,
+        sourceFiles: [...new Set(sourceFiles)]
+      };
+    });
+  }
+  isDesignSystemFile(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()) {
+      for (const path of [watchTarget.manifestPath, watchTarget.buildInfoPath, watchTarget.presetPath]) {
+        kinds.set(this.compiler.path.realpath(path), "artifact");
+      }
+      for (const path of watchTarget.sourceFiles) {
+        kinds.set(this.compiler.path.realpath(path), "source");
+      }
+    }
+    return kinds;
+  }
+  async syncDesignSystemFileChange(change) {
+    const kind = this.isDesignSystemFile(change.path);
+    if (kind === "artifact") {
+      const diff = await this.reload();
+      if (diff.hasChanged) this.parseFiles();
+      return diff.hasChanged;
+    }
+    if (kind === "source") return this.applySourceChange(change, "design-system");
+    return false;
+  }
+  syncDesignSystemSources() {
+    const changes = [];
+    const activeFiles = new Map(
+      this.compiler.fileManifest().map((file) => [this.compiler.path.realpath(file.path), file.path])
+    );
+    for (const target of this.designSystemWatchTargets()) {
+      for (const path of target.sourceFiles) {
+        const activePath = activeFiles.get(this.compiler.path.realpath(path));
+        if (!activePath) continue;
+        changes.push({ path: activePath, kind: this.compiler.fs.exists(path) ? "change" : "unlink" });
+      }
+    }
+    return this.applyChanges(changes);
+  }
+  async reload() {
+    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(next);
+    const designSystemArtifactsChanged = this.#designSystemArtifactSnapshot !== nextDesignSystemArtifactSnapshot;
+    if (diff.hasChanged || designSystemArtifactsChanged) {
+      this.#loaded = next;
+      const built = createProjectFromLoadedConfig(next);
+      this.setCompiler(built.compiler);
+      this.#designSystemDiagnostics = built.designSystemDiagnostics;
+      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) {
+    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));
+  }
+  async writeDesignSystemLib(options = {}) {
+    if (!this.#loaded.path) {
+      throw new Error(
+        "panda lib requires a resolved config file to compile the design system preset. Run `panda init`, or check --config/--cwd."
+      );
+    }
+    const parsed = this.parseDesignSystemLib();
+    if (!diagnosticsPass(parsed.diagnostics, { maxWarnings: options.maxWarnings }))
+      return skippedDesignSystemLib(parsed);
+    const preset = await this.compileDesignSystemPreset();
+    return this.writeDesignSystemLibArtifacts(options, preset, parsed);
+  }
+  codegen(options) {
+    const outdir = this.getOutdir(options?.outdir);
+    const cwd = options?.cwd ?? this.#options.cwd;
+    const prepareHooks = this.#loaded.hostHooks?.["codegen:prepare"] ?? [];
+    const doneHooks = this.#loaded.hostHooks?.["codegen:done"] ?? [];
+    const files = prepareHooks.length > 0 ? this.codegenWithPrepareHooks(prepareHooks, outdir, cwd, options) : super.codegen(options);
+    for (const entry of doneHooks) {
+      const handler = resolveHookHandler(entry.value, "codegen:done");
+      handler({ files, outdir, cwd });
+    }
+    return files;
+  }
+  cssgen(options) {
+    const output = super.cssgen(options);
+    this.runCssgenDone({
+      artifact: "styles.css",
+      content: output.css,
+      cwd: this.#options.cwd,
+      manifest: output.manifest,
+      layerRanges: output.layerRanges
+    });
+    return output;
+  }
+  writeCss(options) {
+    const result = super.writeCss(options);
+    this.runCssgenDone({
+      artifact: "styles.css",
+      content: result.css,
+      path: result.path,
+      outfile: options.outfile,
+      cwd: options.cwd ?? this.#options.cwd,
+      manifest: result.manifest,
+      layerRanges: result.layerRanges
+    });
+    return result;
+  }
+  writeLayerCss(options) {
+    const result = super.writeLayerCss(options);
+    this.runCssgenDone({
+      artifact: "styles.layer",
+      content: result.css,
+      path: result.path,
+      outfile: options.outfile,
+      cwd: options.cwd ?? this.#options.cwd,
+      manifest: result.manifest,
+      layerRanges: result.layerRanges
+    });
+    return result;
+  }
+  writeSplitCss(options) {
+    const result = super.writeSplitCss(options);
+    const cwd = options?.cwd ?? this.#options.cwd;
+    const outdir = result.root;
+    for (const file of result.files) {
+      const path = this.compiler.path.join([result.root, file.path]);
+      this.runCssgenDone({
+        artifact: "styles.split",
+        content: file.code,
+        path,
+        outdir,
+        cwd
+      });
+    }
+    return result;
+  }
+  runCssgenDone(args) {
+    const hooks = this.#loaded.hostHooks?.["cssgen:done"] ?? [];
+    for (const entry of hooks) {
+      const handler = resolveHookHandler(entry.value, "cssgen:done");
+      handler(args);
+    }
+  }
+  codegenWithPrepareHooks(hooks, outdir, cwd, 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 });
+      if (next !== void 0) {
+        if (!Array.isArray(next)) {
+          throw new Error("Invalid codegen:prepare hook result. Expected an artifact array or undefined.");
+        }
+        artifacts = fromCodegenPrepareArtifacts(next);
+      }
+    }
+    return this.compiler.writeArtifacts({
+      outdir,
+      cwd,
+      forceImportExtension: options?.forceImportExtension,
+      artifacts,
+      overlay
+    });
+  }
+  isConfigFile(file) {
+    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);
+      paths.add(this.compiler.path.realpath(dependencyPath));
+    }
+    return paths;
+  }
+  parseDesignSystemLib() {
+    const parsed = this.parseFiles();
+    const parseDiagnostics = collectParseDiagnostics(parsed, {
+      normalizeFile: (file) => stabilizePath(this.#options.cwd, file)
+    });
+    const diagnostics = normalizeDiagnostics([...parseDiagnostics, ...this.compiler.diagnostics()], {
+      normalizeFile: (file) => stabilizePath(this.#options.cwd, file)
+    });
+    return { parsedFileCount: parsed.length, diagnostics };
+  }
+  async compileDesignSystemPreset() {
+    return this.#designSystemPreset ??= await compilePreset({
+      configPath: this.#loaded.path,
+      cwd: this.#options.cwd
+    });
+  }
+  writeDesignSystemLibArtifacts(options, preset, parsed) {
+    const identity = readPackageIdentity(this.#options.cwd);
+    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 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)
+    });
+    const { files: libFiles, diagnostics: filesDiagnostics } = resolveDesignSystemLibFiles({
+      explicit: options.files,
+      compiler: this.compiler,
+      cwd: this.#options.cwd,
+      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: "./preset.mjs",
+      buildInfo: "./buildinfo.json",
+      spec,
+      importMap: defaultImportMap(identity.name),
+      designSystem: typeof this.config.designSystem === "string" ? this.config.designSystem : void 0,
+      files: libFiles
+    });
+    this.compiler.writeArtifacts({
+      outdir,
+      cwd: this.#options.cwd,
+      artifacts: [
+        {
+          id: "design-system-lib",
+          files: [
+            {
+              path: "panda/lib.json",
+              code: `${JSON.stringify(manifest, null, 2)}
+`,
+              dependencies: []
+            },
+            {
+              path: "panda/buildinfo.json",
+              code: JSON.stringify(buildInfo, null, options.minify ? 0 : 2),
+              dependencies: []
+            },
+            {
+              path: "panda/preset.mjs",
+              code: preset.code,
+              dependencies: []
+            }
+          ]
+        }
+      ]
+    });
+    const { changed: exportsChanged, conflicts } = syncPackageExports(this.compiler, identity.packagePath, {
+      pandaDir,
+      styledDir: this.getOutdir()
+    });
+    return {
+      manifestPath,
+      buildInfoPath,
+      presetPath,
+      exportsChanged,
+      parsedFileCount: parsed.parsedFileCount,
+      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.filesBase, options.buildInfo);
+  const { files, unpublished } = filterPublishableLibFiles({
+    files: inferred,
+    packageRoot: options.packageRoot,
+    outRoot: options.filesBase,
+    publishFiles: options.publishFiles
+  });
+  if (unpublished.length === 0) {
+    return { files, diagnostics: [] };
+  }
+  return {
+    files,
+    diagnostics: [unpublishedLibFilesDiagnostic(options.packageName, unpublished)]
+  };
+}
+function unpublishedLibFilesDiagnostic(name, unpublished) {
+  const sample = unpublished.slice(0, 3).map((path) => JSON.stringify(path)).join(", ");
+  const more = unpublished.length > 3 ? `, and ${unpublished.length - 3} more` : "";
+  return {
+    code: "design_system_files_not_publishable",
+    severity: "warning",
+    category: "designSystem",
+    message: `\`panda lib\` omitted ${unpublished.length === 1 ? "a fallback file" : "fallback files"} from ${JSON.stringify(name)}'s manifest because package.json \`"files"\` would not publish ${sample}${more}. Happy-path consumers still hydrate build info. For dist-only recovery, re-run with \`panda lib --files './**/*.{js,mjs}'\` (or the globs you actually publish).`
+  };
+}
+function exportConflictDiagnostics(name, conflicts) {
+  if (conflicts.length === 0) return [];
+  const paths = conflicts.map((path) => JSON.stringify(path)).join(", ");
+  const plural = conflicts.length > 1;
+  return [
+    {
+      code: "design_system_export_overwritten",
+      severity: "warning",
+      category: "designSystem",
+      message: `\`panda lib\` overwrote the existing ${paths} export${plural ? "s" : ""} in ${JSON.stringify(name)}'s package.json. Restore or rename ${plural ? "them" : "it"} if you still need the previous target${plural ? "s" : ""}.`
+    }
+  ];
+}
+function resolveHookHandler(value, name) {
+  if (typeof value === "function") return value;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid ${name} hook. Expected a function or { filter, handler }.`);
+  }
+  const handler = value.handler;
+  if (typeof handler !== "function") {
+    throw new Error(`Invalid ${name} hook. Expected a function or { filter, handler }.`);
+  }
+  return handler;
+}
+function skippedDesignSystemLib(parsed) {
+  return {
+    manifestPath: "",
+    buildInfoPath: "",
+    presetPath: "",
+    exportsChanged: false,
+    parsedFileCount: parsed.parsedFileCount,
+    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/*": pandaGlob,
+    ...styledSystemExports(compiler, base, paths.styledDir)
+  };
+  const packageJson = compiler.fs.readFile(packagePath);
+  if (packageJson == null) {
+    throw new Error(`Could not read package.json at ${JSON.stringify(packagePath)}.`);
+  }
+  const result = syncExports({ packageJson, entries });
+  if (result.changed) {
+    compiler.writeArtifacts({
+      outdir: base,
+      artifacts: [
+        {
+          id: "design-system-lib-package",
+          files: [{ path: "package.json", code: result.json, dependencies: [] }]
+        }
+      ]
+    });
+  }
+  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(loaded) {
+  return JSON.stringify(
+    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 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(filesBase, file);
+  });
+  return files.length > 0 ? [...new Set(files)] : DEFAULT_DESIGN_SYSTEM_LIB_FILES;
+}
+function toGenerateArtifactOptions(options) {
+  return options?.forceImportExtension === void 0 ? void 0 : { forceImportExtension: options.forceImportExtension };
+}
+
+// src/index.ts
+var binding = loadNativeBinding() ?? fallback;
+var nativeCompilerFromConfig = "fromConfig" in binding.Compiler && typeof binding.Compiler.fromConfig === "function" ? binding.Compiler.fromConfig.bind(binding.Compiler) : void 0;
+function compile(input) {
+  return binding.compile(input);
+}
+function startTracing(options) {
+  return binding.startTracing?.(options) ?? false;
+}
+function flushTracing() {
+  binding.flushTracing?.();
+}
+function takeTimingsJson() {
+  return binding.takeTimingsJson?.() ?? void 0;
+}
+function shutdownTracing() {
+  return binding.shutdownTracing?.() ?? false;
+}
+function createCompiler(config, options) {
+  return build(config, options?.callbacks ?? {}, options);
+}
+function createCompilerFromSnapshot(snapshot, options) {
+  const callbacks = mergeCallbacks(snapshot.callbacks, options?.callbacks);
+  const hooks = mergeHooks(snapshot.hooks, options?.hooks);
+  return build(snapshot.config, callbacks, { ...options, hooks });
+}
+function getBindingInfo() {
+  return {
+    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.tokenDictionary?.());
+  attachFileSystem(compiler);
+  attachPathSystem(compiler);
+  attachBuildInfo(compiler);
+  attachDesignSystem(compiler);
+  attachInspection(compiler);
+  return compiler;
+}
+function attachFileSystem(compiler) {
+  Object.defineProperty(compiler, "fs", {
+    value: {
+      readFile: (path) => compiler.readFile(path),
+      exists: (path) => compiler.exists(path)
+    },
+    enumerable: false,
+    configurable: true
+  });
+}
+function attachPathSystem(compiler) {
+  Object.defineProperty(compiler, "path", {
+    value: {
+      realpath: (path) => compiler.realpath(path),
+      resolve: (path, cwd) => compiler.resolvePath(path, cwd),
+      join: (parts) => compiler.joinPath(parts),
+      dirname: (path) => compiler.dirname(path)
+    },
+    enumerable: false,
+    configurable: true
+  });
+}
+function attachBuildInfo(compiler) {
+  Object.defineProperty(compiler, "buildInfo", {
+    enumerable: false,
+    configurable: true,
+    get() {
+      const api = new BuildInfo2(compiler);
+      Object.defineProperty(compiler, "buildInfo", {
+        value: api,
+        enumerable: false,
+        configurable: true
+      });
+      return api;
+    }
+  });
+}
+function attachDesignSystem(compiler) {
+  Object.defineProperty(compiler, "designSystem", {
+    enumerable: false,
+    configurable: true,
+    get() {
+      const api = new DesignSystem2(toDesignSystemBinding(compiler), compiler.buildInfo);
+      Object.defineProperty(compiler, "designSystem", {
+        value: api,
+        enumerable: false,
+        configurable: true
+      });
+      return api;
+    }
+  });
+}
+function attachInspection(compiler) {
+  Object.defineProperty(compiler, "inspectFile", {
+    enumerable: false,
+    configurable: true,
+    value: (input) => inspectFile(compiler, input)
+  });
+  Object.defineProperty(compiler, "inspectFiles", {
+    enumerable: false,
+    configurable: true,
+    value: (files) => inspectFiles(compiler, files)
+  });
+}
+function toDesignSystemBinding(compiler) {
+  return {
+    createManifest: (input) => compiler.createDesignSystemManifest(input),
+    manifestSchemaVersion: () => compiler.designSystemManifestSchemaVersion()
+  };
+}
+function toNativeOptions(options) {
+  if (!options || options.crossFile === void 0) return void 0;
+  return { crossFile: options.crossFile };
+}
+function createUtilityValuesCallbacks(callbacks) {
+  const utilityValues = callbacks["utility.values"];
+  if (!utilityValues || Object.keys(utilityValues).length === 0) return void 0;
+  return utilityValues;
+}
+
+export {
+  createNodeDriver,
+  NodeDriver,
+  compile,
+  startTracing,
+  flushTracing,
+  takeTimingsJson,
+  shutdownTracing,
+  createCompiler,
+  createCompilerFromSnapshot,
+  getBindingInfo,
+  createUsageReport
+};