@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/__tests__/fixtures/empty-vocabulary-runtime.fixture.ts

@@ -0,0 +1,15 @@
+import { getVocabularyDictionaryPrefix } from '../../arrow/vocabularyDictionary.js';
+import { getVocabularyGeneration } from '../../vocabularyRegistry.js';
+
+const generation = getVocabularyGeneration();
+const prefix = getVocabularyDictionaryPrefix(generation);
+
+console.log(
+  JSON.stringify({
+    generation: generation.generation,
+    ids: Array.from(generation.ids),
+    prefixLength: prefix.length,
+    prefixValues: Array.from(prefix.column),
+    emptyDenseIndex: prefix.valueToDenseIndex.get(''),
+  }),
+);

package/src/lib/__tests__/flushScheduler.test.ts

@@ -23,7 +23,11 @@ function createTestBuffer(): AnySpanBuffer {
   buffer._writeIndex = 5;
   for (let i = 0; i < buffer._writeIndex; i++) {
     buffer.timestamp[i] = BigInt(Date.now()) * 1_000_000n;
-    buffer.entry_type[i] = 1;
+    {
+      const entryTypes = buffer.entry_type;
+      if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+      entryTypes[i] = 1;
+    }
   }
   return buffer;
 }

package/src/lib/__tests__/identity-view.property.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, it, spyOn } from 'bun:test';
+import fc from 'fast-check';
+import { JsBufferStrategy } from '../JsBufferStrategy.js';
+import { createTraceId } from '../traceId.js';
+import type { AnySpanBuffer } from '../types.js';
+import { createTestOpMetadata, createTestSchema, createTestTraceRoot } from './test-helpers.js';
+
+const schema = createTestSchema({});
+const metadata = createTestOpMetadata({ name: 'identity-view', line: 14 });
+const encoder = new TextEncoder();
+
+function exactBytes(bytes: Uint8Array): number[] {
+  return Array.from(bytes);
+}
+
+function expectJsIdentity(buffer: AnySpanBuffer, parent: AnySpanBuffer | undefined, traceBytes: Uint8Array): void {
+  const identity = buffer._identity;
+  const view = new DataView(identity.buffer, identity.byteOffset, identity.byteLength);
+
+  expect(view.getBigUint64(0, true)).toBe(buffer.thread_id);
+  expect(view.getUint32(8, true)).toBe(buffer.span_id);
+  if (parent === undefined) {
+    expect(identity.byteLength).toBe(13 + traceBytes.byteLength);
+    expect(identity[12]).toBe(traceBytes.byteLength);
+    expect(exactBytes(identity.subarray(13))).toEqual(exactBytes(traceBytes));
+    expect(buffer.parent_thread_id).toBe(0n);
+    expect(buffer.parent_span_id).toBe(0);
+    expect(buffer._hasParent).toBe(false);
+  } else {
+    expect(identity.byteLength).toBe(12);
+    expect(buffer.parent_thread_id).toBe(parent.thread_id);
+    expect(buffer.parent_span_id).toBe(parent.span_id);
+    expect(buffer._hasParent).toBe(true);
+  }
+}
+
+function printableTraceIdArbitrary() {
+  return fc
+    .array(fc.integer({ min: 0x20, max: 0x7e }), { minLength: 1, maxLength: 128 })
+    .map((codes) => String.fromCharCode(...codes));
+}
+
+describe('JavaScript span identity views', () => {
+  it('uses stable trace bytes and performs no DataView allocation or UTF-8 decode during identity access', () => {
+    const strategy = new JsBufferStrategy<typeof schema>();
+    const incoming = createTraceId('0af7651916cd43dd8448eb211c80319c');
+    const traceRoot = createTestTraceRoot(incoming);
+    const root = strategy.createSpanBuffer(schema, traceRoot, metadata, 8);
+    const child = strategy.createChildSpanBuffer(root, metadata, metadata, 8);
+    const overflow = strategy.createOverflowBuffer(child);
+    const traceBytes = traceRoot._traceIdBytes;
+
+    expect(traceRoot.trace_id).toBe(incoming);
+    expect(traceRoot._traceIdBytes).toBe(traceBytes);
+    expect(exactBytes(traceBytes)).toEqual(exactBytes(encoder.encode(incoming)));
+    expect(root._identity).not.toBe(child._identity);
+    expect(overflow._identity).toBe(child._identity);
+    expect(root._traceRoot._traceIdBytes).toBe(traceBytes);
+    expect(child._traceRoot._traceIdBytes).toBe(traceBytes);
+    expect(overflow._traceRoot._traceIdBytes).toBe(traceBytes);
+
+    const originalDataView = globalThis.DataView;
+    const dataViewDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'DataView');
+    if (dataViewDescriptor === undefined) throw new Error('global DataView descriptor is unavailable');
+    let dataViewAllocations = 0;
+    const CountingDataView = new Proxy(originalDataView, {
+      construct(target, argumentsList, newTarget) {
+        dataViewAllocations++;
+        return Reflect.construct(target, argumentsList, newTarget);
+      },
+    });
+    const decode = spyOn(TextDecoder.prototype, 'decode');
+    decode.mockClear();
+    Object.defineProperty(globalThis, 'DataView', { ...dataViewDescriptor, value: CountingDataView });
+    const copiedThreadIds = new Uint8Array(32);
+
+    try {
+      for (let iteration = 0; iteration < 20; iteration++) {
+        void root.span_id;
+        void root.thread_id;
+        void root.trace_id;
+        void child.span_id;
+        void child.thread_id;
+        void child.trace_id;
+        void child.parent_span_id;
+        void child.parent_thread_id;
+        void overflow.span_id;
+        void overflow.thread_id;
+        void overflow.trace_id;
+        void overflow.parent_span_id;
+        void overflow.parent_thread_id;
+      }
+      root.copyThreadIdTo(copiedThreadIds, 3);
+      child.copyParentThreadIdTo(copiedThreadIds, 19);
+
+      expect(dataViewAllocations).toBe(0);
+      expect(decode).toHaveBeenCalledTimes(0);
+    } finally {
+      Object.defineProperty(globalThis, 'DataView', dataViewDescriptor);
+      decode.mockRestore();
+    }
+
+    const copied = new DataView(copiedThreadIds.buffer);
+    expect(copied.getBigUint64(3, true)).toBe(root.thread_id);
+    expect(copied.getBigUint64(19, true)).toBe(root.thread_id);
+  });
+
+  it('preserves exact root, child, and overflow identity bytes for randomized span trees and release generations', () => {
+    fc.assert(
+      fc.property(
+        printableTraceIdArbitrary(),
+        fc.integer({ min: 0, max: 3 }),
+        fc.array(
+          fc.record({
+            parentSelector: fc.nat(),
+            overflowCount: fc.integer({ min: 0, max: 3 }),
+          }),
+          { minLength: 1, maxLength: 36 },
+        ),
+        (traceIdValue, rootOverflowCount, nodes) => {
+          const strategy = new JsBufferStrategy<typeof schema>();
+          const incoming = createTraceId(traceIdValue);
+          const traceRoot = createTestTraceRoot(incoming);
+          const root = strategy.createSpanBuffer(schema, traceRoot, metadata, 8);
+          const logicalSpans = [root];
+          const traceBytes = traceRoot._traceIdBytes;
+          const encodedTraceId = encoder.encode(incoming);
+
+          expect(traceRoot.trace_id).toBe(incoming);
+          expect(traceRoot._traceIdBytes).toBe(traceBytes);
+          expect(exactBytes(traceBytes)).toEqual(exactBytes(encodedTraceId));
+          expectJsIdentity(root, undefined, encodedTraceId);
+
+          let rootOverflowOwner = root;
+          for (let index = 0; index < rootOverflowCount; index++) {
+            const overflow = strategy.createOverflowBuffer(rootOverflowOwner);
+            expect(overflow._identity).toBe(root._identity);
+            expect(overflow._traceRoot._traceIdBytes).toBe(traceBytes);
+            expect(overflow.trace_id).toBe(incoming);
+            expect(overflow.span_id).toBe(root.span_id);
+            rootOverflowOwner = overflow;
+          }
+
+          for (const node of nodes) {
+            const parent = logicalSpans[node.parentSelector % logicalSpans.length];
+            if (parent === undefined) throw new Error('randomized parent selection failed');
+            const child = strategy.createChildSpanBuffer(parent, metadata, metadata, 8);
+            logicalSpans.push(child);
+
+            expect(child._identity).not.toBe(parent._identity);
+            expect(child._traceRoot._traceIdBytes).toBe(traceBytes);
+            expect(child.trace_id).toBe(incoming);
+            expectJsIdentity(child, parent, encodedTraceId);
+
+            let overflowOwner = child;
+            for (let index = 0; index < node.overflowCount; index++) {
+              const overflow = strategy.createOverflowBuffer(overflowOwner);
+              expect(overflow._identity).toBe(child._identity);
+              expect(overflow._traceRoot._traceIdBytes).toBe(traceBytes);
+              expect(overflow.trace_id).toBe(incoming);
+              expect(overflow.span_id).toBe(child.span_id);
+              expect(overflow.parent_span_id).toBe(parent.span_id);
+              expect(overflow.parent_thread_id).toBe(parent.thread_id);
+              overflowOwner = overflow;
+            }
+          }
+
+          const topology = traceRoot._topology;
+          const generation = topology.generation;
+          strategy.releaseBuffer(root);
+          expect(topology.generation).toBe(generation + 1);
+          expect(traceRoot._traceIdBytes).toBe(traceBytes);
+          expect(exactBytes(traceBytes)).toEqual(exactBytes(encodedTraceId));
+        },
+      ),
+      { numRuns: 60 },
+    );
+  });
+});

