@genex-ai/multiplayer 0.7.1 → 0.8.0

package/README.md

@@ -13,24 +13,15 @@ import { connect } from '@genex-ai/multiplayer';
 ## Connect
 
 ```ts
-import { waitForPlayer, getColyseusAuth } from '@genex-ai/embed-sdk';
-
 type State = { x: number; y: number; z: number };   // YOUR per-player state — any JSON shape
 
-await waitForPlayer();                        // identity gate — resolves for guests AND accounts
 const room = await connect<State>({
   url:  'wss://demo-colyseus.glotech.world',  // the genex multiplayer server
   room: '<game-id>',                          // everyone with the same id shares a room (use the project slug)
   name: 'ada',                                // optional display name
-  auth: getColyseusAuth()!,                   // REQUIRED — the relay rejects tokenless joins
 });
 ```
 
-`auth` is **required** — the relay rejects tokenless joins. Get it from `@genex-ai/embed-sdk`:
-`await waitForPlayer()` first (never `waitForAuth()` — that resolves only for signed-in accounts
-and keeps guests out forever), then read `getColyseusAuth()` **fresh at every `connect()`** —
-tokens rotate every ~10 min, so never cache the object across reconnects. Never log it.
-
 Different `room` ids are **fully isolated** — players in game A never see game B.
 
 ---
@@ -91,10 +82,8 @@ player. `state` is smoothed; `stateRaw` is the raw latest (hit-tests). `objects.
 
 ## `isHost` / `host` — the elected room authority
 
-One client is the **host** — the earliest **signed-in** player still present (guests host only
-while no account is in the room), re-elected automatically. The host can change on **join** as
-well as leave: the first account entering a guest-hosted room takes over. Use it to pick a single
-writer for scores/rounds or a single simulator for NPCs.
+One client is the **host** (the first joiner still present, re-elected automatically when they
+leave). Use it to pick a single writer for scores/rounds or a single simulator for NPCs.
 
 ```ts
 if (room.isHost) room.shared.set('round', nextRound);   // only the host advances the round
@@ -114,10 +103,52 @@ room.on('shared', (key, value) => {}); // a shared key changed
 room.on('object', (id)        => {});  // an object's owner changed (handoff)
 room.on('host',   (id)        => {});  // the room host changed
 room.on('hit',    (payload)   => {});  // a custom event someone sent (see `send`)
