@fitzzero/quickdraw-core 5.1.2 → 5.1.3

package/dist/{chunk-6K5BY47X.js → chunk-JVTONQFI.js}

@@ -12,11 +12,11 @@ import {
   quietly,
   strictWarningsOf,
   versionTime
-} from "./chunk-Z5ILULF2.js";
+} from "./chunk-SQ5VUG77.js";
 import {
   isCallEnvelope,
   isCancel
-} from "./chunk-RL4VKLBX.js";
+} from "./chunk-KKQANRLG.js";
 import {
   NEVER_ABORTED,
   SUBSCRIBER_LEVELS,
@@ -52,12 +52,12 @@ import {
   watchCallerReads,
   wholeView,
   withSignal
-} from "./chunk-MBH6IDSM.js";
+} from "./chunk-OCZJ4EYV.js";
 import {
   createRecorder,
   describeError,
   failureLevel
-} from "./chunk-LCC7HNFP.js";
+} from "./chunk-RZXJTDH5.js";
 import {
   INTERNAL_FAILURE,
   acknowledge,
@@ -76,25 +76,57 @@ import {
   toCallReply,
   transportCookieNaming,
   unreadable
-} from "./chunk-RJ5I2VO3.js";
+} from "./chunk-PHCURHC7.js";
 import {
   ANY_FIELD,
   modelKey,
   storageOf
 } from "./chunk-DUBU3BB3.js";
