@smoothbricks/lmao 0.1.0

package/dist/lib/wasm/wasmAllocator.js

@@ -0,0 +1,227 @@
+/**
+ * Size class enum matching Zig's SizeClass
+ */
+export var SizeClass;
+(function (SizeClass) {
+    SizeClass[SizeClass["SpanSystem"] = 0] = "SpanSystem";
+    SizeClass[SizeClass["Col1B"] = 1] = "Col1B";
+    SizeClass[SizeClass["Col4B"] = 2] = "Col4B";
+    SizeClass[SizeClass["Col8B"] = 3] = "Col8B";
+    SizeClass[SizeClass["Identity"] = 4] = "Identity";
+})(SizeClass || (SizeClass = {}));
+function isWasmExports(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return (typeof Reflect.get(value, 'init') === 'function' && typeof Reflect.get(value, 'alloc_span_system') === 'function');
+}
+// =============================================================================
+// Implementation
+// =============================================================================
+const DEFAULT_INITIAL_PAGES = 17; // ~1MB - matches WASM module minimum
+const DEFAULT_MAX_PAGES = 16384; // 1GB max (can grow up to this)
+const DEFAULT_CAPACITY = 64;
+/**
+ * Create typed views over WASM memory.
+ * Must be called after memory creation and after any grow().
+ */
+function createViews(memory) {
+    return {
+        u8: new Uint8Array(memory.buffer),
+        u32: new Uint32Array(memory.buffer),
+        i64: new BigInt64Array(memory.buffer),
+        f64: new Float64Array(memory.buffer),
+    };
+}
+/**
+ * Create WasmAllocator from instantiated WASM module.
+ */
+function wrapWasmInstance(instance, memory, capacity) {
+    if (!isWasmExports(instance.exports)) {
+        throw new Error('allocator.wasm exports did not match the expected ABI');
+    }
+    const exports = instance.exports;
+    let views = createViews(memory);
+    let currentBuffer = memory.buffer;
+    // Initialize the allocator header
+    exports.init();
+    return {
+        memory,
+        capacity,
+        exports: {
+            write_col_f64: exports.write_col_f64,
+            write_col_u32: exports.write_col_u32,
+            write_col_u8: exports.write_col_u8,
+            write_log_entry: exports.write_log_entry,
+        },
+        get u8() {
+            // Check if memory grew since last access
+            if (memory.buffer !== currentBuffer) {
+                currentBuffer = memory.buffer;
+                views = createViews(memory);
+            }
+            return views.u8;
+        },
+        get u32() {
+            if (memory.buffer !== currentBuffer) {
+                currentBuffer = memory.buffer;
+                views = createViews(memory);
+            }
+            return views.u32;
+        },
+        get i64() {
+            if (memory.buffer !== currentBuffer) {
+                currentBuffer = memory.buffer;
+                views = createViews(memory);
+            }
+            return views.i64;
+        },
+        get f64() {
+            if (memory.buffer !== currentBuffer) {
+                currentBuffer = memory.buffer;
+                views = createViews(memory);
+            }
+            return views.f64;
+        },
+        init: exports.init,
+        reset: exports.reset,
+        // Allocation with optional capacity (defaults to instance capacity)
+        allocSpanSystem: (cap = capacity) => exports.alloc_span_system(cap),
+        alloc1B: (cap = capacity) => exports.alloc_col_1b(cap),
+        alloc4B: (cap = capacity) => exports.alloc_col_4b(cap),
+        alloc8B: (cap = capacity) => exports.alloc_col_8b(cap),
+        // Deallocation with optional capacity
+        freeSpanSystem: (offset, cap = capacity) => exports.free_span_system(offset, cap),
+        free1B: (offset, cap = capacity) => exports.free_col_1b(offset, cap),
+        free4B: (offset, cap = capacity) => exports.free_col_4b(offset, cap),
+        free8B: (offset, cap = capacity) => exports.free_col_8b(offset, cap),
+        // Span lifecycle with optional capacity
+        spanStart: (systemPtr, identityPtr, traceRootPtr, cap = capacity) => exports.span_start(systemPtr, identityPtr, traceRootPtr, cap),
+        spanEndOk: (systemPtr, traceRootPtr, cap = capacity) => exports.span_end_ok(systemPtr, traceRootPtr, cap),
+        spanEndErr: (systemPtr, traceRootPtr, cap = capacity) => exports.span_end_err(systemPtr, traceRootPtr, cap),
+        writeLogEntry: (systemPtr, traceRootPtr, idx, entryType, cap = capacity) => exports.write_log_entry(systemPtr, traceRootPtr, idx, entryType, cap),
+        // Column writes with optional capacity
+        writeColF64: (colOffset, rowIdx, value, cap = capacity) => exports.write_col_f64(colOffset, rowIdx, value, cap),
+        writeColU32: (colOffset, rowIdx, value, cap = capacity) => exports.write_col_u32(colOffset, rowIdx, value, cap),
+        writeColU8: (colOffset, rowIdx, value, cap = capacity) => exports.write_col_u8(colOffset, rowIdx, value, cap),
+        initTraceRoot: exports.init_trace_root,
+        getBumpPtr: exports.get_bump_ptr,
+        getAllocCount: exports.get_alloc_count,
+        getFreeCount: exports.get_free_count,
+        getSpanSystemSize: (cap = capacity) => exports.get_span_system_size(cap),
+        getCol1BSize: (cap = capacity) => exports.get_col_1b_size(cap),
+        getCol4BSize: (cap = capacity) => exports.get_col_4b_size(cap),
+        getCol8BSize: (cap = capacity) => exports.get_col_8b_size(cap),
+        readTimestamp: exports.read_timestamp,
+        readEntryType: (systemPtr, rowIdx, cap = capacity) => exports.read_entry_type(systemPtr, rowIdx, cap),
+        readWriteIndex: exports.read_write_index,
+        readColF64: (colOffset, rowIdx, cap = capacity) => exports.read_col_f64(colOffset, rowIdx, cap),
+        readColIsValid: exports.read_col_is_valid,
+        // Thread ID management
+        setThreadId: exports.set_thread_id,
+        getThreadIdHigh: exports.get_thread_id_high,
+        getThreadIdLow: exports.get_thread_id_low,
+        isThreadIdSet: exports.is_thread_id_set,
+        getSpanIdCounter: exports.get_span_id_counter,
+        // Identity block operations (thread_id is global, use getThreadIdHigh/Low)
+        allocIdentityRootForJsWrite: exports.alloc_identity_root_for_js_write,
+        allocIdentityChild: exports.alloc_identity_child,
+        freeIdentity: exports.free_identity,
+        readIdentitySpanId: exports.read_identity_span_id,
+        readIdentityTraceIdLen: exports.read_identity_trace_id_len,
+        getIdentityTraceIdPtr: exports.get_identity_trace_id_ptr,
+        // Freelist statistics with optional capacity
+        getFreelistLen: (sizeClass, cap = capacity) => exports.get_freelist_len(sizeClass, cap),
+        getFreelistReuseCount: (sizeClass, cap = capacity) => exports.get_freelist_reuse_count(sizeClass, cap),
+        getFreelistSplitCount: (sizeClass, cap = capacity) => exports.get_freelist_split_count(sizeClass, cap),
+        getFreelistMergeCount: (sizeClass, cap = capacity) => exports.get_freelist_merge_count(sizeClass, cap),
+    };
+}
+/**
+ * Create imports object for WASM instantiation.
+ */
+function createImports(memory) {
+    return {
+        env: {
+            memory,
+            performanceNow: () => performance.now(),
+            dateNow: () => Date.now(),
+        },
+    };
+}
+// Cache for compiled WASM module (shared across all allocators)
+// This eliminates recompilation cost in benchmarks and production
+let cachedWasmModule = null;
+/**
+ * Load WASM bytes - handles both Node.js and browser environments.
+ */
+async function loadWasmBytes() {
+    // Try Node.js first
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        const { readFile } = await import('node:fs/promises');
+        const { fileURLToPath } = await import('node:url');
+        const { dirname, join } = await import('node:path');
+        // __dirname equivalent for ESM
+        const currentFile = fileURLToPath(import.meta.url);
+        const currentDir = dirname(currentFile);
+        const wasmPath = join(currentDir, '../../../dist/allocator.wasm');
+        const buffer = await readFile(wasmPath);
+        // Create a proper ArrayBuffer from the Node.js Buffer
+        const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+        new Uint8Array(arrayBuffer).set(buffer);
+        return arrayBuffer;
+    }
+    // Browser: fetch from relative path
+    const response = await fetch(new URL('../../../dist/allocator.wasm', import.meta.url));
+    return response.arrayBuffer();
+}
+/**
+ * Get compiled WASM module (cached after first load).
+ */
+async function getWasmModule() {
+    if (cachedWasmModule) {
+        return cachedWasmModule;
+    }
+    const wasmBytes = await loadWasmBytes();
+    cachedWasmModule = await WebAssembly.compile(wasmBytes);
+    return cachedWasmModule;
+}
+/**
+ * Create a WASM allocator instance.
+ *
+ * The allocator uses freelist for O(1) alloc/free with memory reuse.
+ * Buddy allocation enables efficient memory management across different capacities.
+ */
+export async function createWasmAllocator(options) {
+    const initialPages = options?.initialPages ?? DEFAULT_INITIAL_PAGES;
+    const maxPages = options?.maxPages ?? DEFAULT_MAX_PAGES;
+    const capacity = options?.capacity ?? DEFAULT_CAPACITY;
+    // Create memory
+    const memory = new WebAssembly.Memory({
+        initial: initialPages,
+        maximum: maxPages,
+    });
+    // Get cached compiled module (only compiles once)
+    const module = await getWasmModule();
+    // Instantiate with our memory
+    const imports = createImports(memory);
+    const instance = await WebAssembly.instantiate(module, imports);
+    return wrapWasmInstance(instance, memory, capacity);
+}
+/**
+ * Synchronous version for when WASM is pre-loaded.
+ */
+export function createWasmAllocatorSync(wasmModule, options) {
+    const initialPages = options?.initialPages ?? DEFAULT_INITIAL_PAGES;
+    const maxPages = options?.maxPages ?? DEFAULT_MAX_PAGES;
+    const capacity = options?.capacity ?? DEFAULT_CAPACITY;
+    // Create memory
+    const memory = new WebAssembly.Memory({
+        initial: initialPages,
+        maximum: maxPages,
+    });
+    // Instantiate with our memory
+    const imports = createImports(memory);
+    const instance = new WebAssembly.Instance(wasmModule, imports);
+    return wrapWasmInstance(instance, memory, capacity);
+}

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

