@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/wasm/wasmSpanBuffer.ts

@@ -14,11 +14,24 @@ import type { ColumnValueType } from '@smoothbricks/arrow-builder';
 import { getSchemaType } from '@smoothbricks/arrow-builder';
 import { checkCapacityTuning } from '../capacityTuning.js';
 import type { OpMetadata } from '../op.js';
+import type { EagerColumnDescriptor } from '../physicalLayoutPlan.js';
+import type { MessageLayoutFamily, MessagePhysicalLayout } from '../runtimeHint.js';
 import type { LogSchema } from '../schema/LogSchema.js';
 import type { SpanBufferStats } from '../spanBufferStats.js';
 import type { ITraceRoot } from '../traceRoot.js';
-import type { AnySpanBuffer } from '../types.js';
-import type { WasmAllocator } from './wasmAllocator.js';
+import type { SpanBuffer } from '../types.js';
+import { getVocabularyGeneration, type VocabularyGeneration } from '../vocabularyRegistry.js';
+import {
+  WASM_NO_LAYOUT_OFFSET,
+  WASM_SPAN_IDENTITY_CHILD,
+  WASM_SPAN_IDENTITY_ROOT,
+  type WasmAllocator,
+} from './wasmAllocator.js';
+import {
+  getWasmPhysicalLayout,
+  type WasmNumericFamily,
+  type WasmPhysicalLayoutDescriptor,
+} from './wasmPhysicalLayout.js';
 
 // Spec link (88): realizes specs/lmao/01q_wasm_memory_architecture.md#smoo/lmao!n/wasm-mem (SpanBuffer + SpanLogger codegen).
 //#region smoo/lmao!n/wasm-mem.spanbuffer
@@ -33,45 +46,95 @@ import type { WasmAllocator } from './wasmAllocator.js';
  * Internal fields (_traceRoot, _scopeValues, _opMetadata, _callsiteMetadata) are passed separately
  * by the create* functions.
  */
