@tribe-nest/media-client 0.1.0

package/src/core/_tests/signal.spec.ts

@@ -0,0 +1,347 @@
+import { MEDIA_PROTOCOL_VERSION, MediaError } from "@tribe-nest/media-protocol";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { MediaSignal, assertTokenNotInUrl, type DisconnectCause, type SignalLogLevel } from "../signal";
+import { FakeSignalServer, flush } from "./fakeSignalServer";
+
+const MEDIA_URL = "wss://media.example/signal";
+
+type Harness = {
+  server: FakeSignalServer;
+  signal: MediaSignal;
+  logs: { level: SignalLogLevel; message: string }[];
+  closes: DisconnectCause[];
+};
+
+function harness(options: ConstructorParameters<typeof FakeSignalServer>[0] = {}, mediaUrl = MEDIA_URL): Harness {
+  const server = new FakeSignalServer(options);
+  const logs: { level: SignalLogLevel; message: string }[] = [];
+  const closes: DisconnectCause[] = [];
+  const signal = new MediaSignal({
+    getCredentials: () => ({ mediaUrl, token: "join-ticket" }),
+    webSocket: server.factory,
+    onLog: (level, message) => logs.push({ level, message }),
+  });
+  signal.onClose((cause) => closes.push(cause));
+  return { server, signal, logs, closes };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("the handshake", () => {
+  it("sends the token in the FIRST frame and never in the URL", async () => {
+    const { server, signal } = harness();
+    await signal.connect();
+
+    // The whole reason the token is not a query parameter: a query string lands
+    // in load-balancer access logs, and a join ticket in a log is a join ticket
+    // for anyone who can read logs.
+    expect(server.urls).toEqual([MEDIA_URL]);
+    expect(server.urls[0]).not.toContain("join-ticket");
+
+    const first = server.received[0];
+    expect(first?.method).toBe("join");
+    expect(first).toMatchObject({ method: "join", id: 0, token: "join-ticket", protocolVersion: MEDIA_PROTOCOL_VERSION });
+    expect(server.invalidFrames).toEqual([]);
+  });
+
+  it("refuses a mediaUrl that carries a token in the query string", async () => {
+    const { server, signal } = harness({}, `${MEDIA_URL}?token=leaked`);
+    await expect(signal.connect()).rejects.toThrow(/first frame/);
+    // Refused BEFORE opening anything: nothing must reach the balancer's log.
+    expect(server.urls).toEqual([]);
+  });
+
+  it("guards every query-parameter spelling of a credential", () => {
+    expect(() => assertTokenNotInUrl("wss://m/s?access_token=x")).toThrow();
+    expect(() => assertTokenNotInUrl("wss://m/s?jwt=x")).toThrow();
+    expect(() => assertTokenNotInUrl("wss://m/s?ticket=x")).toThrow();
+    expect(() => assertTokenNotInUrl("wss://m/s?authorization=x")).toThrow();
+    expect(() => assertTokenNotInUrl("wss://m/s?region=eu")).not.toThrow();
+  });
+
+  it("resolves only when BOTH the reply and the joined event have arrived, in either order", async () => {
+    for (const joinOrder of ["reply-first", "event-first"] as const) {
+      const { signal } = harness({ joinOrder });
+      const joined = await signal.connect();
+      expect(joined.event).toBe("joined");
+      expect(joined.room).toBe("room-1");
+      expect(signal.identity).toBe("u-1");
+      expect(signal.phase).toBe("joined");
+      signal.close();
+    }
+  });
+
+  it("does not resolve on the reply alone", async () => {
+    // The reply says the token was accepted; the EVENT carries the router
+    // capabilities, the peer snapshot and the recording flag. Resolving early
+    // hands the caller a room it knows nothing about.
+    const { server, signal } = harness({ autoJoin: false, onRequest: (frame, socket, srv) => {
+      if (frame.method === "join") srv.reply(frame.id, { accepted: true }, socket);
+    } });
+
+    let settled = false;
+    const pending = signal.connect().then(() => (settled = true));
+    await flush(8);
+    expect(settled).toBe(false);
+
+    server.event(server.joinedFrame());
+    await pending;
+    expect(settled).toBe(true);
+  });
+
+  it("rejects with the refusal code and closes the socket", async () => {
+    const { server, signal, closes } = harness({ autoJoin: false, onRequest: (frame, socket, srv) => {
+      if (frame.method === "join") srv.fail(frame.id, "unauthorized", "no", socket);
+    } });
+
+    await expect(signal.connect()).rejects.toMatchObject({ name: "MediaError", code: "unauthorized" });
+    expect(signal.phase).toBe("closed");
+    expect(closes).toEqual([{ type: "refused", code: "unauthorized", message: "no" }]);
+    expect(server.socket.readyState).toBe(3);
+  });
+
+  /**
+   * `close()` during the credential fetch.
+   *
+   * This is the one window in a connect that has no socket in it yet, so it is
+   * the one window `close()` cannot reach: it flips the phase and returns. The
+   * window is not small, either, because fetching a ticket is a network round
+   * trip of its own. Everything after it is cancelled by `handleClose`, which
+   * is why the check is here and not repeated at every step.
+   */
+  it("opens no socket when close() lands inside the credential fetch", async () => {
+    const server = new FakeSignalServer();
+    let release: (() => void) | undefined;
+    const held = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const signal = new MediaSignal({
+      getCredentials: async () => {
+        await held;
+        return { mediaUrl: MEDIA_URL, token: "join-ticket" };
+      },
+      webSocket: server.factory,
+    });
+
+    const connecting = signal.connect().then(
+      () => null,
+      (error: Error) => error,
+    );
+    await flush();
+
+    signal.close();
+    release?.();
+    const error = await connecting;
+    await flush();
+
+    expect(error).toBeInstanceOf(MediaError);
+    expect(error?.message).toMatch(/abandoned/);
+    // Not "a socket that was then closed": no socket, and no `join`. Otherwise
+    // the caller has closed and moved on while this attempt goes on to JOIN
+    // with a live token, leaving a participant in the room that nothing holds a
+    // reference to and nothing will ever close.
+    expect(server.sockets).toEqual([]);
+    expect(server.received).toEqual([]);
+    expect(signal.phase).toBe("closed");
+  });
+
+  it("opens one socket, not two, when a second connect starts inside the first credential fetch", async () => {
+    const server = new FakeSignalServer();
+    const gates: (() => void)[] = [];
+    const signal = new MediaSignal({
+      getCredentials: () =>
+        new Promise((resolve) => {
+          gates.push(() => resolve({ mediaUrl: MEDIA_URL, token: "join-ticket" }));
+        }),
+      webSocket: server.factory,
+    });
+
+    const abandoned = signal.connect().then(
+      () => null,
+      (error: Error) => error,
+    );
+    await flush();
+    // The reconnect policy gives up on the first attempt and starts another.
+    // `connect()` permits that once the phase is `closed`.
+    signal.close();
+    const second = signal.connect();
+    await flush();
+
+    gates[1]?.();
+    gates[0]?.();
+    await flush(8);
+
+    expect(await abandoned).toBeInstanceOf(MediaError);
+    await expect(second).resolves.toMatchObject({ event: "joined" });
+    // The abandoned attempt must not open a socket of its own, and must not
+    // close the one the live attempt is using either.
+    expect(server.sockets).toHaveLength(1);
+    expect(signal.phase).toBe("joined");
+  });
+});
+
+describe("request and reply correlation", () => {
+  it("routes each reply to its own request, whatever order they arrive in", async () => {
+    const ids: number[] = [];
+    const { server, signal } = harness({ onRequest: (frame) => {
+      if (frame.method !== "join") ids.push(frame.id);
+    } });
+    await signal.connect();
+
+    const first = signal.request({ method: "pauseProducer", producerId: "p-1" });
+    const second = signal.request({ method: "resumeProducer", producerId: "p-2" });
+    await flush();
+
+    const [idA, idB] = ids as [number, number];
+    expect(idA).not.toBe(idB);
+    // Deliberately answered out of order.
+    server.reply(idB, { producerId: "p-2" });
+    server.reply(idA, { producerId: "p-1" });
+
+    expect(await first).toEqual({ producerId: "p-1" });
+    expect(await second).toEqual({ producerId: "p-2" });
+  });
+
+  it("turns an ok:false reply into a MediaError carrying the code", async () => {
+    const { signal } = harness({ onRequest: (frame, socket, srv) => {
+      if (frame.method === "consume") srv.fail(frame.id, "not_subscribable", undefined, socket);
+    } });
+    await signal.connect();
+
+    const error = await signal
+      .request({ method: "consume", transportId: "t-1", producerId: "p-9", rtpCapabilities: {} })
+      .catch((e: unknown) => e);
+
+    expect(error).toBeInstanceOf(MediaError);
+    expect((error as MediaError).code).toBe("not_subscribable");
+  });
+
+  it("ignores a second reply to an id it has already settled", async () => {
+    // "exactly one reply with that id" is the protocol. A node that breaks it
+    // must not corrupt the client, and must not do it quietly either.
+    const { signal, logs } = harness({ onRequest: (frame, socket, srv) => {
+      if (frame.method === "closeProducer") {
+        srv.reply(frame.id, { closed: true }, socket);
+        srv.reply(frame.id, { closed: "again" }, socket);
+      }
+    } });
+    await signal.connect();
+
+    expect(await signal.request({ method: "closeProducer", producerId: "p-1" })).toEqual({ closed: true });
+    await flush();
+    expect(logs.some((l) => l.message.includes("unknown request id"))).toBe(true);
+  });
+
+  it("times out a request that is never answered", async () => {
+    vi.useFakeTimers();
+    const { signal } = harness();
+    await signal.connect();
+
+    const pending = signal.request({ method: "requestKeyFrame", consumerId: "c-1" }, 5_000);
+    // Attached before the clock moves: the rejection lands inside
+    // `advanceTimersByTimeAsync`, and an unattached one is an unhandled error.
+    const settled = expect(pending).rejects.toThrow(/no reply to requestKeyFrame/);
+    await vi.advanceTimersByTimeAsync(5_001);
+    await settled;
+  });
+
+  it("refuses to send once the connection is closed", async () => {
+    const { signal } = harness();
+    await signal.connect();
+    signal.close();
+    await expect(signal.request({ method: "leave" })).rejects.toMatchObject({ code: "internal" });
+  });
+});
+
+describe("events", () => {
+  it("dispatches to typed and catch-all handlers, in arrival order", async () => {
+    const { server, signal } = harness();
+    await signal.connect();
+
+    const appeared: string[] = [];
+    const all: string[] = [];
+    signal.on("producerAppeared", (frame) => appeared.push(frame.producerId));
+    signal.onAny((frame) => all.push(frame.event));
+
+    server.event({ event: "producerAppeared", producerId: "p-1", identity: "u-2", kind: "audio" });
+    server.event({ event: "activeSpeakers", producerIds: ["p-1"] });
+    await flush();
+
+    expect(appeared).toEqual(["p-1"]);
+    expect(all).toEqual(["producerAppeared", "activeSpeakers"]);
+  });
+
+  it("drops a frame the protocol does not describe without killing the session", async () => {
+    // A node that gains a frame in a later version must not end an older
+    // client's live call.
+    const { server, signal, logs } = harness();
+    await signal.connect();
+    const seen: string[] = [];
+    signal.onAny((frame) => seen.push(frame.event));
+
+    server.raw({ event: "somethingNewer", detail: 1 });
+    server.raw("not json at all");
+    server.event({ event: "recordingChanged", recording: true });
+    await flush();
+
+    expect(seen).toEqual(["recordingChanged"]);
+    expect(logs.filter((l) => l.level === "warn")).toHaveLength(2);
+    expect(signal.phase).toBe("joined");
+  });
+});
+
+describe("why the connection ended", () => {
+  it("reports draining, with the window the node asked for", async () => {
+    const { server, signal, closes } = harness();
+    await signal.connect();
+
+    server.event({ event: "draining", reconnectAfterMs: 5_000 });
+    await flush();
+    server.socket.dropFromServer();
+    await flush();
+
+    // Recorded from the event, because by the time the socket closes the reason
+    // is gone - and "retry this node" is exactly the wrong response.
+    expect(closes).toEqual([{ type: "draining", reconnectAfterMs: 5_000 }]);
+  });
+
+  it("reports a closed room rather than a dropped socket", async () => {
+    const { server, signal, closes } = harness();
+    await signal.connect();
+
+    server.event({ event: "roomClosed", reason: "ended_by_host" });
+    await flush();
+    server.socket.dropFromServer();
+    await flush();
+
+    expect(closes).toEqual([{ type: "room_closed", reason: "ended_by_host" }]);
+  });
+
+  it("reports a bare socket drop, and rejects everything still in flight", async () => {
+    const { server, signal, closes } = harness({ onRequest: () => undefined });
+    await signal.connect();
+
+    const pending = signal.request({ method: "createTransport", direction: "send" });
+    await flush();
+    server.socket.dropFromServer(1006, "gone");
+    await flush();
+
+    await expect(pending).rejects.toThrow(/closed before a reply arrived/);
+    expect(closes).toEqual([{ type: "socket_closed", code: 1006, reason: "gone" }]);
+  });
+
+  it("reports a client-initiated close, and leave() sends the frame first", async () => {
+    const { server, signal, closes } = harness({ onRequest: (frame, socket, srv) => {
+      if (frame.method === "leave") srv.reply(frame.id, {}, socket);
+    } });
+    await signal.connect();
+
+    await signal.leave();
+    expect(server.lastRequest("leave")).toBeDefined();
+    expect(closes).toEqual([{ type: "closed_by_client" }]);
+    expect(signal.phase).toBe("closed");
+  });
+});

package/src/core/_tests/state.spec.ts

@@ -0,0 +1,226 @@
+import type { EventFrame } from "@tribe-nest/media-protocol";
+import { describe, expect, it } from "vitest";
+
+import {
+  visibleProducers,
+  activeProducers,
+  initialRoomState,
+  producerById,
+  producersOf,
+  reduceRoomState,
+  reduceRoomStateAll,
+  type RoomState,
+} from "../state";
+
+const joined = (overrides: Partial<Extract<EventFrame, { event: "joined" }>> = {}): EventFrame => ({
+  event: "joined",
+  identity: "me",
+  room: "room-1",
+  routerRtpCapabilities: {},
+  peers: [
+    { identity: "a", name: "Ada", kind: "human" },
+    { identity: "b", kind: "human" },
+  ],
+  producers: [
+    { producerId: "pa", identity: "a", kind: "audio" },
+    { producerId: "pb", identity: "b", kind: "video" },
+  ],
+  iceServers: [],
+  recording: false,
+  ...overrides,
+});
+
+const afterJoin = (overrides?: Partial<Extract<EventFrame, { event: "joined" }>>): RoomState =>
+  reduceRoomState(initialRoomState, joined(overrides));
+
+describe("joining", () => {
+  it("replaces the whole room rather than merging", () => {
+    // `joined` also arrives after a reconnect. Merging would leave peers who
+    // left while we were away on screen for the rest of the call.
+    const stale = reduceRoomState(afterJoin(), { event: "peerJoined", peer: { identity: "ghost", kind: "human" } });
+    const rejoined = reduceRoomState(stale, joined({ peers: [{ identity: "a", kind: "human" }], producers: [] }));
+
+    expect(rejoined.peers.map((p) => p.identity)).toEqual(["a"]);
+    expect(rejoined.producers).toEqual([]);
+    expect(rejoined.identity).toBe("me");
+    expect(rejoined.phase).toBe("joined");
+  });
+
+  it("clears a drain flag from the previous connection", () => {
+    const draining = reduceRoomState(afterJoin(), { event: "draining", reconnectAfterMs: 3_000 });
+    expect(draining.draining).toEqual({ reconnectAfterMs: 3_000 });
+    expect(reduceRoomState(draining, joined()).draining).toBeNull();
+  });
+
+  it("carries the recording flag from the snapshot and follows it", () => {
+    const state = afterJoin({ recording: true });
+    expect(state.recording).toBe(true);
+    expect(reduceRoomState(state, { event: "recordingChanged", recording: false }).recording).toBe(false);
+  });
+});
+
+describe("peers and producers", () => {
+  it("drops a departing peer's producers, and the speaker slots holding them", () => {
+    // A `producerClosed` for each is NOT guaranteed when a peer's socket simply
+    // dies. A producer left behind is a tile that never clears.
+    const state = reduceRoomState(afterJoin(), { event: "activeSpeakers", producerIds: ["pa", "pb"] });
+    const after = reduceRoomState(state, { event: "peerLeft", identity: "a" });
+
+    expect(after.peers.map((p) => p.identity)).toEqual(["b"]);
+    expect(after.producers.map((p) => p.producerId)).toEqual(["pb"]);
+    expect(after.activeSpeakers).toEqual(["pb"]);
+  });
+
+  it("ignores a duplicate producerAppeared and a repeat peerLeft", () => {
+    const state = afterJoin();
+    const again = reduceRoomState(state, { event: "producerAppeared", producerId: "pa", identity: "a", kind: "audio" });
+    expect(again).toBe(state);
+
+    const left = reduceRoomState(state, { event: "peerLeft", identity: "a" });
+    expect(reduceRoomState(left, { event: "peerLeft", identity: "a" })).toBe(left);
+  });
+
+  it("tracks pause state and returns the same state when nothing changed", () => {
+    const state = afterJoin();
+    const paused = reduceRoomState(state, { event: "producerPaused", producerId: "pa", paused: true });
+    expect(producerById(paused, "pa")?.paused).toBe(true);
+    expect(reduceRoomState(paused, { event: "producerPaused", producerId: "pa", paused: true })).toBe(paused);
+    expect(reduceRoomState(paused, { event: "producerPaused", producerId: "nope", paused: true })).toBe(paused);
+  });
+
+  it("closes a producer and prunes it from the active set", () => {
+    const state = reduceRoomState(afterJoin(), { event: "activeSpeakers", producerIds: ["pa", "pb"] });
+    const after = reduceRoomState(state, { event: "producerClosed", producerId: "pa" });
+    expect(after.producers.map((p) => p.producerId)).toEqual(["pb"]);
+    expect(after.activeSpeakers).toEqual(["pb"]);
+  });
+
+  it("keeps an active-speaker id it has not seen a producer for yet", () => {
+    // The node decides the active set. Dropping an id because our view is a
+    // frame behind would discard a stream we were told to take.
+    const state = reduceRoomState(afterJoin(), { event: "activeSpeakers", producerIds: ["pc", "pa"] });
+    expect(state.activeSpeakers).toEqual(["pc", "pa"]);
+    expect(activeProducers(state).map((p) => p.producerId)).toEqual(["pa"]);
+
+    const arrived = reduceRoomState(state, { event: "producerAppeared", producerId: "pc", identity: "c", kind: "video" });
+    expect(activeProducers(arrived).map((p) => p.producerId)).toEqual(["pc", "pa"]);
+  });
+
+  it("looks producers up by id and by identity", () => {
+    const state = afterJoin();
+    expect(producerById(state, "pb")).toMatchObject({ identity: "b", kind: "video" });
+    expect(producersOf(state, "a").map((p) => p.producerId)).toEqual(["pa"]);
+  });
+});
+
+describe("the information barrier", () => {
+  it("drops what a narrowed rule no longer permits, mid-call", () => {
+    // The rule is pushed because a rule that only applied at join would not
+    // apply to anyone already in the room. The node has already stopped the
+    // media; this is the tile going away with it.
+    const state = reduceRoomState(afterJoin(), { event: "activeSpeakers", producerIds: ["pa", "pb"] });
+    const narrowed = reduceRoomState(state, {
+      event: "subscribeRuleChanged",
+      subscribe: { mode: "deny", identities: ["a"] },
+    });
+
+    // Visibility is DERIVED: `producers` still holds everything the node
+    // announced, which is what makes a later widening reversible.
+    expect(visibleProducers(narrowed).map((p) => p.producerId)).toEqual(["pb"]);
+    expect(narrowed.producers.map((p) => p.producerId)).toEqual(["pa", "pb"]);
+    expect(narrowed.activeSpeakers).toEqual(["pb"]);
+    expect(narrowed.subscribeRule).toEqual({ mode: "deny", identities: ["a"] });
+  });
+
+  it("keeps only the named identities under an allow rule, and nothing under none", () => {
+    const state = afterJoin();
+    const allowed = reduceRoomState(state, { event: "subscribeRuleChanged", subscribe: { mode: "allow", identities: ["b"] } });
+    expect(visibleProducers(allowed).map((p) => p.identity)).toEqual(["b"]);
+
+    const none = reduceRoomState(state, { event: "subscribeRuleChanged", subscribe: { mode: "none" } });
+    expect(visibleProducers(none)).toEqual([]);
+
+    const all = reduceRoomState(state, { event: "subscribeRuleChanged", subscribe: { mode: "all" } });
+    expect(visibleProducers(all)).toHaveLength(2);
+  });
+
+  /**
+   * The bug a destructive prune caused. Narrowing DELETED producers, so a
+   * widening had nothing to restore and there is no `producerAppeared` replay
+   * to bring them back. The wire carries any SubscribeRule, `{mode:"all"}`
+   * included, so a node lifting a barrier mid-call is a real event.
+   */
+  it("RESTORES producers when a narrowed rule is widened again", () => {
+    const joined = afterJoin();
+    const narrowed = reduceRoomState(joined, {
+      event: "subscribeRuleChanged",
+      subscribe: { mode: "deny", identities: ["a"] },
+    });
+    expect(visibleProducers(narrowed).map((p) => p.identity)).toEqual(["b"]);
+
+    const widened = reduceRoomState(narrowed, { event: "subscribeRuleChanged", subscribe: { mode: "all" } });
+    expect(visibleProducers(widened).map((p) => p.identity)).toEqual(["a", "b"]);
+  });
+});
+
+describe("closing", () => {
+  it("keeps who was in the room and drops what is no longer consumable", () => {
+    const state = reduceRoomState(afterJoin(), { event: "activeSpeakers", producerIds: ["pa"] });
+    const closed = reduceRoomState(state, { event: "roomClosed", reason: "ended_by_host" });
+
+    expect(closed.phase).toBe("closed");
+    expect(closed.closedReason).toBe("ended_by_host");
+    expect(closed.producers).toEqual([]);
+    expect(closed.activeSpeakers).toEqual([]);
+    expect(closed.peers).toHaveLength(2);
+  });
+});
+
+describe("purity", () => {
+  it("never mutates the state it was given", () => {
+    const frames: EventFrame[] = [
+      joined(),
+      { event: "peerJoined", peer: { identity: "c", kind: "agent" } },
+      { event: "producerAppeared", producerId: "pc", identity: "c", kind: "audio" },
+      { event: "activeSpeakers", producerIds: ["pc", "pa"] },
+      { event: "producerPaused", producerId: "pa", paused: true },
+      { event: "recordingChanged", recording: true },
+      { event: "peerLeft", identity: "b" },
+      { event: "subscribeRuleChanged", subscribe: { mode: "deny", identities: ["c"] } },
+      { event: "draining", reconnectAfterMs: 1_000 },
+      { event: "roomClosed", reason: "done" },
+    ];
+
+    let state = deepFreeze(initialRoomState);
+    for (const frame of frames) {
+      state = deepFreeze(reduceRoomState(state, frame));
+    }
+
+    expect(state.phase).toBe("closed");
+    expect(state.recording).toBe(true);
+    // Frozen input plus a reducer that mutates would have thrown by here in
+    // strict mode; asserting the end state as well keeps the test honest.
+    expect(state.peers.map((p) => p.identity)).toEqual(["a", "c"]);
+  });
+
+  it("returns the same state for an event it does not know", () => {
+    const state = afterJoin();
+    expect(reduceRoomState(state, { event: "somethingNewer" } as unknown as EventFrame)).toBe(state);
+  });
+
+  it("folds a stream of frames", () => {
+    const state = reduceRoomStateAll(initialRoomState, [
+      joined({ peers: [], producers: [] }),
+      { event: "peerJoined", peer: { identity: "z", kind: "sip" } },
+    ]);
+    expect(state.peers.map((p) => p.identity)).toEqual(["z"]);
+  });
+});
+
+function deepFreeze<T>(value: T): T {
+  for (const key of Object.getOwnPropertyNames(value)) {
+    const child = (value as Record<string, unknown>)[key];
+    if (child && typeof child === "object" && !Object.isFrozen(child)) deepFreeze(child);
+  }
+  return Object.freeze(value);
+}

package/src/core/index.ts

@@ -0,0 +1,63 @@
+/**
+ * `@tribe-nest/media-client/core` - the headless half of the SDK.
+ *
+ * No DOM, no `mediasoup-client`, no React, and that is load-bearing rather than
+ * tidy: the load harness, the egress client and the SIP gateway all need a
+ * protocol client and none of them is a browser. Without this subpath each of
+ * them hand-rolls a socket and the three drift.
+ *
+ * What lives here: the signalling client, the reconnect policy and the room
+ * state reducer. The room API, `mediasoup-client` and the React and Forge
+ * wrappers are P3b and are exported from other subpaths.
+ */
+export {
+  MediaSignal,
+  assertTokenNotInUrl,
+  causeFromError,
+  type DisconnectCause,
+  type MediaCoreCredentials,
+  type MediaSignalOptions,
+  type SignalLogLevel,
+  type SignalPhase,
+  type SignalRequest,
+} from "./signal";
+
+export {
+  DEFAULT_RECONNECT_OPTIONS,
+  RECONNECT_CODE_CLASSES,
+  backoffDelay,
+  classifyCode,
+  decideReconnect,
+  superviseConnection,
+  type JitterMode,
+  type ReconnectDecision,
+  type ReconnectOptions,
+  type StopReason,
+} from "./reconnect";
+
+export {
+  activeProducers,
+  initialRoomState,
+  producerById,
+  producersOf,
+  reduceRoomState,
+  reduceRoomStateAll,
+  visibleProducers,
+  type ProducerEntry,
+  type RoomState,
+} from "./state";
+
+export {
+  SOCKET_CLOSED,
+  SOCKET_CLOSING,
+  SOCKET_CONNECTING,
+  SOCKET_OPEN,
+  defaultWebSocketFactory,
+  type MediaWebSocketFactory,
+  type SocketCloseEvent,
+  type SocketErrorEvent,
+  type SocketEventMap,
+  type SocketMessageEvent,
+  type SocketOpenEvent,
+  type WebSocketLike,
+} from "./socket";