@sochdb/sochdb 0.4.0

package/dist/cjs/embedded/transaction.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedTransaction = void 0;
+const errors_1 = require("../errors");
+const bindings_1 = require("./ffi/bindings");
+const koffi = __importStar(require("koffi"));
+class EmbeddedTransaction {
+    constructor(db, dbHandle, txnHandle) {
+        this.committed = false;
+        this.aborted = false;
+        this.db = db;
+        this.dbHandle = dbHandle;
+        this.txnHandle = txnHandle;
+        this.bindings = bindings_1.NativeBindings.getInstance();
+    }
+    async put(key, value) {
+        this.ensureActive();
+        const res = this.bindings.sochdb_put(this.dbHandle, this.txnHandle, key, key.length, value, value.length);
+        if (res !== 0) {
+            throw new errors_1.DatabaseError('Failed to put value');
+        }
+    }
+    async get(key) {
+        this.ensureActive();
+        const outPtr = [null];
+        const outLen = [0];
+        // returns 0 on success, 1 on not found, -1 on error
+        const res = this.bindings.sochdb_get(this.dbHandle, this.txnHandle, key, key.length, outPtr, outLen);
+        if (res === 1) { // Not found
+            return null;
+        }
+        if (res !== 0) {
+            throw new errors_1.DatabaseError('Failed to get value');
+        }
+        // Copy buffer
+        const ptr = outPtr[0];
+        const len = outLen[0];
+        const buffer = Buffer.from(koffi.decode(ptr, 'uint8', len));
+        // Free native memory
+        this.bindings.sochdb_free_bytes(ptr, len);
+        return buffer;
+    }
+    async delete(key) {
+        this.ensureActive();
+        const res = this.bindings.sochdb_delete(this.dbHandle, this.txnHandle, key, key.length);
+        if (res !== 0) {
+            throw new errors_1.DatabaseError('Failed to delete value');
+        }
+    }
+    async putPath(path, value) {
+        this.ensureActive();
+        const res = this.bindings.sochdb_put_path(this.dbHandle, this.txnHandle, path, value, value.length);
+        if (res !== 0) {
+            throw new errors_1.DatabaseError('Failed to put path');
+        }
+    }
+    async getPath(path) {
+        this.ensureActive();
+        const outPtr = [null];
+        const outLen = [0];
+        const res = this.bindings.sochdb_get_path(this.dbHandle, this.txnHandle, path, outPtr, outLen);
+        if (res === 1) {
+            return null;
+        }
+        if (res !== 0) {
+            throw new errors_1.DatabaseError('Failed to get path');
+        }
+        const ptr = outPtr[0];
+        const len = outLen[0];
+        const buffer = Buffer.from(koffi.decode(ptr, 'uint8', len));
+        this.bindings.sochdb_free_bytes(ptr, len);
+        return buffer;
+    }
+    async *scanPrefix(prefix) {
+        this.ensureActive();
+        const iter = this.bindings.sochdb_scan_prefix(this.dbHandle, this.txnHandle, prefix, prefix.length);
+        if (!iter)
+            return;
+        try {
+            const keyPtr = [null];
+            const keyLen = [0];
+            const valPtr = [null];
+            const valLen = [0];
+            while (true) {
+                // Returns 0 on success, 1 on done, -1 on error
+                const res = this.bindings.sochdb_iterator_next(iter, keyPtr, keyLen, valPtr, valLen);
+                if (res === 1)
+                    break; // Done
+                if (res !== 0)
+                    throw new errors_1.DatabaseError('Scan failed');
+                // Decode key
+                const k = Buffer.from(koffi.decode(keyPtr[0], 'uint8', keyLen[0]));
+                // koffi automatically handles pointers, but here we received a pointer value into keyPtr[0]
+                // Wait, keyPtr is passed as out(pointer(uint8*)).
+                // So keyPtr[0] IS the pointer.
+                // Rust scan_next allocates new boxed slices for key and value?
+                // Yes: `let mut key_buf = key.into_boxed_slice();`
+                // So we own it and must free it?
+                // `let _ = Box::into_raw(key_buf);` -> leaks.
+                // But `sochdb_scan_next` doesn't seem to export a free function for these individual items?
+                // Wait, `sochdb_scan_next` returns them. Does the caller free them?
+                // Usually yes. `NativeBindings` has `sochdb_free_bytes`.
+                this.bindings.sochdb_free_bytes(keyPtr[0], keyLen[0]);
+                // Decode value 
+                const v = Buffer.from(koffi.decode(valPtr[0], 'uint8', valLen[0]));
+                this.bindings.sochdb_free_bytes(valPtr[0], valLen[0]);
+                yield [k, v];
+            }
+        }
+        finally {
+            this.bindings.sochdb_iterator_close(iter);
+        }
+    }
+    async commit() {
+        this.ensureActive();
+        const result = this.bindings.sochdb_commit(this.dbHandle, this.txnHandle);
+        this.committed = true;
+        if (result.error_code !== 0) {
+            // -1 indicates error, -2 indicates SSI conflict
+            throw new errors_1.TransactionError(`Transaction failed to commit (Code ${result.error_code})`);
+        }
+    }
+    async abort() {
+        if (!this.isActive())
+            return;
+        this.bindings.sochdb_abort(this.dbHandle, this.txnHandle);
+        this.aborted = true;
+    }
+    isActive() {
+        return !this.committed && !this.aborted;
+    }
+    ensureActive() {
+        if (!this.isActive()) {
+            throw new errors_1.TransactionError('Transaction is no longer active');
+        }
+    }
+}
+exports.EmbeddedTransaction = EmbeddedTransaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/embedded/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionError, DatabaseError } from '../errors';\nimport { NativeBindings } from './ffi/bindings';\nimport { EmbeddedDatabase } from './database';\nimport * as koffi from 'koffi';\n\nexport class EmbeddedTransaction {\n    private db: EmbeddedDatabase;\n    private dbHandle: any;\n    private txnHandle: any; // Now a Struct object (C_TxnHandle)\n    private bindings: NativeBindings;\n    private committed = false;\n    private aborted = false;\n\n    constructor(db: EmbeddedDatabase, dbHandle: any, txnHandle: any) {\n        this.db = db;\n        this.dbHandle = dbHandle;\n        this.txnHandle = txnHandle;\n        this.bindings = NativeBindings.getInstance();\n    }\n\n    async put(key: Buffer, value: Buffer): Promise<void> {\n        this.ensureActive();\n        const res = this.bindings.sochdb_put(this.dbHandle, this.txnHandle, key, key.length, value, value.length);\n        if (res !== 0) {\n            throw new DatabaseError('Failed to put value');\n        }\n    }\n\n    async get(key: Buffer): Promise<Buffer | null> {\n        this.ensureActive();\n\n        const outPtr = [null];\n        const outLen = [0];\n\n        // returns 0 on success, 1 on not found, -1 on error\n        const res = this.bindings.sochdb_get(this.dbHandle, this.txnHandle, key, key.length, outPtr, outLen);\n\n        if (res === 1) { // Not found\n            return null;\n        }\n        if (res !== 0) {\n            throw new DatabaseError('Failed to get value');\n        }\n\n        // Copy buffer\n        const ptr = outPtr[0];\n        const len = outLen[0];\n        const buffer = Buffer.from(koffi.decode(ptr, 'uint8', len));\n\n        // Free native memory\n        this.bindings.sochdb_free_bytes(ptr, len);\n\n        return buffer;\n    }\n\n    async delete(key: Buffer): Promise<void> {\n        this.ensureActive();\n        const res = this.bindings.sochdb_delete(this.dbHandle, this.txnHandle, key, key.length);\n        if (res !== 0) {\n            throw new DatabaseError('Failed to delete value');\n        }\n    }\n\n    async putPath(path: string, value: Buffer): Promise<void> {\n        this.ensureActive();\n        const res = this.bindings.sochdb_put_path(this.dbHandle, this.txnHandle, path, value, value.length);\n        if (res !== 0) {\n            throw new DatabaseError('Failed to put path');\n        }\n    }\n\n    async getPath(path: string): Promise<Buffer | null> {\n        this.ensureActive();\n\n        const outPtr = [null];\n        const outLen = [0];\n\n        const res = this.bindings.sochdb_get_path(this.dbHandle, this.txnHandle, path, outPtr, outLen);\n\n        if (res === 1) {\n            return null;\n        }\n        if (res !== 0) {\n            throw new DatabaseError('Failed to get path');\n        }\n\n        const ptr = outPtr[0];\n        const len = outLen[0];\n        const buffer = Buffer.from(koffi.decode(ptr, 'uint8', len));\n        this.bindings.sochdb_free_bytes(ptr, len);\n\n        return buffer;\n    }\n\n    async *scanPrefix(prefix: Buffer): AsyncGenerator<[Buffer, Buffer]> {\n        this.ensureActive();\n\n        const iter = this.bindings.sochdb_scan_prefix(this.dbHandle, this.txnHandle, prefix, prefix.length);\n        if (!iter) return;\n\n        try {\n            const keyPtr = [null];\n            const keyLen = [0];\n            const valPtr = [null];\n            const valLen = [0];\n\n            while (true) {\n                // Returns 0 on success, 1 on done, -1 on error\n                const res = this.bindings.sochdb_iterator_next(iter, keyPtr, keyLen, valPtr, valLen);\n                if (res === 1) break; // Done\n                if (res !== 0) throw new DatabaseError('Scan failed');\n\n                // Decode key\n                const k = Buffer.from(koffi.decode(keyPtr[0], 'uint8', keyLen[0]));\n                // koffi automatically handles pointers, but here we received a pointer value into keyPtr[0]\n                // Wait, keyPtr is passed as out(pointer(uint8*)).\n                // So keyPtr[0] IS the pointer.\n\n                // Rust scan_next allocates new boxed slices for key and value?\n                // Yes: `let mut key_buf = key.into_boxed_slice();`\n                // So we own it and must free it?\n                // `let _ = Box::into_raw(key_buf);` -> leaks.\n                // But `sochdb_scan_next` doesn't seem to export a free function for these individual items?\n                // Wait, `sochdb_scan_next` returns them. Does the caller free them?\n                // Usually yes. `NativeBindings` has `sochdb_free_bytes`.\n\n                this.bindings.sochdb_free_bytes(keyPtr[0], keyLen[0]);\n\n                // Decode value \n                const v = Buffer.from(koffi.decode(valPtr[0], 'uint8', valLen[0]));\n                this.bindings.sochdb_free_bytes(valPtr[0], valLen[0]);\n\n                yield [k, v];\n            }\n        } finally {\n            this.bindings.sochdb_iterator_close(iter);\n        }\n    }\n\n    async commit(): Promise<void> {\n        this.ensureActive();\n\n        const result = this.bindings.sochdb_commit(this.dbHandle, this.txnHandle);\n        this.committed = true;\n\n        if (result.error_code !== 0) {\n            // -1 indicates error, -2 indicates SSI conflict\n            throw new TransactionError(`Transaction failed to commit (Code ${result.error_code})`);\n        }\n    }\n\n    async abort(): Promise<void> {\n        if (!this.isActive()) return;\n\n        this.bindings.sochdb_abort(this.dbHandle, this.txnHandle);\n        this.aborted = true;\n    }\n\n    private isActive(): boolean {\n        return !this.committed && !this.aborted;\n    }\n\n    private ensureActive(): void {\n        if (!this.isActive()) {\n            throw new TransactionError('Transaction is no longer active');\n        }\n    }\n}\n"]}

package/dist/cjs/errors.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * SochDB Error Classes
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseError = exports.ProtocolError = exports.TransactionError = exports.ConnectionError = exports.SochDBError = 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
+/**
+ * Base error class for all SochDB errors.
+ */
+class SochDBError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SochDBError';
+        Object.setPrototypeOf(this, SochDBError.prototype);
+    }
+}
+exports.SochDBError = SochDBError;
+/**
+ * Error thrown when connection to the database fails.
+ */
+class ConnectionError extends SochDBError {
+    constructor(message) {
+        super(message);
+        this.name = 'ConnectionError';
+        Object.setPrototypeOf(this, ConnectionError.prototype);
+    }
+}
+exports.ConnectionError = ConnectionError;
+/**
+ * Error thrown when a transaction operation fails.
+ */
+class TransactionError extends SochDBError {
+    constructor(message) {
+        super(message);
+        this.name = 'TransactionError';
+        Object.setPrototypeOf(this, TransactionError.prototype);
+    }
+}
+exports.TransactionError = TransactionError;
+/**
+ * Error thrown when there's a protocol error in IPC communication.
+ */
+class ProtocolError extends SochDBError {
+    constructor(message) {
+        super(message);
+        this.name = 'ProtocolError';
+        Object.setPrototypeOf(this, ProtocolError.prototype);
+    }
+}
+exports.ProtocolError = ProtocolError;
+/**
+ * Error thrown when a database operation fails.
+ */
+class DatabaseError extends SochDBError {
+    constructor(message) {
+        super(message);
+        this.name = 'DatabaseError';
+        Object.setPrototypeOf(this, DatabaseError.prototype);
+    }
+}
+exports.DatabaseError = DatabaseError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/format.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatCapabilities = exports.CanonicalFormat = exports.ContextFormat = exports.WireFormat = exports.FormatConversionError = void 0;
+/**
+ * Unified Output Format Semantics
+ *
+ * Provides format enums for query results and LLM context packaging.
+ * This mirrors the Rust sochdb-client format module for consistency.
+ */
+/**
+ * Error when format conversion fails.
+ */
+class FormatConversionError extends Error {
+    constructor(fromFormat, toFormat, reason) {
+        super(`Cannot convert ${fromFormat} to ${toFormat}: ${reason}`);
+        this.fromFormat = fromFormat;
+        this.toFormat = toFormat;
+        this.reason = reason;
+        this.name = 'FormatConversionError';
+    }
+}
+exports.FormatConversionError = FormatConversionError;
+/**
+ * Output format for query results sent to clients.
+ *
+ * These formats are optimized for transmission efficiency and
+ * client-side processing.
+ */
+var WireFormat;
+(function (WireFormat) {
+    /**
+     * TOON format (default, 40-66% fewer tokens than JSON).
+     * Optimized for LLM consumption.
+     */
+    WireFormat["TOON"] = "toon";
+    /**
+     * Standard JSON for compatibility.
+     */
+    WireFormat["JSON"] = "json";
+    /**
+     * Raw columnar format for analytics.
+     * More efficient for large result sets with projection pushdown.
+     */
+    WireFormat["COLUMNAR"] = "columnar";
+})(WireFormat || (exports.WireFormat = WireFormat = {}));
+(function (WireFormat) {
+    /**
+     * Parse format from string.
+     */
+    function fromString(s) {
+        const lower = s.toLowerCase();
+        switch (lower) {
+            case 'toon':
+                return WireFormat.TOON;
+            case 'json':
+                return WireFormat.JSON;
+            case 'columnar':
+            case 'column':
+                return WireFormat.COLUMNAR;
+            default:
+                throw new FormatConversionError(s, 'WireFormat', `Unknown format '${s}'. Valid: toon, json, columnar`);
+        }
+    }
+    WireFormat.fromString = fromString;
+})(WireFormat || (exports.WireFormat = WireFormat = {}));
+/**
+ * Output format for LLM context packaging.
+ *
+ * These formats are optimized for readability and token efficiency
+ * when constructing prompts for language models.
+ */
+var ContextFormat;
+(function (ContextFormat) {
+    /**
+     * TOON format (default, token-efficient).
+     * Structured data with minimal syntax overhead.
+     */
+    ContextFormat["TOON"] = "toon";
+    /**
+     * JSON format.
+     * Widely understood by LLMs, good for structured data.
+     */
+    ContextFormat["JSON"] = "json";
+    /**
+     * Markdown format.
+     * Best for human-readable context with formatting.
+     */
+    ContextFormat["MARKDOWN"] = "markdown";
+})(ContextFormat || (exports.ContextFormat = ContextFormat = {}));
+(function (ContextFormat) {
+    /**
+     * Parse format from string.
+     */
+    function fromString(s) {
+        const lower = s.toLowerCase();
+        switch (lower) {
+            case 'toon':
+                return ContextFormat.TOON;
+            case 'json':
+                return ContextFormat.JSON;
+            case 'markdown':
+            case 'md':
+                return ContextFormat.MARKDOWN;
+            default:
+                throw new FormatConversionError(s, 'ContextFormat', `Unknown format '${s}'. Valid: toon, json, markdown`);
+        }
+    }
+    ContextFormat.fromString = fromString;
+})(ContextFormat || (exports.ContextFormat = ContextFormat = {}));
+/**
+ * Canonical storage format (server-side only).
+ *
+ * This is the format used for internal storage and is optimized
+ * for storage efficiency and query performance.
+ */
+var CanonicalFormat;
+(function (CanonicalFormat) {
+    /**
+     * TOON canonical format.
+     */
+    CanonicalFormat["TOON"] = "toon";
+})(CanonicalFormat || (exports.CanonicalFormat = CanonicalFormat = {}));
+/**
+ * Helper to check format capabilities and conversions.
+ */
+class FormatCapabilities {
+    /**
+     * Convert WireFormat to ContextFormat if compatible.
+     */
+    static wireToContext(wire) {
+        switch (wire) {
+            case WireFormat.TOON:
+                return ContextFormat.TOON;
+            case WireFormat.JSON:
+                return ContextFormat.JSON;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Convert ContextFormat to WireFormat if compatible.
+     */
+    static contextToWire(ctx) {
+        switch (ctx) {
+            case ContextFormat.TOON:
+                return WireFormat.TOON;
+            case ContextFormat.JSON:
+                return WireFormat.JSON;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Check if format supports round-trip: decode(encode(x)) = x.
+     */
+    static supportsRoundTrip(fmt) {
+        return fmt === WireFormat.TOON || fmt === WireFormat.JSON;
+    }
+}
+exports.FormatCapabilities = FormatCapabilities;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/format.ts"],"names":[],"mappings":"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","sourcesContent":["/**\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 *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Unified Output Format Semantics\n * \n * Provides format enums for query results and LLM context packaging.\n * This mirrors the Rust sochdb-client format module for consistency.\n */\n\n/**\n * Error when format conversion fails.\n */\nexport class FormatConversionError extends Error {\n  constructor(\n    public fromFormat: string,\n    public toFormat: string,\n    public reason: string\n  ) {\n    super(`Cannot convert ${fromFormat} to ${toFormat}: ${reason}`);\n    this.name = 'FormatConversionError';\n  }\n}\n\n/**\n * Output format for query results sent to clients.\n * \n * These formats are optimized for transmission efficiency and\n * client-side processing.\n */\nexport enum WireFormat {\n  /**\n   * TOON format (default, 40-66% fewer tokens than JSON).\n   * Optimized for LLM consumption.\n   */\n  TOON = 'toon',\n\n  /**\n   * Standard JSON for compatibility.\n   */\n  JSON = 'json',\n\n  /**\n   * Raw columnar format for analytics.\n   * More efficient for large result sets with projection pushdown.\n   */\n  COLUMNAR = 'columnar',\n}\n\nexport namespace WireFormat {\n  /**\n   * Parse format from string.\n   */\n  export function fromString(s: string): WireFormat {\n    const lower = s.toLowerCase();\n    switch (lower) {\n      case 'toon':\n        return WireFormat.TOON;\n      case 'json':\n        return WireFormat.JSON;\n      case 'columnar':\n      case 'column':\n        return WireFormat.COLUMNAR;\n      default:\n        throw new FormatConversionError(\n          s,\n          'WireFormat',\n          `Unknown format '${s}'. Valid: toon, json, columnar`\n        );\n    }\n  }\n}\n\n/**\n * Output format for LLM context packaging.\n * \n * These formats are optimized for readability and token efficiency\n * when constructing prompts for language models.\n */\nexport enum ContextFormat {\n  /**\n   * TOON format (default, token-efficient).\n   * Structured data with minimal syntax overhead.\n   */\n  TOON = 'toon',\n\n  /**\n   * JSON format.\n   * Widely understood by LLMs, good for structured data.\n   */\n  JSON = 'json',\n\n  /**\n   * Markdown format.\n   * Best for human-readable context with formatting.\n   */\n  MARKDOWN = 'markdown',\n}\n\nexport namespace ContextFormat {\n  /**\n   * Parse format from string.\n   */\n  export function fromString(s: string): ContextFormat {\n    const lower = s.toLowerCase();\n    switch (lower) {\n      case 'toon':\n        return ContextFormat.TOON;\n      case 'json':\n        return ContextFormat.JSON;\n      case 'markdown':\n      case 'md':\n        return ContextFormat.MARKDOWN;\n      default:\n        throw new FormatConversionError(\n          s,\n          'ContextFormat',\n          `Unknown format '${s}'. Valid: toon, json, markdown`\n        );\n    }\n  }\n}\n\n/**\n * Canonical storage format (server-side only).\n * \n * This is the format used for internal storage and is optimized\n * for storage efficiency and query performance.\n */\nexport enum CanonicalFormat {\n  /**\n   * TOON canonical format.\n   */\n  TOON = 'toon',\n}\n\n/**\n * Helper to check format capabilities and conversions.\n */\nexport class FormatCapabilities {\n  /**\n   * Convert WireFormat to ContextFormat if compatible.\n   */\n  static wireToContext(wire: WireFormat): ContextFormat | null {\n    switch (wire) {\n      case WireFormat.TOON:\n        return ContextFormat.TOON;\n      case WireFormat.JSON:\n        return ContextFormat.JSON;\n      default:\n        return null;\n    }\n  }\n\n  /**\n   * Convert ContextFormat to WireFormat if compatible.\n   */\n  static contextToWire(ctx: ContextFormat): WireFormat | null {\n    switch (ctx) {\n      case ContextFormat.TOON:\n        return WireFormat.TOON;\n      case ContextFormat.JSON:\n        return WireFormat.JSON;\n      default:\n        return null;\n    }\n  }\n\n  /**\n   * Check if format supports round-trip: decode(encode(x)) = x.\n   */\n  static supportsRoundTrip(fmt: WireFormat): boolean {\n    return fmt === WireFormat.TOON || fmt === WireFormat.JSON;\n  }\n}\n"]}