@smoothbricks/lmao 0.1.0

package/dist/lib/utf8Cache.js

@@ -0,0 +1,177 @@
+/**
+ * SIEVE-based cache for UTF-8 string encoding
+ *
+ * Per string storage design specs:
+ * - Category/text columns store raw JS strings in hot path (zero cost)
+ * - UTF-8 encoding happens in cold path (Arrow conversion)
+ * - Frequent strings benefit from caching to avoid re-encoding
+ *
+ * Uses SIEVE algorithm (NSDI'24) which is simpler AND better than LRU
+ * for web workloads. SIEVE achieves ~9% lower miss ratio than LRU-K,
+ * ARC, and 2Q while being much simpler to implement.
+ *
+ * @see https://junchengyang.com/publication/nsdi24-SIEVE.pdf
+ */
+import { SieveCache } from '@neophi/sieve-cache';
+/**
+ * Default cache size for UTF-8 encoding
+ *
+ * 4096 entries is a reasonable default that:
+ * - Handles typical category cardinality (user IDs, session IDs, etc.)
+ * - Bounds memory usage (~4KB keys + encoded values)
+ * - Provides good hit rate for repetitive strings
+ */
+const DEFAULT_UTF8_CACHE_SIZE = 4096;
+/**
+ * UTF-8 encoding cache using SIEVE eviction algorithm
+ *
+ * This cache is used during Arrow conversion to avoid re-encoding
+ * strings that appear multiple times across buffers or conversions.
+ *
+ * Thread-safety: JavaScript is single-threaded, so no locks needed.
+ * The cache is safe to use in async contexts since JS awaits don't
+ * allow concurrent access to the same cache instance.
+ */
+export class Utf8Cache {
+    cache;
+    encoder = new TextEncoder();
+    // Stats for debugging/monitoring
+    hits = 0;
+    misses = 0;
+    constructor(maxSize = DEFAULT_UTF8_CACHE_SIZE) {
+        this.cache = new SieveCache(maxSize);
+    }
+    /**
+     * Get UTF-8 encoded bytes for a string, using cache if available
+     *
+     * @param str - String to encode
+     * @returns UTF-8 encoded bytes
+     */
+    encode(str) {
+        const cached = this.cache.get(str);
+        if (cached !== undefined) {
+            this.hits++;
+            return cached;
+        }
+        this.misses++;
+        const encoded = this.encoder.encode(str);
+        this.cache.set(str, encoded);
+        return encoded;
+    }
+    /**
+     * Calculate UTF-8 byte length of a string
+     *
+     * Uses cache if available to avoid re-encoding.
+     *
+     * @param str - String to measure
+     * @returns UTF-8 byte length
+     */
+    byteLength(str) {
+        // Check cache first - if encoded, we know the length
+        const cached = this.cache.get(str);
+        if (cached !== undefined) {
+            this.hits++;
+            return cached.length;
+        }
+        // Not cached - encode and cache it, then return length
+        this.misses++;
+        const encoded = this.encoder.encode(str);
+        this.cache.set(str, encoded);
+        return encoded.length;
+    }
+    /**
+     * Encode string directly into buffer at offset
+     *
+     * @param str - String to encode
+     * @param buffer - Target buffer
+     * @param offset - Offset in buffer to write at
+     * @returns Number of bytes written
+     */
+    encodeInto(str, buffer, offset) {
+        // Use encode() which leverages the cache
+        const encoded = this.encode(str);
+        buffer.set(encoded, offset);
+        return encoded.length;
+    }
+    /**
+     * Encode multiple strings, returning concatenated bytes and offsets
+     *
+     * This is optimized for Arrow dictionary construction where we need
+     * both the concatenated bytes and the offset array.
+     *
+     * @param strings - Array of strings to encode
+     * @returns Concatenated UTF-8 bytes and Arrow-format offsets
+     */
+    encodeMany(strings) {
+        // First pass: encode all strings and calculate total size
+        const encoded = new Array(strings.length);
+        let totalSize = 0;
+        for (let i = 0; i < strings.length; i++) {
+            encoded[i] = this.encode(strings[i]);
+            totalSize += encoded[i].length;
+        }
+        // Build offsets array (Arrow format: length = strings.length + 1)
+        const offsets = new Int32Array(strings.length + 1);
+        offsets[0] = 0;
+        for (let i = 0; i < encoded.length; i++) {
+            offsets[i + 1] = offsets[i] + encoded[i].length;
+        }
+        // Concatenate all encoded bytes
+        const data = new Uint8Array(totalSize);
+        let offset = 0;
+        for (const bytes of encoded) {
+            data.set(bytes, offset);
+            offset += bytes.length;
+        }
+        return { data, offsets };
+    }
+    /**
+     * Get cache statistics
+     */
+    get stats() {
+        const total = this.hits + this.misses;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? this.hits / total : 0,
+            size: this.cache.size,
+        };
+    }
+    /**
+     * Reset statistics (useful for per-conversion tracking)
+     */
+    resetStats() {
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * Clear the cache entirely
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+}
+/**
+ * Global UTF-8 cache instance
+ *
+ * Using a global cache provides cross-conversion caching benefits:
+ * - Strings that appear in multiple spans/buffers are cached
+ * - Warm cache improves performance over time
+ *
+ * The SIEVE eviction ensures bounded memory even with unbounded inputs.
+ */
+export const globalUtf8Cache = new Utf8Cache();
+/**
+ * Create a new UTF-8 cache with custom size
+ *
+ * Use this when you want a dedicated cache instance (e.g., for testing
+ * or for isolation between different conversion contexts).
+ *
+ * @param maxSize - Maximum number of entries to cache
+ * @returns New Utf8Cache instance
+ */
+export function createUtf8Cache(maxSize) {
+    return new Utf8Cache(maxSize);
+}

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

