@peers-app/peers-sdk 0.26.5 → 0.26.6

package/dist/data/group-members.d.ts

@@ -3,6 +3,7 @@ import type { DataContext } from "../context/data-context";
 import { GroupMemberRole } from "./group-member-roles";
 import type { ISaveOptions } from "./orm/data-query";
 import { Table } from "./orm/table";
+/** Schema for a signed group membership, including its role and soft deletion state. */
 export declare const groupMemberSchema: z.ZodObject<{
     groupMemberId: z.ZodEffects<z.ZodString, string, string>;
     groupId: z.ZodEffects<z.ZodString, string, string>;
@@ -25,18 +26,22 @@ export declare const groupMemberSchema: z.ZodObject<{
     groupMemberId: string;
     deleted?: boolean | undefined;
 }>;
+/** A signed association between a user and a group with an assigned role. */
 export type IGroupMember = z.infer<typeof groupMemberSchema>;
+/** System table name for group membership records. */
 export declare const groupMembersTableName = "GroupMembers";
+/** Group membership table with signature checks and signed soft deletion. */
 export declare class GroupMembersTable extends Table<IGroupMember> {
     static isPassthrough: boolean;
     save(groupMember: IGroupMember, opts?: ISaveOptions): Promise<IGroupMember>;
     signAndSave(groupMember: IGroupMember, opts?: ISaveOptions): Promise<IGroupMember>;
     delete(groupMemberId: string): Promise<void>;
-    private static addSignatureToGroupMember;
+    /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
     static enableGroupMemberSigning(fn: (groupMember: IGroupMember) => IGroupMember): void;
     /** @deprecated Forbidden on GroupsTable; use save() */
     insert(..._args: Parameters<Table<IGroupMember>["insert"]>): never;
     /** @deprecated Forbidden on GroupsTable; use save() */
     update(..._args: Parameters<Table<IGroupMember>["update"]>): never;
 }
+/** Returns the GroupMembers table for the given context or the current default context. */
 export declare function GroupMembers(dataContext?: DataContext): GroupMembersTable;

package/dist/data/group-members.js

@@ -46,6 +46,7 @@ const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
 const users_1 = require("./users");
+/** Schema for a signed group membership, including its role and soft deletion state. */
 exports.groupMemberSchema = zod_1.z.object({
     groupMemberId: zod_types_1.zodPeerId,
     groupId: zod_types_1.zodPeerId.describe("The id of the group"),
@@ -59,6 +60,7 @@ exports.groupMemberSchema = zod_1.z.object({
         .optional()
         .describe("Whether this membership has been deleted (soft delete)"),
 });
+/** System table name for group membership records. */
 exports.groupMembersTableName = "GroupMembers";
 const metaData = {
     name: exports.groupMembersTableName,
@@ -67,6 +69,10 @@ const metaData = {
     fields: (0, types_1.schemaToFields)(exports.groupMemberSchema),
     indexes: [{ fields: ["groupId", "userId"], unique: true }],
 };
+// Symbol.for keeps signer registration shared by separately installed SDK copies.
+const signingKey = Symbol.for("@peers-app/peers-sdk/group-member-signing");
+const signingGlobals = globalThis;
+/** Group membership table with signature checks and signed soft deletion. */
 let GroupMembersTable = (() => {
     let _classSuper = table_1.Table;
     let _instanceExtraInitializers = [];
@@ -96,10 +102,11 @@ let GroupMembersTable = (() => {
             throw new Error("Group member signature is not valid");
         }
         async signAndSave(groupMember, opts) {
-            if (!GroupMembersTable.addSignatureToGroupMember) {
+            const sign = signingGlobals[signingKey];
+            if (!sign) {
                 throw new Error("Group member signing must be enabled to sign and save group members. Call GroupMembersTable.enableGroupMemberSigning(fn) to enable it.");
             }
-            groupMember = GroupMembersTable.addSignatureToGroupMember(groupMember);
+            groupMember = sign.call(GroupMembersTable, groupMember);
             return this.save(groupMember, {
                 saveAsSnapshot: true,
                 restoreIfDeleted: true,
@@ -118,9 +125,9 @@ let GroupMembersTable = (() => {
                 await this.signAndSave(groupMember);
             }
         }
-        static addSignatureToGroupMember = undefined;
+        /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
         static enableGroupMemberSigning(fn) {
-            GroupMembersTable.addSignatureToGroupMember = fn;
+            signingGlobals[signingKey] = fn;
         }
         /** @deprecated Forbidden on GroupsTable; use save() */
         insert(..._args) {
@@ -138,6 +145,7 @@ let GroupMembersTable = (() => {
 })();
 exports.GroupMembersTable = GroupMembersTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.groupMemberSchema, GroupMembersTable);
+/** Returns the GroupMembers table for the given context or the current default context. */
 function GroupMembers(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.groupMemberSchema, GroupMembersTable);
 }

package/dist/data/groups.d.ts

@@ -3,6 +3,7 @@ import type { DataContext } from "../context/data-context";
 import { GroupMemberRole } from "./group-member-roles";
 import type { ISaveOptions } from "./orm/data-query";
 import { Table } from "./orm/table";
+/** Schema for a signed group record, including membership policy and group public keys. */
 export declare const groupSchema: z.ZodObject<{
     groupId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
@@ -37,18 +38,22 @@ export declare const groupSchema: z.ZodObject<{
     iconClassName?: string | undefined;
     publicRole?: GroupMemberRole | undefined;
 }>;
+/** A signed group record shared between personal and group contexts. */
 export type IGroup = z.infer<typeof groupSchema>;
+/** System table name for group records. */
 export declare const groupsTableName = "Groups";
+/** Group table with signature enforcement outside the personal context. */
 export declare class GroupsTable extends Table<IGroup> {
     static isPassthrough: boolean;
     save(group: IGroup, opts?: ISaveOptions): Promise<IGroup>;
     signAndSave(group: IGroup, opts?: ISaveOptions): Promise<IGroup>;
     delete(groupId: string): Promise<void>;
-    private static addSignatureToGroup;
+    /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
     static enableGroupSigning(fn: (group: IGroup) => IGroup): void;
     /** @deprecated Direct inserts forbidden; use save() */
     insert(..._args: Parameters<Table<IGroup>["insert"]>): never;
     /** @deprecated Direct updates forbidden; use save() */
     update(..._args: Parameters<Table<IGroup>["update"]>): never;
 }
+/** Returns the Groups table for the given context or the current default context. */
 export declare function Groups(dataContext?: DataContext): GroupsTable;

package/dist/data/groups.js

@@ -45,6 +45,7 @@ const decorators_1 = require("./orm/decorators");
 const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
+/** Schema for a signed group record, including membership policy and group public keys. */
 exports.groupSchema = zod_1.z.object({
     groupId: zod_types_1.zodPeerId,
     name: zod_1.z.string(),
@@ -67,6 +68,7 @@ exports.groupSchema = zod_1.z.object({
         .string()
         .describe("The public key used to encrypt data that only group members with writer permissions or higher can decrypt"),
 });
+/** System table name for group records. */
 exports.groupsTableName = "Groups";
 const metaData = {
     name: exports.groupsTableName,
@@ -76,6 +78,10 @@ const metaData = {
     iconClassName: "bi bi-people-fill",
     indexes: [{ fields: ["name"] }],
 };
+// Symbol.for keeps signer registration shared by separately installed SDK copies.
+const signingKey = Symbol.for("@peers-app/peers-sdk/group-signing");
+const signingGlobals = globalThis;
+/** Group table with signature enforcement outside the personal context. */
 let GroupsTable = (() => {
     let _classSuper = table_1.Table;
     let _instanceExtraInitializers = [];
@@ -103,10 +109,11 @@ let GroupsTable = (() => {
             return super.save(group, opts);
         }
         async signAndSave(group, opts) {
-            if (!GroupsTable.addSignatureToGroup) {
+            const sign = signingGlobals[signingKey];
+            if (!sign) {
                 throw new Error("Group signing must be enabled to sign and save groups. Call GroupsTable.enableGroupSigning(fn) to enable it.");
             }
-            group = GroupsTable.addSignatureToGroup(group);
+            group = sign.call(GroupsTable, group);
             return this.save(group, opts);
         }
         async delete(groupId) {
@@ -117,9 +124,9 @@ let GroupsTable = (() => {
             }
             throw new Error("Only deleting groups from the user context Groups table is allowed");
         }
-        static addSignatureToGroup = undefined;
+        /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
         static enableGroupSigning(fn) {
-            GroupsTable.addSignatureToGroup = fn;
+            signingGlobals[signingKey] = fn;
         }
         /** @deprecated Direct inserts forbidden; use save() */
         insert(..._args) {
@@ -137,6 +144,7 @@ let GroupsTable = (() => {
 })();
 exports.GroupsTable = GroupsTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.groupSchema, GroupsTable);
+/** Returns the Groups table for the given context or the current default context. */
 function Groups(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.groupSchema, GroupsTable);
 }

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/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 });
+        }
+    });
+});

package/dist/data/users.d.ts

@@ -84,8 +84,7 @@ export declare class UsersTable extends Table<IUser> {
      */
     save(user: IUser, opts?: ISaveOptions): Promise<IUser>;
     signAndSave(user: IUser, opts?: ISaveOptions): Promise<IUser>;
-    private static addSignatureToUser;
-    /** Enables signing for proxied `signAndSave` calls. */
+    /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
     static enableUserSigning(fn: (user: IUser) => IUser): void;
     /** @deprecated Forbidden on UsersTable; use save() */
     insert(..._args: Parameters<Table<IUser>["insert"]>): never;

package/dist/data/users.js

@@ -102,6 +102,9 @@ let userRowChangeGuard = refuseIdentityChanges;
 function setUserRowChangeGuard(guard) {
     userRowChangeGuard = guard ?? refuseIdentityChanges;
 }
+// Symbol.for keeps signer registration shared by separately installed SDK copies.
+const signingKey = Symbol.for("@peers-app/peers-sdk/user-signing");
+const signingGlobals = globalThis;
 /** User table with owner-signature enforcement outside the personal context. */
 let UsersTable = (() => {
     let _classSuper = table_1.Table;
@@ -170,20 +173,20 @@ let UsersTable = (() => {
             return super.save(verdict.row, opts);
         }
         async signAndSave(user, opts) {
-            if (!UsersTable.addSignatureToUser) {
+            const sign = signingGlobals[signingKey];
+            if (!sign) {
                 throw new Error("User signing must be enabled to sign and save users. Call UsersTable.enableUserSigning(fn) to enable it.");
             }
             user = {
                 ...user,
                 name: user.name.slice(0, devices_1.DISPLAY_NAME_MAX_LENGTH),
             };
-            user = UsersTable.addSignatureToUser(user);
+            user = sign.call(UsersTable, user);
             return this.save(user, opts);
         }
-        static addSignatureToUser = undefined;
-        /** Enables signing for proxied `signAndSave` calls. */
+        /** Registers the signer for all SDK copies in this JavaScript realm. Replaces any prior signer. */
         static enableUserSigning(fn) {
-            UsersTable.addSignatureToUser = fn;
+            signingGlobals[signingKey] = fn;
         }
         /** @deprecated Forbidden on UsersTable; use save() */
         insert(..._args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.26.5",
+  "version": "0.26.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"