@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/testing/mock-host-contract.test.js

@@ -1,782 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const host_contract_client_1 = require("../contracts/host-contract-client");
-const host_contract_transport_1 = require("../contracts/host-contract-transport");
-const access_level_1 = require("../data/access-level");
-const types_1 = require("../data/orm/types");
-const contract_ref_1 = require("../define/contract-ref");
-const declare_contract_1 = require("../define/declare-contract");
-const define_package_1 = require("../define/define-package");
-const events_1 = require("../define/events");
-const manifest_1 = require("../define/manifest");
-const observables_1 = require("../define/observables");
-const table_1 = require("../define/table");
-const tool_1 = require("../define/tool");
-const vars_1 = require("../define/vars");
-const observable_1 = require("../observable");
-const peer_id_1 = require("../peer-id");
-const field_type_1 = require("../types/field-type");
-const zod_types_1 = require("../types/zod-types");
-const index_1 = require("./index");
-const contractId = "00mvjqva0cduvm6qdq536381m";
-const Notes = (0, table_1.defineTable)({
-    name: "Notes",
-    description: "Notes.",
-    primaryKeyName: "noteId",
-    schema: zod_1.z.object({
-        noteId: zod_types_1.zodPeerId,
-        title: zod_1.z.string().trim(),
-        rank: zod_1.z.number().default(0),
-        tag: zod_1.z.string().optional(),
-    }),
-});
-const summarize = (0, tool_1.defineTool)({
-    name: "summarize",
-    usageDescription: "Summarize notes.",
-    accessLevel: 0,
-    inputSchema: zod_1.z.object({ count: zod_1.z.number().default(3) }),
-    outputSchema: zod_1.z.object({ text: zod_1.z.string() }),
-    handler: () => ({ text: "real handler" }),
-});
-const archive = (0, tool_1.defineTool)({
-    name: "archive",
-    usageDescription: "Archive.",
-    // Above None: the mock host still runs it (no access checks).
-    accessLevel: access_level_1.AccessLevel.Writer,
-    inputSchema: zod_1.z.object({}),
-    outputSchema: zod_1.z.object({}),
-    handler: () => ({}),
-});
-const saved = (0, events_1.defineEvent)({
-    name: "saved",
-    description: "Notes were saved.",
-    payloadSchema: zod_1.z.object({ count: zod_1.z.number() }),
-});
-const theme = (0, observables_1.defineObservable)({
-    name: "theme",
-    description: "Writable theme.",
-    schema: zod_1.z.string().trim().min(1),
-    writable: true,
-    source: (0, observable_1.observable)("light"),
-});
-const label = (0, observables_1.defineObservable)({
-    name: "label",
-    description: "Writable stored label.",
-    schema: zod_1.z.string().trim(),
-    writable: true,
-    source: (0, vars_1.deviceVar)("mockHostLabel", { defaultValue: "notes" }),
-});
-const status = (0, observables_1.defineObservable)({
-    name: "status",
-    description: "Read-only status.",
-    schema: zod_1.z.string(),
-    source: (0, observable_1.observable)("idle"),
-});
-const NotesContract = (0, define_package_1.defineContract)({
-    contractId,
-    version: 1,
-    name: "Notes",
-    tables: [Notes],
-    tools: [summarize, archive],
-    events: [saved],
-    observables: [theme, status, label],
-});
-const note = (title, rank = 0, tag) => ({ noteId: (0, peer_id_1.newid)(), title, rank, tag });
-/** Let pushes and fire-and-forget requests land. */
-const flush = async () => {
-    for (let i = 0; i < 5; i++)
-        await new Promise((resolve) => setTimeout(resolve, 0));
-};
-const cleanups = [];
-afterEach(() => {
-    for (const cleanup of cleanups.splice(0).reverse())
-        cleanup();
-    jest.restoreAllMocks();
-});
-function start(options = {}) {
-    const host = (0, index_1.mockHostContract)(NotesContract, options);
-    cleanups.push(() => host.dispose());
-    return host;
-}
-function client() {
-    const made = (0, host_contract_client_1.hostContract)(contractId, 1, { timeoutMs: 500 });
-    cleanups.push(() => made.dispose());
-    return made;
-}
-describe("hostContract(contractId, version)", () => {
-    test("is the same client as the reference form, typed from the contract", async () => {
-        const host = start({ tables: { Notes: [note("first")] } });
-        const shared = (0, host_contract_client_1.hostContract)(contractId, 1);
-        expect((0, host_contract_client_1.hostContract)(contractId, 1)).toBe(shared);
-        expect((0, host_contract_client_1.hostContract)((0, contract_ref_1.contractRef)(contractId, 1))).toBe(shared);
-        const rows = await shared.tables.Notes.list();
-        expect(rows.map((row) => row.title)).toEqual(["first"]);
-        expect(host.tables.Notes.rows).toHaveLength(1);
-        const typeChecks = () => {
-            // @ts-expect-error the version must be the contract's
-            (0, host_contract_client_1.hostContract)(contractId, 2);
-            // @ts-expect-error the id must be the contract's
-            (0, host_contract_client_1.hostContract)("00mvjqva0xyy1fqyt9pupb16b", 1);
-            // @ts-expect-error unknown tool
-            void shared.tools.missing;
-            // Without a contract type, any member, as with an untyped contractRef.
-            void (0, host_contract_client_1.hostContract)(contractId, 1).tools.anything;
-            void (0, host_contract_client_1.hostContract)((0, contract_ref_1.contractRef)(contractId, 1)).tools.anything;
-        };
-        void typeChecks;
-    });
-    test("validates its arguments", () => {
-        expect(() => (0, host_contract_client_1.hostContract)("", 1)).toThrow("contractRef requires a contractId");
-        expect(() => (0, host_contract_client_1.hostContract)(contractId, 0)).toThrow("positive integer");
-    });
-});
-describe("mockHostContract", () => {
-    test("mocks a declared contract: fakes stand in for handlers, start values for sources", async () => {
-        const Skill = (0, declare_contract_1.declareContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Skill",
-            tools: [
-                (0, tool_1.declareTool)({
-                    name: "invoke",
-                    usageDescription: "Run one.",
-                    accessLevel: access_level_1.AccessLevel.Reader,
-                    inputSchema: zod_1.z.object({ tool: zod_1.z.string() }),
-                    outputSchema: zod_1.z.object({ speech: zod_1.z.string().optional() }),
-                }),
-            ],
-            observables: [
-                (0, observables_1.declareObservable)({
-                    name: "skill",
-                    description: "The catalog.",
-                    schema: zod_1.z.object({ slug: zod_1.z.string() }),
-                }),
-            ],
-            events: [
-                (0, events_1.defineEvent)({
-                    name: "alert",
-                    description: "Attention.",
-                    payloadSchema: zod_1.z.object({ title: zod_1.z.string() }),
-                }),
-            ],
-        });
-        const host = (0, index_1.mockHostContract)(Skill, {
-            tools: { invoke: ({ tool }) => ({ speech: `ran ${tool}` }) },
-            observables: { skill: { slug: "timers" } },
-        });
-        cleanups.push(() => host.dispose());
-        const skill = (0, host_contract_client_1.hostContract)(Skill);
-        cleanups.push(() => skill.dispose());
-        // A UI may also import only the declaration's type.
-        const typedSkill = (0, host_contract_client_1.hostContract)(Skill.contractId, Skill.version);
-        expect(typedSkill).toBe(skill);
-        const typedResult = await typedSkill.tools.invoke({ tool: "typed" });
-        const speech = typedResult.speech;
-        expect(speech).toBe("ran typed");
-        await expect(skill.tools.invoke({ tool: "list" })).resolves.toEqual({ speech: "ran list" });
-        skill.observables.skill.subscribe(() => { });
-        await flush();
-        expect(skill.observables.skill()).toEqual({ slug: "timers" });
-        const alerts = [];
-        const subscription = skill.events.alert.subscribe((alert) => {
-            alerts.push(alert.title);
-        });
-        await subscription.ready;
-        await host.events.alert.emit({ title: "Done" });
-        expect(alerts).toEqual(["Done"]);
-    });
-    test("tool fakes see empty optional inputs removed and defaults filled, and clean their results", async () => {
-        const inputs = [];
-        const rate = (0, tool_1.defineTool)({
-            name: "rate",
-            usageDescription: "Rate.",
-            accessLevel: 0,
-            inputSchema: zod_1.z.object({ rating: zod_1.z.number().default(5), note: zod_1.z.string().optional() }),
-            outputSchema: zod_1.z.object({ note: zod_1.z.string().nullish() }),
-            handler: () => ({}),
-        });
-        const contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Ratings",
-            tools: [rate],
-        });
-        const host = (0, index_1.mockHostContract)(contract, {
-            tools: {
-                rate: (input) => {
-                    inputs.push(input);
-                    return { note: null };
-                },
-            },
-        });
-        cleanups.push(() => host.dispose());
-        const ratings = (0, host_contract_client_1.hostContract)(contract.contractId, 1);
-        cleanups.push(() => ratings.dispose());
-        await expect(ratings.tools.rate({ rating: null, note: null })).resolves.toStrictEqual({});
-        expect(inputs).toStrictEqual([{ rating: 5 }]);
-    });
-    test("tool fakes get the input as the tool's schema parses it", async () => {
-        const inputs = [];
-        start({
-            tools: {
-                summarize: (input) => {
-                    const count = input.count;
-                    void count;
-                    inputs.push(input);
-                    return { text: `${input.count} notes` };
-                },
-            },
-        });
-        const notes = client();
-        await expect(notes.tools.summarize()).resolves.toEqual({ text: "3 notes" });
-        await expect(notes.tools.summarize({ count: 5 })).resolves.toEqual({ text: "5 notes" });
-        expect(inputs).toEqual([{ count: 3 }, { count: 5 }]);
-        await expect(notes.tools.archive()).rejects.toThrow("no fake for tool 'archive'");
-    });
-    test("fake inputs have their parsed types, including schema transforms", async () => {
-        const convert = (0, tool_1.defineTool)({
-            name: "convert",
-            usageDescription: "Parse a count.",
-            accessLevel: 0,
-            inputSchema: zod_1.z.object({ count: zod_1.z.string().transform(Number) }),
-            outputSchema: zod_1.z.object({ count: zod_1.z.number() }),
-            handler: (input) => input,
-        });
-        const Converted = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Converted",
-            tools: [convert],
-        });
-        const host = (0, index_1.mockHostContract)(Converted, {
-            tools: {
-                convert: (input) => {
-                    const count = input.count;
-                    return { count: count + 1 };
-                },
-            },
-        });
-        cleanups.push(() => host.dispose());
-        const converted = (0, host_contract_client_1.hostContract)(Converted.contractId, 1, { timeoutMs: 500 });
-        cleanups.push(() => converted.dispose());
-        await expect(converted.tools.convert({ count: "4" })).resolves.toEqual({ count: 5 });
-    });
-    test("a private tool refuses UI calls, as the host does, even with a fake", async () => {
-        const internal = (0, tool_1.defineTool)({
-            name: "internal",
-            usageDescription: "Only the package's own dispatcher may call this.",
-            accessLevel: 0,
-            private: true,
-            inputSchema: zod_1.z.object({}),
-            outputSchema: zod_1.z.object({ ok: zod_1.z.boolean() }),
-            handler: () => ({ ok: true }),
-        });
-        const Internal = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Internal",
-            tools: [internal],
-        });
-        const host = (0, index_1.mockHostContract)(Internal, { tools: { internal: () => ({ ok: true }) } });
-        cleanups.push(() => host.dispose());
-        const client = (0, host_contract_client_1.hostContract)(Internal.contractId, 1, { timeoutMs: 500 });
-        cleanups.push(() => client.dispose());
-        await expect(client.tools.internal()).rejects.toThrow("tool 'internal' is private");
-    });
-    test("tables read, filter, sort, and page in memory", async () => {
-        start({
-            tables: { Notes: [note("b", 2, "x"), note("a", 1, "y"), note("c", 3, "x")] },
-        });
-        const notes = client().tables.Notes;
-        expect((await notes.list({ tag: "x" })).map((row) => row.title)).toEqual(["b", "c"]);
-        expect((await notes.list({}, { sortBy: ["-rank"] })).map((row) => row.title)).toEqual([
-            "c",
-            "b",
-            "a",
-        ]);
-        expect((await notes.list({}, { sortBy: ["title"], page: 2, pageSize: 2 })).map((row) => row.title)).toEqual(["c"]);
-        expect(await notes.count({ tag: "x" })).toBe(2);
-        expect((await notes.findOne({ tag: "y" }))?.title).toBe("a");
-        expect((await notes.list({ title: { $in: ["a", "c"] } }, { sortBy: ["title"] })).map((row) => row.title)).toEqual(["a", "c"]);
-        expect(await notes.count({ tag: "x", title: { $in: ["a", "b"] } })).toBe(1);
-        await expect(notes.list({ $or: [{ tag: "x" }] })).rejects.toThrow("equality and $in filters only");
-        await expect(notes.list({ title: { $ne: "a" } })).rejects.toThrow("equality and $in filters only");
-        await expect(notes.list({}, { textSearch: "a" })).rejects.toThrow("does not support query option 'textSearch'");
-    });
-    test("UI saves go through the table's schema, and host writes reach subscribers", async () => {
-        const host = start();
-        const notes = client().tables.Notes;
-        const events = [];
-        const subscription = notes.dataChanged.subscribe((event) => events.push(`${event.op}:${event.dataObject.title}`));
-        await subscription.ready;
-        const typeChecks = () => {
-            // @ts-expect-error `title` has no default
-            void notes.save({ noteId: (0, peer_id_1.newid)() });
-        };
-        void typeChecks;
-        // The provider's table parses the save, so the schema's default fills `rank`.
-        const first = await notes.save({ noteId: (0, peer_id_1.newid)(), title: "from UI" });
-        expect(first.rank).toBe(0);
-        expect(host.tables.Notes.rows).toEqual([first]);
-        await expect(notes.save({ noteId: (0, peer_id_1.newid)() })).rejects.toThrow();
-        await host.tables.Notes.save({ ...first, title: "from host" });
-        await host.tables.Notes.delete(first.noteId);
-        await flush();
-        expect(events).toEqual(["insert:from UI", "update:from host", "delete:from host"]);
-        expect(await notes.get(first.noteId)).toBeUndefined();
-    });
-    test("UI calls and changes go through the table's class", async () => {
-        const schema = zod_1.z.object({
-            itemId: zod_types_1.zodPeerId,
-            title: zod_1.z.string(),
-            hidden: zod_1.z.boolean().default(false),
-        });
-        class ItemsTable extends table_1.PackageTable {
-            async save(item) {
-                return super.save({ ...item, title: item.title.trim() });
-            }
-            async list(...args) {
-                return (await super.list(...args)).filter((item) => !item.hidden);
-            }
-            dataChanged(event) {
-                return event.dataObject.hidden ? undefined : event;
-            }
-        }
-        const Items = (0, table_1.defineTable)({
-            name: "Items",
-            description: "Items.",
-            primaryKeyName: "itemId",
-            schema,
-            tableClass: ItemsTable,
-        });
-        const itemsContractId = (0, peer_id_1.newid)();
-        const ItemsContract = (0, define_package_1.defineContract)({
-            contractId: itemsContractId,
-            version: 1,
-            name: "Items",
-            tables: [Items],
-        });
-        const host = (0, index_1.mockHostContract)(ItemsContract);
-        cleanups.push(() => host.dispose());
-        const items = (0, host_contract_client_1.hostContract)(itemsContractId, 1, { timeoutMs: 500 });
-        cleanups.push(() => items.dispose());
-        const changes = [];
-        await items.tables.Items.dataChanged.subscribe((event) => changes.push(`${event.op}:${event.dataObject.title}`)).ready;
-        const saved = await items.tables.Items.save({ itemId: (0, peer_id_1.newid)(), title: "  shown  " });
-        expect(saved).toMatchObject({ title: "shown", hidden: false });
-        await host.tables.Items.save({ itemId: (0, peer_id_1.newid)(), title: "secret", hidden: true });
-        await flush();
-        expect((await items.tables.Items.list()).map((item) => item.title)).toEqual(["shown"]);
-        expect(host.tables.Items.rows).toHaveLength(2);
-        expect(changes).toEqual(["insert:shown"]);
-    });
-    test("null equality filters match omitted optional fields, as host storage does", async () => {
-        start({ tables: { Notes: [note("untagged"), note("tagged", 0, "work")] } });
-        const notes = client().tables.Notes;
-        for (const filter of [{ tag: null }, { tag: undefined }]) {
-            expect((await notes.list(filter)).map((row) => row.title)).toEqual(["untagged"]);
-            expect(await notes.count(filter)).toBe(1);
-            expect((await notes.findOne(filter))?.title).toBe("untagged");
-        }
-    });
-    test("table delivery hooks stop when the mock host is disposed", async () => {
-        const schema = zod_1.z.object({ itemId: zod_types_1.zodPeerId, title: zod_1.z.string() });
-        let release;
-        const pending = new Promise((resolve) => {
-            release = resolve;
-        });
-        const seen = [];
-        class DelayedTable extends table_1.PackageTable {
-            async dataChanged(event) {
-                seen.push(event.dataObject.title);
-                await pending;
-                return event;
-            }
-        }
-        const Items = (0, table_1.defineTable)({
-            name: "Items",
-            description: "Items",
-            primaryKeyName: "itemId",
-            schema,
-            tableClass: DelayedTable,
-        });
-        const Contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Delayed",
-            tables: [Items],
-        });
-        const host = (0, index_1.mockHostContract)(Contract);
-        cleanups.push(() => host.dispose());
-        await host.tables.Items.save({ itemId: (0, peer_id_1.newid)(), title: "unobserved" });
-        await flush();
-        expect(seen).toEqual([]);
-        const items = (0, host_contract_client_1.hostContract)(Contract.contractId, 1, { timeoutMs: 500 });
-        cleanups.push(() => items.dispose());
-        const pushed = jest.fn();
-        await items.tables.Items.dataChanged.subscribe(pushed).ready;
-        await host.tables.Items.save({ itemId: (0, peer_id_1.newid)(), title: "pending" });
-        await flush();
-        expect(seen).toEqual(["pending"]);
-        await host.tables.Items.save({ itemId: (0, peer_id_1.newid)(), title: "queued" });
-        host.dispose();
-        release();
-        await host.tables.Items.save({ itemId: (0, peer_id_1.newid)(), title: "disposed" });
-        await flush();
-        expect(seen).toEqual(["pending"]);
-        expect(pushed).not.toHaveBeenCalled();
-    });
-    test("UI saves run the table's schema; stored rows validate the manifest's fields", async () => {
-        const definition = (0, define_package_1.definePackage)((pkg) => {
-            pkg.packageId = (0, peer_id_1.newid)();
-            pkg.version = "1.0.0";
-            pkg.provides(NotesContract);
-        });
-        const fields = (0, manifest_1.buildPackageManifest)(definition).tables?.[0].fields;
-        if (!fields)
-            throw new Error("missing table fields");
-        const storedSchema = (0, types_1.fieldsToSchema)(fields);
-        const incomplete = { noteId: (0, peer_id_1.newid)(), title: " incomplete " };
-        // Storage has only the manifest's fields: starting rows must be complete.
-        expect(() => storedSchema.parse(incomplete)).toThrow();
-        expect(() => start({ tables: { Notes: [incomplete] } })).toThrow();
-        // A UI save reaches the package's table, whose schema trims the title and fills `rank`.
-        const host = start();
-        const saved = await client().tables.Notes.save(incomplete);
-        expect(saved).toMatchObject({ title: "incomplete", rank: 0 });
-        expect(host.tables.Notes.rows).toEqual([saved]);
-    });
-    test("stored mock rows match richer manifest fields without enforcing nested shapes", () => {
-        const Places = (0, table_1.defineTable)({
-            name: "Places",
-            description: "Places.",
-            primaryKeyName: "placeId",
-            schema: zod_1.z.object({
-                placeId: zod_types_1.zodPeerId,
-                mode: zod_1.z.enum(["on", "off"]),
-                detail: zod_1.z.object({ city: zod_1.z.string() }).optional(),
-            }),
-        });
-        const Contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Places",
-            tables: [Places],
-        });
-        const rows = [
-            { placeId: (0, peer_id_1.newid)(), mode: "on" },
-            { placeId: (0, peer_id_1.newid)(), mode: "on", detail: { city: "Austin", extra: true } },
-            // Synced stored rows get type-level checks; the package parses consumer saves.
-            { placeId: (0, peer_id_1.newid)(), mode: "future", detail: { city: 3 } },
-        ];
-        const host = (0, index_1.mockHostContract)(Contract, { tables: { Places: rows } });
-        cleanups.push(() => host.dispose());
-        expect(host.tables.Places.rows).toEqual(rows);
-    });
-    test("an empty optional field is left out, as in host storage", async () => {
-        const Places = (0, table_1.defineTable)({
-            name: "Places",
-            description: "Places.",
-            primaryKeyName: "placeId",
-            schema: zod_1.z.object({
-                placeId: zod_types_1.zodPeerId,
-                city: zod_1.z.string(),
-                note: zod_1.z.string().optional(),
-                where: zod_1.z.object({ zip: zod_1.z.string().optional() }).optional(),
-            }),
-        });
-        const Contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Places",
-            tables: [Places],
-        });
-        const first = { placeId: (0, peer_id_1.newid)(), city: "Austin", note: null };
-        const host = (0, index_1.mockHostContract)(Contract, { tables: { Places: [first] } });
-        cleanups.push(() => host.dispose());
-        expect(host.tables.Places.rows).toEqual([{ placeId: first.placeId, city: "Austin" }]);
-        const second = { placeId: (0, peer_id_1.newid)(), city: "Austin", note: null, where: { zip: null } };
-        const stored = { placeId: second.placeId, city: "Austin", where: {} };
-        // The save returns the row as stored, so saving it again changes nothing.
-        expect(await host.tables.Places.save(second)).toEqual(stored);
-        expect(await host.tables.Places.get(second.placeId)).toEqual(stored);
-    });
-    test("a .nullable() table field is refused, as the build refuses it", () => {
-        const Places = (0, table_1.defineTable)({
-            name: "Places",
-            description: "Places.",
-            primaryKeyName: "placeId",
-            schema: zod_1.z.object({ placeId: zod_types_1.zodPeerId, city: zod_1.z.string().nullable() }),
-        });
-        const Contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Places",
-            tables: [Places],
-        });
-        expect(() => (0, index_1.mockHostContract)(Contract)).toThrow('Field "city" uses .nullable()');
-    });
-    test("the UI holds copies, not the host's rows", async () => {
-        const host = start({ tables: { Notes: [note("original")] } });
-        const [row] = await client().tables.Notes.list();
-        row.title = "changed in the UI";
-        expect(host.tables.Notes.rows[0].title).toBe("original");
-    });
-    test("works without structuredClone, as in Jest's jsdom environment", async () => {
-        const clone = globalThis.structuredClone;
-        try {
-            // @ts-expect-error jsdom does not provide this global
-            delete globalThis.structuredClone;
-            const host = start({ tables: { Notes: [note("original")] } });
-            const notes = client().tables.Notes;
-            expect(await notes.list()).toEqual(host.tables.Notes.rows);
-            const saved = await notes.save(note("saved"));
-            expect(await notes.get(saved.noteId)).toEqual(saved);
-        }
-        finally {
-            globalThis.structuredClone = clone;
-        }
-    });
-    test("a call delayed by onCall rejects if its host is disposed", async () => {
-        let release;
-        const gate = new Promise((resolve) => {
-            release = resolve;
-        });
-        const host = start({
-            tables: { Notes: [note("a")] },
-            onCall: async () => gate,
-        });
-        const notes = client().tables.Notes;
-        const count = notes.count();
-        await flush();
-        host.dispose();
-        release();
-        await expect(count).rejects.toThrow("disposed");
-    });
-    test("calls that would never be answered reject when the host is disposed", async () => {
-        const host = start({
-            tables: { Notes: [note("a")] },
-            tools: { summarize: () => new Promise(() => { }) },
-            onCall: (call) => (call.operation === "count" ? new Promise(() => { }) : undefined),
-        });
-        const notes = client();
-        const count = notes.tables.Notes.count();
-        const summary = notes.tools.summarize();
-        await flush();
-        host.dispose();
-        await expect(count).rejects.toThrow(/Mock host for .* is disposed/);
-        await expect(summary).rejects.toThrow(/Mock host for .* is disposed/);
-    });
-    test("observables follow the host, and a read-only one refuses writes", async () => {
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        const host = start({ observables: { theme: "dark", status: "ready" } });
-        const notes = client();
-        const seen = [];
-        notes.observables.theme.subscribe((value) => seen.push(value));
-        notes.observables.status.subscribe(() => { });
-        await flush();
-        expect(notes.observables.theme()).toBe("dark");
-        expect(notes.observables.status()).toBe("ready");
-        notes.observables.theme("blue");
-        await flush();
-        expect(host.observables.theme()).toBe("blue");
-        host.observables.status("busy");
-        await flush();
-        expect(notes.observables.status()).toBe("busy");
-        notes.observables.status("hacked");
-        await flush();
-        expect(host.observables.status()).toBe("busy");
-        expect(notes.observables.status()).toBe("busy");
-        expect(errors).toHaveBeenCalledWith("Contract observable set failed", expect.anything());
-        expect(seen).toContain("blue");
-    });
-    test("observables start as the host serves them unless given a value", async () => {
-        const host = start({ observables: { status: "ready" } });
-        const notes = client();
-        notes.observables.theme.subscribe(() => { });
-        notes.observables.status.subscribe(() => { });
-        notes.observables.label.subscribe(() => { });
-        await flush();
-        // In memory: the source's value, which the worker publishes at start.
-        expect(notes.observables.theme()).toBe("light");
-        // Given a starting value.
-        expect(notes.observables.status()).toBe("ready");
-        // Stored: the variable's default.
-        expect(notes.observables.label()).toBe("notes");
-        expect(host.observables.label()).toBe("notes");
-    });
-    test("observable reads and pushes leave empty fields out without changing the source", async () => {
-        const items = (0, observables_1.defineObservable)({
-            name: "items",
-            description: "Items.",
-            schema: zod_1.z.array(zod_1.z.object({ note: zod_1.z.string().optional() })),
-            source: (0, observable_1.observable)([{ note: null }]),
-        });
-        const contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Items",
-            observables: [items],
-        });
-        const host = (0, index_1.mockHostContract)(contract);
-        cleanups.push(() => host.dispose());
-        const client = (0, host_contract_client_1.hostContract)(contract.contractId, 1);
-        cleanups.push(() => client.dispose());
-        const seen = [];
-        client.observables.items.subscribe((value) => seen.push(value));
-        await flush();
-        expect(client.observables.items()).toStrictEqual([{}]);
-        expect(host.observables.items()).toStrictEqual([{ note: null }]);
-        host.observables.items([{ note: null }, { note: "set" }]);
-        await flush();
-        expect(client.observables.items()).toStrictEqual([{}, { note: "set" }]);
-        expect(seen.at(-1)).toStrictEqual([{}, { note: "set" }]);
-    });
-    test("UI observable writes are checked with the schema, as the host checks them", async () => {
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        const host = start({ observables: { theme: "dark", label: "notes" } });
-        const notes = client();
-        notes.observables.theme.subscribe(() => { });
-        notes.observables.label.subscribe(() => { });
-        await flush();
-        // An in-memory observable keeps the parsed value, as its write handler does.
-        notes.observables.theme("  blue  ");
-        await flush();
-        expect(host.observables.theme()).toBe("blue");
-        expect(notes.observables.theme()).toBe("blue");
-        // A value the schema refuses fails, and the UI reads the host's value again.
-        for (const refused of [undefined, "   "]) {
-            errors.mockClear();
-            notes.observables.theme(refused);
-            await flush();
-            expect(host.observables.theme()).toBe("blue");
-            expect(notes.observables.theme()).toBe("blue");
-            expect(errors).toHaveBeenCalledWith("Contract observable set failed", expect.anything());
-        }
-        // A stored observable keeps the parsed value, as the package stores it.
-        notes.observables.label("  todo  ");
-        await flush();
-        expect(host.observables.label()).toBe("todo");
-    });
-    test("observable writes must fit the manifest type before defaults, coercion, or IR writes", async () => {
-        const Counter = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Counter",
-            observables: [
-                (0, observables_1.defineObservable)({
-                    name: "defaulted",
-                    description: "A default does not make undefined a valid host write.",
-                    schema: zod_1.z.number().default(1),
-                    writable: true,
-                    source: (0, observable_1.observable)(1),
-                }),
-                (0, observables_1.defineObservable)({
-                    name: "coerced",
-                    description: "Coercion runs only after the host checks the incoming value.",
-                    schema: zod_1.z.coerce.number(),
-                    writable: true,
-                    source: (0, observable_1.observable)(1),
-                }),
-                (0, observables_1.defineObservable)({
-                    name: "declaredIr",
-                    description: "An IR declaration still has a host value type.",
-                    valueType: field_type_1.FieldType.number,
-                    writable: true,
-                    source: (0, observable_1.observable)(1),
-                }),
-                {
-                    name: "rawIr",
-                    description: "A raw IR member has the same host check.",
-                    valueType: field_type_1.FieldType.number,
-                    writable: true,
-                    persistentVar: { scope: "device", name: "rawIr", defaultValue: 1 },
-                },
-            ],
-        });
-        const host = (0, index_1.mockHostContract)(Counter, {
-            observables: { defaulted: 2, coerced: 2, declaredIr: 2, rawIr: 2 },
-        });
-        cleanups.push(() => host.dispose());
-        const counter = (0, host_contract_client_1.hostContract)(Counter.contractId, 1, { timeoutMs: 500 });
-        cleanups.push(() => counter.dispose());
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        const values = counter.observables;
-        // Access each lazy member before waiting for its initial read.
-        values.defaulted.subscribe(() => { });
-        values.coerced.subscribe(() => { });
-        values.declaredIr.subscribe(() => { });
-        values.rawIr.subscribe(() => { });
-        await flush();
-        values.defaulted(undefined);
-        values.coerced("3");
-        values.declaredIr("3");
-        values.rawIr("3");
-        await flush();
-        expect(errors).toHaveBeenCalledTimes(4);
-        for (const name of ["defaulted", "coerced", "declaredIr", "rawIr"]) {
-            expect(host.observables[name]()).toBe(2);
-            expect(values[name]()).toBe(2);
-            values[name](3);
-        }
-        await flush();
-        for (const name of ["defaulted", "coerced", "declaredIr", "rawIr"]) {
-            expect(host.observables[name]()).toBe(3);
-            expect(values[name]()).toBe(3);
-        }
-    });
-    test("events reach subscribers", async () => {
-        const host = start();
-        const payloads = [];
-        const subscription = client().events.saved.subscribe((payload) => payloads.push(payload));
-        await subscription.ready;
-        await host.events.saved.emit({ count: 2 });
-        await flush();
-        expect(payloads).toEqual([{ count: 2 }]);
-    });
-    test("onCall can delay or fail a call", async () => {
-        const calls = [];
-        let release;
-        const gate = new Promise((resolve) => {
-            release = resolve;
-        });
-        start({
-            tables: { Notes: [note("a")] },
-            onCall: async (call) => {
-                calls.push(call);
-                if (call.operation === "count")
-                    throw new Error("offline");
-                if (call.operation === "list")
-                    await gate;
-            },
-        });
-        const notes = client().tables.Notes;
-        await expect(notes.count()).rejects.toThrow("offline");
-        let listed = false;
-        const reading = notes.list().then(() => {
-            listed = true;
-        });
-        await flush();
-        expect(listed).toBe(false);
-        release();
-        await reading;
-        expect(calls.map((call) => `${call.member}.${call.name}.${call.operation}`)).toEqual([
-            "table.Notes.count",
-            "table.Notes.list",
-        ]);
-    });
-    test("checks names, runs one at a time, and disconnects on dispose", () => {
-        expect(() => (0, index_1.mockHostContract)(NotesContract, { tables: { Missing: [] } })).toThrow("has no table 'Missing'");
-        expect(() => (0, index_1.mockHostContract)(NotesContract, { tools: { missing: () => ({}) } })).toThrow("has no tool 'missing'");
-        expect(() => (0, index_1.mockHostContract)({})).toThrow("defineContract");
-        expect(() => (0, index_1.mockHostContract)(NotesContract, { observables: { typo: "dark" } })).toThrow("has no observable 'typo'");
-        const host = (0, index_1.mockHostContract)(NotesContract);
-        expect((0, host_contract_transport_1.getHostContractTransport)()).toBeDefined();
-        expect(() => (0, index_1.mockHostContract)(NotesContract)).toThrow("still running");
-        host.dispose();
-        host.dispose();
-        expect((0, host_contract_transport_1.getHostContractTransport)()).toBeUndefined();
-        (0, index_1.mockHostContract)(NotesContract).dispose();
-    });
-});