@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-22BD3RHN.mjs

@@ -0,0 +1,1809 @@
+import { FLOW_DELIVERED, FLOW_BACKLOG } from './chunk-5BYDGGWO.mjs';
+import { settleDoubleFields } from './chunk-XPG3N5CF.mjs';
+import { SOFT_COLLIDER_FLOATS, SOFT_MAX_COLLIDERS, CLOTH_COLLIDER_FLOATS, CLOTH_MAX_COLLIDERS, SOFT_STRETCH, SOFT_BEND, SOFT_VOLUME, SOFT_DAMPING, SOFT_GRAVITY, SOFT_SUBSTEPS, SOFT_RADIUS, SOFT_FRICTION, SOFT_CONTRACTION, SOFT_YIELD, SOFT_CREEP, SOFT_LIMIT, SOFT_FIBRE, SOFT_COLLIDER_PLANE, SOFT_COLLIDER_SPHERE, SOFT_COLLIDER_CAPSULE, SOFT_COLLIDER_BOX, CLOTH_MASS, CLOTH_STRETCH, CLOTH_BEND, CLOTH_TETHER_SLACK, CLOTH_DAMPING, CLOTH_GRAVITY, CLOTH_SUBSTEPS, CLOTH_THICKNESS, CLOTH_FRICTION, CLOTH_COLUMNS, CLOTH_ROWS, CLOTH_SPACING, CLOTH_ORIGIN, CLOTH_ACROSS, CLOTH_DOWN, CLOTH_PIN_TOP_CORNERS, CLOTH_PIN_TOP_ROW, CLOTH_PIN_NONE, CLOTH_PIN, CLOTH_COLLIDER_SPHERE, CLOTH_COLLIDER_CAPSULE, CRUMPLE_DESC_FLOATS } from './chunk-5YFBGGCK.mjs';
+import { KernelVm, parseProgram } from './chunk-MOBSBXVE.mjs';
+import { ACCESS_ARRAY } from './chunk-SMK6JU2F.mjs';
+import { prefetchDepth } from './chunk-K46SMZ66.mjs';
+import { ChunkPriority } from './chunk-V7ZRH3PY.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/random.ts
+var LITTLE_ENDIAN = new Uint8Array(Uint16Array.of(1).buffer)[0] === 1, HALF_INDEX = LITTLE_ENDIAN ? Int32Array.of(0, 1, 2, 3) : Int32Array.of(3, 2, 1, 0), CENTERED_MAX_EXTENT = 16384, CENTERED_FIXED_UNITS = 256;
+function add32(a, b) {
+  let lo = (a & 65535) + (b & 65535);
+  return (a >>> 16) + (b >>> 16) + (lo >>> 16) << 16 | lo & 65535;
+}
+var SeededRandom = class {
+  constructor(seed) {
+    this.state = new Uint32Array(4);
+    this.output = new Uint32Array(2);
+    this.words = new Int32Array(this.state.buffer);
+    this.drawn = new Int32Array(this.output.buffer);
+    this.limbs = new Int32Array(7);
+    this.cell = new Float64Array(1);
+    this.halves = new Uint16Array(this.cell.buffer);
+    this.views = [this.state, this.output];
+    this.reseed(seed);
+  }
+  rollbackViews() {
+    return this.views;
+  }
+  get seed() {
+    return this.output[1];
+  }
+  reseed(seed) {
+    this.output[1] = seed;
+    let s = this.output[1];
+    for (let i = 0; i < 4; i++) {
+      s = s + 2654435769 >>> 0;
+      let z = s;
+      z = Math.imul(z ^ z >>> 16, 2246822507), z = Math.imul(z ^ z >>> 13, 3266489909), this.state[i] = (z ^ z >>> 16) >>> 0;
+    }
+    for (let i = 0; i < 12; i++) this.advance();
+  }
+  nextUint32() {
+    return this.advance(), this.output[0];
+  }
+  float() {
+    return this.advance(), this.output[0] / 4294967296;
+  }
+  range(min, max) {
+    return this.advance(), min + (max - min) * (this.output[0] / 4294967296);
+  }
+  rangeInto(out, slot, min, max) {
+    this.advance(), out[slot] = min + (max - min) * (this.output[0] / 4294967296);
+  }
+  int(min, maxInclusive) {
+    return this.advance(), min + (this.output[0] / 4294967296 * (maxInclusive - min + 1) | 0);
+  }
+  chance(probability) {
+    return this.advance(), this.output[0] / 4294967296 < probability;
+  }
+  centeredInto(out, slot, halfExtent, fixed, fixedAt) {
+    this.advance();
+    let s = this.drawn[0] ^ -2147483648, sign = s >>> 31, m = sign === 1 ? ~s : s, al = (m & 65535) + sign, ah = m >>> 16;
+    al > 65535 && (al = 0, ah++);
+    let lo = halfExtent * al, hi = halfExtent * ah;
+    hi += lo >>> 16, lo &= 65535;
+    let units = hi >>> 7;
+    if (fixed[fixedAt] = (units ^ -sign) + sign, hi === 0 && lo === 0) {
+      out[slot] = 0;
+      return;
+    }
+    let top = hi !== 0 ? 47 - Math.clz32(hi) : 31 - Math.clz32(lo), limbs = this.limbs;
+    limbs[0] = lo, limbs[1] = hi & 65535, limbs[2] = hi >>> 16, limbs[top >> 4] &= ~(1 << (top & 15)), limbs[3] = 0, limbs[4] = 0, limbs[5] = 0, limbs[6] = 0;
+    let shift = 52 - top;
+    for (let i = 0; i < 3; i++) {
+      let v = limbs[i];
+      if (v === 0) continue;
+      let at = i * 16 + shift, q = at >> 4, r = at & 15;
+      limbs[3 + q] |= (v & 65535 >>> r) << r, r > 0 && q + 1 < 4 && (limbs[3 + q + 1] |= v >>> 16 - r);
+    }
+    let halves = this.halves, high = sign << 15 | top + 992 << 4 | limbs[6] & 15;
+    halves[HALF_INDEX[0]] = limbs[3], halves[HALF_INDEX[1]] = limbs[4], halves[HALF_INDEX[2]] = limbs[5], halves[HALF_INDEX[3]] = high, out.set(this.cell, slot);
+  }
+  advance() {
+    let st = this.words, a = st[0], b = st[1], c = st[2], d = st[3], t = add32(add32(a, b), d);
+    st[3] = add32(d, 1), st[0] = b ^ b >>> 9, st[1] = add32(c, c << 3);
+    let rotated = c << 21 | c >>> 11;
+    st[2] = add32(rotated, t), this.drawn[0] = t;
+  }
+  saveState(out) {
+    out.set(this.state);
+  }
+  restoreState(source) {
+    this.state.set(source);
+  }
+};
+
+// src/game/kernel/loops.ts
+var LOOP_MAX_REGION_ROWS = 65536, STORAGE = { f32: 0, i32: 1, u32: 2, u8: 3, f64: 4 }, STORAGE_F64_HI = 5, BYTES = { f32: 4, i32: 4, u32: 4, u8: 1, f64: 8 }, WORD = 4, ALIGN = 8, DESCRIPTOR_WORDS = 2, MIN_CAPACITY = 256, MAX_INDEX = 2147483647, TRIAL_RUNS = 4, TRIAL_MS = 2, TRIAL_LIMIT = 48, NS_PER_MS = 1e6, BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", PHASE_TRIAL = 0, PHASE_KERNEL = 1, PHASE_JS = 2, NO_PROGRAM = -1, FAILED = -2, FIELD = /^([ar])(\d+)$/, TABLE_FIELD = /^%tb(\d+)$/, TABLE_ARG = /^tb(\d+)$/, SCALAR_ARG = /^s(\d+)$/, ROW_ARG = "__base", settings = { schedule: "auto", chunkRows: (65536), enabled: true }, engine = null, generation = 0;
+function clock() {
+  let perf = globalThis.performance;
+  return perf === void 0 ? Date.now() : perf.now();
+}
+function decode(text) {
+  let end = text.length;
+  for (; end > 0 && text[end - 1] === "="; ) end--;
+  let out = new Uint8Array(Math.floor(end * 3 / 4)), bits = 0, value = 0, at = 0;
+  for (let k = 0; k < end; k++) {
+    let digit = BASE64.indexOf(text[k]);
+    if (digit < 0) throw new GameError("invalid_argument", "a lowered loop carries invalid base64");
+    value = (value << 6 | digit) & 16777215, bits += 6, bits >= 8 && (bits -= 8, out[at++] = value >> bits & 255);
+  }
+  return out.subarray(0, at);
+}
+function matches(kind, value) {
+  switch (kind) {
+    case "f32":
+      return value instanceof Float32Array;
+    case "f64":
+      return value instanceof Float64Array;
+    case "i32":
+      return value instanceof Int32Array;
+    case "u32":
+      return value instanceof Uint32Array;
+    case "u8":
+      return value instanceof Uint8Array;
+  }
+}
+function view(kind, buffer, at, rows) {
+  switch (kind) {
+    case "f32":
+      return new Float32Array(buffer, at, rows);
+    case "f64":
+      return new Float64Array(buffer, at, rows);
+    case "i32":
+      return new Int32Array(buffer, at, rows);
+    case "u32":
+      return new Uint32Array(buffer, at, rows);
+    case "u8":
+      return new Uint8Array(buffer, at, rows);
+  }
+}
+function setLoopEngine(next) {
+  next !== engine && (engine = next, generation++);
+}
+function loopEngineOf(kernels) {
+  if (kernels === null) return null;
+  let runRegion = kernels.runRegion;
+  if (typeof runRegion != "function") return null;
+  let exports = kernels.exports;
+  return {
+    memory: kernels.memory,
+    alloc: (bytes, align) => exports.engine_alloc(bytes, align),
+    free: (at, bytes, align) => {
+      exports.engine_free(at, bytes, align);
+    },
+    load: (at, bytes) => exports.engine_kernel_load(at, bytes),
+    unload: (program) => {
+      exports.engine_kernel_unload(program);
+    },
+    runRegion
+  };
+}
+function configureLoops(next) {
+  if (next.schedule !== void 0 && (settings.schedule = next.schedule), next.enabled !== void 0 && (settings.enabled = next.enabled), next.chunkRows !== void 0) {
+    if (!Number.isInteger(next.chunkRows) || next.chunkRows < 1 || next.chunkRows > (65536)) throw new GameError("invalid_argument", `chunkRows must be 1..${(65536)}`);
+    settings.chunkRows = next.chunkRows;
+  }
+}
+function vmLoopEngine(arenaBytes = 1 << 24) {
+  let buffer = new ArrayBuffer(arenaBytes), programs = [], machines = [], capacity = [], top = 64;
+  return {
+    memory: { buffer },
+    alloc: (bytes, align) => {
+      if (top = Math.ceil(top / align) * align, top + bytes > arenaBytes) return 0;
+      let at = top;
+      return top += Math.max(bytes, 1), at;
+    },
+    free: () => {
+    },
+    load: (at, bytes) => {
+      try {
+        programs.push(parseProgram(new Uint8Array(buffer, at, bytes).slice()));
+      } catch {
+        return -4;
+      }
+      return machines.push(null), capacity.push(0), programs.length - 1;
+    },
+    runRegion: (program, columns, rows, count, args, argWords) => {
+      let parsed = programs[program];
+      if (parsed === void 0) return -3;
+      let descriptor = new Uint32Array(buffer, columns, parsed.slots.length * (2)), halves = [], views = parsed.slots.map((_, s) => {
+        let at = descriptor[s * (2)], storage = descriptor[s * (2) + 1];
+        if (storage === STORAGE.f64 || storage === (5)) {
+          let words = new Uint32Array(buffer, at, rows * 2), high = storage === (5) ? 1 : 0, column = new Uint32Array(rows);
+          for (let r = 0; r < rows; r++) column[r] = words[2 * r + high];
+          return halves.push({ words, column, high }), { values: column, storage: STORAGE.u32 };
+        }
+        let whole = ((parsed.slots[s].word ?? 0) & ACCESS_ARRAY) !== 0, span = (bytes) => whole ? Math.floor((buffer.byteLength - at) / bytes) : rows;
+        return { values: storage === STORAGE.u8 ? new Uint8Array(buffer, at, span(1)) : storage === STORAGE.i32 ? new Int32Array(buffer, at, span((4))) : storage === STORAGE.u32 ? new Uint32Array(buffer, at, span((4))) : new Float32Array(buffer, at, span((4))), storage };
+      });
+      (machines[program] === null || capacity[program] < rows) && (machines[program] = new KernelVm(parsed, rows), capacity[program] = rows), machines[program].run(views, count, null, new Uint32Array(buffer, args, argWords));
+      for (let { words, column, high } of halves) for (let r = 0; r < count; r++) words[2 * r + high] = column[r];
+      return count;
+    }
+  };
+}
+var LoweredLoop = class {
+  constructor(payload) {
+    this.columns = [];
+    this.argHalves = new Float64Array(1);
+    this.argView = new Uint32Array(this.argHalves.buffer);
+    this.program = (-1);
+    this.owner = null;
+    this.ownerGeneration = -1;
+    this.arena = null;
+    this.capacity = 0;
+    this.descriptorAt = 0;
+    this.argsAt = 0;
+    this.descriptor = new Uint32Array(0);
+    this.argsView = new Uint32Array(0);
+    this.stamps = new Uint32Array(0);
+    this.stamp = 0;
+    this.phase = (0);
+    this.pending = false;
+    this.pendingAt = 0;
+    this.pendingRows = 0;
+    this.kernelMs = 0;
+    this.kernelRows = 0;
+    this.kernelRuns = 0;
+    this.jsMs = 0;
+    this.jsRows = 0;
+    this.jsRuns = 0;
+    this.payload = payload, this.a = new Array(payload.bindings).fill(null), this.s = new Float64Array(Math.max(payload.scalars, 1)), this.o = new Float64Array(Math.max(payload.offsets, 1)), this.g = new Array(payload.gathers).fill(null), this.r = new Float64Array(Math.max(payload.folds.length, 1));
+    let slots = payload.meta.slots;
+    this.slotColumn = new Int32Array(slots.length), this.slotStorage = new Uint32Array(slots.length), this.reductionColumn = new Int32Array(payload.folds.length).fill(-1);
+    let byName = /* @__PURE__ */ new Map(), tables = payload.tables ?? [];
+    this.slotTable = new Int32Array(slots.length).fill(-1), this.tableAt = new Int32Array(tables.length), this.tableBytes = new Float64Array(tables.length), slots.forEach((slot, k) => {
+      let table = TABLE_FIELD.exec(slot.field);
+      if (table !== null) {
+        let t = Number(table[1]);
+        if (t >= tables.length) throw new GameError("invalid_argument", `a lowered loop binds unknown table ${slot.field}`);
+        this.slotTable[k] = t, this.slotColumn[k] = -1;
+        return;
+      }
+      let m = FIELD.exec(slot.field);
+      if (m === null) throw new GameError("invalid_argument", `a lowered loop binds unknown column ${slot.field}`);
+      let index = Number(m[2]), reduction = m[1] === "r", kind = reduction ? "f64" : payload.fields[index]?.kind ?? "f32";
+      if (!reduction && payload.fields[index] === void 0) throw new GameError("invalid_argument", `a lowered loop binds unknown column ${slot.field}`);
+      let column = byName.get(slot.field);
+      column === void 0 && (column = this.columns.length, byName.set(slot.field, column), this.columns.push({ field: reduction ? -1 - index : index, kind, bytes: BYTES[kind] }), reduction && (this.reductionColumn[index] = column)), this.slotColumn[k] = column, this.slotStorage[k] = kind === "f64" ? slot.component === 1 ? (5) : STORAGE.f64 : STORAGE[kind];
+    }), this.argWords = new Uint32Array(Math.max(payload.meta.argWords, 1)), this.argScalar = new Int32Array(payload.meta.args.length).fill(-1), this.argTable = new Int32Array(payload.meta.args.length).fill(-1), payload.meta.args.forEach((arg, k) => {
+      let m = SCALAR_ARG.exec(arg.name), t = TABLE_ARG.exec(arg.name);
+      if (m !== null && arg.kind === "f64") this.argScalar[k] = Number(m[1]);
+      else if (t !== null && arg.kind === "u32" && Number(t[1]) < tables.length) this.argTable[k] = Number(t[1]);
+      else if (arg.name !== ROW_ARG || arg.kind !== "i32") throw new GameError("invalid_argument", `a lowered loop takes an unknown argument ${arg.name}`);
+    });
+    let n = this.columns.length;
+    this.columnAt = new Int32Array(n), this.columnViews = new Array(n).fill(null), this.sources = new Array(n).fill(null), this.sourceArray = new Array(n).fill(null), this.sourceStart = new Float64Array(n), this.sourceRows = new Float64Array(n), this.targets = new Array(n).fill(null), this.targetRows = new Float64Array(n);
+  }
+  get stats() {
+    return {
+      kernelRuns: this.kernelRuns,
+      jsRuns: this.jsRuns,
+      decided: this.phase === (1) ? "kernel" : this.phase === (2) ? "js" : "trial",
+      kernelNsPerRow: this.kernelRows === 0 ? 0 : this.kernelMs * (1e6) / this.kernelRows,
+      jsNsPerRow: this.jsRows === 0 ? 0 : this.jsMs * (1e6) / this.jsRows
+    };
+  }
+  run(n) {
+    if (this.pending = false, !settings.enabled || settings.schedule === "js" || !Number.isInteger(n) || n < 0 || n > (2147483647)) return false;
+    let auto = settings.schedule === "auto";
+    if (auto && n < this.payload.minRows) return false;
+    let target = engine;
+    if (target === null || !this.attach(target) || !this.admissible(n)) return false;
+    if (auto && this.phase !== (1)) {
+      if (this.phase === (2)) return false;
+      if ((this.kernelRuns + this.jsRuns) % 2 === 1)
+        return this.pending = true, this.pendingRows = n, this.pendingAt = clock(), false;
+    }
+    let started = auto ? clock() : 0;
+    return this.execute(target, n), this.kernelRuns++, auto && this.phase === (0) && (this.kernelMs += clock() - started, this.kernelRows += n, this.decide()), true;
+  }
+  after() {
+    this.pending && (this.pending = false, this.jsMs += clock() - this.pendingAt, this.jsRows += this.pendingRows, this.jsRuns++, this.decide());
+  }
+  decide() {
+    let enough = (runs, ms) => runs >= (4) && ms >= (2);
+    if (!(enough(this.kernelRuns, this.kernelMs) && enough(this.jsRuns, this.jsMs) || this.kernelRuns + this.jsRuns >= (48))) return;
+    let kernel = this.kernelRows === 0 ? 1 / 0 : this.kernelMs / this.kernelRows, js = this.jsRows === 0 ? 1 / 0 : this.jsMs / this.jsRows;
+    this.phase = kernel <= js ? (1) : (2);
+  }
+  release() {
+    this.detach(), this.a.fill(null), this.g.fill(null);
+  }
+  detach() {
+    let owner = this.owner;
+    if (owner !== null && this.program >= 0) {
+      for (let c = 0; c < this.columns.length && this.capacity > 0; c++) owner.free(this.columnAt[c], this.capacity * this.columns[c].bytes, (8));
+      owner.free(this.descriptorAt, Math.max(this.payload.meta.slots.length * (2) * (4), (4)), (8)), owner.free(this.argsAt, Math.max(this.argWords.length * (4), (4)), (8));
+      for (let t = 0; t < this.tableBytes.length; t++) this.tableBytes[t] > 0 && owner.free(this.tableAt[t], this.tableBytes[t], (8));
+      owner.unload?.(this.program);
+    }
+    this.owner = null, this.ownerGeneration = -1, this.program = (-1), this.capacity = 0, this.arena = null, this.tableBytes.fill(0);
+  }
+  attach(target) {
+    if (this.owner === target && this.ownerGeneration === generation) return this.program >= 0;
+    this.owner !== null && this.program >= 0 && this.detach(), this.owner = target, this.ownerGeneration = generation, this.program = (-2), this.capacity = 0, this.arena = null;
+    let bytes = decode(this.payload.program), at = target.alloc(Math.max(bytes.byteLength, (4)), (4));
+    if (at === 0) return false;
+    new Uint8Array(target.memory.buffer, at, bytes.byteLength).set(bytes);
+    let id = -1;
+    try {
+      id = target.load(at, bytes.byteLength);
+    } catch {
+      id = -1;
+    }
+    if (target.free(at, Math.max(bytes.byteLength, (4)), (4)), id < 0) return false;
+    let descriptorBytes = Math.max(this.payload.meta.slots.length * (2) * (4), (4));
+    return this.descriptorAt = target.alloc(descriptorBytes, (8)), this.argsAt = target.alloc(Math.max(this.argWords.length * (4), (4)), (8)), this.descriptorAt === 0 || this.argsAt === 0 ? false : (this.program = id, true);
+  }
+  admissible(n) {
+    for (let t of this.payload.tables ?? []) if (!matches(t.kind, this.a[t.bind])) return false;
+    let fields = this.payload.fields;
+    for (let k = 0; k < fields.length; k++) {
+      let f = fields[k], array = this.a[f.bind];
+      if (!matches(f.kind, array)) return false;
+      if (f.gather >= 0) {
+        let rows = this.g[f.gather];
+        if (!(rows instanceof Int32Array || rows instanceof Uint32Array) || rows.length < n) return false;
+        let limit = array.length;
+        for (let i = 0; i < n; i++) {
+          let r = rows[i];
+          if (r < 0 || r >= limit) return false;
+        }
+        if (f.write && !this.distinct(rows, n, limit)) return false;
+      } else {
+        let off = f.offset >= 0 ? this.o[f.offset] : 0;
+        if (!Number.isInteger(off) || off < 0 || off + n > array.length) return false;
+      }
+    }
+    for (let j = 0; j < fields.length; j++)
+      if (fields[j].write) {
+        for (let k = 0; k < fields.length; k++)
+          if (k !== j && this.overlaps(j, k, n))
+            return false;
+      }
+    return true;
+  }
+  distinct(rows, n, limit) {
+    this.stamps.length < limit && (this.stamps = new Uint32Array(Math.max(limit, this.stamps.length * 2)), this.stamp = 0), this.stamp++, this.stamp === 4294967295 && (this.stamps.fill(0), this.stamp = 1);
+    let stamps = this.stamps, mark = this.stamp;
+    for (let i = 0; i < n; i++) {
+      let r = rows[i];
+      if (stamps[r] === mark) return false;
+      stamps[r] = mark;
+    }
+    return true;
+  }
+  overlaps(j, k, n) {
+    let fields = this.payload.fields, x = this.a[fields[j].bind], y = this.a[fields[k].bind];
+    return x.buffer !== y.buffer || fields[j].bind === fields[k].bind && fields[j].gather === fields[k].gather && fields[j].offset === fields[k].offset ? false : this.spanStart(j, x) < this.spanEnd(k, y, n) && this.spanStart(k, y) < this.spanEnd(j, x, n);
+  }
+  spanStart(k, array) {
+    let f = this.payload.fields[k];
+    return f.gather >= 0 ? array.byteOffset : array.byteOffset + (f.offset >= 0 ? this.o[f.offset] : 0) * array.BYTES_PER_ELEMENT;
+  }
+  spanEnd(k, array, n) {
+    let f = this.payload.fields[k];
+    return f.gather >= 0 ? array.byteOffset + array.byteLength : array.byteOffset + ((f.offset >= 0 ? this.o[f.offset] : 0) + n) * array.BYTES_PER_ELEMENT;
+  }
+  stageTables(target) {
+    let tables = this.payload.tables ?? [];
+    for (let t = 0; t < tables.length; t++) {
+      let array = this.a[tables[t].bind], bytes = Math.max(array.byteLength, (4));
+      if (this.tableBytes[t] < bytes) {
+        this.tableBytes[t] > 0 && target.free(this.tableAt[t], this.tableBytes[t], (8));
+        let at = target.alloc(bytes, (8));
+        if (at === 0)
+          return this.tableBytes[t] = 0, false;
+        this.tableAt[t] = at, this.tableBytes[t] = bytes;
+      }
+      new Uint8Array(target.memory.buffer, this.tableAt[t], array.byteLength).set(new Uint8Array(array.buffer, array.byteOffset, array.byteLength));
+    }
+    return true;
+  }
+  execute(target, n) {
+    let chunk = Math.min(settings.chunkRows, (65536));
+    if (!this.stageTables(target)) throw new GameError("invalid_argument", "the engine has no room for a lowered loop's lookup tables");
+    this.reserve(target, Math.min(n, chunk));
+    let folds = this.payload.folds, r = this.r;
+    for (let base = 0; base < n; base += chunk) {
+      let m = Math.min(chunk, n - base);
+      this.prepare(target, base, m);
+      let code = target.runRegion(this.program, this.descriptorAt, m, m, this.argsAt, this.payload.meta.argWords);
+      if (code < 0)
+        throw base === 0 ? new GameError("invalid_argument", `the engine refused a lowered loop (${code})`) : new GameError("invalid_argument", `the engine refused a lowered loop part way (${code})`);
+      this.finish(base, m);
+      for (let k = 0; k < folds.length; k++) {
+        let values = this.columnViews[this.reductionColumn[k]], acc = r[k];
+        switch (folds[k]) {
+          case "+":
+            for (let i = 0; i < m; i++) acc = acc + values[i];
+            break;
+          case "-":
+            for (let i = 0; i < m; i++) acc = acc - values[i];
+            break;
+          case "*":
+            for (let i = 0; i < m; i++) acc = acc * values[i];
+            break;
+          case "/":
+            for (let i = 0; i < m; i++) acc = acc / values[i];
+            break;
+          case "min":
+            for (let i = 0; i < m; i++) acc = Math.min(acc, values[i]);
+            break;
+          case "max":
+            for (let i = 0; i < m; i++) acc = Math.max(acc, values[i]);
+            break;
+        }
+        r[k] = acc;
+      }
+    }
+  }
+  inPlace(column, buffer) {
+    if (column.field < 0) return null;
+    let f = this.payload.fields[column.field];
+    if (f.gather >= 0) return null;
+    let array = this.a[f.bind];
+    return array.buffer === buffer ? array : null;
+  }
+  reserve(target, rows) {
+    let buffer = target.memory.buffer;
+    if (rows > this.capacity) {
+      let next = Math.max((256), this.capacity);
+      for (; next < rows; ) next *= 2;
+      next = Math.min(next, (65536));
+      for (let c = 0; c < this.columns.length; c++) {
+        let bytes = this.columns[c].bytes;
+        this.capacity > 0 && target.free(this.columnAt[c], this.capacity * bytes, (8));
+        let at = target.alloc(next * bytes, (8));
+        if (at === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold a lowered loop's columns");
+        this.columnAt[c] = at;
+      }
+      this.capacity = next, this.arena = null;
+    }
+    if (target.memory.buffer !== this.arena) {
+      this.arena = target.memory.buffer;
+      for (let c = 0; c < this.columns.length; c++)
+        this.columnViews[c] = view(this.columns[c].kind, buffer, this.columnAt[c], this.capacity), this.targets[c] = null, this.sources[c] = null;
+      this.descriptor = new Uint32Array(buffer, this.descriptorAt, Math.max(this.payload.meta.slots.length * (2), 1)), this.argsView = new Uint32Array(buffer, this.argsAt, this.argWords.length);
+    }
+  }
+  source(c, array, start, rows) {
+    let cached = this.sources[c];
+    if (cached !== null && this.sourceArray[c] === array && this.sourceStart[c] === start && this.sourceRows[c] === rows) return cached;
+    let made = array.subarray(start, start + rows);
+    return this.sources[c] = made, this.sourceArray[c] = array, this.sourceStart[c] = start, this.sourceRows[c] = rows, made;
+  }
+  target(c, rows) {
+    let cached = this.targets[c];
+    if (cached !== null && this.targetRows[c] === rows) return cached;
+    let made = this.columnViews[c].subarray(0, rows);
+    return this.targets[c] = made, this.targetRows[c] = rows, made;
+  }
+  prepare(target, base, m) {
+    let buffer = target.memory.buffer, fields = this.payload.fields, address = this.columnAt;
+    for (let c = 0; c < this.columns.length; c++) {
+      let column = this.columns[c];
+      if (column.field < 0) continue;
+      let f = fields[column.field], array = this.a[f.bind];
+      if (this.inPlace(column, buffer) !== null) continue;
+      let values = this.columnViews[c];
+      if (f.gather >= 0) {
+        let rows = this.g[f.gather];
+        for (let i = 0; i < m; i++) values[i] = array[rows[base + i]];
+      } else {
+        let off = f.offset >= 0 ? this.o[f.offset] : 0;
+        values.set(this.source(c, array, off + base, m));
+      }
+    }
+    let descriptor = this.descriptor;
+    for (let s = 0; s < this.slotColumn.length; s++) {
+      let table = this.slotTable[s];
+      if (table >= 0) {
+        descriptor[s * (2)] = this.tableAt[table], descriptor[s * (2) + 1] = STORAGE[this.payload.tables[table].kind];
+        continue;
+      }
+      let c = this.slotColumn[s], column = this.columns[c], own = this.inPlace(column, buffer), at = address[c];
+      if (own !== null) {
+        let f = fields[column.field], off = f.offset >= 0 ? this.o[f.offset] : 0;
+        at = own.byteOffset + (off + base) * column.bytes;
+      }
+      descriptor[s * (2)] = at, descriptor[s * (2) + 1] = this.slotStorage[s];
+    }
+    let words = this.argWords, args = this.payload.meta.args, origin = this.payload.origin >= 0 ? this.o[this.payload.origin] : 0, w = 0;
+    for (let k = 0; k < args.length; k++) {
+      let scalar = this.argScalar[k], table = this.argTable[k];
+      if (table >= 0) words[w++] = this.a[this.payload.tables[table].bind].length >>> 0;
+      else if (scalar >= 0) {
+        this.argHalves[0] = this.s[scalar];
+        let nan = Number.isNaN(this.argHalves[0]);
+        words[w++] = nan ? 0 : this.argView[0], words[w++] = nan ? 2146959360 : this.argView[1];
+      } else
+        words[w++] = base + origin | 0;
+    }
+    this.argsView.set(words);
+  }
+  finish(base, m) {
+    let buffer = this.arena, fields = this.payload.fields;
+    for (let c = 0; c < this.columns.length; c++) {
+      let column = this.columns[c];
+      if (column.field < 0) continue;
+      let f = fields[column.field];
+      if (!f.write || this.inPlace(column, buffer) !== null) continue;
+      let array = this.a[f.bind], values = this.columnViews[c];
+      if (f.gather >= 0) {
+        let rows = this.g[f.gather];
+        for (let i = 0; i < m; i++) array[rows[base + i]] = values[i];
+      } else {
+        let off = f.offset >= 0 ? this.o[f.offset] : 0;
+        array.set(this.target(c, m), off + base);
+      }
+    }
+  }
+}, LOOP_PROBE_GLOBAL = "__cimplify_loop_probe";
+function loopProbe() {
+  let probe = globalThis[LOOP_PROBE_GLOBAL];
+  return probe === void 0 ? null : probe;
+}
+var loops = /* @__PURE__ */ new Map();
+function lowerLoop(payload) {
+  let loop = loops.get(payload);
+  return loop === void 0 && (loop = new LoweredLoop(JSON.parse(payload)), loops.set(payload, loop)), loop;
+}
+
+// src/game/input/input.ts
+var RECORDED_EVENT_BYTES = 32, RECORDED_TYPE_AT = 0, RECORDED_A_AT = 4, RECORDED_X_AT = 8, RECORDED_Y_AT = 12, RECORDED_Z_AT = 16, RECORDED_TIME_AT = 24;
+function drainSource(events, count) {
+  if (count === 0 || events.length < (32)) return "touch";
+  let type = events[(0)];
+  return type === (10) ? "tilt" : type === (0) || type === (1) || type === (5) || type === (6) || type === (7) ? "key" : "touch";
+}
+var ACTION_BUTTON = 0, ACTION_AXIS = 1, BIND_KEY = 0, BIND_POINTER = 1, BIND_GAMEPAD_BUTTON = 2, BIND_VIRTUAL = 3, BIND_KEYS_AXIS = 4, BIND_GAMEPAD_AXIS = 5, BIND_VIRTUAL_AXIS = 6, EVENT_KEY_DOWN = 0, EVENT_KEY_UP = 1, EVENT_POINTER_DOWN = 2, EVENT_POINTER_MOVE = 3, EVENT_POINTER_UP = 4, EVENT_GAMEPAD_BUTTON = 5, EVENT_GAMEPAD_AXIS = 6, EVENT_VIRTUAL = 7, EVENT_WHEEL = 8, EVENT_MOTION = 9, EVENT_ORIENTATION = 10, EVENT_WHEEL_AT = 11, EVENT_LOOK = 12, EVENT_DEVICE = 13, InputDevice = { none: 0, keyboard: 1, pointer: 2, gamepad: 3 }, GAMEPAD_ACTIVITY = 0.5, STAGE_X = 0, STAGE_Y = 1, STAGE_Z = 2, STAGE_TIME = 3, STAGE_WORDS = 4, NO_POINTER = -1, BUTTON_THRESHOLD = 0.5, TAP_MAX_DISTANCE_FACTOR = 0.5, PRIMARY_BUTTONS = 1, MIN_PINCH_DISTANCE = 1e-6, DEFAULT_LONG_PRESS_MS = 500, LONG_PRESS_SLOP_FACTOR = 0.5, PINCH_POINTERS = 2, SwipeGesture = class {
+  constructor() {
+    this.ready = false;
+    this.startX = 0;
+    this.startY = 0;
+    this.endX = 0;
+    this.endY = 0;
+    this.deltaX = 0;
+    this.deltaY = 0;
+    this.distance = 0;
+    this.durationMs = 0;
+    this.velocityX = 0;
+    this.velocityY = 0;
+    this.curl = 0;
+  }
+}, TapGesture = class {
+  constructor() {
+    this.ready = false;
+    this.x = 0;
+    this.y = 0;
+  }
+}, PointerState = class {
+  constructor() {
+    this.active = false;
+    this.down = false;
+    this.x = 0;
+    this.y = 0;
+    this.buttons = 0;
+    this.count = 0;
+  }
+}, PinchGesture = class {
+  constructor() {
+    this.active = false;
+    this.scale = 1;
+    this.totalScale = 1;
+    this.centerX = 0;
+    this.centerY = 0;
+    this.panX = 0;
+    this.panY = 0;
+    this.rotation = 0;
+    this.distance = 0;
+  }
+}, WheelState = class {
+  constructor() {
+    this.deltaX = 0;
+    this.deltaY = 0;
+    this.deltaZ = 0;
+    this.x = 0;
+    this.y = 0;
+  }
+}, PointerDelta = class {
+  constructor() {
+    this.x = 0;
+    this.y = 0;
+  }
+}, FrameInput = class {
+  constructor() {
+    this.drag = new PointerDelta();
+    this.motion = new PointerDelta();
+    this.wheel = new WheelState();
+    this.pinch = new PinchGesture();
+    this.pressed = false;
+    this.released = false;
+    this.releasedButtons = 0;
+    this.pressX = 0;
+    this.pressY = 0;
+  }
+  dragging(pointer) {
+    return (pointer.down || this.released) && pointer.count <= 1;
+  }
+  dragButtons(pointer) {
+    return pointer.down ? pointer.buttons : this.releasedButtons;
+  }
+  begin() {
+    this.drag.x = 0, this.drag.y = 0, this.motion.x = 0, this.motion.y = 0, this.wheel.deltaX = 0, this.wheel.deltaY = 0, this.wheel.deltaZ = 0, this.pinch.active = false, this.pinch.scale = 1, this.pinch.panX = 0, this.pinch.panY = 0, this.pinch.rotation = 0, this.pressed = false, this.released = false, this.releasedButtons = 0;
+  }
+}, LongPressGesture = class {
+  constructor() {
+    this.ready = false;
+    this.x = 0;
+    this.y = 0;
+    this.durationMs = 0;
+  }
+}, OrientationState = class {
+  constructor() {
+    this.available = false;
+    this.alpha = 0;
+    this.beta = 0;
+    this.gamma = 0;
+  }
+};
+settleDoubleFields(new SwipeGesture(), [
+  "startX",
+  "startY",
+  "endX",
+  "endY",
+  "deltaX",
+  "deltaY",
+  "distance",
+  "durationMs",
+  "velocityX",
+  "velocityY",
+  "curl"
+]);
+settleDoubleFields(new TapGesture(), ["x", "y"]);
+settleDoubleFields(new PointerState(), ["x", "y"]);
+settleDoubleFields(new PinchGesture(), ["scale", "totalScale", "centerX", "centerY", "panX", "panY", "rotation", "distance"]);
+settleDoubleFields(new WheelState(), ["deltaX", "deltaY", "deltaZ", "x", "y"]);
+settleDoubleFields(new PointerDelta(), ["x", "y"]);
+settleDoubleFields(new FrameInput(), ["pressX", "pressY"]);
+settleDoubleFields(new LongPressGesture(), ["x", "y", "durationMs"]);
+settleDoubleFields(new OrientationState(), ["alpha", "beta", "gamma"]);
+var InputActions = class {
+  constructor(options = {}) {
+    this.swipe = new SwipeGesture();
+    this.tap = new TapGesture();
+    this.pointer = new PointerState();
+    this.pinch = new PinchGesture();
+    this.wheel = new WheelState();
+    this.drag = new PointerDelta();
+    this.motion = new PointerDelta();
+    this.look = new PointerDelta();
+    this.frame = new FrameInput();
+    this.longPress = new LongPressGesture();
+    this.orientation = new OrientationState();
+    this.pendingSwipe = new SwipeGesture();
+    this.pendingTap = new TapGesture();
+    this.pendingPinch = new PinchGesture();
+    this.pendingWheel = new WheelState();
+    this.pendingDrag = new PointerDelta();
+    this.pendingMotion = new PointerDelta();
+    this.pendingLongPress = new LongPressGesture();
+    this.pointerX = new Float32Array(10);
+    this.pointerY = new Float32Array(10);
+    this.pointerButtons = new Int32Array(10);
+    this.pointerOrder = new Float64Array(10);
+    this.pointerSerial = 0;
+    this.pinchA = (-1);
+    this.pinchB = (-1);
+    this.pinchDistance = 0;
+    this.pinchAngle = 0;
+    this.pinchCenterX = 0;
+    this.pinchCenterY = 0;
+    this.multiTouch = false;
+    this.longPressFired = false;
+    this.longPressMoved = false;
+    this.lastEventTime = 0;
+    this.lastDevice = InputDevice.none;
+    this.lastDeviceTime = 0;
+    this.frameNow = 0;
+    this.pointerFilter = null;
+    this.stage = new Float64Array((4));
+    this.pointerStage = new Float64Array((4));
+    this.actionNames = /* @__PURE__ */ new Map();
+    this.actionCount = 0;
+    this.actionKind = new Uint8Array(128);
+    this.actionValue = new Float32Array(128);
+    this.bindingOut = new Float64Array(1);
+    this.actionDown = new Uint8Array(128);
+    this.pressedLatch = new Uint8Array(128);
+    this.releasedLatch = new Uint8Array(128);
+    this.justPressedStep = new Uint8Array(128);
+    this.justReleasedStep = new Uint8Array(128);
+    this.bindingCount = 0;
+    this.bindAction = new Uint16Array(512);
+    this.bindKind = new Uint8Array(512);
+    this.bindA = new Int32Array(512);
+    this.bindB = new Int32Array(512);
+    this.bindParam = new Float32Array(512);
+    this.bindInvert = new Uint8Array(512);
+    this.keySlots = /* @__PURE__ */ new Map();
+    this.keyDown = new Uint8Array(256);
+    this.virtualSlots = /* @__PURE__ */ new Map();
+    this.virtualValue = new Float32Array(256);
+    this.virtualButtons = new Uint16Array(256);
+    this.gamepadButtons = new Float32Array(32);
+    this.gamepadAxes = new Float32Array(16);
+    this.pointerIds = new Int32Array(10).fill((-1));
+    this.primaryPointer = (-1);
+    this.pointerDownCount = 0;
+    this.gestureStartX = 0;
+    this.gestureStartY = 0;
+    this.gestureStartTime = 0;
+    this.sampleX = new Float32Array(64);
+    this.sampleY = new Float32Array(64);
+    this.sampleCount = 0;
+    this.eventType = new Uint8Array(512);
+    this.eventA = new Int32Array(512);
+    this.eventX = new Float32Array(512);
+    this.eventY = new Float32Array(512);
+    this.eventZ = new Float32Array(512);
+    this.eventTime = new Float64Array(512);
+    this.eventHead = 0;
+    this.eventCount = 0;
+    this.droppedEvents = 0;
+    this.unlockListener = null;
+    this.inputTap = null;
+    this.tapBytes = null;
+    this.tapView = null;
+    this.replayView = null;
+    this.swipeMinDistance = options.swipeMinDistance ?? 0.04, this.swipeMaxDurationMs = options.swipeMaxDurationMs ?? 800, this.longPressMs = options.longPressMs ?? (500);
+  }
+  pointerCount() {
+    return this.pointerDownCount;
+  }
+  pointerAt(index, out, offset = 0) {
+    let seen = 0;
+    for (let i = 0; i < 10; i++)
+      if (this.pointerIds[i] !== (-1)) {
+        if (seen === index)
+          return out[offset] = this.pointerX[i], out[offset + 1] = this.pointerY[i], true;
+        seen++;
+      }
+    return false;
+  }
+  get dropped() {
+    return this.droppedEvents;
+  }
+  onFirstGesture(listener) {
+    this.unlockListener = listener;
+  }
+  defineButton(name, bindings) {
+    let action = this.defineAction(name, (0));
+    for (let binding of bindings)
+      switch (binding.device) {
+        case "key":
+          this.bind(action, (0), this.keySlot(binding.code), 0, 0, false);
+          break;
+        case "pointer":
+          this.bind(action, (1), 0, 0, 0, false);
+          break;
+        case "gamepad":
+          this.bind(
+            action,
+            (2),
+            this.checkIndex(binding.button, 32),
+            0,
+            binding.threshold ?? (0.5),
+            false
+          );
+          break;
+        case "virtual": {
+          let slot = this.virtualSlot(binding.control);
+          this.bind(action, (3), slot, 0, (0.5), false), this.virtualButtons[slot]++;
+          break;
+        }
+      }
+    return action;
+  }
+  defineAxis(name, bindings) {
+    let action = this.defineAction(name, (1));
+    for (let binding of bindings)
+      switch (binding.device) {
+        case "keys":
+          this.bind(
+            action,
+            (4),
+            this.keySlot(binding.negative),
+            this.keySlot(binding.positive),
+            0,
+            false
+          );
+          break;
+        case "gamepad":
+          this.bind(
+            action,
+            (5),
+            this.checkIndex(binding.axis, 16),
+            0,
+            binding.deadzone ?? 0.15,
+            binding.invert === true
+          );
+          break;
+        case "virtual":
+          this.bind(
+            action,
+            (6),
+            this.virtualSlot(binding.control),
+            0,
+            0,
+            binding.invert === true
+          );
+          break;
+      }
+    return action;
+  }
+  hasAction(name) {
+    return this.actionNames.has(name);
+  }
+  axisAction(name, negative, positive) {
+    let existing = this.actionNames.get(name);
+    if (existing !== void 0) return existing;
+    let bindings = [], n = Math.min(negative.length, positive.length);
+    for (let i = 0; i < n; i++) bindings.push({ device: "keys", negative: negative[i], positive: positive[i] });
+    return this.defineAxis(name, bindings);
+  }
+  action(name) {
+    let id = this.actionNames.get(name);
+    if (id === void 0) throw new GameError("invalid_argument", `unknown action ${name}`);
+    return id;
+  }
+  pressed(action) {
+    return this.actionDown[action] === 1;
+  }
+  justPressed(action) {
+    return this.justPressedStep[action] === 1;
+  }
+  justReleased(action) {
+    return this.justReleasedStep[action] === 1;
+  }
+  value(action) {
+    return this.actionValue[action];
+  }
+  valueInto(action, out, index) {
+    out[index] = this.actionValue[action];
+  }
+  keyEvent(code, down, timeMs) {
+    let slot = this.keySlots.get(code);
+    slot !== void 0 && this.push(down ? (0) : (1), slot, 0, 0, timeMs);
+  }
+  pointerStaged(phase, id, buttons = (1)) {
+    let stage = this.stage, filter = this.pointerFilter;
+    if (filter !== null) {
+      let pointer = this.pointerStage;
+      if (pointer[(0)] = stage[(0)], pointer[(1)] = stage[(1)], pointer[(3)] = stage[(3)], filter.filterPointer(phase, id, pointer)) {
+        if (phase === "down") {
+          stage[(3)] = pointer[(3)], this.pushStaged((13), InputDevice.pointer);
+          return;
+        }
+        stage[(0)] = 0, stage[(1)] = 0;
+        return;
+      }
+    }
+    stage[(2)] = buttons, this.pushStaged(phase === "down" ? (2) : phase === "move" ? (3) : (4), id);
+  }
+  setPointerFilter(filter) {
+    this.pointerFilter = filter;
+  }
+  pointerEvent(phase, id, x, y, timeMs, buttons = (1)) {
+    let filter = this.pointerFilter;
+    if (filter !== null) {
+      let pointer = this.pointerStage;
+      if (pointer[(0)] = x, pointer[(1)] = y, pointer[(3)] = timeMs, filter.filterPointer(phase, id, pointer)) {
+        phase === "down" && this.push((13), InputDevice.pointer, 0, 0, timeMs);
+        return;
+      }
+    }
+    let type = phase === "down" ? (2) : phase === "move" ? (3) : (4);
+    this.push(type, id, x, y, timeMs, buttons);
+  }
+  wheelEvent(deltaX, deltaY, deltaZ, x, y, timeMs) {
+    this.push((11), 0, x, y, timeMs), this.push((8), 0, deltaX, deltaY, timeMs, deltaZ);
+  }
+  motionEvent(movementX, movementY, timeMs) {
+    this.push((9), 0, movementX, movementY, timeMs);
+  }
+  orientationEvent(alpha, beta, gamma, timeMs) {
+    this.push((10), 0, alpha, beta, timeMs, gamma);
+  }
+  gamepadButtonEvent(button, value, timeMs) {
+    button < 0 || button >= 32 || this.push((5), button, value, 0, timeMs);
+  }
+  gamepadAxisEvent(axis, value, timeMs) {
+    axis < 0 || axis >= 16 || this.push((6), axis, value, 0, timeMs);
+  }
+  virtualEvent(control, value, timeMs) {
+    let slot = this.virtualSlots.get(control);
+    slot !== void 0 && this.push((7), slot, value, 0, timeMs);
+  }
+  virtualControl(control) {
+    return this.virtualSlot(control);
+  }
+  virtualSlotEvent(slot, value, timeMs) {
+    let stage = this.stage;
+    stage[(0)] = value, stage[(3)] = timeMs, this.virtualStaged(slot);
+  }
+  virtualStaged(slot) {
+    slot < 0 || slot >= 256 || this.pushStaged((7), slot);
+  }
+  lookEvent(dx, dy, timeMs) {
+    let stage = this.stage;
+    stage[(0)] = dx, stage[(1)] = dy, stage[(3)] = timeMs, this.lookStaged();
+  }
+  lookStaged() {
+    this.pushStaged((12), 0);
+  }
+  deviceStaged(device) {
+    this.pushStaged((13), device);
+  }
+  deviceEvent(device, timeMs) {
+    this.stage[(3)] = timeMs, this.deviceStaged(device);
+  }
+  get device() {
+    return this.lastDevice;
+  }
+  get deviceTimeMs() {
+    return this.lastDeviceTime;
+  }
+  processEvents(nowMs = this.lastEventTime) {
+    this.frameNow = nowMs, this.drain();
+  }
+  processEventsFrom(clock2, slot) {
+    this.frameNow = clock2[slot], this.drain();
+  }
+  /** Starts or stops hearing every drain, for recording a play; preallocates the packing buffer once. */
+  setTap(tap) {
+    this.inputTap = tap, tap !== null && this.tapBytes === null && (this.tapBytes = new Uint8Array(512 * (32)), this.tapView = new DataView(this.tapBytes.buffer));
+  }
+  /** Applies a recorded drain exactly as it first happened: its events in order, then the drain at its frame time. */
+  replay(nowMs, events, count) {
+    if (events !== null) {
+      (this.replayView === null || this.replayView.buffer !== events.buffer) && (this.replayView = new DataView(events.buffer));
+      let view2 = this.replayView;
+      for (let i = 0; i < count; i++) {
+        let at = events.byteOffset + i * (32);
+        this.push(
+          view2.getUint32(at + (0), true),
+          view2.getInt32(at + (4), true),
+          view2.getFloat32(at + (8), true),
+          view2.getFloat32(at + (12), true),
+          view2.getFloat64(at + (24), true),
+          view2.getFloat32(at + (16), true)
+        );
+      }
+    }
+    this.frameNow = nowMs, this.drain();
+  }
+  record() {
+    let tap = this.inputTap, view2 = this.tapView, bytes = this.tapBytes;
+    if (tap === null || view2 === null || bytes === null) return;
+    let index = this.eventHead;
+    for (let i = 0; i < this.eventCount; i++) {
+      let at = i * (32);
+      view2.setUint32(at + (0), this.eventType[index], true), view2.setInt32(at + (4), this.eventA[index], true), view2.setFloat32(at + (8), this.eventX[index], true), view2.setFloat32(at + (12), this.eventY[index], true), view2.setFloat32(at + (16), this.eventZ[index], true), view2.setFloat64(at + (24), this.eventTime[index], true), index = (index + 1) % 512;
+    }
+    tap.drained(this.frameNow, bytes.subarray(0, this.eventCount * (32)), this.eventCount);
+  }
+  drain() {
+    this.inputTap !== null && this.record(), this.look.x = 0, this.look.y = 0, this.frame.begin();
+    let index = this.eventHead;
+    for (let i = 0; i < this.eventCount; i++)
+      this.apply(index), index = (index + 1) % 512;
+    this.eventHead = index, this.eventCount = 0, this.trackPinch(), this.detectLongPress(), this.evaluate();
+  }
+  beginStep() {
+    for (let a = 0; a < this.actionCount; a++)
+      this.justPressedStep[a] = this.pressedLatch[a], this.justReleasedStep[a] = this.releasedLatch[a], this.pressedLatch[a] = 0, this.releasedLatch[a] = 0;
+    copySwipe(this.swipe, this.pendingSwipe), this.pendingSwipe.ready = false, this.tap.ready = this.pendingTap.ready, this.tap.x = this.pendingTap.x, this.tap.y = this.pendingTap.y, this.pendingTap.ready = false, publishPinch(this.pinch, this.pendingPinch);
+    let w = this.pendingWheel;
+    this.wheel.deltaX = w.deltaX, this.wheel.deltaY = w.deltaY, this.wheel.deltaZ = w.deltaZ, this.wheel.x = w.x, this.wheel.y = w.y, w.deltaX = 0, w.deltaY = 0, w.deltaZ = 0, this.drag.x = this.pendingDrag.x, this.drag.y = this.pendingDrag.y, this.pendingDrag.x = 0, this.pendingDrag.y = 0, this.motion.x = this.pendingMotion.x, this.motion.y = this.pendingMotion.y, this.pendingMotion.x = 0, this.pendingMotion.y = 0;
+    let l = this.pendingLongPress;
+    this.longPress.ready = l.ready, this.longPress.x = l.x, this.longPress.y = l.y, this.longPress.durationMs = l.durationMs, l.ready = false;
+  }
+  trackPinch() {
+    let a = (-1), b = (-1);
+    for (let i = 0; i < 10; i++)
+      this.pointerIds[i] !== (-1) && (a === (-1) || this.pointerOrder[i] < this.pointerOrder[a] ? (b = a, a = i) : (b === (-1) || this.pointerOrder[i] < this.pointerOrder[b]) && (b = i));
+    let p = this.pendingPinch;
+    if (this.pointerDownCount < (2) || a === (-1) || b === (-1)) {
+      p.active = false, this.pinchA = (-1), this.pinchB = (-1);
+      return;
+    }
+    if (a > b) {
+      let t = a;
+      a = b, b = t;
+    }
+    let dx = this.pointerX[b] - this.pointerX[a], dy = this.pointerY[b] - this.pointerY[a], distance = Math.sqrt(dx * dx + dy * dy), angle = Math.atan2(dy, dx), cx = (this.pointerX[a] + this.pointerX[b]) * 0.5, cy = (this.pointerY[a] + this.pointerY[b]) * 0.5;
+    if (a !== this.pinchA || b !== this.pinchB)
+      this.pinchA = a, this.pinchB = b, p.active || (p.totalScale = 1);
+    else if (this.pinchDistance > (1e-6) && distance > (1e-6)) {
+      let ratio = distance / this.pinchDistance;
+      p.scale *= ratio, p.totalScale *= ratio, p.panX += cx - this.pinchCenterX, p.panY += cy - this.pinchCenterY;
+      let turn = angle - this.pinchAngle;
+      turn > Math.PI ? turn -= Math.PI * 2 : turn < -Math.PI && (turn += Math.PI * 2), p.rotation += turn;
+      let f = this.frame.pinch;
+      f.scale *= ratio, f.panX += cx - this.pinchCenterX, f.panY += cy - this.pinchCenterY, f.rotation += turn;
+    }
+    p.active = true, this.frame.pinch.active = true, this.frame.pinch.totalScale = p.totalScale, this.frame.pinch.centerX = cx, this.frame.pinch.centerY = cy, this.frame.pinch.distance = distance, p.centerX = cx, p.centerY = cy, p.distance = distance, this.pinchDistance = distance, this.pinchAngle = angle, this.pinchCenterX = cx, this.pinchCenterY = cy;
+  }
+  detectLongPress() {
+    if (this.primaryPointer === (-1) || this.longPressFired || this.longPressMoved || this.multiTouch) return;
+    let held = (this.frameNow > this.lastEventTime ? this.frameNow : this.lastEventTime) - this.gestureStartTime;
+    if (held < this.longPressMs) return;
+    this.longPressFired = true;
+    let l = this.pendingLongPress;
+    l.ready = true, l.x = this.gestureStartX, l.y = this.gestureStartY, l.durationMs = held;
+  }
+  defineAction(name, kind) {
+    if (this.actionNames.has(name)) throw new GameError("invalid_argument", `action ${name} exists`);
+    if (this.actionCount >= 128)
+      throw new GameError("capacity_exceeded", `at most ${128} actions`);
+    let id = this.actionCount++;
+    return this.actionKind[id] = kind, this.actionNames.set(name, id), id;
+  }
+  bind(action, kind, a, b, param, invert) {
+    if (this.bindingCount >= 512)
+      throw new GameError("capacity_exceeded", `at most ${512} bindings`);
+    let i = this.bindingCount++;
+    this.bindAction[i] = action, this.bindKind[i] = kind, this.bindA[i] = a, this.bindB[i] = b, this.bindParam[i] = param, this.bindInvert[i] = invert ? 1 : 0;
+  }
+  keySlot(code) {
+    return slotFor(this.keySlots, code);
+  }
+  virtualSlot(control) {
+    return slotFor(this.virtualSlots, control);
+  }
+  checkIndex(index, limit) {
+    if (index < 0 || index >= limit) throw new GameError("invalid_argument", `index ${index} out of range`);
+    return index;
+  }
+  pushStaged(type, a) {
+    if (this.eventCount >= 512) {
+      this.droppedEvents++;
+      return;
+    }
+    let index = (this.eventHead + this.eventCount) % 512, stage = this.stage;
+    this.eventType[index] = type, this.eventA[index] = a, this.eventX[index] = stage[(0)], this.eventY[index] = stage[(1)], this.eventZ[index] = stage[(2)], this.eventTime[index] = stage[(3)], stage[(0)] = 0, stage[(1)] = 0, stage[(2)] = 0, this.eventCount++;
+  }
+  push(type, a, x, y, timeMs, z = 0) {
+    if (this.eventCount >= 512) {
+      this.droppedEvents++;
+      return;
+    }
+    let index = (this.eventHead + this.eventCount) % 512;
+    this.eventType[index] = type, this.eventA[index] = a, this.eventX[index] = x, this.eventY[index] = y, this.eventZ[index] = z, this.eventTime[index] = timeMs, this.eventCount++;
+  }
+  apply(index) {
+    let a = this.eventA[index], x = this.eventX[index], y = this.eventY[index], z = this.eventZ[index], time = this.eventTime[index];
+    time > this.lastEventTime && (this.lastEventTime = time);
+    let device = InputDevice.none;
+    switch (this.eventType[index]) {
+      case (8):
+        this.pendingWheel.deltaX += x, this.pendingWheel.deltaY += y, this.pendingWheel.deltaZ += z, this.frame.wheel.deltaX += x, this.frame.wheel.deltaY += y, this.frame.wheel.deltaZ += z, this.firstGesture();
+        break;
+      case (11):
+        this.pendingWheel.x = x, this.pendingWheel.y = y, this.frame.wheel.x = x, this.frame.wheel.y = y;
+        break;
+      case (9):
+        this.pendingMotion.x += x, this.pendingMotion.y += y, this.frame.motion.x += x, this.frame.motion.y += y;
+        break;
+      case (10):
+        this.orientation.available = true, this.orientation.alpha = x, this.orientation.beta = y, this.orientation.gamma = z;
+        break;
+      case (12):
+        this.look.x += x, this.look.y += y;
+        break;
+      case (13):
+        device = a, this.firstGesture();
+        break;
+      case (0):
+        this.keyDown[a] === 0 && this.latchSlot((0), a, true), this.keyDown[a] = 1, device = InputDevice.keyboard, this.firstGesture();
+        break;
+      case (1):
+        this.keyDown[a] === 1 && this.latchSlot((0), a, false), this.keyDown[a] = 0;
+        break;
+      case (2):
+        this.pointerDown(a, index), device = InputDevice.pointer, this.firstGesture();
+        break;
+      case (3):
+        this.pointerMove(a, index);
+        break;
+      case (4):
+        this.pointerUp(a, index);
+        break;
+      case (5):
+        this.gamepadButtons[a] = x, x >= (0.5) && (device = InputDevice.gamepad), this.firstGesture();
+        break;
+      case (6):
+        this.gamepadAxes[a] = x, (x >= (0.5) || x <= -(0.5)) && (device = InputDevice.gamepad);
+        break;
+      case (7):
+        this.latchVirtual(a, index), this.virtualValue[a] = x, this.firstGesture();
+        break;
+    }
+    device !== InputDevice.none && (this.lastDevice = device, this.lastDeviceTime = time);
+  }
+  latchVirtual(slot, index) {
+    if (this.virtualButtons[slot] === 0) return;
+    let before = this.virtualValue[slot], after = this.eventX[index];
+    for (let i = 0; i < this.bindingCount; i++) {
+      if (this.bindKind[i] !== (3) || this.bindA[i] !== slot) continue;
+      let threshold = this.bindParam[i], action = this.bindAction[i];
+      before < threshold && after >= threshold ? this.pressedLatch[action] = 1 : before >= threshold && after < threshold && (this.releasedLatch[action] = 1);
+    }
+  }
+  firstGesture() {
+    let listener = this.unlockListener;
+    listener && (this.unlockListener = null, listener());
+  }
+  latchSlot(kind, slot, down) {
+    for (let i = 0; i < this.bindingCount; i++) {
+      if (this.bindKind[i] !== kind || this.bindA[i] !== slot) continue;
+      let action = this.bindAction[i];
+      down ? this.pressedLatch[action] = 1 : this.releasedLatch[action] = 1;
+    }
+  }
+  pointerDown(id, index) {
+    let x = this.eventX[index], y = this.eventY[index], buttons = this.eventZ[index], slot = this.pointerSlot(id);
+    if (slot === (-1)) {
+      if (slot = this.pointerSlot((-1)), slot === (-1)) return;
+      this.pointerIds[slot] = id, this.pointerOrder[slot] = this.pointerSerial++, this.pointerDownCount++;
+    }
+    this.pointerX[slot] = x, this.pointerY[slot] = y, this.pointerButtons[slot] = buttons, this.pointer.count = this.pointerDownCount, this.pointerDownCount >= (2) && (this.multiTouch = true), this.primaryPointer === (-1) && (this.primaryPointer = id, this.gestureStartX = x, this.gestureStartY = y, this.gestureStartTime = this.eventTime[index], this.multiTouch = this.pointerDownCount >= (2), this.longPressFired = false, this.longPressMoved = false, this.sampleCount = 0, this.recordSample(index), this.pointer.active = true, this.pointer.down = true, this.pointer.x = x, this.pointer.y = y, this.pointer.buttons = buttons, this.frame.pressed = true, this.frame.pressX = x, this.frame.pressY = y, this.latchSlot((1), 0, true));
+  }
+  pointerMove(id, index) {
+    let x = this.eventX[index], y = this.eventY[index], buttons = this.eventZ[index], slot = this.pointerSlot(id);
+    if (slot !== (-1) && (this.pointerX[slot] = x, this.pointerY[slot] = y, this.pointerButtons[slot] = buttons), id !== this.primaryPointer) {
+      this.primaryPointer === (-1) && (this.pointer.active = true, this.pointer.x = x, this.pointer.y = y);
+      return;
+    }
+    this.pointerDownCount < (2) && this.addDrag(x - this.pointer.x, y - this.pointer.y), this.pointer.x = x, this.pointer.y = y, this.pointer.buttons = buttons;
+    let sx = x - this.gestureStartX, sy = y - this.gestureStartY, slop = this.swipeMinDistance * (0.5);
+    sx * sx + sy * sy > slop * slop && (this.longPressMoved = true), this.recordSample(index);
+  }
+  pointerUp(id, index) {
+    let x = this.eventX[index], y = this.eventY[index], slot = this.pointerSlot(id);
+    slot !== (-1) && (this.pointerIds[slot] = (-1), this.pointerButtons[slot] = 0, this.pointerDownCount--), this.pointer.count = this.pointerDownCount, id === this.primaryPointer && (this.primaryPointer = (-1), this.pointerDownCount < (2) - 1 && this.addDrag(x - this.pointer.x, y - this.pointer.y), this.frame.releasedButtons = this.pointer.buttons, this.pointer.down = false, this.pointer.buttons = 0, this.pointer.x = x, this.pointer.y = y, this.frame.released = true, this.recordSample(index), this.latchSlot((1), 0, false), !this.multiTouch && !this.longPressFired && this.recognize(index));
+  }
+  addDrag(dx, dy) {
+    this.pendingDrag.x += dx, this.pendingDrag.y += dy, this.frame.drag.x += dx, this.frame.drag.y += dy;
+  }
+  pointerSlot(id) {
+    for (let i = 0; i < 10; i++) if (this.pointerIds[i] === id) return i;
+    return (-1);
+  }
+  recordSample(index) {
+    let at = this.sampleCount >= 64 ? 63 : this.sampleCount++;
+    this.sampleX[at] = this.eventX[index], this.sampleY[at] = this.eventY[index];
+  }
+  recognize(index) {
+    let x = this.eventX[index], y = this.eventY[index], dx = x - this.gestureStartX, dy = y - this.gestureStartY, distance = (dx * dx + dy * dy) ** 0.5, scratch = this.bindingOut;
+    scratch[0] = this.eventTime[index] - this.gestureStartTime, scratch[0] < 1 && (scratch[0] = 1);
+    let duration = scratch[0];
+    if (distance >= this.swipeMinDistance && duration <= this.swipeMaxDurationMs) {
+      let s = this.pendingSwipe;
+      s.ready = true, s.startX = this.gestureStartX, s.startY = this.gestureStartY, s.endX = x, s.endY = y, s.deltaX = dx, s.deltaY = dy, s.distance = distance, s.durationMs = duration, s.velocityX = dx / duration, s.velocityY = dy / duration, this.curlInto(s);
+      return;
+    }
+    distance < this.swipeMinDistance * (0.5) && (this.pendingTap.ready = true, this.pendingTap.x = x, this.pendingTap.y = y);
+  }
+  curlInto(s) {
+    let distance = s.distance, extreme = this.bindingOut;
+    extreme[0] = 0;
+    let nx = -s.deltaY / distance, ny = s.deltaX / distance;
+    for (let i = 0; i < this.sampleCount; i++) {
+      let d = (this.sampleX[i] - this.gestureStartX) * nx + (this.sampleY[i] - this.gestureStartY) * ny;
+      Math.abs(d) > Math.abs(extreme[0]) && (extreme[0] = d);
+    }
+    s.curl = extreme[0] / distance;
+  }
+  evaluate() {
+    let values = this.actionValue;
+    for (let a = 0; a < this.actionCount; a++) values[a] = 0;
+    let out = this.bindingOut;
+    for (let i = 0; i < this.bindingCount; i++) {
+      let action = this.bindAction[i];
+      this.bindingValue(i, out);
+      let v = out[0], current = values[action];
+      Math.abs(v) > Math.abs(current) && (values[action] = v);
+    }
+    for (let a = 0; a < this.actionCount; a++) {
+      if (this.actionKind[a] !== (0)) continue;
+      let down = values[a] >= (0.5) ? 1 : 0;
+      down === 1 && this.actionDown[a] === 0 && (this.pressedLatch[a] = 1), down === 0 && this.actionDown[a] === 1 && (this.releasedLatch[a] = 1), this.actionDown[a] = down;
+    }
+  }
+  bindingValue(i, out) {
+    let a = this.bindA[i], v = 0;
+    switch (this.bindKind[i]) {
+      case (0):
+        v = this.keyDown[a];
+        break;
+      case (1):
+        v = this.pointerDownCount > 0 ? 1 : 0;
+        break;
+      case (2):
+        v = this.gamepadButtons[a] >= this.bindParam[i] ? 1 : 0;
+        break;
+      case (3):
+        v = this.virtualValue[a] >= this.bindParam[i] ? 1 : 0;
+        break;
+      case (4):
+        v = this.keyDown[this.bindB[i]] - this.keyDown[a];
+        break;
+      case (5): {
+        let raw = this.gamepadAxes[a], dead = this.bindParam[i];
+        v = (raw < 0 ? -raw : raw) < dead ? 0 : (raw - (raw > 0 ? 1 : raw < 0 ? -1 : raw) * dead) / (1 - dead);
+        break;
+      }
+      case (6):
+        v = this.virtualValue[a];
+        break;
+    }
+    out[0] = this.bindInvert[i] === 1 ? -v : v;
+  }
+};
+function slotFor(map, name) {
+  let existing = map.get(name);
+  if (existing !== void 0) return existing;
+  if (map.size >= 256)
+    throw new GameError("capacity_exceeded", `at most ${256} input slots`);
+  let slot = map.size;
+  return map.set(name, slot), slot;
+}
+function publishPinch(out, from) {
+  out.active = from.active, out.scale = from.scale, out.totalScale = from.totalScale, out.centerX = from.centerX, out.centerY = from.centerY, out.panX = from.panX, out.panY = from.panY, out.rotation = from.rotation, out.distance = from.distance, from.scale = 1, from.panX = 0, from.panY = 0, from.rotation = 0;
+}
+function copySwipe(out, from) {
+  out.ready = from.ready, out.startX = from.startX, out.startY = from.startY, out.endX = from.endX, out.endY = from.endY, out.deltaX = from.deltaX, out.deltaY = from.deltaY, out.distance = from.distance, out.durationMs = from.durationMs, out.velocityX = from.velocityX, out.velocityY = from.velocityY, out.curl = from.curl;
+}
+
+// src/game/softbody/softbody.ts
+var SOFT_DEFAULTS = {
+  stretch: 1e-6,
+  bend: 1e-4,
+  volume: 0,
+  damping: 0.5,
+  gravity: { x: 0, y: -9.81, z: 0 },
+  substeps: 10,
+  radius: 0.01,
+  friction: 0.3,
+  contraction: 0.3,
+  density: 1e3,
+  ropeMass: 0.02
+}, MAX_SUBSTEPS = 32;
+function writeSoftOptions(f, r, options) {
+  let substeps = options.substeps ?? SOFT_DEFAULTS.substeps;
+  if (!Number.isInteger(substeps) || substeps < 1 || substeps > (32))
+    throw new GameError("invalid_argument", `soft body substeps must be a whole number from 1 to ${(32)}`);
+  let gravity = options.gravity ?? SOFT_DEFAULTS.gravity;
+  f[SOFT_STRETCH] = options.stretch ?? SOFT_DEFAULTS.stretch, f[SOFT_BEND] = options.bend ?? SOFT_DEFAULTS.bend, f[SOFT_VOLUME] = options.volume ?? SOFT_DEFAULTS.volume, f[SOFT_DAMPING] = options.damping ?? SOFT_DEFAULTS.damping, f[SOFT_GRAVITY] = gravity.x, f[SOFT_GRAVITY + 1] = gravity.y, f[SOFT_GRAVITY + 2] = gravity.z, r[SOFT_SUBSTEPS] = substeps, f[SOFT_RADIUS] = options.radius ?? SOFT_DEFAULTS.radius, f[SOFT_FRICTION] = options.friction ?? SOFT_DEFAULTS.friction, f[SOFT_CONTRACTION] = options.contraction ?? SOFT_DEFAULTS.contraction, f[SOFT_YIELD] = options.plastic?.yieldStrain ?? 0, f[SOFT_CREEP] = options.plastic ? options.plastic.creep ?? 1 : 0, f[SOFT_LIMIT] = options.plastic ? options.plastic.limit ?? 0.5 : 0, f[SOFT_FIBRE] = options.fibre?.x ?? 0, f[SOFT_FIBRE + 1] = options.fibre?.y ?? 0, f[SOFT_FIBRE + 2] = options.fibre?.z ?? 0;
+}
+function packSoftCollider(out, at, collider) {
+  out.fill(0, at, at + SOFT_COLLIDER_FLOATS);
+  let put = (k, v) => {
+    out[at + k] = v.x, out[at + k + 1] = v.y, out[at + k + 2] = v.z;
+  };
+  if ("plane" in collider)
+    out[at] = SOFT_COLLIDER_PLANE, put(1, collider.plane.normal), out[at + 7] = collider.plane.offset;
+  else if ("sphere" in collider)
+    out[at] = SOFT_COLLIDER_SPHERE, put(1, collider.sphere.center), out[at + 7] = collider.sphere.radius;
+  else if ("capsule" in collider)
+    out[at] = SOFT_COLLIDER_CAPSULE, put(1, collider.capsule.a), put(4, collider.capsule.b), out[at + 7] = collider.capsule.radius;
+  else {
+    out[at] = SOFT_COLLIDER_BOX, put(1, collider.box.center), put(4, collider.box.half);
+    let q = collider.box.rotation ?? { x: 0, y: 0, z: 0, w: 1 };
+    out[at + 8] = q.x, out[at + 9] = q.y, out[at + 10] = q.z, out[at + 11] = q.w;
+  }
+}
+function packCrumple(options, low, high) {
+  let d = new Float32Array(CRUMPLE_DESC_FLOATS), span = Math.max(high.x - low.x, high.y - low.y, high.z - low.z), cells = options.cells ?? [4, 2, 6];
+  return d.set(cells, 0), d.set([low.x, low.y, low.z, high.x, high.y, high.z], 3), d[9] = options.threshold ?? 3, d[10] = options.crush ?? 0.02, d[11] = options.maxDepth ?? 0.35, d[12] = options.radius ?? span * 0.25, d[13] = options.stiffness ?? 1e-5, d;
+}
+var SoftBody = class {
+  constructor(port, info, geometry) {
+    this.port = port;
+    this.info = info;
+    this.disposed = false;
+    this.particles = info.particles, this.skinned = info.skinned, this.tets = info.tets, this.geometry = geometry;
+  }
+  get id() {
+    return this.info.id;
+  }
+  positions() {
+    return this.port.positions(this.info.id, this.particles);
+  }
+  attach(geometry) {
+    if (geometry !== null && this.skinned === 0) throw new GameError("invalid_argument", "this soft body has no embedded surface to draw");
+    this.geometry = geometry;
+  }
+  setOptions(options) {
+    writeSoftOptions(this.port.prepare(), this.port.registers, options), this.port.params(this.info.id);
+  }
+  setActivation(activation) {
+    if (!(activation >= 0 && activation <= 1)) throw new GameError("invalid_argument", "muscle activation runs from 0 to 1");
+    this.port.activate(this.info.id, activation);
+  }
+  setAnchors(anchors) {
+    this.port.anchors(this.info.id, anchors);
+  }
+  push(offset, velocity) {
+    this.port.move(this.info.id, [offset.x, offset.y, offset.z], [velocity.x, velocity.y, velocity.z]);
+  }
+  present() {
+    return this.disposed || this.geometry === null ? 0 : this.port.present(this.info.id, this.geometry);
+  }
+  dispose() {
+    this.disposed || (this.disposed = true, this.port.remove(this.info.id));
+  }
+}, SoftBodies = class {
+  constructor(port) {
+    this.port = port;
+    this.bodies = [];
+    this.block = new Float32Array(SOFT_COLLIDER_FLOATS * SOFT_MAX_COLLIDERS);
+  }
+  create(shape, options = {}) {
+    writeSoftOptions(this.port.prepare(), this.port.registers, options);
+    let info;
+    if ("lattice" in shape) {
+      let l = shape.lattice;
+      info = this.port.lattice(
+        { cells: l.cells, size: [l.size.x, l.size.y, l.size.z], origin: [l.origin.x, l.origin.y, l.origin.z], density: l.density ?? SOFT_DEFAULTS.density },
+        shape.surface ?? null
+      );
+    } else "rope" in shape ? info = this.port.rope(shape.rope.points, shape.rope.mass ?? SOFT_DEFAULTS.ropeMass, shape.rope.pinFirst ?? false) : info = this.port.asset(shape.asset);
+    let body = new SoftBody(this.port, info, options.geometry ?? null);
+    return this.bodies.push(body), body;
+  }
+  remove(body) {
+    let index = this.bodies.indexOf(body);
+    index >= 0 && this.bodies.splice(index, 1), body.dispose();
+  }
+  setColliders(colliders) {
+    if (colliders.length > SOFT_MAX_COLLIDERS) throw new GameError("capacity_exceeded", `soft bodies collide with at most ${SOFT_MAX_COLLIDERS} shapes`);
+    for (let i = 0; i < colliders.length; i++) packSoftCollider(this.block, i * SOFT_COLLIDER_FLOATS, colliders[i]);
+    this.port.colliders(this.block, colliders.length);
+  }
+  couple(collider) {
+    if (this.port.couple === void 0) throw new GameError("unsupported_feature", "soft bodies couple to rigid bodies only on the native engine (feature rigid_coupling_1)");
+    return this.port.couple(collider);
+  }
+  uncouple(slot) {
+    this.port.uncouple?.(slot);
+  }
+  get count() {
+    return this.bodies.length;
+  }
+  step(seconds) {
+    this.bodies.length > 0 && this.port.step(seconds);
+  }
+  present() {
+    for (let i = 0; i < this.bodies.length; i++) this.bodies[i].present();
+  }
+  digest() {
+    return this.port.digest();
+  }
+  dispose() {
+    for (let body of this.bodies) body.dispose();
+    this.bodies.length = 0, this.port.dispose();
+  }
+};
+function crumpleDesc(vertices, options) {
+  if (options === void 0) return null;
+  let low = { x: 1 / 0, y: 1 / 0, z: 1 / 0 }, high = { x: -1 / 0, y: -1 / 0, z: -1 / 0 };
+  for (let i = 0; i < vertices.length; i += 3)
+    low.x = Math.min(low.x, vertices[i]), low.y = Math.min(low.y, vertices[i + 1]), low.z = Math.min(low.z, vertices[i + 2]), high.x = Math.max(high.x, vertices[i]), high.y = Math.max(high.y, vertices[i + 1]), high.z = Math.max(high.z, vertices[i + 2]);
+  return packCrumple(options, low, high);
+}
+
+// src/game/cloth/cloth.ts
+var CLOTH_DEFAULTS = {
+  mass: 0.01,
+  stretch: 1e-7,
+  bend: 1e-4,
+  tetherSlack: 0.05,
+  damping: 0.5,
+  gravity: { x: 0, y: -9.81, z: 0 },
+  substeps: 8,
+  thickness: 5e-3,
+  friction: 0.2
+}, MAX_SUBSTEPS2 = 64, MIN_SIDE = 2, PINNING = { none: CLOTH_PIN_NONE, top: CLOTH_PIN_TOP_ROW, corners: CLOTH_PIN_TOP_CORNERS };
+function refuse(what) {
+  throw new GameError("invalid_argument", `cloth ${what}`);
+}
+function nonNegative(value, what) {
+  return Number.isFinite(value) && value >= 0 || refuse(`${what} must be finite and not negative`), value;
+}
+function finite(value, what) {
+  return Number.isFinite(value) || refuse(`${what} must be finite`), value;
+}
+function writeClothOptions(f, r, options) {
+  let substeps = options.substeps ?? CLOTH_DEFAULTS.substeps;
+  (!Number.isInteger(substeps) || substeps < 1 || substeps > (64)) && refuse(`substeps must be a whole number from 1 to ${(64)}`);
+  let mass = options.mass ?? CLOTH_DEFAULTS.mass;
+  Number.isFinite(mass) && mass > 0 || refuse("mass must be positive");
+  let friction = options.friction ?? CLOTH_DEFAULTS.friction;
+  friction >= 0 && friction <= 1 || refuse("friction runs from 0 to 1");
+  let gravity = options.gravity ?? CLOTH_DEFAULTS.gravity;
+  f[CLOTH_MASS] = mass, f[CLOTH_STRETCH] = nonNegative(options.stretch ?? CLOTH_DEFAULTS.stretch, "stretch"), f[CLOTH_BEND] = nonNegative(options.bend ?? CLOTH_DEFAULTS.bend, "bend"), f[CLOTH_TETHER_SLACK] = nonNegative(options.tetherSlack ?? CLOTH_DEFAULTS.tetherSlack, "tetherSlack"), f[CLOTH_DAMPING] = nonNegative(options.damping ?? CLOTH_DEFAULTS.damping, "damping"), f[CLOTH_GRAVITY] = finite(gravity.x, "gravity"), f[CLOTH_GRAVITY + 1] = finite(gravity.y, "gravity"), f[CLOTH_GRAVITY + 2] = finite(gravity.z, "gravity"), r[CLOTH_SUBSTEPS] = substeps, f[CLOTH_THICKNESS] = nonNegative(options.thickness ?? CLOTH_DEFAULTS.thickness, "thickness"), f[CLOTH_FRICTION] = friction;
+}
+function writeClothGrid(f, r, grid) {
+  let side = (n, what) => ((!Number.isInteger(n) || n < (2)) && refuse(`${what} must be a whole number of at least ${(2)}`), n);
+  r[CLOTH_COLUMNS] = side(grid.columns, "columns"), r[CLOTH_ROWS] = side(grid.rows, "rows"), Number.isFinite(grid.spacing) && grid.spacing > 0 || refuse("spacing must be positive"), f[CLOTH_SPACING] = grid.spacing;
+  let put = (at, v) => {
+    f[at] = v === void 0 ? 0 : finite(v.x, "axes"), f[at + 1] = v === void 0 ? 0 : finite(v.y, "axes"), f[at + 2] = v === void 0 ? 0 : finite(v.z, "axes");
+  };
+  put(CLOTH_ORIGIN, grid.origin), put(CLOTH_ACROSS, grid.across), put(CLOTH_DOWN, grid.down), r[CLOTH_PIN] = PINNING[grid.pin ?? "top"];
+}
+function packClothCollider(out, at, collider) {
+  out.fill(0, at, at + CLOTH_COLLIDER_FLOATS);
+  let put = (k, v) => {
+    out[at + k] = v.x, out[at + k + 1] = v.y, out[at + k + 2] = v.z;
+  };
+  "sphere" in collider ? (out[at] = CLOTH_COLLIDER_SPHERE, put(1, collider.sphere.center), out[at + 7] = collider.sphere.radius) : (out[at] = CLOTH_COLLIDER_CAPSULE, put(1, collider.capsule.a), put(4, collider.capsule.b), out[at + 7] = collider.capsule.radius);
+}
+var ClothSheet = class {
+  constructor(port, info, geometry) {
+    this.port = port;
+    this.info = info;
+    this.disposed = false;
+    this.particles = info.particles, this.triangles = info.triangles, this.pins = info.pins, this.geometry = geometry;
+  }
+  get id() {
+    return this.info.id;
+  }
+  get engineHost() {
+    return this.port.engineHost ?? null;
+  }
+  positions() {
+    return this.port.positions(this.info.id, this.particles);
+  }
+  attach(geometry) {
+    this.geometry = geometry;
+  }
+  setOptions(options) {
+    writeClothOptions(this.port.prepare(), this.port.registers, options), this.port.params(this.info.id);
+  }
+  setAnchors(anchors) {
+    this.port.anchors(this.info.id, anchors);
+  }
+  present() {
+    return this.disposed || this.geometry === null ? 0 : this.port.present(this.info.id, this.geometry);
+  }
+  dispose() {
+    this.disposed || (this.disposed = true, this.port.remove(this.info.id));
+  }
+}, Cloths = class {
+  constructor(port) {
+    this.port = port;
+    this.sheets = [];
+    this.block = new Float32Array(CLOTH_COLLIDER_FLOATS * CLOTH_MAX_COLLIDERS);
+  }
+  create(shape, options = {}) {
+    let floats = this.port.prepare();
+    writeClothOptions(floats, this.port.registers, options);
+    let info;
+    if ("grid" in shape) {
+      writeClothGrid(floats, this.port.registers, shape.grid);
+      let pins = shape.grid.pins;
+      info = this.port.grid(pins === void 0 || pins.length === 0 ? null : Uint32Array.from(pins));
+    } else
+      info = this.port.mesh(shape.mesh.positions, shape.mesh.triangles, shape.mesh.pins ?? null);
+    let sheet = new ClothSheet(this.port, info, options.geometry ?? null);
+    return this.sheets.push(sheet), sheet;
+  }
+  remove(sheet) {
+    let index = this.sheets.indexOf(sheet);
+    index >= 0 && this.sheets.splice(index, 1), sheet.dispose();
+  }
+  setColliders(colliders) {
+    if (colliders.length > CLOTH_MAX_COLLIDERS) throw new GameError("capacity_exceeded", `cloth collides with at most ${CLOTH_MAX_COLLIDERS} shapes`);
+    for (let i = 0; i < colliders.length; i++) packClothCollider(this.block, i * CLOTH_COLLIDER_FLOATS, colliders[i]);
+    this.port.colliders(this.block, colliders.length);
+  }
+  couple(collider) {
+    if (this.port.couple === void 0) throw new GameError("unsupported_feature", "cloth couples to rigid bodies only on the native engine (feature rigid_coupling_1)");
+    return this.port.couple(collider);
+  }
+  uncouple(slot) {
+    this.port.uncouple?.(slot);
+  }
+  get count() {
+    return this.sheets.length;
+  }
+  step(seconds) {
+    this.sheets.length > 0 && this.port.step(seconds);
+  }
+  present() {
+    for (let i = 0; i < this.sheets.length; i++) this.sheets[i].present();
+  }
+  digest() {
+    return this.port.digest();
+  }
+  dispose() {
+    for (let sheet of this.sheets) sheet.dispose();
+    this.sheets.length = 0, this.port.dispose();
+  }
+};
+
+// src/game/prefetch/predict.ts
+var DEFAULT_HORIZONS = [1, 3, 8], DEFAULT_MAX_SPEED = 10, DEFAULT_SPREAD = 0.35, DEFAULT_MIN_SPREAD = 1.5, DEFAULT_TURN_PENALTY = 3, DEFAULT_PLAN_INTERVAL = 6, DEFAULT_PREFETCH_BUDGET = 24 * 1024 * 1024, DEFAULT_MAX_PENDING = 8, DEFAULT_MAX_SPECULATIVE = 2, DEFAULT_CANDIDATES = 1024, DEFAULT_TELEPORT = 50, DEFAULT_SMOOTHING = 0.3, IDLE_HORIZON_SCALE = 2, EntryState = { idle: 0, pending: 1, resident: 2, consumed: 3 }, LEVEL_SPAN = 16, TIME_SPAN = 1 << 20, ENTRY_SPAN = 1 << 24, MS = 1e3, EPSILON = 1e-9, NO_SLOT = -1, NO_CELL = -1, SCALE_SLOT = 7, S_PX = 0, S_PY = 1, S_PZ = 2, S_VX = 3, S_VY = 4, S_VZ = 5, S_SIGMA = 6, S_TOP = 7, S_STOP = 8, S_RADIUS = 9, S_LIMIT = 10, S_RELEASE = 11, S_SCALE = 12, S_KEY = 13, S_BYTES = 14, S_DT = 15, S_ELAPSED = 16, S_ARRIVED = 17, S_LAST = 18, S_RATE = 19, S_OWN_PENDING = 20, S_DEMAND = 21, SCRATCH = 22, RATE_SMOOTHING = 0.25, LOADED_SHARE = 0.5, DEFAULT_SATURATION_SECONDS = 2, LinkLoad = { free: 0, loaded: 1, saturated: 2 }, R_X = 0, R_Z = 1, R_VX = 2, R_VZ = 3, R_HORIZON = 4, R_OUT = 5, R_RANGE = 2, T_MAX_SPEED = 0, T_SPREAD = 1, T_MIN_SPREAD = 2, T_TURN = 3, T_RELEASE = 4, T_TELEPORT = 5, T_SMOOTHING = 6, T_SATURATION = 7, StreamPredictor = class {
+  constructor(layer, assets, options = {}) {
+    this.stats = { plans: 0, requested: 0, reprioritised: 0, released: 0, consumed: 0, pendingBytes: 0, pending: 0, tracked: 0 };
+    this.local = new Float64Array(3);
+    this.previous = new Float64Array(3);
+    this.velocity = new Float64Array(3);
+    this.s = new Float64Array((22));
+    this.r = new Float64Array(6);
+    this.trackedCount = 0;
+    this.candidateCount = 0;
+    this.planId = 0;
+    this.frames = 0;
+    this.hasPrevious = false;
+    this.idleMode = false;
+    this.pendingCount = 0;
+    this.pendingBytes = 0;
+    this.inFlight = 0;
+    this.linkLoad = LinkLoad.free;
+    this.prefetchAllowed = true;
+    this.layer = layer, this.assets = assets;
+    let entries = layer.entries;
+    this.state = new Uint8Array(entries), this.priority = new Uint8Array(entries), this.time = new Float64Array(entries).fill(1 / 0), this.stamp = new Uint32Array(entries), this.slot = new Int32Array(entries).fill((-1)), this.tracked = new Int32Array(entries), this.keys = new Float64Array(Math.max(1, options.capacity ?? (1024)));
+    let horizons = options.horizons ?? DEFAULT_HORIZONS;
+    this.horizons = Float64Array.from(horizons.length > 0 ? horizons : DEFAULT_HORIZONS), this.tuning = Float64Array.of(
+      options.maxSpeed ?? (10),
+      options.spread ?? (0.35),
+      Math.max((1e-9), options.minSpread ?? (1.5)),
+      Math.max(1, options.turnPenalty ?? (3)),
+      options.releaseSeconds ?? this.horizons[this.horizons.length - 1] * 2,
+      options.teleport ?? (50),
+      Math.min(1, Math.max((1e-9), options.smoothing ?? (0.3))),
+      Math.max((1e-9), options.saturationSeconds ?? (2))
+    ), this.budget = Math.max(0, Math.floor(options.budgetBytes ?? DEFAULT_PREFETCH_BUDGET)), this.interval = Math.max(1, Math.floor(options.interval ?? (6))), this.maxPending = Math.max(1, options.maxPending ?? (8)), this.maxSpeculative = Math.max(1, options.maxSpeculative ?? (2));
+    let reach = options.reach ?? null;
+    if (this.reach = reach, this.reachCell = new Int32Array(reach === null ? 0 : layer.count), reach !== null) for (let i = 0; i < layer.count; i++) this.reachCell[i] = reach.cellAt(layer.x[i], layer.z[i]);
+  }
+  attach(assets) {
+    assets !== this.assets && (this.releaseAll(), this.assets = assets);
+  }
+  set idle(on) {
+    this.idleMode = on;
+  }
+  get idle() {
+    return this.idleMode;
+  }
+  get stopTime() {
+    return this.s[(8)];
+  }
+  get bytesPending() {
+    return this.pendingBytes;
+  }
+  get speed() {
+    let v = this.velocity;
+    return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  }
+  velocityInto(out) {
+    out[0] = this.velocity[0], out[1] = this.velocity[1], out[2] = this.velocity[2];
+  }
+  activeHorizons(depth) {
+    return this.idleMode && depth.horizons > 1 ? this.horizons.length : Math.min(this.horizons.length, Math.max(1, depth.horizons));
+  }
+  horizonLimit(depth) {
+    let limit = this.horizons[this.activeHorizons(depth) - 1];
+    return this.idleMode && depth.horizons > 1 ? limit * (2) : limit;
+  }
+  frame(eye, dtSeconds) {
+    this.s[(15)] = dtSeconds, this.step(eye);
+  }
+  frameAt(eye, clock2, slot) {
+    this.s[(15)] = clock2[slot], this.step(eye);
+  }
+  get load() {
+    return this.linkLoad;
+  }
+  get throughput() {
+    return this.s[(19)];
+  }
+  step(eye) {
+    this.s[(15)] > 0 && (this.s[(16)] += this.s[(15)]), this.layer.toLocal(eye, this.local, 0, true), this.observe();
+    let due = this.frames % this.interval === 0;
+    this.frames++, due && this.assets !== null && this.assets.prefetch !== void 0 && this.plan();
+  }
+  observe() {
+    let dt = this.s[(15)], position = this.local, previous = this.previous, v = this.velocity, first = !this.hasPrevious, dx = position[0] - previous[0], dy = position[1] - previous[1], dz = position[2] - previous[2];
+    previous[0] = position[0], previous[1] = position[1], previous[2] = position[2], this.hasPrevious = true;
+    let limit = this.tuning[(5)] / this.layer.place[(7)];
+    if (first || dx * dx + dy * dy + dz * dz > limit * limit) {
+      v[0] = 0, v[1] = 0, v[2] = 0;
+      return;
+    }
+    if (!(dt > 0)) return;
+    let a = this.tuning[(6)];
+    v[0] += (dx / dt - v[0]) * a, v[1] += (dy / dt - v[1]) * a, v[2] += (dz / dt - v[2]) * a;
+  }
+  plan() {
+    let layer = this.layer, assets = this.assets, s = this.s, tuning = this.tuning;
+    this.planId = this.planId + 1 >>> 0 || 1, this.stats.plans++;
+    let depth = prefetchDepth(assets?.networkHint?.() ?? null);
+    this.prefetchAllowed = depth.prefetch;
+    let idle = this.idleMode && depth.horizons > 1, active = idle ? this.horizons.length : Math.min(this.horizons.length, Math.max(1, depth.horizons));
+    s[(10)] = idle ? this.horizons[active - 1] * (2) : this.horizons[active - 1], s[(11)] = Math.max(tuning[(4)], s[(10)] * 2), this.linkLoad = this.measureLoad(), this.linkLoad !== LinkLoad.free && (s[(10)] = this.horizons[0], this.prefetchAllowed = false), s[(12)] = layer.place[(7)], s[(9)] = layer.needRadius() / s[(12)], s[(0)] = this.local[0], s[(1)] = this.local[1], s[(2)] = this.local[2];
+    let v = this.velocity;
+    s[(3)] = v[0], s[(4)] = v[1], s[(5)] = v[2];
+    let speed = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    s[(6)] = Math.max(tuning[(2)] / s[(12)], speed * tuning[(1)]), s[(7)] = Math.max(tuning[(0)] / s[(12)], speed), s[(8)] = 1 / 0;
+    let reach = this.reach;
+    if (reach !== null) {
+      let r = this.r;
+      r[(0)] = s[(0)], r[(1)] = s[(2)], r[(2)] = s[(7)] * s[(11)] * tuning[(3)] + s[(9)], reach.updateFrom(r), r[(0)] = s[(0)], r[(1)] = s[(2)], r[(2)] = s[(3)], r[(3)] = s[(5)], r[(4)] = s[(11)], reach.stopTimeInto(r), s[(8)] = r[(5)];
+    }
+    let range = s[(9)] + layer.maxRadius + s[(7)] * s[(11)], cell = layer.cellSize, c0 = Math.max(0, Math.floor((s[(0)] - range - layer.originX) / cell)), c1 = Math.min(layer.cols - 1, Math.floor((s[(0)] + range - layer.originX) / cell)), r0 = Math.max(0, Math.floor((s[(2)] - range - layer.originZ) / cell)), r1 = Math.min(layer.rows - 1, Math.floor((s[(2)] + range - layer.originZ) / cell));
+    this.candidateCount = 0;
+    for (let row = r0; row <= r1; row++)
+      for (let col = c0; col <= c1; col++) {
+        let c = row * layer.cols + col, end = layer.cellStart[c + 1];
+        for (let k = layer.cellStart[c]; k < end; k++) this.consider(layer.cellItems[k]);
+      }
+    this.refresh(), this.issue(), this.stats.pendingBytes = this.pendingBytes, this.stats.pending = this.pendingCount, this.stats.tracked = this.trackedCount;
+  }
+  consider(item) {
+    let layer = this.layer, s = this.s, wx = layer.x[item] - s[(0)], wy = layer.y[item] - s[(1)], wz = layer.z[item] - s[(2)], distance = Math.sqrt(wx * wx + wy * wy + wz * wz), radius = s[(9)], r = layer.radius[item], top = s[(7)], release = s[(11)];
+    if (distance - r - radius > top * release) return;
+    let held = layer.held, route = distance;
+    if (this.reach !== null) {
+      let at = this.reachCell[item], path = at === (-1) ? 1 / 0 : this.reach.distance[at];
+      path > route && (route = path);
+    }
+    let vx = s[(3)], vy = s[(4)], vz = s[(5)], sigma = s[(6)], stop = s[(8)], limit = s[(10)], scale = s[(12)], turnPenalty = this.tuning[(3)], first = this.horizons[0];
+    for (let e = layer.entryStart[item]; e < layer.entryStart[item + 1]; e++) {
+      let within = layer.entryWithin[e] / scale, reachDistance = (within < radius ? within : radius) + r, t = 0;
+      if (distance > reachDistance) {
+        let c = distance * distance - reachDistance * reachDistance, a = vx * vx + vy * vy + vz * vz - sigma * sigma, b = -2 * (wx * vx + wy * vy + wz * vz + reachDistance * sigma), motion = 1 / 0;
+        if (Math.abs(a) < (1e-9))
+          b < 0 && (motion = -c / b);
+        else {
+          let disc = b * b - 4 * a * c;
+          if (disc >= 0) {
+            let root = Math.sqrt(disc), t1 = (-b - root) / (2 * a), t2 = (-b + root) / (2 * a);
+            a > 0 ? motion = t2 < 0 ? 1 / 0 : t1 > 0 ? t1 : 0 : motion = t1 > t2 ? t1 : t2;
+          }
+        }
+        if (motion > stop) {
+          let sx = wx - vx * stop, sy = wy - vy * stop, sz = wz - vz * stop, gap = (Math.sqrt(sx * sx + sy * sy + sz * sz) - reachDistance) / sigma;
+          motion = gap > stop ? gap : stop;
+        }
+        let turn = route === 1 / 0 ? 1 / 0 : (route - reachDistance) / top * turnPenalty, lower = (distance - reachDistance) / top;
+        t = motion < turn ? motion : turn, t < lower && (t = lower);
+      }
+      if (this.stamp[e] = this.planId, this.time[e] = t, t > limit || held !== null && held(e)) continue;
+      let level = layer.entryLevel[e], priority = ChunkPriority.prefetch;
+      if (level === 0 && t <= first) priority = ChunkPriority.soon;
+      else if (!this.prefetchAllowed) continue;
+      let state = this.state[e];
+      if (state !== EntryState.idle && !(state === EntryState.pending && priority < this.priority[e])) continue;
+      let quantised = t * (1e3) < TIME_SPAN - 1 ? Math.floor(t * (1e3)) : TIME_SPAN - 1;
+      s[(13)] = ((priority * (16) + level) * TIME_SPAN + quantised) * ENTRY_SPAN + e, this.candidate();
+    }
+  }
+  candidate() {
+    let keys = this.keys, key = this.s[(13)];
+    if (this.candidateCount < keys.length) {
+      keys[this.candidateCount++] = key;
+      return;
+    }
+    let worst = 0;
+    for (let i = 1; i < this.candidateCount; i++) keys[i] > keys[worst] && (worst = i);
+    key < keys[worst] && (keys[worst] = key);
+  }
+  measureLoad() {
+    let flow = this.layer.flow;
+    if (flow === null) return LinkLoad.free;
+    let s = this.s, delivered = flow[FLOW_DELIVERED] + s[(17)], elapsed = s[(16)];
+    if (elapsed > 0) {
+      if (s[(21)] > 0) {
+        let rate = (delivered - s[(18)]) / elapsed;
+        s[(19)] = s[(19)] > 0 ? s[(19)] + (rate - s[(19)]) * (0.25) : rate;
+      }
+      s[(18)] = delivered, s[(16)] = 0;
+    }
+    let demand = flow[FLOW_BACKLOG] + s[(20)];
+    if (s[(21)] = demand, demand <= 0) return LinkLoad.free;
+    let drain = s[(19)] * this.tuning[(7)];
+    return demand > drain ? LinkLoad.saturated : demand > drain * (0.5) ? LinkLoad.loaded : LinkLoad.free;
+  }
+  refresh() {
+    let assets = this.assets, planId = this.planId, release = this.s[(11)];
+    this.inFlight = 0, this.s[(20)] = 0;
+    for (let i = this.trackedCount - 1; i >= 0; i--) {
+      let e = this.tracked[i], path = this.layer.paths[e], state = this.state[e];
+      if (state === EntryState.pending || state === EntryState.resident) {
+        let resident = assets?.resident?.(path) === true, pending = !resident && assets?.pending?.(path) === true;
+        resident ? (state === EntryState.pending && (this.s[(17)] += this.layer.entryBytes[e]), state = EntryState.resident) : pending || (state = EntryState.consumed, this.stats.consumed++, this.untrackBytes(e)), this.state[e] = state;
+      }
+      let keep = this.stamp[e] === planId && this.time[e] <= release;
+      keep && state === EntryState.pending && (this.s[(20)] += this.layer.entryBytes[e], this.priority[e] === ChunkPriority.prefetch && this.inFlight++), !keep && ((state === EntryState.pending || state === EntryState.resident) && (assets?.cancelPrefetch?.(path), this.stats.released++, this.untrackBytes(e)), this.state[e] = EntryState.idle, this.untrack(i));
+    }
+  }
+  issue() {
+    let assets = this.assets, keys = this.keys, n = this.candidateCount;
+    if (heapSort(keys, n), assets === null || assets.prefetch === void 0) return;
+    let busy = this.layer.busy !== null && this.layer.busy();
+    for (let i = 0; i < n; i++) {
+      let key = keys[i], entry = key % ENTRY_SPAN | 0, priority = Math.floor(key / ENTRY_SPAN / TIME_SPAN / (16)) | 0, state = this.state[entry], path = this.layer.paths[entry];
+      if (state === EntryState.pending) {
+        assets.prefetch(path, priority) && (this.priority[entry] = priority, this.stats.reprioritised++);
+        continue;
+      }
+      if (this.linkLoad !== LinkLoad.free || this.pendingCount >= this.maxPending || busy && priority === ChunkPriority.prefetch || priority === ChunkPriority.prefetch && this.inFlight >= this.maxSpeculative) continue;
+      let bytes = this.layer.entryBytes[entry];
+      if (!(this.pendingBytes + bytes > this.budget && (this.s[(13)] = key, this.s[(14)] = bytes, !this.evict()))) {
+        if (!assets.prefetch(path, priority)) {
+          this.state[entry] = EntryState.consumed, this.track(entry);
+          continue;
+        }
+        this.state[entry] = assets.resident?.(path) === true ? EntryState.resident : EntryState.pending, this.priority[entry] = priority, this.track(entry), this.pendingBytes += bytes, this.pendingCount++, priority === ChunkPriority.prefetch && this.state[entry] === EntryState.pending && this.inFlight++, this.stats.requested++;
+      }
+    }
+  }
+  evict() {
+    let assets = this.assets, key = this.s[(13)], bytes = this.s[(14)];
+    for (; this.pendingBytes + bytes > this.budget; ) {
+      let worst = (-1), worstKey = key;
+      for (let i = 0; i < this.trackedCount; i++) {
+        let e2 = this.tracked[i], state = this.state[e2];
+        if (state !== EntryState.resident && state !== EntryState.pending) continue;
+        let t = this.time[e2], quantised = t * (1e3) < TIME_SPAN - 1 ? Math.floor(t * (1e3)) : TIME_SPAN - 1, k = ((this.priority[e2] * (16) + this.layer.entryLevel[e2]) * TIME_SPAN + quantised) * ENTRY_SPAN + e2;
+        k > worstKey && (worstKey = k, worst = i);
+      }
+      if (worst === (-1)) return false;
+      let e = this.tracked[worst];
+      assets?.cancelPrefetch?.(this.layer.paths[e]), this.stats.released++, this.untrackBytes(e), this.state[e] = EntryState.idle, this.untrack(worst);
+    }
+    return true;
+  }
+  track(entry) {
+    this.slot[entry] === (-1) && (this.slot[entry] = this.trackedCount, this.tracked[this.trackedCount++] = entry);
+  }
+  untrack(index) {
+    let entry = this.tracked[index], last = this.tracked[--this.trackedCount];
+    this.tracked[index] = last, this.slot[last] = index, this.slot[entry] = (-1);
+  }
+  untrackBytes(entry) {
+    let left = this.pendingBytes - this.layer.entryBytes[entry];
+    this.pendingBytes = left > 0 ? left : 0, this.pendingCount > 0 && this.pendingCount--;
+  }
+  releaseAll() {
+    let assets = this.assets;
+    for (let i = this.trackedCount - 1; i >= 0; i--) {
+      let e = this.tracked[i], state = this.state[e];
+      (state === EntryState.pending || state === EntryState.resident) && (assets?.cancelPrefetch?.(this.layer.paths[e]), this.stats.released++), this.state[e] = EntryState.idle, this.slot[e] = (-1);
+    }
+    this.trackedCount = 0, this.pendingBytes = 0, this.pendingCount = 0;
+  }
+  reset() {
+    this.releaseAll(), this.hasPrevious = false, this.velocity.fill(0), this.frames = 0;
+  }
+};
+function cone(wx, wy, wz, vx, vy, vz, reach, sigma) {
+  let c = wx * wx + wy * wy + wz * wz - reach * reach;
+  if (c <= 0) return 0;
+  let a = vx * vx + vy * vy + vz * vz - sigma * sigma, b = -2 * (wx * vx + wy * vy + wz * vz + reach * sigma);
+  if (Math.abs(a) < (1e-9)) return b < 0 ? -c / b : 1 / 0;
+  let disc = b * b - 4 * a * c;
+  if (disc < 0) return 1 / 0;
+  let root = Math.sqrt(disc), t1 = (-b - root) / (2 * a), t2 = (-b + root) / (2 * a);
+  return a > 0 ? t2 < 0 ? 1 / 0 : t1 > 0 ? t1 : 0 : t1 > t2 ? t1 : t2;
+}
+function heapSort(keys, n) {
+  for (let start = (n >> 1) - 1; start >= 0; start--) siftDown(keys, start, n);
+  for (let end = n - 1; end > 0; end--) {
+    let top = keys[0];
+    keys[0] = keys[end], keys[end] = top, siftDown(keys, 0, end);
+  }
+}
+function siftDown(keys, start, end) {
+  let root = start, value = keys[root];
+  for (; ; ) {
+    let child = 2 * root + 1;
+    if (child >= end || (child + 1 < end && keys[child + 1] > keys[child] && child++, keys[child] <= value)) break;
+    keys[root] = keys[child], root = child;
+  }
+  keys[root] = value;
+}
+
+export { CENTERED_FIXED_UNITS, CENTERED_MAX_EXTENT, CLOTH_DEFAULTS, ClothSheet, Cloths, DEFAULT_CANDIDATES, DEFAULT_HORIZONS, DEFAULT_MAX_PENDING, DEFAULT_MAX_SPECULATIVE, DEFAULT_MAX_SPEED, DEFAULT_MIN_SPREAD, DEFAULT_PLAN_INTERVAL, DEFAULT_PREFETCH_BUDGET, DEFAULT_SATURATION_SECONDS, DEFAULT_SMOOTHING, DEFAULT_SPREAD, DEFAULT_TELEPORT, DEFAULT_TURN_PENALTY, EntryState, FrameInput, InputActions, InputDevice, LOOP_MAX_REGION_ROWS, LOOP_PROBE_GLOBAL, LongPressGesture, LoweredLoop, OrientationState, PinchGesture, PointerDelta, PointerState, RECORDED_EVENT_BYTES, SOFT_DEFAULTS, STAGE_TIME, STAGE_X, STAGE_Y, STAGE_Z, SeededRandom, SoftBodies, SoftBody, StreamPredictor, SwipeGesture, TapGesture, WheelState, cone, configureLoops, crumpleDesc, drainSource, loopEngineOf, loopProbe, lowerLoop, setLoopEngine, vmLoopEngine };