@pandacss/compiler-wasm 2.0.0-beta.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Chakra Systems Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# @pandacss/compiler-wasm
+
+The WebAssembly build of the Panda CSS compiler engine, for browser and playground targets where the native
+`@pandacss/compiler` binding can't run.
+
+This package is consumed by Panda tooling; you typically don't install it directly.
+
+## Documentation
+
+Visit the [Panda CSS documentation](https://panda-css.com) to learn more.
+
+## License
+
+MIT © [Chakra Systems Inc.](https://github.com/chakra-ui)

package/dist/chunk-R2J25HLY.js

@@ -0,0 +1,108 @@
+// src/web.ts
+import {
+  assertProjectCallbacks,
+  assertProjectHooks,
+  getTokenCategoryValues,
+  makeBuildInfoApi,
+  mergeCallbacks,
+  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"];
+  if (utilityTransforms && Object.keys(utilityTransforms).length > 0 && !project.registerUtilityTransform) {
+    throw new Error("WASM project does not support utility.transform callbacks");
+  }
+  if (project.registerUtilityTransform && utilityTransforms && Object.keys(utilityTransforms).length > 0) {
+    for (const [id, callback] of Object.entries(utilityTransforms)) {
+      project.registerUtilityTransform(id, (resolved, original) => {
+        return callback(resolved, createTransformArgs(original, tokenDictionary));
+      });
+    }
+  }
+  const patternTransforms = callbacks["pattern.transform"];
+  if (patternTransforms && Object.keys(patternTransforms).length > 0 && !project.registerPatternTransform) {
+    throw new Error("WASM project does not support pattern.transform callbacks");
+  }
+  const config = project.config();
+  const patternDefaultValues = callbacks["pattern.defaultValues"];
+  const patternDefaultValueRefs = config && patternDefaultValues ? getPatternDefaultValueRefsByTransformId(config) : /* @__PURE__ */ new Map();
+  if (project.registerPatternTransform && patternTransforms && Object.keys(patternTransforms).length > 0) {
+    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());
+      });
+    }
+  }
+  const sourceTransforms = hooks?.["parser:before"];
+  if (sourceTransforms?.length && !project.registerSourceTransform) {
+    throw new Error("WASM 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/web.ts
+function createCompilerFromWasmModule(mod, config, options) {
+  return build(mod, config, options?.callbacks ?? {}, options?.hooks);
+}
+function build(mod, config, callbacks, hooks) {
+  const fs = new mod.WasmFileSystem();
+  assertProjectCallbacks(config, callbacks);
+  assertProjectHooks(hooks, callbacks);
+  const prepared = prepareCompilerConfig(config);
+  const compiler = mod.WasmCompiler.fromConfig(fs, prepared, buildFromConfigOptions(callbacks));
+  registerCallbacks(compiler, callbacks, hooks, compiler.token_dictionary?.());
+  compiler.fs = fs;
+  Object.defineProperty(compiler, "buildInfo", {
+    value: makeBuildInfoApi(compiler),
+    enumerable: false
+  });
+  return compiler;
+}
+function buildFromConfigOptions(callbacks) {
+  const utilityValues = callbacks["utility.values"];
+  if (!utilityValues || Object.keys(utilityValues).length === 0) return void 0;
+  return {
+    configCallbacks: {
+      utilityValues: Object.fromEntries(
+        Object.entries(utilityValues).map(([id, callback]) => [
+          id,
+          (tokenDictionary) => callback((category) => getTokenCategoryValues(category, tokenDictionary))
+        ])
+      )
+    }
+  };
+}
+
+export {
+  mergeCallbacks,
+  createCompilerFromWasmModule,
+  build,
+  buildFromConfigOptions
+};

package/dist/index.d.ts

@@ -0,0 +1,222 @@
+import { ParseFileReport, ScanOptions, LayerNames, Spec, SourceEntry, FileInspectionResult, GenerateArtifactOptions, CompileOptions, WriteCssResult, WriteFilesResult, SerializedHookFilter, Atom, RecipeEntry, EncodedRecipeStyles, ProjectSummary, CompileOutput, StylesheetLayerName, CssFile, CodegenArtifact, CodegenArtifactId, CodegenDependency, Diagnostic, CompileFileManifest, ParsedFileView, StaticPatternResult, BuildInfo, SerializedConfig, CompilerOptions, Compiler, ProjectCallbacks, ProjectHooks, ConfigSnapshot, Driver } from '@pandacss/compiler-shared';
+export * from '@pandacss/compiler-shared';
+export { PatternHelpers, mergeCallbacks } from '@pandacss/compiler-shared';
+
+/**
+ * TS-facing types that mirror the wasm-bindgen generated interfaces.
+ * Kept hand-written (rather than re-exporting from `../pkg-node/*`) so
+ * `tsc` typechecks succeed before the wasm artifact is built.
+ *
+ * The data shapes (`Atom`, `Diagnostic`, `CompileOutput`, …) come from
+ * `@pandacss/compiler-shared` — the single contract shared with the native
+ * binding. Only the wasm-bindgen *class* shapes live here.
+ *
+ * Run `pnpm build:wasm` to (re)generate the actual wasm bundle.
+ */
+
+interface MatcherInput {
+    /** Module specifier substrings to match (e.g. `["@panda/css"]`). */
+    modules: string[];
+    /**
+     * Allowed imported names. Omit (or pass `null`) to accept any name —
+     * used for recipe/pattern matchers where names are user-defined.
+     */
+    names?: string[] | null;
+}
+interface TokenDictionaryInput {
+    /** `path → raw value` (e.g. `colors.red.500 → #ef4444`). */
+    values: Record<string, string>;
+    /** `path → CSS var form` (e.g. `colors.red.500 → var(--colors-red-500)`). */
+    vars: Record<string, string>;
+}
+type JsxFramework = 'react' | 'solid' | 'preact' | 'vue' | 'qwik' | (string & {});
+type CssSyntax = 'template-literal' | 'object-literal';
+interface MatchersInput {
+    css?: MatcherInput;
+    recipe?: MatcherInput;
+    pattern?: MatcherInput;
+    jsx?: MatcherInput;
+    tokens?: MatcherInput;
+    /** Configured JSX framework. Enables JSX-aware extraction diagnostics. */
+    jsxFramework?: JsxFramework;
+    /** Defaults to `["styled"]` when omitted. */
+    jsxFactories?: string[];
+    /** CSS authoring syntax preference. Omit for object-literal mode. */
+    syntax?: CssSyntax;
+    /** Enable `token('…')` folding by passing a resolved dictionary. */
+    tokenDictionary?: TokenDictionaryInput;
+}
+declare class WasmFileSystem {
+    constructor();
+    addFile(path: string, content: string): void;
+    removeFile(path: string): boolean;
+    readFile(path: string): string | undefined;
+    exists(path: string): boolean;
+    fileCount(): number;
+}
+declare class WasmExtractor {
+    constructor(fs: WasmFileSystem, matchers: MatchersInput);
+    parseFile(path: string, source: string): unknown;
+}
+/** Stateful compiler handle over a `WasmFileSystem`. Cross-file resolution
+ *  always shares the same FS — `import { x } from './tokens'` references
+ *  resolve through whatever the JS host has populated.
+ *
+ *  Mirrors the native `Compiler` class. The TS facade adapts this into the
+ *  shared {@link @pandacss/compiler-shared#Compiler} surface (attaching `fs`,
+ *  hiding `registerUtilityTransform` / `registerPatternTransform`). */
+declare class WasmCompiler {
+    static fromConfig(fs: WasmFileSystem, config: Record<string, unknown>, options?: unknown): WasmCompiler;
+    config(): Record<string, unknown> | null;
+    extractFileSource(path: string, source: string): unknown;
+    parseFile(path: string): ParseFileReport;
+    parseFileSource(path: string, source: string): ParseFileReport;
+    refreshFile(path: string): boolean;
+    refreshFileSource(path: string, source: string): boolean;
+    removeFile(path: string): boolean;
+    clear(): void;
+    scan(options?: ScanOptions): string[];
+    realpath(path: string): string;
+    resolvePath(path: string, cwd?: string): string;
+    joinPath(parts: string[]): string;
+    dirname(path: string): string;
+    isSourceFile(path: string): boolean;
+    parseFiles(paths: string[]): ParseFileReport[];
+    layers(): LayerNames;
+    hasLayerDeclaration(css: string): boolean;
+    spec(): Spec;
+    sources(): SourceEntry[];
+    inspectFileSource(path: string, source: string): FileInspectionResult;
+    writeArtifacts(outdir: string, cwd?: string, options?: GenerateArtifactOptions): string[];
+    writeCss(outfile: string, cwd?: string, options?: CompileOptions): WriteCssResult;
+    writeSplitCss(outdir: string, cwd?: string): WriteFilesResult;
+    isEmpty(): boolean;
+    registerUtilityTransform?(id: string, callback: (resolved: unknown, original: unknown) => unknown): void;
+    registerPatternTransform?(id: string, callback: (props: unknown, helpers: Record<string, unknown>) => unknown): void;
+    registerSourceTransform?(id: string, filter: SerializedHookFilter | undefined, callback: (filePath: string, content: string) => string | undefined): void;
+    atoms(): Atom[];
+    recipes(): RecipeEntry[];
+    slotRecipes(): RecipeEntry[];
+    encodedRecipes(): EncodedRecipeStyles;
+    summary(): ProjectSummary;
+    compile(options?: CompileOptions): CompileOutput;
+    layerCss(layers: StylesheetLayerName[]): string;
+    splitCss(): CssFile[];
+    generateArtifacts(options?: GenerateArtifactOptions): CodegenArtifact[];
+    generateArtifact(id: CodegenArtifactId, options?: GenerateArtifactOptions): CodegenArtifact | undefined;
+    generateAffectedArtifacts(dependencies: CodegenDependency[], options?: GenerateArtifactOptions): CodegenArtifact[];
+    diagnostics(): Diagnostic[];
+    fileManifest(): CompileFileManifest[];
+    /** Per-file view, or `null` when `path` isn't known. */
+    getFile(path: string): ParsedFileView | null;
+    staticPatternAtoms(): StaticPatternResult;
+    serializeBuildInfo(panda: string): BuildInfo;
+    applyBuildInfo(name: string, buildInfo: BuildInfo, only?: string[]): boolean;
+    buildInfoSchemaVersion(): number;
+    configFingerprint(): string;
+}
+
+/**
+ * `@pandacss/compiler-wasm/web` — browser-only facade.
+ *
+ * Exports only the wasm-module facade (`createCompilerFromWasmModule`) and the
+ * types/helpers that go with it. Has **no** `import('../pkg-node/...')` in its
+ * module graph, so tsup injects no Node `fileURLToPath` shim into the browser
+ * bundle.
+ *
+ * Browser consumers:
+ *
+ * ```ts
+ * import initWasm, * as wasmMod from '@pandacss/compiler-wasm/pkg-web/compiler_wasm.js'
+ * import { createCompilerFromWasmModule } from '@pandacss/compiler-wasm/web'
+ *
+ * await initWasm(new URL('/compiler_wasm_bg.wasm', window.location.origin))
+ * const compiler = createCompilerFromWasmModule(wasmMod, config, options)
+ * ```
+ */
+
+/** `configCallbacks` carry construction-time `utility.values` resolvers. */
+interface WasmFromConfigOptions {
+    configCallbacks?: {
+        utilityValues?: Record<string, (tokenDictionary: TokenDictionaryInput | undefined) => unknown>;
+    };
+}
+/** The raw wasm instance — superset of {@link Compiler} carrying the internal
+ *  `token_dictionary` the facade hides. */
+interface RawWasmCompiler extends WasmCompiler {
+    token_dictionary?(): TokenDictionaryInput | undefined;
+}
+interface WasmModule {
+    WasmFileSystem: new () => WasmFileSystem;
+    WasmExtractor: new (fs: WasmFileSystem, matchers: unknown) => unknown;
+    WasmCompiler: {
+        fromConfig(fs: WasmFileSystem, config: SerializedConfig, options?: WasmFromConfigOptions): RawWasmCompiler;
+    };
+    installPanicHook: () => void;
+}
+/**
+ * Build a compiler from an already-loaded wasm module. Browser callers that
+ * import `./pkg-web/compiler_wasm.js` should call its default `init()` first,
+ * then pass the initialized module here.
+ */
+declare function createCompilerFromWasmModule(mod: WasmModule, config: SerializedConfig, options?: CompilerOptions): Compiler;
+declare function build(mod: WasmModule, config: SerializedConfig, callbacks: ProjectCallbacks, hooks?: ProjectHooks): Compiler;
+declare function buildFromConfigOptions(callbacks: ProjectCallbacks): WasmFromConfigOptions | undefined;
+
+interface BrowserDriverOptions {
+    /** Pre-built config snapshot (no in-browser bundling — Rolldown is Node-only). */
+    snapshot: ConfigSnapshot;
+    /** Source files to stage into the in-memory fs before the first `scan`. */
+    sources?: Record<string, string>;
+    /**
+     * An initialized `pkg-web` wasm module — the browser path: the caller does
+     * `import init, * as mod from '@pandacss/compiler-wasm/pkg-web/compiler_wasm.js'; await init()`
+     * and passes `mod` here. Omit in Node/SSR/tests to load the bundled `pkg-node`
+     * artifact via `loadWasm`.
+     */
+    module?: WasmModule;
+}
+/**
+ * Build a {@link Driver} backed by the wasm compiler (`MemoryFileSystem`). The
+ * browser has no disk, so the host hands in a pre-built config snapshot and
+ * stages source files into the in-memory fs; `scan` then runs over that tree in
+ * Rust.
+ *
+ * Pass an initialized `pkg-web` `module` for the real browser path; omit it in
+ * Node/SSR/tests to load the bundled `pkg-node` artifact.
+ */
+declare function createBrowserDriver(options: BrowserDriverOptions): Promise<Driver>;
+
+/**
+ * `@pandacss/compiler-wasm` — WebAssembly binding for the Panda Rust engine.
+ *
+ * Two output targets are bundled:
+ * - `./pkg-node/*` — CommonJS, for Node / Vitest / SSR.
+ * - `./pkg-web/*` — ESM with `fetch`-based init, for browser playgrounds.
+ *
+ * Consumers should `import { createCompiler } from '@pandacss/compiler-wasm'`.
+ * It loads the wasm module and resolves to a `Compiler` — the same flat shape
+ * as the native binding, with the shared in-memory FS exposed as `compiler.fs`.
+ *
+ * Browser consumers that want a shim-free bundle should import from
+ * `@pandacss/compiler-wasm/web` instead — it carries only the wasm-module
+ * facade with no `pkg-node` / `loadWasm` in its module graph.
+ */
+
+/**
+ * Load the Node-targeted wasm module. Idempotent — a single shared binding
+ * handle is cached after first call. Browser consumers should import
+ * `./pkg-web/*` directly and call its `init()`.
+ */
+declare function loadWasm(): Promise<WasmModule>;
+/**
+ * Build a compiler from a resolved, JSON-safe Panda config. Resolves to a
+ * `Compiler` whose `fs` is the shared in-memory filesystem — populate it
+ * (`compiler.fs.addFile(...)`) so cross-file imports fold during extraction.
+ */
+declare function createCompiler(config: SerializedConfig, options?: CompilerOptions): Promise<Compiler>;
+/** Like {@link createCompiler}, but takes a `{ config, callbacks }` snapshot.
+ *  Snapshot callbacks merge under any passed in `options.callbacks`. */
+declare function createCompilerFromSnapshot(snapshot: ConfigSnapshot, options?: CompilerOptions): Promise<Compiler>;
+
+export { type BrowserDriverOptions, type MatcherInput, type MatchersInput, type TokenDictionaryInput, WasmCompiler, WasmExtractor, WasmFileSystem, type WasmModule, build, buildFromConfigOptions, createBrowserDriver, createCompiler, createCompilerFromSnapshot, createCompilerFromWasmModule, loadWasm };

package/dist/index.js

@@ -0,0 +1,93 @@
+import {
+  build,
+  buildFromConfigOptions,
+  createCompilerFromWasmModule,
+  mergeCallbacks
+} from "./chunk-R2J25HLY.js";
+
+// src/index.ts
+import { createRequire } from "module";
+import { mergeCallbacks as mergeCallbacks2, mergeHooks } from "@pandacss/compiler-shared";
+
+// src/driver.ts
+import {
+  BaseDriver
+} from "@pandacss/compiler-shared";
+var NO_CHANGE = { hasChanged: false, dependencies: [], recipes: [], patterns: [], changes: [] };
+async function createBrowserDriver(options) {
+  const compiler = options.module ? createCompilerFromWasmModule(options.module, options.snapshot.config, {
+    callbacks: options.snapshot.callbacks
+  }) : await createCompilerFromSnapshot(options.snapshot);
+  if (options.sources) {
+    for (const [path, content] of Object.entries(options.sources)) {
+      compiler.fs?.addFile(path, content);
+    }
+  }
+  return new BrowserDriver(compiler, options.snapshot.config);
+}
+var BrowserDriver = class extends BaseDriver {
+  #config;
+  constructor(compiler, config) {
+    super(compiler);
+    this.#config = config;
+  }
+  get config() {
+    return this.#config;
+  }
+  get configPath() {
+    return void 0;
+  }
+  get configDependencies() {
+    return [];
+  }
+  // Browser drivers are snapshot-fed; reloading happens by constructing a fresh
+  // driver with a new snapshot, so there's nothing to diff here.
+  async reload() {
+    return NO_CHANGE;
+  }
+  applyChange(change) {
+    if (change.kind === "unlink") {
+      this.compiler.fs?.removeFile(change.path);
+      return this.compiler.removeFile(change.path);
+    }
+    if (change.content == null) return false;
+    this.compiler.fs?.addFile(change.path, change.content);
+    this.compiler.parseFileSource(change.path, change.content);
+    return true;
+  }
+  getOutdir(outdir) {
+    return this.compiler.resolvePath(this.getConfiguredOutdir(outdir));
+  }
+};
+
+// src/index.ts
+var cached = null;
+var require2 = createRequire(import.meta.url);
+async function loadWasm() {
+  if (cached) return cached;
+  const mod = require2("../pkg-node/compiler_wasm.js");
+  cached = mod;
+  if (typeof mod.installPanicHook === "function") {
+    mod.installPanicHook();
+  }
+  return mod;
+}
+async function createCompiler(config, options) {
+  const { createCompilerFromWasmModule: createCompilerFromWasmModule2 } = await import("./web-Z44NGLTK.js");
+  return createCompilerFromWasmModule2(await loadWasm(), config, options);
+}
+async function createCompilerFromSnapshot(snapshot, options) {
+  const callbacks = mergeCallbacks2(snapshot.callbacks, options?.callbacks);
+  const hooks = mergeHooks(snapshot.hooks, options?.hooks);
+  return build(await loadWasm(), snapshot.config, callbacks, hooks);
+}
+export {
+  build,
+  buildFromConfigOptions,
+  createBrowserDriver,
+  createCompiler,
+  createCompilerFromSnapshot,
+  createCompilerFromWasmModule,
+  loadWasm,
+  mergeCallbacks
+};

package/dist/web-Z44NGLTK.js

@@ -0,0 +1,12 @@
+import {
+  build,
+  buildFromConfigOptions,
+  createCompilerFromWasmModule,
+  mergeCallbacks
+} from "./chunk-R2J25HLY.js";
+export {
+  build,
+  buildFromConfigOptions,
+  createCompilerFromWasmModule,
+  mergeCallbacks
+};

package/dist/web.d.ts

@@ -0,0 +1,166 @@
+import { ParseFileReport, ScanOptions, LayerNames, Spec, SourceEntry, FileInspectionResult, GenerateArtifactOptions, CompileOptions, WriteCssResult, WriteFilesResult, SerializedHookFilter, Atom, RecipeEntry, EncodedRecipeStyles, ProjectSummary, CompileOutput, StylesheetLayerName, CssFile, CodegenArtifact, CodegenArtifactId, CodegenDependency, Diagnostic, CompileFileManifest, ParsedFileView, StaticPatternResult, BuildInfo, SerializedConfig, CompilerOptions, Compiler, ProjectCallbacks, ProjectHooks } from '@pandacss/compiler-shared';
+export * from '@pandacss/compiler-shared';
+export { PatternHelpers, mergeCallbacks } from '@pandacss/compiler-shared';
+
+/**
+ * TS-facing types that mirror the wasm-bindgen generated interfaces.
+ * Kept hand-written (rather than re-exporting from `../pkg-node/*`) so
+ * `tsc` typechecks succeed before the wasm artifact is built.
+ *
+ * The data shapes (`Atom`, `Diagnostic`, `CompileOutput`, …) come from
+ * `@pandacss/compiler-shared` — the single contract shared with the native
+ * binding. Only the wasm-bindgen *class* shapes live here.
+ *
+ * Run `pnpm build:wasm` to (re)generate the actual wasm bundle.
+ */
+
+interface MatcherInput {
+    /** Module specifier substrings to match (e.g. `["@panda/css"]`). */
+    modules: string[];
+    /**
+     * Allowed imported names. Omit (or pass `null`) to accept any name —
+     * used for recipe/pattern matchers where names are user-defined.
+     */
+    names?: string[] | null;
+}
+interface TokenDictionaryInput {
+    /** `path → raw value` (e.g. `colors.red.500 → #ef4444`). */
+    values: Record<string, string>;
+    /** `path → CSS var form` (e.g. `colors.red.500 → var(--colors-red-500)`). */
+    vars: Record<string, string>;
+}
+type JsxFramework = 'react' | 'solid' | 'preact' | 'vue' | 'qwik' | (string & {});
+type CssSyntax = 'template-literal' | 'object-literal';
+interface MatchersInput {
+    css?: MatcherInput;
+    recipe?: MatcherInput;
+    pattern?: MatcherInput;
+    jsx?: MatcherInput;
+    tokens?: MatcherInput;
+    /** Configured JSX framework. Enables JSX-aware extraction diagnostics. */
+    jsxFramework?: JsxFramework;
+    /** Defaults to `["styled"]` when omitted. */
+    jsxFactories?: string[];
+    /** CSS authoring syntax preference. Omit for object-literal mode. */
+    syntax?: CssSyntax;
+    /** Enable `token('…')` folding by passing a resolved dictionary. */
+    tokenDictionary?: TokenDictionaryInput;
+}
+declare class WasmFileSystem {
+    constructor();
+    addFile(path: string, content: string): void;
+    removeFile(path: string): boolean;
+    readFile(path: string): string | undefined;
+    exists(path: string): boolean;
+    fileCount(): number;
+}
+declare class WasmExtractor {
+    constructor(fs: WasmFileSystem, matchers: MatchersInput);
+    parseFile(path: string, source: string): unknown;
+}
+/** Stateful compiler handle over a `WasmFileSystem`. Cross-file resolution
+ *  always shares the same FS — `import { x } from './tokens'` references
+ *  resolve through whatever the JS host has populated.
+ *
+ *  Mirrors the native `Compiler` class. The TS facade adapts this into the
+ *  shared {@link @pandacss/compiler-shared#Compiler} surface (attaching `fs`,
+ *  hiding `registerUtilityTransform` / `registerPatternTransform`). */
+declare class WasmCompiler {
+    static fromConfig(fs: WasmFileSystem, config: Record<string, unknown>, options?: unknown): WasmCompiler;
+    config(): Record<string, unknown> | null;
+    extractFileSource(path: string, source: string): unknown;
+    parseFile(path: string): ParseFileReport;
+    parseFileSource(path: string, source: string): ParseFileReport;
+    refreshFile(path: string): boolean;
+    refreshFileSource(path: string, source: string): boolean;
+    removeFile(path: string): boolean;
+    clear(): void;
+    scan(options?: ScanOptions): string[];
+    realpath(path: string): string;
+    resolvePath(path: string, cwd?: string): string;
+    joinPath(parts: string[]): string;
+    dirname(path: string): string;
+    isSourceFile(path: string): boolean;
+    parseFiles(paths: string[]): ParseFileReport[];
+    layers(): LayerNames;
+    hasLayerDeclaration(css: string): boolean;
+    spec(): Spec;
+    sources(): SourceEntry[];
+    inspectFileSource(path: string, source: string): FileInspectionResult;
+    writeArtifacts(outdir: string, cwd?: string, options?: GenerateArtifactOptions): string[];
+    writeCss(outfile: string, cwd?: string, options?: CompileOptions): WriteCssResult;
+    writeSplitCss(outdir: string, cwd?: string): WriteFilesResult;
+    isEmpty(): boolean;
+    registerUtilityTransform?(id: string, callback: (resolved: unknown, original: unknown) => unknown): void;
+    registerPatternTransform?(id: string, callback: (props: unknown, helpers: Record<string, unknown>) => unknown): void;
+    registerSourceTransform?(id: string, filter: SerializedHookFilter | undefined, callback: (filePath: string, content: string) => string | undefined): void;
+    atoms(): Atom[];
+    recipes(): RecipeEntry[];
+    slotRecipes(): RecipeEntry[];
+    encodedRecipes(): EncodedRecipeStyles;
+    summary(): ProjectSummary;
+    compile(options?: CompileOptions): CompileOutput;
+    layerCss(layers: StylesheetLayerName[]): string;
+    splitCss(): CssFile[];
+    generateArtifacts(options?: GenerateArtifactOptions): CodegenArtifact[];
+    generateArtifact(id: CodegenArtifactId, options?: GenerateArtifactOptions): CodegenArtifact | undefined;
+    generateAffectedArtifacts(dependencies: CodegenDependency[], options?: GenerateArtifactOptions): CodegenArtifact[];
+    diagnostics(): Diagnostic[];
+    fileManifest(): CompileFileManifest[];
+    /** Per-file view, or `null` when `path` isn't known. */
+    getFile(path: string): ParsedFileView | null;
+    staticPatternAtoms(): StaticPatternResult;
+    serializeBuildInfo(panda: string): BuildInfo;
+    applyBuildInfo(name: string, buildInfo: BuildInfo, only?: string[]): boolean;
+    buildInfoSchemaVersion(): number;
+    configFingerprint(): string;
+}
+
+/**
+ * `@pandacss/compiler-wasm/web` — browser-only facade.
+ *
+ * Exports only the wasm-module facade (`createCompilerFromWasmModule`) and the
+ * types/helpers that go with it. Has **no** `import('../pkg-node/...')` in its
+ * module graph, so tsup injects no Node `fileURLToPath` shim into the browser
+ * bundle.
+ *
+ * Browser consumers:
+ *
+ * ```ts
+ * import initWasm, * as wasmMod from '@pandacss/compiler-wasm/pkg-web/compiler_wasm.js'
+ * import { createCompilerFromWasmModule } from '@pandacss/compiler-wasm/web'
+ *
+ * await initWasm(new URL('/compiler_wasm_bg.wasm', window.location.origin))
+ * const compiler = createCompilerFromWasmModule(wasmMod, config, options)
+ * ```
+ */
+
+/** `configCallbacks` carry construction-time `utility.values` resolvers. */
+interface WasmFromConfigOptions {
+    configCallbacks?: {
+        utilityValues?: Record<string, (tokenDictionary: TokenDictionaryInput | undefined) => unknown>;
+    };
+}
+/** The raw wasm instance — superset of {@link Compiler} carrying the internal
+ *  `token_dictionary` the facade hides. */
+interface RawWasmCompiler extends WasmCompiler {
+    token_dictionary?(): TokenDictionaryInput | undefined;
+}
+interface WasmModule {
+    WasmFileSystem: new () => WasmFileSystem;
+    WasmExtractor: new (fs: WasmFileSystem, matchers: unknown) => unknown;
+    WasmCompiler: {
+        fromConfig(fs: WasmFileSystem, config: SerializedConfig, options?: WasmFromConfigOptions): RawWasmCompiler;
+    };
+    installPanicHook: () => void;
+}
+/**
+ * Build a compiler from an already-loaded wasm module. Browser callers that
+ * import `./pkg-web/compiler_wasm.js` should call its default `init()` first,
+ * then pass the initialized module here.
+ */
+declare function createCompilerFromWasmModule(mod: WasmModule, config: SerializedConfig, options?: CompilerOptions): Compiler;
+declare function build(mod: WasmModule, config: SerializedConfig, callbacks: ProjectCallbacks, hooks?: ProjectHooks): Compiler;
+declare function buildFromConfigOptions(callbacks: ProjectCallbacks): WasmFromConfigOptions | undefined;
+
+export { type MatcherInput, type MatchersInput, type TokenDictionaryInput, WasmCompiler, WasmExtractor, WasmFileSystem, type WasmModule, build, buildFromConfigOptions, createCompilerFromWasmModule };