@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/codegen/js-marshal.ts

@@ -1,999 +0,0 @@
-/**
- * JavaScript Marshaling Code Generation
- *
- * This module generates JavaScript code for serializing JavaScript objects to
- * WebAssembly memory and deserializing results back. The generated code handles:
- *
- * - Input marshaling: Converting JS objects to WASM memory format
- * - Output unmarshaling: Converting WASM memory back to JS objects
- * - Size calculation: Computing memory requirements for marshaling
- * - Type-tagged value encoding: Writing values with type tags for dynamic typing
- *
- * The generated code operates on DataView for cross-endian compatibility and
- * handles both fixed-size types (numbers, booleans) and variable-length types
- * (strings, arrays, objects).
- */
-
-import type { FlattenedLayout } from '../types';
-
-/**
- * Generate JavaScript marshaling code.
- *
- * This function generates the JavaScript code that will serialize
- * JavaScript objects to WebAssembly memory and deserialize results back.
- *
- * @param inputLayout - The flattened input schema layout
- * @param outputLayout - The flattened output schema layout
- * @param schemaHash - The schema hash for runtime validation
- * @returns Generated JavaScript marshaling code as a string
- */
-export function generateMarshalCode(
-  inputLayout: FlattenedLayout,
-  outputLayout: FlattenedLayout,
-  schemaHash: bigint,
-): string {
-  const schemaHashHex = `0x${schemaHash.toString(16).padStart(16, '0')}`;
-
-  // Calculate fixed sizes (sum of all fixed-size fields)
-  const inputFixedSize = inputLayout.fields
-    .filter((f) => f.size !== -1)
-    .reduce((sum, f) => sum + f.size, 0);
-  const outputFixedSize = outputLayout.fields
-    .filter((f) => f.size !== -1)
-    .reduce((sum, f) => sum + f.size, 0);
-
-  return `
-// Generated marshaling code for schema hash ${schemaHashHex}
-// Input fixed size: ${inputFixedSize} bytes
-// Output fixed size: ${outputFixedSize} bytes
-
-// Type tags for marshaling (must match AssemblyScript runtime/Values.ts)
-// All type tags are stored as 4-byte u32
-const TAG_NULL = 0;
-const TAG_BOOLEAN = 1;
-const TAG_INT = 2;
-const TAG_FLOAT = 3;
-const TAG_STRING = 4;
-const TAG_ARRAY = 5;
-const TAG_OBJECT = 6;
-
-// Size of type tag in bytes (must match VALUE_TYPE_SIZE in AssemblyScript)
-const TAG_SIZE = 4;
-
-const SCHEMA_HASH = ${schemaHashHex}n;
-const INPUT_FIXED_SIZE = ${inputFixedSize};
-const OUTPUT_FIXED_SIZE = ${outputFixedSize};
-
-/**
- * Marshal JavaScript input object to WebAssembly memory as a ValueMap.
- *
- * The WASM runtime expects input as a ValueMap: [length: u32][keyPtr1: u32][valuePtr1: u32]...
- * where keys are raw UTF-16 strings and values are tagged Value structures.
- *
- * @param data - The input JavaScript object
- * @param memory - WebAssembly Memory instance
- * @param allocate - Function to allocate memory: (size: number) => number
- * @returns Pointer to marshaled ValueMap in WASM memory
- */
-export function marshalInput(data, memory, allocate) {
-  const view = new DataView(memory.buffer);
-  const entries = Object.entries(data);
-  const length = entries.length;
-
-  // Calculate total size needed for ValueMap
-  // Format: [length: u32][keyPtr1: u32][valuePtr1: u32]...[key data...][value data...]
-  let totalSize = 4 + length * 8; // map header + key/value pointer pairs
-
-  // Calculate size for keys (raw strings) and values (tagged)
-  for (let i = 0; i < length; i++) {
-    const [key, value] = entries[i];
-    // Key: raw UTF-16 string [length: u32][utf16 chars...]
-    totalSize += 4 + key.length * 2;
-    // Value: tagged value
-    totalSize += calculateValueSize(value);
-  }
-
-  // Allocate memory
-  const ptr = allocate(totalSize);
-
-  // Write map length
-  view.setUint32(ptr, length, true);
-
-  // Current offset for variable data (after map structure)
-  let currentOffset = ptr + 4 + length * 8;
-
-  // Write each key/value pair
-  let ptrOffset = ptr + 4;
-  for (let i = 0; i < length; i++) {
-    const [key, value] = entries[i];
-
-    // Write key as raw string (not tagged): [length: u32][utf16 chars...]
-    const keyPtr = currentOffset;
-    view.setUint32(keyPtr, key.length, true);
-    for (let j = 0; j < key.length; j++) {
-      view.setUint16(keyPtr + 4 + j * 2, key.charCodeAt(j), true);
-    }
-    currentOffset += 4 + key.length * 2;
-
-    // Write value (tagged)
-    const valuePtr = currentOffset;
-    currentOffset += writeValue(value, view, valuePtr);
-
-    // Write pointers to map structure
-    view.setUint32(ptrOffset, keyPtr, true);
-    view.setUint32(ptrOffset + 4, valuePtr, true);
-    ptrOffset += 8;
-  }
-
-  return ptr;
-}
-
-/**
- * Unmarshal WebAssembly memory to JavaScript output object.
- * @param ptr - Pointer to output data in WASM memory
- * @param memory - WebAssembly Memory instance
- * @returns The output JavaScript object
- */
-export function unmarshalOutput(ptr, memory) {
-  const view = new DataView(memory.buffer);
-
-  // Output is written using writeValue() which writes a tagged Value
-  // Use readValue() to read it back generically
-  const output = readValue(view, ptr);
-  
-  // Convert flat dotted keys to nested objects.
-  // Decision tables with passThrough emit flat keys like 'features.prioritySupport'
-  // which must be restructured into nested objects for JavaScript consumption.
-  // e.g., {"features.prioritySupport": true} -> {"features": {"prioritySupport": true}}
-  return unflattenObject(output);
-}
-
-/**
- * Convert flat dotted keys to nested objects.
- * Recursively processes objects and arrays.
- * 
- * @param value - The value to unflatten
- * @returns The unflattened value
- */
-function unflattenObject(value) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  
-  if (Array.isArray(value)) {
-    return value.map(item => unflattenObject(item));
-  }
-  
-  if (typeof value !== 'object') {
-    return value;
-  }
-  
-  const result = {};
-  
-  for (const [key, val] of Object.entries(value)) {
-    // Recursively unflatten the value first
-    const unflattenedVal = unflattenObject(val);
-    
-    if (key.includes('.')) {
-      // Split the key and create nested structure
-      const parts = key.split('.');
-      let current = result;
-      
-      for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (!(part in current)) {
-          current[part] = {};
-        } else if (typeof current[part] !== 'object' || current[part] === null) {
-          // Conflicts where both 'a' and 'a.b' exist can occur from multiple decision
-          // table rules. Nested structure takes precedence to preserve data hierarchy.
-          current[part] = {};
-        }
-        current = current[part];
-      }
-      
-      current[parts[parts.length - 1]] = unflattenedVal;
-    } else {
-      // No dot in key - check if we already have a nested object from a dotted key
-      if (key in result && typeof result[key] === 'object' && result[key] !== null && typeof unflattenedVal === 'object' && unflattenedVal !== null) {
-        // Merge the objects
-        Object.assign(result[key], unflattenedVal);
-      } else {
-        result[key] = unflattenedVal;
-      }
-    }
-  }
-  
-  return result;
-}
-
-/**
- * Calculate the total memory size needed for marshaling the input as a ValueMap.
- *
- * Format: [length: u32][keyPtr1: u32][valuePtr1: u32]...[key data...][value data...]
- */
-function calculateInputSize(data) {
-  const entries = Object.entries(data);
-  const length = entries.length;
-
-  // Map header + key/value pointer pairs
-  let size = 4 + length * 8;
-
-  // Add size for keys (raw strings) and values (tagged)
-  for (let i = 0; i < length; i++) {
-    const [key, value] = entries[i];
-    // Key: raw UTF-16 string [length: u32][utf16 chars...]
-    size += 4 + key.length * 2;
-    // Value: tagged value
-    size += calculateValueSize(value);
-  }
-
-  return size;
-}
-
-/**
- * Write null value with type tag.
- *
- * Format: [tag: u32]
- *
- * @param view - DataView for writing
- * @param offset - Offset to write at
- * @returns Total bytes written (4 bytes for tag)
- */
-function writeNull(view, offset) {
-  // Write tag
-  view.setUint32(offset, TAG_NULL, true);
-  return TAG_SIZE; // tag only
-}
-
-/**
- * Write boolean value with type tag.
- *
- * Format: [tag: u32][value: u8]
- *
- * @param value - The boolean value to write
- * @param view - DataView for writing
- * @param offset - Offset to write at
- * @returns Total bytes written (5 bytes: tag + value)
- */
-function writeBoolean(value, view, offset) {
-  // Write tag
-  view.setUint32(offset, TAG_BOOLEAN, true);
-  // Write boolean value as 1 byte (0 or 1)
-  view.setUint8(offset + TAG_SIZE, value ? 1 : 0);
-  return TAG_SIZE + 1; // tag + value
-}
-
-/**
- * Write float (number) value with type tag.
- *
- * Format: [tag: u32][value: f64]
- *
- * Handles all JavaScript number types including:
- * - Regular numbers (0, -0, integers, floats)
- * - Special values (NaN, Infinity, -Infinity)
- *
- * @param value - The number value to write
- * @param view - DataView for writing
- * @param offset - Offset to write at
- * @returns Total bytes written (12 bytes: 4-byte tag + 8-byte f64)
- */
-function writeFloat(value, view, offset) {
-  // Write tag
-  view.setUint32(offset, TAG_FLOAT, true);
-  // Write number as f64 (little-endian)
-  view.setFloat64(offset + TAG_SIZE, value, true);
-  return TAG_SIZE + 8; // tag + f64
-}
-
-/**
- * Read a float value from memory.
- *
- * Format: [tag: u32][value: f64]
- *
- * @param view - DataView for reading
- * @param offset - Offset to read from
- * @returns The decoded number value (as integer if it's a whole number)
- * @throws {Error} If type tag is not TAG_FLOAT
- */
-function readFloat(view, offset) {
-  // Read and verify tag
-  const tag = view.getUint32(offset, true);
-  if (tag !== TAG_FLOAT) {
-    throw new Error(\`Expected float tag (\${TAG_FLOAT}), got \${tag}\`);
-  }
-  // Read number as f64 (little-endian)
-  const value = view.getFloat64(offset + TAG_SIZE, true);
-  // Return as integer if it's a whole number (for cleaner JSON output)
-  if (Number.isInteger(value)) {
-    return value;
-  }
-  return value;
-}
-
-/**
- * Write a UTF-16 string to memory with type tag.
- *
- * Format: [tag: u32][pointer: u32] - pointer points to string data
- * String data format: [length: u32][utf16 code units...]
- *
- * The pointer in the Value structure points immediately after the Value structure
- * itself (at offset + 8), where the string data begins.
- *
- * Uses UTF-16 encoding to match AssemblyScript's native string format.
- *
- * @param str - The string to write
- * @param view - DataView for writing
- * @param offset - Offset to write at
- * @returns Total bytes written (tag + pointer + string data)
- */
-function writeString(str, view, offset) {
-  const len = str.length;
-  // Write tag
-  view.setUint32(offset, TAG_STRING, true);
-  // String data starts right after the Value structure (tag + pointer = 8 bytes)
-  const stringDataPtr = offset + TAG_SIZE + 4;
-  // Write pointer to string data
-  view.setUint32(offset + TAG_SIZE, stringDataPtr, true);
-  // Write string data: [length: u32][utf16 code units...]
-  view.setUint32(stringDataPtr, len, true);
-  for (let i = 0; i < len; i++) {
-    view.setUint16(stringDataPtr + 4 + i * 2, str.charCodeAt(i), true);
-  }
-  // Total: tag (4) + pointer (4) + length (4) + utf16 data (len * 2)
-  return 8 + 4 + len * 2;
-}
-
-/**
- * Read null value with type tag.
- *
- * Format: [tag: u32]
- *
- * @param view - DataView for reading
- * @param offset - Offset to read from
- * @returns null value
- * @throws {Error} If type tag is not TAG_NULL
- */
-function readNull(view, offset) {
-  // Read and verify tag
-  const tag = view.getUint32(offset, true);
-  if (tag !== TAG_NULL) {
-    throw new Error(\`Expected null tag (\${TAG_NULL}), got \${tag}\`);
-  }
-  return null;
-}
-
-/**
- * Read boolean value with type tag.
- *
- * Format: [tag: u32][value: u8]
- *
- * @param view - DataView for reading
- * @param offset - Offset to read from
- * @returns The decoded boolean value
- * @throws {Error} If type tag is not TAG_BOOLEAN
- */
-function readBoolean(view, offset) {
-  // Read and verify tag
-  const tag = view.getUint32(offset, true);
-  if (tag !== TAG_BOOLEAN) {
-    throw new Error(\`Expected boolean tag (\${TAG_BOOLEAN}), got \${tag}\`);
-  }
-  // Read boolean value and convert to boolean
-  const value = view.getUint8(offset + TAG_SIZE);
-  return value !== 0;
-}
-
-/**
- * Read an integer value from memory with type tag.
- *
- * Format: [tag: u32][value: i64]
- *
- * @param view - DataView for reading
- * @param offset - Offset to read from
- * @returns The decoded integer value
- * @throws {Error} If type tag is not TAG_INT
- */
-function readInt(view, offset) {
-  // Read and verify tag
-  const tag = view.getUint32(offset, true);
-  if (tag !== TAG_INT) {
-    throw new Error(\`Expected int tag (\${TAG_INT}), got \${tag}\`);
-  }
-  // Read i64 value (little-endian)
-  // JavaScript DataView doesn't have getBigInt64 in older versions, so use two 32-bit reads
-  const low = view.getUint32(offset + TAG_SIZE, true);
-  const high = view.getInt32(offset + TAG_SIZE + 4, true);
-  // Combine to form a 64-bit signed integer
-  // For values that fit in Number, this works fine
-  const value = low + high * 0x100000000;
-  return value;
-}
-
-/**
- * Read a UTF-16 string from memory with type tag.
- *
- * WASM Format: [tag: u32=4][stringPtr: u32]
- * String data at stringPtr: [length: u32][utf16 chars...]
- *
- * FORMAT DIFFERENCE: This reads the canonical WASM representation using pointers
- * and UTF-16 encoding (AssemblyScript's native string format), while writeString()
- * uses an inlined UTF-8 format for simplicity. Both are valid Value representations.
- *
- * @param view - DataView for reading
- * @param offset - Offset to read from
- * @returns The decoded string
- * @throws {Error} If type tag is not TAG_STRING
- */
-function readString(view, offset) {
-  // Read and verify tag
-  const tag = view.getUint32(offset, true);
-  if (tag !== TAG_STRING) {
-    throw new Error(\`Expected string tag (\${TAG_STRING}), got \${tag}\`);
-  }
-  // Read pointer to string data
-  const stringPtr = view.getUint32(offset + TAG_SIZE, true);
-  
-  // Read string data from the pointer
-  if (stringPtr === 0) return '';
-  
-  const length = view.getUint32(stringPtr, true);
-  if (length === 0) return '';
-  
-  // Read UTF-16 code units and convert to string
-  let result = '';
-  for (let i = 0; i < length; i++) {
-    const codeUnit = view.getUint16(stringPtr + 4 + i * 2, true);
-    result += String.fromCharCode(codeUnit);
-  }
-  
-  return result;
-}
-
-/**
- * Marshal a primitive value to memory with automatic type detection.
- *
- * Supports null, boolean, number, and string types.
- *
- * @param value - The value to write (null, boolean, number, or string)
- * @param view - DataView for writing
- * @param offset - Offset to write at
- * @returns Total bytes written
- * @throws {Error} If value type is not supported
- */
-function writePrimitive(value, view, offset) {
-  if (value === null) {
-    return writeNull(view, offset);
-  } else if (typeof value === 'boolean') {
-    return writeBoolean(value, view, offset);
-  } else if (typeof value === 'number') {
-    return writeFloat(value, view, offset);
-  } else if (typeof value === 'string') {
-    return writeString(value, view, offset);
-  } else {
-    throw new Error('Unsupported type for marshaling: ' + typeof value);
-  }
-}
-
-/**
- * Read a primitive value from memory with type detection.
- *
- * Reads the type tag and dispatches to the appropriate read function.
- *
- * @param view - DataView for reading
- * @param offset - Offset to read from
- * @returns The decoded value (null, boolean, number, or string)
- * @throws {Error} If type tag is not recognized
- */
-function readPrimitive(view, offset) {
-  const tag = view.getUint32(offset, true);
-  switch (tag) {
-    case TAG_NULL:
-      return readNull(view, offset);
-    case TAG_BOOLEAN:
-      return readBoolean(view, offset);
-    case TAG_INT:
-      return readInt(view, offset);
-    case TAG_FLOAT:
-      return readFloat(view, offset);
-    case TAG_STRING:
-      return readString(view, offset);
-    default:
-      throw new Error('Unexpected type tag: ' + tag);
-  }
-}
-
-/**
- * Marshal an object to memory.
- * Returns the total bytes written for the object.
- *
- * Format: [tag: u32][propertyCount: u32][key1: tagged string][value1: tagged][key2: tagged string][value2: tagged]...
- *
- * Keys are written as tagged strings, followed by tagged values.
- * Property order is preserved for deterministic serialization using Object.entries.
- *
- * @param obj - The object to marshal
- * @param view - DataView for writing
- * @param writeOffset - Offset to write the object at
- * @returns Total bytes written
- */
-function writeObject(obj, view, writeOffset) {
-  const startOffset = writeOffset;
-  let offset = writeOffset;
-
-  // Write tag
-  view.setUint32(offset, TAG_OBJECT, true);
-  offset += TAG_SIZE;
-
-  // Get properties in order
-  const entries = Object.entries(obj);
-  const propCount = entries.length;
-
-  // Write property count
-  view.setUint32(offset, propCount, true);
-  offset += 4;
-
-  // Write each (key, value) pair
-  for (let i = 0; i < propCount; i++) {
-    const [key, value] = entries[i];
-
-    // Write key as tagged string (keys are tagged with TAG_STRING)
-    offset += writeString(key, view, offset);
-
-    // Write value (tagged)
-    offset += writeValue(value, view, offset);
-  }
-
-  return offset - startOffset;
-}
-
-/**
- * Marshal a value to memory with automatic type detection.
- *
- * Supports null, boolean, number, string, array, and object types.
- * This is the top-level value marshaling function that dispatches to
- * the appropriate type-specific function.
- *
- * @param value - The value to write
- * @param view - DataView for writing
- * @param offset - Offset to write at
- * @returns Total bytes written
- * @throws {Error} If value type is not supported
- */
-function writeValue(value, view, offset) {
-  if (value === null || value === undefined) {
-    return writeNull(view, offset);
-  } else if (typeof value === 'boolean') {
-    return writeBoolean(value, view, offset);
-  } else if (typeof value === 'number') {
-    return writeFloat(value, view, offset);
-  } else if (typeof value === 'string') {
-    return writeString(value, view, offset);
-  } else if (Array.isArray(value)) {
-    return writeArray(value, view, 0, offset);
-  } else if (typeof value === 'object') {
-    return writeObject(value, view, offset);
-  } else {
-    throw new Error('Unsupported type for marshaling: ' + typeof value);
-  }
-}
-
-/**
- * Read an object from memory.
- *
- * WASM Format: Value.Object has: [type: u32=6][objectPtr: u32]
- * objectPtr points to Map structure: [propCount: u32][keyPtr1: u32][valuePtr1: u32][keyPtr2: u32][valuePtr2: u32]...
- * Key pointers point to UTF-16 string data
- * Value pointers point to heap-allocated tagged values.
- *
- * @param view - DataView for reading
- * @param offset - Offset to the Value.Object structure (NOT objectPtr)
- * @returns The unmarshaled object
- */
-function readObject(view, offset) {
-  // Two cases:
-  // 1. If offset has TAG_OBJECT (6), it's a Value.Object structure: [type: u32][objectPtr: u32]
-  // 2. Otherwise, offset might already point to the Map structure directly
-
-  const tag = view.getUint32(offset, true);
-  let objectPtr;
-
-  if (tag === TAG_OBJECT) {
-    // Case 1: Value.Object structure, read pointer to Map
-    objectPtr = view.getUint32(offset + 4, true);
-  } else {
-    // Case 2: offset point directly to Map structure
-    objectPtr = offset;
-  }
-
-  const result = {};
-  if (objectPtr !== 0) {
-    // Read property count from map structure
-    const propCount = view.getUint32(objectPtr, true);
-    let mapOffset = objectPtr + 4;
-
-    for (let i = 0; i < propCount; i++) {
-      // Read key pointer and value pointer
-      const keyPtr = view.getUint32(mapOffset, true);
-      const valuePtr = view.getUint32(mapOffset + 4, true);
-      mapOffset += 8;
-
-      // Read key (raw UTF-16 string data at keyPtr: [length: u32][utf16 chars...])
-      const keyLen = view.getUint32(keyPtr, true);
-      let key = '';
-      for (let j = 0; j < keyLen; j++) {
-        const codeUnit = view.getUint16(keyPtr + 4 + j * 2, true);
-        key += String.fromCharCode(codeUnit);
-      }
-
-      // Read value (tagged value at valuePtr)
-      const value = readValue(view, valuePtr);
-
-      result[key] = value;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Calculate the size in bytes of a tagged value at the given offset.
- *
- * @param view - DataView for reading
- * @param offset - Offset to calculate size from
- * @returns Total bytes the value occupies
- * @throws {Error} If type tag is not recognized
- */
-function getValueSize(view, offset) {
-  const tag = view.getUint32(offset, true);
-
-  switch (tag) {
-    case TAG_NULL:
-      return TAG_SIZE;
-    case TAG_BOOLEAN:
-      return TAG_SIZE + 1;
-    case TAG_INT:
-      return TAG_SIZE + 8;
-    case TAG_FLOAT:
-      return TAG_SIZE + 8;
-    case TAG_STRING: {
-      const strLen = view.getUint32(offset + TAG_SIZE, true);
-      return TAG_SIZE + 4 + strLen;
-    }
-    case TAG_ARRAY: {
-      const arrLen = view.getUint32(offset + TAG_SIZE, true);
-      let size = TAG_SIZE + 4; // tag + length
-      let elemOffset = offset + TAG_SIZE + 4;
-      for (let i = 0; i < arrLen; i++) {
-        const elemSize = getValueSize(view, elemOffset);
-        size += elemSize;
-        elemOffset += elemSize;
-      }
-      return size;
-    }
-    case TAG_OBJECT: {
-      const propCount = view.getUint32(offset + TAG_SIZE, true);
-      let size = TAG_SIZE + 4; // tag + property count
-      let propOffset = offset + TAG_SIZE + 4;
-      for (let i = 0; i < propCount; i++) {
-        // Skip key (tagged string)
-        const keySize = getValueSize(view, propOffset);
-        size += keySize;
-        propOffset += keySize;
-
-        // Skip value (tagged value)
-        const valSize = getValueSize(view, propOffset);
-        size += valSize;
-        propOffset += valSize;
-      }
-      return size;
-    }
-    default:
-      throw new Error('Unexpected type tag: ' + tag);
-  }
-}
-
-/**
- * Read a value from memory with type detection.
- *
- * Reads the type tag and dispatches to the appropriate read function.
- *
- * @param view - DataView for reading
- * @param offset - Offset to read from
- * @returns The decoded value
- * @throws {Error} If type tag is not recognized
- */
-function readValue(view, offset) {
-  const tag = view.getUint32(offset, true);
-  switch (tag) {
-    case TAG_NULL:
-      return readNull(view, offset);
-    case TAG_BOOLEAN:
-      return readBoolean(view, offset);
-    case TAG_INT:
-      return readInt(view, offset);
-    case TAG_FLOAT:
-      return readFloat(view, offset);
-    case TAG_STRING:
-      return readString(view, offset);
-    case TAG_ARRAY:
-      return readArray(view, offset);
-    case TAG_OBJECT:
-      return readObject(view, offset);
-    default:
-      throw new Error('Unexpected type tag: ' + tag);
-  }
-}
-
-/**
- * Marshal an array to memory.
- * Returns the total bytes written for the array.
- *
- * Format: [tag: u32][length: u32][tagged elements...]
- *
- * @param arr - The array to marshal
- * @param view - DataView for writing
- * @param ptr - Base pointer (unused, kept for API compatibility)
- * @param writeOffset - Offset to write the array at
- * @returns Total bytes written
- */
-function writeArray(arr, view, ptr, writeOffset) {
-  const startOffset = writeOffset;
-  let offset = writeOffset;
-
-  // Write tag
-  view.setUint32(offset, TAG_ARRAY, true);
-  offset += TAG_SIZE;
-
-  // Write length
-  view.setUint32(offset, arr.length, true);
-  offset += 4;
-
-  // Write elements recursively
-  for (let i = 0; i < arr.length; i++) {
-    const value = arr[i];
-    offset += writeValue(value, view, offset);
-  }
-
-  return offset - startOffset;
-}
-
-/**
- * Calculate the size needed to marshal an object.
- *
- * Format: [tag: byte][propertyCount: u32][key1: tagged string][value1: tagged][key2: tagged string][value2: tagged]...
- *
- * @param obj - The object to calculate size for
- * @returns Total bytes needed for the object
- */
-function calculateObjectSize(obj) {
-  let size = 5; // tag (1 byte) + property count (4 bytes)
-
-  const entries = Object.entries(obj);
-  for (let i = 0; i < entries.length; i++) {
-    const [key, value] = entries[i];
-    // Key: tagged string (tag: 4 + pointer: 4 + length: 4 + UTF-16 data: 2 bytes per code unit)
-    size += 8 + 4 + key.length * 2;
-    // Value: calculate size of tagged value
-    size += calculateValueSize(value);
-  }
-
-  return size;
-}
-
-/**
- * Calculate the size needed to marshal a value.
- *
- * @param value - The value to calculate size for
- * @returns Total bytes needed for the value
- */
-function calculateValueSize(value) {
-  if (value === null || value === undefined) {
-    return 1;
-  } else if (typeof value === 'boolean') {
-    return 2;
-  } else if (typeof value === 'number') {
-    return 9;
-  } else if (typeof value === 'string') {
-    // tag (4) + pointer (4) + length (4) + UTF-16 data (2 bytes per code unit)
-    return 8 + 4 + value.length * 2;
-  } else if (Array.isArray(value)) {
-    let size = 5;
-    for (let i = 0; i < value.length; i++) {
-      size += calculateValueSize(value[i]);
-    }
-    return size;
-  } else if (typeof value === 'object') {
-    return calculateObjectSize(value);
-  } else {
-    throw new Error('Unsupported type for marshaling: ' + typeof value);
-  }
-}
-
-/**
- * Read an array from memory.
- *
- * WASM Format: Value.Array has: [type: u32=5][arrayPtr: u32]
- * arrayPtr points to array structure: [length: u32][elementPtr1: u32][elementPtr2: u32]...
- * Each elementPtr points to a tagged Value structure
- *
- * @param view - DataView for reading
- * @param offset - Offset to the Value.Array structure (NOT arrayPtr)
- * @returns The unmarshaled array
- */
-function readArray(view, offset) {
-  // Two cases:
-  // 1. If offset has TAG_ARRAY (5), it's a Value.Array structure: [type: u32][arrayPtr: u32]
-  // 2. Otherwise, offset might already point to the array structure directly
-
-  const tag = view.getUint32(offset, true);
-  let arrayPtr;
-
-  if (tag === TAG_ARRAY) {
-    // Case 1: Value.Array structure, read pointer to array data
-    arrayPtr = view.getUint32(offset + 4, true);
-  } else {
-    // Case 2: offset points directly to array structure
-    arrayPtr = offset;
-  }
-
-  // Validate arrayPtr is within bounds
-  if (arrayPtr === 0 || arrayPtr >= view.byteLength) {
-    return [];
-  }
-
-  // Read length field (may have high bit set for flat format)
-  const lengthField = view.getUint32(arrayPtr, true);
-  const FLAT_ARRAY_MARKER = 0x80000000;
-
-  // Check if this is a flat numeric array (high bit set)
-  if ((lengthField & FLAT_ARRAY_MARKER) !== 0) {
-    // Flat numeric format: [length | marker: u32][f64 elements...]
-    const length = lengthField & ~FLAT_ARRAY_MARKER;
-    const result = [];
-    for (let i = 0; i < length; i++) {
-      const value = view.getFloat64(arrayPtr + 4 + i * 8, true);
-      result.push(value);
-    }
-    return result;
-  }
-
-  // Generic format: [length: u32][Value pointers...]
-  const length = lengthField;
-
-  // Read element pointers and dereference them
-  const result = [];
-  for (let i = 0; i < length; i++) {
-    const elemPtr = view.getUint32(arrayPtr + 4 + i * 4, true);
-    // Skip invalid pointers
-    if (elemPtr === 0 || elemPtr >= view.byteLength) {
-      result.push(null);
-      continue;
-    }
-    const value = readValue(view, elemPtr);
-    result.push(value);
-  }
-
-  return result;
-}
-`;
-}
-
-/**
- * Generate the unmarshal function body.
- *
- * This function is currently unused but kept for potential future use with alternative
- * marshaling strategies. It generates code to read fixed-layout structs directly,
- * which could be more efficient than the current generic Value-based approach.
- *
- * @param layout - The flattened schema layout
- * @param _prefix - Unused parameter (reserved for potential future use with prefixed field names)
- * @returns Generated JavaScript code for unmarshaling
- */
-export function _generateUnmarshalBody(layout: FlattenedLayout, _prefix: string): string {
-  const lines: string[] = [];
-
-  lines.push('  const output = {};');
-  lines.push('');
-
-  // Build nested object structure
-  const paths = buildNestedPaths(layout.fields);
-  lines.push(...paths);
-
-  lines.push('');
-
-  // Read fixed fields
-  for (const field of layout.fields) {
-    if (field.type === 'string' || field.type === 'array') {
-      // Skip - handled in variable section
-      continue;
-    } else if (field.type === 'bool') {
-      lines.push('  // ' + field.path);
-      lines.push(
-        `  output${field.path
-          .split('.')
-          .map((p) => `['${p}']`)
-          .join('')} = view.getUint32(readOffset + ${field.offset}, true) !== 0;`,
-      );
-    } else if (field.type === 'i64') {
-      lines.push('  // ' + field.path);
-      lines.push(
-        `  output${field.path
-          .split('.')
-          .map((p) => `['${p}']`)
-          .join('')} = Number(view.getBigInt64(readOffset + ${field.offset}, true));`,
-      );
-    } else {
-      lines.push('  // ' + field.path);
-      const valueGetter = field.type === 'f64' ? 'getFloat64' : 'getInt32';
-      lines.push(
-        `  output${field.path
-          .split('.')
-          .map((p) => `['${p}']`)
-          .join('')} = view.${valueGetter}(readOffset + ${field.offset}, true);`,
-      );
-    }
-  }
-
-  // Read variable-length data
-  for (const field of layout.fields) {
-    if (field.type === 'string') {
-      lines.push('');
-      lines.push('  // ' + field.path);
-      lines.push(
-        `  const ${field.flatName}_ptr = view.getUint32(readOffset + ${field.offset}, true);`,
-      );
-      lines.push(
-        `  const ${field.flatName}_len = view.getUint32(readOffset + ${field.offset} + 4, true);`,
-      );
-      lines.push(
-        `  output${field.path
-          .split('.')
-          .map((p) => `['${p}']`)
-          .join('')} = ${field.flatName}_len > 0 ? readString(view, ${field.flatName}_ptr) : '';`,
-      );
-    } else if (field.type === 'array') {
-      lines.push('');
-      lines.push('  // ' + field.path);
-      lines.push(
-        `  const ${field.flatName}_ptr = view.getUint32(readOffset + ${field.offset}, true);`,
-      );
-      lines.push(
-        `  const ${field.flatName}_len = view.getUint32(readOffset + ${field.offset} + 4, true);`,
-      );
-      lines.push(
-        `  output${field.path
-          .split('.')
-          .map((p) => `['${p}']`)
-          .join('')} = readArray(view, ${field.flatName}_ptr);`,
-      );
-    }
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Build nested object initialization code
- */
-function buildNestedPaths(fields: Array<{ path: string }>): string[] {
-  const paths: string[] = [];
-  const nestedObjects = new Set<string>();
-
-  for (const field of fields) {
-    const parts = field.path.split('.');
-    for (let i = 0; i < parts.length - 1; i++) {
-      const prefix = parts.slice(0, i + 1).join('.');
-      if (!nestedObjects.has(prefix)) {
-        nestedObjects.add(prefix);
-        const code = `  output${prefix
-          .split('.')
-          .map((p) => `['${p}']`)
-          .join('')} = {};`;
-        paths.push(code);
-      }
-    }
-  }
-
-  // Deduplicate and sort
-  return Array.from(new Set(paths));
-}