@divmain/jdm-asm 0.2.1 → 0.2.3

package/tests/helpers/test-harness-wasm.ts

@@ -1,710 +0,0 @@
-import type { TSchema } from '@sinclair/typebox';
-import { compile as compileWasm, type CompilationResult } from '../../src/compiler';
-import { ensureMemory } from '../../src/compiler/runtime';
-
-export { compileWasm as compile };
-
-/**
- * Compare actual result against expected, but only check keys present in expected.
- * This allows actual to have extra fields (e.g., passthrough fields).
- */
-function expectPartialMatch(actual: unknown, expected: unknown, message: string): void {
-  if (expected === actual) {
-    return;
-  }
-
-  if (typeof expected !== typeof actual) {
-    throw new Error(
-      `${message}: type mismatch (expected ${typeof expected}, got ${typeof actual})`,
-    );
-  }
-
-  if (expected === null || actual === null) {
-    if (expected !== actual) {
-      throw new Error(`${message}: null mismatch`);
-    }
-    return;
-  }
-
-  if (Array.isArray(expected)) {
-    if (!Array.isArray(actual)) {
-      throw new Error(`${message}: expected array, got ${typeof actual}`);
-    }
-    if (expected.length !== actual.length) {
-      throw new Error(`${message}: array length mismatch (${expected.length} vs ${actual.length})`);
-    }
-    for (let i = 0; i < expected.length; i++) {
-      expectPartialMatch(actual[i], expected[i], `${message}[${i}]`);
-    }
-    return;
-  }
-
-  if (typeof expected === 'object') {
-    if (typeof actual !== 'object') {
-      throw new Error(`${message}: expected object, got ${typeof actual}`);
-    }
-    const expectedKeys = Object.keys(expected);
-
-    for (const key of expectedKeys) {
-      const expectedValue = (expected as Record<string, unknown>)[key];
-      if (!(key in (actual as object))) {
-        throw new Error(`${message}: missing key "${key}"`);
-      }
-      expectPartialMatch(
-        (actual as Record<string, unknown>)[key],
-        expectedValue,
-        `${message}.${key}`,
-      );
-    }
-    return;
-  }
-
-  // Primitive comparison
-  if (expected !== actual) {
-    // Check if this looks like a timestamp comparison (Unix timestamps are large numbers)
-    const expectedNum = typeof expected === 'number';
-    const actualNum = typeof actual === 'number';
-    const isTimestamp =
-      expectedNum && actualNum && expected > 1_000_000_000 && actual > 1_000_000_000;
-
-    if (isTimestamp) {
-      // Skip exact timestamp comparison - just verify both are timestamps
-      return;
-    }
-
-    // For floating point numbers, allow small precision differences
-    if (expectedNum && actualNum) {
-      const relativeError =
-        Math.abs((expected as number) - (actual as number)) /
-        Math.max(Math.abs(expected as number), Math.abs(actual as number), 1e-15);
-      if (relativeError < 1e-14) {
-        return;
-      }
-    }
-
-    throw new Error(`${message}: value mismatch (expected ${expected}, got ${actual})`);
-  }
-}
-
-/**
- * WASM-only test configuration (no zen-engine comparison)
- */
-export interface WasmTestConfig {
-  name: string;
-  jdm: string | object;
-  inputSchema: TSchema;
-  outputSchema: TSchema;
-  input?: Record<string, unknown>;
-  expected?: Record<string, unknown> | unknown[];
-  unsupported?: string[];
-}
-
-/**
- * Simplified WASM test config without explicit schemas.
- * Schemas are inferred from input/expected shapes.
- */
-export interface SimpleWasmTestConfig {
-  name: string;
-  jdm: string | object;
-  input?: Record<string, unknown>;
-  expected?: Record<string, unknown> | unknown[];
-  unsupported?: string[];
-}
-
-/**
- * Evaluate a compiled WASM module with the given input.
- */
-export async function evaluateCompiled(
-  compiled: CompilationResult,
-  input: Record<string, unknown>,
-): Promise<Record<string, unknown>> {
-  // Simple helper to marshal input as a Map (for marshaling when schema has no fixed fields)
-  function marshalMapInput(
-    data: Record<string, unknown>,
-    memory: WebAssembly.Memory,
-    basePtr: number,
-  ): number {
-    const view = new DataView(memory.buffer);
-    const entries = Object.entries(data);
-    const length = entries.length;
-
-    // Write map length at basePtr
-    view.setUint32(basePtr, length, true);
-
-    // Allocate and write keys and values
-    let currentOffset = basePtr + 4 + length * 8; // Skip map structure
-
-    const writeValue = (value: unknown): number => {
-      // Returns pointer to a fully allocated Value structure
-      const valuePtr = currentOffset;
-
-      if (value === null || value === undefined) {
-        // Value.Null: [type: u32=0]
-        view.setUint32(valuePtr, 0, true); // TAG_NULL = 0
-        currentOffset += 4;
-      } else if (typeof value === 'boolean') {
-        // Value.Bool: [type: u32=1][value: u8]
-        view.setUint32(valuePtr, 1, true); // TAG_BOOLEAN = 1
-        view.setUint8(valuePtr + 4, value ? 1 : 0);
-        currentOffset += 5;
-      } else if (typeof value === 'number') {
-        // Value.Float: [type: u32=3][value: f64]
-        view.setUint32(valuePtr, 3, true); // TAG_FLOAT = 3
-        view.setFloat64(valuePtr + 4, value, true);
-        currentOffset += 12;
-      } else if (typeof value === 'string') {
-        // Value.String: [type: u32=4][stringPtr: u32]
-        // Allocate space for the Value structure
-        view.setUint32(valuePtr, 4, true); // TAG_STRING = 4
-
-        // Skip to allocate string data
-        currentOffset += 8;
-        const stringDataPtr = currentOffset;
-
-        // Write string data: [length: u32][utf16 chars...]
-        const len = value.length;
-        view.setUint32(stringDataPtr, len, true);
-        for (let i = 0; i < len; i++) {
-          view.setUint16(stringDataPtr + 4 + i * 2, value.charCodeAt(i), true);
-        }
-
-        currentOffset += 4 + len * 2; // length + UTF-16 chars
-
-        // Write pointer back to Value structure
-        view.setUint32(valuePtr + 4, stringDataPtr, true);
-      } else if (Array.isArray(value)) {
-        const arrLength = value.length;
-
-        // Skip past the Value structure (will fill in later)
-        const _tempOffset = currentOffset;
-        currentOffset += 8;
-
-        // Allocate space for array structure: [length: u32][elementPtr1: u32][elementPtr2: u32]...
-        const arrayPtr = currentOffset;
-        currentOffset += 4 + arrLength * 4; // length field + element pointers
-
-        // Write array structure with value pointers
-        view.setUint32(arrayPtr, arrLength, true); // Array length
-
-        // Write each element pointer
-        let ptrOffset = arrayPtr + 4;
-        for (let i = 0; i < arrLength; i++) {
-          const elemPtr = writeValue(value[i]);
-          view.setUint32(ptrOffset, elemPtr, true);
-          ptrOffset += 4;
-        }
-
-        // Now write the Value pointing to this array
-        view.setUint32(valuePtr, 5, true); // TAG_ARRAY = 5
-        view.setUint32(valuePtr + 4, arrayPtr, true); // Pointer to array data
-      } else if (typeof value === 'object') {
-        // Value.Object: [type: u32=6][mapPtr: u32]
-        const obj = value as Record<string, unknown>;
-        const objEntries = Object.entries(obj);
-
-        // Skip past the Value structure (will fill in later)
-        currentOffset += 8;
-
-        // Allocate space for map structure: [length: u32][keyPtr1: u32][valuePtr1: u32]...
-        const mapPtr = currentOffset;
-        currentOffset += 4 + objEntries.length * 8; // length field + key/value pointer pairs
-
-        // Write map structure with key/value pointers
-        view.setUint32(mapPtr, objEntries.length, true); // Number of properties
-
-        // Write each key/value pair
-        let ptrOffset = mapPtr + 4;
-        for (const [key, val] of objEntries) {
-          // Write key: treat string as raw key string data (not a Value structure)
-          const keyStrPtr = currentOffset;
-          const keyLen = key.length;
-          // Allocate space for key string data: [length: u32][utf16 chars...]
-          view.setUint32(keyStrPtr, keyLen, true);
-          for (let i = 0; i < keyLen; i++) {
-            view.setUint16(keyStrPtr + 4 + i * 2, key.charCodeAt(i), true);
-          }
-          currentOffset += 4 + keyLen * 2;
-          view.setUint32(ptrOffset, keyStrPtr, true);
-
-          // Write value pointer
-          const nestedValuePtr = writeValue(val);
-          view.setUint32(ptrOffset + 4, nestedValuePtr, true);
-
-          ptrOffset += 8;
-        }
-
-        // Now write the Value pointing to this map
-        view.setUint32(valuePtr, 6, true); // TAG_OBJECT = 6
-        view.setUint32(valuePtr + 4, mapPtr, true); // Pointer to map data
-      } else {
-        throw new Error(`Unsupported type: ${typeof value}`);
-      }
-
-      return valuePtr;
-    };
-
-    // Write map structure: [length: u32][keyPtr1: u32][valuePtr1: u32]...
-    // Note: writeString now returns a pointer to the string DATA, not the full Value structure
-    let ptrOffset = basePtr + 4;
-    for (let i = 0; i < length; i++) {
-      const [key, value] = entries[i];
-      const keyStrPtr = currentOffset; // Pointer to the string data
-      const keyLen = key.length;
-      // Write key as raw string data (not a Value): [length: u32][utf16 chars...]
-      view.setUint32(keyStrPtr, keyLen, true);
-      for (let j = 0; j < keyLen; j++) {
-        view.setUint16(keyStrPtr + 4 + j * 2, key.charCodeAt(j), true);
-      }
-      currentOffset += 4 + keyLen * 2;
-
-      const valuePtr = writeValue(value);
-      view.setUint32(ptrOffset, keyStrPtr, true);
-      view.setUint32(ptrOffset + 4, valuePtr, true);
-      ptrOffset += 8;
-    }
-
-    return basePtr;
-  }
-
-  // Instantiate WASM module
-  const wasmArray = new Uint8Array(compiled.wasm);
-  const buffer = wasmArray.buffer.slice(
-    wasmArray.byteOffset,
-    wasmArray.byteOffset + wasmArray.byteLength,
-  );
-  const wasmModule = await WebAssembly.compile(buffer as ArrayBuffer);
-  const instance = await WebAssembly.instantiate(wasmModule, {
-    env: {
-      abort: () => {
-        throw new Error('WASM abort called');
-      },
-      'Date.now': () => Date.now(),
-    },
-  });
-
-  const memory = instance.exports.memory as WebAssembly.Memory;
-  const evaluate = instance.exports.evaluate as (ptr: number) => number;
-
-  // Create a simple bump allocator for marshaling
-  // Start after the AssemblyScript data section (static strings, etc.)
-  // The AS compiler places static data around 1036-16000 for typical modules
-  // We use 192KB offset to give the AS runtime plenty of room for heap allocations
-  // during reading of complex nested data structures
-
-  // Start at 192KB to avoid AS runtime heap growth - AssemblyScript allocates its own heap
-  // starting around 1KB-16KB, and complex nested structures during evaluation may cause heap
-  // expansion. 192KB gives sufficient headroom to prevent collision between our marshal buffer
-  // and AS runtime heap.
-  let heapOffset = 192 * 1024;
-  const allocate = (size: number) => {
-    const ptr = heapOffset;
-    heapOffset += size;
-    return ptr;
-  };
-
-  // Load the generated marshal code
-  const cleanedCode = compiled.marshalCode
-    .replace(/^export function marshalInput/gm, 'function marshalInput')
-    .replace(/^export function unmarshalOutput/gm, 'function unmarshalOutput')
-    .replace(/^export function readString/gm, 'function readString')
-    .replace(/^export function readArray/gm, 'function readArray')
-    .replace(/^export function readValue/gm, 'function readValue');
-
-  const marshalCodeModule: any = {};
-  try {
-    const executeCode = new Function(
-      'module',
-      cleanedCode +
-        '\nmodule.marshalInput = marshalInput;\nmodule.unmarshalOutput = unmarshalOutput;\nmodule.readString = readString;\nmodule.readArray = readArray;\nmodule.readValue = readValue;',
-    );
-    executeCode(marshalCodeModule);
-  } catch (e: unknown) {
-    console.error('Generated marshal code:');
-    console.error(cleanedCode);
-    console.error('---');
-    throw e;
-  }
-
-  if (!marshalCodeModule.marshalInput || !marshalCodeModule.unmarshalOutput) {
-    throw new Error('Failed to load marshal functions');
-  }
-
-  // Allocate memory and marshal input
-  // Use manual Map marshaling for now since schema has no fixed-size fields
-  const inputAllocSize = 1024 * 128; // 128KB - increase for complex nested objects
-
-  // Ensure we have enough memory for:
-  // 1. AS runtime heap (0 - ~128KB depending on evaluation complexity)
-  // 2. Input data buffer at heapOffset (192KB) with inputAllocSize (128KB)
-  // 3. WASM custom heap for output marshaling (starts at 512KB in WASM code)
-  // 4. Output data (variable, but usually <100KB)
-  // Total: 512KB + 128KB = 640KB minimum, use 768KB for headroom
-  const requiredMemory = 768 * 1024;
-  ensureMemory(memory, requiredMemory);
-
-  const inputPtr = allocate(inputAllocSize);
-  marshalMapInput(input, memory, inputPtr);
-
-  const outputPtr = evaluate(inputPtr);
-  return (marshalCodeModule.unmarshalOutput as Function)(outputPtr, memory);
-}
-
-/**
- * Infer a TypeBox schema from a value (runtime inference).
- * Less type-safe than explicit schemas, but useful for porting existing tests.
- */
-export function inferSchema(value: unknown): TSchema {
-  if (value === null) {
-    return { type: 'null' } as unknown as TSchema;
-  }
-  if (typeof value === 'boolean') {
-    return { type: 'boolean' } as unknown as TSchema;
-  }
-  if (typeof value === 'number') {
-    return { type: 'number' } as unknown as TSchema;
-  }
-  if (typeof value === 'string') {
-    return { type: 'string' } as unknown as TSchema;
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return { type: 'array', items: {} } as unknown as TSchema;
-    }
-    return { type: 'array', items: inferSchema(value[0]) } as unknown as TSchema;
-  }
-  if (typeof value === 'object') {
-    const properties: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value)) {
-      properties[key] = inferSchema(val);
-    }
-    return { type: 'object', properties } as unknown as TSchema;
-  }
-  return {} as unknown as TSchema;
-}
-
-/**
- * Run a WASM-only test (no zen-engine comparison).
- */
-export async function runWasmTest(config: WasmTestConfig): Promise<void> {
-  // Skip if tests reference unsupported features
-  if (config.unsupported?.length) {
-    console.log(`⏭️  Skipping ${config.name} (unsupported: ${config.unsupported.join(', ')})`);
-    return;
-  }
-
-  // Convert string JDM to object if needed
-  const jdmContent = typeof config.jdm === 'string' ? JSON.parse(config.jdm) : config.jdm;
-
-  type TestCase = {
-    input: Record<string, unknown>;
-    output: Record<string, unknown>;
-  };
-
-  type JDMWithTests = typeof jdmContent & { tests?: TestCase[] };
-
-  const jdm = jdmContent as JDMWithTests;
-
-  // If JDM has embedded tests array, use those
-  const testCases = jdm.tests
-    ? jdm.tests
-    : config.input && config.expected
-      ? [{ input: config.input, output: config.expected }]
-      : [];
-
-  if (testCases.length === 0) {
-    console.log(`⏭️  Skipping ${config.name} (no test cases)`);
-    return;
-  }
-
-  // WASM compilation takes ~250ms per decision, so compiling once and reusing the module
-  // for all test cases dramatically speeds up test execution (seconds vs minutes).
-  let compiled: CompilationResult | null = null;
-  let compilationError: Error | null = null;
-  try {
-    compiled = await compileWasm({
-      jdm: config.jdm as any,
-      inputSchema: config.inputSchema,
-      outputSchema: config.outputSchema,
-      debug: true,
-    });
-    // Debug: dump generated code for specific tests
-    if (config.name.includes('customer-eligibility') && compiled.assemblyScript) {
-      require('fs').writeFileSync('/tmp/eligibility-debug.ts', compiled.assemblyScript);
-    }
-  } catch (error: unknown) {
-    compilationError = error instanceof Error ? error : new Error(String(error));
-  }
-
-  for (let i = 0; i < testCases.length; i++) {
-    const testCase = testCases[i];
-    const testName = jdm.tests ? `${config.name} [test ${i + 1}/${testCases.length}]` : config.name;
-
-    // Run with our implementation
-    try {
-      // Handle compilation errors
-      if (compilationError) {
-        const message = compilationError.message;
-        if (message.includes('Function node')) {
-          console.log(`⏭️  Skipping ${testName} (function node not yet supported)`);
-          continue;
-        } else if (message.includes('compile() not yet implemented')) {
-          console.log(`⏭️  Skipping ${testName} (compile() not yet implemented)`);
-          continue;
-        } else {
-          throw compilationError;
-        }
-      }
-
-      const asmResult = await evaluateCompiled(compiled!, testCase.input);
-
-      // Compare against expected output - only check keys present in expected
-      expectPartialMatch(asmResult, testCase.output, `${testName} - jdm-asm mismatch`);
-      console.log(`✅ ${testName}`);
-    } catch (error: unknown) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes('Function node')) {
-        console.log(`⏭️  Skipping ${testName} (function node not yet supported)`);
-      } else if (message.includes('compile() not yet implemented')) {
-        console.log(`⏭️  Skipping ${testName} (compile() not yet implemented)`);
-      } else {
-        throw error;
-      }
-    }
-  }
-}
-
-/**
- * Convenience wrapper for WASM tests without explicit schemas.
- * Infers schemas from the input/expected shapes.
- */
-export async function runSimpleWasmTest(config: SimpleWasmTestConfig): Promise<void> {
-  const inputSchema = inferSchema(config.input || {});
-  const outputSchema = inferSchema(config.expected || {});
-
-  return runWasmTest({
-    ...config,
-    inputSchema,
-    outputSchema,
-  });
-}
-
-/**
- * Reusable WASM evaluator that pre-instantiates the module once.
- * Use this for benchmarking hot path performance where WASM instantiation
- * should not be included in the timing.
- */
-export class ReusableWasmEvaluator {
-  private instance: WebAssembly.Instance | null = null;
-  private memory: WebAssembly.Memory | null = null;
-  private evaluate: ((ptr: number) => number) | null = null;
-  private collect: (() => void) | null = null;
-  private unmarshalOutput:
-    | ((ptr: number, memory: WebAssembly.Memory) => Record<string, unknown>)
-    | null = null;
-  private marshalMapInput:
-    | ((data: Record<string, unknown>, memory: WebAssembly.Memory, basePtr: number) => number)
-    | null = null;
-
-  constructor(private compiled: CompilationResult) {}
-
-  /**
-   * Initialize the WASM instance. Call this once before evaluating.
-   */
-  async initialize(): Promise<void> {
-    if (this.instance !== null) {
-      return;
-    }
-
-    // Instantiate WASM module
-    const wasmArray = new Uint8Array(this.compiled.wasm);
-    const buffer = wasmArray.buffer.slice(
-      wasmArray.byteOffset,
-      wasmArray.byteOffset + wasmArray.byteLength,
-    );
-    const wasmModule = await WebAssembly.compile(buffer as ArrayBuffer);
-    this.instance = await WebAssembly.instantiate(wasmModule, {
-      env: {
-        abort: () => {
-          throw new Error('WASM abort called');
-        },
-        'Date.now': () => Date.now(),
-      },
-    });
-
-    this.memory = this.instance.exports.memory as WebAssembly.Memory;
-    this.evaluate = this.instance.exports.evaluate as (ptr: number) => number;
-    this.collect = this.instance.exports.__collect as () => void;
-
-    // Load the generated marshal code
-    const cleanedCode = this.compiled.marshalCode
-      .replace(/^export function marshalInput/gm, 'function marshalInput')
-      .replace(/^export function unmarshalOutput/gm, 'function unmarshalOutput')
-      .replace(/^export function readString/gm, 'function readString')
-      .replace(/^export function readArray/gm, 'function readArray')
-      .replace(/^export function readValue/gm, 'function readValue');
-
-    const marshalCodeModule: any = {};
-    const executeCode = new Function(
-      'module',
-      cleanedCode +
-        '\nmodule.marshalInput = marshalInput;\nmodule.unmarshalOutput = unmarshalOutput;\nmodule.readString = readString;\nmodule.readArray = readArray;\nmodule.readValue = readValue;',
-    );
-    executeCode(marshalCodeModule);
-
-    this.unmarshalOutput = marshalCodeModule.unmarshalOutput;
-
-    // Create the marshalMapInput function (inline copy from evaluateCompiled)
-    this.marshalMapInput = this.createMarshalMapInput();
-
-    // Ensure enough memory
-    const requiredMemory = 768 * 1024;
-    ensureMemory(this.memory, requiredMemory);
-  }
-
-  /**
-   * Evaluate with the given input. The WASM instance is reused.
-   */
-  run(input: Record<string, unknown>): Record<string, unknown> {
-    if (
-      !this.instance ||
-      !this.memory ||
-      !this.evaluate ||
-      !this.unmarshalOutput ||
-      !this.marshalMapInput
-    ) {
-      throw new Error('ReusableWasmEvaluator not initialized. Call initialize() first.');
-    }
-
-    // Place input data at 640KB - after the custom heap region (512KB+)
-    // Memory layout:
-    //   - Static data: 0 - ~50KB
-    //   - AS runtime heap: ~50KB - 192KB (grows during evaluation, stub runtime has no GC)
-    //   - Reserved: 192KB - 512KB
-    //   - Custom heap (output): 512KB - 640KB
-    //   - Input data: 640KB - 768KB
-    // The stub runtime heap grows without GC, so putting input above the output heap
-    // ensures no collision even after many evaluations.
-    const inputPtr = 640 * 1024;
-
-    this.marshalMapInput(input, this.memory, inputPtr);
-    const outputPtr = this.evaluate(inputPtr);
-    const result = this.unmarshalOutput(outputPtr, this.memory);
-
-    // Run garbage collection to free memory used during evaluation
-    // Without this, AS runtime heap grows until it conflicts with our input buffer
-    if (this.collect) {
-      this.collect();
-    }
-
-    return result;
-  }
-
-  /**
-   * Create the marshalMapInput function (same logic as in evaluateCompiled).
-   */
-  private createMarshalMapInput(): (
-    data: Record<string, unknown>,
-    memory: WebAssembly.Memory,
-    basePtr: number,
-  ) => number {
-    return (data: Record<string, unknown>, memory: WebAssembly.Memory, basePtr: number): number => {
-      const view = new DataView(memory.buffer);
-      const entries = Object.entries(data);
-      const length = entries.length;
-
-      // Write map length at basePtr
-      view.setUint32(basePtr, length, true);
-
-      // Allocate and write keys and values
-      let currentOffset = basePtr + 4 + length * 8; // Skip map structure
-
-      const writeValue = (value: unknown): number => {
-        // Returns pointer to a fully allocated Value structure
-        const valuePtr = currentOffset;
-
-        if (value === null || value === undefined) {
-          view.setUint32(valuePtr, 0, true); // TAG_NULL = 0
-          currentOffset += 4;
-        } else if (typeof value === 'boolean') {
-          view.setUint32(valuePtr, 1, true); // TAG_BOOLEAN = 1
-          view.setUint8(valuePtr + 4, value ? 1 : 0);
-          currentOffset += 5;
-        } else if (typeof value === 'number') {
-          view.setUint32(valuePtr, 3, true); // TAG_FLOAT = 3
-          view.setFloat64(valuePtr + 4, value, true);
-          currentOffset += 12;
-        } else if (typeof value === 'string') {
-          view.setUint32(valuePtr, 4, true); // TAG_STRING = 4
-          currentOffset += 8;
-          const stringDataPtr = currentOffset;
-          const len = value.length;
-          view.setUint32(stringDataPtr, len, true);
-          for (let i = 0; i < len; i++) {
-            view.setUint16(stringDataPtr + 4 + i * 2, value.charCodeAt(i), true);
-          }
-          currentOffset += 4 + len * 2;
-          view.setUint32(valuePtr + 4, stringDataPtr, true);
-        } else if (Array.isArray(value)) {
-          const arrLength = value.length;
-          currentOffset += 8;
-          const arrayPtr = currentOffset;
-          currentOffset += 4 + arrLength * 4;
-          view.setUint32(arrayPtr, arrLength, true);
-          let ptrOffset = arrayPtr + 4;
-          for (let i = 0; i < arrLength; i++) {
-            const elemPtr = writeValue(value[i]);
-            view.setUint32(ptrOffset, elemPtr, true);
-            ptrOffset += 4;
-          }
-          view.setUint32(valuePtr, 5, true); // TAG_ARRAY = 5
-          view.setUint32(valuePtr + 4, arrayPtr, true);
-        } else if (typeof value === 'object') {
-          const obj = value as Record<string, unknown>;
-          const objEntries = Object.entries(obj);
-          currentOffset += 8;
-          const mapPtr = currentOffset;
-          currentOffset += 4 + objEntries.length * 8;
-          view.setUint32(mapPtr, objEntries.length, true);
-          let ptrOffset = mapPtr + 4;
-          for (const [key, val] of objEntries) {
-            const keyStrPtr = currentOffset;
-            const keyLen = key.length;
-            view.setUint32(keyStrPtr, keyLen, true);
-            for (let i = 0; i < keyLen; i++) {
-              view.setUint16(keyStrPtr + 4 + i * 2, key.charCodeAt(i), true);
-            }
-            currentOffset += 4 + keyLen * 2;
-            view.setUint32(ptrOffset, keyStrPtr, true);
-            const nestedValuePtr = writeValue(val);
-            view.setUint32(ptrOffset + 4, nestedValuePtr, true);
-            ptrOffset += 8;
-          }
-          view.setUint32(valuePtr, 6, true); // TAG_OBJECT = 6
-          view.setUint32(valuePtr + 4, mapPtr, true);
-        } else {
-          throw new Error(`Unsupported type: ${typeof value}`);
-        }
-
-        return valuePtr;
-      };
-
-      let ptrOffset = basePtr + 4;
-      for (let i = 0; i < length; i++) {
-        const [key, value] = entries[i];
-        const keyStrPtr = currentOffset;
-        const keyLen = key.length;
-        view.setUint32(keyStrPtr, keyLen, true);
-        for (let j = 0; j < keyLen; j++) {
-          view.setUint16(keyStrPtr + 4 + j * 2, key.charCodeAt(j), true);
-        }
-        currentOffset += 4 + keyLen * 2;
-        const valuePtr = writeValue(value);
-        view.setUint32(ptrOffset, keyStrPtr, true);
-        view.setUint32(ptrOffset + 4, valuePtr, true);
-        ptrOffset += 8;
-      }
-
-      return basePtr;
-    };
-  }
-}