@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/package-installer/package-tarball.test.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const package_tarball_1 = require("./package-tarball");
-const testPayload = {
-    packageId: "00mh0wlipjixk2gqmurbwee0o",
-    packageVersionId: "00mpdg7xstwt3oe51x9brk15i",
-    version: "1.2.3",
-    versionTag: "stable",
-    packageBundleFileHash: "abc123",
-    routesBundleFileHash: "def456",
-    uiBundleFileHash: "ghi789",
-    publicKey: "testPublicKey123",
-    packageAuthorSignature: "testSignature456",
-};
-describe("package-tarball", () => {
-    describe("packPeersTarball + unpackPeersTarball round-trip", () => {
-        it("round-trips all three bundles", async () => {
-            const opts = {
-                payload: testPayload,
-                packageBundle: "console.log('main bundle');",
-                routesBundle: "console.log('routes');",
-                uiBundle: "console.log('ui');",
-            };
-            const tarball = await (0, package_tarball_1.packPeersTarball)(opts);
-            expect(tarball).toBeInstanceOf(Uint8Array);
-            expect(tarball.length).toBeGreaterThan(0);
-            const result = await (0, package_tarball_1.unpackPeersTarball)(tarball);
-            expect(result.payload).toEqual(testPayload);
-            expect(result.packageBundle).toBe(opts.packageBundle);
-            expect(result.routesBundle).toBe(opts.routesBundle);
-            expect(result.uiBundle).toBe(opts.uiBundle);
-        });
-        it("round-trips with only package bundle (no routes/ui)", async () => {
-            const opts = {
-                payload: { ...testPayload, routesBundleFileHash: undefined, uiBundleFileHash: undefined },
-                packageBundle: "module.exports = {};",
-            };
-            const tarball = await (0, package_tarball_1.packPeersTarball)(opts);
-            const result = await (0, package_tarball_1.unpackPeersTarball)(tarball);
-            expect(result.payload.packageId).toBe(testPayload.packageId);
-            expect(result.packageBundle).toBe(opts.packageBundle);
-            expect(result.routesBundle).toBeUndefined();
-            expect(result.uiBundle).toBeUndefined();
-        });
-        it("handles large bundle content", async () => {
-            const largeBundle = "x".repeat(500_000);
-            const opts = {
-                payload: testPayload,
-                packageBundle: largeBundle,
-            };
-            const tarball = await (0, package_tarball_1.packPeersTarball)(opts);
-            // Gzip should compress the repetitive content significantly
-            expect(tarball.length).toBeLessThan(largeBundle.length);
-            const result = await (0, package_tarball_1.unpackPeersTarball)(tarball);
-            expect(result.packageBundle).toBe(largeBundle);
-        });
-    });
-    describe("unpackPeersTarball validation", () => {
-        it("throws on empty/invalid data", async () => {
-            await expect((0, package_tarball_1.unpackPeersTarball)(new Uint8Array(0))).rejects.toThrow();
-        });
-        it("throws if pv-payload.json is missing", async () => {
-            const { createTarGzip } = await Promise.resolve().then(() => require("nanotar"));
-            const tarball = await createTarGzip([{ name: "package.bundle.js", data: "code" }]);
-            await expect((0, package_tarball_1.unpackPeersTarball)(tarball)).rejects.toThrow("missing pv-payload.json");
-        });
-        it("throws if package.bundle.js is missing", async () => {
-            const { createTarGzip } = await Promise.resolve().then(() => require("nanotar"));
-            const tarball = await createTarGzip([
-                { name: "pv-payload.json", data: JSON.stringify(testPayload) },
-            ]);
-            await expect((0, package_tarball_1.unpackPeersTarball)(tarball)).rejects.toThrow("missing package.bundle.js");
-        });
-    });
-});

package/dist/package-installer/peers-core-installer.test.d.ts

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

