@genex-ai/multiplayer 0.17.10 → 0.17.11

package/dist/bridge-authority.js

@@ -9,10 +9,10 @@ import {
 } from "./chunk-4R7C2TLH.js";
 import {
   connectAuthority
-} from "./chunk-SQC6WTMF.js";
-import "./chunk-42R7NREA.js";
+} from "./chunk-I3DNVGGC.js";
+import "./chunk-BB6OIWQ2.js";
 import "./chunk-YWQ3ALYY.js";
-import "./chunk-HHETHPGL.js";
+import "./chunk-5WENVWVO.js";
 import "./chunk-OD6NRSX2.js";
 import {
   firstpersonWorld
@@ -22,7 +22,7 @@ import {
   CloseCode,
   ServerMessage,
   isReservedEventType
-} from "./chunk-7J3YWPCA.js";
+} from "./chunk-2CSX5WA6.js";
 
 // src/bridge-authority.ts
 import { getAuthorityRegions, getAuthorityUrls, getColyseusAuth } from "@genex-ai/embed-sdk";

package/dist/bridge.js

@@ -15,14 +15,14 @@ import {
   joinPrivate,
   matchmake,
   roomOf
-} from "./chunk-NSQQCLMA.js";
-import "./chunk-42R7NREA.js";
+} from "./chunk-OESKZODQ.js";
+import "./chunk-BB6OIWQ2.js";
 import {
   Limits,
   RESERVED_SHARED_PREFIX,
   ServerMessage,
   isReservedEventType
-} from "./chunk-7J3YWPCA.js";
+} from "./chunk-2CSX5WA6.js";
 
 // src/bridge.ts
 var version = 2;

package/dist/{chunk-7J3YWPCA.js → chunk-2CSX5WA6.js}

@@ -55,7 +55,7 @@ var AuthorityJoinOption = {
    *  refused with 400. */
   SUCCESSOR_CLOSED: "successorClosed"
 };
