@peers-app/peers-sdk 0.27.3 → 0.27.5

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

@@ -1,688 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const access_level_1 = require("../data/access-level");
-const field_type_1 = require("../types/field-type");
-const utils_1 = require("../utils");
-const isolated_artifact_1 = require("./isolated-artifact");
-function makeArtifact(overrides = {}) {
-    const packageId = (0, utils_1.newid)();
-    const contractId = (0, utils_1.newid)();
-    return {
-        packageId,
-        contractId,
-        artifact: {
-            manifest: {
-                packageId,
-                version: "1.0.0",
-                provides: [
-                    {
-                        contractId,
-                        version: 1,
-                        name: "Greeter",
-                        description: "Hello",
-                        tools: [
-                            {
-                                name: "greet",
-                                usageDescription: "Say hello",
-                                inputFields: [{ name: "name", type: field_type_1.FieldType.string, optional: true }],
-                                outputFields: [{ name: "greeting", type: field_type_1.FieldType.string }],
-                                suggestedAccessLevel: access_level_1.AccessLevel.Writer,
-                            },
-                        ],
-                    },
-                ],
-                consumes: [],
-                tables: [],
-            },
-            providerSource: "registerContractTool('x', 1, 'greet', function () {})",
-            ...overrides,
-        },
-    };
-}
-describe("isolated package artifact", () => {
-    test.each([
-        undefined,
-        "sandbox",
-        "privileged",
-    ])("round-trips executionMode=%s without changing the legacy envelope", (executionMode) => {
-        const { artifact } = makeArtifact();
-        if (executionMode !== undefined)
-            artifact.manifest.executionMode = executionMode;
-        const bundle = (0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact);
-        const parsed = (0, isolated_artifact_1.parseIsolatedPackageArtifact)(bundle);
-        expect(parsed.manifest.executionMode).toBe(executionMode);
-        expect((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(parsed)).toBe(bundle);
-        if (executionMode === undefined)
-            expect(bundle).not.toContain("executionMode");
-    });
-    test.each([
-        null,
-        true,
-        false,
-        1,
-        "",
-        "node",
-        "Privileged",
-        {},
-        [],
-    ])("rejects malformed executionMode=%p at validation and parse time", (executionMode) => {
-        const { artifact } = makeArtifact();
-        Object.assign(artifact.manifest, { executionMode });
-        const bundle = `${isolated_artifact_1.ISOLATED_PACKAGE_MAGIC}\n${JSON.stringify(artifact)}\n`;
-        expect((0, isolated_artifact_1.looksLikeIsolatedPackageArtifact)(bundle)).toBe(true);
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/executionMode/);
-        expect(() => (0, isolated_artifact_1.parseIsolatedPackageArtifact)(bundle)).toThrow(/executionMode/);
-        expect(() => (0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)).toThrow(/executionMode/);
-    });
-    test("round-trips a generic authority request and rejects unknown modes", () => {
-        const { artifact } = makeArtifact();
-        const tool = artifact.manifest.provides[0].tools[0];
-        tool.authorityPropagation = "preserve";
-        expect(() => (0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)).not.toThrow();
-        expect((0, isolated_artifact_1.parseIsolatedPackageArtifact)((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)).manifest.provides[0]
-            .tools[0]).toMatchObject({ authorityPropagation: "preserve" });
-        tool.authorityPropagation = "elevate";
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/authorityPropagation/);
-    });
-    test("serializes and parses a valid envelope", () => {
-        const { artifact, contractId } = makeArtifact();
-        const bundle = (0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact);
-        expect(bundle.startsWith(`${isolated_artifact_1.ISOLATED_PACKAGE_MAGIC}\n`)).toBe(true);
-        expect((0, isolated_artifact_1.looksLikeIsolatedPackageArtifact)(bundle)).toBe(true);
-        expect((0, isolated_artifact_1.looksLikeIsolatedPackageArtifact)("module.exports = {}")).toBe(false);
-        const parsed = (0, isolated_artifact_1.parseIsolatedPackageArtifact)(bundle);
-        expect(parsed.manifest.packageId).toBe(artifact.manifest.packageId);
-        expect(parsed.manifest.provides[0].tools[0].inputFields).toEqual([
-            { name: "name", type: field_type_1.FieldType.string, optional: true },
-        ]);
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(parsed.manifest.provides[0], parsed.manifest.tables ?? []);
-        expect(definition.contractId).toBe(contractId);
-        expect(definition.tools[0].name).toBe("greet");
-        expect(definition.tables).toEqual([]);
-    });
-    test("defaults omitted tables to an empty array", () => {
-        const { artifact } = makeArtifact();
-        delete artifact.manifest.tables;
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        expect(manifest.tables).toEqual([]);
-    });
-    test("keeps a private tool out of the public contract definition", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].tools.push({
-            name: "private-write",
-            usageDescription: "Internal write",
-            private: true,
-            suggestedAccessLevel: access_level_1.AccessLevel.Writer,
-        });
-        const validated = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        expect((0, isolated_artifact_1.isolatedContractToDefinition)(validated.provides[0], []).tools.map((tool) => tool.name)).toEqual(["greet"]);
-    });
-    test("accepts an older manifest's retired action aliases and ignores them", () => {
-        const { artifact, contractId } = makeArtifact();
-        const old = artifact.manifest;
-        old.actionAliases = [
-            { name: "write", target: { contractId, version: 1, toolName: "missing" } },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
-        expect(() => (0, isolated_artifact_1.parseIsolatedPackageArtifact)((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact))).not.toThrow();
-        old.actionAliases = "not even an array";
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
-    });
-    test("accepts a package-private table without adding it to the contract definition", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                description: "Owned state",
-                primaryKeyName: "stateId",
-                fields: [
-                    { name: "stateId", type: field_type_1.FieldType.id },
-                    { name: "count", type: field_type_1.FieldType.number },
-                ],
-            },
-        ];
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        expect(manifest.tables?.[0].versionNumber).toBe(1);
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], manifest.tables ?? []);
-        expect(definition.tables).toEqual([]);
-    });
-    test("maps table references and pvar-backed observables to public contract shapes", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.tables = [
-            {
-                name: "SharedState",
-                description: "Consumer-facing state",
-                primaryKeyName: "stateId",
-                fields: [
-                    { name: "stateId", type: field_type_1.FieldType.id },
-                    { name: "count", type: field_type_1.FieldType.number },
-                ],
-            },
-        ];
-        artifact.manifest.provides[0].tables = [{ name: "SharedState" }];
-        artifact.manifest.provides[0].observables = [
-            {
-                name: "sharedCount",
-                description: "Consumer-facing count",
-                valueType: field_type_1.FieldType.number,
-                writable: true,
-                persistentVar: {
-                    scope: "device",
-                    name: "sharedCount",
-                    defaultValue: 0,
-                },
-            },
-        ];
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], manifest.tables ?? []);
-        expect(definition.tables).toEqual([
-            {
-                name: "SharedState",
-                description: "Consumer-facing state",
-                primaryKeyName: "stateId",
-                fields: [
-                    { name: "stateId", type: field_type_1.FieldType.id },
-                    { name: "count", type: field_type_1.FieldType.number },
-                ],
-            },
-        ]);
-        expect(definition.observables).toEqual([
-            {
-                name: "sharedCount",
-                description: "Consumer-facing count",
-                valueType: field_type_1.FieldType.number,
-                writable: true,
-            },
-        ]);
-    });
-    test("accepts local-only tables and keeps the flag out of the contract shape", () => {
-        const { artifact } = makeArtifact();
-        const fields = [
-            { name: "stateId", type: field_type_1.FieldType.id },
-            { name: "count", type: field_type_1.FieldType.number },
-        ];
-        artifact.manifest.tables = [
-            { name: "DeviceState", primaryKeyName: "stateId", fields, localOnly: true },
-            { name: "SharedState", primaryKeyName: "stateId", fields, localOnly: false },
-        ];
-        artifact.manifest.provides[0].tables = [{ name: "DeviceState" }, { name: "SharedState" }];
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], manifest.tables ?? []);
-        expect(manifest.tables?.[0].localOnly).toBe(true);
-        // Sync policy belongs to the provider's table, not to the contract consumers depend on.
-        expect(definition.tables.map((table) => table.name)).toEqual(["DeviceState", "SharedState"]);
-        for (const table of definition.tables)
-            expect(table).not.toHaveProperty("localOnly");
-    });
-    test("rejects a localOnly flag that isn't a boolean", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                primaryKeyName: "stateId",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
-                localOnly: "yes",
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/localOnly must be a boolean/);
-    });
-    test("accepts guestApi 2 and 3 and rejects other values", () => {
-        for (const guestApi of [2, 3]) {
-            const { artifact } = makeArtifact();
-            artifact.manifest.guestApi = guestApi;
-            expect((0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact).guestApi).toBe(guestApi);
-        }
-        for (const guestApi of [1, "2", 4]) {
-            const { artifact: other } = makeArtifact();
-            other.manifest.guestApi = guestApi;
-            expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(other)).toThrow(/guestApi must be 2 or 3/);
-        }
-    });
-    test.each([true, false, "jobs", null])("rejects the removed serial option (%s)", (serial) => {
-        const { artifact } = makeArtifact();
-        const tool = artifact.manifest.provides[0].tools[0];
-        tool.serial = serial;
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/\.serial is not supported/);
-    });
-    test("rejects malformed isolated tables", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                primaryKeyName: "stateId",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
-                tableId: (0, utils_1.newid)(),
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/must not declare tableId/);
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                primaryKeyName: "stateId",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
-                physicalName: "SystemTable",
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/physicalName/);
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                primaryKeyName: "missing",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/primaryKeyName/);
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                primaryKeyName: "stateId",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.string }],
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/type id/);
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                primaryKeyName: "stateId",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
-            },
-        ];
-        artifact.manifest.provides[0].tables = [
-            {
-                name: "State",
-                primaryKeyName: "stateId",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/only a package table name/);
-    });
-    test("requires table names to be unique inside the package", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.tables = [
-            {
-                name: "State",
-                primaryKeyName: "stateId",
-                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
-            },
-            {
-                name: "State",
-                primaryKeyName: "otherStateId",
-                fields: [{ name: "otherStateId", type: field_type_1.FieldType.id }],
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/duplicate table "State"/);
-    });
-    test("rejects a recognized but malformed envelope", () => {
-        expect(() => (0, isolated_artifact_1.parseIsolatedPackageArtifact)(`${isolated_artifact_1.ISOLATED_PACKAGE_MAGIC}\n{not-json`)).toThrow(/JSON is invalid/);
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)({
-            manifest: {
-                packageId: "not-an-id",
-                version: "1.0.0",
-                provides: [],
-                consumes: [],
-            },
-            providerSource: "x",
-        })).toThrow(/peer id|provide at least one/i);
-    });
-    test("defaults missing tool field arrays", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].tools[0] = {
-            name: "greet",
-            usageDescription: "Say hello",
-        };
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        expect(manifest.provides[0].tools[0].inputFields).toEqual([]);
-        expect(manifest.provides[0].tools[0].outputFields).toEqual([]);
-        expect(manifest.provides[0].tables).toEqual([]);
-        expect(manifest.provides[0].observables).toEqual([]);
-        expect(manifest.provides[0].alsoImplements).toEqual([]);
-    });
-    test("validates and preserves alsoImplements declarations", () => {
-        const { artifact } = makeArtifact();
-        const targetContractId = (0, utils_1.newid)();
-        artifact.manifest.provides[0].alsoImplements = [
-            { contractId: targetContractId, version: 1 },
-            { contractId: targetContractId, version: { from: 2, to: 4 } },
-        ];
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        expect(manifest.provides[0].alsoImplements).toEqual([
-            { contractId: targetContractId, version: 1 },
-            { contractId: targetContractId, version: { from: 2, to: 4 } },
-        ]);
-    });
-    test.each([
-        "range",
-        "id",
-        "version",
-        "shape",
-    ])("rejects a carried target with a mismatched %s", (problem) => {
-        const { artifact } = makeArtifact();
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(artifact.manifest.provides[0], []);
-        definition.contractId = (0, utils_1.newid)();
-        const target = { contractId: definition.contractId, version: 1, definition };
-        artifact.manifest.provides[0].alsoImplements = [target];
-        if (problem === "range")
-            Object.assign(target, { version: { from: 1, to: 2 } });
-        if (problem === "id")
-            definition.contractId = (0, utils_1.newid)();
-        if (problem === "version")
-            definition.version = 2;
-        if (problem === "shape")
-            Object.assign(definition, { tools: null });
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/definition/);
-    });
-    test.each([
-        false,
-        true,
-    ])("rejects a single alias to an explicitly provided version (carried: %p)", (carried) => {
-        const { artifact, contractId } = makeArtifact();
-        const newer = structuredClone(artifact.manifest.provides[0]);
-        newer.version = 3;
-        newer.alsoImplements = [
-            {
-                contractId,
-                version: 1,
-                ...(carried
-                    ? { definition: (0, isolated_artifact_1.isolatedContractToDefinition)(artifact.manifest.provides[0], []) }
-                    : {}),
-            },
-        ];
-        artifact.manifest.provides.push(newer);
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/provides explicitly/);
-    });
-    test("keeps legacy ranges that overlap explicitly provided versions", () => {
-        const { artifact, contractId } = makeArtifact();
-        const newer = structuredClone(artifact.manifest.provides[0]);
-        newer.version = 3;
-        newer.alsoImplements = [{ contractId, version: { from: 1, to: 2 } }];
-        artifact.manifest.provides.push(newer);
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
-    });
-    test.each([
-        "table",
-        "input",
-        "output",
-        "event",
-        "observable",
-    ])("bounds the nesting of a carried %s field", (kind) => {
-        const { artifact } = makeArtifact();
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(artifact.manifest.provides[0], []);
-        definition.contractId = (0, utils_1.newid)();
-        let field = { name: "leaf", type: field_type_1.FieldType.string };
-        for (let depth = 0; depth < isolated_artifact_1.ISOLATED_MAX_FIELD_DEPTH; depth++) {
-            field = { name: "nested", type: field_type_1.FieldType.object, fields: [field] };
-        }
-        if (kind === "input")
-            definition.tools[0].inputFields = [field];
-        if (kind === "output")
-            definition.tools[0].outputFields = [field];
-        if (kind === "table")
-            definition.tables = [
-                { name: "Rows", description: "", primaryKeyName: "id", fields: [field] },
-            ];
-        if (kind === "event")
-            definition.events = [{ name: "changed", description: "", payloadFields: [field] }];
-        if (kind === "observable") {
-            const { name: _name, ...value } = field;
-            definition.observables = [
-                { name: "value", description: "", writable: false, valueType: field_type_1.FieldType.object, value },
-            ];
-        }
-        artifact.manifest.provides[0].alsoImplements = [
-            { contractId: definition.contractId, version: 1, definition },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/nests more than 16 levels/);
-    });
-    test("validates exposes: other provided contracts, kept out of the definition", () => {
-        const { artifact, contractId } = makeArtifact();
-        const hubContractId = (0, utils_1.newid)();
-        artifact.manifest.provides.push({
-            contractId: hubContractId,
-            version: 2,
-            name: "Hub",
-            tools: [],
-            events: [{ name: "alert", description: "Attention." }],
-            exposes: [{ contractId, version: 1 }],
-        });
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(JSON.parse(JSON.stringify(artifact)));
-        expect(manifest.provides[1].exposes).toEqual([{ contractId, version: 1 }]);
-        expect(manifest.provides[0]).not.toHaveProperty("exposes");
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[1], manifest.tables ?? []);
-        expect(definition).not.toHaveProperty("exposes");
-        const withExposes = (exposes) => {
-            const copy = JSON.parse(JSON.stringify(artifact));
-            copy.manifest.provides[1].exposes = exposes;
-            return () => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(copy);
-        };
-        expect(withExposes({ contractId, version: 1 })).toThrow("provides[1].exposes must be an array");
-        expect(withExposes([{ contractId, version: 1, toolName: "greet" }])).toThrow(/provides\[1\]\.exposes\[0\]/);
-        expect(withExposes([{ contractId: "short", version: 1 }])).toThrow(/exposes\[0\]\.contractId/);
-        expect(withExposes([{ contractId, version: 0 }])).toThrow(/exposes\[0\]\.version/);
-        expect(withExposes([{ contractId: hubContractId, version: 2 }])).toThrow("a contract can't expose itself");
-        expect(withExposes([
-            { contractId, version: 1 },
-            { contractId, version: 1 },
-        ])).toThrow("is exposed twice");
-        expect(withExposes([{ contractId, version: 2 }])).toThrow(`provides[1] exposes ${contractId}@2, which the package doesn't provide`);
-    });
-    test("maps declared events to the public contract definition", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].events = [
-            {
-                name: "changed",
-                description: "State changed",
-                payloadFields: [{ name: "count", type: field_type_1.FieldType.number }],
-            },
-            { name: "pinged", description: "No payload" },
-        ];
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        expect(manifest.provides[0].events?.[1].payloadFields).toEqual([]);
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], manifest.tables ?? []);
-        expect(definition.events).toEqual([
-            {
-                name: "changed",
-                description: "State changed",
-                payloadFields: [{ name: "count", type: field_type_1.FieldType.number }],
-            },
-            { name: "pinged", description: "No payload", payloadFields: [] },
-        ]);
-        expect((0, isolated_artifact_1.findProvidedContractEvent)(manifest.provides, definition.contractId, 1, "changed")).toBe(manifest.provides[0].events?.[0]);
-        expect((0, isolated_artifact_1.packageProvidesEvent)(manifest.provides, definition.contractId, 1, "missing")).toBe(false);
-    });
-    test("allows an events-only contract", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].tools = [];
-        artifact.manifest.provides[0].events = [{ name: "changed", description: "State changed" }];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
-        artifact.manifest.provides[0].events = [];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/at least one contract member/);
-    });
-    test("rejects malformed or duplicate events", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].events = [
-            { name: "changed", description: "a" },
-            { name: "changed", description: "b" },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/duplicate event "changed"/);
-        artifact.manifest.provides[0].events = [{ name: "changed" }];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/description is required/);
-        artifact.manifest.provides[0].events = [
-            { name: "changed", description: "a", accessLevel: 50 },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/accessLevel is not supported/);
-        artifact.manifest.provides[0].events = [
-            { name: "changed", description: "a", payloadFields: [{ name: "x", type: "nope" }] },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/type must be a FieldType/);
-    });
-    test("checks nested fields and enum values, and carries them into the contract", () => {
-        const { artifact } = makeArtifact();
-        const tool = artifact.manifest.provides[0].tools[0];
-        tool.inputFields = [
-            { name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"], optional: true },
-            {
-                name: "items",
-                type: field_type_1.FieldType.object,
-                isArray: true,
-                fields: [
-                    { name: "label", type: field_type_1.FieldType.string },
-                    { name: "size", type: field_type_1.FieldType.any, enumValues: [1, "large", true] },
-                ],
-            },
-        ];
-        artifact.manifest.provides[0].observables = [
-            {
-                name: "state",
-                description: "The state.",
-                valueType: field_type_1.FieldType.any,
-                value: {
-                    type: field_type_1.FieldType.object,
-                    optional: true,
-                    fields: [{ name: "on", type: field_type_1.FieldType.boolean }],
-                },
-                writable: false,
-            },
-        ];
-        artifact.manifest.guestApi = 3;
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact, { strict: true });
-        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], []);
-        expect(definition.tools[0].inputFields).toEqual(tool.inputFields);
-        expect(definition.observables[0].value).toEqual({
-            type: field_type_1.FieldType.object,
-            optional: true,
-            fields: [{ name: "on", type: field_type_1.FieldType.boolean }],
-        });
-    });
-    test.each([
-        [{ name: "x", type: field_type_1.FieldType.string, enumValues: [] }, /enumValues must be a non-empty array/],
-        [{ name: "x", type: field_type_1.FieldType.string, enumValues: ["a", 1] }, /enumValues must all be string/],
-        [
-            { name: "x", type: field_type_1.FieldType.number, enumValues: [Number.NaN] },
-            /enumValues must all be number/,
-        ],
-        [{ name: "x", type: field_type_1.FieldType.id, enumValues: ["a"] }, /enumValues must all be id/],
-        [{ name: "x", type: field_type_1.FieldType.string, fields: [] }, /fields is only allowed on object fields/],
-        [
-            { name: "x", type: field_type_1.FieldType.object, fields: [{ name: "", type: field_type_1.FieldType.string }] },
-            /fields\[0\]\.name is required/,
-        ],
-        [{ name: "x", type: field_type_1.FieldType.object, fields: {} }, /fields must be an array/],
-    ])("rejects a malformed field %#", (field, message) => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].tools[0].inputFields = [field];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(message);
-    });
-    test("refuses fields nested deeper than the limit", () => {
-        const nest = (levels) => levels === 1
-            ? { name: "leaf", type: field_type_1.FieldType.string }
-            : { name: `level${levels}`, type: field_type_1.FieldType.object, fields: [nest(levels - 1)] };
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].tools[0].inputFields = [nest(isolated_artifact_1.ISOLATED_MAX_FIELD_DEPTH)];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(structuredClone(artifact))).not.toThrow();
-        artifact.manifest.provides[0].tools[0].inputFields = [
-            nest(isolated_artifact_1.ISOLATED_MAX_FIELD_DEPTH + 1),
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/nests more than 16 levels/);
-    });
-    test("a host drops field keys it doesn't know; the build refuses them", () => {
-        const { artifact } = makeArtifact();
-        const withUnknown = () => {
-            const copy = structuredClone(artifact);
-            copy.manifest.provides[0].tools[0].inputFields = [
-                {
-                    name: "mode",
-                    type: field_type_1.FieldType.object,
-                    format: "future",
-                    fields: [
-                        // As a manifest arrives: JSON.parse makes "__proto__" an own key.
-                        JSON.parse('{"name":"on","type":"boolean","__proto__":{"polluted":true}}'),
-                    ],
-                },
-            ];
-            return copy;
-        };
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(withUnknown());
-        expect(manifest.provides[0].tools[0].inputFields).toEqual([
-            { name: "mode", type: field_type_1.FieldType.object, fields: [{ name: "on", type: field_type_1.FieldType.boolean }] },
-        ]);
-        expect({}.polluted).toBeUndefined();
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(withUnknown(), { strict: true })).toThrow(/inputFields\[0\]\.format is not supported/);
-        // Other manifest objects still refuse unknown keys: they carry policy, not descriptions.
-        const tool = artifact.manifest.provides[0].tools[0];
-        tool.cachePolicy = "forever";
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/cachePolicy is not supported/);
-    });
-    test("rejects unsupported contract features instead of dropping them", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].streams = [];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/streams is not supported/);
-    });
-    test("rejects missing public table references and malformed observable bindings", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].tables = [{ name: "Missing" }];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/undeclared package table/);
-        artifact.manifest.provides[0].tables = [];
-        artifact.manifest.provides[0].observables = [
-            {
-                name: "sharedCount",
-                description: "Shared count",
-                valueType: field_type_1.FieldType.number,
-                writable: true,
-                persistentVar: {
-                    scope: "device",
-                    name: "sharedCount",
-                    defaultValue: "zero",
-                },
-            },
-        ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/must match.*number/);
-        const [observable] = artifact.manifest.provides[0].observables;
-        observable.valueType = field_type_1.FieldType.object;
-        observable.persistentVar = {
-            scope: "device",
-            name: "sharedCount",
-            defaultValue: { callback: () => undefined },
-        };
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/JSON-compatible/);
-    });
-    test("an observable without a persistentVar is held by a guest API 2 worker", () => {
-        const { artifact } = makeArtifact();
-        const status = {
-            name: "status",
-            description: "Current status",
-            valueType: field_type_1.FieldType.string,
-            writable: false,
-        };
-        artifact.manifest.provides[0].observables = [status];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/observables\[0\]\.persistentVar is required unless the package uses guestApi 2/);
-        artifact.manifest.guestApi = 2;
-        expect((0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact).provides[0].observables).toEqual([status]);
-        artifact.manifest.provides[0].observables = [{ ...status, persistentVar: null }];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/persistentVar must be an object/);
-    });
-    test("accepts a network allowlist and rejects a host with a scheme", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.network = {
-            allowedHosts: ["api.openai.com"],
-            credentials: [
-                {
-                    ref: "openai",
-                    secretVar: "openaiApiKey",
-                    header: "Authorization",
-                    format: "Bearer {secret}",
-                },
-            ],
-        };
-        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
-        expect(manifest.network?.allowedHosts).toEqual(["api.openai.com"]);
-        artifact.manifest.network = { allowedHosts: ["https://api.openai.com"] };
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/lowercase hostname/);
-        artifact.manifest.network = { allowedHosts: ["127.0.0.1"] };
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/hostname, not an IP address/);
-    });
-    test("rejects a tool timeout above the cap", () => {
-        const { artifact } = makeArtifact();
-        artifact.manifest.provides[0].tools[0].timeoutMs = 120_001;
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/timeoutMs/);
-    });
-});