package/src/lib/__tests__/library.test.ts

@@ -6,7 +6,7 @@
  * - Prefix application for library composition
  * - Dependency wiring with .use()
  * - Clean API with prefixed column storage
- * - RemappedBufferView for Arrow conversion
+ * - Immutable remap descriptors for Arrow conversion
  * - Collision detection and type safety
  * - Library composition scenarios
  * - End-to-end integration verification
@@ -14,17 +14,10 @@
 
 import { describe, expect, it } from 'bun:test';
 import { defineOpContext } from '../defineOpContext.js';
-import {
-  createPrefixMapping,
-  createRemappedSpanLoggerClass,
-  generateRemappedBufferViewClass,
-  generateRemappedSpanLoggerClass,
-  type PrefixMapping,
-  prefixSchema,
-} from '../library.js';
+import { createPrefixMapping, createRemapDescriptor, prefixSchema } from '../library.js';
 import { S } from '../schema/builder.js';
 import { defineLogSchema } from '../schema/defineLogSchema.js';
-import { createBuffer, getMappedOpGroupInternals, getOpGroupInternals } from './test-helpers.js';
+import { getMappedOpGroupInternals, getOpGroupInternals } from './test-helpers.js';
 
 describe('Library Integration Pattern', () => {
   describe('Schema Prefixing', () => {
@@ -132,216 +125,30 @@ describe('Library Integration Pattern', () => {
     });
   });
 
-  describe('RemappedBufferView Generation', () => {
-    it('should generate valid RemappedBufferView class', () => {
-      const mapping: Record<string, string> = {
-        http_status: 'status',
-        http_method: 'method',
-      };
-
-      const ViewClass = generateRemappedBufferViewClass(mapping);
-
-      // Should create a callable constructor
-      expect(typeof ViewClass).toBe('function');
-
-      // Should cache same mapping
-      const ViewClass2 = generateRemappedBufferViewClass(mapping);
-      expect(ViewClass).toBe(ViewClass2); // Same cached instance
-    });
-
-    it('should handle empty prefix mapping', () => {
-      const mapping: Record<string, string> = {};
-      const ViewClass = generateRemappedBufferViewClass(mapping);
-
-      expect(typeof ViewClass).toBe('function');
-    });
-
-    it('should handle single field mapping', () => {
-      const mapping: Record<string, string> = {
-        http_status: 'status',
-      };
-      const ViewClass = generateRemappedBufferViewClass(mapping);
-
-      expect(typeof ViewClass).toBe('function');
-    });
-
-    it('should correctly map column access from prefixed to unprefixed', () => {
-      const mapping: Record<string, string> = {
-        http_status: 'status',
-        http_method: 'method',
-      };
-
-      const ViewClass = generateRemappedBufferViewClass(mapping);
-
-      const mockBuffer = createBuffer(
-        defineLogSchema({
-          status: S.number(),
-          method: S.category(),
-        }),
-      );
-      mockBuffer.status(0, 200);
-      mockBuffer._writeIndex = 1;
-
-      const mockValues = mockBuffer.getColumnIfAllocated('status');
-      const mockNulls = mockBuffer.getNullsIfAllocated('status');
-
-      const view = new ViewClass(mockBuffer);
-
-      // Should map prefixed to unprefixed
-      expect(view.getColumnIfAllocated('http_status')).toBe(mockValues);
-      expect(view.getNullsIfAllocated('http_status')).toBe(mockNulls);
-
-      // Should pass through unknown names
-      expect(view.getColumnIfAllocated('unknown')).toBeUndefined();
-      expect(view.getNullsIfAllocated('unknown')).toBeUndefined();
-    });
-  });
-
-  describe('RemappedSpanLogger Generation', () => {
-    it('should generate valid JavaScript code', () => {
+  describe('Remap descriptor metadata', () => {
+    it('preserves composed output order and schema identity in immutable cold-path metadata', () => {
       const schema = defineLogSchema({
         status: S.number(),
         method: S.enum(['GET', 'POST']),
       });
-      const mapping: PrefixMapping = {
-        status: 'http_status',
-        method: 'http_method',
-      };
-
-      const code = generateRemappedSpanLoggerClass(schema, mapping);
-
-      // Should be valid JavaScript
-      expect(() => new Function(`return ${code}`)()).not.toThrow();
-    });
-
-    it('should generate class with clean method names', () => {
-      const schema = defineLogSchema({
-        status: S.number(),
-        duration: S.number(),
-      });
-      const mapping: PrefixMapping = {
-        status: 'http_status',
-        duration: 'http_duration',
-      };
-
-      const code = generateRemappedSpanLoggerClass(schema, mapping);
-
-      // Should contain clean method names
-      expect(code).toContain('status(value)');
-      expect(code).toContain('duration(value)');
-      // Should reference prefixed columns
-      expect(code).toContain('http_status');
-      expect(code).toContain('http_duration');
-    });
 
-    it('should include enum mapping functions', () => {
-      const schema = defineLogSchema({
-        method: S.enum(['GET', 'POST', 'PUT']),
+      const descriptor = createRemapDescriptor(schema, {
+        v1_api_method: 'method',
+        v1_api_status: 'status',
       });
-      const mapping: PrefixMapping = {
-        method: 'http_method',
-      };
-
-      const code = generateRemappedSpanLoggerClass(schema, mapping);
 
-      // Should contain enum mapping function
-      expect(code).toContain('getEnumIndex_method');
-      expect(code).toContain('case "GET"');
-      expect(code).toContain('case "POST"');
-      expect(code).toContain('case "PUT"');
-    });
-
-    it('should include prefix mapping for with() method', () => {
-      const schema = defineLogSchema({
-        status: S.number(),
+      expect(descriptor.sourceNames).toEqual({
+        v1_api_method: 'method',
+        v1_api_status: 'status',
       });
-      const mapping: PrefixMapping = {
-        status: 'http_status',
-      };
-
-      const code = generateRemappedSpanLoggerClass(schema, mapping);
-
-      // Should include PREFIX_MAPPING constant
-      expect(code).toContain('PREFIX_MAPPING');
-      expect(code).toContain('"status":"http_status"');
-    });
-
-    it('should create a class constructor', () => {
-      const schema = defineLogSchema({
-        status: S.number(),
-      });
-      const mapping: PrefixMapping = {
-        status: 'http_status',
-      };
-
-      const SpanLoggerClass = createRemappedSpanLoggerClass(schema, mapping);
-
-      expect(typeof SpanLoggerClass).toBe('function');
-    });
-
-    it('should handle all field types in code generation', () => {
-      const schema = defineLogSchema({
-        enumField: S.enum(['A', 'B']),
-        categoryField: S.category(),
-        textField: S.text(),
-        numberField: S.number(),
-        booleanField: S.boolean(),
-      });
-
-      const mapping: PrefixMapping = {
-        enumField: 'test_enumField',
-        categoryField: 'test_categoryField',
-        textField: 'test_textField',
-        numberField: 'test_numberField',
-        booleanField: 'test_booleanField',
-      };
-
-      const code = generateRemappedSpanLoggerClass(schema, mapping);
-
-      // Should handle all field types appropriately
-      expect(code).toContain('getEnumIndex_enumField'); // Enum mapping
-      expect(code).toContain('categoryField(value)'); // Category storage
-      expect(code).toContain('textField(value)'); // Text storage
-      expect(code).toContain('numberField(value)'); // Number storage
-      expect(code).toContain('booleanField(value)'); // Boolean storage
-    });
-
-    it('should cache generated classes for the same schema and mapping', () => {
-      const schema = defineLogSchema({
-        status: S.number(),
-      });
-      const mapping: PrefixMapping = {
-        status: 'http_status',
-      };
-
-      const Class1 = createRemappedSpanLoggerClass(schema, mapping);
-      const Class2 = createRemappedSpanLoggerClass(schema, mapping);
-
-      // Same schema + mapping should return cached class
-      expect(Class1).toBe(Class2);
-    });
-
-    it('should create different classes for different schemas', () => {
-      const schema1 = defineLogSchema({ status: S.number() });
-      const schema2 = defineLogSchema({ code: S.number() });
-      const mapping1: PrefixMapping = { status: 'http_status' };
-      const mapping2: PrefixMapping = { code: 'http_code' };
-
-      const Class1 = createRemappedSpanLoggerClass(schema1, mapping1);
-      const Class2 = createRemappedSpanLoggerClass(schema2, mapping2);
-
-      expect(Class1).not.toBe(Class2);
-    });
-
-    it('should create different classes for same schema with different mappings', () => {
-      const schema = defineLogSchema({ status: S.number() });
-      const mapping1: PrefixMapping = { status: 'http_status' };
-      const mapping2: PrefixMapping = { status: 'api_status' };
-
-      const Class1 = createRemappedSpanLoggerClass(schema, mapping1);
-      const Class2 = createRemappedSpanLoggerClass(schema, mapping2);
-
-      expect(Class1).not.toBe(Class2);
+      expect(descriptor.columns).toEqual([
+        ['v1_api_method', 'method', schema.fields.method, 'method_values', 'method_nulls'],
+        ['v1_api_status', 'status', schema.fields.status, 'status_values', 'status_nulls'],
+      ]);
+      expect(Object.isFrozen(descriptor)).toBe(true);
+      expect(Object.isFrozen(descriptor.sourceNames)).toBe(true);
+      expect(Object.isFrozen(descriptor.columns)).toBe(true);
+      expect(descriptor.columns.every(Object.isFrozen)).toBe(true);
     });
   });
 });
@@ -908,27 +715,4 @@ describe('Edge Cases and Error Handling', () => {
       expect(prefixed).toHaveProperty('many_field99');
     });
   });
-
-  describe('Buffer Remapping Edge Cases', () => {
-    it('should handle mapping consistency', () => {
-      // Test that mapping and code generation are consistent
-      const schema = defineLogSchema({
-        status: S.number(),
-        method: S.enum(['GET', 'POST']),
-      });
-
-      const mapping = createPrefixMapping(schema, 'http');
-      const code = generateRemappedSpanLoggerClass(schema, mapping);
-
-      // Verify that the mapping referenced in code matches the generated mapping
-      expect(code).toContain('"status":"http_status"');
-      expect(code).toContain('"method":"http_method"');
-
-      // Verify that all prefixed columns are properly referenced
-      expect(code).toContain('http_status_values');
-      expect(code).toContain('http_status_nulls');
-      expect(code).toContain('http_method_values');
-      expect(code).toContain('http_method_nulls');
-    });
-  });
 });