@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/__tests__/tag-writer-aot.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, it } from 'bun:test';
+import './test-helpers.js';
+import { createTagWriter, getTagWriterClass } from '../codegen/fixedPositionWriterGenerator.js';
+import { resolveEnumLookupDescriptor } from '../enumMetadata.js';
+import { S } from '../schema/builder.js';
+import { defineLogSchema } from '../schema/defineLogSchema.js';
+import { createSpanBuffer } from '../spanBuffer.js';
+import type { AnySpanBuffer } from '../types.js';
+import { createTestOpMetadata, createTestSchema, createTestSpanContext, createTestTraceRoot } from './test-helpers.js';
+
+function countFunctionConstructorCalls(run: () => void): number {
+  const originalDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'Function');
+  if (!originalDescriptor) throw new Error('Expected global Function descriptor');
+
+  const originalFunction = globalThis.Function;
+  let calls = 0;
+  const functionProbe = new Proxy(originalFunction, {
+    apply(target, thisArgument, argumentList) {
+      calls++;
+      return Reflect.apply(target, thisArgument, argumentList);
+    },
+    construct(target, argumentList, newTarget) {
+      calls++;
+      return Reflect.construct(target, argumentList, newTarget);
+    },
+  });
+
+  Object.defineProperty(globalThis, 'Function', {
+    configurable: originalDescriptor.configurable,
+    enumerable: originalDescriptor.enumerable,
+    value: functionProbe,
+    writable: originalDescriptor.writable,
+  });
+  try {
+    run();
+  } finally {
+    Object.defineProperty(globalThis, 'Function', originalDescriptor);
+  }
+  return calls;
+}
+
+function arrayColumn(buffer: AnySpanBuffer, name: string): unknown[] {
+  const column = buffer.getColumnIfAllocated(name);
+  if (!Array.isArray(column)) {
+    throw new Error(`${name} column was not allocated as an array`);
+  }
+  return column;
+}
+
+function float64Column(buffer: AnySpanBuffer, name: string): Float64Array {
+  const column = buffer.getColumnIfAllocated(name);
+  if (!(column instanceof Float64Array)) {
+    throw new Error(`${name} column was not allocated as a Float64Array`);
+  }
+  return column;
+}
+
+function uint8Column(buffer: AnySpanBuffer, name: string): Uint8Array {
+  const column = buffer.getColumnIfAllocated(name);
+  if (!(column instanceof Uint8Array)) {
+    throw new Error(`${name} column was not allocated as a Uint8Array`);
+  }
+  return column;
+}
+
+function bigUint64Column(buffer: AnySpanBuffer, name: string): BigUint64Array {
+  const column = buffer.getColumnIfAllocated(name);
+  if (!(column instanceof BigUint64Array)) {
+    throw new Error(`${name} column was not allocated as a BigUint64Array`);
+  }
+  return column;
+}
+
+function invokeWriterMethod(writer: object, methodName: string, value: unknown): unknown {
+  const method = Reflect.get(writer, methodName);
+  if (typeof method !== 'function') {
+    throw new Error(`TagWriter is missing ${methodName}()`);
+  }
+  return Reflect.apply(method, writer, [value]);
+}
+
+function setupWriter() {
+  const schema = createTestSchema({
+    categoryValue: S.category(),
+    textValue: S.text(),
+    numberValue: S.number(),
+    booleanValue: S.boolean(),
+    enumValue: S.enum(['FIRST', 'SECOND']),
+  });
+  const buffer = createSpanBuffer(schema, createTestTraceRoot('tag-writer-aot'), createTestOpMetadata(), 8);
+  const context = createTestSpanContext(schema, buffer);
+  return { buffer, schema, writer: createTagWriter(schema, context) };
+}
+
+describe('AOT-safe TagWriter class creation', () => {
+  it('creates and caches a constructor for a fresh schema without calling global Function', () => {
+    const schema = defineLogSchema({ status: S.enum(['QUEUED', 'DONE']) });
+    const enumLookup = resolveEnumLookupDescriptor(schema);
+
+    const functionConstructorCalls = countFunctionConstructorCalls(() => {
+      getTagWriterClass(schema, ['status'], enumLookup);
+    });
+
+    expect(functionConstructorCalls).toBe(0);
+  });
+
+  it('caches by schema identity and ordered eager-column key', () => {
+    const schema = defineLogSchema({ alpha: S.number(), beta: S.number() });
+    const sameEagerKey = getTagWriterClass(schema, ['alpha']);
+
+    expect(getTagWriterClass(schema, ['alpha'])).toBe(sameEagerKey);
+    expect(getTagWriterClass(schema, ['beta'])).not.toBe(sameEagerKey);
+    expect(getTagWriterClass(schema, ['alpha', 'beta'])).not.toBe(getTagWriterClass(schema, ['beta', 'alpha']));
+
+    const structurallyEqualSchema = defineLogSchema({ alpha: S.number(), beta: S.number() });
+    expect(getTagWriterClass(structurallyEqualSchema, ['alpha'])).not.toBe(sameEagerKey);
+  });
+});
+
+describe('TagWriter row-0 semantics', () => {
+  it('uses exact schema setter names, writes every scalar lane at row 0, and preserves fluent identity', () => {
+    const { buffer, writer } = setupWriter();
+
+    expect(writer.categoryValue('category-0')).toBe(writer);
+    expect(writer.textValue('text-0')).toBe(writer);
+    expect(writer.numberValue(42.5)).toBe(writer);
+    expect(writer.booleanValue(true)).toBe(writer);
+    expect(writer.enumValue('SECOND')).toBe(writer);
+    expect(writer.uint64_value(18_446_744_073_709_551_615n)).toBe(writer);
+
+    expect(arrayColumn(buffer, 'categoryValue')[0]).toBe('category-0');
+    expect(arrayColumn(buffer, 'textValue')[0]).toBe('text-0');
+    expect(float64Column(buffer, 'numberValue')[0]).toBe(42.5);
+    expect((uint8Column(buffer, 'booleanValue')[0] & 0b0000_0001) !== 0).toBe(true);
+    expect(uint8Column(buffer, 'enumValue')[0]).toBe(1);
+    expect(bigUint64Column(buffer, 'uint64_value')[0]).toBe(18_446_744_073_709_551_615n);
+  });
+
+  it('encodes an invalid enum value as ordinal zero', () => {
+    const { buffer, writer } = setupWriter();
+
+    expect(invokeWriterMethod(writer, 'enumValue', 'INVALID')).toBe(writer);
+    expect(uint8Column(buffer, 'enumValue')[0]).toBe(0);
+  });
+
+  it('with skips nullish values, evaluates attributes in schema order, and returns the same writer', () => {
+    const schema = createTestSchema({
+      first: S.number(),
+      nullValue: S.text(),
+      second: S.category(),
+      undefinedValue: S.number(),
+      third: S.boolean(),
+    });
+    const buffer = createSpanBuffer(schema, createTestTraceRoot('tag-writer-with-order'), createTestOpMetadata(), 8);
+    const context = createTestSpanContext(schema, buffer);
+    const writer = createTagWriter(schema, context);
+    const firstAccesses: string[] = [];
+    const accessed = new Set<string>();
+    const recordFirstAccess = (name: string): void => {
+      if (!accessed.has(name)) {
+        accessed.add(name);
+        firstAccesses.push(name);
+      }
+    };
+    const attributes = Object.defineProperties(
+      {},
+      {
+        third: {
+          enumerable: true,
+          get() {
+            recordFirstAccess('third');
+            return true;
+          },
+        },
+        undefinedValue: {
+          enumerable: true,
+          get() {
+            recordFirstAccess('undefinedValue');
+            return undefined;
+          },
+        },
+        second: {
+          enumerable: true,
+          get() {
+            recordFirstAccess('second');
+            return 'second-0';
+          },
+        },
+        nullValue: {
+          enumerable: true,
+          get() {
+            recordFirstAccess('nullValue');
+            return null;
+          },
+        },
+        first: {
+          enumerable: true,
+          get() {
+            recordFirstAccess('first');
+            return 1;
+          },
+        },
+      },
+    );
+
+    expect(invokeWriterMethod(writer, 'with', attributes)).toBe(writer);
+    expect(firstAccesses).toEqual(['first', 'nullValue', 'second', 'undefinedValue', 'third']);
+    expect(float64Column(buffer, 'first')[0]).toBe(1);
+    expect(arrayColumn(buffer, 'second')[0]).toBe('second-0');
+    expect((uint8Column(buffer, 'third')[0] & 0b0000_0001) !== 0).toBe(true);
+    expect(buffer.getColumnIfAllocated('nullValue')).toBeUndefined();
+    expect(buffer.getColumnIfAllocated('undefinedValue')).toBeUndefined();
+  });
+});

