@genex-ai/multiplayer 0.17.6 → 0.17.8

package/dist/chunk-2NGXXQDS.js

@@ -0,0 +1,1916 @@
+// 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,
+  airDuck: 1,
+  stepHeight: 18,
+  standable: 0.7,
+  groundTrace: 2.5,
+  groundSnap: 1,
+  skin: 0.03,
+  pitchLimit: 1.5533430576324463,
+  jumpBit: 1,
+  duckBit: 2,
+  walkBit: 4,
+  substeps: 2,
+  capZeroJump: 1,
+  runBit: 0,
+  jogSpeed: 1,
+  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),
+  airDuck: integerIn(0, 1),
+  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),
+  capZeroJump: integerIn(0, 1),
+  runBit: integerIn(0, MASK_LIMIT - 1),
+  jogSpeed: inRange(0, 1),
+  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: 32768,
+  MAX_RAMPS: 4096,
+  /** 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 caps = options.caps ?? WorldLimits;
+  const boxes = solidList(spec.boxes, "boxes", caps.MAX_BOXES).map(
+    (box, i) => Object.freeze(solidValues(box, 6, `boxes[${i}]`))
+  );
+  const ramps = solidList(spec.ramps, "ramps", caps.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;
+var TREE_KEY_RADIX = 2 ** 23;
+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 leafOrder(n, t) {
+  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) * TREE_KEY_RADIX + i;
+  }
+  keys.sort();
+  const order = new Int32Array(n);
+  for (let k = 0; k < n; k++) order[k] = keys[k] % TREE_KEY_RADIX;
+  return order;
+}
+function worldTreeOrder(solids) {
+  const table = (k) => Float64Array.from(solids, (s) => s[k]);
+  return leafOrder(solids.length, { minX: table(0), minY: table(1), minZ: table(2), maxX: table(3), maxY: table(4), maxZ: table(5) });
+}
+function buildTree(t) {
+  const n = t.count;
+  const order = leafOrder(n, t);
+  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 = order[k];
+    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 FIRSTPERSON_RADIUS = 16;
+var VEHICLE_RADIUS = 50;
+var OTHER_UNITS = 0.5;
+var unitOf = (radius, defaultRadius) => radius / defaultRadius < OTHER_UNITS ? radius / defaultRadius : 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));
+var costMeter = null;
+function withWorldCostMeter(meter, run) {
+  costMeter = meter;
+  try {
+    return run();
+  } finally {
+    costMeter = null;
+  }
+}
+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;
+  let walked = 0;
+  stack[top++] = tree.root;
+  while (top > 0) {
+    const node = stack[--top];
+    walked += 1;
+    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;
+  if (costMeter !== null) {
+    costMeter.nodes += walked;
+    costMeter.tests += 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.unit) {
+    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 worldCount = m.w.count;
+  const tree = m.w.tree;
+  let walked = 0;
+  let tested = 0;
+  const witness = (j) => {
+    tested += 1;
+    return j !== self && insideSolid(m, qx, qy, qz, j, height) && !insideSolid(m, px, py, pz, j, height);
+  };
+  let found = false;
+  if (tree === null) {
+    for (let j = 0; j < worldCount && !found; j++) found = witness(j);
+  } else {
+    const margin = queryMargin(qx, qy, qz, qx, qy, qz + height);
+    const pad = m.r + margin;
+    const x0 = qx - pad, x1 = qx + pad, y0 = qy - pad, y1 = qy + pad, z0 = qz - margin, z1 = qz + height + margin;
+    const { boxes, ref, levelEnd } = tree;
+    const count = levelEnd[0];
+    const stack = m.stack;
+    let top = 0;
+    stack[top++] = tree.root;
+    while (top > 0 && !found) {
+      const node = stack[--top];
+      walked += 1;
+      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) {
+        found = witness(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;
+    }
+  }
+  for (let j = worldCount; !found && j < worldCount + m.p.count; j++) found = witness(j);
+  if (costMeter !== null) {
+    costMeter.nodes += walked;
+    costMeter.tests += tested;
+  }
+  return found;
+}
+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;
+  if (costMeter !== null) costMeter.sweeps += n;
+  for (let k = 0; k < n; k++) {
+    const i = solidAt(m, k);
+    if (costMeter !== null && i >= w.boxCount && i < w.count) costMeter.wedges += 1;
+    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.unit * m.unit) {
+      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.unit) {
+    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 && !m.onGround && !m.airDuck) {
+  } else 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.jogging ? m.base * m.jogSpeed : 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),
+      unit: unitOf(f(params.radius), preset === "vehicle" ? VEHICLE_RADIUS : FIRSTPERSON_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 * m.unit) 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),
+    jogSpeed: f(params.jogSpeed),
+    jogging: false,
+    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),
+    unit: unitOf(f(params.radius), FIRSTPERSON_RADIUS),
+    standHeight: f(params.standHeight),
+    crouchHeight: f(params.crouchHeight),
+    duckTime: f(params.duckTime),
+    airDuck: params.airDuck !== 0,
+    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;
+  m.jogging = params.runBit !== 0 && (buttons & params.runBit) === 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 && (params.capZeroJump !== 0 || m.cap !== 0);
+    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,
+  capZeroJump: 1,
+  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),
+  capZeroJump: integerIn(0, 1),
+  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),
+    unit: unitOf(f(params.radius), VEHICLE_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 && (params.capZeroJump !== 0 || m.cap !== 0);
+    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);
+}
+
+export {
+  MAX_ABS,
+  MASK_LIMIT,
+  unsignedZero,
+  axis,
+  wrappedAngle,
+  mask,
+  isMask,
+  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,
+  TREE_KEY_RADIX,
+  worldTreeOrder,
+  withWorldCostMeter,
+  hullOps,
+  stepFirstperson,
+  VEHICLE_DEFAULTS,
+  resolveVehicleParams,
+  stepVehicle,
+  PRESETS,
+  definitionOf,
+  stepPreset
+};