@genex-ai/multiplayer 0.17.9 → 0.17.11

package/PROTOCOL.md

@@ -633,6 +633,8 @@ The TypeScript client session is `connectAuthority` (`src/authority/session.ts`)
 - An authority client sends `protocol: 4` (`AUTHORITY_PROTOCOL_VERSION`). Authority rooms accept `AUTHORITY_WINDOW` = `[4, 4]`; anything else is refused with **426** before a room is found or created. A relay room refuses 4 the same way (§2), so neither kind of client can land in the other kind of room.
 - Authority rooms are served by their own cluster, never by a relay. The embed layer supplies its URLs next to the relay URLs (`colyseus.authorityUrls`; in local test mode, a loopback `genex_authority_url` on a loopback page, with a fixed local credential in place of a token), and the same cluster by region (`colyseus.authorityRegions`, below).
 - *Regions.* `colyseus.authorityRegions` is a list of `{ region, urls[] }`; each region is its own matchmaking pool, because the server filters rooms by the region a join entered through (the server-owned `region` option, §17.2). A client reads it leniently: an entry without a non-empty name or without a non-empty url string is dropped, and a repeated name keeps its first entry. When no entry is usable, every `authorityUrls` entry is a region of its own (an older stand, local test mode). With one region the client joins through its first url. With several, it MUST probe as §3.1 does, a preference and never a gate: 3 samples per region, sample n going to the region's url n modulo its url count; a sample is failed when it has not answered after 4000 ms, which is also the ceiling of the whole probe, and once any sample has answered the others get 1000 ms more. A url's latency is its best answered sample (a finite number of ms, at least 0). Regions are tried in this order: those with an answer, nearest first (a tie keeps list order), each entered through its best url (the first on a tie); then the silent ones in list order, through their first url. A dead path moves to the next region at once: no answer at all, a gateway's 502 or 504, or Cloudflare's 520 to 526 and 530. Anything but those and 503 (with 4213, a process shutting down, which a sibling answers on the next try) is the server's answer and final. A join refused 503 twice in a row on one region moves to the next region at once; any other 503 waits the capacity schedule's next step on the same region, and the join gives up with the last refusal when the schedule is spent. An explicit `url` (an invite: the inviter's session url) skips the probe, so a party plays in its leader's region. `netcode-bench/conformance/authority/authority-regions.json` pins every rule; the TypeScript, Unreal, Unity and Rust clients pass it exactly. The Godot client joins its first url (labelled in CI).
+- *Finding players.* Because each region is its own pool, a client that only ever entered its nearest region would leave two players in different regions alone, each in an empty room. So a pool join (the `joinOrCreate` of the next bullet: not a join by code, a private create, a rejoin or an explicit `url`) first asks for a room that already exists, and opens one only when no region in reach has one. A room a join can still enter has a player in it, so this is where the players are. The regions asked are the answered ones whose latency (the probe's best sample) is at most `maxPingMs`, nearest first; the default is 350 ms, and anything but a finite number of ms, at least 0, is the default. Fewer than two such regions is no search, since the join-or-create finds its own region's room itself. Each is asked with Colyseus's `join`, carrying the options the `joinOrCreate` would: seated, the player is in that region; refused, the next region is asked when the refusal is one of *Regions*' dead paths or capacity answers (Colyseus's own answer for no matching room is 521, one of them), and any other refusal is the server's answer about the player or the game, which ends the join with no room opened. When no region asked has a room, the join goes on as *Regions* says: `joinOrCreate`, nearest region first. A game may turn the search off (the rule `nearest`; any other value is `players`, the default), and a player may pin one region by its name: then that region alone is joined and created in, through its best url, and a name the list does not have is no pin. A join by code ignores a pin: its room is where it is. Nothing here is sent to a server or changes one: a client that searches plays with clients that do not. `authority-regions.json` pins the regions asked, where the room is then opened and what each refused ask does (`searches`, `searchRefusals`); the TypeScript, Unreal, Unity and Rust clients pass it exactly. The Godot client joins its first url and looks for no one.
+- *Regrouping.* Two players who start at the same moment in two regions each find no room and each open one, and *Finding players* never runs again for them. So while a player is alone in a pool room (its state lists no other player), the client keeps asking for a room that already has players, and moves the seat there. Every client reads the regions in one order, so of two players each alone in their own region exactly one moves: a client asks only the regions listed BEFORE the one its seat is in, nearest first, among the answered ones no farther than `maxPingMs` (the join's own probe results). It asks with Colyseus's `join` and the pool's options, after each wait of 2, 4, 9, 15 and then every 30 seconds; with company it only looks again after 2 seconds, and the waits start over the next time it is alone. A seat found is given back when, while it was asked for, the player's own room gained company, was lost or was left. Otherwise it is adopted once its first state has landed, as a seat is after a drain (§17.13): the game keeps its session, hears `rejoined` with `moved` set, and the room the player was alone in is left. A refused ask is never an error; the next region is asked. Nothing is asked while a lost room is being replaced, for a private room, a room joined by code, an explicit `url`, a pinned region or the rule `nearest`, and a game may turn regrouping off. After a move the regions listed before the new one are the ones asked. `authority-regions.json` pins the regions asked and the waits (`regroups`, `regroup`). A region picker needs no join: a client may probe the regions as a join does and show each one's latency, and the region of a seat is the one whose urls hold the seat's url.
 - A client joins with `joinOrCreate('authority', { gameId, embedToken, name, protocol: 4 })`, or names a pool or a private room (§17.2 *Choosing a room*). The token rules of §3.2 apply. A preview (staging) token joins the game's staging module, in rooms apart from the live game's (§3.4). A join lands in a room running the module the game currently ships: once a newer module has a room, new joins go there, while rooms on the older one keep their players until they empty.
 - Appending a schema field, adding a message or adding an optional key is not a bump; the §2 bump rules apply to this section with `AUTHORITY_PROTOCOL_VERSION` in place of `PROTOCOL_VERSION`.
 
@@ -655,7 +657,7 @@ A new authority room is admitted by the platform before it is created. Admission
 
 - `matchKey` (string): the pool to join. It is 1 to 32 characters of `a-z 0-9 . _ : -`, the first a letter or a digit (`AuthorityRoomLimits`, `src/authority/room-key.ts`). Anything else, a value of any other type included, is refused with **400** before the token is looked at and before any room exists. Absent and `''` are the same: no key. Rooms are found by game, module, region and key, and the server writes `''` into the filter when no key was sent, so a join without a key never lands in a keyed room. The key narrows the pool the server already chose and replaces none of it: the game and its channel come from the verified token and the region from the worker, so no key reaches another game, another region, or the staging module from live. A key is the client's choice, so a module MUST treat one it does not know as its default and never as an error.
 - `private` (boolean): `create('authority', { …, private: true })` makes a private room; any other type is refused with **400**. A private room is unlisted from before its first await, so `joinOrCreate` and `join` never reach it, whatever key they send, and a `joinOrCreate` that carries `private` may land in a public room. The room's code is its `roomId`, returned by `create`. A private room takes a `matchKey` like any other.
-- *Join by code.* `joinById(code, { … })` reaches that room and no other. A code is 1 to 32 characters of `A-Z a-z 0-9 _ -`, and a client refuses any other before sending it, because a code goes into a url. The room still refuses a seat for another game or channel (403) and a join that entered through another region (**421**), neither taking a seat. A `matchKey` sent with a code is checked (400) and then has no effect: the room's key is its own. A client MUST NOT send one, and an SDK refuses the pair. A client walks its regions in §17.1's order: on 421 and on Colyseus's 522 (no such room here, or it is full or closing) it tries the next region, and any other refusal, or either on the last region, is final. An explicit `url` skips the walk. A room stays on the module it started with, as §17.1 says of any live room.
+- *Join by code.* `joinById(code, { … })` reaches that room and no other. A code is 1 to 32 characters of `A-Z a-z 0-9 _ -`, and a client refuses any other before sending it, because a code goes into a url. The room still refuses a seat for another game or channel (403) and a join that entered through another region (**421**), neither taking a seat. A region that does not hold the room answers 421 or Colyseus's 522; the deployed servers' transport sends 522 as HTTP **500** with 522 in its body, which a Colyseus client reports as 500, so a client walks on after 421, 522 and 500 alike. A `matchKey` sent with a code is checked (400) and then has no effect: the room's key is its own. A client MUST NOT send one, and an SDK refuses the pair. A client walks its regions in §17.1's order: on 421 and on Colyseus's 522 (no such room here, or it is full or closing) it tries the next region, and any other refusal, or either on the last region, is final. An explicit `url` skips the walk. A room stays on the module it started with, as §17.1 says of any live room.
 - *Joining together.* Players who `joinOrCreate` one pool at once share one room, up to its seats. While a pool's room is being created, a later join's request stays open until that room is listed (at most about 30 s, normally the room's create time and under a second more) and is then seated in it; a client sees a slower answer and nothing else. No client sends anything new for this. It holds per pool, and each region is its own pool (§17.1 *Regions*): players whose probes pick different regions do not meet in the default pool. An invite's `url` or a room code brings them together.
 - *Reading it.* `AuthorityRoomState.matchKey` (§17.3) is the room's key, absent for none: this is how a friend who joined by code learns it. A module reads `ctx.matchKey` in `init` (`''` for none) to choose a mode.
 

package/README.md

@@ -638,7 +638,7 @@ import * as genexEmbed from '@genex-ai/embed-sdk';
 await genexEmbed.waitForPlayer();
 const s = await connectAuthority({
   urls: genexEmbed.getAuthorityUrls(),       // the authority cluster, NOT getColyseusUrls()
-  regions: genexEmbed.getAuthorityRegions(), // its regions: the nearest is joined (PROTOCOL.md §17.1)
+  regions: genexEmbed.getAuthorityRegions(), // its regions: a room with players in reach, else the nearest; a player alone is moved to players (PROTOCOL.md §17.1)
   room: 'my-game',
   auth: () => genexEmbed.getColyseusAuth(),
 });

package/dist/authority/fast-webtransport.js

@@ -6,10 +6,10 @@ import {
   openWebTransportFastSocket,
   webTransportFastOpener,
   webTransportOptions
-} from "../chunk-ZDGSUR6E.js";
+} from "../chunk-5WENVWVO.js";
 import "../chunk-OD6NRSX2.js";
 import "../chunk-2NGXXQDS.js";
-import "../chunk-WEMRRIHH.js";
+import "../chunk-2CSX5WA6.js";
 export {
   FAST_WT_HASHES_MAX,
   FAST_WT_HASH_HEX_DIGITS,

package/dist/authority/index.d.ts

@@ -1020,6 +1020,7 @@ declare const AuthorityJoinMethod: {
     readonly JoinOrCreate: "joinOrCreate";
     readonly Create: "create";
     readonly JoinById: "joinById";
+    readonly Join: "join";
 };
 type AuthorityJoinMethod = (typeof AuthorityJoinMethod)[keyof typeof AuthorityJoinMethod];
 /** Why a client refuses a target before anything reaches the network. */
@@ -2143,6 +2144,35 @@ type CapacityAttempt = {
 };
 /** Refusals (503) in a row on one region before the next attempt goes to the next-best region. */
 declare const AUTHORITY_REFUSALS_PER_REGION = 2;
+/** How far a join looks for players by default, as a probe's round trip in ms (§17.1 *Finding players*):
+ *  far enough that a player in one region reaches the others. */
+declare const AUTHORITY_MAX_PING_MS = 350;
+/** The waits before each ask of a player who is alone in a room (§17.1 *Regrouping*); the last repeats. */
+declare const AUTHORITY_REGROUP_WAITS_MS: readonly [2000, 4000, 9000, 15000, 30000];
+/** How a pool join picks its region (§17.1 *Finding players*). */
+declare const RegionRule: {
+    /** A room with players in any region in reach, nearest first; else a new room in the nearest region. */
+    readonly Players: "players";
+    /** The nearest region alone, whoever is elsewhere. */
+    readonly Nearest: "nearest";
+};
+type RegionRule = (typeof RegionRule)[keyof typeof RegionRule];
+/** What a game or its player chose about regions; every field is read leniently. */
+type AuthoritySearchOptions = {
+    /** Default {@link RegionRule.Players}; anything but `nearest` is that. */
+    rule?: unknown;
+    /** The farthest region asked for players, as a probe's round trip in ms. Default
+     *  {@link AUTHORITY_MAX_PING_MS}; anything but a finite number ≥ 0 is the default. */
+    maxPingMs?: unknown;
+    /** The one region to play in, by name (a player's own choice): no other is joined or created in. A
+     *  name the cluster does not have is no choice. */
+    region?: unknown;
+};
+/** Where a pool join goes: the regions asked for an existing room, then where one is opened. */
+type AuthoritySearchPlan = {
+    search: AuthorityRegionPick[];
+    create: AuthorityRegionPick[];
+};
 /** The regions a client uses, read leniently from `colyseus.authorityRegions`, else one per flat url. */
 declare function normalizeAuthorityRegions(regions: unknown, urls: unknown): AuthorityRegion[];
 /** The url each probe sample of a region goes to: sample n to url n modulo the url count. */
@@ -2150,6 +2180,11 @@ declare function regionProbePlan(urls: readonly string[], samples: number): stri
 /** The order regions are tried in, from each url's best sample (`best[region][url]`; anything but a
  *  finite number ≥ 0 is no answer). */
 declare function rankAuthorityRegions(regions: readonly AuthorityRegion[], best: readonly (readonly unknown[] | undefined)[]): AuthorityRegionPick[];
+/** Where a pool join goes (§17.1 *Finding players*), from each url's best sample: the answered regions
+ *  no farther than the limit are asked for an existing room, nearest first, and the room is opened in
+ *  the ranked order. Fewer than two regions in reach is no search (the join-or-create finds its own
+ *  region's room), as is the rule `nearest`. A pinned region is the only one joined. */
+declare function planAuthoritySearch(regions: readonly AuthorityRegion[], best: readonly (readonly unknown[] | undefined)[], options?: AuthoritySearchOptions): AuthoritySearchPlan;
 /** Every attempt of a join that every server refuses 503, over `regionCount` ranked regions and the
  *  capacity schedule `delays`: a prefix of it is the walk of a join that is seated. */
 declare function capacityWalk(regionCount: number, delays: readonly number[]): CapacityAttempt[];
@@ -2165,9 +2200,41 @@ declare const RefusalKind: {
 type RefusalKind = (typeof RefusalKind)[keyof typeof RefusalKind];
 /** What a join refused with `code` does next; no number at all is a network that failed. */
 declare function refusalKind(code: unknown): RefusalKind;
+/** Where a player who is alone in a room keeps asking for one that has players (§17.1 *Regrouping*),
+ *  from each url's best sample and the region it is in. Every client reads the regions in one order, so
+ *  of two players each alone in their own region exactly one moves: only the regions listed before
+ *  `joined` are asked, nearest first, among the answered ones no farther than the limit. The rule
+ *  `nearest`, a pinned region and a region the list does not have ask no one. */
+declare function planAuthorityRegroup(regions: readonly AuthorityRegion[], best: readonly (readonly unknown[] | undefined)[], options: AuthoritySearchOptions | undefined, joined: string): AuthorityRegionPick[];
+/** The region `url` enters, by its name in `regions`; undefined when none lists it. */
+declare function authorityRegionOf(regions: readonly AuthorityRegion[], url: string): string | undefined;
+/** One region as a player's settings show it: its name and its round trip in ms (null: no answer). */
+type AuthorityRegionPing = {
+    region: string;
+    pingMs: number | null;
+};
+/** Every region with its latency, in list order, for a region picker: the probe a join runs, with no
+ *  join. One region is not probed (its ping is null). Never rejects on a probe. */
+declare function measureAuthorityRegions(regions: readonly AuthorityRegion[], options?: RelaySelectOptions): Promise<AuthorityRegionPing[]>;
+/** What a refused ask for an existing room does next (§17.1 *Finding players*). */
+declare const 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. */
+    readonly Next: "next";
+    /** The server's answer about this player or game, which every region would repeat. */
+    readonly Final: "final";
+};
+type SearchRefusal = (typeof SearchRefusal)[keyof typeof SearchRefusal];
+/** What an ask refused with `code` does next; no number at all is a network that failed. */
+declare function searchRefusalKind(code: unknown): SearchRefusal;
 /** Probes every region (relay-select.ts's tolerant samples, one url per sample) and answers the order
  *  to try them in. One region is not probed; none answers []. Never rejects on a probe. */
 declare function selectAuthorityRegions(regions: readonly AuthorityRegion[], options?: RelaySelectOptions): Promise<AuthorityRegionPick[]>;
+/** Probes every region and answers each url's best sample (`best[region][url]`; undefined: silent). */
+declare function probeAuthorityRegions(regions: readonly AuthorityRegion[], options: RelaySelectOptions): Promise<(number | undefined)[][]>;
+/** {@link selectAuthorityRegions} for a pool join: the same probe, answering where to look for players
+ *  and where to open a room. One region is not probed. Never rejects on a probe. */
+declare function selectAuthoritySearch(regions: readonly AuthorityRegion[], search?: AuthoritySearchOptions, options?: RelaySelectOptions): Promise<AuthoritySearchPlan>;
 
 /** The rejoin's schedule and windows, ms. */
 declare const REJOIN: {
@@ -2252,10 +2319,12 @@ type AuthorityRejoining = {
     code: number;
     waitMs: number;
 };
-/** `rejoined`: back in play, as a new seat in a new room (the invite `code` is new too). */
+/** `rejoined`: back in play, as a new seat in a new room (the invite `code` is new too). `moved` is set
+ *  when no room was lost: the player was alone and now sits in a room that has players (§17.1 *Regrouping*). */
 type AuthorityRejoined = {
     code: string;
     url: string;
+    moved?: true;
 };
 
 /** The own-entity fields a prediction step may read and write: the pose and velocity always, and
@@ -2284,6 +2353,15 @@ type AuthorityConnectOptions = {
     /** Override: connect to THIS exact url, skipping latency selection: an invitee passes the inviter's
      *  `session.url` and lands in the inviter's region (a party plays in its leader's region). */
     url?: string;
+    /** How a pool join picks its region (§17.1 *Finding players*). Default `players`: the regions in reach
+     *  are asked for a room that already has players, nearest first, and a room is opened in the nearest
+     *  one only when none has. `nearest` joins the nearest region whoever is elsewhere. */
+    regionRule?: RegionRule;
+    /** The farthest region asked for players, as a probe's round trip in ms. Default 350. */
+    maxPingMs?: number;
+    /** The one region to play in, by its name in `regions` (a player's own choice): no other is joined
+     *  or created in. A name the cluster does not have is ignored. A join by code still finds its room. */
+    region?: string;
     /** One latency sample of a url (relay-select.ts `RelayProbe`). Default: one Colyseus ping. For tests
      *  and benches; a game leaves it unset. */
     probe?: RelayProbe;
@@ -2374,6 +2452,10 @@ type AuthorityConnectOptions = {
     /** Whether a seat whose room ended for a deploy, or whose socket no reconnect restored, goes back into
      *  play by itself (§17.13 *Drain and rejoin*). Default true; false makes that close final. */
     rejoin?: boolean;
+    /** Whether a player who is alone in a pool room keeps asking for a room that already has players and
+     *  moves there (§17.1 *Regrouping*): the session stays the game's object and `rejoined` fires with
+     *  `moved`. Default true; false keeps the player where they are. Needs `rejoin`. */
+    regroup?: boolean;
     /** Every message the server sends, in order, by type: the room module's events and the server's
      *  own (`server:restart` before a drain), with no name withheld. For a facade that forwards them
      *  all, such as the engine bridge; a game subscribes with `on(type)`. */
@@ -2668,4 +2750,4 @@ declare function createPrivateAuthority(opts: AuthorityConnectOptions): Promise<
  */
 declare function joinPrivateAuthority(code: string, opts: AuthorityConnectOptions): Promise<AuthoritySession>;
 
-export { AUTHORITY_REFUSALS_PER_REGION, AuthorityBody, AuthorityCloseCode, type AuthorityConnectOptions, AuthorityContactRule, type AuthorityDraining, AuthorityEntity, type AuthorityEntityView, AuthorityInput, AuthorityJoinMethod, type AuthorityJoinPlan, AuthorityJoint, AuthorityLimits, AuthorityPhysicsEntity, AuthorityPhysicsRoomState, type AuthorityPhysicsStatus, AuthorityPlayer, type AuthorityPlayerView, type AuthorityPrediction, type AuthorityPredictionStatus, type AuthorityRegion, type AuthorityRegionPick, type AuthorityRejoined, type AuthorityRejoining, AuthorityRoomLimits, AuthorityRoomState, type AuthorityRoomTarget, type AuthoritySeatPass, AuthoritySeatRule, type AuthoritySession, AuthorityShape, type AuthorityStep, AuthorityTargetRefusal, type AuthorityTelemetry, CONVEYOR_RATE, type Carried, type CarryReport, type CastHit, ContactBody, ContactDrawing, type ContactEnv, ContactEvent, ContactKind, type ContactPassOptions, ContactPolicy, type ContactReport, type ContactWorld, type ContactWorldSpec, type ConveyorBody, DEFAULT_SEAT_DRAWING, DEFAULT_TICK_HZ, type DeclaredContacts, type DrawnPose, EntityData, type EntityIndex, type EntityOut, type EventOut, FAST_OFFER_WAIT_MS, type FaceFilter, FastFallbackReason, type FastLineAnnouncer, type FastLineObservation, FastNotAsked, type FastSeatStatus, FastSocketOpener, FastTransport, FirstpersonWorld, FirstpersonWorldSpec, type Frame, GuestGlobal, HEAD_LANDING_SPEED, HeadHold, type HeadSlabs, type HeadsContext, type HeldSeat, HullBody, HullOps, INPUT_REPEAT_MAX_MS, INPUT_REPEAT_RUN_MS, INPUT_REPEAT_STEADY, INPUT_TICK_MOD, INPUT_TICK_SLACK_S, type InitOut, InputData, InputRepeat, type InputThrottle, InputUse, Json, type KinematicSupport, LeaveReason, Lift, type LiftBodyPose, type LiftCollider, type LiftPose, type LiftSeat, LiftSolidsCache, type LiftTick, LiftVec, LiftsPolicy, MAX_PROJECTILE_G, MAX_PROJECTILE_TICK, MAX_TICK_HZ, MOTION_VIEW_TAG, PHYSICS_ONLY_TICK_HZ, type PairContact, type PairOutcome, PhysAnswerRow, PhysBodyRow, type PhysCommand, PhysEvRow, type PhysicsAdmission, PhysicsCeiling, PhysicsErrorCode, type PhysicsPredictionStatus, type PhysicsTickIndex, type Plane, PlayerInfo, type PolicyBody, PosedSolid, PosedWorld, PredictBodyRule, PredictCore, PredictKinematicRule, PredictStatus, type PredictedBody, type PredictedField, PresetName, type ProjectileLaunch, type ProjectilePrediction, type ProjectileState, type PropBody, type PropNudge, type PropSeat, PropSlide, REJOIN, RIDE_CHAIN_MAX, type ReconcilerAckHold, RefusalKind, type RejoinInput, type RejoinStep, RejoinStop, RejoinWay, RemoteInput, RemotePredict, ResolvedModuleConfig, type Ride, type RiderPose, SEAT_DRAWINGS, SHOVE_EASE_DONE, STALL_PREDICT_MS, STEADY_BUCKETS, SUCCESSOR_OPEN_MS, type SeatChange, type SeatClock, type SeatDrawing, type SeatLifts, type SeatMotion, type SeatOffset, type SeatPass, type SeatPose, type SeatRate, type SeatRepeats, type SeatStep, SeatWorld, type SeatWorldLifts, type SeatWorldOptions, ShotWorldCount, SlideWay, type SolidGrid, StandRule, THROTTLE_DILATION, THROTTLE_LOW_INPUTS, THROTTLE_SEAT_LEAD, TICK_RATES, TickHz, type TickIn, type TickInput, type TickOut, TickOutFault, type TickSolids, TopRule, UNSTICK_SOLIDS, type V3, type WireResult, WorldCost, WorldCostMeter, type WorldCostReport, capacityWalk, carryOnLift, carrySlot, carryTick, castWorld, comesBackAfter, compileContactWorld, connectAuthority, consumedUse, contactOf, contactPair, contactPass, contactPassOf, contactRuleOf, conveyorNudges, conveyorUnder, createPrivateAuthority, declaredContacts, farApart, fastLineAnnouncer, feedWithPayback, forgiveRepeats, frameOf, hasStand, headHold, headOffset, headSlab, headSlabs, headStands, impartSlot, impartTick, inLiftFrame, inputThrottle, inputTickField, inputTickLag, inputTickSlack, insideFace, insideWorld, isProjectile, joinPrivateAuthority, liftBodyKey, liftBodyPose, liftBodySpawn, liftCollider, liftDrawnAt, liftPose, liftPoses, liftPosesAt, liftStartsOf, liftTopAt, liftUnder, matchKeyOf, mayStand, nextCodeRegion, normalizeAuthorityRegions, pcos, planAuthorityJoin, planSuccessorJoin, posedFor, posedSolids, projectileAt, propSlideNudges, psin, psincos, rankAuthorityRegions, reconcileThrough, reconcilerAck, reconcilerAckHold, refusalKind, regionProbePlan, rejoinStep, repeatMaxTicks, repeatRunTicks, repeatStarved, repeatsSeat, rideSlot, rideStep, rideTick, ridesOn, rodeBy, roomAlong, sameHeldInput, sanitizeInput, seatClock, seatLeadClock, seatLiftsOf, seatOffset, seatRepeats, seatTauMs, seatTouchShare, seatUnderProp, selectAuthorityRegions, selectMatchWorld, serverTick, shoveEase, spinStep, stateThrough, stepOnLifts, steppedThrough, surfaceUp, tagsOf, throttleState, throttleSteps, tickInstant, tickSolids, topRuleOf, udpLine, unstickBody, validMatchKey, validRoomCode, validSuccessorOf, validateInitOut, validateTickOut, viewOnLift, webSocketLine, worldCost, yieldShares };
+export { AUTHORITY_MAX_PING_MS, AUTHORITY_REFUSALS_PER_REGION, AUTHORITY_REGROUP_WAITS_MS, AuthorityBody, AuthorityCloseCode, type AuthorityConnectOptions, AuthorityContactRule, type AuthorityDraining, AuthorityEntity, type AuthorityEntityView, AuthorityInput, AuthorityJoinMethod, type AuthorityJoinPlan, AuthorityJoint, AuthorityLimits, AuthorityPhysicsEntity, AuthorityPhysicsRoomState, type AuthorityPhysicsStatus, AuthorityPlayer, type AuthorityPlayerView, type AuthorityPrediction, type AuthorityPredictionStatus, type AuthorityRegion, type AuthorityRegionPick, type AuthorityRegionPing, type AuthorityRejoined, type AuthorityRejoining, AuthorityRoomLimits, AuthorityRoomState, type AuthorityRoomTarget, type AuthoritySearchOptions, type AuthoritySearchPlan, type AuthoritySeatPass, AuthoritySeatRule, type AuthoritySession, AuthorityShape, type AuthorityStep, AuthorityTargetRefusal, type AuthorityTelemetry, CONVEYOR_RATE, type Carried, type CarryReport, type CastHit, ContactBody, ContactDrawing, type ContactEnv, ContactEvent, ContactKind, type ContactPassOptions, ContactPolicy, type ContactReport, type ContactWorld, type ContactWorldSpec, type ConveyorBody, DEFAULT_SEAT_DRAWING, DEFAULT_TICK_HZ, type DeclaredContacts, type DrawnPose, EntityData, type EntityIndex, type EntityOut, type EventOut, FAST_OFFER_WAIT_MS, type FaceFilter, FastFallbackReason, type FastLineAnnouncer, type FastLineObservation, FastNotAsked, type FastSeatStatus, FastSocketOpener, FastTransport, FirstpersonWorld, FirstpersonWorldSpec, type Frame, GuestGlobal, HEAD_LANDING_SPEED, HeadHold, type HeadSlabs, type HeadsContext, type HeldSeat, HullBody, HullOps, INPUT_REPEAT_MAX_MS, INPUT_REPEAT_RUN_MS, INPUT_REPEAT_STEADY, INPUT_TICK_MOD, INPUT_TICK_SLACK_S, type InitOut, InputData, InputRepeat, type InputThrottle, InputUse, Json, type KinematicSupport, LeaveReason, Lift, type LiftBodyPose, type LiftCollider, type LiftPose, type LiftSeat, LiftSolidsCache, type LiftTick, LiftVec, LiftsPolicy, MAX_PROJECTILE_G, MAX_PROJECTILE_TICK, MAX_TICK_HZ, MOTION_VIEW_TAG, PHYSICS_ONLY_TICK_HZ, type PairContact, type PairOutcome, PhysAnswerRow, PhysBodyRow, type PhysCommand, PhysEvRow, type PhysicsAdmission, PhysicsCeiling, PhysicsErrorCode, type PhysicsPredictionStatus, type PhysicsTickIndex, type Plane, PlayerInfo, type PolicyBody, PosedSolid, PosedWorld, PredictBodyRule, PredictCore, PredictKinematicRule, PredictStatus, type PredictedBody, type PredictedField, PresetName, type ProjectileLaunch, type ProjectilePrediction, type ProjectileState, type PropBody, type PropNudge, type PropSeat, PropSlide, REJOIN, RIDE_CHAIN_MAX, type ReconcilerAckHold, RefusalKind, RegionRule, type RejoinInput, type RejoinStep, RejoinStop, RejoinWay, RemoteInput, RemotePredict, ResolvedModuleConfig, type Ride, type RiderPose, SEAT_DRAWINGS, SHOVE_EASE_DONE, STALL_PREDICT_MS, STEADY_BUCKETS, SUCCESSOR_OPEN_MS, SearchRefusal, type SeatChange, type SeatClock, type SeatDrawing, type SeatLifts, type SeatMotion, type SeatOffset, type SeatPass, type SeatPose, type SeatRate, type SeatRepeats, type SeatStep, SeatWorld, type SeatWorldLifts, type SeatWorldOptions, ShotWorldCount, SlideWay, type SolidGrid, StandRule, THROTTLE_DILATION, THROTTLE_LOW_INPUTS, THROTTLE_SEAT_LEAD, TICK_RATES, TickHz, type TickIn, type TickInput, type TickOut, TickOutFault, type TickSolids, TopRule, UNSTICK_SOLIDS, type V3, type WireResult, WorldCost, WorldCostMeter, type WorldCostReport, authorityRegionOf, capacityWalk, carryOnLift, carrySlot, carryTick, castWorld, comesBackAfter, compileContactWorld, connectAuthority, consumedUse, contactOf, contactPair, contactPass, contactPassOf, contactRuleOf, conveyorNudges, conveyorUnder, createPrivateAuthority, declaredContacts, farApart, fastLineAnnouncer, feedWithPayback, forgiveRepeats, frameOf, hasStand, headHold, headOffset, headSlab, headSlabs, headStands, impartSlot, impartTick, inLiftFrame, inputThrottle, inputTickField, inputTickLag, inputTickSlack, insideFace, insideWorld, isProjectile, joinPrivateAuthority, liftBodyKey, liftBodyPose, liftBodySpawn, liftCollider, liftDrawnAt, liftPose, liftPoses, liftPosesAt, liftStartsOf, liftTopAt, liftUnder, matchKeyOf, mayStand, measureAuthorityRegions, nextCodeRegion, normalizeAuthorityRegions, pcos, planAuthorityJoin, planAuthorityRegroup, planAuthoritySearch, planSuccessorJoin, posedFor, posedSolids, probeAuthorityRegions, projectileAt, propSlideNudges, psin, psincos, rankAuthorityRegions, reconcileThrough, reconcilerAck, reconcilerAckHold, refusalKind, regionProbePlan, rejoinStep, repeatMaxTicks, repeatRunTicks, repeatStarved, repeatsSeat, rideSlot, rideStep, rideTick, ridesOn, rodeBy, roomAlong, sameHeldInput, sanitizeInput, searchRefusalKind, seatClock, seatLeadClock, seatLiftsOf, seatOffset, seatRepeats, seatTauMs, seatTouchShare, seatUnderProp, selectAuthorityRegions, selectAuthoritySearch, selectMatchWorld, serverTick, shoveEase, spinStep, stateThrough, stepOnLifts, steppedThrough, surfaceUp, tagsOf, throttleState, throttleSteps, tickInstant, tickSolids, topRuleOf, udpLine, unstickBody, validMatchKey, validRoomCode, validSuccessorOf, validateInitOut, validateTickOut, viewOnLift, webSocketLine, worldCost, yieldShares };

package/dist/authority/index.js

@@ -6,7 +6,9 @@ import {
   claimToAxis
 } from "../chunk-TSYEWPVO.js";
 import {
+  AUTHORITY_MAX_PING_MS,
   AUTHORITY_REFUSALS_PER_REGION,
+  AUTHORITY_REGROUP_WAITS_MS,
   AuthorityBody,
   AuthorityEntity,
   AuthorityInput,
@@ -58,6 +60,7 @@ import {
   RULED_SLEW,
   RULED_SNAP_TICKS,
   RefusalKind,
+  RegionRule,
   RejoinStop,
   RejoinWay,
   SEAT_DRAWINGS,
@@ -69,6 +72,7 @@ import {
   STALL_PREDICT_MS,
   STEADY_BUCKETS,
   SUCCESSOR_OPEN_MS,
+  SearchRefusal,
   SeatContacts,
   SeatWorld,
   SlideWay,
@@ -78,6 +82,7 @@ import {
   UNSTICK_SOLIDS,
   WIRE_REST_MAX,
   WIRE_ROW_STRIDE,
+  authorityRegionOf,
   bodyRadiusOf,
   bodyStateOf,
   capacityWalk,
@@ -142,15 +147,19 @@ import {
   liftTopAt,
   liftUnder,
   mayStand,
+  measureAuthorityRegions,
   motorText,
   nextPredictSetSize,
   normalizeAuthorityRegions,
   parsePhysDesc,
   physDescText,
   physicsBudgetMs,
+  planAuthorityRegroup,
+  planAuthoritySearch,
   planSuccessorJoin,
   posedFor,
   posedSolids,
+  probeAuthorityRegions,
   propSlideNudges,
   proximityIslands,
   quatMul,
@@ -178,6 +187,7 @@ import {
   ruledPoseAt,
   sameBodyState,
   sameHeldInput,
+  searchRefusalKind,
   seatClock,
   seatLeadClock,
   seatLiftsOf,
@@ -189,6 +199,7 @@ import {
   seatTouchShare,
   seatUnderProp,
   selectAuthorityRegions,
+  selectAuthoritySearch,
   selfTestPredictCore,
   separateAround,
   separateDrawn,
@@ -217,8 +228,8 @@ import {
   wireRowOfState,
   writeWireRow,
   yieldShares
-} from "../chunk-MQYARUGU.js";
-import "../chunk-TEHGMFAG.js";
+} from "../chunk-I3DNVGGC.js";
+import "../chunk-BB6OIWQ2.js";
 import "../chunk-YWQ3ALYY.js";
 import {
   AcceptKind,
@@ -400,7 +411,7 @@ import {
   validRoomCode,
   validateInitOut,
   validateTickOut
-} from "../chunk-ZDGSUR6E.js";
+} from "../chunk-5WENVWVO.js";
 import {
   LeaveReason,
   MODULE_CONTRACT,
@@ -446,7 +457,7 @@ import {
   AUTHORITY_ROOM_ENDED_TEXT,
   AuthorityCloseCode,
   authorityCloseCodeOf
-} from "../chunk-WEMRRIHH.js";
+} from "../chunk-2CSX5WA6.js";
 
 // src/authority/world-cost.ts
 var WorldCost = {
@@ -518,7 +529,9 @@ function worldCost(spec, preset = "firstperson", params) {
   return { ...meter, solids: solids.length, steps, opsPerStep, accepted: opsPerStep <= WorldCost.MAX_OPS_PER_STEP };
 }
 export {
+  AUTHORITY_MAX_PING_MS,
   AUTHORITY_REFUSALS_PER_REGION,
+  AUTHORITY_REGROUP_WAITS_MS,
   AUTHORITY_ROOM_ENDED_TEXT,
   AcceptKind,
   AuthorityBody,
@@ -695,6 +708,7 @@ export {
   RULED_SLEW,
   RULED_SNAP_TICKS,
   RefusalKind,
+  RegionRule,
   RejoinStop,
   RejoinWay,
   RemotePredict,
@@ -708,6 +722,7 @@ export {
   STALL_PREDICT_MS,
   STEADY_BUCKETS,
   SUCCESSOR_OPEN_MS,
+  SearchRefusal,
   SeatContacts,
   SeatWorld,
   ShotWorldCost,
@@ -731,6 +746,7 @@ export {
   acceptUplink,
   applyBody,
   authorityCloseCodeOf,
+  authorityRegionOf,
   axisToClaim,
   blankEntityMotion,
   blankSeatEcho,
@@ -831,6 +847,7 @@ export {
   liftUnder,
   matchKeyOf,
   mayStand,
+  measureAuthorityRegions,
   motorText,
   nextCodeRegion,
   nextPredictSetSize,
@@ -847,12 +864,15 @@ export {
   physicsWorldDesc,
   physicsWorldPredicts,
   planAuthorityJoin,
+  planAuthorityRegroup,
+  planAuthoritySearch,
   planSuccessorJoin,
   posedFor,
   posedSolids,
   posedWorld,
   presetInputRepeat,
   presetParamsValid,
+  probeAuthorityRegions,
   projectileAt,
   propSlideNudges,
   proximityIslands,
@@ -897,6 +917,7 @@ export {
   sameBodyState,
   sameHeldInput,
   sanitizeInput,
+  searchRefusalKind,
   seatClock,
   seatLeadClock,
   seatLiftsOf,
@@ -908,6 +929,7 @@ export {
   seatTouchShare,
   seatUnderProp,
   selectAuthorityRegions,
+  selectAuthoritySearch,
   selectMatchWorld,
   selfTestPredictCore,
   separateAround,