@pandacss/compiler 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/chunk-VRB2SXJJ.js

@@ -0,0 +1,1029 @@
+// 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,
+    resolveChain: () => ({ status: "ordered", order: [] })
+  },
+  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;
+  }
+  resolveDesignSystemChain() {
+    return { status: "ordered", order: [] };
+  }
+  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: [] };
+  }
+  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 [];
+  }
+  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() {
+  },
+  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";
+
+// src/driver.ts
+import {
+  BaseDriver,
+  collectParseDiagnostics,
+  diagnosticsPass,
+  normalizeDiagnostics
+} from "@pandacss/compiler-shared";
+import {
+  compilePreset,
+  defaultImportMap,
+  diffConfig,
+  loadConfig,
+  mergeExcludes,
+  readPackageIdentity,
+  resolveSmartInclude,
+  syncExports,
+  toPosixRelative,
+  toRelativeKey
+} 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 = [];
+  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) {
+    if (!tryStaleFallback(compiler, ds, diagnostics)) throw hydrateReadError(ds, error);
+  }
+  if (buildInfo) {
+    const result = compiler.designSystem.load(ds.manifest, { buildInfo, pandaVersion });
+    if (!result.ok && !tryStaleFallback(compiler, ds, diagnostics)) throw hydrateLoadError(ds, result.reason);
+  }
+  diagnostics.push(...tokenConflictDiagnostics(ds, consumerTokenPaths));
+  return diagnostics;
+}
+function tryStaleFallback(compiler, ds, diagnostics) {
+  if (ds.files.length === 0) return false;
+  const sources = compiler.scan({ include: ds.files, cwd: compiler.path.dirname(ds.manifestPath) });
+  if (sources.length === 0) return false;
+  compiler.parseFiles(sources);
+  diagnostics.push({
+    code: "design_system_buildinfo_stale",
+    severity: "warning",
+    category: "designSystem",
+    message: `Re-extracting ${JSON.stringify(ds.name)} from source; rebuild it with \`panda lib\` to restore the fast path.`
+  });
+  return true;
+}
+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();
+  return conflicts.map((path) => ({
+    code: "design_system_token_conflict",
+    severity: "warning",
+    category: "designSystem",
+    message: `Token ${JSON.stringify(path)} is defined by both ${JSON.stringify(ds.name)} and this config; the local value wins.`
+  }));
+}
+function incompatibleManifestError(compiler, ds, reason, pandaVersion) {
+  if (reason === "schemaVersion") {
+    return new Error(
+      `Failed to hydrate designSystem ${JSON.stringify(ds.name)} from ${JSON.stringify(ds.manifestPath)}: manifest schemaVersion ${ds.manifest.schemaVersion} is incompatible with this compiler (expected ${compiler.designSystem.schemaVersion}).`
+    );
+  }
+  const running = pandaVersion ? ` (you are on ${pandaVersion})` : "";
+  return new Error(
+    `Failed to hydrate designSystem ${JSON.stringify(ds.name)}: manifest requires Panda ${ds.manifest.panda}${running}.`
+  );
+}
+function hydrateReadError(ds, error) {
+  return new Error(
+    `Failed to hydrate designSystem ${JSON.stringify(ds.name)} from ${JSON.stringify(ds.buildInfoPath)}: ${errorMessage(error)}`
+  );
+}
+function hydrateLoadError(ds, reason) {
+  return new Error(
+    `Failed to hydrate designSystem ${JSON.stringify(ds.name)} from ${JSON.stringify(ds.buildInfoPath)}: incompatible buildInfo ${reason}.`
+  );
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// 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 loadConfig({ cwd: options.cwd, file: options.configPath });
+  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;
+  constructor(options, loaded) {
+    const built = buildFromConfig(loaded);
+    super(built.compiler);
+    this.#options = options;
+    this.#loaded = loaded;
+    this.#designSystemDiagnostics = built.designSystemDiagnostics;
+    this.#designSystemArtifactSnapshot = designSystemArtifactSnapshot(this.compiler, loaded);
+  }
+  get designSystemDiagnostics() {
+    return this.#designSystemDiagnostics;
+  }
+  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 base = this.compiler.path.dirname(ds.manifestPath);
+      const presetPath = realpathIfExists(this.compiler, this.compiler.path.resolve(ds.manifest.preset, base));
+      const sourceFiles = ds.files.length > 0 ? this.compiler.scan({ include: ds.files, cwd: base }).map((file) => realpathIfExists(this.compiler, file)) : [];
+      return {
+        name: ds.name,
+        manifestPath: realpathIfExists(this.compiler, ds.manifestPath),
+        buildInfoPath: realpathIfExists(this.compiler, ds.buildInfoPath),
+        presetPath,
+        sourceFiles: [...new Set(sourceFiles)]
+      };
+    });
+  }
+  isDesignSystemFile(file) {
+    const target = this.compiler.path.realpath(file);
+    for (const watchTarget of this.#designSystemWatchTargets ?? this.designSystemWatchTargets()) {
+      if ([watchTarget.manifestPath, watchTarget.buildInfoPath, watchTarget.presetPath].some(
+        (path) => this.compiler.path.realpath(path) === target
+      )) {
+        return "artifact";
+      }
+      if (watchTarget.sourceFiles.some((path) => this.compiler.path.realpath(path) === target)) {
+        return "source";
+      }
+    }
+    return false;
+  }
+  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.applyChange(change);
+    return false;
+  }
+  async reload() {
+    const next = await loadConfig({ cwd: this.#options.cwd, file: this.#options.configPath });
+    if (this.#options.include?.length) applyIncludeOverride(next, this.#options.cwd, this.#options.include);
+    const diff = diffConfig(this.#loaded, next);
+    const nextDesignSystemArtifactSnapshot = designSystemArtifactSnapshot(this.compiler, next);
+    const designSystemArtifactsChanged = this.#designSystemArtifactSnapshot !== nextDesignSystemArtifactSnapshot;
+    if (diff.hasChanged || designSystemArtifactsChanged) {
+      this.#loaded = next;
+      const built = buildFromConfig(next);
+      this.setCompiler(built.compiler);
+      this.#designSystemDiagnostics = built.designSystemDiagnostics;
+      this.#designSystemPreset = void 0;
+      this.#designSystemArtifactSnapshot = nextDesignSystemArtifactSnapshot;
+      this.#designSystemWatchTargets = void 0;
+    }
+    return designSystemArtifactsChanged && !diff.hasChanged ? { ...diff, hasChanged: true } : diff;
+  }
+  applyChange(change) {
+    if (change.kind === "unlink") {
+      return this.compiler.removeFile(change.path);
+    }
+    if (change.kind === "change") {
+      if (change.content == null) {
+        if (this.compiler.refreshFile(change.path)) return true;
+        this.compiler.parseFile(change.path);
+        return true;
+      }
+      if (this.compiler.refreshFileSource(change.path, change.content)) return true;
+      this.compiler.parseFileSource(change.path, change.content);
+      return true;
+    }
+    if (change.content == null) {
+      this.compiler.parseFile(change.path);
+      return true;
+    }
+    this.compiler.parseFileSource(change.path, change.content);
+    return true;
+  }
+  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;
+  }
+  codegenWithPrepareHooks(hooks, outdir, cwd, options) {
+    let artifacts = this.compiler.generateArtifacts(toGenerateArtifactOptions(options));
+    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 = next;
+      }
+    }
+    return this.compiler.writeArtifacts({
+      outdir,
+      cwd,
+      forceImportExtension: options?.forceImportExtension,
+      artifacts
+    });
+  }
+  isConfigFile(file) {
+    const target = this.compiler.path.realpath(file);
+    const configPath = this.compiler.path.realpath(this.#loaded.path);
+    if (configPath === target) return true;
+    return this.#loaded.dependencies.some((dependency) => {
+      const dependencyPath = this.compiler.path.resolve(dependency, this.#options.cwd);
+      return this.compiler.path.realpath(dependencyPath) === target;
+    });
+  }
+  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 = options.panda ?? identity.pandaPeer ?? "*";
+    const outdir = options.outdir ?? DEFAULT_DESIGN_SYSTEM_LIB_OUTDIR;
+    const outRoot = this.compiler.path.resolve(outdir);
+    const manifestPath = this.compiler.path.join([outRoot, "panda.lib.json"]);
+    const buildInfoPath = this.compiler.path.join([outRoot, "panda.buildinfo.json"]);
+    const presetPath = this.compiler.path.join([outRoot, "panda.preset.mjs"]);
+    const info = this.compiler.buildInfo.create({ panda: pandaRange });
+    const buildInfo = this.compiler.buildInfo.normalize(info, {
+      mapModuleKey: (key) => toRelativeKey(key, this.#options.cwd)
+    });
+    const manifest = this.compiler.designSystem.create({
+      name: identity.name,
+      version: identity.version,
+      panda: pandaRange,
+      preset: "./panda.preset.mjs",
+      buildInfo: "./panda.buildinfo.json",
+      importMap: defaultImportMap(identity.name),
+      designSystem: typeof this.config.designSystem === "string" ? this.config.designSystem : void 0,
+      files: options.files ?? inferDesignSystemLibFiles(this.compiler, this.#options.cwd, outRoot, buildInfo)
+    });
+    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 exportsChanged = syncPackageExports(this.compiler, identity.packagePath, {
+      manifestPath,
+      presetPath
+    });
+    return {
+      manifestPath,
+      buildInfoPath,
+      presetPath,
+      exportsChanged,
+      parsedFileCount: parsed.parsedFileCount,
+      diagnostics: parsed.diagnostics
+    };
+  }
+};
+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
+  };
+}
+function syncPackageExports(compiler, packagePath, paths) {
+  const base = compiler.path.dirname(packagePath);
+  const entries = {
+    "./panda.lib.json": toPosixRelative(base, paths.manifestPath),
+    "./preset": toPosixRelative(base, paths.presetPath)
+  };
+  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 result.changed;
+}
+function stabilizePath(cwd, file) {
+  const relativePath = toRelativeKey(file, cwd);
+  return relativePath && !relativePath.startsWith("..") ? relativePath : file;
+}
+function buildFromConfig(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, designSystemDiagnostics };
+}
+function designSystemArtifactSnapshot(compiler, loaded) {
+  return JSON.stringify(
+    loaded.metadata?.designSystem?.map((ds) => ({
+      name: ds.name,
+      specifier: ds.specifier,
+      manifest: ds.manifest,
+      manifestPath: ds.manifestPath,
+      buildInfoPath: ds.buildInfoPath,
+      buildInfo: compiler.fs.readFile(ds.buildInfoPath) ?? "",
+      files: ds.files,
+      tokenPaths: ds.tokenPaths
+    })) ?? []
+  );
+}
+function realpathIfExists(compiler, path) {
+  return compiler.fs.exists(path) ? compiler.path.realpath(path) : path;
+}
+function inferDesignSystemLibFiles(compiler, cwd, outRoot, buildInfo) {
+  const files = Object.keys(buildInfo.modules).filter((key) => !key.startsWith("buildinfo:")).map((key) => {
+    const file = compiler.path.resolve(key, cwd);
+    return toPosixRelative(outRoot, file);
+  });
+  return 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 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 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(),
+    resolveChain: (manifests) => compiler.resolveDesignSystemChain(manifests)
+  };
+}
+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))
+    ])
+  );
+}
+
+export {
+  createNodeDriver,
+  NodeDriver,
+  compile,
+  startTracing,
+  flushTracing,
+  shutdownTracing,
+  createCompiler,
+  createCompilerFromSnapshot,
+  getBindingInfo,
+  createUsageReport
+};