@genex-ai/multiplayer 0.17.6 → 0.17.9

package/dist/authority/index.d.ts

@@ -1,11 +1,15 @@
+import { AuthorityCloseCode } from '../protocol.js';
+export { AUTHORITY_ROOM_ENDED_TEXT, authorityCloseCodeOf } from '../protocol.js';
 import * as _colyseus_schema from '@colyseus/schema';
 import { SchemaType } from '@colyseus/schema';
-import { T as TickHz, E as EntityData, J as Json, R as ResolvedModuleConfig, P as PlayerInfo, L as LeaveReason, I as InputData, a as PhysicsErrorCode, b as InputRepeat, c as LiftVec, C as ContactPolicy, H as HullBody, d as PosedSolid, e as Lift, f as LiftsPolicy, g as HullOps, h as PosedWorld, F as FirstpersonWorld, i as RemotePredict, S as StandRule, j as TopRule, k as PropSlide, l as ContactDrawing, m as FirstpersonWorldSpec } from '../module-DqtFb5wA.js';
-export { n as CONTACT_DEFAULTS, o as CONTACT_PAIRS_MAX, p as CONTACT_PASSES_MAX, q as CONTACT_PRESETS, r as CONTACT_TAG_MAX, s as CONTACT_VALUE_MAX, t as ContactConfigError, u as ContactDeclaration, v as ContactPreset, w as ContactPresetParams, x as ContactPush, y as ContactShape, z as ContactShapeKind, A as EMPTY_WORLD, B as EMPTY_WORLD_HASH, D as EntityApi, G as EntityInit, K as FIRSTPERSON_DEFAULTS, M as FirstpersonBody, N as FirstpersonInput, O as FirstpersonParams, Q as FirstpersonStep, U as GenexRoomModule, V as HeadFriction, W as INPUTS_DEFAULT, X as INPUT_PRESETS, Y as InitContext, Z as InputConfigError, _ as InputDeclaration, $ as InputPolicy, a0 as LIFTS_MAX, a1 as LIFT_ID_MAX, a2 as LIFT_POINTS_MAX, a3 as LIFT_SPIN_MIN_PERIOD, a4 as LIFT_TICKS_MAX, a5 as LIFT_VALUE_MAX, a6 as LiftEase, a7 as LiftImpart, a8 as LiftPath, a9 as LiftPathMode, aa as LiftShape, ab as LiftShapeKind, ac as LiftSpin, ad as LiftTooFast, ae as LiftsApi, af as LiftsConfigError, ag as MODULE_CONTRACT, ah as ModuleConfig, ai as MoveState, aj as NO_LIFTS, ak as NO_POSED, al as POSED_MAX, am as PRESETS, an as PRESET_MAX_DT_S, ao as PairRule, ap as PhysicsAnswer, aq as PhysicsApi, ar as PhysicsBodyDesc, as as PhysicsBodyState, at as PhysicsBodyType, au as PhysicsColliderDesc, av as PhysicsCommandResult, aw as PhysicsCommands, ax as PhysicsEvent, ay as PhysicsGroups, az as PhysicsHit, aA as PhysicsJointDesc, aB as PhysicsLimits, aC as PhysicsMotor, aD as PhysicsOverlap, aE as PhysicsPose, aF as PhysicsQueryFilter, aG as PhysicsRefusal, aH as PhysicsRequest, aI as PhysicsSetPoseOptions, aJ as PhysicsShape, aK as Preset, aL as PresetBody, aM as PresetDefinition, aN as PresetField, aO as PresetInput, aP as PresetName, aQ as PresetParamRange, aR as PresetSpec, aS as ProjectileApi, aT as ProjectileField, aU as ProjectileFlight, aV as ProjectileHit, aW as ProjectileInit, aX as Quat, aY as ResolvedPhysics, aZ as RewindApi, a_ as RoomContext, a$ as SHOOTER_CENTER, b0 as SlideRule, b1 as TOPDOWN_DEFAULTS, b2 as TopPolicy, b3 as TopdownBody, b4 as TopdownInput, b5 as TopdownParams, b6 as VEHICLE_DEFAULTS, b7 as Vec3, b8 as VehicleBody, b9 as VehicleInput, ba as VehicleParams, bb as VehicleStep, bc as WorldBox, bd as WorldError, be as WorldLimits, bf as WorldRamp, bg as defineRoom, bh as definitionOf, bi as firstpersonWorld, bj as hullOps, bk as isLiftId, bl as isPresetName, bm as posedWorld, bn as presetInputRepeat, bo as presetParamsValid, bp as resolveContactConfig, bq as resolveFirstpersonParams, br as resolveInputConfig, bs as resolveLifts, bt as resolvePresetParams, bu as resolveTopdownParams, bv as resolveVehicleParams, bw as stepFirstperson, bx as stepPreset, by as stepTopdown, bz as stepVehicle } from '../module-DqtFb5wA.js';
-import { P as PhysicsCeiling, a as PhysEvRow, b as PhysAnswerRow, c as PhysBodyRow, d as PredictStatus, C as ContactBody, R as RemoteInput, A as AuthorityContactRule, e as AuthoritySeatRule, f as PredictCore, g as PredictBodyRule, h as PredictKinematicRule } from '../physics-predict-49udN3a1.js';
-export { i as AdoptReport, B as BODY_CORRECTION_TAU_MS, j as BODY_EXTRAPOLATE_BACK_TICKS, k as BODY_EXTRAPOLATE_MAX_MS, l as BODY_SNAP_METRES, m as BodyDrawing, n as BodyFields, o as BodyPose, p as BodyQuantization, q as BodySnap, r as BodyState, s as CONTACT_FIELDS, t as ContactField, D as DrawClock, u as DrawHandoff, v as DrawQuat, w as DrawVec3, H as HOST_BODY_FIELDS, I as ISLAND_MARGIN_METRES, x as IslandBody, K as KeyframeBody, y as KeyframeJoint, z as KeyframeOutside, E as KeyframeSeat, O as OwnPoseOf, F as PHYSICS_BODY_FIELDS, G as PHYSICS_CEILING_FACTOR, J as PHYSICS_CONTESTED_METRES, L as PHYSICS_CONTRACT, M as PHYSICS_DEFAULT_CEILING, N as PHYSICS_DEFAULT_LIMITS, Q as PHYSICS_DEFAULT_PATCH_HZ, S as PHYSICS_FULL_RATE_BODIES, T as PHYSICS_KEY_MAX_BYTES, U as PHYSICS_KIND_MAX_BYTES, V as PHYSICS_LIMIT_NAMES, W as PHYSICS_OVERLAP_MAX_KEYS, X as PHYSICS_PATCH_HZ, Y as PHYSICS_PREDICT_MAX_ANGULAR, Z as PHYSICS_PREDICT_MAX_LINEAR, _ as PHYSICS_PREDICT_MIN_ITERATIONS, $ as PHYSICS_PRESET_LENGTH_UNITS, a0 as PHYSICS_REAL_LIMITS, a1 as PHYSICS_ROTATING_BODIES, a2 as PHYSICS_SCALED_LIMITS, a3 as PHYSICS_SHAPES_MAX, a4 as PHYSICS_SHAPE_MAX_CHARS, a5 as PHYSICS_STATIC_PREFIX, a6 as PHYSICS_SUBSTEPS, a7 as PHYS_BUDGET_CALM_SHARE, a8 as PHYS_BUDGET_MIN_SAMPLES, a9 as PHYS_BUDGET_P90_FACTOR, aa as PHYS_BUDGET_WINDOW, ab as PHYS_CANARY_MAX_MISMATCH, ac as PHYS_CANARY_MIN_SAMPLES, ad as PHYS_CANARY_WINDOW, ae as PHYS_CPU_CALM_PROBES, af as PHYS_CPU_PROBE_MS, ag as PHYS_PREDICT_HASHES_KEPT, ah as PHYS_PREDICT_SET_SIZES, ai as PHYS_RESIM_BUDGET_MS, aj as PairPush, ak as PhysDesc, al as PhysDescPredict, am as PhysEvContactBegin, an as PhysEvKind, ao as PhysEvOther, ap as PhysHitRow, aq as PhysOverlapRow, ar as PhysicsBodyField, as as PhysicsConfigRange, at as PhysicsPredictRange, au as PhysicsPredictor, av as PhysicsResolution, aw as PhysicsWorldDesc, ax as PredictKeyframe, ay as PredictLifts, az as PredictResult, aA as PredictSmoothing, aB as PredictWorld, aC as PredictorOptions, aD as PresetBodyShape, aE as QuantizedRange, aF as RULED_SLEW, aG as RULED_SNAP_TICKS, aH as RemoteStep, aI as RuleSeat, aJ as RuleTick, aK as RuleVelocity, aL as SEAT_LIFT_MAX, aM as SEAT_PAIR_EASE, aN as SEAT_ROUND_RATE, aO as SHAPE_REF_KINDS, aP as SeatContacts, aQ as SeatSide, aR as WIRE_REST_MAX, aS as WIRE_ROW_STRIDE, aT as WireBodyState, aU as WireFields, aV as bodyRadiusOf, aW as bodyStateOf, aX as checkResolvedPhysics, aY as clampedVelocity, aZ as correctionAt, a_ as correctionShare, a$ as correctionTauMs, b0 as decayedInput, b1 as dequantizeBodyValue, b2 as drawBody, b3 as effectivePatchHz, b4 as extrapolateBody, b5 as extrapolationSeconds, b6 as inlineShapes, b7 as innerDtOf, b8 as isPhysicsKey, b9 as isPhysicsKind, ba as isPhysicsPatchHz, bb as keyframeTicks, bc as liftOff, bd as motorText, be as nextPredictSetSize, bf as parsePhysDesc, bg as physDescText, bh as physicsBudgetMs, bi as physicsCeilingValid, bj as physicsLimitsAt, bk as physicsWorldDesc, bl as proximityIslands, bm as quantizeBodyValue, bn as quatMul, bo as quatNormalize, bp as receiveBodyState, bq as remoteInputWeight, br as resolvePhysicsConfig, bs as restStepsOf, bt as ruledPoseAt, bu as sameBodyState, bv as seatPairKey, bw as seatRuleTick, bx as selfTestPredictCore, by as separateAround, bz as separateDrawn, bA as separateSeats, bB as slerpFromIdentity, bC as snapMetresOf, bD as solverIterationsOf, bE as wasmSimdSupported, bF as wireFieldsOf, bG as wireRowOfExport, bH as wireRowOfState, bI as writeWireRow } from '../physics-predict-49udN3a1.js';
-import { b as FastFallbackReason, F as FastSocketOpener } from '../fast-client-CZ41v-oB.js';
-export { A as AcceptKind, c as AcceptOptions, d as AcceptResult, e as AcceptedInput, C as ClientRx, E as EntityMotion, f as FAST_GAP_FILL_MS, g as FAST_HANDSHAKE_MS, h as FAST_KEY_BYTES, i as FAST_MAX_ACTIONS, j as FAST_MAX_DATAGRAM_BYTES, k as FAST_MAX_FRAGMENTS, l as FAST_MAX_RECORD_BYTES, m as FAST_REASSEMBLY_SLOTS, n as FAST_SEQ_AHEAD_MS, o as FAST_SNAPSHOT_HISTORY, p as FAST_STALL_FALLBACK_MS, q as FAST_VERSION, a as FastBindMessage, r as FastBinding, s as FastClient, t as FastClientOptions, u as FastDatagramSocket, v as FastFault, w as FastInput, x as FastKind, y as FastMessage, z as FastOffMessage, B as FastReceipt, D as FastResult, G as FastSnapshot, H as FastWebTransport, I as Fragment, J as HeldSnapshot, K as INPUT_REDUNDANCY_MAX, L as INPUT_REDUNDANCY_MIN, M as INPUT_REDUNDANCY_MS, N as MotionRecord, O as MotionRecordKind, P as PartialSnapshot, R as RECORD_ID_MAX_CHARS, Q as ReceiveResult, S as Records, T as SeatEcho, U as SeatRx, V as SnapshotBody, W as SnapshotHead, X as Uplink, Y as UplinkOptions, Z as acceptUplink, _ as applyBody, $ as blankEntityMotion, a0 as blankSeatEcho, a1 as decodeFragment, a2 as decodeRecord, a3 as decodeUplink, a4 as deltaBase, a5 as dequantizeCode, a6 as diffSnapshot, a7 as emptyClientRx, a8 as encodeRecord, a9 as encodeSnapshot, aa as encodeUplink, ab as fromHex, ac as gapFillMax, ad as heldInputs, ae as inputRedundancyTicks, af as isFastBind, ag as isPress, ah as openFastClient, ai as parseBody, aj as quantizeCode, ak as receiveFragment, al as renderStamp, am as seqAheadMax, an as toHex, ao as uplinkFor, ap as uplinkMaxBytes } from '../fast-client-CZ41v-oB.js';
+import { T as TickHz, E as EntityData, J as Json, R as ResolvedModuleConfig, P as PlayerInfo, L as LeaveReason, I as InputData, a as PhysicsErrorCode, b as InputRepeat, c as LiftVec, C as ContactPolicy, d as Lift, e as LiftsPolicy, f as RemotePredict, S as StandRule, g as TopRule, h as PropSlide, i as ContactDrawing } from '../module-CSpXrzFc.js';
+export { A as AuthorityLifetime, j as CONTACT_DEFAULTS, k as CONTACT_PAIRS_MAX, l as CONTACT_PASSES_MAX, m as CONTACT_PRESETS, n as CONTACT_TAG_MAX, o as CONTACT_VALUE_MAX, p as ContactConfigError, q as ContactDeclaration, r as ContactPreset, s as ContactPresetParams, t as ContactPush, u as ContactShape, v as ContactShapeKind, w as EntityApi, x as EntityInit, G as GenexRoomModule, H as HeadFriction, y as INPUTS_DEFAULT, z as INPUT_PRESETS, B as INPUT_SETTLE_MS, D as InitContext, F as InputConfigError, K as InputDeclaration, M as InputPolicy, N as LIFETIME_DEFAULT, O as LIFTS_MAX, Q as LIFT_ID_MAX, U as LIFT_POINTS_MAX, V as LIFT_SPIN_MIN_PERIOD, W as LIFT_TICKS_MAX, X as LIFT_VALUE_MAX, Y as LifetimeConfigError, Z as LifetimeDeclaration, _ as LifetimePolicy, $ as LiftEase, a0 as LiftImpart, a1 as LiftPath, a2 as LiftPathMode, a3 as LiftShape, a4 as LiftShapeKind, a5 as LiftSpin, a6 as LiftTooFast, a7 as LiftsApi, a8 as LiftsConfigError, a9 as MODULE_CONTRACT, aa as ModuleConfig, ab as NO_LIFTS, ac as PairRule, ad as PhysicsAnswer, ae as PhysicsApi, af as PhysicsBodyDesc, ag as PhysicsBodyState, ah as PhysicsBodyType, ai as PhysicsColliderDesc, aj as PhysicsCommandResult, ak as PhysicsCommands, al as PhysicsEvent, am as PhysicsGroups, an as PhysicsHit, ao as PhysicsJointDesc, ap as PhysicsLimits, aq as PhysicsMotor, ar as PhysicsOverlap, as as PhysicsPose, at as PhysicsQueryFilter, au as PhysicsRefusal, av as PhysicsRequest, aw as PhysicsSetPoseOptions, ax as PhysicsShape, ay as PresetSpec, az as ProjectileApi, aA as ProjectileField, aB as ProjectileFlight, aC as ProjectileHit, aD as ProjectileInit, aE as Quat, aF as ResolvedPhysics, aG as RewindApi, aH as RewoundPose, aI as RoomContext, aJ as SHOOTER_CENTER, aK as ShotWorldSpec, aL as SlideRule, aM as TopPolicy, aN as Vec3, aO as WorldApi, aP as WorldClaim, aQ as WorldClaimOptions, aR as WorldRayHit, aS as WorldRayOptions, aT as defineRoom, aU as isLiftId, aV as presetInputRepeat, aW as resolveContactConfig, aX as resolveInputConfig, aY as resolveLifetime, aZ as resolveLifts } from '../module-CSpXrzFc.js';
+import { P as PhysicsCeiling, a as PhysEvRow, b as PhysAnswerRow, c as PhysBodyRow, d as PredictStatus, C as ContactBody, R as RemoteInput, A as AuthorityContactRule, e as AuthoritySeatRule, f as PredictCore, g as PredictBodyRule, h as PredictKinematicRule } from '../physics-predict-C7ZB1gDG.js';
+export { i as AdoptReport, B as BODY_CORRECTION_TAU_MS, j as BODY_EXTRAPOLATE_BACK_TICKS, k as BODY_EXTRAPOLATE_MAX_MS, l as BODY_SNAP_METRES, m as BodyDrawing, n as BodyFields, o as BodyPose, p as BodyQuantization, q as BodySnap, r as BodyState, s as CONTACT_FIELDS, t as ContactField, D as DrawClock, u as DrawHandoff, v as DrawQuat, w as DrawVec3, H as HOST_BODY_FIELDS, I as ISLAND_MARGIN_METRES, x as IslandBody, K as KeyframeBody, y as KeyframeJoint, z as KeyframeOutside, E as KeyframeSeat, O as OwnPoseOf, F as PHYSICS_BODY_FIELDS, G as PHYSICS_CEILING_FACTOR, J as PHYSICS_CONTESTED_METRES, L as PHYSICS_CONTRACT, M as PHYSICS_DEFAULT_CEILING, N as PHYSICS_DEFAULT_LIMITS, Q as PHYSICS_DEFAULT_PATCH_HZ, S as PHYSICS_FULL_RATE_BODIES, T as PHYSICS_KEY_MAX_BYTES, U as PHYSICS_KIND_MAX_BYTES, V as PHYSICS_LIMIT_NAMES, W as PHYSICS_OVERLAP_MAX_KEYS, X as PHYSICS_PATCH_HZ, Y as PHYSICS_PREDICT_MAX_ANGULAR, Z as PHYSICS_PREDICT_MAX_BOXES, _ as PHYSICS_PREDICT_MAX_LINEAR, $ as PHYSICS_PREDICT_MAX_RAMPS, a0 as PHYSICS_PREDICT_MIN_ITERATIONS, a1 as PHYSICS_PRESET_LENGTH_UNITS, a2 as PHYSICS_REAL_LIMITS, a3 as PHYSICS_ROTATING_BODIES, a4 as PHYSICS_SCALED_LIMITS, a5 as PHYSICS_SHAPES_MAX, a6 as PHYSICS_SHAPE_MAX_CHARS, a7 as PHYSICS_STATIC_PIECE_BYTES, a8 as PHYSICS_STATIC_PREFIX, a9 as PHYSICS_SUBSTEPS, aa as PHYS_BUDGET_CALM_SHARE, ab as PHYS_BUDGET_MIN_SAMPLES, ac as PHYS_BUDGET_P90_FACTOR, ad as PHYS_BUDGET_WINDOW, ae as PHYS_CANARY_MAX_MISMATCH, af as PHYS_CANARY_MIN_SAMPLES, ag as PHYS_CANARY_WINDOW, ah as PHYS_CPU_CALM_PROBES, ai as PHYS_CPU_PROBE_MS, aj as PHYS_PREDICT_HASHES_KEPT, ak as PHYS_PREDICT_SET_SIZES, al as PHYS_RESIM_BUDGET_MS, am as PairPush, an as PhysDesc, ao as PhysDescPredict, ap as PhysEvContactBegin, aq as PhysEvKind, ar as PhysEvOther, as as PhysHitRow, at as PhysOverlapRow, au as PhysicsBodyField, av as PhysicsConfigRange, aw as PhysicsPredictRange, ax as PhysicsPredictor, ay as PhysicsResolution, az as PhysicsWorldDesc, aA as PredictKeyframe, aB as PredictLifts, aC as PredictResult, aD as PredictSmoothing, aE as PredictWorld, aF as PredictorOptions, aG as PresetBodyShape, aH as QuantizedRange, aI as RULED_SLEW, aJ as RULED_SNAP_TICKS, aK as RemoteStep, aL as RuleSeat, aM as RuleTick, aN as RuleVelocity, aO as SEAT_LIFT_MAX, aP as SEAT_PAIR_EASE, aQ as SEAT_ROUND_RATE, aR as SHAPE_REF_KINDS, aS as SeatContacts, aT as SeatSide, aU as WIRE_REST_MAX, aV as WIRE_ROW_STRIDE, aW as WireBodyState, aX as WireFields, aY as bodyRadiusOf, aZ as bodyStateOf, a_ as checkResolvedPhysics, a$ as clampedVelocity, b0 as correctionAt, b1 as correctionShare, b2 as correctionTauMs, b3 as decayedInput, b4 as dequantizeBodyValue, b5 as drawBody, b6 as effectivePatchHz, b7 as extrapolateBody, b8 as extrapolationSeconds, b9 as inlineShapes, ba as innerDtOf, bb as isPhysicsKey, bc as isPhysicsKind, bd as isPhysicsPatchHz, be as keyframeTicks, bf as liftOff, bg as motorText, bh as nextPredictSetSize, bi as parsePhysDesc, bj as physDescText, bk as physicsBudgetMs, bl as physicsCeilingValid, bm as physicsLimitsAt, bn as physicsLimitsForWorld, bo as physicsWorldDesc, bp as physicsWorldPredicts, bq as proximityIslands, br as quantizeBodyValue, bs as quatMul, bt as quatNormalize, bu as receiveBodyState, bv as remoteInputWeight, bw as resolvePhysicsConfig, bx as restStepsOf, by as ruledPoseAt, bz as sameBodyState, bA as seatPairKey, bB as seatRuleTick, bC as selfTestPredictCore, bD as separateAround, bE as separateDrawn, bF as separateSeats, bG as slerpFromIdentity, bH as snapMetresOf, bI as solverIterationsOf, bJ as wasmSimdSupported, bK as wireFieldsOf, bL as wireRowOfExport, bM as wireRowOfState, bN as writeWireRow } from '../physics-predict-C7ZB1gDG.js';
+import { S as ShotWorldCount, W as WorldCostMeter, P as PresetName, H as HullBody, a as PosedSolid, b as HullOps, c as PosedWorld, F as FirstpersonWorld, d as FirstpersonWorldSpec } from '../shot-world-D22tqOUT.js';
+export { C as ClaimVerdict, E as EMPTY_WORLD, e as EMPTY_WORLD_HASH, f as FIRSTPERSON_DEFAULTS, g as FirstpersonBody, h as FirstpersonInput, i as FirstpersonParams, j as FirstpersonStep, M as MoveState, N as NO_POSED, k as POSED_MAX, l as PRESETS, m as PRESET_MAX_DT_S, n as Preset, o as PresetBody, p as PresetDefinition, q as PresetField, r as PresetInput, s as PresetParamRange, t as ShotWorldCost, T as TOPDOWN_DEFAULTS, u as TREE_KEY_RADIX, v as TopdownBody, w as TopdownInput, x as TopdownParams, V as VEHICLE_DEFAULTS, y as VehicleBody, z as VehicleInput, A as VehicleParams, B as VehicleStep, D as WorldBox, G as WorldError, I as WorldKey, J as WorldLimits, K as WorldRamp, L as axisToClaim, O as claimToAxis, Q as definitionOf, R as firstpersonWorld, U as hullOps, X as isPresetName, Y as posedWorld, Z as presetParamsValid, _ as resolveFirstpersonParams, $ as resolvePresetParams, a0 as resolveTopdownParams, a1 as resolveVehicleParams, a2 as stepFirstperson, a3 as stepPreset, a4 as stepTopdown, a5 as stepVehicle, a6 as withWorldCostMeter, a7 as worldTreeOrder } from '../shot-world-D22tqOUT.js';
+import { a as FastFallbackReason, F as FastSocketOpener } from '../fast-client--A88q0kk.js';
+export { A as AcceptKind, c as AcceptOptions, d as AcceptResult, e as AcceptedInput, C as ClientRx, E as EntityMotion, f as FAST_ACK_EAGER_GAP_MS, g as FAST_ACK_EAGER_RECORDS, h as FAST_BIND_REV, i as FAST_CHALLENGE_JUMP, j as FAST_FRAME_GAP_MS, k as FAST_GAP_FILL_MS, l as FAST_HANDSHAKE_MS, m as FAST_KEEPALIVE_BIND_MS, n as FAST_KEEPALIVE_MS, o as FAST_KEY_BYTES, p as FAST_MAX_ACTIONS, q as FAST_MAX_DATAGRAM_BYTES, r as FAST_MAX_FRAGMENTS, s as FAST_MAX_RECORD_BYTES, t as FAST_OPEN_ROUND_TRIPS, u as FAST_REASSEMBLY_SLOTS, v as FAST_RETRY_BASE_MS, w as FAST_RETRY_MAX_MS, x as FAST_RETURN_PROOF, y as FAST_RETURN_STABLE_MS, z as FAST_SEQ_AHEAD_MS, B as FAST_SNAPSHOT_HISTORY, D as FAST_STALL_FALLBACK_MS, G as FAST_VERSION, b as FastBindMessage, H as FastBinding, I as FastClient, J as FastClientOptions, K as FastDatagramSocket, L as FastFault, M as FastInput, N as FastKind, O as FastMessage, P as FastOffMessage, Q as FastOnMessage, R as FastReceipt, S as FastResult, T as FastSnapshot, U as FastWebTransport, V as Fragment, W as HeldSnapshot, X as INPUT_REDUNDANCY_MAX, Y as INPUT_REDUNDANCY_MIN, Z as INPUT_REDUNDANCY_MS, _ as MotionRecord, $ as MotionRecordKind, a0 as PartialSnapshot, a1 as RECORD_ID_MAX_CHARS, a2 as ReceiveResult, a3 as Records, a4 as SeatEcho, a5 as SeatRx, a6 as SnapshotBody, a7 as SnapshotHead, a8 as Uplink, a9 as UplinkOptions, aa as acceptUplink, ab as applyBody, ac as blankEntityMotion, ad as blankSeatEcho, ae as decodeFragment, af as decodeRecord, ag as decodeUplink, ah as deltaBase, ai as dequantizeCode, aj as diffSnapshot, ak as emptyClientRx, al as encodeRecord, am as encodeSnapshot, an as encodeUplink, ao as fastRetryDelayMs, ap as fromHex, aq as gapFillMax, ar as heldInputs, as as inputRedundancyTicks, at as isFastBind, au as isPress, av as openFastClient, aw as parseBody, ax as quantizeCode, ay as receiveFragment, az as renderStamp, aA as seqAheadMax, aB as toHex, aC as uplinkFor, aD as uplinkMaxBytes } from '../fast-client--A88q0kk.js';
 import { A as AuthSource } from '../join-CGoInvUM.js';
 
 /** The Colyseus view tag on an entity's motion fields in a physics room's state (PROTOCOL.md §17.12
@@ -315,6 +319,7 @@ declare const AuthorityRoomState: _colyseus_schema.SchemaWithExtendsConstructor<
         motor: string;
     } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
     lifts: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    matchKey: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
 }, _colyseus_schema.BuilderInitProps<{
     players: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
         name: string;
@@ -395,6 +400,7 @@ declare const AuthorityRoomState: _colyseus_schema.SchemaWithExtendsConstructor<
         motor: string;
     } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
     lifts: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    matchKey: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
 }>, typeof _colyseus_schema.Schema>;
 type AuthorityRoomState = SchemaType<typeof AuthorityRoomState>;
 declare const AuthorityPhysicsRoomState: _colyseus_schema.SchemaWithExtendsConstructor<{
@@ -477,6 +483,7 @@ declare const AuthorityPhysicsRoomState: _colyseus_schema.SchemaWithExtendsConst
         motor: string;
     } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
     lifts: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    matchKey: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
 }, _colyseus_schema.BuilderInitProps<{
     entities: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
         kind: string;
@@ -557,6 +564,7 @@ declare const AuthorityPhysicsRoomState: _colyseus_schema.SchemaWithExtendsConst
         motor: string;
     } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
     lifts: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    matchKey: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
 }>, typeof _colyseus_schema.Schema>;
 type AuthorityPhysicsRoomState = SchemaType<typeof AuthorityPhysicsRoomState>;
 
@@ -566,11 +574,15 @@ declare const GuestGlobal: {
     readonly TICK: "__genex_tick";
     /** A physics room's static world, called once after init (§17.10 *The static world*). */
     readonly WORLD: "__genex_world";