@@ -0,0 +1,123 @@
+/**
+ * WASM-backed SpanBuffer class generation.
+ *
+ * Implements spec 01q: WASM Memory Architecture for SpanBuffer Storage
+ *
+ * Key differences from JS SpanBuffer:
+ * - System columns (timestamp, entry_type) live in WASM memory at _systemPtr
+ * - Numeric columns allocated lazily from WASM freelists
+ * - String columns (category, text) remain as JS string[] arrays
+ * - All TypedArray views created on-demand from WASM memory.buffer
+ */
+import type { ColumnValueType } from '@smoothbricks/arrow-builder';
+import type { OpMetadata } from '../op.js';
+import type { LogSchema } from '../schema/LogSchema.js';
+import type { SpanBufferStats } from '../spanBufferStats.js';
+import type { ITraceRoot } from '../traceRoot.js';
+import type { AnySpanBuffer } from '../types.js';
+import type { WasmAllocator } from './wasmAllocator.js';
+/**
+ * Options for WASM SpanBuffer instances.
+ * Used by createWasmSpanBuffer (root), createWasmChildSpanBuffer (child), and createWasmOverflowBuffer.
+ * Internal fields (_traceRoot, _scopeValues, _opMetadata, _callsiteMetadata) are passed separately
+ * by the create* functions.
+ */
+export interface WasmSpanBufferOptions {
+    allocator: WasmAllocator;
+    capacity: number;
+    trace_id: string;
+    thread_id: bigint;
+    span_id: number;
+    parent_thread_id?: bigint;
+    parent_span_id?: number;
+    logSchema: LogSchema;
+    _traceRoot: ITraceRoot;
+    _scopeValues: Readonly<Record<string, unknown>>;
+    _opMetadata: OpMetadata;
+    _callsiteMetadata: OpMetadata;
+}
+/**
+ * WASM SpanBuffer instance interface.
+ * Extends AnySpanBuffer with WASM-specific pointer properties.
+ */
+export interface WasmSpanBufferInstance extends AnySpanBuffer {
+    /** Byte offset into WASM memory for system columns (timestamp + entry_type) */
+    readonly _systemPtr: number;
+    /** Byte offset into WASM memory for identity block (writeIndex, span_id, trace_id) */
+    readonly _identityPtr: number;
+    /** Array of byte offsets for each column (-1 = not allocated) */
+    readonly _columnPtrs: Int32Array;
+    /** Reference to the WASM allocator */
+    readonly _allocator: WasmAllocator;
+    _parent?: WasmSpanBufferInstance;
+    _children: WasmSpanBufferInstance[];
+    _overflow?: WasmSpanBufferInstance;
+    readonly _message: string[];
+    /** Free all WASM memory for this buffer */
+    free(): void;
+    /** Check if column is allocated */
+    isColumnAllocated(columnIndex: number): boolean;
+    /** Get column values array if allocated */
+    getColumnIfAllocated(columnName: string): ColumnValueType | undefined;
+    /** Get column nulls array if allocated */
+    getNullsIfAllocated(columnName: string): Uint8Array | undefined;
+}
+/**
+ * Constructor type for generated WASM SpanBuffer classes.
+ */
+export interface WasmSpanBufferConstructor {
+    new (opts: WasmSpanBufferOptions): WasmSpanBufferInstance;
+    readonly schema: LogSchema;
+    stats: SpanBufferStats;
+}
+export declare function isWasmSpanBufferInstance(value: unknown): value is WasmSpanBufferInstance;
+/**
+ * Generate a WASM SpanBuffer class for the given schema.
+ *
+ * Generates minimal constructor + column methods, then assigns common methods to prototype.
+ *
+ * @param schema - LogSchema defining the buffer structure
+ * @returns WasmSpanBufferConstructor for creating buffer instances
+ */
+export declare function getWasmSpanBufferClass(schema: LogSchema): WasmSpanBufferConstructor;
+/**
+ * Create a WASM SpanBuffer instance.
+ *
+ * @param schema - LogSchema defining the buffer structure
+ * @param opts - Options for buffer creation
+ * @param _traceRoot - Trace root context
+ * @param _scopeValues - Scope values for this span
+ * @param _opMetadata - Op metadata for attribution
+ * @param _callsiteMetadata - Callsite metadata for attribution
+ * @returns WasmSpanBufferInstance
+ */
+export declare function createWasmSpanBuffer(schema: LogSchema, opts: Omit<WasmSpanBufferOptions, 'logSchema' | '_traceRoot' | '_scopeValues' | '_opMetadata' | '_callsiteMetadata'>, _traceRoot: ITraceRoot, _scopeValues: Readonly<Record<string, unknown>>, _opMetadata: OpMetadata, _callsiteMetadata: OpMetadata): WasmSpanBufferInstance;
+/**
+ * Create a child WASM SpanBuffer linked to a parent.
+ *
+ * For cross-library calls, the child buffer may use a different schema than the parent.
+ * Pass the schema option to use a different schema.
+ *
+ * @param parent - Parent WASM SpanBuffer
+ * @param opts - Options for child buffer creation (schema is optional, defaults to parent's)
+ * @param _traceRoot - Trace root context
+ * @param _scopeValues - Scope values for this span
+ * @param _opMetadata - Op metadata for attribution
+ * @param _callsiteMetadata - Callsite metadata for attribution
+ * @returns WasmSpanBufferInstance linked to parent
+ */
+export declare function createWasmChildSpanBuffer(parent: WasmSpanBufferInstance, opts: Omit<WasmSpanBufferOptions, 'logSchema' | 'trace_id' | 'parent_thread_id' | 'parent_span_id' | '_traceRoot' | '_scopeValues' | '_opMetadata' | '_callsiteMetadata'> & {
+    schema?: LogSchema;
+}, _traceRoot: ITraceRoot, _scopeValues: Readonly<Record<string, unknown>>, _opMetadata: OpMetadata, _callsiteMetadata: OpMetadata): WasmSpanBufferInstance;
+/**
+ * Create an overflow WASM SpanBuffer for chaining.
+ *
+ * @param buffer - The full buffer that needs overflow handling
+ * @param _traceRoot - Trace root context
+ * @param _scopeValues - Scope values for this span
+ * @param _opMetadata - Op metadata for attribution
+ * @param _callsiteMetadata - Callsite metadata for attribution
+ * @returns WasmSpanBufferInstance linked as overflow
+ */
+export declare function createWasmOverflowBuffer(buffer: WasmSpanBufferInstance, _traceRoot: ITraceRoot, _scopeValues: Readonly<Record<string, unknown>>, _opMetadata: OpMetadata, _callsiteMetadata: OpMetadata): WasmSpanBufferInstance;
+//# sourceMappingURL=wasmSpanBuffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wasmSpanBuffer.d.ts","sourceRoot":"","sources":["../../../src/lib/wasm/wasmSpanBuffer.ts"],"names":[],"mappings":"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"}