@slexisvn/query-engine 0.1.0

package/dist/storage/column.d.ts

@@ -0,0 +1,38 @@
+import { DataType, type AnyTypedArray, type ColumnValue } from './data-type.js';
+import { type Allocator } from './sab-arena.js';
+export interface ColumnParts {
+    dataType: DataType;
+    data?: AnyTypedArray;
+    offsets?: Uint32Array;
+    stringBytes?: Uint8Array;
+    stringBytesUsed?: number;
+    nullBitmap: Uint32Array;
+    length: number;
+    hasNulls: boolean;
+    allocator?: Allocator;
+}
+export declare class Column {
+    dataType: DataType;
+    capacity: number;
+    length: number;
+    allocator: Allocator;
+    data?: AnyTypedArray;
+    offsets?: Uint32Array;
+    stringBytes?: Uint8Array;
+    stringBytesUsed?: number;
+    nullBitmap: Uint32Array;
+    hasNulls: boolean;
+    constructor(dataType: DataType, capacity?: number, allocator?: Allocator);
+    static fromParts({ dataType, data, offsets, stringBytes, stringBytesUsed, nullBitmap, length, hasNulls, allocator }: ColumnParts): Column;
+    get(index: number): ColumnValue;
+    set(index: number, value: ColumnValue): void;
+    append(value: ColumnValue): void;
+    appendBatch(values: ColumnValue[]): void;
+    isNull(index: number): boolean;
+    slice(start: number, end: number): Column;
+    _setNull(index: number): void;
+    _getString(index: number): string;
+    _setString(index: number, value: string): void;
+    _grow(): void;
+    _growStringBuffer(): void;
+}

package/dist/storage/data-type.d.ts

