@fitzzero/quickdraw-core 5.1.2 → 5.1.3

package/dist/chunk-Z7I6SONO.js

@@ -0,0 +1,825 @@
+import {
+  onPeerRequest
+} from "./chunk-DNP65TD5.js";
+import {
+  controlOf,
+  createLinkCore,
+  encodeMessage,
+  messageBytes,
+  throwLater
+} from "./chunk-ASAMUGHG.js";
+import {
+  channelRoomOf,
+  streamRoomOf
+} from "./chunk-NX2V6SIL.js";
+import {
+  registerLocalHost
+} from "./chunk-STH5DLQP.js";
+import {
+  validateNow
+} from "./chunk-7473HK24.js";
+import {
+  isRoomName
+} from "./chunk-2FDSKLBO.js";
+import {
+  MAX_PEER_MESSAGE_BYTES
+} from "./chunk-X4ZU4QH5.js";
+import {
+  CHANNEL_DEFAULT_RATE,
+  isHostServed
+} from "./chunk-GYLWEJHW.js";
+import {
+  QuickdrawError,
+  isErrorCode
+} from "./chunk-Q4OGQM5I.js";
+import {
+  isRecord
+} from "./chunk-QSU47XEX.js";
+
+// src/client/auth.ts
+var AUTH_TOKEN_KEY = "auth_token";
+var DEFAULT_API_URL = "http://localhost:4000";
+var memoryToken = null;
+function onClient() {
+  return typeof window !== "undefined";
+}
+function storedToken() {
+  try {
+    return globalThis.localStorage.getItem(AUTH_TOKEN_KEY);
+  } catch {
+    return void 0;
+  }
+}
+function announce() {
+  if (typeof window.dispatchEvent === "function" && typeof Event === "function") {
+    window.dispatchEvent(new Event("auth-token-changed"));
+  }
+}
+function apiUrlOf(apiUrl) {
+  if (apiUrl !== void 0) {
+    return apiUrl;
+  }
+  try {
+    return process.env.NEXT_PUBLIC_API_URL ?? DEFAULT_API_URL;
+  } catch {
+    return DEFAULT_API_URL;
+  }
+}
+function getAuthToken() {
+  if (!onClient()) return null;
+  const stored = storedToken();
+  return stored === void 0 ? memoryToken : stored;
+}
+function setAuthToken(token) {
+  if (!onClient()) return;
+  memoryToken = token;
+  try {
+    globalThis.localStorage.setItem(AUTH_TOKEN_KEY, token);
+  } catch {
+  }
+  announce();
+}
+function clearAuthToken() {
+  if (!onClient()) return;
+  memoryToken = null;
+  try {
+    globalThis.localStorage.removeItem(AUTH_TOKEN_KEY);
+  } catch {
+  }
+  announce();
+}
+var PROVIDER_ID = /^[a-z0-9][a-z0-9-]*$/;
+function routesUrl(owner, target) {
+  const base = apiUrlOf(target.apiUrl).replace(/\/+$/, "");
+  const path = target.basePath ?? "/auth";
+  if (typeof path !== "string" || !path.startsWith("/")) {
+    throw new TypeError(`${owner}: basePath must start with "/", as createAuthRoutes takes it`);
+  }
+  return `${base}${path.replace(/\/+$/, "")}`;
+}
+function pageOrigin() {
+  try {
+    const origin = globalThis.location?.origin;
+    return typeof origin === "string" && origin !== "null" ? origin : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function signInUrl(provider, options = {}) {
+  if (typeof provider !== "string" || !PROVIDER_ID.test(provider)) {
+    throw new TypeError(
+      `signInUrl: a provider id is lowercase letters, digits and hyphens; got ${String(provider)}`
+    );
+  }
+  const url = new URL(`${routesUrl("signInUrl", options)}/${provider}/start`);
+  const returnTo = options.returnTo ?? pageOrigin();
+  if (returnTo !== void 0) {
+    url.searchParams.set("returnTo", returnTo);
+  }
+  return url.toString();
+}
+async function refusalOf(response) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = void 0;
+  }
+  const code = isRecord(body) && isErrorCode(body.error) ? body.error : void 0;
+  const message = isRecord(body) && typeof body.message === "string" ? body.message : `The auth route answered ${String(response.status)}`;
+  if (code !== void 0) {
+    return new QuickdrawError(code, message);
+  }
+  return new QuickdrawError(response.status === 429 ? "RATE_LIMITED" : "INTERNAL", message);
+}
+async function postRoute(owner, route, target) {
+  const url = `${routesUrl(owner, target)}${route}`;
+  const token = getAuthToken();
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        ...token === null ? {} : { Authorization: `Bearer ${token}` }
+      },
+      body: "{}"
+    });
+  } catch (error) {
+    throw new QuickdrawError("INTERNAL", `${owner}: ${url} could not be reached`, {
+      cause: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (!response.ok) {
+    throw await refusalOf(response);
+  }
+}
+async function signOut(options = {}) {
+  try {
+    await postRoute("signOut", "/logout", options);
+  } finally {
+    clearAuthToken();
+  }
+}
+var PROVIDER_KINDS = /* @__PURE__ */ new Set(["oauth", "mock", "guest"]);
+function providerInfoOf(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || !PROVIDER_ID.test(value.id)) {
+    return void 0;
+  }
+  const kind = PROVIDER_KINDS.has(value.kind) ? value.kind : void 0;
+  return kind === void 0 ? void 0 : { id: value.id, name: typeof value.name === "string" ? value.name : value.id, kind };
+}
+async function authProviders(options = {}) {
+  const url = `${routesUrl("authProviders", options)}/providers`;
+  let response;
+  try {
+    response = await fetch(url, { headers: { Accept: "application/json" } });
+  } catch (error) {
+    throw new QuickdrawError("INTERNAL", `authProviders: ${url} could not be reached`, {
+      cause: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (!response.ok) {
+    throw await refusalOf(response);
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = void 0;
+  }
+  if (!isRecord(body) || !Array.isArray(body.providers)) {
+    throw new QuickdrawError("INTERNAL", `authProviders: ${url} answered no list of providers`);
+  }
+  return body.providers.flatMap((entry) => {
+    const info = providerInfoOf(entry);
+    return info === void 0 ? [] : [info];
+  });
+}
+async function signOutEverywhere(options = {}) {
+  try {
+    await postRoute("signOutEverywhere", "/logout-all", options);
+  } finally {
+    clearAuthToken();
+  }
+}
+
+// src/client/newId.ts
+function uuidByte(byte, index) {
+  if (index === 6) {
+    return 64 + byte % 16;
+  }
+  return index === 8 ? 128 + byte % 64 : byte;
+}
+function uuidOf(bytes) {
+  const hex = Array.from(
+    bytes,
+    (byte, index) => uuidByte(byte, index).toString(16).padStart(2, "0")
+  ).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function newId() {
+  const { crypto } = globalThis;
+  if (typeof crypto?.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto?.getRandomValues !== "function") {
+    throw new TypeError("newId: this runtime has no crypto.getRandomValues");
+  }
+  return uuidOf(crypto.getRandomValues(new Uint8Array(16)));
+}
+
+// src/client/host/local.ts
+function createLocalLink(room, socketId, userId, maxMessageBytes) {
+  const ends = [];
+  const endOf = (other) => createLinkCore({
+    room,
+    peer: socketId,
+    maxMessageBytes,
+    watchdog: false,
+    hooks: {
+      send: (label, text) => {
+        other()?.receive(text, label);
+        return true;
+      },
+      closed: (_reason, fromHere) => {
+        if (fromHere) {
+          other()?.end("bye");
+        }
+      }
+    }
+  });
+  const near = endOf(() => ends[1]);
+  const far = endOf(() => ends[0]);
+  ends.push(near, far);
+  for (const end of ends) {
+    end.identify(userId);
+  }
+  far.carry("direct");
+  near.carry("direct");
+  return [near.link, far.link];
+}
+
+// src/client/host/serving.ts
+var all = /* @__PURE__ */ new WeakMap();
+function attachAll(state, at) {
+  for (const [service, runtime] of state.runtimes) {
+    if (!at.attached.has(service)) {
+      at.attached.set(service, runtime.attach(at.peer, at.send, at.close));
+    }
+  }
+}
+function deliver(at, message) {
+  const attached = at.attached.get(message[1]);
+  if (attached !== void 0) {
+    attached.receive(message);
+  } else if (message[0] === 4) {
+    at.attached.values().next().value?.unserved(message);
+  }
+}
+function join(state, peer, send, close) {
+  const at = { peer, send, close, attached: /* @__PURE__ */ new Map() };
+  state.peers.add(at);
+  attachAll(state, at);
+  return {
+    receive: (message) => {
+      deliver(at, message);
+    },
+    detach: () => {
+      for (const attached of at.attached.values()) {
+        attached.detach();
+      }
+      at.attached.clear();
+      state.peers.delete(at);
+    }
+  };
+}
+function adopt(state, link, userId, close) {
+  const control = controlOf(link);
+  if (control === void 0 || link.state === "closed") {
+    return;
+  }
+  state.links.add(link);
+  const peer = join(state, { socketId: link.peer, userId, link }, control.send, close);
+  const off = control.on((message) => {
+    peer.receive(message);
+  });
+  link.on("close", () => {
+    off();
+    peer.detach();
+    state.links.delete(link);
+  });
+}
+function accept(state, request) {
+  let link;
+  try {
+    link = request.accept();
+  } catch {
+    return;
+  }
+  adopt(state, link, request.userId, () => {
+    link.close();
+  });
+}
+function open(connection, room, rooms) {
+  const state = { room, runtimes: /* @__PURE__ */ new Map(), peers: /* @__PURE__ */ new Set(), links: /* @__PURE__ */ new Set() };
+  const stopRequests = onPeerRequest(connection, (request) => {
+    if (request.room === room) {
+      accept(state, request);
+    }
+  });
+  const unregister = registerLocalHost(
+    connection,
+    room,
+    (link) => {
+      adopt(state, link, link.userId ?? "", () => void 0);
+    },
+    { createLink: createLocalLink, controlOf }
+  );
+  return {
+    add(service, runtime) {
+      if (state.runtimes.has(service)) {
+        throw new TypeError(
+          `serve: this connection serves ${service} in room "${room}" already; close that Host first`
+        );
+      }
+      state.runtimes.set(service, runtime);
+      for (const at of state.peers) {
+        attachAll(state, at);
+      }
+    },
+    remove(service, runtime) {
+      if (state.runtimes.get(service) !== runtime) {
+        return;
+      }
+      state.runtimes.delete(service);
+      for (const at of state.peers) {
+        at.attached.get(service)?.detach();
+        at.attached.delete(service);
+      }
+      runtime.close();
+      if (state.runtimes.size > 0) {
+        return;
+      }
+      rooms.delete(room);
+      stopRequests();
+      unregister();
+      for (const link of [...state.links]) {
+        link.close();
+      }
+    }
+  };
+}
+function serving(connection, room) {
+  let rooms = all.get(connection);
+  if (rooms === void 0) {
+    rooms = /* @__PURE__ */ new Map();
+    all.set(connection, rooms);
+  }
+  let found = rooms.get(room);
+  if (found === void 0) {
+    found = open(connection, room, rooms);
+    rooms.set(room, found);
+  }
+  return found;
+}
+
+// src/client/host/outbox.ts
+var RETRY_MS = 50;
+var MAX_RETRY_MS = 1e3;
+var MAX_QUEUED_BYTES = 8 * 1024 * 1024;
+function createOutbox(send, close) {
+  const queue = [];
+  let queued = 0;
+  let timer;
+  let wait = RETRY_MS;
+  const clear = () => {
+    clearTimeout(timer);
+    timer = void 0;
+    queue.length = 0;
+    queued = 0;
+  };
+  const sent = (message) => {
+    try {
+      return send("rel", message);
+    } catch (error) {
+      throwLater(error);
+      return true;
+    }
+  };
+  const flush = () => {
+    timer = void 0;
+    for (let next = queue[0]; next !== void 0; next = queue[0]) {
+      if (!sent(next.message)) {
+        timer = setTimeout(flush, wait);
+        wait = Math.min(MAX_RETRY_MS, wait * 2);
+        return;
+      }
+      queue.shift();
+      queued -= next.bytes;
+    }
+    wait = RETRY_MS;
+  };
+  return {
+    send(label, message) {
+      if (label === "fast") {
+        send("fast", message);
+        return;
+      }
+      if (queue.length === 0 && send("rel", message)) {
+        return;
+      }
+      const bytes = messageBytes(encodeMessage(message));
+      queue.push({ message, bytes });
+      queued += bytes;
+      if (queued > MAX_QUEUED_BYTES) {
+        clear();
+        close();
+        return;
+      }
+      timer ??= setTimeout(flush, wait);
+    },
+    clear
+  };
+}
+
+// src/client/host/runtime.ts
+var ABUSE_WINDOW_MS = 1e4;
+var ABUSE_MULTIPLIER = 100;
+var MAX_HOST_FEEDS = 500;
+var HOST_SUBSCRIBE_RATE = 50;
+var MAX_KEPT_SCOPES = 1e4;
+var feedKey = (stream, scope) => `${stream}\0${scope}`;
+function own(record, name) {
+  return Object.hasOwn(record, name) ? record[name] : void 0;
+}
+function overRate(bucket, rate, burst, now) {
+  bucket.tokens = Math.min(burst, bucket.tokens + (now - bucket.refilledAt) / 1e3 * rate);
+  bucket.refilledAt = now;
+  if (bucket.tokens >= 1) {
+    bucket.tokens -= 1;
+    return void 0;
+  }
+  if (now - bucket.windowStart > ABUSE_WINDOW_MS) {
+    bucket.windowStart = now;
+    bucket.dropped = 0;
+  }
+  bucket.dropped += 1;
+  return bucket.dropped > rate * ABUSE_MULTIPLIER;
+}
+function onChannel(state, from, name, payload) {
+  const def = own(state.contract.channels, name);
+  const handler = own(state.implementation.channels ?? {}, name);
+  if (def === void 0 || !isHostServed(def) || handler === void 0) {
+    return;
+  }
+  const rate = def.ratePerSecond ?? CHANNEL_DEFAULT_RATE;
+  const burst = def.burst ?? Math.max(1, rate * 2);
+  const now = Date.now();
+  let bucket = from.buckets.get(name);
+  if (bucket === void 0) {
+    bucket = { tokens: burst, refilledAt: now, windowStart: now, dropped: 0 };
+    from.buckets.set(name, bucket);
+  }
+  const dropped = overRate(bucket, rate, burst, now);
+  if (dropped !== void 0) {
+    if (dropped) {
+      from.close();
+    }
+    return;
+  }
+  const parsed = validateNow(def.payload, payload);
+  if (parsed === "async") {
+    if (!state.warned.has(name)) {
+      state.warned.add(name);
+      throwLater(
+        new TypeError(
+          `Host of ${state.room}: channel ${state.contract.name}.${name} has a payload schema that validates asynchronously; its messages are dropped, since a host checks them synchronously`
+        )
+      );
+    }
+    return;
+  }
+  if (parsed.issues !== void 0 || channelRoomOf(def, parsed.value, [state.room]) !== state.room) {
+    return;
+  }
+  try {
+    handler(parsed.value, { peer: from.peer, room: state.room });
+  } catch (error) {
+    throwLater(error);
+  }
+}
+function seedOf(state, name, def, scope) {
+  const seed = own(state.implementation.streams ?? {}, name)?.seed;
+  if (seed === void 0) {
+    return state.kept.get(name)?.get(scope) ?? [];
+  }
+  return seed(scope).map((item) => {
+    const checked = validateNow(def.item, item);
+    if (checked === "async" || checked.issues !== void 0) {
+      throw new TypeError(
+        `Host of ${state.room}: the seed of ${state.contract.name}.${name} holds an item its schema refuses`
+      );
+    }
+    return checked.value;
+  });
+}
+function aloneBytes(state, name, scope, item) {
+  return messageBytes(encodeMessage([6, state.contract.name, name, scope, [item], false]));
+}
+function chunksOf(state, name, scope, items) {
+  const max = state.maxBytes();
+  const overhead = messageBytes(encodeMessage([6, state.contract.name, name, scope, [], false]));
+  const chunks = [[]];
+  let size = overhead;
+  for (const item of items) {
+    const bytes = messageBytes(JSON.stringify(item) ?? "null");
+    if (overhead + bytes > max) {
+      return void 0;
+    }
+    const chunk = chunks.at(-1) ?? [];
+    if (chunk.length === 0) {
+      chunk.push(item);
+      size += bytes;
+    } else if (size + 1 + bytes > max) {
+      chunks.push([item]);
+      size = overhead + bytes;
+    } else {
+      chunk.push(item);
+      size += 1 + bytes;
+    }
+  }
+  return chunks;
+}
+function refusal(from, service, name, scope) {
+  return (code, message) => {
+    from.out.send("rel", [8, service, name, scope, { code, message }]);
+  };
+}
+function admits(from, refuse) {
+  const flood = overRate(from.subscribes, HOST_SUBSCRIBE_RATE, MAX_HOST_FEEDS, Date.now());
+  if (flood === void 0) {
+    return true;
+  }
+  if (flood) {
+    from.close();
+  } else {
+    refuse("RATE_LIMITED", `A peer subscribes at most ${HOST_SUBSCRIBE_RATE} times a second`);
+  }
+  return false;
+}
+function onUnserved(state, from, message) {
+  const [, service, name, scope] = message;
+  const refuse = refusal(from, service, name, scope);
+  if (!state.closed && state.peers.has(from) && admits(from, refuse)) {
+    refuse("NOT_FOUND", `The host of ${state.room} serves no service "${service}"`);
+  }
+}
+function onSubscribe(state, from, name, scope) {
+  const service = state.contract.name;
+  const refuse = refusal(from, service, name, scope);
+  if (!admits(from, refuse)) {
+    return;
+  }
+  const def = own(state.contract.streams, name);
+  if (def === void 0 || !isHostServed(def)) {
+    refuse("NOT_FOUND", `${service} has no host-served stream "${name}"`);
+    return;
+  }
+  if (streamRoomOf(def, scope) !== state.room) {
+    refuse("FORBIDDEN", `The feed of scope "${scope}" is served by the host of another room`);
+    return;
+  }
+  const key = feedKey(name, scope);
+  if (!from.feeds.has(key) && from.feeds.size >= MAX_HOST_FEEDS) {
+    refuse("CONFLICT", `A peer may hold at most ${MAX_HOST_FEEDS} feeds of a host`);
+    return;
+  }
+  let chunks;
+  try {
+    chunks = chunksOf(state, name, scope, seedOf(state, name, def, scope));
+  } catch (error) {
+    refuse("INTERNAL", "The host could not make the feed's seed");
+    throwLater(error);
+    return;
+  }
+  if (chunks === void 0) {
+    refuse("INTERNAL", "The feed's seed holds an item over the message limit");
+    throwLater(
+      new RangeError(
+        `Host of ${state.room}: the seed of ${service}.${name} holds an item over ${state.maxBytes()} bytes with its message; keep each item smaller`
+      )
+    );
+    return;
+  }
+  from.feeds.add(key);
+  const subscribers = state.feeds.get(key) ?? /* @__PURE__ */ new Set();
+  state.feeds.set(key, subscribers);
+  subscribers.add(from);
+  chunks.forEach((chunk, index) => {
+    from.out.send("rel", [6, service, name, scope, chunk, index === chunks.length - 1]);
+  });
+}
+function leave(state, from, key) {
+  from.feeds.delete(key);
+  const subscribers = state.feeds.get(key);
+  subscribers?.delete(from);
+  if (subscribers?.size === 0) {
+    state.feeds.delete(key);
+  }
+}
+function receive(state, from, message) {
+  if (state.closed || !state.peers.has(from) || message[1] !== state.contract.name) {
+    return;
+  }
+  if (message[0] === 3) {
+    onChannel(state, from, message[2], message[3]);
+  } else if (message[0] === 4) {
+    onSubscribe(state, from, message[2], message[3]);
+  } else if (message[0] === 5) {
+    leave(state, from, feedKey(message[2], message[3]));
+  }
+}
+function keep(state, name, keepCount, scope, item) {
+  const scopes = state.kept.get(name) ?? /* @__PURE__ */ new Map();
+  state.kept.set(name, scopes);
+  const items = scopes.get(scope) ?? [];
+  scopes.delete(scope);
+  scopes.set(scope, [...items, item].slice(-keepCount));
+  if (scopes.size > MAX_KEPT_SCOPES) {
+    const [oldest] = scopes.keys();
+    if (oldest !== void 0) {
+      scopes.delete(oldest);
+    }
+  }
+}
+function push(state, name, scope, item) {
+  const service = state.contract.name;
+  const def = own(state.contract.streams, name);
+  if (def === void 0 || !isHostServed(def)) {
+    throw new TypeError(`host.stream: ${service} has no host-served stream "${name}"`);
+  }
+  if (typeof scope !== "string" || scope === "") {
+    throw new TypeError(`host.stream("${name}").push: pass (scope, item), the scope a string`);
+  }
+  const checked = validateNow(def.item, item);
+  if (checked === "async" || checked.issues !== void 0) {
+    throw new TypeError(
+      `host.stream("${name}").push: the item does not match the stream's schema${checked === "async" ? " (it validates asynchronously)" : ""}`
+    );
+  }
+  const message = [7, service, name, scope, checked.value];
+  const bytes = aloneBytes(state, name, scope, checked.value);
+  if (bytes > state.maxBytes()) {
+    throw new RangeError(
+      `host.stream("${name}").push: an item holds at most ${state.maxBytes()} bytes as JSON with its message; this one has ${bytes}`
+    );
+  }
+  const keepCount = own(state.implementation.streams ?? {}, name)?.seed === void 0 ? def.seed ?? 0 : 0;
+  if (keepCount > 0) {
+    keep(state, name, keepCount, scope, checked.value);
+  }
+  const label = def.volatile === true ? "fast" : "rel";
+  for (const to of state.feeds.get(feedKey(name, scope)) ?? []) {
+    to.out.send(label, message);
+  }
+}
+function createHostRuntime(contract, implementation, room, maxBytes) {
+  const state = {
+    contract,
+    implementation,
+    room,
+    maxBytes,
+    peers: /* @__PURE__ */ new Set(),
+    feeds: /* @__PURE__ */ new Map(),
+    kept: /* @__PURE__ */ new Map(),
+    warned: /* @__PURE__ */ new Set(),
+    closed: false
+  };
+  return Object.freeze({
+    attach(peer, send, close) {
+      const now = Date.now();
+      const from = {
+        peer,
+        out: createOutbox(send, close),
+        close,
+        buckets: /* @__PURE__ */ new Map(),
+        subscribes: { tokens: MAX_HOST_FEEDS, refilledAt: now, windowStart: now, dropped: 0 },
+        feeds: /* @__PURE__ */ new Set()
+      };
+      state.peers.add(from);
+      return {
+        receive: (message) => {
+          receive(state, from, message);
+        },
+        unserved: (message) => {
+          onUnserved(state, from, message);
+        },
+        detach: () => {
+          for (const key of [...from.feeds]) {
+            leave(state, from, key);
+          }
+          from.out.clear();
+          state.peers.delete(from);
+        }
+      };
+    },
+    get peers() {
+      return [...state.peers].map(({ peer }) => peer);
+    },
+    push: (stream, scope, item) => {
+      push(state, stream, scope, item);
+    },
+    close() {
+      state.closed = true;
+      for (const from of state.peers) {
+        from.out.clear();
+      }
+      state.peers.clear();
+      state.feeds.clear();
+    }
+  });
+}
+
+// src/client/host/host.ts
+function checkImplementation(contract, implementation) {
+  const owner = `defineHost(${contract.name})`;
+  const channels = implementation.channels ?? {};
+  for (const [name, def] of Object.entries(contract.channels)) {
+    const handler = Object.hasOwn(channels, name) ? channels[name] : void 0;
+    if (isHostServed(def) && typeof handler !== "function") {
+      throw new TypeError(
+        `${owner}: channels.${name} must be a handler: the room's host serves it`
+      );
+    }
+  }
+  for (const name of Object.keys(channels)) {
+    const def = Object.hasOwn(contract.channels, name) ? contract.channels[name] : void 0;
+    if (def === void 0 || !isHostServed(def)) {
+      throw new TypeError(`${owner}: "${name}" is not a channel the room's host serves`);
+    }
+  }
+  for (const [name, options] of Object.entries(implementation.streams ?? {})) {
+    const def = Object.hasOwn(contract.streams, name) ? contract.streams[name] : void 0;
+    if (def === void 0 || !isHostServed(def)) {
+      throw new TypeError(`${owner}: "${name}" is not a stream the room's host serves`);
+    }
+    if (options?.seed !== void 0 && typeof options.seed !== "function") {
+      throw new TypeError(`${owner}: streams.${name}.seed must be a function of the scope`);
+    }
+  }
+}
+function serve(contract, implementation, connection, room) {
+  if (!isRoomName(room)) {
+    throw new TypeError("serve: room must name an app room, of 1 to 256 characters");
+  }
+  const service = contract.name;
+  const runtime = createHostRuntime(
+    contract,
+    implementation,
+    room,
+    () => connection.getState().hello?.limits.peers?.maxMessageBytes ?? MAX_PEER_MESSAGE_BYTES
+  );
+  const served = serving(connection, room);
+  served.add(service, runtime);
+  let closed = false;
+  return Object.freeze({
+    room,
+    get peers() {
+      return runtime.peers;
+    },
+    stream: (name) => Object.freeze({
+      push: (scope, item) => {
+        runtime.push(name, scope, item);
+      }
+    }),
+    close() {
+      if (!closed) {
+        closed = true;
+        served.remove(service, runtime);
+      }
+    }
+  });
+}
+function defineHost(contract, implementation) {
+  const any = implementation;
+  checkImplementation(contract, any);
+  return Object.freeze({
+    contract,
+    serve: (connection, options) => serve(contract, any, connection, options.room)
+  });
+}
+
+export {
+  getAuthToken,
+  setAuthToken,
+  clearAuthToken,
+  signInUrl,
+  signOut,
+  authProviders,
+  signOutEverywhere,
+  newId,
+  defineHost
+};
+//# sourceMappingURL=chunk-Z7I6SONO.js.map