@smoothbricks/lmao 0.2.2 → 0.3.0

package/src/lib/wasm/__tests__/wasm-integration.test.ts

@@ -11,7 +11,10 @@
  */
 
 import { afterEach, beforeAll, describe, expect, it } from 'bun:test';
+import { convertToArrowTable } from '../../convertToArrow.js';
 import { defineOpContext } from '../../defineOpContext.js';
+import { JsBufferStrategy } from '../../JsBufferStrategy.js';
+import { resolveEntryType, resolveMessage } from '../../resolveMessage.js';
 import { S } from '../../schema/builder.js';
 import { defineLogSchema } from '../../schema/defineLogSchema.js';
 import {
@@ -24,9 +27,11 @@ import {
   ENTRY_TYPE_SPAN_START,
   ENTRY_TYPE_WARN,
 } from '../../schema/systemSchema.js';
+import { createTraceRoot as createNodeTraceRoot } from '../../traceRoot.node.js';
 import { TestTracer } from '../../tracers/TestTracer.js';
+import { iterateSpanChildren } from '../../traceTopology.js';
 import { WasmBufferStrategy } from '../WasmBufferStrategy.js';
-import { createWasmTraceRootFactory } from '../wasmTraceRoot.js';
+import { createWasmTraceRoot } from '../wasmTraceRoot.js';
 
 /**
  * Type for accessing WASM-specific internal buffer properties.
@@ -51,12 +56,22 @@ function asWasm<T>(buffer: T): T & WasmBufferInternals {
   return buffer as T & WasmBufferInternals;
 }
 
+function requireOnlySpanChild(parent: Parameters<typeof iterateSpanChildren>[0], label: string) {
+  const children = iterateSpanChildren(parent);
+  const first = children.next();
+  if (first.done) throw new Error(`${label} has no child span`);
+  const extra = children.next();
+  if (!extra.done) throw new Error(`${label} has more than one child span`);
+  return first.value;
+}
+
 describe('WASM Integration Tests', () => {
   // Test schema with various field types
   const schema = defineLogSchema({
     userId: S.category(),
     latency: S.number(),
     operation: S.enum(['CREATE', 'READ', 'UPDATE', 'DELETE']),
+    success: S.boolean(),
   });
 
   // Define op context - env is optional (undefined by default, not null-sentinel)
@@ -77,14 +92,14 @@ describe('WASM Integration Tests', () => {
 
     tracer = new TestTracer(opContext, {
       bufferStrategy: strategy,
-      createTraceRoot: createWasmTraceRootFactory(strategy.allocator),
+      createTraceRoot: (traceId, lifecycle) => createWasmTraceRoot(strategy.allocator, traceId, lifecycle),
     });
   });
 
   afterEach(() => {
     // Release all WASM memory for buffers
     for (const buffer of tracer.rootBuffers) {
-      strategy.releaseBuffer(buffer);
+      if (buffer._traceRoot._topology.count !== 0) strategy.releaseBuffer(buffer);
     }
     // Clear tracer state
     tracer.clear();
@@ -94,7 +109,7 @@ describe('WASM Integration Tests', () => {
     // Create fresh tracer for next test
     tracer = new TestTracer(opContext, {
       bufferStrategy: strategy,
-      createTraceRoot: createWasmTraceRootFactory(strategy.allocator),
+      createTraceRoot: (traceId, lifecycle) => createWasmTraceRoot(strategy.allocator, traceId, lifecycle),
     });
   });
 
@@ -108,15 +123,15 @@ describe('WASM Integration Tests', () => {
       const buffer = tracer.rootBuffers[0];
 
       // Verify entry types
-      expect(buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(buffer.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
+      expect(resolveEntryType(buffer, 1)).toBe(ENTRY_TYPE_SPAN_OK);
 
       // Verify timestamps are valid
       expect(buffer.timestamp[0]).toBeGreaterThan(0n);
       expect(buffer.timestamp[1]).toBeGreaterThanOrEqual(buffer.timestamp[0]);
 
       // Verify span name is set
-      expect(buffer.message_values[0]).toBe('test-op');
+      expect(resolveMessage(buffer, 0)).toBe('test-op');
     });
 
     it('writes trace_id correctly', async () => {
@@ -182,14 +197,10 @@ describe('WASM Integration Tests', () => {
       });
 
       const parent = tracer.rootBuffers[0];
-      expect(parent._children).toHaveLength(1);
-
-      const child = parent._children[0];
-      // Child should share trace_id with parent
+      if (!parent) throw new Error('nested trace did not produce a root buffer');
+      const child = requireOnlySpanChild(parent, 'nested trace root');
       expect(child.trace_id).toBe(parent.trace_id);
-      // Child's parent_span_id should be parent's span_id
       expect(child.parent_span_id).toBe(parent.span_id);
-      // Child should have its own span_id
       expect(child.span_id).not.toBe(parent.span_id);
     });
 
@@ -205,13 +216,11 @@ describe('WASM Integration Tests', () => {
       });
 
       const root = tracer.rootBuffers[0];
-      expect(root._children).toHaveLength(1);
-
-      const level1 = root._children[0];
-      expect(level1._children).toHaveLength(1);
+      if (!root) throw new Error('deep trace did not produce a root buffer');
+      const level1 = requireOnlySpanChild(root, 'deep trace root');
       expect(level1.parent_span_id).toBe(root.span_id);
 
-      const level2 = level1._children[0];
+      const level2 = requireOnlySpanChild(level1, 'level-1 span');
       expect(level2.parent_span_id).toBe(level1.span_id);
       expect(level2.trace_id).toBe(root.trace_id);
     });
@@ -224,14 +233,19 @@ describe('WASM Integration Tests', () => {
       });
 
       const parent = tracer.rootBuffers[0];
-      expect(parent._children).toHaveLength(2);
-
-      const [child1, child2] = parent._children;
-      expect(child1.message_values[0]).toBe('child-1');
-      expect(child2.message_values[0]).toBe('child-2');
+      if (!parent) throw new Error('sibling trace did not produce a root buffer');
+      const children = iterateSpanChildren(parent);
+      const first = children.next();
+      if (first.done) throw new Error('sibling trace did not produce its first child');
+      const second = children.next();
+      if (second.done) throw new Error('sibling trace did not produce its second child');
+      if (!children.next().done) throw new Error('sibling trace produced an unexpected extra child');
+      const child1 = first.value;
+      const child2 = second.value;
+      expect(resolveMessage(child1, 0)).toBe('child-1');
+      expect(resolveMessage(child2, 0)).toBe('child-2');
       expect(child1.parent_span_id).toBe(parent.span_id);
       expect(child2.parent_span_id).toBe(parent.span_id);
-      // Siblings should have different span IDs
       expect(child1.span_id).not.toBe(child2.span_id);
     });
   });
@@ -247,12 +261,10 @@ describe('WASM Integration Tests', () => {
       }
 
       const buffer = asWasm(tracer.rootBuffers[0]);
-      expect(buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(buffer.entry_type[1]).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
+      expect(resolveEntryType(buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
+      expect(resolveEntryType(buffer, 1)).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
 
-      // Verify error message was written - use message_values getter
-      const messageValues = buffer.message_values;
-      const messages = messageValues.slice(0, buffer._writeIndex).filter((m: string) => m !== undefined);
+      const messages = Array.from({ length: buffer._writeIndex }, (_, row) => resolveMessage(buffer, row));
       expect(messages).toContain('test error');
     });
 
@@ -279,8 +291,8 @@ describe('WASM Integration Tests', () => {
       });
 
       const buffer = tracer.rootBuffers[0];
-      expect(buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(buffer.entry_type[1]).toBe(ENTRY_TYPE_SPAN_ERR);
+      expect(resolveEntryType(buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
+      expect(resolveEntryType(buffer, 1)).toBe(ENTRY_TYPE_SPAN_ERR);
     });
 
     it('writes error code for typed errors', async () => {
@@ -289,7 +301,7 @@ describe('WASM Integration Tests', () => {
       });
 
       const buffer = asWasm(tracer.rootBuffers[0]);
-      expect(buffer.entry_type[1]).toBe(ENTRY_TYPE_SPAN_ERR);
+      expect(resolveEntryType(buffer, 1)).toBe(ENTRY_TYPE_SPAN_ERR);
       // Error code should be written to error_code column
       expect(buffer.error_code_values?.[1]).toBe('VALIDATION_ERROR');
     });
@@ -310,21 +322,18 @@ describe('WASM Integration Tests', () => {
       expect(buffer._writeIndex).toBeGreaterThan(2);
 
       // Row 0 = span-start, Row 1 = span-ok (written at end)
-      expect(buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(buffer.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
+      expect(resolveEntryType(buffer, 1)).toBe(ENTRY_TYPE_SPAN_OK);
 
       // Log entries are written at indices 2+
-      const entryTypes = Array.from(buffer.entry_type.slice(0, buffer._writeIndex));
+      const entryTypes = Array.from({ length: buffer._writeIndex }, (_, row) => resolveEntryType(buffer, row));
 
       // Use entry type constants from systemSchema
       expect(entryTypes).toContain(ENTRY_TYPE_INFO);
       expect(entryTypes).toContain(ENTRY_TYPE_DEBUG);
       expect(entryTypes).toContain(ENTRY_TYPE_WARN);
 
-      // Messages are written via message_values getter (SpanLogger uses this)
-      // Access via the getter since that's what SpanLogger writes to
-      const messageValues = buffer.message_values;
-      const messages = messageValues.slice(0, buffer._writeIndex).filter((m: string) => m !== undefined);
+      const messages = Array.from({ length: buffer._writeIndex }, (_, row) => resolveMessage(buffer, row));
       expect(messages).toContain('info message');
       expect(messages).toContain('debug message');
       expect(messages).toContain('warn message');
@@ -338,11 +347,176 @@ describe('WASM Integration Tests', () => {
 
       const buffer = asWasm(tracer.rootBuffers[0]);
       // Use entry type constant from systemSchema
-      const entryTypes = Array.from(buffer.entry_type.slice(0, buffer._writeIndex));
+      const entryTypes = Array.from({ length: buffer._writeIndex }, (_, row) => resolveEntryType(buffer, row));
       expect(entryTypes).toContain(ENTRY_TYPE_ERROR);
     });
   });
 
+  describe('Identity ownership', () => {
+    it('invalidates released root and child handles before recycled memory is reused', async () => {
+      await tracer.trace('owned-root', async (ctx) => {
+        await ctx.span('released-child', async (child) => child.ok('child done'));
+        return ctx.ok('root done');
+      });
+
+      const root = tracer.rootBuffers[0];
+      if (!root) throw new Error('released trace did not produce a root buffer');
+      const child = requireOnlySpanChild(root, 'released trace root');
+      const topology = root._traceRoot._topology;
+      const rootTraceId = root.trace_id;
+      const rootSpanId = root.span_id;
+      expect(child.trace_id).toBe(rootTraceId);
+      expect(child.span_id).not.toBe(rootSpanId);
+      expect(child.parent_span_id).toBe(rootSpanId);
+      expect(child._identity).not.toEqual(root._identity);
+
+      strategy.releaseBuffer(root);
+      expect(topology.count).toBe(0);
+      expect(() => topology.assertLive(root)).toThrow(/stale/);
+      expect(() => topology.assertLive(child)).toThrow(/stale/);
+      expect(() => iterateSpanChildren(root).next()).toThrow(/stale/);
+
+      await tracer.trace('recycled-child-identity', async (ctx) => ctx.ok('done'));
+      const recycled = tracer.rootBuffers[1];
+      if (!recycled) throw new Error('recycled trace did not produce a root buffer');
+      expect(recycled.trace_id).not.toBe(rootTraceId);
+      expect(resolveMessage(recycled, 0)).toBe('recycled-child-identity');
+    });
+
+    it('preserves logical span identity and linkage across overflow segments', async () => {
+      await tracer.trace('overflow-root', async (ctx) => {
+        for (let i = 0; i < 64; i++) {
+          ctx.log.info(`root-log-${i}`);
+        }
+        await ctx.span('overflow-child', async (child) => {
+          for (let i = 0; i < 64; i++) {
+            child.log.info(`child-log-${i}`);
+          }
+          return child.ok('child done');
+        });
+        return ctx.ok('root done');
+      });
+
+      const root = tracer.rootBuffers[0];
+      const rootOverflow = root._overflow;
+      if (!rootOverflow) throw new Error('root logs did not create an overflow segment');
+      expect(rootOverflow.trace_id).toBe(root.trace_id);
+      expect(rootOverflow.span_id).toBe(root.span_id);
+      expect(rootOverflow.parent_span_id).toBe(root.parent_span_id);
+      expect(rootOverflow._identity).toEqual(root._identity);
+
+      const child = requireOnlySpanChild(root, 'overflow trace root');
+      const childOverflow = child._overflow;
+      if (!childOverflow) throw new Error('child logs did not create an overflow segment');
+      expect(child.trace_id).toBe(root.trace_id);
+      expect(child.span_id).not.toBe(root.span_id);
+      expect(child.parent_span_id).toBe(root.span_id);
+      expect(childOverflow.trace_id).toBe(child.trace_id);
+      expect(childOverflow.span_id).toBe(child.span_id);
+      expect(childOverflow.parent_span_id).toBe(child.parent_span_id);
+      expect(childOverflow._identity).toEqual(child._identity);
+    });
+  });
+
+  describe('Released memory ownership', () => {
+    it('keeps two new traces independent after repeated tree release', async () => {
+      await tracer.trace('released-tree', async (ctx) => {
+        await ctx.span('released-child', async (child) => {
+          child.tag.latency(1);
+          return child.ok('done');
+        });
+        return ctx.ok('done');
+      });
+
+      const released = tracer.rootBuffers[0];
+      strategy.releaseBuffer(released);
+      expect(() => strategy.releaseBuffer(released)).toThrow(/stale/);
+
+      await tracer.trace('first-new-owner', async (ctx) => {
+        ctx.tag.latency(11.5);
+        return ctx.ok('done');
+      });
+      await tracer.trace('second-new-owner', async (ctx) => {
+        ctx.tag.latency(22.5);
+        return ctx.ok('done');
+      });
+
+      const firstTable = strategy.toArrowTable(tracer.rootBuffers[1]);
+      const secondTable = strategy.toArrowTable(tracer.rootBuffers[2]);
+      expect(firstTable.getChild('message')?.get(0)).toBe('first-new-owner');
+      expect(firstTable.getChild('latency')?.get(0)).toBe(11.5);
+      expect(secondTable.getChild('message')?.get(0)).toBe('second-new-owner');
+      expect(secondTable.getChild('latency')?.get(0)).toBe(22.5);
+    });
+
+    it('keeps single-buffer Arrow output isolated from recycled WASM memory', async () => {
+      await tracer.trace('arrow-first', async (ctx) => {
+        ctx.tag.latency(91.25).success(true).operation('READ');
+        return ctx.ok('done');
+      });
+
+      const firstBuffer = tracer.rootBuffers[0];
+      const firstTable = convertToArrowTable(firstBuffer);
+      expect(firstTable.numRows).toBe(2);
+      expect(firstTable.getChild('message')?.get(0)).toBe('arrow-first');
+      expect(firstTable.getChild('latency')?.get(0)).toBe(91.25);
+      expect(firstTable.getChild('success')?.get(0)).toBe(true);
+      expect(firstTable.getChild('operation')?.get(0)).toBe('READ');
+
+      strategy.releaseBuffer(firstBuffer);
+      await tracer.trace('arrow-second', async (ctx) => {
+        ctx.tag.latency(-17.5).success(false).operation('DELETE');
+        return ctx.ok('done');
+      });
+
+      const secondTable = convertToArrowTable(tracer.rootBuffers[1]);
+      expect(secondTable.getChild('latency')?.get(0)).toBe(-17.5);
+      expect(secondTable.getChild('success')?.get(0)).toBe(false);
+      expect(secondTable.getChild('operation')?.get(0)).toBe('DELETE');
+      expect(firstTable.getChild('message')?.get(0)).toBe('arrow-first');
+      expect(firstTable.getChild('latency')?.get(0)).toBe(91.25);
+      expect(firstTable.getChild('success')?.get(0)).toBe(true);
+      expect(firstTable.getChild('operation')?.get(0)).toBe('READ');
+    });
+
+    it('keeps span-tree Arrow output isolated from recycled WASM memory', async () => {
+      await tracer.trace('tree-first', async (ctx) => {
+        ctx.tag.latency(1.25);
+        await ctx.span('child-first', async (child) => {
+          child.tag.latency(2.5);
+          return child.ok('done');
+        });
+        return ctx.ok('done');
+      });
+
+      const firstBuffer = tracer.rootBuffers[0];
+      const firstTable = strategy.toArrowTable(firstBuffer);
+      expect(firstTable.numRows).toBe(4);
+      expect(firstTable.getChild('message')?.get(0)).toBe('tree-first');
+      expect(firstTable.getChild('message')?.get(2)).toBe('child-first');
+      expect(firstTable.getChild('latency')?.get(0)).toBe(1.25);
+      expect(firstTable.getChild('latency')?.get(2)).toBe(2.5);
+
+      strategy.releaseBuffer(firstBuffer);
+      await tracer.trace('tree-second', async (ctx) => {
+        ctx.tag.latency(101.25);
+        await ctx.span('child-second', async (child) => {
+          child.tag.latency(202.5);
+          return child.ok('done');
+        });
+        return ctx.ok('done');
+      });
+
+      const secondTable = strategy.toArrowTable(tracer.rootBuffers[1]);
+      expect(secondTable.getChild('latency')?.get(0)).toBe(101.25);
+      expect(secondTable.getChild('latency')?.get(2)).toBe(202.5);
+      expect(firstTable.getChild('message')?.get(0)).toBe('tree-first');
+      expect(firstTable.getChild('message')?.get(2)).toBe('child-first');
+      expect(firstTable.getChild('latency')?.get(0)).toBe(1.25);
+      expect(firstTable.getChild('latency')?.get(2)).toBe(2.5);
+    });
+  });
+
   describe('Memory reuse', () => {
     it('tracks allocation stats', async () => {
       const statsBefore = strategy.getStats();
@@ -422,7 +596,7 @@ describe('WASM Integration Tests', () => {
       }
 
       const buffer = tracer.rootBuffers[0];
-      expect(buffer.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffer, 1)).toBe(ENTRY_TYPE_SPAN_OK);
     });
 
     it('handles async functions correctly', async () => {
@@ -438,12 +612,211 @@ describe('WASM Integration Tests', () => {
       }
 
       const buffer = tracer.rootBuffers[0];
-      expect(buffer.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffer, 1)).toBe(ENTRY_TYPE_SPAN_OK);
       // Timestamps should reflect the delay
       expect(buffer.timestamp[1]).toBeGreaterThan(buffer.timestamp[0]);
     });
   });
 
+  describe('JS/WASM timestamp output parity', () => {
+    it('emits identical timestamped lifecycle rows across overflow and child spans', async () => {
+      const jsSchema = defineLogSchema({
+        userId: S.category(),
+        latency: S.number(),
+        operation: S.enum(['CREATE', 'READ', 'UPDATE', 'DELETE']),
+        success: S.boolean(),
+      });
+      const jsOpContext = defineOpContext({
+        logSchema: jsSchema,
+        ctx: { env: undefined as { region: string } | undefined },
+      });
+      const jsStrategy = new JsBufferStrategy<typeof jsSchema>();
+      const jsTracer = new TestTracer(jsOpContext, {
+        bufferStrategy: jsStrategy,
+        createTraceRoot: createNodeTraceRoot,
+      });
+      const originalDateNow = Date.now;
+      const originalHrtime = process.hrtime.bigint;
+      const originalPerformanceNow = performance.now;
+      const epochMillis = 1_700_000_000_000;
+      const nodeAnchor = 5_000_000n;
+      const performanceAnchor = 1_000;
+
+      try {
+        Date.now = () => epochMillis;
+        let nodeTick = 0n;
+        process.hrtime.bigint = () => nodeAnchor + nodeTick++ * 125_000n;
+        await jsTracer.trace('parity-root', async (root) => {
+          for (let i = 0; i < 70; i++) root.log.info(`root-${i}`);
+          await root.span('parity-child', async (child) => {
+            for (let i = 0; i < 70; i++) child.log.info(`child-${i}`);
+            return child.ok('child done');
+          });
+          return root.ok('root done');
+        });
+
+        let performanceTick = 0;
+        Object.defineProperty(performance, 'now', {
+          configurable: true,
+          value: () => performanceAnchor + performanceTick++ * 0.125,
+        });
+        await tracer.trace('parity-root', async (root) => {
+          for (let i = 0; i < 70; i++) root.log.info(`root-${i}`);
+          await root.span('parity-child', async (child) => {
+            for (let i = 0; i < 70; i++) child.log.info(`child-${i}`);
+            return child.ok('child done');
+          });
+          return root.ok('root done');
+        });
+
+        const jsTable = jsStrategy.toArrowTable(jsTracer.rootBuffers[0]);
+        const wasmTable = strategy.toArrowTable(tracer.rootBuffers[0]);
+        expect(wasmTable.numRows).toBe(jsTable.numRows);
+        for (const columnName of ['entry_type', 'message', 'timestamp'] as const) {
+          const jsColumn = jsTable.getChild(columnName);
+          const wasmColumn = wasmTable.getChild(columnName);
+          if (!jsColumn || !wasmColumn) throw new Error(`missing parity column: ${columnName}`);
+          const jsValues = Array.from({ length: jsTable.numRows }, (_, row) => jsColumn.get(row));
+          const wasmValues = Array.from({ length: wasmTable.numRows }, (_, row) => wasmColumn.get(row));
+          expect(wasmValues).toEqual(jsValues);
+        }
+      } finally {
+        Date.now = originalDateNow;
+        process.hrtime.bigint = originalHrtime;
+        Object.defineProperty(performance, 'now', { configurable: true, value: originalPerformanceNow });
+      }
+    });
+
+    it('preserves ordered Arrow rows for root, child, grandchild, random, and overflow workloads', async () => {
+      const jsStrategy = new JsBufferStrategy<typeof schema>();
+      const jsTracer = new TestTracer(opContext, {
+        bufferStrategy: jsStrategy,
+        createTraceRoot: createNodeTraceRoot,
+      });
+      const workloads = [
+        {
+          name: 'root',
+          run: async (target: typeof tracer) => {
+            await target.trace('ordered-root', async (root) => {
+              root.tag.latency(1.25).success(true).operation('CREATE');
+              root.log.info('ordered-root-log');
+              return root.ok('root done');
+            });
+            return ['ordered-root'];
+          },
+        },
+        {
+          name: 'child',
+          run: async (target: typeof tracer) => {
+            await target.trace('ordered-parent', async (root) => {
+              await root.span('ordered-child-0', async (child) => child.ok('first child done'));
+              await root.span('ordered-child-1', async (child) => child.ok('second child done'));
+              return root.ok('parent done');
+            });
+            return ['ordered-parent', 'ordered-child-0', 'ordered-child-1'];
+          },
+        },
+        {
+          name: 'grandchild',
+          run: async (target: typeof tracer) => {
+            await target.trace('ordered-grand-root', async (root) => {
+              await root.span('ordered-branch', async (child) => {
+                await child.span('ordered-grandchild', async (grandchild) => grandchild.ok('grandchild done'));
+                return child.ok('branch done');
+              });
+              await root.span('ordered-sibling', async (child) => child.ok('sibling done'));
+              return root.ok('grand root done');
+            });
+            return ['ordered-grand-root', 'ordered-branch', 'ordered-grandchild', 'ordered-sibling'];
+          },
+        },
+        {
+          name: 'random',
+          run: async (target: typeof tracer) => {
+            let state = 0x6d2b_79f5;
+            const next = () => {
+              state = (Math.imul(state, 1_664_525) + 1_013_904_223) >>> 0;
+              return state;
+            };
+            const expected = ['random-root'];
+            await target.trace('random-root', async (root) => {
+              for (let childIndex = 0; childIndex < 24; childIndex++) {
+                const childName = `random-child-${childIndex}`;
+                expected.push(childName);
+                await root.span(childName, async (child) => {
+                  const logCount = next() % 6;
+                  for (let logIndex = 0; logIndex < logCount; logIndex++) {
+                    child.log.info(`random-log-${childIndex}-${logIndex}`);
+                  }
+                  const grandchildCount = next() % 4;
+                  for (let grandchildIndex = 0; grandchildIndex < grandchildCount; grandchildIndex++) {
+                    const grandchildName = `random-grandchild-${childIndex}-${grandchildIndex}`;
+                    expected.push(grandchildName);
+                    await child.span(grandchildName, async (grandchild) => {
+                      grandchild.tag.latency(next() % 10_000).operation('UPDATE');
+                      return grandchild.ok('random grandchild done');
+                    });
+                  }
+                  return child.ok('random child done');
+                });
+              }
+              return root.ok('random root done');
+            });
+            return expected;
+          },
+        },
+        {
+          name: 'overflow',
+          run: async (target: typeof tracer) => {
+            await target.trace('overflow-parity-root', async (root) => {
+              for (let index = 0; index < 70; index++) root.log.info(`overflow-root-${index}`);
+              await root.span('overflow-parity-child', async (child) => {
+                for (let index = 0; index < 70; index++) child.log.info(`overflow-child-${index}`);
+                return child.ok('overflow child done');
+              });
+              return root.ok('overflow root done');
+            });
+            return ['overflow-parity-root', 'overflow-parity-child'];
+          },
+        },
+      ];
+
+      for (const workload of workloads) {
+        const jsRootIndex = jsTracer.rootBuffers.length;
+        const wasmRootIndex = tracer.rootBuffers.length;
+        const jsExpected = await workload.run(jsTracer);
+        const wasmExpected = await workload.run(tracer);
+        expect(wasmExpected).toEqual(jsExpected);
+
+        const jsRoot = jsTracer.rootBuffers[jsRootIndex];
+        if (!jsRoot) throw new Error(`${workload.name} JS workload did not produce a root buffer`);
+        const wasmRoot = tracer.rootBuffers[wasmRootIndex];
+        if (!wasmRoot) throw new Error(`${workload.name} WASM workload did not produce a root buffer`);
+        const jsTable = jsStrategy.toArrowTable(jsRoot);
+        const wasmTable = strategy.toArrowTable(wasmRoot);
+        expect(wasmTable.numRows).toBe(jsTable.numRows);
+
+        for (const columnName of ['entry_type', 'message', 'latency', 'success', 'operation']) {
+          const jsColumn = jsTable.getChild(columnName);
+          const wasmColumn = wasmTable.getChild(columnName);
+          if (!jsColumn || !wasmColumn) throw new Error(`${workload.name} is missing parity column ${columnName}`);
+          const jsValues = Array.from({ length: jsTable.numRows }, (_, row) => jsColumn.get(row));
+          const wasmValues = Array.from({ length: wasmTable.numRows }, (_, row) => wasmColumn.get(row));
+          expect(wasmValues).toEqual(jsValues);
+        }
+
+        const entryTypes = wasmTable.getChild('entry_type');
+        const messages = wasmTable.getChild('message');
+        if (!entryTypes || !messages) throw new Error(`${workload.name} is missing ordered span columns`);
+        const spanOrder: unknown[] = [];
+        for (let row = 0; row < wasmTable.numRows; row++) {
+          if (entryTypes.get(row) === 'span-start') spanOrder.push(messages.get(row));
+        }
+        expect(spanOrder).toEqual(wasmExpected);
+      }
+    });
+  });
+
   describe('Multiple traces', () => {
     it('maintains separate buffers for each trace', async () => {
       await tracer.trace('trace-1', async (ctx) => {
@@ -465,8 +838,8 @@ describe('WASM Integration Tests', () => {
       expect(buffer1.trace_id).not.toBe(buffer2.trace_id);
 
       // Different span names
-      expect(buffer1.message_values[0]).toBe('trace-1');
-      expect(buffer2.message_values[0]).toBe('trace-2');
+      expect(resolveMessage(buffer1, 0)).toBe('trace-1');
+      expect(resolveMessage(buffer2, 0)).toBe('trace-2');
 
       // Different user IDs
       expect(buffer1.userId_values?.[0]).toBe('user-1');