@genex-ai/multiplayer 0.17.1 → 0.17.8

package/dist/chunk-NFMGIKFZ.js

@@ -0,0 +1,2627 @@
+import {
+  RemotePredict
+} from "./chunk-OD6NRSX2.js";
+import {
+  MASK_LIMIT,
+  MAX_ABS,
+  Preset,
+  axis,
+  definitionOf,
+  isMask,
+  isPresetName,
+  mask,
+  presetParamsValid,
+  resolvePresetParams,
+  unsignedZero,
+  wrappedAngle
+} from "./chunk-2NGXXQDS.js";
+import {
+  JoinError,
+  Limits,
+  isReservedEventType
+} from "./chunk-CSQEEANB.js";
+
+// src/authority/room-key.ts
+var AuthorityRoomLimits = {
+  /** A match key's longest length. */
+  MAX_MATCH_KEY_CHARS: 32,
+  /** A room code's longest length (Colyseus's room ids are 9). */
+  MAX_CODE_CHARS: 32,
+  /** The most named worlds one module's `worlds` map may hold. */
+  MAX_WORLDS: 16
+};
+var ROOM_NOT_FOUND = 522;
+var inRange = (c, lo, hi) => c >= lo.charCodeAt(0) && c <= hi.charCodeAt(0);
+var isLowerOrDigit = (c) => inRange(c, "a", "z") || inRange(c, "0", "9");
+var KEY_MARKS = "._:-";
+var CODE_MARKS = "_-";
+function validMatchKey(value2) {
+  if (typeof value2 !== "string" || value2.length === 0 || value2.length > AuthorityRoomLimits.MAX_MATCH_KEY_CHARS) return false;
+  for (let i = 0; i < value2.length; i++) {
+    if (isLowerOrDigit(value2.charCodeAt(i))) continue;
+    if (i === 0 || !KEY_MARKS.includes(value2.charAt(i))) return false;
+  }
+  return true;
+}
+function validRoomCode(value2) {
+  if (typeof value2 !== "string" || value2.length === 0 || value2.length > AuthorityRoomLimits.MAX_CODE_CHARS) return false;
+  for (let i = 0; i < value2.length; i++) {
+    const c = value2.charCodeAt(i);
+    if (!isLowerOrDigit(c) && !inRange(c, "A", "Z") && !CODE_MARKS.includes(value2.charAt(i))) return false;
+  }
+  return true;
+}
+function matchKeyOf(value2) {
+  if (value2 === void 0 || value2 === "") return "";
+  return validMatchKey(value2) ? value2 : null;
+}
+var AuthorityJoinMethod = { JoinOrCreate: "joinOrCreate", Create: "create", JoinById: "joinById" };
+var AuthorityTargetRefusal = { BadMatchKey: "bad_match_key", BadCode: "bad_code", Conflict: "conflict" };
+function planAuthorityJoin(target) {
+  const key = target.matchKey ?? "";
+  if (target.code !== void 0) {
+    if (target.createPrivate === true || key !== "") return { refused: AuthorityTargetRefusal.Conflict };
+    if (!validRoomCode(target.code)) return { refused: AuthorityTargetRefusal.BadCode };
+    return { method: AuthorityJoinMethod.JoinById, roomId: target.code, options: {} };
+  }
+  const pool = matchKeyOf(key);
+  if (pool === null) return { refused: AuthorityTargetRefusal.BadMatchKey };
+  const options = pool === "" ? {} : { matchKey: pool };
+  if (target.createPrivate === true) return { method: AuthorityJoinMethod.Create, options: { ...options, private: true } };
+  return { method: AuthorityJoinMethod.JoinOrCreate, options };
+}
+function nextCodeRegion(error, region, regions) {
+  const elsewhere = error === JoinError.WRONG_REGION || error === ROOM_NOT_FOUND;
+  return elsewhere && region + 1 < regions ? region + 1 : null;
+}
+function selectMatchWorld(worlds, world, key) {
+  return worlds !== void 0 && Object.hasOwn(worlds, key) ? worlds[key] : world;
+}
+
+// src/authority/physics.ts
+var PHYSICS_CONTRACT = "1.0";
+var PHYSICS_DEFAULT_LIMITS = Object.freeze({
+  bodies: 512,
+  collidersPerBody: 8,
+  hullVertices: 64,
+  triangles: 65536,
+  joints: 64,
+  ccdBodies: 16,
+  queriesPerStep: 64,
+  eventsPerStep: 64,
+  heightfieldSamples: 1048576,
+  staticPieces: 4608,
+  memoryBytes: 64 * 1024 * 1024,
+  worldExtent: 1e5,
+  maxSpeed: 1e3,
+  maxAngularSpeed: 1e3
+});
+var PHYSICS_LIMIT_NAMES = Object.freeze(Object.keys(PHYSICS_DEFAULT_LIMITS));
+var PHYSICS_SCALED_LIMITS = Object.freeze(["worldExtent", "maxSpeed"]);
+var PHYSICS_REAL_LIMITS = Object.freeze(["worldExtent", "maxSpeed", "maxAngularSpeed"]);
+var PHYSICS_CEILING_FACTOR = 4;
+var PHYSICS_STATIC_PIECE_BYTES = 2048;
+var PHYSICS_PREDICT_MAX_BOXES = 4096;
+var PHYSICS_PREDICT_MAX_RAMPS = 512;
+var physicsWorldPredicts = (boxes, ramps) => boxes <= PHYSICS_PREDICT_MAX_BOXES && ramps <= PHYSICS_PREDICT_MAX_RAMPS;
+function physicsLimitsForWorld(limits, pieces) {
+  const lowered = limits.staticPieces < PHYSICS_DEFAULT_LIMITS.staticPieces;
+  if (lowered || pieces <= limits.staticPieces) return limits;
+  const memoryCeiling = PHYSICS_DEFAULT_LIMITS.memoryBytes * PHYSICS_CEILING_FACTOR;
+  return { ...limits, staticPieces: pieces, memoryBytes: Math.min(memoryCeiling, limits.memoryBytes + pieces * PHYSICS_STATIC_PIECE_BYTES) };
+}
+var PHYSICS_DEFAULT_CEILING = PHYSICS_DEFAULT_LIMITS;
+var isPlainObject = (v) => {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+var isLimitName = (key) => Object.hasOwn(PHYSICS_DEFAULT_LIMITS, key);
+var isRealLimit = (key) => PHYSICS_REAL_LIMITS.includes(key);
+function limitValueValid(key, value2) {
+  if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 <= 0) return false;
+  return isRealLimit(key) || Number.isInteger(value2);
+}
+function physicsCeilingValid(ceiling) {
+  if (!isPlainObject(ceiling)) return false;
+  return PHYSICS_LIMIT_NAMES.every((key) => {
+    const value2 = ceiling[key];
+    const base = PHYSICS_DEFAULT_LIMITS[key];
+    return limitValueValid(key, value2) && value2 >= base && value2 <= base * PHYSICS_CEILING_FACTOR;
+  });
+}
+function physicsLimitsAt(perUnit, lengthUnit) {
+  const out = { ...perUnit };
+  for (const key of PHYSICS_SCALED_LIMITS) out[key] = perUnit[key] * lengthUnit;
+  return out;
+}
+var PhysicsConfigRange = {
+  /** `lengthUnit` is in (0, MAX_LENGTH_UNIT]. */
+  MAX_LENGTH_UNIT: 1e6,
+  /** `gravity` is in [0, MAX_GRAVITY]; a default is never refused. */
+  MAX_GRAVITY: 1e7,
+  /** Gravity without a world-stepping preset: this many metres per second squared. */
+  EARTH_GRAVITY: 9.81,
+  MIN_ITERATIONS: 1,
+  MAX_ITERATIONS: 16,
+  DEFAULT_ITERATIONS: 4,
+  /** Distinct physics kinds `subscribe` may name. */
+  MAX_SUBSCRIBE_KINDS: 8,
+  /** `player.radius` and `player.height` are in (0, MAX_PLAYER_SIZE]. */
+  MAX_PLAYER_SIZE: 1e6
+};
+var PHYSICS_PRESET_LENGTH_UNITS = Object.freeze({
+  [Preset.FIRSTPERSON]: 39.37,
+  [Preset.VEHICLE]: 100
+});
+var PHYSICS_PATCH_HZ = Object.freeze([10, 15, 20, 30, 60]);
+var PHYSICS_DEFAULT_PATCH_HZ = 20;
+var PhysicsPredictRange = {
+  DEFAULT_REMOTE_PREDICT: RemotePredict.EXTRAPOLATE,
+  DEFAULT_REMOTE_DECAY_MS: 50,
+  MAX_REMOTE_DECAY_MS: 1e3,
+  DEFAULT_LEAD_MS: 250,
+  MIN_LEAD_MS: 50,
+  MAX_LEAD_MS: 1e3
+};
+var REMOTE_PREDICTS = Object.values(RemotePredict);
+function isPhysicsPatchHz(v) {
+  return typeof v === "number" && PHYSICS_PATCH_HZ.includes(v);
+}
+function effectivePatchHz(tickHz, patchHz) {
+  const fits = PHYSICS_PATCH_HZ.filter((hz) => hz <= patchHz && hz <= tickHz && tickHz % hz === 0);
+  return fits.at(-1) ?? PHYSICS_PATCH_HZ[0];
+}
+function keyframeTicks(tickHz, patchHz) {
+  return tickHz / effectivePatchHz(tickHz, patchHz);
+}
+var PHYSICS_PREDICT_MAX_LINEAR = 64;
+var PHYSICS_PREDICT_MAX_ANGULAR = 64;
+var PHYSICS_PREDICT_MIN_ITERATIONS = null;
+function solverIterationsOf(physics, predicting) {
+  const floor = predicting ? PHYSICS_PREDICT_MIN_ITERATIONS : null;
+  return floor === null ? physics.iterations : Math.max(physics.iterations, floor);
+}
+var PHYSICS_KEY_MAX_BYTES = 64;
+var PHYSICS_KIND_MAX_BYTES = 32;
+var PHYSICS_STATIC_PREFIX = "static:";
+var KEY_CHARSET = /^[A-Za-z0-9_.:-]+$/;
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPhysicsKey(v) {
+  if (typeof v !== "string" || v.length === 0 || v.length > PHYSICS_KEY_MAX_BYTES) return false;
+  if (!KEY_CHARSET.test(v) || FORBIDDEN_KEYS.has(v)) return false;
+  return !v.startsWith(PHYSICS_STATIC_PREFIX);
+}
+function isPhysicsKind(v) {
+  return typeof v === "string" && v.length > 0 && v.length <= PHYSICS_KIND_MAX_BYTES && KEY_CHARSET.test(v);
+}
+var PATH = "$.config.physics";
+var REQUEST_KEYS = /* @__PURE__ */ new Set([
+  "lengthUnit",
+  "gravity",
+  "iterations",
+  "limits",
+  "subscribe",
+  "player",
+  "predict",
+  "patchHz",
+  "remotePredict",
+  "remoteDecayMs",
+  "leadMs"
+]);
+var PLAYER_KEYS = /* @__PURE__ */ new Set(["radius", "height", "events"]);
+var Bad = class {
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+};
+var bad = (path) => {
+  throw new Bad(path);
+};
+var Mode = {
+  REQUEST: "request",
+  RESOLVED: "resolved"
+};
+var asked = (v) => v !== void 0;
+function lengthUnitOf(v, preset, mode) {
+  if (!asked(v)) {
+    if (mode === Mode.RESOLVED) return bad(`${PATH}.lengthUnit`);
+    return (preset !== null ? PHYSICS_PRESET_LENGTH_UNITS[preset.name] : void 0) ?? 1;
+  }
+  const ok2 = typeof v === "number" && Number.isFinite(v) && v > 0 && v <= PhysicsConfigRange.MAX_LENGTH_UNIT;
+  return ok2 ? v : bad(`${PATH}.lengthUnit`);
+}
+function presetGravity(preset) {
+  if (preset === null || !isPresetName(preset.name)) return null;
+  if (preset.name !== Preset.FIRSTPERSON && preset.name !== Preset.VEHICLE) return null;
+  return resolvePresetParams(preset.name, preset.params).gravity ?? null;
+}
+function gravityOf(v, lengthUnit, preset, mode) {
+  if (!asked(v)) {
+    if (mode === Mode.RESOLVED) return bad(`${PATH}.gravity`);
+    return presetGravity(preset) ?? PhysicsConfigRange.EARTH_GRAVITY * lengthUnit;
+  }
+  const ok2 = typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= PhysicsConfigRange.MAX_GRAVITY;
+  return ok2 ? v : bad(`${PATH}.gravity`);
+}
+function iterationsOf(v, mode) {
+  if (!asked(v)) return mode === Mode.RESOLVED ? bad(`${PATH}.iterations`) : PhysicsConfigRange.DEFAULT_ITERATIONS;
+  const ok2 = typeof v === "number" && Number.isInteger(v) && v >= PhysicsConfigRange.MIN_ITERATIONS && v <= PhysicsConfigRange.MAX_ITERATIONS;
+  return ok2 ? v : bad(`${PATH}.iterations`);
+}
+function limitsOf(v, lengthUnit, ceiling, mode) {
+  const path = `${PATH}.limits`;
+  if (!asked(v) && mode === Mode.RESOLVED) return bad(path);
+  const given = asked(v) ? v : {};
+  if (!isPlainObject(given)) return bad(path);
+  if (mode === Mode.REQUEST) {
+    const unknown = Object.keys(given).find((key) => !isLimitName(key));
+    if (unknown !== void 0) return bad(`${path}.${unknown}`);
+  }
+  const top = physicsLimitsAt(ceiling, lengthUnit);
+  const defaults = physicsLimitsAt(PHYSICS_DEFAULT_LIMITS, lengthUnit);
+  const out = { ...defaults };
+  for (const key of PHYSICS_LIMIT_NAMES) {
+    const value2 = given[key];
+    if (!asked(value2)) {
+      if (mode === Mode.RESOLVED) return bad(`${path}.${key}`);
+      out[key] = Math.min(defaults[key], top[key]);
+      continue;
+    }
+    if (!limitValueValid(key, value2)) return bad(`${path}.${key}`);
+    if (mode === Mode.RESOLVED && value2 > top[key]) return bad(`${path}.${key}`);
+    out[key] = Math.min(value2, top[key]);
+  }
+  return out;
+}
+function subscribeOf(v, mode) {
+  const path = `${PATH}.subscribe`;
+  if (!asked(v)) return mode === Mode.RESOLVED ? bad(path) : [];
+  if (!Array.isArray(v) || v.length > PhysicsConfigRange.MAX_SUBSCRIBE_KINDS) return bad(path);
+  const seen = /* @__PURE__ */ new Set();
+  v.forEach((kind, i) => {
+    if (!isPhysicsKind(kind) || seen.has(kind)) bad(`${path}[${i}]`);
+    seen.add(kind);
+  });
+  return [...seen];
+}
+var playerSize = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 && v <= PhysicsConfigRange.MAX_PLAYER_SIZE;
+function playerOf(v, preset, mode) {
+  const path = `${PATH}.player`;
+  if (!asked(v) && mode === Mode.RESOLVED) return bad(path);
+  const given = asked(v) ? v : {};
+  if (!isPlainObject(given)) return bad(path);
+  if (mode === Mode.REQUEST) {
+    const unknown = Object.keys(given).find((key) => !PLAYER_KEYS.has(key));
+    if (unknown !== void 0) return bad(`${path}.${unknown}`);
+  }
+  const out = { events: false };
+  if (asked(given.events)) {
+    if (typeof given.events !== "boolean") return bad(`${path}.events`);
+    out.events = given.events;
+  } else if (mode === Mode.RESOLVED) {
+    return bad(`${path}.events`);
+  }
+  const topdown = preset?.name === Preset.TOPDOWN;
+  for (const key of ["radius", "height"]) {
+    if (!asked(given[key])) continue;
+    if (!topdown || !playerSize(given[key])) return bad(`${path}.${key}`);
+    out[key] = given[key];
+  }
+  return out;
+}
+function predictOf(v, mode) {
+  if (!asked(v)) return mode === Mode.RESOLVED ? bad(`${PATH}.predict`) : true;
+  return typeof v === "boolean" ? v : bad(`${PATH}.predict`);
+}
+function patchHzOf(v, mode) {
+  if (!asked(v)) return mode === Mode.RESOLVED ? bad(`${PATH}.patchHz`) : PHYSICS_DEFAULT_PATCH_HZ;
+  return isPhysicsPatchHz(v) ? v : bad(`${PATH}.patchHz`);
+}
+function remotePredictOf(v, mode) {
+  if (!asked(v)) return mode === Mode.RESOLVED ? bad(`${PATH}.remotePredict`) : PhysicsPredictRange.DEFAULT_REMOTE_PREDICT;
+  return REMOTE_PREDICTS.includes(v) ? v : bad(`${PATH}.remotePredict`);
+}
+function rangeOf(v, name, min, max, fallback, mode) {
+  if (!asked(v)) return mode === Mode.RESOLVED ? bad(`${PATH}.${name}`) : fallback;
+  const ok2 = typeof v === "number" && Number.isFinite(v) && v >= min && v <= max;
+  return ok2 ? v : bad(`${PATH}.${name}`);
+}
+function physicsOf(v, preset, ceiling, mode) {
+  const none = v === void 0 || v === null || v === false;
+  if (none) return ceiling === null ? null : bad(PATH);
+  if (ceiling === null) return bad(PATH);
+  const given = v === true && mode === Mode.REQUEST ? {} : v;
+  if (!isPlainObject(given)) return bad(PATH);
+  if (mode === Mode.REQUEST) {
+    const unknown = Object.keys(given).find((key) => !REQUEST_KEYS.has(key));
+    if (unknown !== void 0) return bad(`${PATH}.${unknown}`);
+  }
+  const lengthUnit = lengthUnitOf(given.lengthUnit, preset, mode);
+  return {
+    lengthUnit,
+    gravity: gravityOf(given.gravity, lengthUnit, preset, mode),
+    iterations: iterationsOf(given.iterations, mode),
+    limits: limitsOf(given.limits, lengthUnit, ceiling, mode),
+    subscribe: subscribeOf(given.subscribe, mode),
+    player: playerOf(given.player, preset, mode),
+    predict: predictOf(given.predict, mode),
+    patchHz: patchHzOf(given.patchHz, mode),
+    remotePredict: remotePredictOf(given.remotePredict, mode),
+    remoteDecayMs: rangeOf(given.remoteDecayMs, "remoteDecayMs", 0, PhysicsPredictRange.MAX_REMOTE_DECAY_MS, PhysicsPredictRange.DEFAULT_REMOTE_DECAY_MS, mode),
+    leadMs: rangeOf(given.leadMs, "leadMs", PhysicsPredictRange.MIN_LEAD_MS, PhysicsPredictRange.MAX_LEAD_MS, PhysicsPredictRange.DEFAULT_LEAD_MS, mode)
+  };
+}
+function resolution(build) {
+  try {
+    return { ok: true, value: build() };
+  } catch (err) {
+    if (err instanceof Bad) return { ok: false, path: err.path };
+    throw err;
+  }
+}
+function resolvePhysicsConfig(request, preset, ceiling) {
+  return resolution(() => physicsOf(request, preset, ceiling, Mode.REQUEST));
+}
+function checkResolvedPhysics(resolved, preset, ceiling) {
+  return resolution(() => physicsOf(resolved, preset, ceiling, Mode.RESOLVED));
+}
+var PHYSICS_SUBSTEPS = Object.freeze({ 20: 3, 30: 2, 60: 1, 120: 1 });
+function physicsWorldDesc(physics, tickHz, predicting = false, worldPieces = 0) {
+  return {
+    contract: PHYSICS_CONTRACT,
+    dt: 1 / tickHz,
+    substeps: PHYSICS_SUBSTEPS[tickHz],
+    gravity: [0, 0, -physics.gravity],
+    upAxis: "z",
+    lengthUnit: physics.lengthUnit,
+    limits: { ...physicsLimitsForWorld(physics.limits, worldPieces) },
+    solver: { iterations: solverIterationsOf(physics, predicting) }
+  };
+}
+var PhysEvKind = {
+  CONTACT_BEGIN: 0,
+  CONTACT_END: 1,
+  TRIGGER_ENTER: 2,
+  TRIGGER_EXIT: 3
+};
+var PHYSICS_OVERLAP_MAX_KEYS = 64;
+var PHYSICS_BODY_FIELDS = Object.freeze([
+  "qx",
+  "qy",
+  "qz",
+  "qw",
+  "lvx",
+  "lvy",
+  "lvz",
+  "avx",
+  "avy",
+  "avz",
+  "sleep"
+]);
+var HOST_BODY_FIELDS = Object.freeze(["x", "y", "z", ...PHYSICS_BODY_FIELDS]);
+var BodyQuantization = {
+  BITS: 16,
+  /** Integer steps across a symmetric range (2^16 − 2). */
+  SPAN: 65534,
+  /** `qx qy qz qw`. */
+  ORIENTATION: Object.freeze({ min: -1, max: 1 }),
+  /** `lvx lvy lvz` (metres per second: velocity divided by lengthUnit) and `avx avy avz` (rad/s). */
+  VELOCITY: Object.freeze({ min: -64, max: 64 })
+};
+function quantizeBodyValue(v, range) {
+  if (Number.isNaN(v)) return 0;
+  const clamped = v < range.min ? range.min : v > range.max ? range.max : v;
+  return Math.floor((clamped - range.min) / (range.max - range.min) * BodyQuantization.SPAN + 0.5);
+}
+function dequantizeBodyValue(q, range) {
+  return range.min + q / BodyQuantization.SPAN * (range.max - range.min);
+}
+var PHYSICS_CONTESTED_METRES = 6;
+var PHYSICS_FULL_RATE_BODIES = 100;
+var PHYSICS_ROTATING_BODIES = 25;
+var BODY_EXTRAPOLATE_MAX_MS = 250;
+var BODY_EXTRAPOLATE_BACK_TICKS = 1;
+var BODY_CORRECTION_TAU_MS = 100;
+var BODY_SNAP_METRES = 1;
+
+// src/authority/contact-config.ts
+var ContactDrawing = { Predicted: "predicted", Separate: "separate", Timeline: "timeline" };
+var ContactPush = { Shared: "shared", Mover: "mover" };
+var ContactPreset = {
+  Shooter: "shooter",
+  Platformer: "platformer",
+  VehicleArena: "vehicle-arena",
+  PhysicsSandbox: "physics-sandbox",
+  Party: "party"
+};
+var TopPolicy = {
+  /** Rest on the head: a landing stands within `center` of the lower's half width and slides off by
+   *  `slide` elsewhere; a resting seat holds while its centre is over the footprint; `ride`: carried. */
+  Stand: "stand",
+  /** Frictionless: the upper seat is slid off within a bounded time. */
+  Slide: "slide",
+  /** A stomp: the upper seat bounces off, and the module hears it. */
+  Bounce: "bounce",
+  /** No collision at all. */
+  Ghost: "ghost"
+};
+var ContactShapeKind = {
+  /** A box turned with the seat's heading and laid on its support up (a vehicle). */
+  Box: "box",
+  /** An upright axis-aligned square footprint (a `firstperson` character). */
+  Hull: "hull"
+};
+var HeadFriction = { Slide: "slide", Carry: "carry" };
+function drawingOf(given, path, base) {
+  if (!has(given, "drawing")) return base;
+  const v = given.drawing;
+  if (!Object.values(ContactDrawing).includes(v)) throw new ContactConfigError(`${path}.drawing`, "must be predicted, separate or timeline");
+  return v;
+}
+function pushOf(given, path, base) {
+  if (!has(given, "push")) return base;
+  const v = given.push;
+  if (!Object.values(ContactPush).includes(v)) throw new ContactConfigError(`${path}.push`, "must be shared or mover");
+  return v;
+}
+var ContactConfigError = class extends RangeError {
+  path;
+  constructor(path, why) {
+    super(`${path}: ${why}`);
+    this.name = "ContactConfigError";
+    this.path = path;
+  }
+};
+var CONTACT_PAIRS_MAX = 32;
+var CONTACT_TAG_MAX = 64;
+var CONTACT_PASSES_MAX = 64;
+var CONTACT_VALUE_MAX = 1e5;
+var slide = (speed, step, share) => ({ speed, step, share });
+var slideTop = (s) => ({ policy: TopPolicy.Slide, ...s });
+var stand = (ride, center, s) => ({ policy: TopPolicy.Stand, ride, center, slide: s });
+var CHARACTER_SLIDE = slide(300, 150, 1);
+var VEHICLE_SLIDE = slide(950, 480, 1);
+var ARENA_OFF_WALL = slide(600, null, 0.5);
+var SHOOTER_CENTER = 0.25;
+var PROP_SLIDE = Object.freeze({ speed: 300, step: 150 });
+var STOMP = { policy: TopPolicy.Bounce, stompMin: 150, bounceSpeed: 450, jumpBoost: 150, slide: CHARACTER_SLIDE };
+var CONTACT_PRESETS = {
+  [ContactPreset.Shooter]: { character: stand(false, SHOOTER_CENTER, CHARACTER_SLIDE), vehicle: slideTop(VEHICLE_SLIDE), restitution: 0, passes: 16, vehicleOffWall: VEHICLE_SLIDE, stopSpin: false, drawing: ContactDrawing.Separate, push: ContactPush.Mover, headFriction: HeadFriction.Slide },
+  [ContactPreset.Platformer]: { character: stand(true, null, CHARACTER_SLIDE), vehicle: slideTop(VEHICLE_SLIDE), restitution: 0, passes: 16, vehicleOffWall: VEHICLE_SLIDE, stopSpin: false, drawing: ContactDrawing.Separate, push: ContactPush.Mover, headFriction: HeadFriction.Slide },
+  [ContactPreset.VehicleArena]: { character: slideTop(CHARACTER_SLIDE), vehicle: slideTop(VEHICLE_SLIDE), restitution: 0.6, passes: 32, vehicleOffWall: ARENA_OFF_WALL, stopSpin: true, drawing: ContactDrawing.Predicted, push: ContactPush.Shared, headFriction: HeadFriction.Carry },
+  [ContactPreset.PhysicsSandbox]: { character: stand(true, null, CHARACTER_SLIDE), vehicle: stand(true, null, VEHICLE_SLIDE), restitution: 0.2, passes: 16, vehicleOffWall: VEHICLE_SLIDE, stopSpin: false, drawing: ContactDrawing.Separate, push: ContactPush.Shared, headFriction: HeadFriction.Carry },
+  [ContactPreset.Party]: { character: stand(true, null, CHARACTER_SLIDE), vehicle: slideTop(VEHICLE_SLIDE), restitution: 0.3, passes: 16, vehicleOffWall: VEHICLE_SLIDE, stopSpin: false, drawing: ContactDrawing.Separate, push: ContactPush.Shared, headFriction: HeadFriction.Slide }
+};
+var CONTACT_DEFAULTS = Object.freeze({ supportCos: 0.7, entrySpeed: 1, entryWindow: 1 / 60, slop: 0.1, roofSkin: 0.01 });
+var KEYS = /* @__PURE__ */ new Set(["preset", "shape", "top", "offWall", "restitution", "passes", "slop", "supportCos", "entrySpeed", "entryWindow", "roofSkin", "maxVelocity", "stopSpin", "pairs", "drawing", "push", "headFriction", "propSlide"]);
+var TOP_KEYS = {
+  [TopPolicy.Stand]: /* @__PURE__ */ new Set(["policy", "ride", "center", "slide"]),
+  [TopPolicy.Slide]: /* @__PURE__ */ new Set(["policy", "speed", "step", "share"]),
+  [TopPolicy.Bounce]: /* @__PURE__ */ new Set(["policy", "stompMin", "bounceSpeed", "jumpBoost"]),
+  [TopPolicy.Ghost]: /* @__PURE__ */ new Set(["policy"])
+};
+var SLIDE_KEYS = /* @__PURE__ */ new Set(["speed", "step", "share"]);
+var PROP_SLIDE_KEYS = /* @__PURE__ */ new Set(["speed", "step"]);
+var PAIR_KEYS = /* @__PURE__ */ new Set(["a", "b", "top"]);
+var BOX_KEYS = /* @__PURE__ */ new Set(["kind", "length", "width", "top"]);
+var HULL_KEYS = /* @__PURE__ */ new Set(["kind", "radius", "height"]);
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var has = (o, k) => Object.hasOwn(o, k) && o[k] !== void 0;
+function onlyKeys(o, keys, path) {
+  const unknown = Object.keys(o).find((k) => !keys.has(k));
+  if (unknown !== void 0) throw new ContactConfigError(`${path}.${unknown}`, "is not a contact setting");
+}
+function num(o, key, path, fallback, lo, hi, open = false) {
+  if (!has(o, key)) return fallback;
+  const v = o[key];
+  const low = open ? v > lo : v >= lo;
+  if (typeof v !== "number" || !Number.isFinite(v) || !low || v > hi) throw new ContactConfigError(`${path}.${key}`, `must be a number in ${open ? "(" : "["}${lo}, ${hi}]`);
+  return v;
+}
+function slideOf(v, path, base, keys = SLIDE_KEYS) {
+  if (!isRecord(v)) throw new ContactConfigError(path, "must be an object");
+  onlyKeys(v, keys, path);
+  const speed = num(v, "speed", path, base.speed, 0, CONTACT_VALUE_MAX);
+  const step = has(v, "step") && v.step === null ? null : num(v, "step", path, base.step ?? CONTACT_VALUE_MAX, 0, CONTACT_VALUE_MAX, true);
+  const keptStep = !has(v, "step") ? base.step : step;
+  return { speed, step: keptStep, share: num(v, "share", path, base.share, 0, 1) };
+}
+var baseSlide = (top, vehicle) => {
+  if (top.policy === TopPolicy.Slide) return { speed: top.speed, step: top.step, share: top.share };
+  if (top.policy === TopPolicy.Bounce || top.policy === TopPolicy.Stand) return top.slide;
+  return vehicle ? VEHICLE_SLIDE : CHARACTER_SLIDE;
+};
+function standOf(v, path, base, vehicle) {
+  const from = base.policy === TopPolicy.Stand ? base : stand(true, null, baseSlide(base, vehicle));
+  if (has(v, "ride") && typeof v.ride !== "boolean") throw new ContactConfigError(`${path}.ride`, "must be true or false");
+  const ride = has(v, "ride") ? v.ride : from.ride;
+  const center = !has(v, "center") ? from.center : v.center === null ? null : num(v, "center", path, 1, 0, 1, true);
+  const s = has(v, "slide") ? slideOf(v.slide, `${path}.slide`, from.slide) : from.slide;
+  return stand(ride, center, s);
+}
+function topOf(v, path, base, vehicle) {
+  if (!isRecord(v)) throw new ContactConfigError(path, "must be an object");
+  const policy = v.policy;
+  if (typeof policy !== "string" || !Object.hasOwn(TOP_KEYS, policy)) throw new ContactConfigError(`${path}.policy`, "must be stand, slide, bounce or ghost");
+  const p = policy;
+  onlyKeys(v, TOP_KEYS[p], path);
+  if (p === TopPolicy.Stand) return standOf(v, path, base, vehicle);
+  if (p === TopPolicy.Ghost) return { policy: p };
+  if (p === TopPolicy.Slide) return slideTop(slideOf(v, path, baseSlide(base, vehicle), TOP_KEYS[p]));
+  const stomp = base.policy === TopPolicy.Bounce ? base : STOMP;
+  return {
+    policy: TopPolicy.Bounce,
+    stompMin: num(v, "stompMin", path, stomp.policy === TopPolicy.Bounce ? stomp.stompMin : 0, 0, CONTACT_VALUE_MAX),
+    bounceSpeed: num(v, "bounceSpeed", path, stomp.policy === TopPolicy.Bounce ? stomp.bounceSpeed : 0, 0, CONTACT_VALUE_MAX),
+    jumpBoost: num(v, "jumpBoost", path, stomp.policy === TopPolicy.Bounce ? stomp.jumpBoost : 0, 0, CONTACT_VALUE_MAX),
+    slide: baseSlide(base, vehicle)
+  };
+}
+function shapeOf(v, path, preset) {
+  const p = preset.params;
+  if (v === void 0) {
+    if (preset.name === "vehicle") return { kind: ContactShapeKind.Box, length: 2 * (p.radius ?? 0), width: 2 * (p.radius ?? 0), top: p.height ?? 0 };
+    return { kind: ContactShapeKind.Hull, radius: p.radius ?? 0, height: p.standHeight ?? p.height ?? 0 };
+  }
+  if (!isRecord(v)) throw new ContactConfigError(path, "must be an object");
+  if (v.kind === ContactShapeKind.Box) {
+    onlyKeys(v, BOX_KEYS, path);
+    const dim = (k) => num(v, k, path, Number.NaN, 0, CONTACT_VALUE_MAX, true);
+    return { kind: ContactShapeKind.Box, length: dim("length"), width: dim("width"), top: dim("top") };
+  }
+  if (v.kind === ContactShapeKind.Hull) {
+    onlyKeys(v, HULL_KEYS, path);
+    const dim = (k) => num(v, k, path, Number.NaN, 0, CONTACT_VALUE_MAX, true);
+    return { kind: ContactShapeKind.Hull, radius: dim("radius"), height: dim("height") };
+  }
+  throw new ContactConfigError(`${path}.kind`, "must be box or hull");
+}
+function requireShape(shape, path) {
+  for (const [k, v] of Object.entries(shape)) if (typeof v === "number" && Number.isNaN(v)) throw new ContactConfigError(`${path}.${k}`, "is required");
+  return shape;
+}
+function headFrictionOf(given, path, base) {
+  if (!has(given, "headFriction")) return base;
+  const v = given.headFriction;
+  if (!Object.values(HeadFriction).includes(v)) throw new ContactConfigError(`${path}.headFriction`, "must be slide or carry");
+  return v;
+}
+function propSlideOf(given, path) {
+  if (!has(given, "propSlide")) return PROP_SLIDE;
+  const v = given.propSlide;
+  const at = `${path}.propSlide`;
+  if (!isRecord(v)) throw new ContactConfigError(at, "must be an object");
+  onlyKeys(v, PROP_SLIDE_KEYS, at);
+  return { speed: num(v, "speed", at, PROP_SLIDE.speed, 0, CONTACT_VALUE_MAX), step: num(v, "step", at, PROP_SLIDE.step, 0, CONTACT_VALUE_MAX, true) };
+}
+function pairsOf(v, path, base, vehicle) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v) || v.length > CONTACT_PAIRS_MAX) throw new ContactConfigError(path, `must be a list of at most ${CONTACT_PAIRS_MAX} pair rules`);
+  return v.map((r, i) => {
+    const at = `${path}[${i}]`;
+    if (!isRecord(r)) throw new ContactConfigError(at, "must be an object");
+    onlyKeys(r, PAIR_KEYS, at);
+    for (const k of ["a", "b"]) {
+      const tag = r[k];
+      if (typeof tag !== "string" || tag.length === 0 || tag.length > CONTACT_TAG_MAX) throw new ContactConfigError(`${at}.${k}`, `must be a tag of 1 to ${CONTACT_TAG_MAX} characters`);
+    }
+    return { a: r.a, b: r.b, top: topOf(r.top, `${at}.top`, base, vehicle) };
+  });
+}
+function passesOf(o, path, fallback) {
+  const n = num(o, "passes", path, fallback, 1, CONTACT_PASSES_MAX);
+  if (!Number.isInteger(n)) throw new ContactConfigError(`${path}.passes`, `must be an integer in [1, ${CONTACT_PASSES_MAX}]`);
+  return n;
+}
+var WORLD_PRESETS = /* @__PURE__ */ new Set(["firstperson", "vehicle"]);
+function resolveContactConfig(given, preset, path = "$.config.contacts") {
+  if (!isRecord(given)) throw new ContactConfigError(path, "must be an object");
+  onlyKeys(given, KEYS, path);
+  if (preset === null || !WORLD_PRESETS.has(preset.name)) throw new ContactConfigError(path, "needs a firstperson or vehicle movement preset");
+  const name = given.preset;
+  if (typeof name !== "string" || !Object.hasOwn(CONTACT_PRESETS, name)) throw new ContactConfigError(`${path}.preset`, "must be shooter, platformer, vehicle-arena, physics-sandbox or party");
+  const table = CONTACT_PRESETS[name];
+  const shape = requireShape(shapeOf(given.shape, `${path}.shape`, preset), `${path}.shape`);
+  const vehicle = shape.kind === ContactShapeKind.Box;
+  const base = vehicle ? table.vehicle : table.character;
+  const top = given.top === void 0 ? base : topOf(given.top, `${path}.top`, base, vehicle);
+  const offBase = vehicle ? table.vehicleOffWall : baseSlide(base, false);
+  const p = preset.params;
+  const maxVelocity = has(given, "maxVelocity") && given.maxVelocity === null ? null : num(given, "maxVelocity", path, p.maxVelocity ?? CONTACT_VALUE_MAX, 0, CONTACT_VALUE_MAX, true);
+  if (has(given, "stopSpin") && typeof given.stopSpin !== "boolean") throw new ContactConfigError(`${path}.stopSpin`, "must be true or false");
+  return {
+    preset: name,
+    shape,
+    hull: { radius: p.radius ?? 0, height: p.standHeight ?? p.height ?? 0, skin: p.skin ?? 0 },
+    groundTrace: p.groundTrace ?? 0,
+    supportCos: num(given, "supportCos", path, CONTACT_DEFAULTS.supportCos, 0, 1),
+    entrySpeed: num(given, "entrySpeed", path, CONTACT_DEFAULTS.entrySpeed, 0, CONTACT_VALUE_MAX, true),
+    entryWindow: num(given, "entryWindow", path, CONTACT_DEFAULTS.entryWindow, 0, 1, true),
+    restitution: num(given, "restitution", path, table.restitution, 0, 1),
+    passes: passesOf(given, path, table.passes),
+    slop: num(given, "slop", path, CONTACT_DEFAULTS.slop, 0, CONTACT_VALUE_MAX),
+    roofSkin: num(given, "roofSkin", path, CONTACT_DEFAULTS.roofSkin, 0, CONTACT_VALUE_MAX),
+    maxVelocity,
+    stopSpin: has(given, "stopSpin") ? given.stopSpin : table.stopSpin,
+    top,
+    offWall: given.offWall === void 0 ? offBase : slideOf(given.offWall, `${path}.offWall`, offBase),
+    pairs: pairsOf(given.pairs, `${path}.pairs`, base, vehicle),
+    drawing: drawingOf(given, path, table.drawing),
+    push: pushOf(given, path, table.push),
+    headFriction: headFrictionOf(given, path, table.headFriction),
+    propSlide: propSlideOf(given, path)
+  };
+}
+
+// src/authority/input-config.ts
+var InputRepeat = { On: "on", Off: "off" };
+var INPUT_SETTLE_MS = { MIN: 100, MAX: 6e4 };
+var INPUT_PRESETS = {
+  [ContactPreset.Shooter]: { repeat: InputRepeat.On },
+  [ContactPreset.Platformer]: { repeat: InputRepeat.On },
+  [ContactPreset.VehicleArena]: { repeat: InputRepeat.Off },
+  [ContactPreset.PhysicsSandbox]: { repeat: InputRepeat.On },
+  [ContactPreset.Party]: { repeat: InputRepeat.On }
+};
+var INPUTS_DEFAULT = { repeat: InputRepeat.On };
+var InputConfigError = class extends Error {
+  path;
+  constructor(path) {
+    super(`bad config at ${path}`);
+    this.name = "InputConfigError";
+    this.path = path;
+  }
+};
+var KEYS2 = /* @__PURE__ */ new Set(["preset", "repeat", "settleMs"]);
+var isPlainObject2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var isPreset = (v) => Object.values(ContactPreset).some((p) => p === v);
+var isRepeat = (v) => v === InputRepeat.On || v === InputRepeat.Off;
+var isSettleMs = (v) => typeof v === "number" && Number.isFinite(v) && v >= INPUT_SETTLE_MS.MIN && v <= INPUT_SETTLE_MS.MAX;
+function resolveInputConfig(given, contactsPreset, path = "$.config.inputs") {
+  if (given === void 0 || given === null) return contactsPreset === null ? null : INPUT_PRESETS[contactsPreset];
+  if (!isPlainObject2(given)) throw new InputConfigError(path);
+  for (const key of Object.keys(given)) if (!KEYS2.has(key)) throw new InputConfigError(`${path}.${key}`);
+  if (given.preset !== void 0 && !isPreset(given.preset)) throw new InputConfigError(`${path}.preset`);
+  if (given.repeat !== void 0 && !isRepeat(given.repeat)) throw new InputConfigError(`${path}.repeat`);
+  if (given.settleMs !== void 0 && !isSettleMs(given.settleMs)) throw new InputConfigError(`${path}.settleMs`);
+  const preset = given.preset ?? contactsPreset;
+  const fromPreset = preset === null ? INPUTS_DEFAULT : INPUT_PRESETS[preset];
+  const repeat = given.repeat ?? fromPreset.repeat;
+  return given.settleMs === void 0 ? { repeat } : { repeat, settleMs: given.settleMs };
+}
+function presetInputRepeat(presetText) {
+  let spec;
+  try {
+    spec = JSON.parse(presetText);
+  } catch {
+    return InputRepeat.On;
+  }
+  const inputs = isPlainObject2(spec) ? spec.inputs : void 0;
+  return isPlainObject2(inputs) && inputs.repeat === InputRepeat.Off ? InputRepeat.Off : InputRepeat.On;
+}
+
+// src/authority/lifetime-config.ts
+var AuthorityLifetime = {
+  IDLE_SEAT_S: 30 * 60,
+  IDLE_SEAT_MIN_S: 30,
+  IDLE_SEAT_MAX_S: 24 * 60 * 60,
+  ROOM_AGE_S: 24 * 60 * 60,
+  ROOM_AGE_MIN_S: 60,
+  ROOM_AGE_MAX_S: 7 * 24 * 60 * 60
+};
+var LIFETIME_DEFAULT = { idleSeatS: AuthorityLifetime.IDLE_SEAT_S, maxRoomAgeS: AuthorityLifetime.ROOM_AGE_S };
+var LifetimeConfigError = class extends Error {
+  path;
+  constructor(path) {
+    super(`bad config at ${path}`);
+    this.name = "LifetimeConfigError";
+    this.path = path;
+  }
+};
+var KEYS3 = /* @__PURE__ */ new Set(["idleSeatS", "maxRoomAgeS"]);
+var inRange2 = (v, min, max) => typeof v === "number" && Number.isInteger(v) && v >= min && v <= max;
+function resolveLifetime(given, path = "$.config.lifetime") {
+  if (given === void 0 || given === null) return null;
+  if (typeof given !== "object" || Array.isArray(given)) throw new LifetimeConfigError(path);
+  const declared = given;
+  for (const key of Object.keys(declared)) if (!KEYS3.has(key)) throw new LifetimeConfigError(`${path}.${key}`);
+  const { idleSeatS, maxRoomAgeS } = declared;
+  if (idleSeatS !== void 0 && !inRange2(idleSeatS, AuthorityLifetime.IDLE_SEAT_MIN_S, AuthorityLifetime.IDLE_SEAT_MAX_S)) throw new LifetimeConfigError(`${path}.idleSeatS`);
+  if (maxRoomAgeS !== void 0 && !inRange2(maxRoomAgeS, AuthorityLifetime.ROOM_AGE_MIN_S, AuthorityLifetime.ROOM_AGE_MAX_S)) throw new LifetimeConfigError(`${path}.maxRoomAgeS`);
+  return { idleSeatS: idleSeatS ?? LIFETIME_DEFAULT.idleSeatS, maxRoomAgeS: maxRoomAgeS ?? LIFETIME_DEFAULT.maxRoomAgeS };
+}
+
+// src/authority/lifts-config.ts
+var LiftShapeKind = {
+  /** A box `half` (x, y, z): axis-aligned, or turned about z when it spins (a sweeper bar). */
+  Box: "box",
+  /** An upright disc of `radius`, `half` its half height (a turntable, a spinner). */
+  Disc: "disc"
+};
+var LiftPathMode = {
+  /** Out along the legs, then back along them. */
+  PingPong: "pingpong",
+  /** Round the points and from the last back to the first. */
+  Loop: "loop"
+};
+var LiftEase = {
+  /** At a steady speed. */
+  Linear: "linear",
+  /** Starting and stopping at rest (`s·s·(3 − 2s)`; its peak speed 1.5 times the mean). */
+  Smooth: "smooth"
+};
+var LiftImpart = {
+  /** The lift's velocity at the rider's point (Unreal's and Godot's default). */
+  All: "all",
+  /** Nothing: the rider leaves with its own velocity. */
+  None: "none"
+};
+var NO_LIFTS = Object.freeze({ platforms: Object.freeze([]), bodies: false });
+var LiftsConfigError = class extends RangeError {
+  path;
+  fast;
+  constructor(path, why, fast) {
+    super(`${path}: ${why}`);
+    this.name = "LiftsConfigError";
+    this.path = path;
+    this.fast = fast;
+  }
+};
+var LIFTS_MAX = 32;
+var LIFT_POINTS_MAX = 16;
+var LIFT_ID_MAX = 32;
+var LIFT_VALUE_MAX = 1e6;
+var LIFT_TICKS_MAX = 2 ** 24;
+var LIFT_SPIN_MIN_PERIOD = 8;
+var SMOOTH_PEAK = 1.5;
+var TWO_PI = 2 * Math.PI;
+var ID = /^[a-z0-9-]+$/;
+var isLiftId = (id) => typeof id === "string" && id.length > 0 && id.length <= LIFT_ID_MAX && ID.test(id);
+var KEYS4 = /* @__PURE__ */ new Set(["platforms", "bodies"]);
+var PLATFORM_KEYS = /* @__PURE__ */ new Set(["id", "shape", "at", "path", "spin", "surface", "impart", "called"]);
+var PATH_KEYS = /* @__PURE__ */ new Set(["points", "legs", "waits", "mode", "ease", "phase"]);
+var SPIN_KEYS = /* @__PURE__ */ new Set(["period", "dir", "phase"]);
+var BOX_KEYS2 = /* @__PURE__ */ new Set(["kind", "half"]);
+var DISC_KEYS = /* @__PURE__ */ new Set(["kind", "radius", "half"]);
+var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var has2 = (o, k) => Object.hasOwn(o, k) && o[k] !== void 0;
+var fround = Math.fround;
+function onlyKeys2(o, keys, path) {
+  const unknown = Object.keys(o).find((k) => !keys.has(k));
+  if (unknown !== void 0) throw new LiftsConfigError(`${path}.${unknown}`, "is not a lift setting");
+}
+function value(v, path, positive = false) {
+  if (typeof v !== "number" || !Number.isFinite(v) || Math.abs(v) > LIFT_VALUE_MAX) throw new LiftsConfigError(path, `must be a number of magnitude at most ${LIFT_VALUE_MAX}`);
+  const f = fround(v) === 0 ? 0 : fround(v);
+  if (positive && !(f > 0)) throw new LiftsConfigError(path, "must be above 0");
+  return f;
+}
+function ticks(v, path, lo) {
+  if (typeof v !== "number" || !Number.isInteger(v) || v < lo || v > LIFT_TICKS_MAX) throw new LiftsConfigError(path, `must be an integer number of ticks in [${lo}, ${LIFT_TICKS_MAX}]`);
+  return v;
+}
+function vector(v, path, n, positive = false) {
+  if (!Array.isArray(v) || v.length !== n) throw new LiftsConfigError(path, `must be an array of ${n} numbers`);
+  return v.map((x, i) => value(x, `${path}[${i}]`, positive));
+}
+function shapeOf2(v, path) {
+  if (!isRecord2(v)) throw new LiftsConfigError(path, "must be an object");
+  if (v.kind === LiftShapeKind.Box) {
+    onlyKeys2(v, BOX_KEYS2, path);
+    return { kind: LiftShapeKind.Box, half: vector(v.half, `${path}.half`, 3, true) };
+  }
+  if (v.kind === LiftShapeKind.Disc) {
+    onlyKeys2(v, DISC_KEYS, path);
+    return { kind: LiftShapeKind.Disc, radius: value(v.radius, `${path}.radius`, true), half: value(v.half, `${path}.half`, true) };
+  }
+  throw new LiftsConfigError(`${path}.kind`, "must be box or disc");
+}
+function enumOf(o, key, path, values, fallback) {
+  if (!has2(o, key)) return fallback;
+  const v = o[key];
+  if (!Object.values(values).includes(v)) throw new LiftsConfigError(`${path}.${key}`, `must be ${Object.values(values).join(" or ")}`);
+  return v;
+}
+function periodOf(legs, waits, mode) {
+  const sum = (xs) => xs.reduce((a, b) => a + b, 0);
+  if (mode === LiftPathMode.Loop) return sum(legs) + sum(waits);
+  return 2 * sum(legs) + 2 * sum(waits) - (waits[0] ?? 0) - (waits[waits.length - 1] ?? 0);
+}
+function pathOf(v, path, called) {
+  if (!isRecord2(v)) throw new LiftsConfigError(path, "must be an object");
+  onlyKeys2(v, PATH_KEYS, path);
+  const mode = enumOf(v, "mode", path, LiftPathMode, LiftPathMode.PingPong);
+  const ease = enumOf(v, "ease", path, LiftEase, LiftEase.Linear);
+  if (!Array.isArray(v.legs) || v.legs.length < 1 || v.legs.length > LIFT_POINTS_MAX) throw new LiftsConfigError(`${path}.legs`, `must be a list of 1 to ${LIFT_POINTS_MAX} leg tick counts`);
+  const legs = v.legs.map((t, i) => ticks(t, `${path}.legs[${i}]`, 1));
+  const wantPoints = mode === LiftPathMode.Loop ? legs.length : legs.length + 1;
+  if (!Array.isArray(v.points) || v.points.length !== wantPoints || wantPoints < 2) {
+    throw new LiftsConfigError(`${path}.points`, `must be ${wantPoints < 2 ? "at least 2" : wantPoints} points (${mode === LiftPathMode.Loop ? "one per leg" : "one more than the legs"})`);
+  }
+  const points = v.points.map((p, i) => vector(p, `${path}.points[${i}]`, 3));
+  const waits = has2(v, "waits") ? v.waits : points.map(() => 0);
+  if (!Array.isArray(waits) || waits.length !== points.length) throw new LiftsConfigError(`${path}.waits`, `must be one wait per point (${points.length})`);
+  const waitTicks = waits.map((t, i) => ticks(t, `${path}.waits[${i}]`, 0));
+  if (called && has2(v, "phase")) throw new LiftsConfigError(`${path}.phase`, "is not allowed on a called lift (its call sets its start)");
+  const phase = has2(v, "phase") ? ticks(v.phase, `${path}.phase`, 0) : 0;
+  return { points, legs, waits: waitTicks, mode, ease, phase, period: periodOf(legs, waitTicks, mode) };
+}
+function spinOf(v, path) {
+  if (!isRecord2(v)) throw new LiftsConfigError(path, "must be an object");
+  onlyKeys2(v, SPIN_KEYS, path);
+  const period = ticks(v.period, `${path}.period`, LIFT_SPIN_MIN_PERIOD);
+  if (has2(v, "dir") && v.dir !== 1 && v.dir !== -1) throw new LiftsConfigError(`${path}.dir`, "must be 1 or -1");
+  return { period, dir: has2(v, "dir") ? v.dir : 1, phase: has2(v, "phase") ? ticks(v.phase, `${path}.phase`, 0) : 0 };
+}
+var reachOf = (s) => s.kind === LiftShapeKind.Disc ? s.radius : Math.sqrt(s.half[0] * s.half[0] + s.half[1] * s.half[1]);
+var speedText = (perTick, tickHz, rate = "") => `${Number(perTick.toFixed(3))} u a tick (${Number((perTick * tickHz).toFixed(1))} u/s${rate})`;
+function refuseFast(lift, path, radius, tickHz) {
+  const spinTip = lift.spin === null ? 0 : reachOf(lift.shape) * TWO_PI / lift.spin.period;
+  const allowed = `at most ${speedText(radius, tickHz, ` at ${tickHz} Hz`)} is allowed (the hull radius a tick)`;
+  const legs = lift.path?.legs ?? [];
+  let fastest = { at: `${path}.spin.period`, move: spinTip };
+  legs.forEach((n, i) => {
+    const p = lift.path;
+    const a = p.points[i];
+    const b = p.points[(i + 1) % p.points.length];
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const dz = b[2] - a[2];
+    const mean = Math.sqrt(dx * dx + dy * dy + dz * dz) / n;
+    const move = (p.ease === LiftEase.Smooth ? SMOOTH_PEAK * mean : mean) + spinTip;
+    if (move > fastest.move) fastest = { at: `${path}.path.legs[${i}]`, move };
+  });
+  if (fastest.move > radius) {
+    throw new LiftsConfigError(fastest.at, `platform '${lift.id}' moves up to ${speedText(fastest.move, tickHz)}; ${allowed}`, { platform: lift.id, move: fastest.move, allowed: radius, tickHz });
+  }
+}
+function platformOf(v, path, ids, radius, tickHz) {
+  if (!isRecord2(v)) throw new LiftsConfigError(path, "must be an object");
+  onlyKeys2(v, PLATFORM_KEYS, path);
+  const id = v.id;
+  if (typeof id !== "string" || id.length === 0 || id.length > LIFT_ID_MAX || !ID.test(id)) throw new LiftsConfigError(`${path}.id`, `must be 1 to ${LIFT_ID_MAX} of a-z, 0-9 and -`);
+  if (ids.has(id)) throw new LiftsConfigError(`${path}.id`, `repeats the id '${id}'`);
+  ids.add(id);
+  const shape = shapeOf2(v.shape, `${path}.shape`);
+  if (has2(v, "called") && typeof v.called !== "boolean") throw new LiftsConfigError(`${path}.called`, "must be true or false");
+  const called = v.called === true;
+  const lpath = has2(v, "path") ? pathOf(v.path, `${path}.path`, called) : null;
+  if (lpath === null && !has2(v, "at")) throw new LiftsConfigError(`${path}.at`, "is required without a path");
+  const at = has2(v, "at") ? vector(v.at, `${path}.at`, 3) : lpath?.points[0];
+  const lift = {
+    id,
+    shape,
+    at,
+    path: lpath,
+    spin: has2(v, "spin") ? spinOf(v.spin, `${path}.spin`) : null,
+    surface: has2(v, "surface") ? vector(v.surface, `${path}.surface`, 2) : null,
+    impart: enumOf(v, "impart", path, LiftImpart, LiftImpart.All),
+    called
+  };
+  refuseFast(lift, path, radius, tickHz);
+  return lift;
+}
+var WORLD_PRESETS2 = /* @__PURE__ */ new Set(["firstperson", "vehicle"]);
+function resolveLifts(given, preset, tickHz, path = "$.config.lifts") {
+  if (!isRecord2(given)) throw new LiftsConfigError(path, "must be an object");
+  onlyKeys2(given, KEYS4, path);
+  if (preset === null || !WORLD_PRESETS2.has(preset.name)) throw new LiftsConfigError(path, "needs a firstperson or vehicle movement preset");
+  const list2 = given.platforms;
+  if (!Array.isArray(list2) || list2.length < 1 || list2.length > LIFTS_MAX) throw new LiftsConfigError(`${path}.platforms`, `must be a list of 1 to ${LIFTS_MAX} platforms`);
+  if (has2(given, "bodies") && typeof given.bodies !== "boolean") throw new LiftsConfigError(`${path}.bodies`, "must be true or false");
+  const radius = preset.params.radius ?? 0;
+  const ids = /* @__PURE__ */ new Set();
+  const platforms = list2.map((p, i) => platformOf(p, `${path}.platforms[${i}]`, ids, radius, tickHz));
+  return { platforms, bodies: given.bodies !== false };
+}
+
+// src/authority/projectile.ts
+var MAX_PROJECTILE_TICK = 2 ** 32 - 1;
+var MAX_PROJECTILE_G = 1e3;
+var isProjectile = (entity) => typeof entity.t0 === "number" && entity.t0 > 0;
+function projectileAt(launch, T, tickHz) {
+  const elapsed = (T - launch.t0) / tickHz;
+  const s = Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : 0;
+  return {
+    x: unsignedZero(Math.fround(launch.x + launch.vx * s)),
+    y: unsignedZero(Math.fround(launch.y + launch.vy * s)),
+    z: unsignedZero(Math.fround(launch.z + launch.vz * s - 0.5 * launch.g * s * s)),
+    vx: unsignedZero(launch.vx),
+    vy: unsignedZero(launch.vy),
+    vz: unsignedZero(Math.fround(launch.vz - launch.g * s))
+  };
+}
+function serverTick(serverNowMs, tickOrigin, tickHz) {
+  return (serverNowMs - tickOrigin) * tickHz / 1e3;
+}
+function tickInstant(tick, tickOrigin, tickHz) {
+  return tickOrigin + tick * 1e3 / tickHz;
+}
+
+// src/authority/wire.ts
+var GuestGlobal = {
+  INIT: "__genex_init",
+  TICK: "__genex_tick",
+  /** A physics room's static world, called once after init (§17.10 *The static world*). */
+  WORLD: "__genex_world",
+  /** The room's hand-off at the end of a drain (PROTOCOL.md §17.13), called once. */
+  HANDOFF: "__genex_handoff"
+};
+var AuthorityLimits = {
+  /** Entities one tick may update, and separately remove. */
+  MAX_ENTITIES: 256,
+  /** A room's hand-off (`onDrain`, PROTOCOL.md §17.13) as JSON text. Over it the successor starts clean. */
+  MAX_HANDOFF_CHARS: 256 * 1024,
+  /** 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). */
+  MAX_ROOM_ENTITIES: 1024,
+  /** One TickOut / InitOut as JSON text. */
+  MAX_OUTPUT_BYTES: 32 * 1024,
+  MAX_EVENTS_PER_TICK: 64,
+  /** One entity's `data` JSON text. */
+  MAX_ENTITY_DATA_BYTES: 256,
+  MAX_ENTITY_ID_CHARS: 64,
+  MAX_KIND_CHARS: 64,
+  /** A session id (`owner`, an event's `to`). */
+  MAX_SESSION_ID_CHARS: 64,
+  /** Every entity number's magnitude (float32 holds it without overflowing). */
+  MAX_ABS,
+  /** `flags` is an integer below this. */
+  MASK_LIMIT,
+  /** `epoch` is an integer in [0, MAX_EPOCH]. */
+  MAX_EPOCH: 2 ** 32 - 1,
+  /** A projectile's launch tick `t0` is an integer in [0, MAX_PROJECTILE_TICK] (§17.9). */
+  MAX_PROJECTILE_TICK,
+  /** A projectile's gravity `g` is in [0, MAX_PROJECTILE_G] units/s². */
+  MAX_PROJECTILE_G,
+  /** 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. */
+  MAX_LAUNCH_UPDATES: 224,
+  MAX_LAUNCH_BYTES: 28 * 1024,
+  /** One event: its type, and its `data` as JSON text. */
+  MAX_EVENT_TYPE_CHARS: Limits.MAX_EVENT_TYPE_CHARS,
+  MAX_EVENT_BYTES: Limits.MAX_EVENT_BYTES,
+  MAX_JSON_DEPTH: Limits.MAX_JSON_DEPTH,
+  MAX_JSON_NODES: Limits.MAX_JSON_NODES,
+  /** Seats one authority room may hold. */
+  MAX_PLAYERS: Limits.ROOM_MAX_CLIENTS,
+  /** 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. */
+  MAX_PHYS_COMMANDS: 256,
+  MAX_PHYS_BYTES: 32 * 1024,
+  MAX_PHYSICS_OUTPUT_BYTES: 64 * 1024,
+  /** 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. */
+  MAX_PHYSICS_WORLD_BOXES: 32768,
+  MAX_PHYSICS_WORLD_RAMPS: 4096,
+  /** `__genex_world()`'s text: base64 of the largest such world, 4 · ⌈(8 + 24 · 32768 + 36 · 4096) / 3⌉. */
+  MAX_WORLD_TEXT_CHARS: 1245196
+};
+var TICK_RATES = [20, 30, 60, 120];
+var PHYSICS_ONLY_TICK_HZ = 120;
+var MAX_TICK_HZ = 120;
+var DEFAULT_TICK_HZ = 60;
+var TickOutFault = {
+  NOT_JSON: "not_json",
+  TOO_LARGE: "too_large",
+  BAD_SHAPE: "bad_shape",
+  NON_FINITE: "non_finite",
+  OUT_OF_RANGE: "out_of_range",
+  BAD_ID: "bad_id",
+  DATA_TOO_LARGE: "data_too_large",
+  TOO_MANY_ENTITIES: "too_many_entities",
+  TOO_MANY_EVENTS: "too_many_events",
+  RESERVED_EVENT: "reserved_event",
+  BAD_CONFIG: "bad_config",
+  /** The module's maps leave a room without a shot world (§17.7 *The shot world*). */
+  NO_SHOT_WORLD: "no_shot_world",
+  /** More `phys` commands than MAX_PHYS_COMMANDS, or more `physQ` queries than `queriesPerStep`. */
+  TOO_MANY_COMMANDS: "too_many_commands"
+};
+var InputUse = {
+  /** A real input: the preset steps it, then `onInput` hears it. */
+  STEP: "step",
+  /** A starved tick: the preset steps the seat's last real input again; `onInput` never hears it. */
+  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. */
+  ABSORB: "absorb"
+};
+function sanitizeInput(raw) {
+  return {
+    moveX: axis(raw.moveX),
+    moveY: axis(raw.moveY),
+    moveZ: axis(raw.moveZ),
+    yaw: wrappedAngle(raw.yaw) ?? 0,
+    pitch: wrappedAngle(raw.pitch) ?? 0,
+    buttons: mask(raw.buttons)
+  };
+}
+var Refusal = class {
+  fault;
+  path;
+  constructor(fault, path) {
+    this.fault = fault;
+    this.path = path;
+  }
+};
+var refuse = (fault, path) => {
+  throw new Refusal(fault, path);
+};
+var FORBIDDEN_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var isRecord3 = (v) => {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+var FLOAT32_FIELDS = ["x", "y", "z", "vx", "vy", "vz", "yaw"];
+var FIRSTPERSON_FLOAT32_FIELDS = ["pitch", "duck", "cap"];
+var VEHICLE_FLOAT32_FIELDS = ["spin", "fuel"];
+var SEAT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+function finite(v, path) {
+  if (typeof v !== "number") return refuse(TickOutFault.BAD_SHAPE, path);
+  if (!Number.isFinite(v)) return refuse(TickOutFault.NON_FINITE, path);
+  if (Math.abs(v) > MAX_ABS) return refuse(TickOutFault.OUT_OF_RANGE, path);
+  return unsignedZero(v);
+}
+function integerIn(v, max, path) {
+  const n = finite(v, path);
+  if (!Number.isInteger(n) || n < 0 || n > max) return refuse(TickOutFault.OUT_OF_RANGE, path);
+  return n;
+}
+function launchTick(v, path) {
+  if (typeof v !== "number") return refuse(TickOutFault.BAD_SHAPE, path);
+  if (!Number.isFinite(v)) return refuse(TickOutFault.NON_FINITE, path);
+  if (!Number.isInteger(v) || v < 0 || v > MAX_PROJECTILE_TICK) return refuse(TickOutFault.OUT_OF_RANGE, path);
+  return unsignedZero(v);
+}
+function boundedString(v, max, path, fault) {
+  if (typeof v !== "string" || v.length > max) return refuse(fault, path);
+  return v;
+}
+function entityId(v, path) {
+  const id = boundedString(v, AuthorityLimits.MAX_ENTITY_ID_CHARS, path, TickOutFault.BAD_ID);
+  if (id.length === 0 || FORBIDDEN_KEYS2.has(id)) return refuse(TickOutFault.BAD_ID, path);
+  return id;
+}
+function jsonValue(v, path, depth, budget) {
+  budget.nodes += 1;
+  if (depth > AuthorityLimits.MAX_JSON_DEPTH || budget.nodes > AuthorityLimits.MAX_JSON_NODES) {
+    return refuse(TickOutFault.BAD_SHAPE, path);
+  }
+  if (v === null || typeof v === "boolean" || typeof v === "string") return v;
+  if (typeof v === "number") {
+    if (!Number.isFinite(v)) return refuse(TickOutFault.NON_FINITE, path);
+    return v;
+  }
+  if (Array.isArray(v)) return v.map((item, i) => jsonValue(item, `${path}[${i}]`, depth + 1, budget));
+  if (!isRecord3(v)) return refuse(TickOutFault.BAD_SHAPE, path);
+  const out = {};
+  for (const key of Object.keys(v)) {
+    if (FORBIDDEN_KEYS2.has(key)) return refuse(TickOutFault.BAD_SHAPE, `${path}.${key}`);
+    out[key] = jsonValue(v[key], `${path}.${key}`, depth + 1, budget);
+  }
+  return out;
+}
+function entityData(v, path) {
+  if (typeof v !== "string") return refuse(TickOutFault.BAD_SHAPE, path);
+  if (v.length > AuthorityLimits.MAX_ENTITY_DATA_BYTES) return refuse(TickOutFault.DATA_TOO_LARGE, path);
+  if (v === "") return v;
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(v);
+  } catch {
+    return refuse(TickOutFault.BAD_SHAPE, path);
+  }
+  jsonValue(parsed2, path, 0, { nodes: 0 });
+  return v;
+}
+function entityOut(v, path) {
+  if (!isRecord3(v)) return refuse(TickOutFault.BAD_SHAPE, path);
+  const out = { id: entityId(v.id, `${path}.id`) };
+  if (v.kind !== void 0) {
+    out.kind = boundedString(v.kind, AuthorityLimits.MAX_KIND_CHARS, `${path}.kind`, TickOutFault.BAD_SHAPE);
+  }
+  if (v.owner !== void 0) {
+    out.owner = boundedString(v.owner, AuthorityLimits.MAX_SESSION_ID_CHARS, `${path}.owner`, TickOutFault.BAD_SHAPE);
+  }
+  for (const key of FLOAT32_FIELDS) {
+    if (v[key] !== void 0) out[key] = unsignedZero(Math.fround(finite(v[key], `${path}.${key}`)));
+  }
+  if (v.hp !== void 0) out.hp = finite(v.hp, `${path}.hp`);
+  if (v.flags !== void 0) out.flags = integerIn(v.flags, MASK_LIMIT - 1, `${path}.flags`);
+  if (v.epoch !== void 0) out.epoch = integerIn(v.epoch, AuthorityLimits.MAX_EPOCH, `${path}.epoch`);
+  if (v.data !== void 0) out.data = entityData(v.data, `${path}.data`);
+  if (v.t0 !== void 0) out.t0 = launchTick(v.t0, `${path}.t0`);
+  if (v.g !== void 0) {
+    const g = finite(v.g, `${path}.g`);
+    if (g < 0 || g > MAX_PROJECTILE_G) return refuse(TickOutFault.OUT_OF_RANGE, `${path}.g`);
+    out.g = unsignedZero(Math.fround(g));
+  }
+  if (v.src !== void 0) {
+    const src = boundedString(v.src, AuthorityLimits.MAX_SESSION_ID_CHARS, `${path}.src`, TickOutFault.BAD_SHAPE);
+    if (src !== "" && !SEAT_ID.test(src)) return refuse(TickOutFault.BAD_SHAPE, `${path}.src`);
+    out.src = src;
+  }
+  for (const key of FIRSTPERSON_FLOAT32_FIELDS) {
+    if (v[key] !== void 0) out[key] = unsignedZero(Math.fround(finite(v[key], `${path}.${key}`)));
+  }
+  if (v.mstate !== void 0) out.mstate = integerIn(v.mstate, MASK_LIMIT - 1, `${path}.mstate`);
+  for (const key of VEHICLE_FLOAT32_FIELDS) {
+    if (v[key] !== void 0) out[key] = unsignedZero(Math.fround(finite(v[key], `${path}.${key}`)));
+  }
+  return out;
+}
+function eventOut(v, path) {
+  if (!isRecord3(v)) return refuse(TickOutFault.BAD_SHAPE, path);
+  const type = boundedString(v.type, AuthorityLimits.MAX_EVENT_TYPE_CHARS, `${path}.type`, TickOutFault.BAD_SHAPE);
+  if (type.length === 0) return refuse(TickOutFault.BAD_SHAPE, `${path}.type`);
+  if (isReservedEventType(type)) return refuse(TickOutFault.RESERVED_EVENT, `${path}.type`);
+  const out = { type };
+  if (v.data !== void 0) {
+    const data = jsonValue(v.data, `${path}.data`, 0, { nodes: 0 });
+    if (JSON.stringify(data).length > AuthorityLimits.MAX_EVENT_BYTES) return refuse(TickOutFault.TOO_LARGE, `${path}.data`);
+    out.data = data;
+  }
+  if (v.to !== void 0) {
+    const to = boundedString(v.to, AuthorityLimits.MAX_SESSION_ID_CHARS, `${path}.to`, TickOutFault.BAD_SHAPE);
+    if (to.length === 0) return refuse(TickOutFault.BAD_SHAPE, `${path}.to`);
+    out.to = to;
+  }
+  return out;
+}
+function list(v, path) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) return refuse(TickOutFault.BAD_SHAPE, path);
+  return v;
+}
+function parsed(raw, maxChars) {
+  if (typeof raw !== "string") return raw;
+  if (raw.length > maxChars) return refuse(TickOutFault.TOO_LARGE, "$");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return refuse(TickOutFault.NOT_JSON, "$");
+  }
+}
+var finiteOnly = (path) => (_key, v) => typeof v === "number" && !Number.isFinite(v) ? refuse(TickOutFault.NON_FINITE, path) : v;
+function commandList(v, path, max) {
+  const items = list(v, path);
+  if (items.length > max) return refuse(TickOutFault.TOO_MANY_COMMANDS, path);
+  items.forEach((item, i) => {
+    if (!isRecord3(item) || Object.keys(item).length !== 1) refuse(TickOutFault.BAD_SHAPE, `${path}[${i}]`);
+  });
+  const text = JSON.stringify(items, finiteOnly(path));
+  return { text, items: JSON.parse(text) };
+}
+function physicsOut(value2, physics) {
+  const out = {};
+  let bytes = 0;
+  if (value2.phys !== void 0) {
+    const phys = commandList(value2.phys, "$.phys", AuthorityLimits.MAX_PHYS_COMMANDS);
+    bytes += phys.text.length;
+    out.phys = phys.items;
+  }
+  if (value2.physQ !== void 0) {
+    if (physics.queries === null) return refuse(TickOutFault.BAD_SHAPE, "$.physQ");
+    const physQ = commandList(value2.physQ, "$.physQ", physics.queries);
+    bytes += physQ.text.length;
+    out.physQ = physQ.items;
+  }
+  if (bytes > AuthorityLimits.MAX_PHYS_BYTES) return refuse(TickOutFault.TOO_LARGE, "$.phys");
+  const { phys: _phys, physQ: _physQ, ...rest } = value2;
+  if (JSON.stringify(rest).length > AuthorityLimits.MAX_OUTPUT_BYTES) return refuse(TickOutFault.TOO_LARGE, "$");
+  return out;
+}
+function checkBodyEntities(value2, out, bodies) {
+  const raw = value2.up;
+  const removed = new Set(out.rm);
+  out.up.forEach((e, i) => {
+    if (!bodies.has(e.id) || removed.has(e.id)) return;
+    const fields = raw?.[i];
+    for (const field of HOST_BODY_FIELDS) {
+      if (fields[field] !== void 0) refuse(TickOutFault.BAD_SHAPE, `$.up[${i}].${field}`);
+    }
+    if ((e.t0 ?? 0) > 0) refuse(TickOutFault.BAD_SHAPE, `$.up[${i}].t0`);
+  });
+}
+function tickOutOf(value2, physics) {
+  if (!isRecord3(value2)) return refuse(TickOutFault.BAD_SHAPE, "$");
+  const up = list(value2.up, "$.up");
+  const rm = list(value2.rm, "$.rm");
+  const ev = list(value2.ev, "$.ev");
+  if (up.length > AuthorityLimits.MAX_ENTITIES) return refuse(TickOutFault.TOO_MANY_ENTITIES, "$.up");
+  if (rm.length > AuthorityLimits.MAX_ENTITIES) return refuse(TickOutFault.TOO_MANY_ENTITIES, "$.rm");
+  if (ev.length > AuthorityLimits.MAX_EVENTS_PER_TICK) return refuse(TickOutFault.TOO_MANY_EVENTS, "$.ev");
+  const out = {
+    up: up.map((e, i) => entityOut(e, `$.up[${i}]`)),
+    rm: rm.map((id, i) => entityId(id, `$.rm[${i}]`)),
+    ev: ev.map((e, i) => eventOut(e, `$.ev[${i}]`))
+  };
+  if (value2.lifts !== void 0) out.lifts = liftStartsOut(value2.lifts);
+  if (physics === void 0) return out;
+  checkBodyEntities(value2, out, physics.bodies);
+  return { ...out, ...physicsOut(value2, physics) };
+}
+var LIFT_START_MAX = 2 ** 31 - 1;
+function liftStartsOut(v) {
+  const path = "$.lifts";
+  if (!isRecord3(v)) return refuse(TickOutFault.BAD_SHAPE, path);
+  const entries = Object.entries(v);
+  if (entries.length > LIFTS_MAX) return refuse(TickOutFault.BAD_SHAPE, path);
+  const out = {};
+  for (const [id, start] of entries) {
+    if (!isLiftId(id)) return refuse(TickOutFault.BAD_SHAPE, path);
+    if (typeof start !== "number" || !Number.isInteger(start) || start < 0 || start > LIFT_START_MAX) return refuse(TickOutFault.BAD_SHAPE, `${path}.${id}`);
+    out[id] = start;
+  }
+  return out;
+}
+function entityCountAfter(room, out) {
+  const added = new Set(out.up.filter((e) => !room.has(e.id)).map((e) => e.id));
+  const updated = new Set(out.up.map((e) => e.id));
+  const removed = new Set(out.rm.filter((id) => room.has(id) && !updated.has(id)));
+  return room.size + added.size - removed.size;
+}
+function checkProjectileOwners(room, out) {
+  const merged = /* @__PURE__ */ new Map();
+  out.up.forEach((e, i) => {
+    const current = merged.get(e.id) ?? room?.get?.(e.id);
+    const next = { t0: e.t0 ?? current?.t0 ?? 0, owner: e.owner ?? current?.owner ?? "" };
+    if (next.t0 > 0 && next.owner !== "") refuse(TickOutFault.BAD_SHAPE, `$.up[${i}].owner`);
+    merged.set(e.id, next);
+  });
+}
+function roomTickOutOf(value2, room, physics) {
+  const out = tickOutOf(value2, physics);
+  if (room !== void 0 && entityCountAfter(room, out) > AuthorityLimits.MAX_ROOM_ENTITIES) {
+    return refuse(TickOutFault.TOO_MANY_ENTITIES, "$.up");
+  }
+  checkProjectileOwners(room, out);
+  return out;
+}
+var EMPTY_ROOM = { size: 0, has: () => false };
+function presetOf(v, path) {
+  if (v === null || v === void 0) return null;
+  if (!isRecord3(v) || !isPresetName(v.name)) return refuse(TickOutFault.BAD_CONFIG, path);
+  if (!presetParamsValid(v.name, v.params)) return refuse(TickOutFault.BAD_CONFIG, `${path}.params`);
+  if (definitionOf(v.name)?.world === true && v.params?.world === void 0) {
+    return refuse(TickOutFault.BAD_CONFIG, `${path}.params.world`);
+  }
+  return v.params === void 0 ? { name: v.name } : { name: v.name, params: { ...v.params } };
+}
+function configOf(v, admission) {
+  if (!isRecord3(v)) return refuse(TickOutFault.BAD_CONFIG, "$.config");
+  const tickHz = TICK_RATES.find((hz) => hz === v.tickHz);
+  if (tickHz === void 0) return refuse(TickOutFault.BAD_CONFIG, "$.config.tickHz");
+  const maxPlayers = v.maxPlayers;
+  const playersOk = typeof maxPlayers === "number" && Number.isInteger(maxPlayers) && maxPlayers >= 1 && maxPlayers <= AuthorityLimits.MAX_PLAYERS;
+  if (!playersOk) return refuse(TickOutFault.BAD_CONFIG, "$.config.maxPlayers");
+  let lagComp = null;
+  if (v.lagComp !== null && v.lagComp !== void 0) {
+    if (!isRecord3(v.lagComp) || !isMask(v.lagComp.buttons)) return refuse(TickOutFault.BAD_CONFIG, "$.config.lagComp");
+    lagComp = { buttons: v.lagComp.buttons };
+  }
+  const preset = presetOf(v.preset, "$.config.preset");
+  const physics = checkResolvedPhysics(v.physics, preset, admission?.ceiling ?? null);
+  if (!physics.ok) return refuse(TickOutFault.BAD_CONFIG, physics.path);
+  if (tickHz === PHYSICS_ONLY_TICK_HZ && physics.value === null) return refuse(TickOutFault.BAD_CONFIG, "$.config.tickHz");
+  const contacts = contactsOf(v.contacts, preset);
+  const inputs = inputsOf(v.inputs, contacts);
+  const lifts = liftsOf(v.lifts, preset, tickHz);
+  const lifetime = lifetimeOf(v.lifetime);
+  return {
+    tickHz,
+    maxPlayers,
+    preset,
+    lagComp,
+    physics: physics.value,
+    ...contacts === null ? {} : { contacts },
+    ...inputs === null ? {} : { inputs },
+    ...lifts === null ? {} : { lifts },
+    ...lifetime === null ? {} : { lifetime }
+  };
+}
+function lifetimeOf(v) {
+  try {
+    return resolveLifetime(v);
+  } catch (e) {
+    if (e instanceof LifetimeConfigError) return refuse(TickOutFault.BAD_CONFIG, e.path);
+    throw e;
+  }
+}
+function inputsOf(v, contacts) {
+  try {
+    return resolveInputConfig(v, contacts?.preset ?? null);
+  } catch (e) {
+    if (e instanceof InputConfigError) return refuse(TickOutFault.BAD_CONFIG, e.path);
+    throw e;
+  }
+}
+function liftsOf(v, preset, tickHz) {
+  if (v === null || v === void 0) return null;
+  const params = preset === null ? null : { name: preset.name, params: resolvePresetParams(preset.name, preset.params) };
+  try {
+    return resolveLifts(v, params, tickHz);
+  } catch (e) {
+    if (e instanceof LiftsConfigError) return refuse(TickOutFault.BAD_CONFIG, e.message);
+    throw e;
+  }
+}
+function contactsOf(v, preset) {
+  if (v === null || v === void 0) return null;
+  const params = preset === null ? null : { name: preset.name, params: resolvePresetParams(preset.name, preset.params) };
+  try {
+    return resolveContactConfig(v, params);
+  } catch (e) {
+    if (e instanceof ContactConfigError) return refuse(TickOutFault.BAD_CONFIG, e.path);
+    throw e;
+  }
+}
+function gate(raw, build, physics) {
+  try {
+    const maxChars = physics ? AuthorityLimits.MAX_PHYSICS_OUTPUT_BYTES : AuthorityLimits.MAX_OUTPUT_BYTES;
+    const value2 = build(parsed(raw, maxChars));
+    if (!physics && typeof raw !== "string" && JSON.stringify(value2).length > AuthorityLimits.MAX_OUTPUT_BYTES) {
+      return { ok: false, fault: TickOutFault.TOO_LARGE, path: "$" };
+    }
+    return { ok: true, value: value2 };
+  } catch (err) {
+    if (err instanceof Refusal) return { ok: false, fault: err.fault, path: err.path };
+    return { ok: false, fault: TickOutFault.BAD_SHAPE, path: "$" };
+  }
+}
+function validateTickOut(raw, room, physics) {
+  const wire = physics === void 0 ? void 0 : { queries: physics.queriesPerStep, bodies: physics.bodies };
+  return gate(raw, (value2) => roomTickOutOf(value2, room, wire), wire !== void 0);
+}
+var NO_BODIES = { has: () => false };
+function shotCountOf(value2) {
+  if (value2 === null || typeof value2 !== "object") return void 0;
+  const { solids, opsPerRay } = value2;
+  return Number.isInteger(solids) && Number.isInteger(opsPerRay) ? { solids, opsPerRay } : void 0;
+}
+function worldNamesOf(value2) {
+  if (!Array.isArray(value2) || value2.length > AuthorityRoomLimits.MAX_WORLDS) return void 0;
+  return value2.every(validMatchKey) ? value2 : void 0;
+}
+function validateInitOut(raw, physics) {
+  const wire = physics === void 0 ? void 0 : { queries: null, bodies: NO_BODIES };
+  return gate(
+    raw,
+    (value2) => {
+      const out = roomTickOutOf(value2, EMPTY_ROOM, wire);
+      const { config, worlds, shotWorld, noShotWorld } = value2;
+      if (typeof noShotWorld === "string") return refuse(TickOutFault.NO_SHOT_WORLD, `$.shotWorld: ${noShotWorld}`);
+      const named = worldNamesOf(worlds);
+      const counted = shotCountOf(shotWorld);
+      return { ...out, config: configOf(config, physics), ...named === void 0 ? {} : { worlds: named }, ...counted === void 0 ? {} : { shotWorld: counted } };
+    },
+    wire !== void 0
+  );
+}
+
+// src/authority/fast-transport.ts
+var FAST_VERSION = 1;
+var FAST_MAX_DATAGRAM_BYTES = 1200;
+var FAST_KEY_BYTES = 8;
+var INPUT_REDUNDANCY_MS = 170;
+var INPUT_REDUNDANCY_MIN = 3;
+var INPUT_REDUNDANCY_MAX = 32;
+var FAST_MAX_ACTIONS = 8;
+var FAST_GAP_FILL_MS = 250;
+var FAST_SEQ_AHEAD_MS = 5e3;
+var FAST_SNAPSHOT_HISTORY = 32;
+var FAST_MAX_FRAGMENTS = 32;
+var FAST_REASSEMBLY_SLOTS = 4;
+var FAST_MAX_RECORD_BYTES = 1024;
+var FAST_HANDSHAKE_MS = 1e3;
+var FAST_STALL_FALLBACK_MS = 2e3;
+var FAST_KEEPALIVE_MS = 250;
+var FAST_KEEPALIVE_BIND_MS = 50;
+var FAST_ACK_EAGER_RECORDS = 32;
+var FAST_ACK_EAGER_GAP_MS = 20;
+var FAST_CHALLENGE_JUMP = 65536;
+var FAST_FRAME_GAP_MS = 250;
+var FAST_BIND_REV = 2;
+var FAST_RETURN_PROOF = 3;
+var FAST_RETRY_BASE_MS = 1e3;
+var FAST_RETRY_MAX_MS = 6e4;
+var FAST_RETURN_STABLE_MS = 3e4;
+function fastRetryDelayMs(attempt, unit) {
+  const full = Math.min(FAST_RETRY_MAX_MS, FAST_RETRY_BASE_MS * 2 ** Math.min(attempt, 16));
+  return full / 2 + full / 2 * unit;
+}
+var FastMessage = {
+  /** Server → client: `{ sid, key, url }`, the seat's binding. */
+  Bind: "__fast",
+  /** Client → server: `{ last }`, the last seq the client sent by datagram; its inputs go by
+   *  `room.input()` from now on. */
+  Off: "__fast:off",
+  /** Client → server: `{}`, a seat off the channel asks for a fresh binding (§17.12 *Return to the channel*). */
+  Again: "__fast:again",
+  /** Client → server: `{ last }`, the last seq it sent by WebSocket; its inputs go by datagram from now on. */
+  On: "__fast:on"
+};
+var FastKind = { Uplink: 1, Snapshot: 2 };
+var FastFault = {
+  Oversized: "oversized",
+  Truncated: "truncated",
+  Trailing: "trailing",
+  Version: "version",
+  Kind: "kind",
+  Session: "session",
+  Key: "key",
+  Count: "count",
+  Fresh: "fresh",
+  Actions: "actions",
+  Flags: "flags",
+  Order: "order",
+  Field: "field",
+  Ahead: "ahead",
+  Fragment: "fragment",
+  Mismatch: "mismatch",
+  Duplicate: "duplicate",
+  Keyframe: "keyframe",
+  Body: "body",
+  Base: "base",
+  Stale: "stale"
+};
+var AcceptKind = {
+  /** First sent in the datagram that brought it. */
+  Fresh: "fresh",
+  /** Sent first in an earlier datagram that was lost; carried again by redundancy or as an action. */
+  Recovered: "recovered",
+  /** No datagram the server got carried it: the last input held stands in for it. */
+  Fill: "fill"
+};
+var UPLINK_HEADER = 29;
+var SNAPSHOT_HEADER = 29;
+var PAYLOAD = 24;
+var SLOT_SAME = 1;
+var SLOT_TICK_SAME = 2;
+var SLOT_TICK_NEXT = 4;
+var SLOT_FLAGS = SLOT_SAME | SLOT_TICK_SAME | SLOT_TICK_NEXT;
+var BACK_NONE = 255;
+var ACTION_HEAD = 10;
+var SLOT_MAX = 4 + PAYLOAD;
+var UINT32_MAX = 4294967295;
+var TICK_MOD = 65536;
+var KEYFRAME = 1;
+var NEUTRAL = { moveX: 0, moveY: 0, moveZ: 0, yaw: 0, pitch: 0, buttons: 0 };
+var ok = (value2) => ({ ok: true, value: value2 });
+var fail = (fault) => ({ ok: false, fault });
+var ticksOf = (ms, tickHz) => Math.ceil(ms * (Number.isFinite(tickHz) && tickHz > 0 ? tickHz : 0) / 1e3);
+var isUint = (v, max) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= max;
+function inputRedundancyTicks(tickHz) {
+  return Math.min(INPUT_REDUNDANCY_MAX, Math.max(INPUT_REDUNDANCY_MIN, ticksOf(INPUT_REDUNDANCY_MS, tickHz)));
+}
+function uplinkMaxBytes(tickHz) {
+  return UPLINK_HEADER + FAST_MAX_ACTIONS * (ACTION_HEAD + PAYLOAD) + inputRedundancyTicks(tickHz) * SLOT_MAX;
+}
+var gapFillMax = (tickHz) => ticksOf(FAST_GAP_FILL_MS, tickHz);
+var seqAheadMax = (tickHz) => ticksOf(FAST_SEQ_AHEAD_MS, tickHz);
+function toHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(hex) {
+  if (!/^(?:[0-9a-fA-F]{2})*$/.test(hex)) return new Uint8Array(0);
+  return Uint8Array.from(hex.match(/../g) ?? [], (h) => Number.parseInt(h, 16));
+}
+var isKey = (key) => typeof key === "string" && key.length === 2 * FAST_KEY_BYTES && /^[0-9a-f]+$/.test(key);
+var isPress = (previous, input) => (input.buttons & ~(previous?.buttons ?? 0)) !== 0;
+var validPayload = (p) => [p.moveX, p.moveY, p.moveZ, p.yaw, p.pitch].every((x) => typeof x === "number" && Number.isFinite(Math.fround(x))) && isUint(p.buttons, UINT32_MAX);
+var validInput = (s) => isUint(s.seq, UINT32_MAX) && s.seq >= 1 && isUint(s.tick, TICK_MOD - 1) && isUint(s.render, UINT32_MAX) && validPayload(s.input);
+var windowRender = (window) => window.reduce((m, s) => Math.max(m, s.render), 0);
+var backOf = (render, s) => s.render === 0 || render - s.render >= BACK_NONE ? BACK_NONE : render - s.render;
+var renderOf = (render, back) => back === BACK_NONE || render - back <= 0 ? 0 : render - back;
+function validUplink(u) {
+  const { window, actions } = u;
+  if (!isUint(u.sid, UINT32_MAX) || !isKey(u.key) || !isUint(u.ackSnap, UINT32_MAX)) return false;
+  if (window.length === 0) return u.fresh === 0 && actions.length === 0;
+  if (window.length > INPUT_REDUNDANCY_MAX || actions.length > FAST_MAX_ACTIONS) return false;
+  if (!isUint(u.fresh, window.length) || u.fresh < 1) return false;
+  if (![...actions, ...window].every(validInput)) return false;
+  const contiguous = window.every((s, i) => i === 0 || s.seq === window[i - 1].seq + 1);
+  const ascending = actions.every((s, i) => s.seq < (i + 1 < actions.length ? actions[i + 1].seq : window[0].seq));
+  return contiguous && ascending;
+}
+function writePayload(view, at, p) {
+  view.setFloat32(at, p.moveX, true);
+  view.setFloat32(at + 4, p.moveY, true);
+  view.setFloat32(at + 8, p.moveZ, true);
+  view.setFloat32(at + 12, p.yaw, true);
+  view.setFloat32(at + 16, p.pitch, true);
+  view.setUint32(at + 20, p.buttons, true);
+  return at + PAYLOAD;
+}
+function readPayload(view, at) {
+  return {
+    moveX: view.getFloat32(at, true),
+    moveY: view.getFloat32(at + 4, true),
+    moveZ: view.getFloat32(at + 8, true),
+    yaw: view.getFloat32(at + 12, true),
+    pitch: view.getFloat32(at + 16, true),
+    buttons: view.getUint32(at + 20, true)
+  };
+}
+var payloadBits = (p) => {
+  const b = new Uint8Array(PAYLOAD);
+  writePayload(new DataView(b.buffer), 0, p);
+  return toHex(b);
+};
+function slotFlags(previous, s) {
+  if (previous === null) return 0;
+  let flags = payloadBits(previous.input) === payloadBits(s.input) ? SLOT_SAME : 0;
+  if (s.tick === previous.tick) flags |= SLOT_TICK_SAME;
+  else if (s.tick === (previous.tick + 1) % TICK_MOD) flags |= SLOT_TICK_NEXT;
+  return flags;
+}
+function encodeUplink(u) {
+  if (!validUplink(u)) return fail(FastFault.Field);
+  const out = new Uint8Array(FAST_MAX_DATAGRAM_BYTES);
+  const view = new DataView(out.buffer);
+  out[0] = FAST_VERSION;
+  out[1] = FastKind.Uplink;
+  view.setUint32(2, u.sid, true);
+  out.set(fromHex(u.key), 6);
+  view.setUint32(14, u.ackSnap, true);
+  view.setUint32(18, u.window.at(-1)?.seq ?? 0, true);
+  out[22] = u.window.length;
+  out[23] = u.fresh;
+  out[24] = u.actions.length;
+  const render = windowRender(u.window);
+  view.setUint32(25, render, true);
+  let at = UPLINK_HEADER;
+  for (const a of u.actions) {
+    view.setUint32(at, a.seq, true);
+    view.setUint16(at + 4, a.tick, true);
+    view.setUint32(at + 6, a.render, true);
+    at = writePayload(view, at + ACTION_HEAD, a.input);
+  }
+  u.window.forEach((s, i) => {
+    const flags = slotFlags(i === 0 ? null : u.window[i - 1], s);
+    out[at] = flags;
+    at += 1;
+    if ((flags & (SLOT_TICK_SAME | SLOT_TICK_NEXT)) === 0) {
+      view.setUint16(at, s.tick, true);
+      at += 2;
+    }
+    out[at] = backOf(render, s);
+    at += 1;
+    if ((flags & SLOT_SAME) === 0) at = writePayload(view, at, s.input);
+  });
+  return ok(out.slice(0, at));
+}
+function frame(bytes, kind, header) {
+  if (bytes.length > FAST_MAX_DATAGRAM_BYTES) return FastFault.Oversized;
+  if (bytes.length < 2) return FastFault.Truncated;
+  if (bytes[0] !== FAST_VERSION) return FastFault.Version;
+  if (bytes[1] !== kind) return FastFault.Kind;
+  return bytes.length < header ? FastFault.Truncated : null;
+}
+function decodeUplink(bytes, binding) {
+  const framed = frame(bytes, FastKind.Uplink, UPLINK_HEADER);
+  if (framed !== null) return fail(framed);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const sid = view.getUint32(2, true);
+  if (sid !== binding.sid) return fail(FastFault.Session);
+  const key = toHex(bytes.subarray(6, 6 + FAST_KEY_BYTES));
+  if (key !== binding.key) return fail(FastFault.Key);
+  const newest = view.getUint32(18, true);
+  const count = bytes[22];
+  const fresh = bytes[23];
+  const actionCount = bytes[24];
+  const ackSnap = view.getUint32(14, true);
+  if (count === 0 && newest === 0 && fresh === 0 && actionCount === 0 && view.getUint32(25, true) === 0) {
+    if (bytes.length !== UPLINK_HEADER) return fail(FastFault.Trailing);
+    return ok({ sid, key, ackSnap, fresh: 0, actions: [], window: [] });
+  }
+  if (count < 1 || count > INPUT_REDUNDANCY_MAX || newest < count) return fail(FastFault.Count);
+  if (fresh < 1 || fresh > count) return fail(FastFault.Fresh);
+  if (actionCount > FAST_MAX_ACTIONS) return fail(FastFault.Actions);
+  const first = newest - count + 1;
+  const read = readBody(view, actionCount, count, first, view.getUint32(25, true));
+  if (!read.ok) return read;
+  return ok({ sid, key, ackSnap, fresh, actions: read.value.actions, window: read.value.window });
+}
+function readBody(view, actionCount, count, first, render) {
+  let at = UPLINK_HEADER;
+  const actions = [];
+  for (let i = 0; i < actionCount; i += 1) {
+    if (at + ACTION_HEAD + PAYLOAD > view.byteLength) return fail(FastFault.Truncated);
+    const seq = view.getUint32(at, true);
+    if (seq < 1 || seq >= first || i > 0 && seq <= actions[i - 1].seq) return fail(FastFault.Order);
+    actions.push({ seq, tick: view.getUint16(at + 4, true), render: view.getUint32(at + 6, true), input: readPayload(view, at + ACTION_HEAD) });
+    at += ACTION_HEAD + PAYLOAD;
+  }
+  const window = [];
+  for (let i = 0; i < count; i += 1) {
+    const slot = readSlot(view, at, i === 0 ? null : window[i - 1], first + i, render);
+    if (!slot.ok) return slot;
+    window.push(slot.value.input);
+    at = slot.value.at;
+  }
+  return at === view.byteLength ? ok({ actions, window }) : fail(FastFault.Trailing);
+}
+function readSlot(view, start, previous, seq, render) {
+  if (start >= view.byteLength) return fail(FastFault.Truncated);
+  const flags = view.getUint8(start);
+  const tickBits = flags & (SLOT_TICK_SAME | SLOT_TICK_NEXT);
+  const badFlags = (flags & ~SLOT_FLAGS) !== 0 || tickBits === (SLOT_TICK_SAME | SLOT_TICK_NEXT) || previous === null && flags !== 0;
+  if (badFlags) return fail(FastFault.Flags);
+  let at = start + 1;
+  let tick = 0;
+  if (previous !== null && tickBits === SLOT_TICK_SAME) tick = previous.tick;
+  else if (previous !== null && tickBits === SLOT_TICK_NEXT) tick = (previous.tick + 1) % TICK_MOD;
+  else {
+    if (at + 2 > view.byteLength) return fail(FastFault.Truncated);
+    tick = view.getUint16(at, true);
+    at += 2;
+  }
+  if (at + 1 > view.byteLength) return fail(FastFault.Truncated);
+  const slotRender = renderOf(render, view.getUint8(at));
+  at += 1;
+  if (previous !== null && (flags & SLOT_SAME) !== 0) return ok({ input: { seq, tick, render: slotRender, input: { ...previous.input } }, at });
+  if (at + PAYLOAD > view.byteLength) return fail(FastFault.Truncated);
+  return ok({ input: { seq, tick, render: slotRender, input: readPayload(view, at) }, at: at + PAYLOAD });
+}
+var wholeMs = (x) => Math.floor(x + 0.5);
+function renderStamp(serverNow, renderDelay, rtt) {
+  if (serverNow === null || !Number.isFinite(serverNow)) return 0;
+  const now = Math.min(UINT32_MAX, Math.max(0, wholeMs(serverNow)));
+  const lead = renderDelay + (Number.isFinite(rtt) ? rtt : 0) / 2;
+  const delta = Number.isFinite(lead) ? Math.min(65535, Math.max(0, wholeMs(lead))) : 0;
+  return now > delta ? now - delta : 0;
+}
+function uplinkFor(sent, o) {
+  const window = sent.slice(-inputRedundancyTicks(o.tickHz));
+  const first = window.length > 0 ? window[0].seq : Number.POSITIVE_INFINITY;
+  const actions = sent.filter((s, i) => s.seq > o.inputAck && s.seq < first && isPress(i > 0 ? sent[i - 1].input : null, s.input)).slice(0, FAST_MAX_ACTIONS);
+  return { sid: o.sid, key: o.key, ackSnap: o.ackSnap, fresh: Math.min(o.fresh, window.length), actions, window };
+}
+function acceptUplink(seat, u, o) {
+  const newestSlot = u.window.at(-1);
+  if (newestSlot === void 0) {
+    const moved = u.ackSnap > seat.ackSnap && u.ackSnap <= o.snapSent;
+    return { seat: moved ? { ...seat, ackSnap: u.ackSnap } : seat, accepted: [], skipped: 0 };
+  }
+  const newest = newestSlot.seq;
+  if (newest - seat.last > seqAheadMax(o.tickHz)) return { seat, accepted: [], skipped: 0, fault: FastFault.Ahead };
+  const firstFresh = newest - u.fresh + 1;
+  const accepted = [];
+  let last = seat.last;
+  let held = seat.input;
+  let skipped = 0;
+  for (const s of [...u.actions, ...u.window]) {
+    if (s.seq <= last) continue;
+    const gap = s.seq - last - 1;
+    if (gap > gapFillMax(o.tickHz)) skipped += gap;
+    else {
+      for (let g = last + 1; g < s.seq; g += 1) {
+        accepted.push({ seq: g, tick: ((s.tick - (s.seq - g)) % TICK_MOD + TICK_MOD) % TICK_MOD, render: s.render, input: { ...held ?? NEUTRAL }, kind: AcceptKind.Fill });
+      }
+    }
+    const input = sanitizeInput({ ...s.input });
+    accepted.push({ seq: s.seq, tick: s.tick, render: s.render, input, kind: s.seq >= firstFresh ? AcceptKind.Fresh : AcceptKind.Recovered });
+    last = s.seq;
+    held = input;
+  }
+  const ackSnap = u.ackSnap > seat.ackSnap && u.ackSnap <= o.snapSent ? u.ackSnap : seat.ackSnap;
+  if (accepted.length === 0 && ackSnap === seat.ackSnap) return { seat, accepted, skipped };
+  return { seat: { last, input: held, ackSnap }, accepted, skipped };
+}
+var sameBytes = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+var byKey = (records) => [...records].sort((a, b) => a.key - b.key);
+function diffSnapshot(base, next) {
+  if (base === null) return { removed: [], records: byKey(next) };
+  const old = new Map(base.map((r) => [r.key, r.bytes]));
+  const keys = new Set(next.map((r) => r.key));
+  const removed = base.filter((r) => !keys.has(r.key)).map((r) => r.key).sort((a, b) => a - b);
+  const changed = next.filter((r) => {
+    const before = old.get(r.key);
+    return before === void 0 || !sameBytes(before, r.bytes);
+  });
+  return { removed, records: byKey(changed) };
+}
+var deltaBase = (held, ackSnap) => ackSnap > 0 && held.includes(ackSnap) ? ackSnap : 0;
+var bodyScratch = new Uint8Array(4096);
+function bodyBytes(body) {
+  const valid = body.removed.every((k) => isUint(k, 65535)) && body.records.every((r) => isUint(r.key, 65535) && r.bytes.length <= FAST_MAX_RECORD_BYTES);
+  if (!valid || body.removed.length > 65535 || body.records.length > 65535) return null;
+  const size = 4 + 2 * body.removed.length + body.records.reduce((n, r) => n + 4 + r.bytes.length, 0);
+  if (size > bodyScratch.length) bodyScratch = new Uint8Array(size * 2);
+  const out = bodyScratch.subarray(0, size);
+  const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+  view.setUint16(0, body.removed.length, true);
+  let at = 2;
+  for (const k of body.removed) {
+    view.setUint16(at, k, true);
+    at += 2;
+  }
+  view.setUint16(at, body.records.length, true);
+  at += 2;
+  for (const r of body.records) {
+    view.setUint16(at, r.key, true);
+    view.setUint16(at + 2, r.bytes.length, true);
+    out.set(r.bytes, at + 4);
+    at += 4 + r.bytes.length;
+  }
+  return out;
+}
+var validHead = (h) => isUint(h.sid, UINT32_MAX) && isUint(h.snap, UINT32_MAX) && h.snap >= 1 && isUint(h.base, UINT32_MAX) && h.base < h.snap && isUint(h.tick, UINT32_MAX) && isUint(h.inputAck, UINT32_MAX) && isUint(h.sent, UINT32_MAX);
+function encodeSnapshot(head, body) {
+  const bytes = bodyBytes(body);
+  const keyframeBody = head.base !== 0 || body.removed.length === 0;
+  if (bytes === null || !validHead(head) || !keyframeBody) return fail(FastFault.Field);
+  const room = FAST_MAX_DATAGRAM_BYTES - SNAPSHOT_HEADER;
+  const frags = Math.max(1, Math.ceil(bytes.length / room));
+  if (frags > FAST_MAX_FRAGMENTS) return fail(FastFault.Oversized);
+  const out = [];
+  for (let i = 0; i < frags; i += 1) {
+    const chunk = bytes.subarray(i * room, (i + 1) * room);
+    const d = new Uint8Array(SNAPSHOT_HEADER + chunk.length);
+    const view = new DataView(d.buffer);
+    d[0] = FAST_VERSION;
+    d[1] = FastKind.Snapshot;
+    view.setUint32(2, head.sid, true);
+    view.setUint32(6, head.snap, true);
+    view.setUint32(10, head.base, true);
+    view.setUint32(14, head.tick, true);
+    view.setUint32(18, head.inputAck, true);
+    d[22] = head.base === 0 ? KEYFRAME : 0;
+    d[23] = i;
+    d[24] = frags;
+    view.setUint32(25, head.sent, true);
+    d.set(chunk, SNAPSHOT_HEADER);
+    out.push(d);
+  }
+  return ok(out);
+}
+function decodeFragment(bytes, sid) {
+  const framed = frame(bytes, FastKind.Snapshot, SNAPSHOT_HEADER);
+  if (framed !== null) return fail(framed);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(2, true) !== sid) return fail(FastFault.Session);
+  const snap = view.getUint32(6, true);
+  const base = view.getUint32(10, true);
+  const flags = bytes[22];
+  const frag = bytes[23];
+  const frags = bytes[24];
+  if (frags < 1 || frags > FAST_MAX_FRAGMENTS || frag >= frags) return fail(FastFault.Fragment);
+  const keyframeAgrees = (flags & ~KEYFRAME) === 0 && flags === KEYFRAME === (base === 0);
+  if (!keyframeAgrees || snap < 1 || base >= snap) return fail(FastFault.Keyframe);
+  const chunk = bytes.slice(SNAPSHOT_HEADER);
+  return ok({ snap, base, tick: view.getUint32(14, true), inputAck: view.getUint32(18, true), sent: view.getUint32(25, true), keyframe: flags === KEYFRAME, frag, frags, chunk });
+}
+function parseBody(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.length < 2) return fail(FastFault.Body);
+  const removedCount = view.getUint16(0, true);
+  let at = 2;
+  const removed = [];
+  for (let i = 0; i < removedCount; i += 1) {
+    if (at + 2 > bytes.length) return fail(FastFault.Body);
+    const k = view.getUint16(at, true);
+    if (i > 0 && k <= removed[i - 1]) return fail(FastFault.Body);
+    removed.push(k);
+    at += 2;
+  }
+  if (at + 2 > bytes.length) return fail(FastFault.Body);
+  const count = view.getUint16(at, true);
+  at += 2;
+  const records = [];
+  for (let i = 0; i < count; i += 1) {
+    if (at + 4 > bytes.length) return fail(FastFault.Body);
+    const key = view.getUint16(at, true);
+    const len = view.getUint16(at + 2, true);
+    const bad2 = len > FAST_MAX_RECORD_BYTES || at + 4 + len > bytes.length || i > 0 && key <= records[i - 1].key;
+    if (bad2) return fail(FastFault.Body);
+    records.push({ key, bytes: bytes.slice(at + 4, at + 4 + len) });
+    at += 4 + len;
+  }
+  return at === bytes.length ? ok({ removed, records }) : fail(FastFault.Body);
+}
+function applyBody(base, body) {
+  const gone = new Set(body.removed);
+  const out = new Map(base.filter((r) => !gone.has(r.key)).map((r) => [r.key, r]));
+  for (const r of body.records) out.set(r.key, r);
+  return byKey([...out.values()]);
+}
+var emptyClientRx = () => ({ partials: [], history: [], newest: 0 });
+var sameHead = (p, f) => p.base === f.base && p.tick === f.tick && p.inputAck === f.inputAck && p.sent === f.sent && p.keyframe === f.keyframe && p.frags === f.frags;
+function receiveFragment(rx, bytes, sid) {
+  const decoded = decodeFragment(bytes, sid);
+  if (!decoded.ok) return { rx, applied: null, fault: decoded.fault };
+  const f = decoded.value;
+  if (f.snap <= rx.newest) return { rx, applied: null, fault: FastFault.Stale };
+  const existing = rx.partials.find((p) => p.snap === f.snap);
+  if (existing !== void 0 && !sameHead(existing, f)) return { rx, applied: null, fault: FastFault.Mismatch };
+  if (existing?.chunks[f.frag]) return { rx, applied: null, fault: FastFault.Duplicate };
+  const set = existing ?? { snap: f.snap, base: f.base, tick: f.tick, inputAck: f.inputAck, sent: f.sent, keyframe: f.keyframe, frags: f.frags, chunks: Array(f.frags).fill(null) };
+  const gathered = { ...set, chunks: set.chunks.map((c, i) => i === f.frag ? f.chunk : c) };
+  const others = rx.partials.filter((p) => p.snap !== f.snap);
+  if (gathered.chunks.some((c) => c === null)) {
+    const partials = [...others, gathered].sort((a, b) => a.snap - b.snap).slice(-FAST_REASSEMBLY_SLOTS);
+    return { rx: { ...rx, partials }, applied: null };
+  }
+  return applyComplete({ ...rx, partials: others }, rx, gathered);
+}
+function applyComplete(rest, given, set) {
+  const dropped = rest.partials.length === given.partials.length ? given : rest;
+  const body = parseBody(concat(set.chunks));
+  if (!body.ok) return { rx: dropped, applied: null, fault: FastFault.Body };
+  const base = set.keyframe ? null : given.history.find((h) => h.snap === set.base);
+  if (base === void 0) return { rx: dropped, applied: null, fault: FastFault.Base };
+  if (set.keyframe && body.value.removed.length > 0) return { rx: dropped, applied: null, fault: FastFault.Body };
+  const records = applyBody(base?.records ?? [], body.value);
+  const history = [...given.history, { snap: set.snap, tick: set.tick, inputAck: set.inputAck, sent: set.sent, records }].slice(-FAST_SNAPSHOT_HISTORY);
+  const partials = rest.partials.filter((p) => p.snap > set.snap);
+  return { rx: { partials, history, newest: set.snap }, applied: set.snap };
+}
+function concat(chunks) {
+  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+  let at = 0;
+  for (const c of chunks) {
+    out.set(c, at);
+    at += c.length;
+  }
+  return out;
+}
+
+// src/authority/fast-records.ts
+var MotionRecordKind = { Entity: 1, Seat: 2 };
+var FieldWire = {
+  F32: "f32",
+  U32: "u32",
+  U16: "u16",
+  /** A quantized orientation component in [−1, 1], uint16. */
+  Orientation: "q-orientation",
+  /** A quantized velocity in [−64, 64], uint16. */
+  Velocity: "q-velocity",
+  /** A boolean: the mask bit alone. */
+  Flag: "flag"
+};
+var ENTITY_FIELDS = [
+  ["x", FieldWire.F32],
+  ["y", FieldWire.F32],
+  ["z", FieldWire.F32],
+  ["vx", FieldWire.F32],
+  ["vy", FieldWire.F32],
+  ["vz", FieldWire.F32],
+  ["yaw", FieldWire.F32],
+  ["pitch", FieldWire.F32],
+  ["duck", FieldWire.F32],
+  ["spin", FieldWire.F32],
+  ["fuel", FieldWire.F32],
+  ["epoch", FieldWire.U32],
+  ["mstate", FieldWire.U32],
+  ["qx", FieldWire.Orientation],
+  ["qy", FieldWire.Orientation],
+  ["qz", FieldWire.Orientation],
+  ["qw", FieldWire.Orientation],
+  ["lvx", FieldWire.Velocity],
+  ["lvy", FieldWire.Velocity],
+  ["lvz", FieldWire.Velocity],
+  ["avx", FieldWire.Velocity],
+  ["avy", FieldWire.Velocity],
+  ["avz", FieldWire.Velocity],
+  ["sleep", FieldWire.Flag],
+  ["rest", FieldWire.U16]
+];
+var SEAT_FIELDS = [
+  ["inMoveX", FieldWire.F32],
+  ["inMoveY", FieldWire.F32],
+  ["inMoveZ", FieldWire.F32],
+  ["inYaw", FieldWire.F32],
+  ["inPitch", FieldWire.F32],
+  ["inButtons", FieldWire.U32],
+  ["inRep", FieldWire.U32],
+  ["inStarve", FieldWire.U32],
+  ["inBuf", FieldWire.U32],
+  ["inAck", FieldWire.U32]
+];
+var RECORD_ID_MAX_CHARS = 64;
+var HEAD = 2;
+var MASK_BYTES = 4;
+var UINT32_MAX2 = 4294967295;
+var UINT16_MAX = 65535;
+var Q_SPAN = 65534;
+var Q_ZERO = Q_SPAN / 2;
+var Q_RANGE = { [FieldWire.Orientation]: 1, [FieldWire.Velocity]: 64 };
+var blankEntityMotion = () => ({
+  x: 0,
+  y: 0,
+  z: 0,
+  vx: 0,
+  vy: 0,
+  vz: 0,
+  yaw: 0,
+  pitch: 0,
+  duck: 0,
+  spin: 0,
+  fuel: 0,
+  epoch: 0,
+  mstate: 0,
+  qx: 0,
+  qy: 0,
+  qz: 0,
+  qw: 0,
+  lvx: 0,
+  lvy: 0,
+  lvz: 0,
+  avx: 0,
+  avy: 0,
+  avz: 0,
+  sleep: false,
+  rest: 0
+});
+var blankSeatEcho = () => ({ inMoveX: 0, inMoveY: 0, inMoveZ: 0, inYaw: 0, inPitch: 0, inButtons: 0, inRep: 0, inStarve: 0, inBuf: 0, inAck: 0 });
+function quantizeCode(half, value2) {
+  const v = Math.min(half, Math.max(-half, value2));
+  return Math.floor((v + half) / (2 * half) * Q_SPAN + 0.5);
+}
+var dequantizeCode = (half, code) => -half + code / Q_SPAN * (2 * half);
+var fieldsOf = (kind) => {
+  if (kind === MotionRecordKind.Entity) return ENTITY_FIELDS;
+  if (kind === MotionRecordKind.Seat) return SEAT_FIELDS;
+  return null;
+};
+var isUint2 = (v, max) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= max;
+function wireValue(wire, v) {
+  switch (wire) {
+    case FieldWire.F32: {
+      if (typeof v !== "number" || !Number.isFinite(Math.fround(v))) return null;
+      return Math.fround(v) === 0 ? void 0 : Math.fround(v);
+    }
+    case FieldWire.U32:
+      if (!isUint2(v, UINT32_MAX2)) return null;
+      return v === 0 ? void 0 : v;
+    case FieldWire.U16:
+      if (!isUint2(v, UINT16_MAX)) return null;
+      return v === 0 ? void 0 : v;
+    case FieldWire.Flag:
+      if (typeof v !== "boolean") return null;
+      return v ? 1 : void 0;
+    default: {
+      if (typeof v !== "number" || Number.isNaN(v)) return null;
+      const code = quantizeCode(Q_RANGE[wire], v);
+      return code === Q_ZERO ? void 0 : code;
+    }
+  }
+}
+var WIDTH = { f32: 4, u32: 4, u16: 2, "q-orientation": 2, "q-velocity": 2, flag: 0 };
+var ID_MAX_BYTES = 255;
+var FIELD_MAX_BYTES = 4;
+var FIELDS_MAX = 32;
+var RECORD_SCRATCH = new Uint8Array(HEAD + ID_MAX_BYTES + MASK_BYTES + FIELDS_MAX * FIELD_MAX_BYTES);
+var RECORD_VIEW = new DataView(RECORD_SCRATCH.buffer);
+var ID_BYTES = /* @__PURE__ */ new Map();
+var ID_BYTES_MAX = 4096;
+var ID_ENCODER = new TextEncoder();
+var idBytesOf = (id) => {
+  const known = ID_BYTES.get(id);
+  if (known !== void 0) return known;
+  if (ID_BYTES.size >= ID_BYTES_MAX) ID_BYTES.clear();
+  const bytes = ID_ENCODER.encode(id);
+  ID_BYTES.set(id, bytes);
+  return bytes;
+};
+function encodeRecord(r) {
+  const fields = fieldsOf(r.kind);
+  const idOk = typeof r.id === "string" && r.id.length >= 1 && r.id.length <= RECORD_ID_MAX_CHARS;
+  const id = idOk ? idBytesOf(r.id) : null;
+  if (fields === null || id === null || id.length > ID_MAX_BYTES || r.motion === null || typeof r.motion !== "object") return { ok: false, fault: FastFault.Field };
+  const motion = r.motion;
+  RECORD_SCRATCH[0] = r.kind;
+  RECORD_SCRATCH[1] = id.length;
+  RECORD_SCRATCH.set(id, HEAD);
+  const maskAt = HEAD + id.length;
+  let at = maskAt + MASK_BYTES;
+  let mask2 = 0;
+  for (let i = 0; i < fields.length; i += 1) {
+    const [name, wire] = fields[i];
+    const value2 = wireValue(wire, motion[name]);
+    if (value2 === null) return { ok: false, fault: FastFault.Field };
+    if (value2 === void 0) continue;
+    mask2 = (mask2 | 1 << i) >>> 0;
+    at = writeField(RECORD_VIEW, at, wire, value2);
+  }
+  RECORD_VIEW.setUint32(maskAt, mask2, true);
+  return { ok: true, value: RECORD_SCRATCH.slice(0, at) };
+}
+function writeField(view, at, wire, value2) {
+  if (wire === FieldWire.F32) view.setFloat32(at, value2, true);
+  else if (wire === FieldWire.U32) view.setUint32(at, value2, true);
+  else if (wire !== FieldWire.Flag) view.setUint16(at, value2, true);
+  return at + WIDTH[wire];
+}
+function readField(view, at, wire) {
+  if (at + WIDTH[wire] > view.byteLength) return { ok: false, fault: FastFault.Truncated };
+  switch (wire) {
+    case FieldWire.Flag:
+      return { ok: true, value: true };
+    case FieldWire.F32: {
+      const v = view.getFloat32(at, true);
+      return Number.isFinite(v) && v !== 0 ? { ok: true, value: v } : { ok: false, fault: FastFault.Field };
+    }
+    case FieldWire.U32: {
+      const v = view.getUint32(at, true);
+      return v !== 0 ? { ok: true, value: v } : { ok: false, fault: FastFault.Field };
+    }
+    case FieldWire.U16: {
+      const v = view.getUint16(at, true);
+      return v !== 0 ? { ok: true, value: v } : { ok: false, fault: FastFault.Field };
+    }
+    default: {
+      const code = view.getUint16(at, true);
+      const canonical = code !== Q_ZERO && code <= Q_SPAN;
+      return canonical ? { ok: true, value: dequantizeCode(Q_RANGE[wire], code) } : { ok: false, fault: FastFault.Field };
+    }
+  }
+}
+var UTF8 = new TextDecoder("utf-8", { fatal: true });
+function readId(bytes) {
+  const len = bytes[1];
+  if (HEAD + len > bytes.length) return { ok: false, fault: FastFault.Truncated };
+  if (len === 0) return { ok: false, fault: FastFault.Field };
+  try {
+    const id = UTF8.decode(bytes.subarray(HEAD, HEAD + len));
+    return id.length <= RECORD_ID_MAX_CHARS ? { ok: true, value: id } : { ok: false, fault: FastFault.Field };
+  } catch {
+    return { ok: false, fault: FastFault.Field };
+  }
+}
+function decodeRecord(bytes) {
+  if (bytes.length < HEAD) return { ok: false, fault: FastFault.Truncated };
+  const fields = fieldsOf(bytes[0]);
+  if (fields === null) return { ok: false, fault: FastFault.Kind };
+  const id = readId(bytes);
+  if (!id.ok) return id;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let at = HEAD + bytes[1];
+  if (at + MASK_BYTES > bytes.length) return { ok: false, fault: FastFault.Truncated };
+  const mask2 = view.getUint32(at, true);
+  at += MASK_BYTES;
+  if (fields.length < 32 && mask2 >>> fields.length !== 0) return { ok: false, fault: FastFault.Flags };
+  if (bytes[0] === MotionRecordKind.Entity) {
+    const motion2 = readMotion(view, at, mask2, blankEntityMotion(), fields);
+    return motion2.ok ? { ok: true, value: { kind: MotionRecordKind.Entity, id: id.value, motion: motion2.value } } : motion2;
+  }
+  const motion = readMotion(view, at, mask2, blankSeatEcho(), fields);
+  return motion.ok ? { ok: true, value: { kind: MotionRecordKind.Seat, id: id.value, motion: motion.value } } : motion;
+}
+function readMotion(view, start, mask2, blank, fields) {
+  const values = {};
+  let at = start;
+  for (const [i, [name, wire]] of fields.entries()) {
+    if ((mask2 & 1 << i) === 0) continue;
+    const v = readField(view, at, wire);
+    if (!v.ok) return v;
+    values[name] = v.value;
+    at += WIDTH[wire];
+  }
+  if (at !== view.byteLength) return { ok: false, fault: FastFault.Trailing };
+  return { ok: true, value: Object.assign(blank, values) };
+}
+
+// src/authority/fast-client.ts
+var UINT32_MAX3 = 4294967295;
+var FAST_OPEN_ROUND_TRIPS = 4;
+var FastFallbackReason = {
+  /** The `__fast` binding was malformed, this client cannot open its url, or its socket failed. */
+  Unreachable: "unreachable",
+  /** No snapshot within {@link FAST_HANDSHAKE_MS} of the first datagram. */
+  Handshake: "handshake",
+  /** No snapshot for {@link FAST_STALL_FALLBACK_MS} after the last one. */
+  Stall: "stall",
+  /** The server asked for it (`__fast:off` from the server). */
+  Server: "server",
+  /** A browser with no `WebTransport` (or not a secure context): the seat never asked for the channel. */
+  NoWebTransport: "no-webtransport",
+  /** The binding carries no `wt` this browser can open: the room's server runs no relay. */
+  NoRelay: "no-relay",
+  /** The seat asked and no binding came within {@link FAST_HANDSHAKE_MS} of its first frame: the room's
+   *  server has no channel, or is too old to offer it. The seat was on the WebSocket all along, and a
+   *  binding that comes after all still opens. */
+  NotOffered: "not-offered"
+};
+var isUint3 = (v, max) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= max;
+function isFastBind(m) {
+  if (typeof m !== "object" || m === null) return false;
+  const { sid, key, url } = m;
+  const keyOk = typeof key === "string" && key.length === 2 * FAST_KEY_BYTES && /^[0-9a-f]+$/.test(key);
+  return isUint3(sid, UINT32_MAX3) && keyOk && typeof url === "string" && url.length > 0;
+}
+function heldInputs(sent, inputAck, tickHz) {
+  if (sent.length === 0) return [];
+  const newest = sent[sent.length - 1].seq;
+  const keepFrom = Math.min(inputAck, newest - inputRedundancyTicks(tickHz) + 1);
+  const capped = Math.max(keepFrom, newest - seqAheadMax(tickHz) + 1);
+  return sent.filter((s) => s.seq >= capped);
+}
+var recordName = (kind, id) => `${kind}:${id}`;
+function openFastClient(o) {
+  let rx = emptyClientRx();
+  let sent = [];
+  const sentTimes = /* @__PURE__ */ new Map();
+  let fresh = 0;
+  let closed = false;
+  let firstSentAt = null;
+  let lastAppliedAt = null;
+  let lastUplinkAt = null;
+  let lastFrameAt = null;
+  const keepsAlive = typeof o.bind.rev === "number" && o.bind.rev >= FAST_BIND_REV;
+  let openedAt = null;
+  let decodedByKey = /* @__PURE__ */ new Map();
+  let latest = /* @__PURE__ */ new Map();
+  const inputAck = () => rx.history.at(-1)?.inputAck ?? 0;
+  const decodeChanged = (records) => {
+    const nextByKey = /* @__PURE__ */ new Map();
+    const nextLatest = /* @__PURE__ */ new Map();
+    const changed = [];
+    for (const r of records) {
+      const before = decodedByKey.get(r.key);
+      const same = before !== void 0 && (before.bytes === r.bytes || sameBytes2(before.bytes, r.bytes));
+      const record = same ? before.record : decodeOrNull(r.bytes);
+      nextByKey.set(r.key, { bytes: r.bytes, record });
+      if (record === null) continue;
+      nextLatest.set(recordName(record.kind, record.id), record);
+      if (!same) changed.push(record);
+    }
+    decodedByKey = nextByKey;
+    latest = nextLatest;
+    return changed;
+  };
+  function receive(bytes) {
+    if (closed) return { applied: null };
+    const r = receiveFragment(rx, bytes, o.bind.sid);
+    rx = r.rx;
+    if (r.fault !== void 0 || r.applied === null) return { applied: null, fault: r.fault };
+    const held = rx.history.at(-1);
+    if (held === void 0) return { applied: null };
+    const before = lastAppliedSnap;
+    lastAppliedSnap = held.snap;
+    lastAppliedAt = o.now();
+    sent = heldInputs(sent, held.inputAck, o.tickHz);
+    const applied = { snap: held.snap, tick: held.tick, inputAck: held.inputAck, sent: held.sent, changed: decodeChanged(held.records) };
+    o.onSnapshot?.(applied);
+    const eager = applied.changed.length >= FAST_ACK_EAGER_RECORDS && (lastUplinkAt === null || o.now() - lastUplinkAt >= FAST_ACK_EAGER_GAP_MS);
+    if (held.snap - before >= FAST_CHALLENGE_JUMP || eager) sendEmpty();
+    return { applied };
+  }
+  function sendEmpty() {
+    if (closed || !keepsAlive || socket === null) return;
+    const bytes = encodeUplink({ sid: o.bind.sid, key: o.bind.key, ackSnap: rx.newest, fresh: 0, actions: [], window: [] });
+    if (!bytes.ok) return;
+    const now = o.now();
+    firstSentAt ??= now;
+    lastUplinkAt = now;
+    socket.send(bytes.value);
+  }
+  let lastAppliedSnap = 0;
+  const socket = o.open(
+    o.bind.url,
+    (bytes) => {
+      receive(bytes);
+    },
+    o.bind
+  );
+  if (socket === null) return null;
+  const largestUplink = uplinkMaxBytes(o.tickHz);
+  return {
+    bind: o.bind,
+    get rx() {
+      return rx;
+    },
+    get lastQueued() {
+      return sent.at(-1)?.seq ?? 0;
+    },
+    get closed() {
+      return closed;
+    },
+    opening: () => socket.opening?.() === true,
+    queue(input) {
+      if (closed) return;
+      sent.push({ seq: input.seq, tick: input.tick, render: input.render, input: { ...input.input } });
+      fresh += 1;
+    },
+    flush() {
+      if (closed || fresh === 0) return;
+      const now = o.now();
+      for (const s of sent.slice(-fresh)) sentTimes.set(s.seq, now);
+      forgetSendTimes(sentTimes, (sent.at(-1)?.seq ?? 0) - seqAheadMax(o.tickHz) + 1);
+      const window = inputRedundancyTicks(o.tickHz);
+      let from = sent.length - fresh;
+      fresh = 0;
+      while (from < sent.length) {
+        const to = Math.min(from + window, sent.length);
+        const u = uplinkFor(sent.slice(0, to), { sid: o.bind.sid, key: o.bind.key, ackSnap: rx.newest, inputAck: inputAck(), fresh: to - from, tickHz: o.tickHz });
+        from = to;
+        const bytes = encodeUplink(u);
+        if (!bytes.ok) continue;
+        firstSentAt ??= now;
+        lastUplinkAt = now;
+        socket.send(bytes.value);
+      }
+    },
+    framed() {
+      const now = o.now();
+      const gap = lastFrameAt === null ? 0 : now - lastFrameAt;
+      lastFrameAt = now;
+      if (gap <= FAST_FRAME_GAP_MS) return;
+      if (lastAppliedAt !== null) lastAppliedAt = Math.min(now, lastAppliedAt + gap);
+      if (firstSentAt !== null) firstSentAt = Math.min(now, firstSentAt + gap);
+    },
+    keepalive() {
+      if (closed || !keepsAlive) return;
+      const every = lastAppliedAt === null ? FAST_KEEPALIVE_BIND_MS : FAST_KEEPALIVE_MS;
+      if (lastUplinkAt === null || o.now() - lastUplinkAt >= every) sendEmpty();
+    },
+    inputAt: (seq) => sent.find((s) => s.seq === seq),
+    sentAt: (seq) => sentTimes.get(seq),
+    motionOf: (kind, id) => latest.get(recordName(kind, id)),
+    records: () => [...latest.values()],
+    due() {
+      if (closed) return null;
+      if (socket.failed?.() === true) return FastFallbackReason.Unreachable;
+      const room = socket.maxDatagramBytes?.();
+      if (room !== void 0 && room < largestUplink) return FastFallbackReason.Unreachable;
+      const now = o.now();
+      if (lastAppliedAt !== null) return now - lastAppliedAt > FAST_STALL_FALLBACK_MS ? FastFallbackReason.Stall : null;
+      if (firstSentAt === null) return null;
+      const opening = socket.opening?.();
+      if (opening === true) {
+        const openBound = Math.max(FAST_HANDSHAKE_MS, FAST_OPEN_ROUND_TRIPS * (o.roundTripMs?.() ?? 0));
+        return now - firstSentAt > openBound ? FastFallbackReason.Handshake : null;
+      }
+      if (opening === false) openedAt ??= now;
+      const from = opening === false ? Math.max(firstSentAt, openedAt ?? now) : firstSentAt;
+      return now - from > FAST_HANDSHAKE_MS ? FastFallbackReason.Handshake : null;
+    },
+    receive,
+    close() {
+      if (closed) return;
+      closed = true;
+      socket.close();
+    }
+  };
+}
+function forgetSendTimes(times, from) {
+  for (const seq of times.keys()) {
+    if (seq >= from) return;
+    times.delete(seq);
+  }
+}
+function decodeOrNull(bytes) {
+  const d = decodeRecord(bytes);
+  return d.ok ? d.value : null;
+}
+var sameBytes2 = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+
+// src/authority/fast-webtransport.ts
+var FAST_WT_HASH_HEX_DIGITS = 64;
+var FAST_WT_HASHES_MAX = 4;
+var WT_SCHEME = "https:";
+var CONNECT_QUEUE_MAX = 32;
+var HASH_PATTERN = /^[0-9a-f]+$/;
+var RELIABLE_ONLY = "reliable-only";
+function fastWebTransportOf(bind) {
+  const wt = bind.wt;
+  if (typeof wt !== "object" || wt === null) return null;
+  const { url, hashes } = wt;
+  if (typeof url !== "string" || !Array.isArray(hashes)) return null;
+  if (hashes.length === 0 || hashes.length > FAST_WT_HASHES_MAX) return null;
+  const hashOk = (h) => typeof h === "string" && h.length === FAST_WT_HASH_HEX_DIGITS && HASH_PATTERN.test(h);
+  if (!hashes.every(hashOk)) return null;
+  let parsed2;
+  try {
+    parsed2 = new URL(url);
+  } catch {
+    return null;
+  }
+  const bare = parsed2.username === "" && parsed2.password === "" && parsed2.search === "" && parsed2.hash === "";
+  if (parsed2.protocol !== WT_SCHEME || parsed2.hostname === "" || !bare) return null;
+  return { url, hashes: hashes.map((h) => fromHex(h)) };
+}
+function webTransportOptions(target) {
+  return {
+    serverCertificateHashes: target.hashes.map((value2) => ({ algorithm: "sha-256", value: value2 })),
+    requireUnreliable: true,
+    allowPooling: false,
+    congestionControl: "low-latency"
+  };
+}
+var carriesFast = (t) => t.reliability !== RELIABLE_ONLY;
+function datagramWriter(t) {
+  const writable = t.datagrams.createWritable?.() ?? t.datagrams.writable;
+  return writable?.getWriter() ?? null;
+}
+var SocketState = { Connecting: "connecting", Open: "open", Failed: "failed", Closed: "closed" };
+function webTransportFastOpener(WebTransport) {
+  const open = (_url, receive, bind) => {
+    const target = bind === void 0 ? null : fastWebTransportOf(bind);
+    if (target === null || WebTransport === void 0) return null;
+    let t;
+    try {
+      t = new WebTransport(target.url, webTransportOptions(target));
+    } catch {
+      return null;
+    }
+    let state = SocketState.Connecting;
+    let waiting = [];
+    let writer = null;
+    const fail2 = () => {
+      if (state === SocketState.Closed || state === SocketState.Failed) return;
+      state = SocketState.Failed;
+      writer = null;
+      waiting = [];
+      try {
+        t.close();
+      } catch {
+      }
+    };
+    const write = (w, bytes) => void w.write(bytes).catch(() => {
+    });
+    const readAll = async (reader) => {
+      for (; ; ) {
+        const r = await reader.read();
+        if (r.done) return;
+        if (state === SocketState.Open) receive(r.value);
+      }
+    };
+    t.ready.then(
+      () => {
+        if (state !== SocketState.Connecting) return;
+        if (!carriesFast(t)) return fail2();
+        const w = datagramWriter(t);
+        if (w === null) return fail2();
+        state = SocketState.Open;
+        writer = w;
+        for (const bytes of waiting) write(w, bytes);
+        waiting = [];
+        readAll(t.datagrams.readable.getReader()).then(fail2, fail2);
+      },
+      () => fail2()
+    );
+    t.closed.then(fail2, fail2);
+    const socket = {
+      send(bytes) {
+        if (state === SocketState.Open && writer !== null) write(writer, bytes);
+        else if (state === SocketState.Connecting) waiting = [...waiting, bytes].slice(-CONNECT_QUEUE_MAX);
+      },
+      close() {
+        if (state === SocketState.Closed) return;
+        const was = state;
+        state = SocketState.Closed;
+        writer = null;
+        waiting = [];
+        if (was === SocketState.Failed) return;
+        try {
+          t.close();
+        } catch {
+        }
+      },
+      failed: () => state === SocketState.Failed,
+      opening: () => state === SocketState.Connecting,
+      // The browser's outgoing limit, known once the session is open: the browser sends only uplinks,
+      // so the seat's largest uplink must fit (Chromium reports 1024; a 120 Hz seat's is 889).
+      maxDatagramBytes() {
+        const size = state === SocketState.Open ? t.datagrams.maxDatagramSize : void 0;
+        return typeof size === "number" ? size : void 0;
+      }
+    };
+    return socket;
+  };
+  open.whyNull = (bind) => {
+    if (WebTransport === void 0) return FastFallbackReason.NoWebTransport;
+    return fastWebTransportOf(bind) === null ? FastFallbackReason.NoRelay : FastFallbackReason.Unreachable;
+  };
+  return open;
+}
+var webTransportOf = (scope) => typeof scope.WebTransport === "function" ? scope.WebTransport : void 0;
+var openWebTransportFastSocket = (url, receive, bind) => webTransportFastOpener(webTransportOf(globalThis))(url, receive, bind);
+openWebTransportFastSocket.whyNull = (bind) => webTransportFastOpener(webTransportOf(globalThis)).whyNull?.(bind) ?? FastFallbackReason.Unreachable;
+function chooseFastSocket(given, scope = globalThis) {
+  if (given === false) return { open: void 0, fallback: null };
+  if (given !== void 0) return { open: given, fallback: null };
+  if (webTransportOf(scope) !== void 0) return { open: openWebTransportFastSocket, fallback: null };
+  const inBrowser = scope.document !== void 0 || typeof scope.importScripts === "function";
+  return { open: void 0, fallback: inBrowser ? FastFallbackReason.NoWebTransport : null };
+}
+
+export {
+  AuthorityRoomLimits,
+  validMatchKey,
+  validRoomCode,
+  matchKeyOf,
+  AuthorityJoinMethod,
+  AuthorityTargetRefusal,
+  planAuthorityJoin,
+  nextCodeRegion,
+  selectMatchWorld,
+  PHYSICS_CONTRACT,
+  PHYSICS_DEFAULT_LIMITS,
+  PHYSICS_LIMIT_NAMES,
+  PHYSICS_SCALED_LIMITS,
+  PHYSICS_REAL_LIMITS,
+  PHYSICS_CEILING_FACTOR,
+  PHYSICS_STATIC_PIECE_BYTES,
+  PHYSICS_PREDICT_MAX_BOXES,
+  PHYSICS_PREDICT_MAX_RAMPS,
+  physicsWorldPredicts,
+  physicsLimitsForWorld,
+  PHYSICS_DEFAULT_CEILING,
+  physicsCeilingValid,
+  physicsLimitsAt,
+  PhysicsConfigRange,
+  PHYSICS_PRESET_LENGTH_UNITS,
+  PHYSICS_PATCH_HZ,
+  PHYSICS_DEFAULT_PATCH_HZ,
+  PhysicsPredictRange,
+  isPhysicsPatchHz,
+  effectivePatchHz,
+  keyframeTicks,
+  PHYSICS_PREDICT_MAX_LINEAR,
+  PHYSICS_PREDICT_MAX_ANGULAR,
+  PHYSICS_PREDICT_MIN_ITERATIONS,
+  solverIterationsOf,
+  PHYSICS_KEY_MAX_BYTES,
+  PHYSICS_KIND_MAX_BYTES,
+  PHYSICS_STATIC_PREFIX,
+  isPhysicsKey,
+  isPhysicsKind,
+  resolvePhysicsConfig,
+  checkResolvedPhysics,
+  PHYSICS_SUBSTEPS,
+  physicsWorldDesc,
+  PhysEvKind,
+  PHYSICS_OVERLAP_MAX_KEYS,
+  PHYSICS_BODY_FIELDS,
+  HOST_BODY_FIELDS,
+  BodyQuantization,
+  quantizeBodyValue,
+  dequantizeBodyValue,
+  PHYSICS_CONTESTED_METRES,
+  PHYSICS_FULL_RATE_BODIES,
+  PHYSICS_ROTATING_BODIES,
+  BODY_EXTRAPOLATE_MAX_MS,
+  BODY_EXTRAPOLATE_BACK_TICKS,
+  BODY_CORRECTION_TAU_MS,
+  BODY_SNAP_METRES,
+  MAX_PROJECTILE_TICK,
+  MAX_PROJECTILE_G,
+  isProjectile,
+  projectileAt,
+  serverTick,
+  tickInstant,
+  ContactDrawing,
+  ContactPush,
+  ContactPreset,
+  TopPolicy,
+  ContactShapeKind,
+  HeadFriction,
+  ContactConfigError,
+  CONTACT_PAIRS_MAX,
+  CONTACT_TAG_MAX,
+  CONTACT_PASSES_MAX,
+  CONTACT_VALUE_MAX,
+  SHOOTER_CENTER,
+  CONTACT_PRESETS,
+  CONTACT_DEFAULTS,
+  resolveContactConfig,
+  LiftShapeKind,
+  LiftPathMode,
+  LiftEase,
+  LiftImpart,
+  NO_LIFTS,
+  LiftsConfigError,
+  LIFTS_MAX,
+  LIFT_POINTS_MAX,
+  LIFT_ID_MAX,
+  LIFT_VALUE_MAX,
+  LIFT_TICKS_MAX,
+  LIFT_SPIN_MIN_PERIOD,
+  isLiftId,
+  resolveLifts,
+  InputRepeat,
+  INPUT_SETTLE_MS,
+  INPUT_PRESETS,
+  INPUTS_DEFAULT,
+  InputConfigError,
+  resolveInputConfig,
+  presetInputRepeat,
+  AuthorityLifetime,
+  LIFETIME_DEFAULT,
+  LifetimeConfigError,
+  resolveLifetime,
+  GuestGlobal,
+  AuthorityLimits,
+  TICK_RATES,
+  PHYSICS_ONLY_TICK_HZ,
+  MAX_TICK_HZ,
+  DEFAULT_TICK_HZ,
+  TickOutFault,
+  InputUse,
+  sanitizeInput,
+  validateTickOut,
+  validateInitOut,
+  FAST_VERSION,
+  FAST_MAX_DATAGRAM_BYTES,
+  FAST_KEY_BYTES,
+  INPUT_REDUNDANCY_MS,
+  INPUT_REDUNDANCY_MIN,
+  INPUT_REDUNDANCY_MAX,
+  FAST_MAX_ACTIONS,
+  FAST_GAP_FILL_MS,
+  FAST_SEQ_AHEAD_MS,
+  FAST_SNAPSHOT_HISTORY,
+  FAST_MAX_FRAGMENTS,
+  FAST_REASSEMBLY_SLOTS,
+  FAST_MAX_RECORD_BYTES,
+  FAST_HANDSHAKE_MS,
+  FAST_STALL_FALLBACK_MS,
+  FAST_KEEPALIVE_MS,
+  FAST_KEEPALIVE_BIND_MS,
+  FAST_ACK_EAGER_RECORDS,
+  FAST_ACK_EAGER_GAP_MS,
+  FAST_CHALLENGE_JUMP,
+  FAST_FRAME_GAP_MS,
+  FAST_BIND_REV,
+  FAST_RETURN_PROOF,
+  FAST_RETRY_BASE_MS,
+  FAST_RETRY_MAX_MS,
+  FAST_RETURN_STABLE_MS,
+  fastRetryDelayMs,
+  FastMessage,
+  FastKind,
+  FastFault,
+  AcceptKind,
+  inputRedundancyTicks,
+  uplinkMaxBytes,
+  gapFillMax,
+  seqAheadMax,
+  toHex,
+  fromHex,
+  isPress,
+  encodeUplink,
+  decodeUplink,
+  renderStamp,
+  uplinkFor,
+  acceptUplink,
+  diffSnapshot,
+  deltaBase,
+  encodeSnapshot,
+  decodeFragment,
+  parseBody,
+  applyBody,
+  emptyClientRx,
+  receiveFragment,
+  MotionRecordKind,
+  RECORD_ID_MAX_CHARS,
+  blankEntityMotion,
+  blankSeatEcho,
+  quantizeCode,
+  dequantizeCode,
+  encodeRecord,
+  decodeRecord,
+  FAST_OPEN_ROUND_TRIPS,
+  FastFallbackReason,
+  isFastBind,
+  heldInputs,
+  openFastClient,
+  FAST_WT_HASH_HEX_DIGITS,
+  FAST_WT_HASHES_MAX,
+  fastWebTransportOf,
+  webTransportOptions,
+  webTransportFastOpener,
+  openWebTransportFastSocket,
+  chooseFastSocket
+};