@sochdb/sochdb 0.4.2 → 0.4.4

package/README.md

@@ -1,8 +1,212 @@
 # SochDB Node.js SDK
 
-**Dual-mode architecture: Embedded (FFI) + Server (gRPC/IPC)**  
+**LLM-Optimized Embedded Database with Native Vector Search**
+
+---
+
+## Installation
+
+```bash
+npm install @sochdb/sochdb
+```
+
+Or from source:
+```bash
+cd sochdb-typescript-sdk
+npm install
+```
+
+---
+
+## Architecture: Flexible Deployment
+
+**Tri-mode architecture: Embedded + Concurrent + Server (gRPC/IPC)**  
 Choose the deployment mode that fits your needs.
 
+---
+
+# SochDB Node.js SDK Documentation
+
+**LLM-Optimized Embedded Database with Native Vector Search**
+
+---
+
+## Table of Contents
+
+1. [Quick Start](#1-quick-start)
+2. [Installation](#2-installation)
+3. [Features](#3-features)
+   - [Namespace API](#namespace-api---multi-tenant-isolation)
+   - [Priority Queue API](#priority-queue-api---task-processing)
+4. [Architecture Overview](#4-architecture-overview)
+5. [Core Key-Value Operations](#5-core-key-value-operations)
+6. [Transactions (ACID with SSI)](#6-transactions-acid-with-ssi)
+7. [Query Builder](#7-query-builder)
+8. [Prefix Scanning](#8-prefix-scanning)
+9. [SQL Operations](#9-sql-operations)
+10. [Table Management & Index Policies](#10-table-management--index-policies)
+11. [Namespaces & Collections](#11-namespaces--collections)
+12. [Priority Queues](#12-priority-queues)
+13. [Vector Search](#13-vector-search)
+14. [Hybrid Search (Vector + BM25)](#14-hybrid-search-vector--bm25)
+15. [Graph Operations](#15-graph-operations)
+16. [Temporal Graph (Time-Travel)](#16-temporal-graph-time-travel)
+17. [Semantic Cache](#17-semantic-cache)
+18. [Memory System](#18-memory-system)
+19. [Session Management](#19-session-management)
+20. [Context Query Builder (LLM Optimization)](#20-context-query-builder-llm-optimization)
+21. [Atomic Multi-Index Writes](#21-atomic-multi-index-writes)
+22. [Recovery & WAL Management](#22-recovery--wal-management)
+23. [Checkpoints & Snapshots](#23-checkpoints--snapshots)
+24. [Compression & Storage](#24-compression--storage)
+25. [Statistics & Monitoring](#25-statistics--monitoring)
+26. [Distributed Tracing](#26-distributed-tracing)
+27. [Workflow & Run Tracking](#27-workflow--run-tracking)
+28. [Server Mode (gRPC Client)](#28-server-mode-grpc-client)
+29. [IPC Client (Unix Sockets)](#29-ipc-client-unix-sockets)
+30. [Standalone VectorIndex](#30-standalone-vectorindex)
+31. [Vector Utilities](#31-vector-utilities)
+32. [Data Formats (TOON/JSON/Columnar)](#32-data-formats-toonjsoncolumnar)
+33. [Policy Service](#33-policy-service)
+34. [MCP (Model Context Protocol)](#34-mcp-model-context-protocol)
+35. [Configuration Reference](#35-configuration-reference)
+36. [Error Handling](#36-error-handling)
+37. [Async Support](#37-async-support)
+38. [Building & Development](#38-building--development)
+39. [Complete Examples](#39-complete-examples)
+40. [Migration Guide](#40-migration-guide)
+
+---
+
+## 1. Quick Start
+
+### Concurrent Embedded Mode
+
+For web applications with multiple Node.js processes (PM2 cluster, multiple workers):
+
+```typescript
+import { EmbeddedDatabase } from '@sochdb/sochdb';
+import express from 'express';
+
+// Open in concurrent mode - multiple processes can access simultaneously
+const db = EmbeddedDatabase.openConcurrent('./web_db');
+
+const app = express();
+
+app.get('/user/:id', async (req, res) => {
+  // Multiple concurrent requests can read simultaneously (~100ns)
+  const data = await db.get(Buffer.from(`user:${req.params.id}`));
+  if (!data) {
+    res.status(404).json({ error: 'not found' });
+    return;
+  }
+  res.send(data);
+});
+
+app.post('/user/:id', async (req, res) => {
+  // Writes are automatically coordinated (~60µs amortized)
+  await db.put(Buffer.from(`user:${req.params.id}`), req.body);
+  res.json({ status: 'ok' });
+});
+
+// Check concurrent mode status
+console.log(`Concurrent mode: ${db.isConcurrent}`);  // true
+
+// Start with PM2 cluster mode (multiple workers can access DB)
+// pm2 start app.js -i max
+app.listen(3000);
+```
+
+### Performance
+
+| Operation | Standard Mode | Concurrent Mode |
+|-----------|---------------|-----------------|
+| Read (single process) | ~100ns | ~100ns |
+| Read (multi-process) | **Blocked** ❌ | ~100ns ✅ |
+| Write | ~5ms (fsync) | ~60µs (amortized) |
+| Max concurrent readers | 1 | 1024 |
+
+### PM2 Cluster Example
+
+```bash
+# Install PM2
+npm install -g pm2
+
+# Start with automatic worker scaling
+pm2 start server.js -i max
+
+# All workers can access the same database concurrently!
+pm2 logs
+```
+
+### PM2 Ecosystem File
+
+```javascript
+// ecosystem.config.js
+module.exports = {
+  apps: [{
+    name: 'api-server',
+    script: './server.js',
+    instances: 'max',  // Scale across all CPU cores
+    exec_mode: 'cluster',
+    env: {
+      NODE_ENV: 'production',
+      DB_PATH: './shared_db'  // All workers use same DB
+    }
+  }]
+};
+```
+
+```bash
+# Deploy with ecosystem file
+pm2 start ecosystem.config.js
+
+# Monitor all workers
+pm2 monit
+```
+
+### Docker Compose with PM2
+
+```yaml
+version: '3.8'
+services:
+  app:
+    build: .
+    environment:
+      - NODE_ENV=production
+      - INSTANCES=4  # 4 PM2 workers
+    volumes:
+      - ./data:/app/data  # Shared database volume
+    ports:
+      - "3000:3000"
+    command: pm2-runtime start ecosystem.config.js
+```
+
+### Kubernetes Deployment
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: sochdb-app
+spec:
+  replicas: 4  # 4 pods share the database
+  template:
+    spec:
+      containers:
+      - name: app
+        image: myapp:latest
+        volumeMounts:
+        - name: db-storage
+          mountPath: /app/data
+      volumes:
+      - name: db-storage
+        persistentVolumeClaim:
+          claimName: sochdb-pvc  # Shared PVC with ReadWriteMany
+```
+
+---
+
 ## Features
 
 ### Memory System - LLM-Native Memory for AI Agents
@@ -239,21 +443,161 @@ console.log(`Pending: ${stats.pending}, Completed: ${stats.completed}`);
 
 ---
 
-## Installation
+---
+
+## System Requirements
+
+### For Concurrent Mode
+
+- **SochDB Core**: Latest version
+- **Node.js**: 14.0+ (18.0+ recommended)
+- **Native Library**: `libsochdb_storage.{dylib,so}`
+- **FFI**: Koffi (automatically installed)
+
+**Operating Systems:**
+- ✅ Linux (Ubuntu 20.04+, RHEL 8+)
+- ✅ macOS (10.15+, both Intel and Apple Silicon)
+- ⚠️  Windows (requires native builds)
+
+**File Descriptors:**
+- Default limit: 1024 (sufficient for most workloads)
+- For high concurrency with PM2: `ulimit -n 4096`
+
+**Memory:**
+- Standard mode: ~50MB base + data
+- Concurrent mode: +4KB per concurrent reader slot (1024 slots = ~4MB overhead)
+- PM2 cluster: Each worker has independent memory
+
+---
+
+## Troubleshooting
+
+### "Database is locked" Error (Standard Mode)
+
+```
+Error: SQLITE_BUSY: database is locked
+```
+
+**Solution**: Use concurrent mode for multi-process access:
+
+```typescript
+// ❌ Standard mode - PM2 cluster will fail
+const db = new EmbeddedDatabase('./data.db');
 
+// ✅ Concurrent mode - PM2 cluster works!
+const db = EmbeddedDatabase.openConcurrent('./data.db');
+```
+
+### Library Not Found Error
+
+```
+Error: Dynamic library 'libsochdb_storage.dylib' not found
+```
+
+**macOS**:
 ```bash
-npm install @sochdb/sochdb
+# Build and install library
+cd /path/to/sochdb
+cargo build --release
+sudo cp target/release/libsochdb_storage.dylib /usr/local/lib/
 ```
 
-Or from source:
+**Linux**:
 ```bash
-cd sochdb-typescript-sdk
-npm install
+cd /path/to/sochdb
+cargo build --release
+sudo cp target/release/libsochdb_storage.so /usr/local/lib/
+sudo ldconfig
+```
+
+**Development Mode** (no install):
+```bash
+export DYLD_LIBRARY_PATH=/path/to/sochdb/target/release  # macOS
+export LD_LIBRARY_PATH=/path/to/sochdb/target/release    # Linux
+```
+
+### PM2 Cluster Issues
+
+**Symptom**: Workers crash with "database locked"
+
+**Solution**: Ensure concurrent mode is used:
+```javascript
+// ecosystem.config.js
+module.exports = {
+  apps: [{
+    name: 'api',
+    script: './server.js',
+    instances: 4,
+    exec_mode: 'cluster',
+    env: {
+      USE_CONCURRENT_MODE: 'true'  // Flag to use openConcurrent()
+    }
+  }]
+};
+```
+
+```typescript
+// server.ts
+const db = process.env.USE_CONCURRENT_MODE 
+  ? EmbeddedDatabase.openConcurrent('./db')
+  : new EmbeddedDatabase('./db');
+
+console.log('Concurrent mode:', db.isConcurrent);  // Should be true
+```
+
+### Docker Volume Permissions
+
+**Symptom**: `EACCES: permission denied` when opening database
+
+**Solution**: Fix volume ownership:
+```dockerfile
+FROM node:18
+WORKDIR /app
+
+# Create data directory with correct permissions
+RUN mkdir -p /app/data && chown -R node:node /app
+
+# Switch to non-root user
+USER node
+
+COPY --chown=node:node . .
+RUN npm install
+
+CMD ["npm", "start"]
+```
+
+### Performance Issues
+
+**Symptom**: Concurrent reads slower than expected
+
+**Check 1** - Verify concurrent mode:
+```typescript
+if (!db.isConcurrent) {
+    console.error('Database is not in concurrent mode!');
+    process.exit(1);
+}
+```
+
+**Check 2** - Monitor PM2 workers:
+```bash
+pm2 monit  # Real-time monitoring
+pm2 logs --lines 200  # Check for errors
+```
+
+**Check 3** - Batch writes:
+```typescript
+// ❌ Slow - individual writes
+for (const item of items) {
+    await collection.insert(item);
+}
+
+// ✅ Fast - batch write
+await collection.insertBatch(items);
 ```
 
 ---
 
-## 🆕 Vector Search - Native HNSW (v0.4.2)
+## 🆕 Vector Search - Native HNSW
 
 SochDB now includes **native HNSW (Hierarchical Navigable Small World)** vector search for sub-millisecond similarity search across millions of vectors.
 
@@ -337,8 +681,6 @@ const results = await collection.search({ queryVector: [...], k: 10 });
 - Direct HNSW API (above), OR
 - gRPC Server Mode (see below)
 
-**✅ Coming in v0.4.3:** Collection API will automatically use native HNSW
-
 #### 3. gRPC Server Mode (Production-Ready)
 
 For distributed systems, multi-language support:
@@ -440,15 +782,15 @@ class HnswIndex {
 
 ### Roadmap
 
-- **v0.4.2** (current): Direct HNSW FFI bindings
-- **v0.4.3** (next): Collection API auto-uses HNSW in embedded mode
-- **v0.5.0**: Persistent HNSW indexes with disk storage
+- **Current**: Direct HNSW FFI bindings
+- **Next**: Collection API auto-uses HNSW in embedded mode
+- **Future**: Persistent HNSW indexes with disk storage
 
 ---
 
 # SochDB Node.js SDK Documentation
 
-**Version 0.4.2** | LLM-Optimized Embedded Database with Native Vector Search
+**LLM-Optimized Embedded Database with Native Vector Search**
 
 ---
 
@@ -3679,7 +4021,7 @@ A:
 A: Yes! Both modes have the same API. Change `Database.open()` to `SochDBClient()` and vice versa.
 
 **Q: Do temporal graphs work in embedded mode?**  
-A: Yes! As of v0.4.0, temporal graphs work in both embedded and server modes with identical APIs.
+A: Yes! Temporal graphs work in both embedded and server modes with identical APIs.
 
 **Q: Is embedded mode slower than server mode?**  
 A: Embedded mode is faster for single-process use (no network overhead). Server mode is better for distributed deployments.

package/dist/cjs/embedded/database.js

@@ -24,14 +24,20 @@ const transaction_1 = require("./transaction");
  * ```
  */
 class EmbeddedDatabase {
-    constructor(path, handle) {
+    constructor(path, handle, concurrent = false, fallback = false) {
         this.closed = false;
+        this.concurrent = false;
+        this._concurrentModeFallback = false;
         this.path = path;
         this.handle = handle;
+        this.concurrent = concurrent;
+        this._concurrentModeFallback = fallback;
         this.bindings = bindings_1.NativeBindings.getInstance();
     }
     /**
-     * Open a database at the specified path
+     * Open a database at the specified path in standard mode
+     *
+     * For web applications with multiple processes, use `openConcurrent()` instead.
      *
      * @param path - Path to database directory
      * @param config - Optional configuration
@@ -60,7 +66,95 @@ class EmbeddedDatabase {
         if (!handle) {
             throw new errors_1.DatabaseError(`Failed to open database at ${path}`);
         }
-        return new EmbeddedDatabase(path, handle);
+        return new EmbeddedDatabase(path, handle, false);
+    }
+    /**
+     * Open a database in concurrent mode for multi-process web applications
+     *
+     * This mode allows multiple Node.js processes (e.g., PM2 cluster workers,
+     * multiple Express instances) to access the database simultaneously.
+     *
+     * Features:
+     * - Lock-free reads with ~100ns latency
+     * - Multi-reader, single-writer coordination
+     * - Automatic write serialization
+     *
+     * @example
+     * ```typescript
+     * import { EmbeddedDatabase } from '@sochdb/sochdb';
+     * import express from 'express';
+     *
+     * // Open in concurrent mode - multiple workers can access
+     * const db = EmbeddedDatabase.openConcurrent('./web_db');
+     *
+     * const app = express();
+     *
+     * app.get('/user/:id', async (req, res) => {
+     *   // Multiple concurrent requests can read simultaneously
+     *   const data = await db.get(Buffer.from(`user:${req.params.id}`));
+     *   if (!data) {
+     *     res.status(404).json({ error: 'not found' });
+     *     return;
+     *   }
+     *   res.send(data);
+     * });
+     *
+     * app.post('/user/:id', async (req, res) => {
+     *   // Writes are serialized automatically
+     *   await db.put(Buffer.from(`user:${req.params.id}`), req.body);
+     *   res.json({ status: 'ok' });
+     * });
+     *
+     * // Start with PM2 cluster mode:
+     * // pm2 start app.js -i max
+     * app.listen(3000);
+     * ```
+     *
+     * @param path - Path to database directory
+     * @param options - Optional configuration for concurrent mode
+     * @returns EmbeddedDatabase instance in concurrent mode
+     */
+    static openConcurrent(path, options) {
+        const bindings = bindings_1.NativeBindings.getInstance();
+        const fallbackToStandard = options?.fallbackToStandard ?? false;
+        if (!bindings.isConcurrentModeAvailable()) {
+            if (fallbackToStandard) {
+                console.warn('[SochDB] Concurrent mode not available in native library (requires v0.4.8+). ' +
+                    'Falling back to standard mode. For production multi-process deployments, ' +
+                    'please upgrade the SochDB native library.');
+                const handle = bindings.sochdb_open(path);
+                if (!handle) {
+                    throw new errors_1.DatabaseError(`Failed to open database at ${path}`);
+                }
+                return new EmbeddedDatabase(path, handle, false, true);
+            }
+            throw new errors_1.DatabaseError('Concurrent mode not supported. Please upgrade the SochDB native library to v0.4.8+ ' +
+                'or use openConcurrent(path, { fallbackToStandard: true }) to fall back to standard mode.');
+        }
+        const handle = bindings.sochdb_open_concurrent(path);
+        if (!handle) {
+            throw new errors_1.DatabaseError(`Failed to open database in concurrent mode at ${path}`);
+        }
+        const isConcurrent = bindings.sochdb_is_concurrent?.(handle) === 1;
+        return new EmbeddedDatabase(path, handle, isConcurrent, false);
+    }
+    /**
+     * Check if database is opened in concurrent mode
+     */
+    get isConcurrent() {
+        return this.concurrent;
+    }
+    /**
+     * Check if concurrent mode fell back to standard mode
+     */
+    get isConcurrentFallback() {
+        return this._concurrentModeFallback;
+    }
+    /**
+     * Check if concurrent mode is available in the native library
+     */
+    static isConcurrentModeAvailable() {
+        return bindings_1.NativeBindings.getInstance().isConcurrentModeAvailable();
     }
     /**
      * Put a key-value pair (auto-transaction)
@@ -233,4 +327,4 @@ class EmbeddedDatabase {
     }
 }
 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 '@sochdb/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"]}
+//# 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 '@sochdb/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    private concurrent = false;\n    private _concurrentModeFallback = false;\n\n    private constructor(path: string, handle: any, concurrent = false, fallback = false) {\n        this.path = path;\n        this.handle = handle;\n        this.concurrent = concurrent;\n        this._concurrentModeFallback = fallback;\n        this.bindings = NativeBindings.getInstance();\n    }\n\n    /**\n     * Open a database at the specified path in standard mode\n     * \n     * For web applications with multiple processes, use `openConcurrent()` instead.\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, false);\n    }\n\n    /**\n     * Open a database in concurrent mode for multi-process web applications\n     * \n     * This mode allows multiple Node.js processes (e.g., PM2 cluster workers,\n     * multiple Express instances) to access the database simultaneously.\n     * \n     * Features:\n     * - Lock-free reads with ~100ns latency\n     * - Multi-reader, single-writer coordination\n     * - Automatic write serialization\n     * \n     * @example\n     * ```typescript\n     * import { EmbeddedDatabase } from '@sochdb/sochdb';\n     * import express from 'express';\n     * \n     * // Open in concurrent mode - multiple workers can access\n     * const db = EmbeddedDatabase.openConcurrent('./web_db');\n     * \n     * const app = express();\n     * \n     * app.get('/user/:id', async (req, res) => {\n     *   // Multiple concurrent requests can read simultaneously\n     *   const data = await db.get(Buffer.from(`user:${req.params.id}`));\n     *   if (!data) {\n     *     res.status(404).json({ error: 'not found' });\n     *     return;\n     *   }\n     *   res.send(data);\n     * });\n     * \n     * app.post('/user/:id', async (req, res) => {\n     *   // Writes are serialized automatically\n     *   await db.put(Buffer.from(`user:${req.params.id}`), req.body);\n     *   res.json({ status: 'ok' });\n     * });\n     * \n     * // Start with PM2 cluster mode:\n     * // pm2 start app.js -i max\n     * app.listen(3000);\n     * ```\n     * \n     * @param path - Path to database directory\n     * @param options - Optional configuration for concurrent mode\n     * @returns EmbeddedDatabase instance in concurrent mode\n     */\n    static openConcurrent(path: string, options?: { fallbackToStandard?: boolean }): EmbeddedDatabase {\n        const bindings = NativeBindings.getInstance();\n        const fallbackToStandard = options?.fallbackToStandard ?? false;\n        \n        if (!bindings.isConcurrentModeAvailable()) {\n            if (fallbackToStandard) {\n                console.warn(\n                    '[SochDB] Concurrent mode not available in native library (requires v0.4.8+). ' +\n                    'Falling back to standard mode. For production multi-process deployments, ' +\n                    'please upgrade the SochDB native library.'\n                );\n                const handle = bindings.sochdb_open(path);\n                if (!handle) {\n                    throw new DatabaseError(`Failed to open database at ${path}`);\n                }\n                return new EmbeddedDatabase(path, handle, false, true);\n            }\n            throw new DatabaseError(\n                'Concurrent mode not supported. Please upgrade the SochDB native library to v0.4.8+ ' +\n                'or use openConcurrent(path, { fallbackToStandard: true }) to fall back to standard mode.'\n            );\n        }\n\n        const handle = bindings.sochdb_open_concurrent(path);\n        if (!handle) {\n            throw new DatabaseError(`Failed to open database in concurrent mode at ${path}`);\n        }\n\n        const isConcurrent = bindings.sochdb_is_concurrent?.(handle) === 1;\n        return new EmbeddedDatabase(path, handle, isConcurrent, false);\n    }\n\n    /**\n     * Check if database is opened in concurrent mode\n     */\n    get isConcurrent(): boolean {\n        return this.concurrent;\n    }\n\n    /**\n     * Check if concurrent mode fell back to standard mode\n     */\n    get isConcurrentFallback(): boolean {\n        return this._concurrentModeFallback;\n    }\n\n    /**\n     * Check if concurrent mode is available in the native library\n     */\n    static isConcurrentModeAvailable(): boolean {\n        return NativeBindings.getInstance().isConcurrentModeAvailable();\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"]}