package/src/lib/__tests__/test-helpers.ts

@@ -6,7 +6,7 @@
  */
 
 import { DEFAULT_BUFFER_CAPACITY } from '@smoothbricks/arrow-builder';
-import { createSpanLogger, type SpanLoggerImpl } from '../codegen/spanLoggerGenerator.js';
+import type { SpanLoggerImpl } from '../codegen/spanLoggerGenerator.js';
 import { defineOpContext } from '../defineOpContext.js';
 import { JsBufferStrategy } from '../JsBufferStrategy.js';
 import { createOpMetadata, DEFAULT_METADATA } from '../opContext/defineOp.js';
@@ -20,10 +20,19 @@ import type {
 } from '../opContext/opGroupTypes.js';
 import type { OpMetadata } from '../opContext/opTypes.js';
 import type { OpContext } from '../opContext/types.js';
+import { type CallsitePlan, getPhysicalLayoutPlan, sealCallsitePlan } from '../physicalLayoutPlan.js';
+import {
+  RUNTIME_HINT_ANALYZED_VALID,
+  RUNTIME_HINT_FULL_CAPABILITIES,
+  RUNTIME_HINT_MESSAGE_LAYOUT_DYNAMIC_ONLY,
+  RUNTIME_HINT_MESSAGE_LAYOUT_MIXED,
+  RUNTIME_HINT_MESSAGE_LAYOUT_STATIC_ONLY,
+} from '../runtimeHint.js';
 import { LogSchema } from '../schema/LogSchema.js';
 import { mergeWithSystemSchema, type SystemSchemaFieldTypes } from '../schema/systemSchema.js';
 import type { SchemaFields } from '../schema/types.js';
