@peers-app/peers-sdk 0.23.10 → 0.23.12

package/dist/package-loader/isolated-artifact.test.js

@@ -235,12 +235,60 @@ describe("isolated package artifact", () => {
             { contractId: targetContractId, version: { from: 2, to: 4 } },
         ]);
     });
-    test("rejects unsupported contract features instead of dropping them", () => {
+    test("maps declared events to the public contract definition", () => {
         const { artifact } = makeArtifact();
         artifact.manifest.provides[0].events = [
-            { name: "changed", payloadFields: [] },
+            {
+                name: "changed",
+                description: "State changed",
+                payloadFields: [{ name: "count", type: field_type_1.FieldType.number }],
+            },
+            { name: "pinged", description: "No payload" },
         ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/events is not supported/);
+        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
+        expect(manifest.provides[0].events?.[1].payloadFields).toEqual([]);
+        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], manifest.tables ?? []);
+        expect(definition.events).toEqual([
+            {
+                name: "changed",
+                description: "State changed",
+                payloadFields: [{ name: "count", type: field_type_1.FieldType.number }],
+            },
+            { name: "pinged", description: "No payload", payloadFields: [] },
+        ]);
+        expect((0, isolated_artifact_1.findProvidedContractEvent)(manifest.provides, definition.contractId, 1, "changed")).toBe(manifest.provides[0].events?.[0]);
+        expect((0, isolated_artifact_1.packageProvidesEvent)(manifest.provides, definition.contractId, 1, "missing")).toBe(false);
+    });
+    test("allows an events-only contract", () => {
+        const { artifact } = makeArtifact();
+        artifact.manifest.provides[0].tools = [];
+        artifact.manifest.provides[0].events = [{ name: "changed", description: "State changed" }];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
+        artifact.manifest.provides[0].events = [];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/at least one contract member/);
+    });
+    test("rejects malformed or duplicate events", () => {
+        const { artifact } = makeArtifact();
+        artifact.manifest.provides[0].events = [
+            { name: "changed", description: "a" },
+            { name: "changed", description: "b" },
+        ];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/duplicate event "changed"/);
+        artifact.manifest.provides[0].events = [{ name: "changed" }];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/description is required/);
+        artifact.manifest.provides[0].events = [
+            { name: "changed", description: "a", accessLevel: 50 },
+        ];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/accessLevel is not supported/);
+        artifact.manifest.provides[0].events = [
+            { name: "changed", description: "a", payloadFields: [{ name: "x", type: "nope" }] },
+        ];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/type must be a FieldType/);
+    });
+    test("rejects unsupported contract features instead of dropping them", () => {
+        const { artifact } = makeArtifact();
+        artifact.manifest.provides[0].streams = [];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/streams is not supported/);
     });
     test("rejects missing public table references and malformed observable bindings", () => {
         const { artifact } = makeArtifact();

package/dist/package-loader/isolated-runtime.d.ts

@@ -126,7 +126,19 @@ export interface IIsolatedPackageTableGateway {
      * The host validates declaration and provider identity before calling the gateway.
      */
     call(ref: IIsolatedPackageTableRef, operation: IsolatedContractTableOperation, args: unknown[]): Promise<unknown>;
+    /**
+     * Subscribe to a host-owned table event. Only `dataChanged` is supported;
+     * payloads are copied before delivery. The host validates declaration and
+     * contract exposure before calling the gateway.
+     *
+     * @returns A callback that detaches the host-side subscription.
+     */
+    subscribe(ref: IIsolatedPackageTableRef, eventName: IsolatedContractTableEvent, handler: (event: unknown) => void): Promise<() => void>;
 }
+/** Table events consumers may subscribe to on an isolated contract table. */
+export declare const ISOLATED_CONTRACT_TABLE_EVENTS: readonly ["dataChanged"];
+/** Consumer-subscribable event on an isolated contract table. */
+export type IsolatedContractTableEvent = (typeof ISOLATED_CONTRACT_TABLE_EVENTS)[number];
 /**
  * Trusted identity of one package-owned pvar.
  *
@@ -168,8 +180,11 @@ export interface IIsolatedPackagePersistentVarGateway {
 export interface IIsolatedContractProviderEndpointRequest extends IContractProviderEndpointRequest {
     /** Installed isolated package making the consumed-contract call. */
     consumerPackageId: string;
-    /** Registry-selected provider package. */
-    providerPackageId: string;
+    /**
+     * Registry-selected provider package. Omitted for a device-targeted route
+     * (`targetDeviceId` set), where the executing device selects the provider.
+     */
+    providerPackageId?: string;
     /** Optional deadline the gateway should enforce for provider setup/calls. */
     timeoutMs?: number;
 }

package/dist/package-loader/isolated-runtime.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ISOLATED_CONTRACT_TABLE_OPERATIONS = void 0;
+exports.ISOLATED_CONTRACT_TABLE_EVENTS = exports.ISOLATED_CONTRACT_TABLE_OPERATIONS = void 0;
 exports.setIsolatedPackageRuntimeFactory = setIsolatedPackageRuntimeFactory;
 exports.getIsolatedPackageRuntimeFactory = getIsolatedPackageRuntimeFactory;
 /** Standard table methods exposed through isolated contract-table references. */
@@ -14,6 +14,8 @@ exports.ISOLATED_CONTRACT_TABLE_OPERATIONS = [
     "update",
     "delete",
 ];
+/** Table events consumers may subscribe to on an isolated contract table. */
+exports.ISOLATED_CONTRACT_TABLE_EVENTS = ["dataChanged"];
 let isolatedRuntimeFactory;
 /**
  * Register the process-wide isolated package runtime factory.

package/dist/package-loader/isolated-table-gateway.d.ts

@@ -1,5 +1,5 @@
 import type { DataContext } from "../context/data-context";
-import type { IIsolatedPackageTableGateway } from "./isolated-runtime";
+import { type IIsolatedPackageTableGateway } from "./isolated-runtime";
 /**
  * In-memory isolated table gateway for tests. Bindings and rows survive
  * `register` of the same owner so unload/reinstall can resume persisted data.

package/dist/package-loader/isolated-table-gateway.js

@@ -6,7 +6,9 @@ const table_container_1 = require("../data/orm/table-container");
 const types_1 = require("../data/orm/types");
 const package_table_identity_1 = require("../data/package-table-identity");
 const table_definitions_table_1 = require("../data/table-definitions-table");
+const events_1 = require("../events");
 const utils_1 = require("../utils");
+const isolated_runtime_1 = require("./isolated-runtime");
 const isolated_value_1 = require("./isolated-value");
 function tableKey(ref) {
     return `${ref.packageId}:${ref.tableName}`;
@@ -159,6 +161,12 @@ function copyTableResult(value) {
 function matchesFilter(row, filter = {}) {
     return Object.entries(filter).every(([name, value]) => row[name] === value);
 }
+function assertTableEvent(eventName) {
+    if (!isolated_runtime_1.ISOLATED_CONTRACT_TABLE_EVENTS.includes(eventName)) {
+        throw new Error(`Unsupported isolated table event '${eventName}'`);
+    }
+    return eventName;
+}
 /**
  * In-memory isolated table gateway for tests. Bindings and rows survive
  * `register` of the same owner so unload/reinstall can resume persisted data.
@@ -169,6 +177,19 @@ function createMemoryIsolatedPackageTableGateway() {
     const declarations = new Map();
     const byTableId = new Map();
     const rows = new Map();
+    const emitters = new Map();
+    const emitterFor = (key) => {
+        let emitter = emitters.get(key);
+        if (!emitter) {
+            // Unique per gateway instance so parallel tests never share a global event name.
+            emitter = new events_1.Emitter(`isolated-memory-table:${(0, utils_1.newid)()}:${key}`);
+            emitters.set(key, emitter);
+        }
+        return emitter;
+    };
+    const emitChange = (key, op, dataObject) => {
+        void emitterFor(key).emit({ dataObject, op, source: "local" });
+    };
     const registerBatch = async (batch) => {
         const candidateDeclarations = new Map(declarations);
         const candidateByTableId = new Map(byTableId);
@@ -213,6 +234,7 @@ function createMemoryIsolatedPackageTableGateway() {
             const tableRows = rows.get(key) ?? new Map();
             tableRows.set(recordId, stored);
             rows.set(key, tableRows);
+            emitChange(key, "save", stored);
             return (0, isolated_value_1.copyIsolatedValue)(stored);
         },
         async call(ref, operation, args) {
@@ -259,6 +281,7 @@ function createMemoryIsolatedPackageTableGateway() {
                         throw new Error(`Record ${id} does not exist`);
                     }
                     tableRows.set(id, stored);
+                    emitChange(key, operation, stored);
                     return (0, isolated_value_1.copyIsolatedValue)(stored);
                 }
                 case "delete": {
@@ -268,11 +291,28 @@ function createMemoryIsolatedPackageTableGateway() {
                     if (typeof id !== "string") {
                         throw new Error(`Isolated table delete requires "${declaration.primaryKeyName}"`);
                     }
+                    const existing = tableRows.get(id);
                     tableRows.delete(id);
+                    if (existing) {
+                        emitChange(key, "delete", existing);
+                    }
                     return undefined;
                 }
             }
         },
+        async subscribe(ref, eventName, handler) {
+            assertTableEvent(eventName);
+            const key = tableKey(ref);
+            if (!declarations.has(key)) {
+                throw new Error(`Undeclared isolated table ${ref.tableName}`);
+            }
+            const subscription = emitterFor(key).event.subscribe((event) => {
+                handler((0, isolated_value_1.copyIsolatedValue)(event));
+            });
+            return () => {
+                subscription.unsubscribe();
+            };
+        },
     };
 }
 /**
@@ -371,5 +411,19 @@ function createIsolatedPackageTableGateway(dataContext) {
             const result = await method.apply(table, (0, isolated_value_1.copyIsolatedValue)(args));
             return copyTableResult(result);
         },
+        async subscribe(ref, eventName, handler) {
+            assertTableEvent(eventName);
+            await registrationQueue;
+            const table = await ensureTable(resolve(ref));
+            const subscription = table.dataChanged.subscribe((event) => {
+                handler({
+                    ...event,
+                    dataObject: copyTableResult(event.dataObject),
+                });
+            });
+            return () => {
+                subscription.unsubscribe();
+            };
+        },
     };
 }

package/dist/package-loader/isolated-table-gateway.test.js

@@ -203,4 +203,65 @@ describe("isolated package table gateway", () => {
             count: 4,
         });
     });
+    test("memory gateway delivers copied dataChanged events for save/call and detaches", async () => {
+        const gateway = (0, isolated_table_gateway_1.createMemoryIsolatedPackageTableGateway)();
+        const declaration = makeDeclaration();
+        const other = makeDeclaration();
+        const recordId = (0, utils_1.newid)();
+        await gateway.registerBatch([declaration, other]);
+        const received = [];
+        const unsubscribe = await gateway.subscribe(declaration, "dataChanged", (event) => {
+            received.push(event);
+        });
+        await gateway.save(declaration, { stateId: recordId, count: 1 });
+        await gateway.call(declaration, "update", [{ stateId: recordId, count: 2 }]);
+        await gateway.save(other, { stateId: (0, utils_1.newid)(), count: 9 });
+        await gateway.call(declaration, "delete", [recordId]);
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(received).toEqual([
+            { dataObject: { stateId: recordId, count: 1 }, op: "save", source: "local" },
+            { dataObject: { stateId: recordId, count: 2 }, op: "update", source: "local" },
+            { dataObject: { stateId: recordId, count: 2 }, op: "delete", source: "local" },
+        ]);
+        const first = received[0];
+        first.dataObject.count = 99;
+        await expect(gateway.get(declaration, recordId)).resolves.toBeUndefined();
+        unsubscribe();
+        await gateway.save(declaration, { stateId: recordId, count: 3 });
+        await new Promise((resolve) => setImmediate(resolve));
+        expect(received).toHaveLength(3);
+        await expect(gateway.subscribe(declaration, "somethingElse", () => undefined)).rejects.toThrow(/Unsupported isolated table event/);
+        await expect(gateway.subscribe(makeDeclaration(), "dataChanged", () => undefined)).rejects.toThrow(/Undeclared isolated table/);
+    });
+    test("data-context gateway subscribes to the host table dataChanged event", async () => {
+        const declaration = makeDeclaration();
+        const handlers = new Set();
+        const table = {
+            get: jest.fn(),
+            save: jest.fn(),
+            dataChanged: {
+                subscribe: jest.fn((handler) => {
+                    handlers.add(handler);
+                    return { unsubscribe: () => handlers.delete(handler) };
+                }),
+            },
+        };
+        const gateway = (0, isolated_table_gateway_1.createIsolatedPackageTableGateway)({
+            tableContainer: { registerTableDefinition: jest.fn(), getTable: jest.fn(() => table) },
+        });
+        await gateway.register(declaration);
+        const received = [];
+        const unsubscribe = await gateway.subscribe(declaration, "dataChanged", (event) => {
+            received.push(event);
+        });
+        expect(table.dataChanged.subscribe).toHaveBeenCalledTimes(1);
+        const row = { stateId: (0, utils_1.newid)(), count: 1 };
+        for (const handler of handlers) {
+            handler({ dataObject: row, op: "save", source: "local" });
+        }
+        expect(received).toEqual([{ dataObject: row, op: "save", source: "local" }]);
+        expect(received[0].dataObject).not.toBe(row);
+        unsubscribe();
+        expect(handlers.size).toBe(0);
+    });
 });

package/dist/package-loader/package-loader.d.ts

@@ -2,7 +2,7 @@ import type { DataContext } from "../context/data-context";
 import { type IContractProviderEndpointRequest } from "../contracts/contract-provider-router";
 import { type IContractConsumer, type IContractProviderEndpoint } from "../contracts/contract-proxy";
 import { ContractRegistry } from "../contracts/registry";
-import type { IConsumedContract } from "../contracts/types";
+import type { IConsumedContract, IRemoteContract, IRemoteContractConsumer } from "../contracts/types";
 import { type IPackage } from "../data/packages";
 import type { IPeersPackage } from "../types/peers-package";
 import { type IIsolatedPackageRuntime } from "./isolated-runtime";
@@ -96,6 +96,20 @@ export declare class PackageLoader {
      * @returns A live consumer proxy, or `undefined` when no provider matches.
      */
     resolveConsumedContract(dependency: IConsumedContract): Promise<IContractConsumer | undefined>;
+    /**
+     * Bind a legacy package's `remote()` declaration to a per-device consumer factory.
+     *
+     * No local provider is selected: every device consumer stamps `targetDeviceId` and
+     * this loader's own router forwards the call through
+     * {@link resolveContractEndpoint}, which hands remote targets to the mesh transport
+     * and resolves this device's id locally. The contract definition must already be
+     * registered in this context (from the package's own `provides` or another
+     * installed package) so the proxy knows the tool names.
+     *
+     * @param declaration - Validated package remote declaration.
+     * @returns A per-device consumer factory, or `undefined` when the contract is unknown.
+     */
+    resolveRemoteContract(declaration: IRemoteContract): Promise<IRemoteContractConsumer<IContractConsumer> | undefined>;
     /**
      * Resolve a sandbox-backed provider endpoint when this context owns an
      * isolated provider for the requested contract.

package/dist/package-loader/package-loader.js

@@ -7,6 +7,7 @@ const contract_proxy_1 = require("../contracts/contract-proxy");
 const contract_resolvers_1 = require("../contracts/contract-resolvers");
 const contract_transport_1 = require("../contracts/contract-transport");
 const registry_1 = require("../contracts/registry");
+const remote_contract_transport_1 = require("../contracts/remote-contract-transport");
 const system_contracts_1 = require("../contracts/system-contracts");
 const files_1 = require("../data/files");
 const package_version_resolver_1 = require("../data/package-version-resolver");
@@ -132,6 +133,16 @@ class PackageLoader {
      * @throws If no provider or matching endpoint implementation is available.
      */
     async resolveContractEndpoint(request, opts = {}) {
+        // A route that names another device is forwarded over the mesh instead of being
+        // resolved against a local provider. Only routers serving local principals set
+        // targetDeviceId; remote-caller routers reject it before reaching this point.
+        const remoteEndpoint = (0, remote_contract_transport_1.resolveRemoteTargetEndpoint)(request, {
+            localDeviceId: this.dataContext.userContext?.deviceId(),
+            userContext: this.dataContext.userContext,
+        });
+        if (remoteEndpoint) {
+            return remoteEndpoint;
+        }
         const providerPackageId = opts.providerPackageId ??
             request.providerPackageId ??
             this.contractRegistry.getProviderPackageId(request.contractId, request.version);
@@ -244,6 +255,43 @@ class PackageLoader {
         };
         return consumer;
     }
+    /**
+     * Bind a legacy package's `remote()` declaration to a per-device consumer factory.
+     *
+     * No local provider is selected: every device consumer stamps `targetDeviceId` and
+     * this loader's own router forwards the call through
+     * {@link resolveContractEndpoint}, which hands remote targets to the mesh transport
+     * and resolves this device's id locally. The contract definition must already be
+     * registered in this context (from the package's own `provides` or another
+     * installed package) so the proxy knows the tool names.
+     *
+     * @param declaration - Validated package remote declaration.
+     * @returns A per-device consumer factory, or `undefined` when the contract is unknown.
+     */
+    async resolveRemoteContract(declaration) {
+        const definition = this.contractRegistry.getDefinition(declaration.contractId, declaration.version);
+        if (!definition) {
+            return undefined;
+        }
+        const [consumerTransport, hostTransport] = (0, contract_transport_1.inProcessTransportPair)();
+        const router = (0, contract_provider_router_1.createContractProviderRouter)(hostTransport, {
+            authorizeCall: () => ({
+                dataContextId: this.dataContext.dataContextId,
+                context: { dataContext: this.dataContext },
+            }),
+            resolveProviderPackageId: (request) => this.contractRegistry.getProviderPackageId(request.contractId, request.version),
+            resolveEndpoint: (request) => this.resolveContractEndpoint(request),
+        });
+        const remote = (0, contract_proxy_1.createRemoteContractConsumer)(definition, consumerTransport, {
+            dataContextId: this.dataContext.dataContextId,
+        });
+        const dispose = remote.dispose.bind(remote);
+        remote.dispose = () => {
+            dispose();
+            router.dispose();
+        };
+        return remote;
+    }
     /**
      * Resolve a sandbox-backed provider endpoint when this context owns an
      * isolated provider for the requested contract.

package/dist/package-loader/resolve-consumed-contracts.d.ts

@@ -2,12 +2,16 @@ import type { DataContext } from "../context/data-context";
 import type { ContractRegistry } from "../contracts/registry";
 import type { IPackageDefinitionResult } from "../contracts/types";
 /**
- * Settle each deferred `consumes` handle on a package definition after its
- * providers have been registered.
+ * Settle each deferred `consumes` and `remote` handle on a package definition
+ * after its providers have been registered.
  *
  * A consume succeeds only when {@link ContractRegistry.selectProvider} finds a
  * matching provider and the owning PackageLoader can bind an endpoint. The
  * endpoint may be resolver-backed or isolated. Missing optional deps settle to
  * `undefined`; missing required deps reject the handle.
+ *
+ * A remote declaration needs no local provider: it settles to a per-device
+ * consumer factory as long as the contract definition is registered locally and
+ * a PackageLoader owns the context; otherwise the handle rejects.
  */
 export declare function resolveConsumedContracts(dataContext: DataContext, registry: ContractRegistry, packageDefinition: IPackageDefinitionResult): Promise<void>;

package/dist/package-loader/resolve-consumed-contracts.js

@@ -5,15 +5,20 @@ const builder_1 = require("../contracts/builder");
 const contract_resolvers_1 = require("../contracts/contract-resolvers");
 const create_local_consumer_1 = require("../contracts/create-local-consumer");
 /**
- * Settle each deferred `consumes` handle on a package definition after its
- * providers have been registered.
+ * Settle each deferred `consumes` and `remote` handle on a package definition
+ * after its providers have been registered.
  *
  * A consume succeeds only when {@link ContractRegistry.selectProvider} finds a
  * matching provider and the owning PackageLoader can bind an endpoint. The
  * endpoint may be resolver-backed or isolated. Missing optional deps settle to
  * `undefined`; missing required deps reject the handle.
+ *
+ * A remote declaration needs no local provider: it settles to a per-device
+ * consumer factory as long as the contract definition is registered locally and
+ * a PackageLoader owns the context; otherwise the handle rejects.
  */
 async function resolveConsumedContracts(dataContext, registry, packageDefinition) {
+    await resolveRemoteContracts(dataContext, packageDefinition);
     for (const dep of packageDefinition.consumes) {
         const handle = dep.handle;
         if (!handle) {
@@ -44,6 +49,29 @@ async function resolveConsumedContracts(dataContext, registry, packageDefinition
         }
     }
 }
+async function resolveRemoteContracts(dataContext, packageDefinition) {
+    for (const declaration of packageDefinition.remotes ?? []) {
+        const handle = declaration.handle;
+        if (!handle) {
+            continue;
+        }
+        const key = `${declaration.contractId}@${declaration.version}`;
+        try {
+            const loader = dataContext.packageLoader;
+            if (!loader?.resolveRemoteContract) {
+                throw new Error(`Remote contract ${key} requires a package loader on the data context`);
+            }
+            const remote = await loader.resolveRemoteContract(declaration);
+            if (!remote) {
+                throw new Error(`Remote contract ${key} could not be resolved: its definition is not registered on this device`);
+            }
+            (0, builder_1.settleContractHandle)(handle, remote);
+        }
+        catch (err) {
+            (0, builder_1.rejectContractHandle)(handle, err);
+        }
+    }
+}
 async function resolveLegacyLocalConsumer(dataContext, selected, contractId, version) {
     const resolver = (0, contract_resolvers_1.getContractResolver)(contractId, version, selected.providerPackageId);
     if (!resolver) {

package/dist/package-loader/resolve-consumed-contracts.test.js

@@ -120,4 +120,47 @@ describe("resolveConsumedContracts", () => {
         }
         await expect(consumeHandle.consumer).resolves.toBeUndefined();
     });
+    describe("remote declarations", () => {
+        it("settles a remote handle through the package loader without a local provider", async () => {
+            const remote = { contractId, version: 1, device: jest.fn(), dispose: jest.fn() };
+            const resolveRemoteContract = jest.fn().mockResolvedValue(remote);
+            const dataContext = {
+                dataContextId: "test-ctx",
+                packageLoader: { resolveRemoteContract },
+            };
+            let remoteHandle;
+            const packageDefinition = (0, builder_1.definePackage)((pkg) => {
+                pkg.packageId = (0, utils_1.newid)();
+                pkg.version = "1.0.0";
+                remoteHandle = pkg.remote(contractId, 1);
+            });
+            await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(dataContext, new registry_1.ContractRegistry(), packageDefinition);
+            expect(resolveRemoteContract).toHaveBeenCalledWith(expect.objectContaining({ contractId, version: 1 }));
+            await expect(remoteHandle?.consumer).resolves.toBe(remote);
+        });
+        it("rejects a remote handle when the contract definition is unknown locally", async () => {
+            const dataContext = {
+                dataContextId: "test-ctx",
+                packageLoader: { resolveRemoteContract: jest.fn().mockResolvedValue(undefined) },
+            };
+            let remoteHandle;
+            const packageDefinition = (0, builder_1.definePackage)((pkg) => {
+                pkg.packageId = (0, utils_1.newid)();
+                pkg.version = "1.0.0";
+                remoteHandle = pkg.remote(contractId, 1);
+            });
+            await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(dataContext, new registry_1.ContractRegistry(), packageDefinition);
+            await expect(remoteHandle?.consumer).rejects.toThrow(/not registered on this device/);
+        });
+        it("rejects a remote handle when no package loader owns the context", async () => {
+            let remoteHandle;
+            const packageDefinition = (0, builder_1.definePackage)((pkg) => {
+                pkg.packageId = (0, utils_1.newid)();
+                pkg.version = "1.0.0";
+                remoteHandle = pkg.remote(contractId, 1);
+            });
+            await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(mockDataContext(), new registry_1.ContractRegistry(), packageDefinition);
+            await expect(remoteHandle?.consumer).rejects.toThrow(/requires a package loader/);
+        });
+    });
 });

package/package.json

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