@smoothbricks/lmao 0.2.2 → 0.2.3

package/dist/lib/wasm/wasmTraceRoot.d.ts

@@ -9,8 +9,10 @@
  * @module wasmTraceRoot
  */
 import { Nanoseconds } from '@smoothbricks/arrow-builder';
+import type { LogSchema } from '../schema/LogSchema.js';
 import { type TraceId } from '../traceId.js';
-import type { ITraceRoot, TracerLifecycleHooks } from '../traceRoot.js';
+import { type ITraceRoot, type SpanEndPrimitive, type SpanStartPrimitive, type TimestampAppendPrimitive, type TimestampNowPrimitive, type TraceRootFactory, type TracerLifecycleHooks } from '../traceRoot.js';
+import { TraceTopology } from '../traceTopology.js';
 import type { AnySpanBuffer } from '../types.js';
 import type { WasmAllocator } from './wasmAllocator.js';
 /**
@@ -20,45 +22,45 @@ import type { WasmAllocator } from './wasmAllocator.js';
 export interface WasmSpanBufferLike {
     /** Byte offset into WASM memory for system columns (timestamp + entry_type) */
     readonly _systemPtr: number;
+    /** Concrete per-op capacity; may differ from the allocator default. */
+    readonly _capacity: number;
     /** Byte offset into WASM memory for identity block (writeIndex, span_id, trace_id) */
     readonly _identityPtr: number;
     /** Message column - string array for span names and log messages */
     readonly _message: string[];
     /** Current write position (getter/setter reads from WASM identity block) */
     _writeIndex: number;
+    readonly _identityOwner: boolean;
+    readonly timestamp: BigInt64Array;
+    readonly entry_type: Uint8Array;
 }
 /**
  * Type guard to check if a buffer is WASM-backed.
  */
 export declare function isWasmSpanBuffer(buffer: unknown): buffer is WasmSpanBufferLike;
