@fitzzero/quickdraw-core 5.1.2 → 5.1.3

package/dist/chunk-STH5DLQP.js

@@ -0,0 +1,1192 @@
+import {
+  isRoomName,
+  isSocketId
+} from "./chunk-2FDSKLBO.js";
+import {
+  QUICKDRAW_VERSION
+} from "./chunk-A2RBQD66.js";
+import {
+  CLIENT_EVENTS,
+  MAX_PEER_MESSAGE_BYTES,
+  MAX_SUBSCRIBE_IDS,
+  PROTOCOL_VERSION,
+  SERVER_EVENTS,
+  isAuthenticationRefused,
+  isAuthenticationUnavailable,
+  isProtocolMismatch
+} from "./chunk-X4ZU4QH5.js";
+import {
+  createJsonParser
+} from "./chunk-SN3OZVEQ.js";
+import {
+  QuickdrawError,
+  fromWire
+} from "./chunk-Q4OGQM5I.js";
+import {
+  isRecord
+} from "./chunk-QSU47XEX.js";
+
+// src/client/backoff.ts
+var DEFAULT_BACKOFF_MS = 5e3;
+var MIN_BACKOFF_MS = 250;
+var MAX_BACKOFF_MS = 5 * 60 * 1e3;
+var JITTER_RATIO = 0.5;
+function retryAfterOf(error) {
+  const retryAfterMs = isRecord(error.data) ? error.data.retryAfterMs : void 0;
+  return typeof retryAfterMs === "number" ? retryAfterMs : void 0;
+}
+function waitFor(retryAfterMs) {
+  const wait = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) ? retryAfterMs : DEFAULT_BACKOFF_MS;
+  return Math.min(Math.max(wait, MIN_BACKOFF_MS), MAX_BACKOFF_MS);
+}
+function createBackoff(onChange) {
+  const until = /* @__PURE__ */ new Map();
+  const timers = /* @__PURE__ */ new Map();
+  const windows = () => Object.freeze(Object.fromEntries(until));
+  function end(kind) {
+    timers.delete(kind);
+    until.delete(kind);
+    onChange(windows());
+  }
+  return Object.freeze({
+    report(kind, retryAfterMs) {
+      const wait = waitFor(retryAfterMs);
+      const delay = wait + Math.random() * wait * JITTER_RATIO;
+      const ends = Date.now() + delay;
+      if (ends <= (until.get(kind) ?? 0)) {
+        return;
+      }
+      clearTimeout(timers.get(kind));
+      until.set(kind, ends);
+      timers.set(
+        kind,
+        setTimeout(() => {
+          end(kind);
+        }, delay)
+      );
+      onChange(windows());
+    },
+    remaining(kind) {
+      const ends = until.get(kind);
+      return ends === void 0 ? 0 : Math.max(0, ends - Date.now());
+    },
+    windows,
+    clear() {
+      for (const timer of timers.values()) {
+        clearTimeout(timer);
+      }
+      timers.clear();
+      if (until.size > 0) {
+        until.clear();
+        onChange(windows());
+      }
+    }
+  });
+}
+
+// src/client/watch.ts
+function topicId(service, topic) {
+  return `${service}\0${topic}`;
+}
+function rethrowLater(error) {
+  queueMicrotask(() => {
+    throw error;
+  });
+}
+function notifyEach(listeners, notify) {
+  for (const listener of [...listeners]) {
+    try {
+      notify(listener);
+    } catch (error) {
+      rethrowLater(error);
+    }
+  }
+}
+function oncePerKey(records) {
+  const keys = /* @__PURE__ */ new Set();
+  return [...records].filter(({ watch }) => {
+    if (watch.key === void 0) {
+      return true;
+    }
+    const first = !keys.has(watch.key);
+    keys.add(watch.key);
+    return first;
+  });
+}
+function modelName(model) {
+  return `${model.charAt(0).toLowerCase()}${model.slice(1)}`;
+}
+function concerns(watch, frame) {
+  const { models } = watch;
+  if (models === void 0 || !Array.isArray(frame.models)) {
+    return true;
+  }
+  const changed = new Set(frame.models.map((model) => modelName(String(model))));
+  return models.some((model) => changed.has(modelName(model)));
+}
+function tell(topic, frame) {
+  const concerned = [...topic.watches].filter(({ watch }) => concerns(watch, frame));
+  notifyEach(oncePerKey(concerned), ({ watch }) => {
+    watch.onChanged(frame);
+  });
+}
+function tellJoined(topic) {
+  const waited = new Set([...topic.holds].map((hold) => hold.key));
+  const unjoined = new Set(topic.unjoinedReads);
+  topic.unjoinedReads.clear();
+  const owed = [...topic.watches].filter(
+    ({ watch, told }) => !told || watch.key !== void 0 && unjoined.has(watch.key)
+  );
+  for (const record of owed) {
+    record.told = true;
+  }
+  const toTell = owed.filter(({ watch }) => watch.key === void 0 || !waited.has(watch.key));
+  notifyEach(oncePerKey(toTell), ({ watch }) => {
+    watch.onJoined?.();
+  });
+}
+function releaseHolds(topic) {
+  const holds = [...topic.holds];
+  topic.holds.clear();
+  for (const hold of holds) {
+    if (topic.state !== "joined" && hold.key !== void 0) {
+      topic.unjoinedReads.add(hold.key);
+    }
+    hold.release();
+  }
+}
+function isChangedFrame(value) {
+  return isRecord(value) && typeof value.s === "string" && typeof value.topic === "string";
+}
+function retryIn(registry, topic, delayMs) {
+  clearTimeout(topic.retry);
+  topic.state = "waiting";
+  topic.retry = setTimeout(() => {
+    topic.retry = void 0;
+    if (registry.topics.get(topic.id) === topic) {
+      join(registry, topic);
+    }
+  }, delayMs);
+}
+function refused(registry, topic, reply) {
+  const { host } = registry;
+  const failure = fromWire(isRecord(reply) ? reply.e : void 0);
+  if (failure.code === "RATE_LIMITED") {
+    host.reportRateLimited("subscription", retryAfterOf(failure));
+    retryIn(registry, topic, host.backoffRemaining("subscription"));
+  } else {
+    topic.state = "refused";
+  }
+}
+function answered(registry, topic, error, reply) {
+  if (error !== null) {
+    if (registry.host.socket.connected) {
+      retryIn(registry, topic, DEFAULT_BACKOFF_MS);
+    } else {
+      topic.state = "waiting";
+    }
+  } else if (isRecord(reply) && reply.ok === true) {
+    topic.state = "joined";
+    tellJoined(topic);
+  } else {
+    refused(registry, topic, reply);
+  }
+  releaseHolds(topic);
+}
+function join(registry, topic) {
+  const { host } = registry;
+  clearTimeout(topic.retry);
+  topic.retry = void 0;
+  topic.attempt += 1;
+  const wait = host.backoffRemaining("subscription");
+  if (!host.socket.connected) {
+    topic.state = "waiting";
+    releaseHolds(topic);
+  } else if (wait > 0) {
+    retryIn(registry, topic, wait);
+    releaseHolds(topic);
+  } else {
+    topic.state = "joining";
+    const { attempt } = topic;
+    host.lane.send(CLIENT_EVENTS.watch, topic.frame, (error, reply) => {
+      if (registry.topics.get(topic.id) === topic && topic.attempt === attempt) {
+        answered(registry, topic, error, reply);
+      }
+    });
+  }
+}
+function leave(registry, topic) {
+  registry.topics.delete(topic.id);
+  clearTimeout(topic.retry);
+  clearTimeout(topic.leaving);
+  topic.leaving = void 0;
+  topic.attempt += 1;
+  releaseHolds(topic);
+  const sent = topic.state === "joining" || topic.state === "joined";
+  if (sent && registry.host.socket.connected) {
+    registry.host.socket.emit(CLIENT_EVENTS.unwatch, topic.frame);
+  }
+}
+function waitForJoin(registry, wait) {
+  const topic = registry.topics.get(topicId(wait.service, wait.topic));
+  if (topic === void 0) {
+    return void 0;
+  }
+  if (topic.state === "joining" && registry.host.socket.connected) {
+    return new Promise((resolve) => {
+      topic.holds.add({ key: wait.key, release: resolve });
+    });
+  }
+  if (topic.state !== "joined" && wait.key !== void 0) {
+    topic.unjoinedReads.add(wait.key);
+  }
+  return void 0;
+}
+function startWatch(registry, watch) {
+  const id = topicId(watch.service, watch.topic);
+  const topic = registry.topics.get(id) ?? {
+    id,
+    frame: Object.freeze({ s: watch.service, topic: watch.topic }),
+    watches: /* @__PURE__ */ new Set(),
+    holds: /* @__PURE__ */ new Set(),
+    unjoinedReads: /* @__PURE__ */ new Set(),
+    state: "waiting",
+    retry: void 0,
+    leaving: void 0,
+    attempt: 0
+  };
+  registry.topics.set(id, topic);
+  const kept = topic.leaving !== void 0;
+  clearTimeout(topic.leaving);
+  topic.leaving = void 0;
+  const record = { watch, told: topic.state === "joined" };
+  topic.watches.add(record);
+  if (topic.watches.size === 1 && !kept) {
+    join(registry, topic);
+  }
+  return () => {
+    if (topic.watches.delete(record) && topic.watches.size === 0) {
+      topic.leaving = setTimeout(() => {
+        if (topic.watches.size === 0 && registry.topics.get(topic.id) === topic) {
+          leave(registry, topic);
+        }
+      }, 0);
+    }
+  };
+}
+function createTopics(host) {
+  const registry = { host, topics: /* @__PURE__ */ new Map() };
+  host.socket.on(SERVER_EVENTS.changed, (frame) => {
+    const topic = isChangedFrame(frame) ? registry.topics.get(topicId(frame.s, frame.topic)) : void 0;
+    if (topic !== void 0) {
+      tell(topic, frame);
+    }
+  });
+  host.socket.on("disconnect", () => {
+    for (const topic of registry.topics.values()) {
+      if (topic.state === "joined") {
+        topic.state = "waiting";
+      }
+    }
+  });
+  return Object.freeze({
+    watch: (watch) => startWatch(registry, watch),
+    waitForJoin: (wait) => waitForJoin(registry, wait),
+    rejoin() {
+      for (const topic of [...registry.topics.values()]) {
+        if (topic.watches.size === 0) {
+          leave(registry, topic);
+        } else {
+          join(registry, topic);
+        }
+      }
+    },
+    stop() {
+      for (const topic of [...registry.topics.values()]) {
+        if (topic.watches.size === 0) {
+          leave(registry, topic);
+        } else {
+          clearTimeout(topic.retry);
+          topic.retry = void 0;
+          topic.attempt += 1;
+          topic.state = "waiting";
+          releaseHolds(topic);
+        }
+      }
+    }
+  });
+}
+
+// src/client/lane.ts
+var DEFAULT_SUBSCRIPTION_LANE = 8;
+function positiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+function subscriptionLimits(hello) {
+  const limits = hello?.limits;
+  const record = isRecord(limits) ? limits : {};
+  const lane = isRecord(record.subscriptions) ? record.subscriptions : {};
+  return {
+    maxInFlight: positiveInteger(lane.maxInFlight, DEFAULT_SUBSCRIPTION_LANE),
+    maxSubscribeIds: positiveInteger(record.maxSubscribeIds, MAX_SUBSCRIBE_IDS)
+  };
+}
+function notConnected() {
+  return new Error("The socket is not connected; the event was not sent");
+}
+function createSubscriptionLane(host) {
+  const queue = [];
+  let inFlight = 0;
+  let backoffTimer;
+  const answer = (pending, error, reply) => {
+    notifyEach([pending.done], (done) => {
+      done(error, reply);
+    });
+  };
+  function sendOne(pending) {
+    inFlight += 1;
+    const emitter = host.socket.timeout(host.timeoutMs());
+    emitter.emit(pending.event, pending.frame, (error, reply) => {
+      inFlight -= 1;
+      answer(pending, error, reply);
+      pump();
+    });
+  }
+  function waitForBackoff(wait) {
+    backoffTimer ??= setTimeout(() => {
+      backoffTimer = void 0;
+      pump();
+    }, wait);
+  }
+  function dropAll() {
+    for (const dropped of queue.splice(0)) {
+      answer(dropped, notConnected(), void 0);
+    }
+  }
+  function pump() {
+    const { maxInFlight } = subscriptionLimits(host.hello());
+    while (queue.length > 0 && inFlight < maxInFlight) {
+      if (!host.socket.connected) {
+        dropAll();
+        return;
+      }
+      const wait = host.backoffRemaining("subscription");
+      if (wait > 0) {
+        waitForBackoff(wait);
+        return;
+      }
+      sendOne(queue.shift());
+    }
+  }
+  return Object.freeze({
+    send(event, frame, done) {
+      queue.push({ event, frame, done });
+      pump();
+    },
+    inFlight: () => inFlight,
+    waiting: () => queue.length,
+    stop() {
+      clearTimeout(backoffTimer);
+      backoffTimer = void 0;
+      dropAll();
+    }
+  });
+}
+
+// src/client/reload.ts
+var RELOAD_KEY_PREFIX = "quickdraw:protocol-reload:";
+function firstReload(scope, key) {
+  try {
+    const storage = scope.sessionStorage;
+    if (storage === void 0 || storage.getItem(key) !== null) {
+      return false;
+    }
+    storage.setItem(key, String(Date.now()));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reloadOncePerSession(mismatch) {
+  const scope = globalThis;
+  const location = scope.location;
+  if (typeof location?.reload !== "function") {
+    return;
+  }
+  if (firstReload(scope, `${RELOAD_KEY_PREFIX}${mismatch.expected}`)) {
+    location.reload();
+  }
+}
+
+// src/client/retry.ts
+var MAX_DOUBLINGS = 20;
+function retryDelay(socket, attempt) {
+  const manager = socket.io;
+  const wait = manager.reconnectionDelay() * 2 ** Math.min(attempt, MAX_DOUBLINGS);
+  const deviation = Math.floor(Math.random() * manager.randomizationFactor() * wait);
+  const jittered = Math.random() < 0.5 ? wait - deviation : wait + deviation;
+  return Math.min(jittered, manager.reconnectionDelayMax());
+}
+function createRetry(socket, wanted) {
+  let timer;
+  let attempts = 0;
+  return Object.freeze({
+    later() {
+      const manager = socket.io;
+      if (!wanted() || !manager.reconnection() || attempts >= manager.reconnectionAttempts()) {
+        return false;
+      }
+      clearTimeout(timer);
+      timer = setTimeout(
+        () => {
+          timer = void 0;
+          if (wanted() && !socket.connected && !socket.active) {
+            socket.connect();
+          }
+        },
+        retryDelay(socket, attempts)
+      );
+      attempts += 1;
+      return true;
+    },
+    stop() {
+      clearTimeout(timer);
+      timer = void 0;
+      attempts = 0;
+    },
+    connected() {
+      attempts = 0;
+    }
+  });
+}
+
+// src/client/socket.ts
+import { io } from "socket.io-client";
+function createSocket(settings, credentials) {
+  return io(settings.url, {
+    forceNew: true,
+    withCredentials: true,
+    transports: ["websocket", "polling"],
+    ...settings.binary === true ? {} : { parser: createJsonParser() },
+    ...settings.socketOptions,
+    ...settings.transports === void 0 ? {} : { transports: settings.transports },
+    autoConnect: false,
+    auth: (send) => {
+      send({ ...credentials(), qd: { protocol: PROTOCOL_VERSION, client: QUICKDRAW_VERSION } });
+    }
+  });
+}
+
+// src/client/connection.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var HELLO_TIMEOUT_MARGIN_MS = 2e3;
+var INITIAL_CONNECTION_STATE = Object.freeze({
+  status: "idle",
+  reconnecting: false,
+  hello: null,
+  serviceAccess: null,
+  refusal: null,
+  backoff: Object.freeze({})
+});
+function createStore() {
+  let state = INITIAL_CONNECTION_STATE;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get: () => state,
+    set(patch) {
+      state = Object.freeze({ ...state, ...patch });
+      for (const listener of [...listeners]) {
+        listener();
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function credentialsOf(auth) {
+  if (typeof auth === "string") {
+    return auth === "" ? {} : { token: auth };
+  }
+  return auth ?? {};
+}
+function authKey(auth) {
+  const sorted = (_key, value) => isRecord(value) ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : 1)) : value;
+  return JSON.stringify(credentialsOf(auth), sorted);
+}
+function failBuffered(socket, error) {
+  const buffered = socket.sendBuffer.splice(0);
+  const { acks } = socket;
+  for (const packet of buffered) {
+    const id = packet.id === void 0 ? void 0 : String(packet.id);
+    const ack = id === void 0 ? void 0 : acks[id];
+    if (id !== void 0 && ack !== void 0) {
+      Reflect.deleteProperty(acks, id);
+      if (ack.withError === true) {
+        ack.call(socket, error);
+      }
+    }
+  }
+}
+function isServerDisconnect(reason) {
+  return reason === "io server disconnect";
+}
+function mayConnect(connection) {
+  return connection.socket.active || connection.getState().status === "connecting";
+}
+function isSessionRefusal(data) {
+  return isRecord(data) && (data.code === "UNAUTHENTICATED" || data.code === "FORBIDDEN");
+}
+function refusalOf(error) {
+  if (isProtocolMismatch(error.data)) {
+    return { code: error.data.code, expected: error.data.expected };
+  }
+  if (isAuthenticationRefused(error.data)) {
+    return { code: "UNAUTHENTICATED" };
+  }
+  if (isAuthenticationUnavailable(error.data)) {
+    return { code: "INTERNAL" };
+  }
+  return { code: "REFUSED", message: error.message };
+}
+var MAX_TIMEOUT_MS = 2147483647;
+function isTimeLimit(value) {
+  return typeof value === "number" && value > 0 && value <= MAX_TIMEOUT_MS;
+}
+function checkOptions(options) {
+  if (typeof options.url !== "string" || options.url === "") {
+    throw new TypeError("createQuickdrawConnection: url must be the server's URL");
+  }
+  const { timeoutMs } = options;
+  if (timeoutMs !== void 0 && !isTimeLimit(timeoutMs)) {
+    throw new TypeError(
+      "createQuickdrawConnection: timeoutMs must be a number of milliseconds, above 0 and at most 2^31 - 1"
+    );
+  }
+  return timeoutMs;
+}
+function defaultTimeout(option, hello) {
+  if (option !== void 0) {
+    return option;
+  }
+  const limits = hello?.limits;
+  const serverMs = isRecord(limits) ? limits.callTimeoutMs : void 0;
+  const fromHello = typeof serverMs === "number" ? serverMs + HELLO_TIMEOUT_MARGIN_MS : void 0;
+  return isTimeLimit(fromHello) ? fromHello : DEFAULT_TIMEOUT_MS;
+}
+function createLifecycle(socket, store, backoff, session) {
+  let opened2 = false;
+  let switching = false;
+  let users = 0;
+  let closeTimer;
+  let rotateTimer;
+  function connect2() {
+    socket.connect();
+    store.set({ status: "connecting", refusal: null });
+  }
+  function reconnect() {
+    if (!opened2) {
+      return;
+    }
+    switching = true;
+    socket.disconnect();
+    switching = false;
+    connect2();
+  }
+  function open() {
+    clearTimeout(closeTimer);
+    closeTimer = void 0;
+    opened2 = true;
+    if (!socket.connected && !socket.active) {
+      connect2();
+    }
+  }
+  function close() {
+    opened2 = false;
+    session.established = false;
+    session.topics.stop();
+    session.lane.stop();
+    session.retry.stop();
+    clearTimeout(closeTimer);
+    closeTimer = void 0;
+    clearTimeout(rotateTimer);
+    rotateTimer = void 0;
+    backoff.clear();
+    failBuffered(
+      socket,
+      new QuickdrawError("CANCELLED", "The connection closed before the call was sent")
+    );
+    socket.disconnect();
+    store.set({ status: "idle", reconnecting: false });
+  }
+  function retain() {
+    users += 1;
+    open();
+    let released = false;
+    return () => {
+      if (!released) {
+        released = true;
+        users -= 1;
+        if (users === 0) {
+          closeTimer = setTimeout(close, 0);
+        }
+      }
+    };
+  }
+  function rotateWithin(withinMs) {
+    if (rotateTimer === void 0) {
+      rotateTimer = setTimeout(() => {
+        rotateTimer = void 0;
+        reconnect();
+      }, Math.random() * withinMs);
+    }
+  }
+  function stoppedStatus() {
+    if (switching) {
+      return "connecting";
+    }
+    return opened2 ? "disconnected" : "idle";
+  }
+  return { open, close, retain, reconnect, rotateWithin, stoppedStatus };
+}
+function sayHello(hellos, entry, hello) {
+  if (hellos.has(entry) && entry.last !== hello) {
+    entry.last = hello;
+    entry.listener(hello);
+  }
+}
+function addListener(set, listener) {
+  set.add(listener);
+  return () => {
+    set.delete(listener);
+  };
+}
+function listenForHellos(wiring, listener) {
+  const { hellos, store } = wiring;
+  const entry = { listener, last: void 0 };
+  hellos.add(entry);
+  const { status, hello } = store.get();
+  if (status === "connected" && hello !== null) {
+    queueMicrotask(() => {
+      notifyEach([entry], (current) => {
+        sayHello(hellos, current, hello);
+      });
+    });
+  }
+  return () => {
+    hellos.delete(entry);
+  };
+}
+function listenToSocket(wiring) {
+  const { socket, store, lifecycle, session } = wiring;
+  socket.on("connect", () => {
+    const again = session.established;
+    session.established = true;
+    session.retry.connected();
+    store.set({ status: "connected", reconnecting: false, refusal: null });
+    session.topics.rejoin();
+    if (again) {
+      notifyEach(wiring.reconnected, (listener) => {
+        listener();
+      });
+    }
+  });
+  socket.on("disconnect", (reason) => {
+    const status = socket.active ? "connecting" : lifecycle.stoppedStatus();
+    const ended = isServerDisconnect(reason) ? { hello: null, serviceAccess: null } : {};
+    store.set({ status, reconnecting: status === "connecting" && session.established, ...ended });
+  });
+  socket.on("connect_error", (error) => {
+    if (socket.active) {
+      return;
+    }
+    if (isAuthenticationUnavailable(error.data) && session.retry.later()) {
+      store.set({ status: "connecting", reconnecting: session.established, refusal: null });
+      return;
+    }
+    const refusal = refusalOf(error);
+    session.established = false;
+    const ended = isSessionRefusal(error.data);
+    if (ended) {
+      failBuffered(
+        socket,
+        new QuickdrawError("CANCELLED", "The session ended before the call was sent")
+      );
+    }
+    store.set({
+      status: "refused",
+      reconnecting: false,
+      refusal,
+      ...ended ? { hello: null, serviceAccess: null } : {}
+    });
+    if (refusal.code === "PROTOCOL_MISMATCH") {
+      wiring.onProtocolMismatch(refusal);
+    }
+  });
+}
+function listenToPushes(wiring) {
+  const { socket, store, lifecycle } = wiring;
+  socket.on(SERVER_EVENTS.hello, (frame) => {
+    const grants = isRecord(frame) && isRecord(frame.serviceAccess) ? frame.serviceAccess : null;
+    store.set({ hello: frame, serviceAccess: grants });
+    notifyEach(wiring.hellos, (entry) => {
+      sayHello(wiring.hellos, entry, frame);
+    });
+  });
+  socket.on(SERVER_EVENTS.access, (frame) => {
+    if (isRecord(frame) && isRecord(frame.serviceAccess)) {
+      store.set({ serviceAccess: frame.serviceAccess });
+    }
+  });
+  socket.on(SERVER_EVENTS.rotate, (frame) => {
+    const withinMs = isRecord(frame) ? frame.withinMs : void 0;
+    if (typeof withinMs === "number" && Number.isFinite(withinMs) && withinMs >= 0) {
+      lifecycle.rotateWithin(withinMs);
+    }
+  });
+}
+function createQuickdrawConnection(options) {
+  const timeoutOption = checkOptions(options);
+  const store = createStore();
+  const backoff = createBackoff((windows) => {
+    store.set({ backoff: windows });
+  });
+  let auth = options.auth;
+  let nextId = 0;
+  const socket = createSocket(options, () => credentialsOf(auth));
+  const timeoutMs = () => defaultTimeout(timeoutOption, store.get().hello);
+  const subscriptionLane = createSubscriptionLane({
+    socket,
+    timeoutMs,
+    hello: () => store.get().hello,
+    backoffRemaining: backoff.remaining
+  });
+  const topics = createTopics({
+    socket,
+    lane: subscriptionLane,
+    backoffRemaining: backoff.remaining,
+    reportRateLimited: backoff.report
+  });
+  const retry = createRetry(socket, () => store.get().status === "connecting");
+  const session = { established: false, topics, lane: subscriptionLane, retry };
+  const lifecycle = createLifecycle(socket, store, backoff, session);
+  const reconnected = /* @__PURE__ */ new Set();
+  const wiring = {
+    socket,
+    store,
+    lifecycle,
+    session,
+    reconnected,
+    hellos: /* @__PURE__ */ new Set(),
+    onProtocolMismatch: options.onProtocolMismatch ?? reloadOncePerSession
+  };
+  listenToSocket(wiring);
+  listenToPushes(wiring);
+  return Object.freeze({
+    url: options.url,
+    get timeoutMs() {
+      return timeoutMs();
+    },
+    socket,
+    subscriptionLane,
+    getState: store.get,
+    subscribe: store.subscribe,
+    open: lifecycle.open,
+    close: lifecycle.close,
+    retain: lifecycle.retain,
+    setAuth(next) {
+      if (authKey(next) === authKey(auth)) {
+        return false;
+      }
+      auth = next;
+      session.established = false;
+      retry.stop();
+      failBuffered(
+        socket,
+        new QuickdrawError("CANCELLED", "The credentials changed before the call was sent")
+      );
+      store.set({ hello: null, serviceAccess: null });
+      lifecycle.reconnect();
+      return true;
+    },
+    nextCallId() {
+      const id = nextId;
+      nextId = nextId >= Number.MAX_SAFE_INTEGER ? 0 : nextId + 1;
+      return id;
+    },
+    reportRateLimited: backoff.report,
+    backoffRemaining: backoff.remaining,
+    onReconnect: (listener) => addListener(reconnected, listener),
+    onHello: (listener) => listenForHellos(wiring, listener),
+    watch: topics.watch,
+    waitForJoin: topics.waitForJoin
+  });
+}
+
+// src/client/host/hosts.ts
+function createDirectory(connection) {
+  const rooms = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const set = (room, host) => {
+    if ((rooms.get(room) ?? null) === host) {
+      return;
+    }
+    if (host === null) {
+      rooms.delete(room);
+    } else {
+      rooms.set(room, host);
+    }
+    notifyEach(listeners, (listener) => {
+      listener(room, host);
+    });
+  };
+  const { socket } = connection;
+  socket.on(SERVER_EVENTS.host, (frame) => {
+    const [room, host] = Array.isArray(frame) ? frame : [];
+    if (isRoomName(room) && (host === null || isSocketId(host))) {
+      set(room, host);
+    }
+  });
+  socket.on(SERVER_EVENTS.presence, (frame) => {
+    if (isRecord(frame) && isRoomName(frame.room) && Array.isArray(frame.users) && frame.users.length === 0) {
+      set(frame.room, null);
+    }
+  });
+  socket.on("disconnect", () => {
+    for (const room of [...rooms.keys()]) {
+      set(room, null);
+    }
+  });
+  return Object.freeze({
+    of: (room) => rooms.get(room),
+    rooms,
+    listen(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  });
+}
+var directories = /* @__PURE__ */ new WeakMap();
+function hostsOf(connection) {
+  let directory = directories.get(connection);
+  if (directory === void 0) {
+    directory = createDirectory(connection);
+    directories.set(connection, directory);
+  }
+  return directory;
+}
+function hostOf(connection, room) {
+  return hostsOf(connection).of(room) ?? null;
+}
+function onHostChange(connection, listener) {
+  return hostsOf(connection).listen(listener);
+}
+
+// src/client/host/links.ts
+var HOST_LINK_RETRY_MS = 1e3;
+var HOST_LINK_MAX_RETRY_MS = 15e3;
+var MAX_SEED_ITEMS = 1e4;
+var remote;
+function loadRemote() {
+  remote ??= import("./remote-N7OUAGOW.js").catch((error) => {
+    remote = void 0;
+    throw error;
+  });
+  return remote;
+}
+function loadWhenAnnounced(connection) {
+  const announced = () => {
+    const limits = connection.getState().hello?.limits;
+    return isRecord(limits) && limits.peers !== void 0;
+  };
+  const load = () => {
+    loadRemote().catch(() => void 0);
+  };
+  if (announced()) {
+    load();
+    return;
+  }
+  const stop = connection.subscribe(() => {
+    if (announced()) {
+      stop();
+      load();
+    }
+  });
+}
+var feedKey = (service, stream, scope) => `${service}\0${stream}\0${scope}`;
+function onMessage(state, message) {
+  if (message[0] !== 6 && message[0] !== 7 && message[0] !== 8) {
+    return;
+  }
+  const entry = state.feeds.get(feedKey(message[1], message[2], message[3]));
+  if (entry === void 0) {
+    return;
+  }
+  if (message[0] === 6) {
+    const chunks = [...entry.chunks ?? [], ...message[4]].slice(-MAX_SEED_ITEMS);
+    entry.chunks = message[5] ? void 0 : chunks;
+    if (message[5]) {
+      entry.feed.seeded(chunks);
+    }
+  } else if (message[0] === 7) {
+    entry.feed.item(message[4]);
+  } else if (message[0] === 8) {
+    entry.feed.refused(message[4]);
+  }
+}
+function subscribeOn(way, feed) {
+  way.send("rel", [4, feed.service, feed.stream, feed.scope]);
+}
+function opened(state, way) {
+  state.way = way;
+  state.retryMs = HOST_LINK_RETRY_MS;
+  state.backoff = void 0;
+  for (const entry of state.feeds.values()) {
+    entry.chunks = void 0;
+    subscribeOn(way, entry.feed);
+  }
+}
+function disconnect(state) {
+  const { pending } = state;
+  state.pending = void 0;
+  state.way = void 0;
+  state.host = void 0;
+  clearTimeout(state.retry);
+  state.retry = void 0;
+  pending?.();
+  for (const entry of state.feeds.values()) {
+    entry.chunks = void 0;
+    entry.feed.lost();
+  }
+}
+function takeLink(links, state, host, link, control) {
+  if (control === void 0) {
+    return;
+  }
+  const way = {
+    send: (label, message) => control.send(label, message),
+    close: () => {
+      link.close();
+    }
+  };
+  state.pending = way.close;
+  control.on((message) => {
+    onMessage(state, message);
+  });
+  const open = () => {
+    if (state.pending === way.close) {
+      opened(state, way);
+    }
+  };
+  link.on("open", open);
+  link.on("close", () => {
+    if (state.pending === way.close) {
+      disconnect(state);
+      retryLater(links, state, host);
+    }
+  });
+  if (link.state === "open") {
+    open();
+  }
+}
+function connectLocal(links, state, local, self) {
+  const { connection } = links;
+  const userId = connection.getState().hello?.userId ?? "";
+  const [near, far] = local.createLink(
+    state.room,
+    self,
+    userId,
+    () => connection.getState().hello?.limits.peers?.maxMessageBytes ?? MAX_PEER_MESSAGE_BYTES
+  );
+  local.host(far);
+  takeLink(links, state, self, near, local.controlOf(near));
+}
+function connectLink(links, state, host) {
+  const loading = () => void 0;
+  state.pending = loading;
+  void loadRemote().then(
+    ({ createPeerLink, controlOf }) => {
+      if (state.pending !== loading) {
+        return;
+      }
+      state.pending = void 0;
+      if (links.directory.of(state.room) !== host) {
+        disconnect(state);
+        return;
+      }
+      let link;
+      try {
+        link = createPeerLink(links.connection, { room: state.room, to: host, offerer: true });
+      } catch {
+        return;
+      }
+      takeLink(links, state, host, link, controlOf(link));
+    },
+    () => {
+      if (state.pending === loading) {
+        disconnect(state);
+        retryLater(links, state, host);
+      }
+    }
+  );
+}
+function connect(links, state) {
+  const host = links.directory.of(state.room);
+  if (host === void 0 || state.host === host && state.pending !== void 0) {
+    return;
+  }
+  if (state.backoff?.host === host && Date.now() < state.backoff.until) {
+    return;
+  }
+  if (state.pending !== void 0) {
+    disconnect(state);
+  }
+  state.host = host;
+  const self = links.connection.socket.id;
+  const local = links.locals.get(state.room);
+  if (host === self) {
+    if (local !== void 0 && self !== void 0) {
+      connectLocal(links, state, local, self);
+    }
+    return;
+  }
+  connectLink(links, state, host);
+}
+function retryLater(links, state, host) {
+  const wait = state.retryMs;
+  state.backoff = { host, until: Date.now() + wait };
+  state.retryMs = Math.min(HOST_LINK_MAX_RETRY_MS, wait * 2);
+  if (links.directory.of(state.room) === void 0) {
+    return;
+  }
+  clearTimeout(state.retry);
+  state.retry = setTimeout(() => {
+    state.retry = void 0;
+    state.backoff = void 0;
+    if (state.feeds.size > 0) {
+      connect(links, state);
+    }
+  }, wait);
+}
+function roomOf(links, room) {
+  let state = links.rooms.get(room);
+  if (state === void 0) {
+    state = {
+      room,
+      host: void 0,
+      way: void 0,
+      pending: void 0,
+      feeds: /* @__PURE__ */ new Map(),
+      retry: void 0,
+      retryMs: HOST_LINK_RETRY_MS,
+      backoff: void 0
+    };
+    links.rooms.set(room, state);
+  }
+  return state;
+}
+function createLinks(connection) {
+  const links = {
+    connection,
+    directory: hostsOf(connection),
+    rooms: /* @__PURE__ */ new Map(),
+    locals: /* @__PURE__ */ new Map()
+  };
+  loadWhenAnnounced(connection);
+  links.directory.listen((room, host) => {
+    const state = links.rooms.get(room);
+    if (state === void 0) {
+      return;
+    }
+    if (host === null) {
+      disconnect(state);
+      return;
+    }
+    state.backoff = void 0;
+    state.retryMs = HOST_LINK_RETRY_MS;
+    if (state.feeds.size > 0) {
+      connect(links, state);
+    }
+  });
+  return Object.freeze({
+    ...links,
+    send(room, service, channel, payload) {
+      const state = roomOf(links, room);
+      connect(links, state);
+      return state.way?.send("fast", [3, service, channel, payload]) ?? false;
+    },
+    subscribe(room, feed) {
+      const state = roomOf(links, room);
+      const key = feedKey(feed.service, feed.stream, feed.scope);
+      const entry = { feed, chunks: void 0 };
+      state.feeds.set(key, entry);
+      const { way } = state;
+      connect(links, state);
+      if (way !== void 0 && state.way === way) {
+        subscribeOn(way, feed);
+      }
+      return () => {
+        if (state.feeds.get(key) === entry) {
+          state.feeds.delete(key);
+          state.way?.send("rel", [5, feed.service, feed.stream, feed.scope]);
+        }
+      };
+    }
+  });
+}
+var all = /* @__PURE__ */ new WeakMap();
+function linksStateOf(connection) {
+  let links = all.get(connection);
+  if (links === void 0) {
+    links = createLinks(connection);
+    all.set(connection, links);
+  }
+  return links;
+}
+function hostLinksOf(connection) {
+  return linksStateOf(connection);
+}
+function registerLocalHost(connection, room, host, local) {
+  const links = linksStateOf(connection);
+  const serving = { host, ...local };
+  links.locals.set(room, serving);
+  const state = links.rooms.get(room);
+  if (state !== void 0 && state.feeds.size > 0) {
+    connect(links, state);
+  }
+  return () => {
+    if (links.locals.get(room) === serving) {
+      links.locals.delete(room);
+      const current = links.rooms.get(room);
+      if (current !== void 0 && current.host === connection.socket.id) {
+        disconnect(current);
+      }
+    }
+  };
+}
+
+export {
+  DEFAULT_BACKOFF_MS,
+  retryAfterOf,
+  notifyEach,
+  DEFAULT_SUBSCRIPTION_LANE,
+  subscriptionLimits,
+  reloadOncePerSession,
+  INITIAL_CONNECTION_STATE,
+  isServerDisconnect,
+  mayConnect,
+  isSessionRefusal,
+  isTimeLimit,
+  createQuickdrawConnection,
+  hostsOf,
+  hostOf,
+  onHostChange,
+  hostLinksOf,
+  registerLocalHost
+};
+//# sourceMappingURL=chunk-STH5DLQP.js.map