@peers-app/peers-sdk 0.26.5 → 0.27.0

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

@@ -0,0 +1,793 @@
+"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;
+    });
+});