@gasm-compiler/core 0.3.1 → 0.4.0

package/dist/{error_codes-D6RsiZ33.d.ts → error_codes-Cdy_3FNo.d.ts}

@@ -24,6 +24,7 @@ interface ImportedGlobal {
     module: string;
     name: string;
     type: ValueType;
+    mutable: boolean;
 }
 interface DefinedGlobal {
     kind: "definition";
@@ -40,10 +41,16 @@ interface WasmMemory {
     max?: number;
 }
 interface WasmDataSegment {
+    mode: "active" | "passive";
     memoryIndex: number;
     offset: Instruction[];
     data: Uint8Array;
 }
+interface AtomicRegionDescriptor {
+    memoryIndex: number;
+    offset: number;
+    length: number;
+}
 interface WasmExport {
     name: string;
     kind: "func" | "table" | "mem" | "global";
@@ -54,6 +61,10 @@ interface WasmImport {
     name: string;
     kind: "func" | "table" | "mem" | "global";
     typeIndex?: number;
+    memoryMin?: number;
+    memoryMax?: number;
+    globalType?: ValueType;
+    globalMutable?: boolean;
 }
 interface WasmType {
     params: ValueType[];
@@ -70,6 +81,11 @@ interface WasmModule {
     startFunctionIndex?: number;
     /** Custom sections from the WebAssembly module (for graphics extension metadata) */
     customSections?: CustomSection[];
+    extensions?: string[];
+    workgroupSizes?: Map<number, [number, number, number]>;
+    atomicRegion?: AtomicRegionDescriptor;
+    hasTableSection?: boolean;
+    hasElementSection?: boolean;
 }
 interface CompileError extends Error {
     functionName?: string;
@@ -218,10 +234,12 @@ declare function extractDebugInfo(wasmBytes: Uint8Array): DebugInfo;
  * WGSL mappings, vector dimensions, and validation specs.
  *
  * Functions are imported from the "gasm" module with names like:
- * - "sin" (scalar f32 -> f32)
+ * - "sin_f32" (scalar f32 -> f32)
  * - "sin_v2f32" (vector vec2<f32> -> vec2<f32>)
  * - "sin_v3f32" (vector vec3<f32> -> vec3<f32>)
- * - "sin_v4f32" (vector vec4<f32> -> vec4<f32>, default for vector ops)
+ * - "sin_v4f32" (vector vec4<f32> -> vec4<f32>)
+ *
+ * Unsuffixed scalar names remain accepted as legacy aliases.
  */
 
 /**
@@ -306,14 +324,13 @@ interface DemotionPolicy {
 /**
  * Supported Gasm specification versions.
  *
- * - "0.1": Default, current behavior. See spec/gasm-v0.1.md.
- * - "0.2": Opt-in v0.2 mode. See spec/gasm-v0.2.md. Until the v0.2
- *   conformance suite is complete, v0.2 mode is opt-in and existing
- *   compile() defaults preserve v0.1 behavior.
+ * - "0.1": Compatibility mode for the archived TypeScript-era behavior.
+ * - "0.2": Default Rust/Wasm compiler behavior. See spec/gasm-v0.2.md.
  */
 type SpecVersion = "0.1" | "0.2";
 declare const SPEC_VERSION_V01: SpecVersion;
 declare const SPEC_VERSION_V02: SpecVersion;
+declare const DEFAULT_SPEC_VERSION: SpecVersion;
 declare function resolveSpecVersion(options?: CompileOptions): SpecVersion;
 declare function isV02Mode(options?: CompileOptions): boolean;
 interface CompileOptions {
@@ -377,13 +394,10 @@ interface CompileOptions {
     /**
      * Target Gasm specification version.
      *
-     * - "0.1" (default): Current v0.1 behavior is preserved for existing callers.
-     * - "0.2": Opt into v0.2 strict validation and lowering. Until the v0.2
-     *   conformance suite is complete, this mode is intentionally opt-in.
+     * - "0.1": Explicit compatibility mode for existing v0.1 callers.
+     * - "0.2" (default): Strict v0.2 validation and Rust/Wasm lowering.
      *
-     * Setting this to "0.2" implicitly activates strict conformance and any
-     * additional v0.2-only rules added in subsequent PRs. The default WGSL
-     * header is NOT changed by this flag in PR-0.
+     * Setting this to "0.1" preserves the compatibility escape hatch.
      */
     specVersion?: SpecVersion;
 }
@@ -464,4 +478,4 @@ declare const ErrorCodes: {
 };
 type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
 
-export { type CompileDiagnostics as C, type DispatchInfo as D, ErrorCodes as E, type MathIntrinsicSpec as M, type SpecVersion as S, type VectorDimension as V, type WasmModule as W, type CompileOptions as a, type CompileError as b, SPEC_VERSION_V01 as c, SPEC_VERSION_V02 as d, isCompileError$1 as e, compile as f, isCompileError as g, type ErrorCode as h, isV02Mode as i, type MathLevel as j, getIntrinsicsAtLevel as k, getMathSpec as l, getVectorDimension as m, getWgslMapping as n, isMathIntrinsic as o, MATH_INTRINSICS as p, type DebugInfo as q, resolveSpecVersion as r, type SourceLanguage as s, type SourceMappingLevel as t, detectSourceLanguage as u, extractDebugInfo as v, parseNamesSection as w, parseProducersSection as x };
+export { type CompileOptions as C, type DispatchInfo as D, ErrorCodes as E, type MathIntrinsicSpec as M, type SpecVersion as S, type VectorDimension as V, type WasmModule as W, type CompileDiagnostics as a, type CompileError as b, DEFAULT_SPEC_VERSION as c, SPEC_VERSION_V01 as d, SPEC_VERSION_V02 as e, isCompileError$1 as f, compile as g, isCompileError as h, isV02Mode as i, type ErrorCode as j, type MathLevel as k, getIntrinsicsAtLevel as l, getMathSpec as m, getVectorDimension as n, getWgslMapping as o, isMathIntrinsic as p, MATH_INTRINSICS as q, resolveSpecVersion as r, type DebugInfo as s, type SourceLanguage as t, type SourceMappingLevel as u, detectSourceLanguage as v, extractDebugInfo as w, parseNamesSection as x, parseProducersSection as y };

package/dist/mod.d.ts

@@ -1,10 +1,85 @@
-import { W as WasmModule, C as CompileDiagnostics, D as DispatchInfo, a as CompileOptions } from './error_codes-D6RsiZ33.js';
-export { b as CompileError, q as DebugInfo, h as ErrorCode, E as ErrorCodes, p as MATH_INTRINSICS, M as MathIntrinsicSpec, j as MathLevel, c as SPEC_VERSION_V01, d as SPEC_VERSION_V02, s as SourceLanguage, t as SourceMappingLevel, S as SpecVersion, V as VectorDimension, u as detectSourceLanguage, v as extractDebugInfo, k as getIntrinsicsAtLevel, l as getMathSpec, m as getVectorDimension, n as getWgslMapping, e as isCompileError, o as isMathIntrinsic, g as isParseError, i as isV02Mode, w as parseNamesSection, x as parseProducersSection, f as parseWasmModule, r as resolveSpecVersion } from './error_codes-D6RsiZ33.js';
+import { W as WasmModule, C as CompileOptions, D as DispatchInfo, a as CompileDiagnostics } from './error_codes-Cdy_3FNo.js';
+export { b as CompileError, c as DEFAULT_SPEC_VERSION, s as DebugInfo, j as ErrorCode, E as ErrorCodes, q as MATH_INTRINSICS, M as MathIntrinsicSpec, k as MathLevel, d as SPEC_VERSION_V01, e as SPEC_VERSION_V02, t as SourceLanguage, u as SourceMappingLevel, S as SpecVersion, V as VectorDimension, v as detectSourceLanguage, w as extractDebugInfo, l as getIntrinsicsAtLevel, m as getMathSpec, n as getVectorDimension, o as getWgslMapping, f as isCompileError, p as isMathIntrinsic, h as isParseError, i as isV02Mode, x as parseNamesSection, y as parseProducersSection, g as parseWasmModule, r as resolveSpecVersion } from './error_codes-Cdy_3FNo.js';
 import { IGPUExecutor, ExecutorConfig, BufferData, ExecuteOptions } from './executor.js';
 export { ExecutionError, OutputBufferSpec, isExecutionError } from './executor.js';
 export { BrowserGPUExecutor } from './browser-executor.js';
 export { CompileOptions as NodeCompilerOptions, compileAssemblyScriptToWGSL, compileWasmToWGSL } from './compiler.js';
 
+type GasmBindingRole = "memory" | "atomic_region" | "imported_global" | "mutable_globals" | "workgroup_memory" | "extension_resource";
+interface GasmBinding {
+    group: number;
+    binding: number;
+    kind: "storage" | "uniform" | "texture" | "sampler";
+    rw?: "read" | "read_write" | "write";
+    role: GasmBindingRole;
+    wasmName?: string;
+    wgslName?: string;
+    type?: "i32" | "i64" | "f32" | "f64" | "u32" | "vec4<u32>" | "external";
+    atomic?: boolean;
+}
+declare function buildBindingTable(module: WasmModule): GasmBinding[];
+
+interface GasmMetadata {
+    specVersion: "0.2";
+    extensions: string[];
+    memory: {
+        sizeBytes: number;
+        atomicRegion?: {
+            offset: number;
+            length: number;
+            binding: {
+                group: number;
+                binding: number;
+            };
+        } | null;
+        workgroupMemoryBytes?: number;
+    };
+    entryPoints: GasmMetadataEntryPoint[];
+    bindings: GasmBinding[];
+    dataSegments: GasmMetadataDataSegment[];
+    atomicDataSegments?: GasmMetadataDataSegment[];
+    passiveDataSegments?: GasmMetadataPassiveDataSegment[];
+    mutableGlobals?: Array<{
+        index: number;
+        name?: string;
+        type: "i32" | "i64" | "f32" | "f64";
+        offset: number;
+        byteLength: number;
+        initialValue?: string;
+    }>;
+    extras?: Record<string, unknown>;
+}
+interface GasmMetadataEntryPoint {
+    name: string;
+    wgslName: string;
+    workgroupSize: [number, number, number];
+}
+interface GasmMetadataDataSegment {
+    memory: number;
+    offset: number;
+    byteLength: number;
+    dataB64: string;
+}
+interface GasmMetadataPassiveDataSegment {
+    index: number;
+    byteLength: number;
+    dataB64: string;
+    dropped: boolean;
+}
+interface MetadataBuildContext {
+    options?: CompileOptions;
+    dispatchInfo?: DispatchInfo;
+}
+declare function buildGasmMetadata(module: WasmModule, context?: MetadataBuildContext): GasmMetadata;
+declare function validateGasmMetadataSchema(metadata: unknown): {
+    valid: true;
+} | {
+    valid: false;
+    errors: string[];
+};
+declare function assertCustomSectionsAndMetadataAgree(module: WasmModule, metadata: GasmMetadata): void;
+declare function entryWrapperName(exportName: string): string;
+
 /**
  * WAT Disassembler
  *
@@ -85,10 +160,21 @@ type CompileWithDiagnosticsResult = {
     ok: false;
     diagnostics: CompileDiagnostics;
 };
+type CompileArtifactResult = {
+    ok: true;
+    wgsl: string;
+    metadata: GasmMetadata;
+    diagnostics: CompileDiagnostics;
+    dispatchInfo: DispatchInfo;
+} | {
+    ok: false;
+    diagnostics: CompileDiagnostics;
+};
 declare function compileWithDiagnostics(wasmBytes: Uint8Array, options?: CompileOptions): CompileWithDiagnosticsResult;
+declare function compileToArtifact(wasmBytes: Uint8Array, options?: CompileOptions): CompileArtifactResult;
 declare function preloadCompiler(): Promise<void>;
 declare function compileWithDiagnosticsAsync(wasmBytes: Uint8Array, options?: CompileOptions): Promise<CompileWithDiagnosticsResult>;
 declare function compile(wasmBytes: Uint8Array, options?: CompileOptions): string;
 declare function compileAsync(wasmBytes: Uint8Array, options?: CompileOptions): Promise<string>;
 
-export { BufferData, CompileDiagnostics, CompileOptions, type CompileWithDiagnosticsResult, DenoGPUExecutor, DispatchInfo, ExecuteOptions, ExecutorConfig, IGPUExecutor, compile, compileAsync, compileWithDiagnostics, compileWithDiagnosticsAsync, disassembleToWAT, preloadCompiler };
+export { BufferData, type CompileArtifactResult, CompileDiagnostics, CompileOptions, type CompileWithDiagnosticsResult, DenoGPUExecutor, DispatchInfo, ExecuteOptions, ExecutorConfig, type GasmBinding, type GasmMetadata, type GasmMetadataEntryPoint, IGPUExecutor, assertCustomSectionsAndMetadataAgree, buildBindingTable, buildGasmMetadata, compile, compileAsync, compileToArtifact, compileWithDiagnostics, compileWithDiagnosticsAsync, disassembleToWAT, entryWrapperName, preloadCompiler, validateGasmMetadataSchema };

package/dist/mod.js

@@ -1 +1 @@
-import{a as s,b as w,c as x,d as y,e as z,f as A,g as B,h as C,i as D}from"./chunk-VSCQDCQR.js";import{D as o,E as p,F as q,G as r,b as a,d as b,e as c,f as d,i as e,j as f,k as g,l as h,m as i,o as j,u as k,v as l,w as m,x as n}from"./chunk-PS4NV6ZB.js";import{a as v}from"./chunk-IZGS3OS2.js";import{a as t,b as u}from"./chunk-STDXBN5E.js";export{v as BrowserGPUExecutor,w as DenoGPUExecutor,d as ErrorCodes,t as ExecutionError,e as MATH_INTRINSICS,o as SPEC_VERSION_V01,p as SPEC_VERSION_V02,C as compile,x as compileAssemblyScriptToWGSL,D as compileAsync,y as compileWasmToWGSL,z as compileWithDiagnostics,B as compileWithDiagnosticsAsync,m as detectSourceLanguage,s as disassembleToWAT,n as extractDebugInfo,j as getIntrinsicsAtLevel,g as getMathSpec,i as getVectorDimension,h as getWgslMapping,a as isCompileError,u as isExecutionError,f as isMathIntrinsic,c as isParseError,r as isV02Mode,k as parseNamesSection,l as parseProducersSection,b as parseWasmModule,A as preloadCompiler,q as resolveSpecVersion};
+import{a as t,b as u,c as v,d as w,e as x,f as y,g as C,h as D,i as E,j as F,k as G,l as H,m as I,n as J,o as K}from"./chunk-NQJKL2KQ.js";import{D as o,E as p,F as q,G as r,H as s,b as a,d as b,e as c,f as d,i as e,j as f,k as g,l as h,m as i,o as j,u as k,v as l,w as m,x as n}from"./chunk-R6SXLNEJ.js";import{a as B}from"./chunk-IZGS3OS2.js";import{a as z,b as A}from"./chunk-STDXBN5E.js";export{B as BrowserGPUExecutor,q as DEFAULT_SPEC_VERSION,C as DenoGPUExecutor,b as ErrorCodes,z as ExecutionError,e as MATH_INTRINSICS,o as SPEC_VERSION_V01,p as SPEC_VERSION_V02,w as assertCustomSectionsAndMetadataAgree,t as buildBindingTable,u as buildGasmMetadata,J as compile,D as compileAssemblyScriptToWGSL,K as compileAsync,G as compileToArtifact,E as compileWasmToWGSL,F as compileWithDiagnostics,I as compileWithDiagnosticsAsync,m as detectSourceLanguage,y as disassembleToWAT,x as entryWrapperName,n as extractDebugInfo,j as getIntrinsicsAtLevel,g as getMathSpec,i as getVectorDimension,h as getWgslMapping,a as isCompileError,A as isExecutionError,f as isMathIntrinsic,d as isParseError,s as isV02Mode,k as parseNamesSection,l as parseProducersSection,c as parseWasmModule,H as preloadCompiler,r as resolveSpecVersion,v as validateGasmMetadataSchema};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gasm-compiler/core",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Gasm Compiler — compile WebAssembly to WGSL (WebGPU Shading Language)",
   "type": "module",
   "main": "./dist/mod.js",
@@ -43,16 +43,6 @@
     "LICENSE",
     "README.md"
   ],
-  "scripts": {
-    "build": "pnpm --dir ../.. core-rs:build:wasm:release && deno run --allow-read --allow-write ../../scripts/generate_core_rs_wasm_embed.ts --release && tsup && deno run --allow-read --allow-write ../../scripts/fix_node_builtin_imports.ts && deno run --allow-read --allow-write --allow-run --allow-env ../../scripts/copy_core_rs_wasm.ts --release",
-    "test": "pnpm --dir ../.. core-rs:build:wasm && GASM_CORE_BACKEND=rust deno test --allow-all",
-    "test:e2e": "deno test --allow-all --unstable-webgpu --no-check tests/e2e_execution_test.ts",
-    "test:e2e:gpu": "ENABLE_GPU_TESTS=1 deno test --allow-all --unstable-webgpu --no-check tests/e2e_execution_test.ts",
-    "lint": "biome lint .",
-    "prepublishOnly": "pnpm run build",
-    "size": "pnpm --dir ../.. core-rs:size",
-    "pack:smoke": "pnpm --dir ../.. core-rs:pack-smoke"
-  },
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
     "access": "public"
@@ -75,5 +65,14 @@
   "devDependencies": {
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "pnpm --dir ../.. core-rs:build:wasm:release && deno run --allow-read --allow-write ../../scripts/generate_core_rs_wasm_embed.ts --release && tsup && deno run --allow-read --allow-write ../../scripts/fix_node_builtin_imports.ts && deno run --allow-read --allow-write --allow-run --allow-env ../../scripts/copy_core_rs_wasm.ts --release",
+    "test": "pnpm --dir ../.. core-rs:build:wasm && GASM_CORE_BACKEND=rust deno test --allow-all",
+    "test:e2e": "deno test --allow-all --unstable-webgpu --no-check tests/e2e_execution_test.ts",
+    "test:e2e:gpu": "ENABLE_GPU_TESTS=1 deno test --allow-all --unstable-webgpu --no-check tests/e2e_execution_test.ts",
+    "lint": "biome lint .",
+    "size": "pnpm --dir ../.. core-rs:size",
+    "pack:smoke": "pnpm --dir ../.. core-rs:pack-smoke"
   }
-}
+}