@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/codegen/__tests__/fixedPositionWriter-uint64.test.ts

@@ -22,7 +22,13 @@
 
 import { describe, expect, it } from 'bun:test';
 import { createResultWriter, createTagWriter, ENTRY_TYPE_SPAN_OK, ENTRY_TYPE_SPAN_START, S } from '@smoothbricks/lmao';
-import { createTestOpMetadata, createTestSchema, createTestTraceRoot } from '../../__tests__/test-helpers.js';
+import {
+  createTestOpMetadata,
+  createTestSchema,
+  createTestSpanContext,
+  createTestTraceRoot,
+} from '../../__tests__/test-helpers.js';
+import { resolveEntryType } from '../../resolveMessage.js';
 import { createSpanBuffer } from '../../spanBuffer.js';
 import type { AnySpanBuffer } from '../../types.js';
 
@@ -37,7 +43,8 @@ import type { AnySpanBuffer } from '../../types.js';
 function setup() {
   const schema = createTestSchema({ batchId: S.category(), count: S.number() });
   const buffer = createSpanBuffer(schema, createTestTraceRoot('t'), createTestOpMetadata(), 8);
-  return { schema, buffer };
+  const context = createTestSpanContext(schema, buffer);
+  return { schema, buffer, context };
 }
 
 // Read the allocated `uint64_value` values, narrowed to BigUint64Array.
@@ -77,15 +84,35 @@ function writeUint64Runtime(writer: object, value: bigint | null): void {
   Reflect.apply(method, writer, [value]);
 }
 
