@sochdb/sochdb 0.4.0

package/dist/esm/database.js

@@ -0,0 +1,931 @@
+"use strict";
+/**
+ * SochDB Embedded Database
+ *
+ * Direct database access via IPC to the SochDB server.
+ * This provides the same API as the Python SDK's Database class.
+ *
+ * @packageDocumentation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = exports.Transaction = void 0;
+// Copyright 2025 Sushanth (https://github.com/sushanthpy)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const errors_1 = require("./errors");
+const ipc_client_1 = require("./ipc-client");
+const query_1 = require("./query");
+const server_manager_1 = require("./server-manager");
+/**
+ * Transaction handle for atomic operations.
+ */
+class Transaction {
+    _db;
+    _txnId = null;
+    _committed = false;
+    _aborted = false;
+    constructor(db) {
+        this._db = db;
+    }
+    /**
+     * Begin the transaction.
+     * @internal
+     */
+    async begin() {
+        this._txnId = await this._db['_beginTransaction']();
+    }
+    /**
+     * Get a value by key within this transaction.
+     */
+    async get(key) {
+        this._ensureActive();
+        return this._db.get(key);
+    }
+    /**
+     * Put a key-value pair within this transaction.
+     */
+    async put(key, value) {
+        this._ensureActive();
+        return this._db.put(key, value);
+    }
+    /**
+     * Delete a key within this transaction.
+     */
+    async delete(key) {
+        this._ensureActive();
+        return this._db.delete(key);
+    }
+    /**
+     * Scan keys with a prefix within this transaction.
+     * @param prefix - The prefix to scan for
+     * @param end - Optional end boundary (exclusive)
+     */
+    async *scan(prefix, end) {
+        this._ensureActive();
+        // Delegate to database's scan method
+        // Transactional isolation is maintained by the underlying storage
+        for await (const entry of this._db.scanGenerator(prefix, end)) {
+            yield entry;
+        }
+    }
+    /**
+     * Get a value by path within this transaction.
+     */
+    async getPath(pathStr) {
+        this._ensureActive();
+        return this._db.getPath(pathStr);
+    }
+    /**
+     * Put a value at a path within this transaction.
+     */
+    async putPath(pathStr, value) {
+        this._ensureActive();
+        return this._db.putPath(pathStr, value);
+    }
+    /**
+     * Commit the transaction.
+     *
+     * After committing, an optional checkpoint is triggered to ensure writes
+     * are durable. This prevents race conditions where subsequent reads might
+     * not see committed data due to async flush timing.
+     */
+    async commit() {
+        this._ensureActive();
+        if (this._txnId !== null) {
+            await this._db['_commitTransaction'](this._txnId);
+            // Trigger checkpoint to ensure durability (addresses race condition)
+            // Note: This is a trade-off between consistency and performance.
+            // For high-throughput scenarios, consider batching checkpoints.
+            await this._db.checkpoint();
+        }
+        this._committed = true;
+    }
+    /**
+     * Abort/rollback the transaction.
+     */
+    async abort() {
+        if (this._committed || this._aborted)
+            return;
+        if (this._txnId !== null) {
+            await this._db['_abortTransaction'](this._txnId);
+        }
+        this._aborted = true;
+    }
+    _ensureActive() {
+        if (this._committed) {
+            throw new errors_1.TransactionError('Transaction already committed');
+        }
+        if (this._aborted) {
+            throw new errors_1.TransactionError('Transaction already aborted');
+        }
+    }
+}
+exports.Transaction = Transaction;
+/**
+ * SochDB Database client.
+ *
+ * Provides access to SochDB with full transaction support.
+ *
+ * @example
+ * ```typescript
+ * import { Database } from '@sushanth/sochdb';
+ *
+ * // Open a database
+ * const db = await Database.open('./my_database');
+ *
+ * // Simple key-value operations
+ * await db.put(Buffer.from('user:123'), Buffer.from('{"name": "Alice"}'));
+ * const value = await db.get(Buffer.from('user:123'));
+ *
+ * // Path-native API
+ * await db.putPath('users/alice/email', Buffer.from('alice@example.com'));
+ * const email = await db.getPath('users/alice/email');
+ *
+ * // Transactions
+ * await db.withTransaction(async (txn) => {
+ *   await txn.put(Buffer.from('key1'), Buffer.from('value1'));
+ *   await txn.put(Buffer.from('key2'), Buffer.from('value2'));
+ * });
+ *
+ * // Clean up
+ * await db.close();
+ * ```
+ */
+class Database {
+    _client = null;
+    _config;
+    _closed = false;
+    _embeddedServerStarted = false;
+    constructor(config) {
+        this._config = {
+            createIfMissing: true,
+            walEnabled: true,
+            syncMode: 'normal',
+            memtableSizeBytes: 64 * 1024 * 1024,
+            embedded: true, // Default to embedded mode
+            ...config,
+        };
+    }
+    /**
+     * Open a database at the specified path.
+     *
+     * @param pathOrConfig - Path to the database directory or configuration object
+     * @returns A new Database instance
+     *
+     * @example
+     * ```typescript
+     * // Simple usage (embedded mode - starts server automatically)
+     * const db = await Database.open('./my_database');
+     *
+     * // With configuration
+     * const db = await Database.open({
+     *   path: './my_database',
+     *   walEnabled: true,
+     *   syncMode: 'full',
+     * });
+     *
+     * // Connect to existing external server
+     * const db = await Database.open({
+     *   path: './my_database',
+     *   embedded: false,  // Don't start embedded server
+     * });
+     * ```
+     */
+    static async open(pathOrConfig) {
+        const config = typeof pathOrConfig === 'string' ? { path: pathOrConfig } : pathOrConfig;
+        // Ensure database directory exists
+        if (config.createIfMissing !== false) {
+            if (!fs.existsSync(config.path)) {
+                fs.mkdirSync(config.path, { recursive: true });
+            }
+        }
+        const db = new Database(config);
+        // Start embedded server if configured (default: true)
+        let socketPath;
+        if (db._config.embedded !== false) {
+            // Start embedded server and get socket path
+            socketPath = await (0, server_manager_1.startEmbeddedServer)(config.path);
+            db._embeddedServerStarted = true;
+        }
+        else {
+            // Connect to existing server socket
+            socketPath = path.join(config.path, 'sochdb.sock');
+        }
+        db._client = await ipc_client_1.IpcClient.connect(socketPath);
+        // Track database open event (only analytics event we send)
+        try {
+            const { trackDatabaseOpen } = await import('./analytics.js');
+            await trackDatabaseOpen(config.path, 'embedded');
+        }
+        catch {
+            // Never let analytics break database operations
+        }
+        return db;
+    }
+    /**
+     * Get a value by key.
+     *
+     * @param key - The key to look up (Buffer or string)
+     * @returns The value as a Buffer, or null if not found
+     */
+    async get(key) {
+        this._ensureOpen();
+        const keyBuf = typeof key === 'string' ? Buffer.from(key) : key;
+        return this._client.get(keyBuf);
+    }
+    /**
+     * Put a key-value pair.
+     *
+     * @param key - The key (Buffer or string)
+     * @param value - The value (Buffer or string)
+     */
+    async put(key, value) {
+        this._ensureOpen();
+        const keyBuf = typeof key === 'string' ? Buffer.from(key) : key;
+        const valueBuf = typeof value === 'string' ? Buffer.from(value) : value;
+        return this._client.put(keyBuf, valueBuf);
+    }
+    /**
+     * Delete a key.
+     *
+     * @param key - The key to delete (Buffer or string)
+     */
+    async delete(key) {
+        this._ensureOpen();
+        const keyBuf = typeof key === 'string' ? Buffer.from(key) : key;
+        return this._client.delete(keyBuf);
+    }
+    /**
+     * Get a value by path.
+     *
+     * @param pathStr - The path (e.g., "users/alice/email")
+     * @returns The value as a Buffer, or null if not found
+     */
+    async getPath(pathStr) {
+        this._ensureOpen();
+        return this._client.getPath(pathStr);
+    }
+    /**
+     * Put a value at a path.
+     *
+     * @param pathStr - The path (e.g., "users/alice/email")
+     * @param value - The value (Buffer or string)
+     */
+    async putPath(pathStr, value) {
+        this._ensureOpen();
+        const valueBuf = typeof value === 'string' ? Buffer.from(value) : value;
+        return this._client.putPath(pathStr, valueBuf);
+    }
+    /**
+     * Create a query builder for the given path prefix.
+     *
+     * @param pathPrefix - The path prefix to query (e.g., "users/")
+     * @returns A Query builder instance
+     *
+     * @example
+     * ```typescript
+     * const results = await db.query('users/')
+     *   .limit(10)
+     *   .select(['name', 'email'])
+     *   .execute();
+     * ```
+     */
+    query(pathPrefix) {
+        this._ensureOpen();
+        return new query_1.Query(this._client, pathPrefix);
+    }
+    /**
+     * Scan for keys with a prefix, returning key-value pairs.
+     * This is the preferred method for simple prefix-based iteration.
+     *
+     * @param prefix - The prefix to scan for (e.g., "users/", "tenants/tenant1/")
+     * @returns Array of key-value pairs
+     *
+     * @example
+     * ```typescript
+     * const results = await db.scan('tenants/tenant1/');
+     * for (const { key, value } of results) {
+     *   console.log(`${key.toString()}: ${value.toString()}`);
+     * }
+     * ```
+     */
+    async scan(prefix) {
+        this._ensureOpen();
+        return this._client.scan(prefix);
+    }
+    /**
+     * Scan for keys with a prefix using an async generator.
+     * This allows for memory-efficient iteration over large result sets.
+     *
+     * @param prefix - The prefix to scan for
+     * @param end - Optional end boundary (exclusive)
+     * @returns Async generator yielding [key, value] tuples
+     *
+     * @example
+     * ```typescript
+     * for await (const [key, value] of db.scanGenerator('users/')) {
+     *   console.log(`${key.toString()}: ${value.toString()}`);
+     * }
+     * ```
+     */
+    async *scanGenerator(prefix, end) {
+        this._ensureOpen();
+        const prefixBuf = typeof prefix === 'string' ? Buffer.from(prefix) : prefix;
+        const endBuf = end ? (typeof end === 'string' ? Buffer.from(end) : end) : undefined;
+        const results = await this._client.scan(prefixBuf.toString());
+        for (const { key, value } of results) {
+            // Filter by end boundary if provided
+            if (endBuf && Buffer.compare(key, endBuf) >= 0) {
+                break;
+            }
+            yield [key, value];
+        }
+    }
+    /**
+     * Execute operations within a transaction.
+     *
+     * The transaction automatically commits on success or aborts on error.
+     *
+     * @param fn - Async function that receives a Transaction object
+     *
+     * @example
+     * ```typescript
+     * await db.withTransaction(async (txn) => {
+     *   await txn.put(Buffer.from('key1'), Buffer.from('value1'));
+     *   await txn.put(Buffer.from('key2'), Buffer.from('value2'));
+     *   // Automatically commits
+     * });
+     * ```
+     */
+    async withTransaction(fn) {
+        this._ensureOpen();
+        const txn = new Transaction(this);
+        await txn.begin();
+        try {
+            const result = await fn(txn);
+            await txn.commit();
+            return result;
+        }
+        catch (error) {
+            await txn.abort();
+            throw error;
+        }
+    }
+    /**
+     * Create a new transaction.
+     *
+     * @returns A new Transaction instance
+     * @deprecated Use withTransaction() for automatic commit/abort handling
+     */
+    async transaction() {
+        this._ensureOpen();
+        const txn = new Transaction(this);
+        await txn.begin();
+        return txn;
+    }
+    /**
+     * Force a checkpoint to persist memtable to disk.
+     */
+    async checkpoint() {
+        this._ensureOpen();
+        return this._client.checkpoint();
+    }
+    /**
+     * Get storage statistics.
+     */
+    async stats() {
+        this._ensureOpen();
+        return this._client.stats();
+    }
+    /**
+     * Execute a SQL query.
+     *
+     * SochDB supports a subset of SQL for relational data stored on top of
+     * the key-value engine. Tables and rows are stored as:
+     * - Schema: _sql/tables/{table_name}/schema
+     * - Rows: _sql/tables/{table_name}/rows/{row_id}
+     *
+     * Supported SQL:
+     * - CREATE TABLE table_name (col1 TYPE, col2 TYPE, ...)
+     * - DROP TABLE table_name
+     * - INSERT INTO table_name (cols) VALUES (vals)
+     * - SELECT cols FROM table_name [WHERE ...] [ORDER BY ...] [LIMIT ...]
+     * - UPDATE table_name SET col=val [WHERE ...]
+     * - DELETE FROM table_name [WHERE ...]
+     *
+     * Supported types: INT, TEXT, FLOAT, BOOL, BLOB
+     *
+     * @param sql - SQL query string
+     * @returns SQLQueryResult with rows and metadata
+     *
+     * @example
+     * ```typescript
+     * // Create a table
+     * await db.execute("CREATE TABLE users (id INT PRIMARY KEY, name TEXT, age INT)");
+     *
+     * // Insert data
+     * await db.execute("INSERT INTO users (id, name, age) VALUES (1, 'Alice', 30)");
+     *
+     * // Query data
+     * const result = await db.execute("SELECT * FROM users WHERE age > 26");
+     * result.rows.forEach(row => console.log(row));
+     * ```
+     */
+    async execute(sql) {
+        this._ensureOpen();
+        // Import the SQL executor
+        const { SQLExecutor } = await import('./sql-engine.js');
+        // Create a database adapter for the SQL executor
+        const dbAdapter = {
+            get: (key) => this.get(key),
+            put: (key, value) => this.put(key, value),
+            delete: (key) => this.delete(key),
+            scan: (prefix) => this.scan(prefix),
+        };
+        const executor = new SQLExecutor(dbAdapter);
+        return executor.execute(sql);
+    }
+    // =========================================================================
+    // Static Serialization Methods
+    // =========================================================================
+    /**
+     * Convert records to TOON format for token-efficient LLM context.
+     *
+     * TOON format achieves 40-66% token reduction compared to JSON by using
+     * a columnar text format with minimal syntax.
+     *
+     * @param tableName - Name of the table/collection
+     * @param records - Array of objects with the data
+     * @param fields - Optional array of field names to include
+     * @returns TOON-formatted string
+     *
+     * @example
+     * ```typescript
+     * const records = [
+     *   { id: 1, name: 'Alice', email: 'alice@ex.com' },
+     *   { id: 2, name: 'Bob', email: 'bob@ex.com' }
+     * ];
+     * console.log(Database.toToon('users', records, ['name', 'email']));
+     * // users[2]{name,email}:Alice,alice@ex.com;Bob,bob@ex.com
+     * ```
+     */
+    static toToon(tableName, records, fields) {
+        if (!records || records.length === 0) {
+            return `${tableName}[0]{}:`;
+        }
+        // Determine fields from first record if not specified
+        const useFields = fields ?? Object.keys(records[0]);
+        // Build header: table[count]{field1,field2,...}:
+        const header = `${tableName}[${records.length}]{${useFields.join(',')}}:`;
+        // Escape values containing delimiters
+        const escapeValue = (v) => {
+            const s = v != null ? String(v) : '';
+            if (s.includes(',') || s.includes(';') || s.includes('\n')) {
+                return `"${s}"`;
+            }
+            return s;
+        };
+        // Build rows: value1,value2;value1,value2;...
+        const rows = records
+            .map(r => useFields.map(f => escapeValue(r[f])).join(','))
+            .join(';');
+        return header + rows;
+    }
+    /**
+     * Convert records to JSON format for easy application decoding.
+     *
+     * While TOON format is optimized for LLM context (40-66% token reduction),
+     * JSON is often easier for applications to parse. Use this method when
+     * the output will be consumed by application code rather than LLMs.
+     *
+     * @param tableName - Name of the table/collection
+     * @param records - Array of objects with the data
+     * @param fields - Optional array of field names to include
+     * @param compact - If true (default), outputs minified JSON
+     * @returns JSON-formatted string
+     *
+     * @example
+     * ```typescript
+     * const records = [
+     *   { id: 1, name: 'Alice' },
+     *   { id: 2, name: 'Bob' }
+     * ];
+     * console.log(Database.toJson('users', records));
+     * // {"table":"users","count":2,"records":[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]}
+     * ```
+     */
+    static toJson(tableName, records, fields, compact = true) {
+        if (!records || records.length === 0) {
+            return JSON.stringify({ table: tableName, count: 0, records: [] });
+        }
+        // Filter fields if specified
+        const filteredRecords = fields
+            ? records.map(r => {
+                const filtered = {};
+                for (const f of fields) {
+                    filtered[f] = r[f];
+                }
+                return filtered;
+            })
+            : records;
+        const output = {
+            table: tableName,
+            count: filteredRecords.length,
+            records: filteredRecords,
+        };
+        return compact ? JSON.stringify(output) : JSON.stringify(output, null, 2);
+    }
+    /**
+     * Parse a JSON format string back to structured data.
+     *
+     * @param jsonStr - JSON-formatted string (from toJson)
+     * @returns Object with table, fields, and records
+     */
+    static fromJson(jsonStr) {
+        const data = JSON.parse(jsonStr);
+        const table = data.table ?? 'unknown';
+        const records = data.records ?? [];
+        const fields = records.length > 0 ? Object.keys(records[0]) : [];
+        return { table, fields, records };
+    }
+    // =========================================================================
+    // Graph Overlay Operations
+    // =========================================================================
+    /**
+     * Add a node to the graph overlay.
+     *
+     * @param namespace - Namespace for the graph
+     * @param nodeId - Unique node identifier
+     * @param nodeType - Type of node (e.g., "person", "document", "concept")
+     * @param properties - Optional node properties
+     *
+     * @example
+     * ```typescript
+     * await db.addNode('default', 'alice', 'person', { role: 'engineer' });
+     * await db.addNode('default', 'project_x', 'project', { status: 'active' });
+     * ```
+     */
+    async addNode(namespace, nodeId, nodeType, properties) {
+        this._ensureOpen();
+        const key = `_graph/${namespace}/nodes/${nodeId}`;
+        const value = JSON.stringify({
+            id: nodeId,
+            node_type: nodeType,
+            properties: properties || {},
+        });
+        await this.put(Buffer.from(key), Buffer.from(value));
+    }
+    /**
+     * Add an edge between nodes in the graph overlay.
+     *
+     * @param namespace - Namespace for the graph
+     * @param fromId - Source node ID
+     * @param edgeType - Type of relationship
+     * @param toId - Target node ID
+     * @param properties - Optional edge properties
+     *
+     * @example
+     * ```typescript
+     * await db.addEdge('default', 'alice', 'works_on', 'project_x');
+     * await db.addEdge('default', 'alice', 'knows', 'bob', { since: '2020' });
+     * ```
+     */
+    async addEdge(namespace, fromId, edgeType, toId, properties) {
+        this._ensureOpen();
+        const key = `_graph/${namespace}/edges/${fromId}/${edgeType}/${toId}`;
+        const value = JSON.stringify({
+            from_id: fromId,
+            edge_type: edgeType,
+            to_id: toId,
+            properties: properties || {},
+        });
+        await this.put(Buffer.from(key), Buffer.from(value));
+    }
+    /**
+     * Traverse the graph from a starting node.
+     *
+     * @param namespace - Namespace for the graph
+     * @param startNode - Node ID to start traversal from
+     * @param maxDepth - Maximum traversal depth (default: 10)
+     * @param order - "bfs" for breadth-first, "dfs" for depth-first
+     * @returns Object with nodes and edges arrays
+     *
+     * @example
+     * ```typescript
+     * const { nodes, edges } = await db.traverse('default', 'alice', 2);
+     * for (const node of nodes) {
+     *   console.log(`Node: ${node.id} (${node.node_type})`);
+     * }
+     * ```
+     */
+    async traverse(namespace, startNode, maxDepth = 10, order = 'bfs') {
+        this._ensureOpen();
+        const visited = new Set();
+        const nodes = [];
+        const edges = [];
+        const frontier = [[startNode, 0]];
+        while (frontier.length > 0) {
+            const [currentNode, depth] = order === 'bfs'
+                ? frontier.shift()
+                : frontier.pop();
+            if (depth > maxDepth || visited.has(currentNode)) {
+                continue;
+            }
+            visited.add(currentNode);
+            // Get node data
+            const nodeKey = `_graph/${namespace}/nodes/${currentNode}`;
+            const nodeData = await this.get(Buffer.from(nodeKey));
+            if (nodeData) {
+                nodes.push(JSON.parse(nodeData.toString()));
+            }
+            // Get outgoing edges
+            const edgePrefix = `_graph/${namespace}/edges/${currentNode}/`;
+            const edgeResults = await this.scan(edgePrefix);
+            for (const { value } of edgeResults) {
+                const edge = JSON.parse(value.toString());
+                edges.push(edge);
+                if (!visited.has(edge.to_id)) {
+                    frontier.push([edge.to_id, depth + 1]);
+                }
+            }
+        }
+        return { nodes, edges };
+    }
+    // =========================================================================
+    // Semantic Cache Operations
+    // =========================================================================
+    /**
+     * Store a value in the semantic cache with its embedding.
+     *
+     * @param cacheName - Name of the cache
+     * @param key - Cache key (for display/debugging)
+     * @param value - Value to cache
+     * @param embedding - Embedding vector for similarity matching
+     * @param ttlSeconds - Time-to-live in seconds (0 = no expiry)
+     *
+     * @example
+     * ```typescript
+     * await db.cachePut(
+     *   'llm_responses',
+     *   'What is Python?',
+     *   'Python is a programming language...',
+     *   [0.1, 0.2, 0.3, ...],  // 384-dim
+     *   3600
+     * );
+     * ```
+     */
+    async cachePut(cacheName, key, value, embedding, ttlSeconds = 0) {
+        this._ensureOpen();
+        // Hash the key for storage
+        const keyHash = Buffer.from(key).toString('hex').slice(0, 16);
+        const cacheKey = `_cache/${cacheName}/${keyHash}`;
+        const expiresAt = ttlSeconds > 0
+            ? Math.floor(Date.now() / 1000) + ttlSeconds
+            : 0;
+        const cacheValue = JSON.stringify({
+            key,
+            value,
+            embedding,
+            expires_at: expiresAt,
+        });
+        await this.put(Buffer.from(cacheKey), Buffer.from(cacheValue));
+    }
+    /**
+     * Look up a value in the semantic cache by embedding similarity.
+     *
+     * @param cacheName - Name of the cache
+     * @param queryEmbedding - Query embedding to match against
+     * @param threshold - Minimum cosine similarity threshold (0.0 to 1.0)
+     * @returns Cached value if similarity >= threshold, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const result = await db.cacheGet(
+     *   'llm_responses',
+     *   [0.12, 0.18, ...],  // Similar to "What is Python?"
+     *   0.85
+     * );
+     * if (result) {
+     *   console.log(`Cache hit: ${result}`);
+     * }
+     * ```
+     */
+    async cacheGet(cacheName, queryEmbedding, threshold = 0.85) {
+        this._ensureOpen();
+        const prefix = `_cache/${cacheName}/`;
+        const entries = await this.scan(prefix);
+        const now = Math.floor(Date.now() / 1000);
+        let bestMatch = null;
+        for (const { value } of entries) {
+            const entry = JSON.parse(value.toString());
+            // Check expiry
+            if (entry.expires_at > 0 && now > entry.expires_at) {
+                continue;
+            }
+            // Compute cosine similarity
+            if (entry.embedding && entry.embedding.length === queryEmbedding.length) {
+                const similarity = this._cosineSimilarity(queryEmbedding, entry.embedding);
+                if (similarity >= threshold) {
+                    if (!bestMatch || similarity > bestMatch.similarity) {
+                        bestMatch = { similarity, value: entry.value };
+                    }
+                }
+            }
+        }
+        return bestMatch?.value ?? null;
+    }
+    _cosineSimilarity(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        normA = Math.sqrt(normA);
+        normB = Math.sqrt(normB);
+        return normA === 0 || normB === 0 ? 0 : dot / (normA * normB);
+    }
+    // =========================================================================
+    // Trace Operations (Observability)
+    // =========================================================================
+    /**
+     * Start a new trace.
+     *
+     * @param name - Name of the trace (e.g., "user_request", "batch_job")
+     * @returns Object with traceId and rootSpanId
+     *
+     * @example
+     * ```typescript
+     * const { traceId, rootSpanId } = await db.startTrace('user_query');
+     * // ... do work ...
+     * await db.endSpan(traceId, rootSpanId, 'ok');
+     * ```
+     */
+    async startTrace(name) {
+        this._ensureOpen();
+        const traceId = `trace_${Date.now().toString(16)}${Math.random().toString(16).slice(2, 10)}`;
+        const spanId = `span_${Date.now().toString(16)}${Math.random().toString(16).slice(2, 10)}`;
+        const now = Date.now() * 1000; // microseconds
+        // Store trace
+        const traceKey = `_traces/${traceId}`;
+        const traceValue = JSON.stringify({
+            trace_id: traceId,
+            name,
+            start_us: now,
+            root_span_id: spanId,
+        });
+        await this.put(Buffer.from(traceKey), Buffer.from(traceValue));
+        // Store root span
+        const spanKey = `_traces/${traceId}/spans/${spanId}`;
+        const spanValue = JSON.stringify({
+            span_id: spanId,
+            name,
+            start_us: now,
+            parent_span_id: null,
+            status: 'active',
+        });
+        await this.put(Buffer.from(spanKey), Buffer.from(spanValue));
+        return { traceId, rootSpanId: spanId };
+    }
+    /**
+     * Start a child span within a trace.
+     *
+     * @param traceId - ID of the parent trace
+     * @param parentSpanId - ID of the parent span
+     * @param name - Name of this span
+     * @returns The new span ID
+     *
+     * @example
+     * ```typescript
+     * const { traceId, rootSpanId } = await db.startTrace('user_query');
+     * const dbSpan = await db.startSpan(traceId, rootSpanId, 'database_lookup');
+     * // ... do database work ...
+     * const duration = await db.endSpan(traceId, dbSpan, 'ok');
+     * ```
+     */
+    async startSpan(traceId, parentSpanId, name) {
+        this._ensureOpen();
+        const spanId = `span_${Date.now().toString(16)}${Math.random().toString(16).slice(2, 10)}`;
+        const now = Date.now() * 1000;
+        const spanKey = `_traces/${traceId}/spans/${spanId}`;
+        const spanValue = JSON.stringify({
+            span_id: spanId,
+            name,
+            start_us: now,
+            parent_span_id: parentSpanId,
+            status: 'active',
+        });
+        await this.put(Buffer.from(spanKey), Buffer.from(spanValue));
+        return spanId;
+    }
+    /**
+     * End a span and record its duration.
+     *
+     * @param traceId - ID of the trace
+     * @param spanId - ID of the span to end
+     * @param status - "ok", "error", or "unset"
+     * @returns Duration in microseconds
+     *
+     * @example
+     * ```typescript
+     * const duration = await db.endSpan(traceId, spanId, 'ok');
+     * console.log(`Operation took ${duration}µs`);
+     * ```
+     */
+    async endSpan(traceId, spanId, status = 'ok') {
+        this._ensureOpen();
+        const spanKey = `_traces/${traceId}/spans/${spanId}`;
+        const spanData = await this.get(Buffer.from(spanKey));
+        if (!spanData) {
+            throw new errors_1.DatabaseError(`Span not found: ${spanId}`);
+        }
+        const span = JSON.parse(spanData.toString());
+        const now = Date.now() * 1000;
+        const duration = now - span.start_us;
+        const updatedSpan = {
+            ...span,
+            status,
+            end_us: now,
+            duration_us: duration,
+        };
+        await this.put(Buffer.from(spanKey), Buffer.from(JSON.stringify(updatedSpan)));
+        return duration;
+    }
+    /**
+     * Close the database connection.
+     * If running in embedded mode, also stops the embedded server.
+     */
+    async close() {
+        if (this._closed)
+            return;
+        if (this._client) {
+            await this._client.close();
+            this._client = null;
+        }
+        // Stop embedded server if we started it
+        if (this._embeddedServerStarted) {
+            await (0, server_manager_1.stopEmbeddedServer)(this._config.path);
+            this._embeddedServerStarted = false;
+        }
+        this._closed = true;
+    }
+    // Internal methods for transaction management
+    async _beginTransaction() {
+        return this._client.beginTransaction();
+    }
+    async _commitTransaction(txnId) {
+        return this._client.commitTransaction(txnId);
+    }
+    async _abortTransaction(txnId) {
+        return this._client.abortTransaction(txnId);
+    }
+    _ensureOpen() {
+        if (this._closed) {
+            throw new errors_1.DatabaseError('Database is closed');
+        }
+        if (!this._client) {
+            throw new errors_1.DatabaseError('Database not connected');
+        }
+    }
+}
+exports.Database = Database;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"database.js","sourceRoot":"","sources":["../../src/database.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SochDB Embedded Database\n *\n * Direct database access via IPC to the SochDB server.\n * This provides the same API as the Python SDK's Database class.\n *\n * @packageDocumentation\n */\n\n// Copyright 2025 Sushanth (https://github.com/sushanthpy)\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     http://www.apache.org/licenses/LICENSE-2.0\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { DatabaseError, TransactionError } from './errors';\nimport { IpcClient } from './ipc-client';\nimport { Query } from './query';\nimport { startEmbeddedServer, stopEmbeddedServer } from './server-manager';\n\n/**\n * Configuration options for the Database.\n */\nexport interface DatabaseConfig {\n  /** Path to the database directory */\n  path: string;\n  /** Whether to create the database if it doesn't exist (default: true) */\n  createIfMissing?: boolean;\n  /** Enable WAL (Write-Ahead Logging) for durability (default: true) */\n  walEnabled?: boolean;\n  /** Sync mode: 'full' | 'normal' | 'off' (default: 'normal') */\n  syncMode?: 'full' | 'normal' | 'off';\n  /** Maximum size of the memtable before flushing (default: 64MB) */\n  memtableSizeBytes?: number;\n  /** \n   * Whether to automatically start an embedded server (default: true)\n   * Set to false if connecting to an existing external server\n   */\n  embedded?: boolean;\n}\n\n/**\n * Result of a SQL query execution.\n */\nexport interface SQLQueryResult {\n  /** Result rows */\n  rows: Array<Record<string, any>>;\n  /** Column names */\n  columns: string[];\n  /** Number of rows affected (for INSERT/UPDATE/DELETE) */\n  rowsAffected: number;\n}\n\n/**\n * Transaction handle for atomic operations.\n */\nexport class Transaction {\n  private _db: Database;\n  private _txnId: bigint | null = null;\n  private _committed = false;\n  private _aborted = false;\n\n  constructor(db: Database) {\n    this._db = db;\n  }\n\n  /**\n   * Begin the transaction.\n   * @internal\n   */\n  async begin(): Promise<void> {\n    this._txnId = await this._db['_beginTransaction']();\n  }\n\n  /**\n   * Get a value by key within this transaction.\n   */\n  async get(key: Buffer | string): Promise<Buffer | null> {\n    this._ensureActive();\n    return this._db.get(key);\n  }\n\n  /**\n   * Put a key-value pair within this transaction.\n   */\n  async put(key: Buffer | string, value: Buffer | string): Promise<void> {\n    this._ensureActive();\n    return this._db.put(key, value);\n  }\n\n  /**\n   * Delete a key within this transaction.\n   */\n  async delete(key: Buffer | string): Promise<void> {\n    this._ensureActive();\n    return this._db.delete(key);\n  }\n\n  /**\n   * Scan keys with a prefix within this transaction.\n   * @param prefix - The prefix to scan for\n   * @param end - Optional end boundary (exclusive)\n   */\n  async *scan(prefix: string | Buffer, end?: string | Buffer): AsyncGenerator<[Buffer, Buffer]> {\n    this._ensureActive();\n    // Delegate to database's scan method\n    // Transactional isolation is maintained by the underlying storage\n    for await (const entry of this._db.scanGenerator(prefix, end)) {\n      yield entry;\n    }\n  }\n\n  /**\n   * Get a value by path within this transaction.\n   */\n  async getPath(pathStr: string): Promise<Buffer | null> {\n    this._ensureActive();\n    return this._db.getPath(pathStr);\n  }\n\n  /**\n   * Put a value at a path within this transaction.\n   */\n  async putPath(pathStr: string, value: Buffer | string): Promise<void> {\n    this._ensureActive();\n    return this._db.putPath(pathStr, value);\n  }\n\n  /**\n   * Commit the transaction.\n   * \n   * After committing, an optional checkpoint is triggered to ensure writes\n   * are durable. This prevents race conditions where subsequent reads might\n   * not see committed data due to async flush timing.\n   */\n  async commit(): Promise<void> {\n    this._ensureActive();\n    if (this._txnId !== null) {\n      await this._db['_commitTransaction'](this._txnId);\n      // Trigger checkpoint to ensure durability (addresses race condition)\n      // Note: This is a trade-off between consistency and performance.\n      // For high-throughput scenarios, consider batching checkpoints.\n      await this._db.checkpoint();\n    }\n    this._committed = true;\n  }\n\n  /**\n   * Abort/rollback the transaction.\n   */\n  async abort(): Promise<void> {\n    if (this._committed || this._aborted) return;\n    if (this._txnId !== null) {\n      await this._db['_abortTransaction'](this._txnId);\n    }\n    this._aborted = true;\n  }\n\n  private _ensureActive(): void {\n    if (this._committed) {\n      throw new TransactionError('Transaction already committed');\n    }\n    if (this._aborted) {\n      throw new TransactionError('Transaction already aborted');\n    }\n  }\n}\n\n/**\n * SochDB Database client.\n *\n * Provides access to SochDB with full transaction support.\n *\n * @example\n * ```typescript\n * import { Database } from '@sushanth/sochdb';\n *\n * // Open a database\n * const db = await Database.open('./my_database');\n *\n * // Simple key-value operations\n * await db.put(Buffer.from('user:123'), Buffer.from('{\"name\": \"Alice\"}'));\n * const value = await db.get(Buffer.from('user:123'));\n *\n * // Path-native API\n * await db.putPath('users/alice/email', Buffer.from('alice@example.com'));\n * const email = await db.getPath('users/alice/email');\n *\n * // Transactions\n * await db.withTransaction(async (txn) => {\n *   await txn.put(Buffer.from('key1'), Buffer.from('value1'));\n *   await txn.put(Buffer.from('key2'), Buffer.from('value2'));\n * });\n *\n * // Clean up\n * await db.close();\n * ```\n */\nexport class Database {\n  private _client: IpcClient | null = null;\n  private _config: DatabaseConfig;\n  private _closed = false;\n  private _embeddedServerStarted = false;\n\n  private constructor(config: DatabaseConfig) {\n    this._config = {\n      createIfMissing: true,\n      walEnabled: true,\n      syncMode: 'normal',\n      memtableSizeBytes: 64 * 1024 * 1024,\n      embedded: true,  // Default to embedded mode\n      ...config,\n    };\n  }\n\n  /**\n   * Open a database at the specified path.\n   *\n   * @param pathOrConfig - Path to the database directory or configuration object\n   * @returns A new Database instance\n   *\n   * @example\n   * ```typescript\n   * // Simple usage (embedded mode - starts server automatically)\n   * const db = await Database.open('./my_database');\n   *\n   * // With configuration\n   * const db = await Database.open({\n   *   path: './my_database',\n   *   walEnabled: true,\n   *   syncMode: 'full',\n   * });\n   * \n   * // Connect to existing external server\n   * const db = await Database.open({\n   *   path: './my_database',\n   *   embedded: false,  // Don't start embedded server\n   * });\n   * ```\n   */\n  static async open(pathOrConfig: string | DatabaseConfig): Promise<Database> {\n    const config: DatabaseConfig =\n      typeof pathOrConfig === 'string' ? { path: pathOrConfig } : pathOrConfig;\n\n    // Ensure database directory exists\n    if (config.createIfMissing !== false) {\n      if (!fs.existsSync(config.path)) {\n        fs.mkdirSync(config.path, { recursive: true });\n      }\n    }\n\n    const db = new Database(config);\n\n    // Start embedded server if configured (default: true)\n    let socketPath: string;\n    if (db._config.embedded !== false) {\n      // Start embedded server and get socket path\n      socketPath = await startEmbeddedServer(config.path);\n      db._embeddedServerStarted = true;\n    } else {\n      // Connect to existing server socket\n      socketPath = path.join(config.path, 'sochdb.sock');\n    }\n\n    db._client = await IpcClient.connect(socketPath);\n\n    // Track database open event (only analytics event we send)\n    try {\n      const { trackDatabaseOpen } = await import('./analytics.js');\n      await trackDatabaseOpen(config.path, 'embedded');\n    } catch {\n      // Never let analytics break database operations\n    }\n\n    return db;\n  }\n\n  /**\n   * Get a value by key.\n   *\n   * @param key - The key to look up (Buffer or string)\n   * @returns The value as a Buffer, or null if not found\n   */\n  async get(key: Buffer | string): Promise<Buffer | null> {\n    this._ensureOpen();\n    const keyBuf = typeof key === 'string' ? Buffer.from(key) : key;\n    return this._client!.get(keyBuf);\n  }\n\n  /**\n   * Put a key-value pair.\n   *\n   * @param key - The key (Buffer or string)\n   * @param value - The value (Buffer or string)\n   */\n  async put(key: Buffer | string, value: Buffer | string): Promise<void> {\n    this._ensureOpen();\n    const keyBuf = typeof key === 'string' ? Buffer.from(key) : key;\n    const valueBuf = typeof value === 'string' ? Buffer.from(value) : value;\n    return this._client!.put(keyBuf, valueBuf);\n  }\n\n  /**\n   * Delete a key.\n   *\n   * @param key - The key to delete (Buffer or string)\n   */\n  async delete(key: Buffer | string): Promise<void> {\n    this._ensureOpen();\n    const keyBuf = typeof key === 'string' ? Buffer.from(key) : key;\n    return this._client!.delete(keyBuf);\n  }\n\n  /**\n   * Get a value by path.\n   *\n   * @param pathStr - The path (e.g., \"users/alice/email\")\n   * @returns The value as a Buffer, or null if not found\n   */\n  async getPath(pathStr: string): Promise<Buffer | null> {\n    this._ensureOpen();\n    return this._client!.getPath(pathStr);\n  }\n\n  /**\n   * Put a value at a path.\n   *\n   * @param pathStr - The path (e.g., \"users/alice/email\")\n   * @param value - The value (Buffer or string)\n   */\n  async putPath(pathStr: string, value: Buffer | string): Promise<void> {\n    this._ensureOpen();\n    const valueBuf = typeof value === 'string' ? Buffer.from(value) : value;\n    return this._client!.putPath(pathStr, valueBuf);\n  }\n\n  /**\n   * Create a query builder for the given path prefix.\n   *\n   * @param pathPrefix - The path prefix to query (e.g., \"users/\")\n   * @returns A Query builder instance\n   *\n   * @example\n   * ```typescript\n   * const results = await db.query('users/')\n   *   .limit(10)\n   *   .select(['name', 'email'])\n   *   .execute();\n   * ```\n   */\n  query(pathPrefix: string): Query {\n    this._ensureOpen();\n    return new Query(this._client!, pathPrefix);\n  }\n\n  /**\n   * Scan for keys with a prefix, returning key-value pairs.\n   * This is the preferred method for simple prefix-based iteration.\n   *\n   * @param prefix - The prefix to scan for (e.g., \"users/\", \"tenants/tenant1/\")\n   * @returns Array of key-value pairs\n   *\n   * @example\n   * ```typescript\n   * const results = await db.scan('tenants/tenant1/');\n   * for (const { key, value } of results) {\n   *   console.log(`${key.toString()}: ${value.toString()}`);\n   * }\n   * ```\n   */\n  async scan(prefix: string): Promise<Array<{ key: Buffer; value: Buffer }>> {\n    this._ensureOpen();\n    return this._client!.scan(prefix);\n  }\n\n  /**\n   * Scan for keys with a prefix using an async generator.\n   * This allows for memory-efficient iteration over large result sets.\n   *\n   * @param prefix - The prefix to scan for\n   * @param end - Optional end boundary (exclusive)\n   * @returns Async generator yielding [key, value] tuples\n   *\n   * @example\n   * ```typescript\n   * for await (const [key, value] of db.scanGenerator('users/')) {\n   *   console.log(`${key.toString()}: ${value.toString()}`);\n   * }\n   * ```\n   */\n  async *scanGenerator(prefix: string | Buffer, end?: string | Buffer): AsyncGenerator<[Buffer, Buffer]> {\n    this._ensureOpen();\n    const prefixBuf = typeof prefix === 'string' ? Buffer.from(prefix) : prefix;\n    const endBuf = end ? (typeof end === 'string' ? Buffer.from(end) : end) : undefined;\n\n    const results = await this._client!.scan(prefixBuf.toString());\n    for (const { key, value } of results) {\n      // Filter by end boundary if provided\n      if (endBuf && Buffer.compare(key, endBuf) >= 0) {\n        break;\n      }\n      yield [key, value];\n    }\n  }\n\n  /**\n   * Execute operations within a transaction.\n   *\n   * The transaction automatically commits on success or aborts on error.\n   *\n   * @param fn - Async function that receives a Transaction object\n   *\n   * @example\n   * ```typescript\n   * await db.withTransaction(async (txn) => {\n   *   await txn.put(Buffer.from('key1'), Buffer.from('value1'));\n   *   await txn.put(Buffer.from('key2'), Buffer.from('value2'));\n   *   // Automatically commits\n   * });\n   * ```\n   */\n  async withTransaction<T>(fn: (txn: Transaction) => Promise<T>): Promise<T> {\n    this._ensureOpen();\n    const txn = new Transaction(this);\n    await txn.begin();\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   * Create a new transaction.\n   *\n   * @returns A new Transaction instance\n   * @deprecated Use withTransaction() for automatic commit/abort handling\n   */\n  async transaction(): Promise<Transaction> {\n    this._ensureOpen();\n    const txn = new Transaction(this);\n    await txn.begin();\n    return txn;\n  }\n\n  /**\n   * Force a checkpoint to persist memtable to disk.\n   */\n  async checkpoint(): Promise<void> {\n    this._ensureOpen();\n    return this._client!.checkpoint();\n  }\n\n  /**\n   * Get storage statistics.\n   */\n  async stats(): Promise<{\n    memtableSizeBytes: number;\n    walSizeBytes: number;\n    activeTransactions: number;\n  }> {\n    this._ensureOpen();\n    return this._client!.stats();\n  }\n\n  /**\n   * Execute a SQL query.\n   * \n   * SochDB supports a subset of SQL for relational data stored on top of \n   * the key-value engine. Tables and rows are stored as:\n   * - Schema: _sql/tables/{table_name}/schema\n   * - Rows: _sql/tables/{table_name}/rows/{row_id}\n   * \n   * Supported SQL:\n   * - CREATE TABLE table_name (col1 TYPE, col2 TYPE, ...)\n   * - DROP TABLE table_name\n   * - INSERT INTO table_name (cols) VALUES (vals)\n   * - SELECT cols FROM table_name [WHERE ...] [ORDER BY ...] [LIMIT ...]\n   * - UPDATE table_name SET col=val [WHERE ...]\n   * - DELETE FROM table_name [WHERE ...]\n   * \n   * Supported types: INT, TEXT, FLOAT, BOOL, BLOB\n   * \n   * @param sql - SQL query string\n   * @returns SQLQueryResult with rows and metadata\n   * \n   * @example\n   * ```typescript\n   * // Create a table\n   * await db.execute(\"CREATE TABLE users (id INT PRIMARY KEY, name TEXT, age INT)\");\n   * \n   * // Insert data\n   * await db.execute(\"INSERT INTO users (id, name, age) VALUES (1, 'Alice', 30)\");\n   * \n   * // Query data\n   * const result = await db.execute(\"SELECT * FROM users WHERE age > 26\");\n   * result.rows.forEach(row => console.log(row));\n   * ```\n   */\n  async execute(sql: string): Promise<SQLQueryResult> {\n    this._ensureOpen();\n\n    // Import the SQL executor\n    const { SQLExecutor } = await import('./sql-engine.js');\n\n    // Create a database adapter for the SQL executor\n    const dbAdapter = {\n      get: (key: Buffer | string) => this.get(key),\n      put: (key: Buffer | string, value: Buffer | string) => this.put(key, value),\n      delete: (key: Buffer | string) => this.delete(key),\n      scan: (prefix: string) => this.scan(prefix),\n    };\n\n    const executor = new SQLExecutor(dbAdapter);\n    return executor.execute(sql);\n  }\n\n  // =========================================================================\n  // Static Serialization Methods\n  // =========================================================================\n\n  /**\n   * Convert records to TOON format for token-efficient LLM context.\n   * \n   * TOON format achieves 40-66% token reduction compared to JSON by using\n   * a columnar text format with minimal syntax.\n   * \n   * @param tableName - Name of the table/collection\n   * @param records - Array of objects with the data\n   * @param fields - Optional array of field names to include\n   * @returns TOON-formatted string\n   * \n   * @example\n   * ```typescript\n   * const records = [\n   *   { id: 1, name: 'Alice', email: 'alice@ex.com' },\n   *   { id: 2, name: 'Bob', email: 'bob@ex.com' }\n   * ];\n   * console.log(Database.toToon('users', records, ['name', 'email']));\n   * // users[2]{name,email}:Alice,alice@ex.com;Bob,bob@ex.com\n   * ```\n   */\n  static toToon(\n    tableName: string,\n    records: Array<Record<string, any>>,\n    fields?: string[]\n  ): string {\n    if (!records || records.length === 0) {\n      return `${tableName}[0]{}:`;\n    }\n\n    // Determine fields from first record if not specified\n    const useFields = fields ?? Object.keys(records[0]);\n\n    // Build header: table[count]{field1,field2,...}:\n    const header = `${tableName}[${records.length}]{${useFields.join(',')}}:`;\n\n    // Escape values containing delimiters\n    const escapeValue = (v: any): string => {\n      const s = v != null ? String(v) : '';\n      if (s.includes(',') || s.includes(';') || s.includes('\\n')) {\n        return `\"${s}\"`;\n      }\n      return s;\n    };\n\n    // Build rows: value1,value2;value1,value2;...\n    const rows = records\n      .map(r => useFields.map(f => escapeValue(r[f])).join(','))\n      .join(';');\n\n    return header + rows;\n  }\n\n  /**\n   * Convert records to JSON format for easy application decoding.\n   * \n   * While TOON format is optimized for LLM context (40-66% token reduction),\n   * JSON is often easier for applications to parse. Use this method when\n   * the output will be consumed by application code rather than LLMs.\n   * \n   * @param tableName - Name of the table/collection\n   * @param records - Array of objects with the data\n   * @param fields - Optional array of field names to include\n   * @param compact - If true (default), outputs minified JSON\n   * @returns JSON-formatted string\n   * \n   * @example\n   * ```typescript\n   * const records = [\n   *   { id: 1, name: 'Alice' },\n   *   { id: 2, name: 'Bob' }\n   * ];\n   * console.log(Database.toJson('users', records));\n   * // {\"table\":\"users\",\"count\":2,\"records\":[{\"id\":1,\"name\":\"Alice\"},{\"id\":2,\"name\":\"Bob\"}]}\n   * ```\n   */\n  static toJson(\n    tableName: string,\n    records: Array<Record<string, any>>,\n    fields?: string[],\n    compact: boolean = true\n  ): string {\n    if (!records || records.length === 0) {\n      return JSON.stringify({ table: tableName, count: 0, records: [] });\n    }\n\n    // Filter fields if specified\n    const filteredRecords = fields\n      ? records.map(r => {\n        const filtered: Record<string, any> = {};\n        for (const f of fields) {\n          filtered[f] = r[f];\n        }\n        return filtered;\n      })\n      : records;\n\n    const output = {\n      table: tableName,\n      count: filteredRecords.length,\n      records: filteredRecords,\n    };\n\n    return compact ? JSON.stringify(output) : JSON.stringify(output, null, 2);\n  }\n\n  /**\n   * Parse a JSON format string back to structured data.\n   * \n   * @param jsonStr - JSON-formatted string (from toJson)\n   * @returns Object with table, fields, and records\n   */\n  static fromJson(jsonStr: string): {\n    table: string;\n    fields: string[];\n    records: Array<Record<string, any>>;\n  } {\n    const data = JSON.parse(jsonStr);\n    const table = data.table ?? 'unknown';\n    const records = data.records ?? [];\n    const fields = records.length > 0 ? Object.keys(records[0]) : [];\n\n    return { table, fields, records };\n  }\n\n  // =========================================================================\n  // Graph Overlay Operations\n  // =========================================================================\n\n  /**\n   * Add a node to the graph overlay.\n   *\n   * @param namespace - Namespace for the graph\n   * @param nodeId - Unique node identifier\n   * @param nodeType - Type of node (e.g., \"person\", \"document\", \"concept\")\n   * @param properties - Optional node properties\n   *\n   * @example\n   * ```typescript\n   * await db.addNode('default', 'alice', 'person', { role: 'engineer' });\n   * await db.addNode('default', 'project_x', 'project', { status: 'active' });\n   * ```\n   */\n  async addNode(\n    namespace: string,\n    nodeId: string,\n    nodeType: string,\n    properties?: Record<string, string>\n  ): Promise<void> {\n    this._ensureOpen();\n\n    const key = `_graph/${namespace}/nodes/${nodeId}`;\n    const value = JSON.stringify({\n      id: nodeId,\n      node_type: nodeType,\n      properties: properties || {},\n    });\n\n    await this.put(Buffer.from(key), Buffer.from(value));\n  }\n\n  /**\n   * Add an edge between nodes in the graph overlay.\n   *\n   * @param namespace - Namespace for the graph\n   * @param fromId - Source node ID\n   * @param edgeType - Type of relationship\n   * @param toId - Target node ID\n   * @param properties - Optional edge properties\n   *\n   * @example\n   * ```typescript\n   * await db.addEdge('default', 'alice', 'works_on', 'project_x');\n   * await db.addEdge('default', 'alice', 'knows', 'bob', { since: '2020' });\n   * ```\n   */\n  async addEdge(\n    namespace: string,\n    fromId: string,\n    edgeType: string,\n    toId: string,\n    properties?: Record<string, string>\n  ): Promise<void> {\n    this._ensureOpen();\n\n    const key = `_graph/${namespace}/edges/${fromId}/${edgeType}/${toId}`;\n    const value = JSON.stringify({\n      from_id: fromId,\n      edge_type: edgeType,\n      to_id: toId,\n      properties: properties || {},\n    });\n\n    await this.put(Buffer.from(key), Buffer.from(value));\n  }\n\n  /**\n   * Traverse the graph from a starting node.\n   *\n   * @param namespace - Namespace for the graph\n   * @param startNode - Node ID to start traversal from\n   * @param maxDepth - Maximum traversal depth (default: 10)\n   * @param order - \"bfs\" for breadth-first, \"dfs\" for depth-first\n   * @returns Object with nodes and edges arrays\n   *\n   * @example\n   * ```typescript\n   * const { nodes, edges } = await db.traverse('default', 'alice', 2);\n   * for (const node of nodes) {\n   *   console.log(`Node: ${node.id} (${node.node_type})`);\n   * }\n   * ```\n   */\n  async traverse(\n    namespace: string,\n    startNode: string,\n    maxDepth: number = 10,\n    order: 'bfs' | 'dfs' = 'bfs'\n  ): Promise<{ nodes: any[]; edges: any[] }> {\n    this._ensureOpen();\n\n    const visited = new Set<string>();\n    const nodes: any[] = [];\n    const edges: any[] = [];\n    const frontier: Array<[string, number]> = [[startNode, 0]];\n\n    while (frontier.length > 0) {\n      const [currentNode, depth] = order === 'bfs'\n        ? frontier.shift()!\n        : frontier.pop()!;\n\n      if (depth > maxDepth || visited.has(currentNode)) {\n        continue;\n      }\n      visited.add(currentNode);\n\n      // Get node data\n      const nodeKey = `_graph/${namespace}/nodes/${currentNode}`;\n      const nodeData = await this.get(Buffer.from(nodeKey));\n      if (nodeData) {\n        nodes.push(JSON.parse(nodeData.toString()));\n      }\n\n      // Get outgoing edges\n      const edgePrefix = `_graph/${namespace}/edges/${currentNode}/`;\n      const edgeResults = await this.scan(edgePrefix);\n      for (const { value } of edgeResults) {\n        const edge = JSON.parse(value.toString());\n        edges.push(edge);\n\n        if (!visited.has(edge.to_id)) {\n          frontier.push([edge.to_id, depth + 1]);\n        }\n      }\n    }\n\n    return { nodes, edges };\n  }\n\n  // =========================================================================\n  // Semantic Cache Operations\n  // =========================================================================\n\n  /**\n   * Store a value in the semantic cache with its embedding.\n   *\n   * @param cacheName - Name of the cache\n   * @param key - Cache key (for display/debugging)\n   * @param value - Value to cache\n   * @param embedding - Embedding vector for similarity matching\n   * @param ttlSeconds - Time-to-live in seconds (0 = no expiry)\n   *\n   * @example\n   * ```typescript\n   * await db.cachePut(\n   *   'llm_responses',\n   *   'What is Python?',\n   *   'Python is a programming language...',\n   *   [0.1, 0.2, 0.3, ...],  // 384-dim\n   *   3600\n   * );\n   * ```\n   */\n  async cachePut(\n    cacheName: string,\n    key: string,\n    value: string,\n    embedding: number[],\n    ttlSeconds: number = 0\n  ): Promise<void> {\n    this._ensureOpen();\n\n    // Hash the key for storage\n    const keyHash = Buffer.from(key).toString('hex').slice(0, 16);\n    const cacheKey = `_cache/${cacheName}/${keyHash}`;\n\n    const expiresAt = ttlSeconds > 0\n      ? Math.floor(Date.now() / 1000) + ttlSeconds\n      : 0;\n\n    const cacheValue = JSON.stringify({\n      key,\n      value,\n      embedding,\n      expires_at: expiresAt,\n    });\n\n    await this.put(Buffer.from(cacheKey), Buffer.from(cacheValue));\n  }\n\n  /**\n   * Look up a value in the semantic cache by embedding similarity.\n   *\n   * @param cacheName - Name of the cache\n   * @param queryEmbedding - Query embedding to match against\n   * @param threshold - Minimum cosine similarity threshold (0.0 to 1.0)\n   * @returns Cached value if similarity >= threshold, null otherwise\n   *\n   * @example\n   * ```typescript\n   * const result = await db.cacheGet(\n   *   'llm_responses',\n   *   [0.12, 0.18, ...],  // Similar to \"What is Python?\"\n   *   0.85\n   * );\n   * if (result) {\n   *   console.log(`Cache hit: ${result}`);\n   * }\n   * ```\n   */\n  async cacheGet(\n    cacheName: string,\n    queryEmbedding: number[],\n    threshold: number = 0.85\n  ): Promise<string | null> {\n    this._ensureOpen();\n\n    const prefix = `_cache/${cacheName}/`;\n    const entries = await this.scan(prefix);\n\n    const now = Math.floor(Date.now() / 1000);\n    let bestMatch: { similarity: number; value: string } | null = null;\n\n    for (const { value } of entries) {\n      const entry = JSON.parse(value.toString());\n\n      // Check expiry\n      if (entry.expires_at > 0 && now > entry.expires_at) {\n        continue;\n      }\n\n      // Compute cosine similarity\n      if (entry.embedding && entry.embedding.length === queryEmbedding.length) {\n        const similarity = this._cosineSimilarity(queryEmbedding, entry.embedding);\n        if (similarity >= threshold) {\n          if (!bestMatch || similarity > bestMatch.similarity) {\n            bestMatch = { similarity, value: entry.value };\n          }\n        }\n      }\n    }\n\n    return bestMatch?.value ?? null;\n  }\n\n  private _cosineSimilarity(a: number[], b: number[]): number {\n    let dot = 0, normA = 0, normB = 0;\n    for (let i = 0; i < a.length; i++) {\n      dot += a[i] * b[i];\n      normA += a[i] * a[i];\n      normB += b[i] * b[i];\n    }\n    normA = Math.sqrt(normA);\n    normB = Math.sqrt(normB);\n    return normA === 0 || normB === 0 ? 0 : dot / (normA * normB);\n  }\n\n  // =========================================================================\n  // Trace Operations (Observability)\n  // =========================================================================\n\n  /**\n   * Start a new trace.\n   *\n   * @param name - Name of the trace (e.g., \"user_request\", \"batch_job\")\n   * @returns Object with traceId and rootSpanId\n   *\n   * @example\n   * ```typescript\n   * const { traceId, rootSpanId } = await db.startTrace('user_query');\n   * // ... do work ...\n   * await db.endSpan(traceId, rootSpanId, 'ok');\n   * ```\n   */\n  async startTrace(name: string): Promise<{ traceId: string; rootSpanId: string }> {\n    this._ensureOpen();\n\n    const traceId = `trace_${Date.now().toString(16)}${Math.random().toString(16).slice(2, 10)}`;\n    const spanId = `span_${Date.now().toString(16)}${Math.random().toString(16).slice(2, 10)}`;\n    const now = Date.now() * 1000; // microseconds\n\n    // Store trace\n    const traceKey = `_traces/${traceId}`;\n    const traceValue = JSON.stringify({\n      trace_id: traceId,\n      name,\n      start_us: now,\n      root_span_id: spanId,\n    });\n    await this.put(Buffer.from(traceKey), Buffer.from(traceValue));\n\n    // Store root span\n    const spanKey = `_traces/${traceId}/spans/${spanId}`;\n    const spanValue = JSON.stringify({\n      span_id: spanId,\n      name,\n      start_us: now,\n      parent_span_id: null,\n      status: 'active',\n    });\n    await this.put(Buffer.from(spanKey), Buffer.from(spanValue));\n\n    return { traceId, rootSpanId: spanId };\n  }\n\n  /**\n   * Start a child span within a trace.\n   *\n   * @param traceId - ID of the parent trace\n   * @param parentSpanId - ID of the parent span\n   * @param name - Name of this span\n   * @returns The new span ID\n   *\n   * @example\n   * ```typescript\n   * const { traceId, rootSpanId } = await db.startTrace('user_query');\n   * const dbSpan = await db.startSpan(traceId, rootSpanId, 'database_lookup');\n   * // ... do database work ...\n   * const duration = await db.endSpan(traceId, dbSpan, 'ok');\n   * ```\n   */\n  async startSpan(\n    traceId: string,\n    parentSpanId: string,\n    name: string\n  ): Promise<string> {\n    this._ensureOpen();\n\n    const spanId = `span_${Date.now().toString(16)}${Math.random().toString(16).slice(2, 10)}`;\n    const now = Date.now() * 1000;\n\n    const spanKey = `_traces/${traceId}/spans/${spanId}`;\n    const spanValue = JSON.stringify({\n      span_id: spanId,\n      name,\n      start_us: now,\n      parent_span_id: parentSpanId,\n      status: 'active',\n    });\n    await this.put(Buffer.from(spanKey), Buffer.from(spanValue));\n\n    return spanId;\n  }\n\n  /**\n   * End a span and record its duration.\n   *\n   * @param traceId - ID of the trace\n   * @param spanId - ID of the span to end\n   * @param status - \"ok\", \"error\", or \"unset\"\n   * @returns Duration in microseconds\n   *\n   * @example\n   * ```typescript\n   * const duration = await db.endSpan(traceId, spanId, 'ok');\n   * console.log(`Operation took ${duration}µs`);\n   * ```\n   */\n  async endSpan(\n    traceId: string,\n    spanId: string,\n    status: 'ok' | 'error' | 'unset' = 'ok'\n  ): Promise<number> {\n    this._ensureOpen();\n\n    const spanKey = `_traces/${traceId}/spans/${spanId}`;\n    const spanData = await this.get(Buffer.from(spanKey));\n\n    if (!spanData) {\n      throw new DatabaseError(`Span not found: ${spanId}`);\n    }\n\n    const span = JSON.parse(spanData.toString());\n    const now = Date.now() * 1000;\n    const duration = now - span.start_us;\n\n    const updatedSpan = {\n      ...span,\n      status,\n      end_us: now,\n      duration_us: duration,\n    };\n    await this.put(Buffer.from(spanKey), Buffer.from(JSON.stringify(updatedSpan)));\n\n    return duration;\n  }\n\n  /**\n   * Close the database connection.\n   * If running in embedded mode, also stops the embedded server.\n   */\n  async close(): Promise<void> {\n    if (this._closed) return;\n    if (this._client) {\n      await this._client.close();\n      this._client = null;\n    }\n    // Stop embedded server if we started it\n    if (this._embeddedServerStarted) {\n      await stopEmbeddedServer(this._config.path);\n      this._embeddedServerStarted = false;\n    }\n    this._closed = true;\n  }\n\n  // Internal methods for transaction management\n  private async _beginTransaction(): Promise<bigint> {\n    return this._client!.beginTransaction();\n  }\n\n  private async _commitTransaction(txnId: bigint): Promise<void> {\n    return this._client!.commitTransaction(txnId);\n  }\n\n  private async _abortTransaction(txnId: bigint): Promise<void> {\n    return this._client!.abortTransaction(txnId);\n  }\n\n  private _ensureOpen(): void {\n    if (this._closed) {\n      throw new DatabaseError('Database is closed');\n    }\n    if (!this._client) {\n      throw new DatabaseError('Database not connected');\n    }\n  }\n}\n"]}