+
+room.on('reconnecting', ({ attempt }) => {}); // connection dropped — auto-reconnect underway
+room.on('reconnected',  ()            => {}); // back in the SAME seat: id, objects, host intact
+room.on('disconnect',   (code)        => {}); // terminal — connect() fresh to play again
 ```
 
 `on(...)` returns an unsubscribe function.
 
+## Reconnection (automatic)
+
+A dropped socket (Wi-Fi blip, brief signal loss) is **not** a leave: the relay holds your
+seat for a grace window (~30s) and the SDK reconnects with backoff. On success nothing
+changed — same session id, owned objects still yours, host status intact, and mid-match a
+blip is **not a forfeit**. Render `reconnecting`/`reconnected` as an overlay and keep your
+loop running. `disconnect` is terminal (server restart, revoked session, or the link never
+recovered): read a fresh token and `connect()` again. A deliberate `leave()` never
+reconnects. The relay also broadcasts `server:restart` right before a deploy — flush saves
+when you see it.
+
+**One seat per player:** the relay enforces a single session per identity per room — a
+second tab / device / reloaded page supersedes the previous session (old one gets
+`disconnect`, code 4409), so the same player never appears twice and reloads never leave
+a ghost. Reload/close sockets ("going away") get only a ~5s seat-hold; genuine network
+drops keep the full reconnection grace.
+
+## `inputs` + `onHostTick` — host-authoritative physics (contested objects)
+
+Claim-on-touch is right for one-touch objects (kick a ball). For **sustained contact**
+(two players pushing one crate) let ONE simulation own the contest: everyone sends inputs —
+the relay routes them to the **current host only** — and the host applies them on a fixed
+tick and publishes results via `objects` (auto-smoothed for everyone):
+
+```ts
+if (pushing) room.inputs.send({ obj: 'crate', push: dir });   // any client → host only
+
+room.inputs.on((fromId, payload) => queue.push(payload));      // fires only while YOU host
+room.onHostTick(30, (dtMs) => {                                // runs only on the host,
+  // adopt objects + seed from stateRaw on first tick, apply    //  auto-migrates with the
+  // queued inputs to YOUR one physics world, then:             //  host election
+  room.objects.set('crate', { x, y, z, q });
+});
+```
+
+`onHostTick` auto-starts on election and auto-stops on demotion; a new host seeds its world
+from each object's `stateRaw`, so the simulation survives host migration without a snap.
+
 ## `send` — custom one-off events
 
 Fire-and-forget to all **other** clients (not stored in state). For shots, emotes, chat, pings.
@@ -152,15 +183,9 @@ Remote players are **smoothed automatically** — nothing to configure. `room.pl
 
 ```ts
 import { connect } from '@genex-ai/multiplayer';
-import { waitForPlayer, getColyseusAuth } from '@genex-ai/embed-sdk';
 type S = { x: number; z: number };
 
-await waitForPlayer();   // identity gate (guest OR signed-in) — see Connect above
-const room = await connect<S>({
-  url: 'wss://demo-colyseus.glotech.world',
-  room: GAME_ID,
-  auth: getColyseusAuth()!,   // REQUIRED — tokenless joins are rejected
-});
+const room = await connect<S>({ url: 'wss://demo-colyseus.glotech.world', room: GAME_ID });
 
 const me = { x: 0, z: 0 };
 
@@ -206,26 +231,18 @@ mm.on("matched", () => {/* session is live */});
 mm.on("matchStart", ({ roundId }) => {/* round began */});
 mm.on("matchEnded", ({ winnerId, scores, draw }) => {/* result screen */});
 mm.on("spectate", () => {/* seated as a spectator (overflow) — read-only */});
-mm.on("error", (e) => {/* queue join failed even after the SDK's automatic retries — persistent
-                          (broken auth / server unreachable); fix the cause, then mm.retry() */});
 
 // Report ONLY your own outcome — the server adjudicates. Pick the call that matches the win condition:
 mm.eliminated();   // I'm out              (lastStanding)
 mm.score(1);       // I scored             (firstToScore / highScoreInTime)
 mm.finish();       // I finished the race  (firstToFinish)
 
-mm.retry();        // re-enter the queue after a terminal 'error' (no-op in any other state)
 mm.cancel();       // stop searching / leave the match
 ```
 
-A failed queue join is **retried automatically** with backoff (~10s total), so transient failures
-(a token mid-rotation, identity still settling on page load) never surface. Only a persistent
-failure emits `error`; the handle then idles until you call `mm.retry()`.
-
 **`mm.matchmaking`** (read every frame for your HUD): `status` (`searching` | `waiting` | `countdown` | `playing` | `ended` | `spectating`), `queue` (`{ position, size }`), `players`, `opponents`, `teams`, `myTeam`, `scores`, `winCondition`, `config` (numeric knobs), `roundId`, `winnerId`, `message`. `championId`/`challengerId` are 1v1 aliases.
 