-/**
- * WASM-backed TraceRoot implementation.
- *
- * Implements ITraceRoot so it's compatible with SpanContext and the base Tracer.
- * Writes timestamps and entry types to WASM memory for WASM-backed buffers.
- *
- * Memory Layout at _traceRootPtr (16 bytes):
- * - Offset 0-7: anchorEpochNanos (i64) - wall clock time in nanoseconds
- * - Offset 8-15: anchorPerfNow (f64) - performance.now() anchor value
- *
- * The WASM allocator's initTraceRoot() captures these values at trace start,
- * and span lifecycle methods use them to calculate timestamps.
- */
-export declare class WasmTraceRoot implements ITraceRoot {
+export declare class WasmTraceRoot<T extends LogSchema = LogSchema> implements ITraceRoot<T> {
     /** Byte offset in WASM memory where TraceRoot data lives */
     readonly _traceRootPtr: number;
+    private _state;
     /** The WASM allocator instance */
     readonly allocator: WasmAllocator;
     /** Trace ID string */
     readonly trace_id: TraceId;
+    readonly _traceIdBytes: Uint8Array;
     /** Tracer reference for lifecycle hooks */
-    readonly tracer: TracerLifecycleHooks;
+    readonly tracer: TracerLifecycleHooks<T>;
+    readonly _topology: TraceTopology;
+    readonly _timestampNow: TimestampNowPrimitive;
+    readonly _appendLogEntry: TimestampAppendPrimitive;
+    readonly _writeSpanStart: SpanStartPrimitive;
+    readonly _writeSpanEnd: SpanEndPrimitive;
     /**
      * Raw backing buffer - not used for WASM, but required by ITraceRoot.
      * We create a minimal ArrayBuffer just to satisfy the interface.
      */
     readonly _system: ArrayBuffer;
-    constructor(allocator: WasmAllocator, trace_id: TraceId, tracer: TracerLifecycleHooks);
+    constructor(allocator: WasmAllocator, trace_id: TraceId, tracer: TracerLifecycleHooks<T>);
+    _assertLive(): void;
     /**
      * Epoch time in nanoseconds when trace was created.
      * Read from WASM memory at _traceRootPtr offset 0.
@@ -141,9 +143,9 @@ export declare class WasmTraceRoot implements ITraceRoot {
      * @param identityPtr - Byte offset of buffer's identity block in WASM memory
      */
     readWriteIndex(identityPtr: number): number;
-    /**
-     * Free the TraceRoot's memory block when trace completes.
-     */
+    /** Mark the handle stale when its allocator is reset wholesale. */
+    invalidate(): void;
+    /** Free the TraceRoot allocation exactly once. */
     free(): void;
 }
 /**
@@ -154,7 +156,7 @@ export declare class WasmTraceRoot implements ITraceRoot {
  * @param trace_id - Trace ID for this trace
  * @param tracer - Tracer lifecycle hooks
  */
-export declare function createWasmTraceRoot(allocator: WasmAllocator, trace_id: string, tracer: TracerLifecycleHooks): WasmTraceRoot;
+export declare function createWasmTraceRoot<T extends LogSchema = LogSchema>(allocator: WasmAllocator, trace_id: string, tracer: TracerLifecycleHooks<T>): WasmTraceRoot<T>;
 /**
  * Factory function to create WasmTraceRoot factory.
  *
@@ -163,5 +165,5 @@ export declare function createWasmTraceRoot(allocator: WasmAllocator, trace_id:
  * @param allocator - WASM allocator instance
  * @returns Factory function compatible with TraceRootFactory type
  */
-export declare function createWasmTraceRootFactory(allocator: WasmAllocator): (trace_id: string, tracer: TracerLifecycleHooks) => WasmTraceRoot;
+export declare function createWasmTraceRootFactory<T extends LogSchema = LogSchema>(allocator: WasmAllocator): TraceRootFactory<T>;
 //# sourceMappingURL=wasmTraceRoot.d.ts.map

package/dist/lib/wasm/wasmTraceRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wasmTraceRoot.d.ts","sourceRoot":"","sources":["../../../src/lib/wasm/wasmTraceRoot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AASxD;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC5B,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,kBAAkB,CAE9E;AAMD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,YAAW,UAAU;IAC9C,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,kCAAkC;IAClC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAElC,sBAAsB;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAEtC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAE9B,YAAY,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAepF;IAED;;;OAGG;IACH,IAAI,gBAAgB,IAAI,MAAM,CAG7B;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,MAAM,CAG1B;IAED;;;;;;;;OAQG;IACH,iBAAiB,IAAI,WAAW,CAI/B;IAOD;;;;;;;;;OASG;IACH,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAmB5D;IAED;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAwB3D;IAED;;;;;;;OAOG;IACH,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAW9D;IAOD;;;;;;;OAOG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAE9D;IAED;;;OAGG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEzC;IAED;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE1C;IAED;;;;;;;;OAQG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAElF;IAED;;;OAGG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE1C;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,CAEX;CACF;AAMD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,oBAAoB,GAC3B,aAAa,CAEf;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,aAAa,cAC/C,MAAM,UAAU,oBAAoB,KAAG,aAAa,CAGvE"}
+{"version":3,"file":"wasmTraceRoot.d.ts","sourceRoot":"","sources":["../../../src/lib/wasm/wasmTraceRoot.ts"],"names":[],"mappings":"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"}

package/dist/lib/wasm/wasmTraceRoot.js

@@ -11,6 +11,9 @@
 import { Nanoseconds } from '@smoothbricks/arrow-builder';
 import { ENTRY_TYPE_SPAN_EXCEPTION, ENTRY_TYPE_SPAN_START } from '../schema/systemSchema.js';
 import { createTraceId } from '../traceId.js';
+import { consumeSpanStartedAtAllocation, } from '../traceRoot.js';
+import { TraceTopology } from '../traceTopology.js';
+const traceIdEncoder = new TextEncoder();
 /**
  * Type guard to check if a buffer is WASM-backed.
  */
@@ -33,15 +36,89 @@ export function isWasmSpanBuffer(buffer) {
  * The WASM allocator's initTraceRoot() captures these values at trace start,
  * and span lifecycle methods use them to calculate timestamps.
  */
+const timestampNow = (traceRoot) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- WASM primitive table is only installed on WasmTraceRoot instances.
+    const root = traceRoot;
+    root._assertLive();
+    const elapsedNanos = BigInt(Math.round((performance.now() - root.anchorPerfNow) * 1000000));
+    return Nanoseconds.unsafe(root.anchorEpochNanos + elapsedNanos);
+};
+const appendLogEntry = (traceRoot, buffer, entryType) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- WASM primitive table is only installed on WasmTraceRoot instances.
+    const root = traceRoot;
+    root._assertLive();
+    if (isWasmSpanBuffer(buffer) && buffer._messagePhysicalLayout !== 'packed' && buffer._identityOwner) {
+        return root.allocator.writeLogEntry(buffer._systemPtr, buffer._identityPtr, root._traceRootPtr, entryType, buffer._capacity);
+    }
+    const idx = buffer._writeIndex;
+    const entryTypes = buffer.entry_type;
+    if (entryTypes === undefined)
+        throw new TypeError('Split WASM appender requires entry_type storage');
+    buffer.timestamp[idx] = timestampNow(root);
+    entryTypes[idx] = entryType;
+    buffer._writeIndex = idx + 1;
+    return idx;
+};
+const writeSpanStartPrimitive = (traceRoot, buffer, spanName) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- WASM primitive table is only installed on WasmTraceRoot instances.
+    const root = traceRoot;
+    root._assertLive();
+    if (isWasmSpanBuffer(buffer) && buffer._messagePhysicalLayout !== 'packed') {
+        if (!consumeSpanStartedAtAllocation(buffer)) {
+            root.allocator.spanStart(buffer._systemPtr, buffer._identityPtr, root._traceRootPtr, buffer._capacity);
+        }
+        buffer._message[0] = spanName;
+        return;
+    }
+    const entryTypes = buffer.entry_type;
+    if (entryTypes === undefined)
+        throw new TypeError('Split WASM span-start appender requires entry_type storage');
+    buffer.timestamp[0] = timestampNow(root);
+    entryTypes[0] = ENTRY_TYPE_SPAN_START;
+    buffer.message(0, spanName);
+    entryTypes[1] = ENTRY_TYPE_SPAN_EXCEPTION;
+    buffer.timestamp[1] = 0n;
+    buffer._writeIndex = 2;
+};
+const writeSpanEndPrimitive = (traceRoot, buffer, entryType) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- WASM primitive table is only installed on WasmTraceRoot instances.
+    const root = traceRoot;
+    root._assertLive();
+    if (isWasmSpanBuffer(buffer) && buffer._messagePhysicalLayout !== 'packed') {
+        if (entryType === 2)
+            root.allocator.spanEndOk(buffer._systemPtr, root._traceRootPtr, buffer._capacity);
+        else
+            root.allocator.spanEndErr(buffer._systemPtr, root._traceRootPtr, buffer._capacity);
+        if (entryType !== 2 && entryType !== 3) {
+            const splitEntryTypes = buffer.entry_type;
+            if (splitEntryTypes === undefined)
+                throw new TypeError('Split WASM buffer is missing entry_type storage');
+            splitEntryTypes[1] = entryType;
+        }
+        return;
+    }
+    const entryTypes = buffer.entry_type;
+    if (entryTypes === undefined)
+        throw new TypeError('Split WASM span-end appender requires entry_type storage');
+    buffer.timestamp[1] = timestampNow(root);
+    entryTypes[1] = entryType;
+};
 export class WasmTraceRoot {
     /** Byte offset in WASM memory where TraceRoot data lives */
     _traceRootPtr;
+    _state = 'live';
     /** The WASM allocator instance */
     allocator;
     /** Trace ID string */
     trace_id;
+    _traceIdBytes;
     /** Tracer reference for lifecycle hooks */
     tracer;
+    _topology;
+    _timestampNow = timestampNow;
+    _appendLogEntry = appendLogEntry;
+    _writeSpanStart = writeSpanStartPrimitive;
+    _writeSpanEnd = writeSpanEndPrimitive;
     /**
      * Raw backing buffer - not used for WASM, but required by ITraceRoot.
      * We create a minimal ArrayBuffer just to satisfy the interface.
@@ -50,21 +127,28 @@ export class WasmTraceRoot {
     constructor(allocator, trace_id, tracer) {
         this.allocator = allocator;
         this.trace_id = trace_id;
+        this._traceIdBytes = traceIdEncoder.encode(trace_id);
         this.tracer = tracer;
-        // Create minimal _system buffer (not actually used, but required by interface)
+        this._topology = new TraceTopology();
         this._system = new ArrayBuffer(16);
-        // Allocate an 8B column block for TraceRoot data (16 bytes needed, 8B block is large enough)
-        // The 8B column block size is: ceil(capacity/8) + capacity*8 = 8 + 512 = 520 bytes for capacity 64
-        // We only need 16 bytes, so this works fine
-        this._traceRootPtr = allocator.alloc8B();
-        // Initialize wall clock and monotonic start times in WASM memory
+        // Native TraceRoot is exactly two aligned 8-byte fields.
+        const traceRootPtr = allocator.allocExact(16, 8);
+        if (traceRootPtr === 0) {
+            throw new Error('WASM trace-root allocation failed');
+        }
+        this._traceRootPtr = traceRootPtr;
         allocator.initTraceRoot(this._traceRootPtr);
     }
+    _assertLive() {
+        if (this._state !== 'live')
+            throw new Error('WASM trace root has been released');
+    }
     /**
      * Epoch time in nanoseconds when trace was created.
      * Read from WASM memory at _traceRootPtr offset 0.
      */
     get anchorEpochNanos() {
+        this._assertLive();
         // i64 view is indexed by 8-byte chunks
         return this.allocator.i64[this._traceRootPtr / 8];
     }
@@ -73,6 +157,7 @@ export class WasmTraceRoot {
      * Read from WASM memory at _traceRootPtr offset 8.
      */
     get anchorPerfNow() {
+        this._assertLive();
         // f64 view is indexed by 8-byte chunks
         return this.allocator.f64[(this._traceRootPtr + 8) / 8];
     }
@@ -86,9 +171,7 @@ export class WasmTraceRoot {
      * We convert to nanoseconds for consistency with the trace format.
      */
     getTimestampNanos() {
-        const elapsedMs = performance.now() - this.anchorPerfNow;
-        const elapsedNanos = BigInt(Math.round(elapsedMs * 1000000));
-        return Nanoseconds.unsafe(this.anchorEpochNanos + elapsedNanos);
+        return this._timestampNow(this);
     }
     // ===========================================================================
     // ITraceRoot implementation (takes buffer parameter)
@@ -105,25 +188,7 @@ export class WasmTraceRoot {
      * @param spanName - Name for this span
      */
     writeSpanStart(buffer, spanName) {
-        if (isWasmSpanBuffer(buffer)) {
-            // WASM path: delegate to WASM allocator
-            // spanStart writes row 0 (span-start) and row 1 (span-exception placeholder)
-            // Also sets writeIndex to 2 in the identity block
-            this.allocator.spanStart(buffer._systemPtr, buffer._identityPtr, this._traceRootPtr);
-            // Write span name to message column (JS string array)
-            buffer._message[0] = spanName;
-            // Note: _writeIndex is set by WASM spanStart to 2, but the getter reads from WASM
-            // so we don't need to set it here explicitly (the setter would write to WASM anyway)
-        }
-        else {
-            // JS path: write directly to TypedArrays (fallback for mixed usage)
-            buffer.timestamp[0] = this.getTimestampNanos();
-            buffer.entry_type[0] = ENTRY_TYPE_SPAN_START;
-            buffer.message(0, spanName);
-            buffer.entry_type[1] = ENTRY_TYPE_SPAN_EXCEPTION;
-            buffer.timestamp[1] = 0n;
-            buffer._writeIndex = 2;
-        }
+        this._writeSpanStart(this, buffer, spanName);
     }
     /**
      * Write span-end entry to buffer at row 1.
@@ -133,32 +198,7 @@ export class WasmTraceRoot {
      * @param entryType - Entry type (SPAN_OK, SPAN_ERR, or SPAN_EXCEPTION)
      */
     writeSpanEnd(buffer, entryType) {
-        if (isWasmSpanBuffer(buffer)) {
-            // WASM path: use appropriate end function based on entry type
-            // Note: WASM spanEndOk/spanEndErr write to row 1
-            if (entryType === 2) {
-                // SPAN_OK
-                this.allocator.spanEndOk(buffer._systemPtr, this._traceRootPtr);
-            }
-            else if (entryType === 3) {
-                // SPAN_ERR
-                this.allocator.spanEndErr(buffer._systemPtr, this._traceRootPtr);
-            }
-            else {
-                // SPAN_EXCEPTION or other - write via generic log entry
-                // For now, use spanEndErr as fallback (entry_type will be overwritten)
-                this.allocator.spanEndErr(buffer._systemPtr, this._traceRootPtr);
-                // Overwrite entry_type if needed (for EXCEPTION)
-                if (entryType !== 3) {
-                    buffer.entry_type[1] = entryType;
-                }
-            }
-        }
-        else {
-            // JS path
-            buffer.timestamp[1] = this.getTimestampNanos();
-            buffer.entry_type[1] = entryType;
-        }
+        this._writeSpanEnd(this, buffer, entryType);
     }
     /**
      * Write log entry: bump writeIndex, write timestamp + entry_type, return idx.
@@ -169,16 +209,7 @@ export class WasmTraceRoot {
      * @returns The row index where entry was written
      */
     writeLogEntry(buffer, entryType) {
-        if (isWasmSpanBuffer(buffer)) {
-            // WASM path: bump writeIndex, write timestamp + entry_type, return idx
-            return this.allocator.writeLogEntry(buffer._systemPtr, buffer._identityPtr, this._traceRootPtr, entryType);
-        }
-        // JS path: bump writeIndex, write directly, return idx
-        const idx = buffer._writeIndex;
-        buffer.timestamp[idx] = this.getTimestampNanos();
-        buffer.entry_type[idx] = entryType;
-        buffer._writeIndex = idx + 1;
-        return idx;
+        return this._appendLogEntry(this, buffer, entryType);
     }
     // ===========================================================================
     // Low-level WASM pointer-based methods (for direct WASM access and tests)
@@ -193,6 +224,7 @@ export class WasmTraceRoot {
      * @param identityPtr - Byte offset of buffer's identity block in WASM memory
      */
     writeSpanStartPtr(systemPtr, identityPtr) {
+        this._assertLive();
         this.allocator.spanStart(systemPtr, identityPtr, this._traceRootPtr);
     }
     /**
@@ -200,6 +232,7 @@ export class WasmTraceRoot {
      * @param systemPtr - Byte offset of buffer's system block in WASM memory
      */
     writeSpanEndOkPtr(systemPtr) {
+        this._assertLive();
         this.allocator.spanEndOk(systemPtr, this._traceRootPtr);
     }
     /**
@@ -207,6 +240,7 @@ export class WasmTraceRoot {
      * @param systemPtr - Byte offset of buffer's system block in WASM memory
      */
     writeSpanEndErrPtr(systemPtr) {
+        this._assertLive();
         this.allocator.spanEndErr(systemPtr, this._traceRootPtr);
     }
     /**
@@ -219,6 +253,7 @@ export class WasmTraceRoot {
      * @returns Row index where entry was written
      */
     writeLogEntryPtr(systemPtr, identityPtr, entryType) {
+        this._assertLive();
         return this.allocator.writeLogEntry(systemPtr, identityPtr, this._traceRootPtr, entryType);
     }
     /**
@@ -226,13 +261,19 @@ export class WasmTraceRoot {
      * @param identityPtr - Byte offset of buffer's identity block in WASM memory
      */
     readWriteIndex(identityPtr) {
+        this._assertLive();
         return this.allocator.readWriteIndex(identityPtr);
     }
-    /**
-     * Free the TraceRoot's memory block when trace completes.
-     */
+    /** Mark the handle stale when its allocator is reset wholesale. */
+    invalidate() {
+        this._state = 'freed';
+    }
+    /** Free the TraceRoot allocation exactly once. */
     free() {
-        this.allocator.free8B(this._traceRootPtr);
+        if (this._state === 'freed')
+            return;
+        this.allocator.freeExact(this._traceRootPtr, 16, 8);
+        this._state = 'freed';
     }
 }
 // =============================================================================
@@ -258,8 +299,6 @@ export function createWasmTraceRoot(allocator, trace_id, tracer) {
  * @returns Factory function compatible with TraceRootFactory type
  */
 export function createWasmTraceRootFactory(allocator) {
-    return (trace_id, tracer) => {
-        return new WasmTraceRoot(allocator, createTraceId(trace_id), tracer);
-    };
+    return (trace_id, tracer) => new WasmTraceRoot(allocator, createTraceId(trace_id), tracer);
 }
 //#endregion smoo/lmao!n/wasm-mem.trace-root

package/dist/vocabulary/register/v1.d.ts

@@ -0,0 +1,2 @@
+import '../../lib/vocabularyRegistry.js';
+//# sourceMappingURL=v1.d.ts.map

package/dist/vocabulary/register/v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v1.d.ts","sourceRoot":"","sources":["../../../src/vocabulary/register/v1.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/dist/vocabulary/register/v1.js

@@ -0,0 +1 @@
+import '../../lib/vocabularyRegistry.js';

package/dist/wasm.d.ts

@@ -0,0 +1,5 @@
+export { WasmBufferStrategy, type WasmBufferStrategyOptions } from './lib/wasm/WasmBufferStrategy.js';
+export { createWasmAllocator, createWasmAllocatorSync, WASM_NO_LAYOUT_OFFSET, WASM_SPAN_IDENTITY_CHILD, WASM_SPAN_IDENTITY_ROOT, type WasmAllocator, type WasmAllocatorOptions, } from './lib/wasm/wasmAllocator.js';
+export { isWasmSpanBufferInstance, type WasmSpanBufferInstance, } from './lib/wasm/wasmSpanBuffer.js';
+export { createWasmTraceRoot, createWasmTraceRootFactory, WasmTraceRoot, } from './lib/wasm/wasmTraceRoot.js';
+//# sourceMappingURL=wasm.d.ts.map

package/dist/wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm.d.ts","sourceRoot":"","sources":["../src/wasm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AACtG,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,oBAAoB,GAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,wBAAwB,EACxB,KAAK,sBAAsB,GAC5B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,aAAa,GACd,MAAM,6BAA6B,CAAC"}

package/dist/wasm.js

@@ -0,0 +1,4 @@
+export { WasmBufferStrategy } from './lib/wasm/WasmBufferStrategy.js';
+export { createWasmAllocator, createWasmAllocatorSync, WASM_NO_LAYOUT_OFFSET, WASM_SPAN_IDENTITY_CHILD, WASM_SPAN_IDENTITY_ROOT, } from './lib/wasm/wasmAllocator.js';
+export { isWasmSpanBufferInstance, } from './lib/wasm/wasmSpanBuffer.js';
+export { createWasmTraceRoot, createWasmTraceRootFactory, WasmTraceRoot, } from './lib/wasm/wasmTraceRoot.js';

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@smoothbricks/lmao",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/vocabulary/register/v1.js",
+    "./src/vocabulary/register/v1.ts",
+    "./dist/lib/span-buffer/aot/v1.js",
+    "./src/lib/span-buffer/aot/v1.ts"
+  ],
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,6 +19,18 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./span-buffer/aot/v1": {
+      "types": "./dist/lib/span-buffer/aot/v1.d.ts",
+      "development": "./src/lib/span-buffer/aot/v1.ts",
+      "import": "./dist/lib/span-buffer/aot/v1.js",
+      "default": "./dist/lib/span-buffer/aot/v1.js"
+    },
+    "./vocabulary/register/v1": {
+      "types": "./dist/vocabulary/register/v1.d.ts",
+      "development": "./src/vocabulary/register/v1.ts",
+      "import": "./dist/vocabulary/register/v1.js",
+      "default": "./dist/vocabulary/register/v1.js"
+    },
     "./node": {
       "types": "./dist/node.d.ts",
       "development": "./src/node.ts",
@@ -26,6 +43,12 @@
       "import": "./dist/es.js",
       "default": "./dist/es.js"
     },
+    "./wasm": {
+      "types": "./dist/wasm.d.ts",
+      "development": "./src/wasm.ts",
+      "import": "./dist/wasm.js",
+      "default": "./dist/wasm.js"
+    },
     "./cloudflare": {
       "types": "./dist/cloudflare.d.ts",
       "development": "./src/cloudflare.ts",
@@ -124,16 +147,16 @@
   "dependencies": {
     "@msgpack/msgpack": "^3.1.3",
     "@neophi/sieve-cache": "^1.5.0",
-    "@smoothbricks/arrow-builder": "0.1.4",
-    "@smoothbricks/validation": "0.1.3",
+    "@smoothbricks/arrow-builder": "0.1.5",
+    "@smoothbricks/validation": "0.1.4",
     "@uwdata/flechette": "^2.3.0",
     "tslib": "^2.8.1",
-    "typia": "13.1.1"
+    "typia": "13.1.19"
   },
   "scripts": {
     "bench": "bun run benchmarks/*.bench.ts",
     "bench:wasm": "bun run benchmarks/js-vs-wasm.bench.ts",
-    "build:wasm": "zig build -Doptimize=ReleaseSmall",
+    "build:wasm": "nx run lmao:rust-wasm",
     "test": "nx run lmao:test --outputStyle=stream"
   },
   "nx": {
@@ -155,6 +178,31 @@
           "timeoutMs": 120000,
           "killAfterMs": 1e4
         }
+      },
+      "rust-wasm": {
+        "executor": "nx:run-commands",
+        "cache": true,
+        "dependsOn": [
+          "^build",
+          {
+            "projects": [
+              "lmao-rs"
+            ],
+            "target": "cargo-wasm"
+          }
+        ],
+        "inputs": [
+          {
+            "dependentTasksOutputFiles": "**/*.wasm"
+          }
+        ],
+        "outputs": [
+          "{projectRoot}/dist/allocator.wasm"
+        ],
+        "options": {
+          "command": "mkdir -p dist && cp ../lmao-rs/dist/lmao_wasm.wasm dist/allocator.wasm",
+          "cwd": "{projectRoot}"
+        }
       }
     },
     "tags": [

package/src/index.ts

@@ -114,6 +114,7 @@ export { createSpanLogger, createSpanLoggerClass } from './lib/codegen/spanLogge
 
 export * from './lib/convertToArrow.js';
 export * from './lib/spanBuffer.js';
+export * from './lib/traceTopology.js';
 export * from './lib/types.js';
 
 // =============================================================================

package/src/lib/JsBufferStrategy.ts

@@ -21,6 +21,7 @@ import {
   createOverflowBuffer as createOverflowBufferImpl,
   createSpanBuffer as createSpanBufferImpl,
   getSpanBufferClass,
+  resolveSpanBufferCapacity,
   type SpanBufferConstructor,
 } from './spanBuffer.js';
 import type { ITraceRoot } from './traceRoot.js';
@@ -69,8 +70,14 @@ export class JsBufferStrategy<T extends LogSchema = LogSchema> implements Buffer
     return cached;
   }
 
-  createSpanBuffer(schema: T, traceRoot: ITraceRoot, opMetadata: OpMetadata, capacity?: number): SpanBuffer<T> {
-    return createSpanBufferImpl(schema, traceRoot, opMetadata, capacity);
+  createSpanBuffer(
+    schema: T,
+    traceRoot: ITraceRoot,
+    opMetadata: OpMetadata,
+    capacity?: number,
+    plannedClass?: SpanBufferConstructor<T>,
+  ): SpanBuffer<T> {
+    return createSpanBufferImpl(schema, traceRoot, opMetadata, capacity, plannedClass);
   }
 
   createChildSpanBuffer(
@@ -79,11 +86,23 @@ export class JsBufferStrategy<T extends LogSchema = LogSchema> implements Buffer
     opMetadata: OpMetadata,
     capacity?: number,
     schema?: T,
+    plannedClass?: SpanBufferConstructor<T>,
   ): SpanBuffer<T> {
-    // Use provided schema (for cross-library calls) or parent's schema
-    const childSchema = schema ?? parentBuffer._logSchema;
-    const SpanBufferClass = this.getSpanBufferClassForSchema(childSchema);
-    return createChildSpanBufferImpl(parentBuffer, SpanBufferClass, callsiteMetadata, opMetadata, capacity);
+    const targetSchema = schema ?? parentBuffer._logSchema;
+    const metadataSpanBufferClass = opMetadata._physicalLayoutPlan?.SpanBufferClass;
+    if (
+      metadataSpanBufferClass !== undefined &&
+      !isSpanBufferConstructorForSchema(metadataSpanBufferClass, targetSchema)
+    ) {
+      throw new TypeError('Planned SpanBuffer class does not match schema');
+    }
+    const plannedSpanBufferClass = plannedClass ?? metadataSpanBufferClass;
+    const SpanBufferClass = plannedSpanBufferClass ?? this.getSpanBufferClassForSchema(targetSchema);
+    const actualCapacity =
+      plannedSpanBufferClass === undefined
+        ? resolveSpanBufferCapacity(capacity, SpanBufferClass.stats.capacity)
+        : capacity;
+    return createChildSpanBufferImpl(parentBuffer, SpanBufferClass, callsiteMetadata, opMetadata, actualCapacity);
   }
 
   createOverflowBuffer(buffer: SpanBuffer<T>): SpanBuffer<T> {
@@ -95,8 +114,7 @@ export class JsBufferStrategy<T extends LogSchema = LogSchema> implements Buffer
     return convertSpanTreeToArrowTable(buffer);
   }
 
-  releaseBuffer(_buffer: AnySpanBuffer): void {
-    // No-op for JS strategy - GC handles memory
-    // The buffer will be collected when no references remain
+  releaseBuffer(buffer: AnySpanBuffer): void {
+    buffer._traceRoot._topology.release();
   }
 }