@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/__tests__/arrow-builder-integration/binary-arrow-conversion.test.ts

@@ -8,7 +8,14 @@
 import { describe, expect, it } from 'bun:test';
 import { decode } from '@msgpack/msgpack';
 import { createColumnWriter } from '@smoothbricks/arrow-builder';
-import { convertSpanTreeToArrowTable, convertToArrowTable, createSpanBuffer, S } from '@smoothbricks/lmao';
+import {
+  convertSpanTreeToArrowTable,
+  convertToArrowTable,
+  createChildSpanBuffer,
+  createSpanBuffer,
+  getSpanBufferClass,
+  S,
+} from '@smoothbricks/lmao';
 import typia from 'typia';
 import { ENTRY_TYPE_INFO, ENTRY_TYPE_SPAN_START } from '../../schema/systemSchema.js';
 import { invokeWriterMethod, nextWriterRow, requireBinaryCell, requireColumn } from '../arrow-test-helpers.js';
@@ -29,13 +36,21 @@ describe('Binary Arrow Conversion', () => {
       const row0 = invokeWriterMethod(nextWriterRow(writer), 'payload', { action: 'click', x: 100, y: 200 });
       invokeWriterMethod(row0, 'requestId', 'req-1');
       buffer.timestamp[0] = 1000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
 
       // Write row with a string payload
       const row1 = invokeWriterMethod(nextWriterRow(writer), 'payload', 'simple-string');
       invokeWriterMethod(row1, 'requestId', 'req-2');
       buffer.timestamp[1] = 2000n;
-      buffer.entry_type[1] = ENTRY_TYPE_INFO;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[1] = ENTRY_TYPE_INFO;
+      }
 
       buffer._writeIndex = 2;
 
@@ -82,7 +97,11 @@ describe('Binary Arrow Conversion', () => {
       };
       invokeWriterMethod(nextWriterRow(writer), 'request', requestData);
       buffer.timestamp[0] = 1000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       buffer._writeIndex = 1;
 
       const table = convertToArrowTable(buffer);
@@ -108,7 +127,11 @@ describe('Binary Arrow Conversion', () => {
       const rawBytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
       invokeWriterMethod(nextWriterRow(writer), 'rawData', rawBytes);
       buffer.timestamp[0] = 1000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       buffer._writeIndex = 1;
 
       const table = convertToArrowTable(buffer);
@@ -133,12 +156,20 @@ describe('Binary Arrow Conversion', () => {
       const firstRow = invokeWriterMethod(nextWriterRow(writer), 'payload', { key: 'value' });
       invokeWriterMethod(firstRow, 'requestId', 'req-1');
       buffer.timestamp[0] = 1000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
 
       // Row 1: payload NOT set (null)
       invokeWriterMethod(nextWriterRow(writer), 'requestId', 'req-2');
       buffer.timestamp[1] = 2000n;
-      buffer.entry_type[1] = ENTRY_TYPE_INFO;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[1] = ENTRY_TYPE_INFO;
+      }
 
       buffer._writeIndex = 2;
 
@@ -175,7 +206,11 @@ describe('Binary Arrow Conversion', () => {
         'GET',
       );
       buffer.timestamp[0] = 1000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       buffer._writeIndex = 1;
 
       const table = convertToArrowTable(buffer);
@@ -204,23 +239,32 @@ describe('Binary Arrow Conversion', () => {
       const rootRow = invokeWriterMethod(nextWriterRow(rootWriter), 'payload', { level: 'root', data: [1, 2] });
       invokeWriterMethod(rootRow, 'userId', 'user-root');
       rootBuffer.timestamp[0] = 1000n;
-      rootBuffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = rootBuffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       rootBuffer._writeIndex = 1;
 
-      // Create child buffer
-      const childBuffer = createSpanBuffer(schema, createTestTraceRoot('test-trace'), createTestOpMetadata());
+      // Create and register child buffer in the root trace topology.
+      const childBuffer = createChildSpanBuffer(
+        rootBuffer,
+        getSpanBufferClass(schema),
+        createTestOpMetadata(),
+        createTestOpMetadata(),
+      );
       const childWriter = createColumnWriter(schema, childBuffer);
 
       const childRow = invokeWriterMethod(nextWriterRow(childWriter), 'payload', { level: 'child', nested: { a: 1 } });
       invokeWriterMethod(childRow, 'userId', 'user-child');
       childBuffer.timestamp[0] = 2000n;
-      childBuffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = childBuffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       childBuffer._writeIndex = 1;
 
-      // Link parent-child
-      rootBuffer._children.push(childBuffer);
-      childBuffer._parent = rootBuffer;
-
       const table = convertSpanTreeToArrowTable(rootBuffer);
       const payloadCol = requireColumn(table, 'payload');
       expect(payloadCol).toBeDefined();
@@ -251,7 +295,11 @@ describe('Binary Arrow Conversion', () => {
 
       invokeWriterMethod(nextWriterRow(writer), 'payload', obj);
       buffer.timestamp[0] = 1000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       buffer._writeIndex = 1;
 
       // Mutate AFTER tagging -- Object.freeze should prevent this from affecting the stored reference
@@ -284,32 +332,51 @@ describe('Binary Arrow Conversion', () => {
       const rootRow0 = invokeWriterMethod(nextWriterRow(rootWriter), 'payload', { req: 1 });
       invokeWriterMethod(invokeWriterMethod(rootRow0, 'userId', 'user-A'), 'action', 'click');
       rootBuffer.timestamp[0] = 1000n;
-      rootBuffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = rootBuffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
 
       const rootRow1 = invokeWriterMethod(nextWriterRow(rootWriter), 'payload', { req: 2 });
       invokeWriterMethod(invokeWriterMethod(rootRow1, 'userId', 'user-A'), 'action', 'scroll');
       rootBuffer.timestamp[1] = 2000n;
-      rootBuffer.entry_type[1] = ENTRY_TYPE_INFO;
+      {
+        const entryTypes = rootBuffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[1] = ENTRY_TYPE_INFO;
+      }
 
       const rootRow2 = invokeWriterMethod(nextWriterRow(rootWriter), 'payload', { req: 3 });
       invokeWriterMethod(invokeWriterMethod(rootRow2, 'userId', 'user-B'), 'action', 'click');
       rootBuffer.timestamp[2] = 3000n;
-      rootBuffer.entry_type[2] = ENTRY_TYPE_INFO;
+      {
+        const entryTypes = rootBuffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[2] = ENTRY_TYPE_INFO;
+      }
 
       rootBuffer._writeIndex = 3;
 
-      // Child buffer with overlapping category values
-      const childBuffer = createSpanBuffer(schema, createTestTraceRoot('test-trace'), createTestOpMetadata());
+      // Child buffer with overlapping category values, registered in the root topology.
+      const childBuffer = createChildSpanBuffer(
+        rootBuffer,
+        getSpanBufferClass(schema),
+        createTestOpMetadata(),
+        createTestOpMetadata(),
+      );
       const childWriter = createColumnWriter(schema, childBuffer);
 
       const childDataRow = invokeWriterMethod(nextWriterRow(childWriter), 'payload', { req: 4 });
       invokeWriterMethod(invokeWriterMethod(childDataRow, 'userId', 'user-B'), 'action', 'submit');
       childBuffer.timestamp[0] = 4000n;
-      childBuffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = childBuffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
 
       childBuffer._writeIndex = 1;
-      rootBuffer._children.push(childBuffer);
-      childBuffer._parent = rootBuffer;
 
       // convertSpanTreeToArrowTable uses the shared-dict path (buildSortedCategoryDictionary)
       const table = convertSpanTreeToArrowTable(rootBuffer);
@@ -370,7 +437,11 @@ describe('Binary Arrow Conversion', () => {
 
         invokeWriterMethod(nextWriterRow(writer), 'payload', testValue);
         buffer.timestamp[0] = 1000n;
-        buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[0] = ENTRY_TYPE_SPAN_START;
+        }
         buffer._writeIndex = 1;
 
         const table = convertToArrowTable(buffer);

package/src/lib/__tests__/arrow-builder-integration/binary-comparison.test.ts

@@ -123,7 +123,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const value of testValues) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.value(idx, value);
         buffer._writeIndex++;
       }
@@ -158,7 +162,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const value of testValues) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.flag(idx, value);
         buffer._writeIndex++;
       }
@@ -184,7 +192,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const enumIdx of testIndices) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         callBufferWriter(buffer, 'status', idx, enumIdx);
         buffer._writeIndex++;
       }
@@ -207,7 +219,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const userId of testValues) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.userId(idx, userId);
         buffer._writeIndex++;
       }
@@ -233,7 +249,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const value of testValues) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.userMessage(idx, value);
         buffer._writeIndex++;
       }
@@ -257,7 +277,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const value of testValues) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         if (value !== null) {
           buffer.value(idx, value);
         } else {
@@ -298,7 +322,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const row of testData) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
 
         if (row.count !== null) {
           buffer.count(idx, row.count);
@@ -351,7 +379,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (let i = 0; i < 3; i++) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = timestamps[i];
-        buffer.entry_type[idx] = i;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = i;
+        }
         buffer._writeIndex++;
       }
 
@@ -407,7 +439,11 @@ describe('Arrow IPC Round-Trip', () => {
 
       const idx = buffer._writeIndex;
       buffer.timestamp[idx] = 1000n;
-      buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+      }
       buffer._writeIndex++;
 
       const table = convertToArrowTable(buffer);
@@ -449,7 +485,11 @@ describe('Arrow IPC Round-Trip', () => {
 
       const idx = buffer._writeIndex;
       buffer.timestamp[idx] = 1000n;
-      buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+      }
       buffer.category(idx, 'cat1');
       buffer.text(idx, 'text1');
       callBufferWriter(buffer, 'status', idx, 0);
@@ -482,7 +522,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const value of values) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         if (value !== null) {
           buffer.value(idx, value);
         } else {
@@ -526,7 +570,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const value of values) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         if (value !== null) {
           buffer.value(idx, value);
         } else {
@@ -566,7 +614,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const value of values) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.value(idx, value);
         buffer._writeIndex++;
       }
@@ -599,7 +651,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (const category of testValues) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.category(idx, category);
         buffer._writeIndex++;
       }
