@sochdb/sochdb 0.4.0

package/dist/esm/embedded/database.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * Embedded Database - FFI Mode
+ *
+ * Direct FFI access to SochDB native library.
+ * No server required - similar to Python SDK's Database class.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedDatabase = void 0;
+const errors_1 = require("../errors");
+const bindings_1 = require("./ffi/bindings");
+const transaction_1 = require("./transaction");
+/**
+ * Embedded Database using direct FFI
+ *
+ * @example
+ * ```typescript
+ * import { EmbeddedDatabase } from '@sushanth/sochdb';
+ *
+ * const db = await EmbeddedDatabase.open('./mydb');
+ * await db.put(Buffer.from('key'), Buffer.from('value'));
+ * const value = await db.get(Buffer.from('key'));
+ * await db.close();
+ * ```
+ */
+class EmbeddedDatabase {
+    handle;
+    bindings;
+    closed = false;
+    path;
+    constructor(path, handle) {
+        this.path = path;
+        this.handle = handle;
+        this.bindings = bindings_1.NativeBindings.getInstance();
+    }
+    /**
+     * Open a database at the specified path
+     *
+     * @param path - Path to database directory
+     * @param config - Optional configuration
+     * @returns EmbeddedDatabase instance
+     */
+    static open(path, config) {
+        const bindings = bindings_1.NativeBindings.getInstance();
+        let handle;
+        if (config) {
+            const cConfig = {
+                wal_enabled: config.walEnabled ?? false,
+                wal_enabled_set: config.walEnabled !== undefined,
+                sync_mode: config.syncMode === 'full' ? 2 : (config.syncMode === 'normal' ? 1 : 0),
+                sync_mode_set: config.syncMode !== undefined,
+                memtable_size_bytes: BigInt(config.memtableSizeBytes ?? 0),
+                group_commit: config.groupCommit ?? false,
+                group_commit_set: config.groupCommit !== undefined,
+                default_index_policy: 1, // Default to Balanced
+                default_index_policy_set: false
+            };
+            handle = bindings.sochdb_open_with_config(path, cConfig);
+        }
+        else {
+            handle = bindings.sochdb_open(path);
+        }
+        if (!handle) {
+            throw new errors_1.DatabaseError(`Failed to open database at ${path}`);
+        }
+        return new EmbeddedDatabase(path, handle);
+    }
+    /**
+     * Put a key-value pair (auto-transaction)
+     */
+    async put(key, value) {
+        this.ensureOpen();
+        const txn = this.transaction();
+        try {
+            await txn.put(key, value);
+            await txn.commit();
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Get a value by key (auto-transaction)
+     */
+    async get(key) {
+        this.ensureOpen();
+        const txn = this.transaction();
+        try {
+            const value = await txn.get(key);
+            await txn.commit();
+            return value;
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Delete a key (auto-transaction)
+     */
+    async delete(key) {
+        this.ensureOpen();
+        const txn = this.transaction();
+        try {
+            await txn.delete(key);
+            await txn.commit();
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Put value at path (auto-transaction)
+     */
+    async putPath(path, value) {
+        this.ensureOpen();
+        const txn = this.transaction();
+        try {
+            await txn.putPath(path, value);
+            await txn.commit();
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Get value at path (auto-transaction)
+     */
+    async getPath(path) {
+        this.ensureOpen();
+        const txn = this.transaction();
+        try {
+            const value = await txn.getPath(path);
+            await txn.commit();
+            return value;
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Scan keys with prefix
+     */
+    async *scanPrefix(prefix) {
+        this.ensureOpen();
+        const txn = this.transaction();
+        try {
+            for await (const entry of txn.scanPrefix(prefix)) {
+                yield entry;
+            }
+            await txn.commit();
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Begin a transaction
+     */
+    transaction() {
+        this.ensureOpen();
+        const txnHandle = this.bindings.sochdb_begin_txn(this.handle);
+        return new transaction_1.EmbeddedTransaction(this, this.handle, txnHandle);
+    }
+    /**
+     * Execute operations within a transaction (with auto-commit/abort)
+     */
+    async withTransaction(fn) {
+        const txn = this.transaction();
+        try {
+            const result = await fn(txn);
+            await txn.commit();
+            return result;
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Force a checkpoint
+     */
+    async checkpoint() {
+        this.ensureOpen();
+        const lsn = this.bindings.sochdb_checkpoint(this.handle);
+        return BigInt(lsn);
+    }
+    /**
+     * Get storage statistics
+     */
+    async stats() {
+        this.ensureOpen();
+        // Returns struct by value (automatically decoded)
+        const stats = this.bindings.sochdb_stats(this.handle);
+        const result = {
+            memtableSizeBytes: BigInt(stats.memtable_size_bytes),
+            walSizeBytes: BigInt(stats.wal_size_bytes),
+            activeTransactions: stats.active_transactions,
+            minActiveSnapshot: BigInt(stats.min_active_snapshot),
+            lastCheckpointLsn: BigInt(stats.last_checkpoint_lsn),
+        };
+        return result;
+    }
+    /**
+     * Close the database
+     */
+    close() {
+        if (!this.closed) {
+            this.bindings.sochdb_close(this.handle);
+            this.closed = true;
+        }
+    }
+    ensureOpen() {
+        if (this.closed) {
+            throw new errors_1.DatabaseError('Database is closed');
+        }
+    }
+    /**
+     * Get internal handle (for transactions)
+     * @internal
+     */
+    getHandle() {
+        return this.handle;
+    }
+    /**
+     * Get bindings instance (for transactions)
+     * @internal
+     */
+    getBindings() {
+        return this.bindings;
+    }
+}
+exports.EmbeddedDatabase = EmbeddedDatabase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"database.js","sourceRoot":"","sources":["../../../src/embedded/database.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Embedded Database - FFI Mode\n * \n * Direct FFI access to SochDB native library.\n * No server required - similar to Python SDK's Database class.\n */\n\nimport { DatabaseError } from '../errors';\nimport { NativeBindings } from './ffi/bindings';\nimport { EmbeddedTransaction } from './transaction';\nimport * as koffi from 'koffi';\n\nexport interface EmbeddedDatabaseConfig {\n    walEnabled?: boolean;\n    syncMode?: 'full' | 'normal' | 'off';\n    memtableSizeBytes?: number;\n    groupCommit?: boolean;\n    indexPolicy?: 'write_optimized' | 'balanced' | 'scan_optimized' | 'append_only';\n}\n\n/**\n * Embedded Database using direct FFI\n * \n * @example\n * ```typescript\n * import { EmbeddedDatabase } from '@sushanth/sochdb';\n * \n * const db = await EmbeddedDatabase.open('./mydb');\n * await db.put(Buffer.from('key'), Buffer.from('value'));\n * const value = await db.get(Buffer.from('key'));\n * await db.close();\n * ```\n */\nexport class EmbeddedDatabase {\n    private handle: any;\n    private bindings: NativeBindings;\n    private closed = false;\n    private path: string;\n\n    private constructor(path: string, handle: any) {\n        this.path = path;\n        this.handle = handle;\n        this.bindings = NativeBindings.getInstance();\n    }\n\n    /**\n     * Open a database at the specified path\n     * \n     * @param path - Path to database directory\n     * @param config - Optional configuration\n     * @returns EmbeddedDatabase instance\n     */\n    static open(path: string, config?: EmbeddedDatabaseConfig): EmbeddedDatabase {\n        const bindings = NativeBindings.getInstance();\n        let handle;\n\n        if (config) {\n            const cConfig = {\n                wal_enabled: config.walEnabled ?? false,\n                wal_enabled_set: config.walEnabled !== undefined,\n                sync_mode: config.syncMode === 'full' ? 2 : (config.syncMode === 'normal' ? 1 : 0),\n                sync_mode_set: config.syncMode !== undefined,\n                memtable_size_bytes: BigInt(config.memtableSizeBytes ?? 0),\n                group_commit: config.groupCommit ?? false,\n                group_commit_set: config.groupCommit !== undefined,\n                default_index_policy: 1, // Default to Balanced\n                default_index_policy_set: false\n            };\n            handle = bindings.sochdb_open_with_config(path, cConfig);\n        } else {\n            handle = bindings.sochdb_open(path);\n        }\n\n        if (!handle) {\n            throw new DatabaseError(`Failed to open database at ${path}`);\n        }\n\n        return new EmbeddedDatabase(path, handle);\n    }\n\n    /**\n     * Put a key-value pair (auto-transaction)\n     */\n    async put(key: Buffer, value: Buffer): Promise<void> {\n        this.ensureOpen();\n\n        const txn = this.transaction();\n        try {\n            await txn.put(key, value);\n            await txn.commit();\n        } catch (error) {\n            await txn.abort();\n            throw error;\n        }\n    }\n\n    /**\n     * Get a value by key (auto-transaction)\n     */\n    async get(key: Buffer): Promise<Buffer | null> {\n        this.ensureOpen();\n\n        const txn = this.transaction();\n        try {\n            const value = await txn.get(key);\n            await txn.commit();\n            return value;\n        } catch (error) {\n            await txn.abort();\n            throw error;\n        }\n    }\n\n    /**\n     * Delete a key (auto-transaction)\n     */\n    async delete(key: Buffer): Promise<void> {\n        this.ensureOpen();\n\n        const txn = this.transaction();\n        try {\n            await txn.delete(key);\n            await txn.commit();\n        } catch (error) {\n            await txn.abort();\n            throw error;\n        }\n    }\n\n    /**\n     * Put value at path (auto-transaction)\n     */\n    async putPath(path: string, value: Buffer): Promise<void> {\n        this.ensureOpen();\n\n        const txn = this.transaction();\n        try {\n            await txn.putPath(path, value);\n            await txn.commit();\n        } catch (error) {\n            await txn.abort();\n            throw error;\n        }\n    }\n\n    /**\n     * Get value at path (auto-transaction)\n     */\n    async getPath(path: string): Promise<Buffer | null> {\n        this.ensureOpen();\n\n        const txn = this.transaction();\n        try {\n            const value = await txn.getPath(path);\n            await txn.commit();\n            return value;\n        } catch (error) {\n            await txn.abort();\n            throw error;\n        }\n    }\n\n    /**\n     * Scan keys with prefix\n     */\n    async *scanPrefix(prefix: Buffer): AsyncGenerator<[Buffer, Buffer]> {\n        this.ensureOpen();\n\n        const txn = this.transaction();\n        try {\n            for await (const entry of txn.scanPrefix(prefix)) {\n                yield entry;\n            }\n            await txn.commit();\n        } catch (error) {\n            await txn.abort();\n            throw error;\n        }\n    }\n\n    /**\n     * Begin a transaction\n     */\n    transaction(): EmbeddedTransaction {\n        this.ensureOpen();\n\n        const txnHandle = this.bindings.sochdb_begin_txn(this.handle);\n        return new EmbeddedTransaction(this, this.handle, txnHandle);\n    }\n\n    /**\n     * Execute operations within a transaction (with auto-commit/abort)\n     */\n    async withTransaction<T>(fn: (txn: EmbeddedTransaction) => Promise<T>): Promise<T> {\n        const txn = this.transaction();\n        try {\n            const result = await fn(txn);\n            await txn.commit();\n            return result;\n        } catch (error) {\n            await txn.abort();\n            throw error;\n        }\n    }\n\n    /**\n     * Force a checkpoint\n     */\n    async checkpoint(): Promise<bigint> {\n        this.ensureOpen();\n        const lsn = this.bindings.sochdb_checkpoint(this.handle);\n        return BigInt(lsn);\n    }\n\n    /**\n     * Get storage statistics\n     */\n    async stats(): Promise<{\n        memtableSizeBytes: bigint;\n        walSizeBytes: bigint;\n        activeTransactions: number;\n        minActiveSnapshot: bigint;\n        lastCheckpointLsn: bigint;\n    }> {\n        this.ensureOpen();\n\n        // Returns struct by value (automatically decoded)\n        const stats = this.bindings.sochdb_stats(this.handle);\n\n        const result = {\n            memtableSizeBytes: BigInt(stats.memtable_size_bytes),\n            walSizeBytes: BigInt(stats.wal_size_bytes),\n            activeTransactions: stats.active_transactions,\n            minActiveSnapshot: BigInt(stats.min_active_snapshot),\n            lastCheckpointLsn: BigInt(stats.last_checkpoint_lsn),\n        };\n\n        return result;\n    }\n\n    /**\n     * Close the database\n     */\n    close(): void {\n        if (!this.closed) {\n            this.bindings.sochdb_close(this.handle);\n            this.closed = true;\n        }\n    }\n\n    private ensureOpen(): void {\n        if (this.closed) {\n            throw new DatabaseError('Database is closed');\n        }\n    }\n\n    /**\n     * Get internal handle (for transactions)\n     * @internal\n     */\n    getHandle(): any {\n        return this.handle;\n    }\n\n    /**\n     * Get bindings instance (for transactions)\n     * @internal\n     */\n    getBindings(): NativeBindings {\n        return this.bindings;\n    }\n}\n"]}

package/dist/esm/embedded/ffi/bindings.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeBindings = void 0;
+const koffi = __importStar(require("koffi"));
+const library_finder_1 = require("./library-finder");
+// Opaque pointer types
+const DatabaseHandle = koffi.pointer('DatabaseHandle', koffi.opaque());
+const IteratorHandle = koffi.pointer('IteratorHandle', koffi.opaque());
+// Structs
+const Stats = koffi.struct('Stats', {
+    memtable_size_bytes: 'size_t',
+    wal_size_bytes: 'size_t',
+    active_transactions: 'uint32',
+    min_active_snapshot: 'uint64',
+    last_checkpoint_lsn: 'uint64'
+});
+const DatabaseConfig = koffi.struct('DatabaseConfig', {
+    wal_enabled: 'bool',
+    wal_enabled_set: 'bool',
+    sync_mode: 'uint8',
+    sync_mode_set: 'bool',
+    memtable_size_bytes: 'uint64',
+    group_commit: 'bool',
+    group_commit_set: 'bool',
+    default_index_policy: 'uint8',
+    default_index_policy_set: 'bool'
+});
+const TxnHandle = koffi.struct('TxnHandle', {
+    txn_id: 'uint64',
+    snapshot_ts: 'uint64'
+});
+const CommitResult = koffi.struct('CommitResult', {
+    commit_ts: 'uint64',
+    error_code: 'int32'
+});
+class NativeBindings {
+    static instance;
+    lib;
+    // FFIs
+    sochdb_open;
+    sochdb_open_with_config;
+    sochdb_close;
+    // Transactional Operations (mapped to base functions)
+    sochdb_begin_txn;
+    sochdb_commit;
+    sochdb_abort;
+    // KV Operations (All take DatabaseHandle AND TxnHandle)
+    // put: (db, txn, key, klen, val, vlen) -> int
+    sochdb_put;
+    // get: (db, txn, key, klen, val_out*, len_out*) -> int
+    sochdb_get;
+    // delete: (db, txn, key, klen) -> int
+    sochdb_delete;
+    // Path Operations
+    sochdb_put_path;
+    sochdb_get_path;
+    // Scanning
+    sochdb_scan_prefix;
+    sochdb_iterator_next;
+    sochdb_iterator_close;
+    // Stats
+    sochdb_stats;
+    sochdb_checkpoint;
+    // Memory
+    sochdb_free_bytes;
+    constructor() {
+        const libPath = (0, library_finder_1.findLibrary)();
+        try {
+            this.lib = koffi.load(libPath);
+        }
+        catch (error) {
+            console.error(`Failed to load SochDB library from ${libPath}:`, error);
+            throw error;
+        }
+        // Initialize bindings
+        // DB Management
+        this.sochdb_open = this.lib.func('sochdb_open', DatabaseHandle, ['string']);
+        this.sochdb_open_with_config = this.lib.func('sochdb_open_with_config', DatabaseHandle, ['string', DatabaseConfig]);
+        this.sochdb_close = this.lib.func('sochdb_close', 'void', [DatabaseHandle]);
+        // Transactions
+        this.sochdb_begin_txn = this.lib.func('sochdb_begin_txn', TxnHandle, [DatabaseHandle]);
+        this.sochdb_commit = this.lib.func('sochdb_commit', CommitResult, [DatabaseHandle, TxnHandle]);
+        this.sochdb_abort = this.lib.func('sochdb_abort', 'int', [DatabaseHandle, TxnHandle]);
+        // KV Operations
+        this.sochdb_put = this.lib.func('sochdb_put', 'int', [DatabaseHandle, TxnHandle, 'uint8*', 'size_t', 'uint8*', 'size_t']);
+        this.sochdb_get = this.lib.func('sochdb_get', 'int', [DatabaseHandle, TxnHandle, 'uint8*', 'size_t', koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t'))]);
+        this.sochdb_delete = this.lib.func('sochdb_delete', 'int', [DatabaseHandle, TxnHandle, 'uint8*', 'size_t']);
+        // Path Operations
+        this.sochdb_put_path = this.lib.func('sochdb_put_path', 'int', [DatabaseHandle, TxnHandle, 'string', 'uint8*', 'size_t']);
+        this.sochdb_get_path = this.lib.func('sochdb_get_path', 'int', [DatabaseHandle, TxnHandle, 'string', koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t'))]);
+        // Scanning
+        this.sochdb_scan_prefix = this.lib.func('sochdb_scan_prefix', IteratorHandle, [DatabaseHandle, TxnHandle, 'uint8*', 'size_t']);
+        this.sochdb_iterator_next = this.lib.func('sochdb_scan_next', 'int', [IteratorHandle, koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t')), koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t'))]);
+        this.sochdb_iterator_close = this.lib.func('sochdb_scan_free', 'void', [IteratorHandle]);
+        // Stats & Checkpoint
+        this.sochdb_stats = this.lib.func('sochdb_stats', Stats, [DatabaseHandle]);
+        this.sochdb_checkpoint = this.lib.func('sochdb_checkpoint', 'int', [DatabaseHandle]);
+        // Memory Management
+        this.sochdb_free_bytes = this.lib.func('sochdb_free_bytes', 'void', ['uint8*', 'size_t']);
+    }
+    static getInstance() {
+        if (!NativeBindings.instance) {
+            NativeBindings.instance = new NativeBindings();
+        }
+        return NativeBindings.instance;
+    }
+}
+exports.NativeBindings = NativeBindings;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bindings.js","sourceRoot":"","sources":["../../../../src/embedded/ffi/bindings.ts"],"names":[],"mappings":"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","sourcesContent":["import * as koffi from 'koffi';\nimport { findLibrary } from './library-finder';\n\n// Opaque pointer types\nconst DatabaseHandle = koffi.pointer('DatabaseHandle', koffi.opaque());\nconst IteratorHandle = koffi.pointer('IteratorHandle', koffi.opaque());\n\n// Structs\nconst Stats = koffi.struct('Stats', {\n    memtable_size_bytes: 'size_t',\n    wal_size_bytes: 'size_t',\n    active_transactions: 'uint32',\n    min_active_snapshot: 'uint64',\n    last_checkpoint_lsn: 'uint64'\n});\n\nconst DatabaseConfig = koffi.struct('DatabaseConfig', {\n    wal_enabled: 'bool',\n    wal_enabled_set: 'bool',\n    sync_mode: 'uint8',\n    sync_mode_set: 'bool',\n    memtable_size_bytes: 'uint64',\n    group_commit: 'bool',\n    group_commit_set: 'bool',\n    default_index_policy: 'uint8',\n    default_index_policy_set: 'bool'\n});\n\nconst TxnHandle = koffi.struct('TxnHandle', {\n    txn_id: 'uint64',\n    snapshot_ts: 'uint64'\n});\n\nconst CommitResult = koffi.struct('CommitResult', {\n    commit_ts: 'uint64',\n    error_code: 'int32'\n});\n\nexport class NativeBindings {\n    private static instance: NativeBindings;\n    private lib: any;\n\n    // FFIs\n    public sochdb_open: any;\n    public sochdb_open_with_config: any;\n    public sochdb_close: any;\n\n    // Transactional Operations (mapped to base functions)\n    public sochdb_begin_txn: any;\n    public sochdb_commit: any;\n    public sochdb_abort: any;\n\n    // KV Operations (All take DatabaseHandle AND TxnHandle)\n    // put: (db, txn, key, klen, val, vlen) -> int\n    public sochdb_put: any;\n    // get: (db, txn, key, klen, val_out*, len_out*) -> int\n    public sochdb_get: any;\n    // delete: (db, txn, key, klen) -> int\n    public sochdb_delete: any;\n\n    // Path Operations\n    public sochdb_put_path: any;\n    public sochdb_get_path: any;\n\n    // Scanning\n    public sochdb_scan_prefix: any;\n    public sochdb_iterator_next: any;\n    public sochdb_iterator_close: any;\n\n    // Stats\n    public sochdb_stats: any;\n    public sochdb_checkpoint: any;\n\n    // Memory\n    public sochdb_free_bytes: any;\n\n    private constructor() {\n        const libPath = findLibrary();\n        try {\n            this.lib = koffi.load(libPath);\n        } catch (error: any) {\n            console.error(`Failed to load SochDB library from ${libPath}:`, error);\n            throw error;\n        }\n\n        // Initialize bindings\n\n        // DB Management\n        this.sochdb_open = this.lib.func('sochdb_open', DatabaseHandle, ['string']);\n        this.sochdb_open_with_config = this.lib.func('sochdb_open_with_config', DatabaseHandle, ['string', DatabaseConfig]);\n        this.sochdb_close = this.lib.func('sochdb_close', 'void', [DatabaseHandle]);\n\n        // Transactions\n        this.sochdb_begin_txn = this.lib.func('sochdb_begin_txn', TxnHandle, [DatabaseHandle]);\n        this.sochdb_commit = this.lib.func('sochdb_commit', CommitResult, [DatabaseHandle, TxnHandle]);\n        this.sochdb_abort = this.lib.func('sochdb_abort', 'int', [DatabaseHandle, TxnHandle]);\n\n        // KV Operations\n        this.sochdb_put = this.lib.func('sochdb_put', 'int', [DatabaseHandle, TxnHandle, 'uint8*', 'size_t', 'uint8*', 'size_t']);\n        this.sochdb_get = this.lib.func('sochdb_get', 'int', [DatabaseHandle, TxnHandle, 'uint8*', 'size_t', koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t'))]);\n        this.sochdb_delete = this.lib.func('sochdb_delete', 'int', [DatabaseHandle, TxnHandle, 'uint8*', 'size_t']);\n\n        // Path Operations\n        this.sochdb_put_path = this.lib.func('sochdb_put_path', 'int', [DatabaseHandle, TxnHandle, 'string', 'uint8*', 'size_t']);\n        this.sochdb_get_path = this.lib.func('sochdb_get_path', 'int', [DatabaseHandle, TxnHandle, 'string', koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t'))]);\n\n        // Scanning\n        this.sochdb_scan_prefix = this.lib.func('sochdb_scan_prefix', IteratorHandle, [DatabaseHandle, TxnHandle, 'uint8*', 'size_t']);\n        this.sochdb_iterator_next = this.lib.func('sochdb_scan_next', 'int', [IteratorHandle, koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t')), koffi.out(koffi.pointer('uint8*')), koffi.out(koffi.pointer('size_t'))]);\n        this.sochdb_iterator_close = this.lib.func('sochdb_scan_free', 'void', [IteratorHandle]);\n\n        // Stats & Checkpoint\n        this.sochdb_stats = this.lib.func('sochdb_stats', Stats, [DatabaseHandle]);\n        this.sochdb_checkpoint = this.lib.func('sochdb_checkpoint', 'int', [DatabaseHandle]);\n\n        // Memory Management\n        this.sochdb_free_bytes = this.lib.func('sochdb_free_bytes', 'void', ['uint8*', 'size_t']);\n    }\n\n    public static getInstance(): NativeBindings {\n        if (!NativeBindings.instance) {\n            NativeBindings.instance = new NativeBindings();\n        }\n        return NativeBindings.instance;\n    }\n}\n"]}

package/dist/esm/embedded/ffi/library-finder.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * FFI Library Finder
+ *
+ * Locates the SochDB native library for the current platform.
+ * Search order matches Python SDK for consistency.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLibrary = findLibrary;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Get the Rust target triple for the current platform
+ */
+function getTargetTriple() {
+    const platform = os.platform();
+    const arch = os.arch();
+    if (platform === 'darwin') {
+        return arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+    }
+    else if (platform === 'linux') {
+        return arch === 'arm64' ? 'aarch64-unknown-linux-gnu' : 'x86_64-unknown-linux-gnu';
+    }
+    else if (platform === 'win32') {
+        return arch === 'x64' ? 'x86_64-pc-windows-msvc' : 'i686-pc-windows-msvc';
+    }
+    throw new Error(`Unsupported platform: ${platform}/${arch}`);
+}
+/**
+ * Get the library filename for the current platform
+ */
+function getLibraryFilename() {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        return 'libsochdb_storage.dylib';
+    }
+    else if (platform === 'linux') {
+        return 'libsochdb_storage.so';
+    }
+    else if (platform === 'win32') {
+        return 'sochdb_storage.dll';
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+}
+/**
+ * Find the SochDB native library
+ *
+ * Search order:
+ * 1. SOCHDB_LIB_PATH environment variable
+ * 2. Bundled library in package (_bin/{target}/)
+ * 3. Development build (../target/release, ../target/debug)
+ * 4. System paths
+ */
+function findLibrary() {
+    const target = getTargetTriple();
+    const filename = getLibraryFilename();
+    // 1. Environment variable override
+    if (process.env.SOCHDB_LIB_PATH) {
+        const envPath = process.env.SOCHDB_LIB_PATH;
+        if (fs.existsSync(envPath)) {
+            return envPath;
+        }
+    }
+    const searchPaths = [
+        // 2. Bundled in package (from dist/cjs or dist/esm)
+        path.join(__dirname, '..', '..', '..', '_bin', target, filename),
+        path.join(__dirname, '..', '..', '_bin', target, filename),
+        path.join(__dirname, '..', '_bin', target, filename),
+        // 3. Development paths - from project root
+        path.join(__dirname, '..', '..', '..', 'target', 'release', filename),
+        path.join(__dirname, '..', '..', '..', 'target', 'debug', filename),
+        path.join(__dirname, '..', '..', 'target', 'release', filename),
+        path.join(__dirname, '..', '..', 'target', 'debug', filename),
+        // From sochdb monorepo (../../sochdb/target/release)
+        path.join(__dirname, '..', '..', '..', '..', 'sochdb', 'target', 'release', filename),
+        // Absolute paths
+        path.resolve(process.cwd(), '_bin', target, filename),
+        path.resolve(process.cwd(), 'target', 'release', filename),
+        path.resolve(process.cwd(), '..', 'target', 'release', filename),
+    ];
+    // Search for library
+    for (const searchPath of searchPaths) {
+        if (fs.existsSync(searchPath)) {
+            return path.resolve(searchPath);
+        }
+    }
+    // 4. Try system paths (LD_LIBRARY_PATH, DYLD_LIBRARY_PATH, PATH)
+    const systemPaths = (process.env.LD_LIBRARY_PATH ||
+        process.env.DYLD_LIBRARY_PATH ||
+        process.env.PATH || '').split(path.delimiter);
+    for (const dir of systemPaths) {
+        const libPath = path.join(dir, filename);
+        if (fs.existsSync(libPath)) {
+            return path.resolve(libPath);
+        }
+    }
+    throw new Error(`Could not find SochDB native library (${filename}). ` +
+        `Searched in: ${searchPaths.join(', ')}. ` +
+        `Set SOCHDB_LIB_PATH environment variable or build the library.`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"library-finder.js","sourceRoot":"","sources":["../../../../src/embedded/ffi/library-finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FFI Library Finder\n * \n * Locates the SochDB native library for the current platform.\n * Search order matches Python SDK for consistency.\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as os from 'os';\n\n/**\n * Get the Rust target triple for the current platform\n */\nfunction getTargetTriple(): string {\n    const platform = os.platform();\n    const arch = os.arch();\n\n    if (platform === 'darwin') {\n        return arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';\n    } else if (platform === 'linux') {\n        return arch === 'arm64' ? 'aarch64-unknown-linux-gnu' : 'x86_64-unknown-linux-gnu';\n    } else if (platform === 'win32') {\n        return arch === 'x64' ? 'x86_64-pc-windows-msvc' : 'i686-pc-windows-msvc';\n    }\n\n    throw new Error(`Unsupported platform: ${platform}/${arch}`);\n}\n\n/**\n * Get the library filename for the current platform\n */\nfunction getLibraryFilename(): string {\n    const platform = os.platform();\n\n    if (platform === 'darwin') {\n        return 'libsochdb_storage.dylib';\n    } else if (platform === 'linux') {\n        return 'libsochdb_storage.so';\n    } else if (platform === 'win32') {\n        return 'sochdb_storage.dll';\n    }\n\n    throw new Error(`Unsupported platform: ${platform}`);\n}\n\n/**\n * Find the SochDB native library\n * \n * Search order:\n * 1. SOCHDB_LIB_PATH environment variable\n * 2. Bundled library in package (_bin/{target}/)\n * 3. Development build (../target/release, ../target/debug)\n * 4. System paths\n */\nexport function findLibrary(): string {\n    const target = getTargetTriple();\n    const filename = getLibraryFilename();\n\n    // 1. Environment variable override\n    if (process.env.SOCHDB_LIB_PATH) {\n        const envPath = process.env.SOCHDB_LIB_PATH;\n        if (fs.existsSync(envPath)) {\n            return envPath;\n        }\n    }\n\n    const searchPaths: string[] = [\n        // 2. Bundled in package (from dist/cjs or dist/esm)\n        path.join(__dirname, '..', '..', '..', '_bin', target, filename),\n        path.join(__dirname, '..', '..', '_bin', target, filename),\n        path.join(__dirname, '..', '_bin', target, filename),\n\n        // 3. Development paths - from project root\n        path.join(__dirname, '..', '..', '..', 'target', 'release', filename),\n        path.join(__dirname, '..', '..', '..', 'target', 'debug', filename),\n        path.join(__dirname, '..', '..', 'target', 'release', filename),\n        path.join(__dirname, '..', '..', 'target', 'debug', filename),\n\n        // From sochdb monorepo (../../sochdb/target/release)\n        path.join(__dirname, '..', '..', '..', '..', 'sochdb', 'target', 'release', filename),\n\n        // Absolute paths\n        path.resolve(process.cwd(), '_bin', target, filename),\n        path.resolve(process.cwd(), 'target', 'release', filename),\n        path.resolve(process.cwd(), '..', 'target', 'release', filename),\n    ];\n\n    // Search for library\n    for (const searchPath of searchPaths) {\n        if (fs.existsSync(searchPath)) {\n            return path.resolve(searchPath);\n        }\n    }\n\n    // 4. Try system paths (LD_LIBRARY_PATH, DYLD_LIBRARY_PATH, PATH)\n    const systemPaths = (process.env.LD_LIBRARY_PATH ||\n        process.env.DYLD_LIBRARY_PATH ||\n        process.env.PATH || '').split(path.delimiter);\n\n    for (const dir of systemPaths) {\n        const libPath = path.join(dir, filename);\n        if (fs.existsSync(libPath)) {\n            return path.resolve(libPath);\n        }\n    }\n\n    throw new Error(\n        `Could not find SochDB native library (${filename}). ` +\n        `Searched in: ${searchPaths.join(', ')}. ` +\n        `Set SOCHDB_LIB_PATH environment variable or build the library.`\n    );\n}\n"]}

package/dist/esm/embedded/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Embedded Mode - FFI Support
+ *
+ * Direct FFI bindings to SochDB native library.
+ * No server required.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedTransaction = exports.EmbeddedDatabase = void 0;
+var database_1 = require("./database");
+Object.defineProperty(exports, "EmbeddedDatabase", { enumerable: true, get: function () { return database_1.EmbeddedDatabase; } });
+var transaction_1 = require("./transaction");
+Object.defineProperty(exports, "EmbeddedTransaction", { enumerable: true, get: function () { return transaction_1.EmbeddedTransaction; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZW1iZWRkZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7OztHQUtHOzs7QUFFSCx1Q0FBc0U7QUFBN0QsNEdBQUEsZ0JBQWdCLE9BQUE7QUFDekIsNkNBQW9EO0FBQTNDLGtIQUFBLG1CQUFtQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbWJlZGRlZCBNb2RlIC0gRkZJIFN1cHBvcnRcbiAqIFxuICogRGlyZWN0IEZGSSBiaW5kaW5ncyB0byBTb2NoREIgbmF0aXZlIGxpYnJhcnkuXG4gKiBObyBzZXJ2ZXIgcmVxdWlyZWQuXG4gKi9cblxuZXhwb3J0IHsgRW1iZWRkZWREYXRhYmFzZSwgRW1iZWRkZWREYXRhYmFzZUNvbmZpZyB9IGZyb20gJy4vZGF0YWJhc2UnO1xuZXhwb3J0IHsgRW1iZWRkZWRUcmFuc2FjdGlvbiB9IGZyb20gJy4vdHJhbnNhY3Rpb24nO1xuIl19