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

package/dist/tooling/index.js

@@ -0,0 +1,1047 @@
+// src/tooling/create-project.ts
+import { defaultConfig } from "@pandacss/compiler-shared";
+import { loadConfig } from "@pandacss/config";
+
+// src/design-system.ts
+import "@pandacss/compiler-shared";
+import { readPandaVersion } from "@pandacss/config";
+function hydrateDesignSystem(compiler, chain, consumerTokenPaths = []) {
+  if (!chain || chain.length === 0) {
+    return [];
+  }
+  const pandaVersion = readPandaVersion();
+  const diagnostics = [];
+  for (const ds of chain) {
+    diagnostics.push(...hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths));
+  }
+  return diagnostics;
+}
+function hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths) {
+  const compat = compiler.designSystem.validate(ds.manifest, { pandaVersion });
+  if (!compat.ok) {
+    throw incompatibleManifestError(compiler, ds, compat.reason, pandaVersion);
+  }
+  const diagnostics = hydrateArtifacts(compiler, ds, pandaVersion);
+  diagnostics.push(...tokenConflictDiagnostics(ds, consumerTokenPaths));
+  return diagnostics;
+}
+function hydrateArtifacts(compiler, ds, pandaVersion) {
+  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 });
+  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 [];
+  }
+  return compiler.scan({ include: ds.files, cwd: compiler.path.dirname(ds.manifestPath) });
+}
+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,
+  getTokenCategoryValues,
+  inspectFile,
+  inspectFiles,
+  mergeCallbacks,
+  mergeHooks,
+  prepareCompilerConfig
+} from "@pandacss/compiler-shared";
+
+// src/callbacks.ts
+import {
+  createPatternHelpers,
+  createTransformArgs,
+  getPatternDefaultValueRefsByTransformId,
+  mergePatternDefaultValues
+} 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();
+  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, createPatternHelpers());
+      });
+    }
+  }
+  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, createTransformArgs(original, tokenDictionary));
+      });
+    }
+  }
+  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;
+  }
+  clear() {
+  }
+  scan() {
+    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;
+  }
+  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, needsCva: false, needsSva: 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 emptyWriteFilesResult(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();
+  }
+  getSplitCss(_options) {
+    return [];
+  }
+  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 emptyWriteFilesResult(root) {
+  return {
+    root,
+    paths: [],
+    files: []
+  };
+}
+
+// src/load-binary.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var bindingUrl = new URL("../binding.cjs", import.meta.url);
+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() {
+  if (bindingUrl.protocol === "file:") {
+    const bindingPath = fileURLToPath(bindingUrl);
+    if (existsSync(bindingPath)) return bindingPath;
+  }
+  return fallbackBindingPaths().find((path) => existsSync(path));
+}
+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 build(config, callbacks, options) {
+  assertProjectCallbacks(config, callbacks);
+  assertProjectHooks(options?.hooks, callbacks);
+  if (!nativeCompilerFromConfig) {
+    throw new Error("createCompiler is not available in this binding");
+  }
+  const prepared = prepareCompilerConfig(config);
+  const compiler = nativeCompilerFromConfig(prepared, toNativeOptions(options), createUtilityValuesCallbacks(callbacks));
+  registerCallbacks(compiler, callbacks, options?.hooks, compiler.token_dictionary?.());
+  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 Object.fromEntries(
+    Object.entries(utilityValues).map(([id, callback]) => [
+      id,
+      (tokenDictionary) => callback((category) => getTokenCategoryValues(category, tokenDictionary))
+    ])
+  );
+}
+
+// src/tooling/create-project.ts
+function createProjectFromLoadedConfig(loaded) {
+  const compiler = createCompilerFromSnapshot({
+    config: loaded.config,
+    callbacks: loaded.callbacks,
+    hooks: loaded.hooks
+  });
+  const designSystemDiagnostics = hydrateDesignSystem(
+    compiler,
+    loaded.metadata?.designSystem,
+    loaded.metadata?.userTokenPaths ?? []
+  );
+  return {
+    compiler,
+    configPath: loaded.path,
+    dependencies: loaded.dependencies,
+    outdir: loaded.config.outdir ?? defaultConfig.outdir,
+    designSystemDiagnostics
+  };
+}
+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 { watch } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { findConfig } from "@pandacss/config";
+var ProjectRegistry = class {
+  #projects = /* @__PURE__ */ new Map();
+  #watchers = /* @__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, [resolvedPath]);
+    const project = this.#createProject(key);
+    project.then(
+      (resolved) => {
+        if (resolvedPath && this.#projects.get(cacheKey) === project) {
+          this.#watch(cacheKey, [resolvedPath, ...resolved.dependencies]);
+        }
+      },
+      () => this.#evict(cacheKey)
+    );
+    this.#projects.set(cacheKey, project);
+    return project;
+  }
+  // Coarse: wipes the whole cache regardless of which paths changed.
+  invalidate(_changedPaths = []) {
+    for (const watchers of this.#watchers.values()) {
+      for (const watcher of watchers) watcher.close();
+    }
+    this.#watchers.clear();
+    this.#projects.clear();
+  }
+  // Watches directories (not individual files) — editors that save via atomic
+  // rename/replace can otherwise silently stop notifying a file-level watcher.
+  #watch(cacheKey, paths) {
+    this.#closeWatchers(cacheKey);
+    const filesByDir = /* @__PURE__ */ new Map();
+    for (const path of new Set(paths)) {
+      const dir = dirname2(path);
+      if (!filesByDir.has(dir)) filesByDir.set(dir, /* @__PURE__ */ new Set());
+      filesByDir.get(dir)?.add(path);
+    }
+    const watchers = [];
+    for (const [dir, filesInDir] of filesByDir) {
+      try {
+        watchers.push(
+          watch(dir, (_event, filename) => {
+            if (filename && filesInDir.has(join2(dir, filename))) this.#evict(cacheKey);
+          })
+        );
+      } catch {
+      }
+    }
+    this.#watchers.set(cacheKey, watchers);
+  }
+  #closeWatchers(cacheKey) {
+    for (const watcher of this.#watchers.get(cacheKey) ?? []) watcher.close();
+  }
+  #evict(cacheKey) {
+    this.#closeWatchers(cacheKey);
+    this.#watchers.delete(cacheKey);
+    this.#projects.delete(cacheKey);
+  }
+};
+function resolveConfigPath(key) {
+  try {
+    return 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
+};