@tribe-nest/forge 3.29.0 → 3.31.0

package/src/ui/media/_tests/bookingSession.spec.tsx

@@ -0,0 +1,179 @@
+// @vitest-environment jsdom
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { renderHook } from "@testing-library/react";
+
+import {
+  BOOKING_CALL_CLOSES_MINUTES_AFTER,
+  BOOKING_CALL_OPENS_MINUTES_BEFORE,
+  bookingCallWindow,
+  useBookingSessionCredentials,
+  type BookingCallSubject,
+} from "../bookingSession";
+
+/**
+ * The Forge context, stubbed at the seam the hook actually reads.
+ *
+ * `ForgeClientProvider` builds its Axios instance from an `apiUrl`, so there is
+ * no way to hand it a fake transport from outside; mocking `useForge` is the
+ * only join where a spec can see the request the hook makes.
+ */
+const { post, forgeContext } = vi.hoisted(() => {
+  const post = vi.fn();
+  // ONE object across renders, like the real provider's memoized client. A
+  // fresh one per render would change the hook's dependency and make the
+  // identity assertion below fail against a correct implementation.
+  return { post, forgeContext: { client: { post }, profileId: "11111111-1111-4111-8111-111111111111" } };
+});
+
+vi.mock("../../../provider/ForgeProvider", () => ({ useForge: () => forgeContext }));
+
+/**
+ * The booking half of the media barrel.
+ *
+ * Two things are worth testing here and nothing else is. `bookingCallWindow` is
+ * a total function that decides whether a Join control is drawn at all, and
+ * getting it wrong shows a client a button that 409s or hides one from a
+ * session that has started. `useBookingSessionCredentials` is a transport, and
+ * the property that matters is that it posts to the credential endpoint with
+ * NO body: the endpoint's schema is `.strict()`, so a field added here in a
+ * moment of helpfulness would 400 every call in production.
+ */
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+
+const booking = (overrides: Partial<BookingCallSubject> = {}): BookingCallSubject => ({
+  status: "confirmed",
+  sessionStartTime: new Date("2026-08-20T10:00:00.000Z").toISOString(),
+  sessionEndTime: new Date("2026-08-20T11:00:00.000Z").toISOString(),
+  location: { type: "video" },
+  ...overrides,
+});
+
+const at = (iso: string) => new Date(iso);
+
+describe("the join window, as literal numbers", () => {
+  /**
+   * The one place in this file that does NOT compute its expectation from the
+   * constants.
+   *
+   * Everything below asserts `opensAt` against
+   * `BOOKING_CALL_OPENS_MINUTES_BEFORE`, which is correct for what those tests
+   * are about (the arithmetic) and completely blind to the value: changing 15 to
+   * 60 leaves the whole suite green. The server carries its OWN pair of literals
+   * in `apps/backend/src/services/public/coaching/commands/bookingSession.ts`
+   * (`SESSION_JOIN_OPENS_MINUTES_BEFORE` / `SESSION_JOIN_CLOSES_MINUTES_AFTER`),
+   * whose spec had exactly the same self-referential shape, so a change on
+   * either side was invisible to both suites.
+   *
+   * The server's answer is the one that counts. When these two disagree the
+   * visible result is a Join button drawn 45 minutes before the server will mint
+   * a ticket (a client clicks and gets a bare 409), or a button hidden while the
+   * room is open. So both sides pin the value, and moving it means editing two
+   * specs that name each other.
+   */
+  it("mirrors the server: 15 minutes before, 120 minutes after", () => {
+    expect(BOOKING_CALL_OPENS_MINUTES_BEFORE).toBe(15);
+    expect(BOOKING_CALL_CLOSES_MINUTES_AFTER).toBe(120);
+  });
+});
+
+describe("bookingCallWindow", () => {
+  it("opens exactly the stated number of minutes before the session", () => {
+    const subject = booking();
+    const opensAt = new Date(new Date(subject.sessionStartTime).getTime() - BOOKING_CALL_OPENS_MINUTES_BEFORE * MINUTE);
+
+    expect(bookingCallWindow(subject).opensAt.toISOString()).toBe(opensAt.toISOString());
+    // One millisecond either side of the boundary, so an off-by-one in the
+    // comparison cannot pass: a client refreshing at the advertised minute must
+    // get in, and one refreshing a moment earlier must not.
+    expect(bookingCallWindow(subject, new Date(opensAt.getTime() - 1)).isOpen).toBe(false);
+    expect(bookingCallWindow(subject, opensAt).isOpen).toBe(true);
+  });
+
+  it("stays open after the hour ends, then shuts", () => {
+    const subject = booking();
+    const closesAt = new Date(new Date(subject.sessionEndTime).getTime() + BOOKING_CALL_CLOSES_MINUTES_AFTER * MINUTE);
+
+    expect(bookingCallWindow(subject).closesAt.toISOString()).toBe(closesAt.toISOString());
+    // A session that runs over must not be cut off, which is what the window
+    // after the end is for.
+    expect(bookingCallWindow(subject, at("2026-08-20T11:30:00.000Z")).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, closesAt).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, new Date(closesAt.getTime() + 1)).isOpen).toBe(false);
+  });
+
+  it("is not a video call when the location is anything else", () => {
+    const midSession = at("2026-08-20T10:30:00.000Z");
+
+    for (const location of [{ type: "online" }, { type: "in_person" }, null, undefined]) {
+      const window = bookingCallWindow(booking({ location }), midSession);
+      expect(window.isVideo).toBe(false);
+      // Never open, however good the timing is: there is no room to enter.
+      expect(window.isOpen).toBe(false);
+    }
+  });
+
+  it("is not a video call when the booking is not confirmed", () => {
+    const midSession = at("2026-08-20T10:30:00.000Z");
+    // A cancelled session has no room. The server withholds `location`
+    // entirely for one, so this is belt and braces against a cached row.
+    const window = bookingCallWindow(booking({ status: "canceled" }), midSession);
+    expect(window.isVideo).toBe(false);
+    expect(window.isOpen).toBe(false);
+  });
+
+  it("holds for a session whose window straddles a day boundary", () => {
+    const subject = booking({
+      sessionStartTime: "2026-08-20T23:50:00.000Z",
+      sessionEndTime: "2026-08-21T00:50:00.000Z",
+    });
+    expect(bookingCallWindow(subject, at("2026-08-20T23:40:00.000Z")).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, at("2026-08-20T23:34:00.000Z")).isOpen).toBe(false);
+    expect(bookingCallWindow(subject, at("2026-08-21T02:49:00.000Z")).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, at("2026-08-21T02:51:00.000Z")).isOpen).toBe(false);
+  });
+});
+
+describe("useBookingSessionCredentials", () => {
+  beforeEach(() => {
+    post.mockReset();
+    post.mockResolvedValue({
+      data: {
+        mediaUrl: "wss://media.test",
+        token: "tok",
+        expiresAt: "2026-08-20T10:10:00.000Z",
+        identity: "guest-acc-1",
+        roomId: "booking-booking-1",
+        grants: { canPublish: true, canSubscribe: true, canPublishData: true },
+        role: "guest",
+        roomOpensAt: "2026-08-20T09:45:00.000Z",
+        roomClosesAt: "2026-08-20T13:00:00.000Z",
+      },
+    });
+  });
+
+  it("posts an EMPTY body to this booking's credential endpoint", async () => {
+    const getCredentials = renderHook(() => useBookingSessionCredentials("booking-1")).result.current;
+
+    const credentials = await getCredentials();
+
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(post).toHaveBeenCalledWith("/public/coaching/bookings/booking-1/session/join", {});
+    // The endpoint's schema is `.strict()` and declares no fields at all, so a
+    // `profileId` added here in a moment of helpfulness would 400 every call.
+    // Asserting the exact second argument is what catches that.
+    expect(credentials.roomId).toBe("booking-booking-1");
+    expect(credentials.role).toBe("guest");
+  });
+
+  it("keeps ONE callback identity per booking", () => {
+    const { result, rerender } = renderHook(() => useBookingSessionCredentials("booking-1"));
+    const first = result.current;
+    rerender();
+    // `<MediaRoomProvider>` holds its options in a ref because an inline arrow
+    // would be a new function every render; a callback that changed identity on
+    // every parent render would defeat that and reconnect a live call.
+    expect(result.current).toBe(first);
+  });
+});