package/dist/package-installer/peers-core-installer.test.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const mockPvList = jest.fn();
-jest.mock("../data/package-versions", () => ({
-    PackageVersions: (ctx) => ({
-        list: (...args) => mockPvList(ctx, ...args),
-    }),
-}));
-const mockRepinInstalled = jest.fn();
-jest.mock("./peers-core-trust-anchor", () => ({
-    repinInstalledPeersCoreIfRevoked: (...args) => mockRepinInstalled(...args),
-}));
-jest.mock("../data/packages", () => ({ Packages: () => ({}) }));
-jest.mock("../data/packages.utils", () => ({ copyPackageToAnotherDataContext: jest.fn() }));
-jest.mock("../data/package-version-resolver", () => ({
-    resolveDevicePackageVersion: jest.fn(),
-}));
-jest.mock("./package-remote-checker", () => ({
-    checkAndInstallPackageRemoteVersion: jest.fn(),
-}));
-jest.mock("./package-seed-installer", () => ({
-    ensurePackageRecord: jest.fn(),
-    seedPackageInContext: jest.fn(),
-}));
-const system_ids_1 = require("../system-ids");
-const peers_core_installer_1 = require("./peers-core-installer");
-describe("ensurePeersCore", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockRepinInstalled.mockResolvedValue(null);
-    });
-    it("re-pins a revoked peers-core key before checking for existing versions", async () => {
-        const dataContext = { dataContextId: "user-ctx" };
-        const order = [];
-        mockRepinInstalled.mockImplementation(async () => {
-            order.push("repin");
-            return null;
-        });
-        mockPvList.mockImplementation(async () => {
-            order.push("list");
-            return [{ packageVersionId: "existing" }];
-        });
-        const installed = await (0, peers_core_installer_1.ensurePeersCore)({}, dataContext, {});
-        expect(installed).toBe(false);
-        expect(mockRepinInstalled).toHaveBeenCalledWith(dataContext);
-        expect(mockPvList).toHaveBeenCalledWith(dataContext, { packageId: system_ids_1.peersCorePackageId });
-        expect(order).toEqual(["repin", "list"]);
-    });
-});

package/dist/package-installer/peers-core-trust-anchor.test.d.ts

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

package/dist/package-installer/peers-core-trust-anchor.test.js

