@meshagent/meshagent 0.36.3 → 0.37.1

package/dist/esm/database-client.js

@@ -1,7 +1,103 @@
 import { DataType } from "./data-types";
 import { RoomServerException } from "./room-server-client";
 import { ControlContent, ErrorContent, JsonContent } from "./response";
+export class DatabaseValueEncoder {
+}
+export class DatabaseExpression extends DatabaseValueEncoder {
+    constructor(expression) {
+        super();
+        const normalized = expression.trim();
+        if (normalized === "") {
+            throw new TypeError("database expression must not be empty");
+        }
+        this.expression = normalized;
+    }
+    encodeDatabaseValue() {
+        return {
+            expression: this.expression,
+        };
+    }
+    toString() {
+        return this.expression;
+    }
+}
+export class DatabaseDate extends DatabaseValueEncoder {
+    constructor(value) {
+        super();
+        const normalized = value.trim();
+        const parsed = new Date(`${normalized}T00:00:00Z`);
+        if (!ISO_DATE_REGEX.test(normalized) || Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== normalized) {
+            throw new TypeError("invalid database date format");
+        }
+        this.value = normalized;
+    }
+    encodeDatabaseValue() {
+        return {
+            date: this.value,
+        };
+    }
+    toString() {
+        return this.value;
+    }
+}
+export class DatabaseStruct extends DatabaseValueEncoder {
+    constructor(fields) {
+        super();
+        this.fields = Object.fromEntries(Object.entries(fields).map(([key, value]) => {
+            if (typeof key !== "string") {
+                throw new TypeError("database struct keys must be strings");
+            }
+            return [key, value];
+        }));
+    }
+    toJson() {
+        return Object.fromEntries(Object.entries(this.fields).map(([key, value]) => [key, encodeRecordValue(value)]));
+    }
+    encodeDatabaseValue() {
+        return {
+            struct: this.toJson(),
+        };
+    }
+}
+export class DatabaseJson extends DatabaseValueEncoder {
+    constructor(value) {
+        super();
+        this.value = normalizeDatabaseJsonValue(value);
+    }
+    toJson() {
+        return this.value;
+    }
+    encodeDatabaseValue() {
+        return {
+            json: this.value,
+        };
+    }
+}
 const globalScope = globalThis;
+const UUID_HEX_REGEX = /^[0-9a-f]{32}$/;
+const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+function normalizeUuidHex(value) {
+    const normalized = value.trim().toLowerCase().replace(/-/g, "");
+    if (!UUID_HEX_REGEX.test(normalized)) {
+        throw new RoomServerException("invalid uuid format");
+    }
+    return normalized;
+}
+function formatUuidHex(value) {
+    return (`${value.substring(0, 8)}-` +
+        `${value.substring(8, 12)}-` +
+        `${value.substring(12, 16)}-` +
+        `${value.substring(16, 20)}-` +
+        `${value.substring(20)}`);
+}
+export class DatabaseUuid {
+    constructor(value) {
+        this.value = formatUuidHex(normalizeUuidHex(value));
+    }
+    toString() {
+        return this.value;
+    }
+}
 function bytesToBase64(bytes) {
     if (globalScope.Buffer) {
         return globalScope.Buffer.from(bytes).toString("base64");
@@ -32,13 +128,32 @@ function base64ToBytes(base64) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isPlainRecord(value) {
+    return isRecord(value) && (Object.getPrototypeOf(value) === Object.prototype
+        || Object.getPrototypeOf(value) === null);
+}
+function normalizeDatabaseJsonValue(value) {
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeDatabaseJsonValue(item));
+    }
+    if (isPlainRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, normalizeDatabaseJsonValue(item)]));
+    }
+    throw new TypeError("database json values must be valid JSON");
+}
 function metadataEntries(metadata) {
     if (metadata == null) {
         return null;
     }
     return Object.entries(metadata).map(([key, value]) => ({
         key,
-        value: typeof value === "string" ? value : JSON.stringify(encodeLegacyValue(value)),
+        value: typeof value === "string" ? value : JSON.stringify(value),
     }));
 }
 function toolkitDataTypeJson(dataType) {
@@ -128,125 +243,124 @@ function publicDataTypeJson(value) {
     }
     return payload;
 }
