@peers-app/peers-sdk 0.26.5 → 0.27.0

package/dist/data/orm/types.test.js

@@ -277,4 +277,133 @@ describe("types", () => {
         expect(() => schema.parse({ recordId: validId, label: "hello" })).not.toThrow();
         expect(() => schema.parse({ recordId: "", label: "hello" })).toThrow();
     });
+    describe("the richer IR", () => {
+        const fields = [
+            { name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] },
+            { name: "note", type: field_type_1.FieldType.string, optional: true },
+            {
+                name: "where",
+                type: field_type_1.FieldType.object,
+                fields: [
+                    { name: "city", type: field_type_1.FieldType.string },
+                    { name: "unit", type: field_type_1.FieldType.string, enumValues: ["F", "C"], optional: true },
+                ],
+            },
+            { name: "tags", type: field_type_1.FieldType.object, isArray: true },
+        ];
+        const valid = {
+            mode: "on",
+            where: { city: "Austin", unit: "F", extra: 1 },
+            tags: [{ a: 1 }],
+        };
+        it("fieldsToSchema checks types and keeps an object's keys", () => {
+            const schema = (0, types_1.fieldsToSchema)(fields);
+            expect(schema.parse(valid)).toEqual(valid);
+            // An empty optional field is removed first (withoutEmptyFields); null itself isn't a value.
+            expect(schema.safeParse({ ...valid, note: null }).success).toBe(false);
+            // Enum values and nested fields describe; the Runtime doesn't enforce them.
+            expect(schema.safeParse({ ...valid, mode: "dim", where: { city: 3 } }).success).toBe(true);
+            expect(schema.safeParse({ ...valid, mode: 1 }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, mode: null }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, where: "Austin" }).success).toBe(false);
+        });
+        it("fieldsToSchema still defers an object to an intersected author schema", () => {
+            const codeSchema = zod_1.z.object({ when: zod_1.z.object({ at: zod_1.z.coerce.date() }) });
+            const schema = (0, types_1.fieldsToSchema)([{ name: "when", type: field_type_1.FieldType.object }], codeSchema);
+            expect(schema.parse({ when: { at: "2026-01-01" } }).when.at).toBeInstanceOf(Date);
+        });
+        it("fieldsToShapeSchema checks enum values and nested fields", () => {
+            const schema = (0, types_1.fieldsToShapeSchema)(fields);
+            expect(schema.parse(valid)).toEqual(valid);
+            expect(schema.safeParse({ ...valid, mode: "dim" }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, where: { city: 3 } }).success).toBe(false);
+            expect(schema.safeParse({ ...valid, where: { city: "Austin", unit: "K" } }).success).toBe(false);
+            const mixed = (0, types_1.fieldsToShapeSchema)([
+                { name: "size", type: field_type_1.FieldType.any, enumValues: [1, "large", true] },
+                { name: "one", type: field_type_1.FieldType.number, enumValues: [3] },
+            ]);
+            expect(mixed.safeParse({ size: true, one: 3 }).success).toBe(true);
+            expect(mixed.safeParse({ size: false, one: 3 }).success).toBe(false);
+            expect(mixed.safeParse({ size: 1, one: 4 }).success).toBe(false);
+        });
+        it("comparableTableFields keeps only the keys a table version is compared on", () => {
+            expect((0, types_1.comparableTableFields)([
+                {
+                    type: field_type_1.FieldType.object,
+                    name: "where",
+                    defaultValue: {},
+                    fields: [],
+                    enumValues: ["x"],
+                    optional: true,
+                    future: 1,
+                },
+            ])).toEqual([{ name: "where", type: field_type_1.FieldType.object, optional: true }]);
+        });
+    });
+    describe("withoutEmptyFields", () => {
+        const fields = [
+            { name: "title", type: field_type_1.FieldType.string },
+            { name: "note", type: field_type_1.FieldType.string, optional: true },
+            {
+                name: "where",
+                type: field_type_1.FieldType.object,
+                optional: true,
+                fields: [
+                    { name: "city", type: field_type_1.FieldType.string },
+                    { name: "unit", type: field_type_1.FieldType.string, optional: true },
+                ],
+            },
+            {
+                name: "stops",
+                type: field_type_1.FieldType.object,
+                isArray: true,
+                fields: [{ name: "at", type: field_type_1.FieldType.string, optional: true }],
+            },
+            { name: "data", type: field_type_1.FieldType.any, optional: true },
+        ];
+        it("removes null and undefined optional fields, in declared nested fields too", () => {
+            const value = {
+                title: "a",
+                note: null,
+                where: { city: "Austin", unit: null },
+                stops: [{ at: null }, { at: "noon" }],
+                data: { inner: null },
+                extra: null,
+            };
+            expect((0, types_1.withoutEmptyFields)(fields, value)).toEqual({
+                title: "a",
+                where: { city: "Austin" },
+                stops: [{}, { at: "noon" }],
+                // Values the fields don't describe, and keys they don't list, are left as they are.
+                data: { inner: null },
+                extra: null,
+            });
+            expect(value.note).toBeNull();
+            expect(value.where.unit).toBeNull();
+            expect((0, types_1.withoutEmptyFields)(fields, { ...value, note: undefined, where: null })).not.toHaveProperty("where");
+        });
+        it("keeps an empty required field, and returns the value itself when nothing is removed", () => {
+            const required = { title: null, stops: [] };
+            expect((0, types_1.withoutEmptyFields)(fields, required)).toBe(required);
+            const clean = { title: "a", where: { city: "Austin" }, stops: [{ at: "noon" }] };
+            expect((0, types_1.withoutEmptyFields)(fields, clean)).toBe(clean);
+            expect((0, types_1.withoutEmptyFields)(fields, null)).toBeNull();
+            expect((0, types_1.withoutEmptyFields)(fields, ["a"])).toEqual(["a"]);
+        });
+        it("deletes own undefined keys at every described depth", () => {
+            const value = { note: undefined, where: { unit: undefined }, stops: [{ at: undefined }] };
+            const cleaned = (0, types_1.withoutEmptyFields)(fields, value);
+            expect(cleaned).toStrictEqual({ where: {}, stops: [{}] });
+            expect(value).toHaveProperty("note");
+            expect(value.where).toHaveProperty("unit");
+        });
+        it("lets parsing fill a default for null just as for a missing field", () => {
+            const defaulted = [{ name: "rank", type: field_type_1.FieldType.number, defaultValue: 5 }];
+            for (const value of [{ rank: null }, { rank: undefined }, {}]) {
+                const cleaned = (0, types_1.withoutEmptyFields)(defaulted, value);
+                expect(cleaned).toStrictEqual({});
+                expect((0, types_1.fieldsToSchema)(defaulted).parse(cleaned)).toStrictEqual({ rank: 5 });
+            }
+        });
+    });
 });