+    /** The room's hand-off at the end of a drain (PROTOCOL.md §17.13), called once. */
+    readonly HANDOFF: "__genex_handoff";
 };
 /** Wire limits. Sizes are JS string lengths (UTF-16 code units), as everywhere in the protocol. */
 declare const AuthorityLimits: {
     /** Entities one tick may update, and separately remove. */
     readonly MAX_ENTITIES: 256;
+    /** A room's hand-off (`onDrain`, PROTOCOL.md §17.13) as JSON text. Over it the successor starts clean. */
+    readonly MAX_HANDOFF_CHARS: number;
     /** Entities one room may hold at once. The room state lives on the host, outside the sandbox's
      *  memory limit, so this cap is what bounds it (and every client's patches). */
     readonly MAX_ROOM_ENTITIES: 1024;
@@ -613,8 +625,12 @@ declare const AuthorityLimits: {
     readonly MAX_PHYS_COMMANDS: 256;
     readonly MAX_PHYS_BYTES: number;
     readonly MAX_PHYSICS_OUTPUT_BYTES: number;
-    /** `__genex_world()`'s text: base64 of the largest §17.7 world, 4 · ⌈(8 + 24 · 4096 + 36 · 512) / 3⌉. */
-    readonly MAX_WORLD_TEXT_CHARS: 155660;
+    /** The most a physics room's static world holds (§17.10 *The static world*): §17.7's caps, so any world a
+     *  module may carry has its physics core. `limits.staticPieces` follows a world past its default. */
+    readonly MAX_PHYSICS_WORLD_BOXES: 32768;
+    readonly MAX_PHYSICS_WORLD_RAMPS: 4096;
+    /** `__genex_world()`'s text: base64 of the largest such world, 4 · ⌈(8 + 24 · 32768 + 36 · 4096) / 3⌉. */
+    readonly MAX_WORLD_TEXT_CHARS: 1245196;
 };
 /** Every tick rate a module may ask for; 120 only with physics (§17.11). */
 declare const TICK_RATES: readonly TickHz[];
@@ -639,6 +655,8 @@ declare const TickOutFault: {
     readonly TOO_MANY_EVENTS: "too_many_events";
     readonly RESERVED_EVENT: "reserved_event";
     readonly BAD_CONFIG: "bad_config";
+    /** The module's maps leave a room without a shot world (§17.7 *The shot world*). */
+    readonly NO_SHOT_WORLD: "no_shot_world";
     /** More `phys` commands than MAX_PHYS_COMMANDS, or more `physQ` queries than `queriesPerStep`. */
     readonly TOO_MANY_COMMANDS: "too_many_commands";
 };
@@ -665,7 +683,9 @@ type InputUse = (typeof InputUse)[keyof typeof InputUse];
  *  fed to the module; `cseq` is the input's CLIENT sequence (Colyseus's `ackSeq` once the host has
  *  consumed it: the seat's inputs counted from 1, the number a client keys a predicted projectile
  *  by, §17.9). `seen` is the sender's lag-comp snapshot: entity id → [x, y, z] as that player saw it