@@ -622,7 +678,11 @@ describe('Arrow IPC Round-Trip', () => {
       for (let i = 0; i < 100; i++) {
         const idx = buffer._writeIndex;
         buffer.timestamp[idx] = 1000n;
-        buffer.entry_type[idx] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[idx] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.userId(idx, testValue);
         buffer._writeIndex++;
       }

package/src/lib/__tests__/arrow-builder-integration/binary-format-compliance.test.ts

@@ -48,7 +48,11 @@ describe('Arrow Binary Format Compliance', () => {
       // Donbuffer._opMetadata = DEFAULT_METADATA;
 
       // Writebuffer.timestamp[0] = BigInt(Date.now()) * 1000000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       buffer.numberValue(0, 42);
       buffer._writeIndex = 1;
 
@@ -74,7 +78,11 @@ describe('Arrow Binary Format Compliance', () => {
       // Write test data using generated methods
       const testValue = 0x12345678;
       buffer.timestamp[0] = BigInt(Date.now()) * 1000000n;
-      buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_SPAN_START;
+      }
       buffer.uint32Value(0, testValue);
       buffer._writeIndex = 1;
 
@@ -115,7 +123,11 @@ describe('Arrow Binary Format Compliance', () => {
       for (let i = 0; i < testData.length; i++) {
         const value = testData[i];
         buffer.timestamp[i] = BigInt(Date.now()) * 1000000n;
-        buffer.entry_type[i] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[i] = ENTRY_TYPE_SPAN_START;
+        }
 
         if (value === null) {
           // Don't call the method for null values, just leave as default (null)
@@ -166,7 +178,11 @@ describe('Arrow Binary Format Compliance', () => {
 
       for (let i = 0; i < testValues.length; i++) {
         buffer.timestamp[i] = BigInt(Date.now()) * 1000000n;
-        buffer.entry_type[i] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[i] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.enumValue(i, testValues[i]);
       }
       buffer._writeIndex = testValues.length;
@@ -202,7 +218,11 @@ describe('Arrow Binary Format Compliance', () => {
 
       for (let i = 0; i < testValues.length; i++) {
         buffer.timestamp[i] = BigInt(Date.now()) * 1000000n;
-        buffer.entry_type[i] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[i] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.textValue(i, testValues[i]);
       }
       buffer._writeIndex = testValues.length;
@@ -260,7 +280,11 @@ describe('Arrow Binary Format Compliance', () => {
 
       for (let i = 0; i < testValues.length; i++) {
         buffer.timestamp[i] = BigInt(Date.now()) * 1000000n;
-        buffer.entry_type[i] = ENTRY_TYPE_SPAN_START;
+        {
+          const entryTypes = buffer.entry_type;
+          if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+          entryTypes[i] = ENTRY_TYPE_SPAN_START;
+        }
         buffer.boolValue(i, testValues[i]);
       }
       buffer._writeIndex = testValues.length;

package/src/lib/__tests__/arrow-builder-integration/buffer-chaining.test.ts

@@ -10,6 +10,7 @@ import {
   getSpanBufferClass,
   type SpanBufferConstructor,
 } from '../../spanBuffer.js';
+import { iterateSpanChildren, NO_NODE } from '../../traceTopology.js';
 
 import type { SpanBuffer } from '../../types.js';
 import { createBuffer, createTestSchema, createTestTraceRoot, createTraceId } from '../test-helpers.js';
@@ -117,7 +118,6 @@ describe('Buffer Chaining', () => {
       const parentBuffer = createBuffer(schema);
 
       const childBuffer = createChildSpanBuffer(parentBuffer, SpanBufferClass, DEFAULT_METADATA, DEFAULT_METADATA);
-      parentBuffer._children.push(childBuffer);
 
       const nextChildBuffer = createOverflowBuffer(childBuffer);
 
@@ -125,21 +125,20 @@ describe('Buffer Chaining', () => {
       expect(nextChildBuffer._parent).toBe(parentBuffer);
 
       // Should NOT be added to parent's children (it's a continuation, not a new span)
-      expect(parentBuffer._children).toHaveLength(1);
-      expect(parentBuffer._children[0]).toBe(childBuffer);
+      expect(Array.from(iterateSpanChildren(parentBuffer))).toEqual([childBuffer]);
     });
 
-    it('should create empty children array for chained buffer', () => {
+    it('should share logical child topology with a chained buffer', () => {
       const buffer = createBuffer(schema);
 
       // Add a child to original buffer
       const childBuffer = createChildSpanBuffer(buffer, SpanBufferClass, DEFAULT_METADATA, DEFAULT_METADATA);
-      buffer._children.push(childBuffer);
 
       const nextBuffer = createOverflowBuffer(buffer);
 
-      // Chained buffer should have empty children array
-      expect(nextBuffer._children).toHaveLength(0);
+      // Overflow segments share the logical span node and its children.
+      expect(nextBuffer._nodeIndex).toBe(buffer._nodeIndex);
+      expect(Array.from(iterateSpanChildren(nextBuffer))).toEqual([childBuffer]);
     });
   });
 
@@ -247,31 +246,29 @@ describe('Buffer Chaining', () => {
       const buffer1 = createOverflowBuffer(rootBuffer);
       const child1 = createChildSpanBuffer(buffer1, SpanBufferClass, DEFAULT_METADATA, DEFAULT_METADATA);
       const child2 = createChildSpanBuffer(buffer1, SpanBufferClass, DEFAULT_METADATA, DEFAULT_METADATA);
-      buffer1._children.push(child1, child2);
 
       // Create second chained buffer with children
       const buffer2 = createOverflowBuffer(buffer1);
       const child3 = createChildSpanBuffer(buffer2, SpanBufferClass, DEFAULT_METADATA, DEFAULT_METADATA);
-      buffer2._children.push(child3);
 
-      // Verify topology
-      // Overflow buffers inherit the logical parent (rootBuffer has no parent → undefined)
+      // Verify physical overflow links and allocation-free logical topology.
+      const topology = rootBuffer._traceRoot._topology;
       expect(rootBuffer._parent).toBeUndefined();
       expect(rootBuffer._overflow).toBe(buffer1);
-      expect(rootBuffer._children).toHaveLength(0);
-
-      // buffer1 is an OVERFLOW of rootBuffer, so it inherits rootBuffer._parent (undefined)
       expect(buffer1._parent).toBeUndefined();
       expect(buffer1._overflow).toBe(buffer2);
-      expect(buffer1._children).toHaveLength(2);
-      expect(buffer1._children[0]).toBe(child1);
-      expect(buffer1._children[1]).toBe(child2);
-
-      // buffer2 is an OVERFLOW of buffer1, so it inherits buffer1._parent (undefined)
       expect(buffer2._parent).toBeUndefined();
       expect(buffer2._overflow).toBeUndefined();
-      expect(buffer2._children).toHaveLength(1);
-      expect(buffer2._children[0]).toBe(child3);
+      expect(buffer1._nodeIndex).toBe(rootBuffer._nodeIndex);
+      expect(buffer2._nodeIndex).toBe(rootBuffer._nodeIndex);
+      expect(topology.count).toBe(4);
+      expect(topology.buffers[topology.root]).toBe(rootBuffer);
+      expect(topology.firstChild[rootBuffer._nodeIndex]).toBe(child1._nodeIndex);
+      expect(topology.nextSibling[child1._nodeIndex]).toBe(child2._nodeIndex);
+      expect(topology.nextSibling[child2._nodeIndex]).toBe(child3._nodeIndex);
+      expect(topology.nextSibling[child3._nodeIndex]).toBe(NO_NODE);
+      expect(topology.lastChild[rootBuffer._nodeIndex]).toBe(child3._nodeIndex);
+      expect(Array.from(iterateSpanChildren(rootBuffer))).toEqual([child1, child2, child3]);
 
       // Verify identity sharing
       expect(rootBuffer.trace_id).toBe(traceId);

package/src/lib/__tests__/arrow-builder-integration/foundation.test.ts

@@ -3,6 +3,7 @@ import { DEFAULT_BUFFER_CAPACITY } from '@smoothbricks/arrow-builder';
 import { DEFAULT_METADATA } from '../../opContext/defineOp.js';
 import { S } from '../../schema/builder.js';
 import { createSpanBuffer, getSpanBufferClass } from '../../spanBuffer.js';
+import { NO_NODE } from '../../traceTopology.js';
 
 import { createBuffer, createTestSchema, createTestTraceRoot, createTraceId } from '../test-helpers.js';
 
@@ -34,7 +35,9 @@ describe('Buffer Foundation', () => {
     expect(buf.count_values).toBeInstanceOf(Float64Array); // number → Float64Array
 
     // Metadata
-    expect(buf._children).toBeInstanceOf(Array);
+    const topology = buf._traceRoot._topology;
+    expect(topology.buffers[topology.root]).toBe(buf);
+    expect(topology.firstChild[buf._nodeIndex]).toBe(NO_NODE);
     expect(buf._writeIndex).toBe(0);
     expect(buf._capacity).toBe(DEFAULT_BUFFER_CAPACITY);
   });
@@ -50,7 +53,7 @@ describe('Buffer Foundation', () => {
     expect(buf.span_id).toBeGreaterThan(0);
     expect(buf._hasParent).toBe(false);
     expect(buf._parent).toBeUndefined();
-    expect(buf._children).toHaveLength(0);
+    expect(buf._traceRoot._topology.firstChild[buf._nodeIndex]).toBe(NO_NODE);
   });
 
   it('provides access to buffer stats via constructor', () => {