@smoothbricks/lmao 0.2.2 → 0.2.3

package/src/lib/wasm/__tests__/WasmBufferStrategy.test.ts

@@ -3,12 +3,17 @@
  */
 
 import { afterEach, beforeAll, describe, expect, it } from 'bun:test';
+import { getColumnValue, getRawTimestamp } from '../../__tests__/arrow-test-helpers.js';
+import { convertToLeasedArrowTable } from '../../convertToArrow.js';
 import { createOpMetadata } from '../../opContext/defineOp.js';
+import { resolveMessage } from '../../resolveMessage.js';
 import { S } from '../../schema/builder.js';
 import { defineLogSchema } from '../../schema/defineLogSchema.js';
 import type { TracerLifecycleHooks } from '../../traceRoot.js';
+import { iterateSpanChildren, iterateSpanTree, NO_NODE } from '../../traceTopology.js';
 import { WasmBufferStrategy } from '../WasmBufferStrategy.js';
 import { createWasmAllocator } from '../wasmAllocator.js';
+import { isWasmSpanBufferInstance, type WasmSpanBufferInstance } from '../wasmSpanBuffer.js';
 import { createWasmTraceRoot } from '../wasmTraceRoot.js';
 
 describe('WasmBufferStrategy', () => {
@@ -23,9 +28,16 @@ describe('WasmBufferStrategy', () => {
   // Test metadata for buffer creation
   const testMetadata = createOpMetadata('test-op', 'test-package', 'test.ts', 'abc123', 1);
 
+  function requireWasmSpanBuffer<T extends typeof testSchema>(value: unknown): WasmSpanBufferInstance<T> {
+    if (!isWasmSpanBufferInstance<T>(value)) {
+      throw new Error('expected WasmSpanBufferInstance');
+    }
+    return value;
+  }
+
   // Mock tracer lifecycle hooks for WasmTraceRoot
   let strategy: WasmBufferStrategy<typeof testSchema>;
-  let mockTracer: TracerLifecycleHooks;
+  let mockTracer: TracerLifecycleHooks<typeof testSchema>;
 
   beforeAll(async () => {
     strategy = await WasmBufferStrategy.create<typeof testSchema>({
@@ -42,6 +54,7 @@ describe('WasmBufferStrategy', () => {
       onSpanStart: () => {},
       onSpanEnd: () => {},
       onStatsWillResetFor: () => {},
+      getFlagEvaluatorForContext: () => undefined,
       bufferStrategy: strategy,
     };
   });
@@ -81,10 +94,11 @@ describe('WasmBufferStrategy', () => {
       const buffer = strategy.createSpanBuffer(testSchema, traceRoot, testMetadata);
       // Caller must set span name via message() - simulating writeSpanStart behavior
       buffer.message(0, 'test-span');
+      expect('message_nulls' in buffer).toBe(false);
 
       expect(buffer).toBeDefined();
       expect(buffer._capacity).toBe(64);
-      expect(buffer.message_values[0]).toBe('test-span');
+      expect(resolveMessage(buffer, 0)).toBe('test-span');
       expect(String(buffer.trace_id)).toBe('test-trace-id');
     });
 
@@ -121,14 +135,19 @@ describe('WasmBufferStrategy', () => {
       const child = strategy.createChildSpanBuffer(parent, testMetadata, testMetadata);
       // Caller must set span name via message() - simulating writeSpanStart behavior
       child.message(0, 'child-span');
+      expect('message_nulls' in child).toBe(false);
 
       expect(child).toBeDefined();
-      expect(child.message_values[0]).toBe('child-span');
+      expect(resolveMessage(child, 0)).toBe('child-span');
       expect(child.trace_id).toBe(parent.trace_id);
       expect(child.parent_span_id).toBe(parent.span_id);
-      // Note: parent._children is NOT populated by the strategy - SpanContext handles that.
-      // The strategy only sets up the parent-child relationship via child._parent.
       expect(child._parent).toBe(parent);
+
+      const children = iterateSpanChildren(parent);
+      const registered = children.next();
+      if (registered.done) throw new Error('topology did not register the child span');
+      expect(registered.value).toBe(child);
+      expect(children.next().done).toBe(true);
     });
 
     it('inherits capacity from parent by default', async () => {
@@ -167,10 +186,50 @@ describe('WasmBufferStrategy', () => {
 
       expect(overflow).toBeDefined();
       expect(overflow._capacity).toBe(buffer._capacity);
-      // Note: Currently overflow allocates its own identity block with new span_id
-      // TODO: Overflow should share identity with parent buffer
       expect(overflow.trace_id).toBe(buffer.trace_id);
+      expect(overflow.span_id).toBe(buffer.span_id);
+      expect(overflow.parent_span_id).toBe(buffer.parent_span_id);
+      expect(overflow._nodeIndex).toBe(buffer._nodeIndex);
+      expect(overflow._topologyGeneration).toBe(buffer._topologyGeneration);
+      expect(traceRoot._topology.count).toBe(1);
       expect(buffer._overflow).toBe(overflow);
+      expect(Array.from(iterateSpanTree(buffer))).toEqual([buffer, overflow]);
+    });
+  });
+
+  describe('trace topology', () => {
+    it('registers many siblings in insertion order while growing every topology lane', async () => {
+      const traceRoot = createWasmTraceRoot(strategy.allocator, 'many-siblings-trace', mockTracer);
+      const root = strategy.createSpanBuffer(testSchema, traceRoot, testMetadata);
+      const siblingCount = 257;
+      const legacyChildLane = ['_', 'children'].join('');
+      expect(Reflect.has(root, legacyChildLane)).toBe(false);
+
+      for (let index = 0; index < siblingCount; index++) {
+        const child = strategy.createChildSpanBuffer(root, testMetadata, testMetadata);
+        child.message(0, `child-${index}`);
+        expect('message_nulls' in child).toBe(false);
+        expect(child._nodeIndex).toBe(index + 1);
+      }
+
+      const topology = traceRoot._topology;
+      expect(topology.count).toBe(siblingCount + 1);
+      expect(topology.buffers.length).toBeGreaterThanOrEqual(siblingCount + 1);
+      expect(topology.firstChild.length).toBe(topology.buffers.length);
+      expect(topology.lastChild.length).toBe(topology.buffers.length);
+      expect(topology.nextSibling.length).toBe(topology.buffers.length);
+      expect(topology.firstChild[root._nodeIndex]).toBe(1);
+      expect(topology.lastChild[root._nodeIndex]).toBe(siblingCount);
+      expect(topology.nextSibling[siblingCount]).toBe(NO_NODE);
+
+      let observed = 0;
+      for (const child of iterateSpanChildren(root)) {
+        expect(child._nodeIndex).toBe(observed + 1);
+        expect(resolveMessage(child, 0)).toBe(`child-${observed}`);
+        expect(Reflect.has(child, legacyChildLane)).toBe(false);
+        observed++;
+      }
+      expect(observed).toBe(siblingCount);
     });
   });
 
@@ -218,6 +277,54 @@ describe('WasmBufferStrategy', () => {
       // Should have freed both buffers
       expect(statsAfter.freeCount).toBeGreaterThan(statsBefore.freeCount);
     });
+
+    it('releases and resets chains deeper than recursive walkers can traverse', async () => {
+      const deepSchema = defineLogSchema({});
+      const deepStrategy = await WasmBufferStrategy.create<typeof deepSchema>({
+        capacity: 8,
+        initialPages: 16,
+        maxPages: 256,
+      });
+      const deepTracer: TracerLifecycleHooks<typeof deepSchema> = {
+        onTraceStart: () => {},
+        onTraceEnd: () => {},
+        onSpanStart: () => {},
+        onSpanEnd: () => {},
+        onStatsWillResetFor: () => {},
+        getFlagEvaluatorForContext: () => undefined,
+        bufferStrategy: deepStrategy,
+      };
+      const depth = 20_000;
+      const buildChain = (traceId: string) => {
+        const traceRoot = createWasmTraceRoot(deepStrategy.allocator, traceId, deepTracer);
+        const root = deepStrategy.createSpanBuffer(deepSchema, traceRoot, testMetadata);
+        let leaf = root;
+        for (let level = 0; level < depth; level++) {
+          leaf = deepStrategy.createChildSpanBuffer(leaf, testMetadata, testMetadata);
+        }
+        return { leaf, root, topology: traceRoot._topology };
+      };
+
+      const released = buildChain('deep-release-trace');
+      const releaseGeneration = released.topology.generation;
+      expect(released.topology.count).toBe(depth + 1);
+      deepStrategy.releaseBuffer(released.root);
+      expect(released.topology.count).toBe(0);
+      expect(released.topology.root).toBe(NO_NODE);
+      expect(released.topology.generation).toBe(releaseGeneration + 1);
+      expect(() => released.topology.assertLive(released.leaf)).toThrow(/stale/);
+      expect(() => deepStrategy.releaseBuffer(released.root)).toThrow(/stale/);
+
+      const reset = buildChain('deep-reset-trace');
+      const resetGeneration = reset.topology.generation;
+      expect(reset.topology.count).toBe(depth + 1);
+      deepStrategy.reset();
+      expect(reset.topology.count).toBe(0);
+      expect(reset.topology.root).toBe(NO_NODE);
+      expect(reset.topology.generation).toBe(resetGeneration + 1);
+      expect(() => reset.topology.assertLive(reset.leaf)).toThrow(/stale/);
+      expect(() => iterateSpanChildren(reset.root).next()).toThrow(/stale/);
+    });
   });
 
   describe('getStats()', () => {
@@ -237,11 +344,11 @@ describe('WasmBufferStrategy', () => {
 
   describe('reset()', () => {
     it('resets allocator state', async () => {
-      const traceRoot = createWasmTraceRoot(strategy.allocator, 'test-trace-id', mockTracer);
+      const firstTraceRoot = createWasmTraceRoot(strategy.allocator, 'first-test-trace-id', mockTracer);
+      const secondTraceRoot = createWasmTraceRoot(strategy.allocator, 'second-test-trace-id', mockTracer);
 
-      // Create some buffers
-      strategy.createSpanBuffer(testSchema, traceRoot, testMetadata);
-      strategy.createSpanBuffer(testSchema, traceRoot, testMetadata);
+      strategy.createSpanBuffer(testSchema, firstTraceRoot, testMetadata);
+      strategy.createSpanBuffer(testSchema, secondTraceRoot, testMetadata);
 
       const statsBeforeReset = strategy.getStats();
       expect(statsBeforeReset.allocCount).toBeGreaterThan(0);
@@ -252,5 +359,102 @@ describe('WasmBufferStrategy', () => {
       expect(statsAfterReset.allocCount).toBe(0);
       expect(statsAfterReset.freeCount).toBe(0);
     });
+
+    it('invalidates root, child, and overflow generations before offsets are reused', async () => {
+      const traceRoot = createWasmTraceRoot(strategy.allocator, 'test-trace-id', mockTracer);
+      const root = strategy.createSpanBuffer(testSchema, traceRoot, testMetadata);
+      const child = strategy.createChildSpanBuffer(root, testMetadata, testMetadata);
+      const overflow = strategy.createOverflowBuffer(root);
+      root.timestamp[0] = 11n;
+      child.timestamp[0] = 22n;
+      overflow.timestamp[0] = 33n;
+      const topologyGeneration = traceRoot._topology.generation;
+
+      strategy.reset();
+
+      expect(() => root.timestamp).toThrow(/generation .* released/);
+      expect(() => child.timestamp).toThrow(/generation .* released/);
+      expect(() => overflow.timestamp).toThrow(/generation .* released/);
+      expect(() => traceRoot._topology.assertLive(root)).toThrow(/stale/);
+      expect(() => traceRoot._topology.assertLive(child)).toThrow(/stale/);
+      expect(() => traceRoot._topology.assertLive(overflow)).toThrow(/stale/);
+      expect(() => iterateSpanChildren(root).next()).toThrow(/stale/);
+      expect(traceRoot._topology.generation).toBe(topologyGeneration + 1);
+      expect(traceRoot._topology.count).toBe(0);
+      expect(traceRoot._topology.root).toBe(NO_NODE);
+      expect(strategy.getStats()).toEqual({ allocCount: 0, freeCount: 0, bumpPtr: 192, capacity: 64 });
+
+      expect(() => strategy.releaseBuffer(root)).toThrow(/stale/);
+      expect(strategy.getStats()).toEqual({ allocCount: 0, freeCount: 0, bumpPtr: 192, capacity: 64 });
+    });
+  });
+
+  describe('leased Arrow conversion', () => {
+    it('survives a WASM memory epoch change, releases safely, and reuses freed slabs', async () => {
+      const leasedStrategy = await WasmBufferStrategy.create<typeof testSchema>({
+        capacity: 8,
+        initialPages: 1,
+        maxPages: 18,
+      });
+      const leasedTracer: TracerLifecycleHooks<typeof testSchema> = {
+        onTraceStart: () => {},
+        onTraceEnd: () => {},
+        onSpanStart: () => {},
+        onSpanEnd: () => {},
+        onStatsWillResetFor: () => {},
+        getFlagEvaluatorForContext: () => undefined,
+        bufferStrategy: leasedStrategy,
+      };
+      const traceRoot = createWasmTraceRoot(leasedStrategy.allocator, 'leased-wasm', leasedTracer);
+      const root = requireWasmSpanBuffer(leasedStrategy.createSpanBuffer(testSchema, traceRoot, testMetadata, 8));
+      root.timestamp[0] = 9_001n;
+      {
+        const entryTypes = root.entry_type;
+        if (entryTypes === undefined) throw new Error('Expected split entry-type lane');
+        entryTypes[0] = 8;
+      }
+      root.message(0, 'leased-wasm-row');
+      expect('message_nulls' in root).toBe(false);
+      root.latency(0, 17.5);
+      root.success(0, true);
+      root.operation(0, 1);
+      root._writeIndex = 1;
+
+      const f64Pointer = root._familyPtrs.f64;
+      const topologyGeneration = traceRoot._topology.generation;
+      const memoryVersion = leasedStrategy.allocator.memoryVersion;
+      const memoryBuffer = leasedStrategy.allocator.memory.buffer;
+      const lease = convertToLeasedArrowTable(root);
+      expect(lease.released).toBe(false);
+      expect(getColumnValue(lease.table, 'latency', 0)).toBe(17.5);
+      expect(getColumnValue(lease.table, 'success', 0)).toBe(true);
+      expect(getColumnValue(lease.table, 'operation', 0)).toBe('READ');
+
+      const bytesToGrow = memoryBuffer.byteLength - leasedStrategy.getStats().bumpPtr + 8;
+      const growth = leasedStrategy.allocator.allocExact(bytesToGrow, 8);
+      expect(growth).toBeGreaterThan(0);
+      expect(leasedStrategy.allocator.memory.buffer).not.toBe(memoryBuffer);
+      expect(leasedStrategy.allocator.memoryVersion).toBeGreaterThan(memoryVersion);
+      expect(getRawTimestamp(lease.table, 0)).toBe(9_001n);
+      expect(getColumnValue(lease.table, 'latency', 0)).toBe(17.5);
+      expect(getColumnValue(lease.table, 'message', 0)).toBe('leased-wasm-row');
+      expect(traceRoot._topology.generation).toBe(topologyGeneration);
+
+      leasedStrategy.releaseBuffer(root);
+      expect(traceRoot._topology.generation).toBe(topologyGeneration);
+      expect(() => traceRoot._topology.assertLive(root)).toThrow(/stale/);
+      expect(root.timestamp[0]).toBe(9_001n);
+      expect(getColumnValue(lease.table, 'latency', 0)).toBe(17.5);
+      lease.release();
+      expect(lease.released).toBe(true);
+      expect(traceRoot._topology.generation).toBe(topologyGeneration + 1);
+      expect(() => root.timestamp).toThrow(/generation .* released/);
+      expect(() => lease.release()).not.toThrow();
+
+      const nextTraceRoot = createWasmTraceRoot(leasedStrategy.allocator, 'leased-wasm-next', leasedTracer);
+      const next = requireWasmSpanBuffer(leasedStrategy.createSpanBuffer(testSchema, nextTraceRoot, testMetadata, 8));
+      expect(next._familyPtrs.f64).toBe(f64Pointer);
+      leasedStrategy.releaseBuffer(next);
+    });
   });
 });

package/src/lib/wasm/__tests__/allocatorFreeBlockClamp.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it } from 'bun:test';
+import { createWasmAllocator, type WasmAllocator } from '../wasmAllocator.js';
+
+/**
+ * Exact slabs may be smaller than the allocator's intrusive free-list metadata.
+ * Releasing such a slab must reserve bookkeeping storage internally rather than
+ * overwrite an adjacent live slab.
+ */
+describe('sub-metadata exact slab safety', () => {
+  let allocator: WasmAllocator;
+
+  beforeEach(async () => {
+    allocator = await createWasmAllocator({ capacity: 64 });
+    allocator.reset();
+  });
+
+  function churnAndAssertNoCorruption(byteLength: 9 | 18) {
+    const batch = 8;
+    const rounds = 25;
+    let nextMarker = 1;
+    const live = new Map<number, number>();
+
+    function allocAndMark(): number {
+      const offset = allocator.allocExact(byteLength, 1);
+      expect(offset).toBeGreaterThan(0);
+      const marker = nextMarker++ & 0xff;
+      allocator.u8[offset + byteLength - 1] = marker;
+      live.set(offset, marker);
+      return offset;
+    }
+
+    function assertAllLiveIntact(context: string) {
+      for (const [offset, marker] of live) {
+        expect(allocator.u8[offset + byteLength - 1], `exact slab at ${offset} corrupted (${context})`).toBe(marker);
+      }
+    }
+
+    for (let i = 0; i < batch; i++) allocAndMark();
+    assertAllLiveIntact('after initial batch');
+
+    for (let round = 0; round < rounds; round++) {
+      const offsets = [...live.keys()];
+      for (let i = 0; i < offsets.length; i += 2) {
+        allocator.freeExact(offsets[i], byteLength, 1);
+        live.delete(offsets[i]);
+      }
+      assertAllLiveIntact(`round ${round} after frees`);
+      while (live.size < batch) allocAndMark();
+      assertAllLiveIntact(`round ${round} after refill`);
+    }
+  }
+
+  it('9-byte exact alloc/free/realloc churn never corrupts a live neighbor', () => {
+    churnAndAssertNoCorruption(9);
+  });
+
+  it('18-byte exact alloc/free/realloc churn never corrupts a live neighbor', () => {
+    churnAndAssertNoCorruption(18);
+  });
+
+  it('never returns an address that still has a live exact owner', () => {
+    const byteLength = 9;
+    const live = new Set<number>();
+    let allocs = 0;
+    let frees = 0;
+
+    for (let i = 0; i < 300; i++) {
+      const shouldFree = live.size > 0 && (i % 3 === 0 || live.size > 40);
+      if (shouldFree) {
+        const victim = [...live][i % live.size];
+        allocator.freeExact(victim, byteLength, 1);
+        live.delete(victim);
+        frees++;
+      } else {
+        const offset = allocator.allocExact(byteLength, 1);
+        expect(offset).toBeGreaterThan(0);
+        expect(live.has(offset), `allocator returned live exact offset ${offset}`).toBe(false);
+        live.add(offset);
+        allocs++;
+      }
+    }
+
+    expect(allocs).toBeGreaterThan(0);
+    expect(frees).toBeGreaterThan(0);
+  });
+});