package/src/ui/media/_tests/callState.spec.ts

@@ -0,0 +1,452 @@
+import { describe, expect, it } from "vitest";
+
+import type { ProducerEntry } from "@tribe-nest/media-client";
+import type { Peer } from "@tribe-nest/media-protocol";
+
+import { callHeadCount, callStatus, callTiles, canPublishSource, remoteAudioProducerIds } from "../callState";
+
+/**
+ * The two decisions a call screen gets wrong.
+ *
+ * Both of them are invisible in a component test that only checks "did it
+ * render", and both of them are the difference between a call that works and a
+ * call that looks broken while working perfectly.
+ */
+
+const peer = (identity: string, name?: string): Peer => ({
+  identity,
+  kind: "human",
+  ...(name === undefined ? {} : { name }),
+});
+
+/** The recording process, which joins the room as a real peer. */
+const recorder = (identity: string): Peer => ({ identity, kind: "egress" });
+
+const producer = (
+  producerId: string,
+  identity: string,
+  kind: "audio" | "video",
+  paused = false,
+): ProducerEntry => ({ producerId, identity, kind, paused });
+
+describe("callTiles keeps the grid from collapsing", () => {
+  it("draws a tile for somebody with NO video at all", () => {
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("anna", "Anna")],
+      producers: [producer("p-audio", "anna", "audio")],
+      activeSpeakers: [],
+    });
+
+    // The whole point. A participant with the camera off has not left the room,
+    // and a grid built by mapping over video tracks drops them silently.
+    expect(tiles).toHaveLength(1);
+    expect(tiles[0]!.name).toBe("Anna");
+    expect(tiles[0]!.videoProducerId).toBeUndefined();
+    expect(tiles[0]!.hasAudio).toBe(true);
+  });
+
+  it("keeps the SAME number of tiles when a camera goes off", () => {
+    const peers = [peer("anna", "Anna"), peer("ben", "Ben")];
+    const withCamera = callTiles({
+      identity: "me",
+      peers,
+      producers: [producer("p-anna-video", "anna", "video"), producer("p-ben-audio", "ben", "audio")],
+      activeSpeakers: [],
+    });
+    const cameraOff = callTiles({
+      identity: "me",
+      peers,
+      producers: [producer("p-ben-audio", "ben", "audio")],
+      activeSpeakers: [],
+    });
+
+    expect(withCamera).toHaveLength(2);
+    // Two before, two after. This is the assertion that fails on the bug.
+    expect(cameraOff).toHaveLength(2);
+    expect(cameraOff.map((t) => t.identity)).toEqual(["anna", "ben"]);
+    // And the key is unchanged, so React updates the tile rather than
+    // unmounting and remounting it under the viewer's eyes.
+    expect(cameraOff[0]!.key).toBe(withCamera[0]!.key);
+  });
+
+  it("never draws the local participant, who has their own preview", () => {
+    const tiles = callTiles({
+      identity: "me",
+      // The node may or may not include us in `peers`; both have to be safe.
+      peers: [peer("me", "Me"), peer("anna", "Anna")],
+      producers: [producer("p-mine", "me", "video")],
+      activeSpeakers: [],
+    });
+
+    expect(tiles.map((t) => t.identity)).toEqual(["anna"]);
+  });
+
+  it("gives a second video stream its own tile rather than replacing the face", () => {
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("anna", "Anna")],
+      producers: [producer("p-cam", "anna", "video"), producer("p-screen", "anna", "video")],
+      activeSpeakers: [],
+    });
+
+    expect(tiles).toHaveLength(2);
+    expect(tiles.map((t) => t.videoProducerId)).toEqual(["p-cam", "p-screen"]);
+    // Same person, so the same name on both. The wire does not label which is
+    // the screen, so neither does this.
+    expect(tiles.every((t) => t.name === "Anna")).toBe(true);
+    expect(new Set(tiles.map((t) => t.key)).size).toBe(2);
+  });
+
+  it("draws a stream whose peer frame has not arrived yet", () => {
+    // `producerAppeared` and `peerJoined` have no ordering guarantee. Dropping
+    // the stream would blank a tile that has media in it.
+    const tiles = callTiles({
+      identity: "me",
+      peers: [],
+      producers: [producer("p-early", "carla", "video")],
+      activeSpeakers: [],
+    });
+
+    expect(tiles).toHaveLength(1);
+    expect(tiles[0]!.identity).toBe("carla");
+    expect(tiles[0]!.videoProducerId).toBe("p-early");
+  });
+
+  it("falls back to the identity, which tells two unnamed people apart", () => {
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("guest-1"), peer("guest-2", "   ")],
+      producers: [],
+      activeSpeakers: [],
+    });
+
+    expect(tiles.map((t) => t.name)).toEqual(["guest-1", "guest-2"]);
+  });
+
+  it("marks the speaker from the node's producer ids, not from identities", () => {
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("anna", "Anna"), peer("ben", "Ben")],
+      producers: [
+        producer("p-anna-audio", "anna", "audio"),
+        producer("p-anna-video", "anna", "video"),
+        producer("p-ben-audio", "ben", "audio"),
+      ],
+      // The node sends PRODUCER ids. Matching these against identities would
+      // light up nobody, and the indication would simply never appear.
+      activeSpeakers: ["p-anna-audio"],
+    });
+
+    expect(tiles.find((t) => t.identity === "anna")!.isSpeaking).toBe(true);
+    expect(tiles.find((t) => t.identity === "ben")!.isSpeaking).toBe(false);
+  });
+
+  it("carries the publisher's own pause through", () => {
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("anna", "Anna")],
+      producers: [producer("p-cam", "anna", "video", true)],
+      activeSpeakers: [],
+    });
+
+    expect(tiles[0]!.videoPaused).toBe(true);
+  });
+});
+
+describe("callHeadCount counts PEOPLE, not tiles", () => {
+  it("does not gain a person when somebody shares their screen", () => {
+    // A coach and a client: two people. The coach shares a screen, which by
+    // `callTiles`' own design gives them a second tile, and a count taken from
+    // `tiles.length` announced a third party in a two-person call at exactly
+    // the moment a coaching call is most likely to have one.
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("anna", "Anna")],
+      producers: [producer("p-cam", "anna", "video"), producer("p-screen", "anna", "video")],
+      activeSpeakers: [],
+    });
+
+    expect(tiles).toHaveLength(2);
+    expect(callHeadCount(tiles)).toBe(2);
+  });
+
+  it("counts everyone once, including the viewer, and the viewer alone in an empty room", () => {
+    expect(callHeadCount([])).toBe(1);
+
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("anna", "Anna"), peer("ben", "Ben")],
+      producers: [producer("p-anna-audio", "anna", "audio"), producer("p-ben-video", "ben", "video")],
+      activeSpeakers: [],
+    });
+
+    expect(callHeadCount(tiles)).toBe(3);
+  });
+
+  /**
+   * The recorder is not somebody who arrived.
+   *
+   * A recording joins as a real peer with `kind: "egress"`, so a grid built
+   * from `peers` drew a third tile called `egress-9f2c` in a 1:1 session and
+   * the header read "In this call: 3" - at exactly the moment a coach is most
+   * likely to be reading that number, and it is the number they use to answer
+   * "has my client actually arrived". `<RecordingIndicator>` already says the
+   * true thing, in words, as content.
+   */
+  it("does not count the recording as a person in the room", () => {
+    const tiles = callTiles({
+      identity: "me",
+      peers: [peer("anna", "Anna"), recorder("egress-9f2c")],
+      producers: [producer("p-anna-audio", "anna", "audio")],
+      activeSpeakers: [],
+    });
+
+    expect(tiles.map((t) => t.identity)).toEqual(["anna"]);
+    // A coach and their client. Two.
+    expect(callHeadCount(tiles)).toBe(2);
+  });
+
+  it("keeps a dial-in caller and an agent, which are somebody to talk to", () => {
+    const tiles = callTiles({
+      identity: "me",
+      peers: [
+        { identity: "+4915112345678", kind: "sip" },
+        { identity: "notetaker", kind: "agent", name: "Notes" },
+      ],
+      producers: [],
+      activeSpeakers: [],
+    });
+
+    // Only `egress` is excluded, and only because it is a recorder rather than
+    // a participant. Dropping every non-human would hide a caller who dialled in.
+    expect(tiles.map((t) => t.identity)).toEqual(["+4915112345678", "notetaker"]);
+    expect(callHeadCount(tiles)).toBe(3);
+  });
+});
+
+describe("remoteAudioProducerIds", () => {
+  it("takes everyone else's audio and none of our own", () => {
+    const ids = remoteAudioProducerIds({
+      identity: "me",
+      producers: [
+        producer("p-mine", "me", "audio"),
+        producer("p-anna", "anna", "audio"),
+        producer("p-anna-video", "anna", "video"),
+      ],
+    });
+
+    // Our own audio played back is a feedback loop, and a video producer
+    // attached to an `<audio>` element is silence.
+    expect(ids).toEqual(["p-anna"]);
+  });
+});
+
+describe("callStatus is honest about what is happening", () => {
+  it("separates a reconnect from a refusal", () => {
+    const dropped = callStatus({
+      connectionState: "reconnecting",
+      error: { type: "socket_closed", code: 1006 },
+      recovering: true,
+    });
+    const refused = callStatus({ connectionState: "reconnecting", error: { type: "refused", code: "unauthorized" } });
+
+    // The room reports ONE state for both. They are completely different things
+    // to the person looking at the screen: one is worth waiting through, the
+    // other is worth pressing a button about.
+    expect(dropped.tone).toBe("reconnecting");
+    expect(refused.tone).toBe("failed");
+    expect(dropped.headline).not.toBe(refused.headline);
+  });
+
+  it("shows the server's own words for a refusal rather than a friendly lie", () => {
+    expect(callStatus({ connectionState: "reconnecting", error: { type: "refused", code: "room_closed" } }).detail).toBe(
+      "room_closed",
+    );
+    expect(
+      callStatus({
+        connectionState: "reconnecting",
+        error: { type: "refused", code: "unauthorized", message: "this session has ended" },
+      }).detail,
+    ).toBe("this session has ended");
+  });
+
+  it("does not offer a retry for something retrying cannot fix", () => {
+    expect(callStatus({ connectionState: "connected", error: undefined }).canRetry).toBe(false);
+    expect(callStatus({ connectionState: "connecting", error: undefined }).canRetry).toBe(false);
+    expect(callStatus({ connectionState: "closed", error: { type: "closed_by_client" } }).canRetry).toBe(false);
+    expect(
+      callStatus({ connectionState: "reconnecting", error: { type: "room_closed", reason: "host ended" } }).canRetry,
+    ).toBe(false);
+    // A node moving us off itself reconnects on its own; a button would be a
+    // second connect racing the first. WHILE it is actually moving us: the
+    // promise and the control are two halves of one decision.
+    expect(
+      callStatus({
+        connectionState: "reconnecting",
+        error: { type: "draining", reconnectAfterMs: 500 },
+        recovering: true,
+      }).canRetry,
+    ).toBe(false);
+  });
+
+  /**
+   * A spinner is a promise, and it has to be one somebody is keeping.
+   *
+   * "Moving you to another server" and "Connection lost, reconnecting" both say
+   * "wait, this is being handled". Said over a stack where nothing is coming
+   * back, they are the worst screen in the product: an ordinary deploy drains a
+   * node, everyone on it reads that nobody was dropped, and the only way back
+   * into a paid coaching hour is working out for yourself that you should
+   * reload the page. So when `recovering` is false, the words change and a
+   * control appears.
+   */
+  describe("it does not promise a recovery that is not happening", () => {
+    it("offers a way back when a drain has nowhere to move you to", () => {
+      const moving = callStatus({
+        connectionState: "reconnecting",
+        error: { type: "draining", reconnectAfterMs: 500 },
+        recovering: true,
+      });
+      const stranded = callStatus({
+        connectionState: "reconnecting",
+        error: { type: "draining", reconnectAfterMs: 500 },
+      });
+
+      expect(moving.tone).toBe("reconnecting");
+      expect(moving.canRetry).toBe(false);
+      // The one the review found: a spinner, no control, and no second socket
+      // ever opened.
+      expect(stranded.tone).toBe("failed");
+      expect(stranded.canRetry).toBe(true);
+      expect(stranded.headline).not.toBe(moving.headline);
+    });
+
+    it("stops saying `reconnecting` about a dropped socket nothing is retrying", () => {
+      const retrying = callStatus({
+        connectionState: "reconnecting",
+        error: { type: "socket_closed", code: 1006 },
+        recovering: true,
+      });
+      const givenUp = callStatus({ connectionState: "reconnecting", error: { type: "socket_closed", code: 1006 } });
+
+      expect(retrying.headline).toBe("Connection lost, reconnecting");
+      expect(givenUp.headline).toBe("Connection lost");
+      expect(givenUp.tone).toBe("failed");
+      expect(givenUp.canRetry).toBe(true);
+    });
+
+    it("reads an absent `recovering` as nothing coming, which is the safe way round", () => {
+      // A caller that has not been taught about it gets a control rather than a
+      // spinner. The wrong answer offers a button somebody did not need; the
+      // other wrong answer strands them under a promise.
+      expect(callStatus({ connectionState: "reconnecting", error: undefined }).canRetry).toBe(true);
+      expect(callStatus({ connectionState: "reconnecting", error: undefined }).tone).toBe("failed");
+    });
+  });
+
+  it("offers a retry when only a fresh ticket will do", () => {
+    // A join ticket expires in minutes, and an expired one comes back as
+    // `unauthorized`; a refusal is very often just that, and `retry()`
+    // re-fetches through `getCredentials`.
+    expect(
+      callStatus({ connectionState: "reconnecting", error: { type: "refused", code: "unauthorized" } }).canRetry,
+    ).toBe(true);
+    expect(callStatus({ connectionState: "reconnecting", error: undefined }).canRetry).toBe(true);
+  });
+
+  it("says the call ended when the room closed, on either connection state", () => {
+    for (const connectionState of ["closed", "reconnecting"] as const) {
+      const status = callStatus({ connectionState, error: { type: "room_closed", reason: "the host ended it" } });
+      expect(status.tone).toBe("ended");
+      expect(status.detail).toBe("the host ended it");
+    }
+  });
+
+  it("says the call ended the moment the ROOM says so, on a socket still open", () => {
+    // A `roomClosed` frame arrives on a live socket, so the connection is still
+    // "connected" until the node hangs up. Reading only the connection would
+    // show "Connected" over a call that has ended, and that is the one entry on
+    // this list somebody would act on wrongly.
+    const status = callStatus({
+      connectionState: "connected",
+      error: undefined,
+      phase: "closed",
+      closedReason: "the host ended it",
+    });
+
+    expect(status.tone).toBe("ended");
+    expect(status.detail).toBe("the host ended it");
+  });
+
+  it("is live only when the room says connected", () => {
+    expect(callStatus({ connectionState: "connected", error: undefined }).tone).toBe("live");
+    expect(callStatus({ connectionState: "connected", error: undefined, phase: "joined" }).tone).toBe("live");
+    expect(callStatus({ connectionState: "idle", error: undefined }).tone).toBe("connecting");
+  });
+});
+
+describe("canPublishSource", () => {
+  const sources = ["microphone", "camera", "screen"] as const;
+
+  it("offers nothing without canPublish", () => {
+    for (const source of sources) {
+      expect(canPublishSource({ canPublish: false, canSubscribe: true, canPublishData: false }, source)).toBe(false);
+      expect(canPublishSource(undefined, source)).toBe(false);
+    }
+  });
+
+  it("treats an absent publishKinds as every kind, which is what the node does", () => {
+    const grants = { canPublish: true, canSubscribe: true, canPublishData: false };
+    for (const source of sources) {
+      expect(canPublishSource(grants, source)).toBe(true);
+    }
+  });
+
+  /**
+   * The SOURCES a control publishes, against the KINDS a grant lists.
+   *
+   * These are two vocabularies and they agree on one word. Asking this function
+   * about "audio" - as the buttons used to - is asking about something no
+   * publish ever declares, so it answered a question the node was never going
+   * to be asked: a booking token minted `["audio", "video", "screen"]` drew a
+   * microphone button and a camera button, and the node refused both, because
+   * what reached it was "microphone" and "camera".
+   */
+  it("offers the microphone and camera a booking token was minted for", () => {
+    const booking = {
+      canPublish: true,
+      canSubscribe: true,
+      canPublishData: false,
+      publishKinds: ["audio", "video", "screen"] as const,
+    };
+
+    for (const source of sources) {
+      expect(canPublishSource({ ...booking, publishKinds: [...booking.publishKinds] }, source)).toBe(true);
+    }
+  });
+
+  it("honours a narrowed publishKinds", () => {
+    const listenAndTalk = {
+      canPublish: true,
+      canSubscribe: true,
+      canPublishData: false,
+      publishKinds: ["audio"] as const,
+    };
+
+    expect(canPublishSource({ ...listenAndTalk, publishKinds: ["audio"] }, "microphone")).toBe(true);
+    expect(canPublishSource({ ...listenAndTalk, publishKinds: ["audio"] }, "camera")).toBe(false);
+    expect(canPublishSource({ ...listenAndTalk, publishKinds: ["audio"] }, "screen")).toBe(false);
+  });
+
+  it("does not offer a screen share on a token granted audio and video", () => {
+    const noPresenting = {
+      canPublish: true,
+      canSubscribe: true,
+      canPublishData: false,
+    };
+
+    expect(canPublishSource({ ...noPresenting, publishKinds: ["audio", "video"] }, "camera")).toBe(true);
+    expect(canPublishSource({ ...noPresenting, publishKinds: ["audio", "video"] }, "screen")).toBe(false);
+  });
+});