@genex-ai/multiplayer 0.17.6 → 0.17.8

package/dist/{chunk-Y6XHXDIK.js → chunk-QZOCUQJT.js}

@@ -5,8 +5,12 @@ import {
   joinOptions,
   useSdkReconnection,
   waitForFirstState
-} from "./chunk-UX3F6YTV.js";
+} from "./chunk-FPWP22Y7.js";
 import {
+  udpFastOpener
+} from "./chunk-YWQ3ALYY.js";
+import {
+  AuthorityJoinMethod,
   BODY_CORRECTION_TAU_MS,
   BODY_EXTRAPOLATE_BACK_TICKS,
   BODY_EXTRAPOLATE_MAX_MS,
@@ -16,11 +20,12 @@ import {
   ContactDrawing,
   ContactPush,
   ContactShapeKind,
-  EMPTY_WORLD,
+  FAST_BIND_REV,
   FAST_HANDSHAKE_MS,
-  FAST_KEY_BYTES,
-  FAST_STALL_FALLBACK_MS,
-  FastFault,
+  FAST_KEEPALIVE_BIND_MS,
+  FAST_RETURN_PROOF,
+  FAST_RETURN_STABLE_MS,
+  FastFallbackReason,
   FastMessage,
   HeadFriction,
   InputRepeat,
@@ -30,48 +35,59 @@ import {
   LiftPathMode,
   LiftShapeKind,
   MAX_PROJECTILE_G,
+  MotionRecordKind,
   NO_LIFTS,
   PHYSICS_PREDICT_MAX_ANGULAR,
   PHYSICS_PREDICT_MAX_LINEAR,
   PHYSICS_PRESET_LENGTH_UNITS,
   PhysicsPredictRange,
-  Preset,
   TopPolicy,
-  definitionOf,
+  blankEntityMotion,
+  blankSeatEcho,
+  chooseFastSocket,
   dequantizeBodyValue,
-  emptyClientRx,
-  encodeUplink,
-  firstpersonWorld,
-  hullOps,
-  inputRedundancyTicks,
+  fastRetryDelayMs,
+  isFastBind,
   isProjectile,
-  posedWorld,
+  nextCodeRegion,
+  openFastClient,
+  planAuthorityJoin,
   presetInputRepeat,
   projectileAt,
-  psincos,
   quantizeBodyValue,
-  receiveFragment,
-  resolvePresetParams,
   sanitizeInput,
   seqAheadMax,
   serverTick,
   tickInstant,
-  unsignedZero,
-  uplinkFor,
-  uplinkMaxBytes
-} from "./chunk-5JGRFT2N.js";
+  validRoomCode
+} from "./chunk-NFMGIKFZ.js";
 import {
   RemotePredict
-} from "./chunk-K3SF5VDS.js";
+} from "./chunk-OD6NRSX2.js";
+import {
+  EMPTY_WORLD,
+  Preset,
+  definitionOf,
+  firstpersonWorld,
+  hullOps,
+  posedWorld,
+  psincos,
+  resolvePresetParams,
+  unsignedZero
+} from "./chunk-2NGXXQDS.js";
 import {
   AUTHORITY_PROTOCOL_VERSION,
+  AUTHORITY_SDK_LABEL,
   AuthorityCaps,
   AuthorityJoinOption,
   AuthorityTiming,
   ClientReconnection,
+  CloseCode,
   JoinError,
-  RoomType
-} from "./chunk-ZSWF4VCN.js";
+  RoomType,
+  ServerMessage,
+  authorityCloseCodeOf
+} from "./chunk-CSQEEANB.js";
 
 // src/authority/regions.ts
 var AUTHORITY_REFUSALS_PER_REGION = 2;
@@ -120,6 +136,20 @@ function capacityWalk(regionCount, delays) {
   }
   return attempts;
 }
