@peers-app/peers-sdk 0.27.2 → 0.27.4

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

@@ -1,238 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../../utils");
-const registry_1 = require("../registry");
-function makeDefinition(contractId, version, name = "Test Contract") {
-    return {
-        contractId,
-        version,
-        devTag: "dev",
-        name,
-        description: "test",
-        tables: [],
-        tools: [],
-        observables: [],
-        events: [],
-    };
-}
-describe("ContractRegistry.selectProvider", () => {
-    const contractId = (0, utils_1.newid)();
-    const packageA = (0, utils_1.newid)();
-    const packageB = (0, utils_1.newid)();
-    const packageC = (0, utils_1.newid)();
-    let registry;
-    beforeEach(() => {
-        registry = new registry_1.ContractRegistry();
-        registry.register(packageA, makeDefinition(contractId, 1, "A"));
-        registry.register(packageB, makeDefinition(contractId, 1, "B"));
-    });
-    it("returns registered provider ids in registration order", () => {
-        expect(registry.getRegisteredProviderIds(contractId, 1)).toEqual([packageA, packageB]);
-    });
-    it("selects the active provider when no preference is given", () => {
-        const selected = registry.selectProvider({ contractId, version: 1 });
-        expect(selected?.providerPackageId).toBe(packageA);
-    });
-    it("selects the first preferred provider that is registered", () => {
-        const dep = {
-            contractId,
-            version: 1,
-            providerPackageIds: [packageC, packageB, packageA],
-        };
-        expect(registry.selectProvider(dep)?.providerPackageId).toBe(packageB);
-    });
-    it("falls back to the active provider when preferred are missing and fallback is enabled", () => {
-        const dep = {
-            contractId,
-            version: 1,
-            providerPackageIds: [packageC],
-            fallbackToDefaultProvider: true,
-        };
-        expect(registry.selectProvider(dep)?.providerPackageId).toBe(packageA);
-    });
-    it("returns undefined when preferred are missing and fallback is disabled", () => {
-        const dep = {
-            contractId,
-            version: 1,
-            providerPackageIds: [packageC],
-            fallbackToDefaultProvider: false,
-        };
-        expect(registry.selectProvider(dep)).toBeUndefined();
-    });
-    it("returns undefined when no providers are registered", () => {
-        const empty = new registry_1.ContractRegistry();
-        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([]);
-    });
-});
-describe("ContractRegistry exposes", () => {
-    const hubId = (0, utils_1.newid)();
-    const newsId = (0, utils_1.newid)();
-    const provider = (0, utils_1.newid)();
-    const other = (0, utils_1.newid)();
-    it("keeps each provider's exposures, outside the contract's definition", () => {
-        const registry = new registry_1.ContractRegistry();
-        const result = registry.registerBatch(provider, [
-            { definition: makeDefinition(newsId, 1, "News") },
-            {
-                definition: makeDefinition(hubId, 2, "Hub"),
-                exposes: [{ contractId: newsId, version: 1 }],
-            },
-        ]);
-        expect(result.valid).toBe(true);
-        registry.registerBatch(other, [{ definition: makeDefinition(hubId, 2, "Hub") }]);
-        expect(registry.getExposedContracts(hubId, 2, provider)).toEqual([
-            { contractId: newsId, version: 1 },
-        ]);
-        expect(registry.getExposedContracts(hubId, 2, other)).toEqual([]);
-        expect(registry.getExposedContracts(newsId, 1, provider)).toEqual([]);
-        expect(registry.getExposedContracts(hubId, 2, (0, utils_1.newid)())).toEqual([]);
-        expect(registry.getDefinition(hubId, 2)).not.toHaveProperty("exposes");
-        expect(registry.getProviderDefinition(newsId, 1, provider)?.name).toBe("News");
-        expect(registry.getProviderDefinition(newsId, 1, other)).toBeUndefined();
-        // A caller can't change what the registry holds through the returned list.
-        registry.getExposedContracts(hubId, 2, provider).pop();
-        expect(registry.getExposedContracts(hubId, 2, provider)).toHaveLength(1);
-    });
-    it("carries exposures to an alsoImplements alias, and drops them on replacement", () => {
-        const registry = new registry_1.ContractRegistry();
-        registry.register(other, makeDefinition(hubId, 1, "Hub v1"));
-        registry.registerBatch(provider, [
-            { definition: makeDefinition(newsId, 1, "News") },
-            {
-                definition: makeDefinition(hubId, 2, "Hub"),
-                alsoImplements: [{ contractId: hubId, version: 1 }],
-                exposes: [{ contractId: newsId, version: 1 }],
-            },
-        ]);
-        expect(registry.getExposedContracts(hubId, 1, provider)).toEqual([
-            { contractId: newsId, version: 1 },
-        ]);
-        registry.replaceBatch(provider, [
-            { definition: makeDefinition(newsId, 1, "News") },
-            { definition: makeDefinition(hubId, 2, "Hub") },
-        ]);
-        expect(registry.getExposedContracts(hubId, 2, provider)).toEqual([]);
-    });
-    it("refuses an exposure the batch doesn't provide, of itself, or twice", () => {
-        const registry = new registry_1.ContractRegistry();
-        const hub = (exposes) => [
-            { definition: makeDefinition(newsId, 1, "News") },
-            { definition: makeDefinition(hubId, 2, "Hub"), exposes },
-        ];
-        expect(registry.validateBatch(provider, hub([{ contractId: (0, utils_1.newid)(), version: 1 }]))).toEqual(expect.objectContaining({
-            valid: false,
-            errors: [expect.objectContaining({ message: expect.stringMatching(/doesn't provide/) })],
-        }));
-        expect(registry.validateBatch(provider, hub([{ contractId: hubId, version: 2 }])).errors[0].message).toMatch(/can't expose itself/);
-        expect(registry.validateBatch(provider, hub([
-            { contractId: newsId, version: 1 },
-            { contractId: newsId, version: 1 },
-        ])).errors[0].message).toMatch(/twice/);
-        expect(registry.registerBatch(provider, hub([{ contractId: newsId, version: 2 }])).valid).toBe(false);
-        expect(registry.getRegisteredProviderIds(newsId, 1)).toEqual([]);
-    });
-});

package/dist/contracts/__tests__/remote-contract-transport.test.d.ts

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

package/dist/contracts/__tests__/remote-contract-transport.test.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const system_ids_1 = require("../../system-ids");
-const index_1 = require("../index");
-const makeRequest = (overrides = {}) => ({
-    contractId: "contract-a",
-    version: 1,
-    dataContextId: "group-1",
-    targetDeviceId: "device-b",
-    context: {},
-    notify: async () => undefined,
-    ...overrides,
-});
-const toolCall = {
-    contractId: "contract-a",
-    version: 1,
-    member: "tool",
-    name: "ping",
-    operation: "run",
-    args: [{ n: 1 }],
-    dataContextId: "group-1",
-    targetDeviceId: "device-b",
-};
-function makeTransport() {
-    const emit = jest.fn(async (_channel, ..._args) => "pong");
-    const transport = { emit, on: () => () => undefined };
-    return { transport, emit };
-}
-afterEach(() => {
-    (0, index_1.setRemoteContractTransportFactory)(undefined);
-});
-describe("remote contract endpoint", () => {
-    it("selects the current transport for every call on a cached endpoint", async () => {
-        const first = makeTransport();
-        const second = makeTransport();
-        let current = first.transport;
-        const endpoint = (0, index_1.createRemoteContractEndpoint)(makeRequest(), () => current);
-        await endpoint.handleCall(toolCall, {});
-        current = second.transport;
-        await endpoint.handleCall(toolCall, {});
-        expect(first.emit).toHaveBeenCalledTimes(1);
-        expect(second.emit).toHaveBeenCalledTimes(1);
-    });
-    it("strips targetDeviceId and pins the authorized data context before emitting", async () => {
-        const { transport, emit } = makeTransport();
-        const factory = jest.fn(() => transport);
-        const endpoint = (0, index_1.createRemoteContractEndpoint)(makeRequest(), factory);
-        await expect(endpoint.handleCall(toolCall, {})).resolves.toBe("pong");
-        expect(factory).toHaveBeenCalledWith({ deviceId: "device-b", dataContextId: "group-1" });
-        expect(emit).toHaveBeenCalledTimes(1);
-        const [channel, sent] = emit.mock.calls[0];
-        expect(channel).toBe(index_1.CONTRACT_REQUEST_CHANNEL);
-        expect(sent).not.toHaveProperty("targetDeviceId");
-        expect(sent).toMatchObject({ name: "ping", dataContextId: "group-1", args: [{ n: 1 }] });
-    });
-    it("refuses to forward anything but tool runs and rejects after dispose", async () => {
-        const { transport, emit } = makeTransport();
-        const endpoint = (0, index_1.createRemoteContractEndpoint)(makeRequest(), () => transport);
-        await expect(endpoint.handleCall({ ...toolCall, member: "table", name: "Items", operation: "list" }, {})).rejects.toThrow("cannot be forwarded");
-        endpoint.dispose();
-        await expect(endpoint.handleCall(toolCall, {})).rejects.toThrow("disposed");
-        expect(emit).not.toHaveBeenCalled();
-    });
-    it.each([
-        ["System App Updates", system_ids_1.appUpdatesContractId],
-        ["System Packages", system_ids_1.packagesContractId],
-        ["Device Operations", system_ids_1.deviceOperationsContractId],
-    ])("refuses to forward a package's call to %s", async (_name, contractId) => {
-        const { transport, emit } = makeTransport();
-        const packageContext = { callerPackageId: "package-a" };
-        expect(() => (0, index_1.createRemoteContractEndpoint)(makeRequest({ contractId, context: packageContext }), () => transport)).toThrow("packages cannot call system contract");
-        // A package endpoint for its own contract cannot be steered at a system contract.
-        const packageTool = (0, index_1.createRemoteContractEndpoint)(makeRequest({ context: packageContext }), () => transport);
-        await expect(packageTool.handleCall({ ...toolCall, contractId }, packageContext)).rejects.toThrow("packages cannot call system contract");
-        expect(emit).not.toHaveBeenCalled();
-        // The user (no package) still reaches it, and the package still reaches its own contract.
-        const operator = (0, index_1.createRemoteContractEndpoint)(makeRequest({ contractId }), () => transport);
-        await expect(operator.handleCall({ ...toolCall, contractId }, {})).resolves.toBe("pong");
-        await expect(packageTool.handleCall(toolCall, packageContext)).resolves.toBe("pong");
-        expect(emit).toHaveBeenCalledTimes(2);
-    });
-    it("fails clearly when no transport factory is registered or the route is incomplete", () => {
-        expect(() => (0, index_1.createRemoteContractEndpoint)(makeRequest())).toThrow("no remote contract transport is registered");
-        expect(() => (0, index_1.createRemoteContractEndpoint)(makeRequest({ dataContextId: undefined }), () => makeTransport().transport)).toThrow("data context");
-        expect(() => (0, index_1.createRemoteContractEndpoint)(makeRequest({ targetDeviceId: undefined }), () => makeTransport().transport)).toThrow("target device");
-    });
-});
-describe("resolveRemoteTargetEndpoint", () => {
-    it("returns undefined for local routes and for the local device itself", () => {
-        (0, index_1.setRemoteContractTransportFactory)(() => makeTransport().transport);
-        expect((0, index_1.resolveRemoteTargetEndpoint)(makeRequest({ targetDeviceId: undefined }), {
-            localDeviceId: "device-a",
-        })).toBeUndefined();
-        expect((0, index_1.resolveRemoteTargetEndpoint)(makeRequest({ targetDeviceId: "device-a" }), {
-            localDeviceId: "device-a",
-        })).toBeUndefined();
-    });
-    it("prefers a factory scoped to the owning user context over the process default", async () => {
-        const scoped = makeTransport();
-        const fallback = makeTransport();
-        const userContext = {};
-        (0, index_1.setRemoteContractTransportFactory)(() => fallback.transport);
-        (0, index_1.setRemoteContractTransportFactory)(() => scoped.transport, { userContext });
-        const scopedEndpoint = (0, index_1.resolveRemoteTargetEndpoint)(makeRequest(), {
-            localDeviceId: "device-a",
-            userContext,
-        });
-        const fallbackEndpoint = (0, index_1.resolveRemoteTargetEndpoint)(makeRequest(), {
-            localDeviceId: "device-a",
-        });
-        await scopedEndpoint?.handleCall(toolCall, {});
-        await fallbackEndpoint?.handleCall(toolCall, {});
-        expect(scoped.emit).toHaveBeenCalledTimes(1);
-        expect(fallback.emit).toHaveBeenCalledTimes(1);
-        (0, index_1.setRemoteContractTransportFactory)(undefined, { userContext });
-        (0, index_1.setRemoteContractTransportFactory)(undefined);
-        expect(() => (0, index_1.resolveRemoteTargetEndpoint)(makeRequest(), { userContext })).toThrow("no remote contract transport is registered");
-    });
-});

package/dist/contracts/__tests__/system-contracts.test.d.ts

@@ -1 +0,0 @@
-import "../system";

package/dist/contracts/__tests__/system-contracts.test.js

@@ -1,247 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const system_ids_1 = require("../../system-ids");
-const utils_1 = require("../../utils");
-const contract_resolvers_1 = require("../contract-resolvers");
-const registry_1 = require("../registry");
-const host_shell_contract_1 = require("../system/host-shell-contract");
-const identity_contract_1 = require("../system/identity-contract");
-const packages_contract_1 = require("../system/packages-contract");
-const system_contracts_1 = require("../system-contracts");
-const tool_catalog_1 = require("../tool-catalog");
-const tool_catalog_service_1 = require("../tool-catalog-service");
-// Populate the catalog with built-in system contracts.
-require("../system");
-describe("system contract catalog", () => {
-    it("self-registers the built-in system contracts", () => {
-        const ids = (0, system_contracts_1.listSystemContracts)()
-            .map((entry) => entry.contractId)
-            .filter(Boolean);
-        expect(ids).toEqual(expect.arrayContaining([
-            system_ids_1.appUpdatesContractId,
-            system_ids_1.logsContractId,
-            system_ids_1.deviceOperationsContractId,
-            system_ids_1.identityContractId,
-            system_ids_1.hostToolsContractId,
-            system_ids_1.desktopToolsContractId,
-            system_ids_1.networkDiagnosticsContractId,
-            system_ids_1.networkControlContractId,
-            system_ids_1.toolAccessControlContractId,
-            system_ids_1.toolCatalogContractId,
-            system_ids_1.packagesContractId,
-        ]));
-    });
-    it("registers the Logs live resolver", async () => {
-        await new Promise((resolve) => queueMicrotask(resolve));
-        expect((0, contract_resolvers_1.getContractResolver)(system_ids_1.logsContractId, 1)).toEqual(expect.any(Function));
-    });
-    it("installSystemContracts seeds a registry with system providers", () => {
-        const registry = new registry_1.ContractRegistry();
-        (0, system_contracts_1.installSystemContracts)(registry);
-        expect(registry.resolve(system_ids_1.logsContractId, 1)?.name).toBe("System Logs");
-        expect(registry.getProviderPackageId(system_ids_1.logsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-        expect(registry.resolve(system_ids_1.deviceOperationsContractId, 1)?.name).toBe("System Device Operations");
-        expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-        expect(registry.resolve(system_ids_1.identityContractId, 1)?.name).toBe("System Identity");
-        expect(registry.getProviderPackageId(system_ids_1.identityContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-        expect(registry.resolve(system_ids_1.networkDiagnosticsContractId, 1)?.name).toBe("System Network Diagnostics");
-        expect(registry.getProviderPackageId(system_ids_1.networkDiagnosticsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-        expect(registry.resolve(system_ids_1.networkControlContractId, 1)?.name).toBe("System Network Control");
-        expect(registry.getProviderPackageId(system_ids_1.networkControlContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-        expect(registry.resolve(system_ids_1.toolAccessControlContractId, 1)?.name).toBe("System Tool Access Control");
-        expect(registry.getProviderPackageId(system_ids_1.toolAccessControlContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-    });
-    it("declares DevicePairingState as the identity ceremony result", async () => {
-        // Loaded lazily. A top-level import cycles through device tables before they finish initializing.
-        const { devicePairingStateSchema } = await Promise.resolve().then(() => require("../../device-pairing/types"));
-        const stateFields = Object.keys(devicePairingStateSchema.shape).sort();
-        const definition = (0, identity_contract_1.getIdentityContractDefinition)();
-        for (const name of ["startSource", "startDestination", "approve", "reject", "cancel"]) {
-            const tool = definition.tools.find((entry) => entry.name === name);
-            expect(tool?.outputFields.map((entry) => entry.name).sort()).toEqual(stateFields);
-        }
-    });
-    it("registerSystemContract makes new contracts installable without loader changes", () => {
-        const fakeContractId = (0, utils_1.newid)();
-        const providerPackageId = (0, utils_1.newid)();
-        (0, system_contracts_1.registerSystemContract)({
-            providerPackageId,
-            contractId: fakeContractId,
-            version: 1,
-            getDefinition: () => ({
-                contractId: fakeContractId,
-                version: 1,
-                devTag: "dev",
-                name: "Fake System Contract",
-                description: "test",
-                tables: [],
-                tools: [],
-                observables: [],
-                events: [],
-            }),
-        });
-        const registry = new registry_1.ContractRegistry();
-        (0, system_contracts_1.installSystemContracts)(registry);
-        expect(registry.getProviderPackageId(fakeContractId, 1)).toBe(providerPackageId);
-    });
-});
-test("system catalog initialization retries without publishing on failed persistence", async () => {
-    const rows = new Map();
-    let fail = true;
-    const context = {
-        tableContainer: {
-            getTable: () => ({
-                list: async () => [...rows.values()],
-                get: async (toolId) => rows.get(toolId),
-                save: async (row) => {
-                    if (fail)
-                        throw new Error("storage unavailable");
-                    rows.set(row.toolId, row);
-                    return row;
-                },
-                dataChanged: { subscribe: () => ({ unsubscribe: () => true }) },
-            }),
-        },
-    };
-    const registry = new registry_1.ContractRegistry();
-    const catalog = new tool_catalog_1.ToolCatalog(context, registry);
-    await expect((0, system_contracts_1.installSystemContracts)(registry)).rejects.toThrow("storage unavailable");
-    expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBeUndefined();
-    fail = false;
-    await (0, system_contracts_1.installSystemContracts)(registry);
-    expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-    expect(registry.getProviderPackageId(system_ids_1.identityContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-    expect([...rows.values()].some((row) => row.contractId === system_ids_1.toolAccessControlContractId)).toBe(true);
-    await catalog.dispose();
-});
-test("a later system provider's persistence failure does not publish an earlier provider", async () => {
-    const contractId = (0, utils_1.newid)();
-    const providerPackageId = (0, utils_1.newid)();
-    (0, system_contracts_1.registerSystemContract)({
-        contractId,
-        version: 1,
-        providerPackageId,
-        getDefinition: () => ({
-            contractId,
-            version: 1,
-            name: "Later system provider",
-            description: "",
-            tables: [],
-            observables: [],
-            tools: [{ name: "read", usageDescription: "", inputFields: [], outputFields: [] }],
-        }),
-    });
-    const rows = new Map();
-    const registry = new registry_1.ContractRegistry();
-    const context = {
-        tableContainer: {
-            getTable: () => ({
-                list: async () => [...rows.values()],
-                save: async (row) => {
-                    if (row.contractId === contractId)
-                        throw new Error("late persistence failure");
-                    rows.set(row.toolId, row);
-                    return row;
-                },
-            }),
-        },
-    };
-    const catalog = new tool_catalog_1.ToolCatalog(context, registry);
-    try {
-        await expect(catalog.ready()).rejects.toThrow(/late persistence failure/);
-        expect(rows.size).toBeGreaterThan(0);
-        expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBeUndefined();
-        expect(registry.getProviderPackageId(contractId, 1)).toBeUndefined();
-    }
-    finally {
-        await catalog.dispose();
-    }
-});
-test("host and desktop workflow members are present with workflow-only policy", () => {
-    const registry = new registry_1.ContractRegistry();
-    (0, system_contracts_1.installSystemContracts)(registry);
-    for (const [id, names] of [
-        [system_ids_1.hostToolsContractId, ["default_assistant_runner", "tool-search"]],
-        [system_ids_1.desktopToolsContractId, ["cd", "send-notification"]],
-    ]) {
-        const definition = registry.resolve(id, 1);
-        for (const name of names)
-            expect(definition?.tools.find((tool) => tool.name === name)?.requiresWorkflowRun).toBe(true);
-    }
-});
-test("System Packages is remote only for Self and never workflow-invocable", () => {
-    const registry = new registry_1.ContractRegistry();
-    (0, system_contracts_1.installSystemContracts)(registry);
-    const definition = registry.resolve(system_ids_1.packagesContractId, 1);
-    expect(definition?.name).toBe("System Packages");
-    expect(registry.getProviderPackageId(system_ids_1.packagesContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-    expect((0, contract_resolvers_1.isLocalOnlyContractId)(system_ids_1.packagesContractId)).toBe(false);
-    for (const tool of definition?.tools ?? []) {
-        expect(tool.remoteAccessLevel).toBeUndefined();
-        expect((0, tool_catalog_service_1.isWorkflowInvocableTarget)({
-            contractId: system_ids_1.packagesContractId,
-            version: 1,
-            toolName: tool.name,
-        })).toBe(false);
-    }
-});
-test("System Host Shell is remote only for Self and never workflow-invocable", () => {
-    const registry = new registry_1.ContractRegistry();
-    (0, system_contracts_1.installSystemContracts)(registry);
-    const definition = registry.resolve(system_ids_1.hostShellContractId, 1);
-    expect(definition?.name).toBe("System Host Shell");
-    expect(registry.getProviderPackageId(system_ids_1.hostShellContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
-    expect((0, contract_resolvers_1.isLocalOnlyContractId)(system_ids_1.hostShellContractId)).toBe(false);
-    expect(definition?.tools.map((tool) => tool.name)).toContain("screenshot");
-    for (const tool of definition?.tools ?? []) {
-        expect(tool.remoteAccessLevel).toBeUndefined();
-        expect((0, tool_catalog_service_1.isWorkflowInvocableTarget)({
-            contractId: system_ids_1.hostShellContractId,
-            version: 1,
-            toolName: tool.name,
-        })).toBe(false);
-    }
-});
-it.each([
-    ["https://peers.app/docs", { kind: "browser", url: "https://peers.app/docs" }],
-    [" http://localhost:3000 ", { kind: "browser", url: "http://localhost:3000" }],
-    ["mailto:someone@example.com", { kind: "browser", url: "mailto:someone@example.com" }],
-    ["~/peers/packages", { kind: "path", path: "~/peers/packages" }],
-    ["/tmp/a b", { kind: "path", path: "/tmp/a b" }],
-    ["C:\\Users\\me", { kind: "path", path: "C:\\Users\\me" }],
-    ["relative/dir", { kind: "path", path: "relative/dir" }],
-])("open routes %p", (target, expected) => {
-    expect((0, host_shell_contract_1.classifyHostOpenTarget)(target)).toEqual(expected);
-});
-it.each([
-    "file:///etc/passwd",
-    "javascript:alert(1)",
-    "vscode://file/x",
-    "smb://host/share",
-    "",
-])("open refuses %p", (target) => {
-    expect(() => (0, host_shell_contract_1.classifyHostOpenTarget)(target)).toThrow(/open (refuses|requires)/);
-});
-it.each([
-    [undefined, ["beta", "stable"]],
-    ["", ["beta", "stable"]],
-    ["dev", ["beta", "stable"]],
-    ["beta", ["stable"]],
-    ["stable", []],
-    ["nightly", []],
-])("promotion targets for %p are %p", (tag, targets) => {
-    expect((0, packages_contract_1.packageVersionPromotionTargets)(tag)).toEqual(targets);
-});
-it.each([
-    ["https://github.com/peers-app/x.git", true],
-    ["http://host/x", true],
-    ["git@github.com:peers-app/x", true],
-    ["  git@github.com:peers-app/x.git", true],
-    ["git@notes", false],
-    ["../x.git", false],
-    ["/abs/x.git", false],
-    ["My Package", false],
-    ["00mvdhk66tdqrj3hy0bacmj32", false],
-])("routes %p to clonePackage: %p", (target, expected) => {
-    expect((0, packages_contract_1.isPackageRepositoryUrl)(target)).toBe(expected);
-});

package/dist/contracts/__tests__/target-dispatch.d.ts

@@ -1,11 +0,0 @@
-import type { IToolInstance } from "../../data/tools";
-import { type ContractToolDispatch } from "../contract-proxy";
-/**
- * The host's `dispatchTool`, for tests: runs `tools` as the provider of `contractId` v1 with the
- * frame the calling tool's provider bound, so each target is admitted as the host would admit
- * it. Targets can dispatch further through the same bridge.
- *
- * @param contractId - The contract the targets are provided under.
- * @param tools - The target tools, by name.
- */
-export declare function targetDispatch(contractId: string, tools: Record<string, IToolInstance>): ContractToolDispatch;

package/dist/contracts/__tests__/target-dispatch.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.targetDispatch = targetDispatch;
-const contract_proxy_1 = require("../contract-proxy");
-/**
- * The host's `dispatchTool`, for tests: runs `tools` as the provider of `contractId` v1 with the
- * frame the calling tool's provider bound, so each target is admitted as the host would admit
- * it. Targets can dispatch further through the same bridge.
- *
- * @param contractId - The contract the targets are provided under.
- * @param tools - The target tools, by name.
- */
-function targetDispatch(contractId, tools) {
-    const dispatch = (target, args, context) => provider({
-        contractId: target.contractId,
-        version: target.version,
-        member: "tool",
-        name: target.toolName,
-        operation: "run",
-        args: [args],
-    }, context);
-    const provider = (0, contract_proxy_1.createContractProvider)({ contractId, version: 1, tools, forwardCallContext: true }, { dispatchTool: dispatch });
-    return dispatch;
-}

package/dist/contracts/__tests__/tool-catalog-inventory.test.d.ts

@@ -1 +0,0 @@
-import "../../index";