@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/__tests__/span-lifecycle.test.ts

@@ -7,6 +7,7 @@ import { describe, expect, it } from 'bun:test';
 import { Nanoseconds } from '@smoothbricks/arrow-builder';
 import { convertSpanTreeToArrowTable } from '../convertToArrow.js';
 import { defineOpContext } from '../defineOpContext.js';
+import { resolveEntryType, resolveMessage } from '../resolveMessage.js';
 import { defineCodeError } from '../result.js';
 import { S } from '../schema/builder.js';
 import { defineLogSchema } from '../schema/defineLogSchema.js';
@@ -135,12 +136,13 @@ describe('Span Lifecycle', () => {
 
   it('should support spanSync for synchronous child spans', async () => {
     const tracer = new TestTracer(ctx, { ...createTestTracerOptions() });
+    const childOp = ctx.defineOp('sync-child-op', (childCtx) => {
+      childCtx.tag.spanName('sync-child');
+      return childCtx.ok('child-ok');
+    });
 
     const result = await tracer.trace('root-task', async (rootCtx) => {
-      const childResult = rootCtx.spanSync('sync-child', (childCtx) => {
-        childCtx.tag.spanName('sync-child');
-        return childCtx.ok('child-ok');
-      });
+      const childResult = rootCtx.spanSync('sync-child', childOp);
 
       expect(childResult).not.toBeInstanceOf(Promise);
       expect(childResult.success).toBe(true);
@@ -496,8 +498,8 @@ describe('Fixed Row Layout', () => {
 
     expect(result.success).toBe(true);
     expect(capturedBuffer).toBeDefined();
-    expect(capturedBuffer?.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-    expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+    expect(capturedBuffer ? resolveEntryType(capturedBuffer, 0) : undefined).toBe(ENTRY_TYPE_SPAN_START);
+    expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_OK);
   });
 
   it('should have span-start at row 0 and span-err at row 1 after ctx.err()', async () => {
@@ -511,8 +513,8 @@ describe('Fixed Row Layout', () => {
 
     expect(result.success).toBe(false);
     expect(capturedBuffer).toBeDefined();
-    expect(capturedBuffer?.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-    expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_ERR);
+    expect(capturedBuffer ? resolveEntryType(capturedBuffer, 0) : undefined).toBe(ENTRY_TYPE_SPAN_START);
+    expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_ERR);
   });
 
   it('should write ok fluent result attributes directly to row 1', async () => {
@@ -529,7 +531,7 @@ describe('Fixed Row Layout', () => {
       throw new Error('capturedBuffer is undefined');
     }
 
-    expect(capturedBuffer.message_values[1]).toBe('completed');
+    expect(resolveMessage(capturedBuffer, 1)).toBe('completed');
     expect(capturedBuffer.userId_values[1]).toBe('user-1');
     expect(capturedBuffer.operation_values[1]).toBe(0);
     expect(capturedBuffer.line_values[1]).toBe(42);
@@ -553,7 +555,7 @@ describe('Fixed Row Layout', () => {
       throw new Error('capturedBuffer is undefined');
     }
 
-    expect(capturedBuffer.message_values[1]).toBe('failed');
+    expect(resolveMessage(capturedBuffer, 1)).toBe('failed');
     expect(capturedBuffer.userId_values[1]).toBe('user-2');
     expect(capturedBuffer.error_code_values[1]).toBe('VALIDATION_ERROR');
     expect(capturedBuffer.line_values[1]).toBe(99);
@@ -571,8 +573,8 @@ describe('Fixed Row Layout', () => {
       }),
     ).rejects.toThrow('Unexpected failure');
     expect(capturedBuffer).toBeDefined();
-    expect(capturedBuffer?.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-    expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
+    expect(capturedBuffer ? resolveEntryType(capturedBuffer, 0) : undefined).toBe(ENTRY_TYPE_SPAN_START);
+    expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
   });
 
   it('should start writeIndex at 2 after span-start is written', async () => {
@@ -660,21 +662,47 @@ describe('Fixed Row Layout', () => {
     expect(buffer._spanStartTime).toBe(Nanoseconds.unsafe(111n));
   });
 
-  it('should expose _lastLoggedTime across overflow chain', () => {
-    const opMetadata = createTestOpMetadata();
-    const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), opMetadata, 4);
+  it('preserves strict chronological timestamps across root overflow and a child span', async () => {
+    let rootBuffer: AnySpanBuffer | undefined;
+    let childBuffer: AnySpanBuffer | undefined;
+    const { trace } = new TestTracer(ctx, { ...createTestTracerOptions() });
 
-    buffer._writeIndex = 4;
-    buffer.timestamp[0] = 100n;
-    buffer.timestamp[1] = 200n;
-    buffer.timestamp[2] = 300n;
-    buffer.timestamp[3] = 400n;
+    await trace('timestamp-order-root', async (root) => {
+      rootBuffer = root.buffer;
+      for (let i = 0; i < 100; i++) root.log.info(`root-${i}`);
+      await root.span('timestamp-order-child', async (child) => {
+        childBuffer = child.buffer;
+        for (let i = 0; i < 100; i++) child.log.info(`child-${i}`);
+        return child.ok('child done');
+      });
+      return root.ok('root done');
+    });
 
-    const overflow = buffer.getOrCreateOverflow();
-    overflow._writeIndex = 2;
-    overflow.timestamp[0] = 500n;
-    overflow.timestamp[1] = 600n;
+    if (!rootBuffer || !childBuffer) throw new Error('trace did not expose both lifecycle buffers');
+    expect(rootBuffer._overflow).toBeDefined();
+    expect(childBuffer._overflow).toBeDefined();
+
+    const chronological: bigint[] = [rootBuffer.timestamp[0]];
+    let segment: AnySpanBuffer | undefined = rootBuffer;
+    let first = true;
+    while (segment) {
+      for (let row = first ? 2 : 0; row < segment._writeIndex; row++) chronological.push(segment.timestamp[row]);
+      first = false;
+      segment = segment._overflow;
+    }
+    chronological.push(childBuffer.timestamp[0]);
+    segment = childBuffer;
+    first = true;
+    while (segment) {
+      for (let row = first ? 2 : 0; row < segment._writeIndex; row++) chronological.push(segment.timestamp[row]);
+      first = false;
+      segment = segment._overflow;
+    }
+    chronological.push(childBuffer.timestamp[1], rootBuffer.timestamp[1]);
 
-    expect(buffer._lastLoggedTime).toBe(Nanoseconds.unsafe(600n));
+    expect(chronological).toHaveLength(204);
+    for (let i = 1; i < chronological.length; i++) {
+      expect(chronological[i]).toBeGreaterThan(chronological[i - 1]);
+    }
   });
 });

package/src/lib/__tests__/spanbuffer-materializer-parity.test.ts

@@ -0,0 +1,266 @@
+/**
+ * Parity suite: SpanBuffer classes built by arrow-builder's compiled
+ * (new Function) materializer versus the closure-composed (no-eval)
+ * materializer MUST be byte-identical in observable behavior. The closure
+ * path — driven by the closureInit/closureMethods extension counterparts in
+ * spanBuffer.ts — is what production workerd runs, so any divergence here is
+ * a production bug.
+ *
+ * Non-deterministic state is normalized: span_id bytes inside _identity
+ * (global counter), thread id (compared for equality of layout, not value —
+ * it IS process-stable so compared directly), wall-clock timestamps are
+ * written explicitly so lanes stay deterministic.
+ */
+
+import { afterEach, describe, expect, it } from 'bun:test';
+import { type MaterializerMode, setMaterializerModeOverride } from '@smoothbricks/arrow-builder';
+import { createOpMetadata } from '../opContext/defineOp.js';
+import type { MessageLayoutFamily, MessagePhysicalLayout } from '../runtimeHint.js';
+import { S } from '../schema/builder.js';
+import { LogSchema } from '../schema/LogSchema.js';
+import { mergeWithSystemSchema } from '../schema/systemSchema.js';
+import { createChildSpanBuffer, createOverflowBuffer, createSpanBuffer, getSpanBufferClass } from '../spanBuffer.js';
+import type { AnySpanBuffer } from '../types.js';
+import { createTestTraceRoot } from './test-helpers.js';
+
+afterEach(() => {
+  setMaterializerModeOverride(undefined);
+});
+
+function withMode<T>(mode: MaterializerMode, fn: () => T): T {
+  setMaterializerModeOverride(mode);
+  try {
+    return fn();
+  } finally {
+    setMaterializerModeOverride(undefined);
+  }
+}
+
+const OP_METADATA = createOpMetadata('parity-op', '@test/parity', 'parity.test.ts', 'deadbeef', 7);
+
+const FAMILIES: readonly MessageLayoutFamily[] = ['mixed', 'static-only', 'dynamic-only'];
+const PHYSICALS: readonly MessagePhysicalLayout[] = ['current', 'specialized', 'packed'];
+
+function makeSchema(): LogSchema {
+  return new LogSchema(
+    mergeWithSystemSchema({
+      userId: S.category(),
+      operation: S.enum(['SELECT', 'INSERT', 'UPDATE', 'DELETE']),
+      duration: S.number(),
+      success: S.boolean(),
+    }),
+  );
+}
+
+function callMethod(target: object, name: string, ...args: unknown[]): unknown {
+  const method = Reflect.get(target, name);
+  if (typeof method !== 'function') throw new Error(`Missing method: ${name}`);
+  return Reflect.apply(method, target, args);
+}
+
+/** Deterministic write script driving generated setters and system lanes. */
+function fillBuffer(buffer: AnySpanBuffer): void {
+  callMethod(buffer, 'message', 0, 'span-name');
+  if (buffer._messageLayoutFamily === 'static-only') callMethod(buffer, 'message', 1, 'terminal');
+  else callMethod(buffer, 'message', 2, 'log-entry');
+  buffer.timestamp[0] = 1000n;
+  buffer.timestamp[2] = 2000n;
+  if (buffer.entry_type) buffer.entry_type[2] = 5;
+  if (buffer._rowHeaders) buffer._rowHeaders[2] = (7 << 8) | 5;
+  if (buffer._messageIds) buffer._messageIds[2] = 3;
+  if (buffer._logHeaders) buffer._logHeaders[2] = 9;
+  callMethod(buffer, 'userId', 2, 'alice');
+  callMethod(buffer, 'userId', 3, 'bob');
+  callMethod(buffer, 'operation', 2, 1);
+  callMethod(buffer, 'duration', 2, 12.5);
+  callMethod(buffer, 'success', 2, true);
+  callMethod(buffer, 'success', 3, false);
+  callMethod(buffer, 'duration', 3, null);
+  callMethod(buffer, 'line', 2, 42);
+  callMethod(buffer, 'uint64_value', 2, 99n);
+  buffer._writeIndex = 4;
+}
+
+function snapshotTypedArray(view: unknown): unknown {
+  if (view === undefined || view === null) return view;
+  if (ArrayBuffer.isView(view) && !(view instanceof DataView)) {
+    return {
+      ctor: view.constructor.name,
+      bytes: Array.from(new Uint8Array(view.buffer, view.byteOffset, view.byteLength)),
+    };
+  }
+  return { unexpected: String(view) };
+}
+
+const SCHEMA_COLUMNS = ['userId', 'operation', 'duration', 'success', 'line', 'uint64_value', 'error_code'] as const;
+
+/** Normalized observable state; span-id bytes in _identity are zeroed (global counter). */
+function snapshotBuffer(buffer: AnySpanBuffer): Record<string, unknown> {
+  const identity = Array.from(buffer._identity);
+  for (let i = 8; i < 12 && i < identity.length; i++) identity[i] = 0;
+  const snapshot: Record<string, unknown> = {
+    capacity: buffer._capacity,
+    writeIndex: buffer._writeIndex,
+    identity,
+    threadId: buffer.thread_id,
+    traceId: buffer.trace_id,
+    spanStartTime: buffer._spanStartTime,
+    lastLoggedTime: buffer._lastLoggedTime,
+    hasParent: Reflect.get(buffer, '_hasParent'),
+    parentThreadId: buffer.parent_thread_id,
+    statsSealed: buffer._statsSealed,
+    statsReservedRows: buffer._statsReservedRows,
+    scopeValues: buffer._scopeValues,
+    spanName: buffer._spanName,
+    terminalMessage: buffer._terminalMessage,
+    messageValues: buffer.message_values ? [...buffer.message_values] : undefined,
+    timestamp: snapshotTypedArray(buffer.timestamp),
+    entryType: snapshotTypedArray(buffer.entry_type),
+    messageIds: snapshotTypedArray(buffer._messageIds),
+    logHeaders: snapshotTypedArray(buffer._logHeaders),
+    rowHeaders: snapshotTypedArray(buffer._rowHeaders),
+    systemByteLength: buffer._system.byteLength,
+  };
+  for (const column of SCHEMA_COLUMNS) {
+    const values = buffer.getColumnIfAllocated(column);
+    const nulls = buffer.getNullsIfAllocated(column);
+    snapshot[`${column}.values`] = Array.isArray(values) ? [...values] : snapshotTypedArray(values);
+    snapshot[`${column}.nulls`] = nulls === undefined ? undefined : Array.from(nulls);
+  }
+  return snapshot;
+}
+
+interface FamilySnapshots {
+  root: Record<string, unknown>;
+  child: Record<string, unknown>;
+  chained: Record<string, unknown>;
+  identitySharedWithRoot: boolean;
+  prototypeShared: boolean;
+  statics: Record<string, unknown>;
+}
+
+function buildAndSnapshot(
+  mode: MaterializerMode,
+  schema: LogSchema,
+  family: MessageLayoutFamily,
+  physical: MessagePhysicalLayout,
+): FamilySnapshots {
+  return withMode(mode, () => {
+    const SpanBufferClass = getSpanBufferClass(schema, family, physical);
+    SpanBufferClass.stats.capacity = 16;
+    SpanBufferClass.stats.totalWrites = 0;
+    SpanBufferClass.stats.spansCreated = 0;
+    const traceRoot = createTestTraceRoot(`parity-${family}-${physical}`);
+
+    const root = createSpanBuffer(schema, traceRoot, OP_METADATA, 16, SpanBufferClass);
+    fillBuffer(root);
+    const child = createChildSpanBuffer(root, SpanBufferClass, OP_METADATA, OP_METADATA, 16);
+    fillBuffer(child);
+    const chained = createOverflowBuffer(root);
+    fillBuffer(chained);
+    callMethod(root, '_sealStatsChain');
+
+    return {
+      root: snapshotBuffer(root),
+      child: snapshotBuffer(child),
+      chained: snapshotBuffer(chained),
+      identitySharedWithRoot: chained._identity === root._identity,
+      prototypeShared: Object.getPrototypeOf(root) === Object.getPrototypeOf(chained),
+      statics: {
+        family: SpanBufferClass.messageLayoutFamily,
+        physical: SpanBufferClass.messagePhysicalLayout,
+        totalWrites: SpanBufferClass.stats.totalWrites,
+        spansCreated: SpanBufferClass.stats.spansCreated,
+      },
+    };
+  });
+}
+
+describe('SpanBuffer materializer parity (compiled vs closure-composed)', () => {
+  for (const family of FAMILIES) {
+    for (const physical of PHYSICALS) {
+      it(`root/child/chained buffers are byte-identical: ${family} x ${physical}`, () => {
+        const schema = makeSchema();
+        const compiled = buildAndSnapshot('compiled', schema, family, physical);
+        const closure = buildAndSnapshot('closure', schema, family, physical);
+        expect(closure).toEqual(compiled);
+        // Anti-vacuity: the scripts really wrote rows and sealed stats.
+        expect(closure.root.writeIndex).toBe(4);
+        expect(closure.statics.totalWrites).toBeGreaterThan(0);
+        expect(closure.identitySharedWithRoot).toBe(true);
+        expect(closure.prototypeShared).toBe(true);
+      });
+    }
+  }
+
+  it('caches classes per materializer mode without cross-mode pollution', () => {
+    const schema = makeSchema();
+    const Compiled = withMode('compiled', () => getSpanBufferClass(schema));
+    const Closure = withMode('closure', () => getSpanBufferClass(schema));
+    expect(Compiled).not.toBe(Closure);
+    expect(withMode('compiled', () => getSpanBufferClass(schema))).toBe(Compiled);
+    expect(withMode('closure', () => getSpanBufferClass(schema))).toBe(Closure);
+  });
+
+  it('exposes identical extension-member descriptors on both prototypes', () => {
+    const schema = makeSchema();
+    const memberNames = [
+      'span_id',
+      'thread_id',
+      'trace_id',
+      '_spanStartTime',
+      '_lastLoggedTime',
+      '_hasParent',
+      'parent_span_id',
+      'parent_thread_id',
+      'isParentOf',
+      'isChildOf',
+      'copyThreadIdTo',
+      'copyParentThreadIdTo',
+      '_logSchema',
+      '_messageLayoutFamily',
+      '_messagePhysicalLayout',
+      '_columns',
+      '_stats',
+      '_sealStats',
+      '_sealStatsChain',
+      'getOrCreateOverflow',
+      'message',
+    ];
+    const describeMembers = (proto: object) =>
+      memberNames.map((name) => {
+        const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+        if (!descriptor) return { name, missing: true };
+        return {
+          name,
+          kind: descriptor.get ? 'getter' : typeof descriptor.value,
+          enumerable: descriptor.enumerable,
+          configurable: descriptor.configurable,
+          writable: descriptor.writable,
+        };
+      });
+
+    const compiled = withMode('compiled', () => describeMembers(getSpanBufferClass(schema).prototype));
+    const closure = withMode('closure', () => describeMembers(getSpanBufferClass(schema).prototype));
+    expect(closure).toEqual(compiled);
+    expect(compiled.some((member) => 'missing' in member)).toBe(false);
+  });
+
+  it('enforces the static-only message row guard identically', () => {
+    const schema = makeSchema();
+    const messageFor = (mode: MaterializerMode) =>
+      withMode(mode, () => {
+        const SpanBufferClass = getSpanBufferClass(schema, 'static-only', 'current');
+        const traceRoot = createTestTraceRoot(`static-guard-${mode}`);
+        const buffer = createSpanBuffer(schema, traceRoot, OP_METADATA, 16, SpanBufferClass);
+        try {
+          callMethod(buffer, 'message', 2, 'not allowed');
+        } catch (error) {
+          return error instanceof Error ? `${error.constructor.name}: ${error.message}` : String(error);
+        }
+        throw new Error('expected the static-only message guard to throw');
+      });
+    expect(messageFor('closure')).toBe(messageFor('compiled'));
+    expect(messageFor('closure')).toContain('rows 0 and 1');
+  });
+});

package/src/lib/__tests__/sync-async-trace.test.ts

@@ -14,6 +14,7 @@ import { describe, expect, it } from 'bun:test';
 // Must import test-helpers first to initialize timestamp implementation
 import './test-helpers.js';
 import { defineOpContext } from '../defineOpContext.js';
+import { resolveEntryType } from '../resolveMessage.js';
 import { S } from '../schema/builder.js';
 import { defineLogSchema } from '../schema/defineLogSchema.js';
 import { ENTRY_TYPE_SPAN_EXCEPTION, ENTRY_TYPE_SPAN_OK, ENTRY_TYPE_SPAN_START } from '../schema/systemSchema.js';
@@ -43,7 +44,7 @@ describe('Sync/Async Trace Execution', () => {
         capturedBuffer = ctx.buffer;
 
         // At this point, span-start is written (row 0)
-        expect(ctx.buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
+        expect(resolveEntryType(ctx.buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
 
         // Row 1 not yet written (happens after function returns)
         return { success: true, value: 42 };
@@ -54,8 +55,8 @@ describe('Sync/Async Trace Execution', () => {
 
       // span-ok should be written to row 1 immediately after sync function returns
       expect(capturedBuffer).toBeDefined();
-      expect(capturedBuffer?.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 0) : undefined).toBe(ENTRY_TYPE_SPAN_START);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_OK);
 
       // Timestamp should be written
       expect(capturedBuffer?.timestamp[1]).toBeGreaterThan(0n);
@@ -78,7 +79,7 @@ describe('Sync/Async Trace Execution', () => {
           capturedBuffer = ctx.buffer;
 
           // span-start written at row 0
-          expect(ctx.buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
+          expect(resolveEntryType(ctx.buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
 
           throw testError;
         });
@@ -86,8 +87,8 @@ describe('Sync/Async Trace Execution', () => {
 
       // span-exception should be written to row 1 immediately
       expect(capturedBuffer).toBeDefined();
-      expect(capturedBuffer?.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 0) : undefined).toBe(ENTRY_TYPE_SPAN_START);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
 
       // Exception details should be written
       expect(capturedBuffer?.timestamp[1]).toBeGreaterThan(0n);
@@ -114,7 +115,7 @@ describe('Sync/Async Trace Execution', () => {
         capturedBuffer = ctx.buffer;
 
         // span-start is written at row 0
-        expect(ctx.buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
+        expect(resolveEntryType(ctx.buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
 
         // Row 1 not yet written (will be written after Promise resolves)
         // At this point, entry_type[1] may be 0 or pre-initialized
@@ -142,8 +143,8 @@ describe('Sync/Async Trace Execution', () => {
 
       // After Promise resolves, span-ok should be written to row 1
       expect(capturedBuffer).toBeDefined();
-      expect(capturedBuffer?.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 0) : undefined).toBe(ENTRY_TYPE_SPAN_START);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_OK);
 
       // Timestamp should be written
       expect(capturedBuffer?.timestamp[1]).toBeGreaterThan(0n);
@@ -166,7 +167,7 @@ describe('Sync/Async Trace Execution', () => {
         capturedBuffer = ctx.buffer;
 
         // span-start written at row 0
-        expect(ctx.buffer.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
+        expect(resolveEntryType(ctx.buffer, 0)).toBe(ENTRY_TYPE_SPAN_START);
 
         // Simulate async work before error
         await new Promise((resolve) => setTimeout(resolve, 10));
@@ -190,8 +191,8 @@ describe('Sync/Async Trace Execution', () => {
 
       // After Promise rejects, span-exception should be written to row 1
       expect(capturedBuffer).toBeDefined();
-      expect(capturedBuffer?.entry_type[0]).toBe(ENTRY_TYPE_SPAN_START);
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 0) : undefined).toBe(ENTRY_TYPE_SPAN_START);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_EXCEPTION);
 
       // Timestamp should be written
       expect(capturedBuffer?.timestamp[1]).toBeGreaterThan(0n);
@@ -227,8 +228,8 @@ describe('Sync/Async Trace Execution', () => {
 
       // Both buffers should have span-ok written
       expect(buffers.length).toBe(2);
-      expect(buffers[0].entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
-      expect(buffers[1].entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffers[0], 1)).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffers[1], 1)).toBe(ENTRY_TYPE_SPAN_OK);
 
       // Both traces should be collected
       expect(tracer.rootBuffers.length).toBe(2);
@@ -270,8 +271,8 @@ describe('Sync/Async Trace Execution', () => {
 
       // Both buffers should have span-ok written
       expect(buffers.length).toBe(2);
-      expect(buffers[0].entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
-      expect(buffers[1].entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffers[0], 1)).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffers[1], 1)).toBe(ENTRY_TYPE_SPAN_OK);
 
       // Both traces should be collected
       expect(tracer.rootBuffers.length).toBe(2);
@@ -315,9 +316,9 @@ describe('Sync/Async Trace Execution', () => {
 
       // All three buffers should have span-ok
       expect(buffers.length).toBe(3);
-      expect(buffers[0].entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
-      expect(buffers[1].entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
-      expect(buffers[2].entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffers[0], 1)).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffers[1], 1)).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(resolveEntryType(buffers[2], 1)).toBe(ENTRY_TYPE_SPAN_OK);
 
       // All three traces should be collected
       expect(tracer.rootBuffers.length).toBe(3);
@@ -347,7 +348,7 @@ describe('Sync/Async Trace Execution', () => {
       expect(result).toEqual({ id: 123 });
 
       // span-ok should be written
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_OK);
     });
 
     it('should support tags in async trace', async () => {
@@ -374,7 +375,7 @@ describe('Sync/Async Trace Execution', () => {
       expect(result).toEqual({ id: 123 });
 
       // span-ok should be written after Promise resolves
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_OK);
     });
 
     it('should support logging in sync trace', () => {
@@ -399,7 +400,7 @@ describe('Sync/Async Trace Execution', () => {
       expect(result).toBe('done');
 
       // span-ok at row 1
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_OK);
 
       // Events logged at rows 2+ (verified by successful completion)
     });
@@ -429,7 +430,7 @@ describe('Sync/Async Trace Execution', () => {
       expect(result).toBe('done');
 
       // span-ok at row 1 (written after Promise resolves)
-      expect(capturedBuffer?.entry_type[1]).toBe(ENTRY_TYPE_SPAN_OK);
+      expect(capturedBuffer ? resolveEntryType(capturedBuffer, 1) : undefined).toBe(ENTRY_TYPE_SPAN_OK);
     });
   });
 });