@@ -0,0 +1,88 @@
+/**
+ * WasmBufferStrategy - Buffer strategy using WASM memory with freelist allocation.
+ *
+ * Uses WebAssembly memory for numeric columns with O(1) freelist allocation/deallocation.
+ * String columns remain in JavaScript.
+ *
+ * Memory characteristics:
+ * - Numeric data lives in contiguous WASM memory (better cache locality)
+ * - Freelist enables O(1) memory reuse across traces
+ * - Explicit release required (not GC-managed)
+ * - Arrow conversion reads from WASM memory views
+ *
+ * @module WasmBufferStrategy
+ */
+import type { Table } from '@uwdata/flechette';
+import type { BufferStrategy } from '../bufferStrategy.js';
+import type { OpMetadata } from '../opContext/opTypes.js';
+import type { LogSchema } from '../schema/LogSchema.js';
+import type { ITraceRoot } from '../traceRoot.js';
+import type { AnySpanBuffer, SpanBuffer } from '../types.js';
+import { type WasmAllocator, type WasmAllocatorOptions } from './wasmAllocator.js';
+/**
+ * Options for WasmBufferStrategy.
+ */
+export interface WasmBufferStrategyOptions extends WasmAllocatorOptions {
+    /** Pre-created allocator. If not provided, one will be created. */
+    allocator?: WasmAllocator;
+}
+type WasmAllocatorStats = {
+    allocCount: number;
+    freeCount: number;
+    bumpPtr: number;
+    capacity: number;
+};
+/**
+ * WasmBufferStrategy - Buffer strategy using WASM memory with freelist allocation.
+ *
+ * This strategy is optimized for high-throughput scenarios:
+ * - Numeric columns allocated from WASM freelists (O(1) alloc/free)
+ * - Better cache locality from contiguous WASM memory
+ * - Explicit memory management via releaseBuffer()
+ *
+ * @example
+ * ```typescript
+ * const strategy = await WasmBufferStrategy.create<MySchema>();
+ * const tracer = new StdioTracer(binding, { bufferStrategy: strategy });
+ * ```
+ */
+export declare class WasmBufferStrategy<T extends LogSchema = LogSchema> implements BufferStrategy<T> {
+    /**
+     * The WASM allocator instance.
+     * Shared across all buffers created by this strategy.
+     */
+    readonly allocator: WasmAllocator;
+    /**
+     * Private constructor - use static create() method.
+     */
+    private constructor();
+    /**
+     * Create a WasmBufferStrategy instance.
+     *
+     * Async because WASM module loading may be asynchronous.
+     *
+     * @param options - Configuration options
+     * @returns Promise<WasmBufferStrategy>
+     */
+    static create<T extends LogSchema = LogSchema>(options?: WasmBufferStrategyOptions): Promise<WasmBufferStrategy<T>>;
+    createSpanBuffer(schema: T, traceRoot: ITraceRoot, opMetadata: OpMetadata, capacity?: number): SpanBuffer<T>;
+    createChildSpanBuffer(parentBuffer: SpanBuffer<T>, callsiteMetadata: OpMetadata, opMetadata: OpMetadata, capacity?: number, schema?: T): SpanBuffer<T>;
+    createOverflowBuffer(buffer: SpanBuffer<T>): SpanBuffer<T>;
+    toArrowTable(buffer: AnySpanBuffer): Table;
+    releaseBuffer(buffer: AnySpanBuffer): void;
+    /**
+     * Recursively free all WASM memory for a span tree.
+     */
+    private freeSpanTree;
+    /**
+     * Reset the allocator (for testing/benchmarking).
+     * WARNING: This invalidates ALL buffers created by this strategy.
+     */
+    reset(): void;
+    /**
+     * Get allocator statistics for debugging/monitoring.
+     */
+    getStats(): WasmAllocatorStats;
+}
+export {};
+//# sourceMappingURL=WasmBufferStrategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WasmBufferStrategy.d.ts","sourceRoot":"","sources":["../../../src/lib/wasm/WasmBufferStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAuB,KAAK,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAgBxG;;GAEG;AACH,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACrE,mEAAmE;IACnE,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED,KAAK,kBAAkB,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,qBAAa,kBAAkB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,CAAE,YAAW,cAAc,CAAC,CAAC,CAAC;IAC3F;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAElC;;OAEG;IACH,OAAO;IAIP;;;;;;;OAOG;WACU,MAAM,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACjD,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAKjC,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;IAwB5G,qBAAqB,CACnB,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,EAC3B,gBAAgB,EAAE,UAAU,EAC5B,UAAU,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC;IA0BhB,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAc1D,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,KAAK;IAK1C,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAK1C;;OAEG;IACH,OAAO,CAAC,YAAY;IAmBpB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,QAAQ,IAAI,kBAAkB;CAQ/B"}

