@peers-app/peers-sdk 0.25.20 → 0.26.0

package/dist/data/orm/sql.data-source.js

@@ -6,9 +6,11 @@ exports.sqlValueToJsValue = sqlValueToJsValue;
 exports.globalDefaultValues = globalDefaultValues;
 const serial_json_1 = require("../../serial-json");
 const utils_1 = require("../../utils");
+const tool_catalog_fields_1 = require("../tool-catalog-fields");
 const data_query_1 = require("./data-query");
 const data_query_sqlite_1 = require("./data-query.sqlite");
 const types_1 = require("./types");
+/** SQLite-backed table storage with additive schema migration and serialized initialization. */
 class SQLDataSource {
     db;
     metaData;
@@ -116,7 +118,8 @@ class SQLDataSource {
     }
     async ensureTableIsNewest() {
         const now = new Date();
-        await this.ensureTableAndIndexesExist();
+        // Indexes referencing new columns must wait until the table has been rebuilt.
+        await this.db.exec(this.buildTableSql(), []);
         let newestTableDef = this.buildTableSql();
         newestTableDef = newestTableDef.replace(/CREATE TABLE IF NOT EXISTS/, "CREATE TABLE");
         const sqlGetTableRecord = `SELECT * FROM sqlite_master WHERE type = 'table' AND name = '${this.tableName}'`;
@@ -128,8 +131,8 @@ class SQLDataSource {
             const tempTableName = `${this.tableName}_old_${now.getTime()}`;
             const renameSql = `ALTER TABLE "${this.tableName}" RENAME TO "${tempTableName}"`;
             await this.db.exec(renameSql, []);
-            // create new table
-            await this.ensureTableAndIndexesExist();
+            // The renamed table still owns the old index names until it is dropped.
+            await this.db.exec(this.buildTableSql(), []);
             // sql query to copy existing data and set new required fields to default values
             const defaults = this.initRecord();
             const fieldsInsert = this.metaData.fields.map((f) => `"${f.name}"`).join(", ");
@@ -158,22 +161,30 @@ class SQLDataSource {
             // drop old table
             const dropSql = `DROP TABLE IF EXISTS "${tempTableName}"`;
             await this.db.exec(dropSql, []);
+            await this.ensureTableAndIndexesExist();
             return true;
         }
+        await this.ensureTableAndIndexesExist();
         return false;
     }
     tableBuild;
+    /** Share schema initialization; a failed attempt is evicted so later calls can retry. */
     async initTable(force = false) {
         if (!this.tableBuild || force) {
-            this.tableBuild = this.ensureTableIsNewest();
+            const build = this.ensureTableIsNewest().catch((error) => {
+                // A failed older forced attempt must not evict a newer initialization.
+                if (this.tableBuild === build)
+                    this.tableBuild = undefined;
+                throw error;
+            });
+            this.tableBuild = build;
         }
         return this.tableBuild;
     }
     async get(id) {
-        let record;
         await this.initTable();
         const sqlRecord = await this.db.get(`SELECT * FROM "${this.tableName}" WHERE ${this.metaData.primaryKeyName} = ?`, [id]);
-        record = this.sqlRecordToJsRecord(sqlRecord);
+        const record = this.sqlRecordToJsRecord(sqlRecord);
         return record;
     }
     async list(filter = {}, opts = {}) {
@@ -261,11 +272,15 @@ class SQLDataSource {
             // @ts-expect-error - need to figure out how to get typescript to understand what's going on here
             record[this.metaData.primaryKeyName] = (0, utils_1.newid)();
         }
-        this.schema.parse(record);
         const primaryKey = record[this.metaData.primaryKeyName];
-        const updateFields = this.fieldsForUpdate(record);
+        // Explicit catalog patches write only their own columns. Keep ordinary row-save
+        // semantics (omitted optional fields clear) unchanged for all other writes.
+        const catalogPatch = this.tableName === "Tools" && (0, tool_catalog_fields_1.isToolCatalogPatch)(record);
+        const updated = catalogPatch ? { ...(await this.get(primaryKey)), ...record } : record;
+        this.schema.parse(updated);
+        const updateFields = this.fieldsForUpdate(record).filter((field) => !catalogPatch || Object.hasOwn(record, field.name));
         if (updateFields.length === 0) {
-            return record;
+            return updated;
         }
         const fields = updateFields.map((field) => `"${field.name}" = ?`).join(",\n");
         const values = updateFields.map((field) => jsValueToSqlValue(record[field.name]));
@@ -275,7 +290,7 @@ class SQLDataSource {
             `WHERE "${this.metaData.primaryKeyName}" = ?`,
         ].join("\n");
         await this.db.exec(sql, [...values, primaryKey]);
-        return record;
+        return updated;
     }
     async delete(idOrRecord) {
         await this.initTable();
@@ -476,6 +491,7 @@ class SQLDataSource {
     }
 }
 exports.SQLDataSource = SQLDataSource;
+/** Encode a JavaScript field for SQLite parameters or an escaped migration literal. */
 function jsValueToSqlValue(value, escapeQuote = false) {
     if (value === undefined)
         return null;
@@ -493,6 +509,7 @@ function jsValueToSqlValue(value, escapeQuote = false) {
     }
     return value;
 }
+/** Restore a SQLite field according to its declared Peers type. */
 function sqlValueToJsValue(value, fieldType, isArray) {
     if (value === null)
         return undefined;
@@ -518,6 +535,7 @@ function sqlValueToJsValue(value, fieldType, isArray) {
     }
     return value;
 }
+/** Default value used when adding a required field to an existing table. */
 function globalDefaultValues(field) {
     const fieldType = field.type;
     const isArray = field.isArray ?? false;

package/dist/data/orm/sql.data-source.test.d.ts

@@ -1 +1 @@
-export {};
+import "../../index";

package/dist/data/orm/sql.data-source.test.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("../../index");
 const SQLiteDB = require("better-sqlite3");
 const lodash_1 = require("lodash");
 const zod_1 = require("zod");
+const registry_1 = require("../../contracts/registry");
+const tool_catalog_1 = require("../../contracts/tool-catalog");
 const field_type_1 = require("../../types/field-type");
 const zod_types_1 = require("../../types/zod-types");
 const utils_1 = require("../../utils");
+const tool_catalog_fields_1 = require("../tool-catalog-fields");
 const sql_data_source_1 = require("./sql.data-source");
+const subscribable_data_source_1 = require("./subscribable.data-source");
 const types_1 = require("./types");
 class DBHarness {
     _db = null;
@@ -427,3 +432,158 @@ describe("table", () => {
         });
     });
 });
