@marimo-team/islands 0.25.3-dev5 → 0.25.3-dev51

package/src/core/host/__tests__/events.test.ts

@@ -0,0 +1,49 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { z } from "zod";
+import { type NotebookEvent, parseNotebookEvent } from "../events";
+
+describe("notebook messages", () => {
+  it("normalizes session and host envelopes for native marimo messages", () => {
+    const notification = {
+      op: "variables",
+      variables: [{ name: "x", value: Number.NaN }],
+    };
+    expectTypeOf<
+      Extract<NotebookEvent, { event: "marimo" }>["data"]["marimo"]
+    >().toBeUnknown();
+    const host = { event: "marimo", data: { marimo: notification } };
+    expect(parseNotebookEvent({ data: notification })).toEqual(host);
+    expect(parseNotebookEvent({ ...host, id: "42" })).toEqual({
+      ...host,
+      id: "42",
+    });
+  });
+
+  it("retains unknown event cursors without interpreting their payloads", () => {
+    expect(
+      parseNotebookEvent({ event: "future", id: "42", data: null }),
+    ).toEqual({ event: "unknown", name: "future", id: "42" });
+  });
+
+  it("decodes known events outside the client's subscription filters", () => {
+    const event = {
+      event: "run.removed",
+      id: "42",
+      data: { id: "r1", time: "2026-10-19T12:00:00Z" },
+    };
+    expect(parseNotebookEvent(event)).toEqual(event);
+  });
+
+  it.each([
+    { event: "cell", id: "42", data: { cell: { id: "c1" } } },
+    { event: "run.removed", id: "42", data: {} },
+    { event: "ready", data: {} },
+    { event: "marimo", data: {} },
+    {},
+    null,
+  ])("rejects malformed known messages: %j", (message) => {
+    expect(() => parseNotebookEvent(message)).toThrow(z.ZodError);
+  });
+});

package/src/core/host/__tests__/fixtures.ts

@@ -0,0 +1,41 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import NodeFs from "node:fs";
+import NodeUrl from "node:url";
+import * as Protocol from "@marimo-team/client/protocol";
+
+/** Read the protocol's portable examples as transport messages. */
+export function fixtureMessages(name: string) {
+  const path = new NodeUrl.URL(
+    `../../../../../protocols/host/fixtures/${name}`,
+    import.meta.url,
+  );
+  return NodeFs.readFileSync(path, "utf8")
+    .split(/\r?\n\r?\n/)
+    .flatMap((frame) => {
+      const event = /^event: (.+)$/m.exec(frame)?.[1];
+      if (!event) {
+        return [];
+      }
+      const data = frame
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+      const payload: unknown = JSON.parse(data);
+      return [
+        {
+          event,
+          id: /^id: (.+)$/m.exec(frame)?.[1],
+          data: payload,
+        },
+      ];
+    });
+}
+
+/** Read the protocol's portable examples as decoded protocol events. */
+export function fixtureEvents(name: string): Protocol.EventOutput[] {
+  return fixtureMessages(name).map(({ id, ...message }) =>
+    Protocol.Event.parse(id === undefined ? message : { ...message, id }),
+  );
+}

package/src/core/host/__tests__/notebook-client.test.ts

