onelobby 0.4.1 → 0.6.0

package/dist/onelobby.global.js

@@ -1,4 +1,4 @@
-/*! onelobby 0.4.1 | MIT license */
+/*! onelobby 0.6.0 | MIT license */
 "use strict";
 var OneLobby = (() => {
   var __defProp = Object.defineProperty;
@@ -17,13 +17,16 @@ var OneLobby = (() => {
     }
     return to;
   };
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
   // src/global.ts
   var global_exports = {};
   __export(global_exports, {
+    BlueprintError: () => BlueprintError,
     CHAT_MAX_BYTES: () => CHAT_MAX_BYTES,
     Chat: () => Chat,
+    DEFAULT_NOSTR_RELAYS: () => DEFAULT_NOSTR_RELAYS,
+    DEFAULT_NOSTR_STUN: () => DEFAULT_NOSTR_STUN,
     DEFAULT_READY_TIMEOUT_MS: () => DEFAULT_READY_TIMEOUT_MS,
     ErrorCodes: () => ErrorCodes,
     Keepalive: () => Keepalive,
@@ -37,17 +40,23 @@ var OneLobby = (() => {
     MIN_PEER_TIMEOUT_MS: () => MIN_PEER_TIMEOUT_MS,
     OneLobby: () => OneLobby,
     OneLobbyError: () => OneLobbyError,
+    Pause: () => Pause,
     SharedState: () => SharedState,
     Voice: () => Voice,
+    checkNostrRelays: () => checkNostrRelays,
     closeCodeFor: () => closeCodeFor,
     codeFromUrl: () => codeFromUrl,
     decodeJoinCode: () => decodeJoinCode,
+    defineBlueprint: () => defineBlueprint,
     defineLobbyElement: () => defineLobbyElement,
     describeError: () => describeError,
+    directJoinInfo: () => directJoinInfo,
+    encodeRoomCode: () => encodeRoomCode,
     formatCode: () => formatCode,
     lobbyServerUrl: () => lobbyServerUrl,
     looksLikeJoinCode: () => looksLikeJoinCode,
     normalizeCode: () => normalizeCode,
+    parseBlueprint: () => parseBlueprint,
     shareUrl: () => shareUrl,
     webCodecsOpusAvailable: () => webCodecsOpusAvailable,
     webRtcLinkFactoryFor: () => webRtcLinkFactoryFor
@@ -156,7 +165,10 @@ var OneLobby = (() => {
     voice: 80,
     chat: 96,
     chat_history: 97,
-    chat_reject: 98
+    chat_reject: 98,
+    pause_request: 112,
+    pause_state: 113,
+    pause_refuse: 114
   };
   var MODE_LOCKSTEP = 1;
   var MODE_RAW = 2;
@@ -227,9 +239,9 @@ var OneLobby = (() => {
     }
   };
   var Reader = class {
-    constructor(buf) {
-      this.buf = buf;
-      this.dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    constructor(buf2) {
+      this.buf = buf2;
+      this.dv = new DataView(buf2.buffer, buf2.byteOffset, buf2.byteLength);
     }
     buf;
     dv;
@@ -377,6 +389,18 @@ var OneLobby = (() => {
         w.u32(msg.id);
         w.u8(msg.reason);
         break;
+      case "pause_request":
+        w.u8(msg.paused);
+        break;
+      case "pause_state":
+        w.u8(msg.paused);
+        w.u16(msg.byPeer);
+        w.u8(msg.flags);
+        break;
+      case "pause_refuse":
+        w.u8(msg.paused);
+        w.u8(msg.reason);
+        break;
     }
     const out = w.done();
     if (!allowOversize && out.length > MAX_FRAME_BYTES) throw new CodecError("too_long", `${out.length} > ${MAX_FRAME_BYTES}`);
@@ -385,11 +409,11 @@ var OneLobby = (() => {
   var TYPE_BY_ID = new Map(
     Object.keys(MsgType).map((k) => [MsgType[k], k])
   );
-  function decodeMessage(buf, reassembled = false) {
+  function decodeMessage(buf2, reassembled = false) {
     const max = reassembled ? MAX_REASSEMBLED_BYTES : MAX_FRAME_BYTES;
-    if (buf.length > max) throw new CodecError("too_long", `${buf.length} > ${max}`);
-    if (buf.length < HEADER_BYTES) throw new CodecError("too_short", "header");
-    const r = new Reader(buf);
+    if (buf2.length > max) throw new CodecError("too_long", `${buf2.length} > ${max}`);
+    if (buf2.length < HEADER_BYTES) throw new CodecError("too_short", "header");
+    const r = new Reader(buf2);
     const type = TYPE_BY_ID.get(r.u8());
     const route = r.u16();
     if (!type) return null;
@@ -472,14 +496,25 @@ var OneLobby = (() => {
       case "chat_reject":
         msg = { type, id: r.u32(), reason: r.u8() };
         break;
+      case "pause_request":
+        msg = { type, paused: r.u8() };
+        break;
+      case "pause_state":
+        msg = { type, paused: r.u8(), byPeer: r.u16(), flags: r.u8() };
+        break;
+      case "pause_refuse":
+        msg = { type, paused: r.u8(), reason: r.u8() };
+        break;
     }
-    if (r.pos !== buf.length) throw new CodecError("trailing", `${buf.length - r.pos} extra bytes`);
+    if (r.pos !== buf2.length) throw new CodecError("trailing", `${buf2.length - r.pos} extra bytes`);
     return { route, msg };
   }
   var CHAT_REJECT = { rate: 1, length: 2, mutedByHost: 3 };
   function chatRejectName(code) {
     return code === 1 ? "rate" : code === 2 ? "length" : code === 3 ? "muted_by_host" : "unknown";
   }
+  var PAUSE_FLAG_PAUSER_LEFT = 1;
+  var PAUSE_REFUSE = { notInGame: 1, rateLimited: 2, notAllowed: 3 };
 
   // src/chat.ts
   var CHAT_MAX_BYTES = 256;
@@ -764,6 +799,7 @@ var OneLobby = (() => {
     cancelTicker = null;
     baseTime = 0;
     emitted = 0;
+    held = false;
     ownHashes = /* @__PURE__ */ new Map();
     peerHashes = /* @__PURE__ */ new Map();
     desyncs = /* @__PURE__ */ new Map();
@@ -869,6 +905,23 @@ var OneLobby = (() => {
       this._started = true;
       this.emit("started");
     }
+    /** The shared pause is on: the host emits no frames and a joiner expects none (no silent-host check). */
+    get isHeld() {
+      return this.held;
+    }
+    /**
+     * Pause (true) or resume (false) frame emission (the shared pause calls this; not for games). Resuming rebases the
+     * host's tick clock to now, so the next frame is simply tick+1 (no gap, no burst) and nobody counts as silent.
+     */
+    hold(held) {
+      if (this.held === held) return;
+      this.held = held;
+      if (held) return;
+      const now = this.hub.clock.now();
+      this.baseTime = now - this.emitted * (1e3 / this.hub.tickRate);
+      this.lastFrameRx = now;
+      for (const p of this.ready) this.lastHashRx.set(p, now);
+    }
     stop() {
       this.cancelTicker?.();
       this.cancelTicker = null;
@@ -884,7 +937,7 @@ var OneLobby = (() => {
     }
     // ---- host: frame emission ---------------------------------------------------------------------------------------
     pump(interval) {
-      if (!this.hosting) return;
+      if (!this.hosting || this.held) return;
       const now = this.hub.clock.now();
       let due = Math.floor((now - this.baseTime + 1) / interval) - this.emitted;
       if (due > 10) {
@@ -1121,7 +1174,7 @@ var OneLobby = (() => {
     }
     /** True when a started joiner has heard no frames for 3 s: the Lobby then runs the host-loss rule (s.9). */
     hostSilent() {
-      return !this.hosting && this._started && this.msSinceFrame > HOST_SILENCE_MS;
+      return !this.hosting && !this.held && this._started && this.msSinceFrame > HOST_SILENCE_MS;
     }
     /** Reset the silence timer, e.g. after the link to a new host opened. */
     touch() {
@@ -1287,6 +1340,138 @@ var OneLobby = (() => {
     return new OneLobbyError(String(m.code ?? "error"), m.msg === void 0 ? void 0 : String(m.msg), m.data);
   }
 
+  // src/pause.ts
+  var PAUSE_MIN_REQUEST_GAP_MS = 500;
+  var NONE = Object.freeze({ paused: false, byPeer: 0, pauserLeft: false });
+  function refusalName(code) {
+    return code === PAUSE_REFUSE.notInGame ? "not_in_game" : code === PAUSE_REFUSE.rateLimited ? "rate_limited" : code === PAUSE_REFUSE.notAllowed ? "not_allowed" : "unknown";
+  }
+  var Pause = class extends Emitter {
+    constructor(hub, deps) {
+      super();
+      this.hub = hub;
+      this.deps = deps;
+    }
+    hub;
+    deps;
+    /** Set by a blueprint (`session.pause`); the default is "anyone". */
+    mode = "anyone";
+    /**
+     * Host: replaces the default policy. Called with (requesting peer, true to pause / false to resume); return true to
+     * allow. Default: anyone pauses, the pauser or the host resumes (host only in "host" mode). Phase and rate run first.
+     */
+    policy = null;
+    current = NONE;
+    lastAccepted = /* @__PURE__ */ new Map();
+    /** The current shared state (the same on every peer once the host's broadcast has arrived). */
+    get state() {
+      return this.current;
+    }
+    /**
+     * True when the local peer may resume now under the default policy: the pauser or the host (in "host" mode, the
+     * host). A custom `policy` lives on the host, so on a joiner this is a hint.
+     */
+    get canResume() {
+      return this.current.paused && this.defaultAllows(this.hub.localPeerId, false);
+    }
+    /**
+     * Ask to pause (true) or resume (false) the match for everyone. Throws `pause_disabled` when the blueprint says
+     * `session.pause` is "off" (the default; set it to "anyone" or "host" in onelobby.json). Works only while the lobby
+     * is in game (phase "in_game", after `start()`): before that the host refuses with `not_in_game`. The result arrives
+     * as `changed` or `refused`; asking for the state that already holds does nothing.
+     */
+    request(paused) {
+      if (this.mode === "off") throw new OneLobbyError("pause_disabled", 'pause is off in onelobby.json (session.pause is "off"); set session.pause to "anyone" or "host" to turn it on');
+      if (this.hub.isHost) this.hostHandle(this.hub.localPeerId, paused);
+      else this.hub.sendToHost({ type: "pause_request", paused: paused ? 1 : 0 });
+    }
+    /**
+     * Host only: unpause at once, skipping the policy and the rate limit. Call it before a restart or game over so the
+     * next round does not start frozen. Does nothing when not paused.
+     */
+    clear() {
+      if (!this.hub.isHost) throw new Error("only the host can clear the pause");
+      if (!this.current.paused) return;
+      this.set({ paused: false, byPeer: this.hub.localPeerId, pauserLeft: false }, true);
+    }
+    // ---- internals (called by Lobby) ------------------------------------------------------------------------------
+    handle(from, msg) {
+      switch (msg.type) {
+        case "pause_request":
+          if (this.hub.isHost && this.hub.connectedPeers().includes(from)) this.hostHandle(from, msg.paused !== 0);
+          break;
+        case "pause_state":
+          if (!this.hub.isHost && from === this.hub.hostPeerId) {
+            this.set({ paused: msg.paused !== 0, byPeer: msg.byPeer, pauserLeft: (msg.flags & PAUSE_FLAG_PAUSER_LEFT) !== 0 }, false);
+          }
+          break;
+        case "pause_refuse":
+          if (!this.hub.isHost && from === this.hub.hostPeerId) this.emit("refused", refusalName(msg.reason));
+          break;
+      }
+    }
+    /** Host: a late joiner's link is up; it gets the state when there is one to tell. */
+    sendState(peerId) {
+      if (this.current.paused) this.hub.sendTo(peerId, this.stateMessage(), 0);
+    }
+    /** A peer is gone: the host takes over the pause its leaver held. */
+    onPeerLeft(peerId) {
+      this.lastAccepted.delete(peerId);
+      const s = this.current;
+      if (this.hub.isHost && s.paused && !s.pauserLeft && s.byPeer === peerId) {
+        this.set({ paused: true, byPeer: this.hub.localPeerId, pauserLeft: true }, true);
+      }
+    }
+    /** This peer just became the host (migration): it keeps the state as is, and takes over a pause whose holder is gone. */
+    onBecameHost() {
+      this.deps.hold(this.current.paused);
+      const s = this.current;
+      if (s.paused && !s.pauserLeft && !this.deps.hasPeer(s.byPeer)) {
+        this.set({ paused: true, byPeer: this.hub.localPeerId, pauserLeft: true }, true);
+      }
+    }
+    /** The lobby went back to the lobby phase: nothing stays paused. */
+    onLobbyPhase() {
+      if (!this.current.paused) return;
+      this.set({ paused: false, byPeer: this.hub.hostPeerId, pauserLeft: false }, this.hub.isHost);
+    }
+    // ---- host path --------------------------------------------------------------------------------------------------
+    defaultAllows(peer, wantPaused) {
+      if (this.mode === "host") return peer === this.hub.hostPeerId;
+      return wantPaused || peer === this.current.byPeer || peer === this.hub.hostPeerId;
+    }
+    hostHandle(from, want) {
+      if (this.mode === "off") return this.refuse(from, want, PAUSE_REFUSE.notAllowed);
+      if (this.deps.phase() !== "in_game") return this.refuse(from, want, PAUSE_REFUSE.notInGame);
+      if (want === this.current.paused) return;
+      const now = this.hub.clock.now();
+      const last = this.lastAccepted.get(from);
+      if (last !== void 0 && now - last < PAUSE_MIN_REQUEST_GAP_MS) return this.refuse(from, want, PAUSE_REFUSE.rateLimited);
+      const ok = this.policy ? this.policy(from, want) : this.defaultAllows(from, want);
+      if (!ok) return this.refuse(from, want, PAUSE_REFUSE.notAllowed);
+      this.lastAccepted.set(from, now);
+      this.set({ paused: want, byPeer: from, pauserLeft: false }, true);
+    }
+    refuse(to, want, reason) {
+      if (to === this.hub.localPeerId) this.emit("refused", refusalName(reason));
+      else this.hub.sendTo(to, { type: "pause_refuse", paused: want ? 1 : 0, reason }, 0);
+    }
+    stateMessage() {
+      const s = this.current;
+      return { type: "pause_state", paused: s.paused ? 1 : 0, byPeer: s.byPeer, flags: s.pauserLeft ? PAUSE_FLAG_PAUSER_LEFT : 0 };
+    }
+    set(next, broadcast) {
+      const prev = this.current;
+      this.current = Object.freeze(next);
+      this.deps.hold(next.paused);
+      if (broadcast) {
+        const msg = this.stateMessage();
+        for (const p of this.hub.connectedPeers()) this.hub.sendTo(p, msg, 0);
+      }
+      if (prev.paused !== next.paused || prev.byPeer !== next.byPeer || prev.pauserLeft !== next.pauserLeft) this.emit("changed", next);
+    }
+  };
+
   // src/voice-core.ts
   var SAMPLE_RATE = 48e3;
   var FRAME_MS = 20;
@@ -1807,6 +1992,7 @@ var OneLobby = (() => {
   // src/lobby.ts
   var MIN_PEER_TIMEOUT_MS = 6e3;
   var KICK_LINGER_MS = 3e3;
+  var HELD_OFFER_MS = 2e4;
   function seatName(p) {
     const n = typeof p.name === "string" ? p.name.trim() : "";
     if (n && n !== "Player") return p;
@@ -1823,31 +2009,61 @@ var OneLobby = (() => {
     tickRate;
     lockstep;
     chat;
+    /** The shared co-op pause (docs/recipes/pause.md). */
+    pause;
     voice;
     localPeerId;
     hostPeerId;
     phase;
     meta;
+    /** The lobby's name as the server keeps it (host()'s `name`, sanitised); "" if the server sends none. */
+    name;
     resumeToken;
     /** Last measured round trip to the host in ms (joiners), or 0. */
     rtt = 0;
     /**
-     * Direct-IP host only (onelobby/direct): the code friends paste to join, e.g. "6B01-RGFE-P2B" (docs/direct-ip.md
+     * Direct-IP host only (onelobby/direct): the code friends paste to join, e.g. "6B01-RGFE-P2B" (docs/design/direct-ip.md
      * s.2a). Show it with joinCodeKind. Empty when the machine has no IPv4 address, and on joiners.
      */
     joinCode = "";
-    /** "internet": the router forwarded the port and the code carries its public address; "same_network": the LAN address. */
+    /**
+     * "nostr": a version 1 code that works through public Nostr relays (spec/nostr-signaling.md; the default for a direct
+     * host). "internet": the router forwarded the port and the code carries its public address; "same_network": the LAN
+     * address. "none": no code.
+     */
     joinCodeKind = "none";
+    /**
+     * Direct-IP host only: the IP code (address and port, version 0), with `directCodeKind` "internet" or "same_network".
+     * Equal to `joinCode` when Nostr is off; otherwise the code to hand out for LAN play or when the router port is open.
+     */
+    directCode = "";
+    directCodeKind = "none";
     /** Direct-IP host only: this machine's addresses with the port, for an "Advanced" fold-out. */
     directAddresses = [];
     /** Direct-IP host only: how the router port-open went ("UPnP", "no UPnP gateway answered; ...", "off"). */
     portMapping = "";
+    /** Direct-IP host only: the one startup line (bound port, join code, port mapping); see `formatHostLog` in onelobby/direct. */
+    directHostLog = "";
+    /** Browser host only (`kit.hostNostr`): true while the host tab is hidden (see the `hostHiddenChanged` event). */
+    hostHidden = false;
+    /** @internal kit.hostNostr: the tab's visibility changed. */
+    setHostHidden(hidden) {
+      if (this.hostHidden === hidden) return;
+      this.hostHidden = hidden;
+      this.emit("hostHiddenChanged", hidden);
+    }
+    /** @internal onelobby/direct: fires `joinCodeChanged` with the current code. */
+    notifyJoinCodeChanged() {
+      this.emit("joinCodeChanged", this.joinCode, this.joinCodeKind);
+    }
     signaling;
     cfg;
     roster = /* @__PURE__ */ new Map();
     links = /* @__PURE__ */ new Map();
     /** ICE from a peer that has no link yet: its candidates can overtake its offer (node-datachannel). */
     earlyIce = /* @__PURE__ */ new Map();
+    /** Offers from roster members that arrived while the host link was open (see offerVerdict), by sender. */
+    heldOffers = /* @__PURE__ */ new Map();
     connected = /* @__PURE__ */ new Set();
     // host: peers that said hi
     hiSentTo = /* @__PURE__ */ new Set();
@@ -1872,6 +2088,8 @@ var OneLobby = (() => {
     lastHeard = /* @__PURE__ */ new Map();
     /** Host: links of kicked / disconnected peers, kept open briefly (removePeer `linger`). */
     lingering = /* @__PURE__ */ new Set();
+    /** Host: joiners that joined but are not ready yet, with the cancel of their readyTimeoutMs timer (peerFailed). */
+    notReady = /* @__PURE__ */ new Map();
     /** Host: per-peer fixed window for rateLimit. */
     rate = /* @__PURE__ */ new Map();
     /**
@@ -1901,6 +2119,7 @@ var OneLobby = (() => {
       this.hostPeerId = st.hostId;
       this.phase = st.phase;
       this.meta = { ...st.meta };
+      this.name = st.name ?? "";
       this.resumeToken = st.resumeToken;
       for (const p of st.peers) this.roster.set(p.peerId, seatName(p));
       this.ready.catch(() => {
@@ -1934,6 +2153,11 @@ var OneLobby = (() => {
       this.lockstep = new Lockstep(this.hub, { hashEveryTicks: cfg.hashEveryTicks });
       this.chat = new Chat(this.hub, cfg.wall, (id) => this.voice.isMutedPeer(id));
       this.voice = new Voice(this.hub, cfg.voice);
+      this.pause = new Pause(this.hub, {
+        phase: () => this.phase,
+        hold: (held) => this.lockstep.hold(held),
+        hasPeer: (id) => this.roster.has(id)
+      });
       this.lockstep.on("started", () => this.setPhase("in_game"));
       this.lockstep.on("error", (e) => this.reportError(e));
       this.signaling.onMessage = (m) => this.onSignaling(m);
@@ -2138,6 +2362,8 @@ var OneLobby = (() => {
       this.teardown("ice_failed");
     }
     // ---- links -----------------------------------------------------------------------------------------------------
+    /** @internal A direct host's hub learns where each joiner's link comes from (Nostr kick bans the address too). */
+    linkAddressSink = null;
     makeLink(peerId, relayOnly = this.cfg.relayOnly) {
       const old = this.links.get(peerId);
       if (old) {
@@ -2152,6 +2378,7 @@ var OneLobby = (() => {
       link.onClose = (reason) => this.onLinkClosed(peerId, link, reason);
       link.onMessage = (ch, bytes) => this.onData(peerId, ch, bytes);
       link.onPath = (path) => this.signaling.send({ t: "path", path });
+      link.onRemoteAddress = (ip) => this.linkAddressSink?.(peerId, ip);
       return link;
     }
     /** Host side: offer to a joiner. */
@@ -2201,6 +2428,7 @@ var OneLobby = (() => {
         return;
       }
       if (!d) return;
+      if (!this.isHost && from !== this.hostPeerId && d.msg.type !== "host_claim") return;
       if (!reassembled) this.lastHeard.set(from, this.cfg.clock.now());
       const { msg, route } = d;
       switch (msg.type) {
@@ -2242,6 +2470,11 @@ var OneLobby = (() => {
         case "chat_reject":
           this.chat.handle(from, route, msg);
           break;
+        case "pause_request":
+        case "pause_state":
+        case "pause_refuse":
+          this.pause.handle(from, msg);
+          break;
         case "voice":
           if (channel === "voice") this.voice.handle(from, route, msg);
           break;
@@ -2261,6 +2494,8 @@ var OneLobby = (() => {
     }
     onHi(from, lastTick) {
       this.connected.add(from);
+      this.notReady.get(from)?.();
+      this.notReady.delete(from);
       this.sendTo(from, {
         type: "welcome_dc",
         // the tick the snapshot will carry (the game's applied tick), so welcome_dc.tick == snapshot.tick even when
@@ -2271,6 +2506,7 @@ var OneLobby = (() => {
         hostId: this.localPeerId
       }, 0);
       this.chat.sendHistory(from);
+      this.pause.sendState(from);
       if (this.mode === "lockstep") this.lockstep.onPeerHi(from, lastTick);
       this.emit("peerReady", this.roster.get(from) ?? { peerId: from, name: "" });
       this.flush(from);
@@ -2309,6 +2545,11 @@ var OneLobby = (() => {
       if (hostId === this.hostPeerId) return;
       this.hostPeerId = hostId;
       this.emit("hostChanged", hostId);
+      const held = this.heldOffers.get(hostId);
+      if (held) {
+        this.heldOffers.delete(hostId);
+        if (this.cfg.clock.now() - held.at <= HELD_OFFER_MS) void this.acceptOffer(hostId, held.payload);
+      }
     }
     /** The host is gone (link closed, no frames for 3 s, or the server said so): run the s.9 rule. */
     handleHostLost(reason) {
@@ -2333,6 +2574,15 @@ var OneLobby = (() => {
       }
       const candidate = pickNewHost([...this.roster.keys(), this.localPeerId], failed) ?? this.localPeerId;
       if (candidate === this.localPeerId) this.becomeHost();
+      this.replayHeldOffers();
+    }
+    /** Offers that came from roster members while the host link was still open: now the host is lost, answer them. */
+    replayHeldOffers() {
+      const now = this.cfg.clock.now();
+      for (const [from, held] of [...this.heldOffers]) {
+        this.heldOffers.delete(from);
+        if (now - held.at <= HELD_OFFER_MS && this.roster.has(from)) void this.acceptOffer(from, held.payload);
+      }
     }
     becomeHost() {
       this.epoch = this.epoch + 1 & 65535;
@@ -2342,6 +2592,7 @@ var OneLobby = (() => {
       this.hiSentTo.clear();
       this.lastHeard.clear();
       this.lockstep.becomeHost();
+      this.pause.onBecameHost();
       this.emit("hostChanged", this.localPeerId);
       if (this.serverUp) this.signaling.send({ t: "host_changed", hostId: this.localPeerId, epoch: this.epoch });
       for (const p of this.roster.keys()) {
@@ -2349,6 +2600,7 @@ var OneLobby = (() => {
       }
     }
     onHostClaim(from, epoch, hostId) {
+      if (hostId !== from) return;
       const mine = { epoch: this.epoch, hostId: this.hostPeerId };
       const theirs = { epoch, hostId };
       if (hostId === this.hostPeerId && epoch === this.epoch && !this.isHost) {
@@ -2382,7 +2634,10 @@ var OneLobby = (() => {
           const peer = seatName(m.peer);
           this.roster.set(peer.peerId, peer);
           this.emit("peerJoined", peer);
-          if (this.isHost) this.offerTo(peer.peerId);
+          if (this.isHost) {
+            this.watchReady(peer.peerId);
+            this.offerTo(peer.peerId);
+          }
           break;
         }
         case "peer_left":
@@ -2411,6 +2666,7 @@ var OneLobby = (() => {
         case "lobby": {
           const st = m;
           this.meta = { ...st.meta };
+          if (st.name) this.name = st.name;
           if (st.resumeToken && st.resumeToken !== this.resumeToken) {
             this.resumeToken = st.resumeToken;
             this.seatSink?.(this.resumeToken);
@@ -2447,16 +2703,15 @@ var OneLobby = (() => {
       if (s.sdp) payload.sdp = s.sdp;
       if (s.ice) payload.ice = s.ice;
       if (s.sdp?.type === "offer") {
-        link = this.makeLink(from);
-        const early = this.earlyIce.get(from) ?? [];
-        this.earlyIce.delete(from);
-        const done = link.handleSignal(payload);
-        for (const e of early) void link.handleSignal(e);
-        await done;
+        const verdict = this.offerVerdict(from);
+        if (verdict === "hold") {
+          if (this.heldOffers.size < 64 || this.heldOffers.has(from)) this.heldOffers.set(from, { payload, at: this.cfg.clock.now() });
+        } else if (verdict === "accept") await this.acceptOffer(from, payload);
         return;
       }
       if (!link) {
         if (!payload.ice || this.ended || !this.roster.has(from)) return;
+        if (this.cfg.direct && from !== this.hostPeerId) return;
         const q = this.earlyIce.get(from) ?? [];
         if (q.length < 64) q.push(payload);
         this.earlyIce.set(from, q);
@@ -2464,6 +2719,28 @@ var OneLobby = (() => {
       }
       await link.handleSignal(payload);
     }
+    /**
+     * Whether an SDP offer from `from` may be answered. The host (or a joiner's host) always may. Direct lobbies have no
+     * migration, so nobody else. In a server lobby a roster member may dial us when we are the host (a claim race decides
+     * who wins) or when our own link to the host is gone (the migration window); while that link is open the offer is
+     * held, to be answered if the host turns out to be lost a moment later.
+     */
+    offerVerdict(from) {
+      if (this.ended || from === this.localPeerId) return "drop";
+      if (!this.isHost && from === this.hostPeerId) return "accept";
+      if (this.cfg.direct || !this.roster.has(from)) return "drop";
+      if (this.isHost) return "accept";
+      if (!this.isReady) return "drop";
+      return this.links.get(this.hostPeerId)?.isOpen ? "hold" : "accept";
+    }
+    async acceptOffer(from, payload) {
+      const link = this.makeLink(from);
+      const early = this.earlyIce.get(from) ?? [];
+      this.earlyIce.delete(from);
+      const done = link.handleSignal(payload);
+      for (const e of early) void link.handleSignal(e);
+      await done;
+    }
     /**
      * `linger` (host kick / disconnect): stop using the peer's link at once but leave it open until that peer closes it
      * or KICK_LINGER_MS pass. The hub tells the peer over its WebSocket; closing the data link first would make it look
@@ -2477,6 +2754,12 @@ var OneLobby = (() => {
       }
       if (peer) this.roster.delete(peerId);
       this.earlyIce.delete(peerId);
+      const cancelWatch = this.notReady.get(peerId);
+      if (cancelWatch) {
+        cancelWatch();
+        this.notReady.delete(peerId);
+        if (peer && reason !== "kicked" && reason !== "disconnected") this.emit("peerFailed", peer, reason);
+      }
       const link = this.links.get(peerId);
       if (link && peerId !== this.hostPeerId) {
         link.onMessage = null;
@@ -2504,6 +2787,7 @@ var OneLobby = (() => {
       this.lockstep.onPeerLeft(peerId);
       this.chat.onPeerLeft(peerId);
       this.voice.onPeerLeft(peerId);
+      this.pause.onPeerLeft(peerId);
       if (peer) this.emit("peerLeft", peer, reason, close);
       if (peerId === this.hostPeerId && !this.isHost) {
         this.handleHostLost(reason);
@@ -2518,6 +2802,7 @@ var OneLobby = (() => {
       if (p !== "lobby" && p !== "in_game") return;
       if (this.phase === p) return;
       this.phase = p;
+      if (p === "lobby") this.pause.onLobbyPhase();
       if (p === "in_game" && !this.lockstep.started) this.lockstep.markStarted();
       this.emit("phase", p);
     }
@@ -2563,10 +2848,26 @@ var OneLobby = (() => {
       if (this.ended || this.isHost) return;
       this.sendTo(this.hostPeerId, { type: "ping", n: ++this.pingN, t: this.cfg.clock.now() >>> 0 }, 0, "fast");
     }
+    /** Host: report a joiner that is not ready `readyTimeoutMs` after joining as peerFailed("timeout"), once. */
+    watchReady(peerId) {
+      const ms = this.cfg.readyTimeoutMs ?? 0;
+      let cancel = () => {
+      };
+      if (ms > 0) {
+        cancel = this.cfg.clock.setTimeout(() => {
+          if (!this.notReady.delete(peerId)) return;
+          const peer = this.roster.get(peerId);
+          if (peer) this.emit("peerFailed", peer, "timeout");
+        }, ms);
+      }
+      this.notReady.set(peerId, cancel);
+    }
     teardown(reason, close) {
       if (this.ended) return;
       this.ended = true;
       this.cancelReadyTimer?.();
+      for (const cancel of this.notReady.values()) cancel();
+      this.notReady.clear();
       if (!this.isReady) {
         const code = reason === "ice_failed" || reason === "kicked" ? reason : "closed";
         this.failReady(new OneLobbyError(code, `the lobby ended before connecting (${reason})`));
@@ -2582,6 +2883,7 @@ var OneLobby = (() => {
       }
       this.links.clear();
       this.earlyIce.clear();
+      this.heldOffers.clear();
       this.lingering.clear();
       this.signaling.onClose = null;
       this.signaling.onMessage = null;
@@ -2605,7 +2907,7 @@ var OneLobby = (() => {
   var webCodecsOpus = {
     createEncoder(opts, onFrame) {
       let ts = 0;
-      const enc4 = new AudioEncoder({
+      const enc5 = new AudioEncoder({
         output: (chunk) => {
           const out = new Uint8Array(chunk.byteLength);
           chunk.copyTo(out);
@@ -2613,7 +2915,7 @@ var OneLobby = (() => {
         },
         error: (e) => console.error("onelobby: AudioEncoder", e)
       });
-      enc4.configure({
+      enc5.configure({
         codec: "opus",
         sampleRate: SAMPLE_RATE,
         numberOfChannels: 1,
@@ -2631,11 +2933,11 @@ var OneLobby = (() => {
             data: pcm
           });
           ts += 2e4;
-          enc4.encode(data);
+          enc5.encode(data);
           data.close();
         },
         close() {
-          if (enc4.state !== "closed") enc4.close();
+          if (enc5.state !== "closed") enc5.close();
         }
       };
     },
@@ -2720,10 +3022,10 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     }
     play(peerId, pcm, gain) {
       if (pcm.length === 0) return;
-      const buf = this.ctx.createBuffer(1, pcm.length, SAMPLE_RATE);
-      buf.copyToChannel(pcm, 0);
+      const buf2 = this.ctx.createBuffer(1, pcm.length, SAMPLE_RATE);
+      buf2.copyToChannel(pcm, 0);
       const src = this.ctx.createBufferSource();
-      src.buffer = buf;
+      src.buffer = buf2;
       const g = this.ctx.createGain();
       g.gain.value = gain;
       src.connect(g).connect(this.ctx.destination);
@@ -2752,6 +3054,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     onClose = null;
     onMessage = null;
     onPath = null;
+    onRemoteAddress = null;
     pc;
     channels = {};
     pendingIce = [];
@@ -2874,6 +3177,8 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         const l = pair && byId.get(pair.localCandidateId);
         const r = pair && byId.get(pair.remoteCandidateId);
         if (l && r) {
+          const addr = String(r.address ?? r.ip ?? "");
+          if (r.candidateType !== "relay" && l.candidateType !== "relay" && addr && !addr.endsWith(".local")) this.onRemoteAddress?.(addr.replace(/^::ffff:/i, ""));
           this.onPath?.(l.candidateType === "relay" || r.candidateType === "relay" ? "relayed" : "direct");
           return;
         }
@@ -2932,7 +3237,9 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     const ip = parseIPv4(ipv4);
     if (ip === null) throw new Error(`not an IPv4 address: ${ipv4}`);
     if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`bad port ${port}`);
-    const data = BigInt(ip) << 16n | BigInt(port);
+    return encodeData(BigInt(ip) << 16n | BigInt(port));
+  }
+  function encodeData(data) {
     let v = data << 5n | BigInt(crc5(data, 50));
     let s = "";
     for (let i = 0; i < JOIN_CODE_LENGTH; i++) {
@@ -2941,6 +3248,15 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     }
     return `${s.slice(0, 4)}-${s.slice(4, 8)}-${s.slice(8)}`;
   }
+  function encodeRoomCodeFor(roomHex) {
+    if (!/^[0-9a-fA-F]{12}$/.test(roomHex)) throw new Error(`room must be 12 hex digits: ${roomHex}`);
+    return encodeData(1n << 48n | BigInt("0x" + roomHex));
+  }
+  function encodeRoomCode() {
+    const b = new Uint8Array(6);
+    globalThis.crypto.getRandomValues(b);
+    return encodeRoomCodeFor([...b].map((x) => x.toString(16).padStart(2, "0")).join(""));
+  }
   function normalizeJoinCode(input) {
     const s = input.replace(/[ \-]/g, "").replace(/[a-z]/g, (c) => c.toUpperCase()).replace(/[IL]/g, "1").replace(/O/g, "0");
     if (s.length !== JOIN_CODE_LENGTH) return null;
@@ -2954,7 +3270,9 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     for (const c of s) v = v << 5n | BigInt(CROCKFORD_ALPHABET.indexOf(c));
     const data = v >> 5n;
     if (crc5(data, 50) !== Number(v & 31n)) return { error: "bad_code" };
-    if (data >> 48n !== 0n) return { error: "unknown_version" };
+    const version = data >> 48n;
+    if (version === 1n) return { room: (data & 0xffffffffffffn).toString(16).padStart(12, "0") };
+    if (version !== 0n) return { error: "unknown_version" };
     const port = Number(data & 0xffffn);
     if (port === 0) return { error: "bad_code" };
     const a = Number(data >> 16n & 0xffffffffn);
@@ -2964,6 +3282,847 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     return !/[.:]/.test(input) && normalizeJoinCode(input) !== null;
   }
 
+  // src/nostr/limits.ts
+  var BATCH_MS = 30;
+  var RESEND_MS = 3e3;
+  var MAX_RESENDS = 5;
+  var BEAT_MS = 1e4;
+  var SILENCE_MS2 = 3e4;
+  var MAX_HELD = 64;
+  var MAX_OUT_FRAMES = 128;
+  var MAX_OUT_BYTES = 256 * 1024;
+  var MAX_FRAME_BYTES2 = 3e4;
+  var TICK_MS = 250;
+  var NEW_SESSION_BURST = 16;
+  var MAX_SESSION_BURST = 64;
+  var NEW_SESSION_REFILL_MS = 1e3;
+  var WAITING_MAX = 64;
+  var WAITING_STALE_MS = 5e3;
+  var OPEN_EVERY_MS = 2e3;
+  var GIVE_UP_MS = 15e3;
+  var HOST_NOSTR_FIRST_RELAY_MS = 1e4;
+  var JOINER_FIRST_RELAY_MS = 1e4;
+  var RELAY_REST_WAIT_MS = 1500;
+  var RELAY_REST_POLL_MS = 50;
+
+  // src/nostr/link.ts
+  var utf8 = new TextEncoder();
+  var byteLen = (s) => utf8.encode(s).length;
+  var ReliableLink = class {
+    o;
+    queue = [];
+    queueBytes = 0;
+    unackedBytes = 0;
+    nextSeq = 1;
+    unacked = /* @__PURE__ */ new Map();
+    rcvNext = 1;
+    // next seq to deliver
+    held = /* @__PURE__ */ new Map();
+    ackOwed = false;
+    lastSent;
+    lastHeard;
+    cancelFlush = null;
+    cancelTick = null;
+    done = false;
+    constructor(o) {
+      this.o = o;
+      this.lastSent = this.lastHeard = o.clock.now();
+      this.cancelTick = o.clock.setInterval(() => this.tick(), TICK_MS);
+    }
+    get closed() {
+      return this.done;
+    }
+    /** Queues a hub text; sent within 30 ms, packed with its neighbours. */
+    send(text) {
+      if (this.done) return;
+      const n = byteLen(text);
+      if (this.queue.length + this.unacked.size >= MAX_OUT_FRAMES || this.queueBytes + this.unackedBytes + n > MAX_OUT_BYTES) return;
+      this.queue.push(text);
+      this.queueBytes += n;
+      this.scheduleFlush();
+    }
+    /** Any frame arrived from the peer (including `open`, which only proves it is alive). */
+    heard() {
+      this.lastHeard = this.o.clock.now();
+    }
+    /** `data`, `beat` and `close` frames from the peer. */
+    receive(f) {
+      if (this.done) return;
+      this.heard();
+      if (f.type === "close") {
+        const reason = typeof f.reason === "string" ? f.reason : "";
+        this.stop();
+        this.o.onPeerClose(reason);
+        return;
+      }
+      if (f.type !== "data" && f.type !== "beat") return;
+      if (Number.isInteger(f.ack)) {
+        for (const s of [...this.unacked.keys()]) if (s <= f.ack) this.dropUnacked(s);
+      }
+      if (f.type === "beat") return;
+      const msgs = Array.isArray(f.msgs) ? f.msgs.filter((m) => typeof m === "string") : [];
+      if (!Number.isInteger(f.seq) || f.seq < 1) return;
+      this.ackOwed = true;
+      if (f.seq === this.rcvNext) {
+        this.rcvNext++;
+        for (const m of msgs) this.o.deliver(m);
+        for (let h = this.held.get(this.rcvNext); h && !this.done; h = this.held.get(this.rcvNext)) {
+          this.held.delete(this.rcvNext);
+          this.rcvNext++;
+          for (const m of h) this.o.deliver(m);
+        }
+      } else if (f.seq > this.rcvNext && f.seq <= this.rcvNext + MAX_HELD) this.held.set(f.seq, msgs);
+      this.scheduleFlush();
+    }
+    /** Sends what is queued, then `close` (once), and stops. */
+    close(reason = "") {
+      if (this.done) return;
+      this.flush();
+      this.o.send({ type: "close", seq: 0, ack: this.rcvNext - 1, ...reason ? { reason } : {} });
+      this.stop();
+    }
+    /** Stops the timers without telling the peer. */
+    stop() {
+      this.done = true;
+      this.cancelFlush?.();
+      this.cancelTick?.();
+      this.cancelFlush = this.cancelTick = null;
+      this.unacked.clear();
+      this.unackedBytes = 0;
+      this.held.clear();
+      this.queue = [];
+      this.queueBytes = 0;
+    }
+    scheduleFlush() {
+      if (this.cancelFlush || this.done) return;
+      this.cancelFlush = this.o.clock.setTimeout(() => {
+        this.cancelFlush = null;
+        this.flush();
+      }, BATCH_MS);
+    }
+    flush() {
+      if (this.done) return;
+      this.cancelFlush?.();
+      this.cancelFlush = null;
+      const now = this.o.clock.now();
+      if (this.queue.length === 0) {
+        if (this.ackOwed) this.emit({ type: "beat", seq: 0, ack: this.rcvNext - 1 }, now);
+        return;
+      }
+      let batch = [];
+      let bytes = 0;
+      const ship = () => {
+        if (batch.length === 0) return;
+        const frame = { type: "data", seq: this.nextSeq++, ack: this.rcvNext - 1, msgs: batch };
+        this.unacked.set(frame.seq, { bytes, frame, lastSent: now, resends: 0 });
+        this.unackedBytes += bytes;
+        this.emit(frame, now);
+        batch = [];
+        bytes = 0;
+      };
+      this.queueBytes = 0;
+      for (const m of this.queue.splice(0)) {
+        const n = byteLen(m);
+        if (batch.length > 0 && bytes + n > MAX_FRAME_BYTES2) ship();
+        batch.push(m);
+        bytes += n;
+      }
+      ship();
+    }
+    dropUnacked(seq) {
+      const p = this.unacked.get(seq);
+      if (!p) return;
+      this.unackedBytes -= p.bytes;
+      this.unacked.delete(seq);
+    }
+    emit(f, now) {
+      this.lastSent = now;
+      this.ackOwed = false;
+      this.o.send(f);
+    }
+    tick() {
+      if (this.done) return;
+      const now = this.o.clock.now();
+      if (now - this.lastHeard >= SILENCE_MS2) return this.die();
+      for (const p of this.unacked.values()) {
+        if (now - p.lastSent < RESEND_MS) continue;
+        if (p.resends >= MAX_RESENDS) return this.die();
+        p.resends++;
+        p.lastSent = now;
+        this.o.send({ ...p.frame, ack: this.rcvNext - 1 });
+        this.lastSent = now;
+      }
+      if (now - this.lastSent >= BEAT_MS) this.emit({ type: "beat", seq: 0, ack: this.rcvNext - 1 }, now);
+    }
+    die() {
+      this.stop();
+      this.o.onDead("timeout");
+    }
+  };
+
+  // src/nostr/crypto.ts
+  var subtle = () => {
+    const s = globalThis.crypto?.subtle;
+    if (!s) throw new Error("WebCrypto (crypto.subtle) is not available; Nostr signaling needs a secure context or Node 18+");
+    return s;
+  };
+  var buf = (b) => b;
+  var utf82 = new TextEncoder();
+  function concatBytes(...parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let o = 0;
+    for (const p of parts) {
+      out.set(p, o);
+      o += p.length;
+    }
+    return out;
+  }
+  var toHex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+  function fromHex(s) {
+    if (s.length % 2 || /[^0-9a-fA-F]/.test(s)) throw new Error("bad hex");
+    const out = new Uint8Array(s.length / 2);
+    for (let i = 0; i < out.length; i++) out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
+    return out;
+  }
+  function toBase64(b) {
+    let s = "";
+    for (let i = 0; i < b.length; i += 32768) s += String.fromCharCode(...b.subarray(i, i + 32768));
+    return btoa(s);
+  }
+  function fromBase64(s) {
+    const bin = atob(s);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  async function sha256(data) {
+    return new Uint8Array(await subtle().digest("SHA-256", buf(data)));
+  }
+  async function hkdf(ikm, salt, info, length = 32) {
+    const key = await subtle().importKey("raw", buf(ikm), "HKDF", false, ["deriveBits"]);
+    const bits = await subtle().deriveBits({ name: "HKDF", hash: "SHA-256", salt: buf(utf82.encode(salt)), info: buf(utf82.encode(info)) }, key, length * 8);
+    return new Uint8Array(bits);
+  }
+  async function deriveRoomKeys(normalizedCode) {
+    const ikm = utf82.encode(normalizedCode);
+    const salt = "onelobby-nostr-v1";
+    const [key, topic] = await Promise.all([hkdf(ikm, salt, "key"), hkdf(ikm, salt, "topic")]);
+    return { key, topic: toHex(topic) };
+  }
+  async function encryptContent(key, plaintext, iv) {
+    const k = await subtle().importKey("raw", buf(key), "AES-GCM", false, ["encrypt"]);
+    const v = iv ?? globalThis.crypto.getRandomValues(new Uint8Array(12));
+    const ct = new Uint8Array(await subtle().encrypt({ name: "AES-GCM", iv: buf(v) }, k, buf(utf82.encode(plaintext))));
+    return toBase64(concatBytes(v, ct));
+  }
+  async function decryptContent(key, content) {
+    try {
+      const raw = fromBase64(content);
+      if (raw.length < 12 + 16) return null;
+      const k = await subtle().importKey("raw", buf(key), "AES-GCM", false, ["decrypt"]);
+      const pt = await subtle().decrypt({ name: "AES-GCM", iv: buf(raw.subarray(0, 12)) }, k, buf(raw.subarray(12)));
+      return new TextDecoder().decode(pt);
+    } catch {
+      return null;
+    }
+  }
+
+  // src/nostr/secp256k1.ts
+  var P = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+  var N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
+  var GX = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n;
+  var GY = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n;
+  var INF = [0n, 1n, 0n];
+  var G = [GX, GY, 1n];
+  var mod = (a, m = P) => {
+    const r = a % m;
+    return r >= 0n ? r : r + m;
+  };
+  function pow(b, e, m) {
+    let r = 1n;
+    b = mod(b, m);
+    while (e > 0n) {
+      if (e & 1n) r = r * b % m;
+      b = b * b % m;
+      e >>= 1n;
+    }
+    return r;
+  }
+  var inv = (a, m = P) => pow(a, m - 2n, m);
+  function dbl(p) {
+    const [X, Y, Z] = p;
+    if (Z === 0n || Y === 0n) return INF;
+    const A = X * X % P;
+    const B = Y * Y % P;
+    const C = B * B % P;
+    const D = mod(2n * ((X + B) * (X + B) - A - C));
+    const E = 3n * A;
+    const F = E * E % P;
+    const X3 = mod(F - 2n * D);
+    return [X3, mod(E * (D - X3) - 8n * C), mod(2n * Y * Z)];
+  }
+  function add(p, q) {
+    if (p[2] === 0n) return q;
+    if (q[2] === 0n) return p;
+    const [X1, Y1, Z1] = p;
+    const [X2, Y2, Z2] = q;
+    const Z1Z1 = Z1 * Z1 % P;
+    const Z2Z2 = Z2 * Z2 % P;
+    const U1 = X1 * Z2Z2 % P;
+    const U2 = X2 * Z1Z1 % P;
+    const S1 = Y1 * Z2 * Z2Z2 % P;
+    const S2 = Y2 * Z1 * Z1Z1 % P;
+    if (U1 === U2) return S1 === S2 ? dbl(p) : INF;
+    const H = mod(U2 - U1);
+    const I = 4n * H * H % P;
+    const J = H * I % P;
+    const r = mod(2n * (S2 - S1));
+    const V = U1 * I % P;
+    const X3 = mod(r * r - J - 2n * V);
+    const Y3 = mod(r * (V - X3) - 2n * S1 * J);
+    const Z3 = mod(((Z1 + Z2) * (Z1 + Z2) - Z1Z1 - Z2Z2) * H);
+    return [X3, Y3, Z3];
+  }
+  function mul(p, k) {
+    let r = INF;
+    let q = p;
+    while (k > 0n) {
+      if (k & 1n) r = add(r, q);
+      q = dbl(q);
+      k >>= 1n;
+    }
+    return r;
+  }
+  function affine(p) {
+    if (p[2] === 0n) return null;
+    const zi = inv(p[2]);
+    const zi2 = zi * zi % P;
+    return [p[0] * zi2 % P, p[1] * zi2 * zi % P];
+  }
+  var bytesToInt = (b) => {
+    let n = 0n;
+    for (const x of b) n = n << 8n | BigInt(x);
+    return n;
+  };
+  function intToBytes(n, len = 32) {
+    const out = new Uint8Array(len);
+    for (let i = len - 1; i >= 0; i--) {
+      out[i] = Number(n & 0xffn);
+      n >>= 8n;
+    }
+    return out;
+  }
+  async function taggedHash(tag, ...msgs) {
+    const t = await sha256(new TextEncoder().encode(tag));
+    return sha256(concatBytes(t, t, ...msgs));
+  }
+  function schnorrPublicKey(secret) {
+    const d = bytesToInt(secret);
+    if (d < 1n || d >= N) throw new Error("secret key out of range");
+    const pt = affine(mul(G, d));
+    return intToBytes(pt[0]);
+  }
+  function randomSecretKey() {
+    for (; ; ) {
+      const b = new Uint8Array(32);
+      globalThis.crypto.getRandomValues(b);
+      const d = bytesToInt(b);
+      if (d >= 1n && d < N) return b;
+    }
+  }
+  async function schnorrSign(msg, secret, aux) {
+    const dPrime = bytesToInt(secret);
+    if (dPrime < 1n || dPrime >= N) throw new Error("secret key out of range");
+    const pt = affine(mul(G, dPrime));
+    const d = pt[1] & 1n ? N - dPrime : dPrime;
+    const px = intToBytes(pt[0]);
+    const a = aux ?? globalThis.crypto.getRandomValues(new Uint8Array(32));
+    const th = await taggedHash("BIP0340/aux", a);
+    const dBytes = intToBytes(d);
+    const t = dBytes.map((x, i) => x ^ th[i]);
+    const rand = await taggedHash("BIP0340/nonce", t, px, msg);
+    const kPrime = bytesToInt(rand) % N;
+    if (kPrime === 0n) throw new Error("bad nonce");
+    const r = affine(mul(G, kPrime));
+    const k = r[1] & 1n ? N - kPrime : kPrime;
+    const rx = intToBytes(r[0]);
+    const e = bytesToInt(await taggedHash("BIP0340/challenge", rx, px, msg)) % N;
+    return concatBytes(rx, intToBytes((k + e * d) % N));
+  }
+
+  // src/nostr/relays.ts
+  var NOSTR_KIND = 25050;
+  async function eventId(pubkey, createdAt, kind, tags, content) {
+    return toHex(await sha256(new TextEncoder().encode(JSON.stringify([0, pubkey, createdAt, kind, tags, content]))));
+  }
+  async function makeEvent(secret, topic, content, createdAt) {
+    const pubkey = toHex(schnorrPublicKey(secret));
+    const tags = [["t", topic]];
+    const id = await eventId(pubkey, createdAt, NOSTR_KIND, tags, content);
+    const sig = toHex(await schnorrSign(fromHex(id), secret));
+    return { id, pubkey, created_at: createdAt, kind: NOSTR_KIND, tags, content, sig };
+  }
+  var defaultRelayConnect = (url) => {
+    const WS = globalThis.WebSocket;
+    if (!WS) throw new Error("no WebSocket in this runtime (Node 22+ has one; older Node needs advanced.nostrConnect)");
+    return new WS(url);
+  };
+  var SEEN_MAX = 4096;
+  var SINCE_SLACK_S = 30;
+  var RelayPool = class {
+    constructor(o) {
+      this.o = o;
+      this.relays = o.urls.map((url) => ({ url, ws: null, open: false, attempted: false, skipped: false, backoff: 1e3, cancelRetry: null }));
+    }
+    o;
+    relays;
+    seen = /* @__PURE__ */ new Set();
+    sub = "ol" + Math.random().toString(16).slice(2, 10);
+    closed = false;
+    waiters = [];
+    get total() {
+      return this.relays.length;
+    }
+    /** Relays connected right now (and not skipped). */
+    get connected() {
+      return this.relays.filter((r) => r.open && !r.skipped).length;
+    }
+    /** Every relay has either connected, failed a connect, or been skipped: waiting longer for the rest is pointless. */
+    get settled() {
+      return this.relays.every((r) => r.attempted || r.skipped);
+    }
+    start() {
+      for (const r of this.relays) this.dial(r);
+    }
+    /** Resolves true once one relay is connected, false after `timeoutMs` (or when closed). */
+    whenUp(timeoutMs) {
+      if (this.connected > 0) return Promise.resolve(true);
+      return new Promise((resolve) => {
+        const cancel = this.o.clock.setTimeout(() => done(false), timeoutMs);
+        const done = (v) => {
+          cancel();
+          this.waiters = this.waiters.filter((w) => w !== check2);
+          resolve(v);
+        };
+        const check2 = () => {
+          if (this.connected > 0) done(true);
+          else if (this.closed) done(false);
+        };
+        this.waiters.push(check2);
+      });
+    }
+    publish(ev) {
+      const msg = JSON.stringify(["EVENT", ev]);
+      for (const r of this.relays) if (r.open && !r.skipped) this.trySend(r, msg);
+    }
+    close() {
+      this.closed = true;
+      for (const r of this.relays) {
+        r.cancelRetry?.();
+        r.cancelRetry = null;
+        this.drop(r, false);
+      }
+      this.changed();
+    }
+    changed() {
+      for (const w of [...this.waiters]) w();
+      this.o.onChange?.();
+    }
+    trySend(r, msg) {
+      try {
+        r.ws?.send(msg);
+      } catch {
+      }
+    }
+    dial(r) {
+      if (this.closed || r.skipped) return;
+      let ws;
+      try {
+        ws = this.o.connect(r.url);
+      } catch {
+        r.attempted = true;
+        this.retryLater(r);
+        return;
+      }
+      r.ws = ws;
+      ws.onopen = () => {
+        if (r.ws !== ws) return;
+        r.open = true;
+        r.attempted = true;
+        r.backoff = 1e3;
+        const since = Math.floor(this.o.wall() / 1e3) - SINCE_SLACK_S;
+        this.trySend(r, JSON.stringify(["REQ", this.sub, { kinds: [NOSTR_KIND], "#t": [this.o.topic], since }]));
+        this.changed();
+      };
+      ws.onmessage = (e) => {
+        if (r.ws === ws) this.onMessage(r, String(e.data));
+      };
+      const lost = () => {
+        if (r.ws !== ws) return;
+        const wasOpen = r.open;
+        r.ws = null;
+        r.open = false;
+        r.attempted = true;
+        if (wasOpen) this.changed();
+        this.retryLater(r);
+      };
+      ws.onclose = lost;
+      ws.onerror = () => {
+        lost();
+      };
+    }
+    drop(r, retry) {
+      const ws = r.ws;
+      r.ws = null;
+      r.open = false;
+      try {
+        ws?.close();
+      } catch {
+      }
+      if (retry) this.retryLater(r);
+    }
+    retryLater(r) {
+      if (this.closed || r.skipped || r.cancelRetry) return;
+      const wait = r.backoff;
+      r.backoff = Math.min(3e4, r.backoff * 2);
+      r.cancelRetry = this.o.clock.setTimeout(() => {
+        r.cancelRetry = null;
+        this.dial(r);
+      }, wait);
+    }
+    skip(r) {
+      if (r.skipped) return;
+      r.skipped = true;
+      r.cancelRetry?.();
+      r.cancelRetry = null;
+      this.drop(r, false);
+      this.changed();
+    }
+    onMessage(r, text) {
+      let m;
+      try {
+        m = JSON.parse(text);
+      } catch {
+        return;
+      }
+      if (!Array.isArray(m)) return;
+      switch (m[0]) {
+        case "EVENT": {
+          const ev = m[2];
+          if (!ev || typeof ev.id !== "string" || typeof ev.pubkey !== "string" || typeof ev.content !== "string" || typeof ev.created_at !== "number") return;
+          if (ev.kind !== NOSTR_KIND || !Array.isArray(ev.tags) || !ev.tags.some((t) => t[0] === "t" && t[1] === this.o.topic)) return;
+          if (this.seen.has(ev.id)) return;
+          this.seen.add(ev.id);
+          if (this.seen.size > SEEN_MAX) this.seen.delete(this.seen.values().next().value);
+          this.o.onEvent(ev);
+          return;
+        }
+        case "OK":
+          if (m[2] === false && !String(m[3] ?? "").startsWith("duplicate")) this.skip(r);
+          return;
+        case "CLOSED":
+          this.skip(r);
+          return;
+      }
+    }
+  };
+  var DEFAULT_NOSTR_RELAYS = [
+    "wss://nos.lol",
+    "wss://relay.primal.net",
+    "wss://nostr-pub.wellorder.net",
+    "wss://nostr.oxtr.dev",
+    "wss://nostr.bitcoiner.social",
+    "wss://relay.nostr.net",
+    "wss://nostr.sathoarder.com"
+  ];
+  var DEFAULT_NOSTR_STUN = ["stun:stun.l.google.com:19302", "stun:stun.cloudflare.com:3478"];
+  async function checkNostrRelays(urls, timeoutMs = 8e3, opts = {}) {
+    const connect = opts.connect ?? defaultRelayConnect;
+    const setT = (fn, ms) => {
+      const h = setTimeout(fn, ms);
+      return () => clearTimeout(h);
+    };
+    return Promise.all(urls.map((url) => checkOne(url, timeoutMs, connect, opts.clock?.setTimeout.bind(opts.clock) ?? setT)));
+  }
+  async function checkOne(url, timeoutMs, connect, setT) {
+    const t0 = Date.now();
+    const secret = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(secret);
+    secret[0] &= 127;
+    if (secret.every((b) => b === 0)) secret[31] = 1;
+    const topic = toHex(globalThis.crypto.getRandomValues(new Uint8Array(32)));
+    let ev;
+    try {
+      ev = await makeEvent(secret, topic, "probe", Math.floor(Date.now() / 1e3));
+    } catch (e) {
+      return { url, ok: false, ms: 0, error: String(e) };
+    }
+    return new Promise((resolve) => {
+      let ws = null;
+      let finished = false;
+      let accepted = false;
+      const finish = (ok, error) => {
+        if (finished) return;
+        finished = true;
+        cancel();
+        try {
+          ws?.close();
+        } catch {
+        }
+        resolve({ url, ok, ms: Date.now() - t0, ...error ? { error } : {} });
+      };
+      const cancel = setT(() => finish(false, accepted ? "accepted but not echoed" : "timeout"), timeoutMs);
+      try {
+        ws = connect(url);
+      } catch (e) {
+        finish(false, String(e));
+        return;
+      }
+      const sub = "chk" + topic.slice(0, 8);
+      let published = false;
+      const publish = () => {
+        if (published) return;
+        published = true;
+        ws.send(JSON.stringify(["EVENT", ev]));
+      };
+      ws.onopen = () => {
+        ws.send(JSON.stringify(["REQ", sub, { kinds: [NOSTR_KIND], "#t": [topic], since: Math.floor(Date.now() / 1e3) - 30 }]));
+        setT(publish, 1500);
+      };
+      ws.onerror = () => finish(false, "connection failed");
+      ws.onclose = () => finish(false, "closed");
+      ws.onmessage = (e) => {
+        let m;
+        try {
+          m = JSON.parse(String(e.data));
+        } catch {
+          return;
+        }
+        if (!Array.isArray(m)) return;
+        if (m[0] === "EOSE") publish();
+        else if (m[0] === "OK" && m[1] === ev.id) {
+          if (m[2] === true) accepted = true;
+          else finish(false, `refused: ${String(m[3] ?? "")}`.slice(0, 120));
+        } else if (m[0] === "CLOSED") finish(false, `closed: ${String(m[2] ?? "")}`.slice(0, 120));
+        else if (m[0] === "EVENT" && m[2]?.id === ev.id) finish(true);
+      };
+    });
+  }
+
+  // src/nostr/room.ts
+  var MAX_AGE_S = 120;
+  var NostrRoom = class _NostrRoom {
+    constructor(secret, keys, o, wall) {
+      this.secret = secret;
+      this.keys = keys;
+      this.wall = wall;
+      this.pub = toHex(schnorrPublicKey(secret));
+      this.pool = new RelayPool({
+        urls: o.relays && o.relays.length > 0 ? o.relays : DEFAULT_NOSTR_RELAYS,
+        topic: keys.topic,
+        connect: o.connect ?? defaultRelayConnect,
+        clock: o.clock,
+        wall,
+        onEvent: (ev) => void this.onEvent(ev),
+        onChange: o.onChange
+      });
+    }
+    secret;
+    keys;
+    wall;
+    pub;
+    /** Called for each valid frame addressed to nobody in particular or to us (`to` empty or our pubkey). */
+    onFrame = null;
+    pool;
+    closed = false;
+    pending = /* @__PURE__ */ new Set();
+    /** Derives the keys and starts connecting. Throws on a code that is not 11 alphabet characters. */
+    static async open(o) {
+      const norm = normalizeJoinCode(o.code);
+      if (!norm) throw new Error(`not a join code: ${o.code}`);
+      const keys = await deriveRoomKeys(norm);
+      const room = new _NostrRoom(randomSecretKey(), keys, o, o.wall ?? (() => Date.now()));
+      room.pool.start();
+      return room;
+    }
+    get relaysConnected() {
+      return this.pool.connected;
+    }
+    get relaysTotal() {
+      return this.pool.total;
+    }
+    /** Every relay has connected, failed or been skipped. */
+    get relaysSettled() {
+      return this.pool.settled;
+    }
+    whenUp(timeoutMs) {
+      return this.pool.whenUp(timeoutMs);
+    }
+    /** Stamps, encrypts, signs and publishes a frame to every relay. */
+    send(to, f) {
+      const p = this.sendNow(to, f);
+      this.pending.add(p);
+      void p.finally(() => this.pending.delete(p));
+      return p;
+    }
+    async sendNow(to, f) {
+      if (this.closed) return;
+      const frame = { v: 1, type: f.type, from: this.pub, to, seq: f.seq, ack: f.ack, ...f.msgs ? { msgs: f.msgs } : {}, ...f.reason ? { reason: f.reason } : {} };
+      const content = await encryptContent(this.keys.key, JSON.stringify(frame));
+      const ev = await makeEvent(this.secret, this.keys.topic, content, Math.floor(this.wall() / 1e3));
+      if (!this.closed) this.pool.publish(ev);
+    }
+    /** Closes now, or (`flush`) once the frames already handed to `send` are published (a final `close` frame). */
+    close(flush = false) {
+      if (flush && this.pending.size > 0) {
+        void Promise.allSettled([...this.pending]).then(() => this.close());
+        return;
+      }
+      this.closed = true;
+      this.onFrame = null;
+      this.pool.close();
+    }
+    async onEvent(ev) {
+      if (this.closed || ev.pubkey === this.pub) return;
+      if (this.wall() / 1e3 - ev.created_at > MAX_AGE_S) return;
+      const text = await decryptContent(this.keys.key, ev.content);
+      if (text === null || this.closed) return;
+      let f;
+      try {
+        f = JSON.parse(text);
+      } catch {
+        return;
+      }
+      if (!f || f.v !== 1 || f.from !== ev.pubkey || f.from === this.pub) return;
+      if (f.type !== "open" && f.type !== "data" && f.type !== "beat" && f.type !== "close") return;
+      if (typeof f.to !== "string" || f.to !== "" && f.to !== this.pub) return;
+      this.onFrame?.(f);
+    }
+  };
+
+  // src/nostr/socket.ts
+  var NostrSocket = class {
+    constructor(o) {
+      this.o = o;
+      void this.start();
+    }
+    o;
+    readyState = 0;
+    onopen = null;
+    onmessage = null;
+    onclose = null;
+    onerror = null;
+    /** Why the socket failed or closed, for messages ("no Nostr relay reachable", "host did not answer"). */
+    failure = "";
+    room = null;
+    link = null;
+    hostPub = "";
+    cancelOpen = null;
+    cancelDeadline = null;
+    sendOpen = null;
+    relaysSeen = 0;
+    /** Relays connected, for a progress line. */
+    get relaysConnected() {
+      return this.room?.relaysConnected ?? 0;
+    }
+    get relaysTotal() {
+      return this.room?.relaysTotal ?? 0;
+    }
+    send(data) {
+      if (this.readyState !== 1 || !this.link) return;
+      if (data.length < 64 && data.startsWith('{"t":"ping"')) {
+        try {
+          const m = JSON.parse(data);
+          queueMicrotask(() => this.readyState === 1 && this.onmessage?.({ data: JSON.stringify({ t: "pong", n: m.n }) }));
+          return;
+        } catch {
+        }
+      }
+      this.link.send(data);
+    }
+    close(_code, reason) {
+      if (this.readyState === 3) return;
+      const wasOpen = this.readyState === 1;
+      if (wasOpen) this.link?.close(reason ?? "");
+      this.finish(1e3, reason ?? "", false);
+    }
+    async start() {
+      const { clock } = this.o;
+      try {
+        this.room = await NostrRoom.open({ ...this.o, onChange: () => this.relaysChanged() });
+      } catch (e) {
+        this.fail(String(e));
+        return;
+      }
+      const room = this.room;
+      if (this.readyState === 3) {
+        room.close();
+        return;
+      }
+      room.onFrame = (f) => this.onFrame(f);
+      this.cancelDeadline = clock.setTimeout(() => this.fail("the host did not answer through the Nostr relays"), this.o.openTimeoutMs ?? GIVE_UP_MS);
+      if (!await room.whenUp(this.o.relayTimeoutMs ?? JOINER_FIRST_RELAY_MS)) {
+        this.fail("no Nostr relay reachable");
+        return;
+      }
+      if (this.readyState !== 0) return;
+      const open = () => void room.send("", { type: "open", seq: 0, ack: 0 });
+      this.relaysSeen = room.relaysConnected;
+      this.sendOpen = open;
+      open();
+      this.cancelOpen = clock.setInterval(open, this.o.openEveryMs ?? OPEN_EVERY_MS);
+    }
+    relaysChanged() {
+      const up = this.room?.relaysConnected ?? 0;
+      if (up > this.relaysSeen && this.readyState === 0) this.sendOpen?.();
+      this.relaysSeen = up;
+    }
+    onFrame(f) {
+      if (this.readyState === 3 || f.to !== this.room?.pub) return;
+      if (this.readyState === 0) {
+        if (f.type !== "open") return;
+        this.hostPub = f.from;
+        this.sendOpen = null;
+        this.cancelOpen?.();
+        this.cancelDeadline?.();
+        this.cancelOpen = this.cancelDeadline = null;
+        const room = this.room;
+        this.link = new ReliableLink({
+          clock: this.o.clock,
+          send: (out) => void room.send(this.hostPub, out),
+          deliver: (text) => this.readyState === 1 && this.onmessage?.({ data: text }),
+          onPeerClose: (reason) => this.finish(1e3, reason, true),
+          onDead: (reason) => this.finish(1006, reason, false)
+        });
+        this.readyState = 1;
+        this.onopen?.();
+        return;
+      }
+      if (f.from !== this.hostPub) return;
+      if (f.type === "open") {
+        this.link?.heard();
+        return;
+      }
+      this.link?.receive(f);
+    }
+    fail(why) {
+      if (this.readyState === 3) return;
+      this.failure = why;
+      if (this.readyState === 0) this.onerror?.({ message: why });
+      this.finish(1006, why, false);
+    }
+    finish(code, reason, clean) {
+      if (this.readyState === 3) return;
+      this.readyState = 3;
+      this.cancelOpen?.();
+      this.cancelDeadline?.();
+      this.cancelOpen = this.cancelDeadline = null;
+      this.link?.stop();
+      this.room?.close(true);
+      queueMicrotask(() => this.onclose?.({ code, reason, wasClean: clean }));
+    }
+  };
+
   // src/direct-address.ts
   var DEFAULT_DIRECT_PORT = 47810;
   var IPV4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
@@ -3014,9 +4173,1576 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     return { host, port, isIPv6: v6, display, url: `ws://${display}/`, candidate: `candidate:1 1 UDP 2122317823 ${host} ${port} typ host` };
   }
 
+  // src/blueprint.ts
+  function defineBlueprint(x) {
+    return x;
+  }
+  var BlueprintError = class extends OneLobbyError {
+    constructor(path, rule, detail) {
+      super("bad_config", `onelobby.json: ${path ? path + ": " : ""}${detail}`);
+      this.path = path;
+      this.rule = rule;
+    }
+    path;
+    rule;
+  };
+  var obj = (props, req) => ({ k: "obj", props, req });
+  var bool = { k: "bool" };
+  var str = (o = {}) => ({ k: "str", ...o });
+  var int = (min, max, zeroOr) => ({ k: "int", min, max, zeroOr });
+  var en = (...vals) => ({ k: "enum", vals });
+  var ROOT = obj(
+    {
+      version: { k: "const", val: 1 },
+      game: obj(
+        { id: str({ pattern: /^[A-Za-z0-9._-]{1,64}$/ }), netVersion: str({ min: 1, max: 32 }), title: str({ max: 64 }) },
+        ["id"]
+      ),
+      engine: en("web", "node-browser", "godot-csharp", "unity", "dotnet"),
+      hosting: obj({
+        direct: bool,
+        server: bool,
+        lobbyServer: str(),
+        directPort: int(1024, 65535),
+        openPort: bool,
+        nostr: bool,
+        nostrRelays: { k: "strarr" },
+        relayOnly: bool,
+        allowedOrigins: { k: "strarr" }
+      }),
+      lobby: obj({
+        maxPlayers: int(2, 64),
+        listed: bool,
+        approveJoins: bool,
+        password: bool,
+        lateJoin: bool,
+        rejoin: bool,
+        joinLink: bool,
+        meta: { k: "meta" }
+      }),
+      sync: obj({ mode: en("raw", "lockstep", "replication"), tickRate: int(1, 120), hashEveryTicks: int(1, 1e5) }),
+      players: obj({ identity: en("name", "anonymous", "platform"), maxNameLength: int(1, 24) }),
+      chat: obj({ text: bool, voice: bool, voiceMode: en("pushToTalk", "voiceActivity") }),
+      session: obj({
+        hostLeaves: en("end", "migrate"),
+        pause: en("off", "host", "anyone"),
+        readyTimeoutMs: int(0, 6e5),
+        peerTimeoutMs: int(6e3, 6e5, true),
+        rateLimit: { k: "rate" },
+        runInBackground: bool
+      }),
+      platforms: obj({ steam: { k: "steam" }, epic: { k: "epic" }, discord: bool }),
+      ui: obj({ kind: en("drop-in", "generated", "none"), entry: str(), theme: en("light", "dark", "auto") })
+    },
+    ["game"]
+  );
+  var IGNORED = /* @__PURE__ */ new Set(["$schema", "$comment"]);
+  var Fail = class {
+    constructor(path, rule, detail) {
+      this.path = path;
+      this.rule = rule;
+      this.detail = detail;
+    }
+    path;
+    rule;
+    detail;
+  };
+  var join = (p, k) => p ? `${p}.${k}` : String(k);
+  var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+  function check(n, v, path) {
+    switch (n.k) {
+      case "obj": {
+        if (!isObj(v)) throw new Fail(path, "type", "must be an object");
+        for (const r of n.req ?? []) if (!(r in v)) throw new Fail(join(path, r), "required", "is required");
+        for (const k of Object.keys(v)) if (!IGNORED.has(k) && !(k in n.props)) throw new Fail(join(path, k), "unknown_key", "unknown key");
+        for (const [k, sub] of Object.entries(n.props)) if (k in v) check(sub, v[k], join(path, k));
+        return;
+      }
+      case "str": {
+        if (typeof v !== "string") throw new Fail(path, "type", "must be a string");
+        if (n.min !== void 0 && v.length < n.min || n.max !== void 0 && v.length > n.max)
+          throw new Fail(path, "length", `must be ${n.min ?? 0} to ${n.max ?? "any"} characters`);
+        if (n.pattern && !n.pattern.test(v)) throw new Fail(path, "pattern", `must match ${n.pattern.source}`);
+        return;
+      }
+      case "int": {
+        if (typeof v !== "number" || !Number.isInteger(v)) throw new Fail(path, "type", "must be an integer");
+        if (n.zeroOr && v === 0) return;
+        if (n.min !== void 0 && v < n.min || n.max !== void 0 && v > n.max)
+          throw new Fail(path, "range", `must be ${n.zeroOr ? "0 or " : ""}${n.min ?? "any"} to ${n.max ?? "any"}`);
+        return;
+      }
+      case "bool":
+        if (typeof v !== "boolean") throw new Fail(path, "type", "must be true or false");
+        return;
+      case "enum":
+        if (typeof v !== "string" || !n.vals.includes(v)) throw new Fail(path, "enum", `must be one of ${n.vals.join(", ")}`);
+        return;
+      case "const":
+        if (v !== n.val) throw new Fail(path, "const", `must be ${n.val}`);
+        return;
+      case "strarr": {
+        if (!Array.isArray(v)) throw new Fail(path, "type", "must be an array of strings");
+        v.forEach((x, i) => {
+          if (typeof x !== "string") throw new Fail(join(path, i), "type", "must be a string");
+        });
+        return;
+      }
+      case "meta": {
+        if (!isObj(v)) throw new Fail(path, "type", "must be an object of strings");
+        const keys = Object.keys(v);
+        if (keys.length > 16) throw new Fail(path, "length", "at most 16 keys");
+        for (const k of keys) {
+          if (k.length > 64) throw new Fail(join(path, k), "length", "key is longer than 64 characters");
+          const x = v[k];
+          if (typeof x !== "string") throw new Fail(join(path, k), "type", "must be a string");
+          if (x.length > 64) throw new Fail(join(path, k), "length", "value is longer than 64 characters");
+        }
+        return;
+      }
+      case "rate":
+        check(obj({ messages: int(1), perMs: int(1) }, ["messages", "perMs"]), v, path);
+        return;
+      case "steam":
+        if (typeof v === "boolean") return;
+        if (!isObj(v)) throw new Fail(path, "type", "must be true, false or { appId }");
+        check(obj({ appId: int(1) }), v, path);
+        return;
+      case "epic": {
+        if (typeof v === "boolean") return;
+        if (!isObj(v)) throw new Fail(path, "type", "must be true, false or { productId }");
+        for (const k of Object.keys(v)) if (!IGNORED.has(k) && typeof v[k] !== "string") throw new Fail(join(path, k), "type", "must be a string");
+        return;
+      }
+    }
+  }
+  var sect = (x) => isObj(x) ? x : {};
+  function strip(o) {
+    if (Array.isArray(o)) return o.map(strip);
+    if (!isObj(o)) return o;
+    const out = {};
+    for (const [k, v] of Object.entries(o)) if (k !== "$comment" && k !== "$schema") out[k] = strip(v);
+    return out;
+  }
+  function deepFreeze(o) {
+    if (typeof o === "object" && o !== null && !Object.isFrozen(o)) {
+      Object.freeze(o);
+      for (const v of Object.values(o)) deepFreeze(v);
+    }
+    return o;
+  }
+  function fill(input) {
+    const game = sect(input.game);
+    const engine = input.engine;
+    const hosting = sect(input.hosting);
+    const lobby = sect(input.lobby);
+    const sync = sect(input.sync);
+    const players = sect(input.players);
+    const chat = sect(input.chat);
+    const session = sect(input.session);
+    const platforms = sect(input.platforms);
+    const ui = sect(input.ui);
+    const tickRate = sync.tickRate ?? 20;
+    const web = engine === "web";
+    const out = {
+      version: 1,
+      game: { id: game.id, netVersion: game.netVersion ?? "1", ...game.title !== void 0 ? { title: game.title } : {} },
+      ...engine !== void 0 ? { engine } : {},
+      hosting: {
+        direct: hosting.direct ?? !web,
+        server: hosting.server ?? web,
+        lobbyServer: hosting.lobbyServer ?? "",
+        directPort: hosting.directPort ?? 47810,
+        openPort: hosting.openPort ?? true,
+        nostr: hosting.nostr ?? true,
+        nostrRelays: hosting.nostrRelays ?? [...DEFAULT_NOSTR_RELAYS],
+        relayOnly: hosting.relayOnly ?? false,
+        allowedOrigins: hosting.allowedOrigins ?? []
+      },
+      lobby: {
+        maxPlayers: lobby.maxPlayers ?? 4,
+        listed: lobby.listed ?? false,
+        approveJoins: lobby.approveJoins ?? false,
+        password: lobby.password ?? false,
+        lateJoin: lobby.lateJoin ?? true,
+        rejoin: lobby.rejoin ?? true,
+        joinLink: lobby.joinLink ?? (web || engine === "node-browser"),
+        meta: lobby.meta ?? {}
+      },
+      sync: { mode: sync.mode ?? "raw", tickRate, hashEveryTicks: sync.hashEveryTicks ?? tickRate },
+      players: { identity: players.identity ?? "name", maxNameLength: players.maxNameLength ?? 24 },
+      chat: { text: chat.text ?? true, voice: chat.voice ?? false, voiceMode: chat.voiceMode ?? "pushToTalk" },
+      session: {
+        hostLeaves: session.hostLeaves ?? "end",
+        pause: session.pause ?? "off",
+        readyTimeoutMs: session.readyTimeoutMs ?? 15e3,
+        peerTimeoutMs: session.peerTimeoutMs ?? 0,
+        ...session.rateLimit !== void 0 ? { rateLimit: session.rateLimit } : {},
+        runInBackground: session.runInBackground ?? true
+      },
+      platforms: { steam: platforms.steam ?? false, epic: platforms.epic ?? false, discord: platforms.discord ?? false },
+      ui: {
+        kind: ui.kind ?? (web ? "drop-in" : "generated"),
+        ...ui.entry !== void 0 ? { entry: ui.entry } : {},
+        theme: ui.theme ?? "auto"
+      }
+    };
+    return out;
+  }
+  function crossRules(b) {
+    if (!b.hosting.direct && !b.hosting.server) throw new Fail("hosting", "hosting_none", "at least one of direct, server must be true");
+    if (b.lobby.listed && b.lobby.approveJoins) throw new Fail("lobby", "listed_and_approve", "listed and approveJoins cannot both be true");
+    if (b.engine === "web" && b.hosting.direct) throw new Fail("hosting.direct", "direct_needs_listener", "engine web cannot host direct (a browser cannot listen on a port)");
+    const csharp = b.engine === "godot-csharp" || b.engine === "unity" || b.engine === "dotnet";
+    if (b.sync.mode === "replication" && !csharp) throw new Fail("sync.mode", "replication_needs_csharp", "replication needs engine godot-csharp, unity or dotnet");
+    if (b.sync.mode === "replication" && b.session.hostLeaves === "migrate") throw new Fail("session.hostLeaves", "migrate_with_replication", "replication has no host migration; use end");
+    if (b.session.hostLeaves === "migrate" && !b.hosting.server) throw new Fail("session.hostLeaves", "migrate_needs_server", "migrate needs hosting.server (direct lobbies always end)");
+  }
+  function parseBlueprint(json) {
+    let b;
+    try {
+      check(ROOT, json, "");
+      b = fill(strip(json));
+      crossRules(b);
+    } catch (e) {
+      if (e instanceof Fail) throw new BlueprintError(e.path, e.rule, e.detail);
+      throw e;
+    }
+    return deepFreeze(b);
+  }
+
+  // src/nostr/host.ts
+  function newSessionBurst(maxPlayers) {
+    return Math.max(NEW_SESSION_BURST, Math.min(MAX_SESSION_BURST, maxPlayers ?? 0));
+  }
+  var PING = '{"t":"ping","n":0}';
+  var CLOSED_MEMORY = 512;
+  var NostrHostBridge = class _NostrHostBridge {
+    constructor(hub, room, clock, maxPlayers) {
+      this.hub = hub;
+      this.room = room;
+      this.clock = clock;
+      this.burst = this.newTokens = newSessionBurst(maxPlayers);
+      room.onFrame = (f) => this.onFrame(f);
+    }
+    hub;
+    room;
+    clock;
+    peers = /* @__PURE__ */ new Map();
+    gone = /* @__PURE__ */ new Set();
+    stopped = false;
+    burst;
+    newTokens;
+    newTokensAt = null;
+    /** Refused new pubkeys, oldest first, with when their last `open` was heard. */
+    waiting = /* @__PURE__ */ new Map();
+    cancelWaiting = null;
+    static async start(hub, o) {
+      return new _NostrHostBridge(hub, await NostrRoom.open(o), o.clock, o.maxPlayers);
+    }
+    get relaysConnected() {
+      return this.room.relaysConnected;
+    }
+    get relaysTotal() {
+      return this.room.relaysTotal;
+    }
+    /** Resolves true once one relay is connected, false after `timeoutMs`. */
+    whenUp(timeoutMs) {
+      return this.room.whenUp(timeoutMs);
+    }
+    get relaysSettled() {
+      return this.room.relaysSettled;
+    }
+    /** Waits for the relays: true once one is connected (then up to RELAY_REST_WAIT_MS more, less when every relay has answered), false after `firstRelayMs`. */
+    async settle(firstRelayMs) {
+      if (!await this.whenUp(firstRelayMs)) return false;
+      for (let i = 0; i < RELAY_REST_WAIT_MS / RELAY_REST_POLL_MS && !this.relaysSettled; i++) await new Promise((r) => setTimeout(r, RELAY_REST_POLL_MS));
+      return true;
+    }
+    /** Joiners currently attached. */
+    get peerCount() {
+      return this.peers.size;
+    }
+    close() {
+      if (this.stopped) return;
+      this.stopped = true;
+      this.cancelWaiting?.();
+      this.cancelWaiting = null;
+      this.waiting.clear();
+      for (const [pub, p] of this.peers) {
+        p.link.close("host left");
+        if (p.session) this.hub.disconnect(p.session);
+        this.peers.delete(pub);
+      }
+      this.room.close(true);
+    }
+    onFrame(f) {
+      if (this.stopped) return;
+      const known = this.peers.get(f.from);
+      if (f.type === "open") {
+        if (this.gone.has(f.from)) return;
+        if (known) {
+          known.link.heard();
+          this.answer(f.from);
+        } else if (this.waiting.has(f.from)) {
+          this.waiting.set(f.from, this.clock.now());
+          this.admitWaiting();
+        } else if (this.waiting.size === 0 && this.admitNew()) {
+          this.accept(f.from);
+        } else if (this.waiting.size < WAITING_MAX) {
+          this.waiting.set(f.from, this.clock.now());
+          this.scheduleWaiting();
+        }
+        return;
+      }
+      if (!known) return;
+      known.link.receive(f);
+      if (f.type === "beat" && known.session) this.hub.receive(known.session, PING);
+    }
+    /** Arms one timer for the next token while anyone waits. */
+    scheduleWaiting() {
+      if (this.cancelWaiting || this.waiting.size === 0 || this.stopped) return;
+      const missing = Math.max(0, 1 - this.newTokens);
+      this.cancelWaiting = this.clock.setTimeout(() => {
+        this.cancelWaiting = null;
+        this.admitWaiting();
+      }, Math.max(1, Math.ceil(missing * NEW_SESSION_REFILL_MS)));
+    }
+    /** Answers waiting pubkeys, oldest first, while tokens last; drops the ones that gave up. */
+    admitWaiting() {
+      if (this.stopped) return;
+      const now = this.clock.now();
+      for (const [pub, heard] of this.waiting) {
+        if (now - heard > WAITING_STALE_MS || this.peers.has(pub) || this.gone.has(pub)) {
+          this.waiting.delete(pub);
+          continue;
+        }
+        if (!this.admitNew()) break;
+        this.waiting.delete(pub);
+        this.accept(pub);
+      }
+      this.scheduleWaiting();
+    }
+    /** Spends one token of the new-session bucket, or false when it is empty. */
+    admitNew() {
+      const now = this.clock.now();
+      if (this.newTokensAt !== null) {
+        this.newTokens = Math.min(this.burst, this.newTokens + (now - this.newTokensAt) / NEW_SESSION_REFILL_MS);
+      }
+      this.newTokensAt = now;
+      if (this.newTokens < 1 - 1e-6) return false;
+      this.newTokens = Math.max(0, this.newTokens - 1);
+      return true;
+    }
+    answer(pub) {
+      void this.room.send(pub, { type: "open", seq: 0, ack: 0 });
+    }
+    accept(pub) {
+      const peer = { session: null, link: null };
+      peer.link = new ReliableLink({
+        clock: this.clock,
+        send: (out) => void this.room.send(pub, out),
+        deliver: (text) => peer.session && this.hub.receive(peer.session, text),
+        onPeerClose: () => this.detach(pub, peer),
+        onDead: () => this.detach(pub, peer)
+      });
+      this.peers.set(pub, peer);
+      this.answer(pub);
+      const session = this.hub.connect(
+        `nostr:${pub.slice(0, 16)}`,
+        (text) => {
+          if (!text.startsWith('{"t":"pong"')) peer.link.send(text);
+        },
+        () => {
+          peer.link.close();
+          this.forget(pub, peer);
+        }
+      );
+      if (peer.link.closed) return;
+      if (!session) {
+        peer.link.close("closed");
+        this.forget(pub, peer);
+        return;
+      }
+      peer.session = session;
+    }
+    detach(pub, peer) {
+      peer.link.stop();
+      if (peer.session) this.hub.disconnect(peer.session);
+      peer.session = null;
+      this.forget(pub, peer);
+    }
+    forget(pub, peer) {
+      if (this.peers.get(pub) === peer) this.peers.delete(pub);
+      this.gone.add(pub);
+      if (this.gone.size > CLOSED_MEMORY) this.gone.delete(this.gone.values().next().value);
+    }
+  };
+
+  // src/direct/metrics.ts
+  var Metrics = class {
+    counters = /* @__PURE__ */ new Map();
+    gauges = /* @__PURE__ */ new Map();
+    help = /* @__PURE__ */ new Map();
+    describe(name, help) {
+      this.help.set(name, help);
+    }
+    gauge(name, help, read) {
+      this.gauges.set(name, { help, read });
+    }
+    /** Counter name plus optional single label, e.g. inc("onelobby_path_total", "path", "relayed"). */
+    inc(name, label, value, by = 1) {
+      const key = keyOf(name, label, value);
+      this.counters.set(key, (this.counters.get(key) ?? 0) + by);
+    }
+    get(name, label, value) {
+      return this.counters.get(keyOf(name, label, value)) ?? 0;
+    }
+    render() {
+      let out = "";
+      for (const name of [...this.gauges.keys()].sort(ordinal)) {
+        const g = this.gauges.get(name);
+        out += `# HELP ${name} ${g.help}
+# TYPE ${name} gauge
+${name} ${g.read()}
+`;
+      }
+      let lastBase = null;
+      for (const key of [...this.counters.keys()].sort(ordinal)) {
+        const br = key.indexOf("{");
+        const base = br < 0 ? key : key.slice(0, br);
+        if (base !== lastBase) {
+          const h = this.help.get(base);
+          if (h !== void 0) out += `# HELP ${base} ${h}
+`;
+          out += `# TYPE ${base} counter
+`;
+          lastBase = base;
+        }
+        out += `${key} ${this.counters.get(key)}
+`;
+      }
+      return out;
+    }
+  };
+  var ordinal = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  var escape = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  var keyOf = (name, label, value) => label === void 0 ? name : `${name}{${label}="${escape(value ?? "")}"}`;
+
+  // src/direct/sha1.ts
+  var enc3 = new TextEncoder();
+  function sha1(data) {
+    const h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
+    const len = data.length;
+    const padded = new Uint8Array((len + 8 >> 6 << 6) + 64);
+    padded.set(data);
+    padded[len] = 128;
+    const dv = new DataView(padded.buffer);
+    dv.setUint32(padded.length - 8, Math.floor(len * 8 / 4294967296));
+    dv.setUint32(padded.length - 4, len * 8 >>> 0);
+    const w = new Uint32Array(80);
+    for (let off = 0; off < padded.length; off += 64) {
+      for (let i = 0; i < 16; i++) w[i] = dv.getUint32(off + i * 4);
+      for (let i = 16; i < 80; i++) {
+        const x = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
+        w[i] = x << 1 | x >>> 31;
+      }
+      let [a, b, c, d, e] = h;
+      for (let i = 0; i < 80; i++) {
+        let f;
+        let k;
+        if (i < 20) {
+          f = b & c | ~b & d;
+          k = 1518500249;
+        } else if (i < 40) {
+          f = b ^ c ^ d;
+          k = 1859775393;
+        } else if (i < 60) {
+          f = b & c | b & d | c & d;
+          k = 2400959708;
+        } else {
+          f = b ^ c ^ d;
+          k = 3395469782;
+        }
+        const t = (a << 5 | a >>> 27) + f + e + k + w[i] | 0;
+        e = d;
+        d = c;
+        c = b << 30 | b >>> 2;
+        b = a;
+        a = t;
+      }
+      h[0] = h[0] + a | 0;
+      h[1] = h[1] + b | 0;
+      h[2] = h[2] + c | 0;
+      h[3] = h[3] + d | 0;
+      h[4] = h[4] + e | 0;
+    }
+    const out = new Uint8Array(20);
+    const odv = new DataView(out.buffer);
+    for (let i = 0; i < 5; i++) odv.setUint32(i * 4, h[i] >>> 0);
+    return out;
+  }
+  function hmacSha1(key, msg) {
+    const k = key.length > 64 ? sha1(key) : key;
+    const ipad = new Uint8Array(64 + msg.length);
+    const opad = new Uint8Array(84);
+    for (let i = 0; i < 64; i++) {
+      const kb = i < k.length ? k[i] : 0;
+      ipad[i] = kb ^ 54;
+      opad[i] = kb ^ 92;
+    }
+    ipad.set(msg, 64);
+    opad.set(sha1(ipad), 64);
+    return sha1(opad);
+  }
+  function toHex2(b) {
+    let s = "";
+    for (const x of b) s += x.toString(16).padStart(2, "0");
+    return s;
+  }
+  function toBase642(b) {
+    let s = "";
+    for (const x of b) s += String.fromCharCode(x);
+    return btoa(s);
+  }
+  function turnCredential(secret, username) {
+    return toBase642(hmacSha1(enc3.encode(secret), enc3.encode(username)));
+  }
+  function shortHash(text) {
+    return toHex2(sha1(enc3.encode(text))).slice(0, 8);
+  }
+  function randomHex(n) {
+    return toHex2(globalThis.crypto.getRandomValues(new Uint8Array(n)));
+  }
+  function randomBelow(n) {
+    const range = 4294967296;
+    const limit = range - range % n;
+    const buf2 = new Uint32Array(1);
+    for (; ; ) {
+      globalThis.crypto.getRandomValues(buf2);
+      if (buf2[0] < limit) return buf2[0] % n;
+    }
+  }
+
+  // src/direct/hub.ts
+  var PROTO2 = "lk1";
+  var NAME_MAX = 24;
+  var LOBBY_NAME_MAX = 48;
+  var META_KEYS_MAX = 16;
+  var META_LEN_MAX = 64;
+  var PENDING_MAX = 8;
+  var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+  var GAME_ID = /^[A-Za-z0-9._-]{1,64}$/;
+  function defaultHubOptions() {
+    return {
+      turnUrls: [],
+      turnSecret: "",
+      stunUrls: ["stun:stun.l.google.com:19302"],
+      region: "",
+      allowedGames: [],
+      gameQuotas: {},
+      maxLobbies: 1e3,
+      maxPeers: 1e4,
+      hardMaxPlayers: 64,
+      rateScale: 1,
+      turnTtlSeconds: 3600,
+      maxMessageBytes: 16 * 1024,
+      disableIpLimits: false,
+      createPerMin: 10,
+      joinPerMin: 60,
+      signalPerSec: 20,
+      socketsPerIp: 32,
+      openLobbiesPerIp: 8,
+      idleTimeoutMs: 3e4,
+      resumeWindowMs: 6e4,
+      codeReuseMs: 24 * 3600 * 1e3,
+      listLimitMax: 100,
+      singleLobby: false,
+      password: null,
+      issueCodes: true
+    };
+  }
+  function directHubOptions(maxPlayers, password) {
+    const n = Math.min(250, Math.max(2, maxPlayers));
+    return {
+      ...defaultHubOptions(),
+      singleLobby: true,
+      issueCodes: false,
+      password: password ? password : null,
+      stunUrls: [],
+      turnUrls: [],
+      maxLobbies: 1,
+      hardMaxPlayers: n,
+      maxPeers: n + 8
+    };
+  }
+  var SIGNAL_FANOUT = 8;
+  var NOSTR_ADDR = "nostr:";
+  var NOSTR_SIGNAL_PER_SEC = 10;
+  var RateWindow = class {
+    constructor(limit, windowMs) {
+      this.limit = limit;
+      this.windowMs = windowMs;
+    }
+    limit;
+    windowMs;
+    hits = [];
+    tryHit(now) {
+      this.trim(now);
+      if (this.hits.length >= this.limit) return false;
+      this.hits.push(now);
+      return true;
+    }
+    retryAfterMs(now) {
+      this.trim(now);
+      return this.hits.length < this.limit || this.hits.length === 0 ? 0 : Math.max(1, this.windowMs - (now - this.hits[0]));
+    }
+    isIdle(now) {
+      this.trim(now);
+      return this.hits.length === 0;
+    }
+    trim(now) {
+      while (this.hits.length > 0 && now - this.hits[0] >= this.windowMs) this.hits.shift();
+    }
+  };
+  function sanitize(s, max, fallback = "") {
+    if (!s) return fallback;
+    let r = "";
+    for (const ch of s) {
+      const c = ch.charCodeAt(0);
+      if (ch.length === 1 && (c <= 31 || c >= 127 && c <= 159 || c >= 8234 && c <= 8238 || c >= 8294 && c <= 8297)) continue;
+      r += ch;
+    }
+    if (r.length > max) {
+      r = r.slice(0, max);
+      const last = r.charCodeAt(r.length - 1);
+      if (last >= 55296 && last <= 56319) r = r.slice(0, -1);
+    }
+    return r.length === 0 ? fallback : r;
+  }
+  function normalizeCode2(input) {
+    if (typeof input !== "string") return null;
+    let out = "";
+    for (const raw of input) {
+      if (raw === " " || raw === "-") continue;
+      let ch = raw >= "a" && raw <= "z" ? raw.toUpperCase() : raw;
+      if (ch === "I" || ch === "L") ch = "1";
+      else if (ch === "O") ch = "0";
+      if (CROCKFORD.indexOf(ch) < 0 || out.length >= 6) return null;
+      out += ch;
+    }
+    return out.length === 6 ? out : null;
+  }
+  var Session = class {
+    constructor(id, ip, connId, send, close) {
+      this.id = id;
+      this.ip = ip;
+      this.connId = connId;
+      this.send = send;
+      this.close = close;
+    }
+    id;
+    ip;
+    connId;
+    send;
+    close;
+    closed = false;
+    lastSeen = 0;
+    helloDone = false;
+    gameId = "";
+    netVersion = "";
+    name = "";
+    lobby = null;
+    member = null;
+    pendingIn = null;
+    pendingMember = null;
+    /** Nostr joiners: the remote address of the host's WebRTC link to this session, once known (kick bans it too). */
+    linkIp = null;
+    /** One window per target member (a member belongs to one lobby, so a new lobby starts fresh). */
+    signalRates = /* @__PURE__ */ new Map();
+    /** All signals of this session, so the per-target budget does not grow without bound with the lobby. */
+    signalTotal = null;
+  };
+  var Member = class {
+    peerId = 0;
+    name = "";
+    joinedAt = 0;
+    session = null;
+    detachedAt = 0;
+    token = "";
+    ip = "";
+  };
+  var HubLobby = class {
+    code = "";
+    gameId = "";
+    netVersion = "";
+    name = "";
+    visibility = "public";
+    mode = "lockstep";
+    tickRate = 20;
+    lateJoin = false;
+    relayOnly = false;
+    phase = "lobby";
+    maxPlayers = 0;
+    createdAt = 0;
+    ownerIp = "";
+    meta = {};
+    members = [];
+    pending = [];
+    kicked = /* @__PURE__ */ new Set();
+    hostId = 0;
+    epoch = 0;
+    /** Highest valid host_changed claim a member made while the host was still connected; applied when the host goes. */
+    pendingClaimPeer = 0;
+    pendingClaimEpoch = 0;
+    nextPeerId = 1;
+    find(peerId) {
+      return this.members.find((m) => m.peerId === peerId);
+    }
+  };
+  var KNOWN_TYPES = /* @__PURE__ */ new Set(["hello", "create", "join", "list", "leave", "signal", "meta", "phase", "kick", "approve", "ping", "host_changed", "path"]);
+  var str2 = (o, k) => typeof o[k] === "string" ? o[k] : null;
+  var int2 = (o, k) => {
+    const v = o[k];
+    return typeof v === "number" && Number.isInteger(v) && Math.abs(v) < 2147483647 ? v : null;
+  };
+  var bool2 = (o, k) => typeof o[k] === "boolean" ? o[k] : null;
+  var has = (o, k) => o[k] !== void 0 && o[k] !== null;
+  var field = (name) => ({ field: name });
+  var hex = (n) => randomHex(n);
+  var byCode = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  function readMeta(node) {
+    if (node === void 0 || node === null) return { meta: {} };
+    if (typeof node !== "object" || Array.isArray(node)) return { err: "meta must be an object of strings" };
+    const entries = Object.entries(node);
+    if (entries.length > META_KEYS_MAX) return { err: `meta allows at most ${META_KEYS_MAX} keys` };
+    const meta = {};
+    for (const [k, v] of entries.sort(([a], [b]) => byCode(a, b))) {
+      if (typeof v !== "string") return { err: "meta values must be strings" };
+      if (k.length > META_LEN_MAX || v.length > META_LEN_MAX) return { err: `meta keys and values are limited to ${META_LEN_MAX} chars` };
+      meta[k] = v;
+    }
+    return { meta };
+  }
+  var SignalingHub = class {
+    o;
+    now;
+    rand;
+    log;
+    lobbies = /* @__PURE__ */ new Map();
+    retired = /* @__PURE__ */ new Map();
+    tokens = /* @__PURE__ */ new Map();
+    sessions = /* @__PURE__ */ new Map();
+    gameLobbies = /* @__PURE__ */ new Map();
+    ips = /* @__PURE__ */ new Map();
+    nextSession = 0;
+    createdOnce = false;
+    members = 0;
+    logSalt = hex(8);
+    metrics = new Metrics();
+    constructor(options = {}, deps = {}) {
+      this.o = { ...defaultHubOptions(), ...options };
+      this.now = deps.now ?? (() => Date.now());
+      this.rand = deps.randomInt ?? ((n) => randomBelow(n));
+      this.log = deps.log ?? (() => {
+      });
+      const m = this.metrics;
+      m.gauge("onelobby_lobbies", "Live lobbies.", () => this.lobbyCount);
+      m.gauge("onelobby_sockets", "Open signaling sockets.", () => this.socketCount);
+      m.gauge("onelobby_lobbies_retired", "Join codes held back from reuse.", () => this.retired.size);
+      m.describe("onelobby_messages_total", "Client messages received, by type.");
+      m.describe("onelobby_errors_total", "Error replies sent, by code.");
+      m.describe("onelobby_path_total", "ICE path reports from peers: direct vs relayed (DESIGN s.10).");
+      m.describe("onelobby_connections_total", "Sockets accepted since start.");
+      m.describe("onelobby_lobbies_created_total", "Lobbies created since start.");
+      m.describe("onelobby_rate_limit_hits_total", "Requests refused by a rate limit, by kind.");
+    }
+    get lobbyCount() {
+      return this.lobbies.size;
+    }
+    get socketCount() {
+      return this.sessions.size;
+    }
+    get scale() {
+      return Math.max(1, this.o.rateScale);
+    }
+    // ---------------------------------------------------------------- connection lifecycle
+    /** Registers a socket. Returns null (after sending server_full and closing) when over maxPeers. */
+    connect(ip, send, close) {
+      const s = new Session(++this.nextSession, ip, hex(6), send, close);
+      s.lastSeen = this.now();
+      this.metrics.inc("onelobby_connections_total");
+      if (this.sessions.size >= this.o.maxPeers) {
+        this.error(s, "server_full", "server is at its peer limit");
+        s.close();
+        return null;
+      }
+      const st = this.ipOf(ip);
+      if (!this.o.disableIpLimits && st.sockets >= this.o.socketsPerIp * this.scale) {
+        this.rateLimited(s, "sockets", 5e3, "max_sockets");
+        s.close(1008, "too_many_sockets");
+        return null;
+      }
+      this.sessions.set(s.id, s);
+      st.sockets++;
+      return s;
+    }
+    disconnect(s) {
+      if (!this.sessions.delete(s.id)) return;
+      s.closed = true;
+      const st = this.ips.get(s.ip);
+      if (st) st.sockets--;
+      if (s.pendingIn) {
+        s.pendingIn.pending = s.pendingIn.pending.filter((p) => p !== s.pendingMember);
+        s.pendingIn = null;
+        s.pendingMember = null;
+      }
+      const m = s.member;
+      const lobby = s.lobby;
+      if (m && lobby) {
+        m.session = null;
+        m.detachedAt = this.now();
+        s.member = null;
+        s.lobby = null;
+        this.logEvent("detach", lobby, s);
+        this.broadcast(lobby, { t: "peer_left", peerId: m.peerId, reason: "timeout" });
+        this.metrics.inc("onelobby_peers_left_total", "reason", "timeout");
+        if (lobby.hostId === m.peerId) this.promoteHost(lobby, m.peerId);
+      }
+    }
+    /**
+     * The host's WebRTC link to joiner `peerId` has the remote address `ip` (selected candidate pair; the host's own
+     * lobby reports it, a relayed or mDNS address must not be passed). Only Nostr sessions take it: their socket address
+     * is a pubkey the joiner chose. A joiner whose link address is banned is removed as kicked; a later kick bans it.
+     */
+    reportLinkAddress(peerId, ip) {
+      for (const lobby of this.lobbies.values()) {
+        const mem = lobby.find(peerId);
+        const sess = mem?.session;
+        if (!mem || !sess || !sess.ip.startsWith(NOSTR_ADDR)) continue;
+        sess.linkIp = ip;
+        if (lobby.kicked.has(ip)) {
+          this.removeMember(lobby, mem, "kicked");
+          this.closeSession(sess);
+        }
+        return;
+      }
+    }
+    closeSession(s) {
+      s.close();
+      this.disconnect(s);
+    }
+    // ---------------------------------------------------------------- time
+    /** Call about once a second: idle timeouts, resume-window expiry, code retirement. */
+    tick() {
+      const now = this.now();
+      for (const s of [...this.sessions.values()])
+        if (now - s.lastSeen > this.o.idleTimeoutMs) {
+          this.metrics.inc("onelobby_idle_timeouts_total");
+          this.closeSession(s);
+        }
+      for (const lobby of [...this.lobbies.values()])
+        for (const m of [...lobby.members]) if (m.detachedAt > 0 && now - m.detachedAt >= this.o.resumeWindowMs) this.removeMember(lobby, m, "timeout");
+      for (const [code, at] of [...this.retired]) if (now - at >= this.o.codeReuseMs) this.retired.delete(code);
+      for (const [key, st] of [...this.ips])
+        if (st.sockets <= 0 && st.open <= 0 && st.create.isIdle(now) && st.join.isIdle(now)) this.ips.delete(key);
+    }
+    // ---------------------------------------------------------------- inbound
+    receive(s, text) {
+      if (s.closed) return;
+      s.lastSeen = this.now();
+      if (text.length > this.o.maxMessageBytes) {
+        this.error(s, "bad_request", "message too large");
+        this.closeSession(s);
+        return;
+      }
+      let msg = null;
+      try {
+        const v = JSON.parse(text);
+        msg = v && typeof v === "object" && !Array.isArray(v) ? v : null;
+      } catch {
+        msg = null;
+      }
+      const t = msg ? str2(msg, "t") : null;
+      if (!msg || t === null) {
+        this.error(s, "bad_request", "expected a JSON object with a string t", field("t"));
+        return;
+      }
+      this.metrics.inc("onelobby_messages_total", "type", KNOWN_TYPES.has(t) ? t : "unknown");
+      if (t === "hello") return this.hello(s, msg);
+      if (!s.helloDone) {
+        if (KNOWN_TYPES.has(t)) this.error(s, "bad_request", "send hello first");
+        return;
+      }
+      switch (t) {
+        case "create":
+          return this.create(s, msg);
+        case "join":
+          return this.join(s, msg);
+        case "list":
+          return this.list(s, msg);
+        case "leave":
+          return this.leave(s);
+        case "signal":
+          return this.signal(s, msg);
+        case "meta":
+          return this.hostMeta(s, msg);
+        case "phase":
+          return this.hostPhase(s, msg);
+        case "kick":
+          return this.kick(s, msg);
+        case "approve":
+          return this.approve(s, msg);
+        case "ping": {
+          const n = int2(msg, "n");
+          if (n === null || n < 0) return this.error(s, "bad_request", "ping needs an integer n", field("n"));
+          return this.send(s, { t: "pong", n });
+        }
+        case "host_changed":
+          return this.claimHost(s, msg);
+        case "path":
+          return this.pathReport(s, msg);
+        default:
+          return;
+      }
+    }
+    // ---------------------------------------------------------------- hello / welcome
+    hello(s, m) {
+      if (s.helloDone) return this.error(s, "bad_request", "hello already sent");
+      if (str2(m, "proto") !== PROTO2) {
+        this.error(s, "bad_request", "unsupported proto, expected lk1", { supported: [PROTO2] });
+        this.closeSession(s);
+        return;
+      }
+      if (has(m, "name") && str2(m, "name") === null) return this.error(s, "bad_request", "name must be a string", field("name"));
+      if (has(m, "client") && (typeof m.client !== "object" || Array.isArray(m.client)))
+        return this.error(s, "bad_request", "client must be an object", field("client"));
+      const gameId = str2(m, "gameId");
+      const netVersion = str2(m, "netVersion");
+      if (gameId === null || !GAME_ID.test(gameId)) return this.error(s, "bad_request", "gameId must match [A-Za-z0-9._-]{1,64}", field("gameId"));
+      if (!netVersion || netVersion.length > 32) return this.error(s, "bad_request", "netVersion must be 1-32 characters", field("netVersion"));
+      if (this.o.allowedGames.length > 0 && !this.o.allowedGames.includes(gameId)) {
+        this.error(s, "game_not_allowed", "this server does not host that game");
+        this.closeSession(s);
+        return;
+      }
+      s.gameId = gameId;
+      s.netVersion = netVersion;
+      s.name = sanitize(str2(m, "name"), NAME_MAX, "Player");
+      s.helloDone = true;
+      let resumed = null;
+      let rl = null;
+      const token = str2(m, "resumeToken");
+      const entry = token !== null ? this.tokens.get(token) : void 0;
+      if (entry && entry.lobby.gameId === gameId && entry.lobby.netVersion === netVersion) {
+        const old = entry.member.session;
+        const takeOver = old !== null && old !== void 0 && old !== s;
+        const inWindow = entry.member.detachedAt > 0 && this.now() - entry.member.detachedAt < this.o.resumeWindowMs;
+        if (takeOver || inWindow) {
+          if (takeOver) this.closeSession(old);
+          resumed = entry.member;
+          rl = entry.lobby;
+        }
+      }
+      const w = {
+        t: "welcome",
+        ice: this.iceList(s),
+        serverTime: this.now(),
+        limits: { maxMsg: this.o.maxMessageBytes, maxPlayers: this.o.hardMaxPlayers }
+      };
+      if (resumed) w.peerId = resumed.peerId;
+      this.send(s, w);
+      if (resumed && rl) {
+        this.tokens.delete(resumed.token);
+        resumed.token = hex(16);
+        this.tokens.set(resumed.token, { lobby: rl, member: resumed });
+        resumed.session = s;
+        resumed.detachedAt = 0;
+        s.lobby = rl;
+        s.member = resumed;
+        this.logEvent("resume", rl, s);
+        this.metrics.inc("onelobby_resumes_total");
+        for (const other of rl.members) if (other !== resumed) this.sendTo(other, { t: "peer_joined", peer: this.peerObj(resumed) });
+        this.send(s, this.lobbyMsg(rl, resumed));
+      }
+    }
+    iceList(s) {
+      const ice = [];
+      if (this.o.stunUrls.length > 0) ice.push({ urls: [...this.o.stunUrls] });
+      if (this.o.turnUrls.length > 0 && this.o.turnSecret.length > 0) {
+        const expiry = Math.floor(this.now() / 1e3) + this.o.turnTtlSeconds;
+        const username = `${expiry}:${s.connId}`;
+        const credential = turnCredential(this.o.turnSecret, username);
+        ice.push({ urls: [...this.o.turnUrls], username, credential, ttl: this.o.turnTtlSeconds });
+      }
+      return ice;
+    }
+    // ---------------------------------------------------------------- create / join / list / leave
+    ipOf(ip) {
+      let st = this.ips.get(ip);
+      if (!st) {
+        st = { create: new RateWindow(this.o.createPerMin * this.scale, 6e4), join: new RateWindow(this.o.joinPerMin * this.scale, 6e4), open: 0, sockets: 0 };
+        this.ips.set(ip, st);
+      }
+      return st;
+    }
+    create(s, m) {
+      if (s.lobby || s.pendingIn) return this.error(s, "bad_request", "already in a lobby");
+      const ip = this.ipOf(s.ip);
+      const now = this.now();
+      if (!this.o.disableIpLimits) {
+        if (!ip.create.tryHit(now)) return this.rateLimited(s, "create", ip.create.retryAfterMs(now), null);
+        if (ip.open >= this.o.openLobbiesPerIp * this.scale) return this.rateLimited(s, "open_lobbies", 5e3, "max_lobbies");
+      }
+      if (this.o.singleLobby && this.createdOnce) return this.error(s, "server_full", "this host runs one lobby");
+      if (this.lobbies.size >= this.o.maxLobbies || this.members >= this.o.maxPeers) return this.error(s, "server_full", "server is at its lobby limit");
+      const quota = this.o.gameQuotas[s.gameId];
+      if (quota !== void 0 && (this.gameLobbies.get(s.gameId) ?? 0) >= quota) return this.error(s, "server_full", "lobby quota for this game is reached");
+      if (has(m, "name") && str2(m, "name") === null) return this.error(s, "bad_request", "name must be a string", field("name"));
+      const vis = str2(m, "visibility") ?? "public";
+      const mode = str2(m, "mode") ?? "lockstep";
+      if (vis !== "public" && vis !== "unlisted" && vis !== "private") return this.error(s, "bad_request", "visibility must be public, unlisted or private", field("visibility"));
+      if (mode !== "lockstep" && mode !== "raw") return this.error(s, "bad_request", "mode must be lockstep or raw", field("mode"));
+      if (has(m, "maxPlayers") && int2(m, "maxPlayers") === null) return this.error(s, "bad_request", "maxPlayers must be an integer", field("maxPlayers"));
+      const maxPlayers = int2(m, "maxPlayers") ?? 8;
+      if (maxPlayers < 2 || maxPlayers > this.o.hardMaxPlayers) return this.error(s, "bad_request", `maxPlayers must be 2-${this.o.hardMaxPlayers}`, field("maxPlayers"));
+      if (has(m, "tickRate") && int2(m, "tickRate") === null) return this.error(s, "bad_request", "tickRate must be an integer", field("tickRate"));
+      const tick = int2(m, "tickRate") ?? 20;
+      if (tick < 1 || tick > 255) return this.error(s, "bad_request", "tickRate must be 1-255", field("tickRate"));
+      if (has(m, "lateJoin") && bool2(m, "lateJoin") === null) return this.error(s, "bad_request", "lateJoin must be a boolean", field("lateJoin"));
+      if (has(m, "relayOnly") && bool2(m, "relayOnly") === null) return this.error(s, "bad_request", "relayOnly must be a boolean", field("relayOnly"));
+      const meta = readMeta(m.meta);
+      if ("err" in meta) return this.error(s, "bad_request", meta.err, field("meta"));
+      const code = this.newCode();
+      if (code === null) return this.error(s, "server_full", "could not allocate a join code");
+      const lobby = new HubLobby();
+      Object.assign(lobby, {
+        code,
+        gameId: s.gameId,
+        netVersion: s.netVersion,
+        name: sanitize(str2(m, "name"), LOBBY_NAME_MAX, `${s.name}'s lobby`),
+        visibility: vis,
+        mode,
+        tickRate: tick,
+        lateJoin: bool2(m, "lateJoin") ?? false,
+        relayOnly: bool2(m, "relayOnly") ?? false,
+        maxPlayers,
+        createdAt: now,
+        ownerIp: s.ip,
+        meta: meta.meta
+      });
+      this.lobbies.set(code, lobby);
+      this.createdOnce = true;
+      this.gameLobbies.set(s.gameId, (this.gameLobbies.get(s.gameId) ?? 0) + 1);
+      ip.open++;
+      this.metrics.inc("onelobby_lobbies_created_total");
+      const host = this.addMember(lobby, s, null);
+      lobby.hostId = host.peerId;
+      this.logEvent("create", lobby, s);
+      this.send(s, this.lobbyMsg(lobby, host));
+    }
+    join(s, m) {
+      if (s.lobby || s.pendingIn) return this.error(s, "bad_request", "already in a lobby");
+      const ip = this.ipOf(s.ip);
+      const now = this.now();
+      if (!this.o.disableIpLimits && !ip.join.tryHit(now)) return this.rateLimited(s, "join", ip.join.retryAfterMs(now), null);
+      let lobby;
+      if (this.o.singleLobby && !has(m, "code")) {
+        lobby = this.lobbies.values().next().value;
+        if (!lobby || lobby.gameId !== s.gameId) return this.error(s, "unknown_code", "this host has no open lobby for that game");
+      } else {
+        const code = normalizeCode2(m.code);
+        if (code === null) return this.error(s, "bad_request", "malformed join code", field("code"));
+        lobby = this.lobbies.get(code);
+        if (!lobby || lobby.gameId !== s.gameId) return this.error(s, "unknown_code", "no lobby with that code");
+      }
+      if (this.o.password !== null && str2(m, "password") !== this.o.password) return this.error(s, "bad_password", "wrong password for this lobby");
+      if (lobby.netVersion !== s.netVersion)
+        return this.error(s, "version_mismatch", `host is on ${lobby.netVersion}, you are on ${s.netVersion}`, { hostNetVersion: lobby.netVersion, yourNetVersion: s.netVersion });
+      if (lobby.kicked.has(s.ip)) return this.error(s, "kicked", "you were removed from this lobby");
+      if (lobby.phase === "in_game" && !lobby.lateJoin) return this.error(s, "in_game", "the game has already started");
+      if (lobby.members.length >= lobby.maxPlayers) return this.error(s, "lobby_full", "lobby is full");
+      if (this.members >= this.o.maxPeers) return this.error(s, "server_full", "server is at its peer limit");
+      if (lobby.visibility === "private") {
+        if (lobby.pending.length >= PENDING_MAX) return this.error(s, "lobby_full", "too many pending requests");
+        const pm = new Member();
+        pm.peerId = lobby.nextPeerId++;
+        pm.name = s.name;
+        pm.session = s;
+        pm.ip = s.ip;
+        lobby.pending.push(pm);
+        s.pendingIn = lobby;
+        s.pendingMember = pm;
+        const hs = lobby.find(lobby.hostId)?.session;
+        if (hs) this.send(hs, { t: "join_request", peer: this.peerObj(pm) });
+        this.logEvent("join_request", lobby, s);
+        return;
+      }
+      this.admit(lobby, s, null);
+    }
+    admit(lobby, s, pending) {
+      const joiner = this.addMember(lobby, s, pending);
+      this.logEvent("join", lobby, s);
+      for (const other of lobby.members) if (other !== joiner) this.sendTo(other, { t: "peer_joined", peer: this.peerObj(joiner) });
+      if (!lobby.find(lobby.hostId)?.session) this.promoteHost(lobby, lobby.hostId);
+      this.send(s, this.lobbyMsg(lobby, joiner));
+    }
+    addMember(lobby, s, reuse) {
+      const mem = reuse ?? new Member();
+      if (!reuse) mem.peerId = lobby.nextPeerId++;
+      mem.name = s.name;
+      mem.session = s;
+      mem.ip = s.ip;
+      mem.joinedAt = this.now();
+      mem.detachedAt = 0;
+      mem.token = hex(16);
+      lobby.members.push(mem);
+      this.members++;
+      this.tokens.set(mem.token, { lobby, member: mem });
+      s.lobby = lobby;
+      s.member = mem;
+      s.pendingIn = null;
+      s.pendingMember = null;
+      return mem;
+    }
+    list(s, m) {
+      const vis = str2(m, "visibility");
+      if (!this.o.issueCodes) return this.send(s, { t: "lobbies", items: [] });
+      if (vis !== "public") return this.error(s, "bad_request", "only public lobbies can be listed", field("visibility"));
+      let limit = 50;
+      if (has(m, "limit")) {
+        const l = int2(m, "limit");
+        if (l === null || l < 1 || l > this.o.listLimitMax) return this.error(s, "bad_request", `limit must be 1-${this.o.listLimitMax}`, field("limit"));
+        limit = l;
+      }
+      let offset = 0;
+      if (has(m, "cursor")) {
+        const c = str2(m, "cursor");
+        if (c === null || !/^\d+$/.test(c)) return this.error(s, "bad_request", "bad cursor", field("cursor"));
+        offset = Number(c);
+      }
+      let filter = null;
+      if (has(m, "meta")) {
+        if (typeof m.meta !== "object" || Array.isArray(m.meta)) return this.error(s, "bad_request", "meta must be an object", field("meta"));
+        filter = {};
+        for (const [k, v] of Object.entries(m.meta)) {
+          if (typeof v !== "string") return this.error(s, "bad_request", "meta values must be strings", field("meta"));
+          filter[k] = v;
+        }
+      }
+      const all = [...this.lobbies.values()].filter((l) => l.gameId === s.gameId && l.netVersion === s.netVersion && l.visibility === "public" && (l.phase !== "in_game" || l.lateJoin) && (filter === null || Object.entries(filter).every(([k, v]) => l.meta[k] === v))).sort((a, b) => a.createdAt - b.createdAt || byCode(a.code, b.code));
+      const page = all.slice(offset, offset + limit);
+      const items = page.map((l) => ({
+        code: l.code,
+        gameId: l.gameId,
+        netVersion: l.netVersion,
+        name: l.name,
+        hostName: l.find(l.hostId)?.name ?? "",
+        players: l.members.length,
+        maxPlayers: l.maxPlayers,
+        phase: l.phase,
+        meta: { ...l.meta },
+        region: this.o.region,
+        createdAt: l.createdAt
+      }));
+      const reply = { t: "lobbies", items };
+      if (offset + page.length < all.length) reply.cursor = String(offset + page.length);
+      this.send(s, reply);
+    }
+    leave(s) {
+      if (s.pendingIn) {
+        s.pendingIn.pending = s.pendingIn.pending.filter((p) => p !== s.pendingMember);
+        s.pendingIn = null;
+        s.pendingMember = null;
+        return;
+      }
+      if (!s.lobby || !s.member) return;
+      this.removeMember(s.lobby, s.member, "left");
+    }
+    // ---------------------------------------------------------------- relay + host-only
+    signal(s, m) {
+      const lobby = s.lobby;
+      const me = s.member;
+      if (!lobby || !me) return this.error(s, "bad_request", "not in a lobby");
+      const to = int2(m, "to");
+      const target = to === null ? void 0 : lobby.find(to);
+      if (!target || !target.session || target === me) return this.error(s, "bad_request", "unknown signal target", field("to"));
+      if (this.o.singleLobby && me.peerId !== lobby.hostId && target.peerId !== lobby.hostId)
+        return this.error(s, "bad_request", "signals go to or from the host only", field("to"));
+      const now = this.now();
+      const rate = this.signalRate(s, target, now);
+      if (!rate.tryHit(now)) return this.rateLimited(s, "signal", rate.retryAfterMs(now), null);
+      const total = s.signalTotal ??= new RateWindow(this.o.signalPerSec * SIGNAL_FANOUT * this.scale, 1e3);
+      if (!total.tryHit(now)) return this.rateLimited(s, "signal", total.retryAfterMs(now), null);
+      if (!has(m, "sdp") && !has(m, "ice")) return this.error(s, "bad_request", "signal needs sdp or ice", field("sdp"));
+      const o = { t: "signal", from: me.peerId };
+      if (has(m, "sdp")) o.sdp = m.sdp;
+      if (has(m, "ice")) o.ice = m.ice;
+      this.send(target.session, o);
+      this.metrics.inc("onelobby_signals_relayed_total");
+    }
+    /**
+     * spec/signaling.md rate limits: `signal` is counted per sender and target, so a host answering several joiners at once
+     * gets the budget for each, and per sender in total (SIGNAL_FANOUT targets' worth).
+     */
+    signalRate(s, to, now) {
+      let w = s.signalRates.get(to);
+      if (!w) {
+        for (const [k, v] of s.signalRates) if (v.isIdle(now)) s.signalRates.delete(k);
+        w = new RateWindow((to.session?.ip.startsWith(NOSTR_ADDR) ? NOSTR_SIGNAL_PER_SEC : this.o.signalPerSec) * this.scale, 1e3);
+        s.signalRates.set(to, w);
+      }
+      return w;
+    }
+    requireHost(s) {
+      if (!s.lobby || !s.member) {
+        this.error(s, "bad_request", "not in a lobby");
+        return null;
+      }
+      if (s.lobby.hostId !== s.member.peerId) {
+        this.error(s, "not_host", "only the host can do that");
+        return null;
+      }
+      return s.lobby;
+    }
+    hostMeta(s, m) {
+      const lobby = this.requireHost(s);
+      if (!lobby) return;
+      const meta = readMeta(m.meta);
+      if ("err" in meta || !has(m, "meta")) return this.error(s, "bad_request", "err" in meta ? meta.err : "meta is required", field("meta"));
+      lobby.meta = meta.meta;
+      this.broadcastLobby(lobby);
+    }
+    hostPhase(s, m) {
+      const lobby = this.requireHost(s);
+      if (!lobby) return;
+      const ph = str2(m, "phase");
+      if (ph !== "in_game" && ph !== "lobby") return this.error(s, "bad_request", "phase must be in_game or lobby", field("phase"));
+      lobby.phase = ph;
+      this.logEvent(`phase:${ph}`, lobby, s);
+      this.broadcastLobby(lobby);
+    }
+    kick(s, m) {
+      const lobby = this.requireHost(s);
+      if (!lobby) return;
+      const id = int2(m, "peerId");
+      const target = id === null ? void 0 : lobby.find(id);
+      if (id === null || id === s.member.peerId || !target) return this.error(s, "bad_request", "unknown peerId", field("peerId"));
+      const ban = bool2(m, "ban");
+      if (has(m, "ban") && ban === null) return this.error(s, "bad_request", "ban must be a boolean", field("ban"));
+      const code = int2(m, "closeCode");
+      if (has(m, "closeCode") && (code === null || !(code === 1e3 || code >= 3e3 && code <= 4999)))
+        return this.error(s, "bad_request", "closeCode must be 1000 or 3000-4999", field("closeCode"));
+      const closeReason = str2(m, "closeReason");
+      if (has(m, "closeReason") && (closeReason === null || closeReason.length > 120))
+        return this.error(s, "bad_request", "closeReason must be a string of at most 120 characters", field("closeReason"));
+      const data = {};
+      if (ban === false) data.ban = false;
+      if (code !== null) data.closeCode = code;
+      if (closeReason !== null) data.closeReason = closeReason;
+      if (ban !== false) {
+        lobby.kicked.add(target.ip);
+        const link = target.session?.linkIp;
+        if (link && target.ip.startsWith(NOSTR_ADDR)) lobby.kicked.add(link);
+      }
+      this.removeMember(lobby, target, ban === false ? "disconnected" : "kicked", Object.keys(data).length ? data : void 0);
+    }
+    approve(s, m) {
+      const lobby = this.requireHost(s);
+      if (!lobby) return;
+      const id = int2(m, "peerId");
+      const pm = id === null ? void 0 : lobby.pending.find((p) => p.peerId === id);
+      const js = pm?.session;
+      if (!pm || !js) return this.error(s, "bad_request", "no such pending request", field("peerId"));
+      if (has(m, "ok") && bool2(m, "ok") === null) return this.error(s, "bad_request", "ok must be a boolean", field("ok"));
+      lobby.pending = lobby.pending.filter((p) => p !== pm);
+      js.pendingIn = null;
+      js.pendingMember = null;
+      if (bool2(m, "ok") !== true) return this.error(js, "kicked", "the host declined your request", { reason: "denied" });
+      if (lobby.members.length >= lobby.maxPlayers) return this.error(js, "lobby_full", "lobby is full");
+      if (lobby.phase === "in_game" && !lobby.lateJoin) return this.error(js, "in_game", "the game has already started");
+      this.admit(lobby, js, pm);
+    }
+    /** Peer-side migration (s.9) tells the server: the new host announces itself with a higher epoch. */
+    claimHost(s, m) {
+      const lobby = s.lobby;
+      const me = s.member;
+      if (!lobby || !me) return;
+      const host = int2(m, "hostId");
+      const epoch = int2(m, "epoch");
+      if (host !== me.peerId || epoch === null || epoch <= lobby.epoch) return;
+      if (this.o.singleLobby) return;
+      if (lobby.hostId !== me.peerId && lobby.find(lobby.hostId)?.session) {
+        if (epoch > lobby.pendingClaimEpoch) {
+          lobby.pendingClaimPeer = me.peerId;
+          lobby.pendingClaimEpoch = epoch;
+        }
+        return;
+      }
+      lobby.hostId = me.peerId;
+      lobby.epoch = epoch;
+      lobby.pendingClaimPeer = lobby.pendingClaimEpoch = 0;
+      this.broadcast(lobby, { t: "host_changed", hostId: lobby.hostId, epoch: lobby.epoch });
+      this.metrics.inc("onelobby_host_changes_total");
+      this.logEvent("host_claim", lobby, s);
+    }
+    pathReport(s, m) {
+      const p = str2(m, "path");
+      if (p === "relayed" || p === "direct") this.metrics.inc("onelobby_path_total", "path", p);
+      else this.error(s, "bad_request", "path must be relayed or direct", field("path"));
+    }
+    // ---------------------------------------------------------------- membership changes
+    /** Removes a member for good. A member that is already detached was announced as left, so nothing is sent for it. */
+    removeMember(lobby, mem, reason, kickData) {
+      const i = lobby.members.indexOf(mem);
+      if (i < 0) return;
+      lobby.members.splice(i, 1);
+      this.members--;
+      this.tokens.delete(mem.token);
+      const ms = mem.session;
+      const wasConnected = mem.detachedAt === 0;
+      if (ms) {
+        ms.lobby = null;
+        ms.member = null;
+      }
+      if (wasConnected) {
+        this.broadcast(lobby, { t: "peer_left", peerId: mem.peerId, reason });
+        this.metrics.inc("onelobby_peers_left_total", "reason", reason);
+        if ((reason === "kicked" || reason === "disconnected") && ms)
+          this.error(ms, "kicked", reason === "kicked" ? "the host removed you from the lobby" : "the host disconnected you", kickData);
+      }
+      this.logEvent(reason, lobby, ms);
+      if (lobby.members.length === 0) return this.closeLobby(lobby);
+      if (lobby.hostId === mem.peerId) this.promoteHost(lobby, mem.peerId);
+    }
+    /** Server mirror of the peer-side rule (s.9): new host is the lowest peerId still connected; epoch +1. */
+    promoteHost(lobby, leavingId) {
+      const claimant = lobby.pendingClaimEpoch > lobby.epoch && lobby.pendingClaimPeer !== leavingId ? lobby.members.find((x) => x.peerId === lobby.pendingClaimPeer && x.session) : void 0;
+      const claimEpoch = lobby.pendingClaimEpoch;
+      lobby.pendingClaimPeer = lobby.pendingClaimEpoch = 0;
+      let next = claimant ?? lobby.members.filter((x) => x.session && x.peerId !== leavingId).sort((a, b) => a.peerId - b.peerId)[0];
+      if (!next) {
+        if (lobby.find(leavingId)) return;
+        next = [...lobby.members].sort((a, b) => a.peerId - b.peerId)[0];
+        if (!next) return;
+      }
+      lobby.hostId = next.peerId;
+      if (claimant) lobby.epoch = claimEpoch;
+      else lobby.epoch++;
+      this.broadcast(lobby, { t: "host_changed", hostId: next.peerId, epoch: lobby.epoch });
+      this.metrics.inc("onelobby_host_changes_total");
+      const hs = next.session;
+      if (hs) for (const pm of lobby.pending) this.send(hs, { t: "join_request", peer: this.peerObj(pm) });
+      this.logEvent("host_changed", lobby, next.session);
+    }
+    closeLobby(lobby) {
+      this.lobbies.delete(lobby.code);
+      this.retired.set(lobby.code, this.now());
+      const n = this.gameLobbies.get(lobby.gameId);
+      if (n !== void 0) {
+        if (n <= 1) this.gameLobbies.delete(lobby.gameId);
+        else this.gameLobbies.set(lobby.gameId, n - 1);
+      }
+      const ip = this.ips.get(lobby.ownerIp);
+      if (ip && ip.open > 0) ip.open--;
+      for (const pm of [...lobby.pending]) {
+        const ps = pm.session;
+        if (ps) {
+          ps.pendingIn = null;
+          ps.pendingMember = null;
+          this.error(ps, "unknown_code", "the lobby closed");
+        }
+      }
+      lobby.pending = [];
+      this.logEvent("close", lobby, null);
+    }
+    newCode() {
+      for (let i = 0; i < 100; i++) {
+        let c = "";
+        for (let k = 0; k < 6; k++) c += CROCKFORD[this.rand(32)];
+        if (!this.lobbies.has(c) && !this.retired.has(c)) return c;
+      }
+      return null;
+    }
+    // ---------------------------------------------------------------- output helpers
+    lobbyMsg(l, you) {
+      const peers = l.members.filter((x) => x.detachedAt === 0).sort((a, b) => a.peerId - b.peerId).map((p) => ({ peerId: p.peerId, name: p.name, joinedAt: p.joinedAt }));
+      return {
+        t: "lobby",
+        code: this.o.issueCodes ? l.code : "",
+        gameId: l.gameId,
+        netVersion: l.netVersion,
+        hostId: l.hostId,
+        you: you.peerId,
+        mode: l.mode,
+        tickRate: l.tickRate,
+        lateJoin: l.lateJoin,
+        phase: l.phase,
+        meta: { ...l.meta },
+        peers,
+        resumeToken: you.token,
+        name: l.name,
+        maxPlayers: l.maxPlayers,
+        visibility: l.visibility,
+        relayOnly: l.relayOnly
+      };
+    }
+    broadcastLobby(l) {
+      for (const m of l.members) if (m.session) this.sendTo(m, this.lobbyMsg(l, m));
+    }
+    broadcast(l, o) {
+      for (const m of l.members) this.sendTo(m, o);
+    }
+    peerObj(m) {
+      return { peerId: m.peerId, name: m.name };
+    }
+    send(s, o) {
+      if (!s.closed) s.send(JSON.stringify(o));
+    }
+    sendTo(m, o) {
+      if (m.session) this.send(m.session, o);
+    }
+    error(s, code, msg, data) {
+      this.metrics.inc("onelobby_errors_total", "code", code);
+      const o = { t: "error", code, msg };
+      if (data !== void 0) o.data = data;
+      s.send(JSON.stringify(o));
+    }
+    rateLimited(s, kind, retryAfterMs, reason) {
+      this.metrics.inc("onelobby_rate_limit_hits_total", "kind", kind);
+      this.log(`rate_limit kind=${kind} ip=${this.hashIp(s.ip)}`);
+      const data = { retryAfterMs };
+      if (reason !== null) data.reason = reason;
+      this.error(s, "rate_limited", `too many ${kind} requests`, data);
+    }
+    logEvent(ev, l, s) {
+      this.log(`lobby ${ev} code=${l.code} game=${l.gameId} players=${l.members.length} ip=${s ? this.hashIp(s.ip) : "-"}`);
+    }
+    hashIp(ip) {
+      return shortHash(this.logSalt + ip);
+    }
+  };
+
+  // src/direct/hub-local.ts
+  var LocalHubSocket = class _LocalHubSocket {
+    constructor(hub) {
+      this.hub = hub;
+      this.session = hub.connect(
+        _LocalHubSocket.ADDRESS,
+        (text) => queueMicrotask(() => this.readyState === 1 && this.onmessage?.({ data: text })),
+        () => this.finish()
+      );
+      queueMicrotask(() => {
+        if (!this.session) {
+          this.finish();
+          return;
+        }
+        this.readyState = 1;
+        this.onopen?.();
+      });
+    }
+    hub;
+    /** Address the hub sees for the host itself (rate limits and kicks are per address). */
+    static ADDRESS = "local";
+    readyState = 0;
+    onopen = null;
+    onmessage = null;
+    onclose = null;
+    onerror = null;
+    session;
+    send(data) {
+      if (this.readyState === 1 && this.session) this.hub.receive(this.session, data);
+    }
+    close() {
+      const s = this.session;
+      const wasOpen = this.readyState === 1;
+      this.finish();
+      if (wasOpen && s) this.hub.disconnect(s);
+    }
+    finish() {
+      if (this.readyState === 3) return;
+      this.readyState = 3;
+      queueMicrotask(() => this.onclose?.());
+    }
+  };
+
+  // src/direct/browser-host.ts
+  function formatBrowserHostLog(code, relays) {
+    return `OneLobby: browser host (no port); code ${code} (Nostr); nostr ${relays} relays`;
+  }
+  async function hostNostr(kit, opts = {}) {
+    const bp = kit.blueprint;
+    if (bp && !bp.hosting.nostr) {
+      throw new OneLobbyError("nostr_disabled", "this game has Nostr signaling turned off (hosting.nostr is false), and a browser host has no other way to be reached");
+    }
+    const defined = Object.fromEntries(Object.entries(opts).filter(([, v]) => v !== void 0));
+    const o = bp ? {
+      maxPlayers: bp.lobby.maxPlayers,
+      lateJoin: bp.lobby.lateJoin,
+      meta: { ...bp.lobby.meta },
+      ...bp.session.rateLimit ? { rateLimit: { ...bp.session.rateLimit } } : {},
+      ...defined,
+      nostr: { ...defined.nostr, relays: defined.nostr?.relays ?? [...bp.hosting.nostrRelays] }
+    } : defined;
+    const maxPlayers = o.maxPlayers ?? 4;
+    const relays = o.nostr?.relays && o.nostr.relays.length > 0 ? o.nostr.relays : [...DEFAULT_NOSTR_RELAYS];
+    const stunUrls = o.nostr?.stun ?? [...DEFAULT_NOSTR_STUN];
+    const hub = new SignalingHub({ ...directHubOptions(maxPlayers, o.password), stunUrls });
+    const ticker = setInterval(() => hub.tick(), 1e3);
+    ticker.unref?.();
+    const code = encodeRoomCode();
+    const env = kit.nostrHostEnv();
+    let bridge;
+    const teardown = () => {
+      clearInterval(ticker);
+      bridge?.close();
+    };
+    try {
+      try {
+        bridge = await NostrHostBridge.start(hub, { code, relays, connect: env.connect, clock: env.clock, wall: env.wall, maxPlayers });
+      } catch (e) {
+        throw new OneLobbyError("direct_unreachable", `cannot reach any Nostr relay (${e instanceof Error ? e.message : String(e)}); a browser host has no other way to be reached`);
+      }
+      if (!await bridge.settle(o.relayTimeoutMs ?? HOST_NOSTR_FIRST_RELAY_MS)) {
+        throw new OneLobbyError("direct_unreachable", `no Nostr relay reachable (tried ${bridge.relaysTotal}); a browser host has no IP fallback, check the connection or pass other relays`);
+      }
+      const name = o.name ?? `${kit.options.displayName || "Player"}'s game`;
+      const h = { name, maxPlayers, lateJoin: o.lateJoin ?? true, meta: o.meta, rateLimit: o.rateLimit };
+      const lobby = await kit.hostDirectWith(h, { socketFactory: () => new LocalHubSocket(hub), wrapLinks: (inner) => inner });
+      lobby.linkAddressSink = (peerId, ip) => hub.reportLinkAddress(peerId, ip);
+      lobby.on("sessionEnded", teardown);
+      lobby.joinCode = code;
+      lobby.joinCodeKind = "nostr";
+      lobby.directCode = "";
+      lobby.directCodeKind = "none";
+      lobby.portMapping = "off";
+      lobby.directHostLog = formatBrowserHostLog(code, `${bridge.relaysConnected}/${bridge.relaysTotal}`);
+      watchVisibility(lobby, o);
+      if (o.log !== false) (o.log ?? console.log)(lobby.directHostLog);
+      return lobby;
+    } catch (e) {
+      teardown();
+      throw e;
+    }
+  }
+  function watchVisibility(lobby, o) {
+    const doc = o.document !== void 0 ? o.document : globalThis.document;
+    if (!doc || typeof doc.addEventListener !== "function") return;
+    const warn = o.warn === false ? null : o.warn ?? ((s) => console.warn(s));
+    const check2 = () => {
+      const hidden = doc.visibilityState === "hidden";
+      const changed = hidden !== lobby.hostHidden;
+      lobby.setHostHidden(hidden);
+      if (changed && hidden) warn?.("OneLobby: the host tab is hidden; the browser slows its timers, so players may lag or drop. Keep this tab visible while hosting.");
+    };
+    doc.addEventListener("visibilitychange", check2);
+    lobby.on("sessionEnded", () => doc.removeEventListener("visibilitychange", check2));
+    check2();
+  }
+
   // src/onelobby.ts
   var LIB_NAME = "onelobby";
-  var LIB_VERSION = "0.4.1";
+  var LIB_VERSION = "0.6.0";
   var DEFAULT_READY_TIMEOUT_MS = 15e3;
   function hasMic() {
     return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof AudioWorkletNode !== "undefined";
@@ -3034,7 +5760,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     for (const l of liveSeats) if (l.resumeToken === token) return true;
     return false;
   }
-  var OneLobby = class extends Emitter {
+  var OneLobby = class _OneLobby extends Emitter {
     options;
     socketFactory;
     linkFactory;
@@ -3044,6 +5770,54 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     createMic;
     createSink;
     storage;
+    nostrConnectFn;
+    /** The validated, frozen onelobby.json this kit was built from (`OneLobby.fromConfig`); undefined for `new OneLobby`. */
+    blueprint;
+    /**
+     * Build a kit from an onelobby.json (already parsed; docs/design/blueprint.md s.7). Throws `bad_config` for an
+     * invalid file or name, `identity_anonymous` for a name when `players.identity` is "anonymous". Then `host()` and
+     * `hostDirect()` default their options from the file and the file's chat/listing switches are enforced.
+     */
+    static fromConfig(json, overrides = {}) {
+      const bp = parseBlueprint(json);
+      const name = (overrides.displayName ?? "").trim();
+      if (name) {
+        if (bp.players.identity === "anonymous") throw new OneLobbyError("identity_anonymous", "this game uses anonymous players: no display names");
+        if (name.length > bp.players.maxNameLength)
+          throw new BlueprintError("displayName", "length", `must be at most ${bp.players.maxNameLength} characters`);
+      }
+      const kit = new _OneLobby({
+        gameId: bp.game.id,
+        netVersion: bp.game.netVersion,
+        lobbyServer: overrides.lobbyServer ?? bp.hosting.lobbyServer,
+        mode: bp.sync.mode === "lockstep" ? "lockstep" : "raw",
+        // replication is C# only; JS speaks raw
+        tickRate: bp.sync.tickRate,
+        hashEveryTicks: bp.sync.hashEveryTicks,
+        displayName: name,
+        relayOnly: bp.hosting.relayOnly,
+        readyTimeoutMs: bp.session.readyTimeoutMs,
+        peerTimeoutMs: bp.session.peerTimeoutMs,
+        rememberSeat: overrides.rememberSeat ?? bp.lobby.rejoin,
+        advanced: overrides.advanced
+      });
+      kit.blueprint = bp;
+      return kit;
+    }
+    /** @internal Host options the blueprint implies (empty without one). */
+    blueprintHostDefaults() {
+      const bp = this.blueprint;
+      if (!bp) return {};
+      const name = this.options.displayName;
+      return {
+        name: name ? `${name}'s game` : "Game",
+        maxPlayers: bp.lobby.maxPlayers,
+        visibility: bp.lobby.listed ? "public" : bp.lobby.approveJoins ? "private" : "unlisted",
+        lateJoin: bp.lobby.lateJoin,
+        meta: { ...bp.lobby.meta },
+        ...bp.session.rateLimit ? { rateLimit: { ...bp.session.rateLimit } } : {}
+      };
+    }
     constructor(o) {
       super();
       const tickRate = o.tickRate ?? 20;
@@ -3071,6 +5845,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       this.createMic = mic !== void 0 ? mic : hasMic() ? () => new WorkletMic() : null;
       const sink = pick("createSink");
       this.createSink = sink !== void 0 ? sink : typeof AudioContext !== "undefined" ? () => new WebAudioSink() : null;
+      this.nostrConnectFn = a.nostrConnect;
       this.storage = o.rememberSeat === false ? null : a.storage !== void 0 ? a.storage : browserStorage();
     }
     // ---- remembered seat -------------------------------------------------------------------------------------------
@@ -3152,6 +5927,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     }
     /** The signaling socket only (no hello yet); with a timeout (direct IP), no answer is `direct_unreachable`. */
     async open(url, factory, timeoutMs) {
+      if (!url.trim() && factory === defaultSocketFactory) throw new OneLobbyError("no_server", "no lobby server address (set hosting.lobbyServer or pass lobbyServer)");
       const sig = new SignalingClient(url, factory, this.clock);
       if (timeoutMs > 0) {
         let cancel = () => {
@@ -3189,6 +5965,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         rateLimit
       });
       lobby.errorSink = (e) => this.emit("error", e);
+      if (this.blueprint) guardLobby(lobby, this.blueprint);
       if (this.storage && !direct) {
         liveSeats.add(lobby);
         this.saveSeat(lobby.code, lobby.resumeToken);
@@ -3200,7 +5977,9 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       }
       return lobby;
     }
-    async host(h) {
+    /** With a blueprint (`fromConfig`) every option defaults from `lobby.*`; explicit options win. */
+    async host(opts) {
+      const h = { name: "Game", maxPlayers: 4, ...this.blueprintHostDefaults(), ...definedOnly(opts) };
       const { sig, welcome } = await this.connect();
       try {
         const state = await sig.request(
@@ -3245,18 +6024,18 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       }
     }
     /**
-     * Join a direct-IP host (docs/direct-ip.md): a join code from the host's screen (`6B01-RGFE-P2B`, any case, spaces
+     * Join a direct-IP host (docs/design/direct-ip.md): a join code from the host's screen (`6B01-RGFE-P2B`, any case, spaces
      * or hyphens) or, advanced, an address (`ip`, `ip:port`, `[v6]:port`). No lobby server is involved: the code is
      * the host's address. A mistyped code fails at once with `bad_code`; nobody listening is `direct_unreachable`.
      * The address is also given to ICE as the host's UDP candidate. When the host leaves, `sessionEnded("host_left")`.
      */
     async joinDirect(codeOrAddress, opts = {}) {
-      const { addr, links } = this.directTarget(codeOrAddress, opts);
-      const { sig, welcome } = await this.connect(addr.url, this.socketFactory, opts.connectTimeoutMs ?? 5e3);
+      const t = this.directTarget(codeOrAddress, opts);
+      const { sig, welcome } = await this.connectDirect(t, opts);
       try {
         const state = await sig.request({ t: "join", ...opts.password ? { password: opts.password } : {} }, "lobby");
-        const lobby = this.makeLobby(sig, welcome, state, { links });
-        lobby.joinCode = joinedWith(addr);
+        const lobby = this.makeLobby(sig, this.withStun(welcome, t, opts), state, { links: t.links });
+        lobby.joinCode = t.joinedWith;
         return lobby;
       } catch (e) {
         sig.close();
@@ -3269,24 +6048,55 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
      * same peer id comes back. Rejects with `invalid_token` when the seat is gone: offer `joinDirect` then.
      */
     async rejoinDirect(codeOrAddress, resumeToken, opts = {}) {
-      const { addr, links } = this.directTarget(codeOrAddress, opts);
-      const lobby = await this.resumeAt(resumeToken, addr.url, opts.connectTimeoutMs ?? 5e3, { links });
-      lobby.joinCode = joinedWith(addr);
+      const t = this.directTarget(codeOrAddress, opts);
+      const lobby = await this.resumeAt(resumeToken, t.url, t.nostr ? 0 : opts.connectTimeoutMs ?? 5e3, { links: t.links }, t.nostr ? this.nostrFactory(t, opts) : void 0, (w) => this.withStun(w, t, opts));
+      lobby.joinCode = t.joinedWith;
       return lobby;
     }
+    nostrFactory(t, opts) {
+      const relays = opts.nostrRelays ?? (this.blueprint ? [...this.blueprint.hosting.nostrRelays] : void 0);
+      return () => new NostrSocket({ code: t.nostr, relays: relays && relays.length > 0 ? relays : void 0, connect: this.nostrConnectFn, clock: this.clock, wall: this.wall });
+    }
+    /** Opens the signaling socket of a direct target: TCP to the host's address, or Nostr relays for a version 1 code. */
+    async connectDirect(t, opts) {
+      if (!t.nostr) return this.connect(t.url, this.socketFactory, opts.connectTimeoutMs ?? 5e3);
+      let sock = null;
+      const factory = this.nostrFactory(t, opts);
+      try {
+        return await this.connect(t.url, (u) => sock = factory(u), 0);
+      } catch (e) {
+        const why = sock?.failure;
+        if (e instanceof OneLobbyError && e.code === "connect_failed") throw new OneLobbyError("direct_unreachable", why || "no answer through the Nostr relays");
+        throw e;
+      }
+    }
+    /** A Nostr joiner needs STUN; take the host's list (it comes in `welcome`), else the public defaults. */
+    withStun(welcome, t, opts) {
+      if (!t.nostr || welcome.ice && welcome.ice.length > 0) return welcome;
+      const urls = opts.stun ?? [...DEFAULT_NOSTR_STUN];
+      return urls.length > 0 ? { ...welcome, ice: [{ urls }] } : welcome;
+    }
     directTarget(codeOrAddress, opts) {
       let input = codeOrAddress.trim();
       if (looksLikeJoinCode(input)) {
         const d = decodeJoinCode(input);
         if ("error" in d)
           throw new OneLobbyError(d.error, d.error === "unknown_version" ? `"${input}" is a join code from a newer version of the game` : `"${input}" is not a valid join code: check for a typo`);
+        if ("room" in d) {
+          const shown = encodeRoomCodeFor(d.room);
+          return { nostr: shown, url: `nostr:${shown}`, joinedWith: shown, links: this.linkFactory };
+        }
         input = `${d.ip}:${d.port}`;
       }
       const addr = parseDirectAddress(input, opts.defaultPort ?? DEFAULT_DIRECT_PORT);
       if (!addr) throw new OneLobbyError("bad_address", `"${codeOrAddress}" is not a join code or an address (try 6B01-RGFE-P2B or 192.168.1.20:47810)`);
       const inner = this.linkFactory;
       const links = { create: (o) => inner.create({ ...o, iceServers: [], extraRemoteCandidates: [addr.candidate] }) };
-      return { addr, links };
+      return { nostr: null, url: addr.url, joinedWith: joinedWith(addr), links };
+    }
+    /** @internal onelobby/direct's Nostr host: the relay seam and the kit's clocks. */
+    nostrHostEnv() {
+      return { connect: this.nostrConnectFn, clock: this.clock, wall: this.wall };
     }
     /** @internal onelobby/direct's host: create the one lobby on the embedded hub, in direct mode. */
     async hostDirectWith(h, hooks) {
@@ -3311,17 +6121,27 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         throw e;
       }
     }
+    /**
+     * Host a direct lobby from this browser tab (or any runtime with WebSocket and WebRTC): no Node process, no port.
+     * The hub runs in the page and joiners find it through Nostr relays with `lobby.joinCode` (a dc1 version 1 code,
+     * `joinCodeKind` "nostr"); they use `kit.joinDirect(code)`. Rejects with `direct_unreachable` when no relay answers
+     * within 10 s (a browser has no IP fallback) and `nostr_disabled` when the blueprint has `hosting.nostr` false.
+     * Keep the tab visible: hidden tabs are throttled (`lobby.hostHidden`, event `hostHiddenChanged`).
+     */
+    hostNostr(opts = {}) {
+      return hostNostr(this, opts);
+    }
     async rejoin(resumeToken) {
       return this.resumeAt(resumeToken, this.options.lobbyServer, 0);
     }
-    async resumeAt(resumeToken, url, timeoutMs, direct) {
-      const sig = await this.open(url, this.socketFactory, timeoutMs);
+    async resumeAt(resumeToken, url, timeoutMs, direct, factory, tweakWelcome) {
+      const sig = await this.open(url, factory ?? this.socketFactory, timeoutMs);
       try {
         const lobbyP = sig.expect("lobby");
         const welcomeP = sig.request(this.helloMsg(resumeToken), "welcome");
         lobbyP.catch(() => {
         });
-        const welcome = await welcomeP;
+        const welcome = tweakWelcome ? tweakWelcome(await welcomeP) : await welcomeP;
         if (welcome.peerId === void 0) throw new OneLobbyError("invalid_token", "resume token unknown or expired");
         const state = await lobbyP;
         return this.makeLobby(sig, welcome, state, direct);
@@ -3331,6 +6151,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       }
     }
     async list(opts = {}) {
+      if (this.blueprint && !this.blueprint.hosting.server) throw new OneLobbyError("listing_disabled", "this game has no lobby server (hosting.server is false)");
       const { sig } = await this.connect();
       try {
         const res = await sig.request(
@@ -3351,6 +6172,36 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       return addr.display;
     }
   }
+  function definedOnly(o) {
+    const out = {};
+    if (o) {
+      for (const [k, v] of Object.entries(o)) if (v !== void 0) out[k] = v;
+    }
+    return out;
+  }
+  function guardLobby(lobby, bp) {
+    lobby.voice.mode = bp.chat.voiceMode;
+    if (!bp.chat.voice) {
+      const voice = lobby.voice;
+      const d = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(voice), "enabled");
+      if (d?.get && d.set) {
+        Object.defineProperty(voice, "enabled", {
+          configurable: true,
+          get: () => d.get.call(voice),
+          set: (v) => {
+            if (v) throw new OneLobbyError("voice_disabled", "this game has voice chat turned off (chat.voice is false)");
+            d.set.call(voice, v);
+          }
+        });
+      }
+    }
+    lobby.pause.mode = bp.session.pause;
+    if (!bp.chat.text) {
+      lobby.chat.send = () => {
+        throw new OneLobbyError("chat_disabled", "this game has text chat turned off (chat.text is false)");
+      };
+    }
+  }
 
   // src/friendly.ts
   var ErrorCodes = {
@@ -3378,7 +6229,18 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     Closed: "closed",
     ServerLost: "server_lost",
     InvalidToken: "invalid_token",
-    NoServer: "no_server"
+    NoServer: "no_server",
+    // from the shared pause (lobby.pause)
+    NotInGame: "not_in_game",
+    NotAllowed: "not_allowed",
+    // from a blueprint (onelobby.json)
+    BadConfig: "bad_config",
+    VoiceDisabled: "voice_disabled",
+    ChatDisabled: "chat_disabled",
+    PauseDisabled: "pause_disabled",
+    ListingDisabled: "listing_disabled",
+    NostrDisabled: "nostr_disabled",
+    IdentityAnonymous: "identity_anonymous"
   };
   var TEXT = {
     // server errors (spec/signaling.md)
@@ -3401,7 +6263,18 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     server_lost: { message: "Lost the connection to the game server.", hint: "Your game may keep going; new players can't join until it's back." },
     invalid_token: { message: "Your old seat in that lobby is no longer available.", hint: "Join again with the lobby code." },
     ice_failed: { message: "Couldn't connect to the other players.", hint: "Some networks (school, work, public Wi-Fi) block game connections. Try another network or a phone hotspot." },
+    no_server: { message: "This game has no lobby server address yet.", hint: "Enter one in the multiplayer settings, or host from your own computer with a join code." },
     timeout: { message: "The connection took too long.", hint: "Check your internet connection, then try again." },
+    voice_disabled: { message: "Voice chat is turned off in this game." },
+    chat_disabled: { message: "Text chat is turned off in this game." },
+    pause_disabled: { message: "Pausing is turned off in this game." },
+    not_in_game: { message: "You can only pause while a game is running.", hint: "Start the game first." },
+    not_allowed: { message: "You can't do that right now.", hint: "The player who paused, or the host, can resume." },
+    listing_disabled: { message: "This game has no public lobby list.", hint: "Join with a code or a link from the host." },
+    direct_unreachable: { message: "Couldn't reach the host.", hint: "Check the code, and that the host is still online. A host in a browser needs its tab open and visible." },
+    nostr_disabled: { message: "This game can't be hosted from a browser.", hint: "Host from the desktop version, or let the game's owner know." },
+    identity_anonymous: { message: "This game doesn't use player names.", hint: "Everyone shows up as Player 1, Player 2, and so on." },
+    bad_config: { message: "The game's multiplayer settings file is not valid.", hint: "Let the game's owner know; the details are in the error message." },
     left: { message: "You left the lobby." },
     unknown: { message: "Something went wrong.", hint: "Try again. If it keeps happening, reload the page." }
   };
@@ -3457,6 +6330,16 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     u.searchParams.set(param, formatCode(norm).replace(" ", "-"));
     return u.toString();
   }
+  async function directJoinInfo(base) {
+    const b = base ?? currentHref();
+    if (!b) return null;
+    try {
+      const res = await fetch(new URL("/joininfo", b), { cache: "no-store" });
+      return res.ok ? await res.json() : null;
+    } catch {
+      return null;
+    }
+  }
   function codeFromUrl(url, param = "join") {
     const href = url ?? currentHref();
     if (!href) return null;
@@ -3475,9 +6358,9 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
   var KeepaliveError = OneLobbyError;
 
   // src/ui/controller.ts
-  var enc3 = new TextEncoder();
+  var enc4 = new TextEncoder();
   var dec3 = new TextDecoder();
-  var toBytes = (w) => enc3.encode(JSON.stringify(w));
+  var toBytes = (w) => enc4.encode(JSON.stringify(w));
   var SharedState = class {
     constructor(c) {
       this.c = c;