@pandacss/compiler 2.0.0-beta.8 → 2.0.0

package/dist/tooling/index.js

@@ -0,0 +1,1236 @@
+// src/tooling/create-project.ts
+import { defaultConfig } from "@pandacss/compiler-shared";
+import {
+  collectExportMissingDiagnostics,
+  collectNameCollisionDiagnostics,
+  loadConfig
+} from "@pandacss/config";
+
+// 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 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/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";
+var binding = loadNativeBinding() ?? fallback;
+var nativeCompilerFromConfig = "fromConfig" in binding.Compiler && typeof binding.Compiler.fromConfig === "function" ? binding.Compiler.fromConfig.bind(binding.Compiler) : void 0;
+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 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;
+}
+
+// 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 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
+  };
+}
+async function createProjectFromConfig(key) {
+  const loaded = await loadConfig({ cwd: key.cwd, file: key.configPath });
+  return createProjectFromLoadedConfig(loaded);
+}
+
+// src/tooling/inspector.ts
+var FileInspector = class {
+  #entries = /* @__PURE__ */ new WeakMap();
+  inspect(compiler, path, source) {
+    let byPath = this.#entries.get(compiler);
+    if (!byPath) {
+      byPath = /* @__PURE__ */ new Map();
+      this.#entries.set(compiler, byPath);
+    }
+    const sourceKey = sourceCacheKey(source);
+    const cached = byPath.get(path);
+    if (cached?.sourceKey === sourceKey) return cached.result;
+    const result = compiler.inspectFile({ path, source });
+    byPath.set(path, { sourceKey, result });
+    return result;
+  }
+  clear(compiler) {
+    if (compiler) {
+      this.#entries.delete(compiler);
+      return;
+    }
+    this.#entries = /* @__PURE__ */ new WeakMap();
+  }
+};
+function sourceCacheKey(source) {
+  let hash = 2166136261;
+  for (let i = 0; i < source.length; i++) {
+    hash ^= source.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${source.length}:${hash >>> 0}`;
+}
+
+// src/tooling/registry.ts
+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));
+  }
+  getProject(key) {
+    const resolvedPath = resolveConfigPath(key);
+    const cacheKey = resolvedPath ?? syntheticKey(key);
+    const cached = this.#projects.get(cacheKey);
+    if (cached) return cached;
+    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, key.cwd, [resolvedPath, ...resolved.dependencies]);
+        }
+      },
+      () => this.#evict(cacheKey)
+    );
+    this.#projects.set(cacheKey, project);
+    return project;
+  }
+  invalidate(_changedPaths = []) {
+    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();
+  }
+  // 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 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(normalized);
+    }
+    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 || 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 canonicalPath(findConfig({ cwd: key.cwd, file: key.configPath }));
+  } catch {
+    return void 0;
+  }
+}
+function syntheticKey(key) {
+  return `${key.cwd}\0${key.configPath ?? ""}`;
+}
+
+// src/tooling/spec-index.ts
+var SpecIndex = class {
+  spec;
+  #categoryByProperty;
+  #literalsByProperty;
+  constructor(spec) {
+    this.spec = spec;
+    this.#categoryByProperty = buildCategoryByProperty(spec);
+    this.#literalsByProperty = buildLiteralsByProperty(spec);
+  }
+  resolveTokenValue(path) {
+    return this.spec.tokens.values[path];
+  }
+  resolveTokenPaths(prefix = "") {
+    const paths = Object.keys(this.spec.tokens.values);
+    return prefix ? paths.filter((path) => path.startsWith(prefix)) : paths;
+  }
+  resolveTokenDeprecation(path) {
+    return this.spec.tokens.deprecated[path];
+  }
+  hasCondition(name) {
+    return this.spec.conditions.keys.includes(name);
+  }
+  /** Bare style-object keys: named/custom conditions plus breakpoints (`sm`, `md`, ...). */
+  resolveStyleObjectKeys() {
+    return [.../* @__PURE__ */ new Set([...this.spec.conditions.keys, ...this.spec.conditions.breakpoints])];
+  }
+  // `property` may be a canonical utility name or one of its shorthands.
+  resolveTokenCategoryForProperty(property) {
+    return this.#categoryByProperty.get(property);
+  }
+  // Populated for fixed-literal utilities (e.g. `scrollbar: 'visible' | 'hidden'`) instead of a token category.
+  resolveLiteralsForProperty(property) {
+    return this.#literalsByProperty.get(property);
+  }
+  resolveKeyframeNames(prefix = "") {
+    const names = this.spec.keyframes.keys;
+    return prefix ? names.filter((name) => name.startsWith(prefix)) : names;
+  }
+  /** Token category names actually present in this config (`colors`, `spacing`, ...). */
+  resolveTokenCategories(prefix = "") {
+    const names = Object.keys(this.spec.tokens.categories);
+    return prefix ? names.filter((name) => name.startsWith(prefix)) : names;
+  }
+};
+function buildCategoryByProperty(spec) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [name, property] of Object.entries(spec.utilities.properties)) {
+    if (property.tokenCategory) map.set(name, property.tokenCategory);
+  }
+  for (const [shorthand, canonical] of Object.entries(spec.utilities.shorthands)) {
+    const category = map.get(canonical);
+    if (category) map.set(shorthand, category);
+  }
+  return map;
+}
+function buildLiteralsByProperty(spec) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [name, property] of Object.entries(spec.utilities.properties)) {
+    if (property.literals.length > 0) map.set(name, property.literals);
+  }
+  for (const [shorthand, canonical] of Object.entries(spec.utilities.shorthands)) {
+    const literals = map.get(canonical);
+    if (literals) map.set(shorthand, literals);
+  }
+  return map;
+}
+
+// src/tooling/config-tokens.ts
+var TOKEN_REF_PATTERN = /\{([a-zA-Z0-9_.]+)\}/g;
+function findConfigTokenRefs(text) {
+  const refs = [];
+  for (const match of text.matchAll(TOKEN_REF_PATTERN)) {
+    const start = match.index;
+    const path = match[1];
+    const pathStart = start + 1;
+    refs.push({ start, end: start + match[0].length, pathStart, pathEnd: pathStart + path.length, path });
+  }
+  return refs;
+}
+function findConfigTokenRefAt(text, position) {
+  return findConfigTokenRefs(text).find((ref) => position >= ref.start && position <= ref.end);
+}
+function completeConfigTokenPath(prefix, index) {
+  return index.resolveTokenPaths(prefix).filter((path) => index.resolveTokenDeprecation(path) === void 0);
+}
+
+// src/tooling/config-style-object.ts
+var CSS_WIDE_KEYWORDS = ["inherit", "initial", "revert", "revert-layer", "unset"];
+function completeConfigStyleObject(context, index) {
+  const activeProperty = context.propertyPath.find((segment) => isKnownUtilityProperty(segment, index));
+  if (context.cursorKind === "value") {
+    return activeProperty ? completeStyleValue(activeProperty, context.prefix, index) : [];
+  }
+  if (activeProperty) {
+    return completeConditionKey(context.existingKeys, context.prefix, index);
+  }
+  return completeStyleKey(context.existingKeys, context.prefix, index);
+}
+function completeStyleKey(existingKeys, prefix, index) {
+  const used = new Set(existingKeys);
+  const utilityNames = [
+    ...Object.keys(index.spec.utilities.properties),
+    ...Object.keys(index.spec.utilities.shorthands)
+  ];
+  const utilities = utilityNames.filter((name) => !used.has(name) && name.startsWith(prefix)).map((name) => ({ name, kind: "utility" }));
+  const conditions = index.resolveStyleObjectKeys().filter((name) => !used.has(name) && name.startsWith(prefix)).map((name) => ({ name, kind: "condition" }));
+  return [...utilities, ...conditions];
+}
+function completeConditionKey(existingKeys, prefix, index) {
+  const used = new Set(existingKeys);
+  return index.resolveStyleObjectKeys().filter((name) => !used.has(name) && name.startsWith(prefix)).map((name) => ({ name, kind: "condition" }));
+}
+function completeStyleValue(property, prefix, index) {
+  if (!isKnownUtilityProperty(property, index)) return [];
+  const entries = resolvePropertyValues(property, prefix, index);
+  const keywords = CSS_WIDE_KEYWORDS.filter((keyword) => keyword.startsWith(prefix)).map((name) => ({
+    name,
+    kind: "keyword"
+  }));
+  return [...entries, ...keywords];
+}
+function resolvePropertyValues(property, prefix, index) {
+  const category = index.resolveTokenCategoryForProperty(property);
+  if (category === "keyframes") {
+    return index.resolveKeyframeNames(prefix).map((name) => ({ name, kind: "keyframe" }));
+  }
+  if (category) {
+    const categoryPrefix = `${category}.`;
+    return index.resolveTokenPaths(`${categoryPrefix}${prefix}`).filter((path) => index.resolveTokenDeprecation(path) === void 0).map((path) => ({ name: path.slice(categoryPrefix.length), kind: "token" }));
+  }
+  const literals = index.resolveLiteralsForProperty(property);
+  if (literals) {
+    return literals.filter((value) => value.startsWith(prefix)).map((value) => ({ name: value, kind: "literal" }));
+  }
+  return [];
+}
+function isKnownUtilityProperty(property, index) {
+  return property in index.spec.utilities.properties || property in index.spec.utilities.shorthands;
+}
+
+// src/tooling/config-semantic-tokens.ts
+function completeSemanticTokenObject(context, index) {
+  const used = new Set(context.existingKeys);
+  if (context.cursorKind === "category") {
+    return index.resolveTokenCategories(context.prefix).filter((name) => !used.has(name)).map((name) => ({ name, kind: "category" }));
+  }
+  return ["base", ...index.resolveStyleObjectKeys()].filter((name) => !used.has(name) && name.startsWith(context.prefix)).map((name) => ({ name, kind: "condition" }));
+}
+
+// src/tooling/module-resolution.ts
+import { outdirBasename } from "@pandacss/compiler-shared";
+function resolveModuleTarget(specifier, importMap, options) {
+  const outdirBase = outdirBasename(options.outdir);
+  const roots = Object.values(importMap).flat();
+  const usesBareOutdirConvention = roots.some((root) => root === outdirBase || root.startsWith(`${outdirBase}/`));
+  if (!usesBareOutdirConvention) return void 0;
+  if (specifier !== outdirBase && !specifier.startsWith(`${outdirBase}/`)) return void 0;
+  return `./${options.outdir}${specifier.slice(outdirBase.length)}`;
+}
+export {
+  FileInspector,
+  ProjectRegistry,
+  SpecIndex,
+  completeConfigStyleObject,
+  completeConfigTokenPath,
+  completeSemanticTokenObject,
+  createProjectFromConfig,
+  createProjectFromLoadedConfig,
+  findConfigTokenRefAt,
+  findConfigTokenRefs,
+  resolveModuleTarget,
+  sourceCacheKey
+};