@peers-app/peers-sdk 0.23.4 → 0.23.5

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

@@ -10,8 +10,12 @@ jest.mock("../data/package-versions", () => ({
     }),
     computePackageVersionHash: (version, versionTag, packageBundleFileHash, routesBundleFileHash, uiBundleFileHash) => mockComputePackageVersionHash(version, versionTag, packageBundleFileHash, routesBundleFileHash, uiBundleFileHash),
 }));
+const contract_resolvers_1 = require("../contracts/contract-resolvers");
 const registry_1 = require("../contracts/registry");
 const system_ids_1 = require("../system-ids");
+const utils_1 = require("../utils");
+const isolated_artifact_1 = require("./isolated-artifact");
+const isolated_runtime_1 = require("./isolated-runtime");
 const package_loader_1 = require("./package-loader");
 describe("PackageLoader.correctPackageVersion", () => {
     const activePvId = "pv-active";
@@ -27,13 +31,11 @@ describe("PackageLoader.correctPackageVersion", () => {
         mockSignAndSave.mockResolvedValue(undefined);
         loader = new package_loader_1.PackageLoader({ dataContextId: "ctx" });
     });
-    async function correctPackageVersion() {
-        loader.correctPackageVersion(pkg, def);
-        // Flush the fire-and-forget promise chain
-        await new Promise((r) => setImmediate(r));
+    async function correctPackageVersion(selectedPackageVersion) {
+        await loader.correctPackageVersion(pkg, selectedPackageVersion, def.version);
     }
     it("updates the active PV hash and clears a stale author signature", async () => {
-        mockGet.mockResolvedValue({
+        await correctPackageVersion({
             packageVersionId: activePvId,
             version: "0.3.1",
             versionTag: "dev",
@@ -43,7 +45,6 @@ describe("PackageLoader.correctPackageVersion", () => {
             packageAuthorSignature: "stale-sig",
             packageVersionHash: "old-hash",
         });
-        await correctPackageVersion();
         expect(mockComputePackageVersionHash).toHaveBeenCalledWith("0.3.6", "dev", "bundle-hash", "routes-hash", "ui-hash");
         expect(mockSignAndSave).toHaveBeenCalledWith(expect.objectContaining({
             packageVersionId: activePvId,
@@ -54,30 +55,27 @@ describe("PackageLoader.correctPackageVersion", () => {
         expect(mockSignAndSave.mock.calls[0][0].packageAuthorSignature).toBeUndefined();
     });
     it("does not update the active PV when it is stable", async () => {
-        mockGet.mockResolvedValue({
+        await correctPackageVersion({
             packageVersionId: activePvId,
             version: "0.3.5",
             versionTag: "stable",
         });
-        await correctPackageVersion();
         expect(mockSignAndSave).not.toHaveBeenCalled();
     });
     it("does not update the active PV when it is beta", async () => {
-        mockGet.mockResolvedValue({
+        await correctPackageVersion({
             packageVersionId: activePvId,
             version: "0.3.5",
             versionTag: "beta",
         });
-        await correctPackageVersion();
         expect(mockSignAndSave).not.toHaveBeenCalled();
     });
     it("does nothing when the active PV version already matches", async () => {
-        mockGet.mockResolvedValue({
+        await correctPackageVersion({
             packageVersionId: activePvId,
             version: "0.3.6",
             versionTag: "dev",
         });
-        await correctPackageVersion();
         expect(mockSignAndSave).not.toHaveBeenCalled();
     });
 });
@@ -95,4 +93,472 @@ describe("PackageLoader.contractRegistry", () => {
         expect(loader.contractRegistry.resolve(system_ids_1.logsContractId, 1)?.name).toBe("System Logs");
         expect(loader.contractRegistry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
     });
+    it("resolves the registry-selected provider through its scoped resolver", async () => {
+        const dataContext = { dataContextId: "ctx-selected-provider" };
+        const loader = new package_loader_1.PackageLoader(dataContext);
+        const contractId = (0, utils_1.newid)();
+        const providerA = (0, utils_1.newid)();
+        const providerB = (0, utils_1.newid)();
+        const definition = {
+            contractId,
+            version: 1,
+            devTag: "dev",
+            name: "Selected Provider",
+            description: "test",
+            tables: [],
+            tools: [],
+            observables: [],
+            events: [],
+        };
+        loader.contractRegistry.register(providerA, definition);
+        loader.contractRegistry.register(providerB, definition);
+        loader.contractRegistry.setActiveProvider(contractId, 1, providerB);
+        const resolverA = jest.fn(() => ({ contractId, version: 1 }));
+        const resolverB = jest.fn(() => ({ contractId, version: 1 }));
+        (0, contract_resolvers_1.registerContractResolver)(contractId, 1, resolverA, { providerPackageId: providerA });
+        (0, contract_resolvers_1.registerContractResolver)(contractId, 1, resolverB, { providerPackageId: providerB });
+        const endpoint = await loader.resolveContractEndpoint({
+            contractId,
+            version: 1,
+            context: {},
+            notify: async () => undefined,
+        });
+        expect(resolverA).not.toHaveBeenCalled();
+        expect(resolverB).toHaveBeenCalledWith({ dataContext });
+        endpoint.dispose();
+    });
+    it("preserves legacy unscoped resolvers without a registry provider", async () => {
+        const dataContext = { dataContextId: "ctx-legacy-resolver" };
+        const loader = new package_loader_1.PackageLoader(dataContext);
+        const contractId = (0, utils_1.newid)();
+        const resolver = jest.fn(() => ({ contractId, version: 1 }));
+        (0, contract_resolvers_1.registerContractResolver)(contractId, 1, resolver);
+        const endpoint = await loader.resolveContractEndpoint({
+            contractId,
+            version: 1,
+            context: {},
+            notify: async () => undefined,
+        });
+        expect(resolver).toHaveBeenCalledWith({ dataContext });
+        endpoint.dispose();
+    });
+});
+const mockGetFileContents = jest.fn();
+jest.mock("../data/files", () => ({
+    Files: () => ({
+        getFileContents: (...args) => mockGetFileContents(...args),
+    }),
+}));
+describe("PackageLoader isolated artifacts", () => {
+    const packageId = (0, utils_1.newid)();
+    const contractId = (0, utils_1.newid)();
+    const artifact = {
+        manifest: {
+            packageId,
+            version: "1.0.0",
+            provides: [
+                {
+                    contractId,
+                    version: 1,
+                    name: "Greeter",
+                    tools: [{ name: "greet", usageDescription: "Hello", inputFields: [], outputFields: [] }],
+                },
+            ],
+            consumes: [],
+        },
+        providerSource: "globalThis.__shouldNotEvalOnHost = true;",
+    };
+    const pkg = {
+        packageId,
+        name: "Isolated Greeter",
+        activePackageVersionId: (0, utils_1.newid)(),
+    };
+    const selectedVersion = (overrides = {}) => ({
+        packageVersionId: pkg.activePackageVersionId,
+        packageId,
+        version: artifact.manifest.version,
+        versionTag: "stable",
+        packageBundleFileId: (0, utils_1.newid)(),
+        packageBundleFileHash: "bundle-hash",
+        ...overrides,
+    });
+    afterEach(() => {
+        (0, isolated_runtime_1.setIsolatedPackageRuntimeFactory)(undefined);
+        mockGetFileContents.mockReset();
+        delete globalThis.__shouldNotEvalOnHost;
+    });
+    function makeRuntime() {
+        const installed = new Set();
+        const runtime = {
+            install: jest.fn(async (next) => {
+                installed.add(next.manifest.packageId);
+                return { packageId: next.manifest.packageId, provided: [], consumes: [] };
+            }),
+            replace: jest.fn(async (next) => {
+                installed.add(next.manifest.packageId);
+                return { packageId: next.manifest.packageId, provided: [], consumes: [] };
+            }),
+            uninstall: jest.fn(async (id) => {
+                installed.delete(id);
+            }),
+            resolveEndpoint: jest.fn(async () => undefined),
+            provides: jest.fn(() => false),
+            isInstalled: jest.fn((id) => installed.has(id)),
+            dispose: jest.fn(async () => {
+                installed.clear();
+            }),
+        };
+        (0, isolated_runtime_1.setIsolatedPackageRuntimeFactory)(() => runtime);
+        return runtime;
+    }
+    it("installs a valid isolated artifact without evaluating provider source", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-iso" });
+        const loaded = await loader.loadPackage(pkg);
+        expect(loaded).toEqual({ packageId, appNavs: undefined });
+        expect(runtime.install).toHaveBeenCalledWith(artifact, expect.objectContaining({
+            contractLifecycle: "stable",
+            packageVersionId: pkg.activePackageVersionId,
+            packageVersion: "1.0.0",
+            versionTag: "stable",
+        }));
+        expect(loader.isIsolatedInstalled(packageId)).toBe(true);
+        expect(loader.isContractInstalled(packageId)).toBe(true);
+        expect(globalThis.__shouldNotEvalOnHost).toBeUndefined();
+    });
+    test.each([
+        ["dev", "mutable"],
+        ["beta", "mutable"],
+        ["stable", "stable"],
+    ])("maps trusted %s package versions to %s contracts", async (versionTag, lifecycle) => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion({ versionTag }));
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: `ctx-${versionTag}` });
+        await loader.loadPackage(pkg);
+        expect(runtime.install).toHaveBeenCalledWith(artifact, expect.objectContaining({ contractLifecycle: lifecycle, versionTag }));
+    });
+    it("rejects an artifact whose package ID does not match the package record", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-mismatch" });
+        await expect(loader.loadPackage({ ...pkg, packageId: (0, utils_1.newid)(), activePackageVersionId: (0, utils_1.newid)() })).rejects.toThrow(/packageId mismatch/);
+        expect(runtime.install).not.toHaveBeenCalled();
+        expect(loader.isIsolatedInstalled(packageId)).toBe(false);
+    });
+    it("skips a valid isolated artifact when no runtime factory is registered", async () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-nofactory" });
+        try {
+            await expect(loader.loadPackage(pkg)).resolves.toBeUndefined();
+            expect(loader.isIsolatedInstalled(packageId)).toBe(false);
+            expect(loader.isContractInstalled(packageId)).toBe(false);
+            expect(warn).toHaveBeenCalledWith(expect.stringMatching(/does not provide an isolated runtime/));
+            expect(globalThis.__shouldNotEvalOnHost).toBeUndefined();
+        }
+        finally {
+            warn.mockRestore();
+        }
+    });
+    it("clears a previously loaded legacy provider when isolation is unsupported", async () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-no-runtime-transition" });
+        const legacyDefinition = {
+            contractId,
+            version: 1,
+            devTag: "dev",
+            name: "Legacy provider",
+            description: "",
+            tables: [],
+            tools: [],
+            observables: [],
+            events: [],
+        };
+        loader.contractRegistry.register(packageId, legacyDefinition);
+        loader.packageInstances[packageId] = { packageId, appNavs: [] };
+        loader.contractInstalledPackages.add(packageId);
+        try {
+            await expect(loader.loadPackage(pkg, { force: true })).resolves.toBeUndefined();
+            expect(loader.contractRegistry.getProviderPackageId(contractId, 1)).toBeUndefined();
+            expect(loader.packageInstances[packageId]).toBeUndefined();
+        }
+        finally {
+            warn.mockRestore();
+        }
+    });
+    it("preserves a working legacy provider when isolated installation fails", async () => {
+        const runtime = makeRuntime();
+        runtime.install.mockRejectedValueOnce(new Error("migration failed"));
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({
+            dataContextId: "ctx-failed-isolated-transition",
+        });
+        const legacyDefinition = {
+            contractId,
+            version: 1,
+            devTag: "dev",
+            name: "Legacy provider",
+            description: "",
+            tables: [],
+            tools: [],
+            observables: [],
+            events: [],
+        };
+        loader.contractRegistry.register(packageId, legacyDefinition);
+        const previous = { packageId, appNavs: [] };
+        loader.packageInstances[packageId] = previous;
+        loader.contractInstalledPackages.add(packageId);
+        await expect(loader.loadPackage(pkg, { force: true })).rejects.toThrow(/migration failed/);
+        expect(loader.contractRegistry.getProviderPackageId(contractId, 1)).toBe(packageId);
+        expect(loader.packageInstances[packageId]).toBe(previous);
+    });
+    it("rejects a package ID mismatch even when the host has no isolated runtime", async () => {
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-nofactory-mismatch" });
+        await expect(loader.loadPackage({ ...pkg, packageId: (0, utils_1.newid)(), activePackageVersionId: (0, utils_1.newid)() })).rejects.toThrow(/packageId mismatch/);
+    });
+    it("continues loading legacy packages after skipping an unsupported isolated package", async () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+        const legacyPackageId = (0, utils_1.newid)();
+        const legacyPkg = {
+            packageId: legacyPackageId,
+            name: "Legacy Package",
+            activePackageVersionId: (0, utils_1.newid)(),
+        };
+        mockGet.mockImplementation(async (packageVersionId) => ({
+            packageVersionId,
+            packageId: packageVersionId === pkg.activePackageVersionId ? packageId : legacyPackageId,
+            version: "1.0.0",
+            packageBundleFileId: (0, utils_1.newid)(),
+            packageBundleFileHash: "bundle-hash",
+            versionTag: "dev",
+        }));
+        mockGetFileContents
+            .mockResolvedValueOnce(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)))
+            .mockResolvedValueOnce(Buffer.from(`module.exports = { packageId: "${legacyPackageId}", appNavs: [] };`));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-mixed-host" });
+        try {
+            await expect(loader.loadPackage(pkg)).resolves.toBeUndefined();
+            await expect(loader.loadPackage(legacyPkg)).resolves.toEqual({
+                packageId: legacyPackageId,
+                appNavs: [],
+            });
+        }
+        finally {
+            warn.mockRestore();
+        }
+    });
+    it("fails closed on a malformed isolated envelope and never evaluates it", async () => {
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from(`${"PEERS_ISOLATED_PACKAGE_V1"}\n{nope`));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-bad" });
+        await expect(loader.loadPackage(pkg)).rejects.toThrow(/JSON is invalid/);
+        expect(globalThis.__shouldNotEvalOnHost).toBeUndefined();
+    });
+    it("passes table and package-pvar gateways from a complete data context", () => {
+        const factory = jest.fn(() => ({
+            install: jest.fn(async () => ({ packageId, provided: [], consumes: [] })),
+            replace: jest.fn(async () => ({ packageId, provided: [], consumes: [] })),
+            uninstall: jest.fn(async () => undefined),
+            resolveEndpoint: jest.fn(async () => undefined),
+            provides: jest.fn(() => false),
+            isInstalled: jest.fn(() => false),
+            dispose: jest.fn(async () => undefined),
+        }));
+        (0, isolated_runtime_1.setIsolatedPackageRuntimeFactory)(factory);
+        const tableContainer = { registerTableDefinition: jest.fn(), getTable: jest.fn() };
+        const dataContext = {
+            dataContextId: "ctx-tables",
+            tableContainer,
+        };
+        dataContext.userContext = {
+            userDataContext: dataContext,
+        };
+        new package_loader_1.PackageLoader(dataContext);
+        expect(factory).toHaveBeenCalledWith(expect.objectContaining({
+            dataContextId: "ctx-tables",
+            providerGateway: expect.objectContaining({
+                resolveEndpoint: expect.any(Function),
+            }),
+            persistentVarGateway: expect.objectContaining({
+                get: expect.any(Function),
+                set: expect.any(Function),
+            }),
+            tableGateway: expect.objectContaining({
+                register: expect.any(Function),
+                get: expect.any(Function),
+                save: expect.any(Function),
+            }),
+        }));
+    });
+    it("unloads an isolated package on force reload and disable", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-unload" });
+        await loader.loadPackage(pkg);
+        await loader.loadPackage(pkg, { force: true });
+        expect(runtime.uninstall).not.toHaveBeenCalled();
+        expect(runtime.install).toHaveBeenCalledTimes(1);
+        expect(runtime.replace).toHaveBeenCalledTimes(1);
+        await loader.loadPackage({ ...pkg, disabled: true });
+        expect(runtime.uninstall).toHaveBeenCalledWith(packageId);
+        expect(loader.isIsolatedInstalled(packageId)).toBe(false);
+    });
+    it("prefers a local isolated bundle over a stored isolated Files bundle", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion({ versionTag: "dev" }));
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)({
+            ...artifact,
+            manifest: { ...artifact.manifest, version: "1.0.0" },
+        })));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-local-iso" });
+        loader.require = ((moduleId) => {
+            if (moduleId === "fs") {
+                return {
+                    readFileSync: () => (0, isolated_artifact_1.serializeIsolatedPackageArtifact)({
+                        ...artifact,
+                        manifest: { ...artifact.manifest, version: "2.0.0" },
+                    }),
+                };
+            }
+            if (moduleId === "path") {
+                return { join: (...parts) => parts.join("/") };
+            }
+            throw new Error(`unexpected require ${moduleId}`);
+        });
+        await loader.loadPackage(pkg, { localPath: "/tmp/isolation-local" });
+        expect(runtime.install).toHaveBeenCalledWith(expect.objectContaining({
+            manifest: expect.objectContaining({ version: "2.0.0" }),
+        }), expect.objectContaining({
+            contractLifecycle: "mutable",
+            packageVersion: "2.0.0",
+            versionTag: "dev",
+        }));
+    });
+    it("does not override a stable selected version from a local checkout", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion({ versionTag: "stable" }));
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)({
+            ...artifact,
+            manifest: { ...artifact.manifest, version: "1.0.0" },
+        })));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-stable-local" });
+        loader.require = ((moduleId) => {
+            if (moduleId === "fs") {
+                return {
+                    readFileSync: () => (0, isolated_artifact_1.serializeIsolatedPackageArtifact)({
+                        ...artifact,
+                        manifest: { ...artifact.manifest, version: "2.0.0" },
+                    }),
+                };
+            }
+            if (moduleId === "path") {
+                return { join: (...parts) => parts.join("/") };
+            }
+            throw new Error(`unexpected require ${moduleId}`);
+        });
+        await loader.loadPackage(pkg, { localPath: "/tmp/stable-checkout" });
+        expect(runtime.install).toHaveBeenCalledWith(expect.objectContaining({
+            manifest: expect.objectContaining({ version: "1.0.0" }),
+        }), expect.objectContaining({ contractLifecycle: "stable", packageVersion: "1.0.0" }));
+    });
+    it("rejects a beta or stable manifest version mismatch", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion({ version: "1.0.0", versionTag: "beta" }));
+        mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)({
+            ...artifact,
+            manifest: { ...artifact.manifest, version: "2.0.0" },
+        })));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-version-mismatch" });
+        await expect(loader.loadPackage(pkg)).rejects.toThrow(/version mismatch/);
+        expect(runtime.install).not.toHaveBeenCalled();
+    });
+    it("uses the instance require callback for legacy package dependencies", async () => {
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+        const runtime = makeRuntime();
+        const requiredValue = { source: "injected-require" };
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from(`module.exports = { packageId: "${packageId}", appNavs: [require("custom-module")] };`));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-custom-require" });
+        loader.require = ((moduleId) => {
+            if (moduleId === "custom-module") {
+                return requiredValue;
+            }
+            throw new Error(`unexpected require ${moduleId}`);
+        });
+        try {
+            await expect(loader.loadPackage(pkg)).resolves.toEqual({
+                packageId,
+                appNavs: [requiredValue],
+            });
+            expect(runtime.install).not.toHaveBeenCalled();
+        }
+        finally {
+            warn.mockRestore();
+        }
+    });
+    it("resolves the virtual PeersSDK import through the canonical package name", async () => {
+        const runtime = makeRuntime();
+        const sdkModule = { marker: "canonical-sdk" };
+        const previousPeersSDK = package_loader_1.PackageLoader.PeersSDK;
+        package_loader_1.PackageLoader.PeersSDK = undefined;
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValue(Buffer.from(`module.exports = { packageId: "${packageId}", appNavs: [require("PeersSDK").marker] };`));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-canonical-sdk" });
+        loader.require = ((moduleId) => {
+            if (moduleId === "@peers-app/peers-sdk") {
+                return sdkModule;
+            }
+            throw new Error(`unexpected require ${moduleId}`);
+        });
+        try {
+            await expect(loader.loadPackage(pkg)).resolves.toEqual({
+                packageId,
+                appNavs: ["canonical-sdk"],
+            });
+            expect(runtime.install).not.toHaveBeenCalled();
+        }
+        finally {
+            package_loader_1.PackageLoader.PeersSDK = previousPeersSDK;
+        }
+    });
+    it("keeps an isolated provider active when legacy evaluation fails", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents.mockResolvedValueOnce(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
+        const loader = new package_loader_1.PackageLoader({
+            dataContextId: "ctx-failed-legacy-transition",
+        });
+        await loader.loadPackage(pkg);
+        mockGetFileContents.mockResolvedValueOnce(Buffer.from("throw new Error('legacy failed');"));
+        await expect(loader.loadPackage(pkg, { force: true })).resolves.toBeUndefined();
+        expect(runtime.uninstall).not.toHaveBeenCalled();
+        expect(runtime.isInstalled(packageId)).toBe(true);
+        expect(loader.isIsolatedInstalled(packageId)).toBe(true);
+    });
+    it("retires isolated state only after a legacy bundle evaluates successfully", async () => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion());
+        mockGetFileContents
+            .mockResolvedValueOnce(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)))
+            .mockResolvedValueOnce(Buffer.from(`module.exports = { packageId: "${packageId}" };`));
+        const loader = new package_loader_1.PackageLoader({
+            dataContextId: "ctx-successful-legacy-transition",
+        });
+        await loader.loadPackage(pkg);
+        await expect(loader.loadPackage(pkg, { force: true })).resolves.toEqual({ packageId });
+        expect(runtime.uninstall).toHaveBeenCalledWith(packageId, { preserveRegistry: false });
+        expect(runtime.isInstalled(packageId)).toBe(false);
+        expect(loader.isIsolatedInstalled(packageId)).toBe(false);
+    });
 });

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