package/dist/data/package-versions.d.ts

@@ -107,16 +107,19 @@ declare const schema: z.ZodObject<{
     uiBundleFileHash?: string | undefined;
     packageAuthorSignature?: string | undefined;
 }>;
+/** A signed package build and its bundle hashes, tag, and lifecycle history. */
 export type IPackageVersion = z.infer<typeof schema>;
+/** Package version table with signature and group promotion permission checks. */
 export declare class PackageVersionsTable extends Table<IPackageVersion> {
     static isPassthrough: boolean;
     insert(packageVersion: IPackageVersion, opts?: ISaveOptions): Promise<IPackageVersion>;
     update(packageVersion: IPackageVersion, opts?: ISaveOptions): Promise<IPackageVersion>;
     save(packageVersion: IPackageVersion, opts?: ISaveOptions): Promise<IPackageVersion>;
     signAndSave(packageVersion: IPackageVersion, opts?: ISaveOptions): Promise<IPackageVersion>;
-    private static addSignatureToPackageVersion;
+    /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
     static enablePackageVersionSigning(fn: (packageVersion: IPackageVersion) => IPackageVersion): void;
 }
+/** Returns the PackageVersions table for the given context or the current default context. */
 export declare function PackageVersions(dataContext?: DataContext): PackageVersionsTable;
 /**
  * Compute a content hash from bundle file hashes. The hash represents code
@@ -134,6 +137,7 @@ export declare function PackageVersions(dataContext?: DataContext): PackageVersi
 export declare function computePackageVersionHash(version: string, 
 /** @deprecated Ignored — will be removed in a future release. */
 _versionTag: string, packageBundleFileHash: string, routesBundleFileHash?: string, uiBundleFileHash?: string): string;