-Configure once in the game's `package.json` (reported at `genex preview` AND `genex publish`;
-removing it clears the stored config on the next preview/publish — never sent from the client):
+Configure once in the game's `package.json` (reported at publish; never sent from the client):
 
 ```jsonc
 "genex": {

package/dist/index.d.ts

@@ -13,11 +13,10 @@ type ConnectOptions = {
     /**
      * Verified-identity credential — REQUIRED to actually join: the relay
      * rejects tokenless joins (there is no anonymous play). Pass
-     * `genexEmbed.getColyseusAuth()` AFTER `await genexEmbed.waitForPlayer()`
-     * (from `@genex-ai/embed-sdk`). NOT `waitForAuth()` — that resolves only for
-     * signed-in accounts and would keep guests out of multiplayer forever.
-     * Read it fresh at every connect() call — never cache the object across
-     * reconnects (tokens rotate every ~10 min). NEVER log this value.
+     * `genexEmbed.getColyseusAuth()` AFTER `await genexEmbed.waitForAuth()`
+     * (from `@genex-ai/embed-sdk`), and read it fresh at every connect() call —
+     * never cache the object across reconnects (tokens rotate every ~10 min).
+     * NEVER log this value.
      */
     auth?: {
         embedToken: string;
@@ -66,8 +65,7 @@ type Session<TState extends Record<string, unknown>> = {
     readonly shared: {
         /** Read a shared value (any JSON), or `undefined`. */
         get(key: string): unknown;
-        /** Set a shared value (any JSON). Any client may write game keys — by convention only
-         * the host writes agreed facts (see `isHost`); `__*` keys are reserved and rejected. */
+        /** Set a shared value (any JSON). Any client may set any key (no auth — demo). */
         set(key: string, value: unknown): void;
         /** All shared keys currently set. */
         keys(): string[];
@@ -92,40 +90,72 @@ type Session<TState extends Record<string, unknown>> = {
         /** Ids of every object seen so far. */
         ids(): string[];
     };
-    /** True if you are the elected room host — the earliest signed-in player still present
-     * (guests host only while no account is in the room); can migrate on join as well as leave.
-     * Settles within the first state patch after connect — read it in your loop or react to
-     * `on('host')`, not once. */
+    /** True if you are the elected room host (first joiner still present). Settles within the
+     * first state patch after connect — read it in your loop or react to `on('host')`, not once. */
     readonly isHost: boolean;
     /** Session id of the current room host, or `undefined` until the first host patch lands. */
     readonly host: string | undefined;
+    /**
+     * Input channel for host-authoritative patterns (contested physics, host-simulated
+     * NPCs): anyone `send`s an input; the server delivers it ONLY to the current host
+     * (never broadcast). The host applies inputs in its one authoritative simulation and
+     * publishes results via `objects` — everyone renders them auto-smoothed.
+     */
+    readonly inputs: {
+        /** Send an input/impulse to the current host (single receiver, cheap). */
+        send(payload: unknown): void;
+        /** Receive inputs — only ever fires while YOU are the host. Returns unsubscribe. */
+        on(cb: (fromId: string, payload: unknown) => void): () => void;
+    };
+    /**
+     * Run `cb(dtMs)` on a fixed tick ONLY while this client is the host — auto-starts on
+     * election and auto-stops on demotion/leave, so host-simulation code needs no "am I
+     * host this frame?" bookkeeping. Returns a disposer.
+     */
+    onHostTick(hz: number, cb: (dtMs: number) => void): () => void;
     /** A player appeared/updated. **Also fires for you** on connect — filter `id === room.id`. */
     on(event: 'join' | 'change', cb: (id: string, state: TState) => void): () => void;
     /** A player left. */
     on(event: 'leave', cb: (id: string) => void): () => void;
     /** A shared key changed (reserved `__*` keys are hidden). For live values just read `shared.get`. */
     on(event: 'shared', cb: (key: string, value: unknown) => void): () => void;
-    /** An object's owner or state changed (fires with its id). */
+    /** An object's OWNERSHIP changed (claim/handoff), or it appeared/was destroyed — fires
+     * with its id. NOT per-tick state: poll `objects.get(id)` in your loop for state. */
     on(event: 'object', cb: (id: string) => void): () => void;
     /** The room host changed (fires with the new host's id, or `undefined`). */
     on(event: 'host', cb: (host: string | undefined) => void): () => void;
+    /**
+     * The connection dropped unexpectedly and auto-reconnect is underway (attempts run
+     * ~0.5s→8s backoff inside the server's grace window). Show a "reconnecting…" overlay;
+     * keep your loop running — the world resumes seamlessly on `reconnected`.
+     */
+    on(event: 'reconnecting', cb: (info: {
+        attempt: number;
+        code: number;
+    }) => void): () => void;
+    /** Auto-reconnect succeeded: same session id, same seat — nothing was torn down. */
+    on(event: 'reconnected', cb: () => void): () => void;
+    /**
+     * The connection is gone for good: the server closed it on purpose (restart, revoked
+     * session, match eviction) or every reconnect attempt failed. The session is dead —
+     * to play again, read a FRESH `getColyseusAuth()` and `connect()` anew.
+     */
+    on(event: 'disconnect', cb: (code: number) => void): () => void;
     /** A custom event another client sent via `send(type, ...)`. */
     on(event: string & {}, cb: (payload: unknown) => void): () => void;
-    /** Fire-and-forget event to all OTHER clients (not stored in state). */
+    /** Fire-and-forget event to all OTHER clients (not stored in state). Event names used
+     * by the relay itself (`state`, `shared`, `claim`, `obj`, `release`, `destroy`, and the
+     * `match:`/`__` prefixes) are refused with a console warning — pick another name. */
     send(type: string, payload?: unknown): void;
-    /** Leave the room. */
+    /** Leave the room (deliberate — no auto-reconnect, no `disconnect` event). */
     leave(): void;
 };
 /**
  * Connect to a genex multiplayer room. You must supply your player-state type:
  *
  * ```ts