+describe('fixed-position WriterState ownership', () => {
+  it('keeps tag and result writers as one-field views over declared state', () => {
+    const { schema, buffer, context } = setup();
+    const writers = [createTagWriter(schema, context), createResultWriter(schema, context)];
+
+    for (const writer of writers) {
+      expect(Reflect.ownKeys(writer)).toEqual(['_state']);
+      expect(Object.hasOwn(writer, '_buffer')).toBe(false);
+      expect(Object.hasOwn(writer, '_spanBuffer')).toBe(false);
+      expect(Object.hasOwn(writer, '_traceRoot')).toBe(false);
+      expect(Object.hasOwn(writer, '_appendLogEntry')).toBe(false);
+
+      const state = Reflect.get(writer, '_state');
+      expect(Object.is(state, context)).toBe(true);
+      expect(Reflect.get(state, '_spanBuffer')).toBe(buffer);
+      expect(Reflect.get(state, '_buffer')).toBe(buffer);
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Row placement
 // ---------------------------------------------------------------------------
 
 describe('uint64_value row placement', () => {
   it('TagWriter writes to row 0 (span-start)', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
 
-    createTagWriter(schema, buffer).uint64_value(123n);
+    createTagWriter(schema, context).uint64_value(123n);
 
     const values = uint64Column(buffer);
     const nulls = uint64Nulls(buffer);
@@ -96,9 +123,9 @@ describe('uint64_value row placement', () => {
   });
 
   it('ResultWriter writes to row 1 (span-completion)', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
 
-    createResultWriter(schema, buffer, { ok: true }, false).uint64_value(456n);
+    createResultWriter(schema, context).uint64_value(456n);
 
     const values = uint64Column(buffer);
     const nulls = uint64Nulls(buffer);
@@ -115,12 +142,12 @@ describe('uint64_value row placement', () => {
 
 describe('uint64_value cross-row independence (no collision)', () => {
   it('tag row 0 and result row 1 hold distinct values on one buffer', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
     const rowZero = 111n;
     const rowOne = 222n;
 
-    createTagWriter(schema, buffer).uint64_value(rowZero);
-    createResultWriter(schema, buffer, { ok: true }, false).uint64_value(rowOne);
+    createTagWriter(schema, context).uint64_value(rowZero);
+    createResultWriter(schema, context).uint64_value(rowOne);
 
     const values = uint64Column(buffer);
     const nulls = uint64Nulls(buffer);
@@ -132,13 +159,13 @@ describe('uint64_value cross-row independence (no collision)', () => {
   });
 
   it('is order-independent: result-first then tag yields the same layout', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
     const rowZero = 333n;
     const rowOne = 444n;
 
     // Reverse the write order relative to the previous case.
-    createResultWriter(schema, buffer, { ok: true }, false).uint64_value(rowOne);
-    createTagWriter(schema, buffer).uint64_value(rowZero);
+    createResultWriter(schema, context).uint64_value(rowOne);
+    createTagWriter(schema, context).uint64_value(rowZero);
 
     const values = uint64Column(buffer);
     expect(values[0]).toBe(rowZero);
@@ -146,12 +173,12 @@ describe('uint64_value cross-row independence (no collision)', () => {
   });
 
   it('survives the span lifecycle: writeSpanStart/writeSpanEnd never touch uint64_value', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
     const rowZero = 900n;
     const rowOne = 901n;
 
-    const tag = createTagWriter(schema, buffer);
-    const result = createResultWriter(schema, buffer, { ok: true }, false);
+    const tag = createTagWriter(schema, context);
+    const result = createResultWriter(schema, context);
 
     // Reproduce the production sequence: lifecycle start, user tags, user result, lifecycle end.
     buffer._traceRoot.writeSpanStart(buffer, 'lifecycle-span');
@@ -160,8 +187,8 @@ describe('uint64_value cross-row independence (no collision)', () => {
     buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_OK);
 
     // The lifecycle actually ran and wrote its OWN columns (entry_type)...
-    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);
     // ...without clobbering the user uint64 values in either row.
     const values = uint64Column(buffer);
     const nulls = uint64Nulls(buffer);
@@ -178,12 +205,12 @@ describe('uint64_value cross-row independence (no collision)', () => {
 
 describe('uint64_value lazy allocation', () => {
   it('is unallocated until first write, then allocated', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
 
     expect(buffer.getColumnIfAllocated('uint64_value')).toBeUndefined();
     expect(buffer.getNullsIfAllocated('uint64_value')).toBeUndefined();
 
-    createTagWriter(schema, buffer).uint64_value(7n);
+    createTagWriter(schema, context).uint64_value(7n);
 
     expect(buffer.getColumnIfAllocated('uint64_value')).toBeDefined();
     expect(uint64Column(buffer)[0]).toBe(7n);
@@ -196,15 +223,15 @@ describe('uint64_value lazy allocation', () => {
 
 describe('uint64_value chaining and sibling non-interference', () => {
   it('returns the writer for chaining', () => {
-    const { schema, buffer } = setup();
-    const tag = createTagWriter(schema, buffer);
+    const { schema, context } = setup();
+    const tag = createTagWriter(schema, context);
     expect(tag.uint64_value(1n)).toBe(tag);
   });
 
   it('batchId(...).uint64_value(...) lands both values', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
 
-    createTagWriter(schema, buffer).batchId('batch-A').uint64_value(10n);
+    createTagWriter(schema, context).batchId('batch-A').uint64_value(10n);
 
     expect(uint64Column(buffer)[0]).toBe(10n);
     const batch = buffer.getColumnIfAllocated('batchId');
@@ -215,9 +242,9 @@ describe('uint64_value chaining and sibling non-interference', () => {
   });
 
   it('uint64_value(...).batchId(...) lands both values (reverse order)', () => {
-    const { schema, buffer } = setup();
+    const { schema, buffer, context } = setup();
 
-    createTagWriter(schema, buffer).uint64_value(20n).batchId('batch-B');
+    createTagWriter(schema, context).uint64_value(20n).batchId('batch-B');
 
     expect(uint64Column(buffer)[0]).toBe(20n);
     const batch = buffer.getColumnIfAllocated('batchId');
@@ -234,8 +261,8 @@ describe('uint64_value chaining and sibling non-interference', () => {
 
 describe('uint64_value null handling', () => {
   it('writing null clears the null bit (value marked absent), not sets it', () => {
-    const { schema, buffer } = setup();
-    const tag = createTagWriter(schema, buffer);
+    const { schema, buffer, context } = setup();
+    const tag = createTagWriter(schema, context);
 
     // First set a real value so the null bit is on...
     tag.uint64_value(99n);
@@ -247,9 +274,9 @@ describe('uint64_value null handling', () => {
   });
 
   it('null at row 1 clears row 1 only, leaving a non-null row 0 intact', () => {
-    const { schema, buffer } = setup();
-    const tag = createTagWriter(schema, buffer);
-    const result = createResultWriter(schema, buffer, { ok: true }, false);
+    const { schema, buffer, context } = setup();
+    const tag = createTagWriter(schema, context);
+    const result = createResultWriter(schema, context);
 
     tag.uint64_value(5n);
     result.uint64_value(6n);
@@ -280,8 +307,8 @@ describe('uint64_value boundary values', () => {
 
   for (const { name, value } of cases) {
     it(`round-trips ${name} exactly`, () => {
-      const { schema, buffer } = setup();
-      createTagWriter(schema, buffer).uint64_value(value);
+      const { schema, buffer, context } = setup();
+      createTagWriter(schema, context).uint64_value(value);
 
       const values = uint64Column(buffer);
       expect(values[0]).toBe(value);
@@ -290,8 +317,8 @@ describe('uint64_value boundary values', () => {
   }
 
   it('stores 0n as a non-null zero, distinct from absent', () => {
-    const { schema, buffer } = setup();
-    createTagWriter(schema, buffer).uint64_value(0n);
+    const { schema, buffer, context } = setup();
+    createTagWriter(schema, context).uint64_value(0n);
 
     const values = uint64Column(buffer);
     const nulls = uint64Nulls(buffer);

package/src/lib/codegen/__tests__/nullBitmap.test.ts

@@ -7,48 +7,44 @@
  * Architecture changes (new design):
  * - SpanLogger handles log entries (rows 2+), NOT tag writes (row 0)
  * - Tag writing is done via ctx.tag which is a separate API (not on SpanLogger)
- * - SpanLogger constructor: (buffer, createNextBuffer)
- * - SpanLogger._writeIndex starts at 1 (rows 0/1 are reserved for span-start/end)
+ * - SpanLogger owns only `_state`, shared with its SpanContext
+ * - SpanContext owns the active buffer and write index state
  * - _setScope() stores scope values in buffer._scopeValues (immutable, frozen)
  * - Scope filling happens at Arrow conversion time, NOT during span execution
  * - Direct writes (tag/log) win over scope values on their respective rows
  */
 
 import { describe, expect, it } from 'bun:test';
-import { createBuffer, createTestTraceRoot } from '../../__tests__/test-helpers.js';
+import {
+  createBuffer,
+  createTestSchema,
+  createTestSpanContext,
+  createTestTraceRoot,
+} from '../../__tests__/test-helpers.js';
 import { DEFAULT_METADATA } from '../../opContext/defineOp.js';
 import { S } from '../../schema/builder.js';
-import { defineLogSchema } from '../../schema/defineLogSchema.js';
 import type { LogSchema } from '../../schema/types.js';
 import { createSpanBuffer, SpanBufferTestUtils } from '../../spanBuffer.js';
 
-import type { AnySpanBuffer } from '../../types.js';
-import { createSpanLoggerClass } from '../spanLoggerGenerator.js';
+import type { SpanBuffer } from '../../types.js';
 
 /**
  * Create a test buffer from a schema
  */
-function createTestBuffer(schema: LogSchema): AnySpanBuffer {
+function createTestBuffer<T extends LogSchema>(schema: T): SpanBuffer<T> {
   return createBuffer(schema);
 }
 
-/**
- * Create a test buffer with a specific capacity
- */
-function createTestBufferWithCapacity(schema: LogSchema, capacity: number): AnySpanBuffer {
-  return createSpanBuffer(schema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, capacity);
-}
-
 describe('null bitmap correctness', () => {
   describe('immutable scope semantics', () => {
     it('should store scope values in buffer._scopeValues as frozen object', () => {
-      const schema = defineLogSchema({
+      const schema = createTestSchema({
         requestId: S.category(),
       });
       const buffer = createTestBuffer(schema);
 
-      const SpanLoggerClass = createSpanLoggerClass(schema);
-      const logger = new SpanLoggerClass(buffer);
+      const ctx = createTestSpanContext(schema, buffer);
+      const logger = ctx._spanLogger;
 
       // _setScope should store values in buffer._scopeValues (not fill buffer columns)
       logger._setScope({ requestId: 'req-123' });
@@ -62,14 +58,14 @@ describe('null bitmap correctness', () => {
     });
 
     it('should create new frozen object on each _setScope call (merge semantics)', () => {
-      const schema = defineLogSchema({
+      const schema = createTestSchema({
         requestId: S.category(),
         userId: S.category(),
       });
       const buffer = createTestBuffer(schema);
 
-      const SpanLoggerClass = createSpanLoggerClass(schema);
-      const logger = new SpanLoggerClass(buffer);
+      const ctx = createTestSpanContext(schema, buffer);
+      const logger = ctx._spanLogger;
 
       // First setScope call
       logger._setScope({ requestId: 'req-123' });
@@ -94,14 +90,14 @@ describe('null bitmap correctness', () => {
     });
 
     it('should clear keys when null is passed (null clears, undefined ignores)', () => {
-      const schema = defineLogSchema({
+      const schema = createTestSchema({
         requestId: S.category(),
         userId: S.category(),
       });
       const buffer = createTestBuffer(schema);
 
-      const SpanLoggerClass = createSpanLoggerClass(schema);
-      const logger = new SpanLoggerClass(buffer);
+      const ctx = createTestSpanContext(schema, buffer);
+      const logger = ctx._spanLogger;
 
       // Set initial values
       logger._setScope({ requestId: 'req-123', userId: 'user-456' });
@@ -117,13 +113,13 @@ describe('null bitmap correctness', () => {
     });
 
     it('should NOT fill buffer columns during _setScope (deferred to Arrow conversion)', () => {
-      const schema = defineLogSchema({
+      const schema = createTestSchema({
         requestId: S.category(),
       });
       const buffer = createTestBuffer(schema);
 
-      const SpanLoggerClass = createSpanLoggerClass(schema);
-      const logger = new SpanLoggerClass(buffer);
+      const ctx = createTestSpanContext(schema, buffer);
+      const logger = ctx._spanLogger;
 
       // _setScope should NOT fill buffer columns
       logger._setScope({ requestId: 'req-123' });
@@ -143,7 +139,7 @@ describe('null bitmap correctness', () => {
       // - Scope values are stored in buffer._scopeValues as a plain object
       // - Scope filling happens at Arrow conversion time, NOT during span execution
       // - This is because scope values are "defaults" that fill null slots
-      const schema = defineLogSchema({
+      const schema = createTestSchema({
         requestId: S.category(),
       });
       const buffer = createTestBuffer(schema);
@@ -151,11 +147,11 @@ describe('null bitmap correctness', () => {
       // Set scope value via buffer._scopeValues directly for test setup
       buffer._scopeValues = Object.freeze({ requestId: 'req-123' });
 
-      const SpanLoggerClass = createSpanLoggerClass(schema);
-      const logger = new SpanLoggerClass(buffer);
+      const ctx = createTestSpanContext(schema, buffer);
+      const logger = ctx._spanLogger;
 
-      // Set _writeIndex to 4 so nextRow() makes it 5
-      logger._writeIndex = 4;
+      // Set the shared writer state so the next append writes row 5
+      ctx._buffer._writeIndex = 5;
 
       // Log a message - this does NOT write scoped attributes during execution
       // Scope values are filled at Arrow conversion time
@@ -173,20 +169,20 @@ describe('null bitmap correctness', () => {
     it('should NOT set null bitmap at index 9 during info() - scope is deferred', () => {
       // Same as above - scope values are NOT written during span execution
       // They are stored in buffer._scopeValues and filled at Arrow conversion
-      const schema = defineLogSchema({
+      const schema = createTestSchema({
         requestId: S.category(),
       });
       // Need capacity > 9 to test writing at index 9
-      const buffer = createTestBufferWithCapacity(schema, 16);
+      const buffer = createSpanBuffer(schema, createTestTraceRoot('test-trace'), DEFAULT_METADATA, 16);
 
       // Set scope value via buffer._scopeValues directly for test setup
       buffer._scopeValues = Object.freeze({ requestId: 'req-456' });
 
-      const SpanLoggerClass = createSpanLoggerClass(schema);
-      const logger = new SpanLoggerClass(buffer);
+      const ctx = createTestSpanContext(schema, buffer);
+      const logger = ctx._spanLogger;
 
-      // Set _writeIndex to 8 so nextRow() makes it 9
-      logger._writeIndex = 8;
+      // Set the shared writer state so the next append writes row 9
+      ctx._buffer._writeIndex = 9;
 
       // Log a message - does NOT write scoped attributes immediately
       logger.info('test message');

package/src/lib/codegen/__tests__/spanLoggerGenerator.test.ts

@@ -12,6 +12,7 @@
 
 import { describe, expect, it } from 'bun:test';
 import { createTestLogger } from '../../__tests__/test-helpers.js';
+import { resolveEntryType } from '../../resolveMessage.js';
 import { S } from '../../schema/builder.js';
 import { defineLogSchema } from '../../schema/defineLogSchema.js';
 import {
@@ -56,31 +57,46 @@ describe('createSpanLoggerClass', () => {
   });
 
   describe('instance creation', () => {
-    it('should create instance with buffer and createNextBuffer', () => {
+    it('should create instance with a state-backed buffer getter', () => {
       const schema = defineLogSchema({ userId: S.category() });
       const { buffer, logger } = createTestLogger(schema);
 
       expect(logger).toBeDefined();
-      expect(logger._buffer).toBe(buffer);
+      expect(Reflect.get(Reflect.get(logger, '_state'), 'buffer')).toBe(buffer);
       expect(buffer._scopeValues).toBeDefined();
     });
 
-    it('should start with _writeIndex = 1', () => {
+    it('should start at the first append row', () => {
       const schema = defineLogSchema({});
-      const { logger } = createTestLogger(schema);
+      const { buffer } = createTestLogger(schema);
+
+      expect(buffer._writeIndex - 1).toBe(1);
+    });
+    it('owns only the shared WriterState reference', () => {
+      const schema = defineLogSchema({ userId: S.category() });
+      const { buffer, logger } = createTestLogger(schema);
+
+      expect(Reflect.ownKeys(logger)).toEqual(['_state']);
+      expect(Object.hasOwn(logger, '_buffer')).toBe(false);
+      expect(Object.hasOwn(logger, '_writeIndex')).toBe(false);
+      expect(Object.hasOwn(logger, '_spanBuffer')).toBe(false);
+      expect(Object.hasOwn(logger, '_traceRoot')).toBe(false);
+      expect(Object.hasOwn(logger, '_appendLogEntry')).toBe(false);
+      expect(Object.hasOwn(logger, '_physicalLayoutPlan')).toBe(false);
 
-      expect(logger._writeIndex).toBe(1);
+      const state = Reflect.get(logger, '_state');
+      expect(Reflect.get(state, 'buffer')).toBe(buffer);
     });
   });
 
   describe('logging methods', () => {
-    it('should increment _writeIndex on info()', () => {
+    it('should advance the active buffer write index on info()', () => {
       const schema = defineLogSchema({ userId: S.category() });
-      const { logger } = createTestLogger(schema);
+      const { buffer, logger } = createTestLogger(schema);
 
-      expect(logger._writeIndex).toBe(1);
+      expect(buffer._writeIndex - 1).toBe(1);
       logger.info('Test message');
-      expect(logger._writeIndex).toBe(2);
+      expect(buffer._writeIndex - 1).toBe(2);
     });
 
     it('should write entry type for info()', () => {
@@ -88,7 +104,7 @@ describe('createSpanLoggerClass', () => {
       const { buffer, logger } = createTestLogger(schema);
 
       logger.info('Test message');
-      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_INFO);
+      expect(resolveEntryType(buffer, 2)).toBe(ENTRY_TYPE_INFO);
     });
 
     it('should write entry type for debug()', () => {
@@ -96,7 +112,7 @@ describe('createSpanLoggerClass', () => {
       const { buffer, logger } = createTestLogger(schema);
 
       logger.debug('Debug message');
-      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_DEBUG);
+      expect(resolveEntryType(buffer, 2)).toBe(ENTRY_TYPE_DEBUG);
     });
 
     it('should write entry type for warn()', () => {
@@ -104,7 +120,7 @@ describe('createSpanLoggerClass', () => {
       const { buffer, logger } = createTestLogger(schema);
 
       logger.warn('Warning message');
-      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_WARN);
+      expect(resolveEntryType(buffer, 2)).toBe(ENTRY_TYPE_WARN);
     });
 
     it('should write entry type for error()', () => {
@@ -112,7 +128,7 @@ describe('createSpanLoggerClass', () => {
       const { buffer, logger } = createTestLogger(schema);
 
       logger.error('Error message');
-      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_ERROR);
+      expect(resolveEntryType(buffer, 2)).toBe(ENTRY_TYPE_ERROR);
     });
 
     it('should write entry type for trace()', () => {
@@ -120,7 +136,7 @@ describe('createSpanLoggerClass', () => {
       const { buffer, logger } = createTestLogger(schema);
 
       logger.trace('Trace message');
-      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_TRACE);
+      expect(resolveEntryType(buffer, 2)).toBe(ENTRY_TYPE_TRACE);
     });
 
     it('should write timestamp for log entries', () => {
@@ -150,10 +166,10 @@ describe('createSpanLoggerClass', () => {
       // FluentLogEntry includes logging methods for continued chaining
       logger.info('First').info('Second').warn('Third');
 
-      expect(logger._writeIndex).toBe(4);
-      expect(buffer.entry_type[2]).toBe(ENTRY_TYPE_INFO);
-      expect(buffer.entry_type[3]).toBe(ENTRY_TYPE_INFO);
-      expect(buffer.entry_type[4]).toBe(ENTRY_TYPE_WARN);
+      expect(buffer._writeIndex - 1).toBe(4);
+      expect(resolveEntryType(buffer, 2)).toBe(ENTRY_TYPE_INFO);
+      expect(resolveEntryType(buffer, 3)).toBe(ENTRY_TYPE_INFO);
+      expect(resolveEntryType(buffer, 4)).toBe(ENTRY_TYPE_WARN);
     });
   });