+describe("Tools additive catalog migration", () => {
+    test("catalog readiness retries failed SQLite schema initialization on the same source", async () => {
+        const { toolSchema } = await Promise.resolve().then(() => require("../tools"));
+        const harness = new DBHarness();
+        const source = new sql_data_source_1.SQLDataSource(harness, {
+            name: "Tools",
+            description: "",
+            primaryKeyName: "toolId",
+            fields: (0, types_1.schemaToFields)(toolSchema),
+            indexes: [{ fields: ["contractId", "contractVersion", "toolName"] }],
+            versionNumber: 2,
+        }, toolSchema);
+        const table = new subscribable_data_source_1.SubscribableDataSource(source);
+        const catalog = new tool_catalog_1.ToolCatalog({
+            dataContextId: (0, utils_1.newid)(),
+            tableContainer: { getTable: () => table },
+        }, new registry_1.ContractRegistry());
+        const exec = jest
+            .spyOn(harness, "exec")
+            .mockRejectedValueOnce(new Error("schema temporarily unavailable"));
+        try {
+            const first = catalog.ready();
+            expect(catalog.ready()).toBe(first);
+            await expect(first).rejects.toThrow("schema temporarily unavailable");
+            expect(exec).toHaveBeenCalledTimes(1);
+            await catalog.ready();
+            const rows = await table.list();
+            expect(rows.length).toBeGreaterThan(0);
+            expect(rows.every((row) => row.catalogState === "resolved")).toBe(true);
+            expect(await harness.all('PRAGMA index_list("Tools")')).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    name: expect.stringContaining("_contractId_contractVersion_toolName_"),
+                }),
+            ]));
+            expect(catalog.registry.getProviderPackageId(rows[0].contractId, rows[0].contractVersion)).toBeDefined();
+        }
+        finally {
+            await catalog.dispose();
+            await harness.close();
+        }
+    });
+    test("an older failed initialization cannot evict a newer forced initialization", async () => {
+        const { toolSchema } = await Promise.resolve().then(() => require("../tools"));
+        const harness = new DBHarness();
+        const source = new sql_data_source_1.SQLDataSource(harness, {
+            name: "Tools",
+            description: "",
+            primaryKeyName: "toolId",
+            fields: (0, types_1.schemaToFields)(toolSchema),
+        }, toolSchema);
+        let reject;
+        const exec = jest.spyOn(harness, "exec").mockImplementationOnce(() => new Promise((_, fail) => {
+            reject = fail;
+        }));
+        try {
+            const first = source.initTable();
+            const failed = expect(first).rejects.toThrow("older failure");
+            await source.initTable(true);
+            const attempts = exec.mock.calls.length;
+            reject(new Error("older failure"));
+            await failed;
+            await source.initTable();
+            expect(exec).toHaveBeenCalledTimes(attempts);
+        }
+        finally {
+            await harness.close();
+        }
+    });
+    test("preserves legacy values and recreates all indexes after table-copy migration", async () => {
+        const { toolSchema } = await Promise.resolve().then(() => require("../tools"));
+        const harness = new DBHarness();
+        const oldSchema = toolSchema.omit({
+            contractId: true,
+            contractVersion: true,
+            toolName: true,
+            catalogIdentity: true,
+            catalogState: true,
+            catalogReason: true,
+        });
+        const metadata = {
+            name: "Tools",
+            description: "",
+            primaryKeyName: "toolId",
+            fields: (0, types_1.schemaToFields)(oldSchema),
+            indexes: [{ fields: ["name"] }, { fields: ["isAssistantRunner"] }],
+            versionNumber: 1,
+        };
+        const old = new sql_data_source_1.SQLDataSource(harness, metadata, oldSchema);
+        const row = oldSchema.parse({
+            toolId: (0, utils_1.newid)(),
+            name: "preserve me",
+            usageDescription: "legacy",
+            code: "executable",
+            inputSchema: { type: "none" },
+            outputSchema: { type: "none" },
+            accessLevel: 70,
+        });
+        try {
+            await old.save(row);
+            const upgraded = new sql_data_source_1.SQLDataSource(harness, {
+                ...metadata,
+                fields: (0, types_1.schemaToFields)(toolSchema),
+                versionNumber: 2,
+                indexes: [...metadata.indexes, { fields: ["contractId", "contractVersion", "toolName"] }],
+            }, toolSchema);
+            await upgraded.initTable();
+            expect(await upgraded.get(row.toolId)).toMatchObject(row);
+            // Runtime backfill owns only the new columns. Updating them must work
+            // without resending (and potentially overwriting) legacy provider metadata.
+            await upgraded.update((0, tool_catalog_fields_1.toolCatalogPatch)({ toolId: row.toolId, catalogState: "unresolved" }));
+            expect(await upgraded.get(row.toolId)).toMatchObject({ ...row, catalogState: "unresolved" });
+            // A descriptive refresh patch keeps policy; an unmarked full row still replaces it.
+            await upgraded.update((0, tool_catalog_fields_1.toolCatalogPatch)({
+                toolId: row.toolId,
+                usageDescription: "refreshed",
+                detailedDescription: "new",
+            }));
+            expect(await upgraded.get(row.toolId)).toMatchObject({
+                ...row,
+                usageDescription: "refreshed",
+                detailedDescription: "new",
+                accessLevel: 70,
+            });
+            const { accessLevel: _policy, ...withoutPolicy } = row;
+            await upgraded.update({ ...withoutPolicy, catalogState: "unresolved" });
+            expect((await upgraded.get(row.toolId))?.accessLevel).toBeUndefined();
+            await upgraded.update({ ...row, catalogState: "unresolved" });
+            expect(() => (0, tool_catalog_fields_1.toolCatalogPatch)({ toolId: row.toolId, accessLevel: 0 })).toThrow(/accessLevel/);
+            for (const field of ["code", "codeRepository", "packageId"])
+                expect(() => (0, tool_catalog_fields_1.toolCatalogPatch)({ toolId: row.toolId, [field]: "historical" })).toThrow(field);
+            const indexes = await harness.all('PRAGMA index_list("Tools")');
+            expect(indexes
+                .filter((index) => !index.name.startsWith("sqlite_autoindex_"))
+                .map((index) => index.name)).toEqual(expect.arrayContaining([
+                expect.stringContaining("_name_"),
+                expect.stringContaining("_isAssistantRunner_"),
+                expect.stringContaining("_contractId_contractVersion_toolName_"),
+            ]));
+            expect(indexes
+                .filter((index) => index.name.includes("contractId"))
+                .every((index) => index.unique === 0)).toBe(true);
+            const target = {
+                contractId: "00muxgugn6xvs8f2r80ru205t",
+                contractVersion: 1,
+                toolName: "invoke",
+            };
+            await upgraded.save({ ...row, ...target, toolId: "00muxoa8xeet2lpi8bdq55q03" });
+            await upgraded.save({ ...row, ...target, toolId: "00muxob3hbo3f6g49mipy1hyt" });
+            expect(await upgraded.count()).toBe(3);
+        }
+        finally {
+            await harness.close();
+        }
+    });
+});