-function encodeLegacyValue(value) {
+function encodeRecordValue(value) {
+    if (value instanceof DatabaseValueEncoder) {
+        return value.encodeDatabaseValue();
+    }
+    if (value instanceof DatabaseUuid) {
+        return {
+            uuid: value.toString(),
+        };
+    }
     if (value instanceof Uint8Array) {
         return {
-            encoding: "base64",
-            data: bytesToBase64(value),
+            binary: bytesToBase64(value),
         };
     }
     if (value instanceof Date) {
-        return value.toISOString().replace("+00:00", "Z");
+        return {
+            timestamp: value.toISOString().replace("+00:00", "Z"),
+        };
     }
     if (Array.isArray(value)) {
-        return value.map((item) => encodeLegacyValue(item));
+        return {
+            list: value.map((item) => encodeRecordValue(item)),
+        };
     }
     if (isRecord(value)) {
-        return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, encodeLegacyValue(entryValue)]));
+        throw new RoomServerException("database object values must use DatabaseStruct or DatabaseJson");
     }
     return value;
 }
-function encodeStreamValue(value) {
-    if (value == null) {
-        return { type: "null" };
+function databaseSqlLiteral(value) {
+    if (value instanceof DatabaseUuid) {
+        return `X'${normalizeUuidHex(value.toString())}'`;
     }
-    if (typeof value === "boolean") {
-        return { type: "bool", value };
-    }
-    if (typeof value === "number") {
-        if (Number.isInteger(value)) {
-            return { type: "int", value };
-        }
-        return { type: "float", value };
+    if (value instanceof DatabaseDate) {
+        return JSON.stringify(value.toString());
     }
-    if (typeof value === "string") {
-        return { type: "text", value };
+    if (value instanceof Date) {
+        return JSON.stringify(value.toISOString().replace("+00:00", "Z"));
     }
-    if (value instanceof Uint8Array) {
-        return {
-            type: "binary",
-            data: bytesToBase64(value),
-        };
+    if (value instanceof DatabaseJson) {
+        return JSON.stringify(JSON.stringify(value.toJson()));
     }
-    if (value instanceof Date) {
-        return {
-            type: "timestamp",
-            value: value.toISOString().replace("+00:00", "Z"),
-        };
+    if (value instanceof DatabaseStruct) {
+        const fields = Object.entries(value.fields).map(([key, fieldValue]) => (`${JSON.stringify(key)}, ${databaseSqlLiteral(fieldValue)}`));
+        return `named_struct(${fields.join(", ")})`;
     }
+    return JSON.stringify(encodeRecordValue(value));
+}
+function decodeRecordValue(value) {
     if (Array.isArray(value)) {
-        return {
-            type: "list",
-            items: value.map((item) => encodeStreamValue(item)),
-        };
+        throw new RoomServerException("database list values must use a {'list': [...]} wrapper");
     }
-    if (isRecord(value)) {
-        return {
-            type: "struct",
-            fields: Object.entries(value).map(([name, fieldValue]) => ({
-                name,
-                value: encodeStreamValue(fieldValue),
-            })),
-        };
+    if (!isRecord(value)) {
+        return value;
     }
-    throw new RoomServerException(`database stream does not support value type ${typeof value}`);
-}
-function decodeStreamValue(value, operation) {
-    if (!isRecord(value) || typeof value.type !== "string") {
-        throw new RoomServerException(`unexpected return type from database.${operation}`);
+    const entries = Object.entries(value);
+    if (entries.length !== 1) {
+        throw new RoomServerException("database object values must use a single-key type wrapper");
     }
-    switch (value.type) {
-        case "null":
-            return null;
-        case "bool":
-            if (typeof value.value !== "boolean") {
-                throw new RoomServerException(`unexpected return type from database.${operation}`);
+    const [wrapper, payload] = entries[0];
+    switch (wrapper) {
+        case "binary":
+            if (typeof payload !== "string") {
+                throw new RoomServerException("database binary values must be base64 strings");
             }
-            return value.value;
-        case "int":
-        case "float":
-            if (typeof value.value !== "number") {
-                throw new RoomServerException(`unexpected return type from database.${operation}`);
+            return base64ToBytes(payload);
+        case "uuid":
+            if (typeof payload !== "string") {
+                throw new RoomServerException("database uuid values must be strings");
+            }
+            return new DatabaseUuid(payload);
+        case "expression":
+            if (typeof payload !== "string") {
+                throw new RoomServerException("database expression values must be strings");
             }
-            return value.value;
-        case "text":
+            return new DatabaseExpression(payload);
         case "date":
+            if (typeof payload !== "string") {
+                throw new RoomServerException("database date values must be strings");
+            }
+            return new DatabaseDate(payload);
         case "timestamp":
-            if (typeof value.value !== "string") {
-                throw new RoomServerException(`unexpected return type from database.${operation}`);
+            if (typeof payload !== "string") {
+                throw new RoomServerException("database timestamp values must be strings");
             }
-            return value.value;
-        case "binary":
-            if (typeof value.data !== "string") {
-                throw new RoomServerException(`unexpected return type from database.${operation}`);
+            {
+                const parsed = new Date(payload);
+                if (Number.isNaN(parsed.getTime())) {
+                    throw new RoomServerException("database timestamp value is not valid");
+                }
+                return parsed;
             }
-            return base64ToBytes(value.data);
         case "list":
-            if (!Array.isArray(value.items)) {
-                throw new RoomServerException(`unexpected return type from database.${operation}`);
+            if (!Array.isArray(payload)) {
+                throw new RoomServerException("database list values must be arrays");
             }
-            return value.items.map((item) => decodeStreamValue(item, operation));
+            return payload.map((item) => decodeRecordValue(item));
         case "struct":
-            if (!Array.isArray(value.fields)) {
-                throw new RoomServerException(`unexpected return type from database.${operation}`);
+            if (!isRecord(payload)) {
+                throw new RoomServerException("database struct values must be objects");
             }
-            return Object.fromEntries(value.fields.map((field) => {
-                if (!isRecord(field) || typeof field.name !== "string") {
-                    throw new RoomServerException(`unexpected return type from database.${operation}`);
-                }
-                return [field.name, decodeStreamValue(field.value, operation)];
-            }));
+            return new DatabaseStruct(Object.fromEntries(Object.entries(payload).map(([key, item]) => [key, decodeRecordValue(item)])));
+        case "json":
+            return new DatabaseJson(normalizeDatabaseJsonValue(payload));
         default:
-            throw new RoomServerException(`unexpected return type from database.${operation}`);
+            throw new RoomServerException(`unsupported database value wrapper '${wrapper}'`);
     }
 }
+function encodeDatabaseRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, encodeRecordValue(value)]));
+}
 function rowsChunk(records) {
     return {
         kind: "rows",
         rows: records.map((record) => ({
             columns: Object.entries(record).map(([name, value]) => ({
                 name,
-                value: encodeStreamValue(value),
+                value: encodeRecordValue(value),
             })),
         })),
     };
@@ -263,7 +377,12 @@ function recordsFromRowsChunk(payload, operation) {
             if (!isRecord(column) || typeof column.name !== "string") {
                 throw new RoomServerException(`unexpected return type from database.${operation}`);
             }
-            return [column.name, decodeStreamValue(column.value, operation)];
+            try {
+                return [column.name, decodeRecordValue(column.value)];
+            }
+            catch {
+                throw new RoomServerException(`unexpected return type from database.${operation}`);
+            }
         }));
     });
 }
@@ -291,7 +410,7 @@ async function* toAsyncIterable(chunks) {
 function buildWhereClause(where) {
     if (where != null && typeof where === "object" && !Array.isArray(where)) {
         return Object.entries(where)
-            .map(([key, value]) => `${key} = ${JSON.stringify(encodeLegacyValue(value))}`)
+            .map(([key, value]) => `${key} = ${databaseSqlLiteral(value)}`)
             .join(" AND ");
     }
     if (typeof where === "string") {
@@ -341,6 +460,39 @@ function tableVersionFromJson(value) {
         metadata,
     };
 }
+function tableBranchFromJson(value) {
+    if (!isRecord(value) || typeof value.name !== "string") {
+        throw new RoomServerException("unexpected return type from database.list_branches");
+    }
+    if (value.parent_branch != null && typeof value.parent_branch !== "string") {
+        throw new RoomServerException("unexpected return type from database.list_branches");
+    }
+    if (value.parent_version != null
+        && (typeof value.parent_version !== "number" || !Number.isInteger(value.parent_version))) {
+        throw new RoomServerException("unexpected return type from database.list_branches");
+    }
+    if (value.manifest_size != null
+        && (typeof value.manifest_size !== "number" || !Number.isInteger(value.manifest_size))) {
+        throw new RoomServerException("unexpected return type from database.list_branches");
+    }
+    let createdAt = null;
+    if (value.created_at != null) {
+        if (typeof value.created_at !== "string") {
+            throw new RoomServerException("unexpected return type from database.list_branches");
+        }
+        createdAt = new Date(value.created_at);
+        if (Number.isNaN(createdAt.getTime())) {
+            throw new RoomServerException("unexpected return type from database.list_branches");
+        }
+    }
+    return {
+        name: value.name,
+        parentBranch: value.parent_branch ?? null,
+        parentVersion: value.parent_version ?? null,
+        createdAt,
+        manifestSize: value.manifest_size ?? null,
+    };
+}
 class DatabaseWriteInputStream {
     constructor(start, chunks) {
         this.start = start;
@@ -521,61 +673,72 @@ export class DatabaseClient {
             input.close();
         }
     }
-    async listTables({ namespace } = {}) {
-        const response = await this.invoke("list_tables", { namespace: namespace ?? null });
+    async listTables({ namespace, branch } = {}) {
+        const response = await this.invoke("list_tables", {
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+        });
         if (!(response instanceof JsonContent)) {
             throw this._unexpectedResponseError("list_tables");
         }
         return Array.isArray(response.json.tables) ? response.json.tables : [];
     }
-    async createTable({ name, data, schema, mode = "create", namespace, metadata, }) {
+    async createTable({ name, data, schema, mode = "create", namespace, branch, metadata, }) {
         const input = new DatabaseWriteInputStream({
             kind: "start",
             name,
             fields: schemaEntries(schema),
             mode,
             namespace: namespace ?? null,
+            branch: branch ?? null,
             metadata: metadataEntries(metadata),
         }, data ?? []);
         await this.drainWriteStream("create_table", input);
     }
-    async createTableWithSchema({ name, schema, data, mode = "create", namespace, metadata }) {
+    async createTableWithSchema({ name, schema, data, mode = "create", namespace, branch, metadata }) {
         return this.createTable({
             name,
             schema,
             data: data == null ? undefined : rowChunkList(data),
             mode,
             namespace,
+            branch,
             metadata,
         });
     }
-    async createTableFromData({ name, data, mode = "create", namespace, metadata }) {
+    async createTableFromData({ name, data, mode = "create", namespace, branch, metadata }) {
         return this.createTable({
             name,
             data: data == null ? undefined : rowChunkList(data),
             mode,
             namespace,
+            branch,
             metadata,
         });
     }
-    async createTableFromDataStream({ name, chunks, schema, mode = "create", namespace, metadata }) {
-        return this.createTable({ name, data: chunks, schema, mode, namespace, metadata });
+    async createTableFromDataStream({ name, chunks, schema, mode = "create", namespace, branch, metadata }) {
+        return this.createTable({ name, data: chunks, schema, mode, namespace, branch, metadata });
     }
-    async dropTable({ name, ignoreMissing = false, namespace }) {
+    async dropTable({ name, ignoreMissing = false, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "drop_table",
-            input: { name, ignore_missing: ignoreMissing, namespace: namespace ?? null },
+            input: {
+                name,
+                ignore_missing: ignoreMissing,
+                namespace: namespace ?? null,
+                branch: branch ?? null,
+            },
         });
     }
-    async dropIndex({ table, name, namespace }) {
+    async dropIndex({ table, name, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "drop_index",
-            input: { table, name, namespace: namespace ?? null },
+            input: { table, name, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async addColumns({ table, newColumns, namespace }) {
+    async addColumns({ table, newColumns, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "add_columns",
@@ -585,56 +748,59 @@ export class DatabaseClient {
                     ? { name, value_sql: null, data_type: toolkitDataTypeJson(value) }
                     : { name, value_sql: value, data_type: null })),
                 namespace: namespace ?? null,
+                branch: branch ?? null,
             },
         });
     }
-    async dropColumns({ table, columns, namespace }) {
+    async dropColumns({ table, columns, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "drop_columns",
-            input: { table, columns, namespace: namespace ?? null },
+            input: { table, columns, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async insert({ table, records, namespace }) {
-        await this.insertStream({ table, chunks: rowChunkList(records), namespace });
+    async insert({ table, records, namespace, branch }) {
+        await this.insertStream({ table, chunks: rowChunkList(records), namespace, branch });
     }
-    async insertStream({ table, chunks, namespace }) {
+    async insertStream({ table, chunks, namespace, branch }) {
         const input = new DatabaseWriteInputStream({
             kind: "start",
             table,
             namespace: namespace ?? null,
+            branch: branch ?? null,
         }, chunks);
         await this.drainWriteStream("insert", input);
     }
-    async update({ table, where, values, valuesSql, namespace }) {
+    async update({ table, where, values, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "update",
             input: {
                 table,
                 where,
-                values: values == null ? null : Object.entries(values).map(([column, value]) => ({ column, value_json: JSON.stringify(encodeLegacyValue(value)) })),
-                values_sql: valuesSql == null ? null : Object.entries(valuesSql).map(([column, expression]) => ({ column, expression })),
+                values: Object.entries(values).map(([column, value]) => ({ column, value_json: JSON.stringify(encodeRecordValue(value)) })),
                 namespace: namespace ?? null,
+                branch: branch ?? null,
             },
         });
     }
-    async delete({ table, where, namespace }) {
+    async delete({ table, where, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "delete",
-            input: { table, where, namespace: namespace ?? null },
+            input: { table, where, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async merge({ table, on, records, namespace }) {
-        await this.mergeStream({ table, on, chunks: rowChunkList(records), namespace });
+    async merge({ table, on, records, namespace, branch }) {
+        await this.mergeStream({ table, on, chunks: rowChunkList(records), namespace, branch });
     }
-    async mergeStream({ table, on, chunks, namespace }) {
+    async mergeStream({ table, on, chunks, namespace, branch }) {
         const input = new DatabaseWriteInputStream({
             kind: "start",
             table,
             on,
             namespace: namespace ?? null,
+            branch: branch ?? null,
         }, chunks);
         await this.drainWriteStream("merge", input);
     }
@@ -650,17 +816,28 @@ export class DatabaseClient {
             kind: "start",
             query,
             tables: normalizeTableRefs(tables),
-            params_json: params == null ? null : JSON.stringify(encodeLegacyValue(params)),
+            params_json: params == null ? null : JSON.stringify(encodeDatabaseRecord(params)),
         });
     }
-    async search({ table, text, vector, where, offset, limit, select, namespace }) {
+    async search({ table, text, vector, where, offset, limit, select, namespace, branch, version }) {
         const rows = [];
-        for await (const chunk of this.searchStream({ table, text, vector, where, offset, limit, select, namespace })) {
+        for await (const chunk of this.searchStream({
+            table,
+            text,
+            vector,
+            where,
+            offset,
+            limit,
+            select,
+            namespace,
+            branch,
+            version,
+        })) {
             rows.push(...chunk);
         }
         return rows;
     }
-    async *searchStream({ table, text, vector, where, offset, limit, select, namespace }) {
+    async *searchStream({ table, text, vector, where, offset, limit, select, namespace, branch, version }) {
         yield* this.streamRows("search", {
             kind: "start",
             table,
@@ -672,9 +849,11 @@ export class DatabaseClient {
             limit: limit ?? null,
             select: select ?? null,
             namespace: namespace ?? null,
+            branch: branch ?? null,
+            version: version ?? null,
         });
     }
-    async count({ table, text, vector, where, namespace }) {
+    async count({ table, text, vector, where, namespace, branch, version }) {
         const response = await this.invoke("count", {
             table,
             text: text ?? null,
@@ -682,14 +861,21 @@ export class DatabaseClient {
             text_columns: null,
             where: buildWhereClause(where),
             namespace: namespace ?? null,
+            branch: branch ?? null,
+            version: version ?? null,
         });
         if (!(response instanceof JsonContent) || typeof response.json.count !== "number" || !Number.isInteger(response.json.count)) {
             throw this._unexpectedResponseError("count");
         }
         return response.json.count;
     }
-    async inspect({ table, namespace }) {
-        const response = await this.invoke("inspect", { table, namespace: namespace ?? null });
+    async inspect({ table, namespace, branch, version }) {
+        const response = await this.invoke("inspect", {
+            table,
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+            version: version ?? null,
+        });
         if (!(response instanceof JsonContent) || !Array.isArray(response.json.fields)) {
             throw this._unexpectedResponseError("inspect");
         }
@@ -703,55 +889,89 @@ export class DatabaseClient {
     async optimize(tableOrParams) {
         const table = typeof tableOrParams === "string" ? tableOrParams : tableOrParams.table;
         const namespace = typeof tableOrParams === "string" ? undefined : tableOrParams.namespace;
-        await this.room.invoke({ toolkit: "database", tool: "optimize", input: { table, namespace: namespace ?? null } });
-    }
-    async restore({ table, version, namespace }) {
+        const branch = typeof tableOrParams === "string" ? undefined : tableOrParams.branch;
         await this.room.invoke({
             toolkit: "database",
-            tool: "restore",
-            input: { table, version, namespace: namespace ?? null },
+            tool: "optimize",
+            input: { table, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async checkout({ table, version, namespace }) {
+    async restore({ table, version, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
-            tool: "checkout",
-            input: { table, version, namespace: namespace ?? null },
+            tool: "restore",
+            input: { table, version, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async listVersions({ table, namespace }) {
-        const response = await this.invoke("list_versions", { table, namespace: namespace ?? null });
+    async listVersions({ table, namespace, branch }) {
+        const response = await this.invoke("list_versions", {
+            table,
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+        });
         if (!(response instanceof JsonContent) || !Array.isArray(response.json.versions)) {
             throw this._unexpectedResponseError("list_versions");
         }
         return response.json.versions.map((version) => tableVersionFromJson(version));
     }
-    async createVectorIndex({ table, column, replace = false, namespace }) {
+    async createVectorIndex({ table, column, replace = false, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "create_vector_index",
-            input: { table, column, replace, namespace: namespace ?? null },
+            input: { table, column, replace, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async createScalarIndex({ table, column, replace = false, namespace }) {
+    async createScalarIndex({ table, column, replace = false, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "create_scalar_index",
-            input: { table, column, replace, namespace: namespace ?? null },
+            input: { table, column, replace, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async createFullTextSearchIndex({ table, column, replace = false, namespace }) {
+    async createFullTextSearchIndex({ table, column, replace = false, namespace, branch }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "create_full_text_search_index",
-            input: { table, column, replace, namespace: namespace ?? null },
+            input: { table, column, replace, namespace: namespace ?? null, branch: branch ?? null },
         });
     }
-    async listIndexes({ table, namespace }) {
-        const response = await this.invoke("list_indexes", { table, namespace: namespace ?? null });
+    async listIndexes({ table, namespace, branch, version }) {
+        const response = await this.invoke("list_indexes", {
+            table,
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+            version: version ?? null,
+        });
         if (!(response instanceof JsonContent) || !Array.isArray(response.json.indexes)) {
             throw this._unexpectedResponseError("list_indexes");
         }
         return response.json.indexes.map((index) => tableIndexFromJson(index));
     }
+    async listBranches({ namespace } = {}) {
+        const response = await this.invoke("list_branches", {
+            namespace: namespace ?? null,
+        });
+        if (!(response instanceof JsonContent) || !Array.isArray(response.json.branches)) {
+            throw this._unexpectedResponseError("list_branches");
+        }
+        return response.json.branches.map((branch) => tableBranchFromJson(branch));
+    }
+    async createBranch({ branch, fromBranch, namespace }) {
+        await this.room.invoke({
+            toolkit: "database",
+            tool: "create_branch",
+            input: {
+                branch,
+                from_branch: fromBranch ?? null,
+                namespace: namespace ?? null,
+            },
+        });
+    }
+    async deleteBranch({ branch, namespace }) {
+        await this.room.invoke({
+            toolkit: "database",
+            tool: "delete_branch",
+            input: { branch, namespace: namespace ?? null },
+        });
+    }
 }