@tribe-nest/media-client 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# @tribe-nest/media-client
+
+The client SDK for the media network. This is **P3a: the headless core only.**
+
+```
+src/core/     the ./core subpath. ISOMORPHIC: no DOM, no mediasoup-client,
+              no React.
+  signal.ts     one socket, media-protocol frames, request/reply correlation,
+                and the reason a connection ended
+  reconnect.ts  backoff with jitter, and what to do about a draining node
+  state.ts      a pure reducer: peers, producers, active speakers, recording
+  socket.ts     the WebSocketLike shape and the injected factory
+
+src/protocol.ts   a re-export of @tribe-nest/media-protocol. Nothing added.
+```
+
+## Why `./core` is not a browser SDK
+
+The load harness, the egress client and the SIP gateway all need a protocol
+client, and none of them is a browser. Without a headless subpath each of them
+hand-rolls a socket, and three hand-rolled clients drift from each other and
+from the node. `src/core/_tests/coreBoundary.spec.ts` and the DOM-free `lib` in
+`tsconfig.json` are what hold the line.
+
+The room API, `mediasoup-client`, and the React and Forge wrappers are **P3b**
+and land at other subpaths. There is deliberately no `.` export yet.
+
+## The three things the core owns
+
+**Correlation.** A request carries an `id` and gets exactly one reply with that
+`id`; an event carries no `id`. That is the whole protocol, so it is the whole
+of `MediaSignal`.
+
+**The handshake.** `join` is the first frame on the socket and carries the
+token. Never 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.
+`connect()` resolves only when both the join reply and the `joined` event have
+arrived, in either order, because the reply says the node accepted the token and
+the event carries the room.
+
+**Why the connection ended.** A bare socket close tells a caller nothing, and
+`draining`, `roomClosed` and a refusal need three different responses. The
+`DisconnectCause` is what `decideReconnect` decides on.
+
+## Credentials are a callback, never a value
+
+```ts
+const signal = new MediaSignal({
+  getCredentials: async () => {
+    const { mediaUrl, token } = await mintJoinToken();
+    return { mediaUrl, token };
+  },
+});
+```
+
+A join ticket expires in minutes and a call lasts an hour. A token passed once
+is not a naming choice, it is a first-reconnect failure.
+
+## Testing
+
+`npm run test` runs everything against an in-process fake node
+(`src/core/_tests/fakeSignalServer.ts`). No network, no mediasoup, no browser.
+The fake parses every frame the client sends with the contract's own
+`requestFrameSchema`, so the question the suite answers is "does this client
+emit frames the frozen schema accepts", not "does this client talk to this
+fake".
+
+Integration against a real node (`P1`) is not here and is not stubbed.

package/build/core/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@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";
+//# sourceMappingURL=index.d.ts.map

package/build/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,yBAAyB,EACzB,sBAAsB,EACtB,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,UAAU,GAChB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,GACf,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,aAAa,GACnB,MAAM,UAAU,CAAC"}

