@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/contracts/__tests__/host-contract-client.test.js

@@ -1,793 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const userContext = require("../../context/user-context-singleton");
-const contract_ref_1 = require("../../define/contract-ref");
-const define_package_1 = require("../../define/define-package");
-const events_1 = require("../../define/events");
-const observables_1 = require("../../define/observables");
-const table_1 = require("../../define/table");
-const tool_1 = require("../../define/tool");
-const events_2 = require("../../events");
-const observable_1 = require("../../observable");
-const peer_id_1 = require("../../peer-id");
-const zod_types_1 = require("../../types/zod-types");
-const contract_proxy_1 = require("../contract-proxy");
-const contract_transport_1 = require("../contract-transport");
-const host_contract_client_1 = require("../host-contract-client");
-const hostTransport = require("../host-contract-transport");
-const host_contract_transport_1 = require("../host-contract-transport");
-const contractId = "00mvhostclient00000000001";
-const widgetSchema = zod_1.z.object({ widgetId: zod_types_1.zodPeerId, label: zod_1.z.string() });
-const Widgets = (0, table_1.defineTable)({
-    name: "Widgets",
-    description: "Widgets.",
-    primaryKeyName: "widgetId",
-    schema: widgetSchema,
-});
-const ping = (0, tool_1.defineTool)({
-    name: "ping",
-    usageDescription: "Echo.",
-    accessLevel: 0,
-    inputSchema: zod_1.z.object({ note: zod_1.z.string().optional() }),
-    outputSchema: zod_1.z.object({ label: zod_1.z.string(), note: zod_1.z.string().optional() }),
-    handler: () => ({ label: "" }),
-});
-const alert = (0, events_1.defineEvent)({
-    name: "alert",
-    description: "Something happened.",
-    payloadSchema: zod_1.z.object({ title: zod_1.z.string() }),
-});
-const count = (0, observables_1.defineObservable)({
-    name: "count",
-    description: "A writable count.",
-    schema: zod_1.z.number(),
-    writable: true,
-    source: (0, observable_1.observable)(0),
-});
-const status = (0, observables_1.defineObservable)({
-    name: "status",
-    description: "A read-only status.",
-    schema: zod_1.z.string(),
-    source: (0, observable_1.observable)("idle"),
-});
-const Main = (0, define_package_1.defineContract)({
-    contractId,
-    version: 1,
-    name: "Main",
-    tables: [Widgets],
-    tools: [ping],
-    events: [alert],
-    observables: [count, status],
-});
-const MainRef = (0, contract_ref_1.contractRef)(contractId, 1);
-/** Let fire-and-forget requests and pushes land. */
-const flush = async () => {
-    for (let i = 0; i < 5; i++) {
-        await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-};
-/** A provider session over its own transport, registered on `connect()`. */
-function host(label, beforeCall, afterCall) {
-    const rows = [{ widgetId: (0, peer_id_1.newid)(), label: "first" }];
-    const changes = new events_2.Emitter(`widgets-${(0, peer_id_1.newid)()}`);
-    const alerts = new events_2.Emitter(`alerts-${(0, peer_id_1.newid)()}`);
-    const live = { count: (0, observable_1.observable)(0), status: (0, observable_1.observable)("idle") };
-    const table = {
-        dataChanged: changes.event,
-        list: async () => rows,
-        get: async (id) => rows.find((row) => row.widgetId === id),
-        count: async () => rows.length,
-        findOne: async () => rows[0],
-        save: async (row) => {
-            rows.push(row);
-            return row;
-        },
-        delete: async (id) => {
-            rows.splice(rows.findIndex((row) => row.widgetId === id), 1);
-        },
-    };
-    const [consumerSide, providerSide] = (0, contract_transport_1.inProcessTransportPair)();
-    const calls = [];
-    const recording = {
-        emit: async (channel, ...args) => {
-            if (channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL) {
-                calls.push(args[0]);
-                await beforeCall?.(args[0]);
-            }
-            const result = await consumerSide.emit(channel, ...args);
-            return afterCall && channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL
-                ? afterCall(args[0], result)
-                : result;
-        },
-        on: (channel, handler) => consumerSide.on(channel, handler),
-    };
-    const session = (0, contract_proxy_1.createContractProviderSession)({
-        contractId,
-        version: 1,
-        tables: { Widgets: table },
-        tools: {
-            ping: {
-                tool: { name: "ping", usageDescription: "Echo.", accessLevel: 0 },
-                toolFn: async (input) => ({ label, ...input }),
-            },
-        },
-        events: { alert: alerts.event },
-        observables: live,
-        observableWritability: { count: true, status: false },
-    }, providerSide);
-    let unregister;
-    return {
-        label,
-        rows,
-        calls,
-        changes,
-        alerts,
-        ...live,
-        connect: () => {
-            unregister = (0, host_contract_transport_1.registerHostContractTransport)(recording);
-        },
-        dispose: () => {
-            unregister?.();
-            session.dispose();
-        },
-    };
-}
-const cleanups = [];
-afterEach(() => {
-    for (const cleanup of cleanups.splice(0).reverse()) {
-        cleanup();
-    }
-    jest.restoreAllMocks();
-});
-function setup(label = "a") {
-    const provider = host(label);
-    provider.connect();
-    const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-    cleanups.push(() => client.dispose(), () => provider.dispose());
-    return { provider, client };
-}
-describe("hostContract", () => {
-    test("calls tools and tables over the host transport, in the client's data context", async () => {
-        const { provider, client } = setup();
-        const pinged = await client.tools.ping({ note: "hi" });
-        expect(pinged).toEqual({ label: "a", note: "hi" });
-        expect(await client.tools.ping()).toEqual({ label: "a" });
-        const rows = await client.tables.Widgets.list({}, { pageSize: 5 });
-        expect(rows.map((row) => row.label)).toEqual(["first"]);
-        const added = await client.tables.Widgets.save({ widgetId: (0, peer_id_1.newid)(), label: "second" });
-        expect(added.label).toBe("second");
-        expect(await client.tables.Widgets.count()).toBe(2);
-        expect(await client.tables.Widgets.get("missing")).toBeUndefined();
-        await client.tables.Widgets.delete(added.widgetId);
-        expect(provider.rows).toHaveLength(1);
-        expect(provider.calls.map((call) => call.dataContextId)).toEqual(provider.calls.map(() => "group-1"));
-        expect(provider.calls.find((call) => call.operation === "list")?.args).toEqual([
-            {},
-            { pageSize: 5 },
-        ]);
-    });
-    test("a client can reach one provider", async () => {
-        const provider = host("a");
-        provider.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, {
-            dataContextId: async () => "group-1",
-            providerPackageId: "00mvprovider0000000000001",
-        });
-        cleanups.push(() => client.dispose(), () => provider.dispose());
-        await client.tools.ping();
-        await client.tables.Widgets.count();
-        expect(provider.calls.map((call) => call.providerPackageId)).toEqual([
-            "00mvprovider0000000000001",
-            "00mvprovider0000000000001",
-        ]);
-        // A client for one provider isn't the shared one.
-        expect(client).not.toBe((0, host_contract_client_1.hostContract)(MainRef));
-        expect(() => (0, host_contract_client_1.hostContract)(MainRef, { providerPackageId: 3 })).toThrow(/package id/);
-        for (const providerPackageId of ["", "  "]) {
-            expect(() => (0, host_contract_client_1.hostContract)(MainRef, { providerPackageId })).toThrow(/non-empty package id/);
-        }
-    });
-    test("provider choice follows observable reads, writes, events, and reconnects", async () => {
-        const providerPackageId = (0, peer_id_1.newid)();
-        const first = host("first");
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, {
-            dataContextId: async () => "group-1",
-            providerPackageId,
-        });
-        const second = host("second");
-        cleanups.push(() => client.dispose(), () => first.dispose(), () => second.dispose());
-        const values = client.observables.count;
-        const alerts = [];
-        const subscription = client.events.alert.subscribe((alert) => alerts.push(alert.title));
-        await subscription.ready;
-        await flush();
-        expect(values()).toBe(0);
-        values(5);
-        await flush();
-        expect(first.count()).toBe(5);
-        await first.alerts.emit({ title: "first" });
-        expect(alerts).toEqual(["first"]);
-        second.count(8);
-        second.connect();
-        await flush();
-        expect(values()).toBe(8);
-        await second.alerts.emit({ title: "second" });
-        expect(alerts).toEqual(["first", "second"]);
-        subscription.unsubscribe();
-        client.dispose();
-        await flush();
-        for (const provider of [first, second]) {
-            expect(provider.calls.map((call) => [call.member, call.operation])).toEqual(expect.arrayContaining([
-                ["observable", "subscribe"],
-                ["observable", "get"],
-                ["observable", "unsubscribe"],
-                ["event", "subscribe"],
-                ["event", "unsubscribe"],
-            ]));
-            expect(provider.calls.every((call) => call.providerPackageId === providerPackageId)).toBe(true);
-        }
-        expect(first.calls).toEqual(expect.arrayContaining([expect.objectContaining({ member: "observable", operation: "set" })]));
-    });
-    test("an observable can await its initial snapshot, and disposal ends a pending load", async () => {
-        let release;
-        const pending = new Promise((resolve) => {
-            release = resolve;
-        });
-        const provider = host("delayed", async (call) => {
-            if (call.member === "observable" && call.operation === "get")
-                await pending;
-        });
-        provider.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => provider.dispose(), release);
-        const value = client.observables.count;
-        const loaded = jest.fn();
-        void value.loadingPromise.then(loaded);
-        await flush();
-        expect(value()).toBeUndefined();
-        expect(loaded).not.toHaveBeenCalled();
-        release();
-        await value.loadingPromise;
-        expect(value()).toBe(0);
-        expect(loaded).toHaveBeenCalledTimes(1);
-        provider.dispose();
-        const next = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => next.dispose());
-        const status = next.observables.status;
-        next.dispose();
-        await expect(status.loadingPromise).resolves.toBeUndefined();
-    });
-    test("a failed initial observable read still settles loading", async () => {
-        const error = jest.spyOn(console, "error").mockImplementation(() => { });
-        const provider = host("failed", async (call) => {
-            if (call.member === "observable" && call.operation === "get")
-                throw new Error("offline");
-        });
-        provider.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => error.mockRestore(), () => client.dispose(), () => provider.dispose());
-        const value = client.observables.status;
-        await value.loadingPromise;
-        expect(value()).toBeUndefined();
-        expect(error).toHaveBeenCalledWith("Contract observable initial get failed", expect.objectContaining({ message: "offline" }));
-    });
-    test("a call waits for the host connection, then fails after the timeout", async () => {
-        const provider = host("late");
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => provider.dispose());
-        const waiting = client.tools.ping();
-        await flush();
-        provider.connect();
-        await expect(waiting).resolves.toEqual({ label: "late" });
-        const impatient = (0, host_contract_client_1.hostContract)(MainRef, {
-            dataContextId: async () => "group-1",
-            timeoutMs: 10,
-        });
-        cleanups.push(() => impatient.dispose());
-        provider.dispose();
-        await expect(impatient.tools.ping()).rejects.toThrow(/Timed out|timed out|timeout/i);
-    });
-    test("table and event subscriptions follow a reconnect and report it", async () => {
-        const first = host("first");
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const changes = [];
-        const alerts = [];
-        const reconnects = [];
-        client.tables.Widgets.dataChanged.subscribe((event) => changes.push(`${event.op}:${event.dataObject.label}`), { onReconnect: () => reconnects.push("table") });
-        client.events.alert.subscribe((payload) => alerts.push(payload.title), {
-            onReconnect: () => reconnects.push("event"),
-        });
-        await flush();
-        await first.changes.emit({
-            op: "insert",
-            dataObject: { widgetId: (0, peer_id_1.newid)(), label: "one" },
-            source: "local",
-        });
-        await first.alerts.emit({ title: "one" });
-        await flush();
-        expect(changes).toEqual(["insert:one"]);
-        expect(alerts).toEqual(["one"]);
-        expect(reconnects).toEqual([]);
-        const second = host("second");
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(reconnects.sort()).toEqual(["event", "table"]);
-        await first.changes.emit({
-            op: "insert",
-            dataObject: { widgetId: (0, peer_id_1.newid)(), label: "stale" },
-            source: "local",
-        });
-        await second.changes.emit({
-            op: "update",
-            dataObject: { widgetId: (0, peer_id_1.newid)(), label: "two" },
-            source: "remote",
-        });
-        await second.alerts.emit({ title: "two" });
-        await flush();
-        expect(changes).toEqual(["insert:one", "update:two"]);
-        expect(alerts).toEqual(["one", "two"]);
-        expect(await client.tools.ping()).toEqual({ label: "second" });
-    });
-    test("an unsubscribed subscription stays off across a reconnect", async () => {
-        const first = host("first");
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const alerts = [];
-        const subscription = client.events.alert.subscribe((payload) => alerts.push(payload.title));
-        await flush();
-        expect(subscription.unsubscribe()).toBe(true);
-        expect(subscription.unsubscribe()).toBe(false);
-        const second = host("second");
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        await second.alerts.emit({ title: "missed" });
-        await flush();
-        expect(alerts).toEqual([]);
-        expect(second.calls.filter((call) => call.member === "event")).toEqual([]);
-    });
-    test("observables mirror the provider, write through, and resync a refused write", async () => {
-        const { provider, client } = setup();
-        const countValue = client.observables.count;
-        await flush();
-        expect(countValue()).toBe(0);
-        provider.count(3);
-        await flush();
-        expect(countValue()).toBe(3);
-        countValue(7);
-        await flush();
-        expect(provider.count()).toBe(7);
-        const errors = jest.spyOn(console, "error").mockImplementation(() => undefined);
-        const statusValue = client.observables.status;
-        await flush();
-        expect(statusValue()).toBe("idle");
-        // @ts-expect-error a read-only declaration cannot be written by a typed caller
-        statusValue("hacked");
-        expect(statusValue()).toBe("hacked");
-        await flush();
-        expect(provider.status()).toBe("idle");
-        expect(statusValue()).toBe("idle");
-        expect(errors).toHaveBeenCalledWith("Contract observable set failed", expect.anything());
-    });
-    test("one observable's pending write does not block another observable", async () => {
-        const errors = jest.spyOn(console, "error").mockImplementation(() => undefined);
-        let release;
-        const provider = host("queues", async (call) => {
-            if (call.name === "count" && call.operation === "set") {
-                await new Promise((resolve) => {
-                    release = resolve;
-                });
-            }
-        });
-        provider.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => provider.dispose());
-        const count = client.observables.count;
-        const status = client.observables.status;
-        await flush();
-        count(7);
-        await flush();
-        expect(release).toBeDefined();
-        // @ts-expect-error exercise provider refusal for an untyped caller
-        status("refused");
-        await flush();
-        expect(errors).toHaveBeenCalledWith("Contract observable set failed", expect.anything());
-        expect(status()).toBe("idle");
-        release?.();
-        await flush();
-        expect(provider.count()).toBe(7);
-    });
-    test("a refused-write reread cannot overwrite a newer provider push", async () => {
-        jest.spyOn(console, "error").mockImplementation(() => undefined);
-        let delay = false;
-        let release;
-        const provider = host("stale", undefined, async (call, result) => {
-            if (delay && call.operation === "get") {
-                await new Promise((resolve) => {
-                    release = resolve;
-                });
-            }
-            return result;
-        });
-        provider.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => provider.dispose());
-        const value = client.observables.status;
-        await flush();
-        delay = true;
-        // @ts-expect-error exercise provider refusal for an untyped caller
-        value("refused");
-        await flush();
-        expect(release).toBeDefined();
-        provider.status("newer");
-        await flush();
-        expect(value()).toBe("newer");
-        release?.();
-        await flush();
-        expect(value()).toBe("newer");
-    });
-    test("observables read the new host's value after a reconnect", async () => {
-        const first = host("first");
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const seen = [];
-        client.observables.count.subscribe((value) => seen.push(value));
-        await flush();
-        const second = host("second");
-        second.count(42);
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(client.observables.count()).toBe(42);
-        second.count(43);
-        await flush();
-        expect(seen).toEqual([0, 42, 43]);
-    });
-    test("a write whose reply is lost with its connection does not hold later writes", async () => {
-        const errors = jest.spyOn(console, "error").mockImplementation(() => undefined);
-        // Like a dropped socket, the first host never answers the write.
-        const first = host("lost", (call) => call.member === "observable" && call.operation === "set"
-            ? new Promise(() => undefined)
-            : Promise.resolve());
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const value = client.observables.count;
-        await flush();
-        value(5);
-        await flush();
-        const second = host("second");
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(errors).toHaveBeenCalledWith("Contract observable set failed", expect.objectContaining({ message: expect.stringMatching(/replaced/) }));
-        // The lost write's outcome is unknown, so the copy follows the new host.
-        expect(value()).toBe(0);
-        value(6);
-        await flush();
-        expect(second.count()).toBe(6);
-        expect(value()).toBe(6);
-    });
-    test("a call whose reply is lost with its connection fails, and the next call uses the new host", async () => {
-        // Like a dropped socket, the first host never answers.
-        const first = host("lost", (call) => call.member === "tool" || call.member === "table"
-            ? new Promise(() => undefined)
-            : Promise.resolve());
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const tool = client.tools.ping({ note: "lost" });
-        const table = client.tables.Widgets.list();
-        const toolFailed = expect(tool).rejects.toThrow(/replaced/);
-        const tableFailed = expect(table).rejects.toThrow(/replaced/);
-        await flush();
-        const second = host("second");
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await toolFailed;
-        await tableFailed;
-        await expect(client.tools.ping({ note: "again" })).resolves.toEqual({
-            label: "second",
-            note: "again",
-        });
-    });
-    test("a call waiting for its reply fails when the host disconnects", async () => {
-        const first = host("lost", (call) => call.member === "tool" ? new Promise(() => undefined) : Promise.resolve());
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose());
-        const tool = client.tools.ping();
-        const failed = expect(tool).rejects.toThrow(/replaced/);
-        await flush();
-        first.dispose();
-        await failed;
-    });
-    test("a reply already on its way when the connection is replaced still lands", async () => {
-        let release;
-        const gate = new Promise((resolve) => {
-            release = resolve;
-        });
-        const first = host("old", undefined, async (call, result) => {
-            if (call.member === "tool" || call.member === "table")
-                await gate;
-            return result;
-        });
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        const second = host("new");
-        cleanups.push(() => client.dispose(), () => first.dispose(), () => second.dispose());
-        const tool = client.tools.ping({ note: "ran" });
-        const table = client.tables.Widgets.list();
-        await flush();
-        second.connect();
-        // The provider ran the call and its answer arrives in the same turn: it isn't reported
-        // as lost, so a caller doesn't retry a call that succeeded.
-        release();
-        await expect(tool).resolves.toEqual({ label: "old", note: "ran" });
-        await expect(table).resolves.toEqual(first.rows);
-    });
-    test("writes queued on a replaced connection cannot overwrite the new host's value", async () => {
-        jest.spyOn(console, "error").mockImplementation(() => undefined);
-        const first = host("lost", (call) => call.member === "observable" && call.operation === "set"
-            ? new Promise(() => undefined)
-            : Promise.resolve());
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const value = client.observables.count;
-        await flush();
-        value(5);
-        await flush();
-        value(6);
-        const second = host("second");
-        second.count(42);
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(second.calls.filter((call) => call.operation === "set")).toEqual([]);
-        expect(second.count()).toBe(42);
-        expect(value()).toBe(42);
-        value(7);
-        await flush();
-        expect(second.count()).toBe(7);
-        expect(value()).toBe(7);
-    });
-    test("after a disconnect, its queued writes are retired and writes made offline reach the next host", async () => {
-        jest.spyOn(console, "error").mockImplementation(() => undefined);
-        const first = host("dropped", (call) => call.member === "observable" && call.operation === "set"
-            ? new Promise(() => undefined)
-            : Promise.resolve());
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const value = client.observables.count;
-        await flush();
-        value(5);
-        await flush();
-        value(6);
-        // As in Electron, the dropped transport is unregistered before the next one registers.
-        first.dispose();
-        value(7);
-        await flush();
-        const second = host("second");
-        second.count(42);
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        const sets = second.calls.filter((call) => call.operation === "set");
-        expect(sets.map((call) => call.args?.[0])).toEqual([7]);
-        expect(second.count()).toBe(7);
-        expect(value()).toBe(7);
-    });
-    test("a refused-write reread lost with its connection does not hold later writes", async () => {
-        jest.spyOn(console, "error").mockImplementation(() => undefined);
-        let refuse = false;
-        const first = host("lost-reread", (call) => {
-            if (refuse && call.operation === "set")
-                return Promise.reject(new Error("refused"));
-            if (refuse && call.operation === "get")
-                return new Promise(() => undefined);
-            return Promise.resolve();
-        });
-        first.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const value = client.observables.count;
-        await flush();
-        refuse = true;
-        value(5);
-        await flush();
-        expect(first.calls.filter((call) => call.operation === "get")).toHaveLength(2);
-        const second = host("second");
-        second.count(42);
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(value()).toBe(42);
-        value(6);
-        await flush();
-        expect(second.count()).toBe(6);
-        expect(value()).toBe(6);
-    });
-    test("a write before the connection is sent once it connects", async () => {
-        const provider = host("late");
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose(), () => provider.dispose());
-        client.observables.count(5);
-        await flush();
-        provider.connect();
-        await flush();
-        expect(provider.count()).toBe(5);
-        expect(client.observables.count()).toBe(5);
-    });
-    test("writes while disconnected wait for the next mirror, and disposed mirrors refuse writes", async () => {
-        const { provider, client } = setup();
-        const value = client.observables.count;
-        await flush();
-        provider.dispose();
-        expect(() => value(9)).not.toThrow();
-        const second = host("second");
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(second.count()).toBe(9);
-        expect(value()).toBe(9);
-        client.dispose();
-        expect(() => value(10)).toThrow(/disposed/);
-        expect(value()).toBe(9);
-    });
-    test("dispose cancels pending calls", async () => {
-        jest.useFakeTimers();
-        try {
-            const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-            const waiting = client.tools.ping();
-            const rejected = expect(waiting).rejects.toThrow(/disposed/);
-            client.dispose();
-            // No need to wait for the ten-second connection timeout.
-            await rejected;
-            expect(jest.getTimerCount()).toBe(0);
-        }
-        finally {
-            jest.useRealTimers();
-        }
-    });
-    test("unsubscribing offline cancels its transport wait", async () => {
-        const wait = jest.spyOn(hostTransport, "waitForHostContractTransport");
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose());
-        const subscription = client.events.alert.subscribe(() => undefined);
-        const signal = wait.mock.calls[0][0]?.signal;
-        expect(signal?.aborted).toBe(false);
-        subscription.unsubscribe();
-        expect(signal?.aborted).toBe(true);
-        await expect(subscription.ready).resolves.toBe(false);
-    });
-    test("the default context uses the active group, then the personal context after reconnect", async () => {
-        let group = "group-1";
-        jest.spyOn(userContext, "getUserContext").mockResolvedValue({
-            userId: "user-1",
-            currentlyActiveGroupId: () => group,
-        });
-        const provider = host("default");
-        provider.connect();
-        const client = (0, host_contract_client_1.hostContract)(MainRef);
-        cleanups.push(() => client.dispose(), () => provider.dispose());
-        await client.tools.ping();
-        expect(provider.calls.at(-1)?.dataContextId).toBe("group-1");
-        group = "";
-        // Re-registering even the same transport must resolve the context for the new connection.
-        provider.connect();
-        await client.tools.ping();
-        expect(provider.calls.at(-1)?.dataContextId).toBe("user-1");
-    });
-    test("a new connection does not wait for the previous connection's context lookup", async () => {
-        const first = host("first");
-        const second = host("second");
-        first.connect();
-        const resolveContext = jest
-            .fn()
-            .mockImplementationOnce(() => new Promise(() => undefined))
-            .mockResolvedValue("group-2");
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: resolveContext });
-        cleanups.push(() => client.dispose(), () => first.dispose(), () => second.dispose());
-        const pending = client.tools.ping();
-        second.connect();
-        await expect(pending).resolves.toEqual({ label: "second" });
-        expect(second.calls.at(-1)?.dataContextId).toBe("group-2");
-    });
-    test("reconnect is reported only after the remote subscription is live", async () => {
-        const { provider, client } = setup();
-        const reconnect = jest.fn();
-        client.tables.Widgets.dataChanged.subscribe(() => undefined, { onReconnect: reconnect });
-        await flush();
-        provider.dispose();
-        let release;
-        const second = host("slow", async (call) => {
-            if (call.operation === "subscribe")
-                await new Promise((resolve) => {
-                    release = resolve;
-                });
-        });
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(release).toBeDefined();
-        expect(reconnect).not.toHaveBeenCalled();
-        release?.();
-        await flush();
-        expect(reconnect).toHaveBeenCalledTimes(1);
-    });
-    test("a subscription whose first attachment failed reports the next one as a reconnect", async () => {
-        jest.spyOn(console, "error").mockImplementation(() => undefined);
-        const first = host("first");
-        first.connect();
-        let failContext = true;
-        const client = (0, host_contract_client_1.hostContract)(MainRef, {
-            dataContextId: async () => {
-                if (failContext)
-                    throw new Error("no context yet");
-                return "group-1";
-            },
-        });
-        cleanups.push(() => client.dispose(), () => first.dispose());
-        const alerts = [];
-        const reconnect = jest.fn();
-        const subscription = client.events.alert.subscribe((payload) => alerts.push(payload.title), {
-            onReconnect: reconnect,
-        });
-        await expect(subscription.ready).resolves.toBe(false);
-        failContext = false;
-        const second = host("second");
-        cleanups.push(() => second.dispose());
-        second.connect();
-        await flush();
-        expect(reconnect).toHaveBeenCalledTimes(1);
-        await second.alerts.emit({ title: "live" });
-        await flush();
-        expect(alerts).toEqual(["live"]);
-    });
-    test("dispose ends subscriptions and refuses calls", async () => {
-        const { provider, client } = setup();
-        const alerts = [];
-        client.events.alert.subscribe((payload) => alerts.push(payload.title));
-        await flush();
-        client.dispose();
-        client.dispose();
-        await provider.alerts.emit({ title: "after" });
-        await flush();
-        expect(alerts).toEqual([]);
-        await expect(client.tools.ping()).rejects.toThrow(/disposed/);
-        expect(() => client.events.alert.subscribe(() => undefined)).toThrow(/disposed/);
-    });
-    test("one shared client per contract, and only references", () => {
-        expect((0, host_contract_client_1.hostContract)(MainRef)).toBe((0, host_contract_client_1.hostContract)(MainRef));
-        expect((0, host_contract_client_1.hostContract)((0, contract_ref_1.contractRef)(contractId, 1))).toBe((0, host_contract_client_1.hostContract)(MainRef));
-        const other = (0, host_contract_client_1.hostContract)(MainRef);
-        other.dispose();
-        expect((0, host_contract_client_1.hostContract)(MainRef)).not.toBe(other);
-        (0, host_contract_client_1.hostContract)(MainRef).dispose();
-        expect(() => (0, host_contract_client_1.hostContract)({ contractId, version: 1 })).toThrow(/contractRef/);
-        // Awaiting or logging a client's members calls nothing.
-        expect(JSON.stringify((0, host_contract_client_1.hostContract)(MainRef, {}).tools)).toBe("{}");
-    });
-    test("members are typed from the contract", () => {
-        const client = (0, host_contract_client_1.hostContract)(MainRef, { dataContextId: async () => "group-1" });
-        cleanups.push(() => client.dispose());
-        // @ts-expect-error no such tool
-        void client.tools.missing;
-        // @ts-expect-error no such table
-        void client.tables.Gadgets;
-        // @ts-expect-error alert carries a title
-        client.events.alert.subscribe((payload) => payload);
-        // @ts-expect-error count is a number
-        const text = client.observables.count;
-        void text;
-    });
-});