@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/define/declare-contract.test.js

@@ -1,573 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const isolated_artifact_1 = require("../package-loader/isolated-artifact");
-const peer_id_1 = require("../peer-id");
-const index_1 = require("./index");
-const manifest_1 = require("./manifest");
-const observables_1 = require("./observables");
-const serve_members_1 = require("./serve-members");
-/** A ctx whose host calls are recorded and answered by `answer`. */
-function fakeContext(answer = () => null) {
-    const calls = [];
-    const ctx = new Proxy({}, {
-        get(_target, method) {
-            return async (...args) => {
-                calls.push([method, ...args]);
-                return answer(method, args);
-            };
-        },
-    });
-    return { ctx, calls };
-}
-const contractId = (0, peer_id_1.newid)();
-const invokeInput = index_1.z.object({
-    tool: index_1.z.string().describe("Catalog tool name."),
-    args: index_1.z.object({}).passthrough().optional().describe("Arguments for that tool."),
-});
-const invokeOutput = index_1.z.object({
-    result: index_1.z.unknown().optional(),
-    speech: index_1.z.string().optional(),
-});
-const catalogSchema = index_1.z.object({ name: index_1.z.string(), slug: index_1.z.string() });
-const alert = (0, index_1.defineEvent)({
-    name: "alert",
-    description: "Something needs attention.",
-    payloadSchema: index_1.z.object({ title: index_1.z.string(), detail: index_1.z.string().optional() }),
-});
-const Notes = (0, index_1.defineTable)({
-    name: "Notes",
-    description: "Notes.",
-    primaryKeyName: "noteId",
-    schema: index_1.z.object({ noteId: index_1.zodPeerId, text: index_1.z.string() }),
-});
-const invokeShape = {
-    name: "invoke",
-    usageDescription: "Run one catalog tool.",
-    accessLevel: index_1.AccessLevel.Reader,
-    authorityPropagation: "preserve",
-    inputSchema: invokeInput,
-    outputSchema: invokeOutput,
-};
-const Skill = (0, index_1.declareContract)({
-    contractId,
-    version: 1,
-    name: "Skill",
-    description: "A skill.",
-    tables: [Notes],
-    tools: [(0, index_1.declareTool)(invokeShape)],
-    observables: [
-        (0, index_1.declareObservable)({ name: "skill", description: "The catalog.", schema: catalogSchema }),
-    ],
-    events: [alert],
-});
-const catalog = (0, index_1.deviceVar)(`skill-${(0, peer_id_1.newid)()}`, { defaultValue: { name: "Timers", slug: "timers" } });
-const handler = async ({ tool }) => ({ speech: tool });
-const packageId = (0, peer_id_1.newid)();
-function manifestOf(contract) {
-    return (0, manifest_1.buildPackageManifest)((0, index_1.definePackage)((pkg) => {
-        pkg.packageId = packageId;
-        pkg.version = "1.0.0";
-        pkg.provides(contract);
-    }));
-}
-describe("declareContract", () => {
-    test("the declaration is a typed reference that can pick a provider", async () => {
-        const { ctx, calls } = fakeContext((method) => method === "callConsumedTool" ? { speech: "ok" } : { name: "Timers", slug: "timers" });
-        const result = await Skill(ctx, { providerPackageId: "p1" }).tools.invoke({ tool: "list" });
-        const speech = result.speech;
-        expect(speech).toBe("ok");
-        const value = await Skill(ctx).observables.skill.get();
-        expect(value?.slug).toBe("timers");
-        await Skill(ctx, { providerPackageId: "p2" }).observables.skill.get();
-        expect(calls).toStrictEqual([
-            ["callConsumedTool", contractId, 1, "invoke", { tool: "list" }, { providerPackageId: "p1" }],
-            ["getConsumedObservable", contractId, 1, "skill"],
-            ["getConsumedObservable", contractId, 1, "skill", { providerPackageId: "p2" }],
-        ]);
-        await expect(Skill(ctx, { providerPackageId: "p1" }).tables.Notes.list()).rejects.toThrow(/can't pick a provider/);
-        expect(() => Skill(ctx, { providerPackageId: 3 })).toThrow(/package id/);
-        for (const providerPackageId of ["", "  "]) {
-            expect(() => Skill(ctx, { providerPackageId })).toThrow(/non-empty package id/);
-        }
-        // @ts-expect-error the skill observable is read-only
-        expect(typeof Skill(ctx).observables.skill.set).toBe("function");
-        // @ts-expect-error invoke needs a tool name
-        void Skill(ctx).tools.invoke({});
-        expect((0, index_1.isContractDeclaration)(Skill)).toBe(true);
-        expect(Skill.declaration.tools.map((tool) => tool.definition.name)).toEqual(["invoke"]);
-    });
-    test("type-only references and implementation helpers accept the declaration's type", async () => {
-        const Literal = (0, index_1.declareContract)({
-            contractId: "00muxgugn6xvs8f2r80ru205t",
-            version: 3,
-            name: "Literal",
-        });
-        (0, index_1.contractRef)(Literal.contractId, Literal.version);
-        // @ts-expect-error the declared id is preserved
-        (0, index_1.contractRef)("00mvhostclient00000000001", 3);
-        // @ts-expect-error the declared version is preserved
-        (0, index_1.contractRef)(Literal.contractId, 4);
-        const implementation = {
-            tools: { invoke: ({ tool }) => ({ speech: tool }) },
-            observables: { skill: catalog },
-        };
-        const implemented = (0, index_1.implementContract)(Skill, implementation);
-        expect(implemented.tools[0].definition.name).toBe("invoke");
-        const Ref = (0, index_1.contractRef)(contractId, 1);
-        const { ctx } = fakeContext(() => ({ speech: "typed" }));
-        const result = await Ref(ctx).tools.invoke({ tool: "list" });
-        const speech = result.speech;
-        expect(speech).toBe("typed");
-        // @ts-expect-error the declared version is 1
-        (0, index_1.contractRef)(contractId, 2);
-        // @ts-expect-error a type-only reference still requires the tool's input
-        void Ref(ctx).tools.invoke({});
-        // @ts-expect-error the observable remains read-only through a type-only reference
-        void Ref(ctx).observables.skill.set;
-        const values = {
-            skill: { name: "Timers", slug: "timers" },
-        };
-        const writable = { skill: false };
-        const rows = { Notes: { noteId: (0, peer_id_1.newid)(), text: "typed" } };
-        const inputs = rows;
-        const payloads = { alert: { title: "typed" } };
-        expect([values.skill.slug, writable.skill, inputs.Notes.text, payloads.alert.title]).toEqual([
-            "timers",
-            false,
-            "typed",
-            "typed",
-        ]);
-    });
-    test("members written inline in the lists keep their names, types, and writability", async () => {
-        const tool = (name, inputSchema) => ({
-            name,
-            usageDescription: "A tool.",
-            accessLevel: index_1.AccessLevel.Reader,
-            inputSchema,
-            outputSchema: index_1.z.object({ ok: index_1.z.boolean() }),
-        });
-        const Inline = (0, index_1.declareContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Inline",
-            tools: [
-                (0, index_1.declareTool)(tool("count", index_1.z.object({ n: index_1.z.number() }))),
-                (0, index_1.declareTool)(tool("label", index_1.z.object({ text: index_1.z.string() }))),
-            ],
-            observables: [
-                (0, index_1.declareObservable)({
-                    name: "level",
-                    description: "Level.",
-                    schema: index_1.z.number(),
-                    writable: true,
-                }),
-                (0, index_1.declareObservable)({ name: "mode", description: "Mode.", schema: index_1.z.string() }),
-            ],
-            events: [
-                (0, index_1.defineEvent)({
-                    name: "counted",
-                    description: "C.",
-                    payloadSchema: index_1.z.object({ n: index_1.z.number() }),
-                }),
-                (0, index_1.defineEvent)({
-                    name: "labeled",
-                    description: "L.",
-                    payloadSchema: index_1.z.object({ t: index_1.z.string() }),
-                }),
-            ],
-        });
-        const { ctx } = fakeContext(() => ({ ok: true }));
-        await Inline(ctx).tools.label({ text: "a" });
-        // @ts-expect-error each tool keeps its own input
-        void Inline(ctx).tools.label({ n: 1 });
-        // @ts-expect-error a name the contract doesn't declare
-        void Inline(ctx).tools.other;
-        // @ts-expect-error a read-only observable stays read-only beside a writable one
-        void Inline(ctx).observables.mode.set;
-        const values = { level: 1, mode: "on" };
-        // @ts-expect-error each observable keeps its own value type
-        values.mode = 1;
-        const payloads = {
-            counted: { n: 1 },
-            labeled: { t: "a" },
-        };
-        // @ts-expect-error each event keeps its own payload
-        payloads.labeled = { n: 1 };
-        // Handlers are typed per tool, and a read-only source may sit beside a writable one.
-        const implemented = (0, index_1.implementContract)(Inline, {
-            tools: {
-                count: ({ n }) => ({ ok: n > 0 }),
-                label: ({ text }) => ({ ok: text.length > 0 }),
-            },
-            observables: { level: (0, index_1.observable)(0), mode: (0, index_1.observable)("on") },
-        });
-        expect(implemented.tools.map((member) => member.definition.name)).toEqual(["count", "label"]);
-        const Defined = (0, index_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Defined",
-            tools: [
-                (0, index_1.defineTool)({
-                    ...tool("count", index_1.z.object({ n: index_1.z.number() })),
-                    handler: ({ n }) => ({ ok: n > 0 }),
-                }),
-            ],
-            observables: [
-                (0, index_1.defineObservable)({
-                    name: "level",
-                    description: "Level.",
-                    schema: index_1.z.number(),
-                    writable: true,
-                    source: (0, index_1.observable)(0),
-                }),
-                (0, index_1.defineObservable)({
-                    name: "mode",
-                    description: "Mode.",
-                    schema: index_1.z.string(),
-                    source: (0, index_1.observable)("on"),
-                }),
-            ],
-        });
-        const Ref = (0, index_1.contractRef)(Defined.contractId, 1);
-        // @ts-expect-error defineContract's inline members keep their names too
-        void Ref(ctx).tools.other;
-        // @ts-expect-error and their writability
-        void Ref(ctx).observables.mode.set;
-    });
-    test("a tools-only reference can still have a tool named declaration", async () => {
-        const Ref = (0, index_1.contractRef)(contractId, 1);
-        const { ctx } = fakeContext(() => ({ speech: "done" }));
-        const { speech } = await Ref(ctx).tools.declaration({ label: "ready" });
-        const value = speech;
-        expect(value).toBe("done");
-    });
-    test("observable writes forward the provider and snapshot values, with no options by default", async () => {
-        const State = (0, index_1.declareContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "State",
-            observables: [
-                (0, index_1.declareObservable)({
-                    name: "value",
-                    description: "Writable state.",
-                    schema: index_1.z.object({ label: index_1.z.string(), detail: index_1.z.string().optional() }),
-                    writable: true,
-                }),
-            ],
-        });
-        const { ctx, calls } = fakeContext((_method, args) => args[3]);
-        const value = { label: "ready", detail: undefined };
-        await State(ctx).observables.value.set(value);
-        await State(ctx, { providerPackageId: "p1" }).observables.value.set(value);
-        expect(calls).toEqual([
-            ["setConsumedObservable", State.contractId, 1, "value", { label: "ready" }],
-            [
-                "setConsumedObservable",
-                State.contractId,
-                1,
-                "value",
-                { label: "ready" },
-                { providerPackageId: "p1" },
-            ],
-        ]);
-        expect(Object.hasOwn(value, "detail")).toBe(true);
-    });
-    test("an empty whole observable value is null on the bridge, including a write's reply", async () => {
-        const State = (0, index_1.declareContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "State",
-            observables: [
-                (0, index_1.declareObservable)({
-                    name: "value",
-                    description: "Optional state.",
-                    schema: index_1.z.string().optional(),
-                    writable: true,
-                }),
-            ],
-        });
-        const source = (0, index_1.observable)();
-        const Implemented = (0, index_1.implementContract)(State, { observables: { value: source } });
-        const handlers = [];
-        (0, serve_members_1.serveContractMembers)(Implemented, (_name, handler) => handlers.push(handler));
-        const { ctx } = fakeContext((method, args) => handlers[0]({
-            member: "observable",
-            name: "value",
-            operation: method === "getConsumedObservable" ? "get" : "set",
-            args: method === "getConsumedObservable" ? [] : [args[3] ?? null],
-        }, ctx));
-        await (0, index_1.startPackage)((0, index_1.definePackage)((pkg) => {
-            pkg.packageId = (0, peer_id_1.newid)();
-            pkg.version = "1.0.0";
-            pkg.provides(Implemented);
-        }), fakeContext().ctx);
-        const read = await State(ctx).observables.value.get();
-        // The type must allow what the provider's member handler actually returns.
-        const emptyRead = null;
-        expect(read).toBe(emptyRead);
-        // A provider's subscribers can adjust the value before it replies to the write.
-        source.subscribe(() => source(undefined));
-        const written = await State(ctx).observables.value.set("clear");
-        const emptyWrite = null;
-        expect(written).toBe(emptyWrite);
-        // @ts-expect-error undefined crosses the bridge as null, which this schema refuses
-        const missingWrite = State(ctx).observables.value.set(undefined);
-        await expect(missingWrite).rejects.toThrow(/null/);
-    });
-    test("a consumer lists the declaration itself", () => {
-        const manifest = (0, manifest_1.buildPackageManifest)((0, index_1.definePackage)((pkg) => {
-            pkg.packageId = (0, peer_id_1.newid)();
-            pkg.version = "1.0.0";
-            pkg.consumes(Skill, { optional: true });
-        }));
-        expect(manifest.consumes).toEqual([{ contractId, version: 1, optional: true }]);
-    });
-    test("refuses members that carry an implementation", () => {
-        const base = { contractId, version: 1, name: "Bad" };
-        expect(() => (0, index_1.declareContract)({ ...base, tools: [(0, index_1.defineTool)({ ...invokeShape, handler })] })).toThrow('tool "invoke" has a handler');
-        expect(() => (0, index_1.declareContract)({
-            ...base,
-            observables: [
-                (0, index_1.defineObservable)({
-                    name: "skill",
-                    description: "The catalog.",
-                    schema: catalogSchema,
-                    source: (0, index_1.observable)({ name: "a", slug: "a" }),
-                }),
-            ],
-        })).toThrow('observable "skill" has a source');
-        class NotesTable extends index_1.PackageTable {
-        }
-        expect(() => (0, index_1.declareContract)({
-            ...base,
-            tables: [(0, index_1.defineTable)({ ...Notes.definition, tableClass: NotesTable })],
-        })).toThrow('table "Notes" has a tableClass');
-        expect(() => (0, index_1.declareContract)({ ...base, contractId: "short" })).toThrow(/25-character/);
-        expect(() => (0, index_1.declareContract)({ ...base, tools: [(0, index_1.declareTool)(invokeShape), (0, index_1.declareTool)(invokeShape)] })).toThrow(/twice/);
-        expect(() => (0, index_1.declareTool)({ ...invokeShape, handler })).toThrow(/takes no handler/);
-        expect(() => (0, index_1.declareObservable)({
-            name: "skill",
-            description: "The catalog.",
-            schema: catalogSchema,
-            source: (0, index_1.observable)(null),
-        })).toThrow(/takes no source/);
-    });
-    test("recognizing an observable declaration does not claim it has a source", () => {
-        const declared = (0, index_1.declareObservable)({
-            name: "value",
-            description: "Value.",
-            schema: index_1.z.number(),
-        });
-        expect((0, observables_1.isPackageObservable)(declared)).toBe(true);
-        expect((0, observables_1.isImplementedObservable)(declared)).toBe(false);
-        if ((0, observables_1.isPackageObservable)(declared)) {
-            // @ts-expect-error recognizing the observable kind does not add an implementation
-            void declared.definition.source;
-        }
-        const implemented = (0, index_1.defineObservable)({
-            name: "value",
-            description: "Value.",
-            schema: index_1.z.number(),
-            source: (0, index_1.observable)(0),
-        });
-        expect((0, observables_1.isImplementedObservable)(implemented)).toBe(true);
-    });
-});
-describe("implementContract", () => {
-    test("only read-only declarations accept a source with a narrower value type", () => {
-        const shape = {
-            name: "mode",
-            description: "The mode.",
-            schema: index_1.z.enum(["on", "off"]),
-        };
-        const ReadOnly = (0, index_1.declareContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Read-only mode",
-            observables: [(0, index_1.declareObservable)(shape)],
-        });
-        const Writable = (0, index_1.declareContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Writable mode",
-            observables: [(0, index_1.declareObservable)({ ...shape, writable: true })],
-        });
-        const narrow = (0, index_1.observable)("on");
-        // Read-only consumers can't give the narrower source a value outside its own type.
-        (0, index_1.implementContract)(ReadOnly, { observables: { mode: narrow } });
-        (0, index_1.implementContract)(Writable, {
-            // @ts-expect-error this source's subscribers only accept "on", but consumers can write "off"
-            observables: { mode: narrow },
-        });
-        (0, index_1.implementContract)(Writable, {
-            // @ts-expect-error explicit type arguments must also reject a narrower writable source
-            observables: { mode: narrow },
-        });
-        const invalid = {
-            // @ts-expect-error a typed implementation must reject a narrower writable source too
-            observables: { mode: narrow },
-        };
-        // Read-only sources keep their covariance even in a typed implementation.
-        const readOnly = { observables: { mode: narrow } };
-        (0, index_1.implementContract)(ReadOnly, readOnly);
-        void invalid;
-        const source = (0, index_1.observable)("on");
-        const implemented = (0, index_1.implementContract)(Writable, { observables: { mode: source } });
-        expect(implemented.observables[0].definition.source).toBe(source);
-        // Explicit declaration type arguments keep valid implementations working too.
-        (0, index_1.implementContract)(Writable, { observables: { mode: source } });
-        expect(() => (0, index_1.implementContract)(Writable, {
-            // @ts-expect-error the source map must still refuse undeclared names
-            observables: { mode: source, extra: source },
-        })).toThrow('declares no observable "extra"');
-    });
-    test("the manifest is the declared shape with the provider's handler and source", async () => {
-        const Implemented = (0, index_1.implementContract)(Skill, {
-            tools: { invoke: { handler, timeoutMs: 90_000 } },
-            observables: { skill: catalog },
-        });
-        const [declaredTool] = Skill.declaration.tools;
-        const [declaredObservable] = Skill.declaration.observables;
-        const Same = (0, index_1.defineContract)({
-            contractId,
-            version: 1,
-            name: "Skill",
-            description: "A skill.",
-            tables: [Notes],
-            tools: [(0, index_1.defineTool)({ ...declaredTool.definition, timeoutMs: 90_000, handler })],
-            observables: [
-                (0, index_1.defineObservable)({ ...declaredObservable.definition, source: catalog }),
-            ],
-            events: [alert],
-        });
-        const manifest = manifestOf(Implemented);
-        expect(manifest).toEqual(manifestOf(Same));
-        const [tool] = manifest.provides[0].tools;
-        expect(tool).toMatchObject({
-            name: "invoke",
-            suggestedAccessLevel: index_1.AccessLevel.Reader,
-            authorityPropagation: "preserve",
-            timeoutMs: 90_000,
-        });
-        expect(manifest.provides[0].observables?.[0].persistentVar).toMatchObject({
-            scope: "device",
-            defaultValue: { name: "Timers", slug: "timers" },
-        });
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)({ manifest, providerSource: "void 0;" }, { strict: true })).not.toThrow();
-        const { ctx } = fakeContext();
-        // The declared schema parses the input, empty optional fields left out.
-        await expect((0, index_1.runPackageTool)(Implemented.tools[0], { tool: "list", args: null }, ctx)).resolves.toEqual({ speech: "list" });
-    });
-    test("the declaration's event goes out on the implemented contract", async () => {
-        const Implemented = (0, index_1.implementContract)(Skill, {
-            tools: { invoke: handler },
-            observables: { skill: catalog },
-        });
-        const calls = [];
-        const ctx = {
-            emitContractEvent: async (...args) => {
-                calls.push(args);
-                return null;
-            },
-            getOwnedPersistentVar: async () => null,
-            watchOwnedPersistentVar: async () => () => undefined,
-        };
-        await (0, index_1.startPackage)((0, index_1.definePackage)((pkg) => {
-            pkg.packageId = (0, peer_id_1.newid)();
-            pkg.version = "1.0.0";
-            pkg.provides(Implemented);
-        }), ctx);
-        await alert.emit({ title: "Done" });
-        expect(calls).toEqual([[contractId, 1, "alert", { title: "Done" }]]);
-    });
-    test("refuses a missing, extra, or unknown member", () => {
-        const observables = { skill: catalog };
-        expect(() => (0, index_1.implementContract)(Skill, { tools: {}, observables })).toThrow('implement tool "invoke" with a handler');
-        expect(() => (0, index_1.implementContract)(Skill, {
-            tools: { invoke: handler, other: handler },
-            observables,
-        })).toThrow('declares no tool "other"');
-        expect(() => (0, index_1.implementContract)(Skill, { tools: { invoke: handler }, observables: {} })).toThrow('implement observable "skill" with a source');
-        expect(() => (0, index_1.implementContract)(Skill, {
-            tools: { invoke: { handler, accessLevel: 0 } },
-            observables,
-        })).toThrow(/handler and timeoutMs only, not accessLevel/);
-        expect(() => (0, index_1.implementContract)(Skill, {
-            tools: { invoke: handler },
-            observables,
-            tables: {},
-        })).toThrow(/tools, observables, exposes, and alsoImplements, not tables/);
-        expect(() => (0, index_1.implementContract)((0, index_1.defineContract)({ contractId, version: 1, name: "X" }), {})).toThrow(/takes a declaration/);
-        // Types follow the declaration.
-        (0, index_1.implementContract)(Skill, {
-            // @ts-expect-error speech is a string
-            tools: { invoke: () => ({ speech: 1 }) },
-            observables,
-        });
-        (0, index_1.implementContract)(Skill, {
-            tools: { invoke: handler },
-            // @ts-expect-error the source must hold the declared value
-            observables: { skill: (0, index_1.observable)(3) },
-        });
-    });
-    test("exposes other contracts the package provides, outside the contract's shape", () => {
-        const News = (0, index_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "News",
-            tools: [
-                (0, index_1.defineTool)({
-                    name: "headlines",
-                    usageDescription: "Recent headlines.",
-                    accessLevel: index_1.AccessLevel.Reader,
-                    inputSchema: index_1.z.object({}),
-                    outputSchema: index_1.z.object({}),
-                    handler: async () => ({}),
-                }),
-            ],
-        });
-        const members = { tools: { invoke: handler }, observables: { skill: catalog } };
-        const Implemented = (0, index_1.implementContract)(Skill, { ...members, exposes: [News] });
-        expect(Implemented.exposes).toEqual([{ contractId: News.contractId, version: 1 }]);
-        // A reference names the contract as well as the contract itself does.
-        expect((0, index_1.implementContract)(Skill, { ...members, exposes: [(0, index_1.contractRef)(News.contractId, 1)] }).exposes).toEqual(Implemented.exposes);
-        const manifest = (0, manifest_1.buildPackageManifest)((0, index_1.definePackage)((pkg) => {
-            pkg.packageId = packageId;
-            pkg.version = "1.0.0";
-            pkg.provides(News);
-            pkg.provides(Implemented);
-        }));
-        expect(manifest.provides[1].exposes).toEqual([{ contractId: News.contractId, version: 1 }]);
-        expect(manifest.provides[0]).not.toHaveProperty("exposes");
-        // The validator fills in defaults, so it checks a copy.
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)({ manifest: JSON.parse(JSON.stringify(manifest)), providerSource: "void 0;" }, { strict: true })).not.toThrow();
-        // Everything but `exposes` is the contract as implemented without it.
-        const { exposes: _exposes, ...shape } = manifest.provides[1];
-        expect(shape).toEqual(manifestOf((0, index_1.implementContract)(Skill, members)).provides[0]);
-        // An implementation without `exposes` carries none.
-        expect((0, index_1.implementContract)(Skill, members)).not.toHaveProperty("exposes");
-    });
-    test("refuses exposing itself, a contract twice, or one the package doesn't provide", () => {
-        const members = { tools: { invoke: handler }, observables: { skill: catalog } };
-        const other = { contractId: (0, peer_id_1.newid)(), version: 1 };
-        expect(() => (0, index_1.implementContract)(Skill, { ...members, exposes: [Skill] })).toThrow(/can't expose itself/);
-        expect(() => (0, index_1.implementContract)(Skill, { ...members, exposes: [other, other] })).toThrow(/exposes .* twice/);
-        expect(() => (0, index_1.implementContract)(Skill, { ...members, exposes: other })).toThrow(/exposes must be a list of contracts/);
-        expect(() => (0, index_1.implementContract)(Skill, { ...members, exposes: [{ contractId: "x", version: 1 }] })).toThrow(/with an id and version/);
-        expect(() => (0, index_1.definePackage)((pkg) => {
-            pkg.packageId = (0, peer_id_1.newid)();
-            pkg.version = "1.0.0";
-            pkg.provides((0, index_1.implementContract)(Skill, { ...members, exposes: [other] }));
-        })).toThrow(/exposes .*, which the package doesn't provide; add it with pkg.provides/);
-    });
-    test("defineContract and pkg.provides refuse what isn't implemented", () => {
-        const base = { contractId, version: 1, name: "X" };
-        expect(() => (0, index_1.defineContract)({ ...base, tools: [Skill.declaration.tools[0]] })).toThrow(/has no handler; .*declareContract and implementContract/);
-        expect(() => (0, index_1.defineContract)({ ...base, observables: [Skill.declaration.observables[0]] })).toThrow(/has no source/);
-        expect(() => (0, index_1.definePackage)((pkg) => {
-            pkg.packageId = (0, peer_id_1.newid)();
-            pkg.version = "1.0.0";
-            pkg.provides(Skill);
-        })).toThrow(/implementContract first/);
-    });
-});

package/dist/define/define.test.d.ts

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