- *  (present only for inputs that match `lagComp.buttons`). `use` is how the tick uses it
+ *  (present only for inputs that match `lagComp.buttons`). `seenPose` rides beside it: entity id →
+ *  [yaw, duck] as that player saw it, for the entities that faced or ducked otherwise than they do
+ *  now (`ctx.rewind.pose`); a snapshot without it reads every entity's as the tick began. `use` is how the tick uses it
  *  ({@link InputUse}; absent = `step`): a repeat carries the seat's last real input with that
  *  input's `seq` and `cseq`, never a `seen`. */
 interface TickInput {
@@ -674,6 +694,7 @@ interface TickInput {
     cseq: number;
     i: InputData;
     seen?: Record<string, [number, number, number]>;
+    seenPose?: Record<string, [number, number]>;
     use?: InputUse;
     /** How many ticks later than its client meant the input is applied (negative: earlier), when its
      *  seat sends `tick@1` and the two differ (§17.11 *The input's tick*); absent: 0. */
@@ -740,6 +761,12 @@ interface TickOut {
  *  physics room's carries `phys` (applied at load) and never `physQ`. */
 interface InitOut extends TickOut {
     config: ResolvedModuleConfig;
+    /** The names of the module's `worlds` map (§17.2 *Choosing a room*), when it has one. */
+    worlds?: string[];
+    /** What the load counted of the module's shot world (§17.7 *The shot world*), when it has one. */
+    shotWorld?: ShotWorldCount;
+    /** How the module's maps leave a room without a shot world: the validator refuses it as `no_shot_world`. */
+    noShotWorld?: string;
 }
 /** What the host passes `validateTickOut` in a physics room. */
 interface PhysicsTickIndex {
@@ -784,10 +811,6 @@ declare function sanitizeInput(raw: Record<string, unknown>): InputData;
  *  room, §17.10) it reads `phys` and `physQ` and the body-entity rules; without, those keys are
  *  unknown and dropped. */
 declare function validateTickOut(raw: unknown, room?: EntityIndex, physics?: PhysicsTickIndex): WireResult<TickOut>;
-/** Validates the `__genex_init` result: every TickOut rule plus a well-formed resolved config.
- *  `physics`: the room was admitted with physics (its ceiling); the resolved config must then ask
- *  for physics within it, its `phys` is read and a `physQ` refused. Without it, a config that asks
- *  for physics is a bad config. */
 declare function validateInitOut(raw: unknown, physics?: PhysicsAdmission): WireResult<InitOut>;
 
 /** Repeats owed at most, as time (shared/duration units: ms); {@link repeatMaxTicks} in ticks. */
@@ -933,6 +956,112 @@ declare function seatLeadClock(stepped: number, drawn: number, t: InputThrottle,
  *  real time at a time, each input sent once half of its step has been paid. */
 declare function throttleSteps(t: InputThrottle, dtMs: number, stepMs: number): number;
 
+/** The walk, and what it may cost. */
+declare const WorldCost: {
+    /** What a step may average, in weighted operations: below the least count of any world that ended a room, ten seats on a c2-standard-4
+     *  (micro 8,192 at 5,318, one run of two: integration cw/vm1). A warning to a creator, and a coarse one: bodies are walked from seeded
+     *  solids, so a world that holds its cost where its module really spawns seats reads low (a cell 2.5 times, dense tiles 3), and one built to
+     *  dodge the walk reads nothing. The sandbox's mean budget and CPU limits are what protect a host. */
+    readonly MAX_OPS_PER_STEP: 5000;
+    /** What each kind of operation costs against a tree entry, c2-standard-4, offline: an entry 4.9 ns, an exact test 36, a wedge's sweep test
+     *  382. A slab's sweep test has no weight of its own: it comes with exact tests in every world measured, three to one. */
+    readonly TEST_WEIGHT: 7;
+    readonly WEDGE_WEIGHT: 78;
+    /** The seats {@link WorldCost.MAX_OPS_PER_STEP} is sized for. */
+    readonly SEATS: 10;
+    /** Bodies walking, and the ticks each walks. */
+    readonly WALKERS: 16;
+    readonly TICKS: 120;
+    readonly SEED: 2026;
+    /** The step's dt: 30 Hz, the rate most rooms run. */
+    readonly DT: number;
+    /** Where a body starts above the top of the solid it is dropped on. */
+    readonly DROP: 1;
+    /** A body's chance a tick to turn, jump and duck. */
+    readonly TURN_CHANCE: 0.03;
+    readonly JUMP_CHANCE: 0.04;
+    readonly DUCK_CHANCE: 0.05;
+};
+/** What {@link worldCost} counted. */
+interface WorldCostReport extends WorldCostMeter {
+    solids: number;
+    /** Steps walked. */
+    steps: number;
+    /** The operations, weighted by kind, a step on average, rounded down. */
+    opsPerStep: number;
+    /** Whether `opsPerStep` is within {@link WorldCost.MAX_OPS_PER_STEP}. */
+    accepted: boolean;
+}
+/**
+ * The cost of `spec` to a room of `preset` (firstperson's or vehicle's), with `params` as the module gives
+ * them. Bodies start on seeded solids, so a world cannot hide its dense part behind where it says bodies
+ * spawn, and a solid is as likely a start as any: where a bake spent its solids is where the bodies are.
+ */
+declare function worldCost(spec: unknown, preset?: PresetName, params?: unknown): WorldCostReport;
+
+/** The bounds of §17.2 *Choosing a room*. */
+declare const AuthorityRoomLimits: {
+    /** A match key's longest length. */
+    readonly MAX_MATCH_KEY_CHARS: 32;
+    /** A room code's longest length (Colyseus's room ids are 9). */
+    readonly MAX_CODE_CHARS: 32;
+    /** The most named worlds one module's `worlds` map may hold. */
+    readonly MAX_WORLDS: 16;
+};
+/** Whether `value` is a match key: 1 to 32 characters of a-z 0-9 . _ : -, a letter or digit first. */
+declare function validMatchKey(value: unknown): value is string;
+/** Whether `value` is a room code: 1 to 32 characters of A-Z a-z 0-9 _ -. A code goes into a url. */
+declare function validRoomCode(value: unknown): value is string;
+/** A join's `matchKey` option as the pool it names: '' for no key (absent or empty), null when it is
+ *  malformed (refused with 400). */
+declare function matchKeyOf(value: unknown): string | null;
+/** The ways into an authority room, by the Colyseus call that makes them. */
+declare const AuthorityJoinMethod: {
+    readonly JoinOrCreate: "joinOrCreate";
+    readonly Create: "create";
+    readonly JoinById: "joinById";
+};
+type AuthorityJoinMethod = (typeof AuthorityJoinMethod)[keyof typeof AuthorityJoinMethod];
+/** Why a client refuses a target before anything reaches the network. */
+declare const AuthorityTargetRefusal: {
+    readonly BadMatchKey: "bad_match_key";
+    readonly BadCode: "bad_code";
+    readonly Conflict: "conflict";
+};
+type AuthorityTargetRefusal = (typeof AuthorityTargetRefusal)[keyof typeof AuthorityTargetRefusal];
+/** Which room a client asks for: a pool (`matchKey`), a new private room, or a room by its code. */
+interface AuthorityRoomTarget {
+    /** The pool to join, or the key of the private room to create. */
+    matchKey?: string;
+    /** Create a private room. */
+    createPrivate?: boolean;
+    /** Join the room with this code. */
+    code?: string;
+}
+/** The Colyseus call a target makes, and the options it adds to the join's own. */
+type AuthorityJoinPlan = {
+    method: AuthorityJoinMethod;
+    roomId?: string;
+    options: {
+        matchKey?: string;
+        private?: true;
+        successorOf?: string;
+        successorClosed?: true;
+    };
+} | {
+    refused: AuthorityTargetRefusal;
+};
+/** What `target` sends. Nothing asked sends nothing new, so a game that names no room joins as it
+ *  always has. A code names one room, whose key is its own: a key or a create beside it is a mistake. */
+declare function planAuthorityJoin(target: AuthorityRoomTarget): AuthorityJoinPlan;
+/** The region a join by code tries after refusal `error` on region `region` of `regions`, or null
+ *  when the refusal is final: only another region can hold a room this one refused as elsewhere. */
+declare function nextCodeRegion(error: unknown, region: number, regions: number): number | null;
+/** The world a room with match key `key` runs, as the sandbox picks it: the `worlds` entry the key
+ *  names, else `world` (absent: the empty world). A client calls this with the module's own map and
+ *  hands the result to `setWorld`, so its hash is the room's and prediction runs. */
+declare function selectMatchWorld<W>(worlds: Readonly<Record<string, W>> | undefined, world: W | undefined, key: string): W | undefined;
+
 /** What `physicsPrediction` reports. */
 interface PhysicsPredictionStatus {
     status: PredictStatus;
@@ -999,23 +1128,26 @@ declare function tickInstant(tick: number, tickOrigin: number, tickHz: number):
 type V3 = readonly [number, number, number];
 /** One face of a grown solid: a point p is inside it when `n · p < e` (n of unit length). */
 type Plane = readonly [number, number, number, number];
-/** A grown solid: its planes (a box's six, a ramp's seven, the bottom last) and its bounds. */
-interface ContactSolid {
-    readonly planes: readonly Plane[];
-    readonly min: V3;
-    readonly max: V3;
-}
-/** A world compiled for one hull: every solid grown by it, and the clearance kept from a surface. */
+/**
+ * A world compiled for one hull: every solid grown by it, and the clearance kept from a surface. Flat, so a
+ * large world costs its numbers and no objects: `bounds` holds each solid's six (the grown footprint and
+ * height: min x y z, max x y z; a ramp's box is its bound), boxes first. A box's six planes follow from
+ * its bounds (see {@link planeInto}); a ramp's seven are in `rampPlanes`, four numbers each, the bottom last.
+ */
 interface ContactWorld {
-    readonly solids: readonly ContactSolid[];
+    /** Solids, and how many of them are boxes. */
+    readonly count: number;
+    readonly boxCount: number;
+    readonly bounds: Float64Array;
+    readonly rampPlanes: Float64Array;
     /** A point is inside a solid only when it is more than this inside every plane (the preset's skin). */
     readonly skin: number;
-    /** The solids by where they stand (compileContactWorld's; none: a cast visits every solid). */
+    /** The solids by where they stand (compileContactWorld's; none: a query visits every solid). */
     readonly grid?: SolidGrid;
 }
 /**
- * A compiled world's solids on an x/y grid, so a cast visits the solids whose footprint it can reach
- * rather than every one (a dust2 map's 1500, about 0.5 ms a cast in QuickJS): cell (i, j) covers
+ * A compiled world's solids on an x/y grid, so a cast or a point query visits the solids whose footprint
+ * it can reach rather than every one (a dust2 map's 1500, about 0.5 ms a cast in QuickJS): cell (i, j) covers
  * [x0 + i·size, x0 + (i + 1)·size) on x (the edge cells reach on to the world's ends), and holds every
  * solid whose bounds grown by castWorld's margin meet it, ascending; a solid on more than GRID_WIDE
  * cells is on `wide` alone, which every query visits. Only where a cast visits solids changes, never
@@ -1027,10 +1159,14 @@ interface SolidGrid {
     readonly size: number;
     readonly nx: number;
     readonly ny: number;
-    /** Cell (i, j) at i + j·nx: its solids' indices, ascending. */
-    readonly cells: readonly (readonly number[])[];
+    /** Cell (i, j) is c = i + j·nx: its solids' indices are `cellSolids` from `cellStart[c]` up to
+     *  `cellStart[c + 1]`, ascending. */
+    readonly cellStart: Int32Array;
+    readonly cellSolids: Int32Array;
     /** The solids too wide for the cells (a floor, a map-long wall), ascending. */
-    readonly wide: readonly number[];
+    readonly wide: Int32Array;
+    /** Each cell's solids and the wide ones as one list, kept once a query has asked for it: most queries are one cell's, and ask again. */
+    readonly merged: (ArrayLike<number> | undefined)[];
 }
 /** A static world as a module gives it (§17.7): boxes `[x0 y0 z0 x1 y1 z1]`, then ramps
  *  `[x0 y0 z0 x1 y1 z1 axis lo hi]`. */
@@ -1667,6 +1803,13 @@ interface ContactEnv {
     /** The id of a seat that never moves (a drawing's own entity, §17.11 *Drawing other seats*): the
      *  other seat of its pair takes the whole push, its own way (along a wall, never into it). */
     readonly fixed?: string;
+    /** A pass's memo of each seat's support up (see {@link contactPass}), by the place it was read at. */
+    readonly supports?: Map<PolicyBody, {
+        x: number;
+        y: number;
+        z: number;
+        up: V3;
+    }>;
 }
 /** One pair's contact: its kind, axis (unit, from `a` to `b`) and depth along it. */
 interface PairContact {
@@ -1903,14 +2046,71 @@ declare const psin: (a: number) => number;
  *  angle, or one past ±1e9, is read as 0 (cosine 1). */
 declare const pcos: (a: number) => number;
 
+/** Which transport a seat's motion and inputs are on. */
+declare const FastTransport: {
+    readonly Udp: "udp";
+    readonly WebSocket: "websocket";
+};
+type FastTransport = (typeof FastTransport)[keyof typeof FastTransport];
+/** Why a seat that never had the channel is on the WebSocket. A fallback's reason is `FastFallbackReason`. */
+declare const FastNotAsked: {
+    /** The game turned it off (`fast: false`, `bFastChannel = false`, ...). */
+    readonly Off: "off";
+    /** This runtime has no UDP socket (WebGL, a browser with no opener). */
+    readonly NoUdp: "no_udp";
+    /** The seat asked and the room sent no binding. */
+    readonly NotOffered: "not_offered";
+};
+type FastNotAsked = (typeof FastNotAsked)[keyof typeof FastNotAsked];
+/** How long after a socket's first state a seat waits for its binding before it says the room offered
+ *  none: the binding follows the state on one ordered stream, so any wait covers it; the handshake's. */
+declare const FAST_OFFER_WAIT_MS = 1000;
+/** The line for a seat on UDP to `url`. */
+declare const udpLine: (url: string) => string;
+/** The line for a seat on the WebSocket because of `reason` (a {@link FastNotAsked} or a fallback reason). */
+declare const webSocketLine: (reason: string) => string;
+/** What a seat knows of its channel at one instant. */
+interface FastLineObservation {
+    /** The game left the channel on. */
+    asked: boolean;
+    /** This runtime has a UDP socket to open. */
+    udp: boolean;
+    /** Milliseconds since this socket's first state; null before it. */
+    joinedMs: number | null;
+    /** The binding's url; null before one came. */
+    url: string | null;
+    /** Snapshots applied on this socket. */
+    snapshots: number;
+    /** Why this socket fell back; null if it has not. */
+    fallback: string | null;
+}
+/** Says each line once per socket. */
+interface FastLineAnnouncer {
+    /** The line this instant owes, or null. */
+    observe(o: FastLineObservation): string | null;
+    /** A new socket: everything may be said again. */
+    reset(): void;
+}
+/** A seat's announcer. */
+declare function fastLineAnnouncer(): FastLineAnnouncer;
+
 /** What the session reads of a seat's fast channel. */
 interface FastSeatStatus {
     /** Snapshots are flowing and inputs go by datagram. */
     readonly live: boolean;
     /** Snapshots applied on this session. */
     readonly snapshots: number;
-    /** Why this socket fell back to the WebSocket, else null. */
+    /** Why this seat is on the WebSocket, else null (on the channel, connecting, or the game turned it
+     *  off): {@link FastFallbackReason}. */
     readonly fallback: FastFallbackReason | null;
+    /** Times this session fell back. */
+    readonly fallbacks: number;
+    /** Times this session came back to the channel after a fallback. */
+    readonly returns: number;
+    /** The transport as last said: UDP once a snapshot came over it, the WebSocket before that and after a fallback. */
+    readonly transport: FastTransport;
+    /** The newest transport line (fast-line.ts), once there is one: names the transport and why. */
+    readonly line: string | null;
 }
 
 /** One latency sample of `url` in ms; rejects (or never settles) when the relay doesn't answer. */
@@ -1953,10 +2153,111 @@ declare function rankAuthorityRegions(regions: readonly AuthorityRegion[], best:
 /** 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[];
+/** What a refused join does next (§17.1 *Regions*). */
+declare const RefusalKind: {
+    /** A full region, or a process shutting down that a sibling answers: the schedule, on this region. */
+    readonly Capacity: "capacity";
+    /** A dead path, with other regions healthy: the next region at once. */
+    readonly NextRegion: "next_region";
+    /** The server's answer: final. */
+    readonly Final: "final";
+};
+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;
 /** 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[]>;
 
+/** The rejoin's schedule and windows, ms. */
+declare const REJOIN: {
+    /** Waits before each attempt; past the end the last one repeats. */
+    readonly scheduleMs: readonly [0, 250, 500, 1000, 2000, 4000];
+    /** Each wait adds up to this much, by chance, so a room's seats do not arrive at once. */
+    readonly jitterMs: 250;
+    /** How long a seat keeps trying: long enough for a roll's next process to come up on a full node. */
+    readonly budgetMs: 180000;
+    /** How long a seat stays with its own region before it tries the next one. */
+    readonly regionStayMs: 60000;
+    /** How long a public seat looks for its room's successor before it joins the game's pool. */
+    readonly successorMs: 90000;
+};
+/** How long a successor room stays closed to the game's pool. Longer than `REJOIN.successorMs`, so a
+ *  late seat of the lost room still reaches it; then it serves the pool like any room. */
+declare const SUCCESSOR_OPEN_MS = 120000;
+/** The ways back: the lost room by its id (a socket drop, where it may still live), its successor, or
+ *  the game's pool. */
+declare const RejoinWay: {
+    readonly Room: "room";
+    readonly Successor: "successor";
+    readonly Pool: "pool";
+};
+type RejoinWay = (typeof RejoinWay)[keyof typeof RejoinWay];
+/** Why a rejoin stopped. */
+declare const RejoinStop: {
+    readonly Final: "final";
+    readonly Budget: "budget";
+};
+type RejoinStop = (typeof RejoinStop)[keyof typeof RejoinStop];
+/** What an attempt is decided from. */
+interface RejoinInput {
+    /** Attempts already made. */
+    attempt: number;
+    /** Since the close. */
+    elapsedMs: number;
+    /** What the last attempt was refused with; null for none yet or a failed network. */
+    refusal: number | null;
+    /** The close that started this rejoin. */
+    lostCode: number;
+    /** The lost room was private: its seats keep to its successor. */
+    closed: boolean;
+    /** How many regions the client knows. */
+    regions: number;
+    /** A number in [0, 1): the attempt's share of the jitter window. */
+    jitter: number;
+}
+type RejoinStep = {
+    stop: RejoinStop;
+} | {
+    waitMs: number;
+    region: number;
+    way: RejoinWay;
+};
+/** Whether a seat closed with `code` goes back into play by itself. */
+declare function comesBackAfter(code: number): boolean;
+/** The next attempt of a rejoin, or why there is none. */
+declare function rejoinStep(input: RejoinInput): RejoinStep;
+/** Whether `value` can name a lost room: a room code, so nothing else reaches a room filter. */
+declare function validSuccessorOf(value: unknown): value is string;
+/** The options a seat's successor join adds to the join's own. */
+declare function planSuccessorJoin(input: {
+    lostRoomId: string;
+    matchKey: string;
+    closed: boolean;
+}): {
+    matchKey?: string;
+    successorOf: string;
+    successorClosed?: true;
+};
+
+/** `draining`: the server closes this room in `closesInMs`, -1 when an older server does not say. Play
+ *  on: the seat moves by itself at the close. */
+type AuthorityDraining = {
+    closesInMs: number;
+};
+/** `rejoining`: the room is gone and attempt `attempt` (from 1) of finding the next one starts in
+ *  `waitMs`. `code` is the close that lost it. Show "reconnecting"; there is nothing to do. */
+type AuthorityRejoining = {
+    attempt: number;
+    code: number;
+    waitMs: number;
+};
+/** `rejoined`: back in play, as a new seat in a new room (the invite `code` is new too). */
+type AuthorityRejoined = {
+    code: string;
+    url: string;
+};
+
 /** The own-entity fields a prediction step may read and write: the pose and velocity always, and
  *  firstperson's `pitch`, `duck`, `mstate` and `cap` and vehicle's `spin` and `fuel` when a step
  *  lists them in `fields`. */
@@ -2012,6 +2313,10 @@ type AuthorityConnectOptions = {
      *  can be drawn through it. Both `predicted` and `separate` keep every seat out of yours and out of
      *  each other on screen (`separateSeats`). */
     seatDrawing?: SeatDrawing;
+    /** The pool to join (§17.2 *Choosing a room*): players with one key share rooms, and the room module
+     *  reads it at init to choose a world or mode. At most 32 of a-z 0-9 . _ : -; absent: the game's one
+     *  pool. Give the world the key picks to `world` (`selectMatchWorld`). */
+    matchKey?: string;
     /** The `firstperson` or `vehicle` collision world, as the room module exports it (`setWorld` later, too):
      *  your own entity is predicted only while its hash equals the room's `params.world`. */
     world?: FirstpersonWorldSpec | FirstpersonWorld;
@@ -2052,18 +2357,23 @@ type AuthorityConnectOptions = {
      *  and draws them as predicted bodies; omitted, they hold each keyframe's pose and are drawn from the
      *  server's states. */
     kinematicRule?: PredictKinematicRule;
-    /** The fast channel (PROTOCOL.md §17.12): how this client opens a datagram socket to the room's
-     *  endpoint (`openUdpFastSocket` from `@genex-ai/multiplayer/authority/fast-udp` in Node). Given, the
-     *  client asks for `fast@1`: in a room that offers it your inputs and the room's motion go by datagram,
-     *  everything else stays on the WebSocket, and the seat falls back to the WebSocket by itself (`fast`
-     *  says when and why). Omitted: WebSocket only. */
-    fast?: FastSocketOpener;
+    /** The fast channel (PROTOCOL.md §17.12): on by default wherever this runtime can reach it, UDP in Node and
+     *  WebTransport in a browser whose room's server runs the relay. Your inputs and the room's motion go by
+     *  datagram, everything else stays on the WebSocket, and the seat falls back to the WebSocket and returns by
+     *  itself (`session.fast` says when and why, and one line says so). An opener is the socket to use instead.
+     *  `false` keeps the seat on the WebSocket. */
+    fast?: FastSocketOpener | false;
+    /** Where the transport line goes (fast-line.ts). Default: stderr in Node, else `console.info`. */
+    fastLog?: (line: string) => void;
     /** The millisecond clock the fast channel's deadlines and round trips run on (default
      *  `performance.now`). */
     fastClock?: () => number;
     /** Waits before each retry of a join refused for capacity (503). Default 1 s, 2 s, 4 s; `[]` never
      *  retries. No other refusal is retried. */
     capacityRetryMs?: readonly number[];
+    /** 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;
     /** 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)`. */
@@ -2186,14 +2496,18 @@ type AuthorityTelemetry = {
     inputsDropped: number;
     /** Server acks the reconciler checked its prediction against. */
     reconciles: number;
-    /** Reconciles that moved the own entity by more than 0.05 world units. */
+    /** Reconciles that moved the own entity's place by more than 5 cm (0.05 × the room's units per metre). */
     visibleCorrections: number;
-    /** The visible corrections by size, world units: under 0.5, 0.5-1, 1-5, 5-20 and over 20
-     *  (CORRECTION_BUCKETS); they sum to `visibleCorrections`. */
+    /** The visible corrections by size, metres: under 0.5, 0.5-1, 1-5, 5-20 and over 20
+     *  (CORRECTION_BUCKET_METRES); they sum to `visibleCorrections`. */
     correctionBuckets: number[];
-    /** Largest correction seen, and the latest one, in world units. */
+    /** Largest correction of the own entity's place seen, and the latest one: the length of the move, in
+     *  room units. Velocity and angles are never in it. */
     peakCorrection: number;
     lastCorrection: number;
+    /** Largest correction of any other mirrored field (velocity, heading, pitch, duck), each in its own
+     *  unit, so only zero or not says anything: with `peakCorrection`, whether the prediction was exact. */
+    peakStateCorrection: number;
     /** Times the prediction was re-seeded from the server: an epoch bump on your own entity (a respawn
      *  or teleport, snapped to the server's new pose and never counted as a correction) or a reconnect. */
     reseeds: number;
@@ -2236,6 +2550,11 @@ type AuthoritySession = {
      * `frame()`, or pass `world` to `connectAuthority`; a later call re-seeds the prediction.
      */
     setWorld(world: FirstpersonWorldSpec | FirstpersonWorld): number;
+    /** The room's invite code (§17.2 *Choosing a room*): friends pass it to `joinPrivateAuthority()`. */
+    readonly code: string;
+    /** The room's match key, '' for none. A friend who joined by code reads it here once the first state
+     *  has landed, to hand the room's world to `setWorld`; until then its entity is unpredicted. */
+    readonly matchKey: string;
     /** Whether your own entity is predicted right now, and why not. */
     readonly prediction: AuthorityPredictionStatus;
     /** Hands the SDK the physicsHash (16 hex digits) of the physics world your client runs a copy of
@@ -2298,8 +2617,15 @@ type AuthoritySession = {
         code: number;
     }) => void): () => void;
     on(event: 'reconnected', handler: () => void): () => void;
-    /** The session is over (a terminal close code, or every reconnect attempt failed). */
-    on(event: 'disconnect', handler: (code: number) => void): () => void;
+    /** The session is over: a close nothing comes back from, or a rejoin that ran out (§17.13). `reason` is why an authority room
+     *  ended, for you, the game's creator: show players AUTHORITY_ROOM_ENDED_TEXT, not the code. Null with no such reason. */
+    on(event: 'disconnect', handler: (code: number, reason: AuthorityCloseCode | null) => void): () => void;
+    /** The server closes this room soon, for a deploy (§17.13). Play on: the seat moves by itself. */
+    on(event: 'draining', handler: (info: AuthorityDraining) => void): () => void;
+    /** The room is gone and the seat is on its way back. Say so; there is nothing to do. */
+    on(event: 'rejoining', handler: (info: AuthorityRejoining) => void): () => void;
+    /** Back in play: a new seat (`id`) in a new room (`code`). */
+    on(event: 'rejoined', handler: (info: AuthorityRejoined) => void): () => void;
     /** A game event the room module emitted. */
     on(event: string, handler: (data: unknown) => void): () => void;
     /** Leave on purpose. Never reconnects. */
@@ -2329,5 +2655,17 @@ declare const DEFAULT_SEAT_DRAWING: SeatDrawing;
  * (`NOT_ENTITLED`), 424, 429 and 426 are not retried; 503 is retried per `capacityRetryMs`.
  */
 declare function connectAuthority(opts: AuthorityConnectOptions): Promise<AuthoritySession>;
+/**
+ * Creates a private authority room (§17.2 *Choosing a room*) and returns its session: `session.code`
+ * is the invite, which friends pass to `joinPrivateAuthority()`. No matchmaking ever reaches the room.
+ * `matchKey` chooses its world or mode as it does a pool's.
+ */
+declare function createPrivateAuthority(opts: AuthorityConnectOptions): Promise<AuthoritySession>;
+/**
+ * Joins the private authority room with invite `code`, walking the regions until one holds it. The
+ * room's key is its own (`session.matchKey`, once the first state lands): hand its world to `setWorld`
+ * with `selectMatchWorld`. `opts.matchKey` must be unset.
+ */
+declare function joinPrivateAuthority(code: string, opts: AuthorityConnectOptions): Promise<AuthoritySession>;
 
-export { AUTHORITY_REFUSALS_PER_REGION, AuthorityBody, type AuthorityConnectOptions, AuthorityContactRule, AuthorityEntity, type AuthorityEntityView, AuthorityInput, AuthorityJoint, AuthorityLimits, AuthorityPhysicsEntity, AuthorityPhysicsRoomState, type AuthorityPhysicsStatus, AuthorityPlayer, type AuthorityPlayerView, type AuthorityPrediction, type AuthorityPredictionStatus, type AuthorityRegion, type AuthorityRegionPick, AuthorityRoomState, type AuthoritySeatPass, AuthoritySeatRule, type AuthoritySession, AuthorityShape, type AuthorityStep, type AuthorityTelemetry, CONVEYOR_RATE, type Carried, type CarryReport, type CastHit, ContactBody, ContactDrawing, type ContactEnv, ContactEvent, ContactKind, type ContactPassOptions, ContactPolicy, type ContactReport, type ContactSolid, type ContactWorld, type ContactWorldSpec, type ConveyorBody, DEFAULT_SEAT_DRAWING, DEFAULT_TICK_HZ, type DeclaredContacts, type DrawnPose, EntityData, type EntityIndex, type EntityOut, type EventOut, type FaceFilter, FastFallbackReason, type FastSeatStatus, FastSocketOpener, 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, type ProjectileLaunch, type ProjectilePrediction, type ProjectileState, type PropBody, type PropNudge, type PropSeat, PropSlide, RIDE_CHAIN_MAX, type ReconcilerAckHold, RemoteInput, RemotePredict, ResolvedModuleConfig, type Ride, type RiderPose, SEAT_DRAWINGS, SHOVE_EASE_DONE, STALL_PREDICT_MS, STEADY_BUCKETS, 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, 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, capacityWalk, carryOnLift, carrySlot, carryTick, castWorld, compileContactWorld, connectAuthority, consumedUse, contactOf, contactPair, contactPass, contactPassOf, contactRuleOf, conveyorNudges, conveyorUnder, declaredContacts, farApart, feedWithPayback, forgiveRepeats, frameOf, hasStand, headHold, headOffset, headSlab, headSlabs, headStands, impartSlot, impartTick, inLiftFrame, inputThrottle, inputTickField, inputTickLag, inputTickSlack, insideFace, insideWorld, isProjectile, liftBodyKey, liftBodyPose, liftBodySpawn, liftCollider, liftDrawnAt, liftPose, liftPoses, liftPosesAt, liftStartsOf, liftTopAt, liftUnder, mayStand, normalizeAuthorityRegions, pcos, posedFor, posedSolids, projectileAt, propSlideNudges, psin, psincos, rankAuthorityRegions, reconcileThrough, reconcilerAck, reconcilerAckHold, regionProbePlan, repeatMaxTicks, repeatRunTicks, repeatStarved, repeatsSeat, rideSlot, rideStep, rideTick, ridesOn, rodeBy, roomAlong, sameHeldInput, sanitizeInput, seatClock, seatLeadClock, seatLiftsOf, seatOffset, seatRepeats, seatTauMs, seatTouchShare, seatUnderProp, selectAuthorityRegions, serverTick, shoveEase, spinStep, stateThrough, stepOnLifts, steppedThrough, surfaceUp, tagsOf, throttleState, throttleSteps, tickInstant, tickSolids, topRuleOf, unstickBody, validateInitOut, validateTickOut, viewOnLift, yieldShares };
+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 };