- * import { waitForPlayer, getColyseusAuth } from '@genex-ai/embed-sdk';
- *
- * await waitForPlayer();             // identity gate (guest OR signed-in)
  * const room = await connect<{ x: number; y: number; z: number }>({
  *   url: 'ws://localhost:2567', room: gameId, name: 'ada',
- *   auth: getColyseusAuth()!,        // REQUIRED — the relay rejects tokenless joins
  * });
  * room.me.set({ x, y, z });          // typed + validated by the compiler
  * room.players.get(id)?.state.x;     // number — auto-smoothed for remote players
@@ -175,8 +205,6 @@ type Matchmaking<TState extends Record<string, unknown>> = {
      * searching: (re)entered the queue. queue: your position changed ({position,size}).
      * matched: `session` is now live. matchStart: a round began ({roundId}).
      * matchEnded: {winnerId,loserId,draw,scores}. spectate: you're watching, not playing.
-     * error: joining the queue failed even after the SDK's automatic retries (persistent —
-     * e.g. auth is broken or the server is unreachable); fix the cause, then call `retry()`.
      */
     on(event: 'searching' | 'queue' | 'matched' | 'matchStart' | 'matchEnded' | 'spectate' | 'error', cb: (payload?: unknown) => void): () => void;
     /** Report your OWN elimination (the `lastStanding` win condition). */
@@ -185,9 +213,6 @@ type Matchmaking<TState extends Record<string, unknown>> = {
     score(delta?: number): void;
     /** Report that you finished (the `firstToFinish` win condition — a race). */
     finish(): void;
-    /** Re-enter the queue after a terminal `error`. No-op while searching/matched, after
-     * `cancel()`, and for private lobbies (create/join a new lobby instead). */
-    retry(): void;
     /** Stop searching / leave the current match. */
     cancel(): void;
 };
@@ -213,10 +238,6 @@ type MatchmakeOptions = {
  * Join a game's matchmaking. Returns immediately in the SEARCHING state (`session` is null); the
  * matchmaker seats you into a match room, at which point `session` becomes a live Session and a
  * `matched` event fires. The preset + config are owned by the project (server-side).
- *
- * A failed queue join is retried automatically with backoff (~10s total) — transient failures
- * (token rotation, identity settling) never surface. A persistent failure emits 'error' and the
- * handle idles until `retry()` is called.
  */
 declare function matchmake<TState extends Record<string, unknown> = never>(opts: MatchmakeOptions): Promise<Matchmaking<TState>>;
 /** A private lobby handle — a Matchmaking whose `session` is live immediately, plus the invite `code`. */

package/dist/index.js

@@ -16,6 +16,7 @@ var RESERVED_PREFIX = "__";
 var OBJ_PREFIX = "__obj:";
 var HOST_KEY = "__host";
 var MATCH_KEY = "__match";
+var INPUT_MSG = "__input";
 var MP_PROTOCOL = 1;
 function parseData(s) {
   if (!s) return { state: {} };
@@ -135,9 +136,15 @@ async function connect(opts) {
     __v: MP_PROTOCOL
     // tells the relay this client hides reserved `__` keys (see MP_PROTOCOL)
   });
-  return attachSession(room);
+  return attachSession(client, room);
 }
