@genex-ai/multiplayer 0.17.1 → 0.17.6

package/dist/chunk-5JGRFT2N.js

@@ -0,0 +1,3646 @@
+import {
+  RemotePredict
+} from "./chunk-K3SF5VDS.js";
+import {
+  Limits,
+  isReservedEventType
+} from "./chunk-ZSWF4VCN.js";
+
+// src/authority/numeric.ts
+var MAX_ABS = 1e9;
+var MASK_LIMIT = 2 ** 24;
+var TWO_PI = 2 * Math.PI;
+var F32_PI = Math.fround(Math.PI);
+var unsignedZero = (v) => v === 0 ? 0 : v;
+function axis(v) {
+  if (typeof v !== "number" || !Number.isFinite(v)) return 0;
+  const clamped = v < -1 ? -1 : v > 1 ? 1 : v;
+  return unsignedZero(Math.fround(clamped));
+}
+function wrappedAngle(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || Math.abs(v) > MAX_ABS) return null;
+  const wrapped = Math.fround(v - TWO_PI * Math.floor((v + Math.PI) / TWO_PI));
+  return wrapped === F32_PI ? -F32_PI : unsignedZero(wrapped);
+}
+function mask(v) {
+  return typeof v === "number" && Number.isInteger(v) && v >= 0 && v < MASK_LIMIT ? v : 0;
+}
+var isMask = (v) => typeof v === "number" && mask(v) === v;
+function stepSeconds(v, max) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) return 0;
+  return v > max ? max : v;
+}
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var INVPIO2 = 5734161139222659 / 2 ** 53;
+var PIO2_1 = 1686629713 / 2 ** 30;
+var PIO2_2 = 2242054355 / 2 ** 65;
+var PIO2_2T = 5376105825661043 / 2 ** 121;
+var S1 = -6004799503160649 / 2 ** 55;
+var S2 = 2401919801261139 / 2 ** 58;
+var S3 = -7320136532976085 / 2 ** 65;
+var S4 = 6506786730409597 / 2 ** 71;
+var S5 = -7571127717829867 / 2 ** 78;
+var S6 = 1537454791456095 / 2 ** 83;
+var C1 = 1501199875790163 / 2 ** 55;
+var C2 = -6405119470031223 / 2 ** 62;
+var C3 = 457508533350745 / 2 ** 64;
+var C4 = -5205429506036397 / 2 ** 74;
+var C5 = 1261860039765105 / 2 ** 79;
+var C6 = -1757820317994549 / 2 ** 87;
+var SINCOS_CONSTANTS = Object.freeze({
+  invpio2: INVPIO2,
+  pio2_1: PIO2_1,
+  pio2_2: PIO2_2,
+  pio2_2t: PIO2_2T,
+  S1,
+  S2,
+  S3,
+  S4,
+  S5,
+  S6,
+  C1,
+  C2,
+  C3,
+  C4,
+  C5,
+  C6
+});
+function psincos(a) {
+  if (!Number.isFinite(a) || Math.abs(a) > MAX_ABS) return [0, 1];
+  const n = Math.floor(a * INVPIO2 + 0.5);
+  const q = n - 4 * Math.floor(n / 4);
+  const r = a - n * PIO2_1 - n * PIO2_2 - n * PIO2_2T;
+  const z = r * r;
+  const ks = r + z * r * (S1 + z * (S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)))));
+  const hz = 0.5 * z;
+  const w = 1 - hz;
+  const kc = w + (1 - w - hz + z * (z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))))));
+  if (q === 0) return [unsignedZero(ks), unsignedZero(kc)];
+  if (q === 1) return [unsignedZero(kc), unsignedZero(-ks)];
+  if (q === 2) return [unsignedZero(-ks), unsignedZero(-kc)];
+  return [unsignedZero(-kc), unsignedZero(ks)];
+}
+var psin = (a) => psincos(a)[0];
+var pcos = (a) => psincos(a)[1];
+
+// src/authority/presets.ts
+var Preset = {
+  /** Planar movement on x/y with an aim angle: the server-authority spike's arena. */
+  TOPDOWN: "topdown",
+  /** Source-engine character movement through a static box-and-ramp world, z up (§17.7). */
+  FIRSTPERSON: "firstperson",
+  /** An arcade car (Rocket League's ground and air handling, kept level) through the same world (§17.7). */
+  VEHICLE: "vehicle"
+};
+var PRESET_MAX_DT_S = 0.25;
+var TOPDOWN_DEFAULTS = Object.freeze({ speed: 6, arena: 20 });
+var TOPDOWN_RANGE = {
+  speed: { min: 0, max: 1e3, positive: false },
+  arena: { min: 0, max: 1e6, positive: true }
+};
+function isPresetName(name) {
+  return Object.values(Preset).some((known) => known === name);
+}
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
+function presetParamsValid(name, params) {
+  if (params === void 0) return true;
+  const ranges = definitionOf(name)?.ranges;
+  if (ranges === void 0 || !isPlainObject(params)) return false;
+  return Object.keys(params).every((key) => {
+    if (!Object.hasOwn(ranges, key)) return false;
+    const range = ranges[key];
+    const v = params[key];
+    if (typeof v !== "number" || !Number.isFinite(v) || v < range.min || v > range.max) return false;
+    if (range.integer === true && !Number.isInteger(v)) return false;
+    return !range.positive || v > 0 && Math.fround(v) > 0;
+  });
+}
+function resolvePresetParams(name, params) {
+  const definition = definitionOf(name);
+  if (definition === void 0) return {};
+  const out = { ...definition.defaults };
+  if (!isPlainObject(params)) return out;
+  for (const key of Object.keys(definition.ranges)) {
+    if (presetParamsValid(name, { [key]: params[key] })) out[key] = params[key];
+  }
+  return out;
+}
+function resolveTopdownParams(params) {
+  return resolvePresetParams(Preset.TOPDOWN, params);
+}
+var finiteOrZero = (v) => Number.isFinite(v) ? v : 0;
+function stepTopdown(body, input, dt, params) {
+  const moveX = axis(input.moveX);
+  const moveY = axis(input.moveY);
+  const step = stepSeconds(dt, PRESET_MAX_DT_S);
+  const len = Math.sqrt(moveX * moveX + moveY * moveY);
+  const scale = len > 1 ? 1 / len : 1;
+  const x = finiteOrZero(body.x) + moveX * scale * params.speed * step;
+  const y = finiteOrZero(body.y) + moveY * scale * params.speed * step;
+  return {
+    x: unsignedZero(Math.fround(clamp(x, -params.arena, params.arena))),
+    y: unsignedZero(Math.fround(clamp(y, -params.arena, params.arena))),
+    yaw: wrappedAngle(input.yaw) ?? unsignedZero(Math.fround(finiteOrZero(body.yaw)))
+  };
+}
+var EMPTY_WORLD_HASH = 2615243109;
+var FIRSTPERSON_DEFAULTS = Object.freeze({
+  maxSpeed: 250,
+  walkSpeed: 0.52,
+  crouchSpeed: 0.34,
+  accelerate: 5.5,
+  airAccelerate: 12,
+  airMaxWishSpeed: 30,
+  friction: 5.2,
+  stopSpeed: 80,
+  gravity: 800,
+  jumpImpulse: 301.993,
+  maxVelocity: 3500,
+  radius: 16,
+  standHeight: 72,
+  crouchHeight: 54,
+  duckTime: 0.4,
+  stepHeight: 18,
+  standable: 0.7,
+  groundTrace: 2.5,
+  groundSnap: 1,
+  skin: 0.03,
+  pitchLimit: 1.5533430576324463,
+  jumpBit: 1,
+  duckBit: 2,
+  walkBit: 4,
+  substeps: 2,
+  world: EMPTY_WORLD_HASH
+});
+var inRange = (min, max) => ({ min, max, positive: false });
+var aboveZero = (max) => ({ min: 0, max, positive: true });
+var integerIn = (min, max) => ({ min, max, positive: false, integer: true });
+var FIRSTPERSON_RANGE = {
+  maxSpeed: inRange(0, 1e4),
+  walkSpeed: inRange(0, 1),
+  crouchSpeed: inRange(0, 1),
+  accelerate: inRange(0, 1e3),
+  airAccelerate: inRange(0, 1e3),
+  airMaxWishSpeed: inRange(0, 1e4),
+  friction: inRange(0, 1e3),
+  stopSpeed: inRange(0, 1e4),
+  gravity: inRange(0, 1e5),
+  jumpImpulse: inRange(0, 1e5),
+  maxVelocity: inRange(0, 1e5),
+  radius: aboveZero(1e4),
+  standHeight: aboveZero(1e4),
+  crouchHeight: aboveZero(1e4),
+  duckTime: aboveZero(100),
+  stepHeight: inRange(0, 1e4),
+  standable: inRange(0, 1),
+  groundTrace: inRange(0, 1e4),
+  groundSnap: inRange(0, 1e4),
+  skin: inRange(0, 100),
+  pitchLimit: inRange(0, 1.5707963705062866),
+  jumpBit: integerIn(0, MASK_LIMIT - 1),
+  duckBit: integerIn(0, MASK_LIMIT - 1),
+  walkBit: integerIn(0, MASK_LIMIT - 1),
+  substeps: integerIn(1, 8),
+  world: integerIn(0, 2 ** 32 - 1)
+};
+function resolveFirstpersonParams(params) {
+  return resolvePresetParams(Preset.FIRSTPERSON, params);
+}
+var MoveState = {
+  ON_GROUND: 1,
+  DUCKING: 2,
+  JUMP_HELD: 4
+};
+var MSTATE_BITS = MoveState.ON_GROUND | MoveState.DUCKING | MoveState.JUMP_HELD;
+var WorldLimits = {
+  MAX_BOXES: 4096,
+  MAX_RAMPS: 512,
+  /** Every world value's magnitude. */
+  MAX_ABS
+};
+var WorldError = class extends RangeError {
+  path;
+  constructor(path, message) {
+    super(`firstperson world: ${path} ${message}`);
+    this.name = "WorldError";
+    this.path = path;
+  }
+};
+var compiled = /* @__PURE__ */ new WeakMap();
+var worldValue = (v, path) => {
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new WorldError(path, "is not a finite number");
+  if (Math.fround(v) !== v) throw new WorldError(path, "is not a float32");
+  if (Math.abs(v) > MAX_ABS) throw new WorldError(path, `is past \xB1${MAX_ABS}`);
+  return unsignedZero(v);
+};
+function solidValues(raw, length, path) {
+  if (!Array.isArray(raw) || raw.length !== length) throw new WorldError(path, `is not an array of ${length} numbers`);
+  const out = [];
+  for (let i = 0; i < length; i++) out.push(worldValue(raw[i], `${path}[${i}]`));
+  if (!(out[0] < out[3] && out[1] < out[4] && out[2] < out[5])) throw new WorldError(path, "needs min < max on every axis");
+  return out;
+}
+function solidList(raw, key, max) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw)) throw new WorldError(key, "is not an array");
+  if (raw.length > max) throw new WorldError(key, `holds more than ${max}`);
+  return raw;
+}
+function worldHash(boxes, ramps) {
+  const bytes = new DataView(new ArrayBuffer(8 + 4 * (6 * boxes.length + 9 * ramps.length)));
+  bytes.setUint32(0, boxes.length, true);
+  bytes.setUint32(4, ramps.length, true);
+  let at = 8;
+  for (const solid of [...boxes, ...ramps]) {
+    for (const v of solid) {
+      bytes.setFloat32(at, v, true);
+      at += 4;
+    }
+  }
+  let h = 2166136261;
+  for (let i = 0; i < bytes.byteLength; i++) h = Math.imul(h ^ bytes.getUint8(i), 16777619) >>> 0;
+  return h;
+}
+function firstpersonWorld(raw, options = {}) {
+  const made = compiled.has(raw) ? raw : void 0;
+  if (made !== void 0 && (options.broadphase === void 0 || options.broadphase === made.broadphase)) return made;
+  if (raw !== void 0 && !isPlainObject(raw)) throw new WorldError("$", "is not an object");
+  const spec = raw ?? {};
+  const boxes = solidList(spec.boxes, "boxes", WorldLimits.MAX_BOXES).map(
+    (box, i) => Object.freeze(solidValues(box, 6, `boxes[${i}]`))
+  );
+  const ramps = solidList(spec.ramps, "ramps", WorldLimits.MAX_RAMPS).map((ramp, i) => {
+    const path = `ramps[${i}]`;
+    const v = solidValues(ramp, 9, path);
+    if (v[6] !== 0 && v[6] !== 1) throw new WorldError(`${path}[6]`, "is not an axis (0 or 1)");
+    const [minZ, maxZ, lo, hi] = [v[2], v[5], v[7], v[8]];
+    if (!(minZ <= lo && minZ <= hi)) throw new WorldError(path, "needs minZ \u2264 lo and minZ \u2264 hi");
+    if (maxZ !== Math.max(lo, hi)) throw new WorldError(path, "needs maxZ = max(lo, hi)");
+    return Object.freeze(v);
+  });
+  const world = Object.freeze({
+    boxes: Object.freeze(boxes),
+    ramps: Object.freeze(ramps),
+    hash: worldHash(boxes, ramps),
+    broadphase: options.broadphase !== false
+  });
+  compiled.set(world, compile(world));
+  return world;
+}
+var EMPTY_WORLD = firstpersonWorld(void 0);
+var PosedKind = { Box: 0, OBox: 1, Disc: 2 };
+var POSED_MAX = 96;
+var POSED_SCRATCH = new Int32Array(POSED_MAX);
+function posedWorld(solids) {
+  const n = solids.length;
+  if (n > POSED_MAX) throw new RangeError(`posed solids: at most ${POSED_MAX} a tick`);
+  const table = () => new Float64Array(n);
+  const p = { count: n, kind: new Uint8Array(n), minX: table(), minY: table(), minZ: table(), maxX: table(), maxY: table(), maxZ: table(), cx: table(), cy: table(), hx: table(), hy: table(), sin: table(), cos: table(), radius: table() };
+  solids.forEach((s, i) => {
+    if (s.kind === "box") {
+      p.kind[i] = PosedKind.Box;
+      [p.minX[i], p.minY[i], p.minZ[i]] = s.min;
+      [p.maxX[i], p.maxY[i], p.maxZ[i]] = s.max;
+      return;
+    }
+    p.cx[i] = s.c[0];
+    p.cy[i] = s.c[1];
+    p.minZ[i] = s.c[2] - (s.kind === "disc" ? s.half : s.half[2]);
+    p.maxZ[i] = s.c[2] + (s.kind === "disc" ? s.half : s.half[2]);
+    if (s.kind === "disc") {
+      p.kind[i] = PosedKind.Disc;
+      p.radius[i] = s.radius;
+      p.minX[i] = s.c[0] - s.radius;
+      p.maxX[i] = s.c[0] + s.radius;
+      p.minY[i] = s.c[1] - s.radius;
+      p.maxY[i] = s.c[1] + s.radius;
+      return;
+    }
+    p.kind[i] = PosedKind.OBox;
+    p.hx[i] = s.half[0];
+    p.hy[i] = s.half[1];
+    p.sin[i] = s.sin;
+    p.cos[i] = s.cos;
+    const ac = Math.abs(s.cos);
+    const as = Math.abs(s.sin);
+    const ex = s.half[0] * ac + s.half[1] * as;
+    const ey = s.half[0] * as + s.half[1] * ac;
+    p.minX[i] = s.c[0] - ex;
+    p.maxX[i] = s.c[0] + ex;
+    p.minY[i] = s.c[1] - ey;
+    p.maxY[i] = s.c[1] + ey;
+  });
+  return p;
+}
+var NO_POSED = posedWorld([]);
+function compiledOf(world) {
+  const known = compiled.get(world);
+  if (known !== void 0) return known;
+  const checked = firstpersonWorld(world, { broadphase: world.broadphase !== false });
+  const tables = compiled.get(checked);
+  compiled.set(world, tables);
+  return tables;
+}
+var TREE_FANOUT = 8;
+function compile(world) {
+  const solids = [...world.boxes, ...world.ramps];
+  const count = solids.length;
+  const table = () => new Float64Array(count);
+  const t = {
+    boxCount: world.boxes.length,
+    count,
+    minX: table(),
+    minY: table(),
+    minZ: table(),
+    maxX: table(),
+    maxY: table(),
+    maxZ: table(),
+    axis: new Uint8Array(count),
+    lo: table(),
+    hi: table(),
+    m0: table(),
+    span: table(),
+    slope: table(),
+    topZ: table()
+  };
+  solids.forEach((s, i) => {
+    t.minX[i] = s[0];
+    t.minY[i] = s[1];
+    t.minZ[i] = s[2];
+    t.maxX[i] = s[3];
+    t.maxY[i] = s[4];
+    t.maxZ[i] = s[5];
+    if (i < t.boxCount) return;
+    const axis2 = s[6];
+    const m0 = axis2 === 0 ? s[0] : s[1];
+    const m1 = axis2 === 0 ? s[3] : s[4];
+    const span = m1 - m0;
+    const slope = (s[8] - s[7]) / span;
+    t.axis[i] = axis2;
+    t.lo[i] = s[7];
+    t.hi[i] = s[8];
+    t.m0[i] = m0;
+    t.span[i] = span;
+    t.slope[i] = slope;
+    t.topZ[i] = 1 / Math.sqrt(1 + slope * slope);
+  });
+  return { ...t, tree: world.broadphase && count > 0 ? buildTree(t) : null };
+}
+function spread3(v) {
+  let x = v & 1023;
+  x = (x | x << 16) & 50331903;
+  x = (x | x << 8) & 50393103;
+  x = (x | x << 4) & 51130563;
+  x = (x | x << 2) & 153391689;
+  return x;
+}
+function buildTree(t) {
+  const n = t.count;
+  let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+  for (let i = 0; i < n; i++) {
+    x0 = Math.min(x0, t.minX[i]);
+    y0 = Math.min(y0, t.minY[i]);
+    z0 = Math.min(z0, t.minZ[i]);
+    x1 = Math.max(x1, t.maxX[i]);
+    y1 = Math.max(y1, t.maxY[i]);
+    z1 = Math.max(z1, t.maxZ[i]);
+  }
+  const cell = (v, lo, hi) => hi > lo ? Math.min(1023, Math.floor((v - lo) / (hi - lo) * 1024)) : 0;
+  const keys = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const cx = cell((t.minX[i] + t.maxX[i]) / 2, x0, x1);
+    const cy = cell((t.minY[i] + t.maxY[i]) / 2, y0, y1);
+    const cz = cell((t.minZ[i] + t.maxZ[i]) / 2, z0, z1);
+    keys[i] = (spread3(cx) | spread3(cy) << 1 | spread3(cz) << 2) * 8192 + i;
+  }
+  keys.sort();
+  const sizes = [n];
+  while (sizes[sizes.length - 1] > 1) sizes.push(Math.ceil(sizes[sizes.length - 1] / TREE_FANOUT));
+  const total = sizes.reduce((a, b) => a + b, 0);
+  const boxes = new Float64Array(total * 6);
+  const ref = new Int32Array(total);
+  const levelEnd = new Int32Array(sizes.length);
+  for (let k = 0; k < n; k++) {
+    const i = keys[k] % 8192;
+    const o = k * 6;
+    boxes[o] = t.minX[i];
+    boxes[o + 1] = t.minY[i];
+    boxes[o + 2] = t.minZ[i];
+    boxes[o + 3] = t.maxX[i];
+    boxes[o + 4] = t.maxY[i];
+    boxes[o + 5] = t.maxZ[i];
+    ref[k] = i;
+  }
+  levelEnd[0] = n;
+  let from = 0;
+  let at = n;
+  for (let level = 1; level < sizes.length; level++) {
+    const end = levelEnd[level - 1];
+    for (let child = from; child < end; child += TREE_FANOUT) {
+      const last = Math.min(child + TREE_FANOUT, end);
+      let a = Infinity, b = Infinity, c = Infinity, d = -Infinity, e = -Infinity, g = -Infinity;
+      for (let k = child; k < last; k++) {
+        const o2 = k * 6;
+        a = Math.min(a, boxes[o2]);
+        b = Math.min(b, boxes[o2 + 1]);
+        c = Math.min(c, boxes[o2 + 2]);
+        d = Math.max(d, boxes[o2 + 3]);
+        e = Math.max(e, boxes[o2 + 4]);
+        g = Math.max(g, boxes[o2 + 5]);
+      }
+      const o = at * 6;
+      boxes[o] = a;
+      boxes[o + 1] = b;
+      boxes[o + 2] = c;
+      boxes[o + 3] = d;
+      boxes[o + 4] = e;
+      boxes[o + 5] = g;
+      ref[at] = child;
+      at++;
+    }
+    from = end;
+    levelEnd[level] = at;
+  }
+  return { boxes, ref, levelEnd, root: total - 1 };
+}
+var queryMargin = (a, b, c, d, e, g) => 1e-3 + 1e-7 * (Math.abs(a) + Math.abs(b) + Math.abs(c) + Math.abs(d) + Math.abs(e) + Math.abs(g));
+function query(m, qx0, qy0, qz0, qx1, qy1, qz1) {
+  queryPosed(m, qx0, qy0, qz0, qx1, qy1, qz1);
+  const tree = m.w.tree;
+  if (tree === null) {
+    m.nCand = -1;
+    return;
+  }
+  const margin = queryMargin(qx0, qy0, qz0, qx1, qy1, qz1);
+  const pad = m.r + margin;
+  const x0 = qx0 - pad, x1 = qx1 + pad, y0 = qy0 - pad, y1 = qy1 + pad, z0 = qz0 - margin, z1 = qz1 + margin;
+  const { boxes, ref, levelEnd } = tree;
+  const count = levelEnd[0];
+  const cand = m.cand;
+  const stack = m.stack;
+  let n = 0;
+  let top = 0;
+  stack[top++] = tree.root;
+  while (top > 0) {
+    const node = stack[--top];
+    const o = node * 6;
+    if (boxes[o + 3] < x0 || boxes[o] > x1 || boxes[o + 4] < y0 || boxes[o + 1] > y1 || boxes[o + 5] < z0 || boxes[o + 2] > z1) continue;
+    if (node < count) {
+      cand[n++] = ref[node];
+      continue;
+    }
+    const first = ref[node];
+    let end = first + TREE_FANOUT;
+    for (let l = 0; l < levelEnd.length; l++) {
+      if (first < levelEnd[l]) {
+        end = Math.min(end, levelEnd[l]);
+        break;
+      }
+    }
+    for (let k = first; k < end; k++) stack[top++] = k;
+  }
+  m.nCand = n;
+}
+function queryPosed(m, qx0, qy0, qz0, qx1, qy1, qz1) {
+  const p = m.p;
+  let n = 0;
+  if (p.count > 0) {
+    const margin = queryMargin(qx0, qy0, qz0, qx1, qy1, qz1);
+    const pad = m.r + margin;
+    const x0 = qx0 - pad, x1 = qx1 + pad, y0 = qy0 - pad, y1 = qy1 + pad, z0 = qz0 - margin, z1 = qz1 + margin;
+    for (let j = 0; j < p.count; j++) {
+      if (p.maxX[j] < x0 || p.minX[j] > x1 || p.maxY[j] < y0 || p.minY[j] > y1 || p.maxZ[j] < z0 || p.minZ[j] > z1) continue;
+      m.pc[n++] = j;
+    }
+  }
+  m.nPosed = n;
+}
+var visits = (m) => (m.nCand < 0 ? m.w.count : m.nCand) + m.nPosed;
+var solidAt = (m, k) => {
+  const base = m.nCand < 0 ? m.w.count : m.nCand;
+  if (k >= base) return m.w.count + m.pc[k - base];
+  return m.nCand < 0 ? k : m.cand[k];
+};
+var hullAt = (m, d) => m.standHeight + (m.crouchHeight - m.standHeight) * d;
+function support(m, i, px, py) {
+  const w = m.w;
+  const slope = w.slope[i];
+  const c = w.axis[i] === 0 ? px : py;
+  const c2 = slope > 0 ? c + m.r : slope < 0 ? c - m.r : c;
+  return w.lo[i] + slope * clamp(c2 - w.m0[i], 0, w.span[i]);
+}
+function topOf(m, i, px, py) {
+  const w = m.w;
+  if (i < w.boxCount) return w.maxZ[i];
+  if (i < w.count) return support(m, i, px, py);
+  return m.p.maxZ[i - w.count];
+}
+var minZOf = (m, i) => i < m.w.count ? m.w.minZ[i] : m.p.minZ[i - m.w.count];
+function overlaps(m, i, px, py) {
+  const w = m.w;
+  const r = m.r;
+  if (i >= w.count) return posedOverlaps(m, i - w.count, px, py);
+  return px + r > w.minX[i] && px - r < w.maxX[i] && py + r > w.minY[i] && py - r < w.maxY[i];
+}
+function fits(m, px, py, pz, height) {
+  const w = m.w;
+  query(m, px, py, pz, px, py, pz + height);
+  const n = visits(m);
+  for (let k = 0; k < n; k++) {
+    const i = solidAt(m, k);
+    if (!overlaps(m, i, px, py) || !(pz + height > minZOf(m, i))) continue;
+    const top = topOf(m, i, px, py);
+    if (pz < top - 1e-4) return false;
+  }
+  return true;
+}
+function traceDown(m, px, py, pz, down, up) {
+  const w = m.w;
+  query(m, px, py, pz - down, px, py, pz + up);
+  const n = visits(m);
+  let best = Number.NaN;
+  let steep = Number.NaN;
+  for (let k = 0; k < n; k++) {
+    const i = solidAt(m, k);
+    if (!overlaps(m, i, px, py)) continue;
+    const top = topOf(m, i, px, py);
+    if (!(top <= pz + up && top >= pz - down)) continue;
+    if (i < w.boxCount || i >= w.count || w.topZ[i] >= m.standable) {
+      if (best !== best || top > best) best = top;
+    } else if (steep !== steep || top > steep) steep = top;
+  }
+  return steep > best ? Number.NaN : best;
+}
+function checkGround(m) {
+  if (m.vz > 0.1) {
+    m.onGround = false;
+    return;
+  }
+  const g = traceDown(m, m.x, m.y, m.z, m.groundTrace, m.groundSnap);
+  if (g === g) {
+    m.z = g;
+    m.onGround = true;
+  } else m.onGround = false;
+}
+function slabAxis(m, p, d, lo, hi, a) {
+  if (Math.abs(d) < 1e-9) return p > lo && p < hi;
+  let t1 = (lo - p) / d;
+  let t2 = (hi - p) / d;
+  let s = -1;
+  if (t1 > t2) {
+    const swap = t1;
+    t1 = t2;
+    t2 = swap;
+    s = 1;
+  }
+  if (t1 >= m.tMin) {
+    m.tMin = t1;
+    m.ax = a;
+    m.sg = s;
+  }
+  if (t2 < m.tMax) m.tMax = t2;
+  return !(m.tMin > m.tMax);
+}
+var PLANE = new Float64Array(4);
+function wedgePlane(m, i, plane, height) {
+  const w = m.w;
+  const r = m.r;
+  let nx = 0;
+  let ny = 0;
+  let nz = 0;
+  let e;
+  switch (plane) {
+    case 0:
+      nx = 1;
+      e = w.maxX[i] + r;
+      break;
+    case 1:
+      nx = -1;
+      e = -w.minX[i] + r;
+      break;
+    case 2:
+      ny = 1;
+      e = w.maxY[i] + r;
+      break;
+    case 3:
+      ny = -1;
+      e = -w.minY[i] + r;
+      break;
+    case 4:
+      nz = -1;
+      e = -w.minZ[i] + height;
+      break;
+    case 5: {
+      const slope = w.slope[i];
+      if (w.axis[i] === 0) nx = -slope;
+      else ny = -slope;
+      nz = 1;
+      e = w.lo[i] - slope * w.m0[i] + r * Math.abs(slope);
+      break;
+    }
+    default:
+      nz = 1;
+      e = w.maxZ[i];
+  }
+  PLANE[0] = nx;
+  PLANE[1] = ny;
+  PLANE[2] = nz;
+  PLANE[3] = e;
+}
+function insideSolid(m, px, py, pz, i, height) {
+  const w = m.w;
+  const r = m.r;
+  const skin = m.skin;
+  if (i >= w.count) return posedInside(m, px, py, pz, i - w.count, height);
+  if (i < w.boxCount) {
+    return px - (w.minX[i] - r) > skin && w.maxX[i] + r - px > skin && py - (w.minY[i] - r) > skin && w.maxY[i] + r - py > skin && pz - (w.minZ[i] - height) > skin && w.maxZ[i] - pz > skin;
+  }
+  for (let plane = 0; plane < 7; plane++) {
+    wedgePlane(m, i, plane, height);
+    const nx = PLANE[0];
+    const ny = PLANE[1];
+    const nz = PLANE[2];
+    const depth = -(nx * px + ny * py + nz * pz - PLANE[3]) * (1 / Math.sqrt(nx * nx + ny * ny + nz * nz));
+    if (!(depth > skin)) return false;
+  }
+  return true;
+}
+function covered(m, qx, qy, qz, px, py, pz, self, height) {
+  const all = m.w.count + m.p.count;
+  for (let j = 0; j < all; j++) {
+    if (j !== self && insideSolid(m, qx, qy, qz, j, height) && !insideSolid(m, px, py, pz, j, height)) return true;
+  }
+  return false;
+}
+function lidCovered(m, px, py, pz, ux, uy, uz, depth, i, height) {
+  return covered(m, px + ux * depth, py + uy * depth, pz + uz * depth, px, py, pz, i, height);
+}
+function slabInside(m, px, py, pz, b, i, height, self) {
+  const r = m.r;
+  const skin = m.skin;
+  const lx = px - (b.minX[i] - r);
+  const hx = b.maxX[i] + r - px;
+  const ly = py - (b.minY[i] - r);
+  const hy = b.maxY[i] + r - py;
+  const lz = pz - (b.minZ[i] - height);
+  const hz = b.maxZ[i] - pz;
+  if (!(lx > skin && hx > skin && ly > skin && hy > skin && lz > skin && hz > skin)) return false;
+  let depth = lx;
+  let nx = -1;
+  let ny = 0;
+  let nz = 0;
+  if (hx < depth) [depth, nx, ny, nz] = [hx, 1, 0, 0];
+  if (ly < depth) [depth, nx, ny, nz] = [ly, 0, -1, 0];
+  if (hy < depth) [depth, nx, ny, nz] = [hy, 0, 1, 0];
+  if (hz < depth && !covered(m, px, py, pz + hz, px, py, pz, self, height)) [depth, nx, ny, nz] = [hz, 0, 0, 1];
+  m.tMin = 0;
+  m.nx = nx;
+  m.ny = ny;
+  m.nz = nz;
+  m.depth = depth;
+  return true;
+}
+function slab(m, px, py, pz, dx, dy, dz, i, height, b = m.w, self = i) {
+  const r = m.r;
+  m.depth = 0;
+  if (slabInside(m, px, py, pz, b, i, height, self)) return true;
+  m.tMin = 0;
+  m.tMax = 1;
+  m.ax = -1;
+  m.sg = 0;
+  if (!slabAxis(m, px, dx, b.minX[i] - r, b.maxX[i] + r, 0)) return false;
+  if (!slabAxis(m, py, dy, b.minY[i] - r, b.maxY[i] + r, 1)) return false;
+  if (!slabAxis(m, pz, dz, b.minZ[i] - height, b.maxZ[i], 2)) return false;
+  if (m.tMin >= 1 || m.ax < 0) return false;
+  m.nx = m.ax === 0 ? m.sg : 0;
+  m.ny = m.ax === 1 ? m.sg : 0;
+  m.nz = m.ax === 2 ? m.sg : 0;
+  return true;
+}
+function wedge(m, px, py, pz, dx, dy, dz, i, height) {
+  const w = m.w;
+  const r = m.r;
+  const slope = w.slope[i];
+  const axisX = w.axis[i] === 0;
+  let enter = 0;
+  let leave = 1;
+  let taken = false;
+  let inside = true;
+  let least = Number.POSITIVE_INFINITY;
+  let lx = 0;
+  let ly = 0;
+  let lz = 0;
+  m.depth = 0;
+  for (let plane = 0; plane < 7; plane++) {
+    let nx = 0;
+    let ny = 0;
+    let nz = 0;
+    let e;
+    switch (plane) {
+      case 0:
+        nx = 1;
+        e = w.maxX[i] + r;
+        break;
+      case 1:
+        nx = -1;
+        e = -w.minX[i] + r;
+        break;
+      case 2:
+        ny = 1;
+        e = w.maxY[i] + r;
+        break;
+      case 3:
+        ny = -1;
+        e = -w.minY[i] + r;
+        break;
+      case 4:
+        nz = -1;
+        e = -w.minZ[i] + height;
+        break;
+      case 5:
+        if (axisX) nx = -slope;
+        else ny = -slope;
+        nz = 1;
+        e = w.lo[i] - slope * w.m0[i] + r * Math.abs(slope);
+        break;
+      default:
+        nz = 1;
+        e = w.maxZ[i];
+    }
+    const dist = nx * px + ny * py + nz * pz - e;
+    const motion = nx * dx + ny * dy + nz * dz;
+    const k = 1 / Math.sqrt(nx * nx + ny * ny + nz * nz);
+    const depth = -dist * k;
+    if (!(depth > m.skin)) inside = false;
+    else if (plane !== 4 && depth < least && !(inside && plane >= 5 && lidCovered(m, px, py, pz, nx * k, ny * k, nz * k, depth, i, height))) {
+      least = depth;
+      lx = nx * k;
+      ly = ny * k;
+      lz = nz * k;
+    }
+    if (Math.abs(motion) < 1e-9) {
+      if (dist > 0) return false;
+      continue;
+    }
+    const t = motion < 0 && dist <= 0 && dist > -m.skin ? 0 : -dist / motion;
+    if (motion < 0) {
+      if (t >= enter) {
+        enter = t;
+        m.nx = nx * k;
+        m.ny = ny * k;
+        m.nz = nz * k;
+        taken = true;
+      }
+    } else leave = Math.min(leave, t);
+    if (enter > leave) return false;
+  }
+  if (inside) {
+    m.tMin = 0;
+    m.nx = lx;
+    m.ny = ly;
+    m.nz = lz;
+    m.depth = least;
+    return true;
+  }
+  if (!taken || !(enter < 1) || !(leave >= 0)) return false;
+  m.tMin = enter;
+  return true;
+}
+function oboxPlane(m, j, plane, height) {
+  const p = m.p;
+  const c = p.cos[j];
+  const s = p.sin[j];
+  const cx = p.cx[j];
+  const cy = p.cy[j];
+  const hx = p.hx[j];
+  const hy = p.hy[j];
+  const r = m.r;
+  const reach = r * (Math.abs(c) + Math.abs(s));
+  let nx = 0;
+  let ny = 0;
+  let nz = 0;
+  let e;
+  switch (plane) {
+    case 0:
+      nx = c;
+      ny = s;
+      e = c * cx + s * cy + hx + reach;
+      break;
+    case 1:
+      nx = -c;
+      ny = -s;
+      e = -(c * cx + s * cy) + hx + reach;
+      break;
+    case 2:
+      nx = -s;
+      ny = c;
+      e = -s * cx + c * cy + hy + reach;
+      break;
+    case 3:
+      nx = s;
+      ny = -c;
+      e = s * cx - c * cy + hy + reach;
+      break;
+    case 4:
+      nx = 1;
+      e = cx + r + hx * Math.abs(c) + hy * Math.abs(s);
+      break;
+    case 5:
+      nx = -1;
+      e = -cx + r + hx * Math.abs(c) + hy * Math.abs(s);
+      break;
+    case 6:
+      ny = 1;
+      e = cy + r + hx * Math.abs(s) + hy * Math.abs(c);
+      break;
+    case 7:
+      ny = -1;
+      e = -cy + r + hx * Math.abs(s) + hy * Math.abs(c);
+      break;
+    case 8:
+      nz = -1;
+      e = -p.minZ[j] + height;
+      break;
+    default:
+      nz = 1;
+      e = p.maxZ[j];
+  }
+  PLANE[0] = nx;
+  PLANE[1] = ny;
+  PLANE[2] = nz;
+  PLANE[3] = e;
+}
+var OBOX_PLANES = 10;
+var OBOX_BOTTOM = 8;
+var OBOX_TOP = 9;
+function posedOverlaps(m, j, px, py) {
+  const p = m.p;
+  const r = m.r;
+  if (!(px + r > p.minX[j] && px - r < p.maxX[j] && py + r > p.minY[j] && py - r < p.maxY[j])) return false;
+  const kind = p.kind[j];
+  if (kind === PosedKind.Box) return true;
+  const dx = px - p.cx[j];
+  const dy = py - p.cy[j];
+  if (kind === PosedKind.Disc) {
+    const ax = Math.max(Math.abs(dx) - r, 0);
+    const ay = Math.max(Math.abs(dy) - r, 0);
+    return ax * ax + ay * ay < p.radius[j] * p.radius[j];
+  }
+  const c = p.cos[j];
+  const s = p.sin[j];
+  const reach = r * (Math.abs(c) + Math.abs(s));
+  return Math.abs(c * dx + s * dy) < p.hx[j] + reach && Math.abs(-s * dx + c * dy) < p.hy[j] + reach;
+}
+function discDepth(m, j, px, py) {
+  const p = m.p;
+  const r = m.r;
+  const dx = px - p.cx[j];
+  const dy = py - p.cy[j];
+  const adx = Math.abs(dx);
+  const ady = Math.abs(dy);
+  const R = p.radius[j];
+  if (adx <= r && ady <= r) {
+    const alongX = adx >= ady;
+    PLANE[0] = alongX ? dx < 0 ? -1 : 1 : 0;
+    PLANE[1] = alongX ? 0 : dy < 0 ? -1 : 1;
+    return R + r - (alongX ? adx : ady);
+  }
+  const qx = adx > r ? dx < 0 ? -(adx - r) : adx - r : 0;
+  const qy = ady > r ? dy < 0 ? -(ady - r) : ady - r : 0;
+  const len = Math.sqrt(qx * qx + qy * qy);
+  PLANE[0] = qx / len;
+  PLANE[1] = qy / len;
+  return R - len;
+}
+function posedInside(m, px, py, pz, j, height) {
+  const p = m.p;
+  const skin = m.skin;
+  const kind = p.kind[j];
+  if (kind === PosedKind.Box) {
+    const r = m.r;
+    return px - (p.minX[j] - r) > skin && p.maxX[j] + r - px > skin && py - (p.minY[j] - r) > skin && p.maxY[j] + r - py > skin && pz - (p.minZ[j] - height) > skin && p.maxZ[j] - pz > skin;
+  }
+  if (!(pz - (p.minZ[j] - height) > skin && p.maxZ[j] - pz > skin)) return false;
+  if (kind === PosedKind.Disc) return discDepth(m, j, px, py) > skin;
+  for (let plane = 0; plane < OBOX_BOTTOM; plane++) {
+    oboxPlane(m, j, plane, height);
+    const nx = PLANE[0];
+    const ny = PLANE[1];
+    if (!(-(nx * px + ny * py - PLANE[3]) * (1 / Math.sqrt(nx * nx + ny * ny)) > skin)) return false;
+  }
+  return true;
+}
+function oboxSweep(m, px, py, pz, dx, dy, dz, j, i, height) {
+  let enter = 0;
+  let leave = 1;
+  let taken = false;
+  let inside = true;
+  let least = Number.POSITIVE_INFINITY;
+  let lx = 0;
+  let ly = 0;
+  let lz = 0;
+  m.depth = 0;
+  for (let plane = 0; plane < OBOX_PLANES; plane++) {
+    oboxPlane(m, j, plane, height);
+    const nx = PLANE[0];
+    const ny = PLANE[1];
+    const nz = PLANE[2];
+    const dist = nx * px + ny * py + nz * pz - PLANE[3];
+    const motion = nx * dx + ny * dy + nz * dz;
+    const k = 1 / Math.sqrt(nx * nx + ny * ny + nz * nz);
+    const depth = -dist * k;
+    if (!(depth > m.skin)) inside = false;
+    else if (plane !== OBOX_BOTTOM && depth < least && !(inside && plane === OBOX_TOP && lidCovered(m, px, py, pz, nx * k, ny * k, nz * k, depth, i, height))) {
+      least = depth;
+      lx = nx * k;
+      ly = ny * k;
+      lz = nz * k;
+    }
+    if (Math.abs(motion) < 1e-9) {
+      if (dist > 0) return false;
+      continue;
+    }
+    const t = motion < 0 && dist <= 0 && dist > -m.skin ? 0 : -dist / motion;
+    if (motion < 0) {
+      if (t >= enter) {
+        enter = t;
+        m.nx = nx * k;
+        m.ny = ny * k;
+        m.nz = nz * k;
+        taken = true;
+      }
+    } else leave = Math.min(leave, t);
+    if (enter > leave) return false;
+  }
+  if (inside) {
+    m.tMin = 0;
+    m.nx = lx;
+    m.ny = ly;
+    m.nz = lz;
+    m.depth = least;
+    return true;
+  }
+  if (!taken || !(enter < 1) || !(leave >= 0)) return false;
+  m.tMin = enter;
+  return true;
+}
+function cylinder(m, px, py, pz, dx, dy, dz, ox, oy, R, z0, z1) {
+  m.tMin = 0;
+  m.tMax = 1;
+  m.ax = -1;
+  m.sg = 0;
+  const ex = px - ox;
+  const ey = py - oy;
+  const a = dx * dx + dy * dy;
+  const c = ex * ex + ey * ey - R * R;
+  if (a < 1e-18) {
+    if (!(c < 0)) return false;
+  } else {
+    const b = ex * dx + ey * dy;
+    const disc = b * b - a * c;
+    if (disc < 0) return false;
+    const sq = Math.sqrt(disc);
+    const t1 = (-b - sq) / a;
+    const t2 = (-b + sq) / a;
+    if (t1 >= m.tMin) {
+      m.tMin = t1;
+      m.ax = 3;
+    }
+    if (t2 < m.tMax) m.tMax = t2;
+    if (m.tMin > m.tMax) return false;
+  }
+  if (!slabAxis(m, pz, dz, z0, z1, 2)) return false;
+  if (m.tMin >= 1 || m.ax < 0) return false;
+  if (m.ax === 3) {
+    const hx = ex + dx * m.tMin;
+    const hy = ey + dy * m.tMin;
+    const len = Math.sqrt(hx * hx + hy * hy);
+    m.nx = hx / len;
+    m.ny = hy / len;
+    m.nz = 0;
+  } else {
+    m.nx = 0;
+    m.ny = 0;
+    m.nz = m.sg;
+  }
+  return true;
+}
+var CROSS = { minX: new Float64Array(2), minY: new Float64Array(2), minZ: new Float64Array(2), maxX: new Float64Array(2), maxY: new Float64Array(2), maxZ: new Float64Array(2) };
+function discSweep(m, px, py, pz, dx, dy, dz, j, i, height) {
+  const p = m.p;
+  const r = m.r;
+  const R = p.radius[j];
+  const cx = p.cx[j];
+  const cy = p.cy[j];
+  const z0 = p.minZ[j] - height;
+  const z1 = p.maxZ[j];
+  m.depth = 0;
+  const side = discDepth(m, j, px, py);
+  const lz = pz - z0;
+  const hz = z1 - pz;
+  if (side > m.skin && lz > m.skin && hz > m.skin) {
+    m.tMin = 0;
+    if (hz < side && !covered(m, px, py, pz + hz, px, py, pz, i, height)) [m.nx, m.ny, m.nz, m.depth] = [0, 0, 1, hz];
+    else [m.nx, m.ny, m.nz, m.depth] = [PLANE[0], PLANE[1], 0, side];
+    return true;
+  }
+  let found = false;
+  let bt = 0;
+  let bx = 0;
+  let by = 0;
+  let bz = 0;
+  CROSS.minX[0] = cx - R;
+  CROSS.maxX[0] = cx + R;
+  CROSS.minY[0] = cy;
+  CROSS.maxY[0] = cy;
+  CROSS.minX[1] = cx;
+  CROSS.maxX[1] = cx;
+  CROSS.minY[1] = cy - R;
+  CROSS.maxY[1] = cy + R;
+  for (let k = 0; k < 2; k++) {
+    CROSS.minZ[k] = p.minZ[j];
+    CROSS.maxZ[k] = z1;
+    if (slab(m, px, py, pz, dx, dy, dz, k, height, CROSS, i) && (!found || m.tMin < bt)) {
+      found = true;
+      bt = m.tMin;
+      bx = m.nx;
+      by = m.ny;
+      bz = m.nz;
+    }
+  }
+  for (let k = 0; k < 4; k++) {
+    const ox = k % 2 === 0 ? cx - r : cx + r;
+    const oy = k < 2 ? cy - r : cy + r;
+    if (cylinder(m, px, py, pz, dx, dy, dz, ox, oy, R, z0, z1) && (!found || m.tMin < bt)) {
+      found = true;
+      bt = m.tMin;
+      bx = m.nx;
+      by = m.ny;
+      bz = m.nz;
+    }
+  }
+  if (!found) return false;
+  m.tMin = bt;
+  m.nx = bx;
+  m.ny = by;
+  m.nz = bz;
+  m.depth = 0;
+  return true;
+}
+function posedSweep(m, px, py, pz, dx, dy, dz, i, height) {
+  const j = i - m.w.count;
+  const kind = m.p.kind[j];
+  if (kind === PosedKind.Box) return slab(m, px, py, pz, dx, dy, dz, j, height, m.p, i);
+  if (kind === PosedKind.OBox) return oboxSweep(m, px, py, pz, dx, dy, dz, j, i, height);
+  return discSweep(m, px, py, pz, dx, dy, dz, j, i, height);
+}
+function sweep(m, px, py, pz, dx, dy, dz) {
+  const w = m.w;
+  const height = hullAt(m, m.duck);
+  const ex = px + dx;
+  const ey = py + dy;
+  const ez = pz + dz;
+  query(m, px < ex ? px : ex, py < ey ? py : ey, pz < ez ? pz : ez, px < ex ? ex : px, py < ey ? ey : py, (pz < ez ? ez : pz) + height);
+  const n = visits(m);
+  let found = false;
+  let bestT = 0;
+  let bestI = 0;
+  let bnx = 0;
+  let bny = 0;
+  let bnz = 0;
+  let bd = 0;
+  for (let k = 0; k < n; k++) {
+    const i = solidAt(m, k);
+    const hit = i < w.boxCount ? slab(m, px, py, pz, dx, dy, dz, i, height) : i < w.count ? wedge(m, px, py, pz, dx, dy, dz, i, height) : posedSweep(m, px, py, pz, dx, dy, dz, i, height);
+    if (hit && (!found || m.tMin < bestT || m.tMin === bestT && i < bestI)) {
+      found = true;
+      bestT = m.tMin;
+      bestI = i;
+      bnx = m.nx;
+      bny = m.ny;
+      bnz = m.nz;
+      bd = m.depth;
+    }
+  }
+  m.hit = found;
+  if (found) {
+    m.tMin = Math.max(0, bestT - 1e-4);
+    m.nx = bnx;
+    m.ny = bny;
+    m.nz = bnz;
+    m.depth = bd;
+  } else {
+    m.tMin = 1;
+    m.depth = 0;
+  }
+}
+function slideMove(m, T, car = false) {
+  let remaining = T;
+  let hasPrev = false;
+  let qx = 0;
+  let qy = 0;
+  let qz = 0;
+  for (let bump = 0; bump < 4 && remaining > 1e-6; bump++) {
+    if (m.vx * m.vx + m.vy * m.vy + m.vz * m.vz < 1e-8) return;
+    sweep(m, m.x, m.y, m.z, m.vx * remaining, m.vy * remaining, m.vz * remaining);
+    const t = m.tMin;
+    if (t > 0) {
+      const s = t * remaining;
+      m.x = m.x + m.vx * s;
+      m.y = m.y + m.vy * s;
+      m.z = m.z + m.vz * s;
+      remaining = remaining - s;
+    }
+    if (!m.hit) return;
+    if (m.depth > 0) {
+      m.x = m.x + m.nx * m.depth;
+      m.y = m.y + m.ny * m.depth;
+      m.z = m.z + m.nz * m.depth;
+    }
+    let nx = m.nx;
+    let ny = m.ny;
+    let nz = m.nz;
+    let lift = false;
+    if (car && nz > 0) {
+      if (nz >= m.standable) lift = true;
+      else {
+        const k = 1 / Math.sqrt(nx * nx + ny * ny);
+        nx = nx * k;
+        ny = ny * k;
+        nz = 0;
+      }
+    }
+    m.x = m.x + nx * m.skin;
+    m.y = m.y + ny * m.skin;
+    m.z = m.z + nz * m.skin;
+    const b = m.vx * nx + m.vy * ny + m.vz * nz;
+    if (b < 0) {
+      if (lift) m.vz = m.vz - b / nz;
+      else {
+        m.vx = m.vx + nx * -b;
+        m.vy = m.vy + ny * -b;
+        m.vz = m.vz + nz * -b;
+      }
+    }
+    if (hasPrev) {
+      let cx = qy * nz - qz * ny;
+      let cy = qz * nx - qx * nz;
+      let cz = qx * ny - qy * nx;
+      const L = cx * cx + cy * cy + cz * cz;
+      if (L > 1e-6) {
+        const k = 1 / Math.sqrt(L);
+        cx = cx * k;
+        cy = cy * k;
+        cz = cz * k;
+        const d = m.vx * cx + m.vy * cy + m.vz * cz;
+        m.vx = cx * d;
+        m.vy = cy * d;
+        m.vz = cz * d;
+      }
+    }
+    hasPrev = true;
+    qx = nx;
+    qy = ny;
+    qz = nz;
+    if (m.vx * m.vx + m.vy * m.vy + m.vz * m.vz < 1e-8) return;
+  }
+}
+function groundMove(m, car = false) {
+  const x0 = m.x, y0 = m.y, z0 = m.z;
+  const vx0 = m.vx, vy0 = m.vy, vz0 = m.vz;
+  slideMove(m, m.h, car);
+  const x1 = m.x, y1 = m.y, z1 = m.z;
+  const vx1 = m.vx, vy1 = m.vy, vz1 = m.vz;
+  const ax = x1 - x0;
+  const ay = y1 - y0;
+  const flat = ax * ax + ay * ay;
+  m.x = x0;
+  m.y = y0;
+  m.z = z0;
+  m.vx = vx0;
+  m.vy = vy0;
+  m.vz = vz0;
+  const lift = m.stepHeight + m.skin;
+  sweep(m, x0, y0, z0, 0, 0, lift);
+  const t = m.tMin;
+  const zl = z0 + lift * t;
+  if (t > 0 && fits(m, x0, y0, zl, hullAt(m, m.duck))) {
+    m.z = zl;
+    slideMove(m, m.h, car);
+    const g = traceDown(m, m.x, m.y, m.z, m.stepHeight * 2, 1e-3);
+    if (g === g) m.z = g;
+    const bx = m.x - x0;
+    const by = m.y - y0;
+    const stepped = bx * bx + by * by;
+    if (g === g && stepped > flat + 1e-3) {
+      m.vz = 0;
+      return;
+    }
+  }
+  m.x = x1;
+  m.y = y1;
+  m.z = z1;
+  m.vx = vx1;
+  m.vy = vy1;
+  m.vz = vz1;
+}
+function stayOnGround(m) {
+  const g = traceDown(m, m.x, m.y, m.z, m.stepHeight, m.groundSnap);
+  if (g === g) {
+    m.z = g;
+    m.vz = 0;
+  }
+}
+function applyFriction(m) {
+  const speed = Math.sqrt(m.vx * m.vx + m.vy * m.vy);
+  if (speed < 0.1) {
+    m.vx = 0;
+    m.vy = 0;
+    return;
+  }
+  const control = speed < m.stopSpeed ? m.stopSpeed : speed;
+  const drop = control * m.friction * m.h;
+  const k = Math.max(0, speed - drop) / speed;
+  m.vx = m.vx * k;
+  m.vy = m.vy * k;
+}
+function groundAccelerate(m) {
+  const add = m.wishSpeed - (m.vx * m.dirX + m.vy * m.dirY);
+  if (add <= 0) return;
+  let a = m.accelerate * m.h * Math.max(m.wishSpeed, m.maxSpeed);
+  if (a > add) a = add;
+  m.vx = m.vx + a * m.dirX;
+  m.vy = m.vy + a * m.dirY;
+}
+function airAccelerate(m) {
+  const add = Math.min(m.wishSpeed, m.airMaxWishSpeed) - (m.vx * m.dirX + m.vy * m.dirY);
+  if (add <= 0) return;
+  let a = m.airAccelerate * m.wishSpeed * m.h;
+  if (a > add) a = add;
+  m.vx = m.vx + a * m.dirX;
+  m.vy = m.vy + a * m.dirY;
+}
+var stored = (v) => unsignedZero(Math.fround(clamp(v, -MAX_ABS, MAX_ABS)));
+function subStep(m, duckDown, walk) {
+  const rate = m.h / m.duckTime;
+  if (duckDown) {
+    const next = Math.min(1, m.duck + rate);
+    if (!m.onGround) m.z = m.z + (hullAt(m, m.duck) - hullAt(m, next));
+    m.duck = next;
+    m.ducking = true;
+  } else if (m.duck > 0) {
+    const next = Math.max(0, m.duck - rate);
+    const zn = m.onGround ? m.z : m.z - (hullAt(m, next) - hullAt(m, m.duck));
+    if (fits(m, m.x, m.y, zn, hullAt(m, next))) {
+      m.duck = next;
+      m.z = zn;
+      if (m.duck === 0) m.ducking = false;
+    }
+  }
+  const was = m.onGround;
+  checkGround(m);
+  if (m.onGround && !was) m.vz = 0;
+  m.base = m.maxSpeed * m.cap;
+  const target = m.ducking ? m.base * m.crouchSpeed : walk ? m.base * m.walkSpeed : m.base;
+  m.wishSpeed = m.amount * target;
+  if (m.onGround) {
+    if (m.pressed) {
+      m.vz = m.jumpImpulse;
+      m.onGround = false;
+      m.pressed = false;
+      airAccelerate(m);
+    } else {
+      applyFriction(m);
+      groundAccelerate(m);
+      m.vz = 0;
+    }
+  } else airAccelerate(m);
+  const falling = !m.onGround;
+  if (falling) m.vz = m.vz - m.gravity * m.h * 0.5;
+  m.vx = clamp(m.vx, -m.maxVelocity, m.maxVelocity);
+  m.vy = clamp(m.vy, -m.maxVelocity, m.maxVelocity);
+  m.vz = clamp(m.vz, -m.maxVelocity, m.maxVelocity);
+  if (m.onGround) {
+    groundMove(m);
+    stayOnGround(m);
+  } else slideMove(m, m.h);
+  checkGround(m);
+  if (falling && !m.onGround) m.vz = m.vz - m.gravity * m.h * 0.5;
+  else if (m.onGround) m.vz = 0;
+  m.x = stored(m.x);
+  m.y = stored(m.y);
+  m.z = stored(m.z);
+  m.vx = stored(m.vx);
+  m.vy = stored(m.vy);
+  m.vz = stored(m.vz);
+  m.duck = unsignedZero(Math.fround(m.duck));
+}
+var bodyValue = (v, fallback, lo, hi) => unsignedZero(Math.fround(clamp(typeof v === "number" && Number.isFinite(v) ? v : fallback, lo, hi)));
+var bodyAngle = (v) => unsignedZero(Math.fround(typeof v === "number" && Number.isFinite(v) ? v : 0));
+var scratch = { cand: new Int32Array(0), stack: new Int32Array(TREE_FANOUT * 16) };
+function scratchFor(w) {
+  if (scratch.cand.length < w.count) scratch = { cand: new Int32Array(w.count), stack: scratch.stack };
+  return scratch;
+}
+function hullOps(preset, params, world = EMPTY_WORLD) {
+  const w = compiledOf(world);
+  const f = Math.fround;
+  const height = (k) => f(preset === "vehicle" ? params.height : params[k]);
+  const hullOf = (body, solids) => {
+    const room = scratchFor(w);
+    return {
+      w,
+      p: posedWorld(solids),
+      r: f(params.radius),
+      standHeight: height("standHeight"),
+      crouchHeight: height("crouchHeight"),
+      stepHeight: f(params.stepHeight),
+      standable: f(params.standable),
+      groundTrace: f(params.groundTrace),
+      groundSnap: f(params.groundSnap),
+      skin: f(params.skin),
+      x: body.x,
+      y: body.y,
+      z: body.z,
+      vx: 0,
+      vy: 0,
+      vz: body.vz ?? 0,
+      duck: preset === "vehicle" ? 0 : body.duck ?? 0,
+      onGround: false,
+      h: 0,
+      tMin: 0,
+      tMax: 0,
+      ax: -1,
+      sg: 0,
+      nx: 0,
+      ny: 0,
+      nz: 0,
+      hit: false,
+      depth: 0,
+      cand: room.cand,
+      nCand: -1,
+      pc: POSED_SCRATCH,
+      nPosed: 0,
+      stack: room.stack
+    };
+  };
+  return {
+    support(body, solids) {
+      const m = hullOf(body, solids);
+      if (m.vz > 0.1) return -1;
+      const g = traceDown(m, m.x, m.y, m.z, m.groundTrace, m.groundSnap);
+      if (g !== g) return -1;
+      for (let j = 0; j < m.p.count; j++) if (m.p.maxZ[j] === g && posedOverlaps(m, j, m.x, m.y)) return j;
+      return -1;
+    },
+    inside(body, solids, k) {
+      const m = hullOf(body, solids);
+      return insideSolid(m, m.x, m.y, m.z, w.count + k, hullAt(m, m.duck));
+    },
+    pushOut(body, solids) {
+      const m = hullOf(body, solids);
+      for (let k = 0; k < 4; k++) {
+        sweep(m, m.x, m.y, m.z, 0, 0, 0);
+        if (!m.hit) break;
+        m.x = m.x + m.nx * m.depth;
+        m.y = m.y + m.ny * m.depth;
+        m.z = m.z + m.nz * m.depth;
+        m.x = m.x + m.nx * m.skin;
+        m.y = m.y + m.ny * m.skin;
+        m.z = m.z + m.nz * m.skin;
+      }
+      const height2 = hullAt(m, m.duck);
+      let inside = false;
+      for (let i = 0; i < w.count + m.p.count && !inside; i++) inside = insideSolid(m, m.x, m.y, m.z, i, height2);
+      return { x: m.x, y: m.y, z: m.z, inside };
+    }
+  };
+}
+function stepFirstperson(body, input, dt, params, world = EMPTY_WORLD, posed = NO_POSED) {
+  const w = compiledOf(world);
+  const room = scratchFor(w);
+  const f = Math.fround;
+  const mstate = mask(body.mstate) & MSTATE_BITS;
+  const m = {
+    w,
+    p: posed,
+    maxSpeed: f(params.maxSpeed),
+    walkSpeed: f(params.walkSpeed),
+    crouchSpeed: f(params.crouchSpeed),
+    accelerate: f(params.accelerate),
+    airAccelerate: f(params.airAccelerate),
+    airMaxWishSpeed: f(params.airMaxWishSpeed),
+    friction: f(params.friction),
+    stopSpeed: f(params.stopSpeed),
+    gravity: f(params.gravity),
+    jumpImpulse: f(params.jumpImpulse),
+    maxVelocity: f(params.maxVelocity),
+    r: f(params.radius),
+    standHeight: f(params.standHeight),
+    crouchHeight: f(params.crouchHeight),
+    duckTime: f(params.duckTime),
+    stepHeight: f(params.stepHeight),
+    standable: f(params.standable),
+    groundTrace: f(params.groundTrace),
+    groundSnap: f(params.groundSnap),
+    skin: f(params.skin),
+    x: bodyValue(body.x, 0, -MAX_ABS, MAX_ABS),
+    y: bodyValue(body.y, 0, -MAX_ABS, MAX_ABS),
+    z: bodyValue(body.z, 0, -MAX_ABS, MAX_ABS),
+    vx: bodyValue(body.vx, 0, -MAX_ABS, MAX_ABS),
+    vy: bodyValue(body.vy, 0, -MAX_ABS, MAX_ABS),
+    vz: bodyValue(body.vz, 0, -MAX_ABS, MAX_ABS),
+    duck: bodyValue(body.duck, 0, 0, 1),
+    cap: bodyValue(body.cap, 1, 0, 4),
+    onGround: (mstate & MoveState.ON_GROUND) !== 0,
+    ducking: (mstate & MoveState.DUCKING) !== 0,
+    jumpHeld: (mstate & MoveState.JUMP_HELD) !== 0,
+    pressed: false,
+    h: 0,
+    dirX: 0,
+    dirY: 0,
+    amount: 0,
+    base: 0,
+    wishSpeed: 0,
+    tMin: 0,
+    tMax: 0,
+    ax: -1,
+    sg: 0,
+    nx: 0,
+    ny: 0,
+    nz: 0,
+    hit: false,
+    depth: 0,
+    cand: room.cand,
+    nCand: -1,
+    pc: POSED_SCRATCH,
+    nPosed: 0,
+    stack: room.stack
+  };
+  const mx = axis(input.moveX);
+  const my = axis(input.moveY);
+  const len = Math.sqrt(mx * mx + my * my);
+  if (len > 1e-4) {
+    m.dirX = mx / len;
+    m.dirY = my / len;
+    m.amount = Math.min(len, 1);
+  }
+  const buttons = mask(input.buttons);
+  const jump = (buttons & params.jumpBit) !== 0;
+  const duckDown = (buttons & params.duckBit) !== 0;
+  const walk = (buttons & params.walkBit) !== 0;
+  const step = stepSeconds(dt, PRESET_MAX_DT_S);
+  m.h = step / params.substeps;
+  const yaw = wrappedAngle(input.yaw) ?? bodyAngle(body.yaw);
+  const pitchLimit = f(params.pitchLimit);
+  const pitch = unsignedZero(clamp(wrappedAngle(input.pitch) ?? bodyAngle(body.pitch), -pitchLimit, pitchLimit));
+  if (step > 0) {
+    m.pressed = jump && !m.jumpHeld;
+    m.jumpHeld = jump;
+    for (let i = 0; i < params.substeps; i++) subStep(m, duckDown, walk);
+  }
+  return {
+    x: m.x,
+    y: m.y,
+    z: m.z,
+    vx: m.vx,
+    vy: m.vy,
+    vz: m.vz,
+    yaw,
+    pitch,
+    duck: m.duck,
+    mstate: (m.onGround ? MoveState.ON_GROUND : 0) + (m.ducking ? MoveState.DUCKING : 0) + (m.jumpHeld ? MoveState.JUMP_HELD : 0)
+  };
+}
+var VEHICLE_DEFAULTS = Object.freeze({
+  maxSpeed: 1410,
+  accel: 1e3,
+  brake: 3500,
+  coast: 525,
+  boostAccel: 1e3,
+  boostMaxSpeed: 2300,
+  boostBurn: 0.3333333432674408,
+  grip: 6e3,
+  driftGrip: 1500,
+  turnRate: 2.2,
+  turnSpeed: 400,
+  spinAccel: 30,
+  airTurnRate: 5.5,
+  airSpinAccel: 9,
+  gravity: 650,
+  jumpImpulse: 450,
+  maxVelocity: 6e3,
+  radius: 50,
+  height: 36,
+  stepHeight: 8,
+  standable: 0.7,
+  groundTrace: 4,
+  groundSnap: 2,
+  skin: 0.03,
+  jumpBit: 1,
+  boostBit: 2,
+  driftBit: 4,
+  substeps: 2,
+  world: EMPTY_WORLD_HASH
+});
+var VEHICLE_RANGE = {
+  maxSpeed: inRange(0, 1e5),
+  accel: inRange(0, 1e5),
+  brake: inRange(0, 1e5),
+  coast: inRange(0, 1e5),
+  boostAccel: inRange(0, 1e5),
+  boostMaxSpeed: inRange(0, 1e5),
+  boostBurn: inRange(0, 1e3),
+  grip: inRange(0, 1e5),
+  driftGrip: inRange(0, 1e5),
+  turnRate: inRange(0, 100),
+  turnSpeed: aboveZero(1e5),
+  spinAccel: inRange(0, 1e4),
+  airTurnRate: inRange(0, 100),
+  airSpinAccel: inRange(0, 1e4),
+  gravity: inRange(0, 1e5),
+  jumpImpulse: inRange(0, 1e5),
+  maxVelocity: inRange(0, 1e5),
+  radius: aboveZero(1e4),
+  height: aboveZero(1e4),
+  stepHeight: inRange(0, 1e4),
+  standable: inRange(0, 1),
+  groundTrace: inRange(0, 1e4),
+  groundSnap: inRange(0, 1e4),
+  skin: inRange(0, 100),
+  jumpBit: integerIn(0, MASK_LIMIT - 1),
+  boostBit: integerIn(0, MASK_LIMIT - 1),
+  driftBit: integerIn(0, MASK_LIMIT - 1),
+  substeps: integerIn(1, 8),
+  world: integerIn(0, 2 ** 32 - 1)
+};
+function resolveVehicleParams(params) {
+  return resolvePresetParams(Preset.VEHICLE, params);
+}
+var VEHICLE_MSTATE_BITS = MoveState.ON_GROUND | MoveState.JUMP_HELD;
+var toward = (v, target, d) => v < target ? Math.min(target, v + d) : v > target ? Math.max(target, v - d) : v;
+var wrap = (v) => wrappedAngle(v) ?? 0;
+function drive(m) {
+  const top = m.maxSpeed * m.cap;
+  const t = m.boosting ? 1 : m.throttle;
+  const target = t * top;
+  let f = m.f;
+  if (t === 0) f = toward(f, 0, m.coast * m.h);
+  else if (t > 0 && f < 0 || t < 0 && f > 0) f = toward(f, 0, m.brake * m.h);
+  else if (Math.abs(f) < Math.abs(target)) f = toward(f, target, m.accel * m.h);
+  else if (!m.boosting) f = toward(f, target, m.coast * m.h);
+  if (m.boosting) {
+    const boostTop = m.boostMaxSpeed * m.cap;
+    if (f < boostTop) f = Math.min(boostTop, f + m.boostAccel * m.h);
+  }
+  const l = toward(m.l, 0, (m.drift ? m.driftGrip : m.grip) * m.h);
+  let want = m.steer * m.turnRate * Math.min(1, Math.abs(f) / m.turnSpeed);
+  if (f < 0) want = -want;
+  m.spin = toward(m.spin, want, m.spinAccel * m.h);
+  m.vx = f * m.c - l * m.s;
+  m.vy = f * m.s + l * m.c;
+  m.vz = 0;
+  m.f = f;
+  m.l = l;
+}
+function air(m) {
+  m.spin = toward(m.spin, m.steer * m.airTurnRate, m.airSpinAccel * m.h);
+  if (m.boosting) {
+    const boostTop = m.boostMaxSpeed * m.cap;
+    if (m.f < boostTop) {
+      const a = Math.min(m.boostAccel * m.h, boostTop - m.f);
+      m.vx = m.vx + a * m.c;
+      m.vy = m.vy + a * m.s;
+    }
+  }
+}
+function carSubStep(m) {
+  const was = m.onGround;
+  checkGround(m);
+  if (m.onGround && !was) m.vz = 0;
+  m.c = pcos(m.yaw);
+  m.s = psin(m.yaw);
+  m.f = m.vx * m.c + m.vy * m.s;
+  m.l = m.vy * m.c - m.vx * m.s;
+  m.boosting = m.boost && m.fuel > 0;
+  if (m.boosting) m.fuel = Math.max(0, m.fuel - m.boostBurn * m.h);
+  if (m.onGround && m.pressed) {
+    m.vz = m.jumpImpulse;
+    m.onGround = false;
+    m.pressed = false;
+  }
+  if (m.onGround) drive(m);
+  else air(m);
+  const falling = !m.onGround;
+  if (falling) m.vz -= m.gravity * m.h * 0.5;
+  m.vx = clamp(m.vx, -m.maxVelocity, m.maxVelocity);
+  m.vy = clamp(m.vy, -m.maxVelocity, m.maxVelocity);
+  m.vz = clamp(m.vz, -m.maxVelocity, m.maxVelocity);
+  m.yaw = wrap(m.yaw + m.spin * m.h);
+  if (m.onGround) {
+    groundMove(m, true);
+    stayOnGround(m);
+  } else slideMove(m, m.h);
+  checkGround(m);
+  if (falling && !m.onGround) m.vz -= m.gravity * m.h * 0.5;
+  else if (m.onGround) m.vz = 0;
+  m.x = stored(m.x);
+  m.y = stored(m.y);
+  m.z = stored(m.z);
+  m.vx = stored(m.vx);
+  m.vy = stored(m.vy);
+  m.vz = stored(m.vz);
+  m.spin = unsignedZero(Math.fround(m.spin));
+  m.fuel = unsignedZero(Math.fround(m.fuel));
+}
+function stepVehicle(body, input, dt, params, world = EMPTY_WORLD, posed = NO_POSED) {
+  const w = compiledOf(world);
+  const room = scratchFor(w);
+  const f = Math.fround;
+  const mstate = mask(body.mstate) & VEHICLE_MSTATE_BITS;
+  const height = f(params.height);
+  const steer = unsignedZero(-axis(input.moveX));
+  const throttle = axis(input.moveY);
+  const buttons = mask(input.buttons);
+  const jump = (buttons & params.jumpBit) !== 0;
+  const step = stepSeconds(dt, PRESET_MAX_DT_S);
+  const readYaw = bodyAngle(body.yaw);
+  const m = {
+    w,
+    p: posed,
+    r: f(params.radius),
+    standHeight: height,
+    crouchHeight: height,
+    stepHeight: f(params.stepHeight),
+    standable: f(params.standable),
+    groundTrace: f(params.groundTrace),
+    groundSnap: f(params.groundSnap),
+    skin: f(params.skin),
+    maxSpeed: f(params.maxSpeed),
+    accel: f(params.accel),
+    brake: f(params.brake),
+    coast: f(params.coast),
+    boostAccel: f(params.boostAccel),
+    boostMaxSpeed: f(params.boostMaxSpeed),
+    boostBurn: f(params.boostBurn),
+    grip: f(params.grip),
+    driftGrip: f(params.driftGrip),
+    turnRate: f(params.turnRate),
+    turnSpeed: f(params.turnSpeed),
+    spinAccel: f(params.spinAccel),
+    airTurnRate: f(params.airTurnRate),
+    airSpinAccel: f(params.airSpinAccel),
+    gravity: f(params.gravity),
+    jumpImpulse: f(params.jumpImpulse),
+    maxVelocity: f(params.maxVelocity),
+    x: bodyValue(body.x, 0, -MAX_ABS, MAX_ABS),
+    y: bodyValue(body.y, 0, -MAX_ABS, MAX_ABS),
+    z: bodyValue(body.z, 0, -MAX_ABS, MAX_ABS),
+    vx: bodyValue(body.vx, 0, -MAX_ABS, MAX_ABS),
+    vy: bodyValue(body.vy, 0, -MAX_ABS, MAX_ABS),
+    vz: bodyValue(body.vz, 0, -MAX_ABS, MAX_ABS),
+    yaw: Math.abs(readYaw) <= MAX_ABS ? wrap(readYaw) : 0,
+    spin: bodyValue(body.spin, 0, -1e3, 1e3),
+    fuel: bodyValue(body.fuel, 0, 0, 1),
+    cap: bodyValue(body.cap, 1, 0, 4),
+    duck: 0,
+    onGround: (mstate & MoveState.ON_GROUND) !== 0,
+    jumpHeld: (mstate & MoveState.JUMP_HELD) !== 0,
+    pressed: false,
+    boosting: false,
+    steer,
+    throttle,
+    boost: (buttons & params.boostBit) !== 0,
+    drift: (buttons & params.driftBit) !== 0,
+    h: step / params.substeps,
+    c: 1,
+    s: 0,
+    f: 0,
+    l: 0,
+    tMin: 0,
+    tMax: 0,
+    ax: -1,
+    sg: 0,
+    nx: 0,
+    ny: 0,
+    nz: 0,
+    hit: false,
+    depth: 0,
+    cand: room.cand,
+    nCand: -1,
+    pc: POSED_SCRATCH,
+    nPosed: 0,
+    stack: room.stack
+  };
+  if (step > 0) {
+    m.pressed = jump && !m.jumpHeld;
+    m.jumpHeld = jump;
+    for (let i = 0; i < params.substeps; i++) carSubStep(m);
+  }
+  return {
+    x: m.x,
+    y: m.y,
+    z: m.z,
+    vx: m.vx,
+    vy: m.vy,
+    vz: m.vz,
+    yaw: m.yaw,
+    spin: m.spin,
+    fuel: m.fuel,
+    mstate: (m.onGround ? MoveState.ON_GROUND : 0) + (m.jumpHeld ? MoveState.JUMP_HELD : 0)
+  };
+}
+var TOPDOWN_PRESET = {
+  defaults: TOPDOWN_DEFAULTS,
+  ranges: TOPDOWN_RANGE,
+  fields: ["x", "y", "yaw"],
+  reads: [],
+  world: false,
+  step: (body, input, dt, params) => stepTopdown(body, input, dt, params)
+};
+var FIRSTPERSON_PRESET = {
+  defaults: FIRSTPERSON_DEFAULTS,
+  ranges: FIRSTPERSON_RANGE,
+  fields: ["x", "y", "z", "vx", "vy", "vz", "yaw", "pitch", "duck", "mstate"],
+  reads: ["cap"],
+  world: true,
+  step: (body, input, dt, params, world, posed) => stepFirstperson(body, input, dt, params, world, posed)
+};
+var VEHICLE_PRESET = {
+  defaults: VEHICLE_DEFAULTS,
+  ranges: VEHICLE_RANGE,
+  fields: ["x", "y", "z", "vx", "vy", "vz", "yaw", "spin", "fuel", "mstate"],
+  reads: ["cap"],
+  world: true,
+  step: (body, input, dt, params, world, posed) => stepVehicle(body, input, dt, params, world, posed)
+};
+var PRESETS = Object.freeze({
+  [Preset.TOPDOWN]: Object.freeze(TOPDOWN_PRESET),
+  [Preset.FIRSTPERSON]: Object.freeze(FIRSTPERSON_PRESET),
+  [Preset.VEHICLE]: Object.freeze(VEHICLE_PRESET)
+});
+function definitionOf(name) {
+  return typeof name === "string" && Object.hasOwn(PRESETS, name) ? PRESETS[name] : void 0;
+}
+function stepPreset(name, body, input, dt, params, world, posed) {
+  const definition = definitionOf(name);
+  if (definition === void 0) throw new RangeError(`unknown preset ${String(name)}`);
+  return definition.step(body, input, dt, params, world, posed);
+}
+
+// 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_DEFAULT_CEILING = PHYSICS_DEFAULT_LIMITS;
+var isPlainObject2 = (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 (!isPlainObject2(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 fits2 = PHYSICS_PATCH_HZ.filter((hz) => hz <= patchHz && hz <= tickHz && tickHz % hz === 0);
+  return fits2.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 (!isPlainObject2(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 (!isPlainObject2(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 (!isPlainObject2(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) {
+  return {
+    contract: PHYSICS_CONTRACT,
+    dt: 1 / tickHz,
+    substeps: PHYSICS_SUBSTEPS[tickHz],
+    gravity: [0, 0, -physics.gravity],
+    upAxis: "z",
+    lengthUnit: physics.lengthUnit,
+    limits: { ...physics.limits },
+    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/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/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 topOf2(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: topOf2(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 : topOf2(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/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_PI2 = 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 KEYS2 = /* @__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_PI2 / 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, KEYS2, 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/input-config.ts
+var InputRepeat = { On: "on", Off: "off" };
+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 KEYS3 = /* @__PURE__ */ new Set(["preset", "repeat"]);
+var isPlainObject3 = (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;
+function resolveInputConfig(given, contactsPreset, path = "$.config.inputs") {
+  if (given === void 0 || given === null) return contactsPreset === null ? null : INPUT_PRESETS[contactsPreset];
+  if (!isPlainObject3(given)) throw new InputConfigError(path);
+  for (const key of Object.keys(given)) if (!KEYS3.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`);
+  const preset = given.preset ?? contactsPreset;
+  const fromPreset = preset === null ? INPUTS_DEFAULT : INPUT_PRESETS[preset];
+  return { repeat: given.repeat ?? fromPreset.repeat };
+}
+function presetInputRepeat(presetText) {
+  let spec;
+  try {
+    spec = JSON.parse(presetText);
+  } catch {
+    return InputRepeat.On;
+  }
+  const inputs = isPlainObject3(spec) ? spec.inputs : void 0;
+  return isPlainObject3(inputs) && inputs.repeat === InputRepeat.Off ? InputRepeat.Off : InputRepeat.On;
+}
+
+// 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"
+};
+var AuthorityLimits = {
+  /** Entities one tick may update, and separately remove. */
+  MAX_ENTITIES: 256,
+  /** 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,
+  /** `__genex_world()`'s text: base64 of the largest §17.7 world, 4 · ⌈(8 + 24 · 4096 + 36 · 512) / 3⌉. */
+  MAX_WORLD_TEXT_CHARS: 155660
+};
+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",
+  /** 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 integerIn2(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 = integerIn2(v.flags, MASK_LIMIT - 1, `${path}.flags`);
+  if (v.epoch !== void 0) out.epoch = integerIn2(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 = integerIn2(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);
+  return {
+    tickHz,
+    maxPlayers,
+    preset,
+    lagComp,
+    physics: physics.value,
+    ...contacts === null ? {} : { contacts },
+    ...inputs === null ? {} : { inputs },
+    ...lifts === null ? {} : { lifts }
+  };
+}
+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 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);
+      return { ...out, config: configOf(value2.config, physics) };
+    },
+    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 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"
+};
+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 < 1 || 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[u.window.length - 1].seq, 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];
+  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: view.getUint32(14, true), 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 newest = u.window[u.window.length - 1].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;
+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);
+  const out = new Uint8Array(size);
+  const view = new DataView(out.buffer);
+  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;
+}
+
+export {
+  unsignedZero,
+  psincos,
+  psin,
+  pcos,
+  Preset,
+  PRESET_MAX_DT_S,
+  TOPDOWN_DEFAULTS,
+  isPresetName,
+  presetParamsValid,
+  resolvePresetParams,
+  resolveTopdownParams,
+  stepTopdown,
+  EMPTY_WORLD_HASH,
+  FIRSTPERSON_DEFAULTS,
+  resolveFirstpersonParams,
+  MoveState,
+  WorldLimits,
+  WorldError,
+  firstpersonWorld,
+  EMPTY_WORLD,
+  POSED_MAX,
+  posedWorld,
+  NO_POSED,
+  hullOps,
+  stepFirstperson,
+  VEHICLE_DEFAULTS,
+  resolveVehicleParams,
+  stepVehicle,
+  PRESETS,
+  definitionOf,
+  stepPreset,
+  PHYSICS_CONTRACT,
+  PHYSICS_DEFAULT_LIMITS,
+  PHYSICS_LIMIT_NAMES,
+  PHYSICS_SCALED_LIMITS,
+  PHYSICS_REAL_LIMITS,
+  PHYSICS_CEILING_FACTOR,
+  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_PRESETS,
+  INPUTS_DEFAULT,
+  InputConfigError,
+  resolveInputConfig,
+  presetInputRepeat,
+  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,
+  FastMessage,
+  FastKind,
+  FastFault,
+  AcceptKind,
+  inputRedundancyTicks,
+  uplinkMaxBytes,
+  gapFillMax,
+  seqAheadMax,
+  toHex,
+  fromHex,
+  isPress,
+  encodeUplink,
+  decodeUplink,
+  renderStamp,
+  uplinkFor,
+  acceptUplink,
+  diffSnapshot,
+  deltaBase,
+  encodeSnapshot,
+  decodeFragment,
+  parseBody,
+  applyBody,
+  emptyClientRx,
+  receiveFragment
+};