@fitzzero/quickdraw-core 5.1.1 → 5.1.3

package/dist/chunk-DNP65TD5.js

@@ -0,0 +1,832 @@
+import {
+  createLinkCore,
+  throwLater
+} from "./chunk-ASAMUGHG.js";
+import {
+  isPeerLabel,
+  isRoomName,
+  isSocketId,
+  readSignal
+} from "./chunk-2FDSKLBO.js";
+import {
+  CLIENT_EVENTS,
+  MAX_PEER_LINKS,
+  MAX_PEER_MESSAGE_BYTES,
+  PEER_RELAY_BURST,
+  PEER_RELAY_BYTES_BURST,
+  PEER_RELAY_BYTES_PER_SECOND,
+  PEER_RELAY_FAST_BACKLOG,
+  PEER_RELAY_RATE,
+  SERVER_EVENTS
+} from "./chunk-X4ZU4QH5.js";
+import {
+  utf8ByteLength
+} from "./chunk-7Y5ROPXL.js";
+import {
+  isRecord
+} from "./chunk-QSU47XEX.js";
+
+// src/client/peer/rtc.ts
+var DISCONNECTED_GRACE_MS = 5e3;
+var FAST_BACKLOG_BYTES = 32768;
+var MAX_EARLY_CANDIDATES = 64;
+function candidateOf(candidate) {
+  const { sdpMid, sdpMLineIndex, usernameFragment } = candidate;
+  return {
+    candidate: candidate.candidate,
+    ...sdpMid === void 0 ? {} : { sdpMid },
+    ...sdpMLineIndex === void 0 ? {} : { sdpMLineIndex },
+    ...usernameFragment === void 0 ? {} : { usernameFragment }
+  };
+}
+function shut(state) {
+  state.closed = true;
+  state.open = false;
+  clearTimeout(state.grace);
+  state.rtc.onicecandidate = null;
+  state.rtc.oniceconnectionstatechange = null;
+  for (const channel of Object.values(state.channels)) {
+    channel.onopen = null;
+    channel.onclose = null;
+    channel.onmessage = null;
+    channel.close();
+  }
+  state.rtc.close();
+}
+function fail(state, closed2 = false) {
+  if (!state.closed) {
+    shut(state);
+    state.events.failed(closed2);
+  }
+}
+function step(state, work) {
+  work().catch(() => {
+    fail(state);
+  });
+}
+function setRemote(state, description) {
+  return state.rtc.setRemoteDescription(description).then(() => {
+    state.remoteSet = true;
+    for (const ice of state.early.splice(0)) {
+      state.rtc.addIceCandidate(ice).catch(() => void 0);
+    }
+  });
+}
+async function describe(state, kind) {
+  const description = await (kind === "offer" ? state.rtc.createOffer() : state.rtc.createAnswer());
+  if (state.closed) {
+    return;
+  }
+  await state.rtc.setLocalDescription(description);
+  if (!state.closed) {
+    state.events.signal({ sdp: { type: kind, sdp: description.sdp ?? "" } });
+  }
+}
+function watch(state) {
+  const { rtc, channels, events } = state;
+  for (const label of ["rel", "fast"]) {
+    const channel = channels[label];
+    channel.binaryType = "arraybuffer";
+    channel.onopen = () => {
+      if (!state.open && channels.rel.readyState === "open" && channels.fast.readyState === "open") {
+        state.open = true;
+        events.opened();
+      }
+    };
+    channel.onclose = () => {
+      fail(state, true);
+    };
+    channel.onmessage = (event) => {
+      events.message(event.data, label);
+    };
+  }
+  rtc.onicecandidate = (event) => {
+    if (event.candidate !== null) {
+      events.signal({ ice: candidateOf(event.candidate) });
+    }
+  };
+  rtc.oniceconnectionstatechange = () => {
+    const ice = rtc.iceConnectionState;
+    if (ice === "failed" || ice === "closed") {
+      fail(state);
+    } else if (ice === "disconnected") {
+      state.grace ??= setTimeout(() => {
+        fail(state);
+      }, DISCONNECTED_GRACE_MS);
+    } else if (ice === "connected" || ice === "completed") {
+      clearTimeout(state.grace);
+      state.grace = void 0;
+    }
+  };
+}
+function createDirectPath(rtc, events) {
+  const state = {
+    rtc,
+    channels: {
+      rel: rtc.createDataChannel("rel", { negotiated: true, id: 0, ordered: true }),
+      fast: rtc.createDataChannel("fast", {
+        negotiated: true,
+        id: 1,
+        ordered: false,
+        maxRetransmits: 0
+      })
+    },
+    events,
+    early: [],
+    open: false,
+    closed: false,
+    remoteSet: false,
+    grace: void 0
+  };
+  watch(state);
+  return {
+    get open() {
+      return state.open;
+    },
+    offer: () => {
+      step(state, () => describe(state, "offer"));
+    },
+    answer: (offer) => {
+      step(state, async () => {
+        await setRemote(state, offer);
+        await describe(state, "answer");
+      });
+    },
+    accept: (answer) => {
+      step(state, () => setRemote(state, answer));
+    },
+    candidate(ice) {
+      if (state.closed) {
+        return;
+      }
+      if (!state.remoteSet) {
+        if (state.early.length < MAX_EARLY_CANDIDATES) {
+          state.early.push(ice);
+        }
+        return;
+      }
+      rtc.addIceCandidate(ice).catch(() => void 0);
+    },
+    send(label, text) {
+      const channel = state.channels[label];
+      if (!state.open || channel.readyState !== "open") {
+        return false;
+      }
+      if (label === "fast" && channel.bufferedAmount > FAST_BACKLOG_BYTES) {
+        return false;
+      }
+      try {
+        channel.send(text);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    close: () => {
+      if (!state.closed) {
+        shut(state);
+      }
+    }
+  };
+}
+
+// src/client/peer/hub.ts
+var PENDING_MS = 15e3;
+var MAX_PENDING = 64;
+var MAX_PENDING_SIGNALS = 64;
+var MAX_PENDING_CHARS = 65536;
+var MAX_PENDING_TOTAL_CHARS = 1048576;
+var SIGNAL_TIMEOUT_MS = 1e4;
+var RATE_SHARE = 0.9;
+var BURST_SHARE = 0.5;
+var DEFAULT_PEER_LIMITS = Object.freeze({
+  maxLinks: MAX_PEER_LINKS,
+  maxMessageBytes: MAX_PEER_MESSAGE_BYTES,
+  relayRate: PEER_RELAY_RATE,
+  relayBurst: PEER_RELAY_BURST,
+  relayBytesPerSecond: PEER_RELAY_BYTES_PER_SECOND,
+  relayBytesBurst: PEER_RELAY_BYTES_BURST
+});
+function charsOf(sig) {
+  if (sig.sdp !== void 0) {
+    return sig.sdp.sdp.length;
+  }
+  const { ice } = sig;
+  return ice === void 0 ? 1 : ice.candidate.length + (ice.sdpMid?.length ?? 0) + (ice.usernameFragment?.length ?? 0);
+}
+var keyOf = (room, peer) => `${room}\0${peer}`;
+var now = () => performance.now();
+function take(bucket, rate, burst, cost = 1) {
+  const at = now();
+  bucket.tokens = Math.min(burst, bucket.tokens + (at - bucket.refilledAt) / 1e3 * rate);
+  bucket.refilledAt = at;
+  if (bucket.tokens < cost) {
+    return false;
+  }
+  bucket.tokens -= cost;
+  return true;
+}
+function servedLimits(connection) {
+  const { hello } = connection.getState();
+  return hello?.features.includes("peer") === true ? hello.limits.peers ?? DEFAULT_PEER_LIMITS : void 0;
+}
+function readForward(frame) {
+  if (!isRecord(frame) || !isRoomName(frame.room) || !isSocketId(frame.from)) {
+    return void 0;
+  }
+  const sig = readSignal(frame.sig);
+  const { userId } = frame;
+  return sig === void 0 || typeof userId !== "string" || userId === "" ? void 0 : { room: frame.room, from: frame.from, userId, sig };
+}
+function dropPending(state, key) {
+  const entry = state.pending.get(key);
+  if (entry !== void 0) {
+    state.pending.delete(key);
+    state.pendingChars -= entry.chars;
+  }
+  return entry;
+}
+function keep(state, entry, sig) {
+  const chars = charsOf(sig);
+  if (entry.signals.length >= MAX_PENDING_SIGNALS || entry.chars + chars > MAX_PENDING_CHARS || state.pendingChars + chars > MAX_PENDING_TOTAL_CHARS) {
+    return false;
+  }
+  entry.signals.push(sig);
+  entry.chars += chars;
+  state.pendingChars += chars;
+  return true;
+}
+function receiveSignal(state, frame) {
+  const forward = readForward(frame);
+  if (forward === void 0) {
+    return;
+  }
+  const key = keyOf(forward.room, forward.from);
+  const link = state.links.get(key);
+  if (link?.signal(forward.sig, forward.userId) === true) {
+    return;
+  }
+  if (forward.sig.bye === true) {
+    dropPending(state, key);
+    return;
+  }
+  const at = now();
+  for (const [old, entry2] of state.pending) {
+    if (at - entry2.at > PENDING_MS) {
+      dropPending(state, old);
+    }
+  }
+  const entry = state.pending.get(key);
+  if (entry !== void 0) {
+    keep(state, entry, forward.sig);
+    return;
+  }
+  const { room, from, userId } = forward;
+  const waiting = { room, from, userId, signals: [], at, chars: 0 };
+  if (state.pending.size >= MAX_PENDING || !keep(state, waiting, forward.sig)) {
+    return;
+  }
+  state.pending.set(key, waiting);
+  for (const listener of [...state.listeners]) {
+    try {
+      listener({ room, from, userId });
+    } catch (error) {
+      throwLater(error);
+    }
+  }
+}
+function receiveRelay(state, frame) {
+  if (!Array.isArray(frame)) {
+    return;
+  }
+  const [room, from, label, text] = frame;
+  if (isRoomName(room) && isSocketId(from) && isPeerLabel(label) && typeof text === "string") {
+    state.links.get(keyOf(room, from))?.relay(label, text);
+  }
+}
+function receivePresence(state, frame) {
+  if (!isRecord(frame) || !isRoomName(frame.room)) {
+    return;
+  }
+  const { users } = frame;
+  if (!Array.isArray(users) || users.length > 0) {
+    return;
+  }
+  const prefix = keyOf(frame.room, "");
+  for (const [key, link] of [...state.links]) {
+    if (key.startsWith(prefix)) {
+      link.left();
+    }
+  }
+}
+function listen(state) {
+  const { socket } = state.connection;
+  socket.on(SERVER_EVENTS.peer, (frame) => {
+    receiveSignal(state, frame);
+  });
+  socket.on(SERVER_EVENTS.relay, (frame) => {
+    receiveRelay(state, frame);
+  });
+  socket.on(SERVER_EVENTS.presence, (frame) => {
+    receivePresence(state, frame);
+  });
+  socket.on("disconnect", () => {
+    state.pending.clear();
+    state.pendingChars = 0;
+    for (const link of [...state.links.values()]) {
+      link.disconnected();
+    }
+  });
+}
+function signalOf(state, room, to, sig) {
+  const { socket } = state.connection;
+  if (!socket.connected) {
+    return Promise.resolve({ ok: false, e: { code: "INTERNAL", message: "Not connected" } });
+  }
+  return socket.timeout(SIGNAL_TIMEOUT_MS).emitWithAck(CLIENT_EVENTS.peer, { room, to, sig }).catch(
+    () => ({ ok: false, e: { code: "TIMEOUT", message: "No answer to a peer signal" } })
+  );
+}
+function backedUp(socket) {
+  const engine = socket.io?.engine;
+  if ((engine?.writeBuffer?.length ?? 0) >= PEER_RELAY_FAST_BACKLOG) {
+    return true;
+  }
+  const buffered = engine?.transport?.ws?.bufferedAmount;
+  return typeof buffered === "number" && buffered > FAST_BACKLOG_BYTES;
+}
+function relayOf(state, frame, pair) {
+  const { socket } = state.connection;
+  const limits = servedLimits(state.connection);
+  if (!socket.connected || limits === void 0) {
+    return false;
+  }
+  if (frame[2] === "fast" && backedUp(socket)) {
+    return false;
+  }
+  if (!take(pair, limits.relayRate * RATE_SHARE, limits.relayBurst * BURST_SHARE)) {
+    return false;
+  }
+  const bytes = utf8ByteLength(frame[3]);
+  const budget = limits.relayBytesPerSecond * RATE_SHARE;
+  if (!take(state.bytes, budget, limits.relayBytesBurst * BURST_SHARE, bytes)) {
+    pair.tokens += 1;
+    return false;
+  }
+  socket.emit(CLIENT_EVENTS.relay, frame);
+  return true;
+}
+function whenReady(connection, ready, gone) {
+  let stop;
+  const check = () => {
+    const { status, hello } = connection.getState();
+    if (status === "connected" && hello !== null) {
+      stop?.();
+      ready(servedLimits(connection));
+      return true;
+    }
+    if (status === "idle" || status === "disconnected" || status === "refused") {
+      stop?.();
+      gone();
+      return true;
+    }
+    return false;
+  };
+  queueMicrotask(() => {
+    if (!check()) {
+      stop = connection.subscribe(() => {
+        check();
+      });
+    }
+  });
+}
+function createHub(connection) {
+  const state = {
+    connection,
+    links: /* @__PURE__ */ new Map(),
+    pending: /* @__PURE__ */ new Map(),
+    pendingChars: 0,
+    listeners: /* @__PURE__ */ new Set(),
+    bytes: { tokens: 0, refilledAt: now() }
+  };
+  state.bytes.tokens = DEFAULT_PEER_LIMITS.relayBytesBurst * BURST_SHARE;
+  listen(state);
+  const hub = {
+    connection,
+    add(room, peer, handle) {
+      const key = keyOf(room, peer);
+      if (state.links.has(key)) {
+        throw new TypeError(
+          `createPeerLink: this connection has a link to ${peer} in room "${room}" already; close it first`
+        );
+      }
+      state.links.set(key, handle);
+      return () => {
+        if (state.links.get(key) === handle) {
+          state.links.delete(key);
+        }
+      };
+    },
+    take(room, peer) {
+      const entry = dropPending(state, keyOf(room, peer));
+      const fresh = entry !== void 0 && now() - entry.at <= PENDING_MS;
+      return {
+        room,
+        from: peer,
+        userId: entry?.userId ?? "",
+        signals: fresh ? entry.signals : []
+      };
+    },
+    forget(room, peer) {
+      dropPending(state, keyOf(room, peer));
+    },
+    signal: (room, to, sig) => signalOf(state, room, to, sig),
+    relay: (room, to, label, text, pair) => relayOf(state, [room, to, label, text], pair),
+    pairBucket: () => ({
+      tokens: (servedLimits(connection) ?? DEFAULT_PEER_LIMITS).relayBurst * BURST_SHARE,
+      refilledAt: now()
+    }),
+    requests(listener) {
+      state.listeners.add(listener);
+      return () => {
+        state.listeners.delete(listener);
+      };
+    },
+    whenReady: (ready, gone) => {
+      whenReady(connection, ready, gone);
+    },
+    limits: () => servedLimits(connection) ?? DEFAULT_PEER_LIMITS
+  };
+  return Object.freeze(hub);
+}
+var hubs = /* @__PURE__ */ new WeakMap();
+function hubOf(connection) {
+  let hub = hubs.get(connection);
+  if (hub === void 0) {
+    hub = createHub(connection);
+    hubs.set(connection, hub);
+  }
+  return hub;
+}
+
+// src/client/peer/link.ts
+var DEFAULT_ICE_SERVERS = Object.freeze([
+  { urls: "stun:stun.l.google.com:19302" },
+  { urls: "stun:stun.cloudflare.com:3478" }
+]);
+var OPEN_TIMEOUT_MS = 15e3;
+var DIRECT_TIMEOUT_MS = 5e3;
+var BYE_WAIT_MS = 2e3;
+function platformFactory() {
+  const Rtc = globalThis.RTCPeerConnection;
+  return Rtc === void 0 ? void 0 : (configuration) => new Rtc(configuration);
+}
+function canDirect(run) {
+  return run.relay !== "always" && run.factory !== void 0;
+}
+function retryDelay(data) {
+  const wait = data?.retryAfterMs;
+  return typeof wait === "number" && wait > 0 ? Math.min(wait, OPEN_TIMEOUT_MS) : 100;
+}
+function signal(run, sig, attempt = 0) {
+  void run.hub.signal(run.room, run.peer, sig).then((answer) => {
+    if (answer.ok || run.core.link.state === "closed" || sig.ice !== void 0) {
+      return;
+    }
+    const { code, data } = answer.e;
+    if (code === "RATE_LIMITED" && attempt < 3) {
+      const retry = setTimeout(() => {
+        run.retries.delete(retry);
+        signal(run, sig, attempt + 1);
+      }, retryDelay(data));
+      run.retries.add(retry);
+    } else if (code !== "TIMEOUT") {
+      run.core.fail("refused");
+    }
+  });
+}
+function closeDirect(run, after) {
+  clearTimeout(run.directTimer);
+  const { direct } = run;
+  run.direct = void 0;
+  if (after === void 0) {
+    direct?.close();
+  } else {
+    const close = () => {
+      direct?.close();
+    };
+    void after.then(close, close);
+  }
+}
+function moveToRelay(run) {
+  clearTimeout(run.byeTimer);
+  if (run.relay === "never") {
+    run.core.fail("failed");
+    return;
+  }
+  closeDirect(run);
+  if (!run.relaySent) {
+    run.relaySent = true;
+    signal(run, { relay: true });
+  }
+  if (run.relayHeard || run.core.link.state === "open") {
+    run.core.carry("relay");
+  }
+}
+function directFailed(run) {
+  if (run.relay === "never") {
+    run.core.fail(run.core.link.state === "open" ? "lost" : "failed");
+  } else {
+    moveToRelay(run);
+  }
+}
+function awaitBye(run) {
+  clearTimeout(run.byeTimer);
+  run.byeTimer = setTimeout(() => {
+    run.byeTimer = void 0;
+    if (run.direct === void 0) {
+      directFailed(run);
+    }
+  }, BYE_WAIT_MS);
+}
+function discard(rtc) {
+  try {
+    rtc?.close();
+  } catch {
+  }
+}
+function openDirect(run, factory) {
+  let rtc;
+  let direct;
+  try {
+    rtc = factory({ iceServers: run.iceServers });
+    direct = createDirectPath(rtc, {
+      signal: (sig) => {
+        if (run.direct === direct) {
+          signal(run, sig);
+        }
+      },
+      opened: () => {
+        clearTimeout(run.directTimer);
+        run.core.carry("direct");
+      },
+      failed: (channelClosed) => {
+        if (run.direct !== direct) {
+          return;
+        }
+        run.direct = void 0;
+        if (channelClosed) {
+          clearTimeout(run.directTimer);
+          awaitBye(run);
+        } else {
+          directFailed(run);
+        }
+      },
+      message: (data, label) => {
+        run.core.receive(data, label);
+      }
+    });
+  } catch {
+    discard(rtc);
+    return void 0;
+  }
+  run.direct = direct;
+  for (const ice of run.early.splice(0)) {
+    direct.candidate(ice);
+  }
+  if (run.relay !== "never") {
+    run.directTimer = setTimeout(() => {
+      if (run.direct === direct && !direct.open) {
+        directFailed(run);
+      }
+    }, DIRECT_TIMEOUT_MS);
+  }
+  return direct;
+}
+function yields(run) {
+  const self = run.hub.connection.socket.id;
+  return !run.relaySent && self !== void 0 && self > run.peer;
+}
+function described(run, sdp) {
+  if (sdp.type === "answer") {
+    if (run.offerer) {
+      run.direct?.accept(sdp);
+    }
+    return;
+  }
+  if (run.offerer) {
+    if (!yields(run)) {
+      return;
+    }
+    closeDirect(run);
+    run.offerer = false;
+    run.heardOffer = true;
+  }
+  if (run.relaySent || run.direct !== void 0) {
+    return;
+  }
+  const direct = canDirect(run) && run.factory !== void 0 ? openDirect(run, run.factory) : void 0;
+  if (direct === void 0) {
+    moveToRelay(run);
+  } else {
+    direct.answer(sdp);
+  }
+}
+var MAX_EARLY_CANDIDATES2 = 64;
+function restarts(run, sig) {
+  if (run.offerer) {
+    return false;
+  }
+  if (sig.relay === true) {
+    return run.relayHeard;
+  }
+  if (sig.sdp?.type !== "offer") {
+    return false;
+  }
+  const again = run.heardOffer || run.relayHeard;
+  run.heardOffer = true;
+  return again;
+}
+function onSignal(run, sig, userId) {
+  if (!run.started) {
+    run.queued.push([sig, userId]);
+    return true;
+  }
+  if (restarts(run, sig)) {
+    run.core.end("bye");
+    return false;
+  }
+  if (userId !== "") {
+    run.core.identify(userId);
+  }
+  if (sig.bye === true) {
+    run.core.end("bye");
+  } else if (sig.relay === true) {
+    run.relayHeard = true;
+    moveToRelay(run);
+  } else if (sig.sdp !== void 0) {
+    described(run, sig.sdp);
+  } else if (sig.ice !== void 0) {
+    if (run.direct !== void 0) {
+      run.direct.candidate(sig.ice);
+    } else if (!run.relaySent && run.early.length < MAX_EARLY_CANDIDATES2) {
+      run.early.push(sig.ice);
+    }
+  }
+  return true;
+}
+function start(run, limits) {
+  if (run.core.link.state === "closed") {
+    return;
+  }
+  if (limits === void 0 || !canDirect(run) && run.relay === "never") {
+    run.core.fail("unsupported");
+    return;
+  }
+  run.started = true;
+  run.pair = run.hub.pairBucket();
+  run.openTimer = setTimeout(() => {
+    if (run.core.link.state === "connecting") {
+      run.core.fail("timeout");
+    }
+  }, OPEN_TIMEOUT_MS);
+  const waiting = run.hub.take(run.room, run.peer);
+  if (run.offerer) {
+    const direct = canDirect(run) && run.factory !== void 0 ? openDirect(run, run.factory) : void 0;
+    if (direct === void 0) {
+      moveToRelay(run);
+    } else {
+      direct.offer();
+    }
+  }
+  for (const [sig, userId] of [
+    ...waiting.signals.map((waited) => [waited, waiting.userId]),
+    ...run.queued.splice(0)
+  ]) {
+    if (!onSignal(run, sig, userId)) {
+      return;
+    }
+  }
+}
+function sendOn(run, label, text) {
+  if (run.direct?.open === true) {
+    return run.direct.send(label, text);
+  }
+  return run.relaySent && run.hub.relay(run.room, run.peer, label, text, run.pair);
+}
+function closed(run, fromHere) {
+  clearTimeout(run.openTimer);
+  clearTimeout(run.byeTimer);
+  for (const retry of run.retries) {
+    clearTimeout(retry);
+  }
+  run.retries.clear();
+  run.remove();
+  const bye = fromHere && run.started ? run.hub.signal(run.room, run.peer, { bye: true }) : void 0;
+  closeDirect(run, bye);
+}
+var RELAY_MODES = ["auto", "always", "never"];
+function checkOptions(options) {
+  if (!isRoomName(options.room)) {
+    throw new TypeError("createPeerLink: room must name an app room, of 1 to 256 characters");
+  }
+  if (!isSocketId(options.to)) {
+    throw new TypeError("createPeerLink: to must be the peer's socket id");
+  }
+  if (typeof options.offerer !== "boolean") {
+    throw new TypeError(
+      "createPeerLink: offerer must be true on the side that offers, false on the other"
+    );
+  }
+  if (options.relay !== void 0 && !RELAY_MODES.includes(options.relay)) {
+    throw new TypeError('createPeerLink: relay must be "auto", "always" or "never"');
+  }
+  if (options.peerConnection !== void 0 && typeof options.peerConnection !== "function") {
+    throw new TypeError("createPeerLink: peerConnection must make an RTCPeerConnection");
+  }
+}
+function createPeerLink(connection, options) {
+  checkOptions(options);
+  const hub = hubOf(connection);
+  const run = {
+    hub,
+    room: options.room,
+    peer: options.to,
+    offerer: options.offerer,
+    relay: options.relay ?? "auto",
+    factory: options.peerConnection ?? platformFactory(),
+    iceServers: (options.iceServers ?? DEFAULT_ICE_SERVERS).map((server) => ({ ...server })),
+    core: createLinkCore({
+      room: options.room,
+      peer: options.to,
+      maxMessageBytes: () => hub.limits().maxMessageBytes,
+      hooks: {
+        send: (label, text) => sendOn(run, label, text),
+        closed: (_reason, fromHere) => {
+          closed(run, fromHere);
+        }
+      }
+    }),
+    pair: hub.pairBucket(),
+    started: false,
+    queued: [],
+    early: [],
+    heardOffer: false,
+    direct: void 0,
+    relaySent: false,
+    relayHeard: false,
+    openTimer: void 0,
+    directTimer: void 0,
+    byeTimer: void 0,
+    retries: /* @__PURE__ */ new Set(),
+    remove: () => void 0
+  };
+  run.remove = hub.add(run.room, run.peer, {
+    signal: (sig, userId) => onSignal(run, sig, userId),
+    relay: (label, text) => {
+      run.core.receive(text, label);
+    },
+    disconnected: () => {
+      run.core.end("disconnected");
+    },
+    left: () => {
+      run.core.end("left");
+    }
+  });
+  hub.whenReady(
+    (limits) => {
+      start(run, limits);
+    },
+    () => {
+      run.core.end("disconnected");
+    }
+  );
+  return run.core.link;
+}
+function onPeerRequest(connection, listener) {
+  const hub = hubOf(connection);
+  return hub.requests((incoming) => {
+    listener(
+      Object.freeze({
+        ...incoming,
+        accept: (options = {}) => createPeerLink(connection, {
+          ...options,
+          room: incoming.room,
+          to: incoming.from,
+          offerer: false
+        }),
+        reject: () => {
+          hub.forget(incoming.room, incoming.from);
+          void hub.signal(incoming.room, incoming.from, { bye: true });
+        }
+      })
+    );
+  });
+}
+
+export {
+  DEFAULT_ICE_SERVERS,
+  createPeerLink,
+  onPeerRequest
+};
+//# sourceMappingURL=chunk-DNP65TD5.js.map