@smoothbricks/lmao 0.2.2 → 0.2.3

package/dist/lib/wasm/wasmSpanBuffer.js

@@ -11,6 +11,15 @@
  */
 import { getSchemaType } from '@smoothbricks/arrow-builder';
 import { checkCapacityTuning } from '../capacityTuning.js';
+import { getVocabularyGeneration } from '../vocabularyRegistry.js';
+import { WASM_NO_LAYOUT_OFFSET, WASM_SPAN_IDENTITY_CHILD, WASM_SPAN_IDENTITY_ROOT, } from './wasmAllocator.js';
+import { getWasmPhysicalLayout, } from './wasmPhysicalLayout.js';
+const EMPTY_EAGER_COLUMNS = Object.freeze({
+    names: Object.freeze([]),
+    words: Object.freeze([]),
+    key: '',
+});
+let nextWasmBufferGeneration = 0;
 function getFieldEager(value) {
     return typeof value === 'object' && value !== null && Reflect.get(value, '__eager') === true;
 }
@@ -21,23 +30,13 @@ function getFieldEnumValues(value) {
     const enumValues = Reflect.get(value, '__enum_values');
     return Array.isArray(enumValues) ? enumValues : undefined;
 }
-function isColumnValueType(value) {
-    return value === undefined || Array.isArray(value) || ArrayBuffer.isView(value);
-}
-function getFreeMethod(sizeClass) {
-    switch (sizeClass) {
-        case '1b':
-            return 'free1B';
-        case '4b':
-            return 'free4B';
-        case '8b':
-            return 'free8B';
-    }
-}
-function isWasmSpanBufferConstructor(value) {
+function isWasmSpanBufferConstructor(value, schema, messageLayoutFamily, messagePhysicalLayout) {
     return (typeof value === 'function' &&
         typeof Reflect.get(value, 'schema') === 'object' &&
         Reflect.get(value, 'schema') !== null &&
+        (schema === undefined || Reflect.get(value, 'schema') === schema) &&
+        (messageLayoutFamily === undefined || Reflect.get(value, 'messageLayoutFamily') === messageLayoutFamily) &&
+        (messagePhysicalLayout === undefined || Reflect.get(value, 'messagePhysicalLayout') === messagePhysicalLayout) &&
         typeof Reflect.get(value, 'stats') === 'object' &&
         Reflect.get(value, 'stats') !== null);
 }
@@ -45,7 +44,7 @@ export function isWasmSpanBufferInstance(value) {
     return typeof value === 'object' && value !== null && typeof Reflect.get(value, '_systemPtr') === 'number';
 }
 function getWasmSpanBufferConstructor(instance) {
-    if (!isWasmSpanBufferConstructor(instance.constructor)) {
+    if (!isWasmSpanBufferConstructor(instance.constructor, instance._logSchema)) {
         throw new Error('Expected generated WasmSpanBuffer constructor');
     }
     return instance.constructor;
@@ -57,14 +56,15 @@ function isWasmSpanBufferFactory(value) {
  * Build column metadata array from schema.
  * Maps each schema field to its storage characteristics.
  */
-function buildColumnMeta(schema) {
+function buildColumnMeta(schema, eagerColumns) {
     const result = [];
     const fields = schema.fields;
+    const preallocatedColumns = new Set(eagerColumns.names);
     let columnIndex = 0;
     for (const name of schema._columnNames) {
         const field = fields[name];
         const schemaType = getSchemaType(field);
-        const isEager = getFieldEager(field);
+        const isSchemaEager = getFieldEager(field);
         const enumValues = getFieldEnumValues(field);
         let sizeClass;
         switch (schemaType) {
@@ -88,7 +88,8 @@ function buildColumnMeta(schema) {
             sizeClass,
             schemaType: schemaType ?? 'unknown',
             columnIndex,
-            isEager,
+            isSchemaEager,
+            isPreallocated: !isSchemaEager && preallocatedColumns.has(name),
             enumValues,
         });
         columnIndex++;
@@ -98,45 +99,42 @@ function buildColumnMeta(schema) {
 // =============================================================================
 // Common WasmSpanBuffer Methods (shared via prototype)
 // =============================================================================
-/**
- * Get timestamp column view from WASM memory.
- * Assigned to prototype after class generation.
- */
+function wasmEnsureViews() {
+    assertWasmBufferLive(this);
+    const memoryVersion = this._allocator.refreshViews();
+    if (memoryVersion !== this._viewVersion)
+        this._refreshViews(memoryVersion);
+}
 function wasmGetTimestamp() {
-    return new BigInt64Array(this._allocator.memory.buffer, this._systemPtr, this._capacity);
+    wasmEnsureViews.call(this);
+    return this._timestampView;
 }
-/**
- * Get entry_type column view from WASM memory.
- * Assigned to prototype after class generation.
- */
 function wasmGetEntryType() {
-    return new Uint8Array(this._allocator.memory.buffer, this._systemPtr + this._capacity * 8, this._capacity);
+    wasmEnsureViews.call(this);
+    return this._entryTypeView;
+}
+function assertWasmBufferLive(buffer) {
+    if (buffer._descriptor.state !== 'live') {
+        const generation = buffer._descriptor.generation;
+        throw new Error(`Cannot access released WASM buffer generation ${generation}; generation ${generation} has been released`);
+    }
 }
-/**
- * Get writeIndex from WASM identity block.
- */
 function wasmGetWriteIndex() {
-    return this._allocator.readWriteIndex(this._identityPtr);
+    wasmEnsureViews.call(this);
+    return this._identityOwner ? this._identityData.getUint32(0, true) : this._overflowWriteIndex;
 }
-/**
- * Set writeIndex in WASM identity block.
- */
 function wasmSetWriteIndex(value) {
-    new DataView(this._allocator.memory.buffer).setUint32(this._identityPtr, value, true);
+    wasmEnsureViews.call(this);
+    if (this._identityOwner) {
+        this._identityData.setUint32(0, value, true);
+    }
+    else {
+        this._overflowWriteIndex = value;
+    }
 }
-/**
- * Get trace_id from WASM identity block.
- */
 function wasmGetTraceId() {
-    const len = this._allocator.readIdentityTraceIdLen(this._identityPtr);
-    if (len === 0) {
-        let p = this._parent;
-        while (p?._parent)
-            p = p._parent;
-        return p ? p.trace_id : '';
-    }
-    const traceIdPtr = this._allocator.getIdentityTraceIdPtr(this._identityPtr);
-    return new TextDecoder().decode(new Uint8Array(this._allocator.memory.buffer, traceIdPtr, len));
+    assertWasmBufferLive(this);
+    return this._traceRoot.trace_id;
 }
 function wasmGetSpanStartTime() {
     return this.timestamp[0];
@@ -163,15 +161,12 @@ function wasmGetLastLoggedTime() {
  * Get thread_id from WASM identity block.
  */
 function wasmGetThreadId() {
-    const high = this._allocator.getThreadIdHigh();
-    const low = this._allocator.getThreadIdLow();
-    return (BigInt(high) << 32n) | BigInt(low);
+    assertWasmBufferLive(this);
+    return this._threadId;
 }
-/**
- * Get span_id from WASM identity block.
- */
 function wasmGetSpanId() {
-    return this._allocator.readIdentitySpanId(this._identityPtr);
+    assertWasmBufferLive(this);
+    return this._spanId;
 }
 /**
  * Get parent_thread_id.
@@ -191,93 +186,102 @@ function wasmGetParentSpanId() {
 function wasmGetHasParent() {
     return this._parent !== null;
 }
-/**
- * Message column setter.
- */
-function wasmMessage(idx, value) {
+function wasmRawMessage(idx, value) {
+    assertWasmBufferLive(this);
     this._message[idx] = value;
     return this;
 }
+function wasmStaticMessage(idx, value) {
+    assertWasmBufferLive(this);
+    if (idx === 0)
+        this._spanName = value;
+    else if (idx === 1)
+        this._terminalMessage = value;
+    else
+        throw new RangeError('Static-only buffers only accept raw system messages at rows 0 and 1');
+    return this;
+}
 /**
  * Get message column values.
  */
 function wasmGetMessageValues() {
+    assertWasmBufferLive(this);
     return this._message;
 }
-/**
- * Get message column nulls (always undefined for eager column).
- */
-function wasmGetMessageNulls() {
-    return undefined;
+function wasmGetMessageLayoutFamily() {
+    return getWasmSpanBufferConstructor(this).messageLayoutFamily;
 }
-/**
- * Free all WASM memory for this buffer.
- */
+function wasmGetMessagePhysicalLayout() {
+    return getWasmSpanBufferConstructor(this).messagePhysicalLayout;
+}
+/** Free the one owned root/child/overflow superblock exactly once. */
 function wasmFree() {
-    // Free identity block
-    this._allocator.freeIdentity(this._identityPtr);
-    // Free system block
-    this._allocator.freeSpanSystem(this._systemPtr);
-    // Free column blocks
-    const columnMeta = buildColumnMeta(this._logSchema);
-    for (const col of columnMeta) {
-        if (col.sizeClass !== 'string' && this._columnPtrs[col.columnIndex] >= 0) {
-            const freeMethod = getFreeMethod(col.sizeClass);
-            this._allocator[freeMethod](this._columnPtrs[col.columnIndex]);
-        }
-    }
+    if (this._descriptor.state === 'freed')
+        return;
+    if (this._viewVersion !== 0)
+        this._sealStats();
+    this._allocator.freeSpanSuperblock(this._allocationPtr, this._allocationByteLength);
+    this._descriptor.state = 'freed';
 }
 /**
  * Check if column is allocated.
  */
 function wasmIsColumnAllocated(columnIndex) {
-    return this._columnPtrs[columnIndex] >= 0;
+    assertWasmBufferLive(this);
+    wasmEnsureViews.call(this);
+    return this._columnPtrs[columnIndex] >= 0 || this._getWasmColumnValue(columnIndex) !== undefined;
 }
-/**
- * Get column values if allocated.
- */
+/** Get a canonical column value view or JS sidecar without accessor reflection. */
 function wasmGetColumnIfAllocated(columnName) {
+    assertWasmBufferLive(this);
     const idx = this._logSchema._columnNames.indexOf(columnName);
     if (idx === -1)
         return undefined;
-    const getter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this), `${columnName}_values`);
-    if (getter?.get) {
-        const value = getter.get.call(this);
-        return isColumnValueType(value) ? value : undefined;
-    }
-    return undefined;
+    wasmEnsureViews.call(this);
+    return this._getWasmColumnValue(idx);
 }
-/**
- * Get column nulls if allocated.
- */
+/** Get a canonical column null-bitmap view without accessor reflection. */
 function wasmGetNullsIfAllocated(columnName) {
-    const getter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this), `${columnName}_nulls`);
-    if (getter?.get) {
-        return getter.get.call(this);
-    }
-    return undefined;
+    assertWasmBufferLive(this);
+    const idx = this._logSchema._columnNames.indexOf(columnName);
+    if (idx === -1)
+        return undefined;
+    wasmEnsureViews.call(this);
+    return this._getWasmColumnNulls(idx);
 }
-/**
- * Get system ArrayBuffer for compatibility with AnySpanBuffer.
- * WASM uses shared memory, so this returns the entire WASM memory buffer.
- */
+/** Get the current WASM memory backing store. */
 function wasmGetSystem() {
+    wasmEnsureViews.call(this);
     return this._allocator.memory.buffer;
 }
-/**
- * Get identity Uint8Array for compatibility with AnySpanBuffer.
- * Returns a view of the identity block (48 bytes) in WASM memory.
- */
+/** Get the canonical identity view for the current memory version. */
 function wasmGetIdentity() {
-    // Identity block is 48 bytes: writeIndex(4) + reserved(4) + span_id(4) + trace_id_len(1) + trace_id(up to 35)
-    return new Uint8Array(this._allocator.memory.buffer, this._identityPtr, 48);
+    wasmEnsureViews.call(this);
+    return this._identityView;
+}
+function wasmSealStats() {
+    if (this._statsSealed)
+        return;
+    const completedRows = this._writeIndex - this._statsReservedRows;
+    if (completedRows > 0)
+        getWasmSpanBufferConstructor(this).stats.totalWrites += completedRows;
+    this._statsSealed = true;
+}
+function wasmSealStatsChain() {
+    let current = this;
+    while (current) {
+        current._sealStats();
+        current = current._overflow;
+    }
 }
 /**
  * Get or create overflow buffer.
  */
 function wasmGetOrCreateOverflow() {
+    assertWasmBufferLive(this);
     if (this._overflow)
         return this._overflow;
+    this._sealStats();
     const tracer = this._traceRoot.tracer;
     tracer.onStatsWillResetFor(this);
     checkCapacityTuning(getWasmSpanBufferConstructor(this).stats);
@@ -313,63 +317,26 @@ function wasmInspect() {
  * Generate eager column initialization code for constructor.
  * Eager columns are pre-allocated, lazy columns start as undefined/-1.
  */
-function generateEagerColumnInit(columnMeta) {
+function generateColumnInit(columnMeta) {
     const lines = [];
     for (const col of columnMeta) {
-        if (col.name === 'message')
-            continue; // Message handled separately
-        if (col.sizeClass === 'string') {
-            if (col.isEager) {
-                lines.push(`this._${col.name}_values = new Array(this._capacity);`);
-            }
-            else {
-                lines.push(`this._${col.name}_values = undefined;`);
-                lines.push(`this._${col.name}_nulls = undefined;`);
-            }
+        if (col.name === 'message' || col.sizeClass !== 'string')
+            continue;
+        if (col.isSchemaEager) {
+            lines.push(`this._${col.name}_values = new Array(this._capacity);`);
+        }
+        else if (col.isPreallocated) {
+            lines.push(`this._${col.name}_values = new Array(this._capacity);`);
+            lines.push(`this._${col.name}_nulls = new Uint8Array((this._capacity + 7) >>> 3);`);
         }
-        else if (col.isEager) {
-            lines.push(`this._columnPtrs[${col.columnIndex}] = this._allocator.alloc${col.sizeClass.toUpperCase()}();`);
+        else {
+            lines.push(`this._${col.name}_values = undefined;`);
+            lines.push(`this._${col.name}_nulls = undefined;`);
         }
     }
     return lines.join('\n    ');
 }
-/**
- * Generate setter method for a numeric column (stored in WASM).
- * Calls WASM exports directly for hot path optimization.
- */
-function generateNumericSetter(col) {
-    const allocMethod = `alloc${col.sizeClass.toUpperCase()}`;
-    // Map to WASM export names
-    const writeExportName = col.schemaType === 'number' || col.schemaType === 'bigUint64'
-        ? 'write_col_f64'
-        : col.sizeClass === '1b'
-            ? 'write_col_u8'
-            : col.sizeClass === '4b'
-                ? 'write_col_u32'
-                : 'write_col_f64';
-    if (col.isEager) {
-        // Eager: column is pre-allocated, just write value (call WASM export directly)
-        return `${col.name}(idx, value) {
-    const ptr = this._columnPtrs[${col.columnIndex}];
-    this._allocator.exports.${writeExportName}(ptr, idx, value, this._capacity);
-    return this;
-  }`;
-    }
-    // Lazy: allocate on first write (call WASM export directly)
-    return `${col.name}(idx, value) {
-    let ptr = this._columnPtrs[${col.columnIndex}];
-    if (ptr < 0) {
-      ptr = this._allocator.${allocMethod}();
-      this._columnPtrs[${col.columnIndex}] = ptr;
-    }
-    this._allocator.exports.${writeExportName}(ptr, idx, value, this._capacity);
-    return this;
-  }`;
-}
-/**
- * Generate getter for numeric column values (creates view on demand).
- */
-function generateNumericValuesGetter(col) {
+function generateNumericViewBinding(col, layoutIndex) {
     const arrayType = col.schemaType === 'number'
         ? 'Float64Array'
         : col.schemaType === 'bigUint64'
@@ -379,59 +346,146 @@ function generateNumericValuesGetter(col) {
                 : col.sizeClass === '4b'
                     ? 'Uint32Array'
                     : 'Float64Array';
-    const bytesPerElement = col.sizeClass === '1b' ? 1 : col.sizeClass === '4b' ? 4 : 8;
-    return `get ${col.name}_values() {
-    const ptr = this._columnPtrs[${col.columnIndex}];
-    if (ptr < 0) return ${col.isEager ? 'null' : 'undefined'};
-    const nullBitmapSize = Math.ceil(this._capacity / 8);
-    const valueOffset = ptr + nullBitmapSize;
-    // Align offset for typed array
-    const alignedOffset = (valueOffset + ${bytesPerElement - 1}) & ~${bytesPerElement - 1};
-    return new ${arrayType}(
-      this._allocator.memory.buffer,
-      alignedOffset,
-      this._capacity
-    );
+    return `const column = this._layout.columns[${layoutIndex}];
+      const familyPtr = this._familyPtrs[column.family];
+      this._${col.name}_nulls = new Uint8Array(memory, familyPtr + column.nullOffset, column.nullByteLength);
+      this._${col.name}_values = new ${arrayType}(memory, familyPtr + column.valueOffset, this._capacity);
+      this._columnPtrs[${col.columnIndex}] = familyPtr + column.nullOffset;`;
+}
+function generateEnsureNumericView(col, layoutIndex) {
+    if (col.isSchemaEager || col.isPreallocated)
+        return '';
+    return `if (this._columnPtrs[${col.columnIndex}] === -1) {
+      const memory = this._allocator.memory.buffer;
+      ${generateNumericViewBinding(col, layoutIndex)}
+    }`;
+}
+function generateNumericSetter(col, layoutIndex) {
+    const ensureView = generateEnsureNumericView(col, layoutIndex);
+    const validity = col.isSchemaEager
+        ? `this._${col.name}_values[idx] = value;`
+        : `if (value == null) {
+      this._${col.name}_nulls[idx >>> 3] &= ~(1 << (idx & 7));
+    } else {
+      this._${col.name}_nulls[idx >>> 3] |= 1 << (idx & 7);
+      this._${col.name}_values[idx] = value;
+    }`;
+    return `${col.name}(idx, value) {
+    this._ensureWasmViews();
+    ${ensureView}
+    ${validity}
+    return this;
   }`;
 }
-/**
- * Generate getter for numeric column nulls bitmap.
- */
-function generateNumericNullsGetter(col) {
-    if (col.isEager) {
-        // Eager columns don't have null bitmaps
-        return `get ${col.name}_nulls() {
-    return undefined;
+function generateNumericValuesGetter(col, layoutIndex) {
+    return `get ${col.name}_values() {
+    this._ensureWasmViews();
+    ${generateEnsureNumericView(col, layoutIndex)}
+    return this._${col.name}_values;
   }`;
+}
+function generateNumericNullsGetter(col, layoutIndex) {
+    if (col.isSchemaEager) {
+        return `get ${col.name}_nulls() { return undefined; }`;
     }
     return `get ${col.name}_nulls() {
-    const ptr = this._columnPtrs[${col.columnIndex}];
-    if (ptr < 0) return undefined;
-    const nullBitmapSize = Math.ceil(this._capacity / 8);
-    return new Uint8Array(
-      this._allocator.memory.buffer,
-      ptr,
-      nullBitmapSize
-    );
+    this._ensureWasmViews();
+    ${generateEnsureNumericView(col, layoutIndex)}
+    return this._${col.name}_nulls;
   }`;
 }
+function generateViewRefresh(columnMeta, messageLayoutFamily, messagePhysicalLayout) {
+    const lines = [
+        'const memory = this._allocator.memory.buffer;',
+        'this._timestampView = new BigInt64Array(memory, this._systemPtr, this._capacity);',
+    ];
+    if (messagePhysicalLayout === 'packed') {
+        lines.push('this._rowHeaders = new Uint32Array(memory, this._systemPtr + this._layout.system.rowHeaderOffset, this._capacity);');
+    }
+    else {
+        lines.push('this._entryTypeView = new Uint8Array(memory, this._systemPtr + this._layout.system.entryTypeOffset, this._capacity);');
+        if (messageLayoutFamily !== 'dynamic-only') {
+            if (messagePhysicalLayout === 'current') {
+                lines.push('this._messageIds = new Uint16Array(memory, this._systemPtr + this._layout.system.messageIdOffset, this._capacity);');
+            }
+            else {
+                lines.push('this._logHeaders = new Uint32Array(memory, this._systemPtr + this._layout.system.messageDenseIndexOffset, this._capacity);');
+            }
+        }
+    }
+    lines.push(`if (this._identityOwner) {
+      this._identityView = new Uint8Array(memory, this._identityPtr, 128);
+      this._identityData = new DataView(memory, this._identityPtr, 128);
+    } else {
+      this._identitySource._ensureWasmViews();
+      this._identityView = this._identitySource._identityView;
+      this._identityData = this._identitySource._identityData;
+    }`);
+    let layoutIndex = 0;
+    for (const col of columnMeta) {
+        if (col.sizeClass === 'string' || col.name === 'message')
+            continue;
+        const binding = generateNumericViewBinding(col, layoutIndex);
+        if (col.isSchemaEager || col.isPreallocated) {
+            lines.push(`{ ${binding} }`);
+        }
+        else {
+            lines.push(`if (this._columnPtrs[${col.columnIndex}] !== -1) { ${binding} }`);
+        }
+        layoutIndex++;
+    }
+    lines.push('this._viewVersion = version;', 'this._descriptor.memoryVersion = version;');
+    return lines.join('\n    ');
+}
+function generateColumnLookup(columnMeta, nulls) {
+    const cases = [];
+    for (const col of columnMeta) {
+        if (col.name === 'message')
+            continue;
+        if (nulls && col.isSchemaEager)
+            cases.push(`case ${col.columnIndex}: return undefined;`);
+        else {
+            const property = nulls ? `_${col.name}_nulls` : `_${col.name}_values`;
+            cases.push(`case ${col.columnIndex}: return this.${property};`);
+        }
+    }
+    return `switch (columnIndex) { ${cases.join(' ')} default: return undefined; }`;
+}
+function generateEnsureStringStorage(col) {
+    if (col.isSchemaEager || col.isPreallocated)
+        return '';
+    return `if (this._${col.name}_values === undefined) {
+      this._${col.name}_values = new Array(this._capacity);
+      this._${col.name}_nulls = new Uint8Array((this._capacity + 7) >>> 3);
+    }`;
+}
 /**
  * Generate setter method for a string column (stored in JS).
  */
 function generateStringSetter(col) {
-    if (col.isEager) {
+    const ensureStorage = generateEnsureStringStorage(col);
+    if (col.isSchemaEager) {
         return `${col.name}(idx, value) {
+    if (this._descriptor.state !== 'live') throw new Error('Cannot write a released WASM buffer');
     this._${col.name}_values[idx] = value;
     return this;
+  }`;
+    }
+    if (col.isPreallocated) {
+        return `${col.name}(idx, value) {
+    if (this._descriptor.state !== 'live') throw new Error('Cannot write a released WASM buffer');
+    if (value == null) this._${col.name}_nulls[idx >>> 3] &= ~(1 << (idx & 7));
+    else {
+      this._${col.name}_values[idx] = value;
+      this._${col.name}_nulls[idx >>> 3] |= 1 << (idx & 7);
+    }
+    return this;
   }`;
     }
     // Lazy string column: allocate arrays on first write
     return `${col.name}(idx, value) {
-    if (this._${col.name}_values === undefined) {
-      this._${col.name}_values = new Array(this._capacity);
-      const nullBitmapSize = Math.ceil(this._capacity / 8);
-      this._${col.name}_nulls = new Uint8Array(nullBitmapSize);
-    }
+    if (this._descriptor.state !== 'live') throw new Error('Cannot write a released WASM buffer');
+    ${ensureStorage}
     if (value == null) {
       // Clear validity bit
       this._${col.name}_nulls[idx >>> 3] &= ~(1 << (idx & 7));
@@ -447,12 +501,10 @@ function generateStringSetter(col) {
  * Generate getter for string column values.
  */
 function generateStringValuesGetter(col) {
-    if (col.isEager) {
-        return `get ${col.name}_values() {
-    return this._${col.name}_values;
-  }`;
-    }
+    const ensureStorage = generateEnsureStringStorage(col);
     return `get ${col.name}_values() {
+    if (this._descriptor.state !== 'live') throw new Error('Cannot read a released WASM buffer');
+    ${ensureStorage}
     return this._${col.name}_values;
   }`;
 }
@@ -460,12 +512,15 @@ function generateStringValuesGetter(col) {
  * Generate getter for string column nulls.
  */
 function generateStringNullsGetter(col) {
-    if (col.isEager) {
+    if (col.isSchemaEager) {
         return `get ${col.name}_nulls() {
     return undefined;
   }`;
     }
+    const ensureStorage = generateEnsureStringStorage(col);
     return `get ${col.name}_nulls() {
+    if (this._descriptor.state !== 'live') throw new Error('Cannot read a released WASM buffer');
+    ${ensureStorage}
     return this._${col.name}_nulls;
   }`;
 }
@@ -475,20 +530,20 @@ function generateStringNullsGetter(col) {
  */
 function generateColumnMethods(columnMeta) {
     const methods = [];
+    let layoutIndex = 0;
     for (const col of columnMeta) {
-        // Skip 'message' - handled specially by generateMessageMethods()
-        if (col.name === 'message') {
+        if (col.name === 'message')
             continue;
-        }
         if (col.sizeClass === 'string') {
             methods.push(generateStringSetter(col));
             methods.push(generateStringValuesGetter(col));
             methods.push(generateStringNullsGetter(col));
         }
         else {
-            methods.push(generateNumericSetter(col));
-            methods.push(generateNumericValuesGetter(col));
-            methods.push(generateNumericNullsGetter(col));
+            methods.push(generateNumericSetter(col, layoutIndex));
+            methods.push(generateNumericValuesGetter(col, layoutIndex));
+            methods.push(generateNumericNullsGetter(col, layoutIndex));
+            layoutIndex++;
         }
     }
     return methods.join('\n\n  ');
@@ -496,10 +551,7 @@ function generateColumnMethods(columnMeta) {
 // =============================================================================
 // Class Cache and Generation
 // =============================================================================
-/**
- * Cache for generated WASM SpanBuffer classes.
- * Key is the schema object reference (WeakMap for GC).
- */
+/** Cache for generated WASM SpanBuffer classes, partitioned by schema and message family. */
 const wasmSpanBufferClassCache = new WeakMap();
 /**
  * Generate a WASM SpanBuffer class for the given schema.
@@ -509,59 +561,132 @@ const wasmSpanBufferClassCache = new WeakMap();
  * @param schema - LogSchema defining the buffer structure
  * @returns WasmSpanBufferConstructor for creating buffer instances
  */
-export function getWasmSpanBufferClass(schema) {
-    const cached = wasmSpanBufferClassCache.get(schema);
-    if (cached) {
+export function getWasmSpanBufferClass(schema, messageLayoutFamily = 'mixed', messagePhysicalLayout = 'current', eagerColumns = EMPTY_EAGER_COLUMNS) {
+    const cacheKey = `${messageLayoutFamily}:${messagePhysicalLayout}:${eagerColumns.key}`;
+    let familyClasses = wasmSpanBufferClassCache.get(schema);
+    const cached = familyClasses?.get(cacheKey);
+    if (cached !== undefined && isWasmSpanBufferConstructor(cached, schema, messageLayoutFamily, messagePhysicalLayout))
         return cached;
-    }
-    // Pre-compute column metadata
-    const columnMeta = buildColumnMeta(schema);
+    const columnMeta = buildColumnMeta(schema, eagerColumns);
     // Generate ONLY schema-specific code (constructor + column methods)
     const classCode = `
 class WasmSpanBuffer {
   constructor(opts) {
-    // Store allocator and capacity
     this._allocator = opts.allocator;
     this._capacity = opts.capacity;
     this._logSchema = opts.logSchema;
+    this._parent = opts._parent ?? null;
+    this._nodeIndex = 4294967295;
+    this._topologyGeneration = 0;
+    this._overflow = null;
+    this._overflowWriteIndex = 0;
+    this._layout = opts._layout;
+    if (this._layout.messageLayoutFamily !== '${messageLayoutFamily}') {
+      throw new TypeError('WASM layout descriptor does not match its generated message family');
+    }
+    if (this._layout.messagePhysicalLayout !== '${messagePhysicalLayout}') {
+      throw new TypeError('WASM layout descriptor does not match its generated physical layout');
+    }
 
-    // Allocate identity block from WASM (root has trace_id, child does not)
-    if (opts.trace_id) {
-      const traceIdBytes = new TextEncoder().encode(opts.trace_id);
-      const packed = opts.allocator.allocIdentityRootForJsWrite(traceIdBytes.length);
-      this._identityPtr = Number(packed >> 32n);
-      const traceIdOffset = Number(packed & 0xFFFFFFFFn);
-      new Uint8Array(opts.allocator.memory.buffer).set(traceIdBytes, traceIdOffset);
+    this._traceRoot = opts._traceRoot;
+    this._scopeValues = opts._scopeValues;
+    this._opMetadata = opts._opMetadata;
+    this._callsiteMetadata = opts._callsiteMetadata;
+    this._vocabularyGeneration = opts._vocabularyGeneration;
+    this._statsSealed = false;
+    this._statsReservedRows = 2;
+    this._columnPtrs = new Int32Array(${columnMeta.length}).fill(-1);
+    ${messageLayoutFamily === 'static-only'
+        ? `this._spanName = undefined;
+    this._terminalMessage = undefined;`
+        : messageLayoutFamily === 'dynamic-only'
+            ? `this._spanName = undefined;
+    this._message = new Array(opts.capacity);`
+            : 'this._message = new Array(opts.capacity);'}
+    ${generateColumnInit(columnMeta)}
+
+    const identityMode = opts._identityMode ?? 'root';
+    this._identityOwner = identityMode !== 'overflow';
+    this._identitySource = identityMode === 'overflow' ? opts._identitySource : undefined;
+    const superblock = this._identityOwner ? this._layout.spanSuperblock : this._layout.overflowSuperblock;
+    this._allocationByteLength = superblock.byteLength;
+    if (identityMode === 'overflow') {
+      if (!this._identitySource) throw new Error('Overflow buffer requires an identity owner');
+      this._allocationPtr = opts.allocator.createOverflowSpan(superblock.byteLength);
+      this._identityPtr = this._identitySource._identityPtr;
     } else {
-      this._identityPtr = opts.allocator.allocIdentityChild();
+      const traceRootPtr = opts._traceRoot._traceRootPtr;
+      if (!Number.isInteger(traceRootPtr) || traceRootPtr <= 0) {
+        throw new TypeError('WASM span requires a live WasmTraceRoot');
+      }
+      const traceIdBytes = identityMode === 'root' ? opts._traceRoot._traceIdBytes : undefined;
+      this._allocationPtr = opts.allocator.createAndStartSpan(
+        identityMode === 'child' ? ${WASM_SPAN_IDENTITY_CHILD} : ${WASM_SPAN_IDENTITY_ROOT},
+        traceIdBytes?.length ?? 0,
+        superblock.byteLength,
+        superblock.systemOffset,
+        this._layout.system.entryTypeOffset ?? ${WASM_NO_LAYOUT_OFFSET},
+        this._layout.system.rowHeaderOffset ?? ${WASM_NO_LAYOUT_OFFSET},
+        traceRootPtr,
+      );
+      this._identityPtr = this._allocationPtr;
+      if (this._allocationPtr !== 0 && traceIdBytes !== undefined) {
+        opts.allocator.u8.set(traceIdBytes, this._identityPtr + 9);
+      }
     }
+    if (this._allocationPtr === 0) throw new Error('WASM span superblock allocation failed');
 
-    // Allocate system block from WASM
-    this._systemPtr = opts.allocator.allocSpanSystem();
+    this._systemPtr = this._allocationPtr + superblock.systemOffset;
+    const familyPtrs = { u8: 0, u32: 0, f64: 0 };
+    for (const family of ['u8', 'u32', 'f64']) {
+      const familyOffset = superblock.familyOffsets[family];
+      if (familyOffset !== 0) familyPtrs[family] = this._allocationPtr + familyOffset;
+    }
+    this._familyPtrs = Object.freeze(familyPtrs);
+    const allocatorWords = opts.allocator.u32;
+    this._threadId =
+      this._identitySource?.thread_id ?? ((BigInt(allocatorWords[7]) << 32n) | BigInt(allocatorWords[6]));
+    this._spanId = this._identitySource?.span_id ?? allocatorWords[(this._identityPtr + 4) >>> 2];
+    this._viewVersion = 0;
+    this._spanStartedAtAllocation = this._identityOwner;
 
-    // Initialize column pointers as unallocated (-1)
-    this._columnPtrs = new Int32Array(${columnMeta.length}).fill(-1);
+    this._descriptor = {
+      generation: opts._generation ?? 0,
+      kind: identityMode,
+      state: 'live',
+      layout: this._layout,
+      allocationPtr: this._allocationPtr,
+      allocationByteLength: this._allocationByteLength,
+      systemPtr: this._systemPtr,
+      familyPtrs: this._familyPtrs,
+      identityPtr: this._identityPtr,
+      ownsIdentity: this._identityOwner,
+      memoryVersion: 0,
+      parent: opts._parent?._descriptor,
+    };
 
-    // Tree structure
-    this._parent = null;
-    this._children = [];
-    this._overflow = null;
+    try {
+      this._refreshViews(this._allocator.refreshViews());
+    } catch (error) {
+      this.free();
+      throw error;
+    }
+  }
 
-    // Assign context properties from opts
-    this._traceRoot = opts._traceRoot;
-    this._scopeValues = opts._scopeValues;
-    this._opMetadata = opts._opMetadata;
-    this._callsiteMetadata = opts._callsiteMetadata;
+  _refreshViews(version) {
+    ${generateViewRefresh(columnMeta, messageLayoutFamily, messagePhysicalLayout)}
+  }
 
-    // Initialize message array
-    this._message = new Array(opts.capacity);
+  _getWasmColumnValue(columnIndex) {
+    ${generateColumnLookup(columnMeta, false)}
+  }
 
-    // Initialize eager columns
-    ${generateEagerColumnInit(columnMeta)}
+  _getWasmColumnNulls(columnIndex) {
+    ${generateColumnLookup(columnMeta, true)}
   }
 
-  // Schema-specific column methods (ONLY part that differs per schema)
   ${generateColumnMethods(columnMeta)}
+
 }
 
 return WasmSpanBuffer;
@@ -578,11 +703,13 @@ return WasmSpanBuffer;
         enumerable: true,
         configurable: true,
     });
-    Object.defineProperty(WasmSpanBufferClass.prototype, 'entry_type', {
-        get: wasmGetEntryType,
-        enumerable: true,
-        configurable: true,
-    });
+    if (messagePhysicalLayout !== 'packed') {
+        Object.defineProperty(WasmSpanBufferClass.prototype, 'entry_type', {
+            get: wasmGetEntryType,
+            enumerable: true,
+            configurable: true,
+        });
+    }
     Object.defineProperty(WasmSpanBufferClass.prototype, '_writeIndex', {
         get: wasmGetWriteIndex,
         set: wasmSetWriteIndex,
@@ -619,13 +746,20 @@ return WasmSpanBuffer;
         enumerable: true,
         configurable: true,
     });
-    Object.defineProperty(WasmSpanBufferClass.prototype, 'message_values', {
-        get: wasmGetMessageValues,
+    if (messageLayoutFamily !== 'static-only') {
+        Object.defineProperty(WasmSpanBufferClass.prototype, 'message_values', {
+            get: wasmGetMessageValues,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    Object.defineProperty(WasmSpanBufferClass.prototype, '_messageLayoutFamily', {
+        get: wasmGetMessageLayoutFamily,
         enumerable: true,
         configurable: true,
     });
-    Object.defineProperty(WasmSpanBufferClass.prototype, 'message_nulls', {
-        get: wasmGetMessageNulls,
+    Object.defineProperty(WasmSpanBufferClass.prototype, '_messagePhysicalLayout', {
+        get: wasmGetMessagePhysicalLayout,
         enumerable: true,
         configurable: true,
     });
@@ -660,12 +794,15 @@ return WasmSpanBuffer;
         enumerable: true,
         configurable: true,
     });
-    WasmSpanBufferClass.prototype.message = wasmMessage;
+    WasmSpanBufferClass.prototype._ensureWasmViews = wasmEnsureViews;
+    WasmSpanBufferClass.prototype.message = messageLayoutFamily === 'static-only' ? wasmStaticMessage : wasmRawMessage;
     WasmSpanBufferClass.prototype.free = wasmFree;
     WasmSpanBufferClass.prototype.isColumnAllocated = wasmIsColumnAllocated;
     WasmSpanBufferClass.prototype.getColumnIfAllocated = wasmGetColumnIfAllocated;
     WasmSpanBufferClass.prototype.getNullsIfAllocated = wasmGetNullsIfAllocated;
     WasmSpanBufferClass.prototype.getOrCreateOverflow = wasmGetOrCreateOverflow;
+    WasmSpanBufferClass.prototype._sealStats = wasmSealStats;
+    WasmSpanBufferClass.prototype._sealStatsChain = wasmSealStatsChain;
     WasmSpanBufferClass.prototype[Symbol.for('nodejs.util.inspect.custom')] = wasmInspect;
     // Add static schema property
     Object.defineProperty(WasmSpanBufferClass, 'schema', {
@@ -674,6 +811,24 @@ return WasmSpanBuffer;
         enumerable: true,
         configurable: false,
     });
+    Object.defineProperty(WasmSpanBufferClass, 'messageLayoutFamily', {
+        value: messageLayoutFamily,
+        writable: false,
+        enumerable: true,
+        configurable: false,
+    });
+    Object.defineProperty(WasmSpanBufferClass, 'messagePhysicalLayout', {
+        value: messagePhysicalLayout,
+        writable: false,
+        enumerable: true,
+        configurable: false,
+    });
+    Object.defineProperty(WasmSpanBufferClass, 'eagerColumns', {
+        value: eagerColumns,
+        writable: false,
+        enumerable: true,
+        configurable: false,
+    });
     // Add static stats property (required by SpanContext and arrow-builder's ColumnWriter)
     // This matches the structure in spanBuffer.ts
     // IMPORTANT: stats object itself must be writable so totalWrites++ and spansCreated++ can modify it
@@ -688,8 +843,12 @@ return WasmSpanBuffer;
         enumerable: true,
         configurable: true,
     });
-    // Cache the class
-    wasmSpanBufferClassCache.set(schema, WasmSpanBufferClass);
+    if (!isWasmSpanBufferConstructor(WasmSpanBufferClass, schema)) {
+        throw new Error('Generated WasmSpanBuffer constructor lost its schema identity');
+    }
+    familyClasses ??= new Map();
+    familyClasses.set(cacheKey, WasmSpanBufferClass);
+    wasmSpanBufferClassCache.set(schema, familyClasses);
     return WasmSpanBufferClass;
 }
 // =============================================================================
@@ -704,17 +863,24 @@ return WasmSpanBuffer;
  * @param _scopeValues - Scope values for this span
  * @param _opMetadata - Op metadata for attribution
  * @param _callsiteMetadata - Callsite metadata for attribution
- * @returns WasmSpanBufferInstance
+ * @returns Schema-specific WASM buffer instance
  */
 export function createWasmSpanBuffer(schema, opts, _traceRoot, _scopeValues, _opMetadata, _callsiteMetadata) {
-    const WasmSpanBufferClass = getWasmSpanBufferClass(schema);
+    const messageLayoutFamily = opts.messageLayoutFamily ?? 'mixed';
+    const messagePhysicalLayout = opts.messagePhysicalLayout ?? 'current';
+    const eagerColumns = _opMetadata._physicalLayoutPlan?.eagerColumns ?? EMPTY_EAGER_COLUMNS;
+    const WasmSpanBufferClass = getWasmSpanBufferClass(schema, messageLayoutFamily, messagePhysicalLayout, eagerColumns);
     return new WasmSpanBufferClass({
         ...opts,
+        _identityMode: 'root',
+        _generation: ++nextWasmBufferGeneration,
+        _layout: getWasmPhysicalLayout(schema, opts.capacity, messageLayoutFamily, messagePhysicalLayout, eagerColumns),
         logSchema: schema,
         _traceRoot,
         _scopeValues,
         _opMetadata,
         _callsiteMetadata,
+        _vocabularyGeneration: _opMetadata._physicalLayoutPlan?.vocabularyGeneration ?? getVocabularyGeneration(),
     });
 }
 /**
@@ -729,25 +895,28 @@ export function createWasmSpanBuffer(schema, opts, _traceRoot, _scopeValues, _op
  * @param _scopeValues - Scope values for this span
  * @param _opMetadata - Op metadata for attribution
  * @param _callsiteMetadata - Callsite metadata for attribution
- * @returns WasmSpanBufferInstance linked to parent
+ * @returns Schema-specific child WASM buffer
  */
 export function createWasmChildSpanBuffer(parent, opts, _traceRoot, _scopeValues, _opMetadata, _callsiteMetadata) {
     // Use provided schema (for cross-library calls) or parent's schema
     const childSchema = opts.schema ?? parent._logSchema;
-    const WasmSpanBufferClass = getWasmSpanBufferClass(childSchema);
+    const messageLayoutFamily = opts.messageLayoutFamily ?? parent._messageLayoutFamily;
+    const messagePhysicalLayout = opts.messagePhysicalLayout ?? parent._messagePhysicalLayout;
+    const eagerColumns = _opMetadata._physicalLayoutPlan?.eagerColumns ?? EMPTY_EAGER_COLUMNS;
+    const WasmSpanBufferClass = getWasmSpanBufferClass(childSchema, messageLayoutFamily, messagePhysicalLayout, eagerColumns);
     const child = new WasmSpanBufferClass({
         ...opts,
-        logSchema: childSchema, // Use the child's schema (may differ from parent)
-        trace_id: parent.trace_id,
-        parent_thread_id: parent.thread_id,
-        parent_span_id: parent.span_id,
+        logSchema: childSchema,
+        _identityMode: 'child',
+        _parent: parent,
+        _generation: ++nextWasmBufferGeneration,
+        _layout: getWasmPhysicalLayout(childSchema, opts.capacity, messageLayoutFamily, messagePhysicalLayout, eagerColumns),
         _traceRoot,
         _scopeValues,
         _opMetadata,
         _callsiteMetadata,
+        _vocabularyGeneration: _opMetadata._physicalLayoutPlan?.vocabularyGeneration ?? getVocabularyGeneration(),
     });
-    // Link to parent (SpanContext will push to parent._children with possible RemappedBufferView wrapper)
-    child._parent = parent;
     return child;
 }
 /**
@@ -758,27 +927,28 @@ export function createWasmChildSpanBuffer(parent, opts, _traceRoot, _scopeValues
  * @param _scopeValues - Scope values for this span
  * @param _opMetadata - Op metadata for attribution
  * @param _callsiteMetadata - Callsite metadata for attribution
- * @returns WasmSpanBufferInstance linked as overflow
+ * @returns Schema-specific overflow WASM buffer
  */
 export function createWasmOverflowBuffer(buffer, _traceRoot, _scopeValues, _opMetadata, _callsiteMetadata) {
-    const WasmSpanBufferClass = getWasmSpanBufferClass(buffer._logSchema);
+    const WasmSpanBufferClass = getWasmSpanBufferConstructor(buffer);
     const overflow = new WasmSpanBufferClass({
         allocator: buffer._allocator,
         capacity: buffer._capacity,
-        trace_id: buffer.trace_id,
-        thread_id: buffer.thread_id,
-        span_id: buffer.span_id,
-        parent_thread_id: buffer.parent_thread_id,
-        parent_span_id: buffer.parent_span_id,
         logSchema: buffer._logSchema,
         _traceRoot,
         _scopeValues,
         _opMetadata,
         _callsiteMetadata,
+        _vocabularyGeneration: buffer._vocabularyGeneration,
+        _identityMode: 'overflow',
+        _identitySource: buffer._identitySource ?? buffer,
+        _parent: buffer._parent,
+        _generation: ++nextWasmBufferGeneration,
+        _layout: buffer._layout,
     });
-    // Link as overflow (not child - same logical span)
-    overflow._parent = buffer._parent;
+    overflow._statsReservedRows = 0;
     buffer._overflow = overflow;
+    buffer._descriptor.overflow = overflow._descriptor;
     return overflow;
 }
 //#endregion smoo/lmao!n/wasm-mem.spanbuffer