package/build/core/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultWebSocketFactory = exports.SOCKET_OPEN = exports.SOCKET_CONNECTING = exports.SOCKET_CLOSING = exports.SOCKET_CLOSED = exports.visibleProducers = exports.reduceRoomStateAll = exports.reduceRoomState = exports.producersOf = exports.producerById = exports.initialRoomState = exports.activeProducers = exports.superviseConnection = exports.decideReconnect = exports.classifyCode = exports.backoffDelay = exports.RECONNECT_CODE_CLASSES = exports.DEFAULT_RECONNECT_OPTIONS = exports.causeFromError = exports.assertTokenNotInUrl = exports.MediaSignal = void 0;
+/**
+ * `@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.
+ */
+var signal_1 = require("./signal");
+Object.defineProperty(exports, "MediaSignal", { enumerable: true, get: function () { return signal_1.MediaSignal; } });
+Object.defineProperty(exports, "assertTokenNotInUrl", { enumerable: true, get: function () { return signal_1.assertTokenNotInUrl; } });
+Object.defineProperty(exports, "causeFromError", { enumerable: true, get: function () { return signal_1.causeFromError; } });
+var reconnect_1 = require("./reconnect");
+Object.defineProperty(exports, "DEFAULT_RECONNECT_OPTIONS", { enumerable: true, get: function () { return reconnect_1.DEFAULT_RECONNECT_OPTIONS; } });
+Object.defineProperty(exports, "RECONNECT_CODE_CLASSES", { enumerable: true, get: function () { return reconnect_1.RECONNECT_CODE_CLASSES; } });
+Object.defineProperty(exports, "backoffDelay", { enumerable: true, get: function () { return reconnect_1.backoffDelay; } });
+Object.defineProperty(exports, "classifyCode", { enumerable: true, get: function () { return reconnect_1.classifyCode; } });
+Object.defineProperty(exports, "decideReconnect", { enumerable: true, get: function () { return reconnect_1.decideReconnect; } });
+Object.defineProperty(exports, "superviseConnection", { enumerable: true, get: function () { return reconnect_1.superviseConnection; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "activeProducers", { enumerable: true, get: function () { return state_1.activeProducers; } });
+Object.defineProperty(exports, "initialRoomState", { enumerable: true, get: function () { return state_1.initialRoomState; } });
+Object.defineProperty(exports, "producerById", { enumerable: true, get: function () { return state_1.producerById; } });
+Object.defineProperty(exports, "producersOf", { enumerable: true, get: function () { return state_1.producersOf; } });
+Object.defineProperty(exports, "reduceRoomState", { enumerable: true, get: function () { return state_1.reduceRoomState; } });
+Object.defineProperty(exports, "reduceRoomStateAll", { enumerable: true, get: function () { return state_1.reduceRoomStateAll; } });
+Object.defineProperty(exports, "visibleProducers", { enumerable: true, get: function () { return state_1.visibleProducers; } });
+var socket_1 = require("./socket");
+Object.defineProperty(exports, "SOCKET_CLOSED", { enumerable: true, get: function () { return socket_1.SOCKET_CLOSED; } });
+Object.defineProperty(exports, "SOCKET_CLOSING", { enumerable: true, get: function () { return socket_1.SOCKET_CLOSING; } });
+Object.defineProperty(exports, "SOCKET_CONNECTING", { enumerable: true, get: function () { return socket_1.SOCKET_CONNECTING; } });
+Object.defineProperty(exports, "SOCKET_OPEN", { enumerable: true, get: function () { return socket_1.SOCKET_OPEN; } });
+Object.defineProperty(exports, "defaultWebSocketFactory", { enumerable: true, get: function () { return socket_1.defaultWebSocketFactory; } });
+//# sourceMappingURL=index.js.map

package/build/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;GAWG;AACH,mCAUkB;AAThB,qGAAA,WAAW,OAAA;AACX,6GAAA,mBAAmB,OAAA;AACnB,wGAAA,cAAc,OAAA;AAShB,yCAWqB;AAVnB,sHAAA,yBAAyB,OAAA;AACzB,mHAAA,sBAAsB,OAAA;AACtB,yGAAA,YAAY,OAAA;AACZ,yGAAA,YAAY,OAAA;AACZ,4GAAA,eAAe,OAAA;AACf,gHAAA,mBAAmB,OAAA;AAOrB,iCAUiB;AATf,wGAAA,eAAe,OAAA;AACf,yGAAA,gBAAgB,OAAA;AAChB,qGAAA,YAAY,OAAA;AACZ,oGAAA,WAAW,OAAA;AACX,wGAAA,eAAe,OAAA;AACf,2GAAA,kBAAkB,OAAA;AAClB,yGAAA,gBAAgB,OAAA;AAKlB,mCAakB;AAZhB,uGAAA,aAAa,OAAA;AACb,wGAAA,cAAc,OAAA;AACd,2GAAA,iBAAiB,OAAA;AACjB,qGAAA,WAAW,OAAA;AACX,iHAAA,uBAAuB,OAAA"}

package/build/core/reconnect.d.ts

@@ -0,0 +1,95 @@
+import { type MediaErrorCode } from "@tribe-nest/media-protocol";
+import { type DisconnectCause } from "./signal";
+/**
+ * When to try again, and when to stop.
+ *
+ * Two decisions, both of which cost an outage if guessed:
+ *
+ * **Jitter is not a refinement.** Every client on a node that just died
+ * reconnects at once. Without jitter they arrive in lockstep, land together on
+ * whichever node the balancer picks, and take that one down too. The retry
+ * storm is the outage; the original failure was one node.
+ *
+ * **`draining` is not a failure.** The node is asking to be left. Retrying the
+ * same node is the one response that cannot work, so a drain always sends the
+ * client back through `MEDIA_URL` for a fresh placement and a fresh token, and
+ * waits at least as long as the node asked.
+ *
+ * Everything here is pure. `Math.random` is injectable, so a spec pins exact
+ * delays rather than asserting a range and hoping.
+ */
+export type JitterMode = "full" | "equal" | "none";
+export type ReconnectOptions = {
+    baseMs: number;
+    maxMs: number;
+    factor: number;
+    jitter: JitterMode;
+    /** Give up after this many consecutive failed attempts. */
+    maxAttempts: number;
+    /**
+     * A reconnect that races the node's reaping of our old session comes back
+     * `duplicate_identity`. Waiting is the fix, so this is a floor rather than a
+     * refusal.
+     */
+    duplicateIdentityFloorMs: number;
+    random: () => number;
+};
+export declare const DEFAULT_RECONNECT_OPTIONS: ReconnectOptions;
+/**
+ * Delay before attempt number `attempt` (0 = the first retry).
+ *
+ * Full jitter is the default because it is the variant that actually
+ * decorrelates a fleet: exponential-with-a-small-fudge still has every client
+ * retrying inside the same narrow window.
+ */
+export declare function backoffDelay(attempt: number, options?: Partial<ReconnectOptions>): number;
+export type StopReason = "client_closed" | "room_closed" | "refused" | "attempts_exhausted";
+export type ReconnectDecision = {
+    action: "stop";
+    reason: StopReason;
+    code?: MediaErrorCode;
+} | {
+    action: "reconnect";
+    delayMs: number;
+    /** The attempt this decision authorises, 0-based. */
+    attempt: number;
+    /**
+     * Always true, and stated in the type rather than in prose: the client
+     * re-resolves through `MEDIA_URL` and takes a FRESH token every time. It
+     * never holds a node address (the wire deliberately carries no `nodeId`),
+     * and a join ticket lives minutes.
+     */
+    viaMediaUrl: true;
+};
+/** Exposed so the exhaustiveness spec can assert every contract code is classified. */
+export declare const RECONNECT_CODE_CLASSES: {
+    readonly retryable: ReadonlySet<"room_closed" | "unauthorized" | "replayed" | "protocol_version" | "forbidden_transport" | "forbidden" | "not_subscribable" | "subscription_limit" | "no_such_room" | "no_such_producer" | "no_such_transport" | "duplicate_identity" | "node_draining" | "capacity" | "bad_request" | "internal">;
+    readonly credential: ReadonlySet<"room_closed" | "unauthorized" | "replayed" | "protocol_version" | "forbidden_transport" | "forbidden" | "not_subscribable" | "subscription_limit" | "no_such_room" | "no_such_producer" | "no_such_transport" | "duplicate_identity" | "node_draining" | "capacity" | "bad_request" | "internal">;
+    readonly terminal: ReadonlySet<"room_closed" | "unauthorized" | "replayed" | "protocol_version" | "forbidden_transport" | "forbidden" | "not_subscribable" | "subscription_limit" | "no_such_room" | "no_such_producer" | "no_such_transport" | "duplicate_identity" | "node_draining" | "capacity" | "bad_request" | "internal">;
+};
+export declare function classifyCode(code: MediaErrorCode): "retryable" | "credential" | "terminal";
+export declare function decideReconnect(input: {
+    cause: DisconnectCause;
+    /** Consecutive failed attempts since the last successful join. 0 on the first drop. */
+    attempt: number;
+    options?: Partial<ReconnectOptions>;
+}): ReconnectDecision;
+/**
+ * Drives connect-then-wait-then-decide until something says stop.
+ *
+ * Deliberately knows nothing about sockets: `attempt` returns whatever a
+ * session is and `waitForClose` resolves with why it ended. That is what makes
+ * the whole loop testable with no server, and it is the same loop the room API
+ * (P3b) should use rather than deriving a second one.
+ */
+export declare function superviseConnection<TSession>(input: {
+    attempt: () => Promise<TSession>;
+    waitForClose: (session: TSession) => Promise<DisconnectCause>;
+    onConnected?: (session: TSession) => void;
+    onDecision?: (decision: ReconnectDecision, cause: DisconnectCause) => void;
+    sleep?: (ms: number) => Promise<void>;
+    options?: Partial<ReconnectOptions>;
+}): Promise<Extract<ReconnectDecision, {
+    action: "stop";
+}>>;
+//# sourceMappingURL=reconnect.d.ts.map

package/build/core/reconnect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconnect.d.ts","sourceRoot":"","sources":["../../src/core/reconnect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhE;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEnD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,wBAAwB,EAAE,MAAM,CAAC;IACjC,MAAM,EAAE,MAAM,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,gBAQvC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAWzF;AAED,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,aAAa,GACb,SAAS,GACT,oBAAoB,CAAC;AAEzB,MAAM,MAAM,iBAAiB,GACzB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,CAAC,EAAE,cAAc,CAAA;CAAE,GAC7D;IACE,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,EAAE,IAAI,CAAC;CACnB,CAAC;AAsCN,uFAAuF;AACvF,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,WAAW,GAAG,YAAY,GAAG,UAAU,CAO1F;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,KAAK,EAAE,eAAe,CAAC;IACvB,uFAAuF;IACvF,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACrC,GAAG,iBAAiB,CAwBpB;AAmBD;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,EAAE;IACzD,OAAO,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;IACjC,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9D,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC1C,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC3E,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACrC,GAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAwB1D"}

package/build/core/reconnect.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECONNECT_CODE_CLASSES = exports.DEFAULT_RECONNECT_OPTIONS = void 0;
+exports.backoffDelay = backoffDelay;
+exports.classifyCode = classifyCode;
+exports.decideReconnect = decideReconnect;
+exports.superviseConnection = superviseConnection;
+const signal_1 = require("./signal");
+exports.DEFAULT_RECONNECT_OPTIONS = {
+    baseMs: 500,
+    maxMs: 30_000,
+    factor: 2,
+    jitter: "full",
+    maxAttempts: 10,
+    duplicateIdentityFloorMs: 2_000,
+    random: Math.random,
+};
+/**
+ * Delay before attempt number `attempt` (0 = the first retry).
+ *
+ * Full jitter is the default because it is the variant that actually
+ * decorrelates a fleet: exponential-with-a-small-fudge still has every client
+ * retrying inside the same narrow window.
+ */
+function backoffDelay(attempt, options) {
+    const o = { ...exports.DEFAULT_RECONNECT_OPTIONS, ...options };
+    const ceiling = Math.min(o.maxMs, o.baseMs * Math.pow(o.factor, Math.max(0, attempt)));
+    switch (o.jitter) {
+        case "none":
+            return Math.round(ceiling);
+        case "equal":
+            return Math.round(ceiling / 2 + o.random() * (ceiling / 2));
+        case "full":
+            return Math.round(o.random() * ceiling);
+    }
+}
+/**
+ * Codes that a later attempt could plausibly survive.
+ *
+ * Split by hand, and pinned by a spec against `MEDIA_ERROR_CODES`, so that a
+ * code added to the contract fails a test here instead of silently falling into
+ * whichever branch the default happened to be.
+ */
+const RETRYABLE_CODES = new Set([
+    "node_draining",
+    "capacity",
+    "internal",
+    "duplicate_identity",
+]);
+/**
+ * Codes that mean "the credential was wrong", which a fresh mint may fix once.
+ *
+ * Once, not forever: a laptop resumed from sleep presents an expired ticket and
+ * deserves a retry, but a revoked grant answers the same way every time and
+ * retrying it is a loop against the minting endpoint.
+ */
+const CREDENTIAL_CODES = new Set(["unauthorized", "replayed"]);
+const TERMINAL_CODES = new Set([
+    "protocol_version",
+    "forbidden_transport",
+    "forbidden",
+    "not_subscribable",
+    "subscription_limit",
+    "room_closed",
+    "no_such_room",
+    "no_such_producer",
+    "no_such_transport",
+    "bad_request",
+]);
+/** Exposed so the exhaustiveness spec can assert every contract code is classified. */
+exports.RECONNECT_CODE_CLASSES = {
+    retryable: RETRYABLE_CODES,
+    credential: CREDENTIAL_CODES,
+    terminal: TERMINAL_CODES,
+};
+function classifyCode(code) {
+    if (RETRYABLE_CODES.has(code))
+        return "retryable";
+    if (CREDENTIAL_CODES.has(code))
+        return "credential";
+    if (TERMINAL_CODES.has(code))
+        return "terminal";
+    // Unclassified is treated as terminal: a client that retries something nobody
+    // reasoned about hammers the node for as long as the user leaves the tab open.
+    return "terminal";
+}
+function decideReconnect(input) {
+    const o = { ...exports.DEFAULT_RECONNECT_OPTIONS, ...input.options };
+    const { cause, attempt } = input;
+    if (cause.type === "closed_by_client")
+        return { action: "stop", reason: "client_closed" };
+    if (cause.type === "room_closed")
+        return { action: "stop", reason: "room_closed" };
+    if (cause.type === "refused") {
+        const kind = classifyCode(cause.code);
+        if (kind === "terminal")
+            return { action: "stop", reason: "refused", code: cause.code };
+        if (kind === "credential" && attempt >= 1) {
+            // The retry already carried a freshly minted token and was refused again.
+            return { action: "stop", reason: "refused", code: cause.code };
+        }
+    }
+    if (attempt >= o.maxAttempts)
+        return { action: "stop", reason: "attempts_exhausted" };
+    return {
+        action: "reconnect",
+        attempt,
+        delayMs: delayFor(cause, attempt, o),
+        viaMediaUrl: true,
+    };
+}
+function delayFor(cause, attempt, o) {
+    const backoff = backoffDelay(attempt, o);
+    if (cause.type === "draining") {
+        // The node named a window; honour it and add the jittered backoff on top so
+        // a drained node's whole population does not arrive at the replacement in
+        // one burst the instant the window expires.
+        return cause.reconnectAfterMs + backoff;
+    }
+    if (cause.type === "refused" && cause.code === "node_draining") {
+        return Math.max(backoff, o.baseMs);
+    }
+    if (cause.type === "refused" && cause.code === "duplicate_identity") {
+        return Math.max(backoff, o.duplicateIdentityFloorMs);
+    }
+    return backoff;
+}
+/**
+ * Drives connect-then-wait-then-decide until something says stop.
+ *
+ * Deliberately knows nothing about sockets: `attempt` returns whatever a
+ * session is and `waitForClose` resolves with why it ended. That is what makes
+ * the whole loop testable with no server, and it is the same loop the room API
+ * (P3b) should use rather than deriving a second one.
+ */
+async function superviseConnection(input) {
+    const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    let attempt = 0;
+    for (;;) {
+        let cause;
+        try {
+            const session = await input.attempt();
+            // A successful join resets the ladder: an hour-long call that drops once
+            // should not start at a 30-second delay because of a blip at minute two.
+            attempt = 0;
+            input.onConnected?.(session);
+            cause = await input.waitForClose(session);
+        }
+        catch (error) {
+            cause = (0, signal_1.causeFromError)(error);
+        }
+        const decision = decideReconnect({ cause, attempt, options: input.options });
+        input.onDecision?.(decision, cause);
+        if (decision.action === "stop")
+            return decision;
+        await sleep(decision.delayMs);
+        attempt += 1;
+    }
+}
+//# sourceMappingURL=reconnect.js.map

package/build/core/reconnect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconnect.js","sourceRoot":"","sources":["../../src/core/reconnect.ts"],"names":[],"mappings":"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"}

package/build/core/signal.d.ts

@@ -0,0 +1,184 @@
+import { type EventFrame, type EventName, type MediaErrorCode, type RequestFrame } from "@tribe-nest/media-protocol";
+import { type MediaWebSocketFactory } from "./socket";
+/**
+ * The headless signalling client: one socket, media-protocol frames, nothing
+ * else.
+ *
+ * It owns exactly three things the wire specifies and no policy beyond them:
+ *
+ * 1. **Request/reply correlation.** A request carries an `id` and gets exactly
+ *    one reply with that `id`; an event carries no `id` and is never replied
+ *    to. That is the whole protocol, so it is the whole of this class.
+ * 2. **The handshake.** `join` is the FIRST frame on the socket and carries the
+ *    token. Nothing else may be sent before it.
+ * 3. **Why the connection ended**, as a `DisconnectCause` the reconnect policy
+ *    can decide on. A socket that just closes tells the caller nothing, and
+ *    "the node is draining" and "the room ended" need opposite responses.
+ *
+ * It deliberately does NOT reconnect, hold room state or know what a track is.
+ * Those are `core/reconnect.ts`, `core/state.ts` and P3b's room API.
+ */
+/** What a caller must supply to open a connection. Fetched fresh EVERY attempt. */
+export type MediaCoreCredentials = {
+    /** `MEDIA_URL`. The load balancer, never a node address the client picked. */
+    mediaUrl: string;
+    /** A join ticket, minted per attempt. */
+    token: string;
+};
+export type SignalLogLevel = "debug" | "warn" | "error";
+export type MediaSignalOptions = {
+    /**
+     * Called before EVERY connection attempt, never once at construction.
+     *
+     * A join ticket expires in minutes and a call lasts an hour, so a token
+     * handed over once is a defect rather than a naming choice: the first
+     * reconnect after a network blip would present an expired token.
+     */
+    getCredentials: () => Promise<MediaCoreCredentials> | MediaCoreCredentials;
+    /** Defaults to `globalThis.WebSocket`, resolved lazily. */
+    webSocket?: MediaWebSocketFactory;
+    requestTimeoutMs?: number;
+    joinTimeoutMs?: number;
+    /**
+     * Overridable only so a spec can drive a mismatch. Production always sends
+     * `MEDIA_PROTOCOL_VERSION`.
+     */
+    protocolVersion?: number;
+    onLog?: (level: SignalLogLevel, message: string, detail?: unknown) => void;
+};
+export type SignalPhase = "idle" | "connecting" | "joining" | "joined" | "closed";
+/**
+ * Why the connection ended.
+ *
+ * The distinctions are the ones a reconnect decision actually turns on: a
+ * drained node must not be retried, a closed room must not be rejoined, and a
+ * refusal carries the code the caller has to show a human.
+ */
+export type DisconnectCause = {
+    type: "closed_by_client";
+} | {
+    type: "room_closed";
+    reason: string;
+} | {
+    type: "draining";
+    reconnectAfterMs: number;
+} | {
+    type: "refused";
+    code: MediaErrorCode;
+    message?: string;
+} | {
+    type: "socket_closed";
+    code?: number;
+    reason?: string;
+};
+type JoinedFrame = Extract<EventFrame, {
+    event: "joined";
+}>;
+/** `Omit` over a union collapses it to the common keys, which for a frame union
+ * is just `method`. Distributing keeps every variant's payload. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Everything a caller may send. `join` is absent on purpose: the handshake
+ * belongs to `connect()`, and a second join on a live socket is not something
+ * the protocol has an answer for.
+ */
+export type SignalRequest = DistributiveOmit<Exclude<RequestFrame, {
+    method: "join";
+}>, "id">;
+type AnyHandler = (frame: EventFrame) => void;
+type CloseHandler = (cause: DisconnectCause) => void;
+/**
+ * A join ticket in a URL is a join ticket in every access log between the
+ * client and the node, and load balancers log query strings by default. The
+ * contract puts the token in the first frame; this refuses a URL that looks
+ * like someone routed around that.
+ */
+export declare function assertTokenNotInUrl(mediaUrl: string): void;
+/** Maps a thrown error back to the cause the reconnect policy decides on. */
+export declare function causeFromError(error: unknown): DisconnectCause;
+export declare class MediaSignal {
+    private readonly options;
+    private socket;
+    private nextId;
+    private readonly pending;
+    private readonly handlers;
+    private readonly anyHandlers;
+    private readonly closeHandlers;
+    /** Set by the events that explain a close BEFORE the socket goes away. */
+    private terminalCause;
+    private phaseValue;
+    private identityValue;
+    private joinedResolve;
+    private connectReject;
+    /**
+     * Which connection attempt is the current one.
+     *
+     * `connect()` awaits `getCredentials()` before it has a socket, and until that
+     * socket exists there is nothing for `close()` to close: it flips the phase
+     * and returns. So the attempt is stamped and re-checked, and an attempt that
+     * is no longer the current one abandons itself instead of opening a socket
+     * and JOINING with a live token that nothing then holds a reference to.
+     */
+    private attempt;
+    private boundClose;
+    constructor(options: MediaSignalOptions);
+    get phase(): SignalPhase;
+    /** Our own identity, as the node reported it in `joined`. */
+    get identity(): string | null;
+    /**
+     * Opens the socket, sends `join` as the first frame, and resolves once BOTH
+     * the join reply and the `joined` event have arrived.
+     *
+     * Waiting for both is deliberate. The reply says the node accepted the token;
+     * the event carries `routerRtpCapabilities`, the peer snapshot and the
+     * recording flag. A caller that resolved on the reply alone would be handed a
+     * room it knows nothing about, and the contract fixes no order between the
+     * two frames, so neither may be assumed to arrive first.
+     */
+    connect(): Promise<JoinedFrame>;
+    /**
+     * Sends a request and resolves with its `data`.
+     *
+     * `unknown`, not a guessed shape: the wire declares `data: unknown` because
+     * most of it is mediasoup's, and a client that pretends otherwise is asserting
+     * a contract this package does not hold.
+     */
+    request(frame: SignalRequest, timeoutMs?: number): Promise<unknown>;
+    /**
+     * Best-effort `leave` then close.
+     *
+     * Best-effort because the node tears the session down on socket close anyway.
+     * A leave that hangs must not stop a user closing a tab.
+     */
+    leave(): Promise<void>;
+    /** Closes the socket. Idempotent. */
+    close(): void;
+    on<K extends EventName>(event: K, handler: (frame: Extract<EventFrame, {
+        event: K;
+    }>) => void): () => void;
+    /** Every event, in arrival order. This is what the state reducer is fed. */
+    onAny(handler: AnyHandler): () => void;
+    onClose(handler: CloseHandler): () => void;
+    /**
+     * Throws when this attempt has been overtaken: either `close()` ran, or a
+     * second `connect()` started (which the entry guard permits once the phase is
+     * `closed`, so an abandoned attempt must not go on to open a second socket).
+     */
+    private assertAttemptIsCurrent;
+    private resetForConnect;
+    private bind;
+    private waitForOpen;
+    private performJoin;
+    private withDeadline;
+    private track;
+    private settle;
+    private send;
+    private handleMessage;
+    private dispatch;
+    private handleEvent;
+    private handleClose;
+    private closeSocket;
+    private log;
+}
+export {};
+//# sourceMappingURL=signal.d.ts.map

package/build/core/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/core/signal.ts"],"names":[],"mappings":"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"}