@divmain/jdm-asm 0.2.0

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

@@ -0,0 +1,999 @@
+/**
+ * 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));
+}