package/dist/lib/wasm/WasmBufferStrategy.js

@@ -0,0 +1,138 @@
+import { convertSpanTreeToArrowTable } from '../convertToArrow.js';
+import { EMPTY_SCOPE } from '../spanBuffer.js';
+import { createWasmAllocator } from './wasmAllocator.js';
+import { createWasmChildSpanBuffer, createWasmOverflowBuffer, createWasmSpanBuffer, isWasmSpanBufferInstance, } from './wasmSpanBuffer.js';
+function requireWasmSpanBuffer(buffer) {
+    if (!isWasmSpanBufferInstance(buffer)) {
+        throw new Error('Expected WASM-backed span buffer');
+    }
+    return buffer;
+}
+/**
+ * WasmBufferStrategy - Buffer strategy using WASM memory with freelist allocation.
+ *
+ * This strategy is optimized for high-throughput scenarios:
+ * - Numeric columns allocated from WASM freelists (O(1) alloc/free)
+ * - Better cache locality from contiguous WASM memory
+ * - Explicit memory management via releaseBuffer()
+ *
+ * @example
+ * ```typescript
+ * const strategy = await WasmBufferStrategy.create<MySchema>();
+ * const tracer = new StdioTracer(binding, { bufferStrategy: strategy });
+ * ```
+ */
+export class WasmBufferStrategy {
+    /**
+     * The WASM allocator instance.
+     * Shared across all buffers created by this strategy.
+     */
+    allocator;
+    /**
+     * Private constructor - use static create() method.
+     */
+    constructor(allocator) {
+        this.allocator = allocator;
+    }
+    /**
+     * Create a WasmBufferStrategy instance.
+     *
+     * Async because WASM module loading may be asynchronous.
+     *
+     * @param options - Configuration options
+     * @returns Promise<WasmBufferStrategy>
+     */
+    static async create(options) {
+        const allocator = options?.allocator ?? (await createWasmAllocator(options));
+        return new WasmBufferStrategy(allocator);
+    }
+    createSpanBuffer(schema, traceRoot, opMetadata, capacity) {
+        const effectiveCapacity = capacity ?? this.allocator.capacity;
+        // Create WASM buffer
+        const wasmBuffer = createWasmSpanBuffer(schema, {
+            allocator: this.allocator,
+            capacity: effectiveCapacity,
+            trace_id: traceRoot.trace_id,
+            // thread_id and span_id come from WASM (global header and allocator respectively)
+            thread_id: 0n, // Will be read from WASM header
+            span_id: 0, // Will be assigned by WASM allocator
+        }, traceRoot, // _traceRoot
+        EMPTY_SCOPE, // _scopeValues
+        opMetadata, // _opMetadata
+        opMetadata);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- generated WASM buffers implement the SpanBuffer contract for the same schema.
+        return wasmBuffer;
+    }
+    createChildSpanBuffer(parentBuffer, callsiteMetadata, opMetadata, capacity, schema) {
+        const wasmParent = requireWasmSpanBuffer(parentBuffer);
+        const effectiveCapacity = capacity ?? wasmParent._capacity;
+        // Use provided schema (for cross-library calls) or parent's schema
+        const childSchema = schema ?? parentBuffer._logSchema;
+        const child = createWasmChildSpanBuffer(wasmParent, {
+            allocator: this.allocator,
+            capacity: effectiveCapacity,
+            thread_id: 0n, // Will be read from WASM header
+            span_id: 0, // Will be assigned by WASM allocator
+            schema: childSchema, // Pass schema for correct buffer class
+        }, parentBuffer._traceRoot, // _traceRoot (inherit from parent)
+        parentBuffer._scopeValues, // _scopeValues (inherit from parent)
+        opMetadata, // _opMetadata
+        callsiteMetadata);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- child buffers preserve the requested schema contract.
+        return child;
+    }
+    createOverflowBuffer(buffer) {
+        const wasmBuffer = requireWasmSpanBuffer(buffer);
+        const overflow = createWasmOverflowBuffer(wasmBuffer, buffer._traceRoot, // _traceRoot (same as original)
+        buffer._scopeValues, // _scopeValues (same as original)
+        buffer._opMetadata, // _opMetadata (same as original)
+        buffer._callsiteMetadata ?? buffer._opMetadata);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- overflow buffers are schema-compatible continuations of the same span.
+        return overflow;
+    }
+    toArrowTable(buffer) {
+        // Uses existing tree conversion with shared dictionaries
+        return convertSpanTreeToArrowTable(buffer);
+    }
+    releaseBuffer(buffer) {
+        // Walk the span tree and free all WASM memory
+        this.freeSpanTree(requireWasmSpanBuffer(buffer));
+    }
+    /**
+     * Recursively free all WASM memory for a span tree.
+     */
+    freeSpanTree(buffer) {
+        // Free children first (depth-first)
+        if (buffer._children) {
+            for (const child of buffer._children) {
+                this.freeSpanTree(child);
+            }
+        }
+        // Free overflow chain
+        if (buffer._overflow) {
+            this.freeSpanTree(buffer._overflow);
+        }
+        // Free this buffer's WASM memory
+        if (typeof buffer.free === 'function') {
+            buffer.free();
+        }
+    }
+    /**
+     * Reset the allocator (for testing/benchmarking).
+     * WARNING: This invalidates ALL buffers created by this strategy.
+     */
+    reset() {
+        this.allocator.reset();
+    }
+    /**
+     * Get allocator statistics for debugging/monitoring.
+     */
+    getStats() {
+        return {
+            allocCount: this.allocator.getAllocCount(),
+            freeCount: this.allocator.getFreeCount(),
+            bumpPtr: this.allocator.getBumpPtr(),
+            capacity: this.allocator.capacity,
+        };
+    }
+}

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