@@ -6,8 +6,8 @@ import type { IPackageDefinitionResult } from "../contracts/types";
  * providers have been registered.
  *
  * A consume succeeds only when {@link ContractRegistry.selectProvider} finds a
- * matching provider **and** a live {@link getContractResolver|ContractResolver}
- * exists for that contract version. Missing optional deps settle to `undefined`;
- * missing required deps reject the handle.
+ * 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.
  */
 export declare function resolveConsumedContracts(dataContext: DataContext, registry: ContractRegistry, packageDefinition: IPackageDefinitionResult): Promise<void>;

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

@@ -9,9 +9,9 @@ const create_local_consumer_1 = require("../contracts/create-local-consumer");
  * providers have been registered.
  *
  * A consume succeeds only when {@link ContractRegistry.selectProvider} finds a
- * matching provider **and** a live {@link getContractResolver|ContractResolver}
- * exists for that contract version. Missing optional deps settle to `undefined`;
- * missing required deps reject the handle.
+ * 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.
  */
 async function resolveConsumedContracts(dataContext, registry, packageDefinition) {
     for (const dep of packageDefinition.consumes) {
@@ -25,15 +25,13 @@ async function resolveConsumedContracts(dataContext, registry, packageDefinition
                 settleMissing(dep.optional === true, handle, dep.contractId, dep.version, "no matching provider");
                 continue;
             }
-            const resolver = (0, contract_resolvers_1.getContractResolver)(dep.contractId, dep.version);
-            if (!resolver) {
-                settleMissing(dep.optional === true, handle, dep.contractId, dep.version, `provider ${selected.providerPackageId} has no live resolver`);
+            const consumer = dataContext.packageLoader?.resolveConsumedContract
+                ? await dataContext.packageLoader.resolveConsumedContract(dep)
+                : await resolveLegacyLocalConsumer(dataContext, selected, dep.contractId, dep.version);
+            if (!consumer) {
+                settleMissing(dep.optional === true, handle, dep.contractId, dep.version, `provider ${selected.providerPackageId} has no live endpoint`);
                 continue;
             }
-            const resolution = await resolver({ dataContext });
-            const consumer = (0, create_local_consumer_1.createLocalContractConsumer)(selected.definition, resolution, {
-                dataContextId: dataContext.dataContextId,
-            });
             (0, builder_1.settleConsumedContractHandle)(handle, consumer);
         }
         catch (err) {
@@ -46,6 +44,16 @@ async function resolveConsumedContracts(dataContext, registry, packageDefinition
         }
     }
 }
+async function resolveLegacyLocalConsumer(dataContext, selected, contractId, version) {
+    const resolver = (0, contract_resolvers_1.getContractResolver)(contractId, version, selected.providerPackageId);
+    if (!resolver) {
+        return undefined;
+    }
+    const resolution = await resolver({ dataContext });
+    return (0, create_local_consumer_1.createLocalContractConsumer)(selected.definition, resolution, {
+        dataContextId: dataContext.dataContextId,
+    });
+}
 function settleMissing(optional, handle, contractId, version, reason) {
     if (optional) {
         (0, builder_1.settleConsumedContractHandle)(handle, undefined);

package/dist/utils.d.ts

@@ -46,6 +46,21 @@ export declare function deterministicPvarId(name: string): string;
  * (starts with the `000pvar0` prefix).
  */
 export declare function isDeterministicPvarId(id: string): boolean;
+/**
+ * Generate a stable host-only peer ID for a package-owned table.
+ *
+ * The physical SQLite name is derived separately; this ID keys synced
+ * `TableDefinitions` metadata and never comes from isolated guest code.
+ *
+ * @param identity Stable package-scoped table identity.
+ */
+export declare function deterministicTableId(identity: string): string;
+/**
+ * Return whether a peer ID was generated by {@link deterministicTableId}.
+ *
+ * @param id Peer ID to inspect.
+ */
+export declare function isDeterministicTableId(id: string): boolean;
 /** Resolves after `ms` milliseconds (0 yields a microtask-yield on most runtimes). */
 export declare function sleep(ms?: number): Promise<void>;
 /** Turns `fooBar` into `Foo Bar` for labels (also replaces `_` with space). */
@@ -96,7 +111,11 @@ export declare function retryOnErrorOrTimeout<T>({ fn, connection, opts, }: {
     };
 }): Promise<T>;
 /**
- * Physical table name: `"name_id"` when `tableId` is set, else `name`.
- * @param metaData Table metadata from the ORM layer
+ * Return a table's physical storage name.
+ *
+ * Trusted package-scoped metadata uses `"name_packageId"`; every existing
+ * table continues to use `"name_tableId"` (or just `"name"` for system tables).
+ *
+ * @param metaData Table metadata from the ORM layer.
  */
 export declare function getFullTableName(metaData: ITableMetaData): string;