@soulcraft/cor 3.0.0-rc.1

package/dist/native/NativeRoaringBitmap32.js

@@ -0,0 +1,221 @@
+/**
+ * Native Roaring Bitmap - Drop-in replacement for roaring-wasm
+ *
+ * Wraps the native Rust CRoaring module to provide the EXACT same API
+ * as roaring-wasm's RoaringBitmap32.
+ *
+ * CRoaring portable serialization format is binary-identical to
+ * roaring-wasm's portable format. Existing persisted indexes are
+ * readable without migration.
+ *
+ * All roaring bitmap consumers import from src/utils/roaring/index.ts —
+ * that module swaps the implementation to use this native wrapper.
+ */
+import { loadNativeModule } from './index.js';
+// Lazily loaded native module
+let _native = null;
+function getNative() {
+    if (!_native) {
+        _native = loadNativeModule();
+    }
+    return _native;
+}
+/**
+ * RoaringBitmap32 - native drop-in replacement for roaring-wasm.
+ *
+ * Same API surface:
+ *   Instance: .size, .isEmpty, .add(u32), .delete(u32), .tryAdd(u32), .has(u32),
+ *             .toArray(), .serialize('portable'), .deserialize(buf, 'portable'),
+ *             .getSerializationSizeInBytes('portable'), [Symbol.iterator]
+ *   Static:   RoaringBitmap32.and(a, b), .or(a, b), .orMany(arr)
+ *   Constructors: new RoaringBitmap32(), new RoaringBitmap32([1,2,3])
+ */
+export class RoaringBitmap32 {
+    inner;
+    constructor(values) {
+        const native = getNative();
+        if (values) {
+            const arr = Array.isArray(values) ? values : Array.from(values);
+            this.inner = new native.NativeRoaringBitmap32(arr);
+        }
+        else {
+            this.inner = new native.NativeRoaringBitmap32();
+        }
+    }
+    /** Create from an existing native instance (internal use) */
+    static fromNative(inner) {
+        const bm = Object.create(RoaringBitmap32.prototype);
+        bm.inner = inner;
+        return bm;
+    }
+    // =========================================================================
+    // Instance properties
+    // =========================================================================
+    /** Number of values in the bitmap */
+    get size() {
+        return this.inner.size;
+    }
+    /** Whether the bitmap is empty */
+    get isEmpty() {
+        return this.inner.isEmpty;
+    }
+    // =========================================================================
+    // Instance methods
+    // =========================================================================
+    /** Add a value to the bitmap */
+    add(value) {
+        this.inner.add(value);
+    }
+    /** Remove a value from the bitmap */
+    delete(value) {
+        this.inner.delete(value);
+    }
+    /** Add a value, return true if newly added */
+    tryAdd(value) {
+        return this.inner.tryAdd(value);
+    }
+    /** Check if the bitmap contains a value */
+    has(value) {
+        return this.inner.has(value);
+    }
+    /** Convert to array of u32 values (sorted) */
+    toArray() {
+        return this.inner.toArray();
+    }
+    /**
+     * Serialize to portable format.
+     * The format parameter is accepted for roaring-wasm API compatibility
+     * but native always uses portable format (binary-identical).
+     */
+    serialize(_format) {
+        return this.inner.serialize();
+    }
+    /**
+     * Deserialize from portable format buffer (instance method).
+     * Replaces the contents of this bitmap with the deserialized data.
+     * Matches roaring-wasm instance method API.
+     */
+    deserialize(buffer, _format) {
+        const native = getNative();
+        const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+        this.inner = native.NativeRoaringBitmap32.deserialize(buf);
+    }
+    /**
+     * Get serialization size in bytes.
+     * The format parameter is accepted for roaring-wasm API compatibility.
+     */
+    getSerializationSizeInBytes(_format) {
+        return this.inner.serializationSizeInBytes();
+    }
+    /** Get minimum value (null if empty — napi maps Rust None → null, not undefined). */
+    minimum() {
+        return this.inner.minimum();
+    }
+    /** Get maximum value (null if empty — napi maps Rust None → null, not undefined). */
+    maximum() {
+        return this.inner.maximum();
+    }
+    /** Iterator support for for...of loops */
+    *[Symbol.iterator]() {
+        const arr = this.inner.toArray();
+        for (const v of arr) {
+            yield v;
+        }
+    }
+    // =========================================================================
+    // Static methods (match roaring-wasm static API)
+    // =========================================================================
+    /** Deserialize from portable format buffer */
+    static deserialize(buffer, _format) {
+        const native = getNative();
+        const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+        const inner = native.NativeRoaringBitmap32.deserialize(buf);
+        return RoaringBitmap32.fromNative(inner);
+    }
+    /** Compute intersection (AND) of two bitmaps */
+    static and(a, b) {
+        const native = getNative();
+        const inner = native.NativeRoaringBitmap32.and(a.inner, b.inner);
+        return RoaringBitmap32.fromNative(inner);
+    }
+    /** Compute union (OR) of two bitmaps */
+    static or(a, b) {
+        const native = getNative();
+        const inner = native.NativeRoaringBitmap32.or(a.inner, b.inner);
+        return RoaringBitmap32.fromNative(inner);
+    }
+    /** Compute union (OR) of multiple bitmaps */
+    static orMany(bitmaps) {
+        if (bitmaps.length === 0) {
+            return new RoaringBitmap32();
+        }
+        if (bitmaps.length === 1) {
+            return bitmaps[0];
+        }
+        const native = getNative();
+        const inner = native.NativeRoaringBitmap32.orMany(bitmaps.map(bm => bm.inner));
+        return RoaringBitmap32.fromNative(inner);
+    }
+    /** Compute difference (AND NOT) */
+    static andNot(a, b) {
+        const native = getNative();
+        const inner = native.NativeRoaringBitmap32.andNot(a.inner, b.inner);
+        return RoaringBitmap32.fromNative(inner);
+    }
+    /** Compute symmetric difference (XOR) */
+    static xor(a, b) {
+        const native = getNative();
+        const inner = native.NativeRoaringBitmap32.xor(a.inner, b.inner);
+        return RoaringBitmap32.fromNative(inner);
+    }
+}
+/**
+ * RoaringBitmap32Iterator - for roaring-wasm API compatibility.
+ * Uses the native toArray() under the hood.
+ */
+export class RoaringBitmap32Iterator {
+    values;
+    index = 0;
+    constructor(bitmap) {
+        this.values = bitmap.toArray();
+    }
+    next() {
+        if (this.index < this.values.length) {
+            return { value: this.values[this.index++], done: false };
+        }
+        return { value: undefined, done: true };
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+/**
+ * roaringLibraryInitialize - no-op for native (ready at load time).
+ * Kept for API compatibility with roaring-wasm.
+ */
+export async function roaringLibraryInitialize() {
+    // Native module is ready at load time - no WASM compilation needed
+    return Promise.resolve();
+}
+/**
+ * roaringLibraryIsReady - always true for native.
+ * Kept for API compatibility with roaring-wasm.
+ */
+export function roaringLibraryIsReady() {
+    return true;
+}
+/**
+ * Serialization format enum - for API compatibility with roaring-wasm.
+ */
+export const SerializationFormat = {
+    portable: 'portable',
+    croaring: 'croaring',
+};
+/**
+ * Deserialization format enum - for API compatibility with roaring-wasm.
+ */
+export const DeserializationFormat = {
+    portable: 'portable',
+    croaring: 'croaring',
+};
+//# sourceMappingURL=NativeRoaringBitmap32.js.map

package/dist/native/ffi.d.ts

@@ -0,0 +1,20 @@
+/**
+ * bun:ffi bindings loader
+ *
+ * Loads the native module via bun:ffi + dlopen for bun --compile on Linux.
+ * The .so file is embedded in the compiled binary via static import.
+ *
+ * This is the PREFERRED production deployment path:
+ *   bun build --compile my-app.ts --outfile my-app
+ *
+ * For development and other platforms, use napi.ts instead.
+ */
+import type { NativeBindings } from './types.js';
+/**
+ * Load the native module via bun:ffi.
+ *
+ * Only available on Linux with Bun.
+ * Falls back to napi-rs on other platforms or if FFI loading fails.
+ */
+export declare function loadViaFFI(): NativeBindings;
+//# sourceMappingURL=ffi.d.ts.map

package/dist/native/ffi.js

@@ -0,0 +1,48 @@
+/**
+ * bun:ffi bindings loader
+ *
+ * Loads the native module via bun:ffi + dlopen for bun --compile on Linux.
+ * The .so file is embedded in the compiled binary via static import.
+ *
+ * This is the PREFERRED production deployment path:
+ *   bun build --compile my-app.ts --outfile my-app
+ *
+ * For development and other platforms, use napi.ts instead.
+ */
+/**
+ * Load the native module via bun:ffi.
+ *
+ * Only available on Linux with Bun.
+ * Falls back to napi-rs on other platforms or if FFI loading fails.
+ */
+export function loadViaFFI() {
+    // bun:ffi is only available in Bun
+    if (typeof Bun === 'undefined') {
+        throw new Error('bun:ffi is only available in Bun runtime');
+    }
+    if (process.platform !== 'linux') {
+        throw new Error('bun:ffi native loading is only supported on Linux');
+    }
+    // Dynamic import of bun:ffi — this is a Bun built-in
+    // The .so file path is resolved at build time for bun --compile
+    // For runtime Bun, it falls back to the local build path
+    throw new Error('bun:ffi loader not yet implemented. ' +
+        'Requires native build output (libbrainy_native.so). ' +
+        'Use napi-rs loader instead.');
+    // Future implementation:
+    // import nativeLib from '../../native/target/release/libbrainy_native.so' with { type: 'file' }
+    // import { dlopen, FFIType } from 'bun:ffi'
+    //
+    // const lib = dlopen(nativeLib, {
+    //   brainy_engine_create: { returns: FFIType.ptr },
+    //   brainy_engine_load: { args: [...], returns: FFIType.i32 },
+    //   brainy_engine_embed: { args: [...], returns: FFIType.ptr },
+    //   brainy_roaring_create: { returns: FFIType.ptr },
+    //   brainy_roaring_add: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.void },
+    //   brainy_cosine_distance: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.f64 },
+    //   // ... etc
+    // })
+    //
+    // return wrapFFIAsNativeBindings(lib)
+}
+//# sourceMappingURL=ffi.js.map

package/dist/native/idMapperTestSupport.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @module native/idMapperTestSupport
+ * @description Test helpers for the #72 Phase C consolidation, where the
+ * metadata index's canonical UUID ↔ entity-int allocator became the shared
+ * mmap `BinaryIdMapper` (injected via `setIdMapper`) instead of the resident
+ * JSON `EntityIdMapperCore` (seeded via the deleted `loadEntityIdMapper`).
+ *
+ * Tests that drive the raw `NativeMetadataIndex` napi must now inject a real
+ * temp-file `BinaryIdMapper` and address entities by REAL UUIDs (the binary
+ * mapper is UUID-only — it parses every key into 16 bytes). These helpers
+ * provide both, plus a deterministic UUID generator and the UUID→Buffer
+ * encoding the mapper's `remove`/lookup surface takes.
+ *
+ * NOTE: the binary mapper assigns ints sequentially from 0 — there is no
+ * "seed the cursor to a high int" hook the way the old JSON envelope had.
+ * The u64-VALUE behaviour (ints above `u32::MAX`) is therefore covered at
+ * the diskann crate level (`binary_id_mapper` unit tests); these helpers
+ * exercise the metadata index's ROUTING through a u32- or u64-mode mapper.
+ */
+import type { EntityIdMapperLike } from '../utils/columnStoreTypes.js';
+/**
+ * Create a fresh temp-file `BinaryIdMapper` in the requested id space.
+ *
+ * @param native - The loaded native module (`loadNativeModule()`).
+ * @param idSpace - `'u32'` or `'u64'`.
+ * @returns The native mapper instance and its temp directory.
+ */
+export declare function createTestBinaryMapper(native: any, idSpace: 'u32' | 'u64'): {
+    mapper: any;
+    dir: string;
+};
+/**
+ * Create a temp-file `BinaryIdMapper` and inject it into a raw
+ * `NativeMetadataIndex` as its canonical allocator.
+ *
+ * @returns The mapper (kept so a test can drive it directly, e.g. to
+ *   tombstone mappings for the unmapped-int-window case) and its temp dir.
+ */
+export declare function injectTestMapper(native: any, idx: any, idSpace: 'u32' | 'u64'): {
+    mapper: any;
+    dir: string;
+};
+/**
+ * Deterministic, valid v4-shaped UUID for test entity `n`. The variant /
+ * version nibbles are fixed; `n` is encoded into the trailing 12 hex digits,
+ * so distinct `n` always yield distinct UUIDs.
+ */
+export declare function testUuid(n: number): string;
+/** Encode a canonical UUID string to the 16-byte Buffer the mapper takes. */
+export declare function uuidToBuffer(uuid: string): Buffer;
+/**
+ * A pure in-memory {@link EntityIdMapperLike} for unit tests that drive a
+ * `NativeDiskAnnWrapper` in isolation (no brainy / no metadata index).
+ *
+ * #72 Phase A+B made the wrapper resolve `slot ↔ uuid` through the
+ * canonical entity-id mapper + the off-heap mmap slotmaps instead of
+ * resident JS maps, so a standalone wrapper now needs a mapper injected
+ * via its `mapperResolver` option. This stub assigns 0-based sequential
+ * ints (matching the production `BinaryIdMapper`'s base offset) to
+ * arbitrary string ids, so existing tests can keep using friendly ids
+ * like `id-0` without minting real UUIDs. Reuse ONE instance across a
+ * cold-restart (w1 → w2) to model the production mapper's mmap durability.
+ *
+ * @returns A fresh, independent mapper.
+ */
+export declare function inMemoryEntityIdMapper(): EntityIdMapperLike;
+//# sourceMappingURL=idMapperTestSupport.d.ts.map

package/dist/native/idMapperTestSupport.js

@@ -0,0 +1,112 @@
+/**
+ * @module native/idMapperTestSupport
+ * @description Test helpers for the #72 Phase C consolidation, where the
+ * metadata index's canonical UUID ↔ entity-int allocator became the shared
+ * mmap `BinaryIdMapper` (injected via `setIdMapper`) instead of the resident
+ * JSON `EntityIdMapperCore` (seeded via the deleted `loadEntityIdMapper`).
+ *
+ * Tests that drive the raw `NativeMetadataIndex` napi must now inject a real
+ * temp-file `BinaryIdMapper` and address entities by REAL UUIDs (the binary
+ * mapper is UUID-only — it parses every key into 16 bytes). These helpers
+ * provide both, plus a deterministic UUID generator and the UUID→Buffer
+ * encoding the mapper's `remove`/lookup surface takes.
+ *
+ * NOTE: the binary mapper assigns ints sequentially from 0 — there is no
+ * "seed the cursor to a high int" hook the way the old JSON envelope had.
+ * The u64-VALUE behaviour (ints above `u32::MAX`) is therefore covered at
+ * the diskann crate level (`binary_id_mapper` unit tests); these helpers
+ * exercise the metadata index's ROUTING through a u32- or u64-mode mapper.
+ */
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/** 64 MB sparse files — plenty for a unit-test corpus, tiny on disk. */
+const TEST_FILE_SIZE = BigInt(64 * 1024 * 1024);
+/**
+ * Create a fresh temp-file `BinaryIdMapper` in the requested id space.
+ *
+ * @param native - The loaded native module (`loadNativeModule()`).
+ * @param idSpace - `'u32'` or `'u64'`.
+ * @returns The native mapper instance and its temp directory.
+ */
+export function createTestBinaryMapper(native, idSpace) {
+    const dir = mkdtempSync(join(tmpdir(), 'cor-idmap-'));
+    const mapper = native.NativeBinaryIdMapper.create({
+        uuidToIntPath: join(dir, 'uuid_to_int.mkv'),
+        intToUuidPath: join(dir, 'int_to_uuid.bin'),
+        intToUuidSize: TEST_FILE_SIZE,
+        uuidToIntSize: TEST_FILE_SIZE,
+        bucketCapacity: 16,
+        maxGlobalDepth: 18,
+        idSpace,
+    });
+    return { mapper, dir };
+}
+/**
+ * Create a temp-file `BinaryIdMapper` and inject it into a raw
+ * `NativeMetadataIndex` as its canonical allocator.
+ *
+ * @returns The mapper (kept so a test can drive it directly, e.g. to
+ *   tombstone mappings for the unmapped-int-window case) and its temp dir.
+ */
+export function injectTestMapper(native, idx, idSpace) {
+    const handle = createTestBinaryMapper(native, idSpace);
+    idx.setIdMapper(handle.mapper);
+    return handle;
+}
+/**
+ * Deterministic, valid v4-shaped UUID for test entity `n`. The variant /
+ * version nibbles are fixed; `n` is encoded into the trailing 12 hex digits,
+ * so distinct `n` always yield distinct UUIDs.
+ */
+export function testUuid(n) {
+    const tail = n.toString(16).padStart(12, '0');
+    return `00000000-0000-4000-8000-${tail}`;
+}
+/** Encode a canonical UUID string to the 16-byte Buffer the mapper takes. */
+export function uuidToBuffer(uuid) {
+    return Buffer.from(uuid.replace(/-/g, ''), 'hex');
+}
+/**
+ * A pure in-memory {@link EntityIdMapperLike} for unit tests that drive a
+ * `NativeDiskAnnWrapper` in isolation (no brainy / no metadata index).
+ *
+ * #72 Phase A+B made the wrapper resolve `slot ↔ uuid` through the
+ * canonical entity-id mapper + the off-heap mmap slotmaps instead of
+ * resident JS maps, so a standalone wrapper now needs a mapper injected
+ * via its `mapperResolver` option. This stub assigns 0-based sequential
+ * ints (matching the production `BinaryIdMapper`'s base offset) to
+ * arbitrary string ids, so existing tests can keep using friendly ids
+ * like `id-0` without minting real UUIDs. Reuse ONE instance across a
+ * cold-restart (w1 → w2) to model the production mapper's mmap durability.
+ *
+ * @returns A fresh, independent mapper.
+ */
+export function inMemoryEntityIdMapper() {
+    const intByUuid = new Map();
+    const uuidByInt = new Map();
+    let next = 0;
+    return {
+        getUuid: (intId) => uuidByInt.get(intId),
+        getInt: (uuid) => intByUuid.get(uuid),
+        getOrAssign: (uuid) => {
+            let i = intByUuid.get(uuid);
+            if (i === undefined) {
+                i = next++;
+                intByUuid.set(uuid, i);
+                uuidByInt.set(i, uuid);
+            }
+            return i;
+        },
+        intsIterableToUuids: (ints) => {
+            const out = [];
+            for (const i of ints) {
+                const u = uuidByInt.get(i);
+                if (u !== undefined)
+                    out.push(u);
+            }
+            return out;
+        },
+    };
+}
+//# sourceMappingURL=idMapperTestSupport.js.map

package/dist/native/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Native Module - Public API
+ *
+ * Auto-detects the best loading strategy:
+ * 1. Bun --compile on Linux: bun:ffi with embedded .so (fastest)
+ * 2. All platforms: napi-rs .node file (universal)
+ *
+ * Exports the unified NativeBindings interface that all consumers use.
+ */
+import type { NativeBindings } from './types.js';
+/**
+ * Open-file-limit raise result, captured once when the native module
+ * first loads. `null` until then (or if the platform/loader doesn't
+ * expose the call).
+ */
+export interface OpenFileLimitInfo {
+    softBefore: number;
+    softAfter: number;
+    hard: number;
+    raised: boolean;
+    /** Linux `vm.max_map_count` (0 if unavailable). A process can't raise
+     * this — the deployment must (docker `--sysctl` / host sysctl). */
+    vmMaxMapCount: number;
+}
+/**
+ * Diagnostic accessor for the startup open-file-limit raise. Returns
+ * `null` until the native module has loaded.
+ */
+export declare function getOpenFileLimitInfo(): OpenFileLimitInfo | null;
+/**
+ * Load the native module using the best available strategy.
+ *
+ * Returns a cached reference on subsequent calls.
+ *
+ * Loading priority:
+ * 1. Bun --compile on Linux → bun:ffi + embedded .so
+ * 2. All platforms → napi-rs .node file
+ */
+export declare function loadNativeModule(): NativeBindings;
+/**
+ * Check if the native module is available.
+ * Does not throw - returns false if loading fails.
+ */
+export declare function isNativeAvailable(): boolean;
+export type { NativeBindings, NativeEmbeddingEngineInstance, NativeRoaringBitmap32Instance, EmbeddingResult, EngineStats, DeviceInfo, } from './types.js';
+export { MODEL_CONSTANTS } from './types.js';
+export { NativeEmbeddingEngine, nativeEmbeddingEngine, cosineSimilarity, } from './NativeEmbeddingEngine.js';
+export { RoaringBitmap32, RoaringBitmap32Iterator, roaringLibraryInitialize, roaringLibraryIsReady, SerializationFormat, DeserializationFormat, } from './NativeRoaringBitmap32.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/native/index.js

@@ -0,0 +1,87 @@
+/**
+ * Native Module - Public API
+ *
+ * Auto-detects the best loading strategy:
+ * 1. Bun --compile on Linux: bun:ffi with embedded .so (fastest)
+ * 2. All platforms: napi-rs .node file (universal)
+ *
+ * Exports the unified NativeBindings interface that all consumers use.
+ */
+import { loadViaNapi } from './napi.js';
+import { loadViaFFI } from './ffi.js';
+// Cached module reference
+let cachedModule = null;
+let fileLimitInfo = null;
+/**
+ * Raise the process's soft open-file limit toward its hard cap, once.
+ * A per-tenant brain pool runs many brains in one process; the default
+ * Linux soft `RLIMIT_NOFILE` (often 1024) caps tenants long before RAM.
+ * Raising soft→hard needs no privilege and is safe. Best-effort — never
+ * blocks module load; the hard cap + `vm.max_map_count` still need the
+ * deployment to set them (see ADR-004).
+ */
+function raiseFileLimitOnce(mod) {
+    if (fileLimitInfo !== null)
+        return;
+    try {
+        const fn = mod.raiseOpenFileLimit;
+        fileLimitInfo = typeof fn === 'function' ? fn() : null;
+    }
+    catch {
+        fileLimitInfo = null;
+    }
+}
+/**
+ * Diagnostic accessor for the startup open-file-limit raise. Returns
+ * `null` until the native module has loaded.
+ */
+export function getOpenFileLimitInfo() {
+    return fileLimitInfo;
+}
+/**
+ * Load the native module using the best available strategy.
+ *
+ * Returns a cached reference on subsequent calls.
+ *
+ * Loading priority:
+ * 1. Bun --compile on Linux → bun:ffi + embedded .so
+ * 2. All platforms → napi-rs .node file
+ */
+export function loadNativeModule() {
+    if (cachedModule) {
+        return cachedModule;
+    }
+    // Strategy 1: Bun --compile on Linux (bun:ffi)
+    if (process.platform === 'linux' && typeof Bun !== 'undefined') {
+        try {
+            cachedModule = loadViaFFI();
+            raiseFileLimitOnce(cachedModule);
+            return cachedModule;
+        }
+        catch {
+            // Fall through to napi-rs (Bun runtime, not compiled binary)
+        }
+    }
+    // Strategy 2: All platforms (napi-rs)
+    cachedModule = loadViaNapi();
+    raiseFileLimitOnce(cachedModule);
+    return cachedModule;
+}
+/**
+ * Check if the native module is available.
+ * Does not throw - returns false if loading fails.
+ */
+export function isNativeAvailable() {
+    try {
+        loadNativeModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { MODEL_CONSTANTS } from './types.js';
+// Re-export engine and roaring wrappers
+export { NativeEmbeddingEngine, nativeEmbeddingEngine, cosineSimilarity, } from './NativeEmbeddingEngine.js';
+export { RoaringBitmap32, RoaringBitmap32Iterator, roaringLibraryInitialize, roaringLibraryIsReady, SerializationFormat, DeserializationFormat, } from './NativeRoaringBitmap32.js';
+//# sourceMappingURL=index.js.map

package/dist/native/napi.d.ts

@@ -0,0 +1,21 @@
+/**
+ * napi-rs bindings loader
+ *
+ * Loads the native module via napi-rs .node files.
+ * Works with: Node.js, Bun runtime, Bun --compile (all platforms).
+ *
+ * Resolution order:
+ * 1. Bundled platform binary: native/brainy-native.{platform-key}.node (shipped in npm package)
+ * 2. Local dev build: native/brainy-native.node (for development, no platform suffix)
+ * 3. Clear error with supported platforms list
+ */
+import type { NativeBindings } from './types.js';
+/**
+ * Load the native module via napi-rs.
+ *
+ * Tries multiple resolution strategies:
+ * 1. Bundled platform binary (native/brainy-native.{platform-key}.node)
+ * 2. Local dev build (native/brainy-native.node)
+ */
+export declare function loadViaNapi(): NativeBindings;
+//# sourceMappingURL=napi.d.ts.map