@smoothbricks/lmao 0.2.2 → 0.2.3

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

@@ -7,9 +7,11 @@ import {
 } from '@smoothbricks/arrow-builder';
 import { convertToArrowTable, createSpanBuffer, ENTRY_TYPE_SPAN_START, S } from '@smoothbricks/lmao';
 import { defineOpContext } from '../../defineOpContext.js';
+import { resolveMessage } from '../../resolveMessage.js';
 import { defineLogSchema } from '../../schema/defineLogSchema.js';
 import { ENTRY_TYPE_INFO } from '../../schema/systemSchema.js';
 import { TestTracer } from '../../tracers/TestTracer.js';
+import { NO_NODE } from '../../traceTopology.js';
 import type { AnySpanBuffer } from '../../types.js';
 import { invokeWriterMethod, nextWriterRow, requireAnySpanBuffer } from '../arrow-test-helpers.js';
 import {
@@ -62,7 +64,7 @@ describe('Buffer Integration', () => {
     // Metadata
     expect(buf._capacity).toBe(capacity);
     expect(buf._writeIndex).toBe(0);
-    expect(buf._children).toHaveLength(0);
+    expect(buf._traceRoot._topology.firstChild[buf._nodeIndex]).toBe(NO_NODE);
   });
 
   it('integrates schema definition with buffer creation', () => {
@@ -144,7 +146,11 @@ describe('Buffer Integration', () => {
 
     // Set required system columns
     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;
 
     // Convert to Arrow table
@@ -188,7 +194,11 @@ describe('Buffer Integration', () => {
 
     // Set required system columns
     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;
 
     // Convert to Arrow table
@@ -230,7 +240,11 @@ describe('Buffer Integration', () => {
 
     // Set required system columns
     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;
 
     // Convert to Arrow table
@@ -300,7 +314,11 @@ describe('Buffer Integration', () => {
 
       // Set system columns
       buffer.timestamp[0] = 1000n;
-      buffer.entry_type[0] = ENTRY_TYPE_INFO;
+      {
+        const entryTypes = buffer.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = ENTRY_TYPE_INFO;
+      }
       buffer._writeIndex = 1;
 
       // Convert to Arrow using arrow-builder
@@ -332,12 +350,12 @@ describe('Buffer Integration', () => {
 
       // Verify buffer properly references schema via constructor
       expect(buffer._logSchema).toBe(schema);
-      expect(buffer.message_values[0]).toBe('context-integration');
+      expect(resolveMessage(buffer, 0)).toBe('context-integration');
 
       // Verify system metadata columns are accessible
       expect(buffer.span_id).toBeGreaterThan(0);
       expect(typeof buffer._hasParent).toBe('boolean');
-      expect(buffer._children).toBeInstanceOf(Array);
+      expect(buffer._traceRoot._topology.buffers[buffer._nodeIndex]).toBe(buffer);
       expect(buffer._writeIndex).toBe(0);
       expect(buffer._capacity).toBe(DEFAULT_BUFFER_CAPACITY);
     });

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

@@ -3,7 +3,7 @@ import { createColumnBuffer } from '@smoothbricks/arrow-builder';
 import { createTagWriter, S } from '@smoothbricks/lmao';
 import { createSpanBuffer } from '../../spanBuffer.js';
 
-import { createTestOpMetadata, createTestSchema, createTestTraceRoot } from '../test-helpers.js';
+import { createTestOpMetadata, createTestSchema, createTestSpanContext, createTestTraceRoot } from '../test-helpers.js';
 
 /**
  * Tests for lazy column initialization
@@ -331,6 +331,7 @@ describe('SpanBuffer Lazy Column Allocation', () => {
     });
 
     const buffer = createSpanBuffer(schema, createTestTraceRoot('test-trace'), createTestOpMetadata(), 8);
+    const context = createTestSpanContext(schema, buffer);
 
     // Lazy columns should be undefined before TagWriter access
     expect(buffer.getColumnIfAllocated('userId')).toBeUndefined();
@@ -339,7 +340,7 @@ describe('SpanBuffer Lazy Column Allocation', () => {
     expect(buffer.getColumnIfAllocated('operation')).toBeUndefined();
 
     // Create TagWriter and write to one column (createTagWriter expects LogSchema instance)
-    const tagWriter = createTagWriter(schema, buffer);
+    const tagWriter = createTagWriter(schema, context);
     tagWriter.userId('user-123');
 
     // After TagWriter write, the column should be allocated

package/src/lib/__tests__/buffer-overflow.test.ts

@@ -1,15 +1,15 @@
 import { beforeEach, describe, expect, it } from 'bun:test';
 import { DEFAULT_BUFFER_CAPACITY } from '@smoothbricks/arrow-builder';
 import fc from 'fast-check';
-import { createSpanLogger } from '../codegen/spanLoggerGenerator.js';
 import { DEFAULT_METADATA } from '../opContext/defineOp.js';
+import { resolveMessage } from '../resolveMessage.js';
 import { S } from '../schema/builder.js';
 import { LogSchema } from '../schema/LogSchema.js';
 import { mergeWithSystemSchema } from '../schema/systemSchema.js';
 import { createSpanBuffer, getSpanBufferClass, type SpanBufferConstructor } from '../spanBuffer.js';
 
-import type { AnySpanBuffer } from '../types.js';
-import { createBuffer, createTestTraceRoot } from './test-helpers.js';
+import type { AnySpanBuffer, SpanBuffer } from '../types.js';
+import { createBuffer, createTestSpanContext, createTestTraceRoot } from './test-helpers.js';
 
 /**
  * Property-based tests for buffer overflow handling.
@@ -41,6 +41,12 @@ const testSchema = new LogSchema(
 const RESERVED_ROWS = 2;
 const DB_OPERATIONS = ['SELECT', 'INSERT', 'UPDATE', 'DELETE'] as const;
 
+function createLoggerContext(buffer: SpanBuffer<typeof testSchema>) {
+  const ctx = createTestSpanContext(testSchema, buffer);
+  ctx._buffer._writeIndex = RESERVED_ROWS;
+  return ctx;
+}
+
 type BufferChainAnalysis = {
   bufferCount: number;
   totalEntries: number;
@@ -198,7 +204,7 @@ describe('Buffer Overflow Property Tests', () => {
             SpanBufferClass.stats.spansCreated = 0;
 
             const buffer = createBuffer(testSchema);
-            const logger = createSpanLogger(testSchema, buffer);
+            const logger = createLoggerContext(buffer)._spanLogger;
 
             // Write entries
             for (let i = 0; i < numEntries; i++) {
@@ -235,7 +241,7 @@ describe('Buffer Overflow Property Tests', () => {
           SpanBufferClass.stats.spansCreated = 0;
 
           const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-          const logger = createSpanLogger(testSchema, buffer);
+          const logger = createLoggerContext(buffer)._spanLogger;
 
           // Write entries
           for (let i = 0; i < numEntries; i++) {
@@ -260,7 +266,7 @@ describe('Buffer Overflow Property Tests', () => {
           SpanBufferClass.stats.spansCreated = 0;
 
           const buffer = createBuffer(testSchema);
-          const logger = createSpanLogger(testSchema, buffer);
+          const logger = createLoggerContext(buffer)._spanLogger;
 
           for (let i = 0; i < numEntries; i++) {
             logger.info(`msg-${i}`);
@@ -302,7 +308,7 @@ describe('Buffer Overflow Property Tests', () => {
           SpanBufferClass.stats.spansCreated = 0;
 
           const buffer = createBuffer(testSchema);
-          const logger = createSpanLogger(testSchema, buffer);
+          const logger = createLoggerContext(buffer)._spanLogger;
 
           const operations = ['SELECT', 'INSERT', 'UPDATE', 'DELETE'] as const;
 
@@ -342,7 +348,7 @@ describe('Buffer Overflow Property Tests', () => {
           SpanBufferClass.stats.spansCreated = 0;
 
           const buffer = createBuffer(testSchema);
-          const logger = createSpanLogger(testSchema, buffer);
+          const logger = createLoggerContext(buffer)._spanLogger;
 
           for (let i = 0; i < numEntries; i++) {
             logger.info(`msg-${i}`);
@@ -365,7 +371,7 @@ describe('Buffer Overflow Property Tests', () => {
           SpanBufferClass.stats.spansCreated = 0;
 
           const buffer = createBuffer(testSchema);
-          const logger = createSpanLogger(testSchema, buffer);
+          const logger = createLoggerContext(buffer)._spanLogger;
 
           for (let i = 0; i < numEntries; i++) {
             logger.info(`msg-${i}`);
@@ -392,7 +398,7 @@ describe('Buffer Overflow Property Tests', () => {
       const usableCapacity = capacity - RESERVED_ROWS; // 6 entries fit
 
       const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-      const logger = createSpanLogger(testSchema, buffer);
+      const logger = createLoggerContext(buffer)._spanLogger;
 
       // Write exactly usable capacity entries (6 with capacity=8, reserved=2)
       for (let i = 0; i < usableCapacity; i++) {
@@ -411,7 +417,7 @@ describe('Buffer Overflow Property Tests', () => {
       const usableCapacity = capacity - RESERVED_ROWS; // 6
 
       const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-      const logger = createSpanLogger(testSchema, buffer);
+      const logger = createLoggerContext(buffer)._spanLogger;
 
       // Write usable capacity + 1 entries (7 entries)
       for (let i = 0; i < usableCapacity + 1; i++) {
@@ -431,7 +437,7 @@ describe('Buffer Overflow Property Tests', () => {
     it('zero entries: single buffer with just reserved space', () => {
       const buffer = createBuffer(testSchema);
       // Create logger but don't write anything
-      createSpanLogger(testSchema, buffer);
+      createLoggerContext(buffer)._spanLogger;
 
       expect(buffer._overflow).toBeUndefined();
       // Logger constructor sets writeIndex to 2 (after reserved rows)
@@ -453,7 +459,7 @@ describe('Buffer Overflow Property Tests', () => {
             SpanBufferClass.stats.spansCreated = 0;
 
             const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-            const logger = createSpanLogger(testSchema, buffer);
+            const logger = createLoggerContext(buffer)._spanLogger;
 
             for (let i = 0; i < numEntries; i++) {
               logger.info(`msg-${i}`).requestId(`req-${i}`);
@@ -480,7 +486,7 @@ describe('Buffer Overflow Property Tests', () => {
       const usableCapacity = capacity - RESERVED_ROWS; // 6
 
       const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-      const logger = createSpanLogger(testSchema, buffer);
+      const logger = createLoggerContext(buffer)._spanLogger;
 
       // Set scope values that should be prefilled
       buffer._scopeValues = Object.freeze({
@@ -509,7 +515,7 @@ describe('Buffer Overflow Property Tests', () => {
       expect(overflowProbe._userId_values).toBeUndefined();
 
       // Row 0 has the actual entry (message IS allocated because .info() writes to it)
-      expect(overflowBuffer.message_values[0]).toBe('msg-6');
+      expect(resolveMessage(overflowBuffer, 0)).toBe('msg-6');
     });
 
     it('should prefill scoped attributes across multiple overflow buffers', () => {
@@ -517,7 +523,7 @@ describe('Buffer Overflow Property Tests', () => {
       const usableCapacity = capacity - RESERVED_ROWS; // 6
 
       const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-      const logger = createSpanLogger(testSchema, buffer);
+      const logger = createLoggerContext(buffer)._spanLogger;
 
       buffer._scopeValues = Object.freeze({
         requestId: 'req-xyz',
@@ -548,7 +554,7 @@ describe('Buffer Overflow Property Tests', () => {
       const usableCapacity = capacity - RESERVED_ROWS; // 6
 
       const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-      const logger = createSpanLogger(testSchema, buffer);
+      const logger = createLoggerContext(buffer)._spanLogger;
 
       // Set scope for ONLY userId and requestId, NOT operation or duration or success
       buffer._scopeValues = Object.freeze({
@@ -579,7 +585,7 @@ describe('Buffer Overflow Property Tests', () => {
       const usableCapacity = capacity - RESERVED_ROWS;
 
       const buffer = createSpanBuffer(testSchema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-      const logger = createSpanLogger(testSchema, buffer);
+      const logger = createLoggerContext(buffer)._spanLogger;
 
       // Set scope for userId but NEVER call .userId() directly
       buffer._scopeValues = Object.freeze({