@gasm-compiler/core 0.1.0

package/dist/browser-executor.d.ts

@@ -0,0 +1,76 @@
+import { IGPUExecutor, ExecutorConfig, BufferData, ExecuteOptions } from './executor.js';
+
+/**
+ * Browser WebGPU Executor Implementation
+ *
+ * Executes WGSL compute shaders using browser's native WebGPU support.
+ * Handles shader compilation, buffer management, and result readback.
+ */
+
+declare class BrowserGPUExecutor implements IGPUExecutor {
+    private config;
+    private device;
+    private queue;
+    private initialized;
+    private pipelineCache;
+    private gpuBufferCache;
+    private stagingBuffer;
+    private stagingBufferSize;
+    private _animBindGroup;
+    private _animInputBuffer;
+    private _animInputSize;
+    private _animPipeline;
+    private _animStagingSize;
+    private _animStagingBuffer;
+    private _animResultBuffer;
+    private _animResultType;
+    private _animCopyU8Src;
+    private _animCopyU8Dst;
+    /**
+     * Zero-allocation animation fast path.
+     *
+     * Unlike execute(), this method:
+     * - Caches bind group, pipeline, buffers across frames
+     * - Creates NO Maps, arrays, Object.entries, template literals per frame
+     * - Only updates buffer contents via writeBuffer (4 bytes for time)
+     * - Returns a pre-allocated result buffer (same reference every frame)
+     *
+     * Call prepareAnimation() once before the loop, then executeFrame() each frame.
+     */
+    prepareAnimation(wgslCode: string, inputData: Float32Array | Int32Array | Uint32Array, inputType: "f32" | "i32" | "u32", outputSize: number, outputType: "f32" | "i32" | "u32", workgroupCount: [number, number, number], entryPoint?: string): Promise<void>;
+    private _animWorkgroupCount;
+    /**
+     * Execute one animation frame — ZERO JS object allocations.
+     *
+     * @param inputData The typed array whose contents to upload. Only the
+     *   portion you've modified needs to be current (e.g. write time at offset 0).
+     * @returns The same pre-allocated result buffer every frame.
+     */
+    executeFrame(inputData: Float32Array | Int32Array | Uint32Array): Promise<Float32Array | Int32Array | Uint32Array>;
+    constructor(config?: ExecutorConfig);
+    /**
+     * Initialize GPU device and queue (lazy initialization).
+     */
+    private ensureInitialized;
+    private resultBufferCache;
+    /**
+     * Get or create a GPU buffer. Buffers with the same label+size+usage are reused
+     * across calls (contents are updated via writeBuffer) to avoid per-frame allocation.
+     */
+    private getOrCreateBuffer;
+    /**
+     * Read back data from a GPU buffer into a pre-allocated result buffer.
+     * The same output TypedArray is reused across frames — no per-frame allocation.
+     */
+    private readBuffer;
+    /**
+     * Execute a WGSL compute shader with the provided inputs.
+     */
+    execute(wgslCode: string, inputs: Record<string, BufferData>, outputs: string[], options?: ExecuteOptions): Promise<Record<string, BufferData>>;
+    /**
+     * Release GPU resources. Call when done with executor.
+     */
+    destroy(): Promise<void>;
+}
+
+export { BrowserGPUExecutor };

package/dist/browser-executor.js

@@ -0,0 +1 @@
+import{a}from"./chunk-G6YRZSKB.js";import"./chunk-STDXBN5E.js";export{a as BrowserGPUExecutor};

package/dist/browser.d.ts

@@ -0,0 +1,20 @@
+import { C as CompileDiagnostics, D as DispatchInfo, a as CompileOptions } from './parser-Q0YamOJY.js';
+export { b as CompileError, i as isCompileError, d as isParseError, c as parseWasmModule } from './parser-Q0YamOJY.js';
+export { BrowserGPUExecutor } from './browser-executor.js';
+export { BufferData, ExecuteOptions, ExecutionError, ExecutorConfig, IGPUExecutor, OutputBufferSpec, isExecutionError } from './executor.js';
+
+declare function disassembleToWAT(wasmBytes: Uint8Array): Promise<string>;
+
+type CompileWithDiagnosticsResult = {
+    ok: true;
+    wgsl: string;
+    diagnostics: CompileDiagnostics;
+    dispatchInfo: DispatchInfo;
+} | {
+    ok: false;
+    diagnostics: CompileDiagnostics;
+};
+declare function compileWithDiagnostics(wasmBytes: Uint8Array, options?: CompileOptions): CompileWithDiagnosticsResult;
+declare function compile(wasmBytes: Uint8Array, options?: CompileOptions): string;
+
+export { CompileDiagnostics, CompileOptions, type CompileWithDiagnosticsResult, DispatchInfo, compile, compileWithDiagnostics, disassembleToWAT };

package/dist/browser.js

@@ -0,0 +1 @@
+import{A as I,B as R,C as S,a as d,b as N,d as l,e as m,f as g,g as h,p as E,q as C,r as x,s as y,x as w,y as D,z as A}from"./chunk-BRCWMQF4.js";import{a as M}from"./chunk-G6YRZSKB.js";import{a as b,b as W}from"./chunk-STDXBN5E.js";async function $(s){try{let r=(await(await import("wabt")).default()).readWasm(s,{readDebugNames:!0});r.generateNames(),r.applyNames();let c=r.toText({foldExprs:!1,inlineExport:!1});return r.destroy(),c}catch(o){return`; Error disassembling WAT: ${o instanceof Error?o.message:String(o)}`}}function O(s,o={}){let e=R(),r=l(s);if(m(r))return e.errors.push({severity:"error",code:"ERR_PARSE",message:r.message,functionName:r.functionName}),{ok:!1,diagnostics:e};let i=g(r);if(h(i))return e.errors.push({severity:"error",code:"ERR_VALIDATION",message:i.message,functionName:i.functionName}),{ok:!1,diagnostics:e};let u=i,a=S(u,o);if(e.warnings.push(...a.diagnostics.warnings),e.errors.push(...a.diagnostics.errors),e.demotions.push(...a.diagnostics.demotions),e.featuresUsed=a.diagnostics.featuresUsed,e.errors.length>0)return{ok:!1,diagnostics:e};let n=w(u);o.optimize!==!1&&(n=A(n,{verbose:o.verbose??!1}));let t=I(n);t=E(t),o.optimize!==!1&&(t=C(t));let p=x();if(o.optimize!==!1){let f=y(t);t=f.module,p=f.dispatchInfo}return{ok:!0,wgsl:D(t,o,s,p),diagnostics:e,dispatchInfo:p}}function j(s,o={}){let e=O(s,o);if(!e.ok){let r=e.diagnostics.errors[0];throw d(r?.message??"Compilation failed",{functionName:r?.functionName,instructionName:r?.code})}return e.wgsl}export{M as BrowserGPUExecutor,b as ExecutionError,j as compile,O as compileWithDiagnostics,$ as disassembleToWAT,N as isCompileError,W as isExecutionError,m as isParseError,l as parseWasmModule};