@peers-app/peers-sdk 0.27.3 → 0.27.5

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

@@ -1,1764 +0,0 @@
-"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}`);
-jest.mock("../data/package-versions", () => ({
-    PackageVersions: () => ({
-        get: (...args) => mockGet(...args),
-        signAndSave: (...args) => mockSignAndSave(...args),
-    }),
-    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 remote_contract_transport_1 = require("../contracts/remote-contract-transport");
-const device_operations_contract_1 = require("../contracts/system/device-operations-contract");
-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");
-test("legacy catalog projection follows the dispatcher's declarations and selected provider", async () => {
-    const context = { dataContextId: (0, utils_1.newid)() };
-    const loader = new package_loader_1.PackageLoader(context);
-    const caller = (0, utils_1.newid)();
-    const provider = (0, utils_1.newid)();
-    const other = (0, utils_1.newid)();
-    const contractId = (0, utils_1.newid)();
-    const definition = {
-        contractId,
-        version: 1,
-        name: "Target",
-        description: "",
-        tools: [],
-        tables: [],
-        observables: [],
-        events: [],
-    };
-    const principal = {
-        userId: (0, utils_1.newid)(),
-        userAccessLevel: 40,
-        callingToolAccessLevel: 20,
-    };
-    const target = { contractId, version: 1, providerPackageId: provider };
-    try {
-        await loader.catalogReady;
-        loader.contractRegistry.register(provider, definition);
-        loader.contractRegistry.register(other, definition);
-        expect(loader.hostToolPrincipal(principal, caller, target)).toBeUndefined();
-        loader.hostConsumes.set(caller, [
-            { contractId, version: 1, providerPackageIds: [provider] },
-        ]);
-        expect(loader.hostToolPrincipal(principal, caller, target)).toMatchObject({
-            assistantAccessLevel: 20,
-            strictActionScope: true,
-        });
-        expect(loader.hostToolPrincipal(principal, caller, { ...target, providerPackageId: other })).toBeUndefined();
-        expect(loader.hostToolPrincipal({ ...principal, userId: undefined }, caller, target)).toBeUndefined();
-        // A provider can reach its own contract without declaring a consume.
-        expect(loader.hostToolPrincipal(principal, provider, target)).toMatchObject({
-            assistantAccessLevel: 20,
-        });
-        expect(loader.hostToolPrincipal(principal, provider, { ...target, providerPackageId: other })).toBeUndefined();
-    }
-    finally {
-        await loader.dispose();
-    }
-});
-describe("host load invalidation", () => {
-    it("retains legacy package identity and refuses system calls before forwarding", async () => {
-        const packageId = (0, utils_1.newid)();
-        const context = { dataContextId: (0, utils_1.newid)() };
-        const loader = new package_loader_1.PackageLoader(context);
-        Object.assign(context, { packageLoader: loader });
-        const emit = jest.fn(async () => "must not execute");
-        (0, remote_contract_transport_1.setRemoteContractTransportFactory)(() => ({ emit, on: () => () => { } }));
-        const definition = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = packageId;
-            pkg.version = "1.0.0";
-            pkg.remote(system_ids_1.deviceOperationsContractId, 1);
-        });
-        try {
-            await loader.catalogReady;
-            loader.contractRegistry.register(system_ids_1.peersSystemPackageId, (0, device_operations_contract_1.getDeviceOperationsContractDefinition)());
-            await consumedContracts.resolveConsumedContracts(context, loader.contractRegistry, definition);
-            const remote = (await definition.remotes?.[0].handle
-                ?.consumer);
-            await expect(remote.device((0, utils_1.newid)()).tools.getDeviceStatus()).rejects.toThrow("packages cannot call system contract");
-            expect(emit).not.toHaveBeenCalled();
-            remote.dispose();
-        }
-        finally {
-            (0, remote_contract_transport_1.setRemoteContractTransportFactory)(undefined);
-            await loader.dispose();
-        }
-    });
-    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 }, (0, utils_1.newid)());
-            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 = {
-        packageId: "pkg-1",
-        name: "Test Package",
-        activePackageVersionId: activePvId,
-    };
-    const def = { version: "0.3.6" };
-    let loader;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockSignAndSave.mockResolvedValue(undefined);
-        loader = new package_loader_1.PackageLoader({ dataContextId: "ctx" });
-    });
-    async function correctPackageVersion(selectedPackageVersion) {
-        await loader.correctPackageVersion(pkg, selectedPackageVersion, def.version);
-    }
-    it("updates the active PV hash and clears a stale author signature", async () => {
-        await correctPackageVersion({
-            packageVersionId: activePvId,
-            version: "0.3.1",
-            versionTag: "dev",
-            packageBundleFileHash: "bundle-hash",
-            routesBundleFileHash: "routes-hash",
-            uiBundleFileHash: "ui-hash",
-            packageAuthorSignature: "stale-sig",
-            packageVersionHash: "old-hash",
-        });
-        expect(mockComputePackageVersionHash).toHaveBeenCalledWith("0.3.6", "dev", "bundle-hash", "routes-hash", "ui-hash");
-        expect(mockSignAndSave).toHaveBeenCalledWith(expect.objectContaining({
-            packageVersionId: activePvId,
-            version: "0.3.6",
-            versionTag: "dev",
-            packageVersionHash: "hash-0.3.6-bundle-hash",
-        }));
-        expect(mockSignAndSave.mock.calls[0][0].packageAuthorSignature).toBeUndefined();
-    });
-    it("does not update the active PV when it is stable", async () => {
-        await correctPackageVersion({
-            packageVersionId: activePvId,
-            version: "0.3.5",
-            versionTag: "stable",
-        });
-        expect(mockSignAndSave).not.toHaveBeenCalled();
-    });
-    it("does not update the active PV when it is beta", async () => {
-        await correctPackageVersion({
-            packageVersionId: activePvId,
-            version: "0.3.5",
-            versionTag: "beta",
-        });
-        expect(mockSignAndSave).not.toHaveBeenCalled();
-    });
-    it("does nothing when the active PV version already matches", async () => {
-        await correctPackageVersion({
-            packageVersionId: activePvId,
-            version: "0.3.6",
-            versionTag: "dev",
-        });
-        expect(mockSignAndSave).not.toHaveBeenCalled();
-    });
-});
-describe("PackageLoader.contractRegistry", () => {
-    it("owns an in-memory ContractRegistry per loader instance", () => {
-        const loaderA = new package_loader_1.PackageLoader({ dataContextId: "ctx-a" });
-        const loaderB = new package_loader_1.PackageLoader({ dataContextId: "ctx-b" });
-        expect(loaderA.contractRegistry).toBeInstanceOf(registry_1.ContractRegistry);
-        expect(loaderB.contractRegistry).toBeInstanceOf(registry_1.ContractRegistry);
-        expect(loaderA.contractRegistry).not.toBe(loaderB.contractRegistry);
-    });
-    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);
-    });
-    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();
-    });
-    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 = {
-            dataContextId: userId,
-            userContext: { userId, deviceId: () => "local-device" },
-        };
-        const loader = new package_loader_1.PackageLoader(dataContext);
-        const contractId = (0, utils_1.newid)();
-        const write = jest.fn();
-        (0, contract_resolvers_1.registerContractResolver)(contractId, 1, () => ({
-            contractId,
-            version: 1,
-            tools: {
-                invoke: {
-                    tool: { toolId: (0, utils_1.newid)(), name: "invoke", accessLevel: access_level_1.AccessLevel.Writer },
-                    toolFn: write,
-                },
-            },
-        }));
-        const endpoint = await loader.resolveContractEndpoint({
-            contractId,
-            version: 1,
-            context: {},
-            notify: async () => undefined,
-        });
-        try {
-            await expect(endpoint.handleCall({
-                contractId,
-                version: 1,
-                member: "tool",
-                name: "invoke",
-                operation: "run",
-                args: [],
-            })).rejects.toThrow("missing caller identity or trusted context for tool 'invoke'");
-            expect(write).not.toHaveBeenCalled();
-        }
-        finally {
-            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: [] };
-            }),
-            updateContractLifecycle: jest.fn(async () => { }),
-            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.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)));
-        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.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: [] })),
-            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 = {
-            userId: (0, utils_1.newid)(),
-            userDataContext: dataContext,
-        };
-        new package_loader_1.PackageLoader(dataContext);
-        expect(factory).toHaveBeenCalledWith(expect.objectContaining({
-            dataContextId: "ctx-tables",
-            getLocalUserContext: expect.any(Function),
-            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),
-            }),
-        }));
-        const resolveLocalUser = factory.mock.calls[0][0].getLocalUserContext;
-        expect(resolveLocalUser?.()).toEqual({ userId: dataContext.userContext.userId, dataContext });
-        expect(resolveLocalUser?.()?.dataContext).toBe(dataContext);
-        dataContext.userContext = undefined;
-        expect(resolveLocalUser?.()).toBeUndefined();
-    });
-    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();
-        Object.assign(runtime, {
-            getPackageHealth: () => ({
-                workerRunning: false,
-                lastWorkerError: { message: "old worker", at: 1 },
-            }),
-        });
-        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);
-        expect(loader.runtimeStates()[packageId].worker).toBeUndefined();
-        expect(loader.getPackageRuntimeState(packageId)?.worker).toBeUndefined();
-    });
-    describe("runtime state", () => {
-        beforeEach(() => {
-            // An earlier executionMode case leaves the shared artifact privileged.
-            delete artifact.manifest.executionMode;
-        });
-        it("records running state with the runtime's provides and consumes", async () => {
-            const runtime = makeRuntime();
-            const provided = [{ contractId, version: 1 }];
-            const consumes = [{ contractId: (0, utils_1.newid)(), version: 2, optional: true, satisfied: false }];
-            runtime.install.mockImplementationOnce((async (next) => ({
-                packageId: next.manifest.packageId,
-                provided,
-                consumes,
-            })));
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-running" });
-            const seen = [];
-            loader.runtimeStates.subscribe((states) => seen.push(states[packageId]?.status));
-            await loader.loadPackage(pkg);
-            expect(loader.getPackageRuntimeState(packageId)).toEqual({
-                packageId,
-                status: "running",
-                running: {
-                    packageVersionId: pkg.activePackageVersionId,
-                    version: "1.0.0",
-                    versionTag: "stable",
-                    kind: "isolated",
-                    executionMode: "sandbox",
-                    provides: provided,
-                    consumes,
-                },
-                updatedAt: expect.any(Number),
-            });
-            expect(seen).toContain("running");
-            await loader.dispose();
-            expect(loader.getPackageRuntimeStates()).toEqual({});
-        });
-        it("keeps the running build on an onlyIfChanged load and reloads a changed one", async () => {
-            const runtime = makeRuntime();
-            mockGet.mockResolvedValue(selectedVersion({ versionTag: "dev" }));
-            mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
-            try {
-                const first = await loader.loadPackage(pkg);
-                expect(runtime.install).toHaveBeenCalledTimes(1);
-                await expect(loader.loadPackage(pkg, { force: true, onlyIfChanged: true })).resolves.toBe(first);
-                expect(runtime.replace).not.toHaveBeenCalled();
-                // A promotion changes only the tag, which is not part of the bundle.
-                mockGet.mockResolvedValue(selectedVersion({ versionTag: "beta" }));
-                await loader.loadPackage(pkg, { force: true, onlyIfChanged: true });
-                expect(runtime.replace).not.toHaveBeenCalled();
-                expect(loader.getPackageRuntimeState(packageId)?.running?.versionTag).toBe("beta");
-                mockGet.mockResolvedValue(selectedVersion({ versionTag: "stable" }));
-                await loader.loadPackage(pkg, { force: true, onlyIfChanged: true });
-                expect(runtime.updateContractLifecycle).toHaveBeenLastCalledWith(packageId, expect.objectContaining({ contractLifecycle: "stable", versionTag: "stable" }));
-                expect(runtime.replace).not.toHaveBeenCalled();
-                mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)({
-                    ...artifact,
-                    providerSource: `${artifact.providerSource}\n// rebuilt`,
-                })));
-                await loader.loadPackage(pkg, { force: true, onlyIfChanged: true });
-                expect(runtime.replace).toHaveBeenCalledTimes(1);
-                await loader.loadPackage(pkg, { force: true });
-                expect(runtime.replace).toHaveBeenCalledTimes(2);
-            }
-            finally {
-                await loader.dispose();
-            }
-        });
-        it.each([
-            "unload",
-            "dispose",
-            "replace",
-        ])("does not overwrite %s while an unchanged-build comparison is pending", async (action) => {
-            const runtime = makeRuntime();
-            mockGet.mockResolvedValue(selectedVersion({ versionTag: "dev" }));
-            const bundle = Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact));
-            mockGetFileContents.mockResolvedValue(bundle);
-            const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
-            let release;
-            let entered;
-            const waiting = new Promise((resolve) => {
-                entered = resolve;
-            });
-            const pendingRead = new Promise((resolve) => {
-                release = resolve;
-            });
-            try {
-                await loader.loadPackage(pkg);
-                mockGet.mockResolvedValue(selectedVersion({ versionTag: "beta" }));
-                mockGetFileContents.mockImplementationOnce(() => {
-                    entered();
-                    return pendingRead;
-                });
-                const pending = loader.loadPackage(pkg, { force: true, onlyIfChanged: true });
-                await waiting;
-                if (action === "replace") {
-                    mockGet.mockResolvedValue(selectedVersion({ versionTag: "stable" }));
-                    await loader.loadPackage(pkg, { force: true });
-                }
-                else if (action === "unload") {
-                    await loader.unloadPackage(packageId);
-                }
-                else {
-                    await loader.dispose();
-                }
-                const latest = loader.getPackageRuntimeState(packageId);
-                release(bundle);
-                await expect(pending).resolves.toBeUndefined();
-                expect(loader.getPackageRuntimeState(packageId)).toEqual(latest);
-                expect(runtime.updateContractLifecycle).not.toHaveBeenCalled();
-                expect(runtime.install).toHaveBeenCalledTimes(1);
-                expect(runtime.replace).toHaveBeenCalledTimes(action === "replace" ? 1 : 0);
-            }
-            finally {
-                release(bundle);
-                await loader.dispose();
-            }
-        });
-        it("validates a changed version label even when its bundle is unchanged", async () => {
-            makeRuntime();
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
-            try {
-                await loader.loadPackage(pkg);
-                mockGet.mockResolvedValue(selectedVersion({ version: "2.0.0" }));
-                await expect(loader.loadPackage(pkg, { force: true, onlyIfChanged: true })).rejects.toThrow(/version mismatch/);
-                expect(loader.getPackageRuntimeState(packageId)?.running?.version).toBe("1.0.0");
-            }
-            finally {
-                await loader.dispose();
-            }
-        });
-        it("keeps the previous running version when a replacement fails", 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-state-replace" });
-            await loader.loadPackage(pkg);
-            runtime.replace.mockRejectedValueOnce(new Error("replacement rejected"));
-            await expect(loader.loadPackage(pkg, { force: true })).rejects.toThrow(/replacement rejected/);
-            const state = loader.getPackageRuntimeState(packageId);
-            expect(state?.status).toBe("failed");
-            expect(state?.running?.version).toBe("1.0.0");
-            expect(state?.lastError).toEqual({
-                phase: "load",
-                message: "replacement rejected",
-                packageVersionId: pkg.activePackageVersionId,
-                version: "1.0.0",
-                at: expect.any(Number),
-            });
-            await loader.loadPackage(pkg, { force: true });
-            expect(loader.getPackageRuntimeState(packageId)?.status).toBe("running");
-            expect(loader.getPackageRuntimeState(packageId)?.lastError).toBeUndefined();
-        });
-        it("records a malformed isolated envelope as a failed load", async () => {
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from("PEERS_ISOLATED_PACKAGE_V1\n{nope"));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-malformed" });
-            await expect(loader.loadPackage(pkg)).rejects.toThrow(/JSON is invalid/);
-            const state = loader.getPackageRuntimeState(packageId);
-            expect(state?.status).toBe("failed");
-            expect(state?.running).toBeUndefined();
-            expect(state?.lastError?.message).toMatch(/JSON is invalid/);
-        });
-        it("records a failed legacy evaluation", async () => {
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from("throw new Error('legacy failed');"));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-legacy" });
-            try {
-                await expect(loader.loadPackage(pkg)).resolves.toBeUndefined();
-                expect(loader.getPackageRuntimeState(packageId)).toMatchObject({
-                    status: "failed",
-                    lastError: { phase: "load", message: "legacy failed" },
-                });
-            }
-            finally {
-                warn.mockRestore();
-            }
-        });
-        it.each([
-            "module.exports = 42;",
-            "// No exports",
-            "module.exports = {};",
-            "module.exports = { default: {} };",
-        ])("records unusable legacy exports as a failed load: %s", async (bundle) => {
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from(bundle));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-empty" });
-            try {
-                await expect(loader.loadPackage(pkg)).resolves.toBeUndefined();
-                expect(loader.getPackageRuntimeState(packageId)).toMatchObject({
-                    status: "failed",
-                    lastError: { phase: "load", message: "Package bundle exports nothing usable" },
-                });
-            }
-            finally {
-                warn.mockRestore();
-            }
-        });
-        it("keeps the previous package when a replacement exports nothing", async () => {
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from(`module.exports = { packageId: "${packageId}" };`));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
-            try {
-                const previous = await loader.loadPackage(pkg);
-                const running = loader.getPackageRuntimeState(packageId)?.running;
-                mockGetFileContents.mockResolvedValue(Buffer.from("// No exports"));
-                await expect(loader.loadPackage(pkg, { force: true })).resolves.toBeUndefined();
-                expect(loader.getPackageRuntimeState(packageId)).toMatchObject({
-                    status: "failed",
-                    running,
-                    lastError: { message: "Package bundle exports nothing usable" },
-                });
-                await expect(loader.loadPackage(pkg)).resolves.toBe(previous);
-            }
-            finally {
-                warn.mockRestore();
-                await loader.dispose();
-            }
-        });
-        it("records unsupported when the host has no isolated runtime", 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-state-unsupported" });
-            try {
-                await loader.loadPackage(pkg);
-                expect(loader.getPackageRuntimeState(packageId)).toMatchObject({
-                    status: "unsupported",
-                    reason: expect.stringMatching(/no isolated package runtime/),
-                });
-            }
-            finally {
-                warn.mockRestore();
-            }
-        });
-        it("records unavailable when the selected bundle is not on this device", async () => {
-            const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
-            makeRuntime();
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(undefined);
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-unavailable" });
-            try {
-                await expect(loader.loadPackage(pkg)).resolves.toBeUndefined();
-                expect(loader.getPackageRuntimeState(packageId)).toMatchObject({
-                    status: "unavailable",
-                    reason: expect.stringMatching(/not on this device/),
-                });
-            }
-            finally {
-                warn.mockRestore();
-            }
-        });
-        it("records disabled and unloaded packages without a running version", async () => {
-            makeRuntime();
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-disabled" });
-            await loader.loadPackage(pkg);
-            await loader.loadPackage({ ...pkg, disabled: true });
-            expect(loader.getPackageRuntimeState(packageId)).toEqual({
-                packageId,
-                status: "disabled",
-                reason: expect.any(String),
-                updatedAt: expect.any(Number),
-            });
-            await loader.unloadPackage(packageId, { reason: "uninstalled" });
-            expect(loader.getPackageRuntimeState(packageId)).toEqual({
-                packageId,
-                status: "unloaded",
-                reason: "uninstalled",
-                updatedAt: expect.any(Number),
-            });
-        });
-        it("does not let a superseded load overwrite newer state", async () => {
-            const runtime = makeRuntime();
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-superseded" });
-            let release;
-            let entered;
-            const gate = new Promise((resolve) => {
-                release = resolve;
-            });
-            const waiting = new Promise((resolve) => {
-                entered = resolve;
-            });
-            mockSignAndSave.mockImplementationOnce(async () => {
-                entered();
-                await gate;
-            });
-            mockGet.mockResolvedValue(selectedVersion({ version: "0.0.1", versionTag: "dev" }));
-            mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
-            const reading = jest.fn(() => (0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact));
-            loader._readLocalBundle = reading;
-            try {
-                const installing = loader.loadPackage(pkg, { force: true, localPath: "/pkg" });
-                await waiting;
-                await loader.unloadPackage(packageId);
-                release();
-                await expect(installing).rejects.toThrow(/invalidated/);
-                expect(runtime.install).not.toHaveBeenCalled();
-                expect(loader.getPackageRuntimeState(packageId)?.status).toBe("unloaded");
-                expect(loader.getPackageRuntimeState(packageId)?.lastError).toBeUndefined();
-            }
-            finally {
-                release();
-                await loader.dispose();
-            }
-        });
-        it("publishes isolated worker health and detaches on disposal", async () => {
-            const runtime = makeRuntime();
-            let health = {
-                workerRunning: false,
-            };
-            let notify;
-            const unsubscribe = jest.fn();
-            Object.assign(runtime, {
-                getPackageHealth: jest.fn(() => health),
-                subscribePackageHealth: (listener) => {
-                    notify = listener;
-                    return unsubscribe;
-                },
-            });
-            mockGet.mockResolvedValue(selectedVersion());
-            mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
-            const loader = new package_loader_1.PackageLoader({ dataContextId: "ctx-state-health" });
-            await loader.loadPackage(pkg);
-            const seen = [];
-            loader.runtimeStates.subscribe((states) => seen.push(states[packageId]?.worker));
-            health = { workerRunning: false, lastWorkerError: { message: "boom", at: 1 } };
-            notify(packageId);
-            expect(loader.getPackageRuntimeState(packageId)?.worker).toEqual(health);
-            expect(loader.getPackageRuntimeStates()[packageId]?.worker).toEqual(health);
-            expect(loader.runtimeStates()[packageId]?.worker).toEqual(health);
-            expect(seen).toContainEqual(health);
-            await loader.dispose();
-            expect(unsubscribe).toHaveBeenCalledTimes(1);
-            notify(packageId);
-            expect(loader.runtimeStates()).toEqual({});
-        });
-        it.each([
-            "failure",
-            "unavailable",
-        ])("ignores an older load's late %s after a newer load", async (outcome) => {
-            makeRuntime();
-            mockGet.mockResolvedValue(selectedVersion());
-            let finish;
-            let fail;
-            const pending = new Promise((resolve, reject) => {
-                finish = resolve;
-                fail = reject;
-            });
-            mockGetFileContents.mockReturnValueOnce(pending);
-            const loader = new package_loader_1.PackageLoader({ dataContextId: (0, utils_1.newid)() });
-            const older = loader.loadPackage(pkg, { force: true });
-            // Let the older load start its file read before the newer attempt.
-            await Promise.resolve();
-            mockGetFileContents.mockResolvedValue(Buffer.from((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)));
-            await loader.loadPackage(pkg, { force: true });
-            if (outcome === "failure")
-                fail(new Error("old failure"));
-            else
-                finish(undefined);
-            await older;
-            expect(loader.getPackageRuntimeState(packageId)?.status).toBe("running");
-            expect(loader.getPackageRuntimeState(packageId)?.lastError).toBeUndefined();
-            await loader.dispose();
-        });
-    });
-});