@@ -1,155 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../keys");
-const systemIds = require("../system-ids");
-const utils_1 = require("../utils");
-const package_author_signing_1 = require("./package-author-signing");
-const peers_core_trust_anchor_1 = require("./peers-core-trust-anchor");
-// Pin the host to a fresh "current" key and revoke a fresh "old" key so the tests do not
-// depend on the real constants. Keys are created inside the factory because jest hoists
-// `jest.mock` above module-level declarations.
-jest.mock("../system-ids", () => {
-    const actual = jest.requireActual("../system-ids");
-    const { newKeys: makeKeys } = jest.requireActual("../keys");
-    const revoked = makeKeys();
-    const current = makeKeys();
-    return {
-        ...actual,
-        peersCorePublishPublicKey: current.publicKey,
-        peersCoreRevokedPublishPublicKeys: [revoked.publicKey],
-        __testKeys: { revoked, current },
-    };
-});
-const { revoked: revokedKeys, current: currentKeys } = systemIds.__testKeys;
-const mockPackagesGet = jest.fn();
-const mockPackagesSignAndSave = jest.fn();
-jest.mock("../data/packages", () => ({
-    Packages: () => ({
-        get: (...args) => mockPackagesGet(...args),
-        signAndSave: (...args) => mockPackagesSignAndSave(...args),
-    }),
-}));
-function makeCtx(id = "ctx") {
-    return { dataContextId: id };
-}
-function makePkg(overrides) {
-    return {
-        packageId: systemIds.peersCorePackageId,
-        name: "peers-core",
-        publishPublicKey: revokedKeys.publicKey,
-        ...overrides,
-    };
-}
-function makePV() {
-    return {
-        packageId: systemIds.peersCorePackageId,
-        packageVersionId: (0, utils_1.newid)(),
-        version: "1.0.0",
-        versionTag: "stable",
-        packageBundleFileHash: "hash",
-    };
-}
-beforeEach(() => {
-    jest.clearAllMocks();
-    jest.spyOn(console, "warn").mockImplementation(() => { });
-    jest.spyOn(console, "error").mockImplementation(() => { });
-});
-afterEach(() => {
-    jest.restoreAllMocks();
-});
-describe("isRevokedPublisherKey", () => {
-    it("uses the host revocation list by default", () => {
-        expect((0, package_author_signing_1.isRevokedPublisherKey)(revokedKeys.publicKey)).toBe(true);
-        expect((0, package_author_signing_1.isRevokedPublisherKey)(currentKeys.publicKey)).toBe(false);
-    });
-    it("accepts an explicit list", () => {
-        expect((0, package_author_signing_1.isRevokedPublisherKey)("abc", ["abc"])).toBe(true);
-        expect((0, package_author_signing_1.isRevokedPublisherKey)(revokedKeys.publicKey, [])).toBe(false);
-    });
-    it("treats empty or missing keys as not revoked", () => {
-        expect((0, package_author_signing_1.isRevokedPublisherKey)("", ["", "x"])).toBe(false);
-        expect((0, package_author_signing_1.isRevokedPublisherKey)(undefined)).toBe(false);
-    });
-});
-describe("verifyPackageAuthorSignature with a revoked key", () => {
-    it("rejects a mathematically valid signature from a revoked key", () => {
-        const pv = { ...makePV(), packageAuthorSignature: "" };
-        pv.packageAuthorSignature = (0, package_author_signing_1.signPackageAuthor)(pv, revokedKeys.secretKey);
-        const result = (0, package_author_signing_1.verifyPackageAuthorSignature)(pv, revokedKeys.publicKey);
-        expect(result).toEqual({ valid: false, publicKey: revokedKeys.publicKey });
-    });
-    it("still accepts the current key", () => {
-        const pv = { ...makePV(), packageAuthorSignature: "" };
-        pv.packageAuthorSignature = (0, package_author_signing_1.signPackageAuthor)(pv, currentKeys.secretKey);
-        expect((0, package_author_signing_1.verifyPackageAuthorSignature)(pv, currentKeys.publicKey).valid).toBe(true);
-    });
-});
-describe("needsPeersCoreRepin", () => {
-    it("is true only for peers-core pinned to a revoked key", () => {
-        expect((0, peers_core_trust_anchor_1.needsPeersCoreRepin)(makePkg())).toBe(true);
-        expect((0, peers_core_trust_anchor_1.needsPeersCoreRepin)(makePkg({ publishPublicKey: currentKeys.publicKey }))).toBe(false);
-        expect((0, peers_core_trust_anchor_1.needsPeersCoreRepin)(makePkg({ publishPublicKey: "" }))).toBe(false);
-        expect((0, peers_core_trust_anchor_1.needsPeersCoreRepin)(makePkg({ packageId: (0, utils_1.newid)() }))).toBe(false);
-    });
-    it("honours explicit key lists", () => {
-        const other = (0, keys_1.newKeys)();
-        const pkg = makePkg({ publishPublicKey: other.publicKey });
-        expect((0, peers_core_trust_anchor_1.needsPeersCoreRepin)(pkg)).toBe(false);
-        expect((0, peers_core_trust_anchor_1.needsPeersCoreRepin)(pkg, {
-            currentPublicKey: currentKeys.publicKey,
-            revokedPublicKeys: [other.publicKey],
-        })).toBe(true);
-    });
-    it("is false when the host has no current key to pin", () => {
-        expect((0, peers_core_trust_anchor_1.needsPeersCoreRepin)(makePkg(), { currentPublicKey: "" })).toBe(false);
-    });
-});
-describe("repinPeersCoreIfRevoked", () => {
-    it("re-pins and saves when the key is revoked", async () => {
-        mockPackagesSignAndSave.mockResolvedValue(undefined);
-        const pkg = makePkg();
-        const result = await (0, peers_core_trust_anchor_1.repinPeersCoreIfRevoked)(makeCtx(), pkg);
-        expect(result).not.toBe(pkg);
-        expect(result.publishPublicKey).toBe(currentKeys.publicKey);
-        expect(mockPackagesSignAndSave).toHaveBeenCalledWith(expect.objectContaining({
-            packageId: systemIds.peersCorePackageId,
-            publishPublicKey: currentKeys.publicKey,
-        }));
-        expect(console.warn).toHaveBeenCalled();
-    });
-    it("returns the same row and does not save when nothing is revoked", async () => {
-        const pkg = makePkg({ publishPublicKey: currentKeys.publicKey });
-        const result = await (0, peers_core_trust_anchor_1.repinPeersCoreIfRevoked)(makeCtx(), pkg);
-        expect(result).toBe(pkg);
-        expect(mockPackagesSignAndSave).not.toHaveBeenCalled();
-    });
-    it("does not touch other packages even when their key is revoked", async () => {
-        const pkg = makePkg({ packageId: (0, utils_1.newid)() });
-        const result = await (0, peers_core_trust_anchor_1.repinPeersCoreIfRevoked)(makeCtx(), pkg);
-        expect(result).toBe(pkg);
-        expect(mockPackagesSignAndSave).not.toHaveBeenCalled();
-    });
-    it("returns the original row when the save is not permitted", async () => {
-        mockPackagesSignAndSave.mockRejectedValue(new Error("not a writer"));
-        const pkg = makePkg();
-        const result = await (0, peers_core_trust_anchor_1.repinPeersCoreIfRevoked)(makeCtx("group-ro"), pkg);
-        expect(result).toBe(pkg);
-        expect(result.publishPublicKey).toBe(revokedKeys.publicKey);
-        expect(console.error).toHaveBeenCalled();
-    });
-});
-describe("repinInstalledPeersCoreIfRevoked", () => {
-    it("returns null when peers-core is not installed", async () => {
-        mockPackagesGet.mockResolvedValue(undefined);
-        expect(await (0, peers_core_trust_anchor_1.repinInstalledPeersCoreIfRevoked)(makeCtx())).toBeNull();
-        expect(mockPackagesSignAndSave).not.toHaveBeenCalled();
-    });
-    it("loads peers-core and re-pins it", async () => {
-        mockPackagesGet.mockResolvedValue(makePkg());
-        mockPackagesSignAndSave.mockResolvedValue(undefined);
-        const result = await (0, peers_core_trust_anchor_1.repinInstalledPeersCoreIfRevoked)(makeCtx());
-        expect(mockPackagesGet).toHaveBeenCalledWith(systemIds.peersCorePackageId);
-        expect(result?.publishPublicKey).toBe(currentKeys.publicKey);
-        expect(mockPackagesSignAndSave).toHaveBeenCalledTimes(1);
-    });
-});

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

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

