@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/tracers/__tests__/ArrayQueueTracer.test.ts

@@ -5,6 +5,8 @@ import { describe, expect, it } from 'bun:test';
 import { createTestTracerOptions } from '../../__tests__/test-helpers.js';
 import { convertSpanTreeToArrowTable } from '../../convertToArrow.js';
 import { defineLogSchema, defineOpContext, S } from '../../defineOpContext.js';
+import { resolveMessage } from '../../resolveMessage.js';
+import { iterateSpanChildren } from '../../traceTopology.js';
 import { ArrayQueueTracer } from '../ArrayQueueTracer.js';
 
 describe('ArrayQueueTracer', () => {
@@ -31,7 +33,7 @@ describe('ArrayQueueTracer', () => {
       await trace('queued-trace', testOp);
 
       expect(tracer.queue).toHaveLength(1);
-      expect(tracer.queue[0].message_values[0]).toBe('queued-trace');
+      expect(resolveMessage(tracer.queue[0], 0)).toBe('queued-trace');
     });
 
     it('should queue multiple traces in order', async () => {
@@ -45,9 +47,9 @@ describe('ArrayQueueTracer', () => {
       await trace('third', testOp);
 
       expect(tracer.queue).toHaveLength(3);
-      expect(tracer.queue[0].message_values[0]).toBe('first');
-      expect(tracer.queue[1].message_values[0]).toBe('second');
-      expect(tracer.queue[2].message_values[0]).toBe('third');
+      expect(resolveMessage(tracer.queue[0], 0)).toBe('first');
+      expect(resolveMessage(tracer.queue[1], 0)).toBe('second');
+      expect(resolveMessage(tracer.queue[2], 0)).toBe('third');
     });
 
     it('should queue buffer even if trace throws', async () => {
@@ -61,7 +63,7 @@ describe('ArrayQueueTracer', () => {
       await expect(trace('failing', failOp)).rejects.toThrow('boom');
 
       expect(tracer.queue).toHaveLength(1);
-      expect(tracer.queue[0].message_values[0]).toBe('failing');
+      expect(resolveMessage(tracer.queue[0], 0)).toBe('failing');
     });
   });
 
@@ -78,8 +80,8 @@ describe('ArrayQueueTracer', () => {
       const drained = tracer.drain();
 
       expect(drained).toHaveLength(2);
-      expect(drained[0].message_values[0]).toBe('a');
-      expect(drained[1].message_values[0]).toBe('b');
+      expect(resolveMessage(drained[0], 0)).toBe('a');
+      expect(resolveMessage(drained[1], 0)).toBe('b');
     });
 
     it('should clear queue after drain', async () => {
@@ -116,7 +118,7 @@ describe('ArrayQueueTracer', () => {
       await trace('after', testOp);
 
       expect(tracer.queue).toHaveLength(1);
-      expect(tracer.queue[0].message_values[0]).toBe('after');
+      expect(resolveMessage(tracer.queue[0], 0)).toBe('after');
     });
 
     it('should return independent array (not reference to internal queue)', async () => {
@@ -177,8 +179,11 @@ describe('ArrayQueueTracer', () => {
       await trace('root', parentOp);
 
       const [buffer] = tracer.drain();
-      expect(buffer._children).toHaveLength(1);
-      expect(buffer._children[0].message_values[0]).toBe('child-span');
+      const children = Array.from(iterateSpanChildren(buffer));
+      expect(children).toHaveLength(1);
+      const [child] = children;
+      if (!child) throw new Error('expected queued child span');
+      expect(resolveMessage(child, 0)).toBe('child-span');
     });
   });
 });

package/src/lib/tracers/__tests__/TestTracer.test.ts

@@ -10,8 +10,10 @@ import '../../__tests__/test-helpers.js';
 import { createTestTracerOptions } from '../../__tests__/test-helpers.js';
 import { convertSpanTreeToArrowTable } from '../../convertToArrow.js';
 import { defineOpContext } from '../../defineOpContext.js';
+import { resolveMessage } from '../../resolveMessage.js';
 import { S } from '../../schema/builder.js';
 import { defineLogSchema } from '../../schema/defineLogSchema.js';
+import { iterateSpanChildren } from '../../traceTopology.js';
 import { TestTracer } from '../TestTracer.js';
 
 describe('TestTracer', () => {
@@ -37,7 +39,7 @@ describe('TestTracer', () => {
       await trace('my-trace', async (ctx) => ctx.ok('done'));
 
       expect(tracer.rootBuffers).toHaveLength(1);
-      expect(tracer.rootBuffers[0].message_values[0]).toBe('my-trace');
+      expect(resolveMessage(tracer.rootBuffers[0], 0)).toBe('my-trace');
     });
 
     it('should accumulate multiple traces', async () => {
@@ -49,9 +51,9 @@ describe('TestTracer', () => {
       await trace('trace-3', async (ctx) => ctx.ok('done'));
 
       expect(tracer.rootBuffers).toHaveLength(3);
-      expect(tracer.rootBuffers[0].message_values[0]).toBe('trace-1');
-      expect(tracer.rootBuffers[1].message_values[0]).toBe('trace-2');
-      expect(tracer.rootBuffers[2].message_values[0]).toBe('trace-3');
+      expect(resolveMessage(tracer.rootBuffers[0], 0)).toBe('trace-1');
+      expect(resolveMessage(tracer.rootBuffers[1], 0)).toBe('trace-2');
+      expect(resolveMessage(tracer.rootBuffers[2], 0)).toBe('trace-3');
     });
 
     it('should accumulate buffer even if trace throws', async () => {
@@ -66,7 +68,7 @@ describe('TestTracer', () => {
 
       // Buffer should still be collected
       expect(tracer.rootBuffers).toHaveLength(1);
-      expect(tracer.rootBuffers[0].message_values[0]).toBe('failing-trace');
+      expect(resolveMessage(tracer.rootBuffers[0], 0)).toBe('failing-trace');
     });
   });
 
@@ -85,9 +87,11 @@ describe('TestTracer', () => {
       expect(tracer.rootBuffers).toHaveLength(1);
       const rootBuffer = tracer.rootBuffers[0];
 
-      // Child spans are in _children array
-      expect(rootBuffer._children).toHaveLength(1);
-      expect(rootBuffer._children[0].message_values[0]).toBe('child-span');
+      const children = Array.from(iterateSpanChildren(rootBuffer));
+      expect(children).toHaveLength(1);
+      const [child] = children;
+      if (!child) throw new Error('expected child span');
+      expect(resolveMessage(child, 0)).toBe('child-span');
     });
 
     it('should support deeply nested spans', async () => {
@@ -105,10 +109,16 @@ describe('TestTracer', () => {
       });
 
       const root = tracer.rootBuffers[0];
-      expect(root._children).toHaveLength(1);
-      expect(root._children[0].message_values[0]).toBe('span-l2');
-      expect(root._children[0]._children).toHaveLength(1);
-      expect(root._children[0]._children[0].message_values[0]).toBe('span-l3');
+      const level2Children = Array.from(iterateSpanChildren(root));
+      expect(level2Children).toHaveLength(1);
+      const [level2] = level2Children;
+      if (!level2) throw new Error('expected level-2 span');
+      expect(resolveMessage(level2, 0)).toBe('span-l2');
+      const level3Children = Array.from(iterateSpanChildren(level2));
+      expect(level3Children).toHaveLength(1);
+      const [level3] = level3Children;
+      if (!level3) throw new Error('expected level-3 span');
+      expect(resolveMessage(level3, 0)).toBe('span-l3');
     });
   });
 
@@ -136,7 +146,7 @@ describe('TestTracer', () => {
       await trace('after-clear', async (ctx) => ctx.ok('done'));
 
       expect(tracer.rootBuffers).toHaveLength(1);
-      expect(tracer.rootBuffers[0].message_values[0]).toBe('after-clear');
+      expect(resolveMessage(tracer.rootBuffers[0], 0)).toBe('after-clear');
     });
   });
 

package/src/lib/types.ts

@@ -19,14 +19,16 @@ import type {
   TypedArray,
 } from '@smoothbricks/arrow-builder';
 import type { OpMetadata } from './opContext/opTypes.js';
+import type { MessageLayoutFamily, MessagePhysicalLayout } from './runtimeHint.js';
 import type { LogSchema } from './schema/LogSchema.js';
 import type { InferSchema } from './schema/types.js';
 import type { SpanBufferStats } from './spanBufferStats.js';
 import type { TraceId } from './traceId.js';
 import type { ITraceRoot } from './traceRoot.js';
+import type { VocabularyGeneration } from './vocabularyRegistry.js';
 
 // Re-export infrastructure types
-export type { LogBinding, RemappedViewConstructor } from './logBinding.js';
+export type { LogBinding, RemapDescriptor, RemappedColumn } from './logBinding.js';
 export type { OpMetadata } from './opContext/opTypes.js';
 export type { extractSpanIdentity, SpanIdentity } from './traceId.js';
 export type { TracerLifecycleHooks } from './traceRoot.js';
@@ -107,13 +109,35 @@ export interface AnySpanBuffer extends AnyColumnBuffer {
    */
   readonly timestamp: BigInt64Array;
 
+  /** Current and specialized layouts expose this direct lane; packed uses `resolveEntryType`. */
+  readonly entry_type?: Uint8Array;
+
+  /** Current-mode buffer-local template IDs. Zero selects the raw reference lane. */
+  readonly _messageIds?: Uint16Array;
+
+  /** Specialized 1-based global dense message identities. Zero selects the raw/null sidecar sentinel. */
+  readonly _logHeaders?: Uint32Array;
+
+  /** Packed row headers: low 8 bits entry type, high 24 bits dense message index plus one. */
+  readonly _rowHeaders?: Uint32Array;
+
+  /** Immutable vocabulary generation against which packed message indices resolve. */
+  readonly _vocabularyGeneration: VocabularyGeneration;
+  /** Concrete semantic message family selected once for this buffer constructor. */
+  readonly _messageLayoutFamily: MessageLayoutFamily;
   /**
-   * Entry type enum for each row (Uint8Array, 1 byte per entry).
-   *
-   * Per specs/lmao/01h_entry_types_and_logging_primitives.md:
-   * Values are ENTRY_TYPE_* constants (span-start=1, span-ok=2, etc.)
+   * One-shot token set by WASM constructors whose allocation export already
+   * initialized row 0, row 1, and the shared write index.
    */
-  readonly entry_type: Uint8Array;
+  _spanStartedAtAllocation?: boolean;
+  /** Concrete physical row layout selected once for this buffer constructor. */
+  readonly _messagePhysicalLayout: MessagePhysicalLayout;
+
+  /** Dedicated row-0 span name used when the selected capacity lane cannot represent it. */
+  _spanName?: string | number;
+
+  /** Dedicated row-1 raw result/exception text for static-only buffers. */
+  _terminalMessage?: string;
 
   /**
    * Timestamp of span start (row 0).
@@ -152,6 +176,12 @@ export interface AnySpanBuffer extends AnyColumnBuffer {
    */
   _overflow?: AnySpanBuffer;
 
+  /** Whether this physical segment has contributed its rows to shared stats. */
+  _statsSealed: boolean;
+
+  /** Lifecycle rows excluded when this physical segment is sealed (2 for first segment, 0 for overflow). */
+  _statsReservedRows: number;
+
   // ===========================================================================
   // Identity Getters (read from _identity bytes)
   // ===========================================================================
@@ -201,15 +231,15 @@ export interface AnySpanBuffer extends AnyColumnBuffer {
   readonly _logSchema: LogSchema;
 
   /**
-   * Column entries for Arrow conversion iteration.
-   * For SpanBuffer: delegates to _logSchema._columns (unprefixed names)
-   * For RemappedBufferView: built in constructor with prefixed names from mapping
-   *
-   * This enables Arrow conversion to iterate column names correctly regardless of
-   * whether the buffer is wrapped in a RemappedBufferView.
+   * Canonical schema column entries for this buffer.
+   * Output remapping lives separately in `_remapDescriptor` and is interpreted
+   * only by cold Arrow traversal.
    */
   readonly _columns: ReadonlyArray<[string, unknown]>;
 
+  /** Immutable cold-path output remapping attached to canonical child buffers. */
+  _remapDescriptor?: import('./logBinding.js').RemapDescriptor;
+
   /**
    * Shared stats for all buffers from same defineOpContext (accessed via constructor.stats).
    * Enables self-tuning capacity learning across all ops in the same context.
@@ -221,16 +251,13 @@ export interface AnySpanBuffer extends AnyColumnBuffer {
   // Tree Structure (for span hierarchy)
   // ===========================================================================
 
-  /**
-   * Child spans created via ctx.span().
-   * Per specs/lmao/01c: Parent-child relationship for trace tree.
-   */
-  _children: AnySpanBuffer[];
+  /** Stable trace-owned logical node index. Overflow segments share the same index. */
+  _nodeIndex: number;
 
-  /**
-   * Parent span buffer (undefined for root).
-   * Set during createChildSpanBuffer().
-   */
+  /** Trace-topology generation used to reject released or reset handles. */
+  _topologyGeneration: number;
+
+  /** Parent span buffer (undefined for root). Preserved for identity access and parent ascent. */
   _parent?: AnySpanBuffer;
 
   // ===========================================================================
@@ -275,12 +302,8 @@ export interface AnySpanBuffer extends AnyColumnBuffer {
   // These are explicitly typed here since they're always present from systemSchema.
   // ===========================================================================
 
-  /**
-   * Message column values - category strings (eager, always allocated).
-   * Contains span names, log messages, exception messages, etc.
-   */
-  readonly message_values: string[];
-  readonly message_nulls: Uint8Array;
+  /** Raw per-row message lane. Omitted by static-only; `undefined` is the null sentinel. */
+  readonly message_values?: (string | undefined)[];
 
   /**
    * Line number column values - Float64Array (lazy but always present).
@@ -391,6 +414,12 @@ export interface AnySpanBuffer extends AnyColumnBuffer {
    */
   getOrCreateOverflow(): AnySpanBuffer;
 
+  /** Account this physical segment's completed rows exactly once. */
+  _sealStats(): void;
+
+  /** Account every physical segment in this logical span's overflow chain exactly once. */
+  _sealStatsChain(): void;
+
   /**
    * Check if this span is a parent of another span.
    * Used for tree traversal and validation.
@@ -468,13 +497,13 @@ type FilterSchemaFields<T> = {
  * T is REQUIRED - there is no default. Use AnySpanBuffer for generic processing.
  */
 export type SpanBuffer<T extends LogSchema> = AnySpanBuffer & {
-  // Override tree structure with typed versions
-  _children: SpanBuffer<T>[];
+  // Preserve typed parent and overflow links.
   _parent?: SpanBuffer<T>;
   _overflow?: SpanBuffer<T>;
 
   // Override schema access with the concrete schema for this buffer family
   readonly _logSchema: T;
+  _traceRoot: ITraceRoot<T>;
   _scopeValues: Readonly<Partial<InferSchema<T>>>;
 
   // Override methods with typed versions
@@ -486,11 +515,13 @@ export type SpanBuffer<T extends LogSchema> = AnySpanBuffer & {
   [key: `${string}_nulls`]: Uint8Array | undefined;
 } & {
   // Schema-specific column data
-  readonly [K in keyof FilterSchemaFields<T['fields']> as `${K & string}_values`]: ValuesArrayType<
-    FilterSchemaFields<T['fields']>[K]
-  >;
+  readonly [K in keyof FilterSchemaFields<T['fields']> as K extends 'message'
+    ? never
+    : `${K & string}_values`]: ValuesArrayType<FilterSchemaFields<T['fields']>[K]>;
 } & {
-  readonly [K in keyof FilterSchemaFields<T['fields']> as `${K & string}_nulls`]: Uint8Array;
+  readonly [K in keyof FilterSchemaFields<T['fields']> as K extends 'message'
+    ? never
+    : `${K & string}_nulls`]: Uint8Array;
 } & {
   // Schema-specific setter methods (return this for method chaining)
   [K in keyof FilterSchemaFields<T['fields']>]: (