@@ -0,0 +1,54 @@
+export declare enum DataType {
+    BOOLEAN = "BOOLEAN",
+    INT32 = "INT32",
+    INT64 = "INT64",
+    FLOAT64 = "FLOAT64",
+    DECIMAL = "DECIMAL",
+    VARCHAR = "VARCHAR",
+    DATE = "DATE",
+    TIMESTAMP = "TIMESTAMP"
+}
+export type ColumnValue = string | number | bigint | boolean | null;
+export type AnyTypedArray = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float64Array | BigInt64Array;
+export interface TypedArrayCtor<T extends AnyTypedArray> {
+    readonly BYTES_PER_ELEMENT: number;
+    new (length: number): T;
+    new (buffer: ArrayBufferLike, byteOffset: number, length: number): T;
+}
+export interface ColumnSchema {
+    name: string;
+    dataType: DataType;
+}
+export declare const FIXED_WIDTH_TYPES: Set<DataType>;
+export declare function typedArrayCtorFor(dataType: DataType): TypedArrayCtor<AnyTypedArray>;
+export declare function typedArrayFor(dataType: DataType, length: number): AnyTypedArray;
+export declare function byteWidthFor(dataType: DataType): number;
+export declare function isFixedWidth(dataType: DataType): boolean;
+export declare function isNumeric(dataType: DataType): boolean;
+export declare function isTemporal(dataType: DataType): boolean;
+export declare function isComparable(a: DataType, b: DataType): boolean;
+export declare function getDecimalScale(): bigint;
+export declare function getDecimalScaleNumber(): number;
+export declare function setDecimalScale(digits: number): void;
+export declare const DECIMAL_SCALE = 100n;
+export declare const DECIMAL_SCALE_NUMBER = 100;
+export declare function dateToEpochDays(year: number, month: number, day: number): number;
+export interface DateParts {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface TimestampParts {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    ms: number;
+}
+export declare function epochDaysToDate(days: number): DateParts;
+export declare function timestampToEpochMs(year: number, month: number, day: number, hour: number, minute: number, second: number, ms?: number): number;
+export declare function epochMsToTimestamp(epochMs: number): TimestampParts;
+export declare function epochDaysToEpochMs(days: number): number;
+export declare function epochMsToEpochDays(ms: number): number;

package/dist/storage/dictionary-column.d.ts

@@ -0,0 +1,33 @@
+import { DataType, type ColumnValue } from './data-type.js';
+import { type Allocator } from './sab-arena.js';
+export interface DictionaryColumnParts {
+    indices: Uint16Array;
+    reverseDict: string[];
+    nullBitmap: Uint32Array;
+    length: number;
+    hasNulls: boolean;
+    allocator?: Allocator;
+}
+export declare class DictionaryColumn {
+    dataType: DataType;
+    capacity: number;
+    length: number;
+    allocator: Allocator;
+    _dictionary: Map<string, number> | null;
+    reverseDict: string[];
+    indices: Uint16Array;
+    nullBitmap: Uint32Array;
+    hasNulls: boolean;
+    constructor(capacity?: number, allocator?: Allocator);
+    static fromParts({ indices, reverseDict, nullBitmap, length, hasNulls, allocator }: DictionaryColumnParts): DictionaryColumn;
+    get dictionary(): Map<string, number>;
+    set dictionary(map: Map<string, number>);
+    get(index: number): ColumnValue;
+    set(index: number, value: ColumnValue): void;
+    append(value: ColumnValue): void;
+    appendBatch(values: ColumnValue[]): void;
+    isNull(index: number): boolean;
+    slice(start: number, end: number): DictionaryColumn;
+    _setNull(index: number): void;
+    _grow(): void;
+}

package/dist/storage/page-store/file-page-store.d.ts

@@ -0,0 +1,13 @@
+import type { DataChunk } from '../chunk.js';
+import type { PageStore } from '../buffer-pool.js';
+import type { Allocator } from '../sab-arena.js';
+export type AllocatorFactory = (byteHint: number) => Allocator;
+export declare class FilePageStore implements PageStore {
+    basePath: string;
+    allocatorFactory: AllocatorFactory | null;
+    constructor(basePath: string, allocatorFactory?: AllocatorFactory | null);
+    getPagePath(pageId: string): string;
+    write(pageId: string, chunk: DataChunk): Promise<void>;
+    read(pageId: string): Promise<DataChunk>;
+    clear(): void;
+}

package/dist/storage/page-store/memory-page-store.d.ts

@@ -0,0 +1,9 @@
+import type { DataChunk } from '../chunk.js';
+import type { PageStore } from '../buffer-pool.js';
+export declare class MemoryPageStore implements PageStore {
+    pages: Map<string, DataChunk>;
+    constructor();
+    write(pageId: string, chunk: DataChunk): Promise<void>;
+    read(pageId: string): Promise<DataChunk | null>;
+    clear(): void;
+}

package/dist/storage/sab-arena.d.ts

@@ -0,0 +1,26 @@
+import type { AnyTypedArray, TypedArrayCtor } from './data-type.js';
+export interface Allocator {
+    readonly shared: boolean;
+    acquire<T extends AnyTypedArray>(Ctor: TypedArrayCtor<T>, length: number): T;
+}
+interface ArenaSegment {
+    sab: SharedArrayBuffer;
+    offset: number;
+}
+export declare class HeapAllocator implements Allocator {
+    get shared(): boolean;
+    acquire<T extends AnyTypedArray>(Ctor: TypedArrayCtor<T>, length: number): T;
+}
+export declare const heapAllocator: HeapAllocator;
+export declare class SabArena implements Allocator {
+    nextSegmentBytes: number;
+    segments: ArenaSegment[];
+    constructor(initialBytes?: number);
+    get shared(): boolean;
+    acquire<T extends AnyTypedArray>(Ctor: TypedArrayCtor<T>, length: number): T;
+    _segmentFor(byteLength: number, alignment: number): ArenaSegment;
+    totalBytes(): number;
+}
+export declare function columnAllocator(byteHint?: number): Allocator;
+export declare function isSharedView(view?: ArrayBufferView): boolean;
+export {};

package/dist/storage/serializer.d.ts

@@ -0,0 +1,6 @@
+import { DataChunk } from './chunk.js';
+import { type Allocator } from './sab-arena.js';
+export declare class ChunkSerializer {
+    static serialize(chunk: DataChunk): Buffer;
+    static deserialize(buffer: Buffer, allocator?: Allocator): DataChunk;
+}

package/dist/storage/spill-manager/fs-storage.d.ts

@@ -0,0 +1,11 @@
+import type { SpillStorage } from './spill-manager.js';
+export declare class FsStorage implements SpillStorage {
+    basePath: string;
+    constructor(basePath: string);
+    filePath(partitionId: string): string;
+    append(partitionId: string, buffer: Buffer): Promise<void>;
+    read(partitionId: string): Promise<Buffer | null>;
+    exists(partitionId: string): boolean;
+    remove(partitionId: string): Promise<void>;
+    removeAll(): Promise<void>;
+}

package/dist/storage/spill-manager/memory-storage.d.ts

@@ -0,0 +1,10 @@
+import type { SpillStorage } from './spill-manager.js';
+export declare class MemoryStorage implements SpillStorage {
+    store: Map<string, Buffer[]>;
+    constructor();
+    append(partitionId: string, buffer: Buffer): Promise<void>;
+    read(partitionId: string): Promise<Buffer | null>;
+    exists(partitionId: string): boolean;
+    remove(partitionId: string): Promise<void>;
+    removeAll(): Promise<void>;
+}

package/dist/storage/spill-manager/spill-manager.d.ts

@@ -0,0 +1,17 @@
+import type { DataChunk } from '../chunk.js';
+export interface SpillStorage {
+    append(partitionId: string, buffer: Buffer): Promise<void>;
+    read(partitionId: string): Promise<Buffer | null>;
+    exists(partitionId: string): boolean;
+    remove(partitionId: string): Promise<void>;
+    removeAll(): Promise<void>;
+}
+export declare class SpillManager {
+    storage: SpillStorage;
+    constructor(storage: SpillStorage);
+    appendChunk(partitionId: string, chunk: DataChunk | null): Promise<void>;
+    readChunks(partitionId: string): AsyncGenerator<DataChunk>;
+    clearPartition(partitionId: string): Promise<void>;
+    clearAll(): Promise<void>;
+    hasSpilled(partitionId: string): boolean;
+}

package/dist/storage/storage-constants.d.ts

@@ -0,0 +1,3 @@
+export declare const PAGE_FILE_SUFFIX = ".qdat";
+export declare const SPILL_FILE_SUFFIX = ".spill";
+export declare const MEMORY_ROOT_PREFIX = "mem://query_engine";

package/dist/storage/table.d.ts

@@ -0,0 +1,31 @@
+import { DataChunk } from './chunk.js';
+import { BufferPoolManager, type PageStore } from './buffer-pool.js';
+import type { ColumnSchema, ColumnValue } from './data-type.js';
+import type { BTreeIndex } from './btree.js';
+interface TableIndex {
+    columnIndex: number;
+    btree: BTreeIndex;
+}
+export declare class Table {
+    name: string;
+    schema: ColumnSchema[];
+    pageIds: string[];
+    _rowCount: number;
+    bufferPool: BufferPoolManager;
+    activeChunk: DataChunk | null;
+    indexes: TableIndex[];
+    constructor(name: string, schema: ColumnSchema[], pageStore: PageStore);
+    getSchema(): ColumnSchema[];
+    getColumnIndex(columnName: string): number;
+    getColumn(columnName: string): ColumnSchema | undefined;
+    rowCount(): number;
+    registerIndex(columnIndex: number, btree: BTreeIndex): void;
+    addChunk(chunk: DataChunk): Promise<void>;
+    insertRows(rows: ColumnValue[][]): Promise<void>;
+    flush(): Promise<void>;
+    scan(): AsyncGenerator<DataChunk>;
+    scanAll(): Promise<DataChunk[]>;
+    getStatistics(): null;
+    _createChunk(): DataChunk;
+}
+export {};

package/dist/storage/temp-space/memory-temp-space.d.ts

@@ -0,0 +1,11 @@
+export interface TempSpaceOptions {
+    baseDir?: string;
+}
+export declare class MemoryTempSpace {
+    rootDir: string;
+    counters: Map<string, number>;
+    constructor(options?: TempSpaceOptions);
+    allocate(category: string, label: string): string;
+    getRoot(): string;
+    cleanup(): void;
+}

package/dist/storage/temp-space/temp-directory-manager.d.ts

@@ -0,0 +1,14 @@
+export interface TempDirectoryOptions {
+    baseDir?: string;
+}
+export declare class TempDirectoryManager {
+    baseDir: string;
+    rootName: string;
+    rootDir: string;
+    counters: Map<string, number>;
+    initialized: boolean;
+    constructor(options?: TempDirectoryOptions);
+    allocate(category: string, label: string): string;
+    getRootDir(): string;
+    cleanup(): void;
+}

package/dist/utils/bitmap.d.ts

@@ -0,0 +1,11 @@
+export declare function bitmapWordCount(length: number): number;
+export declare function createBitmap(length: number): Uint32Array;
+export declare function setBit(bitmap: Uint32Array, index: number): void;
+export declare function clearBit(bitmap: Uint32Array, index: number): void;
+export declare function testBit(bitmap: Uint32Array, index: number): boolean;
+export declare function setBitRange(bitmap: Uint32Array, start: number, end: number): void;
+export declare function andBitmaps(a: Uint32Array, b: Uint32Array, length: number): Uint32Array;
+export declare function orBitmaps(a: Uint32Array, b: Uint32Array, length: number): Uint32Array;
+export declare function notBitmap(bitmap: Uint32Array, length: number): Uint32Array;
+export declare function popcount(bitmap: Uint32Array, length: number): number;
+export declare function countSetBits(bitmap: Uint32Array, length: number): number;

package/dist/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashValue(value: string | number | bigint | boolean | null): number;

package/dist/utils/lru-cache.d.ts

@@ -0,0 +1,24 @@
+interface LRUNode<K, V> {
+    key: K;
+    value: V;
+    prev: LRUNode<K, V> | null;
+    next: LRUNode<K, V> | null;
+}
+export declare class LRUCache<K, V> {
+    _maxSize: number;
+    _map: Map<K, LRUNode<K, V>>;
+    _head: LRUNode<K, V> | null;
+    _tail: LRUNode<K, V> | null;
+    constructor(maxSize: number);
+    _detach(node: LRUNode<K, V>): void;
+    _prepend(node: LRUNode<K, V>): void;
+    _moveToHead(node: LRUNode<K, V>): void;
+    _evictTail(): K | null;
+    get(key: K): V | undefined;
+    set(key: K, value: V): K | null;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+}
+export {};

package/dist/utils/priority-queue.d.ts

@@ -0,0 +1,18 @@
+export type Comparator<T> = (a: T, b: T) => number;
+export declare class PriorityQueue<T> {
+    private _heap;
+    private _comparator;
+    constructor(comparator?: Comparator<T>);
+    get size(): number;
+    isEmpty(): boolean;
+    peek(): T | undefined;
+    push(value: T): void;
+    pop(): T | null;
+    _parent(i: number): number;
+    _left(i: number): number;
+    _right(i: number): number;
+    _siftUp(): void;
+    _siftDown(): void;
+    _compare(i: number, j: number): boolean;
+    _swap(i: number, j: number): void;
+}

package/dist/wasm/dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { WasmDispatchRegistry, WasmKernel, RegisterableKernel } from './wasm-types.js';
+export declare class WasmDispatch implements WasmDispatchRegistry {
+    readonly kernels: Map<string, WasmKernel>;
+    wasmInstance: WebAssembly.Instance | null;
+    memory: WebAssembly.Memory | null;
+    constructor();
+    register(operation: string, dataType: string, kernel: RegisterableKernel): void;
+    lookup(operation: string, dataType: string): WasmKernel | null;
+    has(operation: string, dataType: string): boolean;
+    setInstance(instance: WebAssembly.Instance, memory: WebAssembly.Memory): void;
+    listKernels(): string[];
+}
+export declare const globalDispatch: WasmDispatch;

package/dist/wasm/fetch-byte-source.d.ts

@@ -0,0 +1,2 @@
+export declare function setWasmBaseUrl(url: string | URL | null): void;
+export declare function fetchByteSource(name: string): Promise<Uint8Array>;

package/dist/wasm/kernels/core-instance.d.ts

@@ -0,0 +1,6 @@
+import type { WasmLoaderLike } from '../wasm-types.js';
+export interface CoreInstance {
+    loader: WasmLoaderLike;
+    instance: WebAssembly.Instance;
+}
+export declare function getCoreInstance(): Promise<CoreInstance>;

package/dist/wasm/kernels/kernel-factory.d.ts

@@ -0,0 +1,8 @@
+import type { WasmExports } from '../wasm-types.js';
+export declare function makeFilterKernel<T extends Int32Array | Float64Array>(exportName: keyof WasmExports, byteWidth: number): (data: T, value: number) => Promise<Uint32Array>;
+export declare function makeBetweenKernel<T extends Int32Array | Float64Array>(exportName: keyof WasmExports, byteWidth: number): (data: T, low: number, high: number) => Promise<Uint32Array>;
+export declare function makeScalarAggKernel<T extends Int32Array | Float64Array>(exportName: keyof WasmExports, byteWidth: number): (data: T) => Promise<number>;
+export declare function makeVecOpF64(exportName: keyof WasmExports): (a: Float64Array, b: Float64Array) => Promise<Float64Array>;
+export declare function makeScalarOpF64(exportName: keyof WasmExports): (data: Float64Array, scalar: number) => Promise<Float64Array>;
+export declare function makeScalarOpRevF64(exportName: keyof WasmExports): (scalar: number, data: Float64Array) => Promise<Float64Array>;
+export declare function makeUnaryOpF64(exportName: keyof WasmExports): (data: Float64Array) => Promise<Float64Array>;

package/dist/wasm/kernels/wasm-aggregate.d.ts

@@ -0,0 +1,6 @@
+export declare const wasmSumI32: (data: Int32Array<ArrayBufferLike>) => Promise<number>;
+export declare const wasmSumF64: (data: Float64Array<ArrayBufferLike>) => Promise<number>;
+export declare const wasmMinI32: (data: Int32Array<ArrayBufferLike>) => Promise<number>;
+export declare const wasmMaxI32: (data: Int32Array<ArrayBufferLike>) => Promise<number>;
+export declare const wasmMinF64: (data: Float64Array<ArrayBufferLike>) => Promise<number>;
+export declare const wasmMaxF64: (data: Float64Array<ArrayBufferLike>) => Promise<number>;

package/dist/wasm/kernels/wasm-arithmetic.d.ts

@@ -0,0 +1,13 @@
+export declare const wasmVecAddF64: (a: Float64Array, b: Float64Array) => Promise<Float64Array>;
+export declare const wasmVecSubF64: (a: Float64Array, b: Float64Array) => Promise<Float64Array>;
+export declare const wasmVecMulF64: (a: Float64Array, b: Float64Array) => Promise<Float64Array>;
+export declare const wasmVecDivF64: (a: Float64Array, b: Float64Array) => Promise<Float64Array>;
+export declare const wasmScalarAddF64: (data: Float64Array, scalar: number) => Promise<Float64Array>;
+export declare const wasmScalarSubF64: (data: Float64Array, scalar: number) => Promise<Float64Array>;
+export declare const wasmScalarMulF64: (data: Float64Array, scalar: number) => Promise<Float64Array>;
+export declare const wasmScalarDivF64: (data: Float64Array, scalar: number) => Promise<Float64Array>;
+export declare const wasmScalarSubRevF64: (scalar: number, data: Float64Array) => Promise<Float64Array>;
+export declare const wasmScalarDivRevF64: (scalar: number, data: Float64Array) => Promise<Float64Array>;
+export declare const wasmNegF64: (data: Float64Array) => Promise<Float64Array>;
+export declare function wasmWidenI32ToF64(data: Int32Array): Promise<Float64Array>;
+export declare function wasmCountBits(bitmap: Uint8Array, bitCount: number): Promise<number>;

package/dist/wasm/kernels/wasm-filter-f64.d.ts

@@ -0,0 +1,8 @@
+export declare const wasmFilterEqF64: (data: Float64Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterLtF64: (data: Float64Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterGtF64: (data: Float64Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterLeF64: (data: Float64Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterGeF64: (data: Float64Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterBetweenF64: (data: Float64Array<ArrayBufferLike>, low: number, high: number) => Promise<Uint32Array>;
+export declare const wasmFilterLeI32: (data: Int32Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterGeI32: (data: Int32Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;

package/dist/wasm/kernels/wasm-filter.d.ts

@@ -0,0 +1,5 @@
+export declare const wasmFilterEqI32: (data: Int32Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterLtI32: (data: Int32Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterGtI32: (data: Int32Array<ArrayBufferLike>, value: number) => Promise<Uint32Array>;
+export declare const wasmFilterBetweenI32: (data: Int32Array<ArrayBufferLike>, low: number, high: number) => Promise<Uint32Array>;
+export declare const wasmSumF64: (data: Float64Array<ArrayBufferLike>) => Promise<number>;

package/dist/wasm/loader.d.ts

@@ -0,0 +1,17 @@
+import { WasmLoaderBase } from './wasm-loader-base.js';
+import type { ByteSource } from './wasm-types.js';
+export interface WasmLoaderInitOptions {
+    shared?: boolean;
+}
+export declare class WasmLoader extends WasmLoaderBase {
+    byteSource: ByteSource;
+    memory: WebAssembly.Memory | null;
+    shared: boolean;
+    bumpOffset: number;
+    constructor(byteSource: ByteSource);
+    init(_options?: WasmLoaderInitOptions): Promise<void>;
+    fetchModuleBytes(name: string): Promise<Uint8Array>;
+}
+export declare function configureWasmSource(byteSource: ByteSource): void;
+export declare function getGlobalLoader(options?: WasmLoaderInitOptions): Promise<WasmLoader>;
+export declare function resetGlobalLoader(): void;

package/dist/wasm/node-byte-source.d.ts

@@ -0,0 +1 @@
+export declare function nodeByteSource(name: string): Promise<Uint8Array>;

package/dist/wasm/region-allocator.d.ts

@@ -0,0 +1,23 @@
+import type { RegionDescriptor, RegionBounds, RegionUsage } from './wasm-types.js';
+export declare class RegionAllocator {
+    memory: WebAssembly.Memory;
+    regionSize: number;
+    regions: RegionDescriptor[];
+    totalAllocated: number;
+    stagingOffset: number;
+    dataOffset: number;
+    dataBaseOffset: number;
+    constructor(memory: WebAssembly.Memory, regionSize: number);
+    addRegion(): number;
+    alloc(regionId: number, bytes: number): number;
+    reset(regionId: number): void;
+    getRegionBounds(regionId: number): RegionBounds;
+    getRegionUsage(regionId: number): RegionUsage;
+    regionCount(): number;
+    _growRegion(regionId: number, needed: number): void;
+    allocData(bytes: number): number;
+    resetData(): void;
+    allocStaging(bytes: number): number;
+    resetStaging(): void;
+    _ensureMemory(requiredBytes: number): void;
+}

package/dist/wasm/register-kernels.d.ts

@@ -0,0 +1 @@
+export declare function registerAllKernels(): void;

package/dist/wasm/wasm-loader-base.d.ts

@@ -0,0 +1,33 @@
+import type { RegionAllocatorLike, TypedArrayCtor } from './wasm-types.js';
+export declare const WASM_PAGE_SIZE = 65536;
+export declare const INITIAL_PAGES = 256;
+export declare const MAX_PAGES = 16384;
+export declare abstract class WasmLoaderBase {
+    memory: WebAssembly.Memory | null;
+    instances: Map<string, WebAssembly.Instance>;
+    modules: Map<string, WebAssembly.Module>;
+    moduleBytes: Map<string, Uint8Array>;
+    bumpOffset: number;
+    regionAllocator: RegionAllocatorLike | null;
+    shared: boolean;
+    constructor();
+    abstract init(): Promise<void>;
+    initRegions(regionSize: number): RegionAllocatorLike;
+    fetchModuleBytes(_name: string): Promise<Uint8Array>;
+    loadModule(name: string): Promise<WebAssembly.Instance>;
+    getModule(name: string): WebAssembly.Module | null;
+    getModuleBytes(name: string): Uint8Array | null;
+    alloc(bytes: number): number;
+    reset(): void;
+    getBuffer(): ArrayBufferLike;
+    isShared(): boolean;
+    isWasmBacked(data: Int32Array | Float64Array): boolean;
+    allocTypedArray<T extends Int32Array | Float64Array | Uint32Array | Uint8Array>(TypedArrayCtor: TypedArrayCtor<T>, length: number): T | null;
+    resolveDataPtr(data: Int32Array | Float64Array, byteWidth: number): number;
+    writeI32Array(data: Int32Array, ptr: number): void;
+    writeF64Array(data: Float64Array, ptr: number): void;
+    readI32Array(ptr: number, length: number): Int32Array;
+    readF64Array(ptr: number, length: number): Float64Array;
+    readF64(ptr: number): number;
+    readU32Array(ptr: number, length: number): Uint32Array;
+}

package/dist/wasm/wasm-types.d.ts

@@ -0,0 +1,103 @@
+export type WasmKernelFn = (...args: number[]) => number;
+export interface WasmExports extends WebAssembly.Exports {
+    readonly memory: WebAssembly.Memory;
+    readonly filterEqI32: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterLtI32: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterGtI32: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterLeI32: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterGeI32: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterBetweenI32: (dataPtr: number, selVecPtr: number, count: number, low: number, high: number) => number;
+    readonly filterEqF64: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterLtF64: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterGtF64: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterLeF64: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterGeF64: (dataPtr: number, selVecPtr: number, count: number, value: number) => number;
+    readonly filterBetweenF64: (dataPtr: number, selVecPtr: number, count: number, low: number, high: number) => number;
+    readonly sumI32: (dataPtr: number, count: number) => number;
+    readonly sumF64: (dataPtr: number, count: number) => number;
+    readonly minI32: (dataPtr: number, count: number) => number;
+    readonly maxI32: (dataPtr: number, count: number) => number;
+    readonly minF64: (dataPtr: number, count: number) => number;
+    readonly maxF64: (dataPtr: number, count: number) => number;
+    readonly vecAddF64: (aPtr: number, bPtr: number, outPtr: number, count: number) => void;
+    readonly vecSubF64: (aPtr: number, bPtr: number, outPtr: number, count: number) => void;
+    readonly vecMulF64: (aPtr: number, bPtr: number, outPtr: number, count: number) => void;
+    readonly vecDivF64: (aPtr: number, bPtr: number, outPtr: number, count: number) => void;
+    readonly scalarAddF64: (dataPtr: number, scalar: number, outPtr: number, count: number) => void;
+    readonly scalarSubF64: (dataPtr: number, scalar: number, outPtr: number, count: number) => void;
+    readonly scalarMulF64: (dataPtr: number, scalar: number, outPtr: number, count: number) => void;
+    readonly scalarDivF64: (dataPtr: number, scalar: number, outPtr: number, count: number) => void;
+    readonly scalarSubRevF64: (scalar: number, dataPtr: number, outPtr: number, count: number) => void;
+    readonly scalarDivRevF64: (scalar: number, dataPtr: number, outPtr: number, count: number) => void;
+    readonly widenI32ToF64: (dataPtr: number, outPtr: number, count: number) => void;
+    readonly negF64: (dataPtr: number, outPtr: number, count: number) => void;
+    readonly countBitmapBits: (bitmapPtr: number, bitCount: number) => number;
+}
+export type WasmModuleName = 'core';
+export interface RegionDescriptor {
+    id: number;
+    start: number;
+    capacity: number;
+    offset: number;
+}
+export interface RegionBounds {
+    start: number;
+    end: number;
+}
+export interface RegionUsage {
+    used: number;
+    capacity: number;
+    free: number;
+}
+export interface RegionAllocatorLike {
+    readonly memory: WebAssembly.Memory;
+    readonly regionSize: number;
+    addRegion(): number;
+    alloc(regionId: number, bytes: number): number;
+    reset(regionId: number): void;
+    getRegionBounds(regionId: number): RegionBounds;
+    getRegionUsage(regionId: number): RegionUsage;
+    regionCount(): number;
+    allocData(bytes: number): number;
+    resetData(): void;
+    allocStaging(bytes: number): number;
+    resetStaging(): void;
+}
+export type TypedArrayCtor<T extends Int32Array | Float64Array | Uint32Array | Uint8Array> = {
+    new (buffer: ArrayBufferLike, byteOffset: number, length: number): T;
+    readonly BYTES_PER_ELEMENT: number;
+};
+export interface WasmLoaderLike {
+    memory: WebAssembly.Memory | null;
+    loadModule(name: string): Promise<WebAssembly.Instance>;
+    getModule(name: string): WebAssembly.Module | null;
+    getModuleBytes(name: string): Uint8Array | null;
+    alloc(bytes: number): number;
+    reset(): void;
+    getBuffer(): ArrayBufferLike;
+    isShared(): boolean;
+    isWasmBacked(data: Int32Array | Float64Array): boolean;
+    resolveDataPtr(data: Int32Array | Float64Array, byteWidth: number): number;
+    writeI32Array(data: Int32Array, ptr: number): void;
+    writeF64Array(data: Float64Array, ptr: number): void;
+    readI32Array(ptr: number, length: number): Int32Array;
+    readF64Array(ptr: number, length: number): Float64Array;
+    readF64(ptr: number): number;
+    readU32Array(ptr: number, length: number): Uint32Array;
+}
+export type ByteSource = (name: string) => Promise<Uint8Array> | Uint8Array;
+export type WasmVecData = Float64Array | Int32Array;
+export type WasmKernelArg = Float64Array | Int32Array | Uint8Array | number;
+export type WasmKernelResult = Float64Array | Int32Array | Uint32Array | number;
+export type WasmKernel = (a: WasmVecData | number, b?: WasmVecData | number) => WasmVecData | Promise<WasmVecData>;
+export type RegisterableKernel = {
+    register(a: WasmKernelArg, b?: WasmKernelArg, c?: WasmKernelArg): Promise<WasmKernelResult> | WasmKernelResult;
+}['register'];
+export interface WasmDispatchRegistry {
+    readonly kernels: Map<string, WasmKernel>;
+    register(operation: string, dataType: string, kernel: RegisterableKernel): void;
+    lookup(operation: string, dataType: string): WasmKernel | null;
+    has(operation: string, dataType: string): boolean;
+    setInstance(instance: WebAssembly.Instance, memory: WebAssembly.Memory): void;
+    listKernels(): string[];
+}