@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/wasm/__tests__/wasmTraceRoot.test.ts

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it } from 'bun:test';
-import { createBuffer } from '../../__tests__/test-helpers.js';
+import { JsBufferStrategy } from '../../JsBufferStrategy.js';
 import { defineLogSchema } from '../../schema/defineLogSchema.js';
 import {
   ENTRY_TYPE_DEBUG,
@@ -12,27 +12,22 @@ import {
 } from '../../schema/systemSchema.js';
 import { createTraceId } from '../../traceId.js';
 import type { TracerLifecycleHooks } from '../../traceRoot.js';
-import type { AnySpanBuffer } from '../../types.js';
 import { createWasmAllocator, type WasmAllocator } from '../wasmAllocator.js';
 import { createWasmTraceRoot } from '../wasmTraceRoot.js';
 
-function createMockSpanBuffer(): AnySpanBuffer {
-  return createBuffer(defineLogSchema({}));
-}
+const mockSchema = defineLogSchema({});
 
 /**
  * Mock tracer that implements TracerLifecycleHooks for testing.
  */
-const mockTracer: TracerLifecycleHooks = {
+const mockTracer: TracerLifecycleHooks<typeof mockSchema> = {
   onTraceStart: () => {},
   onTraceEnd: () => {},
   onSpanStart: () => {},
   onSpanEnd: () => {},
   onStatsWillResetFor: () => {},
-  bufferStrategy: {
-    createChildSpanBuffer: createMockSpanBuffer,
-    createOverflowBuffer: createMockSpanBuffer,
-  },
+  getFlagEvaluatorForContext: () => undefined,
+  bufferStrategy: new JsBufferStrategy<typeof mockSchema>(),
 };
 
 describe('WasmTraceRoot', () => {
@@ -111,7 +106,7 @@ describe('WasmTraceRoot', () => {
   describe('writeSpanStartPtr (low-level pointer API)', () => {
     it('sets entry_type[0] = SPAN_START (1)', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -121,7 +116,7 @@ describe('WasmTraceRoot', () => {
 
     it('sets entry_type[1] = SPAN_EXCEPTION (4) for crash safety', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -131,7 +126,7 @@ describe('WasmTraceRoot', () => {
 
     it('sets _writeIndex to 2', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -141,7 +136,7 @@ describe('WasmTraceRoot', () => {
 
     it('writes a valid timestamp at row 0', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -154,7 +149,7 @@ describe('WasmTraceRoot', () => {
   describe('writeSpanEndOkPtr (low-level pointer API)', () => {
     it('sets entry_type[1] = SPAN_OK (2)', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -165,7 +160,7 @@ describe('WasmTraceRoot', () => {
 
     it('writes a valid timestamp at row 1', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -177,7 +172,7 @@ describe('WasmTraceRoot', () => {
 
     it('writes timestamp >= span start timestamp', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -193,7 +188,7 @@ describe('WasmTraceRoot', () => {
   describe('writeSpanEndErrPtr (low-level pointer API)', () => {
     it('sets entry_type[1] = SPAN_ERR (3)', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -204,7 +199,7 @@ describe('WasmTraceRoot', () => {
 
     it('writes a valid timestamp at row 1', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -218,7 +213,7 @@ describe('WasmTraceRoot', () => {
   describe('writeLogEntryPtr (low-level pointer API)', () => {
     it('returns correct row index starting at 2', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -229,7 +224,7 @@ describe('WasmTraceRoot', () => {
 
     it('increments write index for each log entry', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -246,7 +241,7 @@ describe('WasmTraceRoot', () => {
 
     it('writes correct entry type', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -261,7 +256,7 @@ describe('WasmTraceRoot', () => {
 
     it('writes valid timestamps for log entries', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -275,7 +270,7 @@ describe('WasmTraceRoot', () => {
   describe('readWriteIndex', () => {
     it('returns 2 after writeSpanStartPtr', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -285,7 +280,7 @@ describe('WasmTraceRoot', () => {
 
     it('reflects log entries written', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
-      const systemPtr = allocator.allocSpanSystem();
+      const systemPtr = allocator.allocExact(64 * 9, 8);
       const identityPtr = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr, identityPtr);
@@ -326,9 +321,9 @@ describe('WasmTraceRoot', () => {
     it('can write to multiple system blocks', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
 
-      const systemPtr1 = allocator.allocSpanSystem();
+      const systemPtr1 = allocator.allocExact(64 * 9, 8);
       const identityPtr1 = allocator.allocIdentityChild();
-      const systemPtr2 = allocator.allocSpanSystem();
+      const systemPtr2 = allocator.allocExact(64 * 9, 8);
       const identityPtr2 = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr1, identityPtr1);
@@ -343,9 +338,9 @@ describe('WasmTraceRoot', () => {
     it('maintains separate state for each span buffer', () => {
       const traceRoot = createWasmTraceRoot(allocator, 'test-trace-id', mockTracer);
 
-      const systemPtr1 = allocator.allocSpanSystem();
+      const systemPtr1 = allocator.allocExact(64 * 9, 8);
       const identityPtr1 = allocator.allocIdentityChild();
-      const systemPtr2 = allocator.allocSpanSystem();
+      const systemPtr2 = allocator.allocExact(64 * 9, 8);
       const identityPtr2 = allocator.allocIdentityChild();
 
       traceRoot.writeSpanStartPtr(systemPtr1, identityPtr1);

package/src/lib/wasm/__tests__/wasmTracer.test.ts.disabled

@@ -137,8 +137,8 @@ describe('WasmTracer', () => {
 
       // Allocator should have all the expected methods
       expect(tracer.allocator.memory).toBeInstanceOf(WebAssembly.Memory);
-      expect(typeof tracer.allocator.allocSpanSystem).toBe('function');
-      expect(typeof tracer.allocator.freeSpanSystem).toBe('function');
+      expect(typeof tracer.allocator.allocExact).toBe('function');
+      expect(typeof tracer.allocator.freeExact).toBe('function');
       expect(typeof tracer.allocator.getAllocCount).toBe('function');
     });
   });

package/src/lib/wasm/wasmAllocator.ts

@@ -20,23 +20,26 @@
 // Types
 // =============================================================================
 
+export interface WasmMemoryEpochPin {
+  readonly buffer: ArrayBuffer;
+  readonly version: number;
+  readonly released: boolean;
+  release(): void;
+}
+
+export const WASM_SPAN_IDENTITY_ROOT = 0;
+export const WASM_SPAN_IDENTITY_CHILD = 1;
+export const WASM_NO_LAYOUT_OFFSET = 0xffffffff;
+
 export interface WasmAllocator {
   /** The underlying WASM memory */
   readonly memory: WebAssembly.Memory;
-
-  /** WASM exports for direct function calls (hot path optimization) */
-  readonly exports: {
-    write_col_f64: (colOffset: number, rowIdx: number, value: number, capacity: number) => number;
-    write_col_u32: (colOffset: number, rowIdx: number, value: number, capacity: number) => number;
-    write_col_u8: (colOffset: number, rowIdx: number, value: number, capacity: number) => number;
-    write_log_entry: (
-      systemPtr: number,
-      identityPtr: number,
-      traceRootPtr: number,
-      entryType: number,
-      capacity: number,
-    ) => number;
-  };
+  /** Monotonic version of the current linear-memory ArrayBuffer. */
+  readonly memoryVersion: number;
+  /** Refresh canonical allocator views after growth and return memoryVersion. */
+  refreshViews(): number;
+  /** Pin the current linear-memory backing epoch for borrowed Arrow views. */
+  pinMemoryEpoch(): WasmMemoryEpochPin;
 
   /** Cached views (recreated after grow, but pre-sized to avoid grow for benchmarks) */
   readonly u8: Uint8Array;
@@ -53,17 +56,26 @@ export interface WasmAllocator {
   /** Reset all freelists (for testing/benchmarking) */
   reset(): void;
 
-  // Block allocation - capacity determines tier and block size
-  allocSpanSystem(capacity?: number): number;
-  alloc1B(capacity?: number): number;
-  alloc4B(capacity?: number): number;
-  alloc8B(capacity?: number): number;
-
-  // Block deallocation - returns block to freelist, may trigger buddy merge
-  freeSpanSystem(offset: number, capacity?: number): void;
-  free1B(offset: number, capacity?: number): void;
-  free4B(offset: number, capacity?: number): void;
-  free8B(offset: number, capacity?: number): void;
+  /** Allocate and release an exact logical byte extent with explicit alignment. */
+  allocExact(byteLength: number, alignment: number): number;
+  freeExact(offset: number, byteLength: number, alignment: number): void;
+  /**
+   * Allocate one root/child superblock and pre-arm its lifecycle rows in one
+   * WASM call. All offsets are immutable compile/startup layout constants.
+   */
+  createAndStartSpan(
+    identityMode: typeof WASM_SPAN_IDENTITY_ROOT | typeof WASM_SPAN_IDENTITY_CHILD,
+    traceIdLength: number,
+    superblockByteLength: number,
+    systemOffset: number,
+    entryTypeOffset: number,
+    rowHeaderOffset: number,
+    traceRootPtr: number,
+  ): number;
+  /** Allocate one storage-only overflow superblock in one WASM call. */
+  createOverflowSpan(superblockByteLength: number): number;
+  /** Release one root, child, or overflow superblock. */
+  freeSpanSuperblock(offset: number, byteLength: number): void;
 
   // Span lifecycle (writes timestamp + entry_type)
   spanStart(systemPtr: number, identityPtr: number, traceRootPtr: number, capacity?: number): void;
@@ -78,11 +90,6 @@ export interface WasmAllocator {
     capacity?: number,
   ): number;
 
-  // Column writes (auto-allocate if offset is 0)
-  writeColF64(colOffset: number, rowIdx: number, value: number, capacity?: number): number;
-  writeColU32(colOffset: number, rowIdx: number, value: number, capacity?: number): number;
-  writeColU8(colOffset: number, rowIdx: number, value: number, capacity?: number): number;
-
   // TraceRoot initialization
   initTraceRoot(traceRootPtr: number): void;
 
@@ -90,10 +97,6 @@ export interface WasmAllocator {
   getBumpPtr(): number;
   getAllocCount(): number;
   getFreeCount(): number;
-  getSpanSystemSize(capacity?: number): number;
-  getCol1BSize(capacity?: number): number;
-  getCol4BSize(capacity?: number): number;
-  getCol8BSize(capacity?: number): number;
 
   // Reading (for Arrow conversion)
   readTimestamp(systemPtr: number, rowIdx: number): bigint;
@@ -151,16 +154,19 @@ export interface WasmAllocatorOptions {
 interface WasmExports {
   init(): void;
   reset(): void;
-
-  alloc_span_system(capacity: number): number;
-  alloc_col_1b(capacity: number): number;
-  alloc_col_4b(capacity: number): number;
-  alloc_col_8b(capacity: number): number;
-
-  free_span_system(offset: number, capacity: number): void;
-  free_col_1b(offset: number, capacity: number): void;
-  free_col_4b(offset: number, capacity: number): void;
-  free_col_8b(offset: number, capacity: number): void;
+  alloc_exact(byteLength: number, alignment: number): number;
+  free_exact(offset: number, byteLength: number, alignment: number): void;
+  create_and_start_span(
+    identityMode: number,
+    traceIdLength: number,
+    superblockByteLength: number,
+    systemOffset: number,
+    entryTypeOffset: number,
+    rowHeaderOffset: number,
+    traceRootPtr: number,
+  ): number;
+  create_overflow_span(superblockByteLength: number): number;
+  free_span_superblock(offset: number, byteLength: number): void;
 
   span_start(systemPtr: number, identityPtr: number, traceRootPtr: number, capacity: number): void;
   span_end_ok(systemPtr: number, traceRootPtr: number, capacity: number): void;
@@ -182,10 +188,6 @@ interface WasmExports {
   get_bump_ptr(): number;
   get_alloc_count(): number;
   get_free_count(): number;
-  get_span_system_size(capacity: number): number;
-  get_col_1b_size(capacity: number): number;
-  get_col_4b_size(capacity: number): number;
-  get_col_8b_size(capacity: number): number;
 
   read_timestamp(systemPtr: number, rowIdx: number): bigint;
   read_entry_type(systemPtr: number, rowIdx: number, capacity: number): number;
@@ -221,7 +223,11 @@ function isWasmExports(value: unknown): value is WasmExports {
   }
 
   return (
-    typeof Reflect.get(value, 'init') === 'function' && typeof Reflect.get(value, 'alloc_span_system') === 'function'
+    typeof Reflect.get(value, 'init') === 'function' &&
+    typeof Reflect.get(value, 'alloc_exact') === 'function' &&
+    typeof Reflect.get(value, 'create_and_start_span') === 'function' &&
+    typeof Reflect.get(value, 'create_overflow_span') === 'function' &&
+    typeof Reflect.get(value, 'free_span_superblock') === 'function'
   );
 }
 
@@ -256,6 +262,20 @@ function wrapWasmInstance(instance: WebAssembly.Instance, memory: WebAssembly.Me
   const exports = instance.exports;
   let views = createViews(memory);
   let currentBuffer = memory.buffer;
+  let memoryVersion = 1;
+  let memoryEpochPins = 0;
+
+  const refreshViews = (): number => {
+    if (memory.buffer !== currentBuffer) {
+      if (memoryEpochPins !== 0) {
+        throw new Error('WASM memory grew while an Arrow lease pinned the previous epoch');
+      }
+      currentBuffer = memory.buffer;
+      views = createViews(memory);
+      memoryVersion++;
+    }
+    return memoryVersion;
+  };
 
   // Initialize the allocator header
   exports.init();
@@ -263,80 +283,91 @@ function wrapWasmInstance(instance: WebAssembly.Instance, memory: WebAssembly.Me
   return {
     memory,
     capacity,
-    exports: {
-      write_col_f64: exports.write_col_f64,
-      write_col_u32: exports.write_col_u32,
-      write_col_u8: exports.write_col_u8,
-      write_log_entry: exports.write_log_entry,
+    get memoryVersion() {
+      return refreshViews();
+    },
+    refreshViews,
+    pinMemoryEpoch() {
+      const version = refreshViews();
+      const buffer = currentBuffer;
+      memoryEpochPins++;
+      let released = false;
+      return {
+        buffer,
+        version,
+        get released() {
+          return released;
+        },
+        release() {
+          if (released) return;
+          released = true;
+          memoryEpochPins--;
+        },
+      };
     },
 
     get u8() {
-      // Check if memory grew since last access
-      if (memory.buffer !== currentBuffer) {
-        currentBuffer = memory.buffer;
-        views = createViews(memory);
-      }
+      refreshViews();
       return views.u8;
     },
     get u32() {
-      if (memory.buffer !== currentBuffer) {
-        currentBuffer = memory.buffer;
-        views = createViews(memory);
-      }
+      refreshViews();
       return views.u32;
     },
     get i64() {
-      if (memory.buffer !== currentBuffer) {
-        currentBuffer = memory.buffer;
-        views = createViews(memory);
-      }
+      refreshViews();
       return views.i64;
     },
     get f64() {
-      if (memory.buffer !== currentBuffer) {
-        currentBuffer = memory.buffer;
-        views = createViews(memory);
-      }
+      refreshViews();
       return views.f64;
     },
 
     init: exports.init,
     reset: exports.reset,
-
-    // Allocation with optional capacity (defaults to instance capacity)
-    allocSpanSystem: (cap = capacity) => exports.alloc_span_system(cap),
-    alloc1B: (cap = capacity) => exports.alloc_col_1b(cap),
-    alloc4B: (cap = capacity) => exports.alloc_col_4b(cap),
-    alloc8B: (cap = capacity) => exports.alloc_col_8b(cap),
-
-    // Deallocation with optional capacity
-    freeSpanSystem: (offset, cap = capacity) => exports.free_span_system(offset, cap),
-    free1B: (offset, cap = capacity) => exports.free_col_1b(offset, cap),
-    free4B: (offset, cap = capacity) => exports.free_col_4b(offset, cap),
-    free8B: (offset, cap = capacity) => exports.free_col_8b(offset, cap),
+    allocExact: exports.alloc_exact,
+    freeExact: exports.free_exact,
+    createAndStartSpan: (
+      identityMode,
+      traceIdLength,
+      superblockByteLength,
+      systemOffset,
+      entryTypeOffset,
+      rowHeaderOffset,
+      traceRootPtr,
+    ) => {
+      const offset = exports.create_and_start_span(
+        identityMode,
+        traceIdLength,
+        superblockByteLength,
+        systemOffset,
+        entryTypeOffset,
+        rowHeaderOffset,
+        traceRootPtr,
+      );
+      refreshViews();
+      return offset;
+    },
+    createOverflowSpan: (superblockByteLength) => {
+      const offset = exports.create_overflow_span(superblockByteLength);
+      refreshViews();
+      return offset;
+    },
+    freeSpanSuperblock: exports.free_span_superblock,
 
     // Span lifecycle with optional capacity
     spanStart: (systemPtr, identityPtr, traceRootPtr, cap = capacity) =>
       exports.span_start(systemPtr, identityPtr, traceRootPtr, cap),
     spanEndOk: (systemPtr, traceRootPtr, cap = capacity) => exports.span_end_ok(systemPtr, traceRootPtr, cap),
     spanEndErr: (systemPtr, traceRootPtr, cap = capacity) => exports.span_end_err(systemPtr, traceRootPtr, cap),
-    writeLogEntry: (systemPtr, traceRootPtr, idx, entryType, cap = capacity) =>
-      exports.write_log_entry(systemPtr, traceRootPtr, idx, entryType, cap),
-
-    // Column writes with optional capacity
-    writeColF64: (colOffset, rowIdx, value, cap = capacity) => exports.write_col_f64(colOffset, rowIdx, value, cap),
-    writeColU32: (colOffset, rowIdx, value, cap = capacity) => exports.write_col_u32(colOffset, rowIdx, value, cap),
-    writeColU8: (colOffset, rowIdx, value, cap = capacity) => exports.write_col_u8(colOffset, rowIdx, value, cap),
+    writeLogEntry: (systemPtr, identityPtr, traceRootPtr, entryType, cap = capacity) =>
+      exports.write_log_entry(systemPtr, identityPtr, traceRootPtr, entryType, cap),
 
     initTraceRoot: exports.init_trace_root,
 
     getBumpPtr: exports.get_bump_ptr,
     getAllocCount: exports.get_alloc_count,
     getFreeCount: exports.get_free_count,
-    getSpanSystemSize: (cap = capacity) => exports.get_span_system_size(cap),
-    getCol1BSize: (cap = capacity) => exports.get_col_1b_size(cap),
-    getCol4BSize: (cap = capacity) => exports.get_col_4b_size(cap),
-    getCol8BSize: (cap = capacity) => exports.get_col_8b_size(cap),
 
     readTimestamp: exports.read_timestamp,
     readEntryType: (systemPtr, rowIdx, cap = capacity) => exports.read_entry_type(systemPtr, rowIdx, cap),
@@ -384,6 +415,10 @@ function createImports(memory: WebAssembly.Memory) {
 // This eliminates recompilation cost in benchmarks and production
 let cachedWasmModule: WebAssembly.Module | null = null;
 
+// The shipped Rust allocator is the only supported artifact. Node and browser loading
+// deliberately share this fixed path so runtime selection cannot drift by environment.
+const WASM_ARTIFACT_NAME = 'allocator.wasm';
+
 /**
  * Load WASM bytes - handles both Node.js and browser environments.
  */
@@ -397,7 +432,7 @@ async function loadWasmBytes(): Promise<ArrayBuffer> {
     // __dirname equivalent for ESM
     const currentFile = fileURLToPath(import.meta.url);
     const currentDir = dirname(currentFile);
-    const wasmPath = join(currentDir, '../../../dist/allocator.wasm');
+    const wasmPath = join(currentDir, '../../../dist', WASM_ARTIFACT_NAME);
 
     const buffer = await readFile(wasmPath);
     // Create a proper ArrayBuffer from the Node.js Buffer
@@ -407,7 +442,7 @@ async function loadWasmBytes(): Promise<ArrayBuffer> {
   }
 
   // Browser: fetch from relative path
-  const response = await fetch(new URL('../../../dist/allocator.wasm', import.meta.url));
+  const response = await fetch(new URL(`../../../dist/${WASM_ARTIFACT_NAME}`, import.meta.url));
   return response.arrayBuffer();
 }