@genex-ai/multiplayer 0.17.1 → 0.17.8

package/dist/authority/index.d.ts

@@ -0,0 +1,2671 @@
+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, 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
+ *  *Downlink*): a client's view holds it on every entity it sees, except a fast seat's while its
+ *  channel is live, whose motion comes by snapshot only. Server-side encoder metadata: no decoder reads
+ *  it, and the handshake's type description is the same with or without it. */
+declare const MOTION_VIEW_TAG = 1;
+declare const AuthorityInput: _colyseus_schema.SchemaWithExtendsConstructor<{
+    moveX: _colyseus_schema.FieldBuilder<number, true, false>;
+    moveY: _colyseus_schema.FieldBuilder<number, true, false>;
+    moveZ: _colyseus_schema.FieldBuilder<number, true, false>;
+    yaw: _colyseus_schema.FieldBuilder<number, true, false>;
+    pitch: _colyseus_schema.FieldBuilder<number, true, false>;
+    buttons: _colyseus_schema.FieldBuilder<number, true, false>;
+    tick: _colyseus_schema.FieldBuilder<number, true, false>;
+}, _colyseus_schema.BuilderInitProps<{
+    moveX: _colyseus_schema.FieldBuilder<number, true, false>;
+    moveY: _colyseus_schema.FieldBuilder<number, true, false>;
+    moveZ: _colyseus_schema.FieldBuilder<number, true, false>;
+    yaw: _colyseus_schema.FieldBuilder<number, true, false>;
+    pitch: _colyseus_schema.FieldBuilder<number, true, false>;
+    buttons: _colyseus_schema.FieldBuilder<number, true, false>;
+    tick: _colyseus_schema.FieldBuilder<number, true, false>;
+}>, typeof _colyseus_schema.Schema>;
+type AuthorityInput = SchemaType<typeof AuthorityInput>;
+declare const AuthorityEntity: _colyseus_schema.SchemaWithExtendsConstructor<{
+    kind: _colyseus_schema.FieldBuilder<string, true, false>;
+    owner: _colyseus_schema.FieldBuilder<string, true, false>;
+    x: _colyseus_schema.FieldBuilder<number, true, false>;
+    y: _colyseus_schema.FieldBuilder<number, true, false>;
+    z: _colyseus_schema.FieldBuilder<number, true, false>;
+    vx: _colyseus_schema.FieldBuilder<number, true, false>;
+    vy: _colyseus_schema.FieldBuilder<number, true, false>;
+    vz: _colyseus_schema.FieldBuilder<number, true, false>;
+    yaw: _colyseus_schema.FieldBuilder<number, true, false>;
+    hp: _colyseus_schema.FieldBuilder<number, true, false>;
+    flags: _colyseus_schema.FieldBuilder<number, true, false>;
+    epoch: _colyseus_schema.FieldBuilder<number, true, false>;
+    data: _colyseus_schema.FieldBuilder<string, true, false>;
+    t0: _colyseus_schema.FieldBuilder<number, true, false>;
+    g: _colyseus_schema.FieldBuilder<number, true, false>;
+    src: _colyseus_schema.FieldBuilder<string, true, false>;
+    pitch: _colyseus_schema.FieldBuilder<number, true, false>;
+    duck: _colyseus_schema.FieldBuilder<number, true, false>;
+    mstate: _colyseus_schema.FieldBuilder<number, true, false>;
+    cap: _colyseus_schema.FieldBuilder<number, true, false>;
+    spin: _colyseus_schema.FieldBuilder<number, true, false>;
+    fuel: _colyseus_schema.FieldBuilder<number, true, false>;
+    qx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qw: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    sleep: _colyseus_schema.FieldBuilder<boolean | undefined, false, true>;
+    rest: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+}, _colyseus_schema.BuilderInitProps<{
+    kind: _colyseus_schema.FieldBuilder<string, true, false>;
+    owner: _colyseus_schema.FieldBuilder<string, true, false>;
+    x: _colyseus_schema.FieldBuilder<number, true, false>;
+    y: _colyseus_schema.FieldBuilder<number, true, false>;
+    z: _colyseus_schema.FieldBuilder<number, true, false>;
+    vx: _colyseus_schema.FieldBuilder<number, true, false>;
+    vy: _colyseus_schema.FieldBuilder<number, true, false>;
+    vz: _colyseus_schema.FieldBuilder<number, true, false>;
+    yaw: _colyseus_schema.FieldBuilder<number, true, false>;
+    hp: _colyseus_schema.FieldBuilder<number, true, false>;
+    flags: _colyseus_schema.FieldBuilder<number, true, false>;
+    epoch: _colyseus_schema.FieldBuilder<number, true, false>;
+    data: _colyseus_schema.FieldBuilder<string, true, false>;
+    t0: _colyseus_schema.FieldBuilder<number, true, false>;
+    g: _colyseus_schema.FieldBuilder<number, true, false>;
+    src: _colyseus_schema.FieldBuilder<string, true, false>;
+    pitch: _colyseus_schema.FieldBuilder<number, true, false>;
+    duck: _colyseus_schema.FieldBuilder<number, true, false>;
+    mstate: _colyseus_schema.FieldBuilder<number, true, false>;
+    cap: _colyseus_schema.FieldBuilder<number, true, false>;
+    spin: _colyseus_schema.FieldBuilder<number, true, false>;
+    fuel: _colyseus_schema.FieldBuilder<number, true, false>;
+    qx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qw: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    sleep: _colyseus_schema.FieldBuilder<boolean | undefined, false, true>;
+    rest: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+}>, typeof _colyseus_schema.Schema>;
+type AuthorityEntity = SchemaType<typeof AuthorityEntity>;
+declare const AuthorityPhysicsEntity: _colyseus_schema.SchemaWithExtendsConstructor<{
+    kind: _colyseus_schema.FieldBuilder<string, true, false>;
+    owner: _colyseus_schema.FieldBuilder<string, true, false>;
+    x: _colyseus_schema.FieldBuilder<number, true, false>;
+    y: _colyseus_schema.FieldBuilder<number, true, false>;
+    z: _colyseus_schema.FieldBuilder<number, true, false>;
+    vx: _colyseus_schema.FieldBuilder<number, true, false>;
+    vy: _colyseus_schema.FieldBuilder<number, true, false>;
+    vz: _colyseus_schema.FieldBuilder<number, true, false>;
+    yaw: _colyseus_schema.FieldBuilder<number, true, false>;
+    hp: _colyseus_schema.FieldBuilder<number, true, false>;
+    flags: _colyseus_schema.FieldBuilder<number, true, false>;
+    epoch: _colyseus_schema.FieldBuilder<number, true, false>;
+    data: _colyseus_schema.FieldBuilder<string, true, false>;
+    t0: _colyseus_schema.FieldBuilder<number, true, false>;
+    g: _colyseus_schema.FieldBuilder<number, true, false>;
+    src: _colyseus_schema.FieldBuilder<string, true, false>;
+    pitch: _colyseus_schema.FieldBuilder<number, true, false>;
+    duck: _colyseus_schema.FieldBuilder<number, true, false>;
+    mstate: _colyseus_schema.FieldBuilder<number, true, false>;
+    cap: _colyseus_schema.FieldBuilder<number, true, false>;
+    spin: _colyseus_schema.FieldBuilder<number, true, false>;
+    fuel: _colyseus_schema.FieldBuilder<number, true, false>;
+    qx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qw: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    sleep: _colyseus_schema.FieldBuilder<boolean | undefined, false, true>;
+    rest: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+}, _colyseus_schema.BuilderInitProps<{
+    kind: _colyseus_schema.FieldBuilder<string, true, false>;
+    owner: _colyseus_schema.FieldBuilder<string, true, false>;
+    x: _colyseus_schema.FieldBuilder<number, true, false>;
+    y: _colyseus_schema.FieldBuilder<number, true, false>;
+    z: _colyseus_schema.FieldBuilder<number, true, false>;
+    vx: _colyseus_schema.FieldBuilder<number, true, false>;
+    vy: _colyseus_schema.FieldBuilder<number, true, false>;
+    vz: _colyseus_schema.FieldBuilder<number, true, false>;
+    yaw: _colyseus_schema.FieldBuilder<number, true, false>;
+    hp: _colyseus_schema.FieldBuilder<number, true, false>;
+    flags: _colyseus_schema.FieldBuilder<number, true, false>;
+    epoch: _colyseus_schema.FieldBuilder<number, true, false>;
+    data: _colyseus_schema.FieldBuilder<string, true, false>;
+    t0: _colyseus_schema.FieldBuilder<number, true, false>;
+    g: _colyseus_schema.FieldBuilder<number, true, false>;
+    src: _colyseus_schema.FieldBuilder<string, true, false>;
+    pitch: _colyseus_schema.FieldBuilder<number, true, false>;
+    duck: _colyseus_schema.FieldBuilder<number, true, false>;
+    mstate: _colyseus_schema.FieldBuilder<number, true, false>;
+    cap: _colyseus_schema.FieldBuilder<number, true, false>;
+    spin: _colyseus_schema.FieldBuilder<number, true, false>;
+    fuel: _colyseus_schema.FieldBuilder<number, true, false>;
+    qx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    qw: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    lvz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avx: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avy: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    avz: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    sleep: _colyseus_schema.FieldBuilder<boolean | undefined, false, true>;
+    rest: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+}>, typeof _colyseus_schema.Schema>;
+type AuthorityPhysicsEntity = SchemaType<typeof AuthorityPhysicsEntity>;
+declare const AuthorityPlayer: _colyseus_schema.SchemaWithExtendsConstructor<{
+    name: _colyseus_schema.FieldBuilder<string, true, false>;
+    uid: _colyseus_schema.FieldBuilder<string, true, false>;
+    team: _colyseus_schema.FieldBuilder<string, true, false>;
+    connected: _colyseus_schema.FieldBuilder<boolean, true, false>;
+    avatarUrl: _colyseus_schema.FieldBuilder<string, true, false>;
+    seqBase: _colyseus_schema.FieldBuilder<number, true, false>;
+    inMoveX: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inMoveY: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inMoveZ: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inYaw: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inPitch: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inButtons: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inRep: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inStarve: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inBuf: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+}, _colyseus_schema.BuilderInitProps<{
+    name: _colyseus_schema.FieldBuilder<string, true, false>;
+    uid: _colyseus_schema.FieldBuilder<string, true, false>;
+    team: _colyseus_schema.FieldBuilder<string, true, false>;
+    connected: _colyseus_schema.FieldBuilder<boolean, true, false>;
+    avatarUrl: _colyseus_schema.FieldBuilder<string, true, false>;
+    seqBase: _colyseus_schema.FieldBuilder<number, true, false>;
+    inMoveX: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inMoveY: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inMoveZ: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inYaw: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inPitch: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inButtons: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inRep: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inStarve: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    inBuf: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+}>, typeof _colyseus_schema.Schema>;
+type AuthorityPlayer = SchemaType<typeof AuthorityPlayer>;
+declare const AuthorityBody: _colyseus_schema.SchemaWithExtendsConstructor<{
+    type: _colyseus_schema.FieldBuilder<string, true, false>;
+    kind: _colyseus_schema.FieldBuilder<string, true, false>;
+    colliders: _colyseus_schema.FieldBuilder<string, true, false>;
+    desc: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+}, _colyseus_schema.BuilderInitProps<{
+    type: _colyseus_schema.FieldBuilder<string, true, false>;
+    kind: _colyseus_schema.FieldBuilder<string, true, false>;
+    colliders: _colyseus_schema.FieldBuilder<string, true, false>;
+    desc: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+}>, typeof _colyseus_schema.Schema>;
+type AuthorityBody = SchemaType<typeof AuthorityBody>;
+declare const AuthorityShape: _colyseus_schema.SchemaWithExtendsConstructor<{
+    data: _colyseus_schema.FieldBuilder<string, true, false>;
+}, _colyseus_schema.BuilderInitProps<{
+    data: _colyseus_schema.FieldBuilder<string, true, false>;
+}>, typeof _colyseus_schema.Schema>;
+type AuthorityShape = SchemaType<typeof AuthorityShape>;
+declare const AuthorityJoint: _colyseus_schema.SchemaWithExtendsConstructor<{
+    desc: _colyseus_schema.FieldBuilder<string, true, false>;
+    motor: _colyseus_schema.FieldBuilder<string, true, false>;
+}, _colyseus_schema.BuilderInitProps<{
+    desc: _colyseus_schema.FieldBuilder<string, true, false>;
+    motor: _colyseus_schema.FieldBuilder<string, true, false>;
+}>, typeof _colyseus_schema.Schema>;
+type AuthorityJoint = SchemaType<typeof AuthorityJoint>;
+declare const AuthorityRoomState: _colyseus_schema.SchemaWithExtendsConstructor<{
+    players: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        name: string;
+        uid: string;
+        team: string;
+        connected: boolean;
+        avatarUrl: string;
+        seqBase: number;
+    } & {
+        inMoveX?: number | undefined;
+        inMoveY?: number | undefined;
+        inMoveZ?: number | undefined;
+        inYaw?: number | undefined;
+        inPitch?: number | undefined;
+        inButtons?: number | undefined;
+        inRep?: number | undefined;
+        inStarve?: number | undefined;
+        inBuf?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    entities: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        kind: string;
+        owner: string;
+        x: number;
+        y: number;
+        z: number;
+        vx: number;
+        vy: number;
+        vz: number;
+        yaw: number;
+        hp: number;
+        flags: number;
+        epoch: number;
+        data: string;
+        t0: number;
+        g: number;
+        src: string;
+        pitch: number;
+        duck: number;
+        mstate: number;
+        cap: number;
+        spin: number;
+        fuel: number;
+    } & {
+        qx?: number | undefined;
+        qy?: number | undefined;
+        qz?: number | undefined;
+        qw?: number | undefined;
+        lvx?: number | undefined;
+        lvy?: number | undefined;
+        lvz?: number | undefined;
+        avx?: number | undefined;
+        avy?: number | undefined;
+        avz?: number | undefined;
+        sleep?: boolean | undefined;
+        rest?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    tick: _colyseus_schema.FieldBuilder<number, true, false>;
+    clockOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    preset: _colyseus_schema.FieldBuilder<string, true, false>;
+    moduleSha: _colyseus_schema.FieldBuilder<string, true, false>;
+    tickOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    physics: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    lengthUnit: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    bodies: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        type: string;
+        kind: string;
+        colliders: string;
+    } & {
+        desc?: string | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    physDesc: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    keyframe: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    shapes: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        data: string;
+    } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    joints: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        desc: string;
+        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;
+        uid: string;
+        team: string;
+        connected: boolean;
+        avatarUrl: string;
+        seqBase: number;
+    } & {
+        inMoveX?: number | undefined;
+        inMoveY?: number | undefined;
+        inMoveZ?: number | undefined;
+        inYaw?: number | undefined;
+        inPitch?: number | undefined;
+        inButtons?: number | undefined;
+        inRep?: number | undefined;
+        inStarve?: number | undefined;
+        inBuf?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    entities: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        kind: string;
+        owner: string;
+        x: number;
+        y: number;
+        z: number;
+        vx: number;
+        vy: number;
+        vz: number;
+        yaw: number;
+        hp: number;
+        flags: number;
+        epoch: number;
+        data: string;
+        t0: number;
+        g: number;
+        src: string;
+        pitch: number;
+        duck: number;
+        mstate: number;
+        cap: number;
+        spin: number;
+        fuel: number;
+    } & {
+        qx?: number | undefined;
+        qy?: number | undefined;
+        qz?: number | undefined;
+        qw?: number | undefined;
+        lvx?: number | undefined;
+        lvy?: number | undefined;
+        lvz?: number | undefined;
+        avx?: number | undefined;
+        avy?: number | undefined;
+        avz?: number | undefined;
+        sleep?: boolean | undefined;
+        rest?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    tick: _colyseus_schema.FieldBuilder<number, true, false>;
+    clockOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    preset: _colyseus_schema.FieldBuilder<string, true, false>;
+    moduleSha: _colyseus_schema.FieldBuilder<string, true, false>;
+    tickOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    physics: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    lengthUnit: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    bodies: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        type: string;
+        kind: string;
+        colliders: string;
+    } & {
+        desc?: string | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    physDesc: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    keyframe: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    shapes: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        data: string;
+    } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    joints: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        desc: string;
+        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<{
+    entities: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        kind: string;
+        owner: string;
+        x: number;
+        y: number;
+        z: number;
+        vx: number;
+        vy: number;
+        vz: number;
+        yaw: number;
+        hp: number;
+        flags: number;
+        epoch: number;
+        data: string;
+        t0: number;
+        g: number;
+        src: string;
+        pitch: number;
+        duck: number;
+        mstate: number;
+        cap: number;
+        spin: number;
+        fuel: number;
+    } & {
+        qx?: number | undefined;
+        qy?: number | undefined;
+        qz?: number | undefined;
+        qw?: number | undefined;
+        lvx?: number | undefined;
+        lvy?: number | undefined;
+        lvz?: number | undefined;
+        avx?: number | undefined;
+        avy?: number | undefined;
+        avz?: number | undefined;
+        sleep?: boolean | undefined;
+        rest?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    players: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        name: string;
+        uid: string;
+        team: string;
+        connected: boolean;
+        avatarUrl: string;
+        seqBase: number;
+    } & {
+        inMoveX?: number | undefined;
+        inMoveY?: number | undefined;
+        inMoveZ?: number | undefined;
+        inYaw?: number | undefined;
+        inPitch?: number | undefined;
+        inButtons?: number | undefined;
+        inRep?: number | undefined;
+        inStarve?: number | undefined;
+        inBuf?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    tick: _colyseus_schema.FieldBuilder<number, true, false>;
+    clockOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    preset: _colyseus_schema.FieldBuilder<string, true, false>;
+    moduleSha: _colyseus_schema.FieldBuilder<string, true, false>;
+    tickOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    physics: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    lengthUnit: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    bodies: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        type: string;
+        kind: string;
+        colliders: string;
+    } & {
+        desc?: string | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    physDesc: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    keyframe: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    shapes: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        data: string;
+    } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    joints: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        desc: string;
+        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;
+        owner: string;
+        x: number;
+        y: number;
+        z: number;
+        vx: number;
+        vy: number;
+        vz: number;
+        yaw: number;
+        hp: number;
+        flags: number;
+        epoch: number;
+        data: string;
+        t0: number;
+        g: number;
+        src: string;
+        pitch: number;
+        duck: number;
+        mstate: number;
+        cap: number;
+        spin: number;
+        fuel: number;
+    } & {
+        qx?: number | undefined;
+        qy?: number | undefined;
+        qz?: number | undefined;
+        qw?: number | undefined;
+        lvx?: number | undefined;
+        lvy?: number | undefined;
+        lvz?: number | undefined;
+        avx?: number | undefined;
+        avy?: number | undefined;
+        avz?: number | undefined;
+        sleep?: boolean | undefined;
+        rest?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    players: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        name: string;
+        uid: string;
+        team: string;
+        connected: boolean;
+        avatarUrl: string;
+        seqBase: number;
+    } & {
+        inMoveX?: number | undefined;
+        inMoveY?: number | undefined;
+        inMoveZ?: number | undefined;
+        inYaw?: number | undefined;
+        inPitch?: number | undefined;
+        inButtons?: number | undefined;
+        inRep?: number | undefined;
+        inStarve?: number | undefined;
+        inBuf?: number | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string>, true, false>;
+    tick: _colyseus_schema.FieldBuilder<number, true, false>;
+    clockOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    preset: _colyseus_schema.FieldBuilder<string, true, false>;
+    moduleSha: _colyseus_schema.FieldBuilder<string, true, false>;
+    tickOrigin: _colyseus_schema.FieldBuilder<number, true, false>;
+    physics: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    lengthUnit: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    bodies: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        type: string;
+        kind: string;
+        colliders: string;
+    } & {
+        desc?: string | undefined;
+    } & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    physDesc: _colyseus_schema.FieldBuilder<string | undefined, false, true>;
+    keyframe: _colyseus_schema.FieldBuilder<number | undefined, false, true>;
+    shapes: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        data: string;
+    } & {} & _colyseus_schema.Schema<any> & _colyseus_schema.Schema<unknown>, string> | undefined, true, true>;
+    joints: _colyseus_schema.FieldBuilder<_colyseus_schema.MapSchema<{
+        desc: string;
+        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>;
+
+/** The guest's two entry points. */
+declare const GuestGlobal: {
+    readonly INIT: "__genex_init";
+    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;
+    /** One TickOut / InitOut as JSON text. */
+    readonly MAX_OUTPUT_BYTES: number;
+    readonly MAX_EVENTS_PER_TICK: 64;
+    /** One entity's `data` JSON text. */
+    readonly MAX_ENTITY_DATA_BYTES: 256;
+    readonly MAX_ENTITY_ID_CHARS: 64;
+    readonly MAX_KIND_CHARS: 64;
+    /** A session id (`owner`, an event's `to`). */
+    readonly MAX_SESSION_ID_CHARS: 64;
+    /** Every entity number's magnitude (float32 holds it without overflowing). */
+    readonly MAX_ABS: 1000000000;
+    /** `flags` is an integer below this. */
+    readonly MASK_LIMIT: number;
+    /** `epoch` is an integer in [0, MAX_EPOCH]. */
+    readonly MAX_EPOCH: number;
+    /** A projectile's launch tick `t0` is an integer in [0, MAX_PROJECTILE_TICK] (§17.9). */
+    readonly MAX_PROJECTILE_TICK: number;
+    /** A projectile's gravity `g` is in [0, MAX_PROJECTILE_G] units/s². */
+    readonly MAX_PROJECTILE_G: 1000;
+    /** The launches waiting to go out (since the last output the host applied) may hold at most this
+     *  many entities and this much of the output's JSON (§17.9): a launch past either is refused in
+     *  the sandbox, so a burst alone can never make an output the host must refuse (about a hundred
+     *  new projectiles whose floats print in full). The rest of MAX_ENTITIES and MAX_OUTPUT_BYTES
+     *  stays for everything else a tick writes. */
+    readonly MAX_LAUNCH_UPDATES: 224;
+    readonly MAX_LAUNCH_BYTES: number;
+    /** One event: its type, and its `data` as JSON text. */
+    readonly MAX_EVENT_TYPE_CHARS: 128;
+    readonly MAX_EVENT_BYTES: number;
+    readonly MAX_JSON_DEPTH: 32;
+    readonly MAX_JSON_NODES: 4096;
+    /** Seats one authority room may hold. */
+    readonly MAX_PLAYERS: 64;
+    /** A physics room's output (§17.10): at most this many `phys` commands, and `phys` plus `physQ`
+     *  at most this much JSON, apart from the MAX_OUTPUT_BYTES the rest may hold, so the whole text is
+     *  at most MAX_PHYSICS_OUTPUT_BYTES. */
+    readonly MAX_PHYS_COMMANDS: 256;
+    readonly MAX_PHYS_BYTES: number;
+    readonly MAX_PHYSICS_OUTPUT_BYTES: number;
+    /** 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[];
+/** The tick rate only a physics room may run. */
+declare const PHYSICS_ONLY_TICK_HZ: TickHz;
+/** The fastest of {@link TICK_RATES}: an admission at it lets every module run at its own rate. */
+declare const MAX_TICK_HZ: TickHz;
+/** The rate validation and the local server run a module that asks for none at (their admission's
+ *  `unaskedTickHz`): they admit at {@link MAX_TICK_HZ} so an asked rate stands. In production such a
+ *  module runs at its admission's rate, the one its publisher declared (§17.4). */
+declare const DEFAULT_TICK_HZ: TickHz;
+/** Why guest output was refused. */
+declare const TickOutFault: {
+    readonly NOT_JSON: "not_json";
+    readonly TOO_LARGE: "too_large";
+    readonly BAD_SHAPE: "bad_shape";
+    readonly NON_FINITE: "non_finite";
+    readonly OUT_OF_RANGE: "out_of_range";
+    readonly BAD_ID: "bad_id";
+    readonly DATA_TOO_LARGE: "data_too_large";
+    readonly TOO_MANY_ENTITIES: "too_many_entities";
+    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";
+};
+type TickOutFault = (typeof TickOutFault)[keyof typeof TickOutFault];
+/**
+ * How the host hands one input to the guest on a tick (PROTOCOL.md §17.11 *Input pacing*), which is
+ * also how each consumer of an input treats a starved tick's repeat. An input's move axes, aim and
+ * buttons are HELD state for the movement preset (it finds a press edge itself, from `mstate`'s
+ * jumpHeld, so a held jump never jumps twice); the module's `onInput` hears each real input exactly
+ * ONCE (a FIRE, a use, a sequenced command is never repeated). Absent = `STEP`.
+ */
+declare const InputUse: {
+    /** A real input: the preset steps it, then `onInput` hears it. */
+    readonly STEP: "step";
+    /** A starved tick: the preset steps the seat's last real input again; `onInput` never hears it. */
+    readonly REPEAT: "repeat";
+    /** A late real input a repeat already stepped for: `onInput` hears it (its one-shots happen exactly
+     *  once), the preset does not step it again. Only an input whose buttons equal those the preset
+     *  last stepped is absorbed, so no press edge is ever lost or made. */
+    readonly ABSORB: "absorb";
+};
+type InputUse = (typeof InputUse)[keyof typeof InputUse];
+/** One input as the host hands it to the guest. `seq` is the host's own count of the seat's inputs
+ *  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`). `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 {
+    p: string;
+    seq: number;
+    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. */
+    lt?: number;
+}
+/** Host → guest, once per tick. In a physics room (§17.10) the `phys*` keys describe the world
+ *  after the previous tick's step, each present only when non-empty (`physOverflow` only when
+ *  true). Numbers are the core's float32 values, vectors are z up. */
+interface TickIn {
+    t: number;
+    dt: number;
+    /** Seats that send `tick@1` and step none of their inputs this tick (§17.11 *The input's tick*): a
+     *  firstperson view on a spinning lift turns with it (the input meant for this tick, a tick late,
+     *  carries the turn back). Absent when none. */
+    vt?: string[];
+    joins?: PlayerInfo[];
+    leaves?: {
+        id: string;
+        reason: LeaveReason;
+    }[];
+    inputs: TickInput[];
+    /** [index into the `phys` array the host last applied, C§14 code]; the prelude maps the index to
+     *  the command's number. */
+    physRefused?: [number, PhysicsErrorCode][];
+    /** The step's events in C§8.1's order. */
+    physEv?: PhysEvRow[];
+    physOverflow?: true;
+    /** One answer per query of the previous tick's `physQ`, in order. */
+    physAns?: PhysAnswerRow[];
+    /** Subscribed bodies changed since the previous export, in key order. */
+    physBodies?: PhysBodyRow[];
+    /** The entities whose module bodies escaped the world; the host removed them. */
+    physEsc?: string[];
+}
+/** One changed entity: its id plus only the fields that changed. `data` is JSON text ('' = none). */
+type EntityOut = {
+    id: string;
+} & Partial<Omit<EntityData, 'id' | 'data'>> & {
+    data?: string;
+};
+/** One game event to clients (all, or the seat `to`). */
+interface EventOut {
+    type: string;
+    data?: Json;
+    to?: string;
+}
+/** One physics command or query in the contract's JSON form (C§7.3, C§13): one key, the verb, to
+ *  its arguments, exactly as parsed from the guest's text. */
+type PhysCommand = {
+    readonly [verb: string]: Json;
+};
+/** Guest → host, once per tick: changed entities, removed ids, events, and in a physics room the
+ *  tick's physics commands and queries (present only when the room has physics). */
+interface TickOut {
+    up: EntityOut[];
+    rm: string[];
+    ev: EventOut[];
+    phys?: PhysCommand[];
+    physQ?: PhysCommand[];
+    /** Every called lift's start tick (§17.11 *Lifts*), sent after a `ctx.lifts.call` until applied. */
+    lifts?: Record<string, number>;
+}
+/** Guest → host from `__genex_init`: the first output plus the config the module resolved. A
+ *  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 {
+    /** The world's `queriesPerStep`: `physQ` holds at most this many. */
+    readonly queriesPerStep: number;
+    /** The module bodies' keys after the previous tick: the body entities, whose host fields (x y z
+     *  and the body fields) the module may not write and which may not become projectiles. */
+    readonly bodies: {
+        has(key: string): boolean;
+    };
+}
+/** What the host passes `validateInitOut` for a room admitted with physics: its limit ceiling. */
+interface PhysicsAdmission {
+    readonly ceiling: PhysicsCeiling;
+}
+/** The room's current entity ids, as the host holds them (a Set, or the state's MapSchema). With
+ *  `get` (the state's MapSchema has it), the projectile rules are also checked against the fields an
+ *  update leaves unchanged: an update that sets `owner` on a projectile is refused like one that
+ *  launches an owned entity. */
+interface EntityIndex {
+    readonly size: number;
+    has(id: string): boolean;
+    get?(id: string): {
+        readonly t0?: number;
+        readonly owner?: string;
+    } | undefined;
+}
+type WireResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    fault: TickOutFault;
+    path: string;
+};
+/** Sanitizes one raw input into {@link InputData}: axes float32 in [-1, 1] (non-finite → 0),
+ *  yaw and pitch wrapped to [-π, π) (unusable → 0), buttons an integer mask below 2^24 (else 0). */
+declare function sanitizeInput(raw: Record<string, unknown>): InputData;
+/** Validates one `__genex_tick` result (JSON text, or an already parsed value). With `room`, the
+ *  room's current entity ids, it also refuses a tick that would leave more than
+ *  `MAX_ROOM_ENTITIES` entities in the room; the host always passes it. With `physics` (a physics
+ *  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>;
+declare function validateInitOut(raw: unknown, physics?: PhysicsAdmission): WireResult<InitOut>;
+
+/** Repeats owed at most, as time (shared/duration units: ms); {@link repeatMaxTicks} in ticks. */
+declare const INPUT_REPEAT_MAX_MS: 100;
+/** One starve run's repeats at most, as time (ms); {@link repeatRunTicks} in ticks. */
+declare const INPUT_REPEAT_RUN_MS: 33;
+/** {@link INPUT_REPEAT_RUN_MS} in whole ticks at `tickHz`, at least one. */
+declare function repeatRunTicks(tickHz: number): number;
+/** {@link INPUT_REPEAT_MAX_MS} in whole ticks at `tickHz`, at least one. */
+declare function repeatMaxTicks(tickHz: number): number;
+/** One seat's repeats: its last real input, the buttons the preset last stepped, the repeats no later
+ *  input has paid back (`inRep`), its starve runs since its first input (`inStarve`: a run is starved
+ *  ticks in a row) and whether the last tick was starved. */
+interface SeatRepeats {
+    last: InputData | null;
+    steppedButtons: number;
+    owed: number;
+    starveRuns: number;
+    starving: boolean;
+    /** Repeats in the current starve run. */
+    runRepeats: number;
+    /** How many of the seat's latest real inputs in a row are the same held state (the last one counts). */
+    steady: number;
+    /** Diagnostics for the bench: by `steady` at the repeat (index capped at STEADY_BUCKETS − 1), the
+     *  absorbed inputs, and those equal to the input their repeat stepped (a repeat that cost nothing). */
+    absorbsBySteady: number[];
+    exactBySteady: number[];
+    /** The input the owed repeats stepped, and the `steady` count they were stepped at. */
+    repeated: InputData | null;
+    repeatedSteady: number;
+}
+/** A starved seat is repeated only when at least this many of its latest real inputs in a row were
+ *  alike (a steady stick: two 60 Hz frames' worth at 120 Hz); otherwise it holds, as before. Measured on
+ *  car-ball (3 runs a profile, every repeat's absorbed input against the input it repeated): with 1-3
+ *  alike, 0-7% of repeats stood in exactly; with 4 or more, 66-100%. */
+declare const INPUT_REPEAT_STEADY = 4;
+/** Buckets of the diagnostics' `steady` index. */
+declare const STEADY_BUCKETS = 9;
+/** Whether a room with setting `repeat` repeats a seat whose client joined with `caps`: the setting on
+ *  and the client sent `repeat@1`. Off, the cap is ignored and the seat is paced as one without it. */
+declare function repeatsSeat(repeat: InputRepeat, caps: readonly string[]): boolean;
+/** A seat that has sent nothing yet. */
+declare function seatRepeats(): SeatRepeats;
+/** Two inputs the preset steps alike: every held field equal. */
+declare function sameHeldInput(a: InputData, b: InputData): boolean;
+/** A starved tick: the input the preset steps again (the seat's last real one, held), counted as owed;
+ *  null when the seat has no input yet, its stick is not steady (fewer than `steadyMin` of its latest
+ *  inputs in a row alike: a repeat would likely stand in wrongly, so the seat holds as before), this
+ *  starve run already has `runMax` repeats, or it already owes `maxTicks` (it holds). */
+declare function repeatStarved(seat: SeatRepeats, maxTicks: number, steadyMin?: number, runMax?: number): InputData | null;
+/** Inputs this tick consumes: the pacer's `feed`, plus one more when a repeat is owed and the buffer
+ *  holds more than `feed` (the late input a repeat stood in for, with one behind it), within `cap`. */
+declare function feedWithPayback(seat: SeatRepeats, feed: number, buffered: number, cap: number): number;
+/** How one consumed input is used, in sequence order; `more`: another input is consumed after it this
+ *  tick (the tick's last input always steps). Records it as the seat's last real input. */
+declare function consumedUse(seat: SeatRepeats, input: InputData, more: boolean): InputUse;
+/** A new socket for the seat (a reconnect): its inputs count from 1 again and the client re-seeds from
+ *  the state, so no repeat is owed to it. The last input stays, for the next starve. */
+declare function forgiveRepeats(seat: SeatRepeats): void;
+/**
+ * The client's side: the input the state's entity of yours was stepped through, `ack` (Colyseus's
+ * `ackSeq`) plus the room's `inRep` for your seat, never past `sent` (a tab that stopped sending while
+ * the server repeated for it). A replay from the state replays the inputs after it (your reconciler
+ * compares at {@link reconcileThrough}); the seat rule's tick of input `seq` is
+ * `tick + (seq − steppedThrough)`. In a room whose setting `repeat` is off, `inRep` is never read: the ack.
+ */
+declare function steppedThrough(ack: number, inRep: number | undefined, sent: number, repeat?: InputRepeat): number;
+/**
+ * The input the state holds your entity stepped through: `ack + inRep` (a valid `inRep`, else none),
+ * not clamped to `sent` (a hitch steps it past the inputs you sent). In a room whose setting `repeat`
+ * is off: the ack. What {@link reconcilerAck} is handed.
+ */
+declare function stateThrough(ack: number, inRep: number | undefined, repeat?: InputRepeat): number;
+/**
+ * The input your reconciler compares the state with your prediction at, given the one it compared at
+ * last (`held`), §17.11 *The reconciler's ack*, its hitch clause alone: `ack + inRep` once you have sent
+ * that input. While the state is stepped past the last input you sent (`ack + inRep > sent`: a hitch
+ * drained your seat's buffer and the room repeated for inputs you have not sent yet), no prediction of
+ * yours is at the state's input, so the reconcile waits at `held` (never past `sent`) until you send it.
+ * Compared at `sent` instead, a held throttle was pulled forward by the repeated steps, then back by as
+ * many once the next inputs went out. In a room whose setting `repeat` is off: the ack. A reconciler
+ * is told {@link reconcilerAck}, which applies this clause and then the ring's.
+ */
+declare function reconcileThrough(held: number, ack: number, inRep: number | undefined, sent: number, repeat?: InputRepeat): number;
+/** The ack your reconciler was last told and the send count when it began holding one back (null:
+ *  not holding), §17.11 *The reconciler's ack*. */
+interface ReconcilerAckHold {
+    shown: number;
+    heldFrom: number | null;
+}
+/** A hold that has told the reconciler nothing yet. */
+declare function reconcilerAckHold(): ReconcilerAckHold;
+/**
+ * The ack your reconciler is told (§17.11 *The reconciler's ack*), from the input the state holds your
+ * entity stepped through (`through`, {@link stateThrough}: never clamped to `sent`). The hitch clause
+ * first: past `sent` it is the ack told last, never past `sent` ({@link reconcileThrough}). Then the
+ * ring's: that ack `stepped`, unless it advanced while input `stepped + 1` is in neither the replay ring
+ * (`ring` inputs back from `sent`) nor another copy (`kept`: the fast channel's). Then it stays the ack
+ * last told, so a state whose ack is still more than a ring behind your sends is not reconciled with its
+ * oldest inputs gone; at most a ring's length of sends from the first held ack, after which the
+ * reconciler is told `stepped` again and the hold is armed only by an ack within the ring or one that
+ * moved back. A hitch neither arms nor ends a hold.
+ */
+declare function reconcilerAck(hold: ReconcilerAckHold, through: number, sent: number, ring: number, kept: boolean): number;
+/** How much faster a throttled client runs while it builds its cushion (a share of real time; RL's
+ *  simulation time scaling is about 1%). At 3% a tick of lead takes 280 ms to build, and a frame never
+ *  draws more than 3% of its time ahead of the frame before. */
+declare const THROTTLE_DILATION = 0.03;
+/** A starve with at most this many of the seat's inputs buffered at the keyframe asks the client for
+ *  one more input of lead; a deeper buffer had the cushion, and the starve was a stall's. */
+declare const THROTTLE_LOW_INPUTS = 1;
+/** The share of the throttle's lead (`aheadMs`, and the part of an extra input still being paid,
+ *  `accMs`) the other seats are drawn on: 1 draws them on your input clock, as your own car and the
+ *  ball; 0 on the plain frame clock. Half: on car-ball at 200 ms (14 interleaved runs each), 1 drew other
+ *  cars ~3 ms further ahead than the base and eased 5% more correction into them (p 0.001), 0 cost the
+ *  ball (p 0.03); 0.5 kept both within the base (p 0.15, 0.21) and the loss-2 gain on how others see a
+ *  starving car (hitches p 0.025, lurches p 0.000). */
+declare const THROTTLE_SEAT_LEAD = 0.5;
+/** A client's upstream throttle: the starve runs it has answered, the lead (ms) still to add, and the
+ *  lead added so far (`aheadMs`: the client's clock runs this far ahead of real time, which whatever is
+ *  drawn on your input clock adds too, so it never jumps when an extra input goes out). */
+interface InputThrottle {
+    seenRuns: number | null;
+    owedMs: number;
+    accMs: number;
+    aheadMs: number;
+}
+/** A throttle that has seen no keyframe yet. */
+declare function inputThrottle(): InputThrottle;
+/** A state's `inStarve` and `inBuf` for your seat: a new starve run with at most THROTTLE_LOW_INPUTS
+ *  buffered owes one step (`stepMs`) of lead, at most one step owed at a time. The first reading only
+ *  takes the count. In a room whose setting `repeat` is off no reading is taken: nothing is ever owed. */
+declare function throttleState(t: InputThrottle, inStarve: unknown, inBuf: unknown, stepMs: number, repeat?: InputRepeat): void;
+/** The input clock other seats are drawn on (§17.11 *Input pacing*): the input `stepped` your entity
+ *  in the state was stepped through, plus `drawn` inputs past it where your entity is drawn, plus
+ *  THROTTLE_SEAT_LEAD of the throttle's part-paid extra input (`raw`), at THROTTLE_SEAT_LEAD of its lead
+ *  past the frame's instant (`at`). */
+declare function seatLeadClock(stepped: number, drawn: number, t: InputThrottle, stepMs: number, frameNow: number): {
+    raw: number;
+    at: number;
+};
+/** A frame `dtMs` long: the extra inputs it sends (0 or more), the owed lead paid THROTTLE_DILATION of
+ *  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;
+    /** Keyframes adopted by skip-on-match and by replay. */
+    matched: number;
+    replayed: number;
+    /** The slowest replay and the latest, ms (wall clock around one adoption's rebuild and replay). */
+    peakResimMs: number;
+    lastResimMs: number;
+    /** Replays longer than RESIM_FRAME_MS: each held a 60 Hz frame back. */
+    slowResims: number;
+    /** How many times the replay budget turned prediction off (`cpu`), and on again. */
+    fallbacks: number;
+    recoveries: number;
+}
+
+/** Largest launch tick (`t0` is an integer in [0, MAX_PROJECTILE_TICK]; 0 = not a projectile). */
+declare const MAX_PROJECTILE_TICK: number;
+/** Largest downward acceleration a projectile may carry, units/s² (`g` is in [0, MAX_PROJECTILE_G]). */
+declare const MAX_PROJECTILE_G = 1000;
+/** What a launch writes: the entity's float32 pose and velocity, its gravity and its launch tick. */
+interface ProjectileLaunch {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    /** Downward acceleration along −z, units/s². */
+    g: number;
+    /** The launch tick. */
+    t0: number;
+}
+/** A projectile at one instant. */
+interface ProjectileState {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+}
+/** Whether an entity is a projectile: its launch tick is set (§17.9 `t0 > 0`). */
+declare const isProjectile: (entity: {
+    t0?: unknown;
+}) => boolean;
+/**
+ * Where a projectile launched as `launch` is at tick `T` (whole or fractional), in a room at
+ * `tickHz`. Pure; float64 in the written order:
+ *  1. s = (T − t0) / tickHz; non-finite or negative → 0 (before its launch it sits at its origin);
+ *  2. x' = fround(x + vx·s), y' = fround(y + vy·s);
+ *  3. z' = fround(((z + (vz·s)) − (((0.5·g)·s)·s)));
+ *  4. vx' = vx, vy' = vy, vz' = fround(vz − g·s);
+ *  5. a −0 result is written as 0.
+ */
+declare function projectileAt(launch: ProjectileLaunch, T: number, tickHz: number): ProjectileState;
+/** The room's tick at server time `serverNowMs` (the room clock, ms): `(serverNow − tickOrigin) ·
+ *  tickHz / 1000`, fractional. `tickOrigin` is `AuthorityRoomState.tickOrigin`. */
+declare function serverTick(serverNowMs: number, tickOrigin: number, tickHz: number): number;
+/** Tick `tick`'s nominal instant on the room clock, ms: `tickOrigin + tick · 1000 / tickHz`. */
+declare function tickInstant(tick: number, tickOrigin: number, tickHz: number): number;
+
+/** A 3-vector, room units. */
+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 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 {
+    /** 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 query visits every solid). */
+    readonly grid?: SolidGrid;
+}
+/**
+ * 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
+ * what it meets: a solid none of the cast's cells holds fails its bounds test at every length.
+ */
+interface SolidGrid {
+    readonly x0: number;
+    readonly y0: number;
+    readonly size: number;
+    readonly nx: number;
+    readonly ny: 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: 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]`. */
+interface ContactWorldSpec {
+    readonly boxes?: readonly (readonly number[])[];
+    readonly ramps?: readonly (readonly number[])[];
+}
+/** Solids one push-out may move a body out of in turn (a corner is two walls and the floor). */
+declare const UNSTICK_SOLIDS = 4;
+/**
+ * The world `spec` grown by a hull of half side `r` and height `h` (§17.7's `slab` and `wedge`): boxes
+ * first, then ramps, each solid's bottom face last. A point closer than `skin` to a face is outside.
+ */
+declare function compileContactWorld(spec: ContactWorldSpec | null | undefined, r: number, h: number, skin: number): ContactWorld;
+/** Whether (x, y, z) is inside any solid of `world`. */
+declare function insideWorld(world: ContactWorld, x: number, y: number, z: number): boolean;
+/** Where a line first enters a solid: the distance along it and the face it crosses. */
+interface CastHit {
+    t: number;
+    face: Plane | null;
+}
+/** Faces a cast passes through: the surface a seat rides (its preset follows it), never a wall. */
+type FaceFilter = (face: Plane) => boolean;
+/** The faces a body whose support up is `up` rides: ground (a face whose z is at least `cos`, one a
+ *  body can stand on) within `cos` of its up. A wall is never ridden: it always stops a push. */
+declare const ridesOn: (up: V3, cos: number) => FaceFilter;
+/**
+ * The first solid of `world` the segment from `p` along unit `d` meets within `len`: the distance to
+ * where it comes within skin of it, and that face; `{ t: len, face: null }` when it is clear. Solids are
+ * visited in order; a tie keeps the earlier. A solid `p` is already inside is skipped (the push-out, not
+ * the cast, takes a body out of it), and so is one the segment would enter through a face `rides` passes.
+ */
+declare function castWorld(world: ContactWorld, p: V3, d: V3, len: number, rides?: FaceFilter): CastHit;
+/** How far a body's base at `p` can move along unit `d` before a grown solid, clamped to [0, len];
+ *  faces `rides` passes (the surface it rides) do not stop it. */
+declare function roomAlong(world: ContactWorld | null, p: V3, d: V3, len: number, rides?: FaceFilter): number;
+/**
+ * The support up of a body whose base is at (x, y, z) (§17.11 *Contact policy* step 1): the normal of
+ * the first face a cast straight down meets within `trace` (a ramp's top, a box's top), else world up
+ * (in the air). A cast starting inside a solid ignores that solid.
+ */
+declare function surfaceUp(world: ContactWorld | null, x: number, y: number, z: number, trace: number): V3;
+/** The face a body at (x, y, z) is pushed out of the first solid it is inside through (§17.7
+ *  *Starting inside*), as [nx, ny, nz, depth]; null when it is clear. */
+declare function insideFace(world: ContactWorld, x: number, y: number, z: number): Plane | null;
+/** A body's base the contacts left inside the world, pushed back out with the skin's clearance (x y z
+ *  changed in place), up to UNSTICK_SOLIDS solids in turn; returns the deepest push (0: it was clear).
+ *  `onFace` hears each face it is pushed out through, with the depth. */
+declare function unstickBody(world: ContactWorld, body: {
+    x: number;
+    y: number;
+    z: number;
+}, onFace?: (face: Plane) => void): number;
+
+/** A lift's pose at a tick: its centre and yaw (float32). */
+interface LiftPose {
+    readonly c: LiftVec;
+    readonly yaw: number;
+}
+/** Lift `lift`'s pose at `tick`; `start` is a called lift's call tick (undefined: not called). */
+declare function liftPose(lift: Lift, tick: number, start?: number): LiftPose;
+/** Every lift's pose at `tick`, in declared order; `starts` holds called lifts' call ticks by id. */
+declare function liftPoses(policy: LiftsPolicy, tick: number, starts?: ReadonlyMap<string, number>): LiftPose[];
+/** A lift's turn per tick (0 for none). */
+declare const spinStep: (lift: Lift) => number;
+/** A firstperson view on lift `lift` applied `lag` ticks later than its client meant (`inputTickLag`,
+ *  §17.11 *The input's tick*): the view `yaw` carried by the lift's turn over those ticks, float32. */
+declare const viewOnLift: (lift: Lift, yaw: number, lag: number) => number;
+/** A rider's pose as the carry reads and writes it (float64; the caller writes float32). */
+interface RiderPose {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly yaw: number;
+}
+/** A carried rider: its pose at the next tick and its point's velocity over the tick (u/s). */
+interface Carried extends RiderPose {
+    readonly v: LiftVec;
+}
+/**
+ * The carry of a rider on `lift` from `tick` to `tick + 1` (§17.11 *Lifts*, the carry slot): turned by
+ * the lift's spin about its centre, moved with the centre, then by a conveyor's surface velocity in the
+ * lift's frame at `tick + 1` over one tick; its yaw turned with the spin. `v` is the point's move over
+ * the tick: what a rider keeps on leaving (`impart: all`).
+ */
+declare function carryOnLift(lift: Lift, rider: RiderPose, tick: number, tickHz: number, start?: number): Carried;
+/** Every lift as a posed solid (§17.7 *Posed solids*) at the poses given (`liftPoses` at a tick), in
+ *  declared order: a box that never spins is axis-aligned, one that spins an `obox`, a disc a disc. */
+declare function posedSolids(policy: LiftsPolicy, poses: readonly LiftPose[]): PosedSolid[];
+/** A seat as the slots read and write it (float32 writes). */
+interface LiftSeat extends HullBody {
+    readonly id: string;
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    yaw: number;
+    /** Its contact tags and flags (the pair rules match them), for the head slabs. */
+    readonly tags?: readonly string[];
+    readonly flags?: number;
+}
+/** A room's contact policy, for the slots' head slabs and the carry by a lower seat (§17.11 step 6
+ *  `stand` with `ride`). */
+interface HeadsContext {
+    readonly policy: ContactPolicy;
+    readonly env: ContactEnv;
+}
+/** Riders carried through a chain of seats at most (a seat on a seat on a seat on a lift). */
+declare const RIDE_CHAIN_MAX = 4;
+/** What the carry slot did: each seat's lift at the tick's start (−1 none) and its carry's velocity,
+ *  the seats a lift crushed against the world, and each seat's place as the slot left it. */
+interface CarryReport {
+    readonly bases: readonly number[];
+    /** The seat each rides at the tick's start (its pair rule `stand` with `ride`), else null. */
+    readonly on: readonly (string | null)[];
+    readonly v: readonly (LiftVec | null)[];
+    readonly crushed: readonly {
+        seat: string;
+        lift: string;
+    }[];
+    /** Each seat's x y z after the carry slot: the ride slot reads a ridden seat's walk from it. */
+    readonly from: readonly LiftVec[];
+}
+/** A tick's lifts as posed solids at its start (`tick`) and its end (`tick + 1`): computed once a tick
+ *  and handed to both slots and the inputs' steps. */
+interface TickSolids {
+    readonly now: readonly PosedSolid[];
+    readonly next: readonly PosedSolid[];
+}
+/** The lifts posed at `tick` and `tick + 1`. */
+declare function tickSolids(policy: LiftsPolicy, tick: number, starts?: ReadonlyMap<string, number>): TickSolids;
+/**
+ * The carry slot of tick `tick`, before its inputs (§17.11 *Lifts*), on `seats` in their order (ids
+ * ascending), each changed in place, every support and carry read from the seats as they were:
+ *  1. its support: the lift it stands on among the lifts posed at `tick` (`ops.support`), or, with
+ *     `heads`, the seat whose head slab it stands on (ridden when their pair rule is `stand` with `ride`);
+ *  2. on lift L: carried by L to `tick + 1` (`carryOnLift`; a vehicle's yaw, `turnYaw`, turned with it);
+ *     riding seat S: by S's carry, a chain base first (S's walk this tick follows in `rideSlot`, after
+ *     the steps);
+ *  3. every other lift it is inside at `tick + 1`, in order: moved by that lift's move at its point,
+ *     then pushed out (`ops.pushOut`); still inside a solid: crushed by that lift.
+ * Writes x y z (yaw) as float32; the report's `from` is each seat's place as the slot left it.
+ */
+declare function carrySlot(policy: LiftsPolicy, seats: LiftSeat[], tick: number, tickHz: number, starts: ReadonlyMap<string, number> | undefined, ops: HullOps, turnYaw: boolean, posed?: TickSolids, heads?: HeadsContext): CarryReport;
+/**
+ * The ride slot of a tick, after its inputs' steps and before its contact pass (§17.11 *Lifts*): a seat
+ * riding seat S (`report.on`) is moved in x y by S's walk this tick (S's place now less its place after
+ * the carry slot, `report.from`: every step S's inputs took, none on a held starve) and by S's own ride,
+ * base first, RIDE_CHAIN_MAX deep, so it keeps its place on S's head (no lag at a start or a stop). Its
+ * carry's velocity gains that move (what it keeps on leaving S). `seats` are the carry slot's, in its
+ * order, changed in place (x y as float32); returns the report with the riders' velocities.
+ */
+declare function rideSlot(seats: LiftSeat[], report: CarryReport, tickHz: number): CarryReport;
+/**
+ * The impart slot of tick `tick`, after its contact pass: a seat that stood on lift L at the tick's
+ * start (`report.bases`) and no longer stands on it among the lifts posed at `tick + 1` keeps L's
+ * velocity at its point (`report.v`) when L imparts (`impart: all`); a seat that rode seat S
+ * (`report.on`) and no longer stands on S's head keeps its carry's velocity. Writes vx vy vz as float32.
+ */
+declare function impartSlot(policy: LiftsPolicy, seats: LiftSeat[], report: CarryReport, tick: number, starts: ReadonlyMap<string, number> | undefined, ops: HullOps, next?: readonly PosedSolid[], heads?: HeadsContext): void;
+
+/** A room's lifts as this client runs them: the policy (NO_LIFTS with heads only), the preset's hull
+ *  through this client's world, the heads (a declared policy with a stand rule) and the tick rate. */
+interface SeatLifts {
+    readonly policy: LiftsPolicy;
+    readonly ops: HullOps;
+    readonly vehicle: boolean;
+    readonly heads: HeadsContext | undefined;
+    readonly tickHz: number;
+}
+/** The lifts the room's preset text declares (`{ name, params, lifts }`) and its heads, through
+ *  `world`; null when it has neither, or its preset carries no hull (topdown). */
+declare function seatLiftsOf(presetText: string, world: FirstpersonWorld, heads: HeadsContext | undefined, tickHz: number): SeatLifts | null;
+/** The called lifts' starts the state's `lifts` text holds (`{"id":tick,…}`), or undefined. */
+declare function liftStartsOf(text: string | undefined): ReadonlyMap<string, number> | undefined;
+/** One tick of the slots as a predicted step runs it: the lifts at its start and end, the carry's
+ *  report (the ride slot's once it ran), the seats (ids ascending) as the carry left them, and each
+ *  seat's posed world. */
+interface LiftTick {
+    readonly tick: number;
+    readonly solids: TickSolids;
+    report: CarryReport;
+    readonly seats: LiftSeat[];
+    /** Seat id → the posed world its step runs through (the lifts at t + 1 and its head slabs). */
+    readonly posed: ReadonlyMap<string, PosedWorld>;
+    /** The lifts at t + 1 alone, for a seat with no head slab. */
+    readonly next: PosedWorld;
+}
+/** A client's compiled lifts by tick, for one set of starts. */
+declare class LiftSolidsCache {
+    private readonly kept;
+    private startsText;
+    /** Tick `tick`'s lifts at its start and end, and those at its end compiled for a step. */
+    at(policy: LiftsPolicy, tick: number, starts: ReadonlyMap<string, number> | undefined): {
+        solids: TickSolids;
+        next: PosedWorld;
+    };
+}
+/**
+ * The carry slot of tick `tick` on `seats` (ids ascending, changed in place, as float32), then each
+ * seat's posed world for its input step: the lifts posed at `tick + 1` and, with heads, its head slabs
+ * from the seats as the carry left them at their place plus velocity over `dt` (§17.11 *Lifts*, the
+ * host's carryLifts).
+ */
+declare function carryTick(l: SeatLifts, seats: LiftSeat[], tick: number, starts: ReadonlyMap<string, number> | undefined, dt: number, cache: LiftSolidsCache): LiftTick;
+/** The ride slot of tick `t` (after the steps, before the contacts) on its seats, their places set to
+ *  where the steps left them (changed in place); its report becomes the ride slot's. */
+declare function rideTick(l: SeatLifts, t: LiftTick): void;
+/** Seat `k` of tick `t` moved by `move` (x y) in a ride slot run elsewhere (your seat: the seat
+ *  prediction runs the slot with the other seats): its carry's velocity gains the move over the tick. */
+declare function rodeBy(l: SeatLifts, t: LiftTick, k: number, move: readonly [number, number]): void;
+/** The posed world seat `id` steps through in tick `t`. */
+declare const posedFor: (t: LiftTick, id: string) => PosedWorld;
+/** The impart slot of tick `t` on its seats as they are after the contacts (changed in place). */
+declare function impartTick(l: SeatLifts, t: LiftTick, starts: ReadonlyMap<string, number> | undefined): void;
+/** Every lift's pose at fractional tick `f`: between the poses at its two ticks (a spin the short way,
+ *  its yaw unwrapped by the turn of one tick). */
+declare function liftPosesAt(policy: LiftsPolicy, f: number, starts: ReadonlyMap<string, number> | undefined): LiftPose[];
+/** The lift (its index) a hull drawn at `p` stands on at fractional tick `f`, else −1. */
+declare function liftUnder(l: SeatLifts, p: {
+    x: number;
+    y: number;
+    z: number;
+    duck?: number;
+}, f: number, starts: ReadonlyMap<string, number> | undefined): number;
+/** A drawn pose: place and heading. */
+interface DrawnPose {
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+}
+/** A seat drawn at fractional tick `from` on lift `k`, carried in that lift's frame to tick `to`
+ *  (§17.11 *Client prediction*: `P_L(to) ∘ P_L(from)⁻¹ ∘ seat(from)`). Drawing only: Math's sine. */
+declare function inLiftFrame(policy: LiftsPolicy, k: number, p: DrawnPose, from: number, to: number, starts: ReadonlyMap<string, number> | undefined): DrawnPose;
+/** Lift `id`'s pose drawn at fractional tick `f` (centre and yaw), or undefined for no such lift. */
+declare function liftDrawnAt(policy: LiftsPolicy, id: string, f: number, starts: ReadonlyMap<string, number> | undefined): DrawnPose | undefined;
+/** Lift `k`'s top at fractional tick `f`. */
+declare function liftTopAt(policy: LiftsPolicy, k: number, f: number, starts: ReadonlyMap<string, number> | undefined): number;
+/**
+ * One seat's step on tick `tick` with the room's lifts' slots round it, as the host runs them for a seat
+ * alone (§17.11 *Lifts*): the carry, `step` through the lifts at t + 1 (its own head slabs left out: no
+ * other seat is known), the impart. What a physics client world's replay steps another seat by (`hold`,
+ * `inputDecay`); `body` (x y z, velocities, yaw, duck) is changed in place.
+ */
+declare function stepOnLifts(l: SeatLifts, starts: ReadonlyMap<string, number> | undefined, cache: LiftSolidsCache, step: (body: Record<string, number>, posed: PosedWorld) => void, body: Record<string, number>, tick: number, dt: number): void;
+/** A lift's body key in a physics room. */
+declare const liftBodyKey: (id: string) => string;
+/** A lift's collider as its kinematic body carries it: its box, or a disc's 16-sided prism (the
+ *  corners from the portable sine, so every SDK builds the same hull); a conveyor's is frictionless
+ *  (the conveyor rule, not friction, moves what it carries). */
+declare function liftCollider(lift: Lift): LiftCollider;
+/** A lift body's one collider. */
+interface LiftCollider {
+    key: string;
+    shape: {
+        kind: 'box';
+        half: [number, number, number];
+    } | {
+        kind: 'hull';
+        points: [number, number, number][];
+    };
+    friction?: number;
+}
+/** A lift body's pose: its centre and its yaw as a quaternion about z. */
+interface LiftBodyPose {
+    p: [number, number, number];
+    q: [number, number, number, number];
+}
+/** A lift's body pose at `tick`: its centre and its yaw as a quaternion about z (portable sine). */
+declare function liftBodyPose(lift: Lift, tick: number, starts: ReadonlyMap<string, number> | undefined): LiftBodyPose;
+/** A lift's kinematic body as a physics room spawns it at `tick` (the host at load at P(1), a client
+ *  world at the keyframe's tick + 1). */
+declare function liftBodySpawn(lift: Lift, tick: number, starts: ReadonlyMap<string, number> | undefined): {
+    key: string;
+    type: 'kinematic';
+    pose: LiftBodyPose;
+    colliders: LiftCollider[];
+};
+/** How fast a conveyor brings a body on it to its surface velocity, per second: a tick's rule takes
+ *  this over the tick rate (at most all) of the difference, so a crate is at 95% of the belt's speed
+ *  in about 150 ms at any tick rate and in any length unit. */
+declare const CONVEYOR_RATE = 20;
+/** A dynamic body as the conveyor rule reads it after the last step: centre and velocity. */
+interface ConveyorBody {
+    readonly key: string;
+    readonly p: readonly number[];
+    readonly v: readonly number[];
+}
+/** The conveyor a body centred at `p` is over at `tick`, as the conveyor rule reads it (inside its
+ *  footprint in its own frame, `0 < z − top ≤ reach`; the first in declared order): a test of the
+ *  body's place alone. */
+declare function conveyorUnder(policy: LiftsPolicy, tick: number, starts: ReadonlyMap<string, number> | undefined, reach: number): (p: readonly number[]) => Lift | undefined;
+/**
+ * The conveyor rule of tick `tick` (before its physics step): each dynamic body (key order) whose
+ * centre is over a conveyor's top at `tick` (inside its footprint in its own frame, above its top by at
+ * most `reach`: the preset body's height; the first such conveyor in declared order) has its horizontal
+ * velocity brought toward the carry velocity of its point from `tick` to `tick + 1` (the belt's surface
+ * turned with the lift, plus the lift's own move) by the share `min(1, CONVEYOR_RATE / tickHz)` of the
+ * difference; its vertical speed kept. Float64 on the float32 inputs; the velocities as the setVelocity commands carry them.
+ */
+declare function conveyorNudges(policy: LiftsPolicy, tick: number, starts: ReadonlyMap<string, number> | undefined, tickHz: number, bodies: readonly ConveyorBody[], reach: number): {
+    key: string;
+    v: [number, number, number];
+}[];
+
+/**
+ * A seat contact pass: what the room module does to every seat's entity after each tick's preset
+ * steps (car-ball's pairs, pile passes and world passes), as a pure function of them all, ids
+ * ascending, changing their fields in place. The module must run this very function. Without one, a
+ * session runs the pair rule (`contacts`) once on every pair, ids ascending.
+ */
+type AuthoritySeatPass = (seats: ContactBody[]) => void;
+/** Another seat's entity in the latest state: its preset fields (`body`), its life, and its last
+ *  applied input (§17.11 *State*; undefined where the room writes none: moved by its velocity). */
+interface HeldSeat {
+    id: string;
+    epoch: number;
+    body: Record<string, number>;
+    input: RemoteInput | undefined;
+}
+/** How fast a predicted seat's pose moves at an input: room units and radians per ms. */
+interface SeatRate {
+    vx: number;
+    vy: number;
+    vz: number;
+    vyaw: number;
+}
+/** A predicted seat at an input: its pose there and how fast its predicted track moves there. */
+interface SeatMotion {
+    pose: SeatPose;
+    rate: SeatRate;
+}
+/** A seat in the pass it was drawn from (`before`) and in the pass after it (`after`), at one input
+ *  both passes stepped: what a new pass changed. */
+interface SeatChange {
+    before: SeatMotion;
+    after: SeatMotion;
+}
+/** One fixed step of a seat's entity under `input` (the room preset's own step), mutating `body`. */
+type SeatStep = (body: Record<string, number>, input: RemoteInput, dt: number, posed?: PosedWorld) => void;
+/** The room's lifts as the seat prediction runs them (§17.11 *Lifts*): the slots, the called lifts'
+ *  starts and the compiled solids. */
+interface SeatWorldLifts {
+    lifts: SeatLifts;
+    starts: ReadonlyMap<string, number> | undefined;
+    cache: LiftSolidsCache;
+}
+/** A predicted seat after one tick: position, heading (radians) and velocity (room units, per second). */
+interface SeatPose {
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+    vx: number;
+    vy: number;
+    vz: number;
+}
+interface SeatWorldOptions {
+    /** The room module's seat contact rule, on two seats (`a` the lower id). */
+    rule: AuthorityContactRule;
+    /** The room module's whole contact pass; absent: the rule once on every pair. */
+    pass?: AuthoritySeatPass;
+    /** Every other seat in the latest state. */
+    others: () => readonly HeldSeat[];
+    /** The room preset's step, or undefined when this client has none (seats are then extrapolated). */
+    step: () => SeatStep | undefined;
+    /** The room module's seat rule, run on each other seat before each of its steps. */
+    seatRule?: AuthoritySeatRule;
+    /** How other seats move between states (`physDesc.remotePredict`, `remoteDecayMs`). */
+    remote: () => {
+        predict: RemotePredict;
+        decayMs: number;
+    };
+    /** The room's lifts and head slabs, run around each tick's steps as the host runs them; none: no carry. */
+    lifts?: () => SeatWorldLifts | null;
+    /** How far past a state other seats are predicted at most, ms (the lead cap and STALL_PREDICT_MS):
+     *  further on they hold where that left them. */
+    maxAheadMs: () => number;
+}
+/** Other seats keep being predicted through a stall (no new state) this long past the lead cap, ms,
+ *  then hold. */
+declare const STALL_PREDICT_MS = 500;
+/** One pass: the seats stepped from one state, tick by tick, as your inputs ack + 1, ack + 2, … were. */
+interface SeatPass {
+    readonly id: number;
+    readonly ack: number;
+    readonly stateTick: number;
+    readonly tickHz: number;
+    /** The last of your inputs applied, and the ticks the seats were stepped. */
+    last: number;
+    ticks: number;
+    readonly seats: {
+        id: string;
+        epoch: number;
+        body: Record<string, number>;
+        input: RemoteInput | undefined;
+    }[];
+    /** Each seat's pose after the tick your input `seq` was applied on (seq `ack`: the state's). */
+    readonly poses: Map<number, Map<string, SeatPose>>;
+    /** The seats touching your entity in the tick of input `seq` (before the contact pass). */
+    readonly touching: Map<number, Set<string>>;
+    /** Your entity after the contact pass of the tick of input `seq`. */
+    readonly own: Map<number, ContactBody>;
+    /** Your entity as that tick's pass was given it (after your step, before any contact). */
+    readonly ownIn: Map<number, ContactBody>;
+    /** The seat your carry slot had you ride in the tick of input `seq` (null: none). */
+    readonly ownOn: Map<number, string | null>;
+}
+/**
+ * The other seats predicted from the latest state, as your own entity's prediction steps your inputs.
+ * `apply` after your input `seq` was stepped into your entity: a new pass starts when the state's ack
+ * or tick changed, or `seq` is not after the last input applied (a replay), and the other seats are
+ * stepped to that input's tick, then the contact pass runs on all of them and yours.
+ */
+declare class SeatWorld {
+    private readonly options;
+    private serial;
+    /** The current pass. */
+    current: SeatPass | null;
+    /** The passes before it, newest first (RECENT_PASSES): stepped on with the current one's ticks, so
+     *  a seat last drawn from one of them is compared with the current pass at the same input, both
+     *  stepped there (a bump or a turn the next tick brings is in both, not a correction). */
+    private recent;
+    /** The seats touching your entity in the tick each of your inputs was stepped live in (`apply`'s own
+     *  step, not a re-run), by input: what your prediction's contacts were stepped with. */
+    private applied;
+    /** The seats a pass found touching your entity in an input it was already stepped through that the
+     *  input's live step did not have touching it (`takeMissed`). */
+    private missed;
+    constructor(options: SeatWorldOptions);
+    /**
+     * After your input `seq` was stepped into `own` (the state of tick `stateTick` having consumed your
+     * inputs through `ack`): the other seats stepped to that input's tick and the contact pass run on
+     * every seat. Your fields the pass changed are written back as float32 (the entity's wire type).
+     */
+    apply(seq: number, ack: number, stateTick: number, own: ContactBody, tickHz: number, rides?: string | null): readonly [number, number] | null;
+    /**
+     * The seats a pass found touching your entity that your prediction was not stepped with since the last
+     * call, ids ascending (§17.11 *Seat contacts*), and forgets them: a state that put your inputs in
+     * flight on later ticks (one that consumed none of them, then one that consumed several) re-runs
+     * inputs your entity was already stepped through, and the other seats, run on from that state, can
+     * reach yours in one of them. Your entity's changes in a re-run are not kept, so it would stand there
+     * as a wall the other seat stops against: the session re-predicts your inputs from the state instead,
+     * and draws these seats at your entity's input at once.
+     */
+    takeMissed(): string[];
+    /** Pass `pass`'s re-run of your input `seq`: each seat touching yours there that the input's live step
+     *  did not have touching it is missed (a live step with no record is not judged). */
+    private noteMissed;
+    /** Pass `old` stepped on to your input `seq` with your entity as `now` was given it at each tick. */
+    private extend;
+    /** Where seat `id` is at your input `seq` (fractional: between two inputs), in pass `pass` (default
+     *  the current one): between the two ticks around it, moved on by its velocity past the last one
+     *  stepped (the current pass at most a tick, which the next input steps; a pass before it as far as
+     *  asked: where it would have drawn the seat, which a new pass's correction is measured from).
+     *  Undefined for a seat the pass does not have. */
+    poseAt(id: string, seq: number, pass?: SeatPass | null): SeatPose | undefined;
+    /**
+     * Seat `id` at your input `seq` in `pass` (default the current one): its pose and the slope of its
+     * predicted track over the half inputs either side, per ms of your inputs' ticks. That slope is what
+     * the drawn seat moves by (contact push-outs included, which the body's velocity leaves out).
+     */
+    motionAt(id: string, seq: number, pass?: SeatPass | null): SeatMotion | undefined;
+    /**
+     * What the current pass changed for seat `id` from pass `from` (the one it was last drawn from): the
+     * seat in both at your input `seq`, or at `from`'s last stepped input when `seq` is past it (the seat
+     * clock can draw past your last input). Past its last tick the current pass moves a seat on by its
+     * velocity, a tick at most, and `from` along its last steps: compared there, the drawing's own
+     * advance read as a correction. A recent pass is stepped on with the current one, so both have that
+     * input stepped; an older one goes on past its last tick along its last steps (`beyond`).
+     * Undefined when `from` is the current pass.
+     */
+    changeAt(id: string, seq: number, from: SeatPass): SeatChange | undefined;
+    /**
+     * How soon seat `id` touches your entity from your input `seq`, ms (§17.11 *Drawing other seats*,
+     * *Touching*): 0 when the pass's own contact test had the two touching in the tick of an input from
+     * `seq` to the one after it (a contact your predicted steps resolve); else the first of
+     * SEAT_TOUCH_SAMPLES steps along SEAT_CLOCK_TAU_MS at which the room's contact rule touches your
+     * entity there with the seat moved on from it at the two's relative velocity; undefined when it does
+     * not within SEAT_CLOCK_TAU_MS (not touching).
+     */
+    touchAheadMs(id: string, seq: number): number | undefined;
+    /** Whether seat `id` touches your entity in the tick of your input nearest `seq`. */
+    touchingAt(id: string, seq: number): boolean;
+    /** How fast seat `id` moves in the latest state (the server's car, the pass's first pose), room units
+     *  per ms; undefined for a seat the current pass does not have. */
+    stateRate(id: string): SeatRate | undefined;
+    private start;
+    /** Tick `i` of the pass (your input ack + i): every other seat stepped, the ride slot, then the
+     *  contact pass on every seat with yours (`own`, when known; `rides`: the seat your carry slot had
+     *  you ride); `write`: your fields the pass changed written back. Answers the move the ride gave you. */
+    private tick;
+    /**
+     * Tick `i`'s ride slot (§17.11 *Lifts*, after the steps, before the contacts): the carry's seats set
+     * to where the steps left the other seats and yours (`mine`), every rider moved by its ridden seat's
+     * walk. Your entity rides as your carry slot had it (`rides`): the slot's move for it when this pass
+     * knew you at the tick's start, else the ridden seat's walk and ride. Answers your move, or null.
+     */
+    private ride;
+    /** Tick `i`'s carry slot on every other seat (your entity as the tick before left it, when known),
+     *  their carried places written into them; null without lifts. */
+    private carry;
+    /** Tick `i`'s impart slot on every other seat, after the contact pass (`mine`: your entity after it). */
+    private impart;
+    /** One seat's tick `i`: the seat rule, then its step under its held (or decayed) input (through the
+     *  tick's lifts and its head slabs, `posed`), or its velocity when it has no input or this client no step. */
+    private move;
+    /** The room's pass on `all` (ids ascending), or its rule once on every pair. */
+    private contactPass;
+    /** Whether the rule changes your entity or seat `b` (copies of the two): they touch. */
+    private touches;
+}
+/** The input other seats are drawn at (fractional) and the frame's time (ms). */
+interface SeatClock {
+    seq: number;
+    at: number;
+}
+/**
+ * The input other seats are drawn at this frame (§17.11 *Drawing other seats*): last frame's moved on
+ * by the time since at the room's tick rate, then pulled toward the input your entity is drawn at
+ * (`raw`) by a share 1 − e^(−dt / SEAT_CLOCK_TAU_MS), never back; more than SEAT_CLOCK_SNAP_INPUTS off (a
+ * reset, a stall), it is `raw`. Your entity's render fraction restarts at 0 on a frame that sends one
+ * input more than the time asked for (Colyseus' Predict clamps its accumulator), so `raw` moved on by
+ * most of a third input on one frame in four at 57 frames a second: drawn there, every other seat
+ * stepped half a frame's travel at once.
+ */
+declare function seatClock(known: SeatClock | undefined, raw: number, at: number, tickHz: number): SeatClock;
+/**
+ * A seat's share of the way from the seat clock's input to your entity's exact one this frame (§17.11
+ * *Drawing other seats*, *Touching*): last frame's moved toward 1 while the seat is touching yours
+ * (`touchAheadMs` has a time) and toward 0 when it is not, by dtMs / SEAT_CLOCK_TAU_MS, the seat clock's
+ * own time to move other seats from one input clock to another; a seat without a share yet takes its
+ * target. Only the clock is blended: a touching seat keeps its correction (a rival misprediction it
+ * eases), and taking the share at once, or fading the correction with it, moved a car-ball car its
+ * whole correction (~100 u at 200 ms) in a frame: remote snaps 5 to 24 a run.
+ */
+declare function seatTouchShare(known: number | undefined, touching: boolean, dtMs: number): number;
+/** A drawn seat's correction: the offset (room units, radians) from its predicted pose to where it is
+ *  drawn and how fast that offset is moving (per ms), the pass it was measured in and the seat's life;
+ *  the predicted position it was drawn from (`ax`, `ay`, `az`, in that pass); and the way the drawn
+ *  seat was last seen moving (`hx`, `hy`, `hz`, a unit vector, 0 before it moved) and how long it has
+ *  been drawn slower than SEAT_MOVING_UNITS_PER_MS since (`stillMs`); and whether a new pass found it
+ *  stopping late (`stopFound`: slower along that way, at the same input, than the pass it was drawn
+ *  from by more than SEAT_MOVING_UNITS_PER_MS; kept while it is drawn stopped, decided again by each
+ *  pass that arrives while it is drawn moving). */
+interface SeatOffset {
+    pass: SeatPass | null;
+    epoch: number;
+    dx: number;
+    dy: number;
+    dz: number;
+    dyaw: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    vyaw: number;
+    ax: number;
+    ay: number;
+    az: number;
+    hx: number;
+    hy: number;
+    hz: number;
+    stillMs: number;
+    stopFound: boolean;
+}
+/** A shove's ease (`shoveEase`) is done once what is left of it is under this, world units. */
+declare const SHOVE_EASE_DONE = 0.01;
+/** What is left, `elapsedMs` after your inputs were predicted again from the state after a missed
+ *  contact, of the shift `from` (the drawn pose less the new prediction) that eases out at SEAT_TAU_MS:
+ *  `offset` is added to the predicted pose, and `done` once the largest axis is under SHOVE_EASE_DONE
+ *  (the ease is dropped and nothing is added). Pinned by `shoves` in carball-seat-predict.json. */
+declare function shoveEase(from: {
+    dx: number;
+    dy: number;
+    dz: number;
+}, elapsedMs: number): {
+    dx: number;
+    dy: number;
+    dz: number;
+    done: boolean;
+};
+/** τ of a seat's correction (ms): SEAT_CONTACT_TAU_MS while it touches your entity in the prediction
+ *  (a bump lands where it is drawn), else SEAT_TAU_MS. */
+declare const seatTauMs: (touching: boolean) => number;
+/**
+ * A seat's correction this frame (§17.11 *Drawing*): last frame's offset `known` brought `dtMs` closer
+ * to 0 by a critically damped return at the seat's τ (no overshoot; a first-order decay moves a
+ * correction C by C/τ at once, which reads as a one-frame jump), plus what a new pass changed (`change`,
+ * `SeatWorld.changeAt`: the seat in the pass it was drawn from and in this one, at an input both
+ * stepped). The offset takes the change of where it is, and its rate the change of how fast it moves,
+ * so the drawn seat keeps both its place and its velocity on the frame a new pass arrives and turns
+ * onto the new track over the next frames; the return never pulls it back against its drawn motion
+ * (`keepCourse`), nor while the server's car (`server`, the seat's velocity in the latest state,
+ * `SeatWorld.stateRate`) still moves that way. `now` is the seat in this pass at the drawn input. A new
+ * life (epoch) or an offset over `snapUnits` starts at 0: drawn where it is predicted.
+ */
+declare function seatOffset(known: SeatOffset | undefined, pass: SeatPass, epoch: number, change: SeatChange | undefined, now: SeatMotion, dtMs: number, touching: boolean, snapUnits: number, server?: SeatRate): SeatOffset;
+
+/** A seat as the policy sees it: its entity's fields, its tags (pair rules match them) and whether
+ *  its jump is held (a stomp's boost). `flags` bit k adds the tag `flag:k`. */
+interface PolicyBody extends ContactBody {
+    tags?: readonly string[];
+    flags?: number;
+    jump?: number;
+}
+/** Whether a contact is between two sides or one seat over another's top. */
+declare const ContactKind: {
+    readonly Side: "side";
+    readonly Top: "top";
+};
+type ContactKind = (typeof ContactKind)[keyof typeof ContactKind];
+/** How a top contact's slide went: along the upper seat's free way, the lower seat's, or neither. */
+declare const SlideWay: {
+    readonly Free: "free";
+    readonly LowerYields: "lower-yields";
+    readonly Pinned: "pinned";
+};
+type SlideWay = (typeof SlideWay)[keyof typeof SlideWay];
+/** What the module hears from the pass (a stomp's damage stays a server event, never predicted). */
+declare const ContactEvent: {
+    readonly Stomp: "stomp";
+};
+type ContactEvent = (typeof ContactEvent)[keyof typeof ContactEvent];
+/** What the policy runs against: the world grown by the seats' hull, and optionally the module's own
+ *  support up (car-ball's `carUp`, a pure function of the base) and a listener for its events. */
+interface ContactEnv {
+    readonly world: ContactWorld | null;
+    readonly supportUp?: (x: number, y: number, z: number) => V3;
+    /** Hears a pair's event: a stomp names the upper seat first. */
+    readonly onContact?: (upper: PolicyBody, lower: PolicyBody, event: ContactEvent) => void;
+    /** 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 {
+    kind: ContactKind;
+    n: V3;
+    depth: number;
+    /** Whether `b` is the upper seat (top contacts; for side contacts the higher across the plane). */
+    upperIsB: boolean;
+}
+/** What one pair step did: its contact, the impulse along the axis (a slide's change), and a top
+ *  contact's slide: how it went and the way taken (unit, the direction the sliding seat moves). */
+interface PairOutcome extends PairContact {
+    j: number;
+    way: SlideWay | null;
+    w: V3 | null;
+}
+/** A seat's body for one pair test: its geometric up, support up, half extents, top and heading. */
+interface Frame {
+    b: PolicyBody;
+    up: V3;
+    support: V3;
+    hl: number;
+    hw: number;
+    top: number;
+    s: number;
+    c: number;
+}
+/** A seat's frame: a box turned with its heading and laid on its support up; a hull upright. */
+declare function frameOf(b: PolicyBody, policy: ContactPolicy, env: ContactEnv): Frame;
+/** A seat's tags: its own, and `flag:k` for each bit k set in its `flags`. */
+declare function tagsOf(b: PolicyBody): string[];
+/** The first pair rule matching the two seats' tags (either way round), else the policy's top. */
+declare function topRuleOf(policy: ContactPolicy, a: PolicyBody, b: PolicyBody): TopRule;
+/**
+ * The contact of seats `a` and `b` under `policy` (§17.11 *Contact policy* steps 1-3): its kind, axis
+ * (unit, from a to b), depth and which seat is upper; null when they do not touch.
+ */
+declare function contactOf(a: PolicyBody, b: PolicyBody, policy: ContactPolicy, env: ContactEnv): PairContact | null;
+/** Whether two seats' bases are too far apart for their bodies to touch, or one to rest on the other
+ *  (its ground trace and a unit over): no frame is laid for them (each a cast down the world). */
+declare function farApart(a: PolicyBody, b: PolicyBody, policy: ContactPolicy): boolean;
+/**
+ * The shares of a side push of `depth` along `n` (from a to b) that `a` and `b` take (§17.11 step 4):
+ * each the part of the push its way takes (straight to a wall, then along it in the plane it rides, its
+ * support up `upA`, `upB`), `a` at most half (equal masses), `b` at most the rest, then `a` the rest of
+ * what `b` could not take. Continuous in position. A face a seat rides (`ridesA`, `ridesB`: within
+ * `supportCos` of its support up) does not stop its push: its preset follows that surface, so only
+ * walls and ceilings take a share away.
+ */
+declare function yieldShares(a: PolicyBody, b: PolicyBody, n: V3, depth: number, world: ContactWorld | null, ridesA?: FaceFilter, ridesB?: FaceFilter, upA?: V3, upB?: V3, wantA?: number): [number, number];
+/** How far seat `upper`'s centre is off seat `lower`'s, as a share of the lower's half extent: the
+ *  larger of the two in the lower's heading frame (Chebyshev for a hull's square footprint). */
+declare function headOffset(upper: PolicyBody, lower: PolicyBody, policy: ContactPolicy): number;
+/** The least closing speed on a head that is a landing (u/s): above one tick of gravity at any tick
+ *  rate from 10 Hz (800 u/s² × 0.1 s), so a released seat falling back onto the top is not one, and
+ *  below a fall from 6 u (√(2 · 800 · 6.25)). */
+declare const HEAD_LANDING_SPEED = 100;
+/** How a seat over a `stand` head is held (§17.11 step 6 `stand`): it stands (and gets the head's slab);
+ *  it is released (no slab, no kick: it is already leaving); or it slides off by the stand's slide. */
+declare const HeadHold: {
+    readonly Stand: "stand";
+    readonly Release: "release";
+    readonly Slide: "slide";
+};
+type HeadHold = (typeof HeadHold)[keyof typeof HeadHold];
+/**
+ * The stand test (§17.11 step 6 `stand`, and the head slabs): how seat `upper`, over seat `lower` whose
+ * pair rule is the stand `rule`, is held. `center` null: it stands. Else a seat within `center` of the
+ * lower's half extent (headOffset) stands; a landing (closing on it faster than HEAD_LANDING_SPEED)
+ * beyond it slides; a resting seat beyond it whose lower moves away from under it (leavingOf) at half
+ * its slide's step (the slide's speed when the step is null) or more is released (it is leaving: the
+ * lower walked away under it); else it slides once its centre is past the footprint and stands until then.
+ */
+declare function headHold(upper: PolicyBody, lower: PolicyBody, rule: StandRule, policy: ContactPolicy): HeadHold;
+/** Whether seat `upper` stands on seat `lower` under `rule` (a stand that holds it: it gets the slab). */
+declare const headStands: (upper: PolicyBody, lower: PolicyBody, rule: TopRule, policy: ContactPolicy) => boolean;
+/**
+ * Two seats `a` and `b` (`a` the lower id) under `policy` (§17.11 *Contact policy* steps 1-6), changed
+ * in place: a ghost pair or two that do not touch are left as they are (null); a side contact is pushed
+ * apart; a top contact is set on the lower seat's top and runs its pair's top policy. `cooling` holds a
+ * side contact's impulse back (the release-1 room's pair cooldown). `others`: the rest of the pass's
+ * seats, whose tops an upper seat also rests on (its free way clears them all).
+ */
+declare function contactPair(a: PolicyBody, b: PolicyBody, policy: ContactPolicy, env: ContactEnv, cooling?: boolean, others?: readonly PolicyBody[]): PairOutcome | null;
+/** What a contact pass did. */
+interface ContactReport {
+    /** Passes that touched a pair. */
+    passes: number;
+    /** Each seat's deepest push out of the world, by id. */
+    pushed: Map<string, number>;
+    /** Each seat's deepest push out through a wall (a face it could not stand on: its z under
+     *  `supportCos`), by id: what the contacts drove into a wall for the push-out to undo. */
+    walls: Map<string, number>;
+    /** Top contacts that stood pinned (no free way for either seat). */
+    pinned: number;
+}
+/** Options of a pass: the release-1 room's pair cooldown, a module's own rule for the first pass's
+ *  pairs (car-ball's release-1 sweep over its 60 Hz tick: a pair it answers, null or an outcome, is not
+ *  run through the policy; undefined leaves it to the policy), and a listener for every pair touched. */
+interface ContactPassOptions {
+    cooling?: (a: PolicyBody, b: PolicyBody) => boolean;
+    first?: (a: PolicyBody, b: PolicyBody, cooling: boolean) => PairOutcome | null | undefined;
+    onPair?: (a: PolicyBody, b: PolicyBody, outcome: PairOutcome) => void;
+}
+/**
+ * The contact pass (§17.11 *Contact policy* step 7) over `seats` (ids ascending, changed in place): every
+ * pair in id order, then a pile's further passes, up to `policy.passes`, on the pairs still more than
+ * `slop` inside each other; after every pass that touched, every seat the contacts drove into the world
+ * pushed back out (§17.7 *Starting inside*). The server's seat contact pass and the client's replay.
+ */
+declare function contactPass(seats: PolicyBody[], policy: ContactPolicy, env: ContactEnv, options?: ContactPassOptions): ContactReport;
+/** The policy as a seat contact rule on two seats (`connectAuthority({ contacts })`, `separateSeats`'
+ *  drawing guard): one pair step. */
+declare const contactRuleOf: (policy: ContactPolicy, env: ContactEnv) => AuthorityContactRule;
+/** The policy as a whole seat contact pass (`connectAuthority({ contactPass })`). */
+declare const contactPassOf: (policy: ContactPolicy, env: ContactEnv) => AuthoritySeatPass;
+/** A kinematic-rule body a seat may stand on: its box at the tick and how far it moves to the next. */
+interface KinematicSupport {
+    key: string;
+    min: V3;
+    max: V3;
+    /** Its move from this tick to the next (`kinematicRule(t + 1) − kinematicRule(t)`). */
+    dp: V3;
+}
+/** What one seat stands on: another seat or a kinematic body, and the base velocity it gives. */
+interface Ride {
+    id: string;
+    on: string;
+    v: V3;
+}
+/**
+ * The `stand` ride (§17.11 *Contact policy* step 6, run in the seat-rule slot before the tick's preset
+ * steps): each seat standing on a kinematic body or on a seat whose pair rule is `stand` is carried by
+ * its support's velocity for the tick (`1 / tickHz`; a kinematic body's move to the next tick); a seat
+ * leaving it upward (`vz > 0`) keeps that velocity. Every ride is found from the seats as they were
+ * before any moved (ids ascending). Changes x y (vx vy on leaving) in place; returns the rides.
+ */
+declare function rideStep(seats: PolicyBody[], supports: readonly KinematicSupport[], policy: ContactPolicy, env: ContactEnv, tickHz: number): Ride[];
+
+/** A declared policy as the session runs it: the pair rule and the whole pass. */
+interface DeclaredContacts {
+    policy: ContactPolicy;
+    rule: AuthorityContactRule;
+    pass: AuthoritySeatPass;
+    /** The static world the policy runs through (for the head slabs' stand test). */
+    env: ContactEnv;
+    /** The pair rule a drawing runs against your entity `you` (its id): yours fixed, the other seat
+     *  taking the whole push its way allows (§17.11 *Drawing other seats*). */
+    drawRule: (you: string) => AuthorityContactRule;
+}
+/**
+ * The policy the room's preset text declares (`{ name, params, contacts }`), run through `world` (the
+ * static world this client steps the preset through); null when the text declares none.
+ */
+declare function declaredContacts(presetText: string, world: ContactWorldSpec): DeclaredContacts | null;
+
+/** The field's range: the tick modulo this (a uint16 on the wire). */
+declare const INPUT_TICK_MOD = 65536;
+/** The farthest an input's applied tick may be from the tick it carries, in seconds of ticks: past it
+ *  the field is ignored (an input that old, or that far ahead, was not re-timed by pacing). */
+declare const INPUT_TICK_SLACK_S = 0.5;
+/** The field a client writes for an input it predicts at server tick `tick` (an integer): `tick`
+ *  modulo INPUT_TICK_MOD, in [0, INPUT_TICK_MOD). A tick that is not a finite integer writes 0. */
+declare function inputTickField(tick: number): number;
+/** The most ticks an input's applied tick may be off the tick it carries at `tickHz` (at least 1). */
+declare const inputTickSlack: (tickHz: number) => number;
+/**
+ * How many ticks later than the client meant an input is applied (negative: earlier): the input
+ * carries `field` (the tick it was predicted for, modulo INPUT_TICK_MOD) and is applied at server tick
+ * `applied`. The carried tick is the one congruent to `field` nearest `applied`; 0 when `field` is not
+ * an integer in [0, INPUT_TICK_MOD), when `applied` is not a safe integer, or when the two are more
+ * than {@link inputTickSlack} apart (a hostile or stale field changes nothing).
+ */
+declare function inputTickLag(field: unknown, applied: number, tickHz: number): number;
+
+/** One seat's head slabs: the posed solids and, by the same index, the id of the seat each is the top of. */
+interface HeadSlabs {
+    readonly solids: PosedSolid[];
+    readonly lowers: string[];
+}
+/** Whether a policy has any `stand` rule (its top or a pair's): a room without one has no head slabs. */
+declare function hasStand(policy: ContactPolicy): boolean;
+/** Seat `lower`'s top as a slab at its place plus its velocity over `dt`: `groundTrace` thick under the
+ *  top, a hull's square footprint, a box turned with its heading. */
+declare function headSlab(lower: PolicyBody, policy: ContactPolicy, dt: number): PosedSolid;
+/** Whether any seat could get any other's slab moved by up to `dt` of its velocity (the height band
+ *  and the reach alone): false lets a tick skip the heads altogether, with the same result. */
+declare function mayStand(seats: readonly PolicyBody[], policy: ContactPolicy, dt?: number): boolean;
+/**
+ * Every seat's head slabs (ids ascending in `seats`, read as they are): for seat i, the slab of each
+ * other seat it may stand on, in order, at its place plus its velocity over `dt` (0 at the tick's start
+ * for the carry slot's support; the tick's dt for the input steps).
+ */
+declare function headSlabs(seats: readonly PolicyBody[], policy: ContactPolicy, env: ContactEnv, dt: number): HeadSlabs[];
+/** A seat as the prop rule reads it: its feet and velocity (room units, per second). */
+interface PropSeat {
+    readonly key: string;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly vx: number;
+    readonly vy: number;
+}
+/** A dynamic module body as the prop rule reads it after the last step: centre and velocity. */
+interface PropBody {
+    readonly key: string;
+    readonly p: readonly number[];
+    readonly v: readonly number[];
+}
+/** A velocity the prop rule sets (room units per second). */
+interface PropNudge {
+    key: string;
+    v: [number, number, number];
+}
+/** The first seat (in the order given) whose top a body centred at `p` is over, as the prop rule reads
+ *  it (within its preset body's footprint `half`, above its top by at most the seat's height): a test
+ *  of the body's place alone. */
+declare function seatUnderProp(seats: readonly PropSeat[], half: readonly number[], p: readonly number[]): PropSeat | undefined;
+/**
+ * The prop rule under `headFriction: slide` (after the module's body rule, before the physics step):
+ * each dynamic body (key order) whose centre is over a seat's top (within its preset body's footprint
+ * `half`, above its top by at most the seat's height; the first such seat in key order) has its
+ * parting from that seat, along the way from the seat's centre to its own (+x when centred), brought
+ * up to `slide.speed` by at most `slide.step`; vertical speed kept. Float64 on float32 inputs.
+ */
+declare function propSlideNudges(seats: readonly PropSeat[], half: readonly number[], bodies: readonly PropBody[], slide: PropSlide): PropNudge[];
+
+/** `[psin(a), pcos(a)]` in one reduction (§17.7's steps 1–7; steps 2–5 are shared). */
+declare function psincos(a: number): [number, number];
+/** The portable sine of a float64 angle (§17.7): the same bits in every engine. A non-finite angle,
+ *  or one past ±1e9, is read as 0. */
+declare const psin: (a: number) => number;
+/** The portable cosine of a float64 angle (§17.7): the same bits in every engine. A non-finite
+ *  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 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. */
+type RelayProbe = (url: string, timeoutMs: number) => Promise<number>;
+type RelaySelectOptions = {
+    /** Default: one Colyseus ping (`Client.getLatency`) on a fresh socket. */
+    probe?: RelayProbe;
+    /** Samples per relay, taken concurrently. */
+    samples?: number;
+    /** A sample still unanswered after this is a failed sample; also the whole selection's ceiling. */
+    timeoutMs?: number;
+    /** Once any relay has answered, how much longer the others get before the choice is made. */
+    graceMs?: number;
+};
+
+/** One region of the authority cluster: its name and the servers a join may enter it through. */
+type AuthorityRegion = {
+    region: string;
+    urls: string[];
+};
+/** A region as a join enters it: through one of its urls. */
+type AuthorityRegionPick = {
+    region: string;
+    url: string;
+};
+/** One attempt of a join: the region (an index into the ranked list) and the wait before it, ms. */
+type CapacityAttempt = {
+    region: number;
+    waitMs: number;
+};
+/** 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;
+/** 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. */
+declare function regionProbePlan(urls: readonly string[], samples: number): string[];
+/** 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[];
+/** 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`. */
+type PredictedBody = Pick<EntityData, 'x' | 'y' | 'z' | 'vx' | 'vy' | 'vz' | 'yaw'> & Partial<Pick<EntityData, 'pitch' | 'duck' | 'mstate' | 'cap' | 'spin' | 'fuel'>>;
+type PredictedField = keyof PredictedBody;
+/** A game's own prediction step: advance `body` by one fixed step of `dt` seconds under `input`
+ *  (already sanitized like the server's). It must be the step the room module runs. */
+type AuthorityStep = (body: PredictedBody, input: InputData, dt: number, posed?: PosedWorld) => void;
+/** How the own entity is predicted: with your step, mirroring `fields` (default: all of them). */
+type AuthorityPrediction = {
+    step: AuthorityStep;
+    fields?: readonly PredictedField[];
+};
+type AuthorityConnectOptions = {
+    /** Authority cluster urls (pass `getAuthorityUrls()` from @genex-ai/embed-sdk). Without `regions`,
+     *  each is a region of its own (§17.1 *Regions*): several are probed for latency like the relay's;
+     *  one connects straight to it. */
+    urls: string[];
+    /** The cluster's regions (pass `getAuthorityRegions()` from @genex-ai/embed-sdk), §17.1 *Regions*:
+     *  one url per sample of each region is probed, the nearest region is joined, and a join refused 503
+     *  twice there moves to the next-best one. Each region is its own matchmaking pool. Omitted or with
+     *  nothing usable, `urls` are the regions. */
+    regions?: readonly AuthorityRegion[];
+    /** 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;
+    /** 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;
+    /** Game id (your project slug): everyone who passes the same id shares a room. */
+    room: string;
+    /** Display-name fallback when the token carries none. */
+    name?: string;
+    /** Verified identity, as for `connect()`: pass `() => genexEmbed.getColyseusAuth()` after
+     *  `await genexEmbed.waitForPlayer()`. Read fresh at every join attempt. NEVER log it. */
+    auth?: AuthSource;
+    /** Own-entity prediction. Omitted: predict with the room's movement preset when it runs one, and
+     *  render the server's state otherwise. `false`: never predict. An object: predict with your step. */
+    predict?: false | AuthorityPrediction;
+    /** How far in the past other entities render, ms. Default `AuthorityTiming.RENDER_DELAY_MS`. */
+    renderDelayMs?: number;
+    /** How other entities' samples are timed in a predicting room (§17.11 *Drawing other seats*):
+     *  `tick` (default) by their keyframe's tick, `patch` by the patch's server stamp (every other room's
+     *  way, kept for comparison). */
+    remoteSamples?: 'tick' | 'patch';
+    /** How other seats are drawn when the room has a seat contact rule (`contacts`, §17.11 *Drawing other
+     *  seats*): `predicted` (default, the Rocket League model) on your own entity's clock, every other
+     *  seat stepped from the latest state by the room preset under its last input (`remotePredict`) with
+     *  the room's contact pass run on every seat, yours included, so a bump is predicted where it is
+     *  drawn, each correction drawn as a decaying offset; `separate` on the render timeline like every
+     *  other entity, then moved out of your drawn entity by the rule and taken round it, never across it
+     *  (draw-only); `timeline` on the render timeline only, where a seat that missed yours on the server
+     *  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;
+    /** The physicsHash of a physics world this client runs a copy of (`setPhysics` later, too). A
+     *  mismatch is reported (`physics`); prediction checks the room's hash itself. */
+    physics?: string;
+    /** Loads the physics core that predicts a predicting room's bodies (§17.11): `@genex-ai/physics`
+     *  (contract 1.1) after its `init()`, e.g. `async () => { const p = await import('@genex-ai/physics');
+     *  await p.init(); return p; }`. Called only once a room sends keyframes; omitted, bodies are drawn
+     *  from the server (§17.10) everywhere. The room's static world is the one given to `world`. */
+    physicsCore?: () => Promise<PredictCore>;
+    /** `false` never predicts physics bodies, even with `physicsCore` (the client's kill switch). */
+    predictPhysics?: boolean;
+    /** A replay budget, ms, that overrides the device's (§17.11 *Budgets*: 4 desktop, 5 mobile) when it
+     *  is a finite number over 0; anything else is ignored. For benches and CI that hold every client
+     *  to one budget on a slow host; a game leaves it unset. */
+    physicsBudgetMs?: number;
+    /** The clock replays are timed on, ms (default `performance.now`), for the replay budget
+     *  (§17.11 *Budgets*). Tests and conformance runs whose point is not CPU speed hand it a fixed
+     *  clock so a slow host can never turn prediction off (`cpu`); a game leaves it unset. */
+    physicsClock?: () => number;
+    /** The room module's seat contact rule (§17.11 *Seat contacts*), run in your own entity's
+     *  prediction; omitted, a contact between seats arrives as a correction. */
+    contacts?: AuthorityContactRule;
+    /** The room module's whole seat contact pass (§17.11 *Seat contacts*: car-ball's pairs, pile passes
+     *  and world passes), which `seatDrawing: 'predicted'` runs on every seat after each predicted tick;
+     *  omitted, `contacts` runs once on every pair. */
+    contactPass?: AuthoritySeatPass;
+    /** The room module's seat rule (§17.11 *Seat rules*), run on your own entity before each predicted
+     *  input (with that input's tick and sequence) and, in an `inputDecay` room, on other seats' bodies
+     *  before each of their steps. */
+    seatRule?: AuthoritySeatRule;
+    /** The room module's body rule (§17.11 *Body rules*), run before every step of the client world;
+     *  omitted, what the module does to its bodies arrives as a correction. */
+    bodyRule?: PredictBodyRule;
+    /** The room module's kinematic rule (§17.11 *Kinematic rules*): where it poses its kinematic bodies
+     *  (a door, a platform, a moving floor) at each tick, so the client world moves them as the room does
+     *  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): 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)`. */
+    onEvent?: (type: string, data: unknown) => void;
+};
+/** An entity as this client renders it. */
+type AuthorityEntityView = {
+    id: string;
+    kind: string;
+    /** Owning seat's session id, or ''. */
+    owner: string;
+    /** Rendered: interpolated for other entities, predicted for your own. */
+    x: number;
+    y: number;
+    z: number;
+    /** Rendered heading, radians in [-π, π). */
+    yaw: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    hp: number;
+    flags: number;
+    epoch: number;
+    /** The entity's JSON text, '' = none. */
+    data: string;
+    /** A projectile's launch tick (§17.9), 0 = not a projectile. A projectile's x..vz are drawn from
+     *  its flight; your own prediction's is the (fractional) tick it was fired at. */
+    t0: number;
+    /** A projectile's downward acceleration, units/s². */
+    g: number;
+    /** The seat that fired a projectile, '' = none. */
+    src: string;
+    /** A firstperson body's aim pitch, radians: predicted for yours, interpolated for others, within
+     *  the preset's ±pitchLimit. */
+    pitch: number;
+    /** A firstperson body's duck amount, 0 standing to 1 fully ducked: predicted or interpolated. */
+    duck: number;
+    /** A firstperson body's movement bits (1 onGround, 2 ducking, 4 jumpHeld): predicted for yours,
+     *  the server's latest for others. */
+    mstate: number;
+    /** A firstperson body's speed multiplier, or a vehicle's top-speed multiplier, as the server last
+     *  wrote it (default 1). */
+    cap: number;
+    /** A vehicle body's yaw rate, rad/s, positive toward +yaw: predicted for yours, the server's
+     *  latest for others (for wheels and skids; the heading itself is `yaw`). */
+    spin: number;
+    /** A vehicle body's boost fuel, [0, 1]: predicted for yours, the server's latest for others. */
+    fuel: number;
+    /** A physics body (§17.10): drawn at the server's present from its body state, extrapolated and
+     *  eased (x, y, z and the orientation below), never interpolated behind. False for every other
+     *  entity. A body out of this client's view is still listed, held where its last state left it. */
+    body: boolean;
+    /** A physics body's drawn orientation, a unit quaternion (z up, the server's axes); the identity
+     *  for every other entity, whose heading is `yaw`. */
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    /** The server put this physics body to sleep (it is drawn where it is). False for other entities. */
+    sleep: boolean;
+    /** This physics body is predicted (§17.11) rather than drawn from the server's states; or this other
+     *  seat is drawn predicted on your clock (`seatDrawing: 'predicted'`). */
+    predicted?: boolean;
+    /** A seat drawn predicted: how far it is drawn from its predicted pose (room units), the correction
+     *  still being eased in plus any push out of another drawn seat. */
+    correction?: number;
+};
+/** Whether your own entity is predicted, and why not when it is not:
+ *  - `off`: `predict: false`;
+ *  - `no_entity`: you own no entity (yet);
+ *  - `no_preset`: the room runs no movement preset this client knows, and you gave no step;
+ *  - `world_mismatch`: the room's firstperson or vehicle world is not the one given to `setWorld` (its hash is
+ *    `world`, the room's `roomWorld`): your entity renders from the server's state, unpredicted. */
+type AuthorityPredictionStatus = {
+    predicting: boolean;
+    reason: '' | 'off' | 'no_entity' | 'no_preset' | 'world_mismatch';
+    /** The hash of this client's world (the empty world's until `setWorld`). */
+    world: number;
+    /** The world the room's preset steps through (`params.world`), or null when it has none. */
+    roomWorld: number | null;
+};
+/** Whether this client's copy of the room's physics world is the room's (§17.10 *The resolved
+ *  config*): `physics_mismatch` when the room runs physics (`roomPhysics` is not '') and its hash is
+ *  not the one given to `setPhysics` (''), as `world_mismatch` is for presets. Such a client never
+ *  steps its copy from the room's state. */
+type AuthorityPhysicsStatus = {
+    reason: '' | 'physics_mismatch';
+    /** The hash given to `setPhysics`, '' until then. */
+    physics: string;
+    /** The room's `physics` (its world's physicsHash), '' in a room without physics. */
+    roomPhysics: string;
+};
+/** A projectile your game fires, as it predicts it (`predictProjectile`): where it starts, its
+ *  velocity and its gravity, in world units — the values the room module launches it with. */
+type ProjectilePrediction = {
+    kind: string;
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    /** Downward acceleration along −z, units/s², [0, 1000]. Default 0. */
+    g?: number;
+};
+/** A seated player. */
+type AuthorityPlayerView = {
+    id: string;
+    name: string;
+    uid: string;
+    team: string;
+    connected: boolean;
+    avatarUrl: string;
+};
+/** What the session measured. Counters only grow. */
+type AuthorityTelemetry = {
+    /** Inputs transmitted. */
+    inputsSent: number;
+    /** Input steps that came due while the socket was down, and were not sent (never queued). */
+    inputsDropped: number;
+    /** Server acks the reconciler checked its prediction against. */
+    reconciles: number;
+    /** 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, 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 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;
+    /** Physics body states received (§17.10), and how many of them snapped instead of easing in
+     *  (the first state of a body, an epoch change, or an offset over one metre). */
+    bodyStates: number;
+    bodySnaps: number;
+    /** Largest correction a body state started, room units (eased away, never drawn as a jump). */
+    peakBodyCorrection: number;
+    /** Projectiles `predictProjectile` drew before the server had them. */
+    projectilesPredicted: number;
+    /** Predictions the server's projectile of the same id confirmed. */
+    projectilesConfirmed: number;
+    /** Predictions no server projectile confirmed, and dropped: the server refused the shot, or removed
+     *  it before any state patch carried it (a point-blank hit), or its input was lost in a drop. Found
+     *  once the server acknowledges the firing input or the reconnect's first state lacks it, else
+     *  after max(2·RTT, 600 ms), a stalled link's silence not counted. */
+    projectilesRejected: number;
+    /** The latest confirmation's input lead, ms: the server's launch instant minus the prediction's. */
+    lastProjectileLeadMs: number;
+};
+type AuthoritySession = {
+    /** This seat's session id: the `owner` of your entity. */
+    readonly id: string;
+    /** The server this session joined through (its region's, §17.1 *Regions*). An invite carries it:
+     *  an invitee passes it as `url` and plays in this session's region. */
+    readonly url: string;
+    /** The input sent on each step. Mutate it any time; `frame()` sends it. */
+    readonly input: InputData;
+    /** Call once per render frame, before reading positions. Sends one input per due fixed step and
+     *  advances prediction and interpolation. Returns how many inputs it sent. */
+    frame(now?: number): number;
+    /** Your own entity (the first one you own that is not a projectile), predicted. */
+    me(): AuthorityEntityView | undefined;
+    /**
+     * The `firstperson` or `vehicle` collision world: the same `{ boxes, ramps }` the room module exports. Validated
+     * by §17.7's rules (a refused world throws a `WorldError` and changes nothing) and hashed; your
+     * own entity is predicted while that hash equals the room's `params.world`, and rendered from the
+     * server's state otherwise (`prediction` says which). Returns the hash. Call it before the first
+     * `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
+     *  (§17.10). When the room runs physics with another hash, `physics` reports `physics_mismatch`
+     *  (and a console warning explains it once). Returns the hash. */
+    setPhysics(hash: string): string;
+    /** Whether your physics copy matches the room's. */
+    readonly physics: AuthorityPhysicsStatus;
+    /** Whether the room's bodies are predicted (§17.11), why not, and how keyframes were adopted. */
+    readonly physicsPrediction: Readonly<PhysicsPredictionStatus>;
+    /** The tick other seats were last drawn at (`seatDrawing: 'predicted'`): the state after that tick,
+     *  fractional between two, on your own entity's clock; NaN when they are drawn on the render
+     *  timeline (another drawing, or nothing to predict from yet). */
+    drawTick(): number;
+    /** How far ahead of the server's present (ms, on this client's estimate of the room clock) other
+     *  seats were last drawn: `drawTick` as an instant; NaN when it is. */
+    drawLead(): number;
+    /** Where declared lift `id` is drawn now (§17.11 *Lifts*): its centre and yaw on your entity's clock
+     *  (between your drawn input's ticks at the same alpha), else on the render timeline; undefined for
+     *  a room without that lift. */
+    liftPose(id: string): {
+        x: number;
+        y: number;
+        z: number;
+        yaw: number;
+    } | undefined;
+    /** The turn (radians) your view owes the lift your entity stands on since your last call: the
+     *  lift's turn between the ticks the server applies your newest input at then and now, as the
+     *  latest state maps your inputs to ticks; 0 off one, and on the call that finds you on it. A
+     *  firstperson game adds it to its view yaw once a frame, after `frame(now)`, so your view turns with
+     *  a spinner tick for tick, also across a tick the server stepped two of your inputs or none
+     *  (§17.11 *Lifts*, *Input pacing*). */
+    viewCarry(): number;
+    /**
+     * Predict a projectile you fire (§17.9): call it while staging the input that fires, before the
+     * `frame()` that sends it. It is drawn at once from this launch, under the id the room gives it
+     * (`<seat>.<seq>.<n>`: the input's sequence and your launches during it), and `entities()` keeps
+     * that id when the server's projectile arrives, drawn on from where the prediction was. One the
+     * state never shows (a cooldown, a dead shooter, or a hit before any patch carried it) is dropped
+     * as soon as the server acknowledges the input that fired it, one whose input a drop lost at the
+     * reconnect's first state, and any at the latest after max(2·RTT, 600 ms) (a stall in which no
+     * state arrives, the socket up, is not counted). Returns the id, or
+     * `''` (and predicts nothing) while the socket is down: from a drop until the reconnect's first
+     * state, and after the session ends.
+     */
+    predictProjectile(projectile: ProjectilePrediction): string;
+    entity(id: string): AuthorityEntityView | undefined;
+    /** Every entity, rendered, your predicted projectiles included. A fresh map per call. */
+    entities(): Map<string, AuthorityEntityView>;
+    /** Every seated player. A fresh map per call. */
+    players(): Map<string, AuthorityPlayerView>;
+    /** The fixed-step tick the server last wrote. */
+    readonly tick: number;
+    /** False from a drop until the reconnect's first state lands, and after the session ends. */
+    readonly connected: boolean;
+    readonly telemetry: Readonly<AuthorityTelemetry>;
+    /** The fast channel (§17.12): whether it is live, snapshots applied, and why it fell back. */
+    readonly fast: FastSeatStatus;
+    on(event: 'reconnecting', handler: (info: {
+        code: number;
+    }) => void): () => void;
+    on(event: 'reconnected', handler: () => 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. */
+    leave(): Promise<void>;
+};
+/** How other seats are drawn with a seat contact rule (`seatDrawing`). */
+declare const SEAT_DRAWINGS: readonly ["predicted", "separate", "timeline"];
+type SeatDrawing = ContactDrawing;
+/** The drawing a session with a seat contact rule uses when `seatDrawing` is not given: the Rocket
+ *  League model (the car-ball owner's reference), every seat predicted on your clock. */
+declare const DEFAULT_SEAT_DRAWING: SeatDrawing;
+/**
+ * Join a server-authoritative room (PROTOCOL.md §17) and return its session.
+ *
+ * ```ts
+ * const s = await connectAuthority({ urls: genexEmbed.getAuthorityUrls(), room: 'my-game',
+ *   auth: () => genexEmbed.getColyseusAuth() });
+ * function loop(now) {
+ *   s.input.moveX = right - left; s.input.moveY = up - down; s.input.yaw = aim;
+ *   s.frame(now);                       // send due inputs, predict, interpolate
+ *   draw(s.me(), s.entities());
+ *   requestAnimationFrame(loop);
+ * }
+ * ```
+ *
+ * A refused join rejects with the server's error; its `code` is a {@link JoinError}. 402
+ * (`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, 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 };