-export interface WasmSpanBufferOptions {
+export type WasmBufferState = 'live' | 'freed';
+export type WasmIdentityMode = 'root' | 'child' | 'overflow';
+
+export interface WasmBufferDescriptor {
+  readonly generation: number;
+  readonly kind: WasmIdentityMode;
+  state: WasmBufferState;
+  readonly layout: WasmPhysicalLayoutDescriptor;
+  readonly allocationPtr: number;
+  readonly allocationByteLength: number;
+  readonly systemPtr: number;
+  readonly familyPtrs: Readonly<Record<WasmNumericFamily, number>>;
+  readonly identityPtr: number;
+  readonly ownsIdentity: boolean;
+  memoryVersion: number;
+  readonly parent?: WasmBufferDescriptor;
+  overflow?: WasmBufferDescriptor;
+}
+
+const EMPTY_EAGER_COLUMNS: EagerColumnDescriptor = Object.freeze({
+  names: Object.freeze([]),
+  words: Object.freeze([]),
+  key: '',
+});
+let nextWasmBufferGeneration = 0;
+
+export interface WasmSpanBufferOptions<T extends LogSchema = LogSchema> {
   allocator: WasmAllocator;
   capacity: number;
-  trace_id: string;
-  thread_id: bigint;
-  span_id: number;
-  parent_thread_id?: bigint;
-  parent_span_id?: number;
-  logSchema: LogSchema;
-  _traceRoot: ITraceRoot;
+  messageLayoutFamily?: MessageLayoutFamily;
+  messagePhysicalLayout?: MessagePhysicalLayout;
+  logSchema: T;
+  _traceRoot: ITraceRoot<T>;
   _scopeValues: Readonly<Record<string, unknown>>;
   _opMetadata: OpMetadata;
   _callsiteMetadata: OpMetadata;
+  _vocabularyGeneration: VocabularyGeneration;
+  _layout: WasmPhysicalLayoutDescriptor;
+  _identityMode?: WasmIdentityMode;
+  _identitySource?: WasmSpanBufferInstance<T>;
+  _parent?: WasmSpanBufferInstance<T>;
+  _generation?: number;
 }
 
 /**
- * WASM SpanBuffer instance interface.
- * Extends AnySpanBuffer with WASM-specific pointer properties.
+ * Extends the schema-specific SpanBuffer shape with WASM pointer ownership.
  */
-export interface WasmSpanBufferInstance extends AnySpanBuffer {
+export type WasmSpanBufferInstance<T extends LogSchema = LogSchema> = SpanBuffer<T> & {
   // ===========================================================================
   // WASM pointers (internal implementation details)
   // ===========================================================================
   /** Byte offset into WASM memory for system columns (timestamp + entry_type) */
   readonly _systemPtr: number;
+  /** Owning root/child/overflow superblock returned by the allocator. */
+  readonly _allocationPtr: number;
+  readonly _allocationByteLength: number;
   /** Byte offset into WASM memory for identity block (writeIndex, span_id, trace_id) */
   readonly _identityPtr: number;
   /** Array of byte offsets for each column (-1 = not allocated) */
   readonly _columnPtrs: Int32Array;
   /** Reference to the WASM allocator */
   readonly _allocator: WasmAllocator;
-
-  // Override tree structure with WASM-typed versions
-  _parent?: WasmSpanBufferInstance;
-  _children: WasmSpanBufferInstance[];
-  _overflow?: WasmSpanBufferInstance;
-
-  // Override message column - WASM stores as JS array (not WASM memory)
-  readonly _message: string[];
+  readonly _descriptor: WasmBufferDescriptor;
+  readonly _layout: WasmPhysicalLayoutDescriptor;
+  readonly _familyPtrs: Readonly<Record<WasmNumericFamily, number>>;
+  _viewVersion: number;
+  _timestampView: BigInt64Array;
+  _entryTypeView?: Uint8Array;
+  _messageIds?: Uint16Array;
+  _logHeaders?: Uint32Array;
+  _rowHeaders?: Uint32Array;
+  _identityView: Uint8Array;
+  _identityData: DataView;
+  _identitySource?: WasmSpanBufferInstance<T>;
+  readonly _threadId: bigint;
+  readonly _spanId: number;
+  _refreshViews(version: number): void;
+  _ensureWasmViews(): void;
+  _getWasmColumnValue(columnIndex: number): ColumnValueType | undefined;
+  _getWasmColumnNulls(columnIndex: number): Uint8Array | undefined;
+  readonly _identityOwner: boolean;
+  _overflowWriteIndex: number;
+
+  // Preserve WASM-typed parent and overflow links.
+  _parent?: WasmSpanBufferInstance<T>;
+  _overflow?: WasmSpanBufferInstance<T>;
+
+  // Present only for dynamic-only and mixed physical families.
+  readonly _message?: string[];
 
   // ===========================================================================
   // WASM-specific methods
@@ -87,15 +150,21 @@ export interface WasmSpanBufferInstance extends AnySpanBuffer {
 
   /** Get column nulls array if allocated */
   getNullsIfAllocated(columnName: string): Uint8Array | undefined;
-}
+};
+
+type WasmRawMessageBuffer = WasmSpanBufferInstance & { readonly _message: string[] };
+type WasmUnpackedMessageBuffer = WasmSpanBufferInstance & { readonly _entryTypeView: Uint8Array };
 
 /**
  * Constructor type for generated WASM SpanBuffer classes.
  */
-export interface WasmSpanBufferConstructor {
-  new (opts: WasmSpanBufferOptions): WasmSpanBufferInstance;
-  readonly schema: LogSchema;
-  stats: SpanBufferStats; // Mutable stats shared across all instances
+export interface WasmSpanBufferConstructor<T extends LogSchema = LogSchema> {
+  new (opts: WasmSpanBufferOptions<T>): WasmSpanBufferInstance<T>;
+  readonly schema: T;
+  readonly messageLayoutFamily: MessageLayoutFamily;
+  readonly messagePhysicalLayout: MessagePhysicalLayout;
+  readonly eagerColumns: EagerColumnDescriptor;
+  stats: SpanBufferStats;
 }
 
 // =============================================================================
@@ -119,8 +188,10 @@ interface ColumnMeta {
   schemaType: string;
   /** Index in the _columnPtrs array */
   columnIndex: number;
-  /** Whether this column is eager (always allocated) */
-  isEager: boolean;
+  /** Schema-level eager storage suppresses null bitmaps by declaration. */
+  isSchemaEager: boolean;
+  /** Compile-proven eager storage is preallocated but remains nullable. */
+  isPreallocated: boolean;
   /** Enum values if schemaType === 'enum' */
   enumValues?: readonly string[];
 }
@@ -137,39 +208,34 @@ function getFieldEnumValues(value: unknown): readonly string[] | undefined {
   return Array.isArray(enumValues) ? enumValues : undefined;
 }
 
-function isColumnValueType(value: unknown): value is ColumnValueType {
-  return value === undefined || Array.isArray(value) || ArrayBuffer.isView(value);
-}
-
-function getFreeMethod(
-  sizeClass: Exclude<SizeClass, 'string'>,
-): keyof Pick<WasmAllocator, 'free1B' | 'free4B' | 'free8B'> {
-  switch (sizeClass) {
-    case '1b':
-      return 'free1B';
-    case '4b':
-      return 'free4B';
-    case '8b':
-      return 'free8B';
-  }
-}
-
-function isWasmSpanBufferConstructor(value: unknown): value is WasmSpanBufferConstructor {
+function isWasmSpanBufferConstructor<T extends LogSchema = LogSchema>(
+  value: unknown,
+  schema?: T,
+  messageLayoutFamily?: MessageLayoutFamily,
+  messagePhysicalLayout?: MessagePhysicalLayout,
+): value is WasmSpanBufferConstructor<T> {
   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
   );
 }
 
-export function isWasmSpanBufferInstance(value: unknown): value is WasmSpanBufferInstance {
+export function isWasmSpanBufferInstance<T extends LogSchema = LogSchema>(
+  value: unknown,
+): value is WasmSpanBufferInstance<T> {
   return typeof value === 'object' && value !== null && typeof Reflect.get(value, '_systemPtr') === 'number';
 }
 
-function getWasmSpanBufferConstructor(instance: { constructor: unknown }): WasmSpanBufferConstructor {
-  if (!isWasmSpanBufferConstructor(instance.constructor)) {
+function getWasmSpanBufferConstructor<T extends LogSchema>(
+  instance: WasmSpanBufferInstance<T>,
+): WasmSpanBufferConstructor<T> {
+  if (!isWasmSpanBufferConstructor(instance.constructor, instance._logSchema)) {
     throw new Error('Expected generated WasmSpanBuffer constructor');
   }
   return instance.constructor;
@@ -183,15 +249,16 @@ function isWasmSpanBufferFactory(value: unknown): value is () => WasmSpanBufferC
  * Build column metadata array from schema.
  * Maps each schema field to its storage characteristics.
  */
-function buildColumnMeta(schema: LogSchema): ColumnMeta[] {
+function buildColumnMeta(schema: LogSchema, eagerColumns: EagerColumnDescriptor): ColumnMeta[] {
   const result: ColumnMeta[] = [];
   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: SizeClass;
@@ -217,7 +284,8 @@ function buildColumnMeta(schema: LogSchema): ColumnMeta[] {
       sizeClass,
       schemaType: schemaType ?? 'unknown',
       columnIndex,
-      isEager,
+      isSchemaEager,
+      isPreallocated: !isSchemaEager && preallocatedColumns.has(name),
       enumValues,
     });
     columnIndex++;
@@ -230,48 +298,48 @@ function buildColumnMeta(schema: LogSchema): ColumnMeta[] {
 // Common WasmSpanBuffer Methods (shared via prototype)
 // =============================================================================
 
-/**
- * Get timestamp column view from WASM memory.
- * Assigned to prototype after class generation.
- */
+function wasmEnsureViews(this: WasmSpanBufferInstance): void {
+  assertWasmBufferLive(this);
+  const memoryVersion = this._allocator.refreshViews();
+  if (memoryVersion !== this._viewVersion) this._refreshViews(memoryVersion);
+}
+
 function wasmGetTimestamp(this: WasmSpanBufferInstance): BigInt64Array {
-  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(this: WasmSpanBufferInstance): Uint8Array {
-  return new Uint8Array(this._allocator.memory.buffer, this._systemPtr + this._capacity * 8, this._capacity);
+function wasmGetEntryType(this: WasmUnpackedMessageBuffer): Uint8Array {
+  wasmEnsureViews.call(this);
+  return this._entryTypeView;
+}
+
+function assertWasmBufferLive(buffer: WasmSpanBufferInstance): void {
+  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(this: WasmSpanBufferInstance): number {
-  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(this: WasmSpanBufferInstance, value: number): void {
-  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(this: WasmSpanBufferInstance): string {
-  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(this: WasmSpanBufferInstance): bigint {
@@ -303,16 +371,13 @@ function wasmGetLastLoggedTime(this: WasmSpanBufferInstance): bigint | null {
  * Get thread_id from WASM identity block.
  */
 function wasmGetThreadId(this: WasmSpanBufferInstance): bigint {
-  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(this: WasmSpanBufferInstance): number {
-  return this._allocator.readIdentitySpanId(this._identityPtr);
+  assertWasmBufferLive(this);
+  return this._spanId;
 }
 
 /**
@@ -336,102 +401,106 @@ function wasmGetHasParent(this: WasmSpanBufferInstance): boolean {
   return this._parent !== null;
 }
 
-/**
- * Message column setter.
- */
-function wasmMessage(this: WasmSpanBufferInstance, idx: number, value: string): WasmSpanBufferInstance {
+function wasmRawMessage(this: WasmRawMessageBuffer, idx: number, value: string): WasmRawMessageBuffer {
+  assertWasmBufferLive(this);
   this._message[idx] = value;
   return this;
 }
 
+function wasmStaticMessage(this: WasmSpanBufferInstance, idx: number, value: string): WasmSpanBufferInstance {
+  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(this: WasmSpanBufferInstance): string[] {
+function wasmGetMessageValues(this: WasmRawMessageBuffer): string[] {
+  assertWasmBufferLive(this);
   return this._message;
 }
 
-/**
- * Get message column nulls (always undefined for eager column).
- */
-function wasmGetMessageNulls(this: WasmSpanBufferInstance): undefined {
-  return undefined;
+function wasmGetMessageLayoutFamily(this: WasmSpanBufferInstance): MessageLayoutFamily {
+  return getWasmSpanBufferConstructor(this).messageLayoutFamily;
 }
 
-/**
- * Free all WASM memory for this buffer.
- */
-function wasmFree(this: WasmSpanBufferInstance): void {
-  // Free identity block
-  this._allocator.freeIdentity(this._identityPtr);
+function wasmGetMessagePhysicalLayout(this: WasmSpanBufferInstance): MessagePhysicalLayout {
+  return getWasmSpanBufferConstructor(this).messagePhysicalLayout;
+}
 
-  // Free system block
-  this._allocator.freeSpanSystem(this._systemPtr);
+/** Free the one owned root/child/overflow superblock exactly once. */
+function wasmFree(this: WasmSpanBufferInstance): void {
+  if (this._descriptor.state === 'freed') return;
+  if (this._viewVersion !== 0) this._sealStats();
 
-  // 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]);
-    }
-  }
+  this._allocator.freeSpanSuperblock(this._allocationPtr, this._allocationByteLength);
+  this._descriptor.state = 'freed';
 }
 
 /**
  * Check if column is allocated.
  */
 function wasmIsColumnAllocated(this: WasmSpanBufferInstance, columnIndex: number): boolean {
-  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(this: WasmSpanBufferInstance, columnName: string): ColumnValueType | undefined {
+  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(this: WasmSpanBufferInstance, columnName: string): Uint8Array | undefined {
-  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(this: WasmSpanBufferInstance): ArrayBuffer {
+  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(this: WasmSpanBufferInstance): Uint8Array {
-  // 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(this: WasmSpanBufferInstance): void {
+  if (this._statsSealed) return;
+  const completedRows = this._writeIndex - this._statsReservedRows;
+  if (completedRows > 0) getWasmSpanBufferConstructor(this).stats.totalWrites += completedRows;
+  this._statsSealed = true;
+}
+
+function wasmSealStatsChain(this: WasmSpanBufferInstance): void {
+  let current: WasmSpanBufferInstance | undefined = this;
+  while (current) {
+    current._sealStats();
+    current = current._overflow;
+  }
 }
 
 /**
  * Get or create overflow buffer.
  */
 function wasmGetOrCreateOverflow(this: WasmSpanBufferInstance): WasmSpanBufferInstance {
+  assertWasmBufferLive(this);
   if (this._overflow) return this._overflow;
+  this._sealStats();
   const tracer = this._traceRoot.tracer;
   tracer.onStatsWillResetFor(this);
   checkCapacityTuning(getWasmSpanBufferConstructor(this).stats);
@@ -472,69 +541,24 @@ function wasmInspect(this: WasmSpanBufferInstance): string {
  * Generate eager column initialization code for constructor.
  * Eager columns are pre-allocated, lazy columns start as undefined/-1.
  */
-function generateEagerColumnInit(columnMeta: ColumnMeta[]): string {
+function generateColumnInit(columnMeta: ColumnMeta[]): string {
   const lines: string[] = [];
-
   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;`);
-      }
-    } else if (col.isEager) {
-      lines.push(`this._columnPtrs[${col.columnIndex}] = this._allocator.alloc${col.sizeClass.toUpperCase()}();`);
+    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 {
+      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: ColumnMeta): string {
-  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: ColumnMeta): string {
+function generateNumericViewBinding(col: ColumnMeta, layoutIndex: number): string {
   const arrayType =
     col.schemaType === 'number'
       ? 'Float64Array'
@@ -545,65 +569,160 @@ function generateNumericValuesGetter(col: ColumnMeta): string {
           : col.sizeClass === '4b'
             ? 'Uint32Array'
             : 'Float64Array';
+  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;`;
+}
 
-  const bytesPerElement = col.sizeClass === '1b' ? 1 : col.sizeClass === '4b' ? 4 : 8;
+function generateEnsureNumericView(col: ColumnMeta, layoutIndex: number): string {
+  if (col.isSchemaEager || col.isPreallocated) return '';
+  return `if (this._columnPtrs[${col.columnIndex}] === -1) {
+      const memory = this._allocator.memory.buffer;
+      ${generateNumericViewBinding(col, layoutIndex)}
+    }`;
+}
 
-  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
-    );
+function generateNumericSetter(col: ColumnMeta, layoutIndex: number): string {
+  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: ColumnMeta): string {
-  if (col.isEager) {
-    // Eager columns don't have null bitmaps
-    return `get ${col.name}_nulls() {
-    return undefined;
+function generateNumericValuesGetter(col: ColumnMeta, layoutIndex: number): string {
+  return `get ${col.name}_values() {
+    this._ensureWasmViews();
+    ${generateEnsureNumericView(col, layoutIndex)}
+    return this._${col.name}_values;
   }`;
-  }
+}
 
+function generateNumericNullsGetter(col: ColumnMeta, layoutIndex: number): string {
+  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: ColumnMeta[],
+  messageLayoutFamily: MessageLayoutFamily,
+  messagePhysicalLayout: MessagePhysicalLayout,
+): string {
+  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: ColumnMeta[], nulls: boolean): string {
+  const cases: string[] = [];
+  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: ColumnMeta): string {
+  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: ColumnMeta): string {
-  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));
@@ -620,13 +739,10 @@ function generateStringSetter(col: ColumnMeta): string {
  * Generate getter for string column values.
  */
 function generateStringValuesGetter(col: ColumnMeta): string {
-  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;
   }`;
 }
@@ -635,13 +751,16 @@ function generateStringValuesGetter(col: ColumnMeta): string {
  * Generate getter for string column nulls.
  */
 function generateStringNullsGetter(col: ColumnMeta): string {
-  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;
   }`;
 }
@@ -652,21 +771,19 @@ function generateStringNullsGetter(col: ColumnMeta): string {
  */
 function generateColumnMethods(columnMeta: ColumnMeta[]): string {
   const methods: string[] = [];
+  let layoutIndex = 0;
 
   for (const col of columnMeta) {
-    // Skip 'message' - handled specially by generateMessageMethods()
-    if (col.name === 'message') {
-      continue;
-    }
-
+    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++;
     }
   }
 
@@ -677,11 +794,8 @@ function generateColumnMethods(columnMeta: ColumnMeta[]): string {
 // Class Cache and Generation
 // =============================================================================
 
-/**
- * Cache for generated WASM SpanBuffer classes.
- * Key is the schema object reference (WeakMap for GC).
- */
-const wasmSpanBufferClassCache = new WeakMap<LogSchema, WasmSpanBufferConstructor>();
+/** Cache for generated WASM SpanBuffer classes, partitioned by schema and message family. */
+const wasmSpanBufferClassCache = new WeakMap<LogSchema, Map<string, object>>();
 
 /**
  * Generate a WASM SpanBuffer class for the given schema.
@@ -691,61 +805,141 @@ const wasmSpanBufferClassCache = new WeakMap<LogSchema, WasmSpanBufferConstructo
  * @param schema - LogSchema defining the buffer structure
  * @returns WasmSpanBufferConstructor for creating buffer instances
  */
-export function getWasmSpanBufferClass(schema: LogSchema): WasmSpanBufferConstructor {
-  const cached = wasmSpanBufferClassCache.get(schema);
-  if (cached) {
+export function getWasmSpanBufferClass<T extends LogSchema>(
+  schema: T,
+  messageLayoutFamily: MessageLayoutFamily = 'mixed',
+  messagePhysicalLayout: MessagePhysicalLayout = 'current',
+  eagerColumns: EagerColumnDescriptor = EMPTY_EAGER_COLUMNS,
+): WasmSpanBufferConstructor<T> {
+  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;
-
-    // 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);
-    } else {
-      this._identityPtr = opts.allocator.allocIdentityChild();
-    }
-
-    // Allocate system block from WASM
-    this._systemPtr = opts.allocator.allocSpanSystem();
-
-    // Initialize column pointers as unallocated (-1)
-    this._columnPtrs = new Int32Array(${columnMeta.length}).fill(-1);
-
-    // Tree structure
-    this._parent = null;
-    this._children = [];
+    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');
+    }
 
-    // Assign context properties from opts
     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 {
+      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');
 
-    // Initialize message array
-    this._message = new Array(opts.capacity);
+    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;
+
+    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,
+    };
+
+    try {
+      this._refreshViews(this._allocator.refreshViews());
+    } catch (error) {
+      this.free();
+      throw error;
+    }
+  }
+
+  _refreshViews(version) {
+    ${generateViewRefresh(columnMeta, messageLayoutFamily, messagePhysicalLayout)}
+  }
 
-    // Initialize eager columns
-    ${generateEagerColumnInit(columnMeta)}
+  _getWasmColumnValue(columnIndex) {
+    ${generateColumnLookup(columnMeta, false)}
+  }
+
+  _getWasmColumnNulls(columnIndex) {
+    ${generateColumnLookup(columnMeta, true)}
   }
 
-  // Schema-specific column methods (ONLY part that differs per schema)
   ${generateColumnMethods(columnMeta)}
+
 }
 
 return WasmSpanBuffer;
@@ -764,11 +958,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,
@@ -805,13 +1001,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,
   });
@@ -848,12 +1051,15 @@ return WasmSpanBuffer;
     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
@@ -863,6 +1069,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
@@ -879,8 +1103,13 @@ return WasmSpanBuffer;
     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;
 }
@@ -898,24 +1127,40 @@ 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: LogSchema,
-  opts: Omit<WasmSpanBufferOptions, 'logSchema' | '_traceRoot' | '_scopeValues' | '_opMetadata' | '_callsiteMetadata'>,
-  _traceRoot: ITraceRoot,
+export function createWasmSpanBuffer<T extends LogSchema>(
+  schema: T,
+  opts: Omit<
+    WasmSpanBufferOptions<T>,
+    | 'logSchema'
+    | '_traceRoot'
+    | '_scopeValues'
+    | '_opMetadata'
+    | '_callsiteMetadata'
+    | '_vocabularyGeneration'
+    | '_layout'
+  >,
+  _traceRoot: ITraceRoot<T>,
   _scopeValues: Readonly<Record<string, unknown>>,
   _opMetadata: OpMetadata,
   _callsiteMetadata: OpMetadata,
-): WasmSpanBufferInstance {
-  const WasmSpanBufferClass = getWasmSpanBufferClass(schema);
+): WasmSpanBufferInstance<T> {
+  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(),
   });
 }
 
@@ -931,47 +1176,58 @@ export function createWasmSpanBuffer(
  * @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: WasmSpanBufferInstance,
+export function createWasmChildSpanBuffer<T extends LogSchema>(
+  parent: WasmSpanBufferInstance<T>,
   opts: Omit<
-    WasmSpanBufferOptions,
+    WasmSpanBufferOptions<T>,
     | 'logSchema'
-    | 'trace_id'
-    | 'parent_thread_id'
-    | 'parent_span_id'
     | '_traceRoot'
     | '_scopeValues'
     | '_opMetadata'
     | '_callsiteMetadata'
+    | '_vocabularyGeneration'
+    | '_layout'
   > & {
-    schema?: LogSchema;
+    schema?: T;
   },
-  _traceRoot: ITraceRoot,
+  _traceRoot: ITraceRoot<T>,
   _scopeValues: Readonly<Record<string, unknown>>,
   _opMetadata: OpMetadata,
   _callsiteMetadata: OpMetadata,
-): WasmSpanBufferInstance {
+): WasmSpanBufferInstance<T> {
   // 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;
 }
 
@@ -983,35 +1239,35 @@ export function createWasmChildSpanBuffer(
  * @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: WasmSpanBufferInstance,
-  _traceRoot: ITraceRoot,
+export function createWasmOverflowBuffer<T extends LogSchema>(
+  buffer: WasmSpanBufferInstance<T>,
+  _traceRoot: ITraceRoot<T>,
   _scopeValues: Readonly<Record<string, unknown>>,
   _opMetadata: OpMetadata,
   _callsiteMetadata: OpMetadata,
-): WasmSpanBufferInstance {
-  const WasmSpanBufferClass = getWasmSpanBufferClass(buffer._logSchema);
+): WasmSpanBufferInstance<T> {
+  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;
 }