@peers-app/peers-sdk 0.25.20 → 0.26.0

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

@@ -1,5 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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 }) },
+            };
+        },
+    };
+});
 const mockGet = jest.fn();
 const mockSignAndSave = jest.fn();
 const mockComputePackageVersionHash = jest.fn((version, _tag, packageBundleFileHash, _routesBundleFileHash, _uiBundleFileHash) => `hash-${version}-${packageBundleFileHash}`);
@@ -10,14 +42,530 @@ jest.mock("../data/package-versions", () => ({
     }),
     computePackageVersionHash: (version, versionTag, packageBundleFileHash, routesBundleFileHash, uiBundleFileHash) => mockComputePackageVersionHash(version, versionTag, packageBundleFileHash, routesBundleFileHash, uiBundleFileHash),
 }));
+const builder_1 = require("../contracts/builder");
+const contract_provider_router_1 = require("../contracts/contract-provider-router");
+const contract_proxy_1 = require("../contracts/contract-proxy");
 const contract_resolvers_1 = require("../contracts/contract-resolvers");
+const contract_transport_1 = require("../contracts/contract-transport");
 const registry_1 = require("../contracts/registry");
+const tool_catalog_identity_1 = require("../contracts/tool-catalog-identity");
 const access_level_1 = require("../data/access-level");
+const groupPermissions = require("../data/group-permissions");
+const tools_1 = require("../data/tools");
 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");