+import {
+  DEFAULT_COLLECTION_LIMIT,
+  DEFAULT_COLLECTION_MAX_LIMIT
+} from "./chunk-4D2DOGAW.js";
+import {
+  isAccessLevel
+} from "./chunk-AK23XSWD.js";
+import {
+  consoleLogger,
+  errorText
+} from "./chunk-DKE6QO26.js";
+import {
+  validateNow
+} from "./chunk-7473HK24.js";
+import {
+  isPeerLabel,
+  isRoomName,
+  isSocketId,
+  readSignal
+} from "./chunk-2FDSKLBO.js";
+import {
+  QUICKDRAW_VERSION
+} from "./chunk-A2RBQD66.js";
 import {
   CLIENT_EVENTS,
   MAX_ENTITY_IDS_PER_SOCKET,
+  MAX_PEER_LINKS,
+  MAX_PEER_MESSAGE_BYTES,
   MAX_SCOPES_PER_SOCKET,
   MAX_SCOPE_LENGTH,
   MAX_SUBSCRIBE_IDS,
   MAX_TOPICS_PER_SOCKET,
+  PEER_RELAY_BURST,
+  PEER_RELAY_BYTES_BURST,
+  PEER_RELAY_BYTES_PER_SECOND,
+  PEER_RELAY_FAST_BACKLOG,
+  PEER_RELAY_RATE,
+  PEER_SIGNAL_BURST,
+  PEER_SIGNAL_RATE,
   PROTOCOL_MISMATCH,
   PROTOCOL_VERSION,
-  QUICKDRAW_VERSION,
   RESERVED_ROOM_PREFIXES,
   SERVER_EVENTS,
   SERVICE_TOPIC,
+  STREAM_ROOM_PREFIX,
   collectionRoom,
   collectionTopic,
   entityRoom,
@@ -104,24 +136,19 @@ import {
   streamRoom,
   topicRoom,
   userRoom
-} from "./chunk-753VJIUP.js";
+} from "./chunk-X4ZU4QH5.js";
 import {
-  DEFAULT_COLLECTION_LIMIT,
-  DEFAULT_COLLECTION_MAX_LIMIT
-} from "./chunk-4D2DOGAW.js";
-import {
-  isAccessLevel
-} from "./chunk-AK23XSWD.js";
-import {
-  consoleLogger,
-  errorText
-} from "./chunk-DKE6QO26.js";
+  utf8ByteLength
+} from "./chunk-7Y5ROPXL.js";
 import {
   INTERNAL_MESSAGE,
   QuickdrawError,
   httpStatus,
   toWire
-} from "./chunk-4YO5H5ON.js";
+} from "./chunk-Q4OGQM5I.js";
+import {
+  isRecord
+} from "./chunk-QSU47XEX.js";
 
 // src/server/access/forms.ts
 function custom(check) {
@@ -130,7 +157,7 @@ function custom(check) {
   }
   return Object.freeze({ kind: "custom", check });
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isCustomAccess(form) {
@@ -150,7 +177,7 @@ function objectFormProblem(form) {
     return "needs service, entry or scope set to an access level";
   }
   if (form.scope !== void 0) {
-    const valid = levels.length === 1 && isRecord(form.of) && isIdSelector(form.id);
+    const valid = levels.length === 1 && isRecord2(form.of) && isIdSelector(form.id);
     return valid ? void 0 : "a scope form is { scope, of: contract, id } and nothing else";
   }
   if (form.of !== void 0 || form.id !== void 0 && !isIdSelector(form.id)) {
@@ -162,7 +189,7 @@ function accessFormProblem(form) {
   if (form === "public" || form === "authenticated") {
     return void 0;
   }
-  if (!isRecord(form)) {
+  if (!isRecord2(form)) {
     return 'must be "public", "authenticated", { service }, { entry }, { scope, of, id } or custom(fn)';
   }
   if (form.kind === "custom") {
@@ -182,7 +209,7 @@ function accessIds(form, input) {
   let value;
   if (typeof id === "function") {
     value = id(input);
-  } else if (isRecord(input)) {
+  } else if (isRecord2(input)) {
     value = input[id ?? "id"];
   }
   const ids = idsFrom(value);
@@ -366,24 +393,41 @@ function linkQualifies(via, values) {
   }
   return unknown ? void 0 : false;
 }
-var OPTION_KEYS = /* @__PURE__ */ new Set(["anchor", "scopeAccess", "bulkThreshold"]);
-function isRecord2(value) {
+var OPTION_KEYS = /* @__PURE__ */ new Set([
+  "anchor",
+  "scopeAccess",
+  "requires",
+  "bulkThreshold"
+]);
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isContract(value) {
-  return isRecord2(value) && typeof value.name === "string" && value.name.length > 0 && Object.isFrozen(value);
+  return isRecord3(value) && typeof value.name === "string" && value.name.length > 0 && Object.isFrozen(value);
+}
+function checkRequires(owner, requires, fail5) {
+  if (requires === void 0) {
+    return void 0;
+  }
+  const valid = isRecord3(requires) && Object.keys(requires).length === 1 && isAccessLevel(requires.service);
+  if (!valid) {
+    fail5(
+      `${owner}: requires must be { service: level }, the service-wide grant every subscriber needs, as { service: "Read" }`
+    );
+  }
+  return Object.freeze({ service: requires.service });
 }
 function checkOption(owner, option, fail5) {
-  if (!isRecord2(option)) {
+  if (!isRecord3(option)) {
     fail5(`${owner} must be { anchor: contract } or { scopeAccess: "self" }`);
   }
   const unknownKey = Object.keys(option).find((key) => !OPTION_KEYS.has(key));
   if (unknownKey !== void 0) {
     fail5(
-      `${owner} has an unknown option "${unknownKey}"; the options are anchor, scopeAccess and bulkThreshold`
+      `${owner} has an unknown option "${unknownKey}"; the options are anchor, scopeAccess, requires and bulkThreshold`
     );
   }
-  const { anchor, scopeAccess, bulkThreshold = DEFAULT_BULK_THRESHOLD } = option;
+  const { anchor, scopeAccess, requires, bulkThreshold = DEFAULT_BULK_THRESHOLD } = option;
   if (anchor === void 0 === (scopeAccess === void 0)) {
     fail5(
       `${owner} needs exactly one of anchor (the contract whose rows its scope values are ids of) and scopeAccess: "self"`
@@ -400,7 +444,11 @@ function checkOption(owner, option, fail5) {
   if (typeof bulkThreshold !== "number" || !Number.isSafeInteger(bulkThreshold) || bulkThreshold < 1) {
     fail5(`${owner}: bulkThreshold must be a positive whole number`);
   }
-  return { anchor, bulkThreshold };
+  return {
+    anchor,
+    requires: checkRequires(owner, requires, fail5),
+    bulkThreshold
+  };
 }
 function checkIndex(name, def, item, access, fail5) {
   const { index, views } = def;
@@ -514,7 +562,7 @@ function compileOne([name, def], contract, projections, [option, policy], fail5)
       `collection "${name}" needs its scope's access: collections: { ${name}: { anchor: contract } }, or { scopeAccess: "self" } for a scope that is the subscriber's user id`
     );
   }
-  const { anchor, bulkThreshold } = checkOption(`collections.${name}`, option, fail5);
+  const { anchor, requires, bulkThreshold } = checkOption(`collections.${name}`, option, fail5);
   const item = projections.get(def.item);
   if (item === void 0) {
     fail5(`collection "${name}": item "${def.item}" is not a projection of the contract`);
@@ -531,12 +579,13 @@ function compileOne([name, def], contract, projections, [option, policy], fail5)
     maxLimit: def.maxLimit ?? DEFAULT_COLLECTION_MAX_LIMIT,
     access,
     anchor,
+    requires,
     bulkThreshold,
     index: checkIndex(name, def, item, access, fail5)
   });
 }
 function compileCollections(contract, projections, model, option, fail5, policy) {
-  if (option !== void 0 && !isRecord2(option)) {
+  if (option !== void 0 && !isRecord3(option)) {
     fail5(
       'collections must map each collection of the contract to { anchor } or { scopeAccess: "self" }'
     );
@@ -682,7 +731,7 @@ function createDeltaBuffer(options = {}) {
 
 // src/server/collections/items.ts
 var MAX_ITEM_IDS = 200;
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hiddenOf(collection) {
@@ -690,7 +739,7 @@ function hiddenOf(collection) {
 }
 function itemOf(collection, row) {
   const item = projectRow(collection.item, row);
-  return isRecord3(item) ? strip(item, hiddenOf(collection)) : item;
+  return isRecord4(item) ? strip(item, hiddenOf(collection)) : item;
 }
 function patchOf(collection, row, fields) {
   const hidden = hiddenOf(collection);
@@ -849,7 +898,7 @@ function afterCursor(order, values, nullable) {
 
 // src/server/collections/index.ts
 var INDEX_MAX_ROWS = 5e4;
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function indexColumns(collection) {
@@ -866,7 +915,7 @@ function indexSelect(collection, fields) {
   return selectWith(select, indexColumns(collection));
 }
 function indexRowFrom(collection, item, row, rev) {
-  const values = isRecord4(item) ? item : {};
+  const values = isRecord5(item) ? item : {};
   const { versionColumn } = collection.service;
   const version = versionColumn === void 0 ? void 0 : versionTime(row[versionColumn]);
   const id = typeof row.id === "string" ? row.id : "";
@@ -1425,17 +1474,17 @@ var SubscriptionIndex = class {
    * changed row (any row of the service when `id` is absent), of the changed
    * user's sockets (every user's when `userId` is absent).
    */
-  matching(change) {
-    const key = change.id === void 0 ? void 0 : anchorKey(change.service, change.id);
-    const sockets = key === void 0 ? this.#byService.get(change.service) : this.#byAnchor.get(key);
+  matching(change2) {
+    const key = change2.id === void 0 ? void 0 : anchorKey(change2.service, change2.id);
+    const sockets = key === void 0 ? this.#byService.get(change2.service) : this.#byAnchor.get(key);
     const found = /* @__PURE__ */ new Map();
     for (const socket of sockets?.keys() ?? []) {
-      if (change.userId !== void 0 && socket.data.principal?.userId !== change.userId) {
+      if (change2.userId !== void 0 && socket.data.principal?.userId !== change2.userId) {
         continue;
       }
       const entries = [...this.entries(socket)].filter(
         ({ subscription }) => subscription.anchors.some(
-          (anchor) => key === void 0 ? serviceOf(anchor) === change.service : anchor === key
+          (anchor) => key === void 0 ? serviceOf(anchor) === change2.service : anchor === key
         )
       );
       if (entries.length > 0) {
@@ -1447,17 +1496,6 @@ var SubscriptionIndex = class {
 };
 
 // src/server/realtime/validate.ts
-function isThenable(value) {
-  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
-}
-function validateNow(schema, value) {
-  const result = schema["~standard"].validate(value);
-  if (isThenable(result)) {
-    Promise.resolve(result).catch(() => void 0);
-    return "async";
-  }
-  return result.issues === void 0 ? { value: result.value } : { issues: result.issues };
-}
 function checksItems(stream, outputValidation) {
   return stream.validate === "always" || outputValidation;
 }
@@ -1479,31 +1517,47 @@ function checkOutgoing(schema, value, label) {
 // src/server/realtime/channels.ts
 var CHANNEL_ABUSE_WINDOW_MS = 1e4;
 var CHANNEL_ABUSE_MULTIPLIER = 100;
-function take(bucket, channel, now) {
-  const refill = (now - bucket.refilledAt) / 1e3 * channel.ratePerSecond;
-  bucket.tokens = Math.min(channel.burst, bucket.tokens + refill);
-  bucket.refilledAt = now;
-  if (bucket.tokens < 1) {
+function warnHostServed(deps, service, name) {
+  if (typeof service !== "string" || typeof name !== "string") {
+    return;
+  }
+  const channels = deps.hub.registry.services.get(service)?.contract.channels;
+  const def = channels !== void 0 && Object.hasOwn(channels, name) ? channels[name] : void 0;
+  const key = `${service}\0${name}`;
+  if (def?.serve !== "host" || deps.hostWarned.has(key) || process.env.NODE_ENV === "production") {
+    return;
+  }
+  deps.hostWarned.add(key);
+  deps.hub.logger.warn(
+    `Channel ${service}.${name} is served by the room's host (serve: "host"), but a client sent it to the server: the server drops it; send it over the link to the host of its room (useChannel does)`,
+    { category: "quickdraw.channel" }
+  );
+}
+function take(bucket2, channel, now) {
+  const refill = (now - bucket2.refilledAt) / 1e3 * channel.ratePerSecond;
+  bucket2.tokens = Math.min(channel.burst, bucket2.tokens + refill);
+  bucket2.refilledAt = now;
+  if (bucket2.tokens < 1) {
     return false;
   }
-  bucket.tokens -= 1;
+  bucket2.tokens -= 1;
   return true;
 }
-function abusive(bucket, channel, now) {
-  if (now - bucket.windowStart > CHANNEL_ABUSE_WINDOW_MS) {
-    bucket.windowStart = now;
-    bucket.dropped = 0;
+function abusive(bucket2, channel, now) {
+  if (now - bucket2.windowStart > CHANNEL_ABUSE_WINDOW_MS) {
+    bucket2.windowStart = now;
+    bucket2.dropped = 0;
   }
-  bucket.dropped += 1;
-  return bucket.dropped > channel.ratePerSecond * CHANNEL_ABUSE_MULTIPLIER;
+  bucket2.dropped += 1;
+  return bucket2.dropped > channel.ratePerSecond * CHANNEL_ABUSE_MULTIPLIER;
 }
 function bucketOf(state, channel, now) {
-  let bucket = state.buckets.get(channel);
-  if (bucket === void 0) {
-    bucket = { tokens: channel.burst, refilledAt: now, windowStart: now, dropped: 0 };
-    state.buckets.set(channel, bucket);
+  let bucket2 = state.buckets.get(channel);
+  if (bucket2 === void 0) {
+    bucket2 = { tokens: channel.burst, refilledAt: now, windowStart: now, dropped: 0 };
+    state.buckets.set(channel, bucket2);
   }
-  return bucket;
+  return bucket2;
 }
 function parse(deps, channel, payload) {
   const result = validateNow(channel.payload, payload);
@@ -1589,13 +1643,13 @@ function run(deps, channel, value, ctx) {
     failed(deps, channel, ctx, error);
   }
 }
-function flooded(deps, state, channel, bucket) {
+function flooded(deps, state, channel, bucket2) {
   deps.hub.logger.warn(
     `Disconnecting socket ${state.socket.id} for sustained flooding of channel ${channel.service}.${channel.name}`,
     {
       category: "quickdraw.channel",
       userId: state.socket.data.principal?.userId,
-      dropped: bucket.dropped
+      dropped: bucket2.dropped
     }
   );
   state.socket.disconnect(true);
@@ -1607,13 +1661,14 @@ function receive(deps, state, frame) {
   const [service, name, payload] = frame;
   const channel = typeof service === "string" && typeof name === "string" ? deps.hub.registry.services.get(service)?.channels.get(name) : void 0;
   if (channel === void 0) {
+    warnHostServed(deps, service, name);
     return;
   }
   const now = Date.now();
-  const bucket = bucketOf(state, channel, now);
-  if (!take(bucket, channel, now)) {
-    if (abusive(bucket, channel, now)) {
-      flooded(deps, state, channel, bucket);
+  const bucket2 = bucketOf(state, channel, now);
+  if (!take(bucket2, channel, now)) {
+    if (abusive(bucket2, channel, now)) {
+      flooded(deps, state, channel, bucket2);
     }
     return;
   }
@@ -2026,8 +2081,8 @@ var PRESENCE_FALLBACK_MS = 3e4;
 var PRESENCE_WARN_EVERY_MS = 10 * 6e4;
 function coalescer() {
   const slots = /* @__PURE__ */ new Map();
-  const start = (key, ask) => {
-    const running = ask();
+  const start = (key, ask2) => {
+    const running = ask2();
     const slot = { running, queued: void 0 };
     slots.set(key, slot);
     const settle2 = () => {
@@ -2038,14 +2093,14 @@ function coalescer() {
     running.then(settle2, settle2);
     return running;
   };
-  return (key, ask) => {
+  return (key, ask2) => {
     const slot = slots.get(key);
     if (slot === void 0) {
-      return start(key, ask);
+      return start(key, ask2);
     }
     slot.queued ??= slot.running.then(
-      () => start(key, ask),
-      () => start(key, ask)
+      () => start(key, ask2),
+      () => start(key, ask2)
     );
     return slot.queued;
   };
@@ -2061,6 +2116,18 @@ function idsOf(answers) {
   }
   return [...ids];
 }
+function countOf(answers) {
+  let total = 0;
+  for (const answer2 of Array.isArray(answers) ? answers : []) {
+    if (typeof answer2 === "number" && Number.isSafeInteger(answer2) && answer2 > 0) {
+      total += answer2;
+    }
+  }
+  return total;
+}
+function answersOf(error) {
+  return typeof error === "object" && error !== null ? error.responses : void 0;
+}
 async function readUsers(hub, room) {
   const { io } = hub;
   if (io === void 0) {
@@ -2094,11 +2161,13 @@ function answerRequests(hub, records) {
     hub.logger,
     PRESENCE_EVENT,
     (payload, answer2) => {
-      const { room, userId } = payload ?? {};
+      const { room, userId, sockets } = payload ?? {};
       if (typeof room === "string") {
         answer2(records.users(room) ?? []);
       } else if (typeof userId === "string") {
         answer2((io.sockets.adapter.rooms.get(userRoom(userId))?.size ?? 0) > 0);
+      } else if (typeof sockets === "string" && sockets.startsWith(STREAM_ROOM_PREFIX)) {
+        answer2(io.sockets.adapter.rooms.get(sockets)?.size ?? 0);
       } else {
         answer2(null);
       }
@@ -2106,6 +2175,37 @@ function answerRequests(hub, records) {
     null
   );
 }
+function createCount(hub, now) {
+  let warnedAt;
+  const timedOut = () => {
+    const at = now();
+    if (warnedAt === void 0 || at - warnedAt >= PRESENCE_WARN_EVERY_MS) {
+      warnedAt = at;
+      hub.logger.warn(
+        "A node did not answer a stream's subscriber count within cluster.timeoutMs (a node of an earlier quickdraw version during a rolling deploy, a node that stopped answering, or an adapter that does not answer server-side events): the sockets of the nodes whose answers did not arrive counted as 0",
+        { category: "quickdraw.presence" }
+      );
+    }
+  };
+  return async (room) => {
+    const { io } = hub;
+    if (io === void 0) {
+      return 0;
+    }
+    const timeoutMs = hub.cluster?.timeoutMs ?? DEFAULT_CLUSTER_TIMEOUT_MS;
+    try {
+      return countOf(
+        await within(
+          io.serverSideEmitWithAck(PRESENCE_EVENT, tagged(io, { sockets: room })),
+          timeoutMs
+        )
+      );
+    } catch (error) {
+      timedOut();
+      return countOf(answersOf(error));
+    }
+  };
+}
 function createPresenceRequests(hub, records, now = Date.now) {
   const coalesced = coalescer();
   let fallbackUntil = 0;
@@ -2121,7 +2221,8 @@ function createPresenceRequests(hub, records, now = Date.now) {
       );
     }
   };
-  const ask = async (payload, answered, read) => {
+  const count3 = createCount(hub, now);
+  const ask2 = async (payload, answered, read) => {
     const { io } = hub;
     if (io === void 0 || now() < fallbackUntil) {
       return await read();
@@ -2139,15 +2240,16 @@ function createPresenceRequests(hub, records, now = Date.now) {
     }
   };
   return Object.freeze({
-    users: (room) => coalesced(`r\0${room}`, () => ask({ room }, idsOf, () => readUsers(hub, room))),
+    users: (room) => coalesced(`r\0${room}`, () => ask2({ room }, idsOf, () => readUsers(hub, room))),
     online: (userId) => coalesced(
       `u\0${userId}`,
-      () => ask(
+      () => ask2(
         { userId },
         (answers) => Array.isArray(answers) && answers.includes(true),
         () => readOnline(hub, userId)
       )
     ),
+    sockets: (room) => coalesced(`s\0${room}`, () => count3(room)),
     listen: () => {
       answerRequests(hub, records);
     }
@@ -2230,6 +2332,14 @@ async function usersInRoom(state, room) {
   const remote = await state.requests.users(room);
   return [.../* @__PURE__ */ new Set([...remote, ...localUsers(records, room)])];
 }
+async function socketsInRoom(state, room) {
+  const { io } = state.hub;
+  if (io === void 0) {
+    return 0;
+  }
+  const remote = state.hub.probe.local() ? 0 : await state.requests.sockets(room);
+  return remote + (io.sockets.adapter.rooms.get(room)?.size ?? 0);
+}
 async function inRoom(state, room, userId) {
   return (await usersInRoom(state, room)).includes(userId);
 }
@@ -2823,17 +2933,17 @@ async function touchedSince(batch, rev) {
     return { stale: moved === void 0 ? [] : joined, fresh: moved ?? rev };
   }
   const service = target2.service.name;
-  const stale = joined.filter((id) => hub.changeLog.lastChange(service, id) > rev);
-  return { stale, fresh: stale.length === 0 ? rev : currentRev() };
+  const stale2 = joined.filter((id) => hub.changeLog.lastChange(service, id) > rev);
+  return { stale: stale2, fresh: stale2.length === 0 ? rev : currentRev() };
 }
 async function rereadTouched(batch, rev) {
   const { hub, target: target2 } = batch;
-  const { stale, fresh } = await touchedSince(batch, rev);
-  if (stale.length === 0) {
+  const { stale: stale2, fresh } = await touchedSince(batch, rev);
+  if (stale2.length === 0) {
     return;
   }
-  const rows = await readRows2(hub, target2, stale);
-  for (const id of stale) {
+  const rows = await readRows2(hub, target2, stale2);
+  for (const id of stale2) {
     const row = rows.get(id);
     const answer2 = batch.answers.get(id);
     if (row === void 0 || answer2 === void 0) {
@@ -3100,17 +3210,17 @@ var StreamIndex = class {
    * changed row (any row of the service when `id` is absent), of the changed
    * user's sockets (every user's when `userId` is absent).
    */
-  matching(change) {
-    const key = change.id === void 0 ? void 0 : anchorKey(change.service, change.id);
-    const sockets = key === void 0 ? this.#byService.get(change.service) : this.#byAnchor.get(key);
+  matching(change2) {
+    const key = change2.id === void 0 ? void 0 : anchorKey(change2.service, change2.id);
+    const sockets = key === void 0 ? this.#byService.get(change2.service) : this.#byAnchor.get(key);
     const found = /* @__PURE__ */ new Map();
     for (const socket of sockets?.keys() ?? []) {
-      if (change.userId !== void 0 && socket.data.principal?.userId !== change.userId) {
+      if (change2.userId !== void 0 && socket.data.principal?.userId !== change2.userId) {
         continue;
       }
       const entries = this.entries(socket).filter(
         ({ anchors }) => anchors.some(
-          (anchor) => key === void 0 ? serviceOf(anchor) === change.service : anchor === key
+          (anchor) => key === void 0 ? serviceOf(anchor) === change2.service : anchor === key
         )
       );
       if (entries.length > 0) {
@@ -3224,30 +3334,30 @@ async function settleAll(work) {
     throw failed2.reason instanceof Error ? failed2.reason : new Error("A re-resolution failed", { cause: failed2.reason });
   }
 }
-function withRowState(hub, change) {
-  const { service, id } = change;
+function withRowState(hub, change2) {
+  const { service, id } = change2;
   if (id === void 0) {
-    return change;
+    return change2;
   }
   return {
-    ...change,
+    ...change2,
     rev: hub.changeLog.lastChange(service, id),
     removed: hub.changeLog.removed(service, id)
   };
 }
-async function broadcastChange(hub, change) {
-  await hub.broadcasts?.broadcast(ACCESS_CHANGED_EVENT, change);
+async function broadcastChange(hub, change2) {
+  await hub.broadcasts?.broadcast(ACCESS_CHANGED_EVENT, change2);
 }
 function createRevocation(hub, hooks = []) {
   return Object.freeze({
-    async changed(change, remote) {
+    async changed(change2, remote) {
       hub.subscriptions.accessChanges += 1;
-      const others = !remote && hub.io !== void 0 && !hub.probe.local() ? broadcastChange(hub, withRowState(hub, change)) : void 0;
-      const trustLog = !remote || change.removed !== void 0;
+      const others = !remote && hub.io !== void 0 && !hub.probe.local() ? broadcastChange(hub, withRowState(hub, change2)) : void 0;
+      const trustLog = !remote || change2.removed !== void 0;
       await settleAll([
         others,
-        reresolveAll(hub, hub.subscriptions.matching(change), trustLog),
-        ...hooks.map(async (hook) => await hook.changed(change))
+        reresolveAll(hub, hub.subscriptions.matching(change2), trustLog),
+        ...hooks.map(async (hook) => await hook.changed(change2))
       ]);
     },
     async regranted(userId) {
@@ -3288,24 +3398,24 @@ function readChange(value) {
     ...typeof userId === "string" && userId.length > 0 ? { userId } : {}
   };
 }
-function recordRowState(hub, change) {
-  if (change.id !== void 0 && change.rev !== void 0 && change.removed !== void 0) {
-    hub.changeLog.record(change.service, change.id, change.rev, change.removed);
+function recordRowState(hub, change2) {
+  if (change2.id !== void 0 && change2.rev !== void 0 && change2.removed !== void 0) {
+    hub.changeLog.record(change2.service, change2.id, change2.rev, change2.removed);
   }
 }
-function listenForChanges(hub, revocation, forget2) {
+function listenForChanges(hub, revocation, forget3) {
   if (hub.io === void 0) {
     return;
   }
   onNodeEvent(hub.io, hub.logger, ACCESS_CHANGED_EVENT, (broadcast, answer2) => {
-    const change = readChange(broadcast);
-    if (change === void 0) {
+    const change2 = readChange(broadcast);
+    if (change2 === void 0) {
       answer2(false);
       return;
     }
-    recordRowState(hub, change);
-    forget2(change);
-    revocation.changed(change, true).then(
+    recordRowState(hub, change2);
+    forget3(change2);
+    revocation.changed(change2, true).then(
       () => {
         answer2(true);
       },
@@ -3313,7 +3423,7 @@ function listenForChanges(hub, revocation, forget2) {
         answer2(false);
         hub.logger.error("Revoking for an access change another node broadcast failed", {
           category: "quickdraw.access",
-          service: change.service,
+          service: change2.service,
           error: describeError(error)
         });
       }
@@ -3346,6 +3456,12 @@ function streamTarget(hub, value, event) {
   if (stream === void 0) {
     throw new QuickdrawError("NOT_FOUND", `${frame.s} has no stream "${frame.stream}"`);
   }
+  if (stream.host) {
+    throw unreadable(
+      `${frame.s}.${frame.stream} is served by the room's host: subscribe over the link to the host of its room`,
+      ["stream"]
+    );
+  }
   const problem = scopeProblem(stream, frame.scope);
   if (problem !== void 0) {
     throw unreadable(problem, ["scope"]);
@@ -3391,7 +3507,9 @@ async function authorizeStream(hub, socket, target2) {
     signal: NEVER_ABORTED,
     log: hub.logger,
     requestId: crypto.randomUUID(),
-    transport: "socket"
+    transport: "socket",
+    // A custom form may ask about a row its scope names, as a method's does.
+    access: hub.policies
   });
   const input = { scope: target2.scope };
   await hub.access.authorize(form, {
@@ -3488,7 +3606,7 @@ async function reauthorizeAll(hub, index, found) {
 }
 function createStreamRevocation(hub, index) {
   return Object.freeze({
-    changed: async (change) => await reauthorizeAll(hub, index, index.matching(change)),
+    changed: async (change2) => await reauthorizeAll(hub, index, index.matching(change2)),
     regranted: async (sockets) => await reauthorizeAll(
       hub,
       index,
@@ -3877,17 +3995,17 @@ var ScopeIndex = class {
    * changed row (any row of the service when `id` is absent), of the changed
    * user's sockets (every user's when `userId` is absent).
    */
-  matching(change) {
-    const key = change.id === void 0 ? void 0 : anchorKey(change.service, change.id);
-    const sockets = key === void 0 ? this.#byService.get(change.service) : this.#byAnchor.get(key);
+  matching(change2) {
+    const key = change2.id === void 0 ? void 0 : anchorKey(change2.service, change2.id);
+    const sockets = key === void 0 ? this.#byService.get(change2.service) : this.#byAnchor.get(key);
     const found = /* @__PURE__ */ new Map();
     for (const socket of sockets?.keys() ?? []) {
-      if (change.userId !== void 0 && socket.data.principal?.userId !== change.userId) {
+      if (change2.userId !== void 0 && socket.data.principal?.userId !== change2.userId) {
         continue;
       }
       const entries = this.entries(socket).filter(
         ({ anchors }) => anchors.some(
-          (anchor) => key === void 0 ? serviceOf2(anchor) === change.service : anchor === key
+          (anchor) => key === void 0 ? serviceOf2(anchor) === change2.service : anchor === key
         )
       );
       if (entries.length > 0) {
@@ -4489,12 +4607,16 @@ async function allowedScopes(policies, rule, principal, scopes) {
   const allowed2 = /* @__PURE__ */ new Map();
   const { anchor, service } = rule;
   const anchorRow = (scope) => anchor === void 0 ? [] : [anchorKey(anchor, scope)];
-  if (service.adminBypass && serviceGrant(principal, service.name) === "Admin") {
+  const grant = serviceGrant(principal, service.name);
+  if (service.adminBypass && grant === "Admin") {
     for (const scope of scopes) {
       allowed2.set(scope, anchorRow(scope));
     }
     return allowed2;
   }
+  if (rule.requires !== void 0 && !meetsLevel(grant, rule.requires.service)) {
+    return allowed2;
+  }
   if (anchor === void 0) {
     for (const scope of scopes.filter((candidate) => candidate === principal.userId)) {
       allowed2.set(scope, []);
@@ -4519,7 +4641,8 @@ async function authorizeScopes(hub, collection, principal, scopes) {
   const rule = {
     service: collection.service,
     anchor: collection.anchorService?.name,
-    access: collection.access
+    access: collection.access,
+    requires: collection.requires
   };
   return await allowedScopes(hub.policies, rule, principal, scopes);
 }
@@ -4957,12 +5080,12 @@ function createConcurrencyLimiter(limits) {
       }
     };
   }
-  function enqueue(connectionId, lane, signal) {
+  function enqueue(connectionId, lane, signal2) {
     return new Promise((resolve, reject) => {
       const enqueuedAt = performance.now();
       const waiter = { grant };
       function grant() {
-        signal?.removeEventListener("abort", onAbort);
+        signal2?.removeEventListener("abort", onAbort);
         resolve(slot(connectionId, lane, performance.now() - enqueuedAt));
       }
       function onAbort() {
@@ -4973,13 +5096,13 @@ function createConcurrencyLimiter(limits) {
         dropIfIdle(connectionId, lane);
         reject(cancelledError());
       }
-      signal?.addEventListener("abort", onAbort, { once: true });
+      signal2?.addEventListener("abort", onAbort, { once: true });
       lane.queue.push(waiter);
     });
   }
   return {
-    acquire(connectionId, signal) {
-      if (signal?.aborted === true) {
+    acquire(connectionId, signal2) {
+      if (signal2?.aborted === true) {
         return Promise.reject(cancelledError());
       }
       let lane = lanes.get(connectionId);
@@ -4997,7 +5120,7 @@ function createConcurrencyLimiter(limits) {
           new QuickdrawError("RATE_LIMITED", message, { retryAfterMs: limits.retryAfterMs })
         );
       }
-      return enqueue(connectionId, lane, signal);
+      return enqueue(connectionId, lane, signal2);
     },
     get connections() {
       return lanes.size;
@@ -5111,14 +5234,14 @@ function answerEvent(socket, context, event, work) {
 }
 
 // src/server/collections/requests.ts
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isName2(value) {
   return typeof value === "string" && value.length > 0;
 }
 function readRef(frame, event) {
-  if (!isRecord5(frame) || !isName2(frame.s) || !isName2(frame.c) || !isName2(frame.scope)) {
+  if (!isRecord6(frame) || !isName2(frame.s) || !isName2(frame.c) || !isName2(frame.scope)) {
     throw unreadable(`A ${event} frame needs { s, c, scope } with each a non-empty string`);
   }
   if (frame.scope.length > MAX_SCOPE_LENGTH) {
@@ -5565,7 +5688,7 @@ function raiseFloor(hub, collection, userId) {
     hub.collections.buffer.skipAll(groupOf(s, collection.name));
     return;
   }
-  hub.collections.buffer.skip(roomOf({ s, c: collection.name, scope: userId }), currentRev());
+  hub.collections.buffer.reset(roomOf({ s, c: collection.name, scope: userId }), currentRev());
 }
 function logFailure(hub, collection, error) {
   hub.logger.error("Checking a self scope's rows again failed; the scope is reset", {
@@ -5608,33 +5731,38 @@ async function removeUnreadable(hub, io, collection, scope, id) {
     await resetScope(hub, io, collection, scope);
   }
 }
-function recheckScopes(hub, io, collection, change) {
-  const own = change.service === collection.service.name ? change.id : void 0;
-  return hub.collections.scopes.scopes(collection.service.name, collection.name).filter((scope) => change.userId === void 0 || scope === change.userId).map(
+function recheckScopes(hub, io, collection, change2) {
+  const own = change2.service === collection.service.name ? change2.id : void 0;
+  return hub.collections.scopes.scopes(collection.service.name, collection.name).filter((scope) => change2.userId === void 0 || scope === change2.userId).map(
     (scope) => own === void 0 ? resetScope(hub, io, collection, scope) : removeUnreadable(hub, io, collection, scope, own)
   );
 }
-async function recheckSelf(hub, change) {
-  if (change.id !== void 0 && change.userId === void 0) {
+async function recheckSelf(hub, change2) {
+  if (change2.id !== void 0 && change2.userId === void 0) {
     return;
   }
   const { io } = hub;
   const work = [];
   for (const collection of selfCollections(hub)) {
-    if (!policyServices(hub, collection.service).has(change.service)) {
+    if (!policyServices(hub, collection.service).has(change2.service)) {
       continue;
     }
-    raiseFloor(hub, collection, change.userId);
+    raiseFloor(hub, collection, change2.userId);
     if (io !== void 0) {
-      work.push(...recheckScopes(hub, io, collection, change));
+      work.push(...recheckScopes(hub, io, collection, change2));
     }
   }
   await Promise.all(work);
 }
-async function resetSelf(hub, sockets, userId) {
-  for (const collection of userId === void 0 ? [] : selfCollections(hub)) {
+function raiseSelfFloors(hub, userId) {
+  for (const collection of selfCollections(hub)) {
     raiseFloor(hub, collection, userId);
   }
+}
+async function resetSelf(hub, sockets, userId) {
+  if (userId !== void 0) {
+    raiseSelfFloors(hub, userId);
+  }
   const { io } = hub;
   if (io === void 0) {
     return;
@@ -5717,17 +5845,22 @@ async function reauthorizeAll2(hub, found) {
 }
 function createScopeRevocation(hub) {
   return Object.freeze({
-    changed: async (change) => {
+    changed: async (change2) => {
       await settleAll([
-        reauthorizeAll2(hub, hub.collections.scopes.matching(change)),
-        recheckSelf(hub, change)
+        reauthorizeAll2(hub, hub.collections.scopes.matching(change2)),
+        recheckSelf(hub, change2)
       ]);
     },
     regranted: async (sockets, userId) => {
+      raiseSelfFloors(hub, userId);
       const found = new Map(
         sockets.map((socket) => [socket, hub.collections.scopes.entries(socket)])
       );
-      await settleAll([reauthorizeAll2(hub, found), resetSelf(hub, sockets, userId)]);
+      try {
+        await reauthorizeAll2(hub, found);
+      } finally {
+        await resetSelf(hub, sockets, userId);
+      }
     }
   });
 }
@@ -5762,13 +5895,13 @@ function createLiveCollections(hub) {
 }
 
 // src/server/realtime/events.ts
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function payloadSchemaOf(contract, event) {
-  const events = isRecord6(contract) ? contract.events : void 0;
-  if (!isRecord6(events) || typeof event !== "string" || !Object.hasOwn(events, event)) {
-    const name = isRecord6(contract) ? String(contract.name) : "the contract";
+  const events = isRecord7(contract) ? contract.events : void 0;
+  if (!isRecord7(events) || typeof event !== "string" || !Object.hasOwn(events, event)) {
+    const name = isRecord7(contract) ? String(contract.name) : "the contract";
     throw new TypeError(`ctx.rooms.emit: ${name} declares no event "${String(event)}"`);
   }
   return events[event];
@@ -5805,6 +5938,304 @@ function createRoomEvents(hub) {
   });
 }
 
+// src/server/realtime/roomNames.ts
+function checkRoom2(room) {
+  if (typeof room !== "string" || room === "" || room.length > MAX_SCOPE_LENGTH) {
+    throw unreadable(`A room name is a string of 1 to ${MAX_SCOPE_LENGTH} characters`);
+  }
+  if (RESERVED_ROOM_PREFIXES.some((prefix) => room.startsWith(prefix))) {
+    throw unreadable(
+      `Room "${room}" is reserved: rooms starting with ${RESERVED_ROOM_PREFIXES.join(" or ")} are joined only through their own subscriptions`
+    );
+  }
+  if (socketIdShaped(room)) {
+    throw unreadable(
+      `Room "${room}" has the shape of a Socket.IO socket id (20 letters, digits, "_" or "-"): every socket is alone in the room of its id, so an app room never has that shape; give it a prefix ("doc:${room}")`
+    );
+  }
+}
+
+// src/server/realtime/hosts.ts
+var ROOM_HOST_EVENT = "quickdraw:room-host";
+var ROOM_HOSTS_EVENT = "quickdraw:room-hosts";
+var MAX_CLEARED = 1e4;
+var MICROS_PER_MS = 1e3;
+function wins(record, other) {
+  return other === void 0 || record.version > other.version || record.version === other.version && record.host > other.host;
+}
+function stale(state, room, record) {
+  const cleared = state.cleared.get(room);
+  return cleared !== void 0 && !wins(record, cleared);
+}
+function observe(state, version) {
+  state.clock = Math.max(state.clock, version);
+}
+function nextVersion(state) {
+  state.clock = Math.max(Date.now() * MICROS_PER_MS, state.clock + 1);
+  return state.clock;
+}
+function tell(state, room, host) {
+  state.hub.io?.local.to(room).emit(SERVER_EVENTS.host, [room, host]);
+}
+function apply(state, room, record) {
+  if (stale(state, room, record) || !wins(record, state.hosts.get(room))) {
+    return false;
+  }
+  state.hosts.set(room, record);
+  tell(state, room, record.host);
+  return true;
+}
+function forget2(state, room, cleared) {
+  const current = state.hosts.get(room);
+  if (current !== void 0 && !wins(current, cleared)) {
+    state.hosts.delete(room);
+    tell(state, room, null);
+  }
+  const known = state.cleared.get(room);
+  if (known === void 0 || wins(cleared, known)) {
+    state.cleared.delete(room);
+    state.cleared.set(room, cleared);
+    const oldest = state.cleared.size > MAX_CLEARED ? state.cleared.keys().next().value : void 0;
+    if (oldest !== void 0) {
+      state.cleared.delete(oldest);
+    }
+  }
+}
+function publish(state, room, host, record) {
+  const { io } = state.hub;
+  if (io !== void 0 && !state.hub.probe.local()) {
+    const was = host === null ? { was: record.host } : {};
+    emitToNodes(io, ROOM_HOST_EVENT, { room, host, version: record.version, ...was });
+  }
+}
+function change(state, room, host) {
+  const record = { host, version: nextVersion(state) };
+  apply(state, room, record);
+  publish(state, room, host, record);
+}
+function repair(state, room, record) {
+  const current = state.hosts.get(room);
+  const cleared = state.cleared.get(room);
+  if (cleared !== void 0 && wins(cleared, current)) {
+    if (wins(cleared, record)) {
+      publish(state, room, null, cleared);
+    }
+  } else if (current !== void 0 && wins(current, record)) {
+    publish(state, room, current.host, current);
+  }
+}
+function clear(state, room) {
+  const current = state.hosts.get(room);
+  if (current !== void 0) {
+    forget2(state, room, current);
+    publish(state, room, null, current);
+  }
+}
+function setHost(state, socket, room) {
+  checkRoom2(room);
+  if (!state.served()) {
+    throw new QuickdrawError(
+      "INTERNAL",
+      "ctx.rooms.setHost: host mode runs over peer links; create the server with peers: true"
+    );
+  }
+  if (!socket.connected) {
+    return false;
+  }
+  const joined = socket.data.appRooms;
+  if (joined === void 0 || !Object.hasOwn(joined, room)) {
+    throw new QuickdrawError("FORBIDDEN", `Only a socket in room "${room}" can host it`);
+  }
+  if (socket.data.principal === null) {
+    throw new QuickdrawError("UNAUTHENTICATED", "Sign in to host a room");
+  }
+  if (state.hosts.get(room)?.host !== socket.id) {
+    change(state, room, socket.id);
+  }
+  return true;
+}
+function hostLeft(state, socket, room, reason) {
+  clear(state, room);
+  const { hooks, run: run2 } = state;
+  if (run2 === void 0) {
+    return;
+  }
+  const leave2 = {
+    room,
+    socketId: socket.id,
+    principal: socket.data.principal ?? null,
+    reason
+  };
+  for (const { owner, handler } of hooks) {
+    const ran = run2(async (ctx) => {
+      await handler(leave2, ctx);
+    }).catch((error) => {
+      state.hub.logger.error("onHostLeave threw", {
+        category: "quickdraw.rooms",
+        owner,
+        room,
+        socketId: socket.id,
+        reason,
+        error: describeError(error)
+      });
+    });
+    track(state.hub, ran);
+  }
+}
+var isVersion = (version) => Number.isSafeInteger(version) && version > 0;
+function readChange2(payload) {
+  const { room, host, version, was } = payload ?? {};
+  if (!isRoomName(room) || !isVersion(version)) {
+    return void 0;
+  }
+  if (host === null) {
+    return isSocketId(was) ? { room, host, record: { host: was, version } } : void 0;
+  }
+  return isSocketId(host) ? { room, host, record: { host, version } } : void 0;
+}
+function merge(state, answers) {
+  for (const answer2 of Array.isArray(answers) ? answers : []) {
+    const { hosts, clock } = answer2 ?? {};
+    if (isVersion(clock)) {
+      observe(state, clock);
+    }
+    for (const entry of Array.isArray(hosts) ? hosts : []) {
+      const [room, host, version] = Array.isArray(entry) ? entry : [];
+      if (isRoomName(room) && isSocketId(host) && isVersion(version)) {
+        observe(state, version);
+        apply(state, room, { host, version });
+      }
+    }
+  }
+}
+var HOSTS_BY_IO = /* @__PURE__ */ new WeakMap();
+function subscriberOf(io) {
+  const adapter = io.sockets.adapter;
+  const client = adapter?.subClient;
+  if (typeof client !== "object" || client === null) {
+    return void 0;
+  }
+  const { ping, isCluster, masters } = client;
+  const cluster = isCluster === true || Array.isArray(masters);
+  return typeof ping === "function" && !cluster ? client : void 0;
+}
+async function ask(state, io, timeoutMs) {
+  try {
+    merge(
+      state,
+      await within(io.serverSideEmitWithAck(ROOM_HOSTS_EVENT, tagged(io, {})), timeoutMs)
+    );
+  } catch {
+  }
+}
+function pause(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+function seed(state) {
+  const { io } = state.hub;
+  if (io === void 0 || state.hub.probe.local()) {
+    return;
+  }
+  const timeoutMs = state.hub.cluster?.timeoutMs ?? DEFAULT_CLUSTER_TIMEOUT_MS;
+  const twice = async () => {
+    await ask(state, io, timeoutMs);
+    await pause(timeoutMs);
+    await ask(state, io, timeoutMs);
+  };
+  const subscriber = subscriberOf(io);
+  if (subscriber === void 0) {
+    void twice();
+    return;
+  }
+  void within(
+    Promise.resolve().then(() => subscriber.ping()),
+    timeoutMs
+  ).then(async () => {
+    await ask(state, io, timeoutMs);
+  }, twice);
+}
+function listen(state) {
+  const { io } = state.hub;
+  if (io === void 0) {
+    return;
+  }
+  onNodeEvent(io, state.hub.logger, ROOM_HOST_EVENT, (payload) => {
+    const read = readChange2(payload);
+    if (read === void 0) {
+      return;
+    }
+    observe(state, read.record.version);
+    if (read.host === null) {
+      forget2(state, read.room, read.record);
+    } else if (!apply(state, read.room, read.record)) {
+      repair(state, read.room, read.record);
+    }
+  });
+  onNodeEvent(
+    io,
+    state.hub.logger,
+    ROOM_HOSTS_EVENT,
+    (_payload, answer2) => {
+      answer2({
+        hosts: [...state.hosts].filter(([, record]) => io.sockets.sockets.has(record.host)).map(([room, record]) => [room, record.host, record.version]),
+        clock: state.clock
+      });
+    },
+    { hosts: [] }
+  );
+  HOSTS_BY_IO.set(io, state);
+  seed(state);
+}
+function seedRoomHosts(io) {
+  const state = HOSTS_BY_IO.get(io);
+  if (state !== void 0) {
+    seed(state);
+  }
+}
+function createRoomHosts(hub, served) {
+  const state = {
+    hub,
+    served,
+    hosts: /* @__PURE__ */ new Map(),
+    cleared: /* @__PURE__ */ new Map(),
+    clock: 0,
+    hooks: [],
+    run: void 0
+  };
+  return Object.freeze({
+    set: (socket, room) => setHost(state, socket, room),
+    of(room) {
+      checkRoom2(room);
+      return state.hosts.get(room)?.host ?? null;
+    },
+    clear(room) {
+      checkRoom2(room);
+      clear(state, room);
+    },
+    joined(socket, room) {
+      const record = state.hosts.get(room);
+      if (record !== void 0) {
+        socket.emit(SERVER_EVENTS.host, [room, record.host]);
+      }
+    },
+    left(socket, room, reason) {
+      if (state.hosts.get(room)?.host === socket.id) {
+        hostLeft(state, socket, room, reason);
+      }
+    },
+    onLeave(hooks, run2) {
+      state.hooks = hooks;
+      state.run = run2;
+    },
+    listen: () => {
+      listen(state);
+    }
+  });
+}
+
 // src/server/realtime/roomFrames.ts
 function logFailure2(state, room, error) {
   state.hub.logger.error("Reading a room's presence from the cluster failed", {
@@ -5878,25 +6309,11 @@ function exited(state, socket, room, told, everywhere = false) {
   return last;
 }
 
-// src/server/realtime/roomNames.ts
-function checkRoom2(room) {
-  if (typeof room !== "string" || room === "" || room.length > MAX_SCOPE_LENGTH) {
-    throw unreadable(`A room name is a string of 1 to ${MAX_SCOPE_LENGTH} characters`);
-  }
-  if (RESERVED_ROOM_PREFIXES.some((prefix) => room.startsWith(prefix))) {
-    throw unreadable(
-      `Room "${room}" is reserved: rooms starting with ${RESERVED_ROOM_PREFIXES.join(" or ")} are joined only through their own subscriptions`
-    );
-  }
-  if (socketIdShaped(room)) {
-    throw unreadable(
-      `Room "${room}" has the shape of a Socket.IO socket id (20 letters, digits, "_" or "-"): every socket is alone in the room of its id, so an app room never has that shape; give it a prefix ("doc:${room}")`
-    );
-  }
-}
-
 // src/server/realtime/leaving.ts
 var ROOM_LEAVE_EVENT = "quickdraw:room-leave";
+function leavingState(base, left, served) {
+  return { ...base, listener: void 0, left, hosts: createRoomHosts(base.hub, served) };
+}
 function leaveListener(hooks, run2, logger) {
   return async (leave2) => {
     await Promise.all(
@@ -5948,6 +6365,7 @@ function leaveRoom(state, socket, room, reason) {
     state.left?.(socket);
   }
   const last = exited(state, socket, room, socket.connected, reason === "removed");
+  state.hosts.left(socket, room, reason);
   heard(state, socket, reason, [[room, last]]);
   return true;
 }
@@ -5955,6 +6373,9 @@ function leaveAll(state, socket) {
   const left = Object.keys(socket.data.appRooms ?? {}).map(
     (room) => [room, exited(state, socket, room, false)]
   );
+  for (const [room] of left) {
+    state.hosts.left(socket, room, "disconnect");
+  }
   socket.data.appRooms = emptyRecords();
   heard(state, socket, "disconnect", left);
 }
@@ -6018,6 +6439,7 @@ function join3(state, socket, room) {
   joined[room] = true;
   void socket.join(room);
   entered(state, socket, room);
+  state.hosts.joined(socket, room);
   return true;
 }
 function sizeOf(state, room) {
@@ -6033,21 +6455,38 @@ function leaveOf(own, removal) {
     return own(room);
   });
 }
-function createRooms(base, left) {
-  const state = { ...base, listener: void 0, left };
+function createRooms(base, left, served = () => false) {
+  const state = leavingState(base, left, served);
   const events = createRoomEvents(state.hub);
   const removal = (room, target2) => removeUser(state, room, target2);
   const size = (room) => sizeOf(state, room);
-  const server = Object.freeze({ ...events, leave: removal, size });
+  const { hosts } = state;
+  const hostOf = (room) => hosts.of(room);
+  const clearHost = (room) => {
+    hosts.clear(room);
+  };
+  const server = Object.freeze({
+    ...events,
+    leave: removal,
+    size,
+    hostOf,
+    clearHost
+  });
   const bySocket = /* @__PURE__ */ new WeakMap();
   const detached = Object.freeze({
     ...events,
     size,
+    hostOf,
+    clearHost,
     join: (room) => {
       checkRoom2(room);
       return false;
     },
-    leave: leaveOf(() => false, removal)
+    leave: leaveOf(() => false, removal),
+    setHost: (room) => {
+      checkRoom2(room);
+      return false;
+    }
   });
   return Object.freeze({
     of(socket) {
@@ -6056,8 +6495,11 @@ function createRooms(base, left) {
         rooms = Object.freeze({
           ...events,
           size,
+          hostOf,
+          clearHost,
           join: (room) => join3(state, socket, room),
-          leave: leaveOf((room) => leaveRoom(state, socket, room, "leave"), removal)
+          leave: leaveOf((room) => leaveRoom(state, socket, room, "leave"), removal),
+          setHost: (room) => hosts.set(socket, room)
         });
         bySocket.set(socket, rooms);
       }
@@ -6076,8 +6518,10 @@ function createRooms(base, left) {
     onLeave(hooks, run2) {
       state.listener = hooks.length === 0 ? void 0 : leaveListener(hooks, run2, state.hub.logger);
     },
+    hosts,
     listen() {
       listenForRemovals(state);
+      hosts.listen();
     }
   });
 }
@@ -6091,6 +6535,7 @@ function unjoinable(rooms, share) {
   return Object.freeze({
     ...rooms,
     join: () => refuse2("join"),
+    setHost: () => refuse2("setHost"),
     leave: ((room, target2) => target2 === void 0 ? refuse2("leave") : rooms.leave(room, target2))
   });
 }
@@ -6205,6 +6650,11 @@ function servedStream(hub, contract, name) {
   if (stream === void 0) {
     throw new TypeError(`stream: ${service.name} has no stream "${String(name)}"`);
   }
+  if (stream.host) {
+    throw new TypeError(
+      `stream: ${service.name}.${stream.name} is served by the room's host (serve: "host"): its host's client pushes it, with defineHost; the server cannot`
+    );
+  }
   return { service, stream };
 }
 function feedOf(served, method, what, args) {
@@ -6238,7 +6688,17 @@ function pushMany(hub, seeds, served, args) {
   );
   sendItems(hub, seeds, served, feed, checked);
 }
-function createStreams(hub) {
+async function subscribers(served, count3, args) {
+  const { service, stream } = served;
+  const scope = args[0];
+  const problem = scopeProblem(stream, scope);
+  if (problem !== void 0 || args.length !== (stream.scoped ? 1 : 0)) {
+    const usage = stream.scoped ? "pass (scope)" : "pass no argument";
+    throw new TypeError(`${service.name}.${stream.name}.subscribers: ${problem ?? usage}`);
+  }
+  return await count3(streamRoom(service.name, stream.name, scope));
+}
+function createStreams(hub, count3) {
   const seeds = new StreamSeeds();
   const feeds = createStreamFeeds(hub, seeds);
   return Object.freeze({
@@ -6250,7 +6710,8 @@ function createStreams(hub) {
         },
         pushMany: (...args) => {
           pushMany(hub, seeds, served, args);
-        }
+        },
+        subscribers: (...args) => subscribers(served, count3, args)
       });
     },
     extension: feeds.extension,
@@ -6263,12 +6724,25 @@ function createStreams(hub) {
 }
 
 // src/server/realtime/realtime.ts
-function createRealtime(hub) {
+function createRealtime(hub, peers) {
   const state = createPresenceState(hub);
   const presence = createPresence(state);
-  const streams = createStreams(hub);
-  const rooms = createRooms(state, streams.leftRooms);
-  const channels = channelMessages({ hub, rooms, presence, warned: /* @__PURE__ */ new WeakSet() });
+  const streams = createStreams(hub, (room) => socketsInRoom(state, room));
+  const rooms = createRooms(
+    state,
+    (socket) => {
+      streams.leftRooms(socket);
+      peers?.left(socket);
+    },
+    () => peers?.served() ?? false
+  );
+  const channels = channelMessages({
+    hub,
+    rooms,
+    presence,
+    warned: /* @__PURE__ */ new WeakSet(),
+    hostWarned: /* @__PURE__ */ new Set()
+  });
   return Object.freeze({
     extension(socket, context) {
       channels(socket);
@@ -6287,6 +6761,9 @@ function createRealtime(hub) {
     onRoomLeave: (hooks, run2) => {
       rooms.onLeave(hooks, run2);
     },
+    onHostLeave: (hooks, run2) => {
+      rooms.hosts.onLeave(hooks, run2);
+    },
     roomsFor(transport, connectionId, share) {
       const socket = (transport === "socket" || transport === "legacy") && connectionId !== void 0 ? hub.io?.sockets.sockets.get(connectionId) : void 0;
       const own = socket === void 0 ? rooms.detached : rooms.of(socket);
@@ -6306,6 +6783,398 @@ function createRealtime(hub) {
   });
 }
 
+// src/server/realtime/peerFrames.ts
+var SIGNAL_SHAPE = "A qd:peer frame needs { room, to, sig }: an app room, another socket's id, and a signal holding one of sdp, ice, relay: true or bye: true";
+function readSignalFrame(frame, self) {
+  if (!isRecord(frame) || !isRoomName(frame.room) || !isSocketId(frame.to)) {
+    throw unreadable(SIGNAL_SHAPE);
+  }
+  if (frame.to === self) {
+    throw unreadable("A socket cannot link to itself", ["to"]);
+  }
+  const sig = readSignal(frame.sig);
+  if (sig === void 0) {
+    throw unreadable(SIGNAL_SHAPE, ["sig"]);
+  }
+  return { room: frame.room, to: frame.to, sig };
+}
+function messageBytes(text) {
+  if (text.length > MAX_PEER_MESSAGE_BYTES) {
+    return void 0;
+  }
+  const bytes = utf8ByteLength(text);
+  return bytes > MAX_PEER_MESSAGE_BYTES ? void 0 : bytes;
+}
+function readRelayFrame(frame) {
+  if (!Array.isArray(frame)) {
+    return void 0;
+  }
+  const [room, to, label, text] = frame;
+  if (!isRoomName(room) || !isSocketId(to) || !isPeerLabel(label) || typeof text !== "string") {
+    return void 0;
+  }
+  const bytes = messageBytes(text);
+  return bytes === void 0 ? void 0 : { room, to, label, text, bytes };
+}
+function readForwardedSignal(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const { room, to, from, userId } = value;
+  const sig = readSignal(value.sig);
+  if (!isRoomName(room) || !isSocketId(to) || !isSocketId(from) || sig === void 0) {
+    return void 0;
+  }
+  return typeof userId === "string" && userId !== "" ? { room, to, from, userId, sig } : void 0;
+}
+function readForwardedRelay(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const { room, to, from, label, text } = value;
+  if (!isRoomName(room) || !isSocketId(to) || !isSocketId(from) || !isPeerLabel(label)) {
+    return void 0;
+  }
+  return typeof text === "string" && messageBytes(text) !== void 0 ? { room, to, from, label, text } : void 0;
+}
+
+// src/server/realtime/peerState.ts
+var MAX_HEARD = MAX_PEER_LINKS * 2;
+var STATES = /* @__PURE__ */ new WeakMap();
+function bucket(tokens, now) {
+  return { tokens, refilledAt: now };
+}
+function peersOf(socket, now = Date.now()) {
+  let state = STATES.get(socket);
+  if (state === void 0) {
+    state = {
+      socket,
+      signals: bucket(PEER_SIGNAL_BURST, now),
+      bytes: bucket(PEER_RELAY_BYTES_BURST, now),
+      links: /* @__PURE__ */ new Map(),
+      count: 0,
+      heard: /* @__PURE__ */ new Map(),
+      signalDrops: { windowStart: now, dropped: 0 },
+      relayDrops: { windowStart: now, dropped: 0 }
+    };
+    STATES.set(socket, state);
+  }
+  return state;
+}
+function knownPeers(socket) {
+  return STATES.get(socket);
+}
+function take2(state, rate, burst, now, cost = 1) {
+  state.tokens = Math.min(burst, state.tokens + (now - state.refilledAt) / 1e3 * rate);
+  state.refilledAt = now;
+  if (state.tokens < cost) {
+    return false;
+  }
+  state.tokens -= cost;
+  return true;
+}
+function takeSignal(state, now) {
+  return take2(state.signals, PEER_SIGNAL_RATE, PEER_SIGNAL_BURST, now);
+}
+function signalWaitMs(state) {
+  return Math.ceil((1 - state.signals.tokens) / PEER_SIGNAL_RATE * 1e3);
+}
+function takeRelay(state, pair, bytes, now) {
+  if (!take2(pair, PEER_RELAY_RATE, PEER_RELAY_BURST, now)) {
+    return false;
+  }
+  return take2(state.bytes, PEER_RELAY_BYTES_PER_SECOND, PEER_RELAY_BYTES_BURST, now, bytes);
+}
+function abusive2(drops, rate, now) {
+  if (now - drops.windowStart > CHANNEL_ABUSE_WINDOW_MS) {
+    drops.windowStart = now;
+    drops.dropped = 0;
+  }
+  drops.dropped += 1;
+  return drops.dropped > rate * CHANNEL_ABUSE_MULTIPLIER;
+}
+function signalFlood(state, now) {
+  return abusive2(state.signalDrops, PEER_SIGNAL_RATE, now);
+}
+function relayFlood(state, now) {
+  return abusive2(state.relayDrops, PEER_RELAY_RATE, now);
+}
+function pairOf(state, room, peer) {
+  return state.links.get(room)?.get(peer);
+}
+var heardKey = (room, peer) => `${room}\0${peer}`;
+function hear(state, room, peer) {
+  const pair = pairOf(state, room, peer);
+  if (pair !== void 0) {
+    pair.mutual = true;
+    return;
+  }
+  const key = heardKey(room, peer);
+  state.heard.delete(key);
+  state.heard.set(key, [room, peer]);
+  if (state.heard.size > MAX_HEARD) {
+    const [oldest] = state.heard.keys();
+    if (oldest !== void 0) {
+      state.heard.delete(oldest);
+    }
+  }
+}
+function engage(state, room, peer, now) {
+  if (pairOf(state, room, peer) !== void 0) {
+    return true;
+  }
+  if (state.count >= MAX_PEER_LINKS) {
+    return false;
+  }
+  let peers = state.links.get(room);
+  if (peers === void 0) {
+    peers = /* @__PURE__ */ new Map();
+    state.links.set(room, peers);
+  }
+  const mutual = state.heard.delete(heardKey(room, peer));
+  peers.set(peer, { ...bucket(PEER_RELAY_BURST, now), mutual });
+  state.count += 1;
+  return true;
+}
+function disengage(state, room, peer) {
+  state.heard.delete(heardKey(room, peer));
+  const peers = state.links.get(room);
+  if (peers?.delete(peer) === true) {
+    state.count -= 1;
+    if (peers.size === 0) {
+      state.links.delete(room);
+    }
+  }
+}
+function disengageAll(state, ended = () => true) {
+  const gone = [];
+  for (const [room, peers] of state.links) {
+    if (ended(room)) {
+      for (const peer of peers.keys()) {
+        gone.push([room, peer]);
+      }
+      state.links.delete(room);
+      state.count -= peers.size;
+    }
+  }
+  for (const [key, entry] of state.heard) {
+    if (ended(entry[0])) {
+      state.heard.delete(key);
+      gone.push(entry);
+    }
+  }
+  return gone;
+}
+function inRoom2(socket, room) {
+  return ownRecord(socket.data.appRooms, room) !== void 0;
+}
+function reachable(socket, room) {
+  return socket.connected && socket.data.protocol !== "legacy" && socket.data.principal !== null && inRoom2(socket, room);
+}
+
+// src/server/realtime/peerDelivery.ts
+var PEER_SIGNAL_EVENT = "quickdraw:peer";
+var PEER_RELAY_EVENT = "quickdraw:relay";
+function localSocket(hub, id) {
+  return hub.io?.sockets.sockets.get(id);
+}
+function clusterOf(hub) {
+  return hub.probe.local() ? void 0 : hub.io;
+}
+function emitSignal(target2, frame) {
+  target2.emit(SERVER_EVENTS.peer, frame);
+  if (frame.sig.bye !== true) {
+    hear(peersOf(target2), frame.room, frame.from);
+    return;
+  }
+  const state = knownPeers(target2);
+  if (state !== void 0) {
+    disengage(state, frame.room, frame.from);
+  }
+}
+var waiting = /* @__PURE__ */ new WeakMap();
+function emitRelay(target2, frame) {
+  const count3 = waiting.get(target2) ?? 0;
+  if (frame[2] === "fast" && count3 >= PEER_RELAY_FAST_BACKLOG) {
+    return;
+  }
+  if (count3 === 0) {
+    target2.conn.once("drain", () => {
+      waiting.delete(target2);
+    });
+  }
+  waiting.set(target2, count3 + 1);
+  target2.emit(SERVER_EVENTS.relay, frame);
+}
+function sendSignal(hub, to, frame) {
+  const target2 = localSocket(hub, to);
+  if (target2 !== void 0) {
+    if (reachable(target2, frame.room)) {
+      emitSignal(target2, frame);
+    }
+    return;
+  }
+  const io = clusterOf(hub);
+  if (io !== void 0) {
+    emitToNodes(io, PEER_SIGNAL_EVENT, { ...frame, to });
+  }
+}
+function sendRelay(hub, to, frame) {
+  const target2 = localSocket(hub, to);
+  if (target2 !== void 0) {
+    if (reachable(target2, frame[0])) {
+      emitRelay(target2, frame);
+    }
+    return;
+  }
+  const io = clusterOf(hub);
+  if (io !== void 0) {
+    const [room, from, label, text] = frame;
+    emitToNodes(io, PEER_RELAY_EVENT, { room, to, from, label, text });
+  }
+}
+function sayGoodbye(hub, state, ended) {
+  const { socket } = state;
+  const userId = socket.data.principal?.userId;
+  for (const [room, peer] of disengageAll(state, ended)) {
+    if (userId !== void 0) {
+      sendSignal(hub, peer, { room, from: socket.id, userId, sig: { bye: true } });
+    }
+  }
+}
+function listenForPeers(hub) {
+  const { io } = hub;
+  if (io === void 0) {
+    return;
+  }
+  onNodeEvent(io, hub.logger, PEER_SIGNAL_EVENT, (payload) => {
+    const signal2 = readForwardedSignal(payload);
+    const target2 = signal2 === void 0 ? void 0 : localSocket(hub, signal2.to);
+    if (signal2 !== void 0 && target2 !== void 0 && reachable(target2, signal2.room)) {
+      const { room, from, userId, sig } = signal2;
+      emitSignal(target2, { room, from, userId, sig });
+    }
+  });
+  onNodeEvent(io, hub.logger, PEER_RELAY_EVENT, (payload) => {
+    const relay2 = readForwardedRelay(payload);
+    const target2 = relay2 === void 0 ? void 0 : localSocket(hub, relay2.to);
+    if (relay2 !== void 0 && target2 !== void 0 && reachable(target2, relay2.room)) {
+      emitRelay(target2, [relay2.room, relay2.from, relay2.label, relay2.text]);
+    }
+  });
+}
+
+// src/server/realtime/peers.ts
+var OK = Object.freeze({ ok: true });
+function flooded2(hub, state, event) {
+  hub.logger.warn(`Disconnecting socket ${state.socket.id} for sustained flooding of ${event}`, {
+    category: "quickdraw.peer",
+    userId: state.socket.data.principal?.userId
+  });
+  state.socket.disconnect(true);
+}
+function overRate(hub, state, now) {
+  if (signalFlood(state, now)) {
+    flooded2(hub, state, CLIENT_EVENTS.peer);
+  }
+  return new QuickdrawError("RATE_LIMITED", "Too many peer signals from this socket", {
+    retryAfterMs: signalWaitMs(state)
+  });
+}
+function signal(hub, state, frame) {
+  const { socket } = state;
+  const { room, to, sig } = readSignalFrame(frame, socket.id);
+  const now = Date.now();
+  if (!takeSignal(state, now)) {
+    if (sig.bye === true) {
+      disengage(state, room, to);
+    }
+    throw overRate(hub, state, now);
+  }
+  const { principal } = socket.data;
+  if (principal === null) {
+    throw new QuickdrawError("UNAUTHENTICATED", "Sign in to signal a peer");
+  }
+  if (!inRoom2(socket, room)) {
+    throw new QuickdrawError("FORBIDDEN", `This socket is not in room "${room}"`);
+  }
+  const forward = { room, from: socket.id, userId: principal.userId, sig };
+  if (sig.bye === true) {
+    disengage(state, room, to);
+    sendSignal(hub, to, forward);
+    return OK;
+  }
+  const target2 = localSocket(hub, to);
+  if (target2 === void 0 ? clusterOf(hub) === void 0 : !reachable(target2, room)) {
+    disengage(state, room, to);
+    throw new QuickdrawError("NOT_FOUND", `No signed-in socket ${to} is in room "${room}"`);
+  }
+  if (!engage(state, room, to, now)) {
+    throw new QuickdrawError(
+      "CONFLICT",
+      `A socket may signal at most ${MAX_PEER_LINKS} peers at once; close a link first`
+    );
+  }
+  sendSignal(hub, to, forward);
+  return OK;
+}
+function relay(hub, state, frame) {
+  const now = Date.now();
+  const read = readRelayFrame(frame);
+  const pair = read === void 0 ? void 0 : pairOf(state, read.room, read.to);
+  if (read === void 0 || pair?.mutual !== true || !inRoom2(state.socket, read.room) || !takeRelay(state, pair, read.bytes, now)) {
+    if (relayFlood(state, now)) {
+      flooded2(hub, state, CLIENT_EVENTS.relay);
+    }
+    return;
+  }
+  sendRelay(hub, read.to, [read.room, state.socket.id, read.label, read.text]);
+}
+function createPeerLinks(hub) {
+  let served = false;
+  return Object.freeze({
+    extension(socket, context) {
+      socket.on(CLIENT_EVENTS.peer, (frame, ack) => {
+        answerNow(
+          socket,
+          context,
+          CLIENT_EVENTS.peer,
+          ack,
+          () => signal(hub, peersOf(socket), frame)
+        );
+      });
+      socket.on(CLIENT_EVENTS.relay, (frame) => {
+        try {
+          relay(hub, peersOf(socket), frame);
+        } catch (error) {
+          hub.logger.error("A relay message failed", {
+            category: "quickdraw.peer",
+            socketId: socket.id,
+            error: describeError(error)
+          });
+        }
+      });
+      onDisconnect(socket, context, () => {
+        const state = knownPeers(socket);
+        if (state !== void 0) {
+          sayGoodbye(hub, state);
+        }
+      });
+    },
+    listen: () => {
+      served = true;
+      listenForPeers(hub);
+    },
+    served: () => served,
+    left(socket) {
+      const state = knownPeers(socket);
+      if (state !== void 0) {
+        sayGoodbye(hub, state, (room) => !inRoom2(socket, room));
+      }
+    }
+  });
+}
+
 // src/server/collections/changed.ts
 function mark(flush, s, topic) {
   flush.frames.set(topicRoom(s, topic), { s, topic, rev: flush.rev });
@@ -6640,17 +7509,17 @@ var TopicIndex = class {
    * absent), of the changed user's sockets (every user's when `userId` is
    * absent).
    */
-  matching(change) {
-    const key = change.id === void 0 ? void 0 : anchorKey(change.service, change.id);
-    const sockets = key === void 0 ? this.#byAnchorService.get(change.service) : this.#byAnchor.get(key);
+  matching(change2) {
+    const key = change2.id === void 0 ? void 0 : anchorKey(change2.service, change2.id);
+    const sockets = key === void 0 ? this.#byAnchorService.get(change2.service) : this.#byAnchor.get(key);
     const found = /* @__PURE__ */ new Map();
     for (const socket of sockets?.keys() ?? []) {
-      if (change.userId !== void 0 && socket.data.principal?.userId !== change.userId) {
+      if (change2.userId !== void 0 && socket.data.principal?.userId !== change2.userId) {
         continue;
       }
       const watches = this.entries(socket).filter(
         ({ anchors = [] }) => anchors.some(
-          (anchor) => key === void 0 ? serviceOf(anchor) === change.service : anchor === key
+          (anchor) => key === void 0 ? serviceOf(anchor) === change2.service : anchor === key
         )
       );
       if (watches.length > 0) {
@@ -6773,7 +7642,7 @@ async function rewatchAll(hub, index, found) {
 }
 function createTopicRevocation(hub, index) {
   return Object.freeze({
-    changed: async (change) => await rewatchAll(hub, index, index.matching(change)),
+    changed: async (change2) => await rewatchAll(hub, index, index.matching(change2)),
     regranted: async (sockets) => await rewatchAll(
       hub,
       index,
@@ -6944,7 +7813,7 @@ function createEntitySinks(hub) {
 }
 
 // src/server/emit/extension.ts
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isIdList(value) {
@@ -6954,7 +7823,7 @@ function isHeld(value) {
   return value === null || typeof value === "number" && Number.isFinite(value);
 }
 function readIds(frame, event, shape) {
-  if (!isRecord7(frame) || typeof frame.s !== "string" || frame.s === "" || !isIdList(frame.ids)) {
+  if (!isRecord8(frame) || typeof frame.s !== "string" || frame.s === "" || !isIdList(frame.ids)) {
     throw unreadable(`A ${event} frame needs ${shape} with ids a list of row ids`);
   }
   if (frame.ids.length > MAX_SUBSCRIBE_IDS) {
@@ -7022,14 +7891,15 @@ function createLive(options) {
   const collections = createLiveCollections(hub);
   const topics = createTopics(collections.hub);
   const sinks = createEntitySinks(hub);
-  const realtime = createRealtime(hub);
+  const peers = createPeerLinks(hub);
+  const realtime = createRealtime(hub, peers);
   const revocation = createRevocation(hub, [
     collections.revocation,
     topics.revocation,
     realtime.revocation
   ]);
   const entities = entitySubscriptions(hub);
-  options.policies.onAccessChanged((change) => revocation.changed(change, false));
+  options.policies.onAccessChanged((change2) => revocation.changed(change2, false));
   return Object.freeze({
     intake: sinks.intake,
     emit: sinks.emit,
@@ -7044,6 +7914,7 @@ function createLive(options) {
     },
     legacyExtension: realtime.legacyExtension,
     realtime,
+    peers,
     revisions: hub.revisions,
     attach(io, probe, cluster, broadcasts) {
       hub.io = io;
@@ -7052,8 +7923,8 @@ function createLive(options) {
       hub.broadcasts = broadcasts;
       collections.listen();
       realtime.listen();
-      listenForChanges(hub, revocation, (change) => {
-        options.policies.forget(change);
+      listenForChanges(hub, revocation, (change2) => {
+        options.policies.forget(change2);
       });
     },
     regranted: (userId) => {
@@ -7104,8 +7975,42 @@ function checkIds(ids) {
   }
   return ids;
 }
+function checkLevel(level, member) {
+  if (!isAccessLevel(level)) {
+    throw new TypeError(`${member}: level must be an access level`);
+  }
+}
+function contextAccess(state, api, principal) {
+  const levelsFor = async (service, ids) => {
+    if (principal !== null) {
+      return await api.levelsFor(service, principal, ids);
+    }
+    bindingFor(state, service);
+    checkIds(ids);
+    return /* @__PURE__ */ new Map();
+  };
+  return Object.freeze({
+    levelsFor,
+    async can(service, id, level) {
+      checkLevel(level, "ctx.access.can");
+      if (typeof id !== "string" || id === "") {
+        throw new TypeError("ctx.access.can: id must be a row id");
+      }
+      const levels = await levelsFor(service, [id]);
+      return meetsLevel(levels.get(id), level);
+    },
+    async where(service, level) {
+      if (principal !== null) {
+        return await api.accessWhere(service, principal, level);
+      }
+      bindingFor(state, service);
+      checkLevel(level, "ctx.access.where");
+      return "none";
+    }
+  });
+}
 function createAccessApi(state) {
-  return {
+  const api = {
     async levelsFor(service, principal, ids) {
       const binding = bindingFor(state, service);
       const who = checkPrincipal(principal);
@@ -7141,6 +8046,7 @@ function createAccessApi(state) {
       return await startCall(state).where(binding, who, level);
     }
   };
+  return { ...api, forCaller: (principal) => contextAccess(state, api, principal) };
 }
 
 // src/server/access/bindings.ts
@@ -7277,17 +8183,17 @@ function membershipKeys(write2, read) {
 }
 var Changes = class {
   #changes = /* @__PURE__ */ new Map();
-  add(change) {
+  add(change2) {
     this.#changes.set(
-      `${change.service}\0${change.id ?? ""}\0${change.userId ?? ""}`,
-      change
+      `${change2.service}\0${change2.id ?? ""}\0${change2.userId ?? ""}`,
+      change2
     );
   }
   get all() {
     return [...this.#changes.values()];
   }
 };
-function apply(rule, write2, cache, changes) {
+function apply2(rule, write2, cache, changes) {
   const service = rule.binding.service.name;
   if (rule.kind === "rows") {
     if (sets(write2, rule.binding.columns)) {
@@ -7319,16 +8225,16 @@ function apply(rule, write2, cache, changes) {
 }
 async function notify(listeners, changes, logger) {
   const running = [];
-  for (const change of changes) {
+  for (const change2 of changes) {
     for (const listener of listeners) {
       running.push(
         (async () => {
-          await listener(change);
+          await listener(change2);
         })().catch((error) => {
           logger.error("An onAccessChanged listener failed", {
             category: "quickdraw.access",
-            service: change.service,
-            id: change.id,
+            service: change2.service,
+            id: change2.id,
             error: describeError(error)
           });
         })
@@ -7362,7 +8268,7 @@ function createChangeSink(bindings, cache, listeners, logger) {
       const changes = new Changes();
       for (const write2 of writes) {
         for (const rule of rules.get(modelKey(write2.model)) ?? []) {
-          apply(rule, write2, cache, changes);
+          apply2(rule, write2, cache, changes);
         }
       }
       if (listeners.size > 0) {
@@ -7422,7 +8328,7 @@ function createPolicyEngine(options) {
       if (typeof listener !== "function") {
         throw new TypeError("dispatcher.access.onAccessChanged: listener must be a function");
       }
-      const entry = (change) => listener(change);
+      const entry = (change2) => listener(change2);
       listeners.add(entry);
       return () => {
         listeners.delete(entry);
@@ -7848,7 +8754,7 @@ function checkClaims(check, principal, input, what) {
     throw new QuickdrawError("UNAUTHENTICATED", "Authentication required");
   }
   const allowed2 = check(principal.claims, input);
-  if (isThenable2(allowed2)) {
+  if (isThenable(allowed2)) {
     Promise.resolve(allowed2).catch(() => void 0);
     throw new QuickdrawError(
       "INTERNAL",
@@ -7859,7 +8765,7 @@ function checkClaims(check, principal, input, what) {
     throw new QuickdrawError("FORBIDDEN", `${what} is not open to the caller's claims`);
   }
 }
-function isThenable2(value) {
+function isThenable(value) {
   return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
 }
 function checkKindAndClaims(method, principal, input, what) {
@@ -7868,8 +8774,8 @@ function checkKindAndClaims(method, principal, input, what) {
 }
 
 // src/server/pipeline/run.ts
-function stopped(signal) {
-  return { ok: false, error: abortError(signal) };
+function stopped(signal2) {
+  return { ok: false, error: abortError(signal2) };
 }
 function createState(options, controller) {
   let resolveOutcome = () => void 0;
@@ -7902,8 +8808,8 @@ function createState(options, controller) {
   }
   return state;
 }
-function runHandler(options, state, signal) {
-  const invoke = () => options.invoke(signal);
+function runHandler(options, state, signal2) {
+  const invoke = () => options.invoke(signal2);
   let started;
   try {
     started = options.unit.run(options.quiet === true ? () => quietly(invoke) : invoke);
@@ -7928,26 +8834,26 @@ function runHandler(options, state, signal) {
     }
   );
 }
-function joinRun(state, signal) {
-  if (signal?.aborted === true) {
-    return Promise.resolve(stopped(signal));
+function joinRun(state, signal2) {
+  if (signal2?.aborted === true) {
+    return Promise.resolve(stopped(signal2));
   }
   state.participants += 1;
-  if (signal === void 0) {
+  if (signal2 === void 0) {
     return state.outcome;
   }
   return new Promise((resolve) => {
     const onAbort = () => {
       state.participants -= 1;
-      const left = stopped(signal);
+      const left = stopped(signal2);
       resolve(left);
       if (state.participants === 0) {
         state.end(left, true);
       }
     };
-    signal.addEventListener("abort", onAbort, { once: true });
+    signal2.addEventListener("abort", onAbort, { once: true });
     void state.outcome.then((result) => {
-      signal.removeEventListener("abort", onAbort);
+      signal2.removeEventListener("abort", onAbort);
       resolve(result);
     });
   });
@@ -7966,7 +8872,7 @@ function startRun(options) {
     get handlerSettled() {
       return state.handlerSettled;
     },
-    join: (signal) => joinRun(state, signal)
+    join: (signal2) => joinRun(state, signal2)
   };
 }
 
@@ -8220,8 +9126,8 @@ function execute(settings, shares, target2, call, input, ctx) {
     // The pipeline starts every call's time limit at admission, before this.
     timeLimit: call.expired ?? NEVER_ABORTED,
     unit,
-    invoke: (signal) => {
-      const runCtx = withSignal(ctx, signal);
+    invoke: (signal2) => {
+      const runCtx = withSignal(ctx, signal2);
       const handlerCtx = watch ? watchCallerReads(runCtx, (member) => warnSharedRead(settings, target2, member)) : runCtx;
       return method.handler({ input, ctx: handlerCtx, db: settings.db });
     },
@@ -8237,7 +9143,7 @@ function execute(settings, shares, target2, call, input, ctx) {
 }
 
 // src/server/pipeline/notModified.ts
-function isVersion(value) {
+function isVersion2(value) {
   return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 
@@ -8250,11 +9156,11 @@ function lookup2(registry, request) {
   const message = registry.services.has(request.service) ? `Unknown method "${request.method}" on service "${request.service}"` : `Unknown service "${request.service}"`;
   throw new QuickdrawError("NOT_FOUND", message);
 }
-function admit(limiter, request, target2, signal) {
+function admit(limiter, request, target2, signal2) {
   if (target2.method.kind !== "query" || request.connectionId === void 0) {
     return Promise.resolve(void 0);
   }
-  return limiter.acquire(request.connectionId, signal);
+  return limiter.acquire(request.connectionId, signal2);
 }
 function startTimeLimit(timeoutMs, cancel) {
   const controller = new AbortController();
@@ -8265,29 +9171,29 @@ function startTimeLimit(timeoutMs, cancel) {
     stop: () => clearTimeout(timer)
   };
 }
-function untilStopped(work, signal) {
-  if (signal === void 0) {
+function untilStopped(work, signal2) {
+  if (signal2 === void 0) {
     return Promise.resolve(work);
   }
   return new Promise((resolve, reject) => {
-    const onAbort = () => reject(abortError(signal));
-    if (signal.aborted) {
+    const onAbort = () => reject(abortError(signal2));
+    if (signal2.aborted) {
       onAbort();
     }
-    signal.addEventListener("abort", onAbort, { once: true });
+    signal2.addEventListener("abort", onAbort, { once: true });
     work.then(
       (value) => {
-        signal.removeEventListener("abort", onAbort);
+        signal2.removeEventListener("abort", onAbort);
         resolve(value);
       },
       (error) => {
-        signal.removeEventListener("abort", onAbort);
+        signal2.removeEventListener("abort", onAbort);
         reject(error);
       }
     );
   });
 }
-function contextFor(settings, request, requestId, target2, signal, dispatch) {
+function contextFor(settings, request, requestId, target2, signal2, dispatch) {
   const log = settings.logger.child({
     service: target2.service.name,
     method: target2.method.name,
@@ -8296,7 +9202,7 @@ function contextFor(settings, request, requestId, target2, signal, dispatch) {
   const { realtime } = settings.live;
   const fields = {
     principal: request.principal,
-    signal: signal ?? NEVER_ABORTED,
+    signal: signal2 ?? NEVER_ABORTED,
     log,
     requestId,
     transport: request.transport,
@@ -8305,9 +9211,13 @@ function contextFor(settings, request, requestId, target2, signal, dispatch) {
     touch: settings.touch,
     rooms: realtime.roomsFor(request.transport, request.connectionId, target2.method.share),
     presence: realtime.presence,
-    // `ctx.services` calls the app's services as this principal through this
-    // dispatcher; their units of work join this call's, so their writes flush with it.
+    // `ctx.services` calls the app's services as this principal, with this
+    // call's `ctx.mcp`, through this dispatcher; their units of work join
+    // this call's, so their writes flush with it.
     dispatch,
+    // `ctx.access`: the policies' levels and filters for this principal, with
+    // the grants the call runs with.
+    access: settings.policies,
     kit: {
       service: target2.service,
       services: settings.registry.services,
@@ -8327,7 +9237,7 @@ async function currentVersion(settings, target2, input, ctx) {
     return void 0;
   }
   const version = method.version === void 0 ? await settings.versions?.versionOf({ service, method, input, ctx }) : await method.version(input, ctx);
-  return isVersion(version) ? version : void 0;
+  return isVersion2(version) ? version : void 0;
 }
 function versionOfResult(settings, target2, call, result) {
   const { service, method } = target2;
@@ -9013,7 +9923,8 @@ function createRateLimiter(options = {}) {
     windowMs = 6e4,
     maxRequests = DEFAULT_MAX_REQUESTS,
     excludeEvents = [],
-    excludePrefixes = []
+    excludePrefixes = [],
+    skip = () => false
   } = options;
   const entries = /* @__PURE__ */ new Map();
   const cleanupInterval = setInterval(() => {
@@ -9067,7 +9978,8 @@ function createRateLimiter(options = {}) {
       windowMs,
       maxRequests,
       excludeEvents,
-      excludePrefixes
+      excludePrefixes,
+      skip
     }
   };
 }
@@ -9086,7 +9998,7 @@ function applyRateLimitMiddleware(io, rateLimiter, options = {}) {
     error: "Rate limit exceeded",
     code: 429
   }));
-  const { excludeEvents, excludePrefixes } = rateLimiter.options;
+  const { excludeEvents, excludePrefixes, skip } = rateLimiter.options;
   io.on("connection", (socket) => {
     socket.use(([eventName, ...args], next) => {
       if (typeof eventName !== "string") {
@@ -9105,6 +10017,10 @@ function applyRateLimitMiddleware(io, rateLimiter, options = {}) {
         next();
         return;
       }
+      if (skip(eventName, args)) {
+        next();
+        return;
+      }
       const key = keyGenerator(socket, eventName);
       if (rateLimiter.check(key)) {
         next();
@@ -9249,8 +10165,8 @@ function startTrackedModelsCheck(registry, options, logger) {
 
 // src/server/lifecycle.ts
 function watchSignals(close, logger) {
-  const onSignal = (signal) => {
-    logger.info(`Received ${signal}; closing the quickdraw server`, {
+  const onSignal = (signal2) => {
+    logger.info(`Received ${signal2}; closing the quickdraw server`, {
       category: "quickdraw.server"
     });
     close().catch((error) => {
@@ -9369,10 +10285,32 @@ import { Server } from "socket.io";
 function legacyFailure(code, error) {
   return { success: false, error, code: httpStatus(code) };
 }
+var LISTED_ISSUES = 10;
+function issueText(issue) {
+  if (!isRecord(issue) || typeof issue.message !== "string" || !Array.isArray(issue.path)) {
+    return void 0;
+  }
+  const path = issue.path;
+  if (!path.every((segment) => typeof segment === "string" || typeof segment === "number")) {
+    return void 0;
+  }
+  return path.length === 0 ? issue.message : `${path.join(".")}: ${issue.message}`;
+}
+function validationMessage(message, data) {
+  const issues = isRecord(data) && Array.isArray(data.issues) ? data.issues : [];
+  const texts = issues.map(issueText).filter((text) => text !== void 0);
+  if (texts.length === 0) {
+    return message;
+  }
+  const more = texts.length - LISTED_ISSUES;
+  const listed = texts.slice(0, LISTED_ISSUES).join("; ");
+  return `${message}: ${listed}${more > 0 ? `; and ${String(more)} more` : ""}`;
+}
 function toLegacyReply(result) {
   if (!result.ok) {
     const wire = toWire(result.error);
-    return legacyFailure(wire.code, wire.message);
+    const message = wire.code === "VALIDATION" ? validationMessage(wire.message, wire.data) : wire.message;
+    return legacyFailure(wire.code, message);
   }
   return { success: true, data: result.notModified === true ? void 0 : result.data };
 }
@@ -9515,6 +10453,7 @@ var MISMATCH = Object.freeze({
   expected: PROTOCOL_VERSION
 });
 var UNAUTHENTICATED = Object.freeze({ code: "UNAUTHENTICATED" });
+var UNAVAILABLE = Object.freeze({ code: "INTERNAL" });
 function protocolMiddleware(legacyWire, context) {
   return (socket, next) => {
     const auth = socket.handshake.auth;
@@ -9570,13 +10509,13 @@ function authMiddleware(resolvePrincipal, context) {
         next();
       },
       (error) => {
-        const level = isRefusal(error) ? "debug" : "error";
-        context.logger[level]("Socket authentication failed", {
+        const refused = isRefusal(error) || isForbiddenCredential(error);
+        context.logger[refused ? "debug" : "error"]("Socket authentication failed", {
           category: "quickdraw.socket",
           socketId: socket.id,
           error: describeError(error)
         });
-        next(refusal("Authentication failed", UNAUTHENTICATED));
+        next(refusal("Authentication failed", refused ? UNAUTHENTICATED : UNAVAILABLE));
       }
     );
   };
@@ -9592,8 +10531,13 @@ var UNLIMITED_EVENTS = [
   CLIENT_EVENTS.watch,
   CLIENT_EVENTS.unwatch,
   CLIENT_EVENTS.streamSub,
-  CLIENT_EVENTS.streamUnsub
+  CLIENT_EVENTS.streamUnsub,
+  CLIENT_EVENTS.relay
 ];
+function isPeerBye(eventName, args) {
+  const frame = args[0];
+  return eventName === CLIENT_EVENTS.peer && frame?.sig?.bye === true;
+}
 function rateLimited(retryAfterMs) {
   return {
     ok: false,
@@ -9616,9 +10560,11 @@ function noticeForLegacyClients(limiter, options) {
   };
 }
 function applySocketRateLimit(io, options, context) {
+  const { skip } = options;
   const limiter = createRateLimiter({
     ...options,
-    excludeEvents: [...UNLIMITED_EVENTS, ...options.excludeEvents ?? []]
+    excludeEvents: [...UNLIMITED_EVENTS, ...options.excludeEvents ?? []],
+    skip: (eventName, args) => isPeerBye(eventName, args) || skip?.(eventName, args) === true
   });
   const notice = options.onRateLimitExceeded ?? noticeForLegacyClients(limiter, options);
   applyRateLimitMiddleware(io, limiter, {
@@ -9637,7 +10583,7 @@ var RESYNC_WITHIN_MS = 2e3;
 function isEmitter(value) {
   return typeof value === "object" && value !== null && typeof value.on === "function";
 }
-function isThenable3(value) {
+function isThenable2(value) {
   return typeof value === "object" && value !== null && typeof value.then === "function";
 }
 var watched = /* @__PURE__ */ new WeakSet();
@@ -9652,14 +10598,14 @@ function resyncOnReady(io, subClient, logger) {
 }
 function guardPublishes(pubClient, logger) {
   const target2 = pubClient;
-  const publish = target2.publish;
-  if (typeof publish !== "function") {
+  const publish2 = target2.publish;
+  if (typeof publish2 !== "function") {
     return;
   }
   let reported = false;
   target2.publish = function guardedPublish(...args) {
-    const sent = Reflect.apply(publish, this, args);
-    if (isThenable3(sent)) {
+    const sent = Reflect.apply(publish2, this, args);
+    if (isThenable2(sent)) {
       sent.then(void 0, (error) => {
         if (!reported) {
           reported = true;
@@ -10019,6 +10965,20 @@ function helloFor(hello, principal) {
 }
 
 // src/server/transports/socketServer.ts
+var 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 featuresOf(settings) {
+  return Object.freeze([
+    ...settings.binary ? ["binary"] : [],
+    ...settings.peers === true ? ["peer"] : []
+  ]);
+}
 function helloFrame(settings) {
   const { limits } = settings.dispatcher;
   return Object.freeze({
@@ -10037,9 +10997,10 @@ function helloFrame(settings) {
         maxEntityIds: MAX_ENTITY_IDS_PER_SOCKET,
         maxScopes: MAX_SCOPES_PER_SOCKET,
         maxTopics: MAX_TOPICS_PER_SOCKET
-      })
+      }),
+      ...settings.peers === true ? { peers: PEER_LIMITS } : {}
     }),
-    features: Object.freeze(settings.binary ? ["binary"] : [])
+    features: featuresOf(settings)
   });
 }
 function createSocketServer(httpServer, settings) {
@@ -10126,10 +11087,15 @@ function checkOptions(options) {
   if (timeout !== void 0 && !(Number.isSafeInteger(timeout) && timeout >= 0)) {
     throw new TypeError("createServer: shutdownTimeoutMs must be a whole number of milliseconds");
   }
-  if (options.onRoomLeave !== void 0 && typeof options.onRoomLeave !== "function") {
-    throw new TypeError(
-      "createServer: onRoomLeave must be a function of the leave and a run context"
-    );
+  if (options.peers !== void 0 && typeof options.peers !== "boolean") {
+    throw new TypeError("createServer: peers must be true or false");
+  }
+  for (const hook of ["onRoomLeave", "onHostLeave"]) {
+    if (options[hook] !== void 0 && typeof options[hook] !== "function") {
+      throw new TypeError(
+        `createServer: ${hook} must be a function of the leave and a run context`
+      );
+    }
   }
   const socket = options.socket;
   if (socket?.connectionStateRecovery) {
@@ -10138,18 +11104,40 @@ function checkOptions(options) {
     );
   }
 }
-function listenForLeaves(dispatcher, handler) {
+function checkHostMode(services, peers) {
+  for (const service of peers ? [] : services) {
+    const { channels, streams } = service.contract;
+    const hosted = [
+      ...Object.entries(channels).map(([name, def]) => [`channel "${name}"`, def]),
+      ...Object.entries(streams).map(([name, def]) => [`stream "${name}"`, def])
+    ].find(([, def]) => def.serve === "host");
+    if (hosted !== void 0) {
+      throw new TypeError(
+        `createServer: ${service.name}'s ${hosted[0]} is served by the room's host (serve: "host"), which runs over peer links; create the server with peers: true`
+      );
+    }
+  }
+}
+function listenForLeaves(dispatcher, handlers) {
   const services = [...dispatcher.registry.services.values()];
-  const hooks = services.flatMap(
+  const rooms = services.flatMap(
     (service) => service.onRoomLeave === void 0 ? [] : [{ owner: service.name, handler: service.onRoomLeave }]
   );
-  if (handler !== void 0) {
-    hooks.push({ owner: "createServer", handler });
-  }
-  liveOf(dispatcher)?.realtime.onRoomLeave(
-    hooks,
-    async (fn) => await dispatcher.run(fn, { detached: true })
+  const hosts = services.flatMap(
+    (service) => service.onHostLeave === void 0 ? [] : [{ owner: service.name, handler: service.onHostLeave }]
   );
+  if (handlers.room !== void 0) {
+    rooms.push({ owner: "createServer", handler: handlers.room });
+  }
+  if (handlers.host !== void 0) {
+    hosts.push({ owner: "createServer", handler: handlers.host });
+  }
+  const run2 = async (fn) => {
+    await dispatcher.run(fn, { detached: true });
+  };
+  const realtime = liveOf(dispatcher)?.realtime;
+  realtime?.onRoomLeave(rooms, run2);
+  realtime?.onHostLeave(hosts, run2);
 }
 function mountRouter(options, base) {
   if (options.http === false) {
@@ -10160,6 +11148,25 @@ function mountRouter(options, base) {
   options.app?.use(router);
   return router;
 }
+function serveSockets(options, created, httpServer, base) {
+  const live = liveOf(created);
+  const peers = options.peers === true ? live?.peers : void 0;
+  const sockets = createSocketServer(httpServer, {
+    ...base,
+    loadServiceAccess: options.auth?.loadServiceAccess,
+    binary: options.binary === true,
+    cors: options.cors,
+    socket: options.socket,
+    rateLimit: options.rateLimit ?? {},
+    extensions: peers === void 0 ? [] : [peers.extension],
+    live,
+    loops: loopsOf(created),
+    cluster: options.cluster,
+    peers: peers !== void 0
+  });
+  peers?.listen();
+  return sockets;
+}
 function notFound2(_req, res) {
   res.statusCode = 404;
   res.end();
@@ -10191,6 +11198,7 @@ function withGrants(options, grants, grantsSource) {
 }
 function createServer(options) {
   checkOptions(options);
+  checkHostMode(options.services, options.peers === true);
   const legacyWire = resolveLegacyWire(options.legacyWire, options.services);
   const logger = options.logger ?? consoleLogger;
   warnOnAuth(options.services, options.auth, logger);
@@ -10203,24 +11211,15 @@ function createServer(options) {
   const calls = trackCalls(created);
   const { dispatcher } = calls;
   startStartupChecks(dispatcher, options, logger);
-  listenForLeaves(created, options.onRoomLeave);
+  listenForLeaves(created, { room: options.onRoomLeave, host: options.onHostLeave });
   const resolvePrincipal = createPrincipalResolver(options.auth);
   const router = mountRouter(options, { call: dispatcher.call, resolvePrincipal, logger });
   const httpServer = options.httpServer ?? createHttpServer(options.app ?? router ?? notFound2);
-  const sockets = createSocketServer(httpServer, {
+  const sockets = serveSockets(options, created, httpServer, {
     dispatcher,
     logger,
     resolvePrincipal,
-    loadServiceAccess: options.auth?.loadServiceAccess,
-    binary: options.binary === true,
-    legacyWire,
-    cors: options.cors,
-    socket: options.socket,
-    rateLimit: options.rateLimit ?? {},
-    extensions: [],
-    live: liveOf(created),
-    loops: loopsOf(created),
-    cluster: options.cluster
+    legacyWire
   });
   refresh = (userId) => sockets.refresh(userId);
   const load = options.auth?.loadServiceAccess;
@@ -10298,6 +11297,7 @@ export {
   CHANNEL_ABUSE_MULTIPLIER,
   PRESENCE_MAX_LAST_SEEN,
   MAX_APP_ROOMS,
+  seedRoomHosts,
   STREAM_MAX_SCOPES,
   MAX_STREAMS_PER_SOCKET,
   createBasicAccessEngine,
@@ -10319,4 +11319,4 @@ export {
   watchAdapterClients,
   createServer
 };
-//# sourceMappingURL=chunk-6K5BY47X.js.map
+//# sourceMappingURL=chunk-JVTONQFI.js.map