package/dist/data/orm/table-container.d.ts

@@ -9,6 +9,7 @@ import { type ITableMetaData } from "./types";
  * Logs an error if same version but different definitions (caller should bump versionNumber).
  */
 export declare function checkVersionedUpdate(existingVersion: number, incomingVersion: number, existingMetaData: ITableMetaData, incomingMetaData: ITableMetaData): "update" | "skip";
+/** Owns code-defined and synced fallback table bindings for one data context. */
 export declare class TableContainer {
     readonly tableFactory: TableFactory;
     readonly groupId?: string | undefined;
@@ -19,11 +20,21 @@ export declare class TableContainer {
     private fallbackInstances;
     private fallbackSubscribed;
     constructor(tableFactory: TableFactory, groupId?: string | undefined);
+    /** Register a code-owned table, preserving an existing binding unless overwrite is set. */
     registerTableDefinition<T extends {
         [key: string]: any;
     }>(tableDefinition: ITableDefinition<T>, opts?: {
         overwrite?: boolean;
     }): void;
+    /**
+     * Validate and stage the entire batch before changing any live table binding.
+     * An invalid later definition leaves earlier definitions and instances intact.
+     * No table factories or schema persistence run during registration.
+     */
+    registerTableDefinitions(definitions: readonly ITableDefinition<any>[], opts?: {
+        overwrite?: boolean;
+    }): void;
+    private stageTableDefinition;
     /**
      * This shouldn't be used unless you have a good reason to bypass the normal table creation process.
      * The normal process is to register the table definition and let the factory create the instance.
@@ -31,9 +42,11 @@ export declare class TableContainer {
     setTable(table: Table<any>, opts?: {
         overwrite?: boolean;
     }): void;
+    /** Resolve a table by its full registered name. */
     getTable<T extends {
         [key: string]: any;
     }>(tableName: string): Table<T>;
+    /** Lazily create a table from metadata, using a registered constructor when available. */
     getTable<T extends {
         [key: string]: any;
     }>(metaData: ITableMetaData, schema?: z.AnyZodObject, tableConstructor?: TableConstructor<T>): Table<T>;
@@ -43,6 +56,7 @@ export declare class TableContainer {
      * and skips saving the TableDefinitions table itself to avoid recursion.
      */
     private saveTableDefinition;
+    /** Resolve a live, code-defined or synced fallback binding by its full name. */
     getTableByName<T extends {
         [key: string]: any;
     }>(tableName: string): Table<T>;

package/dist/data/orm/table-container.js

@@ -54,6 +54,7 @@ function checkVersionedUpdate(existingVersion, incomingVersion, existingMetaData
     // }
     // return 'update'; // incoming is strictly newer
 }
+/** Owns code-defined and synced fallback table bindings for one data context. */
 class TableContainer {
     tableFactory;
     groupId;
@@ -69,7 +70,25 @@ class TableContainer {
         this.tableFactory = tableFactory;
         this.groupId = groupId;
     }
+    /** Register a code-owned table, preserving an existing binding unless overwrite is set. */
     registerTableDefinition(tableDefinition, opts) {
+        this.registerTableDefinitions([tableDefinition], opts);
+    }
+    /**
+     * Validate and stage the entire batch before changing any live table binding.
+     * An invalid later definition leaves earlier definitions and instances intact.
+     * No table factories or schema persistence run during registration.
+     */
+    registerTableDefinitions(definitions, opts) {
+        const candidate = new TableContainer(this.tableFactory, this.groupId);
+        Object.assign(candidate.tableDefinitions, this.tableDefinitions);
+        Object.assign(candidate.tableInstances, this.tableInstances);
+        for (const definition of definitions)
+            candidate.stageTableDefinition(definition, opts);
+        Object.assign(this.tableDefinitions, candidate.tableDefinitions);
+        this.tableInstances = candidate.tableInstances;
+    }
+    stageTableDefinition(tableDefinition, opts) {
         const tableId = tableDefinition.metaData.tableId;
         if (!(0, utils_1.isid)(tableId)) {
             throw new Error(`Invalid tableId ${tableId} for table ${tableDefinition.metaData.name}. Table IDs must be valid IDs.`);
@@ -186,6 +205,7 @@ class TableContainer {
             this.savingDefinitions = false;
         }
     }
+    /** Resolve a live, code-defined or synced fallback binding by its full name. */
     getTableByName(tableName) {
         // 1. Check for a full instance (from code/packages)
         if (this.tableInstances[tableName]) {

package/dist/data/tool-access-approvals.d.ts

@@ -47,12 +47,12 @@ export declare const toolAccessApprovalSchema: z.ZodObject<{
     nonce: string;
     status: ToolAccessApprovalStatus;
     userId: string;
+    toolName: string;
     toolId: string;
     scope: ToolAccessApprovalScope;
     dataContextId: string;
     createdAt: Date;
     expiresAt: Date;
-    toolName: string;
     toolAccessApprovalId: string;
     argsHash: string;
     argsPreview: string;
@@ -61,19 +61,19 @@ export declare const toolAccessApprovalSchema: z.ZodObject<{
     };
     requiredAccessLevel: number;
     assistantId?: string | undefined;
-    threadMessageId?: string | undefined;
     workflowRunId?: string | undefined;
     workflowLogId?: string | undefined;
+    threadMessageId?: string | undefined;
     decidedAt?: Date | undefined;
     executedAt?: Date | undefined;
     resultSummary?: string | undefined;
 }, {
     nonce: string;
     userId: string;
+    toolName: string;
     toolId: string;
     dataContextId: string;
     expiresAt: Date;
-    toolName: string;
     toolAccessApprovalId: string;
     argsHash: string;
     frozenArgs: {} & {
@@ -83,9 +83,9 @@ export declare const toolAccessApprovalSchema: z.ZodObject<{
     scope?: ToolAccessApprovalScope | undefined;
     assistantId?: string | undefined;
     createdAt?: Date | undefined;
-    threadMessageId?: string | undefined;
     workflowRunId?: string | undefined;
     workflowLogId?: string | undefined;
+    threadMessageId?: string | undefined;
     argsPreview?: string | undefined;
     requiredAccessLevel?: number | undefined;
     decidedAt?: Date | undefined;
@@ -103,12 +103,12 @@ export declare function ToolAccessApprovals(dataContext?: DataContext): import("
     nonce: string;
     status: ToolAccessApprovalStatus;
     userId: string;
+    toolName: string;
     toolId: string;
     scope: ToolAccessApprovalScope;
     dataContextId: string;
     createdAt: Date;
     expiresAt: Date;
-    toolName: string;
     toolAccessApprovalId: string;
     argsHash: string;
     argsPreview: string;
@@ -117,9 +117,9 @@ export declare function ToolAccessApprovals(dataContext?: DataContext): import("
     };
     requiredAccessLevel: number;
     assistantId?: string | undefined;
-    threadMessageId?: string | undefined;
     workflowRunId?: string | undefined;
     workflowLogId?: string | undefined;
+    threadMessageId?: string | undefined;
     decidedAt?: Date | undefined;
     executedAt?: Date | undefined;
     resultSummary?: string | undefined;

package/dist/data/tool-catalog-fields.d.ts

@@ -0,0 +1,31 @@
+/** Catalog-owned identity and state columns. Runtimes before Tools v2 do not know them. */
+export declare const toolCatalogIdentityFields: readonly ["contractId", "contractVersion", "toolName", "catalogIdentity", "catalogState", "catalogReason"];
+/**
+ * Presentation fields described by a public contract member. The catalog refreshes
+ * them from a published definition when provenance is absent or matches its provider.
+ */
+export declare const toolCatalogContractDescriptiveFields: readonly ["name", "usageDescription", "inputSchema", "outputSchema"];
+/** Supplemental presentation and runner configuration, independent of executable code. */
+export declare const toolCatalogSupplementalFields: readonly ["configSchema", "isAssistantRunner", "detailedDescription"];
+/**
+ * Columns a catalog patch may write. Authorization fields (`accessLevel`,
+ * `remoteAccessLevel`, `authorityPropagation`) deliberately remain outside this list:
+ * catalog backfill and metadata refresh must never clear or rewrite live access policy.
+ */
+export declare const toolCatalogPatchFields: readonly string[];
+/**
+ * Mark a restricted Tools update written by the tool catalog. SQL merges a marked
+ * update into the stored row and tracked storage records only the paths it changes,
+ * so a concurrent policy change cannot be reverted by a stale snapshot. Unmarked
+ * updates keep row-replacement semantics: a full save that omits access policy
+ * still clears it. Identity is validated against the merged row in both cases.
+ *
+ * @param patch - Primary key plus fields from {@link toolCatalogPatchFields}.
+ * @returns The same object, marked.
+ * @throws If the patch names a field outside {@link toolCatalogPatchFields}.
+ */
+export declare function toolCatalogPatch<T extends {
+    toolId: string;
+}>(patch: T): T;
+/** Whether `record` was created by {@link toolCatalogPatch}. */
+export declare function isToolCatalogPatch(record: object): boolean;

package/dist/data/tool-catalog-fields.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolCatalogPatchFields = exports.toolCatalogSupplementalFields = exports.toolCatalogContractDescriptiveFields = exports.toolCatalogIdentityFields = void 0;
+exports.toolCatalogPatch = toolCatalogPatch;
+exports.isToolCatalogPatch = isToolCatalogPatch;
+/** Catalog-owned identity and state columns. Runtimes before Tools v2 do not know them. */
+exports.toolCatalogIdentityFields = [
+    "contractId",
+    "contractVersion",
+    "toolName",
+    "catalogIdentity",
+    "catalogState",
+    "catalogReason",
+];
+/**
+ * Presentation fields described by a public contract member. The catalog refreshes
+ * them from a published definition when provenance is absent or matches its provider.
+ */
+exports.toolCatalogContractDescriptiveFields = [
+    "name",
+    "usageDescription",
+    "inputSchema",
+    "outputSchema",
+];
+/** Supplemental presentation and runner configuration, independent of executable code. */
+exports.toolCatalogSupplementalFields = [
+    "configSchema",
+    "isAssistantRunner",
+    "detailedDescription",
+];
+/**
+ * Columns a catalog patch may write. Authorization fields (`accessLevel`,
+ * `remoteAccessLevel`, `authorityPropagation`) deliberately remain outside this list:
+ * catalog backfill and metadata refresh must never clear or rewrite live access policy.
+ */
+exports.toolCatalogPatchFields = [
+    "toolId",
+    ...exports.toolCatalogIdentityFields,
+    ...exports.toolCatalogContractDescriptiveFields,
+    ...exports.toolCatalogSupplementalFields,
+];
+// Registered globally so a duplicated SDK module still recognizes the marker. The
+// property is non-enumerable: it is never copied by spreads, persisted or synced.
+const toolCatalogPatchMarker = Symbol.for("peers.tools-catalog.patch");
+/**
+ * Mark a restricted Tools update written by the tool catalog. SQL merges a marked
+ * update into the stored row and tracked storage records only the paths it changes,
+ * so a concurrent policy change cannot be reverted by a stale snapshot. Unmarked
+ * updates keep row-replacement semantics: a full save that omits access policy
+ * still clears it. Identity is validated against the merged row in both cases.
+ *
+ * @param patch - Primary key plus fields from {@link toolCatalogPatchFields}.
+ * @returns The same object, marked.
+ * @throws If the patch names a field outside {@link toolCatalogPatchFields}.
+ */
+function toolCatalogPatch(patch) {
+    for (const key of Object.keys(patch)) {
+        if (!exports.toolCatalogPatchFields.includes(key))
+            throw new Error(`Tool catalog patches cannot write ${key}`);
+    }
+    Object.defineProperty(patch, toolCatalogPatchMarker, { value: true });
+    return patch;
+}
+/** Whether `record` was created by {@link toolCatalogPatch}. */
+function isToolCatalogPatch(record) {
+    return record[toolCatalogPatchMarker] === true;
+}