freehop 0.1.0-alpha.2 → 0.1.0-alpha.4

package/README.md

@@ -1,23 +1,59 @@
 <div align="center">
 
-# Freehop
+<img src="website/static/img/logo.svg" alt="Freehop" width="76" />
 
-### An open-source SDK for voice and video inside your app or game.
+# freehop
 
-**[Live demo](https://jolynstudios.github.io/freehop/demo)** ·
-**[Documentation](https://jolynstudios.github.io/freehop/)** ·
-**[Quickstart](#quickstart)** ·
-**[Architecture](ARCHITECTURE.md)** ·
-**[Protocol](PROTOCOL.md)**
+### Voice and video, inside your app.
 
-![License: Apache-2.0](https://img.shields.io/badge/code-Apache--2.0-303055)
-![Docs: CC BY 4.0](https://img.shields.io/badge/docs-CC%20BY%204.0-303055)
-![Home-built network test matrix: 40/40](https://img.shields.io/badge/home%E2%80%91built%20network%20tests-40%2F40-096e72)
-![Unit tests: 167/167](https://img.shields.io/badge/unit%20tests-167%2F167-096e72)
-![Status: alpha](https://img.shields.io/badge/status-alpha-ef3b2c)
+Open-source calling for small meeting rooms, in-app conversations, shared workspaces and Electron apps.
+
+**[Try the demos](https://jolynstudios.github.io/freehop/demos)** · **[Documentation](https://jolynstudios.github.io/freehop/docs)** · **[Quickstart](#quickstart)** · **[Protocol](PROTOCOL.md)**
+
+![Apache-2.0](https://img.shields.io/badge/code-Apache--2.0-ffffff?labelColor=000000)
+![Status: alpha](https://img.shields.io/badge/status-alpha-b0a2d4?labelColor=000000)
+![JavaScript and TypeScript](https://img.shields.io/badge/JavaScript_%2B_TypeScript-browser_%2B_Electron-ffffff?labelColor=000000)
 
 </div>
 
+**Typed SDK:** declarations for all 15 public entry points are included in **0.1.0-alpha.4**.
+Install the current alpha from [npm](https://www.npmjs.com/package/freehop), or download the
+[GitHub release](https://github.com/jolynstudios/freehop/releases/tag/v0.1.0-alpha.4).
+
+```sh
+npm install freehop@alpha
+```
+
+See the [TypeScript guide](https://jolynstudios.github.io/freehop/docs/typescript) for typed sessions,
+events and backend APIs. JavaScript usage is unchanged.
+
+## Add a call to what you’re building
+
+Build a small meeting app, add a support call to an existing tool, or put voice beside a shared workspace. Freehop provides audio, optional video and small session messages inside your own interface. The same SDK also fits community rooms and games.
+
+**Build with AI. Build without it. Own the result.** Use an AI coding agent to scaffold an integration or write it yourself. Freehop has an inspectable JavaScript API and source; bring your own models, application logic, authentication and backend. It does not include an AI model, transcription service, or agent runtime.
+
+| Start here | What you can try |
+|---|---|
+| [Hopper](https://jolynstudios.github.io/freehop/hopper) | Small rooms with device preview, video, voice and chat. |
+| [Live demo](https://jolynstudios.github.io/freehop/demo) | A real browser call with connection-path and playback inspection. |
+
+Open Hopper or the live demo in two browsers, or share a room link with someone. Both run the real Freehop client and demonstrate voice, video and session connections.
+
+### Where it fits
+
+| Build | Freehop provides | Your app provides |
+|---|---|---|
+| Small meeting rooms | Voice, video, controls and chat messages | Room UI, invitations and admission |
+| Calls inside a portal or tool | A call attached to the current task | Identity, access rules and customer/project data |
+| Shared workspaces | Media plus small selection or ready events | Editor, document sync and persistence |
+| Electron collaboration apps | Renderer client and optional desktop gateway | Desktop UI, packaging and updates |
+| Community rooms and games | Voice-first rooms, optional video, small events | Community rules, activity or game logic |
+
+These are integration ideas; Hopper and the live demo are the working examples. See the [use-case recipes](https://jolynstudios.github.io/freehop/docs/use-cases).
+
+Read the [Three.js integration guide](https://jolynstudios.github.io/freehop/docs/games), [Electron reference](https://jolynstudios.github.io/freehop/docs/sdk/desktop), or [AI build brief](https://jolynstudios.github.io/freehop/docs/build-with-ai).
+
 ---
 
 WebRTC first tries to connect people directly. Strict NATs and firewalls can block that path, so
@@ -35,23 +71,23 @@ works, Freehop reports `unreachable` instead of sending media through an operato
 
 | | |
 |---|---|
-| 💸 **No media through your gate** | Gates carry sealed signalling only. In every home-lab network test, gate traffic for an entire scenario stayed between 30 and 210 KB. A session gateway you run can still carry media on your bill. |
-| 🧱 **Connects the "impossible" pairs** | Two strict (symmetric) NATs, or a network that blocks UDP, can't connect directly. Freehop routes them through a session member's gateway or the session host, still with no operator relay. |
-| 🛰️ **No single point of failure** | Run one gate or many, operated by you, your community, or public WebTorrent trackers. Peers on different gates still find each other. **Calls keep running when every gate is down.** |
-| 🔐 **Private by construction** | Signalling is sealed (HKDF + AES-256-GCM), so gates can't read or forge envelopes. Direct and gateway paths preserve end-to-end DTLS-SRTP; a forwarding participant decodes and re-encodes media. |
-| ⚙️ **Automatic** | No manual room link is required in a ticket-based integration. Your backend issues a ticket, and the SDK takes the cheapest path that works: direct, then gateway, then relay, then bridge. |
-| 📦 **Small and open** | Zero-dependency browser client; a gate with one dependency (`ws`); TURN gateway and PCP / NAT-PMP / UPnP port mapping in plain Node. Apache-2.0. |
+| **No media through your gate** | Gates carry sealed signalling only. In every home-lab network test, gate traffic for an entire scenario stayed between 30 and 210 KB. A session gateway you run can still carry media on your bill. |
+| **Routes through the session** | Two strict (symmetric) NATs, or a network that blocks UDP, can't connect directly. Freehop routes them through a session member's gateway or the session host, still with no operator relay. |
+| **Multiple signalling gates** | Run one gate or many, operated by you, your community, or public WebTorrent trackers. Peers on different gates still find each other. **Calls keep running when every gate is down.** |
+| **Private by construction** | Signalling is sealed (HKDF + AES-256-GCM), so gates can't read or forge envelopes. Direct and gateway paths preserve end-to-end DTLS-SRTP; a forwarding participant decodes and re-encodes media. |
+| **Automatic** | No manual room link is required in a ticket-based integration. Your backend issues a ticket, and the SDK takes the cheapest path that works: direct, then gateway, then relay, then bridge. |
+| **Small and open** | Zero-dependency browser client; a gate with one dependency (`ws`); TURN gateway and PCP / NAT-PMP / UPnP port mapping in plain Node. Apache-2.0. |
 
 ## How it works
 
 ```mermaid
 flowchart LR
   subgraph session["One session (a call)"]
-    A["🏠 Participant A<br/>(browser)"]
-    B["🏠 Participant B<br/>(phone, strict NAT)"]
-    H["🗼 Host node or<br/>desktop gateway"]
+    A["Participant A<br/>(browser)"]
+    B["Participant B<br/>(phone, strict NAT)"]
+    H["Host node or<br/>desktop gateway"]
   end
-  G["📮 Gate<br/>(your server)"]
+  G["Gate<br/>(your server)"]
   A -. "sealed envelopes (KB)" .-> G
   B -. "sealed envelopes (KB)" .-> G
   A == "media: direct when possible" ==> B
@@ -64,7 +100,7 @@ flowchart LR
 3. **The path ladder finds a route.** Freehop tries direct first (LAN, IPv6, STUN). If that fails it uses an endpoint's own gateway, then a gateway of another session member, then forwarding through a participant. A failure is reported honestly as `unreachable`.
 4. **Kicks rotate keys.** `authority.kick()` issues a new room secret; remaining members `update()` and drop the kicked peer.
 
-## Proof, not promises
+## Published network evidence
 
 These results come from Freehop's own home-built, isolated Linux network test environment—not
 an independent testing laboratory or tests on live ISP, mobile or corporate networks. Real
@@ -88,8 +124,8 @@ arrive.
 
 **40/40 home-lab network test runs passed** on 2 October 2026 after security hardening,
 including gateways that relay only inside their session. That matrix has not been rerun for
-alpha.2. These are repeatable simulated-network results, not field reliability evidence. Other checks:
-- **167/167 unit tests**, including the RFC 5769 STUN vectors and the security regressions.
+this revision. These are repeatable simulated-network results, not field reliability evidence. Other checks:
+- **173/173 unit tests**, including the RFC 5769 STUN vectors and the security regressions.
 - **coturn's own test client** against Freehop's TURN server: 800/800 messages over UDP and 800/800 over TCP, 0 lost.
 - **Browser suites:** multi-gate with every gate shut down mid-call, kick/rekey, a public WebTorrent tracker as the only gate, and the SDK example app.
 
@@ -111,7 +147,7 @@ Freehop is an independent project; any app can use the same public SDK.
 ## Quickstart
 
 ```bash
-npm install freehop@alpha                 # current alpha: 0.1.0-alpha.2
+npm install freehop@alpha                 # install the current alpha release
 ```
 
 **Backend:** decide who is in a room.

package/SDK.md

@@ -4,6 +4,18 @@ Freehop is built to be consumed. Any application uses the same five pieces. Redl
 a planned consumer and test environment, using the same public API. Nothing below is
 game-specific.
 
+## TypeScript support
+
+Version 0.1.0-alpha.4 includes declarations for every public entry point. The runtime remains
+JavaScript; options, event callbacks, tickets, stats and backend APIs are typed for consumers.
+Import `type Session`, `type Ticket` or `type ConnectOptions` from `freehop` as needed.
+Incoming message data is `unknown` and must be narrowed. Outgoing messages are checked for
+JSON compatibility. Backend-only imports do not require DOM types.
+
+Install the typed release with `npm install freehop@alpha`. It is also available on
+[GitHub](https://github.com/jolynstudios/freehop/releases/tag/v0.1.0-alpha.4). See the [TypeScript setup guide](https://jolynstudios.github.io/freehop/docs/typescript).
+
+
 ```
  your backend            your gate host            every client               hosts (optional)
  ───────────             ─────────────             ────────────               ────────────────
@@ -55,6 +67,7 @@ session.on('path', ({ peer, kind, via }) => …);          // direct | gateway |
 session.on('peer-left', ({ id, reason }) => …);
 await session.setMicrophone(false); await session.setCamera(true);
 const levels = await session.levels();                   // speaking indicators
+await session.setPeerMuted(peerId, true);          // silence one member locally
 await session.update(newTicket, { dropped: [kickedPeerId] });   // after a kick
 await session.switchDevice('audio', deviceId);      // another microphone or camera, no renegotiation
 await session.send({ type: 'chat', text: 'hi' });   // app data to everyone (or { to: peerId })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freehop",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.4",
   "description": "Open-source peer-to-peer voice, video and data SDK for browser and desktop apps, with signalling gates and session-member media gateways.",
   "license": "Apache-2.0",
   "type": "module",
@@ -8,27 +8,77 @@
     "node": ">=22"
   },
   "exports": {
-    ".": "./src/sdk/client.mjs",
-    "./client": "./src/client/peerlane.mjs",
-    "./gate": "./src/gate/gate.mjs",
-    "./relay": "./src/relay/agent.mjs",
-    "./turn": "./src/relay/turn-server.mjs",
-    "./port-mapper": "./src/relay/port-mapper.mjs",
-    "./member": "./src/relay/member.mjs",
-    "./stun": "./src/shared/stun.mjs",
-    "./sdk": "./src/sdk/client.mjs",
-    "./authority": "./src/sdk/authority.mjs",
-    "./host": "./src/sdk/host.mjs",
-    "./ticket": "./src/sdk/ticket.mjs",
-    "./electron": "./src/electron/main.mjs",
-    "./electron/preload": "./src/electron/preload.cjs",
-    "./tokens": "./src/shared/tokens.mjs"
+    ".": {
+      "types": "./src/sdk/client.d.mts",
+      "default": "./src/sdk/client.mjs"
+    },
+    "./client": {
+      "types": "./src/client/peerlane.d.mts",
+      "default": "./src/client/peerlane.mjs"
+    },
+    "./gate": {
+      "types": "./src/gate/gate.d.mts",
+      "default": "./src/gate/gate.mjs"
+    },
+    "./relay": {
+      "types": "./src/relay/agent.d.mts",
+      "default": "./src/relay/agent.mjs"
+    },
+    "./turn": {
+      "types": "./src/relay/turn-server.d.mts",
+      "default": "./src/relay/turn-server.mjs"
+    },
+    "./port-mapper": {
+      "types": "./src/relay/port-mapper.d.mts",
+      "default": "./src/relay/port-mapper.mjs"
+    },
+    "./member": {
+      "types": "./src/relay/member.d.mts",
+      "default": "./src/relay/member.mjs"
+    },
+    "./stun": {
+      "types": "./src/shared/stun.d.mts",
+      "default": "./src/shared/stun.mjs"
+    },
+    "./sdk": {
+      "types": "./src/sdk/client.d.mts",
+      "default": "./src/sdk/client.mjs"
+    },
+    "./authority": {
+      "types": "./src/sdk/authority.d.mts",
+      "default": "./src/sdk/authority.mjs"
+    },
+    "./host": {
+      "types": "./src/sdk/host.d.mts",
+      "default": "./src/sdk/host.mjs"
+    },
+    "./ticket": {
+      "types": "./src/sdk/ticket.d.mts",
+      "default": "./src/sdk/ticket.mjs"
+    },
+    "./electron": {
+      "types": "./src/electron/main.d.mts",
+      "default": "./src/electron/main.mjs"
+    },
+    "./electron/preload": {
+      "types": "./src/electron/preload.d.cts",
+      "default": "./src/electron/preload.cjs"
+    },
+    "./tokens": {
+      "types": "./src/shared/tokens.d.mts",
+      "default": "./src/shared/tokens.mjs"
+    }
   },
   "scripts": {
     "test": "node --test test/*.test.mjs",
     "test:browsers": "node test/browser/smoke.mjs chromium,firefox,webkit --tls && node test/browser/multigate.mjs && node test/browser/rekey.mjs && node test/browser/example-app.mjs",
+    "unitgate": "node tools/unitgate.mjs",
+    "exportsgate": "node tools/exportsgate.mjs",
+    "docsyncgate": "node tools/docsyncgate.mjs",
+    "ship": "node tools/ship.mjs",
     "gate": "node bin/freehop-gate.mjs",
-    "example": "node examples/minimal/server.mjs"
+    "example": "node examples/minimal/server.mjs",
+    "typesgate": "node tools/typesgate.mjs"
   },
   "author": "Jolyn Studios",
   "homepage": "https://jolynstudios.github.io/freehop/",
@@ -71,9 +121,12 @@
     "NOTICE"
   ],
   "dependencies": {
+    "@types/node": "22.20.5",
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "playwright": "1.62.0"
-  }
+    "playwright": "1.62.0",
+    "typescript": "7.0.2"
+  },
+  "types": "./src/sdk/client.d.mts"
 }

package/src/client/peerlane.d.mts

@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {ClientGateway, GateAuth, JsonValue, JsonCompatible, Log} from '../shared/types.mjs';
+export type {ClientGateway, GateAuth, JsonValue, JsonCompatible, Log} from '../shared/types.mjs';
+export type PathKind = 'connecting' | 'direct' | 'gateway' | 'relay' | 'bridged' | 'unreachable';
+export type VideoQualityLevel = 'normal' | 'reduced' | 'minimal' | 'paused';
+export interface ConnectionPath {
+  kind: PathKind;
+  via?: string | null;
+  phase?: 0 | 1 | 2;
+  local?: RTCIceCandidateType;
+  remote?: RTCIceCandidateType;
+  protocol?: string;
+  relayProtocol?: string | null;
+  localAddress?: string | null;
+  remoteAddress?: string | null;
+  relayUrl?: string | null;
+  rtt?: number | null;
+  bytesSent?: number;
+  bytesReceived?: number;
+}
+export interface RoomEvents {
+  peer: {id: string};
+  'peer-left': {id: string; reason: 'bye' | 'dropped' | 'rekey' | 'gone'};
+  /** Untrusted data. Narrow/validate before rendering or acting on it. */
+  message: {from: string; data: unknown};
+  track: {peer: string; via: string | null; track: MediaStreamTrack; stream: MediaStream};
+  'track-ended': {peer: string; via: string; stream: string};
+  path: ConnectionPath & {peer: string};
+  'video-quality': {peer: string; direction: 'send' | 'receive'; level: VideoQualityLevel; reason: string};
+  link: {peer: string; connected: boolean};
+  gate: {url: string; state: 'joined' | 'reconnecting' | 'error'; code?: string};
+  gateway: {id: string; available: boolean};
+  closed: Record<string, never>;
+}
+export interface RoomTiming {
+  capsWaitMs: number;
+  politeWaitMs: number;
+  endpointMs: number;
+  sessionMs: number;
+  bridgedRetryMs: number;
+  maxRetryMs: number;
+  restartFallbackMs: number;
+  mediaWatchMs: number;
+  recoveryMs: number;
+  bridgeWaitMs: number;
+  departGraceMs: number;
+  offerTimeoutMs: number;
+  greetMs: number;
+  outboxMs: number;
+  sweepMs: number;
+}
+export interface RoomLimits {
+  audioBitrate: number;
+  videoBitrate: number;
+  forwardVideoBitrate: number;
+  maxPeers: number;
+  maxGatewayMembers: number;
+  maxHints: number;
+  maxBridges: number;
+  meshForwardPerMinute: number;
+  outboxPerPeer: number;
+}
+export interface MediaOptions {
+  audio?: boolean;
+  video?: boolean;
+}
+export interface MediaControls {
+  media?: MediaOptions | MediaStream | null;
+  devices?: {audio?: string | null; video?: string | null};
+  gateway?: ClientGateway | null;
+  stun?: string[];
+  forward?: boolean;
+  adaptiveVideo?: boolean;
+  timing?: Partial<RoomTiming>;
+  limits?: Partial<RoomLimits>;
+  log?: Log;
+  getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+  RTCPeerConnection?: typeof RTCPeerConnection;
+  WebSocket?: typeof WebSocket;
+}
+export interface JoinOptions extends MediaControls {
+  gates: string[];
+  secret: string | Uint8Array;
+  app?: string;
+  auth?: GateAuth;
+}
+export interface InboundMediaStats {
+  packets: number;
+  bytes: number;
+  frames: number;
+  samples: number;
+  lost: number;
+  jitter: number;
+  streams: number;
+  width?: number;
+  height?: number;
+}
+export interface OutboundMediaStats {
+  packets: number;
+  bytes: number;
+  frames: number;
+  streams: number;
+}
+export interface LinkStats {
+  peer: string;
+  connected: boolean;
+  phase: 0 | 1 | 2;
+  path: ConnectionPath;
+  restarts: number;
+  connectMs: number | null;
+  forwardedOrigins: string[];
+  forwarding: string[];
+  media: {
+    inbound: Partial<Record<'audio' | 'video', InboundMediaStats>>;
+    outbound: Partial<Record<'audio' | 'video', OutboundMediaStats>>;
+  };
+}
+export interface GateStats {
+  url: string;
+  state: string;
+  sent: number;
+  received: number;
+  bytesOut: number;
+  bytesIn: number;
+  errors: number;
+  connects: number;
+}
+export interface RoomStats {
+  id: string;
+  tag: string;
+  counters: Record<string, number>;
+  gates: GateStats[];
+  links: LinkStats[];
+  bridges: Array<{peer: string; via: string | null; state: string; requestedAt: number}>;
+  relaying: Array<{a: string; b: string}>;
+}
+export interface PeerConnectionView {
+  id: string;
+  pc: RTCPeerConnection;
+  connected: boolean;
+  closed: boolean;
+  phase: 0 | 1 | 2;
+  path: ConnectionPath;
+}
+export class Room {
+  constructor(options: JoinOptions);
+  readonly id: string;
+  /** Available after start(). Prefer join() for an initialized room. */
+  readonly tag: string | undefined;
+  readonly tag8: string;
+  readonly app: string;
+  readonly closed: boolean;
+  readonly localStream: MediaStream | null;
+  readonly links: Map<string, PeerConnectionView>;
+  readonly known: Set<string>;
+  readonly options: JoinOptions;
+  readonly timing: RoomTiming;
+  readonly limits: RoomLimits;
+  readonly adaptiveVideoEnabled: boolean;
+  readonly devices: {audio: string | null; video: string | null};
+  on<E extends keyof RoomEvents>(event: E, handler: (detail: RoomEvents[E]) => void): () => void;
+  off<E extends keyof RoomEvents>(event: E, handler: (detail: RoomEvents[E]) => void): void;
+  start(): Promise<void>;
+  rekey(secret: string | Uint8Array, options?: {auth?: GateAuth; gates?: string[]; stun?: string[]}): Promise<void>;
+  drop(peer: string): void;
+  send<T>(data: T & JsonCompatible<T>, options?: {to?: string}): Promise<number>;
+  setGateway(gateway: ClientGateway | null): Promise<void>;
+  setMedia(media: MediaOptions | MediaStream | null): Promise<void>;
+  setMicrophone(enabled: boolean): Promise<void>;
+  setCamera(enabled: boolean): Promise<void>;
+  setPeerMuted(peer: string, muted: boolean): void;
+  switchDevice(kind: 'audio' | 'video', deviceId: string | null): Promise<boolean>;
+  setAdaptiveVideo(enabled: boolean): Promise<boolean>;
+  stats(): Promise<RoomStats>;
+  leave(): Promise<void>;
+}
+export interface StartedRoom extends Room {
+  readonly tag: string;
+}
+export function join(options: JoinOptions): Promise<StartedRoom>;
+export const DEFAULT_TIMING: Readonly<RoomTiming>;
+export const DEFAULT_LIMITS: Readonly<RoomLimits>;
+export const PHASE: Readonly<{ENDPOINT: 0; SESSION: 1; BRIDGED: 2}>;
+export function deriveRoom(secret: string | Uint8Array, app?: string): Promise<{tag: string; key: CryptoKey}>;
+export function randomId(bytes?: number): string;

package/src/client/room.mjs

@@ -121,6 +121,8 @@ export class Room extends Emitter {
       offerTimeouts: 0, mediaStalls: 0, appSent: 0, appReceived: 0, appDropped: 0 };
     this.appBudget = new Map();   // sender -> { tokens, at }
     this.videoQuality = new Map(); // peer -> per-link send/receive controller state
+    this.mutedPeers = new Set();  // peers muted locally (setPeerMuted)
+    this.remoteAudio = new Map(); // peer -> Set of live remote audio tracks, for flipping enabled
     // Preferred capture devices (options.devices, switchDevice); every later capture uses them.
     if (!deviceId(options.devices?.audio) || !deviceId(options.devices?.video)) throw new TypeError('Invalid capture device id');
     this.devices = { audio: options.devices?.audio ?? null, video: options.devices?.video ?? null };
@@ -346,8 +348,10 @@ export class Room extends Emitter {
     this.known.delete(peer); this.hintedAt.delete(peer); this.caps.delete(peer); this.presence.delete(peer); this.early.delete(peer); this.outbox.delete(peer);
     this.sendProgress.delete(peer); this.meshBudget.delete(peer); this.appBudget.delete(peer); this.videoQuality.delete(peer);
     this.lastContact.delete(peer); this.gatewayCreds.delete(`${this.tag8}:${peer}`);
-    // The replay window survives a soft departure: a returning peer keeps its counter.
-    if (reason !== 'gone') this.sequences.delete(peer);
+    this.remoteAudio.delete(peer);
+    // A softly departed ('gone') peer may return with the same id: its replay window and local
+    // mute survive. Terminal departures ('bye', 'dropped', 'rekey') clear both.
+    if (reason !== 'gone') { this.sequences.delete(peer); this.mutedPeers.delete(peer); }
     this.departed.set(peer, { at: Date.now(), reason });
     if (this.departed.size > 256) this.departed.delete(this.departed.keys().next().value);
     for (const [key, b] of [...this.bridgePending]) if (b.a === peer || b.b === peer) {
@@ -900,6 +904,18 @@ export class Room extends Emitter {
   setMicrophone(enabled) { return this.#enableTrack('audio', enabled, MIC); }
   setCamera(enabled) { return this.#enableTrack('video', enabled, CAM); }
 
+  /**
+   * Silences one member locally: enabled = false on their current and future remote audio
+   * tracks. Media still arrives and nothing is signalled, so the peer cannot tell. Muting
+   * an unknown peer is allowed and applies when their audio arrives. Video is untouched.
+   */
+  setPeerMuted(peer, muted) {
+    if (typeof peer !== 'string' || !PEER_ID.test(peer)) throw new TypeError('Invalid peer id');
+    if (typeof muted !== 'boolean') throw new TypeError('muted must be a boolean');
+    if (muted) this.mutedPeers.add(peer); else this.mutedPeers.delete(peer);
+    for (const track of this.remoteAudio.get(peer) ?? []) track.enabled = !muted;
+  }
+
   constraintsFor(kind, base) { const id = this.devices[kind]; return id ? { ...base, deviceId: { exact: id } } : base; }
 
   /**
@@ -1193,6 +1209,13 @@ export class Room extends Emitter {
   }
 
   onRemoteTrack(link, origin, track, stream) {
+    if (track.kind === 'audio') {
+      let set = this.remoteAudio.get(origin);
+      if (!set) this.remoteAudio.set(origin, set = new Set());
+      set.add(track);
+      track.addEventListener('ended', () => set.delete(track));
+      if (this.mutedPeers.has(origin)) track.enabled = false;
+    }
     this.emit('track', { peer: origin, via: origin === link.id ? null : link.id, track, stream });
     if (origin !== link.id) return;
     // A forwarder keeps forwarding tracks the origin adds later (e.g. camera switched on).

package/src/electron/main.d.mts

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {Gateway, GatewayOptions} from '../relay/agent.mjs';
+import type {Log} from '../shared/types.mjs';
+/** Structural subset, so browser users do not need Electron installed for SDK types. */
+export interface GatewayIpcEvent {
+  senderFrame: {url: string} | null;
+  sender: {
+    mainFrame: {url: string};
+    on(event: string, listener: () => void): unknown;
+    once(event: string, listener: () => void): unknown;
+  };
+}
+export interface GatewayIpcMain {
+  handle(channel: string, listener: (event: GatewayIpcEvent, ...args: unknown[]) => unknown): void;
+  removeHandler(channel: string): void;
+}
+export interface ElectronGatewayOptions {
+  ipcMain: GatewayIpcMain;
+  allowedOrigins: string[];
+  options?: GatewayOptions;
+  log?: Log;
+}
+export interface ElectronGateway {
+  readonly gateway: Gateway | null;
+  close(): Promise<void>;
+}
+export function installFreehopGateway(options: ElectronGatewayOptions): ElectronGateway;

package/src/electron/preload.d.cts

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: Apache-2.0
+// This entry point is a side-effect-only Electron preload. No runtime exports.
+export {};

package/src/gate/gate.d.mts

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {Server, IncomingMessage} from 'node:http';
+import type {Log, MaybePromise} from '../shared/types.mjs';
+export {mintGateToken, verifyGateToken} from '../shared/tokens.mjs';
+export const GATE_PROTOCOL: 1;
+export interface GateLimits {
+  frame: number;
+  box: number;
+  roomsPerSocket: number;
+  peersPerRoom: number;
+  socketsPerAddress: number;
+  maxSockets: number;
+  maxPendingSockets: number;
+  pendingPerAddress: number;
+  helloMs: number;
+  closeMs: number;
+  idleMs: number;
+  pingMs: number;
+  burstBytes: number;
+  refillBytesPerSec: number;
+  messagesPerSec: number;
+  messageBurst: number;
+  maxBufferedBytes: number;
+  maxBufferedTotal: number;
+  maxPendingFrames: number;
+  maxPendingBytes: number;
+}
+export const GATE_LIMITS: Readonly<GateLimits>;
+export interface GateHello {
+  t: 'hello';
+  v: 1;
+  auth?: unknown;
+  [key: string]: unknown;
+}
+export interface GateOptions {
+  server?: Server;
+  host?: string;
+  port?: number;
+  path?: string;
+  publicHost?: string;
+  stun?: Array<{host?: string; port?: number; ratePerSec?: number; burst?: number; totalRatePerSec?: number; totalBurst?: number; software?: string}>;
+  stunUrls?: string[];
+  tokenSecret?: string;
+  tokenAudience?: string;
+  trustProxy?: boolean;
+  authorize?: (hello: GateHello, request: IncomingMessage) => MaybePromise<boolean>;
+  limits?: Partial<GateLimits>;
+  log?: Log;
+}
+export interface Gate {
+  readonly server: Server;
+  readonly path: string;
+  readonly stunUrls: string[];
+  url(host?: string): string;
+  stats(): {[counter: string]: number | Array<Record<string, number>>; stun: Array<Record<string, number>>};
+  rooms(): number;
+  close(): Promise<void>;
+}
+export function createGate(options?: GateOptions): Promise<Gate>;
+export function randomTag(bytes?: number): string;

package/src/relay/agent.d.mts

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {GatewayInfo, GatewayCredentials, Log} from '../shared/types.mjs';
+import type {TurnLimits, TurnServer} from './turn-server.mjs';
+import type {PortMapper, PortMapperOptions, PortMapping} from './port-mapper.mjs';
+export interface GatewayOptions {
+  host?: string;
+  port?: number;
+  relayPortRange?: [number, number];
+  portMapping?: boolean | PortMapperOptions;
+  mapper?: PortMapper | null;
+  externalAddress?: string;
+  rooms?: string[];
+  credentialTtlSeconds?: number;
+  relayScope?: 'internal' | 'public';
+  limits?: Partial<TurnLimits>;
+  log?: Log;
+}
+export interface GatewayStats {
+  external: string | null;
+  relayScope: 'internal' | 'public';
+  rooms: number;
+  revocations: number;
+  floors: number;
+  mappings: Array<Pick<PortMapping, 'method' | 'protocol' | 'internalPort' | 'externalPort'>>;
+  turn: Record<string, number>;
+}
+export interface Gateway {
+  readonly turn: TurnServer;
+  readonly mapper: PortMapper | null;
+  info(): GatewayInfo | null;
+  credentialsFor(roomTag: string, peer: string): GatewayCredentials | null;
+  allowRoom(roomTag: string): void;
+  revokeRoom(roomTag: string): number;
+  revokePeer(roomTag: string, peer: string): number;
+  rotate(): GatewayInfo | null;
+  stats(): GatewayStats;
+  close(): Promise<void>;
+}
+export function startGateway(options?: GatewayOptions): Promise<Gateway>;
+export function isPublicAddress(address: string): boolean;

package/src/relay/member.d.mts

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {Gateway} from './agent.mjs';
+import type {GateAuth, Log} from '../shared/types.mjs';
+export const GATEWAY_ID_PREFIX: 'gw_';
+export interface GatewayMemberOptions {
+  gates: string[];
+  secret: string | Uint8Array;
+  app?: string;
+  gateway: Gateway;
+  auth?: GateAuth;
+  WebSocketImpl?: typeof WebSocket;
+  departGraceMs?: number;
+  log?: Log;
+}
+export interface GatewayMember {
+  readonly id: string;
+  stats(): Record<string, number>;
+  drop(peer: string): void;
+  rekey(secret: string | Uint8Array, options?: {auth?: GateAuth; dropped?: string[]; gates?: string[]}): Promise<void>;
+  setAuth(auth?: GateAuth): void;
+  close(): Promise<void>;
+}
+export function joinAsGateway(options: GatewayMemberOptions): Promise<GatewayMember>;

package/src/relay/port-mapper.d.mts

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {EventEmitter} from 'node:events';
+import type {Log} from '../shared/types.mjs';
+export type MappingMethod = 'pcp' | 'natpmp' | 'upnp';
+export interface PortMapperOptions {
+  gateway?: string;
+  localAddress?: string;
+  methods?: MappingMethod | MappingMethod[];
+  timeoutMs?: number;
+  pcpPort?: number;
+  natpmpPort?: number;
+  ssdpPort?: number;
+  ssdpAddress?: string;
+  log?: Log;
+}
+export interface MappingRequest {
+  protocol: 'udp' | 'tcp';
+  internalPort: number;
+  suggestedExternalPort?: number;
+  lifetimeSeconds?: number;
+  description?: string;
+}
+export interface PortMapping {
+  method: MappingMethod;
+  protocol: 'udp' | 'tcp';
+  internalAddress: string;
+  internalPort: number;
+  externalAddress: string | null;
+  externalPort: number;
+  lifetimeSeconds: number;
+  expiresAt: number | null;
+  externalAddressIsPrivate: boolean | null;
+  gateway: string;
+  description: string;
+}
+export interface MappingProbe {
+  gateway: string | null;
+  localAddress: string | null;
+  available: Record<MappingMethod, boolean>;
+  externalAddress: string | null;
+  externalAddressIsPrivate: boolean | null;
+  details: Record<string, unknown>;
+}
+export interface PortMapper extends EventEmitter {
+  readonly gateway: string | null;
+  readonly localAddress: string | null;
+  readonly closed: boolean;
+  readonly mappings: PortMapping[];
+  probe(): Promise<MappingProbe>;
+  map(request: MappingRequest): Promise<PortMapping>;
+  unmap(mapping: PortMapping): Promise<boolean>;
+  close(): Promise<void>;
+  on(event: 'renewed', listener: (mapping: PortMapping) => void): this;
+  on(event: 'lost', listener: (mapping: PortMapping, error: PortMapperError) => void): this;
+  on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+}
+export class PortMapperError extends Error {
+  constructor(message: string, code: string, details?: {cause?: unknown; [key: string]: unknown});
+  code: string;
+  method?: MappingMethod;
+  transient?: boolean;
+  unavailable?: boolean;
+  resultCode?: number;
+  upnpErrorCode?: number;
+}
+export function createPortMapper(options?: PortMapperOptions): Promise<PortMapper>;
+export function isPrivateIPv4(ip: string): boolean;
+export interface DefaultGateway {
+  gateway: string;
+  interface: string | null;
+}
+export function parseDefaultGateway(platform: string, text: string): DefaultGateway | null;
+export function detectGateway(options?: {timeoutMs?: number; signal?: AbortSignal}): Promise<DefaultGateway | null>;
+export function parseIgdDescription(xml: string, location: string): Array<{serviceType: string; version: number; rank: number; controlURL: string}>;
+export function parseSoapFault(
+  xml: string,
+): {errorCode: number | null; errorDescription: string | null; faultCode: string | null; faultString: string | null} | null;

package/src/relay/turn-server.d.mts

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {TlsOptions} from 'node:tls';
+import type {Log, MaybePromise} from '../shared/types.mjs';
+export interface TurnLimits {
+  maxAllocations: number;
+  maxAllocationsPerUsername: number;
+  allocationBitrate: number;
+  totalBitrate: number;
+  defaultLifetime: number;
+  maxLifetime: number;
+  permissionLifetime: number;
+  channelLifetime: number;
+  maxPermissions: number;
+  maxChannels: number;
+  nonceLifetime: number;
+  maxTcpConnections: number;
+  tcpIdleMs: number;
+  hookTimeoutMs: number;
+  maxTcpPerAddress: number;
+  tcpPreAuthMs: number;
+  errorRate: number;
+  errorBurst: number;
+  udpResponseRate: number;
+  udpResponseBurst: number;
+  maxAllocationsPerScope?: number;
+  scopeBitrate?: number;
+}
+export const DEFAULT_LIMITS: Readonly<Omit<TurnLimits, 'maxAllocationsPerScope' | 'scopeBitrate'>>;
+export type Transport = 'udp' | 'tcp' | 'tls';
+export type ListenOptions = {host?: string; port?: number} & (
+  {transport?: 'udp' | 'tcp'} | {transport: 'tls'; key: NonNullable<TlsOptions['key']>; cert: NonNullable<TlsOptions['cert']>; passphrase?: string}
+);
+export interface PeerAddress {
+  address: string;
+  port: number;
+  family: 4 | 6;
+}
+export interface TurnOptions {
+  authenticate(username: string, realm: string): MaybePromise<string | null>;
+  realm?: string;
+  software?: string | false | null;
+  listen?: ListenOptions[];
+  relayHost?: string | string[];
+  externalAddress?: string | string[];
+  relayPortRange?: [number, number];
+  peerScope?: 'public' | 'internal';
+  allowPrivatePeers?: boolean;
+  allowPeer?: (peer: PeerAddress, context: {username: string}) => boolean;
+  allocationScope?: (username: string) => string;
+  mapRelayPort?: (localPort: number, family: 4 | 6, signal: AbortSignal) => MaybePromise<number | null>;
+  limits?: Partial<TurnLimits>;
+  log?: Log;
+}
+export interface TurnServer {
+  addresses(): Array<{transport: Transport; address: string; port: number}>;
+  relayedAddresses(): Array<{internal: {address: string; port: number}; external: {address: string; port: number}; username: string}>;
+  stats(): Record<string, number>;
+  revoke(predicate: (username: string) => boolean): number;
+  close(): Promise<void>;
+}
+export function createTurnServer(options: TurnOptions): Promise<TurnServer>;
+export function classifyPeerAddress(address: string | Uint8Array): 'deny' | 'private' | 'public';

package/src/sdk/authority.d.mts

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {Ticket} from './ticket.mjs';
+export interface AuthorityOptions {
+  app: string;
+  gates: string[];
+  gateTokenSecret?: string;
+  gateTokenSecrets?: Record<string, string>;
+  stun?: string[];
+  ticketTtlSeconds?: number;
+  maxRooms?: number;
+}
+export interface RoomDescription {
+  roomId: string;
+  tag: string;
+  epoch: number;
+  members: string[];
+}
+export interface TicketRotation {
+  epoch: number;
+  previousTags: string[];
+  tickets: Map<string, Ticket>;
+  hostTicket: Ticket;
+}
+export interface Authority {
+  openRoom(roomId: string): Promise<Omit<RoomDescription, 'members'> & {members: number}>;
+  ticket(roomId: string, member?: string): Promise<Ticket>;
+  kick(roomId: string, member: string): Promise<TicketRotation>;
+  leave(roomId: string, member: string): Promise<TicketRotation>;
+  closeRoom(roomId: string): Promise<boolean>;
+  describe(roomId: string): RoomDescription | null;
+}
+export function createAuthority(options: AuthorityOptions): Authority;

package/src/sdk/client.d.mts

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {StartedRoom, MediaControls} from '../client/peerlane.mjs';
+import type {DesktopGateway, RotationOptions} from '../shared/types.mjs';
+import type {Ticket} from './ticket.mjs';
+export {encodeTicket, decodeTicket, validTicket} from './ticket.mjs';
+export type {Ticket} from './ticket.mjs';
+export type {RoomEvents, RoomStats, LinkStats, ConnectionPath, PathKind, VideoQualityLevel, RoomTiming, RoomLimits, MediaOptions} from '../client/peerlane.mjs';
+export type {DesktopGateway, GatewayInfo, GatewayCredentials, JsonValue, Log} from '../shared/types.mjs';
+export interface ConnectOptions extends MediaControls {
+  /** null disables automatic discovery of window.freehopGateway. */
+  desktopGateway?: DesktopGateway | null;
+}
+export interface Session extends StartedRoom {
+  ticket(): Ticket;
+  update(ticket: Ticket | string, options?: RotationOptions): Promise<boolean>;
+  refresh(ticket: Ticket | string): Promise<boolean>;
+  disconnectPeer(peer: string): Promise<void>;
+  /** Always rejects. Use authority.kick() and distribute replacement tickets. */
+  kick(): Promise<never>;
+  attach<T extends HTMLMediaElement>(track: MediaStreamTrack, element: T): T;
+  levels(): Promise<Record<string, number>>;
+}
+export function connect(ticket: Ticket | string, options?: ConnectOptions): Promise<Session>;

package/src/sdk/host.d.mts

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {Ticket} from './ticket.mjs';
+import type {Gateway, GatewayOptions, GatewayStats} from '../relay/agent.mjs';
+import type {Log, RotationOptions} from '../shared/types.mjs';
+export interface HostOptions {
+  gateway?: 'auto' | Gateway | null | false;
+  gatewayOptions?: GatewayOptions;
+  log?: Log;
+}
+export interface AvailableHost {
+  available: true;
+  readonly id: string;
+  readonly gateway: Gateway;
+  update(ticket: Ticket | string, options?: RotationOptions): Promise<boolean>;
+  refresh(ticket: Ticket | string): Promise<boolean>;
+  drop(peer: string): void;
+  stats(): {available: true; epoch: number; member: Record<string, number>; gateway: GatewayStats};
+  close(): Promise<void>;
+}
+export interface UnavailableHost {
+  available: false;
+  update(ticket: Ticket | string, options?: RotationOptions): Promise<void>;
+  refresh(ticket: Ticket | string): Promise<false>;
+  stats(): {available: false};
+  close(): Promise<void>;
+}
+export type HostedSession = AvailableHost | UnavailableHost;
+export function sharedGateway(options?: GatewayOptions): Promise<Gateway>;
+export function closeSharedGateway(): Promise<void>;
+export function hostSession(ticket: Ticket | string, options?: HostOptions): Promise<HostedSession>;

package/src/sdk/ticket.d.mts

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {GateAuth} from '../shared/types.mjs';
+export interface Ticket {
+  v: 1;
+  app: string;
+  roomId: string;
+  epoch: number;
+  gates: string[];
+  secret: string;
+  stun?: string[];
+  auth?: GateAuth;
+  /** Unix expiry in seconds. */
+  expires: number;
+}
+export function validTicket(value: unknown): value is Ticket;
+export function encodeTicket(ticket: Ticket): string;
+/** Throws TypeError for malformed, invalid or expired tickets. */
+export function decodeTicket(text: string): Ticket;

package/src/shared/stun.d.mts

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {Buffer} from 'node:buffer';
+export const MAGIC_COOKIE: 0x2112a442;
+export const METHOD: {BINDING: number; ALLOCATE: number; REFRESH: number; SEND: number; DATA: number; CREATE_PERMISSION: number; CHANNEL_BIND: number};
+export const CLASS: {REQUEST: 0; INDICATION: 1; SUCCESS: 2; ERROR: 3};
+export const ATTR: {
+  MAPPED_ADDRESS: number;
+  USERNAME: number;
+  MESSAGE_INTEGRITY: number;
+  ERROR_CODE: number;
+  UNKNOWN_ATTRIBUTES: number;
+  CHANNEL_NUMBER: number;
+  LIFETIME: number;
+  XOR_PEER_ADDRESS: number;
+  DATA: number;
+  REALM: number;
+  NONCE: number;
+  XOR_RELAYED_ADDRESS: number;
+  REQUESTED_ADDRESS_FAMILY: number;
+  EVEN_PORT: number;
+  REQUESTED_TRANSPORT: number;
+  DONT_FRAGMENT: number;
+  MESSAGE_INTEGRITY_SHA256: number;
+  PASSWORD_ALGORITHM: number;
+  USERHASH: number;
+  XOR_MAPPED_ADDRESS: number;
+  RESERVATION_TOKEN: number;
+  PRIORITY: number;
+  USE_CANDIDATE: number;
+  ADDITIONAL_ADDRESS_FAMILY: number;
+  PASSWORD_ALGORITHMS: number;
+  ALTERNATE_DOMAIN: number;
+  SOFTWARE: number;
+  ALTERNATE_SERVER: number;
+  FINGERPRINT: number;
+  ICE_CONTROLLED: number;
+  ICE_CONTROLLING: number;
+};
+export interface Attribute {
+  type: number;
+  value: Buffer;
+  offset: number;
+}
+export interface Message {
+  type: number;
+  method: number;
+  cls: number;
+  transactionId: Buffer;
+  attributes: Attribute[];
+  length: number;
+  raw: Buffer;
+}
+export interface Address {
+  address: string;
+  port: number;
+  family?: 4 | 6 | 'IPv4' | 'IPv6';
+}
+export interface DecodedAddress {
+  address: string;
+  port: number;
+  family: 4 | 6;
+}
+export type Bytes = Uint8Array;
+export type Value = Bytes | string;
+export function isStunMessage(buffer: Bytes | null | undefined): boolean;
+export function isChannelData(buffer: Bytes | null | undefined): boolean;
+export function decode(buffer: Bytes | null | undefined): Message | null;
+export function getAttr(message: Message | null | undefined, type: number): Buffer | undefined;
+export function encode(
+  message: {method: number; cls: number; transactionId?: Value; attributes?: Array<{type: number; value?: Value}>},
+  options?: {integrityKey?: Value; fingerprint?: boolean},
+): Buffer;
+export function ipToBytes(address: string): Buffer | null;
+export function bytesToIp(bytes: Bytes): string | null;
+export function encodeAddress(address: Address): Buffer;
+export function encodeXorAddress(address: Address, transactionId: Value): Buffer;
+export function decodeAddress(value: Bytes | null | undefined): DecodedAddress | null;
+export function decodeXorAddress(value: Bytes | null | undefined, transactionId: Bytes): DecodedAddress | null;
+export function errorCodeValue(code: number, reason?: string): Buffer;
+export function decodeErrorCode(value: Buffer | null | undefined): {code: number; reason: string} | null;
+export function saslprep(value: string): string;
+export function longTermKey(username: Value, realm: Value, password: Value): Buffer;
+export function verifyIntegrity(message: Message | null | undefined, key: Value): boolean;
+export function verifyFingerprint(message: Message | null | undefined): {present: boolean; valid: boolean};
+export function encodeChannelData(channel: number, data: Value, options?: {pad?: boolean}): Buffer;
+export function decodeChannelData(buffer: Bytes | null | undefined): {channel: number; data: Buffer} | null;
+export function frameStreamMessages(buffer?: Bytes | null): {messages: Buffer[]; rest: Buffer; need: number; error?: string};

package/src/shared/tokens.d.mts

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+import type {BinaryLike, KeyObject} from 'node:crypto';
+export interface GateTokenClaims {
+  exp: number;
+  room?: string;
+  aud?: string;
+  [key: string]: unknown;
+}
+export function mintGateToken(secret: BinaryLike | KeyObject, claims: GateTokenClaims): string;
+export function verifyGateToken(
+  secret: BinaryLike | KeyObject,
+  token: unknown,
+  options?: number | {audience?: string; now?: number} | null,
+): GateTokenClaims | null;

package/src/shared/types.d.mts

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+/** Values carried by session.send(). Validate incoming messages before use. */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {[key: string]: JsonValue};
+/** Structural JSON check that also accepts application interfaces. */
+export type JsonCompatible<T> = T extends null | boolean | number | string
+  ? T
+  : T extends (...args: never[]) => unknown
+    ? never
+    : T extends object
+      ? {[K in keyof T]: JsonCompatible<T[K]>}
+      : never;
+export type Log = (event: string, details: Record<string, unknown>) => void;
+export type MaybePromise<T> = T | Promise<T>;
+export type GateAuth = string | Record<string, string>;
+export interface GatewayCredentials {
+  username: string;
+  credential: string;
+}
+export interface GatewayInfo {
+  urls: string[];
+  internalUrls?: string[];
+  ttlSeconds?: number;
+  external?: string[];
+  internal?: string | null;
+}
+export interface GatewayBroker {
+  info(): GatewayInfo | null;
+  credentialsFor(tag: string, peer: string): MaybePromise<GatewayCredentials | null>;
+}
+export type ClientGateway = GatewayBroker | (GatewayInfo & Pick<GatewayBroker, 'credentialsFor'>);
+/** The supported, origin-restricted Electron preload bridge. */
+export interface DesktopGateway {
+  info(): Promise<GatewayInfo | null>;
+  credentialsFor(tag: string, peer: string): Promise<GatewayCredentials | null>;
+  allowRoom(tag: string): Promise<void>;
+  revokePeer(tag: string, peer: string): Promise<void>;
+  revokeRoom(tag: string): Promise<void>;
+}
+export interface RotationOptions {
+  dropped?: string[];
+}