-import { createSpanBuffer } from '../spanBuffer.js';
+import { createSpanBuffer, getSpanBufferClass } from '../spanBuffer.js';
+import { createSpanContextClass } from '../spanContext.js';
 import { createTraceId, type TraceId } from '../traceId.js';
 import type { ITraceRoot, TracerLifecycleHooks } from '../traceRoot.js';
 import { createTraceRoot } from '../traceRoot.node.js';
@@ -107,7 +116,11 @@ export function createTestTracerOptions<T extends LogSchema>(): TracerOptions<T>
  * Shared TestTracer instance for tests that create buffers directly.
  * Typed as TracerLifecycleHooks because that's what TraceRoot expects.
  */
-export const TEST_TRACER: TracerLifecycleHooks = new TestTracer(minimalOpContext, createTestTracerOptions());
+type MinimalLogSchema = (typeof minimalOpContext)['logBinding']['logSchema'];
+export const TEST_TRACER: TracerLifecycleHooks<MinimalLogSchema> = new TestTracer(
+  minimalOpContext,
+  createTestTracerOptions(),
+);
 
 type TestSpanBufferBundle<T extends SchemaFields> = {
   logBinding: LogBinding;
@@ -180,10 +193,7 @@ export function createTestLogBinding<T extends SchemaFields>(schema: T | LogSche
   // Wrap in LogSchema if plain SchemaFields provided
   const logSchema = schema instanceof LogSchema ? schema : createTestSchema(schema);
 
-  return {
-    logSchema,
-    remappedViewClass: undefined,
-  };
+  return { logSchema };
 }
 
 /**
@@ -237,6 +247,48 @@ export function createTestSpanBuffer<T extends SchemaFields>(
   return { logBinding, spanBuffer };
 }
 
+let testWriterContextPlanId = 0;
+
+type TestWriterOpContext<T extends SchemaFields> = OpContext<
+  LogSchema<T>,
+  Record<string, never>,
+  Record<string, never>,
+  Record<string, never>
+>;
+
+/** Create a real capability-complete SpanContext around an existing test buffer. */
+export function createTestSpanContext<
+  T extends SchemaFields,
+  Ctx extends OpContext<LogSchema<T>> = TestWriterOpContext<T>,
+>(schema: LogSchema<T>, buffer: SpanBuffer<LogSchema<T>>, callsitePlan?: CallsitePlan<LogSchema<T>, Ctx>) {
+  const messageLayoutHint =
+    buffer._messageLayoutFamily === 'static-only'
+      ? RUNTIME_HINT_MESSAGE_LAYOUT_STATIC_ONLY
+      : buffer._messageLayoutFamily === 'dynamic-only'
+        ? RUNTIME_HINT_MESSAGE_LAYOUT_DYNAMIC_ONLY
+        : RUNTIME_HINT_MESSAGE_LAYOUT_MIXED;
+  const runtimeHint =
+    RUNTIME_HINT_ANALYZED_VALID | RUNTIME_HINT_FULL_CAPABILITIES | messageLayoutHint | buffer._capacity;
+  const resolvedPlan =
+    callsitePlan ??
+    sealCallsitePlan(
+      getPhysicalLayoutPlan(
+        getSpanBufferClass(schema),
+        runtimeHint,
+        createSpanContextClass<Ctx>(
+          schema,
+          { logSchema: schema, remapDescriptor: undefined },
+          RUNTIME_HINT_FULL_CAPABILITIES,
+        ),
+        undefined,
+        'strategy-selected',
+        `test-writer-context:${testWriterContextPlanId++}`,
+      ),
+      DEFAULT_METADATA,
+    );
+  resolvedPlan.appenders.writeSpanStart(buffer, 'test-writer-context');
+  return new resolvedPlan.SpanContextClass(buffer, schema, resolvedPlan);
+}
 /**
  * Create a properly typed SpanLogger for testing.
  *
@@ -246,12 +298,15 @@ export function createTestSpanBuffer<T extends SchemaFields>(
  * @param schema - LogSchema to use
  * @returns Object with buffer and logger, both properly typed
  */
-export function createTestLogger<T extends LogSchema>(schema: T): TestLoggerBundle<T> {
-  const logBinding = createTestLogBinding(schema);
+export function createTestLogger<T extends SchemaFields>(
+  schema: LogSchema<T>,
+): TestLoggerBundle<LogSchema<SystemSchemaFieldTypes & T>> {
+  const runtimeSchema = createTestSchema(schema.fields);
+  const logBinding = createTestLogBinding(runtimeSchema);
   const traceRoot = createTestTraceRoot();
-  const buffer = createSpanBuffer(schema, traceRoot, DEFAULT_METADATA);
-  const logger = createSpanLogger(schema, buffer);
-  return { buffer, logger, logBinding };
+  const buffer = createSpanBuffer(runtimeSchema, traceRoot, DEFAULT_METADATA);
+  const context = createTestSpanContext(runtimeSchema, buffer);
+  return { buffer, logger: context._spanLogger, logBinding };
 }
 
 // =============================================================================

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

@@ -0,0 +1,62 @@
+import { afterEach, describe, expect, it, spyOn } from 'bun:test';
+
+import { _resetThreadId, copyThreadIdTo, getThreadId } from '../threadId.js';
+
+const THREAD_ID_BYTES = Uint8Array.of(0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef);
+const THREAD_ID_BIGINT = 0xefcdab8967452301n;
+
+afterEach(() => {
+  _resetThreadId();
+});
+
+describe('thread ID initialization', () => {
+  it('initializes once and copies the singleton bytes without aliasing', () => {
+    const getRandomValues = spyOn(crypto, 'getRandomValues').mockImplementation((array: Uint8Array<ArrayBuffer>) => {
+      array.set(THREAD_ID_BYTES);
+      return array;
+    });
+    _resetThreadId();
+
+    try {
+      const firstCopy = new Uint8Array(12).fill(0xaa);
+
+      copyThreadIdTo(firstCopy, 2);
+      firstCopy[2] = 0;
+
+      const secondCopy = new Uint8Array(THREAD_ID_BYTES.length);
+      copyThreadIdTo(secondCopy, 0);
+
+      expect(getRandomValues).toHaveBeenCalledTimes(1);
+      expect(Array.from(firstCopy)).toEqual([0xaa, 0xaa, 0, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xaa, 0xaa]);
+      expect(secondCopy).toEqual(THREAD_ID_BYTES);
+      expect(getThreadId()).toBe(THREAD_ID_BIGINT);
+    } finally {
+      getRandomValues.mockRestore();
+    }
+  });
+
+  it('retries entropy initialization after a provider failure instead of caching zeroes', () => {
+    let attempts = 0;
+    const getRandomValues = spyOn(crypto, 'getRandomValues').mockImplementation((array: Uint8Array<ArrayBuffer>) => {
+      attempts++;
+      if (attempts === 1) throw new Error('entropy temporarily unavailable');
+      array.set(THREAD_ID_BYTES);
+      return array;
+    });
+    _resetThreadId();
+
+    try {
+      expect(() => getThreadId()).toThrow('entropy temporarily unavailable');
+
+      const copied = new Uint8Array(THREAD_ID_BYTES.length);
+      copyThreadIdTo(copied, 0);
+
+      expect(getRandomValues).toHaveBeenCalledTimes(2);
+      expect(copied).toEqual(THREAD_ID_BYTES);
+      expect(getThreadId()).toBe(THREAD_ID_BIGINT);
+      expect(getThreadId()).not.toBe(0n);
+    } finally {
+      getRandomValues.mockRestore();
+    }
+  });
+});