@@ -0,0 +1,496 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+// @vitest-environment jsdom
+
+import { describe, expect, it, vi } from "vitest";
+import { createStore } from "jotai";
+import { ConnectionState } from "../../websocket/types";
+import { Deferred } from "@/utils/Deferred";
+import { jsonParseWithSpecialChar } from "@/utils/json/json-parser";
+import { classifyCloseEvent } from "../../websocket/connection-state";
+import { createNotebookClient } from "../notebook-client";
+import { fixtureEvents, fixtureMessages } from "./fixtures";
+
+function notebookMessage(id: string) {
+  const notebook = {
+    id,
+    project_id: "p1",
+    path: null,
+    name: id,
+    operations: [],
+    updated_at: null,
+  };
+  return JSON.stringify({ event: "notebook", data: { notebook } });
+}
+
+function setup(url: () => string = () => "ws://localhost/ws") {
+  const events = new EventTarget();
+  const healthy = new Deferred<void>();
+  let provider = url;
+  const urls: URL[] = [];
+  const transport = {
+    readyState: WebSocket.CLOSED,
+    reconnect: vi.fn(() => {
+      urls.push(new URL(provider()));
+    }),
+    close: vi.fn(() => events.dispatchEvent(new CloseEvent("close"))),
+    send: vi.fn(),
+    addEventListener: events.addEventListener.bind(events),
+    removeEventListener: events.removeEventListener.bind(events),
+  };
+  const onNotification = vi.fn();
+  const checkHealth = vi.fn(async () => true);
+  const store = createStore();
+  const controller = createNotebookClient(store);
+  const client = controller.client;
+  const connect = (signal: AbortSignal) =>
+    controller.connect({
+      createTransport: (next) => {
+        provider = next;
+        return transport;
+      },
+      url,
+      signal,
+      waitUntilReady: () => healthy.promise,
+      checkHealth,
+      onNotification: (notification) => onNotification({ data: notification }),
+      decodeJson: jsonParseWithSpecialChar,
+      classifyClose: classifyCloseEvent,
+    });
+  return {
+    events,
+    healthy,
+    transport,
+    client,
+    connect,
+    onNotification,
+    store,
+    checkHealth,
+    urls,
+    receive: (message: unknown) =>
+      events.dispatchEvent(
+        new MessageEvent("message", { data: JSON.stringify(message) }),
+      ),
+  };
+}
+
+describe("NotebookClient lifetime", () => {
+  it("exposes identity and capabilities only after the notebook is ready", async () => {
+    const { connect, healthy, events, receive, client, store } = setup();
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    healthy.resolve();
+    await healthy.promise;
+    events.dispatchEvent(new Event("open"));
+    const notebook = {
+      id: "nb/with space",
+      project_id: "p1",
+      path: null,
+      name: "Notebook",
+      operations: ["notebook.edit"],
+      updated_at: null,
+    };
+    receive({ event: "notebook", data: { notebook } });
+    expect(store.get(client.notebookAtom)).toBeNull();
+    receive({ event: "ready", id: "1", data: {} });
+    expect(store.get(client.notebookAtom)).toEqual(notebook);
+    receive({
+      event: "notebook",
+      id: "2",
+      data: { notebook: { ...notebook, operations: [] } },
+    });
+    expect(store.get(client.notebookAtom)?.operations).toEqual([]);
+    receive({ event: "notebook.removed", id: "3", data: { id: notebook.id } });
+    expect(store.get(client.notebookAtom)).toBeNull();
+    lifetime.abort();
+  });
+
+  it("rebuilds the replica after a reconnect reset selects a new notebook", async () => {
+    const notebookId = "n2";
+    const { connect, events, healthy, urls, receive, client, store } = setup(
+      () => "ws://localhost/ws?session_id=visitor",
+    );
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    healthy.resolve();
+    await healthy.promise;
+    events.dispatchEvent(new Event("open"));
+    fixtureMessages("notebook-events.sse").forEach(receive);
+    expect(store.get(client.documentAtom)?.revision.notebook_id).toBe("n1");
+
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(urls.at(-1)?.searchParams.get("cursor")).toBe("97");
+    expect(store.get(client.documentAtom)?.revision.notebook_id).toBe("n1");
+    expect(store.get(client.notebookAtom)).toBeNull();
+    events.dispatchEvent(new Event("open"));
+    receive({ event: "reset", data: {} });
+    expect(store.get(client.documentAtom)).toBeNull();
+    for (const event of fixtureMessages("notebook-events.sse")) {
+      receive(
+        JSON.parse(
+          JSON.stringify(event).replaceAll('"n1"', JSON.stringify(notebookId)),
+        ),
+      );
+    }
+    expect(store.get(client.documentAtom)?.revision.notebook_id).toBe(
+      notebookId,
+    );
+    expect(store.get(client.connectionAtom).state).toBe(ConnectionState.OPEN);
+    expect(store.get(client.notebookAtom)?.id).toBe(notebookId);
+    lifetime.abort();
+  });
+
+  it.each(["{broken", JSON.stringify({ event: "ready", data: {} })])(
+    "stops consuming a malformed host stream: %s",
+    (data) => {
+      const { connect, events, client, store, transport, onNotification } =
+        setup();
+      const lifetime = new AbortController();
+      connect(lifetime.signal);
+      events.dispatchEvent(new Event("open"));
+      events.dispatchEvent(new MessageEvent("message", { data }));
+      events.dispatchEvent(
+        new MessageEvent("message", {
+          data: JSON.stringify({
+            event: "marimo",
+            data: { marimo: { op: "reconnected" } },
+          }),
+        }),
+      );
+      expect(store.get(client.connectionAtom)).toEqual({
+        state: ConnectionState.CLOSED,
+        code: "KERNEL_DISCONNECTED",
+        reason: "Failed to decode notebook message",
+      });
+      expect(transport.close).toHaveBeenCalledOnce();
+      expect(onNotification).not.toHaveBeenCalled();
+      lifetime.abort();
+    },
+  );
+
+  it("resumes from the last cursor until reset or a new session", async () => {
+    const session = { id: "first", token: "a" };
+    const { connect, events, healthy, urls, receive } = setup(
+      () =>
+        `ws://localhost/ws?session_id=${session.id}&access_token=${session.token}&cursor=999`,
+    );
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    healthy.resolve();
+    await healthy.promise;
+    expect(urls[0].searchParams.get("cursor")).toBeNull();
+
+    const snapshot = fixtureMessages("notebook-events.sse");
+    events.dispatchEvent(new Event("open"));
+    for (const message of snapshot) {
+      receive(message);
+    }
+    session.token = "b";
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(urls[1].searchParams.get("cursor")).toBe("97");
+    expect(urls[1].searchParams.get("access_token")).toBe("b");
+
+    events.dispatchEvent(new Event("open"));
+    receive({ event: "reset", data: {} });
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(urls[2].searchParams.get("cursor")).toBeNull();
+
+    events.dispatchEvent(new Event("open"));
+    for (const message of snapshot) {
+      receive(message);
+    }
+    session.id = "second";
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(urls[3].searchParams.get("cursor")).toBeNull();
+    expect(urls[3].searchParams.get("session_id")).toBe("second");
+    lifetime.abort();
+  });
+
+  it("exposes the confirmed document until the lifetime ends", async () => {
+    const { connect, events, client, store, healthy, receive } = setup();
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    healthy.resolve();
+    await healthy.promise;
+    events.dispatchEvent(new Event("open"));
+    const snapshot = fixtureMessages("notebook-events.sse");
+    for (const message of snapshot.slice(0, -3)) {
+      receive(message);
+    }
+    expect(store.get(client.documentAtom)).toBeNull();
+    for (const message of snapshot.slice(-3)) {
+      receive(message);
+    }
+    expect(store.get(client.documentAtom)?.revision.order).toEqual([
+      "c1",
+      "c3",
+      "k7f2",
+    ]);
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(store.get(client.documentAtom)?.revision.order).toEqual([
+      "c1",
+      "c3",
+      "k7f2",
+    ]);
+    lifetime.abort();
+    expect(store.get(client.documentAtom)).toBeNull();
+  });
+
+  it("stops consuming a stream whose notebook changes", () => {
+    const { connect, events, client, store, transport } = setup();
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    events.dispatchEvent(new Event("open"));
+    for (const id of ["n1", "n2"]) {
+      events.dispatchEvent(
+        new MessageEvent("message", { data: notebookMessage(id) }),
+      );
+    }
+    expect(store.get(client.connectionAtom)).toEqual({
+      state: ConnectionState.CLOSED,
+      code: "KERNEL_DISCONNECTED",
+      reason: "Failed to decode notebook message",
+    });
+    expect(transport.close).toHaveBeenCalledOnce();
+    lifetime.abort();
+  });
+
+  it.each(["MARIMO_UNAUTHORIZED", "MARIMO_TRANSPORT_EXHAUSTED"])(
+    "stops automatic recovery after %s but permits an explicit reconnect",
+    async (reason) => {
+      const {
+        connect,
+        client,
+        store,
+        events,
+        transport,
+        healthy,
+        checkHealth,
+      } = setup();
+      const lifetime = new AbortController();
+      connect(lifetime.signal);
+      healthy.resolve();
+      await healthy.promise;
+      events.dispatchEvent(new CloseEvent("close", { reason }));
+      events.dispatchEvent(new Event("error"));
+      expect(store.get(client.connectionAtom).state).toBe(
+        ConnectionState.CLOSED,
+      );
+      expect(transport.reconnect).toHaveBeenCalledOnce();
+      await client.reconnect();
+      expect(checkHealth).toHaveBeenCalledOnce();
+      expect(transport.reconnect).toHaveBeenCalledTimes(2);
+      lifetime.abort();
+    },
+  );
+
+  it("only resets the automatic retry budget after an open event", () => {
+    const { connect, events, transport } = setup();
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    events.dispatchEvent(new CloseEvent("close"));
+    events.dispatchEvent(new Event("error"));
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(transport.reconnect).toHaveBeenCalledOnce();
+    events.dispatchEvent(new Event("open"));
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(transport.reconnect).toHaveBeenCalledTimes(2);
+    lifetime.abort();
+  });
+
+  it("does not revive an aborted lifetime when a manual health check finishes", async () => {
+    const { connect, client, transport, checkHealth } = setup();
+    const health = new Deferred<boolean>();
+    checkHealth.mockReturnValue(health.promise);
+    const lifetime = new AbortController();
+    connect(lifetime.signal);
+    const attempt = client.reconnect();
+    lifetime.abort();
+    health.resolve(true);
+    await attempt;
+    expect(transport.reconnect).not.toHaveBeenCalled();
+  });
+
+  it("does not connect after abort, even when the health check finishes", async () => {
+    const { client, connect, healthy, transport } = setup();
+    const controller = new AbortController();
+    connect(controller.signal);
+    controller.abort();
+    healthy.resolve();
+    await healthy.promise;
+    client.reconnect();
+    expect(transport.reconnect).not.toHaveBeenCalled();
+    expect(transport.close).toHaveBeenCalledOnce();
+  });
+
+  it("detaches listeners before closing so cleanup cannot trigger a session retry", () => {
+    const { connect, client, store, events, transport, onNotification } =
+      setup();
+    const controller = new AbortController();
+    connect(controller.signal);
+    controller.abort();
+    events.dispatchEvent(
+      new MessageEvent("message", {
+        data: JSON.stringify({ data: { op: "reconnected" } }),
+      }),
+    );
+    expect(transport.reconnect).not.toHaveBeenCalled();
+    expect(store.get(client.connectionAtom)).toEqual({
+      state: ConnectionState.NOT_STARTED,
+    });
+    expect(onNotification).not.toHaveBeenCalled();
+  });
+
+  it("can reconnect after effect cleanup without reviving the earlier client attempt", async () => {
+    const { connect, healthy, transport, events, onNotification } = setup();
+    const first = new AbortController();
+    connect(first.signal);
+    first.abort();
+    const second = new AbortController();
+    connect(second.signal);
+    healthy.resolve();
+    await healthy.promise;
+    expect(transport.reconnect).toHaveBeenCalledOnce();
+    events.dispatchEvent(
+      new MessageEvent("message", {
+        data: JSON.stringify({
+          event: "marimo",
+          data: { marimo: { op: "reconnected" } },
+        }),
+      }),
+    );
+    expect(onNotification).toHaveBeenCalledExactlyOnceWith({
+      data: { op: "reconnected" },
+    });
+    second.abort();
+  });
+});
+
+async function open() {
+  const url = vi.fn(() => "ws://localhost/ws?session_id=first&cursor=999");
+  const setupResult = setup(url);
+  const lifetime = new AbortController();
+  setupResult.connect(lifetime.signal);
+  setupResult.healthy.resolve();
+  await setupResult.healthy.promise;
+  setupResult.events.dispatchEvent(new Event("open"));
+  return { ...setupResult, lifetime, url };
+}
+
+describe("NotebookClient attachments", () => {
+  const [browser, agent] = fixtureEvents("notebook-events.sse").flatMap(
+    (event) => (event.event === "attachment" ? [event.data.attachment] : []),
+  );
+
+  it("publishes a complete snapshot and applies live changes independently of kernel readiness", async () => {
+    const { client, store, receive, lifetime } = await open();
+    const snapshot = fixtureMessages("notebook-events.sse");
+    const readyIndex = snapshot.findIndex((event) => event.event === "ready");
+    snapshot.slice(0, readyIndex).forEach(receive);
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    snapshot.slice(readyIndex).forEach(receive);
+    expect(store.get(client.attachmentsAtom)).toEqual([browser, agent]);
+    const renamed = { ...agent, name: "Renamed agent" };
+    receive({ event: "attachment", id: "98", data: { attachment: renamed } });
+    receive({
+      event: "attachment.removed",
+      id: "99",
+      data: { id: browser.id },
+    });
+    expect(store.get(client.attachmentsAtom)).toEqual([renamed]);
+    receive({ data: { op: "kernel-ready", resumed: false } });
+    expect(store.get(client.attachmentsAtom)).toEqual([renamed]);
+    receive({ event: "attachment.removed", id: "100", data: { id: agent.id } });
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    lifetime.abort();
+  });
+
+  it("resumes attachments alongside an incomplete document and waits for replay ready", async () => {
+    const { client, store, receive, events, urls, lifetime } = await open();
+    expect(urls[0].searchParams.has("cursor")).toBe(false);
+    fixtureMessages("notebook-events.sse").forEach(receive);
+    const confirmed = store.get(client.documentAtom);
+    const edits = fixtureMessages("edits.sse");
+    edits.slice(0, 3).forEach(receive);
+    const renamed = { ...agent, name: "Renamed agent" };
+    receive({ event: "attachment", id: "112a", data: { attachment: renamed } });
+    expect(store.get(client.attachmentsAtom)).toEqual([browser, renamed]);
+    events.dispatchEvent(new CloseEvent("close"));
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    expect(urls.at(-1)!.searchParams.get("cursor")).toBe("112a");
+    events.dispatchEvent(new Event("open"));
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    expect(store.get(client.documentAtom)).toBe(confirmed);
+    edits.slice(3).forEach(receive);
+    receive({
+      event: "attachment.removed",
+      id: "115",
+      data: { id: browser.id },
+    });
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    receive({ event: "ready", id: "116", data: {} });
+    expect(store.get(client.attachmentsAtom)).toEqual([renamed]);
+    const revisions = fixtureEvents("edits.sse").flatMap((event) =>
+      event.event === "document" ? [event.data.document] : [],
+    );
+    expect(store.get(client.documentAtom)?.revision).toEqual(revisions.at(-1));
+    lifetime.abort();
+  });
+
+  it("replaces stale attachments with an empty snapshot after reset", async () => {
+    const { client, store, receive, lifetime } = await open();
+    fixtureMessages("notebook-events.sse").forEach(receive);
+    receive({ event: "reset", data: {} });
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    fixtureMessages("notebook-events.sse")
+      .filter((event) => event.event !== "attachment")
+      .forEach(receive);
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    lifetime.abort();
+  });
+
+  it.each(["close", "error", "malformed", "removed", "abort", "identity"])(
+    "clears presence on %s and ignores messages after disposal",
+    async (reason) => {
+      const { client, store, receive, events, url, lifetime } = await open();
+      fixtureMessages("notebook-events.sse").forEach(receive);
+      expect(store.get(client.attachmentsAtom)).toEqual([browser, agent]);
+      switch (reason) {
+        case "close":
+          events.dispatchEvent(
+            new CloseEvent("close", { reason: "MARIMO_UNAUTHORIZED" }),
+          );
+          break;
+        case "error":
+          events.dispatchEvent(new Event("error"));
+          break;
+        case "malformed":
+          receive({ event: "attachment", id: "98", data: {} });
+          break;
+        case "removed":
+          receive({ event: "notebook.removed", id: "98", data: { id: "n1" } });
+          break;
+        case "identity":
+          url.mockReturnValue(
+            "ws://localhost/api/marimo/v1/notebooks/n2/events/ws",
+          );
+          events.dispatchEvent(new CloseEvent("close"));
+          receive({ event: "ready", id: "98", data: {} });
+          break;
+        default:
+          lifetime.abort();
+      }
+      expect(store.get(client.attachmentsAtom)).toEqual([]);
+      lifetime.abort();
+      fixtureMessages("notebook-events.sse").forEach(receive);
+      expect(store.get(client.attachmentsAtom)).toEqual([]);
+    },
+  );
+
+  it("keeps host resources empty for notification-only WASM connections", async () => {
+    const { client, store, receive, lifetime } = await open();
+    receive({ data: { op: "kernel-ready" } });
+    receive({ data: { op: "reconnected" } });
+    expect(store.get(client.attachmentsAtom)).toEqual([]);
+    lifetime.abort();
+  });
+});