+const consumedContracts = require("./resolve-consumed-contracts");
+describe("host load invalidation", () => {
+    it.each([
+        ["contract", "quarantine"],
+        ["contract", "unload"],
+        ["legacy", "quarantine"],
+        ["legacy", "unload"],
+    ])("rejects %s tool invocation when %s completes during authorization", async (kind, action) => {
+        const packageId = (0, utils_1.newid)();
+        const contractId = (0, utils_1.newid)();
+        const context = { dataContextId: (0, utils_1.newid)() };
+        const loader = new package_loader_1.PackageLoader(context);
+        const toolFn = jest.fn(() => "must not execute");
+        loader.require = (() => {
+            const instance = {
+                tool: { name: "read", usageDescription: "Read", accessLevel: access_level_1.AccessLevel.Self },
+                toolFn,
+            };
+            (0, contract_resolvers_1.registerContractResolver)(contractId, 1, () => ({
+                contractId,
+                version: 1,
+                tools: { read: instance },
+            }));
+            return kind === "contract"
+                ? (0, builder_1.definePackage)((pkg) => {
+                    pkg.packageId = packageId;
+                    pkg.version = "1.0.0";
+                    pkg.contract(contractId, 1, "Authorization race").tools = [instance];
+                })
+                : { packageId };
+        });
+        let entered;
+        const waiting = new Promise((resolve) => {
+            entered = resolve;
+        });
+        let release;
+        const permission = jest
+            .spyOn(groupPermissions, "getUserAccessLevel")
+            .mockImplementationOnce(() => {
+            entered();
+            return new Promise((resolve) => {
+                release = resolve;
+            });
+        });
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        let endpoint;
+        try {
+            await loader._loadBundle({ packageId, name: "Authorization race" }, kind === "contract"
+                ? 'module.exports.packageDefinition = require("fixture");'
+                : 'module.exports = require("fixture");', undefined, false, false);
+            // Legacy resolver-only bundles have no manifest to index; model an existing row.
+            const toolId = (0, tool_catalog_identity_1.deriveToolCatalogId)({ contractId, version: 1, toolName: "read" });
+            if (kind === "legacy")
+                await (0, tools_1.Tools)(context).save({
+                    toolId,
+                    name: "read",
+                    code: "",
+                    usageDescription: "Read",
+                    inputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
+                    outputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
+                    contractId,
+                    contractVersion: 1,
+                    toolName: "read",
+                    catalogIdentity: "deterministic",
+                    catalogState: "resolved",
+                });
+            endpoint = await loader.resolveContractEndpoint({
+                contractId,
+                version: 1,
+                context: { dataContext: context, callerUserId: "self", localUserId: "self" },
+                notify: async () => undefined,
+            });
+            const call = endpoint.handleCall({
+                contractId,
+                version: 1,
+                member: "tool",
+                name: "read",
+                operation: "run",
+                args: [],
+            });
+            const rejection = expect(call).rejects.toThrow(action === "quarantine" ? /quarantined/i : /retired/);
+            await waiting;
+            if (action === "quarantine")
+                await (0, tools_1.Tools)(context).update({ toolId, catalogState: "quarantined" });
+            else
+                await loader.unloadPackage(packageId);
+            release(access_level_1.AccessLevel.Self);
+            await rejection;
+            expect(toolFn).not.toHaveBeenCalled();
+        }
+        finally {
+            release?.(access_level_1.AccessLevel.Self);
+            endpoint?.dispose();
+            permission.mockRestore();
+            warn.mockRestore();
+            await loader.dispose();
+        }
+    });
+    it("settles a fresh package's remote and consume handles after its own contract activates", async () => {
+        const packageId = (0, utils_1.newid)();
+        const contractId = (0, utils_1.newid)();
+        const context = { dataContextId: (0, utils_1.newid)() };
+        const loader = new package_loader_1.PackageLoader(context);
+        Object.assign(context, { packageLoader: loader });
+        let definition;
+        loader.require = (() => {
+            const instance = {
+                tool: { name: "read", usageDescription: "Read", accessLevel: access_level_1.AccessLevel.None },
+                toolFn: () => "own provider",
+            };
+            (0, contract_resolvers_1.registerContractResolver)(contractId, 1, () => ({
+                contractId,
+                version: 1,
+                tools: { read: instance },
+            }));
+            definition = (0, builder_1.definePackage)((pkg) => {
+                pkg.packageId = packageId;
+                pkg.version = "1.0.0";
+                pkg.contract(contractId, 1, "Own contract").tools = [instance];
+                pkg.remote(contractId, 1);
+                pkg.consumes(contractId, 1);
+            });
+            return definition;
+        });
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        try {
+            expect(loader.contractRegistry.getDefinition(contractId, 1)).toBeUndefined();
+            await expect(loader._loadBundle({ packageId, name: "Own contract" }, 'module.exports.packageDefinition = require("fixture");', undefined, false, false)).resolves.toMatchObject({ packageId });
+            const remoteHandle = definition.remotes?.[0].handle;
+            await expect(remoteHandle?.consumer).resolves.toMatchObject({ contractId, version: 1 });
+            const remote = (await remoteHandle?.consumer);
+            expect(typeof remote?.device((0, utils_1.newid)()).tools.read).toBe("function");
+            remote?.dispose();
+            const consumeHandle = definition.consumes[0].handle;
+            await expect(consumeHandle?.consumer).resolves.toMatchObject({ contractId, version: 1 });
+            const consumer = (await consumeHandle?.consumer);
+            await expect(consumer?.tools.read()).resolves.toBe("own provider");
+            consumer?.dispose();
+        }
+        finally {
+            warn.mockRestore();
+            await loader.dispose();
+        }
+    });
+    it.each([
+        "persistence",
+        "evaluation",
+        "invalidation",
+    ])("stages host resolvers until activation and retains the old implementation on %s failure", async (failure) => {
+        const packageId = (0, utils_1.newid)();
+        const contractId = (0, utils_1.newid)();
+        const definition = {
+            packageId,
+            version: "1.0.0",
+            contracts: [
+                {
+                    contractId,
+                    version: 1,
+                    name: "Host",
+                    description: "",
+                    devTag: "dev",
+                    tables: [],
+                    observables: [],
+                    tools: [{ name: "read", usageDescription: "", inputFields: [], outputFields: [] }],
+                },
+            ],
+            consumes: [],
+            alsoImplements: new Map(),
+            assistants: [],
+            appNavs: [],
+            tableDefinitions: [],
+        };
+        const context = { dataContextId: (0, utils_1.newid)() };
+        const otherContext = { dataContextId: (0, utils_1.newid)() };
+        const loader = new package_loader_1.PackageLoader(context);
+        const otherLoader = new package_loader_1.PackageLoader(otherContext);
+        let value = "OLD";
+        let failEvaluation = false;
+        let current = true;
+        const fixture = () => {
+            const captured = value;
+            (0, contract_resolvers_1.registerContractResolver)(contractId, 1, () => ({
+                contractId,
+                version: 1,
+                tools: {
+                    read: {
+                        tool: { name: "read", accessLevel: access_level_1.AccessLevel.None },
+                        toolFn: () => captured,
+                    },
+                },
+            }), { providerPackageId: packageId });
+            if (failEvaluation)
+                throw new Error("evaluation failed");
+            return definition;
+        };
+        loader.require = fixture;
+        otherLoader.require = fixture;
+        const load = (target = loader) => target._loadBundle({ packageId, name: "Host" }, 'module.exports.packageDefinition = require("fixture");', undefined, false, true, () => {
+            if (!current)
+                throw new Error("load invalidated");
+        });
+        const call = async (target = loader) => {
+            const endpoint = await target.resolveContractEndpoint({
+                contractId,
+                version: 1,
+                context: { callerUserId: "self", localUserId: "self" },
+                notify: async () => undefined,
+            });
+            try {
+                return await endpoint.handleCall({
+                    contractId,
+                    version: 1,
+                    member: "tool",
+                    name: "read",
+                    operation: "run",
+                    args: [],
+                });
+            }
+            finally {
+                endpoint.dispose();
+            }
+        };
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        let release = () => { };
+        let consumer;
+        let endpoint;
+        // External host transports own their routers, so loader-side invalidation
+        // cannot evict their cached endpoints directly.
+        const [clientTransport, serverTransport] = (0, contract_transport_1.inProcessTransportPair)();
+        const externalRouter = (0, contract_provider_router_1.createContractProviderRouter)(serverTransport, {
+            authorizeCall: () => ({ context: { dataContext: context } }),
+            resolveProviderPackageId: () => packageId,
+            resolveEndpoint: (request) => loader.resolveContractEndpoint(request),
+        });
+        const externalConsumer = (0, contract_proxy_1.createContractConsumer)(definition.contracts[0], clientTransport);
+        try {
+            await load();
+            consumer = await loader.resolveConsumedContract({ contractId, version: 1 });
+            expect(await consumer?.tools.read()).toBe("OLD");
+            expect(await externalConsumer.tools.read()).toBe("OLD");
+            endpoint = await loader.resolveContractEndpoint({
+                contractId,
+                version: 1,
+                context: {},
+                notify: async () => undefined,
+            });
+            expect(await call()).toBe("OLD");
+            value = "OTHER CONTEXT";
+            await load(otherLoader);
+            expect(await call()).toBe("OLD");
+            expect(await call(otherLoader)).toBe("OTHER CONTEXT");
+            value = "NEW";
+            let entered;
+            const waiting = new Promise((resolve) => {
+                entered = resolve;
+            });
+            const gate = new Promise((resolve) => {
+                release = resolve;
+            });
+            if (failure === "evaluation")
+                failEvaluation = true;
+            else
+                mockBeforeToolSave.mockImplementationOnce(async () => {
+                    entered();
+                    await gate;
+                    if (failure === "persistence")
+                        throw new Error("catalog disk failure");
+                    current = false;
+                });
+            const loading = load();
+            if (failure !== "evaluation") {
+                await waiting;
+                // Candidate resolver registrations are invisible even while persistence waits.
+                expect(await call()).toBe("OLD");
+                release();
+            }
+            expect(await loading).toBeUndefined();
+            expect(await consumer?.tools.read()).toBe("OLD");
+            expect(await call()).toBe("OLD");
+            expect(await call(otherLoader)).toBe("OTHER CONTEXT");
+            expect((0, contract_resolvers_1.getContractResolver)(contractId, 1, packageId)).toBeUndefined();
+            current = true;
+            failEvaluation = false;
+            mockBeforeToolSave.mockReset();
+            await load();
+            expect(await call()).toBe("NEW");
+            expect(await consumer?.tools.read()).toBe("NEW");
+            expect(await externalConsumer.tools.read()).toBe("NEW");
+            await expect(endpoint.handleCall({
+                contractId,
+                version: 1,
+                member: "tool",
+                name: "read",
+                operation: "run",
+                args: [],
+            })).rejects.toThrow(/retired/);
+            await loader.unloadPackage(packageId);
+            await expect(consumer?.tools.read()).rejects.toThrow(/not a registered provider/);
+            await expect(externalConsumer.tools.read()).rejects.toThrow(/not a registered provider/);
+            expect((0, contract_resolvers_1.getContractResolver)(contractId, 1, packageId, context)).toBeUndefined();
+            expect(await call(otherLoader)).toBe("OTHER CONTEXT");
+        }
+        finally {
+            release();
+            consumer?.dispose();
+            externalConsumer.dispose();
+            externalRouter.dispose();
+            endpoint?.dispose();
+            mockBeforeToolSave.mockReset();
+            warn.mockRestore();
+            await loader.dispose();
+            await otherLoader.dispose();
+        }
+    });
+    it("retires cached legacy endpoints even when a bundle reuses its resolver function", async () => {
+        const packageId = (0, utils_1.newid)();
+        const contractId = (0, utils_1.newid)();
+        const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
+        let value = "OLD";
+        const resolver = () => {
+            const captured = value;
+            return {
+                contractId,
+                version: 1,
+                tools: {
+                    read: {
+                        tool: { name: "read", accessLevel: access_level_1.AccessLevel.None },
+                        toolFn: () => captured,
+                    },
+                },
+            };
+        };
+        loader.require = (() => {
+            (0, contract_resolvers_1.registerContractResolver)(contractId, 1, resolver);
+            return { packageId };
+        });
+        const load = () => loader._loadBundle({ packageId, name: "legacy" }, 'module.exports = require("fixture");', undefined, false, true);
+        const resolve = () => loader.resolveContractEndpoint({
+            contractId,
+            version: 1,
+            context: {},
+            notify: async () => undefined,
+        });
+        const call = (endpoint) => endpoint.handleCall({
+            contractId,
+            version: 1,
+            member: "tool",
+            name: "read",
+            operation: "run",
+            args: [],
+        });
+        const endpoints = [];
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        let release = () => { };
+        try {
+            await load();
+            const old = await resolve();
+            endpoints.push(old);
+            expect(await call(old)).toBe("OLD");
+            value = "NEW";
+            await load();
+            await expect(call(old)).rejects.toThrow(/retired/);
+            const current = await resolve();
+            endpoints.push(current);
+            expect(await call(current)).toBe("NEW");
+            let entered;
+            const waiting = new Promise((resolve) => {
+                entered = resolve;
+            });
+            const gate = new Promise((resolve) => {
+                release = resolve;
+            });
+            const assertTarget = loader.toolCatalog.assertTargetUsable.bind(loader.toolCatalog);
+            jest
+                .spyOn(loader.toolCatalog, "assertTargetUsable")
+                .mockImplementationOnce(async (target) => {
+                await assertTarget(target);
+                entered();
+                await gate;
+            });
+            const pending = call(current);
+            const rejected = expect(pending).rejects.toThrow(/retired/);
+            await waiting;
+            await loader.unloadPackage(packageId);
+            release();
+            await rejected;
+            await expect(call(current)).rejects.toThrow(/retired/);
+        }
+        finally {
+            release();
+            for (const endpoint of endpoints)
+                endpoint.dispose();
+            await loader.dispose();
+            warn.mockRestore();
+        }
+    });
+    it("loads a tool-free legacy bundle and rejects executable replacement without side effects", async () => {
+        const packageId = (0, utils_1.newid)();
+        const contractId = (0, utils_1.newid)();
+        const context = {
+            dataContextId: (0, utils_1.newid)(),
+            tableContainer: { registerTableDefinitions: jest.fn() },
+        };
+        const loader = new package_loader_1.PackageLoader(context);
+        const original = { packageId, appNavs: [] };
+        let bundle = original;
+        loader.require = ((id) => id === "@peers-app/peers-sdk"
+            ? { registerContractResolver: contract_resolvers_1.registerContractResolver }
+            : bundle);
+        const load = (code = 'module.exports = require("fixture");') => loader._loadBundle({ packageId, name: "legacy" }, code, undefined, false, true);
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        try {
+            expect(await load()).toBe(original);
+            const before = await (0, tools_1.Tools)(context).list();
+            bundle = {
+                packageId,
+                tableDefinitions: [{}],
+                toolInstances: [{ tool: { toolId: (0, utils_1.newid)() }, toolFn: jest.fn() }],
+            };
+            expect(await load(`require("@peers-app/peers-sdk").registerContractResolver("${contractId}", 1, () => ({})); module.exports = require("fixture");`)).toBeUndefined();
+            expect(warn).toHaveBeenCalledWith(expect.stringContaining("Failed to evaluate"), expect.stringContaining("ships legacy executable tools"));
+            expect(await (0, tools_1.Tools)(context).list()).toEqual(before);
+            expect(context.tableContainer.registerTableDefinitions).not.toHaveBeenCalled();
+            expect((0, contract_resolvers_1.getContractResolver)(contractId, 1, packageId, context)).toBeUndefined();
+            expect(loader.packageInstances[packageId]).toBe(original);
+        }
+        finally {
+            warn.mockRestore();
+            await loader.dispose();
+        }
+    });
+    it.each([
+        "dependencies",
+        "preparation",
+    ])("unload invalidates a host load waiting on %s", async (boundary) => {
+        const packageId = (0, utils_1.newid)();
+        const contractId = (0, utils_1.newid)();
+        const context = {
+            dataContextId: (0, utils_1.newid)(),
+            tableContainer: { registerTableDefinition: jest.fn() },
+        };
+        const loader = new package_loader_1.PackageLoader(context);
+        const definition = {
+            packageId,
+            version: "1.0.0",
+            contracts: [
+                {
+                    contractId,
+                    version: 1,
+                    name: "Pending",
+                    description: "",
+                    tables: [],
+                    observables: [],
+                    tools: [],
+                },
+            ],
+            consumes: [],
+            alsoImplements: new Map(),
+            assistants: [],
+            appNavs: [],
+            tableDefinitions: [],
+        };
+        loader.require = (() => definition);
+        let release;
+        let entered;
+        const waiting = new Promise((resolve) => {
+            entered = resolve;
+        });
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const hold = async () => {
+            entered();
+            await gate;
+        };
+        const dependencySpy = jest
+            .spyOn(consumedContracts, "resolveConsumedContracts")
+            .mockResolvedValue(undefined);
+        const preparationSpy = jest
+            .spyOn(loader, "correctPackageVersion")
+            .mockResolvedValue(undefined);
+        if (boundary === "dependencies")
+            dependencySpy.mockImplementationOnce(hold);
+        else
+            preparationSpy.mockImplementationOnce(hold);
+        const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+        const load = () => loader._loadBundle({ packageId, name: "Pending" }, 'module.exports.packageDefinition = require("fixture");', undefined, false, false);
+        try {
+            const installing = load();
+            await waiting;
+            const removing = loader.unloadPackage(packageId);
+            if (boundary === "dependencies")
+                await removing;
+            release();
+            await Promise.all([installing, removing]);
+            expect(loader.contractRegistry.getProviderPackageId(contractId, 1)).toBeUndefined();
+            expect(loader.isContractInstalled(packageId)).toBe(false);
+            await load();
+            expect(loader.contractRegistry.getProviderPackageId(contractId, 1)).toBe(packageId);
+        }
+        finally {
+            release();
+            dependencySpy.mockRestore();
+            preparationSpy.mockRestore();
+            warn.mockRestore();
+            await loader.dispose();
+        }
+    });
+});
 describe("PackageLoader.correctPackageVersion", () => {
     const activePvId = "pv-active";
     const pkg = {
@@ -88,8 +636,10 @@ describe("PackageLoader.contractRegistry", () => {
         expect(loaderB.contractRegistry).toBeInstanceOf(registry_1.ContractRegistry);
         expect(loaderA.contractRegistry).not.toBe(loaderB.contractRegistry);
     });
-    it("installs system contracts into each new registry", () => {
+    it("installs system contracts after explicit readiness", async () => {
         const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-system" });
+        expect(loader.contractRegistry.resolve(system_ids_1.logsContractId, 1)).toBeUndefined();
+        await loader.catalogReady;
         expect(loader.contractRegistry.getProviderPackageId(system_ids_1.logsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
         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);
@@ -143,6 +693,51 @@ describe("PackageLoader.contractRegistry", () => {
         expect(resolver).toHaveBeenCalledWith({ dataContext });
         endpoint.dispose();
     });
+    it("checks retained identity evidence even for an unscoped legacy resolver", async () => {
+        const dataContext = { dataContextId: "ctx-legacy-quarantine" };
+        const loader = new package_loader_1.PackageLoader(dataContext);
+        const contractId = (0, utils_1.newid)();
+        const toolFn = jest.fn();
+        (0, contract_resolvers_1.registerContractResolver)(contractId, 1, () => ({
+            contractId,
+            version: 1,
+            tools: { read: { toolFn, tool: {} } },
+        }));
+        const endpoint = await loader.resolveContractEndpoint({
+            contractId,
+            version: 1,
+            context: {},
+            notify: async () => undefined,
+        });
+        const toolId = (0, tool_catalog_identity_1.deriveToolCatalogId)({ contractId, version: 1, toolName: "read" });
+        await (0, tools_1.Tools)(dataContext).save({
+            toolId,
+            contractId,
+            contractVersion: 1,
+            toolName: "read",
+            name: "read",
+            usageDescription: "",
+            code: "",
+            inputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
+            outputSchema: { type: tools_1.IOSchemaType.none, fields: [] },
+            catalogState: "quarantined",
+        });
+        try {
+            await expect(endpoint.handleCall({
+                contractId,
+                version: 1,
+                member: "tool",
+                name: "read",
+                operation: "run",
+                args: [],
+            })).rejects.toThrow(/Quarantined/);
+            expect(toolFn).not.toHaveBeenCalled();
+        }
+        finally {
+            endpoint.dispose();
+            await loader.dispose();
+        }
+    });
     it("does not supply local identity to ordinary callers that omit it", async () => {
         const userId = (0, utils_1.newid)();
         const dataContext = {
@@ -252,7 +847,90 @@ describe("PackageLoader isolated artifacts", () => {
         (0, isolated_runtime_1.setIsolatedPackageRuntimeFactory)(() => runtime);
         return runtime;
     }
-    it("installs a valid isolated artifact without evaluating provider source", async () => {
+    it.each([
+        "unload",
+        "dispose",
+    ])("%s invalidates isolated loads awaiting dev version correction", async (action) => {
+        const runtime = makeRuntime();
+        const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
+        let release;
+        let entered;
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const waiting = new Promise((resolve) => {
+            entered = resolve;
+        });
+        mockSignAndSave.mockImplementationOnce(async () => {
+            entered();
+            await gate;
+        });
+        const load = () => loader._loadBundle(pkg, (0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact), selectedVersion({ version: "0.0.1", versionTag: "dev" }), true, true);
+        try {
+            const installing = load();
+            await waiting;
+            if (action === "unload")
+                await loader.unloadPackage(packageId);
+            else
+                await loader.dispose();
+            release();
+            await expect(installing).rejects.toThrow(/invalidated|disposed/);
+            expect(runtime.install).not.toHaveBeenCalled();
+            expect(runtime.replace).not.toHaveBeenCalled();
+            expect(runtime.isInstalled(packageId)).toBe(false);
+            expect(loader.isIsolatedInstalled(packageId)).toBe(false);
+            expect(loader.isContractInstalled(packageId)).toBe(false);
+            if (action === "unload") {
+                await load();
+                expect(runtime.isInstalled(packageId)).toBe(true);
+            }
+        }
+        finally {
+            release();
+            await loader.dispose();
+        }
+    });
+    it("does not restore activation bookkeeping when unload overlaps an isolated install", async () => {
+        const runtime = makeRuntime();
+        const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
+        let release;
+        let entered;
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const waiting = new Promise((resolve) => {
+            entered = resolve;
+        });
+        const install = runtime.install.getMockImplementation();
+        if (!install)
+            throw new Error("Missing runtime install fixture");
+        runtime.install.mockImplementationOnce(async (next) => {
+            const result = await install(next);
+            entered();
+            await gate;
+            return result;
+        });
+        const installing = loader._loadBundle(pkg, (0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact), selectedVersion(), false, true);
+        try {
+            await waiting;
+            await loader.unloadPackage(packageId);
+            release();
+            await expect(installing).rejects.toThrow(/invalidated/);
+            expect(loader.isIsolatedInstalled(packageId)).toBe(false);
+            expect(loader.isContractInstalled(packageId)).toBe(false);
+            expect(runtime.isInstalled(packageId)).toBe(false);
+        }
+        finally {
+            release();
+            await loader.dispose();
+        }
+    });
+    it.each([
+        undefined,
+        "sandbox",
+        "privileged",
+    ])("installs executionMode=%s without host evaluation", async (executionMode) => {
+        artifact.manifest.executionMode = executionMode;
         const runtime = makeRuntime();
         mockGet.mockResolvedValue(selectedVersion());
         mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
@@ -405,6 +1083,21 @@ describe("PackageLoader isolated artifacts", () => {
         await expect(loader.loadPackage(pkg)).rejects.toThrow(/JSON is invalid/);
         expect(globalThis.__shouldNotEvalOnHost).toBeUndefined();
     });
+    it.each([
+        null,
+        true,
+        "unknown",
+    ])("fails closed on malformed executionMode=%p", async (executionMode) => {
+        const runtime = makeRuntime();
+        mockGet.mockResolvedValue(selectedVersion());
+        const malformed = structuredClone(artifact);
+        Object.assign(malformed.manifest, { executionMode });
+        mockGetFileContents.mockResolvedValue(Buffer.from(`PEERS_ISOLATED_PACKAGE_V1\n${JSON.stringify(malformed)}`));
+        const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-bad-mode" });
+        await expect(loader.loadPackage(pkg)).rejects.toThrow(/executionMode/);
+        expect(runtime.install).not.toHaveBeenCalled();
+        expect(globalThis.__shouldNotEvalOnHost).toBeUndefined();
+    });
     it("passes gateways and a trusted local identity resolver from its data context", () => {
         const factory = jest.fn((_options) => ({
             install: jest.fn(async () => ({ packageId, provided: [], consumes: [] })),