package/dist/package-loader/contract-package-loader.test.js

@@ -1,274 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("../index");
-const mockBeforeToolSave = jest.fn();
-jest.mock("../data/tools", () => {
-    const actual = jest.requireActual("../data/tools");
-    const contexts = new WeakMap();
-    return {
-        ...actual,
-        Tools: (context) => {
-            let rows = contexts.get(context);
-            if (!rows) {
-                rows = new Map();
-                contexts.set(context, rows);
-            }
-            const records = rows;
-            return {
-                list: async () => [...records.values()],
-                get: async (id) => records.get(id),
-                save: async (row, opts) => {
-                    await mockBeforeToolSave(row);
-                    if (!opts?.insertOnly || !records.has(row.toolId))
-                        records.set(row.toolId, row);
-                    return records.get(row.toolId);
-                },
-                update: async (patch) => {
-                    const row = { ...records.get(patch.toolId), ...patch };
-                    records.set(patch.toolId, row);
-                    return row;
-                },
-                dataChanged: { subscribe: () => ({ unsubscribe: () => true }) },
-            };
-        },
-    };
-});
-jest.mock("../data/assistants", () => ({
-    Assistants: () => ({
-        save: jest.fn().mockResolvedValue(undefined),
-    }),
-}));
-const registry_1 = require("../contracts/registry");
-const tool_catalog_1 = require("../contracts/tool-catalog");
-const tool_catalog_identity_1 = require("../contracts/tool-catalog-identity");
-const table_container_1 = require("../data/orm/table-container");
-const tools_1 = require("../data/tools");
-const field_type_1 = require("../types/field-type");
-const utils_1 = require("../utils");
-const contract_package_loader_1 = require("./contract-package-loader");
-describe("installContractPackage registry wiring", () => {
-    const packageId = (0, utils_1.newid)();
-    const contractId = (0, utils_1.newid)();
-    function makeDefinition(overrides = {}) {
-        return {
-            packageId,
-            version: "1.0.0",
-            contracts: [
-                {
-                    contractId,
-                    version: 1,
-                    devTag: "dev",
-                    name: "Test Contract",
-                    description: "For registry install tests",
-                    tables: [],
-                    tools: [],
-                    observables: [],
-                    events: [],
-                },
-            ],
-            consumes: [],
-            alsoImplements: new Map(),
-            assistants: [],
-            appNavs: [],
-            tableDefinitions: [],
-            ...overrides,
-        };
-    }
-    function mockDataContext() {
-        return {
-            dataContextId: "test-ctx",
-            tableContainer: {
-                registerTableDefinitions: jest.fn(),
-            },
-        };
-    }
-    it("registers contract providers into the provided ContractRegistry", async () => {
-        const registry = new registry_1.ContractRegistry();
-        const dataContext = mockDataContext();
-        const definition = makeDefinition();
-        await (0, contract_package_loader_1.installContractPackage)(dataContext, definition, { registry });
-        expect(registry.resolve(contractId, 1)?.name).toBe("Test Contract");
-        expect(registry.getProviderPackageId(contractId, 1)).toBe(packageId);
-        expect(registry.getContractKeysForPackage(packageId)).toEqual([`${contractId}@1`]);
-    });
-    it("registers what a hub implementation exposes", async () => {
-        const registry = new registry_1.ContractRegistry();
-        const hubId = (0, utils_1.newid)();
-        const definition = makeDefinition({
-            exposes: new Map([[`${hubId}@1`, [{ contractId, version: 1 }]]]),
-        });
-        definition.contracts.push({ ...definition.contracts[0], contractId: hubId, name: "Hub" });
-        await (0, contract_package_loader_1.installContractPackage)(mockDataContext(), definition, { registry });
-        expect(registry.getExposedContracts(hubId, 1, packageId)).toEqual([{ contractId, version: 1 }]);
-        expect(registry.getExposedContracts(contractId, 1, packageId)).toEqual([]);
-    });
-    it("persists CLI runner metadata without executable registration", async () => {
-        const registry = new registry_1.ContractRegistry();
-        const context = mockDataContext();
-        const tool = {
-            toolId: "00mlwl2km0iymo1hwhtvqij2n",
-            name: "cli_assistant_runner",
-            usageDescription: "CLI",
-            code: "",
-            inputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
-            outputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
-            isAssistantRunner: true,
-            configSchema: { type: tools_1.IOSchemaType.simple, fields: [] },
-        };
-        const definition = makeDefinition({
-            toolMetadata: [
-                {
-                    contractId: "00mp287gdomtx12ald8oelyp0",
-                    version: 1,
-                    toolName: tool.name,
-                    isAssistantRunner: true,
-                    configSchema: tool.configSchema,
-                },
-            ],
-        });
-        definition.contracts[0] = {
-            ...definition.contracts[0],
-            contractId: "00mp287gdomtx12ald8oelyp0",
-            tools: [{ name: tool.name, usageDescription: "CLI", inputFields: [], outputFields: [] }],
-        };
-        await (0, contract_package_loader_1.installContractPackage)(context, definition, { registry });
-        expect(await (0, tools_1.Tools)(context).get(tool.toolId)).toMatchObject({
-            isAssistantRunner: true,
-            configSchema: tool.configSchema,
-            catalogState: "resolved",
-        });
-        await registry.toolCatalog?.dispose();
-        jest.clearAllMocks();
-    });
-    it("does not register providers when no registry is provided", async () => {
-        const dataContext = mockDataContext();
-        const dispose = jest.spyOn(tool_catalog_1.ToolCatalog.prototype, "dispose");
-        try {
-            await expect((0, contract_package_loader_1.installContractPackage)(dataContext, makeDefinition())).resolves.toBeUndefined();
-            // The throwaway registry's catalog must not outlive the call.
-            expect(dispose).toHaveBeenCalledTimes(1);
-            const registry = new registry_1.ContractRegistry();
-            await (0, contract_package_loader_1.installContractPackage)(dataContext, makeDefinition(), { registry });
-            expect(dispose).toHaveBeenCalledTimes(1);
-            await registry.toolCatalog?.dispose();
-        }
-        finally {
-            dispose.mockRestore();
-        }
-    });
-    it("keeps the previous provider active when package persistence fails", async () => {
-        const registry = new registry_1.ContractRegistry();
-        const previous = makeDefinition();
-        previous.contracts[0] = { ...previous.contracts[0], name: "Previous Contract" };
-        await (0, contract_package_loader_1.installContractPackage)(mockDataContext(), previous, { registry });
-        const dataContext = mockDataContext();
-        dataContext.tableContainer.registerTableDefinitions.mockImplementation(() => {
-            throw new Error("table registration failed");
-        });
-        const replacement = makeDefinition({
-            tableDefinitions: [{}],
-        });
-        await expect((0, contract_package_loader_1.installContractPackage)(dataContext, replacement, { registry })).rejects.toThrow(/table registration failed/);
-        expect(registry.resolve(contractId, 1)?.name).toBe("Previous Contract");
-        expect(registry.getProviderPackageId(contractId, 1)).toBe(packageId);
-    });
-    it.each([
-        "catalog-write",
-        "invalid-table",
-    ])("keeps active host tables through %s failure and permits retry", async (failure) => {
-        const registry = new registry_1.ContractRegistry();
-        const container = new table_container_1.TableContainer((metaData) => ({ metaData }));
-        const context = { dataContextId: (0, utils_1.newid)(), tableContainer: container };
-        const definition = makeDefinition();
-        definition.contracts[0].tools = [
-            { name: "read", usageDescription: "Read", inputFields: [], outputFields: [] },
-        ];
-        const tableId = (0, utils_1.newid)();
-        const tableDefinition = (primaryKeyName) => ({
-            metaData: {
-                tableId,
-                name: "State",
-                description: "State",
-                primaryKeyName,
-                fields: [{ name: primaryKeyName, type: field_type_1.FieldType.id }],
-            },
-        });
-        definition.tableDefinitions = [tableDefinition("oldId")];
-        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
-        try {
-            await (0, contract_package_loader_1.installContractPackage)(context, definition, { registry });
-            const previous = registry.resolve(contractId, 1);
-            const oldTable = container.getTableByName(`State_${tableId}`);
-            let saves = 0;
-            mockBeforeToolSave.mockImplementation(async (row) => {
-                if (failure === "catalog-write" && row.contractId === contractId && ++saves === 2) {
-                    expect(container.getTableByName(`State_${tableId}`)).toBe(oldTable);
-                    throw new Error("final catalog disk failure");
-                }
-            });
-            const replacement = { ...definition, tableDefinitions: [tableDefinition("newId")] };
-            if (failure === "invalid-table") {
-                const invalid = tableDefinition("invalidId");
-                invalid.metaData.tableId = "invalid";
-                replacement.tableDefinitions.push(invalid);
-            }
-            await expect((0, contract_package_loader_1.installContractPackage)(context, replacement, { registry })).rejects.toThrow(failure === "catalog-write" ? "final catalog disk failure" : "Invalid tableId");
-            expect(registry.resolve(contractId, 1)).toBe(previous);
-            expect(container.getTableByName(`State_${tableId}`)).toBe(oldTable);
-            expect(oldTable.metaData.primaryKeyName).toBe("oldId");
-            mockBeforeToolSave.mockReset();
-            replacement.tableDefinitions = [tableDefinition("newId")];
-            await (0, contract_package_loader_1.installContractPackage)(context, replacement, { registry });
-            expect(container.getTableByName(`State_${tableId}`).metaData.primaryKeyName).toBe("newId");
-        }
-        finally {
-            mockBeforeToolSave.mockReset();
-            warn.mockRestore();
-            await registry.toolCatalog?.dispose();
-        }
-    });
-    it("indexes public host definitions without instances and activates only after loader preparation", async () => {
-        const registry = new registry_1.ContractRegistry();
-        const dataContext = mockDataContext();
-        const definition = makeDefinition();
-        definition.contracts[0].tools = [
-            { name: "read", usageDescription: "Read", inputFields: [], outputFields: [] },
-        ];
-        const toolId = (0, tool_catalog_identity_1.deriveToolCatalogId)({ contractId, version: 1, toolName: "read" });
-        const activated = jest.fn();
-        const prepare = jest.fn(async () => {
-            expect(await (0, tools_1.Tools)(dataContext).get(toolId)).toMatchObject({ catalogState: "resolved" });
-            expect(registry.resolve(contractId, 1)).toBeUndefined();
-            throw new Error("loader preparation failed");
-        });
-        await expect((0, contract_package_loader_1.installContractPackage)(dataContext, definition, {
-            registry,
-            prepare,
-            onActivated: activated,
-        })).rejects.toThrow(/loader preparation failed/);
-        expect(activated).not.toHaveBeenCalled();
-        expect(registry.resolve(contractId, 1)).toBeUndefined();
-        await (0, contract_package_loader_1.installContractPackage)(dataContext, definition, { registry, onActivated: activated });
-        expect(activated).toHaveBeenCalledTimes(1);
-        expect((await (0, tools_1.Tools)(dataContext).list()).filter((row) => row.contractId === contractId)).toHaveLength(1);
-        await registry.toolCatalog?.dispose();
-    });
-});
-describe("extractPackageDefinition", () => {
-    it("returns a package definition when packageId and contracts are present", () => {
-        const packageId = (0, utils_1.newid)();
-        const def = {
-            packageId,
-            contracts: [],
-            consumes: [],
-            alsoImplements: new Map(),
-            assistants: [],
-            appNavs: [],
-            tableDefinitions: [],
-        };
-        expect((0, contract_package_loader_1.extractPackageDefinition)({ packageDefinition: def })).toBe(def);
-    });
-    it("returns undefined when packageDefinition is missing", () => {
-        expect((0, contract_package_loader_1.extractPackageDefinition)({})).toBeUndefined();
-    });
-});