-var AUTHORITY_SDK_LABEL = "ts/0.17.10";
+var AUTHORITY_SDK_LABEL = "ts/0.17.11";
 var AuthorityCaps = {
   /** Decodes and draws §17.10's physics bodies. A physics room refuses a join without it (426). An
    *  SDK sends it only once its drawing passes `physics-draw.json` and, for an engine SDK, its own

package/dist/{chunk-HHETHPGL.js → chunk-5WENVWVO.js}

@@ -19,7 +19,7 @@ import {
   JoinError,
   Limits,
   isReservedEventType
-} from "./chunk-7J3YWPCA.js";
+} from "./chunk-2CSX5WA6.js";
 
 // src/authority/room-key.ts
 var AuthorityRoomLimits = {
@@ -31,6 +31,7 @@ var AuthorityRoomLimits = {
   MAX_WORLDS: 16
 };
 var ROOM_NOT_FOUND = 522;
+var ROOM_NOT_FOUND_AS_SENT = 500;
 var inRange = (c, lo, hi) => c >= lo.charCodeAt(0) && c <= hi.charCodeAt(0);
 var isLowerOrDigit = (c) => inRange(c, "a", "z") || inRange(c, "0", "9");
 var KEY_MARKS = "._:-";
@@ -71,7 +72,7 @@ function planAuthorityJoin(target) {
   return { method: AuthorityJoinMethod.JoinOrCreate, options };
 }
 function nextCodeRegion(error, region, regions) {
-  const elsewhere = error === JoinError.WRONG_REGION || error === ROOM_NOT_FOUND;
+  const elsewhere = error === JoinError.WRONG_REGION || error === ROOM_NOT_FOUND || error === ROOM_NOT_FOUND_AS_SENT;
   return elsewhere && region + 1 < regions ? region + 1 : null;
 }
 function selectMatchWorld(worlds, world, key) {

package/dist/{chunk-42R7NREA.js → chunk-BB6OIWQ2.js}

@@ -2,7 +2,7 @@ import {
   ClientReconnection,
   JoinError,
   PROTOCOL_VERSION
-} from "./chunk-7J3YWPCA.js";
+} from "./chunk-2CSX5WA6.js";
 
 // src/join.ts
 import { Client as Client2 } from "@colyseus/sdk";

package/dist/{chunk-SQC6WTMF.js → chunk-I3DNVGGC.js}

@@ -5,7 +5,7 @@ import {
   joinOptions,
   useSdkReconnection,
   waitForFirstState
-} from "./chunk-42R7NREA.js";
+} from "./chunk-BB6OIWQ2.js";
 import {
   udpFastOpener
 } from "./chunk-YWQ3ALYY.js";
@@ -60,7 +60,7 @@ import {
   serverTick,
   tickInstant,
   validRoomCode
-} from "./chunk-HHETHPGL.js";
+} from "./chunk-5WENVWVO.js";
 import {
   RemotePredict
 } from "./chunk-OD6NRSX2.js";
@@ -88,11 +88,12 @@ import {
   RoomType,
   ServerMessage,
   authorityCloseCodeOf
-} from "./chunk-7J3YWPCA.js";
+} from "./chunk-2CSX5WA6.js";
 
 // src/authority/regions.ts
 var AUTHORITY_REFUSALS_PER_REGION = 2;
 var AUTHORITY_MAX_PING_MS = 350;
+var AUTHORITY_REGROUP_WAITS_MS = [2e3, 4e3, 9e3, 15e3, 3e4];
 var RegionRule = {
   /** A room with players in any region in reach, nearest first; else a new room in the nearest region. */
   Players: "players",
@@ -171,6 +172,24 @@ function refusalKind(code) {
   if (typeof code !== "number" || code <= 0 || DEAD_PATH_REFUSALS.has(code)) return RefusalKind.NextRegion;
   return CAPACITY_REFUSALS.has(code) ? RefusalKind.Capacity : RefusalKind.Final;
 }
+function planAuthorityRegroup(regions, best, options = {}, joined) {
+  if (options.rule === RegionRule.Nearest) return [];
+  if (typeof options.region === "string" && regions.some((r) => r.region === options.region)) return [];
+  const at2 = regions.findIndex((r) => r.region === joined);
+  if (at2 < 0) return [];
+  const limit = answered(options.maxPingMs) ? options.maxPingMs : AUTHORITY_MAX_PING_MS;
+  return rankWithLatency(regions, best).filter((x) => x.index < at2 && x.ms !== null && x.ms <= limit).map((x) => x.pick);
+}
+function authorityRegionOf(regions, url) {
+  return regions.find((r) => r.urls.includes(url))?.region;
+}
+async function measureAuthorityRegions(regions, options = {}) {
+  const best = regions.length <= 1 ? [] : await probeAuthorityRegions(regions, options);
+  return regions.map((r, i) => {
+    const heard = (best[i] ?? []).filter(answered);
+    return { region: r.region, pingMs: heard.length === 0 ? null : Math.min(...heard) };
+  });
+}
 var SearchRefusal = {
   /** No room here (Colyseus's 521, no room matches the criteria), a dead path, a full or draining
    *  region: the next region is asked. */
@@ -194,9 +213,9 @@ function nextAttempt(state, regionCount, delays) {
 async function selectAuthorityRegions(regions, options = {}) {
   if (regions.length === 0) return [];
   if (regions.length === 1) return rankAuthorityRegions(regions, []);
-  return rankAuthorityRegions(regions, await probeBest(regions, options));
+  return rankAuthorityRegions(regions, await probeAuthorityRegions(regions, options));
 }
-async function probeBest(regions, options) {
+async function probeAuthorityRegions(regions, options) {
   const samples = Math.max(1, options.samples ?? RELAY_SELECT_DEFAULTS.SAMPLES);
   const plans = regions.map((r) => regionProbePlan(r.urls, samples));
   const results = await probeLatencies(plans, options);
@@ -213,7 +232,7 @@ async function probeBest(regions, options) {
 }
 async function selectAuthoritySearch(regions, search = {}, options = {}) {
   if (regions.length <= 1) return planAuthoritySearch(regions, [], search);
-  return planAuthoritySearch(regions, await probeBest(regions, options), search);
+  return planAuthoritySearch(regions, await probeAuthorityRegions(regions, options), search);
 }
 async function probeLatencies(plans, options = {}) {
   const probe = options.probe ?? defaultProbe;
@@ -336,6 +355,8 @@ function survivingSession(first, deps) {
   const listeners = /* @__PURE__ */ new Map();
   let current = first;
   let left = false;
+  let rejoining = false;
+  let endWait = null;
   let physicsHash = null;
   let world = null;
   const fire = (event, ...payload) => {
@@ -348,6 +369,14 @@ function survivingSession(first, deps) {
     });
   };
   const rejoin = async (lostCode, lostReason) => {
+    rejoining = true;
+    try {
+      await replaceLostRoom(lostCode, lostReason);
+    } finally {
+      rejoining = false;
+    }
+  };
+  const replaceLostRoom = async (lostCode, lostReason) => {
     const startedAt = now();
     const lost = { roomId: current.code, matchKey: current.matchKey, closed: deps.closed };
     const regions = deps.targets.length;
@@ -398,6 +427,46 @@ function survivingSession(first, deps) {
     });
   };
   watch(first);
+  const regroupWait = (ms) => {
+    if (deps.sleep !== void 0) return deps.sleep(ms);
+    return new Promise((resolve) => {
+      const timer = setTimeout(done, ms);
+      timer.unref?.();
+      function done() {
+        clearTimeout(timer);
+        endWait = null;
+        resolve();
+      }
+      endWait = done;
+    });
+  };
+  const regroup = async (ask) => {
+    const waits = AUTHORITY_REGROUP_WAITS_MS;
+    let step = 0;
+    while (!left) {
+      await regroupWait(waits[Math.min(step, waits.length - 1)]);
+      if (left) return;
+      if (rejoining || current.players().size > 1) {
+        step = 0;
+        continue;
+      }
+      step += 1;
+      const next = await ask().catch(() => null);
+      if (next === null) continue;
+      if (left || rejoining || current.players().size > 1) {
+        await next.leave().catch(() => {
+        });
+        continue;
+      }
+      const empty = current;
+      adopt(next);
+      fire(RejoinEvent.Rejoined, { code: next.code, url: next.url, moved: true });
+      await empty.leave().catch(() => {
+      });
+      step = 0;
+    }
+  };
+  if (deps.regroup !== void 0) void regroup(deps.regroup.bind(deps));
   const own = {
     input,
     frame(frameNow) {
@@ -428,6 +497,7 @@ function survivingSession(first, deps) {
     },
     async leave() {
       left = true;
+      endWait?.();
       await current.leave();
     }
   };
@@ -5325,25 +5395,27 @@ function resimBudgetMs() {
   return /Mobi|Android|iPhone|iPad/i.test(agent) ? PHYS_RESIM_BUDGET_MS.mobile : PHYS_RESIM_BUDGET_MS.desktop;
 }
 async function joinTargets(opts, method) {
-  if (opts.url) return { search: [], create: [opts.url] };
+  if (opts.url) return { search: [], create: [opts.url], regroup: () => [] };
   const regions = normalizeAuthorityRegions(opts.regions, opts.urls);
   if (regions.length === 0) throw new Error("genex multiplayer: `urls` must contain at least one authority server URL");
   const pool = method === AuthorityJoinMethod.JoinOrCreate;
-  const plan = await selectAuthoritySearch(
-    regions,
-    {
-      rule: pool ? opts.regionRule : RegionRule.Nearest,
-      maxPingMs: opts.maxPingMs,
-      ...method === AuthorityJoinMethod.JoinById ? {} : { region: opts.region }
-    },
-    opts.probe === void 0 ? {} : { probe: opts.probe }
-  );
-  return { search: plan.search.map((pick) => pick.url), create: plan.create.map((pick) => pick.url) };
+  const options = {
+    rule: pool ? opts.regionRule : RegionRule.Nearest,
+    maxPingMs: opts.maxPingMs,
+    ...method === AuthorityJoinMethod.JoinById ? {} : { region: opts.region }
+  };
+  const best = regions.length <= 1 ? [] : await probeAuthorityRegions(regions, opts.probe === void 0 ? {} : { probe: opts.probe });
+  const plan = planAuthoritySearch(regions, best, options);
+  return {
+    search: plan.search.map((pick) => pick.url),
+    create: plan.create.map((pick) => pick.url),
+    regroup: (url) => planAuthorityRegroup(regions, best, options, authorityRegionOf(regions, url) ?? "").map((pick) => pick.url)
+  };
 }
-async function joinWherePlayersAre(opts, plan, search, targets) {
+async function joinWherePlayersAre(opts, plan, search, where) {
   for (const url of search) {
     try {
-      return { room: await joinOnce(new Client(url), opts, { ...plan, method: AuthorityJoinMethod.Join }), url, targets };
+      return { room: await joinOnce(new Client(url), opts, { ...plan, method: AuthorityJoinMethod.Join }), url, ...where };
     } catch (err) {
       if (searchRefusalKind(errorCode(err)) === SearchRefusal.Final) explainAuthorityRefusal(err);
     }
@@ -5353,15 +5425,16 @@ async function joinWherePlayersAre(opts, plan, search, targets) {
 async function joinAuthority(opts, target) {
   const plan = planAuthorityJoin(target);
   if ("refused" in plan) throw new TypeError(`genex multiplayer: this room cannot be asked for (${plan.refused})`);
-  const { search, create: targets } = await joinTargets(opts, plan.method);
-  const found = await joinWherePlayersAre(opts, plan, search, targets);
+  const { search, create: targets, regroup: regroupOf } = await joinTargets(opts, plan.method);
+  const regroup = plan.method === AuthorityJoinMethod.JoinOrCreate ? regroupOf : () => [];
+  const found = await joinWherePlayersAre(opts, plan, search, { targets, regroup });
   if (found !== null) return found;
   const delays = opts.capacityRetryMs ?? CAPACITY_RETRY_MS;
   let state = { region: 0, refused: 0, step: 0 };
   for (; ; ) {
     const url = targets[state.region];
     try {
-      return { room: await joinOnce(new Client(url), opts, plan), url, targets };
+      return { room: await joinOnce(new Client(url), opts, plan), url, targets, regroup };
     } catch (err) {
       if (plan.method === AuthorityJoinMethod.JoinById) {
         const region = nextCodeRegion(errorCode(err), state.region, targets.length);
@@ -5467,15 +5540,33 @@ async function joinPrivateAuthority(code, opts) {
 function comingBack(session, opts, joined, closed) {
   if (opts.rejoin === false) return session;
   const others = joined.targets.filter((url) => url !== joined.url);
+  const seatAt = async (url, plan) => {
+    const room = await joinOnce(new Client(url), opts, plan);
+    const next = attachAuthoritySession(useSdkReconnection(room), opts, url);
+    await waitForFirstState(room, ClientReconnection.firstStateTimeoutMs);
+    return next;
+  };
+  let here = joined.url;
+  const pool = {
+    method: AuthorityJoinMethod.Join,
+    options: opts.matchKey === void 0 || opts.matchKey === "" ? {} : { matchKey: opts.matchKey }
+  };
+  const regroup = async () => {
+    for (const url of joined.regroup(here)) {
+      try {
+        const next = await seatAt(url, pool);
+        here = url;
+        return next;
+      } catch {
+      }
+    }
+    return null;
+  };
   return survivingSession(session, {
     closed,
     targets: [joined.url, ...others],
-    join: async (url, way, lost) => {
-      const room = await joinOnce(new Client(url), opts, rejoinPlan(way, lost));
-      const next = attachAuthoritySession(useSdkReconnection(room), opts, url);
-      await waitForFirstState(room, ClientReconnection.firstStateTimeoutMs);
-      return next;
-    }
+    join: (url, way, lost) => seatAt(url, rejoinPlan(way, lost)),
+    ...opts.regroup === false || joined.regroup(here).length === 0 ? {} : { regroup }
   });
 }
 function rejoinPlan(way, lost) {
@@ -6788,6 +6879,7 @@ function attachAuthoritySession(room, opts, url) {
 export {
   AUTHORITY_REFUSALS_PER_REGION,
   AUTHORITY_MAX_PING_MS,
+  AUTHORITY_REGROUP_WAITS_MS,
   RegionRule,
   normalizeAuthorityRegions,
   regionProbePlan,
@@ -6796,9 +6888,13 @@ export {
   capacityWalk,
   RefusalKind,
   refusalKind,
+  planAuthorityRegroup,
+  authorityRegionOf,
+  measureAuthorityRegions,
   SearchRefusal,
   searchRefusalKind,
   selectAuthorityRegions,
+  probeAuthorityRegions,
   selectAuthoritySearch,
   REJOIN,
   SUCCESSOR_OPEN_MS,

package/dist/{chunk-NSQQCLMA.js → chunk-OESKZODQ.js}

@@ -8,7 +8,7 @@ import {
   waitForFirstState,
   warnProtocolRefusal,
   withoutReconnection
-} from "./chunk-42R7NREA.js";
+} from "./chunk-BB6OIWQ2.js";
 import {
   ClientMessage,
   ClientReconnection,
@@ -23,7 +23,7 @@ import {
   SEND_TIME_KEY,
   ServerMessage,
   isReservedEventType
-} from "./chunk-7J3YWPCA.js";
+} from "./chunk-2CSX5WA6.js";
 
 // src/index.ts
 import { getStateCallbacks } from "@colyseus/sdk";

package/dist/index.js

@@ -3,9 +3,9 @@ import {
   createPrivate,
   joinPrivate,
   matchmake
-} from "./chunk-NSQQCLMA.js";
-import "./chunk-42R7NREA.js";
-import "./chunk-7J3YWPCA.js";
+} from "./chunk-OESKZODQ.js";
+import "./chunk-BB6OIWQ2.js";
+import "./chunk-2CSX5WA6.js";
 export {
   connect,
   createPrivate,

package/dist/protocol.d.ts

@@ -76,7 +76,7 @@ interface AuthorityDrainNotice {
     drainMs: number;
 }
 /** The SDK label this TypeScript client sends. tests hold it to package.json. */
-declare const AUTHORITY_SDK_LABEL = "ts/0.17.10";
+declare const AUTHORITY_SDK_LABEL = "ts/0.17.11";
 /** Client capabilities (§17.10 *Joining*). */
 declare const AuthorityCaps: {
     /** Decodes and draws §17.10's physics bodies. A physics room refuses a join without it (426). An

package/dist/protocol.js

@@ -50,7 +50,7 @@ import {
   isReservedEventType,
   roomKeyFor,
   slugOfRoomKey
-} from "./chunk-7J3YWPCA.js";
+} from "./chunk-2CSX5WA6.js";
 export {
   AUTHORITY_ENCODER_BUFFER_BYTES,
   AUTHORITY_MAX_FRAME_BYTES,

package/package.json

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