@fitzzero/quickdraw-core 5.1.1 → 5.1.3

package/dist/{chunk-OECZPRPW.js → chunk-64I6MYBC.js}

@@ -1,26 +1,25 @@
 import {
-  adminSpecOf,
   searchSpecOf
-} from "./chunk-CDKG4TFA.js";
-import {
-  ACCESS_LEVELS,
-  CLIENT_EVENTS,
-  MAX_SUBSCRIBE_IDS,
-  PROTOCOL_VERSION,
-  QUICKDRAW_VERSION,
-  SERVER_EVENTS,
-  isAuthenticationRefused,
-  isProtocolMismatch
-} from "./chunk-VSQBHPWH.js";
+} from "./chunk-XD7SRDUY.js";
 import {
   DEFAULT_COLLECTION_MAX_LIMIT
-} from "./chunk-RT6OILOI.js";
+} from "./chunk-4D2DOGAW.js";
 import {
-  createJsonParser
-} from "./chunk-Z2LZ7IZ7.js";
+  ACCESS_LEVELS
+} from "./chunk-AK23XSWD.js";
 import {
   consoleLogger
-} from "./chunk-YSWH776Y.js";
+} from "./chunk-DKE6QO26.js";
+import {
+  DEFAULT_BACKOFF_MS,
+  INITIAL_CONNECTION_STATE,
+  hostLinksOf,
+  isServerDisconnect,
+  isSessionRefusal,
+  notifyEach,
+  retryAfterOf,
+  subscriptionLimits
+} from "./chunk-STH5DLQP.js";
 import {
   KEY_ROOT,
   collectionKey,
@@ -28,738 +27,23 @@ import {
   methodKey,
   methodKeyPrefix,
   serviceKeyPrefix
-} from "./chunk-X5CWPX7H.js";
+} from "./chunk-IIQ3WMJK.js";
+import {
+  adminSpecOf
+} from "./chunk-MPQAT55F.js";
+import {
+  CLIENT_EVENTS,
+  MAX_SCOPE_LENGTH,
+  SERVER_EVENTS
+} from "./chunk-X4ZU4QH5.js";
 import {
   QuickdrawError,
-  fromWire,
+  fromWire
+} from "./chunk-Q4OGQM5I.js";
+import {
   isName,
   isRecord
-} from "./chunk-4YO5H5ON.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 wait2 = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) ? retryAfterMs : DEFAULT_BACKOFF_MS;
-  return Math.min(Math.max(wait2, 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 wait2 = waitFor(retryAfterMs);
-      const delay = wait2 + Math.random() * wait2 * JITTER_RATIO;
-      const ends2 = Date.now() + delay;
-      if (ends2 <= (until.get(kind) ?? 0)) {
-        return;
-      }
-      clearTimeout(timers.get(kind));
-      until.set(kind, ends2);
-      timers.set(
-        kind,
-        setTimeout(() => {
-          end(kind);
-        }, delay)
-      );
-      onChange(windows());
-    },
-    remaining(kind) {
-      const ends2 = until.get(kind);
-      return ends2 === void 0 ? 0 : Math.max(0, ends2 - 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 changed3 = new Set(frame.models.map((model) => modelName(String(model))));
-  return models.some((model) => changed3.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((hold2) => hold2.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 hold2 of holds) {
-    if (topic.state !== "joined" && hold2.key !== void 0) {
-      topic.unjoinedReads.add(hold2.key);
-    }
-    hold2.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 wait2 = host.backoffRemaining("subscription");
-  if (!host.socket.connected) {
-    topic.state = "waiting";
-    releaseHolds(topic);
-  } else if (wait2 > 0) {
-    retryIn(registry, topic, wait2);
-    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, wait2) {
-  const topic = registry.topics.get(topicId(wait2.service, wait2.topic));
-  if (topic === void 0) {
-    return void 0;
-  }
-  if (topic.state === "joining" && registry.host.socket.connected) {
-    return new Promise((resolve) => {
-      topic.holds.add({ key: wait2.key, release: resolve });
-    });
-  }
-  if (topic.state !== "joined" && wait2.key !== void 0) {
-    topic.unjoinedReads.add(wait2.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: (wait2) => waitForJoin(registry, wait2),
-    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(wait2) {
-    backoffTimer ??= setTimeout(() => {
-      backoffTimer = void 0;
-      pump();
-    }, wait2);
-  }
-  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 wait2 = host.backoffRemaining("subscription");
-      if (wait2 > 0) {
-        waitForBackoff(wait2);
-        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/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: (send2) => {
-      send2({ ...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(patch2) {
-      state = Object.freeze({ ...state, ...patch2 });
-      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 refusalOf(error) {
-  if (isProtocolMismatch(error.data)) {
-    return { code: error.data.code, expected: error.data.expected };
-  }
-  if (isAuthenticationRefused(error.data)) {
-    return { code: "UNAUTHENTICATED" };
-  }
-  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 opened = false;
-  let switching = false;
-  let users = 0;
-  let closeTimer;
-  let rotateTimer;
-  function connect() {
-    socket.connect();
-    store.set({ status: "connecting", refusal: null });
-  }
-  function reconnect() {
-    if (!opened) {
-      return;
-    }
-    switching = true;
-    socket.disconnect();
-    switching = false;
-    connect();
-  }
-  function open() {
-    clearTimeout(closeTimer);
-    closeTimer = void 0;
-    opened = true;
-    if (!socket.connected && !socket.active) {
-      connect();
-    }
-  }
-  function close() {
-    opened = false;
-    session.established = false;
-    session.topics.stop();
-    session.lane.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 retain2() {
-    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 opened ? "disconnected" : "idle";
-  }
-  return { open, close, retain: retain2, 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;
-    store.set({ status: "connected", reconnecting: false, refusal: null });
-    session.topics.rejoin();
-    if (again) {
-      notifyEach(wiring.reconnected, (listener) => {
-        listener();
-      });
-    }
-  });
-  socket.on("disconnect", () => {
-    const status = socket.active ? "connecting" : lifecycle.stoppedStatus();
-    store.set({ status, reconnecting: status === "connecting" && session.established });
-  });
-  socket.on("connect_error", (error) => {
-    if (socket.active) {
-      return;
-    }
-    const refusal = refusalOf(error);
-    session.established = false;
-    store.set({ status: "refused", reconnecting: false, refusal });
-    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 session = { established: false, topics, lane: subscriptionLane };
-  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(next2) {
-      if (authKey(next2) === authKey(auth)) {
-        return false;
-      }
-      auth = next2;
-      session.established = false;
-      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
-  });
-}
+} from "./chunk-QSU47XEX.js";
 
 // src/client/loopGuard.ts
 var MUTATION_LIMIT = 5;
@@ -1237,10 +521,10 @@ function shownOf(held) {
   }));
 }
 function refusedOf(held) {
-  const refused3 = (held ?? []).flatMap(
+  const refused2 = (held ?? []).flatMap(
     (addition) => addition.refusal === void 0 ? [] : [{ item: addition.item, error: addition.refusal.error, addition }]
   );
-  return refused3.length === 0 ? NO_REFUSALS : refused3;
+  return refused2.length === 0 ? NO_REFUSALS : refused2;
 }
 function newAddition(service, collection, scope, item, keep2) {
   return {
@@ -1269,7 +553,7 @@ function unasked(additions) {
 }
 function weigh(held, evidence) {
   const ending = [];
-  let refused3 = false;
+  let refused2 = false;
   for (const addition of held) {
     const outcome = verdict(addition, evidence);
     if (outcome === "end") {
@@ -1277,10 +561,10 @@ function weigh(held, evidence) {
     } else if (outcome === "refuse" && addition.unknown !== void 0) {
       addition.refusal = addition.unknown.refusal;
       addition.unknown = void 0;
-      refused3 = true;
+      refused2 = true;
     }
   }
-  return { ending, refused: refused3 };
+  return { ending, refused: refused2 };
 }
 function createAdditions(queryClient) {
   const byScope = /* @__PURE__ */ new Map();
@@ -1596,13 +880,13 @@ function settleScope(layers, ref, evidence) {
   if (layers.additions.size === 0) {
     return;
   }
-  const { ending, refused: refused3 } = layers.additions.settle(
+  const { ending, refused: refused2 } = layers.additions.settle(
     ref.service,
     ref.collection,
     ref.scope,
     evidence
   );
-  discard(layers, [], ending, refused3 ? [ref.service] : []);
+  discard(layers, [], ending, refused2 ? [ref.service] : []);
 }
 function resetLayers(layers) {
   const services = new Set(layers.views.keys());
@@ -1622,7 +906,7 @@ function resetLayers(layers) {
   layers.count = 0;
   changed(layers, services);
 }
-function createStore2(queryClient) {
+function createStore(queryClient) {
   const layers = {
     byRow: /* @__PURE__ */ new Map(),
     additions: createAdditions(queryClient),
@@ -1687,7 +971,7 @@ function createStore2(queryClient) {
 function storeOf(queryClient) {
   let store = stores.get(queryClient);
   if (store === void 0) {
-    store = createStore2(queryClient);
+    store = createStore(queryClient);
     stores.set(queryClient, store);
   }
   return store;
@@ -1745,6 +1029,25 @@ function createSession(connection, queryClient) {
       });
     }
   });
+  const end = () => {
+    queryClient.removeQueries({ queryKey: [KEY_ROOT] });
+    resetOverlays(queryClient);
+    loadedFor.set(queryClient, { userId: null });
+    notifyEach(listeners, (listener) => {
+      listener({ switched: true, first: false });
+    });
+  };
+  const { socket } = connection;
+  socket.on("disconnect", (reason) => {
+    if (isServerDisconnect(reason)) {
+      end();
+    }
+  });
+  socket.on("connect_error", (error) => {
+    if (!socket.active && isRecord(error) && isSessionRefusal(error.data)) {
+      end();
+    }
+  });
   return Object.freeze({
     onHello(listener) {
       listeners.add(listener);
@@ -2445,13 +1748,87 @@ function setState(feeds, feed, state) {
     listener();
   });
 }
-function answered2(feeds, feed, reply) {
+function answered(feeds, feed, reply) {
   const seed = Array.isArray(reply.seed) ? reply.seed : [];
   const items = latest([...seed, ...feed.pending ?? []], capOf(feed));
   feed.pending = void 0;
   setState(feeds, feed, Object.freeze({ items, isLoading: false, error: null }));
 }
+var HOST_RETRY_MS = 1e3;
+function subscribeHost(feeds, feed) {
+  clearTimeout(feed.retry);
+  feed.retry = void 0;
+  feed.release?.();
+  feed.release = void 0;
+  feed.attempt += 1;
+  const { attempt } = feed;
+  const current = () => feed.attempt === attempt && feeds.registry.get(feed.key) === feed;
+  const { s: service, stream } = feed.frame;
+  const scope = feed.frame.scope ?? "";
+  const refused2 = (error) => {
+    feed.pending = void 0;
+    setState(feeds, feed, Object.freeze({ items: [], isLoading: false, error }));
+  };
+  if (!isName(scope) || scope.length > MAX_SCOPE_LENGTH) {
+    refused2(
+      new QuickdrawError(
+        "VALIDATION",
+        `${service}.${stream} is scoped: its scope is a string of 1 to ${MAX_SCOPE_LENGTH} characters`
+      )
+    );
+    return;
+  }
+  if (feed.room === void 0) {
+    refused2(
+      new QuickdrawError(
+        "NOT_FOUND",
+        `No app room serves scope "${scope}" of ${service}.${stream}`
+      )
+    );
+    return;
+  }
+  feed.pending = [];
+  feed.release = hostLinksOf(feeds.host.connection).subscribe(feed.room, {
+    service,
+    stream,
+    scope,
+    seeded: (items) => {
+      if (current()) {
+        answered(feeds, feed, { seed: items });
+      }
+    },
+    item: (item) => {
+      if (current()) {
+        receive(feeds, [service, stream, scope, item]);
+      }
+    },
+    refused: (error) => {
+      if (!current()) {
+        return;
+      }
+      if (error.code === "RATE_LIMITED") {
+        feed.retry = setTimeout(
+          () => {
+            subscribeHost(feeds, feed);
+          },
+          HOST_RETRY_MS * (1 + Math.random() / 2)
+        );
+      } else {
+        refused2(new QuickdrawError(error.code, error.message));
+      }
+    },
+    lost: () => {
+      if (current()) {
+        feed.pending = [];
+      }
+    }
+  });
+}
 function subscribe(feeds, feed) {
+  if (feed.hosted) {
+    subscribeHost(feeds, feed);
+    return;
+  }
   const { host } = feeds;
   clearTimeout(feed.retry);
   feed.retry = void 0;
@@ -2463,7 +1840,7 @@ function subscribe(feeds, feed) {
       return;
     }
     if (outcome.kind === "ok") {
-      answered2(feeds, feed, outcome.reply);
+      answered(feeds, feed, outcome.reply);
     } else if (outcome.kind === "refused") {
       feed.pending = void 0;
       setState(feeds, feed, Object.freeze({ items: [], isLoading: false, error: outcome.error }));
@@ -2481,12 +1858,19 @@ function closeFeed(feeds, feed) {
   const { socket } = feeds.host.connection;
   clearTimeout(feed.retry);
   feed.attempt += 1;
+  if (feed.hosted) {
+    feed.release?.();
+    feed.release = void 0;
+    setState(feeds, feed, PENDING_STREAM);
+    return;
+  }
   if (feed.sent && socket.connected) {
     socket.emit(CLIENT_EVENTS.streamUnsub, feed.frame);
   }
   setState(feeds, feed, PENDING_STREAM);
 }
 function openFeed(target, scope, key) {
+  const { host } = target;
   const frame = scope === void 0 ? { s: target.service, stream: target.stream } : { s: target.service, stream: target.stream, scope };
   return {
     key,
@@ -2496,7 +1880,10 @@ function openFeed(target, scope, key) {
     pending: void 0,
     sent: false,
     attempt: 0,
-    retry: void 0
+    retry: void 0,
+    hosted: host !== void 0,
+    room: host?.(scope ?? ""),
+    release: void 0
   };
 }
 function hold(feeds, target, scope, max) {
@@ -2556,6 +1943,7 @@ function listen(feeds, key, listener) {
   };
 }
 function createStreamStore(host) {
+  hostLinksOf(host.connection);
   const feeds = {
     host,
     registry: createRegistry((feed) => {
@@ -2575,7 +1963,9 @@ function createStreamStore(host) {
     },
     resume() {
       for (const feed of feeds.registry.held()) {
-        subscribe(feeds, feed);
+        if (!feed.hosted || feed.release === void 0) {
+          subscribe(feeds, feed);
+        }
       }
     },
     forget() {
@@ -2590,6 +1980,10 @@ function createStreamStore(host) {
         feed.retry = void 0;
         feed.attempt += 1;
         feed.pending = void 0;
+        if (feed.hosted) {
+          feed.release?.();
+          feed.release = void 0;
+        }
       }
     }
   });
@@ -2676,15 +2070,15 @@ function loadPage(p) {
   const limit = p.pageLimit();
   const frame = { ...scopeFrame(p), cursor, ...limit === void 0 ? {} : { limit } };
   p.write({ loadingMore: true });
-  let answered4 = false;
+  let answered3 = false;
   const page = new Promise((resolve) => {
     request2(p.host, CLIENT_EVENTS.collectionSub, frame, (outcome) => {
-      answered4 = true;
+      answered3 = true;
       p.page = void 0;
       resolve(p.disposed ? false : pageLoaded(p, sent, outcome));
     });
   });
-  if (!answered4) {
+  if (!answered3) {
     p.page = page;
   }
   return page;
@@ -2857,7 +2251,7 @@ function applyLoad(p, reply, kept, readAt) {
     observeItems(p, reply.items, reply.rev, readAt);
     applied = { state: applySnapshot(base, reply, p.shape), reset: false, missing: [] };
   } else {
-    refused2(p, malformed("qd:col:sub"));
+    refused(p, malformed("qd:col:sub"));
     return;
   }
   for (const frame of kept) {
@@ -2881,7 +2275,7 @@ function applyLoad(p, reply, kept, readAt) {
     reloaded
   );
 }
-function refused2(p, error) {
+function refused(p, error) {
   p.joined = false;
   const drops = ["FORBIDDEN", "NOT_FOUND", "UNAUTHENTICATED"].includes(error.code);
   write(p, drops ? { state: null, error, loadingMore: false } : { error });
@@ -2897,7 +2291,7 @@ function loaded(p, { generation, kind, readAt }, outcome) {
   if (outcome.kind === "ok") {
     applyLoad(p, outcome.reply, kept, readAt);
   } else if (outcome.kind === "refused") {
-    refused2(p, outcome.error);
+    refused(p, outcome.error);
   } else if (outcome.kind === "retry") {
     p.retryTimer = setTimeout(() => {
       p.retryTimer = void 0;
@@ -3446,8 +2840,8 @@ function entityResultOf(value) {
   if (isRecord(value) && value.ok === false) {
     return value;
   }
-  const answered4 = isRecord(value) && value.ok === true && isRevision(value.rev) && (value.nm === true || Object.hasOwn(value, "d"));
-  return answered4 ? value : { ok: false, e: { code: "INTERNAL", message: "The server's qd:sub reply is malformed" } };
+  const answered3 = isRecord(value) && value.ok === true && isRevision(value.rev) && (value.nm === true || Object.hasOwn(value, "d"));
+  return answered3 ? value : { ok: false, e: { code: "INTERNAL", message: "The server's qd:sub reply is malformed" } };
 }
 
 // src/client/live/entityStore.ts
@@ -3529,7 +2923,7 @@ function apply(state, batch, results) {
     commit(state, row, before, applyEntityResult(before, result, batch.readAt));
   });
 }
-function answered3(state, batch, outcome) {
+function answered2(state, batch, outcome) {
   if (batch.epoch !== state.epoch || outcome.kind === "offline") {
     return;
   }
@@ -3548,7 +2942,7 @@ function send(state, service, ids) {
   const batch = { service, ids, epoch: state.epoch, readAt: state.host.overlays.now() };
   const frame = revs.some((rev) => rev !== null) ? { s: service, ids, revs } : { s: service, ids };
   request2(state.host, CLIENT_EVENTS.sub, frame, (outcome) => {
-    answered3(state, batch, outcome);
+    answered2(state, batch, outcome);
   });
 }
 function flush(state) {
@@ -4221,13 +3615,6 @@ function showCollection(state, options) {
 }
 
 export {
-  DEFAULT_BACKOFF_MS,
-  retryAfterOf,
-  notifyEach,
-  DEFAULT_SUBSCRIPTION_LANE,
-  reloadOncePerSession,
-  isTimeLimit,
-  createQuickdrawConnection,
   createMutationTrace,
   loopGuardOf,
   DEFAULT_INVALIDATION_WINDOW_MS,
@@ -4284,4 +3671,4 @@ export {
   viewPredicate,
   showCollection
 };
-//# sourceMappingURL=chunk-OECZPRPW.js.map
+//# sourceMappingURL=chunk-64I6MYBC.js.map