@peers-app/peers-sdk 0.23.2 → 0.23.5

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

@@ -3,29 +3,60 @@ import { EventRegistry, type ITableDependencies, type ITableMetaData, Table, Tab
 import type { DataSourceFactory } from "../data/orm/table-definitions.type";
 import { PackageLoader } from "../package-loader/package-loader";
 import type { UserContext } from "./user-context";
+/**
+ * Per-user or per-group workspace: tables, events, and the package loader
+ * that installs both legacy and isolated packages into this context.
+ *
+ * `tableContainer` is created before `packageLoader` so isolated packages that
+ * declare provider-owned tables receive a host table gateway at construct time.
+ */
 export declare class DataContext {
     readonly userContext: UserContext;
     readonly groupId?: string | undefined;
+    private disposePromise?;
+    /** Factory that wraps the user-context data source with this group id. */
     readonly dataSourceFactory: DataSourceFactory;
+    /** Live table registry for this personal or group context. */
     readonly tableContainer: TableContainer;
+    /** Loads and unloads packages for this context, including isolated artifacts. */
     readonly packageLoader: PackageLoader;
+    /** In-process event bus scoped to {@link dataContextId}. */
     readonly eventRegistry: EventRegistry;
+    /** Personal user id, or group id when this context is group-scoped. */
     readonly dataContextId: string;
+    /**
+     * @param userContext - Owning signed-in user.
+     * @param groupId - When set, this context is the named group; otherwise personal.
+     */
     constructor(userContext: UserContext, groupId?: string | undefined);
     /**
-     * Call this to indicate that this should be the current data context to be used unless otherwise specified
+     * Mark this context as the user's default unless a caller pins another one.
      */
     setAsDefault(): void;
     /**
-     * Creates table dependencies for the new DI pattern.
-     * This factory method provides all dependencies a table needs in one object.
+     * Build the dependency bag a `Table` constructor needs for this context.
+     *
+     * @param metaData - Table metadata used to open the data source.
+     * @param schema - Optional Zod schema for the table rows.
      */
     createTableDependencies(metaData: ITableMetaData, schema?: z.AnyZodObject): ITableDependencies;
     /**
-     * Convenience method for creating tables with the new DI pattern.
-     * This is the preferred way to create custom table classes.
+     * Construct a table (or a custom `Table` subclass) bound to this context.
+     *
+     * @param metaData - Table metadata.
+     * @param schema - Optional Zod schema for the table rows.
+     * @param TableClass - Table implementation; defaults to {@link Table}.
      */
     createTable<T extends {
         [key: string]: any;
     }>(metaData: ITableMetaData, schema?: z.AnyZodObject, TableClass?: new (metaData: ITableMetaData, deps: ITableDependencies) => Table<T>): Table<T>;
+    /**
+     * Dispose package runtimes and release event emitters owned by this context.
+     *
+     * Repeated calls share one promise so group-removal and application-shutdown
+     * cleanup can safely race.
+     *
+     * @returns A promise that settles after all context resources are released.
+     */
+    dispose(): Promise<void>;
 }

package/dist/context/data-context.js

@@ -3,37 +3,55 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataContext = void 0;
 const orm_1 = require("../data/orm");
 const package_loader_1 = require("../package-loader/package-loader");
+/**
+ * Per-user or per-group workspace: tables, events, and the package loader
+ * that installs both legacy and isolated packages into this context.
+ *
+ * `tableContainer` is created before `packageLoader` so isolated packages that
+ * declare provider-owned tables receive a host table gateway at construct time.
+ */
 class DataContext {
     userContext;
     groupId;
+    disposePromise;
+    /** Factory that wraps the user-context data source with this group id. */
     dataSourceFactory;
+    /** Live table registry for this personal or group context. */
     tableContainer;
+    /** Loads and unloads packages for this context, including isolated artifacts. */
     packageLoader;
+    /** In-process event bus scoped to {@link dataContextId}. */
     eventRegistry;
+    /** Personal user id, or group id when this context is group-scoped. */
     dataContextId;
+    /**
+     * @param userContext - Owning signed-in user.
+     * @param groupId - When set, this context is the named group; otherwise personal.
+     */
     constructor(userContext, groupId) {
         this.userContext = userContext;
         this.groupId = groupId;
         this.dataContextId = groupId || userContext.userId;
-        // Initialize dependencies in the correct order to avoid circular references
         this.eventRegistry = new orm_1.EventRegistry(this.dataContextId);
-        this.packageLoader = new package_loader_1.PackageLoader(this);
-        // Set up data source factory with group wrapping
         const baseFactory = userContext.dataSourceFactory;
         this.dataSourceFactory = (metaData, schema) => baseFactory(metaData, schema, this.groupId);
-        // Set up table factory and table container
         const tableFactory = (metaData, schema, TableClass) => this.createTable(metaData, schema, TableClass);
         this.tableContainer = new orm_1.TableContainer(tableFactory, groupId);
+        // PackageLoader reads `tableContainer` in its constructor to wire isolated
+        // table persistence. Keep this last.
+        this.packageLoader = new package_loader_1.PackageLoader(this);
     }
     /**
-     * Call this to indicate that this should be the current data context to be used unless otherwise specified
+     * Mark this context as the user's default unless a caller pins another one.
      */
     setAsDefault() {
         this.userContext.defaultDataContext(this);
     }
     /**
-     * Creates table dependencies for the new DI pattern.
-     * This factory method provides all dependencies a table needs in one object.
+     * Build the dependency bag a `Table` constructor needs for this context.
+     *
+     * @param metaData - Table metadata used to open the data source.
+     * @param schema - Optional Zod schema for the table rows.
      */
     createTableDependencies(metaData, schema) {
         return {
@@ -44,12 +62,29 @@ class DataContext {
         };
     }
     /**
-     * Convenience method for creating tables with the new DI pattern.
-     * This is the preferred way to create custom table classes.
+     * Construct a table (or a custom `Table` subclass) bound to this context.
+     *
+     * @param metaData - Table metadata.
+     * @param schema - Optional Zod schema for the table rows.
+     * @param TableClass - Table implementation; defaults to {@link Table}.
      */
     createTable(metaData, schema, TableClass = orm_1.Table) {
         const deps = this.createTableDependencies(metaData, schema);
         return new TableClass(metaData, deps);
     }
+    /**
+     * Dispose package runtimes and release event emitters owned by this context.
+     *
+     * Repeated calls share one promise so group-removal and application-shutdown
+     * cleanup can safely race.
+     *
+     * @returns A promise that settles after all context resources are released.
+     */
+    dispose() {
+        this.disposePromise ??= this.packageLoader.dispose().finally(() => {
+            this.eventRegistry.clear();
+        });
+        return this.disposePromise;
+    }
 }
 exports.DataContext = DataContext;

package/dist/context/user-context.d.ts

@@ -18,8 +18,11 @@ export declare class UserContext {
     readonly loadingPromise: Promise<UserContext>;
     private personalUserSubscription?;
     private ownUserSubscription?;
+    private groupsSubscription?;
+    private observableSubscriptions;
     private groupUserSyncs;
     private _currentlyActiveGroupIdPVar?;
+    private disposed;
     constructor(userId: string, dataSourceFactory: DataSourceFactory, ephemeral?: boolean | undefined);
     private init;
     /**
@@ -35,6 +38,13 @@ export declare class UserContext {
         force?: boolean;
     }): Promise<void>;
     private loadGroupContexts;
+    private removeGroupDataContext;
+    /**
+     * Return the personal context, or the group context for `groupId`, creating
+     * the group context if this user context does not already hold it.
+     *
+     * @param groupId - Group id, or the current user id for the personal context.
+     */
     getDataContext(groupId: string): DataContext;
     /** Wait for any pending `currentlyActiveGroupId` pvar write to be flushed to the DB. */
     waitForActiveGroupPersistence(): Promise<void>;
@@ -44,6 +54,11 @@ export declare class UserContext {
      * for the user context to be fully loaded before proceeding with standard data access
      */
     private loadUserContextObservablesFromDB;
+    /**
+     * Load the signed-in user's `Users` row from the personal data context.
+     *
+     * @returns The cached personal user record, or `undefined` if it is missing.
+     */
     getMe(): Promise<{
         name: string;
         publicKey: string;
@@ -51,12 +66,41 @@ export declare class UserContext {
         userId: string;
         signature?: string | undefined;
     } | undefined>;
+    /**
+     * Sign and persist this user's identity, then copy it into every loaded
+     * group context and copy group records back into the personal context.
+     *
+     * @param userId - Signed-in user id.
+     * @param keys - Current public/private keypair used to sign the user row.
+     * @param me - Optional preloaded personal user row.
+     */
     syncUserAndGroupObjects(userId: string, keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
     private syncMyUserToAllGroups;
     private syncMyUserToGroup;
+    /**
+     * Subscribe to `dataChanged` events for one table across the personal
+     * context and every loaded group context.
+     *
+     * @param table - Table instance or table name.
+     * @param handler - Invoked with the event plus the owning data context.
+     */
     subscribeToDataChangedAcrossAllGroups<T extends {
         [key: string]: any;
     }>(table: string | Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
+    /**
+     * Dispose resources for the personal context and every loaded group context.
+     *
+     * The legacy method name is retained for callers that use this during
+     * Electron shutdown; disposal now also clears each context's event registry.
+     */
+    disposeIsolatedRuntimes(): Promise<void>;
+    /**
+     * Unsubscribe cross-group listeners and dispose isolated package runtimes.
+     *
+     * Runtime disposal is started but not awaited. Prefer
+     * {@link disposeIsolatedRuntimes} when the caller can wait (tests,
+     * Electron shutdown).
+     */
     dispose(): void;
 }
 /** Event payload supplied to subscriptions spanning every group data context. */

package/dist/context/user-context.js

@@ -23,8 +23,11 @@ class UserContext {
     loadingPromise;
     personalUserSubscription;
     ownUserSubscription;
+    groupsSubscription;
+    observableSubscriptions = [];
     groupUserSyncs = new Map();
     _currentlyActiveGroupIdPVar;
+    disposed = false;
     constructor(userId, dataSourceFactory, ephemeral) {
         this.userId = userId;
         this.dataSourceFactory = dataSourceFactory;
@@ -43,6 +46,9 @@ class UserContext {
         if (!this.ephemeral) {
             await this.loadUserContextObservablesFromDB();
         }
+        if (this.disposed) {
+            return this;
+        }
         await this.loadGroupContexts();
         return this;
     }
@@ -64,12 +70,14 @@ class UserContext {
     async loadGroupContexts() {
         const groupsTable = (0, data_1.Groups)(this.userDataContext);
         const groups = await groupsTable.list({ disabled: { $ne: true } });
+        if (this.disposed) {
+            return;
+        }
         this.groupIds(groups.map((g) => g.groupId));
-        groupsTable.dataChanged.subscribe((evt) => {
+        this.groupsSubscription = groupsTable.dataChanged.subscribe((evt) => {
             const groupId = evt.dataObject.groupId;
             if (evt.op === "delete" || evt.dataObject.disabled) {
-                this.groupIds(this.groupIds().filter((id) => id !== groupId));
-                this.groupDataContexts.delete(groupId);
+                this.removeGroupDataContext(groupId);
             }
             else {
                 const dataContext = this.getDataContext(groupId);
@@ -91,22 +99,39 @@ class UserContext {
             this.defaultDataContext(this.userDataContext);
         }
         // ensure when currentlyActiveGroupId changes, currentlyActiveGroup is updated and vice versa
-        this.currentlyActiveGroupId.subscribe(async (groupId) => {
+        this.observableSubscriptions.push(this.currentlyActiveGroupId.subscribe(async (groupId) => {
             const dataContext = this.getDataContext(groupId || this.userId);
             this.defaultDataContext(dataContext);
-        });
-        this.defaultDataContext.subscribe((group) => {
+        }), this.defaultDataContext.subscribe((group) => {
             if (!group) {
                 this.defaultDataContext(this.userDataContext);
             }
             else {
                 this.currentlyActiveGroupId(group.dataContextId);
             }
-        });
+        }));
         if (!this.currentlyActiveGroupId()) {
             this.currentlyActiveGroupId(this.defaultDataContext().dataContextId || this.userId);
         }
     }
+    removeGroupDataContext(groupId) {
+        this.groupIds(this.groupIds().filter((id) => id !== groupId));
+        const removedContext = this.groupDataContexts.get(groupId);
+        this.groupDataContexts.delete(groupId);
+        this.groupUserSyncs.delete(groupId);
+        if (this.defaultDataContext().dataContextId === groupId) {
+            this.defaultDataContext(this.userDataContext);
+        }
+        void removedContext?.dispose().catch((error) => {
+            console.error(`Error disposing removed group context ${groupId}:`, error);
+        });
+    }
+    /**
+     * Return the personal context, or the group context for `groupId`, creating
+     * the group context if this user context does not already hold it.
+     *
+     * @param groupId - Group id, or the current user id for the personal context.
+     */
     getDataContext(groupId) {
         if (!groupId || groupId === this.userId) {
             return this.userDataContext;
@@ -121,7 +146,11 @@ class UserContext {
             const groupContext = new data_context_1.DataContext(this, groupId);
             this.groupDataContexts.set(groupId, groupContext);
         }
-        return this.groupDataContexts.get(groupId);
+        const dataContext = this.groupDataContexts.get(groupId);
+        if (!dataContext) {
+            throw new Error(`Failed to create data context for group ${groupId}`);
+        }
+        return dataContext;
     }
     /** Wait for any pending `currentlyActiveGroupId` pvar write to be flushed to the DB. */
     async waitForActiveGroupPersistence() {
@@ -140,6 +169,9 @@ class UserContext {
         const vars = await persistentVars.list({
             name: { $in: ["thisDeviceId", "currentlyActiveGroupId", "reloadPackagesOnPageRefresh"] },
         });
+        if (this.disposed) {
+            return;
+        }
         const varDbValues = vars.reduce((acc, curr) => {
             acc[curr.name] = curr.value?.value;
             return acc;
@@ -151,7 +183,7 @@ class UserContext {
             userContext: this,
         });
         this.deviceId(deviceIdPVar());
-        (0, observable_1.linkObservables)(deviceIdPVar, this.deviceId);
+        this.observableSubscriptions.push((0, observable_1.linkObservables)(deviceIdPVar, this.deviceId));
         const currentlyActiveGroupIdPVar = (0, data_1.deviceVar)("currentlyActiveGroupId", {
             dbValue: varDbValues.currentlyActiveGroupId,
             defaultValue: "",
@@ -159,24 +191,37 @@ class UserContext {
         });
         this._currentlyActiveGroupIdPVar = currentlyActiveGroupIdPVar;
         this.currentlyActiveGroupId(currentlyActiveGroupIdPVar());
-        (0, observable_1.linkObservables)(currentlyActiveGroupIdPVar, this.currentlyActiveGroupId);
+        this.observableSubscriptions.push((0, observable_1.linkObservables)(currentlyActiveGroupIdPVar, this.currentlyActiveGroupId));
         const reloadPackagesOnPageRefreshPVar = (0, data_1.deviceVar)("reloadPackagesOnPageRefresh", {
             defaultValue: false,
             dbValue: varDbValues.reloadPackagesOnPageRefresh,
             userContext: this,
         });
         this.reloadPackagesOnPageRefresh(reloadPackagesOnPageRefreshPVar());
-        (0, observable_1.linkObservables)(reloadPackagesOnPageRefreshPVar, this.reloadPackagesOnPageRefresh);
+        this.observableSubscriptions.push((0, observable_1.linkObservables)(reloadPackagesOnPageRefreshPVar, this.reloadPackagesOnPageRefresh));
         await Promise.all([
             deviceIdPVar.loadingPromise,
             currentlyActiveGroupIdPVar.loadingPromise,
             reloadPackagesOnPageRefreshPVar.loadingPromise,
         ]);
     }
+    /**
+     * Load the signed-in user's `Users` row from the personal data context.
+     *
+     * @returns The cached personal user record, or `undefined` if it is missing.
+     */
     async getMe() {
         const dbMe = await (0, data_1.Users)(this.userDataContext).get(this.userId, { useCache: true });
         return dbMe;
     }
+    /**
+     * Sign and persist this user's identity, then copy it into every loaded
+     * group context and copy group records back into the personal context.
+     *
+     * @param userId - Signed-in user id.
+     * @param keys - Current public/private keypair used to sign the user row.
+     * @param me - Optional preloaded personal user row.
+     */
     async syncUserAndGroupObjects(userId, keys, me) {
         me ??= await this.getMe();
         if (!me) {
@@ -274,12 +319,21 @@ class UserContext {
             }
         }
     }
+    /**
+     * Subscribe to `dataChanged` events for one table across the personal
+     * context and every loaded group context.
+     *
+     * @param table - Table instance or table name.
+     * @param handler - Invoked with the event plus the owning data context.
+     */
     subscribeToDataChangedAcrossAllGroups(table, handler) {
         const tableName = typeof table === "string" ? table : table.tableName;
         const tableEventPrefix = `${tableName}_DataChanged_`;
         const unsubscribePrefix = (0, events_1.subscribePrefix)(tableEventPrefix);
         const subscription = (0, events_1.subscribe)((evt) => evt.name.startsWith(tableEventPrefix), async (evt) => {
-            const dataContextId = evt.name.endsWith("_") ? this.userId : evt.name.split("_").pop();
+            const dataContextId = evt.name.endsWith("_")
+                ? this.userId
+                : (evt.name.split("_").pop() ?? this.userId);
             const dataContext = this.getDataContext(dataContextId);
             handler({
                 name: evt.name,
@@ -295,9 +349,34 @@ class UserContext {
         };
         return subscription;
     }
+    /**
+     * Dispose resources for the personal context and every loaded group context.
+     *
+     * The legacy method name is retained for callers that use this during
+     * Electron shutdown; disposal now also clears each context's event registry.
+     */
+    async disposeIsolatedRuntimes() {
+        await Promise.all([
+            this.userDataContext.dispose(),
+            ...[...this.groupDataContexts.values()].map((context) => context.dispose()),
+        ]);
+    }
+    /**
+     * Unsubscribe cross-group listeners and dispose isolated package runtimes.
+     *
+     * Runtime disposal is started but not awaited. Prefer
+     * {@link disposeIsolatedRuntimes} when the caller can wait (tests,
+     * Electron shutdown).
+     */
     dispose() {
+        this.disposed = true;
+        this.groupsSubscription?.unsubscribe();
         this.personalUserSubscription?.unsubscribe();
         this.ownUserSubscription?.unsubscribe();
+        for (const subscription of this.observableSubscriptions.splice(0)) {
+            subscription.dispose();
+        }
+        void this.disposeIsolatedRuntimes();
     }
 }
 exports.UserContext = UserContext;

package/dist/contracts/__tests__/contract-provider-router.test.js

@@ -64,6 +64,32 @@ describe("contract provider router", () => {
         expect(resolveEndpoint).not.toHaveBeenCalled();
         router.dispose();
     });
+    it("keys endpoints by provider and invalidates one provider without trusting call payload", async () => {
+        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
+        let activeProvider = "provider-a";
+        const created = [];
+        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
+            authorizeCall: () => ({ dataContextId: "personal-context" }),
+            resolveProviderPackageId: () => activeProvider,
+            resolveEndpoint: (request) => {
+                const providerPackageId = request.providerPackageId ?? "missing";
+                const endpoint = makeEndpoint(providerPackageId);
+                created.push({ providerPackageId, endpoint });
+                return endpoint;
+            },
+        });
+        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).resolves.toBe("provider-a:list");
+        activeProvider = "provider-b";
+        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).resolves.toBe("provider-b:list");
+        expect(created).toHaveLength(2);
+        router.invalidateProvider("provider-a");
+        expect(created[0].endpoint.dispose).toHaveBeenCalledTimes(1);
+        expect(created[1].endpoint.dispose).not.toHaveBeenCalled();
+        activeProvider = "provider-a";
+        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).resolves.toBe("provider-a:list");
+        expect(created).toHaveLength(3);
+        router.dispose();
+    });
     it("ignores peer-supplied context in favor of trusted host context", async () => {
         const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
         const trustedContext = {

package/dist/contracts/__tests__/contract-resolvers.test.js

@@ -259,6 +259,22 @@ describe("local user-context contract routing", () => {
         expect(setup.getDataContext).not.toHaveBeenCalledWith(unknownId);
         router.dispose();
     });
+    it("prefers an isolated package endpoint over an in-process resolver", async () => {
+        const setup = setupLocalRouter();
+        const isolatedHandle = jest.fn(async () => "from-isolated");
+        setup.userContext.userDataContext.packageLoader = {
+            resolveIsolatedEndpoint: jest.fn(async () => ({
+                handleCall: isolatedHandle,
+                dispose() { },
+            })),
+        };
+        const router = (0, index_1.createLocalUserContextContractProviderRouter)(setup.providerTransport, {
+            getUserContext: async () => setup.userContext,
+        });
+        await expect(setup.consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeToolCall(setup.contractId))).resolves.toBe("from-isolated");
+        expect(isolatedHandle).toHaveBeenCalled();
+        router.dispose();
+    });
     it("enforces an optional contract allowlist before resolving a provider", async () => {
         const setup = setupLocalRouter();
         const router = (0, index_1.createLocalUserContextContractProviderRouter)(setup.providerTransport, {
@@ -305,3 +321,31 @@ describe("local user-context contract routing", () => {
         router.dispose();
     });
 });
+describe("provider-scoped contract resolvers", () => {
+    it("prefers the selected provider and preserves the unscoped fallback", () => {
+        const contractId = (0, utils_1.newid)();
+        const providerA = (0, utils_1.newid)();
+        const providerB = (0, utils_1.newid)();
+        const unscoped = jest.fn(() => ({ contractId, version: 1 }));
+        const scopedA = jest.fn(() => ({ contractId, version: 1 }));
+        (0, index_1.registerContractResolver)(contractId, 1, unscoped);
+        (0, index_1.registerContractResolver)(contractId, 1, scopedA, {
+            providerPackageId: providerA,
+        });
+        expect((0, index_1.getContractResolver)(contractId, 1, providerA)).toBe(scopedA);
+        expect((0, index_1.getContractResolver)(contractId, 1, providerB)).toBe(unscoped);
+        expect((0, index_1.getContractResolver)(contractId, 1)).toBe(unscoped);
+    });
+    it("supports legacy unscoped lookup only when a scoped provider is unambiguous", () => {
+        const contractId = (0, utils_1.newid)();
+        const providerA = (0, utils_1.newid)();
+        const providerB = (0, utils_1.newid)();
+        const scopedA = jest.fn(() => ({ contractId, version: 1 }));
+        const scopedB = jest.fn(() => ({ contractId, version: 1 }));
+        (0, index_1.registerContractResolver)(contractId, 1, scopedA, { providerPackageId: providerA });
+        expect((0, index_1.getContractResolver)(contractId, 1)).toBe(scopedA);
+        (0, index_1.registerContractResolver)(contractId, 1, scopedB, { providerPackageId: providerB });
+        expect((0, index_1.getContractResolver)(contractId, 1)).toBeUndefined();
+        expect((0, index_1.getContractResolver)(contractId, 1, providerB)).toBe(scopedB);
+    });
+});

package/dist/contracts/__tests__/registry.test.js

@@ -64,3 +64,107 @@ describe("ContractRegistry.selectProvider", () => {
         expect(empty.selectProvider({ contractId, version: 1 })).toBeUndefined();
     });
 });
+describe("ContractRegistry.registerBatch", () => {
+    it("registers same-batch alsoImplements targets atomically", () => {
+        const registry = new registry_1.ContractRegistry();
+        const providerPackageId = (0, utils_1.newid)();
+        const targetContractId = (0, utils_1.newid)();
+        const implementationContractId = (0, utils_1.newid)();
+        const result = registry.registerBatch(providerPackageId, [
+            { definition: makeDefinition(targetContractId, 1, "Target") },
+            {
+                definition: makeDefinition(implementationContractId, 2, "Implementation"),
+                alsoImplements: [{ contractId: targetContractId, version: 1 }],
+            },
+        ]);
+        expect(result.valid).toBe(true);
+        expect(registry.getProviderPackageId(targetContractId, 1)).toBe(providerPackageId);
+        expect(registry.getProviderPackageId(implementationContractId, 2)).toBe(providerPackageId);
+    });
+    it("registers alsoImplements as a routable provider alias", () => {
+        const registry = new registry_1.ContractRegistry();
+        const originalProvider = (0, utils_1.newid)();
+        const compatibleProvider = (0, utils_1.newid)();
+        const contractId = (0, utils_1.newid)();
+        registry.register(originalProvider, makeDefinition(contractId, 1, "Version 1"));
+        const result = registry.registerBatch(compatibleProvider, [
+            {
+                definition: makeDefinition(contractId, 2, "Version 2"),
+                alsoImplements: [{ contractId, version: 1 }],
+            },
+        ]);
+        expect(result.valid).toBe(true);
+        expect(registry.getRegisteredProviderIds(contractId, 1)).toEqual([
+            originalProvider,
+            compatibleProvider,
+        ]);
+        expect(registry.getProviderImplementation(contractId, 1, compatibleProvider)).toEqual({
+            contractId,
+            version: 2,
+        });
+    });
+    it("leaves registry state unchanged when any batch entry fails", () => {
+        const registry = new registry_1.ContractRegistry();
+        const existingProvider = (0, utils_1.newid)();
+        const rejectedProvider = (0, utils_1.newid)();
+        const existingContractId = (0, utils_1.newid)();
+        const newContractId = (0, utils_1.newid)();
+        const frozen = { ...makeDefinition(existingContractId, 1, "Frozen"), devTag: undefined };
+        expect(registry.register(existingProvider, frozen).valid).toBe(true);
+        const result = registry.registerBatch(rejectedProvider, [
+            { definition: makeDefinition(newContractId, 1, "Would Be Partial") },
+            { definition: makeDefinition(existingContractId, 1, "Frozen Changed") },
+        ]);
+        expect(result.valid).toBe(false);
+        expect(registry.getDefinition(newContractId, 1)).toBeUndefined();
+        expect(registry.getRegisteredProviderIds(newContractId, 1)).toEqual([]);
+        expect(registry.getProviderPackageId(existingContractId, 1)).toBe(existingProvider);
+        expect(registry.getRegisteredProviderIds(existingContractId, 1)).toEqual([existingProvider]);
+    });
+    it("preserves the existing active provider when another package registers a batch", () => {
+        const registry = new registry_1.ContractRegistry();
+        const contractId = (0, utils_1.newid)();
+        const activeProvider = (0, utils_1.newid)();
+        const additionalProvider = (0, utils_1.newid)();
+        registry.register(activeProvider, makeDefinition(contractId, 1, "Active"));
+        expect(registry.registerBatch(additionalProvider, [
+            { definition: makeDefinition(contractId, 1, "Additional") },
+        ]).valid).toBe(true);
+        expect(registry.getProviderPackageId(contractId, 1)).toBe(activeProvider);
+    });
+});
+describe("ContractRegistry.replaceBatch", () => {
+    it("replaces the provider's complete contract set and preserves its active selections", () => {
+        const registry = new registry_1.ContractRegistry();
+        const providerPackageId = (0, utils_1.newid)();
+        const retainedContractId = (0, utils_1.newid)();
+        const removedContractId = (0, utils_1.newid)();
+        const addedContractId = (0, utils_1.newid)();
+        registry.registerBatch(providerPackageId, [
+            { definition: makeDefinition(retainedContractId, 1, "Retained") },
+            { definition: makeDefinition(removedContractId, 1, "Removed") },
+        ]);
+        const result = registry.replaceBatch(providerPackageId, [
+            { definition: makeDefinition(retainedContractId, 1, "Retained replacement") },
+            { definition: makeDefinition(addedContractId, 1, "Added") },
+        ]);
+        expect(result.valid).toBe(true);
+        expect(registry.getProviderPackageId(retainedContractId, 1)).toBe(providerPackageId);
+        expect(registry.getRegisteredProviderIds(removedContractId, 1)).toEqual([]);
+        expect(registry.getProviderPackageId(addedContractId, 1)).toBe(providerPackageId);
+    });
+    it("leaves the previous provider set untouched when replacement validation fails", () => {
+        const registry = new registry_1.ContractRegistry();
+        const providerPackageId = (0, utils_1.newid)();
+        const existingContractId = (0, utils_1.newid)();
+        const rejectedContractId = (0, utils_1.newid)();
+        registry.register(providerPackageId, makeDefinition(existingContractId, 1, "Existing"));
+        const result = registry.replaceBatch(providerPackageId, [
+            { definition: makeDefinition(rejectedContractId, 1, "Rejected") },
+            { definition: makeDefinition(rejectedContractId, 1, "Duplicate") },
+        ]);
+        expect(result.valid).toBe(false);
+        expect(registry.getProviderPackageId(existingContractId, 1)).toBe(providerPackageId);
+        expect(registry.getRegisteredProviderIds(rejectedContractId, 1)).toEqual([]);
+    });
+});