@sochdb/sochdb 0.4.2 → 0.4.3

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,18 @@ const transaction_1 = require("./transaction");
  * ```
  */
 class EmbeddedDatabase {
-    constructor(path, handle) {
+    constructor(path, handle, concurrent = false) {
         this.closed = false;
+        this.concurrent = false;
         this.path = path;
         this.handle = handle;
+        this.concurrent = concurrent;
         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 +64,70 @@ 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
+     * @returns EmbeddedDatabase instance in concurrent mode
+     */
+    static openConcurrent(path) {
+        const bindings = bindings_1.NativeBindings.getInstance();
+        if (!bindings.sochdb_open_concurrent) {
+            throw new errors_1.DatabaseError('Concurrent mode not supported. Please upgrade the SochDB native library to v0.4.4+');
+        }
+        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);
+    }
+    /**
+     * Check if database is opened in concurrent mode
+     */
+    get isConcurrent() {
+        return this.concurrent;
     }
     /**
      * Put a key-value pair (auto-transaction)
@@ -233,4 +300,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\n    private constructor(path: string, handle: any, concurrent = false) {\n        this.path = path;\n        this.handle = handle;\n        this.concurrent = concurrent;\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     * @returns EmbeddedDatabase instance in concurrent mode\n     */\n    static openConcurrent(path: string): EmbeddedDatabase {\n        const bindings = NativeBindings.getInstance();\n        \n        if (!bindings.sochdb_open_concurrent) {\n            throw new DatabaseError('Concurrent mode not supported. Please upgrade the SochDB native library to v0.4.4+');\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);\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     * 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/cjs/embedded/ffi/bindings.js

@@ -80,6 +80,16 @@ class NativeBindings {
         // 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]);
+        // Concurrent mode (v0.4.8+)
+        try {
+            this.sochdb_open_concurrent = this.lib.func('sochdb_open_concurrent', DatabaseHandle, ['string']);
+            this.sochdb_is_concurrent = this.lib.func('sochdb_is_concurrent', 'int', [DatabaseHandle]);
+        }
+        catch (error) {
+            // Older library versions don't have concurrent mode
+            this.sochdb_open_concurrent = null;
+            this.sochdb_is_concurrent = null;
+        }
         this.sochdb_close = this.lib.func('sochdb_close', 'void', [DatabaseHandle]);
         // Transactions
         this.sochdb_begin_txn = this.lib.func('sochdb_begin_txn', TxnHandle, [DatabaseHandle]);
@@ -110,4 +120,4 @@ class NativeBindings {
     }
 }
 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bindings.js","sourceRoot":"","sources":["../../../../src/embedded/ffi/bindings.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAA+B;AAC/B,qDAA+C;AAE/C,uBAAuB;AACvB,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,gBAAgB,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;AACvE,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,gBAAgB,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;AAEvE,UAAU;AACV,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE;IAChC,mBAAmB,EAAE,QAAQ;IAC7B,cAAc,EAAE,QAAQ;IACxB,mBAAmB,EAAE,QAAQ;IAC7B,mBAAmB,EAAE,QAAQ;IAC7B,mBAAmB,EAAE,QAAQ;CAChC,CAAC,CAAC;AAEH,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,gBAAgB,EAAE;IAClD,WAAW,EAAE,MAAM;IACnB,eAAe,EAAE,MAAM;IACvB,SAAS,EAAE,OAAO;IAClB,aAAa,EAAE,MAAM;IACrB,mBAAmB,EAAE,QAAQ;IAC7B,YAAY,EAAE,MAAM;IACpB,gBAAgB,EAAE,MAAM;IACxB,oBAAoB,EAAE,OAAO;IAC7B,wBAAwB,EAAE,MAAM;CACnC,CAAC,CAAC;AAEH,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE;IACxC,MAAM,EAAE,QAAQ;IAChB,WAAW,EAAE,QAAQ;CACxB,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,CAAC,cAAc,EAAE;IAC9C,SAAS,EAAE,QAAQ;IACnB,UAAU,EAAE,OAAO;CACtB,CAAC,CAAC;AAEH,MAAa,cAAc;IAwCvB;QACI,MAAM,OAAO,GAAG,IAAA,4BAAW,GAAE,CAAC;QAC9B,IAAI,CAAC;YACD,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACnC,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YAClB,OAAO,CAAC,KAAK,CAAC,sCAAsC,OAAO,GAAG,EAAE,KAAK,CAAC,CAAC;YACvE,MAAM,KAAK,CAAC;QAChB,CAAC;QAED,sBAAsB;QAEtB,gBAAgB;QAChB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,cAAc,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC5E,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,yBAAyB,EAAE,cAAc,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC;QAEpH,4BAA4B;QAC5B,IAAI,CAAC;YACD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,wBAAwB,EAAE,cAAc,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;YAClG,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QAC/F,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,oDAAoD;YACpD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;YACnC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;QACrC,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QAE5E,eAAe;QACf,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,EAAE,SAAS,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QACvF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC;QAC/F,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,EAAE,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC;QAEtF,gBAAgB;QAChB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC1H,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9K,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;QAE5G,kBAAkB;QAClB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC1H,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAE9K,WAAW;QACX,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,oBAAoB,EAAE,cAAc,EAAE,CAAC,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC/H,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,EAAE,CAAC,cAAc,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACvO,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,EAAE,MAAM,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QAEzF,qBAAqB;QACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QAC3E,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QAErF,oBAAoB;QACpB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,mBAAmB,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC9F,CAAC;IAEM,MAAM,CAAC,WAAW;QACrB,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;YAC3B,cAAc,CAAC,QAAQ,GAAG,IAAI,cAAc,EAAE,CAAC;QACnD,CAAC;QACD,OAAO,cAAc,CAAC,QAAQ,CAAC;IACnC,CAAC;CACJ;AApGD,wCAoGC","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_open_concurrent: any;\n    public sochdb_is_concurrent: 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        \n        // Concurrent mode (v0.4.8+)\n        try {\n            this.sochdb_open_concurrent = this.lib.func('sochdb_open_concurrent', DatabaseHandle, ['string']);\n            this.sochdb_is_concurrent = this.lib.func('sochdb_is_concurrent', 'int', [DatabaseHandle]);\n        } catch (error) {\n            // Older library versions don't have concurrent mode\n            this.sochdb_open_concurrent = null;\n            this.sochdb_is_concurrent = null;\n        }\n        \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/database.js

@@ -28,13 +28,17 @@ class EmbeddedDatabase {
     bindings;
     closed = false;
     path;
-    constructor(path, handle) {
+    concurrent = false;
+    constructor(path, handle, concurrent = false) {
         this.path = path;
         this.handle = handle;
+        this.concurrent = concurrent;
         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
@@ -63,7 +67,70 @@ 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
+     * @returns EmbeddedDatabase instance in concurrent mode
+     */
+    static openConcurrent(path) {
+        const bindings = bindings_1.NativeBindings.getInstance();
+        if (!bindings.sochdb_open_concurrent) {
+            throw new errors_1.DatabaseError('Concurrent mode not supported. Please upgrade the SochDB native library to v0.4.4+');
+        }
+        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);
+    }
+    /**
+     * Check if database is opened in concurrent mode
+     */
+    get isConcurrent() {
+        return this.concurrent;
     }
     /**
      * Put a key-value pair (auto-transaction)
@@ -236,4 +303,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\n    private constructor(path: string, handle: any, concurrent = false) {\n        this.path = path;\n        this.handle = handle;\n        this.concurrent = concurrent;\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     * @returns EmbeddedDatabase instance in concurrent mode\n     */\n    static openConcurrent(path: string): EmbeddedDatabase {\n        const bindings = NativeBindings.getInstance();\n        \n        if (!bindings.sochdb_open_concurrent) {\n            throw new DatabaseError('Concurrent mode not supported. Please upgrade the SochDB native library to v0.4.4+');\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);\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     * 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

@@ -72,6 +72,8 @@ class NativeBindings {
     // FFIs
     sochdb_open;
     sochdb_open_with_config;
+    sochdb_open_concurrent;
+    sochdb_is_concurrent;
     sochdb_close;
     // Transactional Operations (mapped to base functions)
     sochdb_begin_txn;
@@ -109,6 +111,16 @@ class NativeBindings {
         // 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]);
+        // Concurrent mode (v0.4.8+)
+        try {
+            this.sochdb_open_concurrent = this.lib.func('sochdb_open_concurrent', DatabaseHandle, ['string']);
+            this.sochdb_is_concurrent = this.lib.func('sochdb_is_concurrent', 'int', [DatabaseHandle]);
+        }
+        catch (error) {
+            // Older library versions don't have concurrent mode
+            this.sochdb_open_concurrent = null;
+            this.sochdb_is_concurrent = null;
+        }
         this.sochdb_close = this.lib.func('sochdb_close', 'void', [DatabaseHandle]);
         // Transactions
         this.sochdb_begin_txn = this.lib.func('sochdb_begin_txn', TxnHandle, [DatabaseHandle]);
@@ -139,4 +151,4 @@ class NativeBindings {
     }
 }
 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"]}
+//# 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_open_concurrent: any;\n    public sochdb_is_concurrent: 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        \n        // Concurrent mode (v0.4.8+)\n        try {\n            this.sochdb_open_concurrent = this.lib.func('sochdb_open_concurrent', DatabaseHandle, ['string']);\n            this.sochdb_is_concurrent = this.lib.func('sochdb_is_concurrent', 'int', [DatabaseHandle]);\n        } catch (error) {\n            // Older library versions don't have concurrent mode\n            this.sochdb_open_concurrent = null;\n            this.sochdb_is_concurrent = null;\n        }\n        \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/types/embedded/database.d.ts

@@ -31,15 +31,68 @@ export declare class EmbeddedDatabase {
     private bindings;
     private closed;
     private path;
+    private concurrent;
     private constructor();
     /**
-     * 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
      * @returns EmbeddedDatabase instance
      */
     static open(path: string, config?: EmbeddedDatabaseConfig): EmbeddedDatabase;
+    /**
+     * 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
+     * @returns EmbeddedDatabase instance in concurrent mode
+     */
+    static openConcurrent(path: string): EmbeddedDatabase;
+    /**
+     * Check if database is opened in concurrent mode
+     */
+    get isConcurrent(): boolean;
     /**
      * Put a key-value pair (auto-transaction)
      */

package/dist/types/embedded/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/embedded/database.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,MAAM,WAAW,sBAAsB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,iBAAiB,GAAG,UAAU,GAAG,gBAAgB,GAAG,aAAa,CAAC;CACnF;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO;IAMP;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,sBAAsB,GAAG,gBAAgB;IA4B5E;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAapD;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAc9C;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxC;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAazD;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcnD;;OAEG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAenE;;OAEG;IACH,WAAW,IAAI,mBAAmB;IAOlC;;OAEG;IACG,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYlF;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMnC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,iBAAiB,EAAE,MAAM,CAAC;KAC7B,CAAC;IAiBF;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,UAAU;IAMlB;;;OAGG;IACH,SAAS,IAAI,GAAG;IAIhB;;;OAGG;IACH,WAAW,IAAI,cAAc;CAGhC"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/embedded/database.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,MAAM,WAAW,sBAAsB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,iBAAiB,GAAG,UAAU,GAAG,gBAAgB,GAAG,aAAa,CAAC;CACnF;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO;IAOP;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,sBAAsB,GAAG,gBAAgB;IA4B5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB;IAgBrD;;OAEG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAapD;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAc9C;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxC;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAazD;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcnD;;OAEG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAenE;;OAEG;IACH,WAAW,IAAI,mBAAmB;IAOlC;;OAEG;IACG,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYlF;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMnC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,iBAAiB,EAAE,MAAM,CAAC;KAC7B,CAAC;IAiBF;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,UAAU;IAMlB;;;OAGG;IACH,SAAS,IAAI,GAAG;IAIhB;;;OAGG;IACH,WAAW,IAAI,cAAc;CAGhC"}

package/dist/types/embedded/ffi/bindings.d.ts

@@ -3,6 +3,8 @@ export declare class NativeBindings {
     private lib;
     sochdb_open: any;
     sochdb_open_with_config: any;
+    sochdb_open_concurrent: any;
+    sochdb_is_concurrent: any;
     sochdb_close: any;
     sochdb_begin_txn: any;
     sochdb_commit: any;

package/dist/types/embedded/ffi/bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../../../src/embedded/ffi/bindings.ts"],"names":[],"mappings":"AAsCA,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO,CAAC,GAAG,CAAM;IAGV,WAAW,EAAE,GAAG,CAAC;IACjB,uBAAuB,EAAE,GAAG,CAAC;IAC7B,YAAY,EAAE,GAAG,CAAC;IAGlB,gBAAgB,EAAE,GAAG,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,EAAE,GAAG,CAAC;IAIlB,UAAU,EAAE,GAAG,CAAC;IAEhB,UAAU,EAAE,GAAG,CAAC;IAEhB,aAAa,EAAE,GAAG,CAAC;IAGnB,eAAe,EAAE,GAAG,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC;IAGrB,kBAAkB,EAAE,GAAG,CAAC;IACxB,oBAAoB,EAAE,GAAG,CAAC;IAC1B,qBAAqB,EAAE,GAAG,CAAC;IAG3B,YAAY,EAAE,GAAG,CAAC;IAClB,iBAAiB,EAAE,GAAG,CAAC;IAGvB,iBAAiB,EAAE,GAAG,CAAC;IAE9B,OAAO;WA2CO,WAAW,IAAI,cAAc;CAM9C"}
+{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../../../src/embedded/ffi/bindings.ts"],"names":[],"mappings":"AAsCA,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO,CAAC,GAAG,CAAM;IAGV,WAAW,EAAE,GAAG,CAAC;IACjB,uBAAuB,EAAE,GAAG,CAAC;IAC7B,sBAAsB,EAAE,GAAG,CAAC;IAC5B,oBAAoB,EAAE,GAAG,CAAC;IAC1B,YAAY,EAAE,GAAG,CAAC;IAGlB,gBAAgB,EAAE,GAAG,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,EAAE,GAAG,CAAC;IAIlB,UAAU,EAAE,GAAG,CAAC;IAEhB,UAAU,EAAE,GAAG,CAAC;IAEhB,aAAa,EAAE,GAAG,CAAC;IAGnB,eAAe,EAAE,GAAG,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC;IAGrB,kBAAkB,EAAE,GAAG,CAAC;IACxB,oBAAoB,EAAE,GAAG,CAAC;IAC1B,qBAAqB,EAAE,GAAG,CAAC;IAG3B,YAAY,EAAE,GAAG,CAAC;IAClB,iBAAiB,EAAE,GAAG,CAAC;IAGvB,iBAAiB,EAAE,GAAG,CAAC;IAE9B,OAAO;WAsDO,WAAW,IAAI,cAAc;CAM9C"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sochdb/sochdb",
-  "version": "0.4.2",
-  "description": "SochDB is an AI-native database with token-optimized output, O(|path|) lookups, built-in vector search, and durable transactions.",
+  "version": "0.4.3",
+  "description": "SochDB Node.js SDK - AI-native embedded database with concurrent multi-process support",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",