@sochdb/sochdb 0.4.0

package/dist/esm/ipc-client.js

@@ -0,0 +1,505 @@
+"use strict";
+/**
+ * SochDB IPC Client
+ *
+ * Connects to a SochDB IPC server via Unix domain socket.
+ *
+ * @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.IpcClient = exports.OpCode = 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 net = __importStar(require("net"));
+const errors_1 = require("./errors");
+const query_1 = require("./query");
+/**
+ * Wire protocol opcodes.
+ */
+exports.OpCode = {
+    // Client → Server (must match sochdb-storage/src/ipc_server.rs)
+    Put: 0x01,
+    Get: 0x02,
+    Delete: 0x03,
+    BeginTxn: 0x04,
+    CommitTxn: 0x05,
+    AbortTxn: 0x06,
+    Query: 0x07,
+    CreateTable: 0x08,
+    PutPath: 0x09,
+    GetPath: 0x0A,
+    Scan: 0x0B,
+    Checkpoint: 0x0C,
+    Stats: 0x0D,
+    Ping: 0x0E,
+    // Server → Client
+    OK: 0x80,
+    Error: 0x81,
+    Value: 0x82,
+    TxnId: 0x83,
+    Row: 0x84,
+    EndStream: 0x85,
+    StatsResp: 0x86,
+    Pong: 0x87,
+};
+// Internal OpCode map for backwards compatibility
+const InternalOpCode = {
+    PUT: exports.OpCode.Put,
+    GET: exports.OpCode.Get,
+    DELETE: exports.OpCode.Delete,
+    BEGIN_TXN: exports.OpCode.BeginTxn,
+    COMMIT_TXN: exports.OpCode.CommitTxn,
+    ABORT_TXN: exports.OpCode.AbortTxn,
+    QUERY: exports.OpCode.Query,
+    PUT_PATH: exports.OpCode.PutPath,
+    GET_PATH: exports.OpCode.GetPath,
+    SCAN: exports.OpCode.Scan,
+    CHECKPOINT: exports.OpCode.Checkpoint,
+    STATS: exports.OpCode.Stats,
+    PING: exports.OpCode.Ping,
+    OK: exports.OpCode.OK,
+    ERROR: exports.OpCode.Error,
+    VALUE: exports.OpCode.Value,
+    TXN_ID: exports.OpCode.TxnId,
+    ROW: exports.OpCode.Row,
+    END_STREAM: exports.OpCode.EndStream,
+    STATS_RESP: exports.OpCode.StatsResp,
+    PONG: exports.OpCode.Pong,
+};
+const MAX_MESSAGE_SIZE = 16 * 1024 * 1024; // 16 MB
+/**
+ * IPC Client for SochDB.
+ *
+ * Connects to a SochDB server via Unix domain socket.
+ *
+ * @example
+ * ```typescript
+ * import { IpcClient } from '@sushanth/sochdb';
+ *
+ * const client = await IpcClient.connect('/tmp/sochdb.sock');
+ *
+ * await client.put(Buffer.from('key'), Buffer.from('value'));
+ * const value = await client.get(Buffer.from('key'));
+ *
+ * await client.close();
+ * ```
+ */
+class IpcClient {
+    _socket = null;
+    _config;
+    _pendingReads = [];
+    _readBuffer = Buffer.alloc(0);
+    _closed = false;
+    constructor(config) {
+        this._config = {
+            connectTimeout: 5000,
+            readTimeout: 30000,
+            ...config,
+        };
+    }
+    /**
+     * Connect to a SochDB IPC server.
+     *
+     * @param socketPath - Path to the Unix domain socket
+     * @returns A connected IpcClient instance
+     *
+     * @example
+     * ```typescript
+     * const client = await IpcClient.connect('/tmp/sochdb.sock');
+     * ```
+     */
+    static async connect(socketPath) {
+        const client = new IpcClient({ socketPath });
+        await client._connect();
+        return client;
+    }
+    async _connect() {
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection({ path: this._config.socketPath }, () => {
+                this._socket = socket;
+                resolve();
+            });
+            socket.setTimeout(this._config.connectTimeout);
+            socket.on('timeout', () => {
+                socket.destroy();
+                reject(new errors_1.ConnectionError('Connection timeout'));
+            });
+            socket.on('error', (err) => {
+                reject(new errors_1.ConnectionError(`Connection failed: ${err.message}`));
+            });
+            socket.on('data', (data) => {
+                this._readBuffer = Buffer.concat([this._readBuffer, data]);
+                this._processBuffer();
+            });
+            socket.on('close', () => {
+                this._closed = true;
+                for (const pending of this._pendingReads) {
+                    pending.reject(new errors_1.ConnectionError('Connection closed'));
+                }
+                this._pendingReads = [];
+            });
+        });
+    }
+    _processBuffer() {
+        // Process complete messages from the buffer
+        while (this._readBuffer.length >= 5 && this._pendingReads.length > 0) {
+            const length = this._readBuffer.readUInt32LE(1);
+            const totalLength = 5 + length;
+            if (this._readBuffer.length >= totalLength) {
+                const message = this._readBuffer.subarray(0, totalLength);
+                this._readBuffer = this._readBuffer.subarray(totalLength);
+                const pending = this._pendingReads.shift();
+                if (pending) {
+                    pending.resolve(message);
+                }
+            }
+            else {
+                break;
+            }
+        }
+    }
+    async _send(opcode, payload = Buffer.alloc(0)) {
+        if (this._closed || !this._socket) {
+            throw new errors_1.ConnectionError('Not connected');
+        }
+        // Encode message: opcode (1) + length (4 LE) + payload
+        const message = Buffer.alloc(5 + payload.length);
+        message.writeUInt8(opcode, 0);
+        message.writeUInt32LE(payload.length, 1);
+        payload.copy(message, 5);
+        return new Promise((resolve, reject) => {
+            this._pendingReads.push({ resolve, reject });
+            this._socket.write(message, (err) => {
+                if (err) {
+                    this._pendingReads.pop();
+                    reject(new errors_1.ConnectionError(`Write failed: ${err.message}`));
+                }
+            });
+            // Set timeout for response
+            setTimeout(() => {
+                const idx = this._pendingReads.findIndex((p) => p.resolve === resolve);
+                if (idx !== -1) {
+                    this._pendingReads.splice(idx, 1);
+                    reject(new errors_1.ConnectionError('Read timeout'));
+                }
+            }, this._config.readTimeout);
+        });
+    }
+    _parseResponse(response) {
+        const opcode = response.readUInt8(0);
+        const length = response.readUInt32LE(1);
+        const payload = response.subarray(5, 5 + length);
+        if (opcode === InternalOpCode.ERROR) {
+            throw new errors_1.ProtocolError(payload.toString('utf8'));
+        }
+        return { opcode, payload };
+    }
+    /**
+     * Encode a key for the wire protocol.
+     * @internal
+     */
+    static encodeKey(key) {
+        // Format: [length:4][op:1][key_len:4][key:...]
+        const msgLen = 1 + 4 + key.length;
+        const msg = Buffer.alloc(4 + msgLen);
+        msg.writeUInt32BE(msgLen, 0);
+        msg.writeUInt8(InternalOpCode.GET, 4);
+        msg.writeUInt32BE(key.length, 5);
+        key.copy(msg, 9);
+        return msg;
+    }
+    /**
+     * Encode a key-value pair for the wire protocol.
+     * @internal
+     */
+    static encodeKeyValue(key, value) {
+        // Format: [length:4][op:1][key_len:4][key:...][value_len:4][value:...]
+        const msgLen = 1 + 4 + key.length + 4 + value.length;
+        const msg = Buffer.alloc(4 + msgLen);
+        msg.writeUInt32BE(msgLen, 0);
+        msg.writeUInt8(InternalOpCode.PUT, 4);
+        msg.writeUInt32BE(key.length, 5);
+        key.copy(msg, 9);
+        msg.writeUInt32BE(value.length, 9 + key.length);
+        value.copy(msg, 13 + key.length);
+        return msg;
+    }
+    /**
+     * Get a value by key.
+     */
+    async get(key) {
+        const response = await this._send(InternalOpCode.GET, key);
+        const { opcode, payload } = this._parseResponse(response);
+        if (opcode === InternalOpCode.VALUE) {
+            // If payload is empty, the key doesn't exist
+            if (payload.length === 0) {
+                return null;
+            }
+            return payload;
+        }
+        return null;
+    }
+    /**
+     * Put a key-value pair.
+     */
+    async put(key, value) {
+        // Encode: key_len (4 LE) + key + value
+        const payload = Buffer.alloc(4 + key.length + value.length);
+        payload.writeUInt32LE(key.length, 0);
+        key.copy(payload, 4);
+        value.copy(payload, 4 + key.length);
+        const response = await this._send(InternalOpCode.PUT, payload);
+        this._parseResponse(response);
+    }
+    /**
+     * Delete a key.
+     */
+    async delete(key) {
+        const response = await this._send(InternalOpCode.DELETE, key);
+        this._parseResponse(response);
+    }
+    /**
+     * Get a value by path.
+     * Wire format: path_count(2 LE) + [path_len(2 LE) + path_segment]...
+     */
+    async getPath(path) {
+        // Encode path as single segment for now (could split on '/' for multi-segment)
+        const pathBuf = Buffer.from(path, 'utf8');
+        const payload = Buffer.alloc(2 + 2 + pathBuf.length);
+        payload.writeUInt16LE(1, 0); // path_count = 1
+        payload.writeUInt16LE(pathBuf.length, 2); // path_len
+        pathBuf.copy(payload, 4); // path
+        const response = await this._send(InternalOpCode.GET_PATH, payload);
+        const { opcode, payload: responsePayload } = this._parseResponse(response);
+        if (opcode === InternalOpCode.VALUE) {
+            // If payload is empty, the key doesn't exist
+            if (responsePayload.length === 0) {
+                return null;
+            }
+            return responsePayload;
+        }
+        return null;
+    }
+    /**
+     * Put a value at a path.
+     * Wire format: path_count(2 LE) + [path_len(2 LE) + path_segment]... + value
+     */
+    async putPath(path, value) {
+        const pathBuf = Buffer.from(path, 'utf8');
+        const payload = Buffer.alloc(2 + 2 + pathBuf.length + value.length);
+        payload.writeUInt16LE(1, 0); // path_count = 1
+        payload.writeUInt16LE(pathBuf.length, 2); // path_len
+        pathBuf.copy(payload, 4); // path
+        value.copy(payload, 4 + pathBuf.length); // value
+        const response = await this._send(InternalOpCode.PUT_PATH, payload);
+        this._parseResponse(response);
+    }
+    /**
+     * Execute a query and return TOON-formatted results.
+     *
+     * Wire format: path_len(2) + path + limit(4) + offset(4) + cols_count(2) + [col_len(2) + col]...
+     */
+    async query(pathPrefix, options) {
+        const opts = options || {};
+        const pathBuf = Buffer.from(pathPrefix, 'utf8');
+        const columns = opts.columns || [];
+        // Calculate payload size
+        let size = 2 + pathBuf.length + 4 + 4 + 2;
+        for (const col of columns) {
+            size += 2 + Buffer.byteLength(col, 'utf8');
+        }
+        const payload = Buffer.alloc(size);
+        let offset = 0;
+        // Path: path_len(2 LE) + path
+        payload.writeUInt16LE(pathBuf.length, offset);
+        offset += 2;
+        pathBuf.copy(payload, offset);
+        offset += pathBuf.length;
+        // Limit (4 LE) - 0 means no limit
+        payload.writeUInt32LE(opts.limit || 0, offset);
+        offset += 4;
+        // Offset (4 LE)
+        payload.writeUInt32LE(opts.offset || 0, offset);
+        offset += 4;
+        // Columns: count(2 LE) + [col_len(2 LE) + col]...
+        payload.writeUInt16LE(columns.length, offset);
+        offset += 2;
+        for (const col of columns) {
+            const colBuf = Buffer.from(col, 'utf8');
+            payload.writeUInt16LE(colBuf.length, offset);
+            offset += 2;
+            colBuf.copy(payload, offset);
+            offset += colBuf.length;
+        }
+        const response = await this._send(InternalOpCode.QUERY, payload);
+        const { payload: resultPayload } = this._parseResponse(response);
+        return resultPayload.toString('utf8');
+    }
+    /**
+     * Scan for keys with a prefix, returning key-value pairs.
+     * This is the preferred method for simple prefix-based iteration.
+     *
+     * Wire format: prefix string
+     * Response format: count(4 LE) + [key_len(2 LE) + key + val_len(4 LE) + val]...
+     */
+    async scan(prefix) {
+        const prefixBuf = Buffer.from(prefix, 'utf8');
+        const response = await this._send(InternalOpCode.SCAN, prefixBuf);
+        const { opcode, payload } = this._parseResponse(response);
+        if (opcode !== InternalOpCode.VALUE && opcode !== InternalOpCode.OK) {
+            throw new errors_1.ProtocolError(`Unexpected scan response opcode: 0x${opcode.toString(16)}`);
+        }
+        if (payload.length < 4) {
+            return []; // Empty result
+        }
+        // Parse response: count(4 LE) + [key_len(2 LE) + key + val_len(4 LE) + val]...
+        const count = payload.readUInt32LE(0);
+        const results = [];
+        let offset = 4;
+        for (let i = 0; i < count; i++) {
+            if (offset + 2 > payload.length) {
+                throw new errors_1.ProtocolError('Truncated scan response (key_len)');
+            }
+            const keyLen = payload.readUInt16LE(offset);
+            offset += 2;
+            if (offset + keyLen + 4 > payload.length) {
+                throw new errors_1.ProtocolError('Truncated scan response (key+val_len)');
+            }
+            const key = payload.subarray(offset, offset + keyLen);
+            offset += keyLen;
+            const valLen = payload.readUInt32LE(offset);
+            offset += 4;
+            if (offset + valLen > payload.length) {
+                throw new errors_1.ProtocolError('Truncated scan response (value)');
+            }
+            const value = payload.subarray(offset, offset + valLen);
+            offset += valLen;
+            results.push({ key, value });
+        }
+        return results;
+    }
+    /**
+     * Create a query builder.
+     */
+    queryBuilder(pathPrefix) {
+        return new query_1.Query(this, pathPrefix);
+    }
+    /**
+     * Begin a new transaction.
+     */
+    async beginTransaction() {
+        const response = await this._send(InternalOpCode.BEGIN_TXN);
+        const { opcode, payload } = this._parseResponse(response);
+        if (opcode === InternalOpCode.TXN_ID) {
+            return payload.readBigUInt64LE(0);
+        }
+        throw new errors_1.TransactionError('Failed to begin transaction');
+    }
+    /**
+     * Commit a transaction.
+     */
+    async commitTransaction(txnId) {
+        const payload = Buffer.alloc(8);
+        payload.writeBigUInt64LE(txnId, 0);
+        const response = await this._send(InternalOpCode.COMMIT_TXN, payload);
+        this._parseResponse(response);
+    }
+    /**
+     * Abort a transaction.
+     */
+    async abortTransaction(txnId) {
+        const payload = Buffer.alloc(8);
+        payload.writeBigUInt64LE(txnId, 0);
+        const response = await this._send(InternalOpCode.ABORT_TXN, payload);
+        this._parseResponse(response);
+    }
+    /**
+     * Force a checkpoint.
+     */
+    async checkpoint() {
+        const response = await this._send(InternalOpCode.CHECKPOINT);
+        this._parseResponse(response);
+    }
+    /**
+     * Get storage statistics.
+     */
+    async stats() {
+        const response = await this._send(InternalOpCode.STATS);
+        const { payload } = this._parseResponse(response);
+        const json = JSON.parse(payload.toString('utf8'));
+        return {
+            memtableSizeBytes: json.memtable_size_bytes || 0,
+            walSizeBytes: json.wal_size_bytes || 0,
+            activeTransactions: json.active_transactions || 0,
+        };
+    }
+    /**
+     * Ping the server.
+     */
+    async ping() {
+        try {
+            const response = await this._send(InternalOpCode.PING);
+            const { opcode } = this._parseResponse(response);
+            return opcode === InternalOpCode.PONG;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Close the connection.
+     */
+    async close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        if (this._socket) {
+            return new Promise((resolve) => {
+                this._socket.end(() => {
+                    this._socket = null;
+                    resolve();
+                });
+            });
+        }
+    }
+}
+exports.IpcClient = IpcClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ipc-client.js","sourceRoot":"","sources":["../../src/ipc-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SochDB IPC Client\n *\n * Connects to a SochDB IPC server via Unix domain socket.\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 net from 'net';\nimport { ConnectionError, ProtocolError, TransactionError } from './errors';\nimport { Query } from './query';\n\n/**\n * Wire protocol opcodes.\n */\nexport const OpCode = {\n  // Client → Server (must match sochdb-storage/src/ipc_server.rs)\n  Put: 0x01,\n  Get: 0x02,\n  Delete: 0x03,\n  BeginTxn: 0x04,\n  CommitTxn: 0x05,\n  AbortTxn: 0x06,\n  Query: 0x07,\n  CreateTable: 0x08,\n  PutPath: 0x09,\n  GetPath: 0x0A,\n  Scan: 0x0B,\n  Checkpoint: 0x0C,\n  Stats: 0x0D,\n  Ping: 0x0E,\n\n  // Server → Client\n  OK: 0x80,\n  Error: 0x81,\n  Value: 0x82,\n  TxnId: 0x83,\n  Row: 0x84,\n  EndStream: 0x85,\n  StatsResp: 0x86,\n  Pong: 0x87,\n} as const;\n\n// Internal OpCode map for backwards compatibility\nconst InternalOpCode = {\n  PUT: OpCode.Put,\n  GET: OpCode.Get,\n  DELETE: OpCode.Delete,\n  BEGIN_TXN: OpCode.BeginTxn,\n  COMMIT_TXN: OpCode.CommitTxn,\n  ABORT_TXN: OpCode.AbortTxn,\n  QUERY: OpCode.Query,\n  PUT_PATH: OpCode.PutPath,\n  GET_PATH: OpCode.GetPath,\n  SCAN: OpCode.Scan,\n  CHECKPOINT: OpCode.Checkpoint,\n  STATS: OpCode.Stats,\n  PING: OpCode.Ping,\n  OK: OpCode.OK,\n  ERROR: OpCode.Error,\n  VALUE: OpCode.Value,\n  TXN_ID: OpCode.TxnId,\n  ROW: OpCode.Row,\n  END_STREAM: OpCode.EndStream,\n  STATS_RESP: OpCode.StatsResp,\n  PONG: OpCode.Pong,\n} as const;\n\nconst MAX_MESSAGE_SIZE = 16 * 1024 * 1024; // 16 MB\n\n/**\n * Configuration options for IpcClient.\n */\nexport interface IpcClientConfig {\n  /** Path to Unix domain socket */\n  socketPath: string;\n  /** Connection timeout in milliseconds (default: 5000) */\n  connectTimeout?: number;\n  /** Read timeout in milliseconds (default: 30000) */\n  readTimeout?: number;\n}\n\n/**\n * IPC Client for SochDB.\n *\n * Connects to a SochDB server via Unix domain socket.\n *\n * @example\n * ```typescript\n * import { IpcClient } from '@sushanth/sochdb';\n *\n * const client = await IpcClient.connect('/tmp/sochdb.sock');\n *\n * await client.put(Buffer.from('key'), Buffer.from('value'));\n * const value = await client.get(Buffer.from('key'));\n *\n * await client.close();\n * ```\n */\nexport class IpcClient {\n  private _socket: net.Socket | null = null;\n  private _config: Required<IpcClientConfig>;\n  private _pendingReads: Array<{\n    resolve: (buf: Buffer) => void;\n    reject: (err: Error) => void;\n  }> = [];\n  private _readBuffer: Buffer = Buffer.alloc(0);\n  private _closed = false;\n\n  private constructor(config: IpcClientConfig) {\n    this._config = {\n      connectTimeout: 5000,\n      readTimeout: 30000,\n      ...config,\n    };\n  }\n\n  /**\n   * Connect to a SochDB IPC server.\n   *\n   * @param socketPath - Path to the Unix domain socket\n   * @returns A connected IpcClient instance\n   *\n   * @example\n   * ```typescript\n   * const client = await IpcClient.connect('/tmp/sochdb.sock');\n   * ```\n   */\n  static async connect(socketPath: string): Promise<IpcClient> {\n    const client = new IpcClient({ socketPath });\n    await client._connect();\n    return client;\n  }\n\n  private async _connect(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const socket = net.createConnection(\n        { path: this._config.socketPath },\n        () => {\n          this._socket = socket;\n          resolve();\n        }\n      );\n\n      socket.setTimeout(this._config.connectTimeout);\n\n      socket.on('timeout', () => {\n        socket.destroy();\n        reject(new ConnectionError('Connection timeout'));\n      });\n\n      socket.on('error', (err) => {\n        reject(new ConnectionError(`Connection failed: ${err.message}`));\n      });\n\n      socket.on('data', (data) => {\n        this._readBuffer = Buffer.concat([this._readBuffer, data]);\n        this._processBuffer();\n      });\n\n      socket.on('close', () => {\n        this._closed = true;\n        for (const pending of this._pendingReads) {\n          pending.reject(new ConnectionError('Connection closed'));\n        }\n        this._pendingReads = [];\n      });\n    });\n  }\n\n  private _processBuffer(): void {\n    // Process complete messages from the buffer\n    while (this._readBuffer.length >= 5 && this._pendingReads.length > 0) {\n      const length = this._readBuffer.readUInt32LE(1);\n      const totalLength = 5 + length;\n\n      if (this._readBuffer.length >= totalLength) {\n        const message = this._readBuffer.subarray(0, totalLength);\n        this._readBuffer = this._readBuffer.subarray(totalLength);\n\n        const pending = this._pendingReads.shift();\n        if (pending) {\n          pending.resolve(message);\n        }\n      } else {\n        break;\n      }\n    }\n  }\n\n  private async _send(opcode: number, payload: Buffer = Buffer.alloc(0)): Promise<Buffer> {\n    if (this._closed || !this._socket) {\n      throw new ConnectionError('Not connected');\n    }\n\n    // Encode message: opcode (1) + length (4 LE) + payload\n    const message = Buffer.alloc(5 + payload.length);\n    message.writeUInt8(opcode, 0);\n    message.writeUInt32LE(payload.length, 1);\n    payload.copy(message, 5);\n\n    return new Promise((resolve, reject) => {\n      this._pendingReads.push({ resolve, reject });\n\n      this._socket!.write(message, (err) => {\n        if (err) {\n          this._pendingReads.pop();\n          reject(new ConnectionError(`Write failed: ${err.message}`));\n        }\n      });\n\n      // Set timeout for response\n      setTimeout(() => {\n        const idx = this._pendingReads.findIndex((p) => p.resolve === resolve);\n        if (idx !== -1) {\n          this._pendingReads.splice(idx, 1);\n          reject(new ConnectionError('Read timeout'));\n        }\n      }, this._config.readTimeout);\n    });\n  }\n\n  private _parseResponse(response: Buffer): { opcode: number; payload: Buffer } {\n    const opcode = response.readUInt8(0);\n    const length = response.readUInt32LE(1);\n    const payload = response.subarray(5, 5 + length);\n\n    if (opcode === InternalOpCode.ERROR) {\n      throw new ProtocolError(payload.toString('utf8'));\n    }\n\n    return { opcode, payload };\n  }\n\n  /**\n   * Encode a key for the wire protocol.\n   * @internal\n   */\n  static encodeKey(key: Buffer): Buffer {\n    // Format: [length:4][op:1][key_len:4][key:...]\n    const msgLen = 1 + 4 + key.length;\n    const msg = Buffer.alloc(4 + msgLen);\n    msg.writeUInt32BE(msgLen, 0);\n    msg.writeUInt8(InternalOpCode.GET, 4);\n    msg.writeUInt32BE(key.length, 5);\n    key.copy(msg, 9);\n    return msg;\n  }\n\n  /**\n   * Encode a key-value pair for the wire protocol.\n   * @internal\n   */\n  static encodeKeyValue(key: Buffer, value: Buffer): Buffer {\n    // Format: [length:4][op:1][key_len:4][key:...][value_len:4][value:...]\n    const msgLen = 1 + 4 + key.length + 4 + value.length;\n    const msg = Buffer.alloc(4 + msgLen);\n    msg.writeUInt32BE(msgLen, 0);\n    msg.writeUInt8(InternalOpCode.PUT, 4);\n    msg.writeUInt32BE(key.length, 5);\n    key.copy(msg, 9);\n    msg.writeUInt32BE(value.length, 9 + key.length);\n    value.copy(msg, 13 + key.length);\n    return msg;\n  }\n\n  /**\n   * Get a value by key.\n   */\n  async get(key: Buffer): Promise<Buffer | null> {\n    const response = await this._send(InternalOpCode.GET, key);\n    const { opcode, payload } = this._parseResponse(response);\n\n    if (opcode === InternalOpCode.VALUE) {\n      // If payload is empty, the key doesn't exist\n      if (payload.length === 0) {\n        return null;\n      }\n      return payload;\n    }\n    return null;\n  }\n\n  /**\n   * Put a key-value pair.\n   */\n  async put(key: Buffer, value: Buffer): Promise<void> {\n    // Encode: key_len (4 LE) + key + value\n    const payload = Buffer.alloc(4 + key.length + value.length);\n    payload.writeUInt32LE(key.length, 0);\n    key.copy(payload, 4);\n    value.copy(payload, 4 + key.length);\n\n    const response = await this._send(InternalOpCode.PUT, payload);\n    this._parseResponse(response);\n  }\n\n  /**\n   * Delete a key.\n   */\n  async delete(key: Buffer): Promise<void> {\n    const response = await this._send(InternalOpCode.DELETE, key);\n    this._parseResponse(response);\n  }\n\n  /**\n   * Get a value by path.\n   * Wire format: path_count(2 LE) + [path_len(2 LE) + path_segment]...\n   */\n  async getPath(path: string): Promise<Buffer | null> {\n    // Encode path as single segment for now (could split on '/' for multi-segment)\n    const pathBuf = Buffer.from(path, 'utf8');\n    const payload = Buffer.alloc(2 + 2 + pathBuf.length);\n    payload.writeUInt16LE(1, 0); // path_count = 1\n    payload.writeUInt16LE(pathBuf.length, 2); // path_len\n    pathBuf.copy(payload, 4); // path\n    \n    const response = await this._send(InternalOpCode.GET_PATH, payload);\n    const { opcode, payload: responsePayload } = this._parseResponse(response);\n\n    if (opcode === InternalOpCode.VALUE) {\n      // If payload is empty, the key doesn't exist\n      if (responsePayload.length === 0) {\n        return null;\n      }\n      return responsePayload;\n    }\n    return null;\n  }\n\n  /**\n   * Put a value at a path.\n   * Wire format: path_count(2 LE) + [path_len(2 LE) + path_segment]... + value\n   */\n  async putPath(path: string, value: Buffer): Promise<void> {\n    const pathBuf = Buffer.from(path, 'utf8');\n    const payload = Buffer.alloc(2 + 2 + pathBuf.length + value.length);\n    payload.writeUInt16LE(1, 0); // path_count = 1\n    payload.writeUInt16LE(pathBuf.length, 2); // path_len\n    pathBuf.copy(payload, 4); // path\n    value.copy(payload, 4 + pathBuf.length); // value\n\n    const response = await this._send(InternalOpCode.PUT_PATH, payload);\n    this._parseResponse(response);\n  }\n\n  /**\n   * Execute a query and return TOON-formatted results.\n   * \n   * Wire format: path_len(2) + path + limit(4) + offset(4) + cols_count(2) + [col_len(2) + col]...\n   */\n  async query(\n    pathPrefix: string,\n    options?: { limit?: number; offset?: number; columns?: string[] }\n  ): Promise<string> {\n    const opts = options || {};\n    const pathBuf = Buffer.from(pathPrefix, 'utf8');\n    const columns = opts.columns || [];\n    \n    // Calculate payload size\n    let size = 2 + pathBuf.length + 4 + 4 + 2;\n    for (const col of columns) {\n      size += 2 + Buffer.byteLength(col, 'utf8');\n    }\n    \n    const payload = Buffer.alloc(size);\n    let offset = 0;\n    \n    // Path: path_len(2 LE) + path\n    payload.writeUInt16LE(pathBuf.length, offset);\n    offset += 2;\n    pathBuf.copy(payload, offset);\n    offset += pathBuf.length;\n    \n    // Limit (4 LE) - 0 means no limit\n    payload.writeUInt32LE(opts.limit || 0, offset);\n    offset += 4;\n    \n    // Offset (4 LE)\n    payload.writeUInt32LE(opts.offset || 0, offset);\n    offset += 4;\n    \n    // Columns: count(2 LE) + [col_len(2 LE) + col]...\n    payload.writeUInt16LE(columns.length, offset);\n    offset += 2;\n    for (const col of columns) {\n      const colBuf = Buffer.from(col, 'utf8');\n      payload.writeUInt16LE(colBuf.length, offset);\n      offset += 2;\n      colBuf.copy(payload, offset);\n      offset += colBuf.length;\n    }\n\n    const response = await this._send(InternalOpCode.QUERY, payload);\n    const { payload: resultPayload } = this._parseResponse(response);\n\n    return resultPayload.toString('utf8');\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   * Wire format: prefix string\n   * Response format: count(4 LE) + [key_len(2 LE) + key + val_len(4 LE) + val]...\n   */\n  async scan(prefix: string): Promise<Array<{ key: Buffer; value: Buffer }>> {\n    const prefixBuf = Buffer.from(prefix, 'utf8');\n    const response = await this._send(InternalOpCode.SCAN, prefixBuf);\n    const { opcode, payload } = this._parseResponse(response);\n\n    if (opcode !== InternalOpCode.VALUE && opcode !== InternalOpCode.OK) {\n      throw new ProtocolError(`Unexpected scan response opcode: 0x${opcode.toString(16)}`);\n    }\n\n    if (payload.length < 4) {\n      return []; // Empty result\n    }\n\n    // Parse response: count(4 LE) + [key_len(2 LE) + key + val_len(4 LE) + val]...\n    const count = payload.readUInt32LE(0);\n    const results: Array<{ key: Buffer; value: Buffer }> = [];\n    let offset = 4;\n\n    for (let i = 0; i < count; i++) {\n      if (offset + 2 > payload.length) {\n        throw new ProtocolError('Truncated scan response (key_len)');\n      }\n      const keyLen = payload.readUInt16LE(offset);\n      offset += 2;\n\n      if (offset + keyLen + 4 > payload.length) {\n        throw new ProtocolError('Truncated scan response (key+val_len)');\n      }\n      const key = payload.subarray(offset, offset + keyLen);\n      offset += keyLen;\n\n      const valLen = payload.readUInt32LE(offset);\n      offset += 4;\n\n      if (offset + valLen > payload.length) {\n        throw new ProtocolError('Truncated scan response (value)');\n      }\n      const value = payload.subarray(offset, offset + valLen);\n      offset += valLen;\n\n      results.push({ key, value });\n    }\n\n    return results;\n  }\n\n  /**\n   * Create a query builder.\n   */\n  queryBuilder(pathPrefix: string): Query {\n    return new Query(this, pathPrefix);\n  }\n\n  /**\n   * Begin a new transaction.\n   */\n  async beginTransaction(): Promise<bigint> {\n    const response = await this._send(InternalOpCode.BEGIN_TXN);\n    const { opcode, payload } = this._parseResponse(response);\n\n    if (opcode === InternalOpCode.TXN_ID) {\n      return payload.readBigUInt64LE(0);\n    }\n    throw new TransactionError('Failed to begin transaction');\n  }\n\n  /**\n   * Commit a transaction.\n   */\n  async commitTransaction(txnId: bigint): Promise<void> {\n    const payload = Buffer.alloc(8);\n    payload.writeBigUInt64LE(txnId, 0);\n    const response = await this._send(InternalOpCode.COMMIT_TXN, payload);\n    this._parseResponse(response);\n  }\n\n  /**\n   * Abort a transaction.\n   */\n  async abortTransaction(txnId: bigint): Promise<void> {\n    const payload = Buffer.alloc(8);\n    payload.writeBigUInt64LE(txnId, 0);\n    const response = await this._send(InternalOpCode.ABORT_TXN, payload);\n    this._parseResponse(response);\n  }\n\n  /**\n   * Force a checkpoint.\n   */\n  async checkpoint(): Promise<void> {\n    const response = await this._send(InternalOpCode.CHECKPOINT);\n    this._parseResponse(response);\n  }\n\n  /**\n   * Get storage statistics.\n   */\n  async stats(): Promise<{\n    memtableSizeBytes: number;\n    walSizeBytes: number;\n    activeTransactions: number;\n  }> {\n    const response = await this._send(InternalOpCode.STATS);\n    const { payload } = this._parseResponse(response);\n    const json = JSON.parse(payload.toString('utf8'));\n    return {\n      memtableSizeBytes: json.memtable_size_bytes || 0,\n      walSizeBytes: json.wal_size_bytes || 0,\n      activeTransactions: json.active_transactions || 0,\n    };\n  }\n\n  /**\n   * Ping the server.\n   */\n  async ping(): Promise<boolean> {\n    try {\n      const response = await this._send(InternalOpCode.PING);\n      const { opcode } = this._parseResponse(response);\n      return opcode === InternalOpCode.PONG;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Close the connection.\n   */\n  async close(): Promise<void> {\n    if (this._closed) return;\n    this._closed = true;\n\n    if (this._socket) {\n      return new Promise((resolve) => {\n        this._socket!.end(() => {\n          this._socket = null;\n          resolve();\n        });\n      });\n    }\n  }\n}\n"]}