@@ -0,0 +1,109 @@
+/**
+ * TypeScript wrapper for the WASM allocator.
+ *
+ * Implements spec 01q: WASM Memory Architecture for SpanBuffer Storage
+ *
+ * The allocator provides O(1) alloc/free via freelists with memory reuse.
+ * Each OpContext may have a different capacity - capacity is passed to each call.
+ *
+ * Buddy Allocation:
+ * - Blocks are organized by tier (capacity 8, 16, 32, 64, 128, 256, 512)
+ * - When freelist is empty, splits from larger tier
+ * - When freeing, merges with adjacent blocks if both are free (address-based buddy merge)
+ */
+export interface WasmAllocator {
+    /** The underlying WASM memory */
+    readonly memory: WebAssembly.Memory;
+    /** WASM exports for direct function calls (hot path optimization) */
+    readonly exports: {
+        write_col_f64: (colOffset: number, rowIdx: number, value: number, capacity: number) => number;
+        write_col_u32: (colOffset: number, rowIdx: number, value: number, capacity: number) => number;
+        write_col_u8: (colOffset: number, rowIdx: number, value: number, capacity: number) => number;
+        write_log_entry: (systemPtr: number, identityPtr: number, traceRootPtr: number, entryType: number, capacity: number) => number;
+    };
+    /** Cached views (recreated after grow, but pre-sized to avoid grow for benchmarks) */
+    readonly u8: Uint8Array;
+    readonly u32: Uint32Array;
+    readonly i64: BigInt64Array;
+    readonly f64: Float64Array;
+    /** Default capacity for convenience methods */
+    readonly capacity: number;
+    /** Initialize allocator header (call once) */
+    init(): void;
+    /** Reset all freelists (for testing/benchmarking) */
+    reset(): void;
+    allocSpanSystem(capacity?: number): number;
+    alloc1B(capacity?: number): number;
+    alloc4B(capacity?: number): number;
+    alloc8B(capacity?: number): number;
+    freeSpanSystem(offset: number, capacity?: number): void;
+    free1B(offset: number, capacity?: number): void;
+    free4B(offset: number, capacity?: number): void;
+    free8B(offset: number, capacity?: number): void;
+    spanStart(systemPtr: number, identityPtr: number, traceRootPtr: number, capacity?: number): void;
+    spanEndOk(systemPtr: number, traceRootPtr: number, capacity?: number): void;
+    spanEndErr(systemPtr: number, traceRootPtr: number, capacity?: number): void;
+    /** Write log entry, bump writeIndex, return idx written to */
+    writeLogEntry(systemPtr: number, identityPtr: number, traceRootPtr: number, entryType: number, capacity?: number): number;
+    writeColF64(colOffset: number, rowIdx: number, value: number, capacity?: number): number;
+    writeColU32(colOffset: number, rowIdx: number, value: number, capacity?: number): number;
+    writeColU8(colOffset: number, rowIdx: number, value: number, capacity?: number): number;
+    initTraceRoot(traceRootPtr: number): void;
+    getBumpPtr(): number;
+    getAllocCount(): number;
+    getFreeCount(): number;
+    getSpanSystemSize(capacity?: number): number;
+    getCol1BSize(capacity?: number): number;
+    getCol4BSize(capacity?: number): number;
+    getCol8BSize(capacity?: number): number;
+    readTimestamp(systemPtr: number, rowIdx: number): bigint;
+    readEntryType(systemPtr: number, rowIdx: number, capacity?: number): number;
+    readWriteIndex(identityPtr: number): number;
+    readColF64(colOffset: number, rowIdx: number, capacity?: number): number;
+    readColIsValid(colOffset: number, rowIdx: number): number;
+    setThreadId(high: number, low: number): void;
+    getThreadIdHigh(): number;
+    getThreadIdLow(): number;
+    isThreadIdSet(): number;
+    getSpanIdCounter(): number;
+    allocIdentityRootForJsWrite(traceIdLen: number): bigint;
+    allocIdentityChild(): number;
+    freeIdentity(offset: number): void;
+    readIdentitySpanId(identityPtr: number): number;
+    readIdentityTraceIdLen(identityPtr: number): number;
+    getIdentityTraceIdPtr(identityPtr: number): number;
+    getFreelistLen(sizeClass: SizeClass, capacity?: number): number;
+    getFreelistReuseCount(sizeClass: SizeClass, capacity?: number): number;
+    getFreelistSplitCount(sizeClass: SizeClass, capacity?: number): number;
+    getFreelistMergeCount(sizeClass: SizeClass, capacity?: number): number;
+}
+/**
+ * Size class enum matching Zig's SizeClass
+ */
+export declare enum SizeClass {
+    SpanSystem = 0,
+    Col1B = 1,
+    Col4B = 2,
+    Col8B = 3,
+    Identity = 4
+}
+export interface WasmAllocatorOptions {
+    /** Initial memory pages (64KB each). Default: 17 (~1MB) */
+    initialPages?: number;
+    /** Maximum memory pages. Default: 16384 (1GB) */
+    maxPages?: number;
+    /** Default capacity (rows per span buffer). Default: 64 */
+    capacity?: number;
+}
+/**
+ * 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 declare function createWasmAllocator(options?: WasmAllocatorOptions): Promise<WasmAllocator>;
+/**
+ * Synchronous version for when WASM is pre-loaded.
+ */
+export declare function createWasmAllocatorSync(wasmModule: WebAssembly.Module, options?: WasmAllocatorOptions): WasmAllocator;
+//# sourceMappingURL=wasmAllocator.d.ts.map

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

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