+var RefusalKind = {
+  /** A full region, or a process shutting down that a sibling answers: the schedule, on this region. */
+  Capacity: "capacity",
+  /** A dead path, with other regions healthy: the next region at once. */
+  NextRegion: "next_region",
+  /** The server's answer: final. */
+  Final: "final"
+};
+var CAPACITY_REFUSALS = /* @__PURE__ */ new Set([503, 4213]);
+var DEAD_PATH_REFUSALS = /* @__PURE__ */ new Set([502, 504, 520, 521, 522, 523, 524, 525, 526, 530]);
+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 nextAttempt(state, regionCount, delays) {
   const refused = state.refused + 1;
   if (refused >= AUTHORITY_REFUSALS_PER_REGION && state.region + 1 < regionCount) {
@@ -192,6 +222,187 @@ async function probeLatencies(plans, options = {}) {
   return results;
 }
 
+// src/authority/rejoin.ts
+var REJOIN = {
+  /** Waits before each attempt; past the end the last one repeats. */
+  scheduleMs: [0, 250, 500, 1e3, 2e3, 4e3],
+  /** Each wait adds up to this much, by chance, so a room's seats do not arrive at once. */
+  jitterMs: 250,
+  /** How long a seat keeps trying: long enough for a roll's next process to come up on a full node. */
+  budgetMs: 18e4,
+  /** How long a seat stays with its own region before it tries the next one. */
+  regionStayMs: 6e4,
+  /** How long a public seat looks for its room's successor before it joins the game's pool. */
+  successorMs: 9e4
+};
+var SUCCESSOR_OPEN_MS = 12e4;
+var RejoinWay = { Room: "room", Successor: "successor", Pool: "pool" };
+var RejoinStop = { Final: "final", Budget: "budget" };
+var COMES_BACK = /* @__PURE__ */ new Set([
+  CloseCode.GOING_AWAY,
+  CloseCode.NO_STATUS,
+  CloseCode.ABNORMAL,
+  1011,
+  1012,
+  1013,
+  CloseCode.SERVER_SHUTDOWN,
+  CloseCode.FAILED_TO_RECONNECT,
+  CloseCode.MAY_TRY_RECONNECT
+]);
+var FINAL_REFUSALS = /* @__PURE__ */ new Set([
+  JoinError.BAD_OPTION,
+  JoinError.NOT_ENTITLED,
+  JoinError.FORBIDDEN,
+  JoinError.MODULE_UNAVAILABLE,
+  JoinError.PROTOCOL_UNSUPPORTED
+]);
+function comesBackAfter(code) {
+  return COMES_BACK.has(code);
+}
+function rejoinStep(input) {
+  const { attempt, elapsedMs, refusal, lostCode, closed, regions, jitter } = input;
+  if (refusal !== null && FINAL_REFUSALS.has(refusal)) return { stop: RejoinStop.Final };
+  if (elapsedMs >= REJOIN.budgetMs) return { stop: RejoinStop.Budget };
+  const last = REJOIN.scheduleMs.length - 1;
+  const base = REJOIN.scheduleMs[Math.min(attempt, last)];
+  const waitMs = base + Math.floor(jitter * REJOIN.jitterMs);
+  if (attempt === 0 && lostCode !== CloseCode.SERVER_SHUTDOWN) return { waitMs, region: 0, way: RejoinWay.Room };
+  const region = regions < 1 ? 0 : Math.floor(elapsedMs / REJOIN.regionStayMs) % regions;
+  const way = closed || elapsedMs < REJOIN.successorMs ? RejoinWay.Successor : RejoinWay.Pool;
+  return { waitMs, region, way };
+}
+function validSuccessorOf(value) {
+  return validRoomCode(value);
+}
+function planSuccessorJoin(input) {
+  return {
+    ...input.matchKey === "" ? {} : { matchKey: input.matchKey },
+    successorOf: input.lostRoomId,
+    ...input.closed ? { successorClosed: true } : {}
+  };
+}
+
+// src/authority/session-rejoin.ts
+var RejoinEvent = { Draining: "draining", Rejoining: "rejoining", Rejoined: "rejoined" };
+var DISCONNECT = "disconnect";
+var UNKNOWN_CLOSE_MS = -1;
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var refusalOf = (err) => {
+  const code = err !== null && typeof err === "object" ? err.code : void 0;
+  return typeof code === "number" ? code : null;
+};
+function survivingSession(first, deps) {
+  const now = deps.now ?? Date.now;
+  const random = deps.random ?? Math.random;
+  const sleep = deps.sleep ?? defaultSleep;
+  const input = { ...first.input };
+  const listeners = /* @__PURE__ */ new Map();
+  let current = first;
+  let left = false;
+  let physicsHash = null;
+  let world = null;
+  const fire = (event, ...payload) => {
+    for (const handler of listeners.get(event) ?? []) handler(...payload);
+  };
+  const forward = (session, event) => {
+    if (event === DISCONNECT || event === RejoinEvent.Draining || event === RejoinEvent.Rejoining || event === RejoinEvent.Rejoined) return;
+    session.on(event, (...payload) => {
+      if (session === current) fire(event, ...payload);
+    });
+  };
+  const rejoin = async (lostCode, lostReason) => {
+    const startedAt = now();
+    const lost = { roomId: current.code, matchKey: current.matchKey, closed: deps.closed };
+    const regions = deps.targets.length;
+    let attempt = 0;
+    let refusal = null;
+    while (!left) {
+      const step = rejoinStep({ attempt, elapsedMs: now() - startedAt, refusal, lostCode, closed: deps.closed, regions, jitter: random() });
+      if ("stop" in step) {
+        fire(DISCONNECT, lostCode, lostReason);
+        return;
+      }
+      attempt += 1;
+      fire(RejoinEvent.Rejoining, { attempt, code: lostCode, waitMs: step.waitMs });
+      await sleep(step.waitMs);
+      if (left) return;
+      try {
+        const next = await deps.join(deps.targets[step.region], step.way, lost);
+        if (left) {
+          await next.leave().catch(() => {
+          });
+          return;
+        }
+        adopt(next);
+        fire(RejoinEvent.Rejoined, { code: next.code, url: next.url });
+        return;
+      } catch (err) {
+        refusal = refusalOf(err);
+      }
+    }
+  };
+  const adopt = (session) => {
+    current = session;
+    if (physicsHash !== null) session.setPhysics(physicsHash);
+    if (world !== null) session.setWorld(world);
+    for (const event of listeners.keys()) forward(session, event);
+    watch(session);
+  };
+  const watch = (session) => {
+    session.on(ServerMessage.SERVER_RESTART, (notice) => {
+      if (session !== current) return;
+      const drainMs = notice?.drainMs;
+      fire(RejoinEvent.Draining, { closesInMs: typeof drainMs === "number" ? drainMs : UNKNOWN_CLOSE_MS });
+    });
+    session.on(DISCONNECT, (code, reason) => {
+      if (session !== current || left) return;
+      if (comesBackAfter(code)) void rejoin(code, reason);
+      else fire(DISCONNECT, code, reason);
+    });
+  };
+  watch(first);
+  const own = {
+    input,
+    frame(frameNow) {
+      Object.assign(current.input, input);
+      return current.frame(frameNow);
+    },
+    setWorld(next) {
+      const hash = current.setWorld(next);
+      world = next;
+      return hash;
+    },
+    setPhysics(hash) {
+      physicsHash = hash;
+      return current.setPhysics(hash);
+    },
+    on(event, handler) {
+      let set = listeners.get(event);
+      if (set === void 0) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(event, set);
+        forward(current, event);
+      }
+      const fn = handler;
+      set.add(fn);
+      return () => {
+        set.delete(fn);
+      };
+    },
+    async leave() {
+      left = true;
+      await current.leave();
+    }
+  };
+  return new Proxy(first, {
+    get(_target, key) {
+      if (Object.hasOwn(own, key)) return own[key];
+      const value = current[key];
+      return typeof value === "function" ? value.bind(current) : value;
+    }
+  });
+}
+
 // src/authority/physics-draw.ts
 var IDENTITY = [0, 0, 0, 1];
 function quatMul(a, b) {
@@ -289,85 +500,127 @@ var GRID_SIDE = 32;
 var GRID_CELL_MIN = 64;
 var GRID_WIDE = 64;
 var GRID_QUERY_CELLS = 16;
+var GRID_MERGED_WIDE = 64;
 var UNSTICK_SOLIDS = 4;
-function grownBox(b, r, h) {
-  const [x0, y0, z0, x1, y1, z1] = b;
-  return [
-    [-1, 0, 0, -(x0 - r)],
-    [1, 0, 0, x1 + r],
-    [0, -1, 0, -(y0 - r)],
-    [0, 1, 0, y1 + r],
-    [0, 0, 1, z1],
-    [0, 0, -1, -(z0 - h)]
-  ];
-}
-function grownRamp(ramp, r, h) {
+var BOUNDS_STRIDE = 6;
+var PLANE_STRIDE = 4;
+var BOX_PLANES = 6;
+var RAMP_PLANES = 7;
+var RAMP_STRIDE = RAMP_PLANES * PLANE_STRIDE;
+var BOX_NORMALS = [[-1, 0, 0], [1, 0, 0], [0, -1, 0], [0, 1, 0], [0, 0, 1], [0, 0, -1]];
+var BOX_OFFSETS = [0, 3, 1, 4, 5, 2];
+function writeRamp(out, o, ramp, r, h) {
   const [x0, y0, z0, x1, y1, z1, axis, lo, hi] = ramp;
   const m0 = axis === 0 ? x0 : y0;
   const slope = (hi - lo) / ((axis === 0 ? x1 : y1) - m0);
   const k = 1 / Math.sqrt(slope * slope + 1);
   const e = (lo - slope * m0 + r * Math.abs(slope)) * k;
-  const top = axis === 0 ? [-slope * k, 0, k, e] : [0, -slope * k, k, e];
-  return [[1, 0, 0, x1 + r], [-1, 0, 0, -x0 + r], [0, 1, 0, y1 + r], [0, -1, 0, -y0 + r], top, [0, 0, 1, z1], [0, 0, -1, -z0 + h]];
-}
-function solidOf(planes, src, r, h) {
-  return { planes, min: [src[0] - r, src[1] - r, src[2] - h], max: [src[3] + r, src[4] + r, src[5]] };
+  const planes = [1, 0, 0, x1 + r, -1, 0, 0, -x0 + r, 0, 1, 0, y1 + r, 0, -1, 0, -y0 + r, axis === 0 ? -slope * k : 0, axis === 0 ? 0 : -slope * k, k, e, 0, 0, 1, z1, 0, 0, -1, -z0 + h];
+  out.set(planes, o);
 }
 function compileContactWorld(spec, r, h, skin) {
-  const boxes = (spec?.boxes ?? []).map((b) => solidOf(grownBox(b, r, h), b, r, h));
-  const ramps = (spec?.ramps ?? []).map((b) => solidOf(grownRamp(b, r, h), b, r, h));
-  const solids = [...boxes, ...ramps];
-  const grid = gridOf(solids);
-  return grid === null ? { solids, skin } : { solids, skin, grid };
+  const boxes = spec?.boxes ?? [];
+  const ramps = spec?.ramps ?? [];
+  const count = boxes.length + ramps.length;
+  const bounds = new Float64Array(count * BOUNDS_STRIDE);
+  const rampPlanes = new Float64Array(ramps.length * RAMP_STRIDE);
+  for (let i = 0; i < count; i++) {
+    const src = i < boxes.length ? boxes[i] : ramps[i - boxes.length];
+    const o = i * BOUNDS_STRIDE;
+    bounds[o] = src[0] - r;
+    bounds[o + 1] = src[1] - r;
+    bounds[o + 2] = src[2] - h;
+    bounds[o + 3] = src[3] + r;
+    bounds[o + 4] = src[4] + r;
+    bounds[o + 5] = src[5];
+    if (i >= boxes.length) writeRamp(rampPlanes, (i - boxes.length) * RAMP_STRIDE, src, r, h);
+  }
+  const world = { count, boxCount: boxes.length, bounds, rampPlanes, skin };
+  const grid = gridOf(world);
+  return grid === null ? world : { ...world, grid };
+}
+function placeable(b, i) {
+  const o = i * BOUNDS_STRIDE;
+  return Number.isFinite(b[o]) && Number.isFinite(b[o + 3]) && Number.isFinite(b[o + 1]) && Number.isFinite(b[o + 4]);
 }
-var placeable = (s) => Number.isFinite(s.min[0]) && Number.isFinite(s.min[1]) && Number.isFinite(s.max[0]) && Number.isFinite(s.max[1]);
 function cellOf(v, origin, size, n) {
   const c = Math.floor((v - origin) / size);
   if (c < 0) return 0;
   return c > n - 1 ? n - 1 : c;
 }
-function gridOf(solids) {
-  const placed2 = solids.filter(placeable);
-  if (placed2.length < GRID_MIN_SOLIDS) return null;
+function gridOf(world) {
+  const { count, bounds } = world;
+  let placed2 = 0;
   let x0 = Number.POSITIVE_INFINITY;
   let y0 = Number.POSITIVE_INFINITY;
   let x1 = Number.NEGATIVE_INFINITY;
   let y1 = Number.NEGATIVE_INFINITY;
-  for (const s of placed2) {
-    x0 = Math.min(x0, s.min[0] - CAST_MARGIN);
-    y0 = Math.min(y0, s.min[1] - CAST_MARGIN);
-    x1 = Math.max(x1, s.max[0] + CAST_MARGIN);
-    y1 = Math.max(y1, s.max[1] + CAST_MARGIN);
-  }
+  for (let k = 0; k < count; k++) {
+    if (!placeable(bounds, k)) continue;
+    placed2 += 1;
+    const o = k * BOUNDS_STRIDE;
+    x0 = Math.min(x0, bounds[o] - CAST_MARGIN);
+    y0 = Math.min(y0, bounds[o + 1] - CAST_MARGIN);
+    x1 = Math.max(x1, bounds[o + 3] + CAST_MARGIN);
+    y1 = Math.max(y1, bounds[o + 4] + CAST_MARGIN);
+  }
+  if (placed2 < GRID_MIN_SOLIDS) return null;
   const size = Math.max(GRID_CELL_MIN, (x1 - x0) / GRID_SIDE, (y1 - y0) / GRID_SIDE);
+  if (!Number.isFinite(size)) return null;
   const nx = Math.min(GRID_SIDE, Math.floor((x1 - x0) / size) + 1);
   const ny = Math.min(GRID_SIDE, Math.floor((y1 - y0) / size) + 1);
-  const cells = Array.from({ length: nx * ny }, () => []);
-  const wide = [];
-  solids.forEach((s, k) => {
-    if (!placeable(s)) {
-      wide.push(k);
-      return;
+  const visit = (onWide, onCell) => {
+    for (let k = 0; k < count; k++) {
+      if (!placeable(bounds, k)) {
+        onWide(k);
+        continue;
+      }
+      const o = k * BOUNDS_STRIDE;
+      const i0 = cellOf(bounds[o] - CAST_MARGIN, x0, size, nx);
+      const i1 = cellOf(bounds[o + 3] + CAST_MARGIN, x0, size, nx);
+      const j0 = cellOf(bounds[o + 1] - CAST_MARGIN, y0, size, ny);
+      const j1 = cellOf(bounds[o + 4] + CAST_MARGIN, y0, size, ny);
+      if ((i1 - i0 + 1) * (j1 - j0 + 1) > GRID_WIDE) {
+        onWide(k);
+        continue;
+      }
+      for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) onCell(i + j * nx, k);
     }
-    const i0 = cellOf(s.min[0] - CAST_MARGIN, x0, size, nx);
-    const i1 = cellOf(s.max[0] + CAST_MARGIN, x0, size, nx);
-    const j0 = cellOf(s.min[1] - CAST_MARGIN, y0, size, ny);
-    const j1 = cellOf(s.max[1] + CAST_MARGIN, y0, size, ny);
-    if ((i1 - i0 + 1) * (j1 - j0 + 1) > GRID_WIDE) {
-      wide.push(k);
-      return;
+  };
+  const cellStart = new Int32Array(nx * ny + 1);
+  let wideCount = 0;
+  visit(
+    () => {
+      wideCount += 1;
+    },
+    (c) => {
+      cellStart[c + 1] += 1;
     }
-    for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) cells[i + j * nx].push(k);
-  });
-  return { x0, y0, size, nx, ny, cells, wide };
+  );
+  for (let c = 0; c < nx * ny; c++) cellStart[c + 1] = cellStart[c + 1] + cellStart[c];
+  const cellSolids = new Int32Array(cellStart[nx * ny]);
+  const wide = new Int32Array(wideCount);
+  const written = cellStart.slice();
+  let wideAt = 0;
+  visit(
+    (k) => {
+      wide[wideAt] = k;
+      wideAt += 1;
+    },
+    (c, k) => {
+      cellSolids[written[c]] = k;
+      written[c] = written[c] + 1;
+    }
+  );
+  return { x0, y0, size, nx, ny, cellStart, cellSolids, wide, merged: new Array(wideAt <= GRID_MERGED_WIDE ? nx * ny : 0) };
 }
-function mergeAscending(a, b) {
-  if (b.length === 0) return a;
+function mergeAscending(a, b, from, to) {
+  if (to === from) return a;
   const out = [];
   let i = 0;
-  let k = 0;
-  while (i < a.length || k < b.length) {
-    const fromA = k >= b.length || i < a.length && a[i] <= b[k];
+  let k = from;
+  while (i < a.length || k < to) {
+    const fromA = k >= to || i < a.length && a[i] <= b[k];
     const next = fromA ? a[i] : b[k];
     if (fromA) i += 1;
     else k += 1;
@@ -379,50 +632,100 @@ function solidsNear(world, lx, hx, ly, hy) {
   const g = world.grid;
   if (g === void 0 || !(Number.isFinite(lx) && Number.isFinite(hx) && Number.isFinite(ly) && Number.isFinite(hy))) return null;
   const i0 = cellOf(lx, g.x0, g.size, g.nx);
-  const i1 = cellOf(hx, g.x0, g.size, g.nx);
+  const i1 = hx === lx ? i0 : cellOf(hx, g.x0, g.size, g.nx);
   const j0 = cellOf(ly, g.y0, g.size, g.ny);
-  const j1 = cellOf(hy, g.y0, g.size, g.ny);
+  const j1 = hy === ly ? j0 : cellOf(hy, g.y0, g.size, g.ny);
   if ((i1 - i0 + 1) * (j1 - j0 + 1) > GRID_QUERY_CELLS) return null;
+  if (i0 === i1 && j0 === j1 && g.merged.length > 0) {
+    const c = i0 + j0 * g.nx;
+    const kept = g.merged[c];
+    if (kept !== void 0) return kept;
+    const made = mergeAscending(g.wide, g.cellSolids, g.cellStart[c], g.cellStart[c + 1]);
+    g.merged[c] = made;
+    return made;
+  }
   let near2 = g.wide;
-  for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) near2 = mergeAscending(near2, g.cells[i + j * g.nx]);
+  for (let j = j0; j <= j1; j++) {
+    for (let i = i0; i <= i1; i++) {
+      const c = i + j * g.nx;
+      near2 = mergeAscending(near2, g.cellSolids, g.cellStart[c], g.cellStart[c + 1]);
+    }
+  }
   return near2;
 }
-function insidePlanes(planes, skin, x, y, z) {
-  for (const [nx, ny, nz, e] of planes) if (!(e - (nx * x + ny * y + nz * z) > skin)) return false;
+var P = { nx: 0, ny: 0, nz: 0, e: 0 };
+function readPlane(world, i, k) {
+  if (i < world.boxCount) {
+    const n = BOX_NORMALS[k];
+    const at2 = BOX_OFFSETS[k];
+    const v = world.bounds[i * BOUNDS_STRIDE + at2];
+    P.nx = n[0];
+    P.ny = n[1];
+    P.nz = n[2];
+    P.e = at2 < 3 ? -v : v;
+    return;
+  }
+  const o = (i - world.boxCount) * RAMP_STRIDE + k * PLANE_STRIDE;
+  const r = world.rampPlanes;
+  P.nx = r[o];
+  P.ny = r[o + 1];
+  P.nz = r[o + 2];
+  P.e = r[o + 3];
+}
+var planesOf = (world, i) => i < world.boxCount ? BOX_PLANES : RAMP_PLANES;
+function insideSolid(world, i, skin, x, y, z) {
+  const n = planesOf(world, i);
+  for (let k = 0; k < n; k++) {
+    readPlane(world, i, k);
+    if (!(P.e - (P.nx * x + P.ny * y + P.nz * z) > skin)) return false;
+  }
   return true;
 }
+var solidsAt = (world, x, y) => solidsNear(world, x, x, y, y);
 function insideWorld(world, x, y, z) {
-  for (const s of world.solids) if (insidePlanes(s.planes, world.skin, x, y, z)) return true;
+  const near2 = solidsAt(world, x, y);
+  const n = near2 === null ? world.count : near2.length;
+  for (let m = 0; m < n; m++) {
+    if (insideSolid(world, near2 === null ? m : near2[m], world.skin, x, y, z)) return true;
+  }
   return false;
 }
-function segmentNear(s, p, d, len) {
+function segmentNear(world, s, p, d, len) {
+  const o = s * BOUNDS_STRIDE;
   for (let i = 0; i < 3; i++) {
     const a = p[i];
     const b = a + d[i] * len;
     const lo = a < b ? a : b;
     const hi = a < b ? b : a;
-    if (hi < s.min[i] - CAST_MARGIN || lo > s.max[i] + CAST_MARGIN) return false;
+    if (hi < world.bounds[o + i] - CAST_MARGIN || lo > world.bounds[o + 3 + i] + CAST_MARGIN) return false;
   }
   return true;
 }
-function bandHit(s, skin, p, d, rides) {
-  for (const plane of s.planes) {
-    const [nx, ny, nz, e] = plane;
+function bandHit(world, s, skin, p, d, rides) {
+  const n = planesOf(world, s);
+  for (let k = 0; k < n; k++) {
+    readPlane(world, s, k);
+    const { nx, ny, nz, e } = P;
     const margin = e - (nx * p[0] + ny * p[1] + nz * p[2]);
-    if (margin <= skin && nx * d[0] + ny * d[1] + nz * d[2] < 0 && !rides?.(plane)) return { t: 0, face: plane };
+    if (margin <= skin && nx * d[0] + ny * d[1] + nz * d[2] < 0) {
+      const plane = [nx, ny, nz, e];
+      if (!rides?.(plane)) return { t: 0, face: plane };
+    }
   }
   return null;
 }
 var ridesOn = (up, cos) => (face) => face[2] >= cos && face[0] * up[0] + face[1] * up[1] + face[2] * up[2] >= cos;
-function enterSolid(s, skin, p, d, len, rides) {
-  if (insidePlanes(s.planes, skin, p[0], p[1], p[2])) return null;
-  if (insidePlanes(s.planes, -skin, p[0], p[1], p[2])) return bandHit(s, skin, p, d, rides);
+function enterSolid(world, s, skin, p, d, len, rides) {
+  if (insideSolid(world, s, skin, p[0], p[1], p[2])) return null;
+  if (insideSolid(world, s, -skin, p[0], p[1], p[2])) return bandHit(world, s, skin, p, d, rides);
   let lo = 0;
   let hi = len;
   let last = Number.NEGATIVE_INFINITY;
-  let face = null;
-  for (const plane of s.planes) {
-    const [nx, ny, nz, e] = plane;
+  let face = -1;
+  const n = planesOf(world, s);
+  for (let k = 0; k < n; k++) {
+    readPlane(world, s, k);
+    const { nx, ny, nz, e } = P;
     const s0 = e + skin - (nx * p[0] + ny * p[1] + nz * p[2]);
     const sd = nx * d[0] + ny * d[1] + nz * d[2];
     if (sd === 0) {
@@ -433,26 +736,29 @@ function enterSolid(s, skin, p, d, len, rides) {
     if (sd > 0 && t2 < hi) hi = t2;
     if (sd < 0 && t2 > last) {
       last = t2;
-      face = plane;
+      face = k;
     }
   }
   if (last > lo) lo = last;
-  if (face === null || !(lo < hi) || rides?.(face)) return null;
-  return { t: lo, face };
+  if (face < 0 || !(lo < hi)) return null;
+  readPlane(world, s, face);
+  const plane = [P.nx, P.ny, P.nz, P.e];
+  if (rides?.(plane)) return null;
+  return { t: lo, face: plane };
 }
 function castWorld(world, p, d, len, rides) {
   let best = { t: len, face: null };
   if (!(len > 0)) return { t: 0, face: null };
   const visit = (s) => {
-    if (!segmentNear(s, p, d, best.t)) return;
-    const hit = enterSolid(s, world.skin, p, d, best.t, rides);
+    if (!segmentNear(world, s, p, d, best.t)) return;
+    const hit = enterSolid(world, s, world.skin, p, d, best.t, rides);
     if (hit !== null && hit.t < best.t) best = hit;
   };
   const [px, py] = [p[0], p[1]];
   const [ex, ey] = [px + d[0] * len, py + d[1] * len];
   const near2 = solidsNear(world, Math.min(px, ex), Math.max(px, ex), Math.min(py, ey), Math.max(py, ey));
-  if (near2 === null) for (const s of world.solids) visit(s);
-  else for (const k of near2) visit(world.solids[k]);
+  if (near2 === null) for (let s = 0; s < world.count; s++) visit(s);
+  else for (let k = 0; k < near2.length; k++) visit(near2[k]);
   return best;
 }
 function roomAlong(world, p, d, len, rides) {
@@ -469,18 +775,22 @@ function surfaceUp(world, x, y, z, trace) {
   return [hit.face[0], hit.face[1], hit.face[2]];
 }
 function covered(world, self, x, y, z, q) {
-  const { solids, skin } = world;
-  for (let j = 0; j < solids.length; j++) {
+  const { count, skin } = world;
+  const near2 = solidsAt(world, q[0], q[1]);
+  const n = near2 === null ? count : near2.length;
+  for (let m = 0; m < n; m++) {
+    const j = near2 === null ? m : near2[m];
     if (j === self) continue;
-    const planes = solids[j].planes;
-    if (insidePlanes(planes, skin, q[0], q[1], q[2]) && !insidePlanes(planes, skin, x, y, z)) return true;
+    if (insideSolid(world, j, skin, q[0], q[1], q[2]) && !insideSolid(world, j, skin, x, y, z)) return true;
   }
   return false;
 }
-function leastFace(world, i, planes, x, y, z) {
+function leastFace(world, i, x, y, z) {
   let least = null;
-  for (let k = 0; k < planes.length - 1; k++) {
-    const [nx, ny, nz, e] = planes[k];
+  const n = planesOf(world, i);
+  for (let k = 0; k < n - 1; k++) {
+    readPlane(world, i, k);
+    const { nx, ny, nz, e } = P;
     const depth = e - (nx * x + ny * y + nz * z);
     if (least !== null && !(depth < least[3])) continue;
     if (nz > 0 && covered(world, i, x, y, z, [x + nx * depth, y + ny * depth, z + nz * depth])) continue;
@@ -489,10 +799,12 @@ function leastFace(world, i, planes, x, y, z) {
   return least;
 }
 function insideFace(world, x, y, z) {
-  const { solids, skin } = world;
-  for (let i = 0; i < solids.length; i++) {
-    const planes = solids[i].planes;
-    if (insidePlanes(planes, skin, x, y, z)) return leastFace(world, i, planes, x, y, z);
+  const { count, skin } = world;
+  const near2 = solidsAt(world, x, y);
+  const n = near2 === null ? count : near2.length;
+  for (let m = 0; m < n; m++) {
+    const i = near2 === null ? m : near2[m];
+    if (insideSolid(world, i, skin, x, y, z)) return leastFace(world, i, x, y, z);
   }
   return null;
 }
@@ -528,7 +840,13 @@ var cross = (p, q) => [p[1] * q[2] - p[2] * q[1], p[2] * q[0] - p[0] * q[2], p[0
 var neg = (p) => [-p[0], -p[1], -p[2]];
 function supportOf(b, policy, env) {
   if (env.supportUp !== void 0) return env.supportUp(b.x, b.y, b.z);
-  return surfaceUp(env.world, b.x, b.y, b.z, policy.groundTrace);
+  const memo = env.supports;
+  if (memo === void 0) return surfaceUp(env.world, b.x, b.y, b.z, policy.groundTrace);
+  const known = memo.get(b);
+  if (known !== void 0 && known.x === b.x && known.y === b.y && known.z === b.z) return known.up;
+  const up = surfaceUp(env.world, b.x, b.y, b.z, policy.groundTrace);
+  memo.set(b, { x: b.x, y: b.y, z: b.z, up });
+  return up;
 }
 function frameOf(b, policy, env) {
   const shape = policy.shape;
@@ -981,7 +1299,9 @@ function contactPair(a, b, policy, env, cooling = false, others = []) {
   const fa = frameOf(a, policy, env);
   const fb = frameOf(b, policy, env);
   const found = contactOfFrames(fa, fb, policy);
-  if (found === null) return null;
+  return found === null ? null : stepFound(fa, fb, found, rule, policy, env, cooling, others);
+}
+function stepFound(fa, fb, found, rule, policy, env, cooling, others) {
   const { contact, g } = found;
   if (contact.kind === ContactKind.Side) return { ...contact, ...sideContact(fa, fb, contact, g, policy, env, cooling), way: null, w: null };
   return { ...contact, ...topContact(fa, fb, contact, g, rule, policy, env, others) };
@@ -992,15 +1312,38 @@ function pairOfPass(a, b, pass, policy, env, options, seats) {
   return own === void 0 ? contactPair(a, b, policy, env, cooling, seats) : own;
 }
 var stillTouching = (c, policy) => c !== null && (c.depth > policy.slop || c.kind === ContactKind.Top && c.depth > 0);
-function passOnce(seats, pass, policy, env, options, report) {
+var memoryOf = (count) => ({ moves: new Int32Array(count), still: new Int32Array(count * count).fill(-1) });
+function stepIfTouching(a, b, policy, env, seats) {
+  if (farApart(a, b, policy)) return null;
+  const rule = topRuleOf(policy, a, b);
+  if (rule.policy === TopPolicy.Ghost) return null;
+  const fa = frameOf(a, policy, env);
+  const fb = frameOf(b, policy, env);
+  const found = contactOfFrames(fa, fb, policy);
+  if (found === null || !stillTouching(found.contact, policy)) return null;
+  return stepFound(fa, fb, found, rule, policy, env, false, seats);
+}
+function passOnce(seats, pass, policy, env, options, report, memory) {
   let touched = false;
-  for (let i = 0; i < seats.length; i++) {
-    for (let k = i + 1; k < seats.length; k++) {
+  const count = seats.length;
+  for (let i = 0; i < count; i++) {
+    for (let k = i + 1; k < count; k++) {
       const a = seats[i];
       const b = seats[k];
-      if (pass > 0 && !stillTouching(contactOf(a, b, policy, env), policy)) continue;
-      const out = pairOfPass(a, b, pass, policy, env, options, seats);
-      if (out === null) continue;
+      const at2 = i * count + k;
+      if (memory !== null && pass > 0 && memory.still[at2] === memory.moves[i] + memory.moves[k]) continue;
+      let out;
+      if (memory !== null && pass > 0) out = stepIfTouching(a, b, policy, env, seats);
+      else if (pass > 0 && !stillTouching(contactOf(a, b, policy, env), policy)) continue;
+      else out = pairOfPass(a, b, pass, policy, env, options, seats);
+      if (out === null) {
+        if (memory !== null) memory.still[at2] = memory.moves[i] + memory.moves[k];
+        continue;
+      }
+      if (memory !== null) {
+        memory.moves[i] = memory.moves[i] + 1;
+        memory.moves[k] = memory.moves[k] + 1;
+      }
       touched = true;
       if (out.way === SlideWay.Pinned) report.pinned += 1;
       options.onPair?.(a, b, out);
@@ -1010,17 +1353,20 @@ function passOnce(seats, pass, policy, env, options, report) {
 }
 function contactPass(seats, policy, env, options = {}) {
   const report = { passes: 0, pushed: /* @__PURE__ */ new Map(), walls: /* @__PURE__ */ new Map(), pinned: 0 };
+  env = { ...env, supports: /* @__PURE__ */ new Map() };
+  const memory = options.first === void 0 && options.onPair === void 0 && options.cooling === void 0 ? memoryOf(seats.length) : null;
   for (let pass = 0; pass < policy.passes; pass++) {
-    if (!passOnce(seats, pass, policy, env, options, report)) break;
+    if (!passOnce(seats, pass, policy, env, options, report, memory)) break;
     report.passes += 1;
     if (env.world === null) continue;
-    for (const seat of seats) {
+    seats.forEach((seat, s) => {
       const wall = (face) => {
         if (face[2] < policy.supportCos && face[3] > (report.walls.get(seat.id) ?? 0)) report.walls.set(seat.id, face[3]);
       };
       const depth = unstickBody(env.world, seat, wall);
       if (depth > (report.pushed.get(seat.id) ?? 0)) report.pushed.set(seat.id, depth);
-    }
+      if (memory !== null && depth > 0) memory.moves[s] = memory.moves[s] + 1;
+    });
   }
   return report;
 }
@@ -4110,7 +4456,10 @@ var roomStateFields = {
   joints: t.map(AuthorityJoint).optional(),
   // Lift rooms (PROTOCOL.md §17.11 *Lifts*): every called lift's start tick, JSON text `{"id":tick,…}`
   // (ids ascending), written when a module's ctx.lifts.call is taken. Absent = none called.
-  lifts: t.string().optional()
+  lifts: t.string().optional(),
+  // The room's match key (PROTOCOL.md §17.2 *Choosing a room*): how a friend who joined by code learns
+  // which world to hand `setWorld`. Absent = no key, and never written.
+  matchKey: t.string().optional()
 };
 var AuthorityRoomState = schema(roomStateFields, "AuthorityRoomState");
 var AuthorityPhysicsRoomState = schema({ ...roomStateFields, entities: t.map(AuthorityPhysicsEntity).view() }, "AuthorityRoomState");
@@ -4250,380 +4599,72 @@ function throttleSteps(t2, dtMs, stepMs) {
   return steps;
 }
 
-// src/authority/fast-records.ts
-var MotionRecordKind = { Entity: 1, Seat: 2 };
-var FieldWire = {
-  F32: "f32",
-  U32: "u32",
-  U16: "u16",
-  /** A quantized orientation component in [−1, 1], uint16. */
-  Orientation: "q-orientation",
-  /** A quantized velocity in [−64, 64], uint16. */
-  Velocity: "q-velocity",
-  /** A boolean: the mask bit alone. */
-  Flag: "flag"
+// src/authority/fast-line.ts
+var FastTransport = { Udp: "udp", WebSocket: "websocket" };
+var FastNotAsked = {
+  /** The game turned it off (`fast: false`, `bFastChannel = false`, ...). */
+  Off: "off",
+  /** This runtime has no UDP socket (WebGL, a browser with no opener). */
+  NoUdp: "no_udp",
+  /** The seat asked and the room sent no binding. */
+  NotOffered: "not_offered"
 };
-var ENTITY_FIELDS = [
-  ["x", FieldWire.F32],
-  ["y", FieldWire.F32],
-  ["z", FieldWire.F32],
-  ["vx", FieldWire.F32],
-  ["vy", FieldWire.F32],
-  ["vz", FieldWire.F32],
-  ["yaw", FieldWire.F32],
-  ["pitch", FieldWire.F32],
-  ["duck", FieldWire.F32],
-  ["spin", FieldWire.F32],
-  ["fuel", FieldWire.F32],
-  ["epoch", FieldWire.U32],
-  ["mstate", FieldWire.U32],
-  ["qx", FieldWire.Orientation],
-  ["qy", FieldWire.Orientation],
-  ["qz", FieldWire.Orientation],
-  ["qw", FieldWire.Orientation],
-  ["lvx", FieldWire.Velocity],
-  ["lvy", FieldWire.Velocity],
-  ["lvz", FieldWire.Velocity],
-  ["avx", FieldWire.Velocity],
-  ["avy", FieldWire.Velocity],
-  ["avz", FieldWire.Velocity],
-  ["sleep", FieldWire.Flag],
-  ["rest", FieldWire.U16]
-];
-var SEAT_FIELDS = [
-  ["inMoveX", FieldWire.F32],
-  ["inMoveY", FieldWire.F32],
-  ["inMoveZ", FieldWire.F32],
-  ["inYaw", FieldWire.F32],
-  ["inPitch", FieldWire.F32],
-  ["inButtons", FieldWire.U32],
-  ["inRep", FieldWire.U32],
-  ["inStarve", FieldWire.U32],
-  ["inBuf", FieldWire.U32],
-  ["inAck", FieldWire.U32]
-];
-var RECORD_ID_MAX_CHARS = 64;
-var HEAD = 2;
-var MASK_BYTES = 4;
-var UINT32_MAX = 4294967295;
-var UINT16_MAX = 65535;
-var Q_SPAN = 65534;
-var Q_ZERO = Q_SPAN / 2;
-var Q_RANGE = { [FieldWire.Orientation]: 1, [FieldWire.Velocity]: 64 };
-var blankEntityMotion = () => ({
-  x: 0,
-  y: 0,
-  z: 0,
-  vx: 0,
-  vy: 0,
-  vz: 0,
-  yaw: 0,
-  pitch: 0,
-  duck: 0,
-  spin: 0,
-  fuel: 0,
-  epoch: 0,
-  mstate: 0,
-  qx: 0,
-  qy: 0,
-  qz: 0,
-  qw: 0,
-  lvx: 0,
-  lvy: 0,
-  lvz: 0,
-  avx: 0,
-  avy: 0,
-  avz: 0,
-  sleep: false,
-  rest: 0
-});
-var blankSeatEcho = () => ({ inMoveX: 0, inMoveY: 0, inMoveZ: 0, inYaw: 0, inPitch: 0, inButtons: 0, inRep: 0, inStarve: 0, inBuf: 0, inAck: 0 });
-function quantizeCode(half, value) {
-  const v = Math.min(half, Math.max(-half, value));
-  return Math.floor((v + half) / (2 * half) * Q_SPAN + 0.5);
-}
-var dequantizeCode = (half, code) => -half + code / Q_SPAN * (2 * half);
-var fieldsOf = (kind) => {
-  if (kind === MotionRecordKind.Entity) return ENTITY_FIELDS;
-  if (kind === MotionRecordKind.Seat) return SEAT_FIELDS;
-  return null;
+var FAST_OFFER_WAIT_MS = FAST_HANDSHAKE_MS;
+var WHY = {
+  [FastNotAsked.Off]: "the game turned the fast channel off",
+  [FastNotAsked.NoUdp]: "this platform has no UDP",
+  [FastNotAsked.NotOffered]: "the room does not offer the fast channel",
+  unreachable: "fell back, the binding could not be used or its socket failed",
+  handshake: "fell back, no UDP snapshot within 1 s of the first datagram (UDP blocked?)",
+  stall: "fell back, no UDP snapshot for 2 s",
+  server: "fell back, the room closed the channel",
+  "no-webtransport": "this browser has no WebTransport",
+  "no-relay": "the room has no WebTransport relay"
 };
-var isUint = (v, max) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= max;
-function wireValue(wire, v) {
-  switch (wire) {
-    case FieldWire.F32: {
-      if (typeof v !== "number" || !Number.isFinite(Math.fround(v))) return null;
-      return Math.fround(v) === 0 ? void 0 : Math.fround(v);
-    }
-    case FieldWire.U32:
-      if (!isUint(v, UINT32_MAX)) return null;
-      return v === 0 ? void 0 : v;
-    case FieldWire.U16:
-      if (!isUint(v, UINT16_MAX)) return null;
-      return v === 0 ? void 0 : v;
-    case FieldWire.Flag:
-      if (typeof v !== "boolean") return null;
-      return v ? 1 : void 0;
-    default: {
-      if (typeof v !== "number" || Number.isNaN(v)) return null;
-      const code = quantizeCode(Q_RANGE[wire], v);
-      return code === Q_ZERO ? void 0 : code;
-    }
-  }
-}
-var WIDTH = { f32: 4, u32: 4, u16: 2, "q-orientation": 2, "q-velocity": 2, flag: 0 };
-function encodeRecord(r) {
-  const fields = fieldsOf(r.kind);
-  const id = typeof r.id === "string" ? new TextEncoder().encode(r.id) : null;
-  const idOk = id !== null && r.id.length >= 1 && r.id.length <= RECORD_ID_MAX_CHARS && id.length <= 255;
-  if (fields === null || !idOk || r.motion === null || typeof r.motion !== "object") return { ok: false, fault: FastFault.Field };
-  const motion = r.motion;
-  const present = [];
-  let mask = 0;
-  for (const [i, [name, wire]] of fields.entries()) {
-    const value = wireValue(wire, motion[name]);
-    if (value === null) return { ok: false, fault: FastFault.Field };
-    if (value === void 0) continue;
-    mask = (mask | 1 << i) >>> 0;
-    present.push([wire, value]);
-  }
-  const out = new Uint8Array(HEAD + id.length + MASK_BYTES + present.reduce((n, [w]) => n + WIDTH[w], 0));
-  const view = new DataView(out.buffer);
-  out[0] = r.kind;
-  out[1] = id.length;
-  out.set(id, HEAD);
-  let at2 = HEAD + id.length;
-  view.setUint32(at2, mask, true);
-  at2 += MASK_BYTES;
-  for (const [wire, value] of present) at2 = writeField(view, at2, wire, value);
-  return { ok: true, value: out };
-}
-function writeField(view, at2, wire, value) {
-  if (wire === FieldWire.F32) view.setFloat32(at2, value, true);
-  else if (wire === FieldWire.U32) view.setUint32(at2, value, true);
-  else if (wire !== FieldWire.Flag) view.setUint16(at2, value, true);
-  return at2 + WIDTH[wire];
-}
-function readField(view, at2, wire) {
-  if (at2 + WIDTH[wire] > view.byteLength) return { ok: false, fault: FastFault.Truncated };
-  switch (wire) {
-    case FieldWire.Flag:
-      return { ok: true, value: true };
-    case FieldWire.F32: {
-      const v = view.getFloat32(at2, true);
-      return Number.isFinite(v) && v !== 0 ? { ok: true, value: v } : { ok: false, fault: FastFault.Field };
-    }
-    case FieldWire.U32: {
-      const v = view.getUint32(at2, true);
-      return v !== 0 ? { ok: true, value: v } : { ok: false, fault: FastFault.Field };
-    }
-    case FieldWire.U16: {
-      const v = view.getUint16(at2, true);
-      return v !== 0 ? { ok: true, value: v } : { ok: false, fault: FastFault.Field };
-    }
-    default: {
-      const code = view.getUint16(at2, true);
-      const canonical = code !== Q_ZERO && code <= Q_SPAN;
-      return canonical ? { ok: true, value: dequantizeCode(Q_RANGE[wire], code) } : { ok: false, fault: FastFault.Field };
-    }
-  }
-}
-var UTF8 = new TextDecoder("utf-8", { fatal: true });
-function readId(bytes) {
-  const len = bytes[1];
-  if (HEAD + len > bytes.length) return { ok: false, fault: FastFault.Truncated };
-  if (len === 0) return { ok: false, fault: FastFault.Field };
-  try {
-    const id = UTF8.decode(bytes.subarray(HEAD, HEAD + len));
-    return id.length <= RECORD_ID_MAX_CHARS ? { ok: true, value: id } : { ok: false, fault: FastFault.Field };
-  } catch {
-    return { ok: false, fault: FastFault.Field };
-  }
-}
-function decodeRecord(bytes) {
-  if (bytes.length < HEAD) return { ok: false, fault: FastFault.Truncated };
-  const fields = fieldsOf(bytes[0]);
-  if (fields === null) return { ok: false, fault: FastFault.Kind };
-  const id = readId(bytes);
-  if (!id.ok) return id;
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let at2 = HEAD + bytes[1];
-  if (at2 + MASK_BYTES > bytes.length) return { ok: false, fault: FastFault.Truncated };
-  const mask = view.getUint32(at2, true);
-  at2 += MASK_BYTES;
-  if (fields.length < 32 && mask >>> fields.length !== 0) return { ok: false, fault: FastFault.Flags };
-  if (bytes[0] === MotionRecordKind.Entity) {
-    const motion2 = readMotion(view, at2, mask, blankEntityMotion(), fields);
-    return motion2.ok ? { ok: true, value: { kind: MotionRecordKind.Entity, id: id.value, motion: motion2.value } } : motion2;
-  }
-  const motion = readMotion(view, at2, mask, blankSeatEcho(), fields);
-  return motion.ok ? { ok: true, value: { kind: MotionRecordKind.Seat, id: id.value, motion: motion.value } } : motion;
-}
-function readMotion(view, start, mask, blank, fields) {
-  const values = {};
-  let at2 = start;
-  for (const [i, [name, wire]] of fields.entries()) {
-    if ((mask & 1 << i) === 0) continue;
-    const v = readField(view, at2, wire);
-    if (!v.ok) return v;
-    values[name] = v.value;
-    at2 += WIDTH[wire];
-  }
-  if (at2 !== view.byteLength) return { ok: false, fault: FastFault.Trailing };
-  return { ok: true, value: Object.assign(blank, values) };
-}
-
-// src/authority/fast-client.ts
-var UINT32_MAX2 = 4294967295;
-var FastFallbackReason = {
-  /** The `__fast` binding was malformed, this client cannot open its url, or its socket failed. */
-  Unreachable: "unreachable",
-  /** No snapshot within {@link FAST_HANDSHAKE_MS} of the first datagram. */
-  Handshake: "handshake",
-  /** No snapshot for {@link FAST_STALL_FALLBACK_MS} after the last one. */
-  Stall: "stall",
-  /** The server asked for it (`__fast:off` from the server). */
-  Server: "server"
-};
-var isUint2 = (v, max) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= max;
-function isFastBind(m) {
-  if (typeof m !== "object" || m === null) return false;
-  const { sid, key, url } = m;
-  const keyOk = typeof key === "string" && key.length === 2 * FAST_KEY_BYTES && /^[0-9a-f]+$/.test(key);
-  return isUint2(sid, UINT32_MAX2) && keyOk && typeof url === "string" && url.length > 0;
-}
-function heldInputs(sent, inputAck, tickHz) {
-  if (sent.length === 0) return [];
-  const newest = sent[sent.length - 1].seq;
-  const keepFrom = Math.min(inputAck, newest - inputRedundancyTicks(tickHz) + 1);
-  const capped = Math.max(keepFrom, newest - seqAheadMax(tickHz) + 1);
-  return sent.filter((s) => s.seq >= capped);
-}
-var recordName = (kind, id) => `${kind}:${id}`;
-function openFastClient(o) {
-  let rx = emptyClientRx();
-  let sent = [];
-  const sentTimes = /* @__PURE__ */ new Map();
-  let fresh = 0;
-  let closed = false;
-  let firstSentAt = null;
-  let lastAppliedAt = null;
-  let decodedByKey = /* @__PURE__ */ new Map();
-  let latest = /* @__PURE__ */ new Map();
-  const inputAck = () => rx.history.at(-1)?.inputAck ?? 0;
-  const decodeChanged = (records) => {
-    const nextByKey = /* @__PURE__ */ new Map();
-    const nextLatest = /* @__PURE__ */ new Map();
-    const changed = [];
-    for (const r of records) {
-      const before = decodedByKey.get(r.key);
-      const same = before !== void 0 && (before.bytes === r.bytes || sameBytes(before.bytes, r.bytes));
-      const record = same ? before.record : decodeOrNull(r.bytes);
-      nextByKey.set(r.key, { bytes: r.bytes, record });
-      if (record === null) continue;
-      nextLatest.set(recordName(record.kind, record.id), record);
-      if (!same) changed.push(record);
-    }
-    decodedByKey = nextByKey;
-    latest = nextLatest;
-    return changed;
-  };
-  function receive(bytes) {
-    if (closed) return { applied: null };
-    const r = receiveFragment(rx, bytes, o.bind.sid);
-    rx = r.rx;
-    if (r.fault !== void 0 || r.applied === null) return { applied: null, fault: r.fault };
-    const held = rx.history.at(-1);
-    if (held === void 0) return { applied: null };
-    lastAppliedAt = o.now();
-    sent = heldInputs(sent, held.inputAck, o.tickHz);
-    const applied = { snap: held.snap, tick: held.tick, inputAck: held.inputAck, sent: held.sent, changed: decodeChanged(held.records) };
-    o.onSnapshot?.(applied);
-    return { applied };
-  }
-  const socket = o.open(
-    o.bind.url,
-    (bytes) => {
-      receive(bytes);
-    },
-    o.bind
-  );
-  if (socket === null) return null;
-  const largestUplink = uplinkMaxBytes(o.tickHz);
+var udpLine = (url) => `genex transport: udp fast@1 ${url}`;
+var webSocketLine = (reason) => `genex transport: websocket, ${reason}: ${WHY[reason] ?? "unknown"}`;
+function fastLineAnnouncer() {
+  const said = /* @__PURE__ */ new Set();
+  const once = (line) => {
+    if (said.has(line)) return null;
+    said.add(line);
+    return line;
+  };
   return {
-    bind: o.bind,
-    get rx() {
-      return rx;
-    },
-    get lastQueued() {
-      return sent.at(-1)?.seq ?? 0;
-    },
-    get closed() {
-      return closed;
+    observe(o) {
+      if (o.joinedMs === null) return null;
+      if (!o.asked) return once(webSocketLine(FastNotAsked.Off));
+      if (!o.udp) return once(webSocketLine(FastNotAsked.NoUdp));
+      if (o.fallback !== null) return once(webSocketLine(o.fallback));
+      if (o.url !== null) return o.snapshots > 0 ? once(udpLine(o.url)) : null;
+      return o.joinedMs >= FAST_OFFER_WAIT_MS ? once(webSocketLine(FastNotAsked.NotOffered)) : null;
     },
-    queue(input) {
-      if (closed) return;
-      sent.push({ seq: input.seq, tick: input.tick, render: input.render, input: { ...input.input } });
-      fresh += 1;
-    },
-    flush() {
-      if (closed || fresh === 0) return;
-      const now = o.now();
-      for (const s of sent.slice(-fresh)) sentTimes.set(s.seq, now);
-      forgetSendTimes(sentTimes, (sent.at(-1)?.seq ?? 0) - seqAheadMax(o.tickHz) + 1);
-      const window = inputRedundancyTicks(o.tickHz);
-      let from = sent.length - fresh;
-      fresh = 0;
-      while (from < sent.length) {
-        const to = Math.min(from + window, sent.length);
-        const u = uplinkFor(sent.slice(0, to), { sid: o.bind.sid, key: o.bind.key, ackSnap: rx.newest, inputAck: inputAck(), fresh: to - from, tickHz: o.tickHz });
-        from = to;
-        const bytes = encodeUplink(u);
-        if (!bytes.ok) continue;
-        firstSentAt ??= now;
-        socket.send(bytes.value);
-      }
-    },
-    inputAt: (seq) => sent.find((s) => s.seq === seq),
-    sentAt: (seq) => sentTimes.get(seq),
-    motionOf: (kind, id) => latest.get(recordName(kind, id)),
-    due() {
-      if (closed) return null;
-      if (socket.failed?.() === true) return FastFallbackReason.Unreachable;
-      const room = socket.maxDatagramBytes?.();
-      if (room !== void 0 && room < largestUplink) return FastFallbackReason.Unreachable;
-      const now = o.now();
-      if (lastAppliedAt !== null) return now - lastAppliedAt > FAST_STALL_FALLBACK_MS ? FastFallbackReason.Stall : null;
-      return firstSentAt !== null && now - firstSentAt > FAST_HANDSHAKE_MS ? FastFallbackReason.Handshake : null;
-    },
-    receive,
-    close() {
-      if (closed) return;
-      closed = true;
-      socket.close();
+    reset() {
+      said.clear();
     }
   };
 }
-function forgetSendTimes(times, from) {
-  for (const seq of times.keys()) {
-    if (seq >= from) return;
-    times.delete(seq);
-  }
-}
-function decodeOrNull(bytes) {
-  const d = decodeRecord(bytes);
-  return d.ok ? d.value : null;
-}
-var sameBytes = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
 
 // src/authority/fast-session.ts
 import { $refId, OPERATION } from "@colyseus/schema";
 var ROOM_INPUT_RELIABLE = 19;
+var RETRY_AFTER_SERVER_OFF = 3;
 var PROTOCOL_CODE_MASK = 31;
 var ENTITY_MOTION_FIELDS = Object.keys(blankEntityMotion());
 var SEAT_MOTION_FIELDS = Object.keys(blankSeatEcho()).filter((f) => f !== "inAck");
 var motionFieldsOf = (kind) => kind === MotionRecordKind.Entity ? ENTITY_MOTION_FIELDS : SEAT_MOTION_FIELDS;
 var ROOT_TICK_FIELDS = ["tick", "keyframe"];
+function defaultFastLog(line) {
+  const stderr = globalThis.process?.stderr;
+  if (stderr?.write !== void 0) stderr.write(`${line}
+`);
+  else console.info(line);
+}
+var defaultEvery = (ms, fn) => {
+  const timer = setInterval(fn, ms);
+  timer.unref?.();
+  return () => clearInterval(timer);
+};
 function baselinesOf(handle) {
   if (typeof handle !== "object" || handle === null) return null;
   const h = handle;
@@ -4642,13 +4683,30 @@ function renderStampOf(handle) {
 }
 function fastSeat(o) {
   const { room, handle } = o;
-  const status = { live: false, snapshots: 0, fallback: null };
+  const status = { live: false, snapshots: 0, fallback: o.neverAsked, fallbacks: 0, returns: 0, transport: FastTransport.WebSocket, line: null };
+  let returnsSaid = 0;
+  const announcer = fastLineAnnouncer();
+  let joinedAt = null;
+  let boundUrl = null;
+  let snapshotsBefore = 0;
   let link = null;
   let fallback = null;
   let fastAck = 0;
   let early = [];
   let pendingBind = null;
+  let offerAwaitedFrom = null;
+  let roundTripMs = 0;
   const guard = o.open === void 0 ? null : motionGuard(room, () => link?.client ?? null);
+  const stopTimer = o.open === void 0 ? null : (o.every ?? defaultEvery)(FAST_KEEPALIVE_BIND_MS, () => {
+    link?.client.keepalive();
+    probe?.client.keepalive();
+  });
+  const random = o.random ?? Math.random;
+  let probe = null;
+  let hostReturns = false;
+  let attempt = 0;
+  let retryAt = null;
+  let liveSince = null;
   const baselines = baselinesOf(handle);
   const renderStamp = renderStampOf(handle);
   const ack = () => {
@@ -4658,8 +4716,17 @@ function fastSeat(o) {
     return ws > 0 ? Math.max(fallback.ack, fallback.at + ws) : fallback.ack;
   };
   const seqBase = () => room.state.players?.get(room.sessionId)?.seqBase ?? 0;
+  const scheduleRetry = () => {
+    if (!hostReturns || o.open === void 0) return;
+    retryAt = o.now() + fastRetryDelayMs(attempt, random());
+    attempt += 1;
+  };
   const fallBack = (reason) => {
     if (fallback !== null) return;
+    if (liveSince !== null && o.now() - liveSince >= FAST_RETURN_STABLE_MS) attempt = 0;
+    if (reason === FastFallbackReason.Server) attempt = Math.max(attempt, RETRY_AFTER_SERVER_OFF);
+    liveSince = null;
+    status.fallbacks += 1;
     const live = link;
     const base = link?.seqBase ?? seqBase();
     fallback = { at: handle.sentCount, wsBefore: link?.wsBefore ?? handle.sentCount, ack: ack(), reason };
@@ -4675,6 +4742,81 @@ function fastSeat(o) {
     const off = { last: base + handle.sentCount };
     room.send(FastMessage.Off, off);
     guard?.release();
+    scheduleRetry();
+  };
+  const offChannel = (reason) => {
+    if (status.fallback === null) status.fallbacks += 1;
+    status.fallback = reason;
+  };
+  const abandonProbe = (reason) => {
+    if (probe === null) return;
+    probe.client.close();
+    probe = null;
+    offChannel(reason);
+    const off = { last: seqBase() + handle.sentCount };
+    room.send(FastMessage.Off, off);
+    scheduleRetry();
+  };
+  const swapToProbe = (s) => {
+    const p = probe;
+    if (p === null || fallback === null) return;
+    probe = null;
+    const base = seqBase();
+    const wsBefore = fallback.wsBefore + (handle.sentCount - fallback.at);
+    fastAck = ack();
+    link = { client: p.client, seqBase: base, wsBefore, stampAtBind: baselines?._lastStamp ?? 0 };
+    fallback = null;
+    retryAt = null;
+    liveSince = o.now();
+    status.live = true;
+    status.fallback = null;
+    if (status.fallbacks > 0) status.returns += 1;
+    const on = { last: base + handle.sentCount };
+    room.send(FastMessage.On, on);
+    applied({ ...s, changed: p.client.records() });
+  };
+  const askRoundTrip = (client) => {
+    if (!client.opening()) return;
+    room.ping((ms) => {
+      roundTripMs = ms;
+    });
+  };
+  const startProbe = (message) => {
+    if (o.open === void 0) return;
+    attempt = Math.max(0, attempt - 1);
+    hostReturns = true;
+    probe?.client.close();
+    probe = null;
+    if (fallback === null) status.fallback = null;
+    fallback ??= { at: 0, wsBefore: 0, ack: 0, reason: FastFallbackReason.Unreachable };
+    early = [];
+    if (!isFastBind(message)) {
+      offChannel(FastFallbackReason.Unreachable);
+      return scheduleRetry();
+    }
+    boundUrl = message.url;
+    const proof = { client: null, applied: 0 };
+    const client = openFastClient({
+      bind: message,
+      tickHz: o.tickHz(),
+      open: o.open,
+      now: o.now,
+      roundTripMs: () => roundTripMs,
+      onSnapshot: (s) => {
+        if (link !== null && link.client === proof.client) return applied(s);
+        proof.applied += 1;
+        if (proof.applied >= FAST_RETURN_PROOF) swapToProbe(s);
+      }
+    });
+    if (client === null) {
+      offChannel(o.open.whyNull?.(message) ?? FastFallbackReason.Unreachable);
+      return scheduleRetry();
+    }
+    askRoundTrip(client);
+    proof.client = client;
+    probe = proof;
+    retryAt = null;
+    client.keepalive();
   };
   const applied = (s) => {
     const l = link;
@@ -4693,21 +4835,49 @@ function fastSeat(o) {
     guard?.write(s);
   };
   const bind = (message) => {
-    if (o.open === void 0 || link !== null || fallback !== null) return;
+    const asProbe = message?.probe === true;
+    if (o.open === void 0 || link !== null || fallback !== null && !asProbe) return;
     if (!o.stateCurrent()) {
       pendingBind = message;
       return;
     }
     pendingBind = null;
+    if (asProbe) return startProbe(message);
+    status.fallback = null;
     if (!isFastBind(message)) return fallBack(FastFallbackReason.Unreachable);
-    const client = openFastClient({ bind: message, tickHz: o.tickHz(), open: o.open, now: o.now, onSnapshot: applied });
-    if (client === null) return fallBack(FastFallbackReason.Unreachable);
+    boundUrl = message.url;
+    hostReturns = typeof message.rev === "number" && message.rev >= FAST_BIND_REV;
+    const client = openFastClient({ bind: message, tickHz: o.tickHz(), open: o.open, now: o.now, roundTripMs: () => roundTripMs, onSnapshot: applied });
+    if (client === null) return fallBack(o.open.whyNull?.(message) ?? FastFallbackReason.Unreachable);
+    askRoundTrip(client);
     link = { client, seqBase: seqBase(), wsBefore: handle.sentCount, stampAtBind: baselines?._lastStamp ?? 0 };
     fastAck = 0;
     status.live = true;
+    liveSince = o.now();
     for (const s of early) client.queue({ ...s, seq: link.seqBase + s.seq });
     early = [];
     client.flush();
+    client.keepalive();
+  };
+  const noteOffer = () => {
+    const waiting = o.open !== void 0 && link === null && fallback === null && pendingBind === null && o.stateCurrent();
+    if (!waiting) return;
+    offerAwaitedFrom ??= o.now();
+    if (o.now() - offerAwaitedFrom > FAST_HANDSHAKE_MS) status.fallback = FastFallbackReason.NotOffered;
+  };
+  const announce = () => {
+    if (joinedAt === null && o.stateCurrent() && room.state.players?.get(room.sessionId) !== void 0) joinedAt = o.now();
+    const snapshots = status.snapshots - snapshotsBefore;
+    status.transport = status.live && snapshots > 0 ? FastTransport.Udp : FastTransport.WebSocket;
+    if (status.returns !== returnsSaid) {
+      returnsSaid = status.returns;
+      announcer.reset();
+    }
+    const fallback2 = status.fallback === FastFallbackReason.NotOffered ? null : status.fallback;
+    const line = announcer.observe({ asked: !o.off, udp: o.open !== void 0, joinedMs: joinedAt === null ? null : o.now() - joinedAt, url: boundUrl, snapshots, fallback: fallback2 });
+    if (line === null) return;
+    status.line = line;
+    o.log(line);
   };
   if (o.open !== void 0) {
     room.onMessage(FastMessage.Bind, (m) => bind(m));
@@ -4735,8 +4905,20 @@ function fastSeat(o) {
       link?.client.flush();
     },
     poll() {
+      link?.client.framed();
       const reason = link?.client.due() ?? null;
       if (reason !== null) fallBack(reason);
+      link?.client.keepalive();
+      probe?.client.framed();
+      const probeReason = probe?.client.due() ?? null;
+      if (probeReason !== null) abandonProbe(probeReason);
+      probe?.client.keepalive();
+      if (retryAt !== null && o.now() >= retryAt && probe === null && fallback !== null) {
+        room.send(FastMessage.Again, {});
+        scheduleRetry();
+      }
+      noteOffer();
+      announce();
     },
     motionKnown(id) {
       return link === null || link.client.motionOf(MotionRecordKind.Entity, id) !== void 0;
@@ -4749,15 +4931,30 @@ function fastSeat(o) {
     dropped() {
       link?.client.close();
       link = null;
+      probe?.client.close();
+      probe = null;
+      retryAt = null;
+      attempt = 0;
+      liveSince = null;
+      hostReturns = false;
       guard?.forget();
       fallback = null;
       fastAck = 0;
       early = [];
       pendingBind = null;
+      offerAwaitedFrom = null;
       status.live = false;
-      status.fallback = null;
+      status.fallback = o.neverAsked;
+      status.transport = FastTransport.WebSocket;
+      announcer.reset();
+      joinedAt = null;
+      boundUrl = null;
+      snapshotsBefore = status.snapshots;
     },
     dispose() {
+      stopTimer?.();
+      probe?.client.close();
+      probe = null;
       link?.client.close();
       link = null;
       status.live = false;
@@ -4809,7 +5006,7 @@ function motionGuard(room, live) {
     const known = fields.get(field);
     if (known === void 0) fields.set(field, { fast: value, ws: ref[field] ?? BLANK_MOTION[field] });
     else known.fast = value;
-    writeField2(ref, field, value, changes);
+    writeField(ref, field, value, changes);
   };
   const expose = () => {
     learn();
@@ -4886,7 +5083,7 @@ function motionGuard(room, live) {
       const resent = room.state.physics !== void 0;
       for (const [ref, fields] of held) {
         if (!current(ref) || resent && owners.get(ref)?.kind === MotionRecordKind.Entity) continue;
-        for (const [field, f] of fields) writeField2(ref, field, f.ws, changes);
+        for (const [field, f] of fields) writeField(ref, field, f.ws, changes);
       }
       held.clear();
       if (changes.length === 0) return;
@@ -4913,7 +5110,7 @@ function writeRecord(ref, record, write) {
     write(ref, field, value);
   }
 }
-function writeField2(ref, field, value, changes) {
+function writeField(ref, field, value, changes) {
   const previousValue = ref[field];
   if (previousValue === value) return;
   ref[field] = value;
@@ -4924,6 +5121,29 @@ function writeField2(ref, field, value, changes) {
 import { Client, getStateCallbacks } from "@colyseus/sdk";
 import { Predict } from "@colyseus/sdk/predict";
 
+// src/authority/correction.ts
+var VISIBLE_CORRECTION_METRES = 0.05;
+var CORRECTION_BUCKET_METRES = [0.5, 1, 5, 20];
+var PLACE = /* @__PURE__ */ new Set(["x", "y", "z"]);
+var UNCOUNTED = /* @__PURE__ */ new Set(["mstate", "cap", "spin", "fuel"]);
+var TWO_PI4 = 2 * Math.PI;
+function correctionSizes(fields, before, after) {
+  let squares = 0;
+  let state = 0;
+  fields.forEach((field, i) => {
+    if (UNCOUNTED.has(field)) return;
+    const delta = (after[i] ?? 0) - (before[i] ?? 0);
+    if (PLACE.has(field)) squares += delta * delta;
+    else state = Math.max(state, Math.abs(field === "yaw" ? delta - TWO_PI4 * Math.floor((delta + Math.PI) / TWO_PI4) : delta));
+  });
+  return { place: Math.sqrt(squares), state };
+}
+var isVisibleCorrection = (place2, unitsPerMetre) => place2 > VISIBLE_CORRECTION_METRES * unitsPerMetre;
+function correctionBucket(place2, unitsPerMetre) {
+  const bucket = CORRECTION_BUCKET_METRES.findIndex((edge) => place2 < edge * unitsPerMetre);
+  return bucket < 0 ? CORRECTION_BUCKET_METRES.length : bucket;
+}
+
 // src/authority/tick-drawing.ts
 var RING = 80;
 var fold = (prev, next) => prev + Math.atan2(Math.sin(next - prev), Math.cos(next - prev));
@@ -4979,8 +5199,17 @@ var TickDrawing = class {
   }
 };
 
+// src/authority/fast-default.ts
+function defaultFastOpener() {
+  const builtin = globalThis.process?.getBuiltinModule;
+  const dgram = builtin?.("node:dgram");
+  const dns = builtin?.("node:dns");
+  const net = builtin?.("node:net");
+  if (dgram === void 0 || dns === void 0 || net === void 0) return void 0;
+  return udpFastOpener({ createSocket: dgram.createSocket, lookup: dns.lookup, isIP: net.isIP });
+}
+
 // src/authority/session.ts
-var VISIBLE_CORRECTION = 0.05;
 var LIFT_BLEND_MS = 100;
 var LIFT_DRAWN = ["x", "y", "z", "yaw"];
 var RIDE_FRAME_DONE = 1e-3;
@@ -4990,18 +5219,16 @@ function liftLeftover(was, k, shift, decay) {
   if (was.k === k) return kept;
   return was.shift.map((s, i) => s + kept[i] - shift[i]);
 }
-var CORRECTION_BUCKETS = [0.5, 1, 5, 20];
 var CAPACITY_RETRY_MS = [1e3, 2e3, 4e3];
 var MAX_CATCH_UP_STEPS = 8;
 var SIDE_STALE_MS = 250;
 var PROJECTILE_TTL_MIN_MS = 600;
 var ALL_PREDICTED_FIELDS = ["x", "y", "z", "vx", "vy", "vz", "yaw"];
-var NOT_A_PLACE = /* @__PURE__ */ new Set(["mstate", "cap", "spin", "fuel"]);
-var ANGLES = /* @__PURE__ */ new Set(["yaw"]);
 var SessionEvent = {
   Reconnecting: "reconnecting",
   Reconnected: "reconnected",
-  Disconnect: "disconnect"
+  Disconnect: "disconnect",
+  ...RejoinEvent
 };
 var SESSION_EVENTS = new Set(Object.values(SessionEvent));
 var MESSAGE = {
@@ -5026,16 +5253,29 @@ async function joinTargets(opts) {
   const ranked = await selectAuthorityRegions(regions, opts.probe === void 0 ? {} : { probe: opts.probe });
   return ranked.map((pick) => pick.url);
 }
-async function joinAuthority(opts) {
+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 targets = await joinTargets(opts);
   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), url };
+      return { room: await joinOnce(new Client(url), opts, plan), url, targets };
     } catch (err) {
-      const next = errorCode(err) === JoinError.AUTHORITY_CAPACITY ? nextAttempt(state, targets.length, delays) : null;
+      if (plan.method === AuthorityJoinMethod.JoinById) {
+        const region = nextCodeRegion(errorCode(err), state.region, targets.length);
+        if (region === null) explainAuthorityRefusal(err);
+        state = { region, refused: 0, step: 0 };
+        continue;
+      }
+      const kind = refusalKind(errorCode(err));
+      if (kind === RefusalKind.NextRegion && state.region + 1 < targets.length) {
+        state = { region: state.region + 1, refused: 0, step: state.step };
+        continue;
+      }
+      const next = kind === RefusalKind.Capacity ? nextAttempt(state, targets.length, delays) : null;
       if (next === null) explainAuthorityRefusal(err);
       const wait = next.attempt.waitMs;
       if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
@@ -5043,17 +5283,23 @@ async function joinAuthority(opts) {
     }
   }
 }
-function joinOnce(client, opts) {
-  const fastCaps = opts.fast === void 0 ? [] : [AuthorityCaps.FAST];
-  return client.joinOrCreate(RoomType.AUTHORITY, {
+var fastChoiceOf = (opts) => chooseFastSocket(opts.fast ?? defaultFastOpener());
+function joinOnce(client, opts, plan) {
+  const fastCaps = fastChoiceOf(opts).open === void 0 ? [] : [AuthorityCaps.FAST, AuthorityCaps.FAST_RETURN];
+  const options = {
     ...joinOptions(opts.room, opts.name, opts.auth),
+    ...plan.options,
     // §17.10 *Joining*: this session decodes and draws physics bodies (physics-draw.ts, held to
     // the netcode bench's physics-draw vectors), so it may join a physics room.
     // §17.11: a client that can load the core predicts too.
     [AuthorityJoinOption.CAPS]: predictsPhysics(opts) ? [AuthorityCaps.PHYSICS, AuthorityCaps.PHYSICS_PREDICT, AuthorityCaps.INPUT_REPEAT, AuthorityCaps.LIFTS, AuthorityCaps.INPUT_TICK, ...fastCaps] : [AuthorityCaps.PHYSICS, AuthorityCaps.INPUT_REPEAT, AuthorityCaps.LIFTS, AuthorityCaps.INPUT_TICK, ...fastCaps],
+    [AuthorityJoinOption.SDK]: AUTHORITY_SDK_LABEL,
     // Last, so nothing can misreport it (PROTOCOL.md §17.1: anything but 4 is refused with 426).
     protocol: AUTHORITY_PROTOCOL_VERSION
-  });
+  };
+  if (plan.method === AuthorityJoinMethod.JoinById) return client.joinById(plan.roomId, options);
+  if (plan.method === AuthorityJoinMethod.Create) return client.create(RoomType.AUTHORITY, options);
+  return client.joinOrCreate(RoomType.AUTHORITY, options);
 }
 function roomPreset(presetText) {
   if (!presetText) return null;
@@ -5097,8 +5343,8 @@ function heldInput(player) {
 }
 var NOT_A_BODY = { body: false, qx: 0, qy: 0, qz: 0, qw: 1, sleep: false };
 var NOTHING_YET = /* @__PURE__ */ new Map();
-var TWO_PI4 = 2 * Math.PI;
-var wrapAngle = (v) => v - TWO_PI4 * Math.floor((v + Math.PI) / TWO_PI4);
+var TWO_PI5 = 2 * Math.PI;
+var wrapAngle = (v) => v - TWO_PI5 * Math.floor((v + Math.PI) / TWO_PI5);
 var SEAT_DRAWINGS = [ContactDrawing.Predicted, ContactDrawing.Separate, ContactDrawing.Timeline];
 var DEFAULT_SEAT_DRAWING = ContactDrawing.Predicted;
 var renderInternals = (reconciler) => {
@@ -5107,8 +5353,35 @@ var renderInternals = (reconciler) => {
   return ok ? r : null;
 };
 async function connectAuthority(opts) {
-  const joined = await joinAuthority(opts);
-  return attachAuthoritySession(useSdkReconnection(joined.room), opts, joined.url);
+  const joined = await joinAuthority(opts, opts.matchKey === void 0 ? {} : { matchKey: opts.matchKey });
+  return comingBack(attachAuthoritySession(useSdkReconnection(joined.room), opts, joined.url), opts, joined, false);
+}
+async function createPrivateAuthority(opts) {
+  const joined = await joinAuthority(opts, { createPrivate: true, ...opts.matchKey === void 0 ? {} : { matchKey: opts.matchKey } });
+  return comingBack(attachAuthoritySession(useSdkReconnection(joined.room), opts, joined.url), opts, joined, true);
+}
+async function joinPrivateAuthority(code, opts) {
+  const joined = await joinAuthority(opts, { code, ...opts.matchKey === void 0 ? {} : { matchKey: opts.matchKey } });
+  return comingBack(attachAuthoritySession(useSdkReconnection(joined.room), opts, joined.url), opts, joined, true);
+}
+function comingBack(session, opts, joined, closed) {
+  if (opts.rejoin === false) return session;
+  const others = joined.targets.filter((url) => url !== joined.url);
+  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;
+    }
+  });
+}
+function rejoinPlan(way, lost) {
+  if (way === RejoinWay.Room) return { method: AuthorityJoinMethod.JoinById, roomId: lost.roomId, options: {} };
+  if (way === RejoinWay.Successor) return { method: AuthorityJoinMethod.JoinOrCreate, options: planSuccessorJoin({ lostRoomId: lost.roomId, matchKey: lost.matchKey, closed: lost.closed }) };
+  return { method: AuthorityJoinMethod.JoinOrCreate, options: lost.matchKey === "" ? {} : { matchKey: lost.matchKey } };
 }
 function attachAuthoritySession(room, opts, url) {
   const state = room.state;
@@ -5116,10 +5389,14 @@ function attachAuthoritySession(room, opts, url) {
   const playerMap = () => state.players ?? NOTHING_YET;
   const renderDelay = opts.renderDelayMs ?? AuthorityTiming.RENDER_DELAY_MS;
   const handle = room.input({ type: AuthorityInput, mode: "reliable", renderDelay });
+  const fastChoice = fastChoiceOf(opts);
   const fast = fastSeat({
     room,
     handle,
-    open: opts.fast,
+    open: fastChoice.open,
+    neverAsked: fastChoice.fallback,
+    off: opts.fast === false,
+    log: opts.fastLog ?? defaultFastLog,
     now: opts.fastClock ?? (() => performance.now()),
     tickHz: () => tickHz(),
     stateCurrent: () => !resyncFirstState
@@ -5172,9 +5449,10 @@ function attachAuthoritySession(room, opts, url) {
     inputsDropped: 0,
     reconciles: 0,
     visibleCorrections: 0,
-    correctionBuckets: CORRECTION_BUCKETS.map(() => 0).concat(0),
+    correctionBuckets: CORRECTION_BUCKET_METRES.map(() => 0).concat(0),
     peakCorrection: 0,
     lastCorrection: 0,
+    peakStateCorrection: 0,
     reseeds: 0,
     bodyStates: 0,
     bodySnaps: 0,
@@ -5185,8 +5463,8 @@ function attachAuthoritySession(room, opts, url) {
     lastProjectileLeadMs: 0
   };
   const listeners = /* @__PURE__ */ new Map();
-  const emit = (event, payload) => {
-    for (const handler of listeners.get(event) ?? []) handler(payload);
+  const emit = (event, ...payload) => {
+    for (const handler of listeners.get(event) ?? []) handler(...payload);
   };
   let connected = true;
   let ended = false;
@@ -5449,20 +5727,15 @@ function attachAuthoritySession(room, opts, url) {
   };
   const noteCorrection = (predicted, before, seqBefore) => {
     if (predicted.reconciler.reconcileSeq === seqBefore) return;
-    const after = predictedPose(predicted);
-    let magnitude = 0;
-    predicted.fields.forEach((field, i) => {
-      if (NOT_A_PLACE.has(field)) return;
-      const delta = (after[i] ?? 0) - (before[i] ?? 0);
-      magnitude = Math.max(magnitude, Math.abs(ANGLES.has(field) ? wrapAngle(delta) : delta));
-    });
+    const { place: place2, state: stateGap } = correctionSizes(predicted.fields, before, predictedPose(predicted));
     telemetry.reconciles++;
-    telemetry.lastCorrection = magnitude;
-    telemetry.peakCorrection = Math.max(telemetry.peakCorrection, magnitude);
-    if (magnitude > VISIBLE_CORRECTION) {
+    telemetry.lastCorrection = place2;
+    telemetry.peakCorrection = Math.max(telemetry.peakCorrection, place2);
+    telemetry.peakStateCorrection = Math.max(telemetry.peakStateCorrection, stateGap);
+    const unit2 = unitsPerMetre();
+    if (isVisibleCorrection(place2, unit2)) {
       telemetry.visibleCorrections++;
-      const bucket = CORRECTION_BUCKETS.findIndex((edge) => magnitude < edge);
-      telemetry.correctionBuckets[bucket < 0 ? CORRECTION_BUCKETS.length : bucket] += 1;
+      telemetry.correctionBuckets[correctionBucket(place2, unit2)] += 1;
     }
   };
   const yawBefore = (predicted) => {
@@ -5922,10 +6195,10 @@ function attachAuthoritySession(room, opts, url) {
     predict.dispose();
     physicsPrediction.dispose();
   };
-  room.onLeave((code) => {
+  room.onLeave((code, reason) => {
     if (ended) return;
     end();
-    emit(SessionEvent.Disconnect, code);
+    emit(SessionEvent.Disconnect, code, authorityCloseCodeOf(reason));
   });
   room.onMessage("*", (type, payload) => {
     if (typeof type !== "string") return;
@@ -6278,6 +6551,10 @@ function attachAuthoritySession(room, opts, url) {
       if (!ended) trackOwn();
       return own ? view(own.id, own.entity) : void 0;
     },
+    code: room.roomId,
+    get matchKey() {
+      return state.matchKey ?? "";
+    },
     setWorld(next) {
       const checked = firstpersonWorld(next);
       const changed2 = checked.hash !== world.hash;
@@ -6414,7 +6691,17 @@ export {
   regionProbePlan,
   rankAuthorityRegions,
   capacityWalk,
+  RefusalKind,
+  refusalKind,
   selectAuthorityRegions,
+  REJOIN,
+  SUCCESSOR_OPEN_MS,
+  RejoinWay,
+  RejoinStop,
+  comesBackAfter,
+  rejoinStep,
+  validSuccessorOf,
+  planSuccessorJoin,
   quatMul,
   quatNormalize,
   slerpFromIdentity,
@@ -6599,19 +6886,15 @@ export {
   throttleState,
   seatLeadClock,
   throttleSteps,
-  MotionRecordKind,
-  RECORD_ID_MAX_CHARS,
-  blankEntityMotion,
-  blankSeatEcho,
-  quantizeCode,
-  dequantizeCode,
-  encodeRecord,
-  decodeRecord,
-  FastFallbackReason,
-  isFastBind,
-  heldInputs,
-  openFastClient,
+  FastTransport,
+  FastNotAsked,
+  FAST_OFFER_WAIT_MS,
+  udpLine,
+  webSocketLine,
+  fastLineAnnouncer,
   SEAT_DRAWINGS,
   DEFAULT_SEAT_DRAWING,
-  connectAuthority
+  connectAuthority,
+  createPrivateAuthority,
+  joinPrivateAuthority
 };