package/src/core/host/connection.ts

@@ -0,0 +1,81 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+export const ConnectionState = {
+  NOT_STARTED: "NOT_STARTED",
+  CONNECTING: "CONNECTING",
+  OPEN: "OPEN",
+  CLOSING: "CLOSING",
+  CLOSED: "CLOSED",
+} as const;
+
+export type ConnectionState =
+  (typeof ConnectionState)[keyof typeof ConnectionState];
+
+export const ConnectionClosedReason = {
+  KERNEL_DISCONNECTED: "KERNEL_DISCONNECTED",
+  KERNEL_STARTUP_ERROR: "KERNEL_STARTUP_ERROR",
+} as const;
+
+export type ConnectionClosedReason =
+  (typeof ConnectionClosedReason)[keyof typeof ConnectionClosedReason];
+
+export type ConnectionStatus =
+  | {
+      state: typeof ConnectionState.CLOSED;
+      code: ConnectionClosedReason;
+      reason: string;
+    }
+  | {
+      state: typeof ConnectionState.CONNECTING;
+    }
+  | {
+      state:
+        | typeof ConnectionState.OPEN
+        | typeof ConnectionState.CLOSING
+        | typeof ConnectionState.NOT_STARTED;
+    };
+
+/** The recovery policy for a closed connection. */
+export interface CloseDecision {
+  kind: "terminal" | "gave-up" | "retry";
+  status: ConnectionStatus;
+}
+
+export type ConnectionEvent = "open" | "close" | "message" | "error";
+
+export interface IConnectionTransportMap {
+  open: WebSocketEventMap["open"];
+  message: WebSocketEventMap["message"];
+  close: WebSocketEventMap["close"];
+  error: WebSocketEventMap["error"];
+}
+
+export type ConnectionTransportCallback<T extends ConnectionEvent> = (
+  data: IConnectionTransportMap[T],
+) => void;
+
+/** Transport readiness, using the WebSocket readyState values. */
+export const TransportReadyState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3,
+} as const;
+
+export type TransportReadyState =
+  (typeof TransportReadyState)[keyof typeof TransportReadyState];
+
+/** A reconnectable source of notebook messages. */
+export interface NotebookTransport {
+  reconnect(code?: number | undefined, reason?: string | undefined): void;
+  close(): void;
+  addEventListener<T extends ConnectionEvent>(
+    event: T,
+    callback: ConnectionTransportCallback<T>,
+  ): void;
+  removeEventListener<T extends ConnectionEvent>(
+    event: T,
+    callback: ConnectionTransportCallback<T>,
+  ): void;
+  readyState: TransportReadyState;
+}