package/dist/package-loader/host-authority-loading.test.d.ts

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

package/dist/package-loader/host-authority-loading.test.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../index");
-test("host-backed package endpoints honor declared propagation and reread live metadata", async () => {
-    const packageId = (0, index_1.newid)();
-    const contractId = (0, index_1.newid)();
-    const userId = (0, index_1.newid)();
-    const groupId = (0, index_1.newid)();
-    const rows = new Map();
-    const tools = {
-        list: async () => [...rows.values()],
-        get: async (id) => rows.get(id),
-        save: async (row, opts) => {
-            if (!opts?.insertOnly || !rows.has(row.toolId))
-                rows.set(row.toolId, row);
-            return rows.get(row.toolId);
-        },
-        dataChanged: { subscribe: () => ({ unsubscribe: () => true }) },
-    };
-    const dataContext = {
-        dataContextId: groupId,
-        groupId,
-        tableContainer: {
-            getTable: (meta) => meta.name === "Tools"
-                ? tools
-                : meta.name === "Groups"
-                    ? { get: async () => ({ founderUserId: (0, index_1.newid)() }) }
-                    : { findOne: async () => ({ userId, role: index_1.GroupMemberRole.Admin }) },
-        },
-    };
-    Object.assign(dataContext, {
-        userContext: {
-            userId,
-            deviceId: () => (0, index_1.newid)(),
-            loadingPromise: Promise.resolve(),
-            userDataContext: dataContext,
-            getDataContext: () => dataContext,
-        },
-    });
-    const loader = new index_1.PackageLoader(dataContext);
-    const make = (name, level, fn) => ({
-        tool: {
-            toolId: (0, index_1.newid)(),
-            name,
-            accessLevel: level,
-            code: "",
-            usageDescription: name,
-            inputSchema: { type: index_1.IOSchemaType.simple, fields: [] },
-            outputSchema: { type: index_1.IOSchemaType.simple, fields: [] },
-        },
-        toolFn: fn,
-    });
-    const route = make("route", 20, (_, ctx) => ctx.dispatchTool?.({ contractId, version: 1, toolName: "target", providerPackageId: packageId }, {}));
-    route.tool.authorityPropagation = "preserve";
-    const effect = jest.fn(() => "admin target");
-    (0, index_1.registerContractResolver)(contractId, 1, () => ({
-        contractId,
-        version: 1,
-        forwardCallContext: true,
-        tools: { route, target: make("target", 60, effect) },
-    }), { providerPackageId: packageId });
-    loader.contractRegistry.register(packageId, {
-        contractId,
-        version: 1,
-        name: "Arbitrary",
-        description: "",
-        tools: ["route", "target"].map((name) => ({
-            name,
-            usageDescription: name,
-            inputFields: [],
-            outputFields: [],
-        })),
-        tables: [],
-        observables: [],
-        events: [],
-    });
-    const endpoint = await loader.resolveContractEndpoint({
-        contractId,
-        version: 1,
-        providerPackageId: packageId,
-        context: { callerUserId: userId, dataContext },
-        notify: async () => undefined,
-    });
-    const call = {
-        contractId,
-        version: 1,
-        member: "tool",
-        name: "route",
-        operation: "run",
-        args: [{}],
-        dataContextId: groupId,
-    };
-    try {
-        await expect(endpoint.handleCall(call)).resolves.toBe("admin target");
-        // Metadata is read on every call: an ordinary Reader wrapper caps the Admin at Reader.
-        route.tool.authorityPropagation = "cap";
-        await expect(endpoint.handleCall(call)).rejects.toThrow("strict delegation");
-        expect(effect).toHaveBeenCalledTimes(1);
-    }
-    finally {
-        endpoint.dispose();
-        await loader.dispose();
-    }
-});

package/dist/package-loader/host-dispatch-policy.test.d.ts

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