-function attachSession(room) {
+var RESERVED_SEND_TYPES = /* @__PURE__ */ new Set(["state", "shared", "claim", "obj", "release", "destroy"]);
+var isReservedSendType = (type) => RESERVED_SEND_TYPES.has(type) || type.startsWith("match:") || type.startsWith(RESERVED_PREFIX);
+var RECONNECT_DELAYS_MS = [500, 1e3, 2e3, 4e3, 8e3];
+var ROOM_REF = /* @__PURE__ */ Symbol("genex.roomRef");
+var roomOf = (s) => s[ROOM_REF]();
+function attachSession(client, initialRoom) {
+  let room = initialRoom;
   const buffers = /* @__PURE__ */ new Map();
   const lastStamp = /* @__PURE__ */ new Map();
   const clockOffsets = /* @__PURE__ */ new Map();
@@ -211,23 +218,20 @@ function attachSession(room) {
   };
   const emitters = /* @__PURE__ */ new Map();
   const bridged = /* @__PURE__ */ new Set();
-  const reserved = /* @__PURE__ */ new Set(["join", "leave", "change", "shared", "object", "host"]);
+  const reserved = /* @__PURE__ */ new Set([
+    "join",
+    "leave",
+    "change",
+    "shared",
+    "object",
+    "host",
+    "reconnecting",
+    "reconnected",
+    "disconnect",
+    INPUT_MSG
+    // inputs.on() has its own channel — never bridged as a custom event
+  ]);
   const emit = (event, ...args) => emitters.get(event)?.forEach((cb) => cb(...args));
-  const $ = getStateCallbacks(room);
-  $(room.state).players.onAdd((player, id) => {
-    const { state, sendTime } = parseData(player.data);
-    emit("join", id, state);
-    if (id !== room.sessionId) pushSnap(id, state, sendTime);
-    $(player).onChange(() => {
-      const { state: st, sendTime: ts } = parseData(player.data);
-      emit("change", id, st);
-      if (id !== room.sessionId) pushSnap(id, st, ts);
-    });
-  });
-  $(room.state).players.onRemove((_player, id) => {
-    emit("leave", id);
-    clearStream(id);
-  });
   const lastShared = /* @__PURE__ */ new Map();
   const handleShared = (value, key) => {
     if (lastShared.get(key) === value) return;
@@ -261,26 +265,90 @@ function attachSession(room) {
     }
     emit("shared", key, parseValue(value));
   };
-  $(room.state).shared.onAdd(handleShared);
-  $(room.state).shared.onChange(handleShared);
-  $(room.state).shared.onRemove((_value, key) => {
-    lastShared.delete(key);
-    if (key === HOST_KEY) {
-      if (hostId !== void 0) {
-        hostId = void 0;
-        emit("host", void 0);
+  const parseCache = /* @__PURE__ */ new Map();
+  const cachedParse = (id, raw) => {
+    if (!raw) return {};
+    const hit = parseCache.get(id);
+    if (hit && hit.raw === raw) return hit.state;
+    const { state } = parseData(raw);
+    parseCache.set(id, { raw, state });
+    return state;
+  };
+  let intentionalLeave = false;
+  let dead = false;
+  const wireRoom = (r) => {
+    const $ = getStateCallbacks(r);
+    $(r.state).players.onAdd((player, id) => {
+      const { state, sendTime } = parseData(player.data);
+      emit("join", id, state);
+      if (id !== room.sessionId) pushSnap(id, state, sendTime);
+      $(player).onChange(() => {
+        const { state: st, sendTime: ts } = parseData(player.data);
+        emit("change", id, st);
+        if (id !== room.sessionId) pushSnap(id, st, ts);
+      });
+    });
+    $(r.state).players.onRemove((_player, id) => {
+      emit("leave", id);
+      clearStream(id);
+      parseCache.delete(id);
+    });
+    $(r.state).shared.onAdd(handleShared);
+    $(r.state).shared.onChange(handleShared);
+    $(r.state).shared.onRemove((_value, key) => {
+      lastShared.delete(key);
+      if (key === HOST_KEY) {
+        if (hostId !== void 0) {
+          hostId = void 0;
+          emit("host", void 0);
+        }
+        return;
+      }
+      if (key.startsWith(OBJ_PREFIX)) {
+        const id = key.slice(OBJ_PREFIX.length);
+        clearStream(key);
+        objRaw.delete(id);
+        objOwners.delete(id);
+        localObjState.delete(id);
+        emit("object", id);
       }
+    });
+    r.onMessage(INPUT_MSG, (msg) => {
+      if (msg && typeof msg.from === "string") emit(INPUT_MSG, msg.from, msg.d);
+    });
+    for (const event of bridged) r.onMessage(event, (msg) => emit(event, msg));
+    r.onLeave((code) => handleLeave(r, code ?? 1006));
+    r.onError(() => {
+    });
+  };
+  const handleLeave = (left, code) => {
+    if (left !== room || dead) return;
+    if (intentionalLeave) return;
+    if (code === 1e3 || code >= 4e3) {
+      dead = true;
+      emit("disconnect", code);
       return;
     }
-    if (key.startsWith(OBJ_PREFIX)) {
-      const id = key.slice(OBJ_PREFIX.length);
-      clearStream(key);
-      objRaw.delete(id);
-      objOwners.delete(id);
-      localObjState.delete(id);
-      emit("object", id);
+    void attemptReconnect(left.reconnectionToken, code);
+  };
+  const attemptReconnect = async (token, code) => {
+    for (let attempt = 1; attempt <= RECONNECT_DELAYS_MS.length; attempt++) {
+      emit("reconnecting", { attempt, code });
+      await new Promise((r) => setTimeout(r, RECONNECT_DELAYS_MS[attempt - 1]));
+      if (intentionalLeave || dead) return;
+      try {
+        const next = await client.reconnect(token);
+        room = next;
+        wireRoom(next);
+        emit("reconnected");
+        return;
+      } catch {
+      }
     }
-  });
+    dead = true;
+    emit("disconnect", code);
+  };
+  wireRoom(room);
   const on = ((event, cb) => {
     let set = emitters.get(event);
     if (!set) emitters.set(event, set = /* @__PURE__ */ new Set());
@@ -293,13 +361,13 @@ function attachSession(room) {
       set?.delete(cb);
     };
   });
-  return {
+  const session = {
     id: room.sessionId,
     get players() {
       const out = /* @__PURE__ */ new Map();
       const localNow = nowMs();
       room.state?.players?.forEach((p, id) => {
-        const { state: latest } = parseData(p.data);
+        const latest = cachedParse(id, p.data);
         let state = latest;
         let raw = latest;
         if (id === room.sessionId) {
@@ -387,16 +455,59 @@ function attachSession(room) {
     get host() {
       return hostId;
     },
+    inputs: {
+      send(payload) {
+        room.send(INPUT_MSG, payload);
+      },
+      on(cb) {
+        let set = emitters.get(INPUT_MSG);
+        if (!set) emitters.set(INPUT_MSG, set = /* @__PURE__ */ new Set());
+        const listener = (from, payload) => cb(from, payload);
+        set.add(listener);
+        return () => void set?.delete(listener);
+      }
+    },
+    onHostTick(hz, cb) {
+      let timer = null;
+      let last = 0;
+      const sync = () => {
+        const shouldRun = hostId !== void 0 && hostId === room.sessionId;
+        if (shouldRun && !timer) {
+          last = nowMs();
+          timer = setInterval(() => {
+            const t = nowMs();
+            cb(t - last);
+            last = t;
+          }, Math.max(10, Math.round(1e3 / hz)));
+        } else if (!shouldRun && timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+      };
+      const off = on("host", sync);
+      sync();
+      return () => {
+        off();
+        if (timer) clearInterval(timer);
+        timer = null;
+      };
+    },
     on,
     send(type, payload) {
+      if (isReservedSendType(type)) {
+        console.warn(`[multiplayer] send('${type}') collides with a relay-internal channel \u2014 use a different event name`);
+        return;
+      }
       room.send(type, payload);
     },
     leave() {
+      intentionalLeave = true;
       void room.leave();
     }
   };
+  Object.defineProperty(session, ROOM_REF, { value: () => room, enumerable: false });
+  return session;
 }
-var SEARCH_BACKOFF_MS = [1e3, 2e3, 4e3];
 var resolveAuth = (auth) => typeof auth === "function" ? auth() : auth;
 var matchJoinOptions = (opts) => ({
   gameId: opts.room,
@@ -470,52 +581,48 @@ async function matchmake(opts) {
   let queueRoom = null;
   let queueInfo = { position: 0, size: 0 };
   let cancelled = false;
-  let searching = false;
   const search = async () => {
-    if (cancelled || searching) return;
-    searching = true;
+    if (cancelled) return;
+    session = null;
+    matchRoom = null;
+    if (queueRoom) {
+      void queueRoom.leave();
+      queueRoom = null;
+    }
+    queueInfo = { position: 0, size: 0 };
+    let q;
     try {
-      session = null;
-      matchRoom = null;
-      for (let attempt = 0; ; attempt++) {
-        if (queueRoom) {
-          void queueRoom.leave();
-          queueRoom = null;
-        }
-        queueInfo = { position: 0, size: 0 };
-        let q;
-        try {
-          q = await client.joinOrCreate(QUEUE_ROOM_TYPE, matchJoinOptions(opts));
-        } catch (err) {
-          if (cancelled) return;
-          const delay = SEARCH_BACKOFF_MS[attempt];
-          if (delay == null) {
-            emit("error", err);
-            return;
-          }
-          await new Promise((r) => setTimeout(r, delay));
-          if (cancelled) return;
-          continue;
-        }
-        if (cancelled) {
-          void q.leave();
-          return;
-        }
-        queueRoom = q;
-        q.onMessage("queue", (msg) => {
-          queueInfo = { position: msg.position, size: msg.size };
-          emit("queue", msg);
-        });
-        q.onMessage(
-          "seat",
-          (msg) => void consumeSeat(msg.reservation, msg.role)
-        );
-        emit("searching");
-        return;
-      }
-    } finally {
-      searching = false;
+      q = await client.joinOrCreate(QUEUE_ROOM_TYPE, matchJoinOptions(opts));
+    } catch (err) {
+      if (!cancelled) emit("error", err);
+      return;
     }
+    if (cancelled) {
+      void q.leave();
+      return;
+    }
+    queueRoom = q;
+    q.onMessage("queue", (msg) => {
+      queueInfo = { position: msg.position, size: msg.size };
+      emit("queue", msg);
+    });
+    q.onMessage(
+      "seat",
+      (msg) => void consumeSeat(msg.reservation, msg.role)
+    );
+    q.onLeave(() => {
+      if (cancelled || queueRoom !== q) return;
+      queueRoom = null;
+      void (async () => {
+        for (const delayMs of RECONNECT_DELAYS_MS) {
+          await new Promise((r) => setTimeout(r, delayMs));
+          if (cancelled || queueRoom || session) return;
+          await search();
+          if (queueRoom || session) return;
+        }
+      })();
+    });
+    emit("searching");
   };
   const consumeSeat = async (reservation, role) => {
     try {
@@ -525,10 +632,14 @@ async function matchmake(opts) {
         return;
       }
       matchRoom = mr;
-      session = attachSession(mr);
-      mr.onMessage("match:start", (m) => emit("matchStart", m));
-      mr.onMessage("match:ended", (m) => emit("matchEnded", m));
-      mr.onMessage("match:requeue", () => void requeue());
+      const s = attachSession(client, mr);
+      session = s;
+      s.on("match:start", (m) => emit("matchStart", m));
+      s.on("match:ended", (m) => emit("matchEnded", m));
+      s.on("match:requeue", () => void requeue());
+      s.on("disconnect", () => {
+        if (!cancelled && session === s) void requeue();
+      });
       if (queueRoom) {
         void queueRoom.leave();
         queueRoom = null;
@@ -540,38 +651,34 @@ async function matchmake(opts) {
     }
   };
   const requeue = async () => {
-    if (matchRoom) {
-      void matchRoom.leave();
-      matchRoom = null;
-    }
+    session?.leave();
+    matchRoom = null;
     session = null;
     await search();
   };
-  void search();
+  await search();
+  const liveRoom = () => session ? roomOf(session) : null;
   return {
     get session() {
       return session;
     },
     get matchmaking() {
-      return buildView(matchRoom, queueInfo);
+      return buildView(liveRoom(), queueInfo);
     },
     on,
     eliminated() {
-      matchRoom?.send("match:eliminated", {});
+      liveRoom()?.send("match:eliminated", {});
     },
     score(delta = 1) {
-      matchRoom?.send("match:score", { delta });
+      liveRoom()?.send("match:score", { delta });
     },
     finish() {
-      matchRoom?.send("match:finish", {});
-    },
-    retry() {
-      if (cancelled || searching || queueRoom || matchRoom) return;
-      void search();
+      liveRoom()?.send("match:finish", {});
     },
     cancel() {
       cancelled = true;
-      if (matchRoom) void matchRoom.leave();
+      session?.leave();
+      if (!session && matchRoom) void matchRoom.leave();
       if (queueRoom) void queueRoom.leave();
       matchRoom = null;
       queueRoom = null;
@@ -588,35 +695,33 @@ function wirePrivate(client, room) {
     set.add(cb);
     return () => void set?.delete(cb);
   });
-  let matchRoom = room;
-  const session = attachSession(room);
-  room.onMessage("match:start", (m) => emit("matchStart", m));
-  room.onMessage("match:ended", (m) => emit("matchEnded", m));
-  room.onMessage("match:requeue", () => void (matchRoom = null));
-  room.onLeave(() => void (matchRoom = null));
+  let live = true;
+  const session = attachSession(client, room);
+  session.on("match:start", (m) => emit("matchStart", m));
+  session.on("match:ended", (m) => emit("matchEnded", m));
+  session.on("match:requeue", () => void (live = false));
+  session.on("disconnect", () => void (live = false));
+  const liveRoom = () => live ? roomOf(session) : null;
   return {
     get session() {
-      return matchRoom ? session : null;
+      return live ? session : null;
     },
     get matchmaking() {
-      return buildView(matchRoom, { position: 0, size: 0 });
+      return buildView(liveRoom(), { position: 0, size: 0 });
     },
     on,
     eliminated() {
-      matchRoom?.send("match:eliminated", {});
+      liveRoom()?.send("match:eliminated", {});
     },
     score(delta = 1) {
-      matchRoom?.send("match:score", { delta });
+      liveRoom()?.send("match:score", { delta });
     },
     finish() {
-      matchRoom?.send("match:finish", {});
-    },
-    retry() {
+      liveRoom()?.send("match:finish", {});
     },
     cancel() {
-      if (matchRoom) void matchRoom.leave();
-      matchRoom = null;
-      void client;
+      session.leave();
+      live = false;
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/multiplayer",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "The multiplayer client wrapper + shared room schema for genex.",
   "type": "module",
   "main": "./dist/index.js",