+/** Checks whether an incoming version falls within the selected automatic update range. */
 export declare function isVersionInRange(activeVersion: string, incomingVersion: string, range: "pinned" | "patch" | "minor" | "latest"): boolean;
 /**
  * Returns true if incomingVersion is strictly newer than activeVersion (semver comparison).

package/dist/data/package-versions.js

@@ -92,6 +92,10 @@ const metaData = {
     fields: (0, types_1.schemaToFields)(schema),
     indexes: [{ fields: ["packageId"] }],
 };
+// Symbol.for keeps signer registration shared by separately installed SDK copies.
+const signingKey = Symbol.for("@peers-app/peers-sdk/package-version-signing");
+const signingGlobals = globalThis;
+/** Package version table with signature and group promotion permission checks. */
 let PackageVersionsTable = (() => {
     let _classSuper = table_1.Table;
     let _instanceExtraInitializers = [];
@@ -122,15 +126,16 @@ let PackageVersionsTable = (() => {
             return super.save(packageVersion, opts);
         }
         async signAndSave(packageVersion, opts) {
-            if (!PackageVersionsTable.addSignatureToPackageVersion) {
+            const sign = signingGlobals[signingKey];
+            if (!sign) {
                 throw new Error("Package version signing is not enabled. Call PackageVersionsTable.enablePackageVersionSigning(fn) to enable it.");
             }
-            packageVersion = await PackageVersionsTable.addSignatureToPackageVersion(packageVersion);
+            packageVersion = await sign.call(PackageVersionsTable, packageVersion);
             return this.save(packageVersion, opts);
         }
-        static addSignatureToPackageVersion = undefined;
+        /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
         static enablePackageVersionSigning(fn) {
-            PackageVersionsTable.addSignatureToPackageVersion = fn;
+            signingGlobals[signingKey] = fn;
         }
         constructor() {
             super(...arguments);
@@ -140,6 +145,7 @@ let PackageVersionsTable = (() => {
 })();
 exports.PackageVersionsTable = PackageVersionsTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, schema, PackageVersionsTable);
+/** Returns the PackageVersions table for the given context or the current default context. */
 function PackageVersions(dataContext) {
     return (0, context_1.getTableContainer)(dataContext).getTable(metaData, schema, PackageVersionsTable);
 }
@@ -161,6 +167,7 @@ function computePackageVersionHash(version,
 _versionTag, packageBundleFileHash, routesBundleFileHash, uiBundleFileHash) {
     return (0, keys_1.hashValue)([version, packageBundleFileHash, routesBundleFileHash ?? "", uiBundleFileHash ?? ""].join(":"));
 }
+/** Checks whether an incoming version falls within the selected automatic update range. */
 function isVersionInRange(activeVersion, incomingVersion, range) {
     if (range === "pinned")
         return false;

package/dist/data/packages.d.ts

@@ -42,19 +42,25 @@ declare const schema: z.ZodObject<{
     followVersionTags?: string | undefined;
     updateUrl?: string | undefined;
 }>;
+/** A signed package record with publisher identity and version selection policy. */
 export type IPackage = z.infer<typeof schema>;
+/** Package table with signature enforcement outside personal contexts. */
 export declare class PackagesTable extends Table<IPackage> {
     static isPassthrough: boolean;
     insert(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
     update(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
     save(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
     signAndSave(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
-    private static addSignatureToPackage;
+    /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
     static enablePackageSigning(fn: (packageObj: IPackage) => IPackage): void;
     delete(packageId: string): Promise<void>;
 }
+/** Returns the Packages table for the given context or the current default context. */
 export declare function Packages(dataContext?: DataContext): PackagesTable;
+/** Default directory for locally stored package files. */
 export declare const packagesRootDir = "~/peers/packages";
+/** Device preference controlling package reloads when the UI refreshes. */
 export declare const reloadPackagesOnPageRefresh: import("./persistent-vars").PersistentVar<boolean>;
+/** Device preference enabling automatic peers-core updates. */
 export declare const autoUpdatePeersCore: import("./persistent-vars").PersistentVar<boolean>;
 export {};

package/dist/data/packages.js

@@ -83,6 +83,10 @@ const metaData = {
     iconClassName: "bi bi-box-fill",
     fields: (0, types_1.schemaToFields)(schema),
 };
+// Symbol.for keeps signer registration shared by separately installed SDK copies.
+const signingKey = Symbol.for("@peers-app/peers-sdk/package-signing");
+const signingGlobals = globalThis;
+/** Package table with signature enforcement outside personal contexts. */
 let PackagesTable = (() => {
     let _classSuper = table_1.Table;
     let _instanceExtraInitializers = [];
@@ -113,15 +117,16 @@ let PackagesTable = (() => {
             return super.save(packageObj, opts);
         }
         async signAndSave(packageObj, opts) {
-            if (!PackagesTable.addSignatureToPackage) {
+            const sign = signingGlobals[signingKey];
+            if (!sign) {
                 throw new Error("Package signing is not enabled. Call PackagesTable.enablePackageSigning(fn) to enable it.");
             }
-            packageObj = await PackagesTable.addSignatureToPackage(packageObj);
+            packageObj = await sign.call(PackagesTable, packageObj);
             return this.save(packageObj, opts);
         }
-        static addSignatureToPackage = undefined;
+        /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
         static enablePackageSigning(fn) {
-            PackagesTable.addSignatureToPackage = fn;
+            signingGlobals[signingKey] = fn;
         }
         async delete(packageId) {
             // anyone (with write permissions) can delete packages since that isn't a security risk (unless something else is relying on a package to be present?)
@@ -141,11 +146,15 @@ let PackagesTable = (() => {
 })();
 exports.PackagesTable = PackagesTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, schema, PackagesTable);
+/** Returns the Packages table for the given context or the current default context. */
 function Packages(dataContext) {
     return (0, context_1.getTableContainer)(dataContext).getTable(metaData, schema, PackagesTable);
 }
+/** Default directory for locally stored package files. */
 exports.packagesRootDir = "~/peers/packages";
+/** Device preference controlling package reloads when the UI refreshes. */
 exports.reloadPackagesOnPageRefresh = (0, persistent_vars_1.deviceVar)("reloadPackagesOnPageRefresh", {
     defaultValue: true,
 });
+/** Device preference enabling automatic peers-core updates. */
 exports.autoUpdatePeersCore = (0, persistent_vars_1.deviceVar)("autoUpdatePeersCore", { defaultValue: true });

package/dist/data/peer-types.d.ts

@@ -14,60 +14,22 @@ declare const valueTypeSchema: z.ZodObject<{
             optional: z.ZodOptional<z.ZodBoolean>;
             isArray: z.ZodOptional<z.ZodBoolean>;
             subType: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            name: string;
-            type: import("..").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }, {
-            name: string;
-            type: import("..").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }>, "many">>;
+            fields: z.ZodOptional<z.ZodLazy<z.ZodArray<z.ZodType<import("..").IField>>>>;
+            enumValues: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, "strip", z.ZodTypeAny, import("..").IField, import("..").IField>, "many">>;
     }, "strip", z.ZodTypeAny, {
         type: import("./tools").IOSchemaType;
-        fields: {
-            name: string;
-            type: import("..").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[];
+        fields: import("..").IField[];
     }, {
         type: import("./tools").IOSchemaType;
-        fields?: {
-            name: string;
-            type: import("..").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[] | undefined;
+        fields?: import("..").IField[] | undefined;
     }>;
     iconClass: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     schema: {
         type: import("./tools").IOSchemaType;
-        fields: {
-            name: string;
-            type: import("..").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[];
+        fields: import("..").IField[];
     };
     peerTypeId: string;
     description?: string | undefined;
@@ -76,15 +38,7 @@ declare const valueTypeSchema: z.ZodObject<{
     name: string;
     schema: {
         type: import("./tools").IOSchemaType;
-        fields?: {
-            name: string;
-            type: import("..").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[] | undefined;
+        fields?: import("..").IField[] | undefined;
     };
     peerTypeId: string;
     description?: string | undefined;
@@ -95,15 +49,7 @@ export declare function PeerTypes(dataContext?: DataContext): import("..").Table
     name: string;
     schema: {
         type: import("./tools").IOSchemaType;
-        fields: {
-            name: string;
-            type: import("..").FieldType;
-            optional?: boolean | undefined;
-            description?: string | undefined;
-            defaultValue?: any;
-            isArray?: boolean | undefined;
-            subType?: string | undefined;
-        }[];
+        fields: import("..").IField[];
     };
     peerTypeId: string;
     description?: string | undefined;

package/dist/data/persistent-vars.d.ts

@@ -61,7 +61,10 @@ export declare class PersistentVarsTable extends Table<IPersistentVar> {
     insert(persistentVar: IPersistentVar): Promise<IPersistentVar>;
     /** Update a persistent variable through the canonical save path. */
     update(persistentVar: IPersistentVar): Promise<IPersistentVar>;
-    /** Save a variable, assigning its deterministic ID and encrypting new secret plaintext. */
+    /**
+     * Save a variable, assigning its deterministic ID and encrypting new secret plaintext. Saves as
+     * a snapshot and restores a deleted row unless `opts` says otherwise.
+     */
     save(persistentVar: IPersistentVar, opts?: ISaveOptions): Promise<IPersistentVar>;
     /**
      * Replace a secret variable's stored ciphertext as-is, without passing it through

package/dist/data/persistent-vars.js

@@ -128,7 +128,10 @@ let PersistentVarsTable = (() => {
         async update(persistentVar) {
             return this.save(persistentVar);
         }
-        /** Save a variable, assigning its deterministic ID and encrypting new secret plaintext. */
+        /**
+         * Save a variable, assigning its deterministic ID and encrypting new secret plaintext. Saves as
+         * a snapshot and restores a deleted row unless `opts` says otherwise.
+         */
         async save(persistentVar, opts) {
             if (!persistentVar.persistentVarId) {
                 persistentVar.persistentVarId = (0, utils_1.deterministicPvarId)(persistentVar.name);
@@ -145,7 +148,9 @@ let PersistentVarsTable = (() => {
             }
             persistentVar.modifiedAt = Date.now();
             opts ??= {};
-            opts = { saveAsSnapshot: true, ...opts };
+            // The ID comes from the name, so setting a deleted pvar again, or re-creating it under a new
+            // scope, reuses a deleted ID; change tracking refuses that save unless it restores the row.
+            opts = { saveAsSnapshot: true, restoreIfDeleted: true, ...opts };
             return super.save(persistentVar, opts);
         }
         /**

package/dist/data/table-signing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/data/table-signing.test.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tableNames = ["package-version", "package", "group", "group-member", "user"];
+// These key strings are the contract between installed SDK versions; do not rename them.
+const signingKey = (name) => Symbol.for(`@peers-app/peers-sdk/${name}-signing`);
+// Restore process-global registrations so these tests never leave test signers installed.
+const priorSigners = tableNames.map((name) => {
+    const key = signingKey(name);
+    return { key, descriptor: Object.getOwnPropertyDescriptor(globalThis, key) };
+});
+beforeEach(() => {
+    for (const { key } of priorSigners) {
+        Reflect.deleteProperty(globalThis, key);
+    }
+});
+afterEach(() => {
+    for (const { key, descriptor } of priorSigners) {
+        if (descriptor) {
+            Object.defineProperty(globalThis, key, descriptor);
+        }
+        else {
+            Reflect.deleteProperty(globalThis, key);
+        }
+    }
+});
+function loadSigningTables() {
+    let tables;
+    jest.isolateModules(() => {
+        const { PackageVersionsTable } = require("./package-versions");
+        const { PackagesTable } = require("./packages");
+        const { GroupsTable } = require("./groups");
+        const { GroupMembersTable } = require("./group-members");
+        const { UsersTable } = require("./users");
+        tables = {
+            "package-version": {
+                prototype: PackageVersionsTable.prototype,
+                enable: PackageVersionsTable.enablePackageVersionSigning,
+            },
+            package: { prototype: PackagesTable.prototype, enable: PackagesTable.enablePackageSigning },
+            group: { prototype: GroupsTable.prototype, enable: GroupsTable.enableGroupSigning },
+            "group-member": {
+                prototype: GroupMembersTable.prototype,
+                enable: GroupMembersTable.enableGroupMemberSigning,
+            },
+            user: { prototype: UsersTable.prototype, enable: UsersTable.enableUserSigning },
+        };
+    });
+    return tables;
+}
+describe("table signing across SDK module instances", () => {
+    it.each(tableNames)("shares and replaces the %s signer across copies", async (name) => {
+        const first = loadSigningTables()[name];
+        const second = loadSigningTables()[name];
+        expect(first.prototype).not.toBe(second.prototype);
+        // Stub persistence only: exercise the real signAndSave and registration methods.
+        const receiver = { save: jest.fn(async (record) => record) };
+        const row = { name: "Example", signature: "" };
+        const opts = { saveAsSnapshot: false };
+        await expect(second.prototype.signAndSave.call(receiver, row, opts)).rejects.toThrow(/signing.*enabled/i);
+        expect(receiver.save).not.toHaveBeenCalled();
+        const sign = jest.fn((record) => ({ ...record, signature: "first" }));
+        first.enable(sign);
+        expect(Reflect.get(globalThis, signingKey(name))).toBe(sign);
+        await expect(second.prototype.signAndSave.call(receiver, row, opts)).resolves.toEqual({
+            ...row,
+            signature: "first",
+        });
+        expect(sign).toHaveBeenCalledWith(row);
+        expect(sign.mock.contexts.at(-1)).toBe(second.prototype.constructor);
+        expect(receiver.save).toHaveBeenLastCalledWith({ ...row, signature: "first" }, name === "group-member" ? { ...opts, restoreIfDeleted: true } : opts);
+        // Loading another copy must preserve a signer that is already registered.
+        const third = loadSigningTables()[name];
+        expect(third.prototype).not.toBe(first.prototype);
+        await expect(third.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
+            ...row,
+            signature: "first",
+        });
+        expect(sign.mock.contexts.at(-1)).toBe(third.prototype.constructor);
+        second.enable((record) => ({ ...record, signature: "replacement" }));
+        for (const copy of [first, third]) {
+            await expect(copy.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
+                ...row,
+                signature: "replacement",
+            });
+        }
+        receiver.save.mockClear();
+        const failsOnce = jest
+            .fn((record) => ({ ...record, signature: "recovered" }))
+            .mockImplementationOnce(() => {
+            throw new Error("signing failed");
+        });
+        first.enable(failsOnce);
+        await expect(second.prototype.signAndSave.call(receiver, row)).rejects.toThrow("signing failed");
+        expect(receiver.save).not.toHaveBeenCalled();
+        await expect(third.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
+            ...row,
+            signature: "recovered",
+        });
+        expect(failsOnce).toHaveBeenCalledTimes(2);
+        receiver.save.mockRejectedValueOnce(new Error("save failed"));
+        await expect(second.prototype.signAndSave.call(receiver, row)).rejects.toThrow("save failed");
+        await expect(first.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
+            ...row,
+            signature: "recovered",
+        });
+    });
+    it("keeps the five signer registrations independent", async () => {
+        const first = loadSigningTables();
+        const second = loadSigningTables();
+        for (const name of tableNames) {
+            first[name].enable((record) => ({ ...record, signature: name }));
+        }
+        const receiver = { save: jest.fn(async (record) => record) };
+        for (const name of tableNames) {
+            await expect(second[name].prototype.signAndSave.call(receiver, { name: "Example", signature: "" })).resolves.toEqual({ name: "Example", signature: name });
+        }
+    });
+});