@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-MOBSBXVE.mjs

@@ -0,0 +1,2391 @@
+import { Op, MLP_MAX_WIDTH, MLP_MAX_OUTPUTS, CURVE_STEP, CURVE_LINEAR, CURVE_HERMITE, LUT_LINEAR, LUT_WRAP, SAMPLE_NEAREST, SAMPLE_BILINEAR, SAMPLER_WORDS, QFILTER_EQUAL, QFILTER_ANY, QFILTER_NONE, QUERY_SEGMENT, XOP, xopRange, XOP_RANGE, SIMD_REDUCE, SIMD_CROSS, SIMD_NORMALIZE, SIMD_LENGTH, SIMD_DOT, SIMD_DOT_F32, SIMD_EXTRACT, SIMD_PACK, SIMD_REPLACE, SIMD_SHUFFLE, ACCESS_INDEXED, GROUP_DEFAULT, XOP_QUERY, crossRow, stageEndingOp, SORT_RADIX_BITS, deferredService, serviceOf, RING_HEADER_WORDS, DEFAULT_EVENT_CAPACITY, DataMachine, RING_COUNT, RING_DROPPED, SERVICE_SIGNATURES, operandCount, lookupOp, LOOKUP_OP, CROSS_OP, XOP_GATHER, XOP_FIELD, XOP_QRANK, runLanes, XOP_MLP_IN, XOP_MLP_OUT, XOP_MLP_MOE, recurSub, XOP_RECUR_IN, recurStateWords, RECUR, SORT_KEY_MASK, SORT_DESCENDING, sortKey, XOP_SORT, XOP_TOPK, XOP_GROUP, SCAN_F_INCLUSIVE, SCAN_I_INCLUSIVE, SCAN_F_EXCLUSIVE, CROSS_BLOCK, SCATTER_FADD, ARG_FMAX, REDUCE_FSUM, REDUCE_FMIN, REDUCE_FMAX, LOOP_COUNT_F32, CANONICAL_NAN32, RECUR_KIND_MASK, RECUR_WIDE, REDUCE_UMIN, REDUCE_IMAX, REDUCE_IMIN, REDUCE_ISUM, log2, log, exp, atan, acos, asin, tan, cos, sin, atan2, pow, CURVE_HEADER, LUT1_HEADER, SAMPLE_NORMAL_X, SAMPLE_NORMAL_Y, f32From, QUERY_CONE, QUERY_BOX, SIMD_MAP, SIMD_MAP_OPS, SIMD_WIDTH_MASK, XOP_QSTOP, XOP_COMPONENTS_EDGES, XOP_COMPONENTS_GRID, GRAPH_EMPTY, XOP_REACH_GRID, f32Bits, ARG_UMIN, ARG_IMAX, ARG_IMIN, ARG_FMIN, SIMD_LANE_BITS, SIMD_LANE_MASK, QUERY_SHAPE, QUERY_SPHERE, QUERY_FILTERED, SIMD_SCALAR_A, SIMD_SCALAR_B, SIMD_SCALAR_C, CELL_WRAP, RECUR_EXCLUSIVE, LUT2_HEADER } from './chunk-SMK6JU2F.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// src/game/kernel/toolkit.ts
+var toolkit_exports = {};
+__export(toolkit_exports, {
+  Csr: () => Csr,
+  KernelSchedule: () => KernelSchedule,
+  KernelWatch: () => KernelWatch,
+  NEVER: () => (4294967295),
+  NO_LABEL: () => (4294967295),
+  UNREACHED: () => (4294967295),
+  WALL: () => (4294967295),
+  bfsGraph: () => bfsGraph,
+  bfsGrid: () => bfsGrid,
+  componentsEdges: () => componentsEdges,
+  componentsGrid: () => componentsGrid,
+  findNode: () => findNode,
+  floodFill: () => floodFill,
+  gridCells: () => gridCells,
+  isDue: () => isDue,
+  nearestLabelGrid: () => nearestLabelGrid,
+  propagateGraph: () => propagateGraph,
+  propagateGrid: () => propagateGrid,
+  reachSeeded: () => reachSeeded,
+  stagger: () => stagger,
+  unionNodes: () => unionNodes
+});
+var NEVER = 4294967295, UNREACHED = 4294967295, NO_LABEL = 4294967295, EMPTY = 4294967295, MIN_SLOTS = 64, WORD_BITS = 32;
+function isDue(tick, wake) {
+  return wake !== (4294967295) && (tick - wake | 0) >= 0;
+}
+function ascending(a, b) {
+  return a - b;
+}
+function powerOfTwo(n) {
+  let p = 1;
+  for (; p < n; ) p *= 2;
+  return p;
+}
+var KernelSchedule = class {
+  constructor(capacity, horizon = (64)) {
+    this.now = 0;
+    this.len = 0;
+    this.count = 0;
+    let slots = powerOfTwo(Math.max(horizon, (64)));
+    this.mask = slots - 1, this.head = new Uint32Array(slots).fill((4294967295)), this.next = new Uint32Array(capacity).fill((4294967295)), this.prev = new Uint32Array(capacity).fill((4294967295)), this.slotOf = new Uint32Array(capacity).fill((4294967295)), this.rows = new Uint32Array(capacity);
+  }
+  rebuild(wake, count, now) {
+    if (count > this.next.length || wake.length < count) throw new GameError("capacity_exceeded", "the schedule holds fewer rows than the table");
+    this.head.fill((4294967295)), this.slotOf.fill((4294967295)), this.count = count, this.now = now >>> 0, this.len = 0;
+    for (let row = 0; row < count; row++) this.insert(row, wake[row] >>> 0);
+  }
+  unlink(row) {
+    let slot = this.slotOf[row];
+    if (slot === (4294967295)) return;
+    let prev = this.prev[row], next = this.next[row];
+    prev === (4294967295) ? this.head[slot] = next : this.next[prev] = next, next !== (4294967295) && (this.prev[next] = prev), this.slotOf[row] = (4294967295);
+  }
+  insert(row, wake) {
+    if (wake === (4294967295)) return;
+    let slot = (isDue(this.now, wake) ? this.now + 1 >>> 0 : wake) & this.mask, head = this.head[slot];
+    this.next[row] = head, this.prev[row] = (4294967295), head !== (4294967295) && (this.prev[head] = row), this.head[slot] = row, this.slotOf[row] = slot;
+  }
+  set(row, wake) {
+    if (row >= this.count) throw new GameError("invalid_argument", `row ${row} is outside the schedule`);
+    this.unlink(row), this.insert(row, wake >>> 0);
+  }
+  collect(tick, wake) {
+    tick >>>= 0, this.len = 0;
+    let elapsed = tick - this.now >>> 0, slots = elapsed > this.mask ? this.mask + 1 : elapsed;
+    for (let step = 0; step < slots; step++) {
+      let slot = tick - step & this.mask, row = this.head[slot];
+      for (; row !== (4294967295); )
+        isDue(tick, wake[row] >>> 0) && (this.rows[this.len++] = row), row = this.next[row];
+    }
+    this.now = tick;
+    let due = this.rows.subarray(0, this.len);
+    return due.sort(ascending), due;
+  }
+  due() {
+    return this.rows.subarray(0, this.len);
+  }
+  settle(wake) {
+    for (let k = 0; k < this.len; k++) {
+      let row = this.rows[k];
+      this.unlink(row), this.insert(row, wake[row] >>> 0);
+    }
+  }
+  into(selection) {
+    if (selection.rows.length < this.len) throw new GameError("capacity_exceeded", "the selection is smaller than the due rows");
+    return selection.rows.set(this.due()), selection.length = this.len, selection;
+  }
+};
+function stagger(tick, every, ids, count, out) {
+  let period = Math.max(1, every >>> 0), phase = (tick >>> 0) % period, len = 0;
+  if (ids === null)
+    for (let row = phase; row < count && len < out.length; row += period) out[len++] = row;
+  else
+    for (let row = 0; row < count; row++) (ids[row] >>> 0) % period === phase && len < out.length && (out[len++] = row);
+  return len;
+}
+var KernelWatch = class {
+  constructor(columns, capacity) {
+    this.len = 0;
+    this.count = 0;
+    this.primed = false;
+    this.views = /* @__PURE__ */ new Map();
+    this.columns = columns, this.capacity = capacity, this.shadow = new Uint32Array(columns * capacity), this.marks = new Uint32Array(Math.ceil(capacity / (32))), this.rows = new Uint32Array(capacity);
+  }
+  mark(row) {
+    row < this.capacity && (this.marks[row >>> 5] |= 1 << (row & 31));
+  }
+  markAll() {
+    this.primed = false;
+  }
+  view(column) {
+    let view = this.views.get(column);
+    return view === void 0 && (view = words(column), this.views.set(column, view)), view;
+  }
+  check(watched, count) {
+    if (watched.length !== this.columns || count > this.capacity) throw new GameError("invalid_argument", "watched columns do not match the watch");
+  }
+  changed(watched, count) {
+    this.check(watched, count);
+    let primed = this.primed && count === this.count;
+    for (let c = 0; c < watched.length; c++) {
+      let column = this.view(watched[c]), base = c * this.capacity;
+      for (let row = 0; row < count; row++) column[row] !== this.shadow[base + row] && (this.marks[row >>> 5] |= 1 << (row & 31));
+    }
+    this.len = 0;
+    for (let row = 0; row < count; row++) (!primed || (this.marks[row >>> 5] & 1 << (row & 31)) !== 0) && (this.rows[this.len++] = row);
+    return this.rows.subarray(0, this.len);
+  }
+  commit(watched, count) {
+    this.check(watched, count);
+    let all = !this.primed || count !== this.count;
+    for (let c = 0; c < watched.length; c++) {
+      let column = this.view(watched[c]), base = c * this.capacity;
+      if (all) for (let row = 0; row < count; row++) this.shadow[base + row] = column[row];
+      else for (let k = 0; k < this.len; k++) this.shadow[base + this.rows[k]] = column[this.rows[k]];
+    }
+    if (all) this.marks.fill(0);
+    else for (let k = 0; k < this.len; k++) this.marks[this.rows[k] >>> 5] &= ~(1 << (this.rows[k] & 31));
+    this.count = count, this.primed = true;
+  }
+  into(selection) {
+    if (selection.rows.length < this.len) throw new GameError("capacity_exceeded", "the selection is smaller than the changed rows");
+    return selection.rows.set(this.rows.subarray(0, this.len)), selection.length = this.len, selection;
+  }
+};
+function words(column) {
+  return column instanceof Uint8Array ? column : new Uint32Array(column.buffer, column.byteOffset, column.length);
+}
+function gridCells(grid) {
+  return grid.width * grid.height * grid.depth;
+}
+var NEAR = new Uint32Array(6), PICK = new Uint32Array(7);
+function around(grid, cell, out) {
+  let w = grid.width, h = grid.height, x = cell % w, y = Math.floor(cell / w) % h, z = Math.floor(cell / (w * h)), n = 0;
+  return x > 0 && (out[n++] = cell - 1), x + 1 < w && (out[n++] = cell + 1), y > 0 && (out[n++] = cell - w), y + 1 < h && (out[n++] = cell + w), z > 0 && (out[n++] = cell - w * h), z + 1 < grid.depth && (out[n++] = cell + w * h), n;
+}
+function find(parent, start) {
+  let x = start;
+  for (; parent[x] !== x; ) {
+    let up = parent[parent[x]];
+    parent[x] = up, x = up;
+  }
+  return x;
+}
+function union(parent, a, b) {
+  let ra = find(parent, a), rb = find(parent, b);
+  ra < rb ? parent[rb] = ra : rb < ra && (parent[ra] = rb);
+}
+function finish(parent, labels, n, active) {
+  let components = 0;
+  for (let i = 0; i < n; i++) {
+    if (!active(i)) {
+      labels[i] = (4294967295);
+      continue;
+    }
+    let root = find(parent, i);
+    root === i && components++, labels[i] = root;
+  }
+  return components;
+}
+function componentsEdges(nodes, a, b, parent, labels) {
+  if (parent.length < nodes || labels.length < nodes || a.length !== b.length) throw new GameError("capacity_exceeded", "graph buffers are too small");
+  for (let i = 0; i < nodes; i++) parent[i] = i;
+  for (let k = 0; k < a.length; k++) a[k] < nodes && b[k] < nodes && union(parent, a[k], b[k]);
+  return finish(parent, labels, nodes, () => true);
+}
+function componentsGrid(grid, values, empty, parent, labels) {
+  let cells = gridCells(grid);
+  if (values.length < cells || parent.length < cells || labels.length < cells) throw new GameError("capacity_exceeded", "grid buffers are too small");
+  for (let i = 0; i < cells; i++) parent[i] = i;
+  let w = grid.width, plane = w * grid.height;
+  for (let cell = 0; cell < cells; cell++) {
+    let v = values[cell];
+    if (v === empty) continue;
+    let x = cell % w, y = Math.floor(cell / w) % grid.height;
+    x + 1 < w && values[cell + 1] === v && union(parent, cell, cell + 1), y + 1 < grid.height && values[cell + w] === v && union(parent, cell, cell + w), cell + plane < cells && values[cell + plane] === v && union(parent, cell, cell + plane);
+  }
+  return finish(parent, labels, cells, (i) => values[i] !== empty);
+}
+function bfsGrid(grid, passable, sources, dist, queue) {
+  let cells = gridCells(grid);
+  if (passable.length < cells || dist.length < cells || queue.length < cells) throw new GameError("capacity_exceeded", "grid buffers are too small");
+  dist.fill((4294967295), 0, cells);
+  let tail = 0;
+  for (let k = 0; k < sources.length; k++) {
+    let s = sources[k];
+    s < cells && passable[s] !== 0 && dist[s] === (4294967295) && (dist[s] = 0, queue[tail++] = s);
+  }
+  let near = NEAR;
+  for (let head = 0; head < tail; head++) {
+    let cell = queue[head], next = dist[cell] + 1, n = around(grid, cell, near);
+    for (let k = 0; k < n; k++) {
+      let c = near[k];
+      passable[c] !== 0 && dist[c] === (4294967295) && (dist[c] = next, queue[tail++] = c);
+    }
+  }
+  return tail;
+}
+function nearestLabelGrid(grid, dist, queue, reached, sources, sourceLabels, labels) {
+  let cells = gridCells(grid);
+  labels.fill((4294967295), 0, cells);
+  for (let k = 0; k < sources.length; k++) {
+    let s = sources[k];
+    s < cells && dist[s] === 0 && (labels[s] = Math.min(labels[s], sourceLabels[k] >>> 0));
+  }
+  let near = NEAR;
+  for (let q = 0; q < reached; q++) {
+    let cell = queue[q];
+    if (dist[cell] === 0) continue;
+    let n = around(grid, cell, near), best = (4294967295);
+    for (let k = 0; k < n; k++) dist[near[k]] === dist[cell] - 1 && (best = Math.min(best, labels[near[k]]));
+    labels[cell] = best;
+  }
+}
+function floodFill(grid, passable, seeds, label, out, dist, queue) {
+  let reached = bfsGrid(grid, passable, seeds, dist, queue);
+  for (let k = 0; k < reached; k++) out[queue[k]] = label;
+  return reached;
+}
+var Csr = class {
+  constructor(nodes, edges) {
+    this.count = 0;
+    this.offsets = new Uint32Array(nodes + 1), this.targets = new Uint32Array(edges * 2);
+  }
+  build(nodes, a, b) {
+    if (nodes + 1 > this.offsets.length || a.length !== b.length || a.length * 2 > this.targets.length) throw new GameError("capacity_exceeded", "graph buffers are too small");
+    let o = this.offsets;
+    o.fill(0, 0, nodes + 1);
+    let valid = (x, y) => x < nodes && y < nodes && x !== y;
+    for (let k = 0; k < a.length; k++)
+      valid(a[k], b[k]) && (o[a[k] + 1]++, o[b[k] + 1]++);
+    for (let i = 1; i <= nodes; i++) o[i] += o[i - 1];
+    for (let k = 0; k < a.length; k++)
+      valid(a[k], b[k]) && (this.targets[o[a[k]]++] = b[k], this.targets[o[b[k]]++] = a[k]);
+    for (let i = nodes; i >= 1; i--) o[i] = o[i - 1];
+    o[0] = 0;
+    for (let i = 0; i < nodes; i++) this.targets.subarray(o[i], o[i + 1]).sort(ascending);
+    this.count = nodes;
+  }
+  nodes() {
+    return this.count;
+  }
+  neighbours(node) {
+    return this.targets.subarray(this.offsets[node], this.offsets[node + 1]);
+  }
+  maxDegree() {
+    let most = 0;
+    for (let i = 0; i < this.count; i++) most = Math.max(most, this.offsets[i + 1] - this.offsets[i]);
+    return most;
+  }
+};
+function bfsGraph(graph, sources, dist, queue) {
+  let n = graph.nodes();
+  dist.fill((4294967295), 0, n);
+  let tail = 0;
+  for (let k = 0; k < sources.length; k++) {
+    let s = sources[k];
+    s < n && dist[s] === (4294967295) && (dist[s] = 0, queue[tail++] = s);
+  }
+  for (let head = 0; head < tail; head++) {
+    let node = queue[head], next = dist[node] + 1, near = graph.neighbours(node);
+    for (let k = 0; k < near.length; k++)
+      dist[near[k]] === (4294967295) && (dist[near[k]] = next, queue[tail++] = near[k]);
+  }
+  return tail;
+}
+function mostCommon(work) {
+  work.sort(ascending);
+  let best = (4294967295), bestRun = 0, at = 0;
+  for (; at < work.length; ) {
+    let label = work[at], end = at + 1;
+    for (; end < work.length && work[end] === label; ) end++;
+    label !== (4294967295) && end - at > bestRun && (best = label, bestRun = end - at), at = end;
+  }
+  return best;
+}
+function propagateGraph(graph, labels, next, work, rounds) {
+  let n = graph.nodes();
+  for (let round = 0; round < rounds; round++) {
+    let changed = false;
+    for (let node = 0; node < n; node++) {
+      if (labels[node] === (4294967295)) {
+        next[node] = (4294967295);
+        continue;
+      }
+      let near = graph.neighbours(node);
+      work[0] = labels[node];
+      for (let k = 0; k < near.length; k++) work[k + 1] = labels[near[k]];
+      let label = mostCommon(work.subarray(0, near.length + 1));
+      changed || (changed = label !== labels[node]), next[node] = label;
+    }
+    if (labels.set(next.subarray(0, n)), !changed) return round;
+  }
+  return rounds;
+}
+function propagateGrid(grid, labels, next, rounds) {
+  let cells = gridCells(grid), near = NEAR, work = PICK;
+  for (let round = 0; round < rounds; round++) {
+    let changed = false;
+    for (let cell = 0; cell < cells; cell++) {
+      if (labels[cell] === (4294967295)) {
+        next[cell] = (4294967295);
+        continue;
+      }
+      let n = around(grid, cell, near);
+      work[0] = labels[cell];
+      for (let k = 0; k < n; k++) work[k + 1] = labels[near[k]];
+      let label = mostCommon(work.subarray(0, n + 1));
+      changed || (changed = label !== labels[cell]), next[cell] = label;
+    }
+    if (labels.set(next.subarray(0, cells)), !changed) return round;
+  }
+  return rounds;
+}
+var WALL = 4294967295;
+function reachSeeded(grid, labels, dist, queue, seeded, owner) {
+  let cells = gridCells(grid), tail = seeded, near = NEAR;
+  for (let head = 0; head < tail; head++) {
+    let cell = queue[head], next = dist[cell] + 1, n = around(grid, cell, near);
+    for (let k = 0; k < n; k++) {
+      let c = near[k];
+      c < cells && labels[c] !== (4294967295) && dist[c] === (4294967295) && (dist[c] = next, queue[tail++] = c);
+    }
+  }
+  if (owner !== null)
+    for (let q = seeded; q < tail; q++) {
+      let cell = queue[q], n = around(grid, cell, near), best = (4294967295);
+      for (let k = 0; k < n; k++) dist[near[k]] === dist[cell] - 1 && (best = Math.min(best, owner[near[k]]));
+      owner[cell] = best;
+    }
+  return tail;
+}
+function unionNodes(parent, a, b) {
+  union(parent, a, b);
+}
+function findNode(parent, x) {
+  return find(parent, x);
+}
+
+// src/game/kernel/mlp.ts
+var MLP_MAGIC = 1347177795, MLP_MAX_LAYERS = 8, MLP_HEADER_WORDS = 5, MLP_LAYER_WORDS = 6, MLP_MULTIPLIER_LIMIT = 1 << 23, MLP_MAX_SHIFT = 47, MLP_ACC_LIMIT = (1 << 24) - 1, MLP_ACT_LINEAR = 0, MLP_ACT_RELU = 1, INPUT_SPAN = 256, I8_MIN = -128, I8_MAX = 127, BYTES = 4, f32Scratch = new Float32Array(1), u32Scratch = new Uint32Array(f32Scratch.buffer);
+function fromBits(bits) {
+  return u32Scratch[0] = bits, f32Scratch[0];
+}
+function toBits(value) {
+  return f32Scratch[0] = value, u32Scratch[0];
+}
+function int8(v) {
+  return v >= (-128) && v <= (127);
+}
+function parseMlp(words2, length, inputs, outputs) {
+  let word = (k) => words2[k] >>> 0;
+  if (length < (5) || word(0) !== (1347177795)) return null;
+  let count = word(1), zero = word(4) | 0;
+  if (count === 0 || count > (8) || word(2) !== inputs || inputs === 0 || inputs > MLP_MAX_WIDTH || !int8(zero)) return null;
+  let at = (5) + count * (6);
+  if (length < at) return null;
+  let layers = [], width = inputs;
+  for (let l = 0; l < count; l++) {
+    let h = (5) + l * (6), n = word(h), last = l + 1 === count, layerZero = word(h + 4) | 0;
+    if (n === 0 || n > (last ? MLP_MAX_OUTPUTS : MLP_MAX_WIDTH) || word(h + 1) > (1) || word(h + 2) >= MLP_MULTIPLIER_LIMIT || word(h + 3) > (47) || !int8(layerZero)) return null;
+    let stride = Math.ceil(width / (4)), bias = at, weights = bias + n;
+    if (at = weights + n * stride, at > length) return null;
+    layers.push({ inputs: width, outputs: n, activation: word(h + 1), multiplier: word(h + 2), shift: word(h + 3), zero: layerZero, scale: fromBits(word(h + 5)), bias, weights, stride }), width = n;
+  }
+  return width !== outputs ? null : { words: words2, inputs, outputs, scale: fromBits(word(3)), zero, layers };
+}
+function roundHalfEven(t) {
+  let floor = Math.floor(t), rest = t - floor;
+  return rest > 0.5 ? floor + 1 : rest < 0.5 || floor % 2 === 0 ? floor : floor + 1;
+}
+function mlpQuantize(bits, scale, zero) {
+  let t = Math.fround(fromBits(bits) * scale);
+  return t = Number.isNaN(t) ? 0 : Math.min(Math.max(t, -(256)), (256)), Math.min(Math.max(roundHalfEven(t) + zero, (-128)), (127));
+}
+function saturate(acc) {
+  return Math.min(Math.max(acc, -MLP_ACC_LIMIT), MLP_ACC_LIMIT);
+}
+function mlpRequantize(acc, layer) {
+  let a = saturate(acc), magnitude = Math.abs(a) * layer.multiplier, scaled = layer.shift === 0 ? magnitude : Math.floor((magnitude + 2 ** (layer.shift - 1)) / 2 ** layer.shift), signed = a < 0 ? -scaled : scaled, low = layer.activation === (1) ? layer.zero : (-128);
+  return Math.min(Math.max(signed + layer.zero, low), (127));
+}
+function mlpDequantize(acc, layer) {
+  let a = saturate(acc);
+  return layer.activation === (1) && (a = Math.max(a, 0)), toBits(Math.fround(a * layer.scale));
+}
+function byte(word, k) {
+  return word >>> 8 * k << 24 >> 24;
+}
+var firstActs = new Int32Array(MLP_MAX_WIDTH), secondActs = new Int32Array(MLP_MAX_WIDTH);
+function evalMlp(net, inputs, outputs) {
+  evalMlpLane(net, inputs, 0, 1, outputs);
+}
+function evalMlpLane(net, inputs, lane, stride, outputs) {
+  let acts = firstActs, next = secondActs;
+  for (let i = 0; i < net.inputs; i++) acts[i] = mlpQuantize(inputs[i * stride + lane] >>> 0, net.scale, net.zero);
+  let words2 = net.words;
+  for (let l = 0; l < net.layers.length; l++) {
+    let layer = net.layers[l], last = l + 1 === net.layers.length;
+    for (let j = 0; j < layer.outputs; j++) {
+      let acc = words2[layer.bias + j] | 0, row = layer.weights + j * layer.stride;
+      for (let i = 0; i < layer.inputs; i++) acc = acc + byte(words2[row + (i >> 2)] >>> 0, i & 3) * acts[i] | 0;
+      last ? outputs[j] = mlpDequantize(acc, layer) : next[j] = mlpRequantize(acc, layer);
+    }
+    let swap = acts;
+    acts = next, next = swap;
+  }
+}
+function activated(acc, layer) {
+  let a = saturate(acc);
+  return layer.activation === (1) ? Math.max(a, 0) : a;
+}
+function routeMlpLane(net, inputs, lane, stride) {
+  let acts = firstActs, next = secondActs;
+  for (let i = 0; i < net.inputs; i++) acts[i] = mlpQuantize(inputs[i * stride + lane] >>> 0, net.scale, net.zero);
+  let words2 = net.words, best = 0;
+  for (let l = 0; l < net.layers.length; l++) {
+    let layer = net.layers[l], last = l + 1 === net.layers.length, top = 0;
+    for (let j = 0; j < layer.outputs; j++) {
+      let acc = words2[layer.bias + j] | 0, row = layer.weights + j * layer.stride;
+      for (let i = 0; i < layer.inputs; i++) acc = acc + byte(words2[row + (i >> 2)] >>> 0, i & 3) * acts[i] | 0;
+      if (last) {
+        let v = activated(acc, layer);
+        (j === 0 || v > top) && (top = v, best = j);
+      } else next[j] = mlpRequantize(acc, layer);
+    }
+    let swap = acts;
+    acts = next, next = swap;
+  }
+  return best;
+}
+var MOE_MAGIC = 1162825027, MOE_VERSION = 1, MOE_MIN_EXPERTS = 2, MOE_MAX_EXPERTS = 16, MOE_HEADER_WORDS = 5, MOE_ENTRY_WORDS = 2;
+function part(words2, offset, length) {
+  return words2 instanceof Uint32Array ? words2.subarray(offset, offset + length) : Array.prototype.slice.call(words2, offset, offset + length);
+}
+function parseMoe(words2, length, inputs, outputs) {
+  let word = (k) => words2[k] >>> 0;
+  if (length < (5) || word(0) !== (1162825027) || word(1) !== (1)) return null;
+  let count = word(2);
+  if (count < (2) || count > (16) || word(3) !== inputs || word(4) !== outputs) return null;
+  let table = (5) + (count + 1) * (2);
+  if (length < table) return null;
+  let nets = [];
+  for (let k = 0; k <= count; k++) {
+    let at = (5) + k * (2), offset = word(at), size = word(at + 1);
+    if (offset < table || offset + size > length) return null;
+    let net = parseMlp(part(words2, offset, size), size, inputs, k === 0 ? count : outputs);
+    if (net === null) return null;
+    nets.push(net);
+  }
+  return { inputs, outputs, router: nets[0], experts: nets.slice(1) };
+}
+function evalMoeLane(net, inputs, lane, stride, outputs) {
+  let expert = routeMlpLane(net.router, inputs, lane, stride);
+  return evalMlpLane(net.experts[expert], inputs, lane, stride, outputs), expert;
+}
+function moeBlob(inputs, outputs, router, experts) {
+  let table = (5) + (experts.length + 1) * (2), parts = [router, ...experts], total = parts.reduce((sum, p) => sum + p.length, table), words2 = new Uint32Array(total);
+  words2.set([(1162825027), (1), experts.length, inputs, outputs]);
+  let at = table;
+  return parts.forEach((p, k) => {
+    words2[(5) + k * (2)] = at, words2[(5) + k * (2) + 1] = p.length, words2.set(Array.from(p, (w) => w >>> 0), at), at += p.length;
+  }), words2;
+}
+function moe(net, inputs, outputs) {
+  let parsed = parseMoe(net.data, net.data.length, inputs.length, outputs), result = new Array(outputs).fill(0);
+  if (parsed === null) return result;
+  for (let i = 0; i < inputs.length; i++) rowInputs[i] = toBits(Math.fround(inputs[i]));
+  evalMoeLane(parsed, rowInputs, 0, 1, rowOutputs);
+  for (let j = 0; j < outputs; j++) result[j] = fromBits(rowOutputs[j]);
+  return result;
+}
+function mlpBlob(inputs, scale, zero, layers) {
+  let words2 = [(1347177795), layers.length, inputs, toBits(scale), zero >>> 0];
+  for (let l of layers) words2.push(l.outputs, l.activation, l.multiplier, l.shift, l.zero >>> 0, toBits(l.scale));
+  let width = inputs;
+  for (let l of layers) {
+    for (let j = 0; j < l.outputs; j++) words2.push(l.bias[j] >>> 0);
+    let stride = Math.ceil(width / (4));
+    for (let j = 0; j < l.outputs; j++)
+      for (let w = 0; w < stride; w++) {
+        let word = 0;
+        for (let k = 0; k < (4); k++) {
+          let i = w * (4) + k;
+          i < width && (word |= (l.weights[j * width + i] & 255) << 8 * k);
+        }
+        words2.push(word >>> 0);
+      }
+    width = l.outputs;
+  }
+  return Uint32Array.from(words2);
+}
+var rowInputs = new Uint32Array(MLP_MAX_WIDTH), rowOutputs = new Uint32Array(MLP_MAX_OUTPUTS);
+function mlp(net, inputs, outputs) {
+  let parsed = parseMlp(net.data, net.data.length, inputs.length, outputs), result = new Array(outputs).fill(0);
+  if (parsed === null) return result;
+  for (let i = 0; i < inputs.length; i++) rowInputs[i] = toBits(Math.fround(inputs[i]));
+  evalMlp(parsed, rowInputs, rowOutputs);
+  for (let j = 0; j < outputs; j++) result[j] = fromBits(rowOutputs[j]);
+  return result;
+}
+function mlpWords(bytes) {
+  let view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  if (view.byteLength % (4) !== 0 || view.byteLength < (5) * (4)) throw new GameError("invalid_argument", "an mlp weight blob is a whole number of little-endian u32 words with a header");
+  let words2 = new Uint32Array(view.byteLength / (4)), data = new DataView(view.buffer, view.byteOffset, view.byteLength);
+  for (let k = 0; k < words2.length; k++) words2[k] = data.getUint32(k * (4), true);
+  if (words2[0] !== (1347177795) && words2[0] !== (1162825027)) throw new GameError("invalid_argument", "this is not an mlp or mixture-of-experts weight blob (bad magic)");
+  return words2;
+}
+function setMlp(net, words2) {
+  if (words2.length > net.data.length) throw new GameError("capacity_exceeded", `mlp weights of ${words2.length} words do not fit kernel array ${net.name} (${net.data.length} words)`);
+  net.data.fill(0), net.data.set(words2);
+}
+async function loadMlp(net, url) {
+  let response = await fetch(url);
+  if (!response.ok) throw new GameError("asset_load_failed", `mlp weights ${url} failed with ${response.status}`);
+  setMlp(net, mlpWords(await response.arrayBuffer()));
+}
+
+// src/game/kernel/lookup.ts
+var fround = Math.fround, COORD_LIMIT = 16777216;
+function coord(t) {
+  return Number.isNaN(t) ? 0 : Math.min(Math.max(t, -(16777216)), (16777216));
+}
+function index(i, n, wrap) {
+  return wrap ? (i % n + n) % n : Math.min(Math.max(i, 0), n - 1);
+}
+function lerp(a, b, t) {
+  return fround(a + fround(fround(b - a) * t));
+}
+function f(word) {
+  return f32From(word >>> 0);
+}
+function curve(record, at, channel, x) {
+  let kind = record[at], n = record[at + 1], c = record[at + 2], keys = at + CURVE_HEADER, values = keys + n, value = (k) => f(record[values + k * c + channel]);
+  if (n === 1 || !(x > f(record[keys]))) return value(0);
+  if (!(x < f(record[keys + n - 1]))) return value(n - 1);
+  let s = 0;
+  for (; s + 2 < n && f(record[keys + s + 1]) <= x; ) s++;
+  let k0 = f(record[keys + s]), k1 = f(record[keys + s + 1]), v0 = value(s), v1 = value(s + 1), t = fround(fround(x - k0) / fround(k1 - k0));
+  if (kind === CURVE_STEP) return v0;
+  if (kind === CURVE_LINEAR) return lerp(v0, v1, t);
+  if (kind === CURVE_HERMITE) {
+    let tangents = values + n * c, m0 = f(record[tangents + s * c + channel]), m1 = f(record[tangents + (s + 1) * c + channel]), h = fround(k1 - k0), t2 = fround(t * t), t3 = fround(t2 * t), a = fround(t3 + t3), b = fround(t2 * 3), h00 = fround(fround(a - b) + 1), h10 = fround(fround(t3 - fround(t2 + t2)) + t), h01 = fround(b - a), h11 = fround(t3 - t2), r2 = fround(h00 * v0);
+    return r2 = fround(r2 + fround(fround(h10 * h) * m0)), r2 = fround(r2 + fround(h01 * v1)), fround(r2 + fround(fround(h11 * h) * m1));
+  }
+  let outs = values + n * c, ins = outs + n * c, p1 = fround(v0 + f(record[outs + s * c + channel])), p2 = fround(v1 - f(record[ins + (s + 1) * c + channel])), u = fround(1 - t), uu = fround(u * u), tt = fround(t * t), r = fround(fround(uu * u) * v0);
+  return r = fround(r + fround(fround(fround(uu * 3) * t) * p1)), r = fround(r + fround(fround(fround(u * 3) * tt) * p2)), fround(r + fround(fround(tt * t) * v1));
+}
+function lut1(record, at, x) {
+  let n = record[at], flags = record[at + 1], wrap = (flags & LUT_WRAP) !== 0, values = at + LUT1_HEADER, t = coord(fround(fround(x - f(record[at + 2])) * f(record[at + 3])));
+  if ((flags & LUT_LINEAR) === 0) {
+    let i = Math.floor(fround(t + 0.5));
+    return f(record[values + index(i, n, wrap)]);
+  }
+  let floor = Math.floor(t), frac = fround(t - floor);
+  return lerp(f(record[values + index(floor, n, wrap)]), f(record[values + index(floor + 1, n, wrap)]), frac);
+}
+function bilinear(nx, ny, wrap, u, v, fetch2) {
+  let fu = Math.floor(u), fv = Math.floor(v), tx = fround(u - fu), ty = fround(v - fv), i0 = index(fu, nx, wrap), i1 = index(fu + 1, nx, wrap), j0 = index(fv, ny, wrap), j1 = index(fv + 1, ny, wrap), top = lerp(fetch2(i0, j0), fetch2(i1, j0), tx), bottom = lerp(fetch2(i0, j1), fetch2(i1, j1), tx);
+  return lerp(top, bottom, ty);
+}
+function nearest(nx, ny, wrap, u, v, fetch2) {
+  return fetch2(index(Math.floor(fround(u + 0.5)), nx, wrap), index(Math.floor(fround(v + 0.5)), ny, wrap));
+}
+function lut2(record, at, x, y) {
+  let nx = record[at], ny = record[at + 1], flags = record[at + 2], wrap = (flags & LUT_WRAP) !== 0, values = at + LUT2_HEADER, u = coord(fround(fround(x - f(record[at + 4])) * f(record[at + 6]))), v = coord(fround(fround(y - f(record[at + 5])) * f(record[at + 7]))), fetch2 = (i, j) => f(record[values + j * nx + i]);
+  return (flags & LUT_LINEAR) === 0 ? nearest(nx, ny, wrap, u, v, fetch2) : bilinear(nx, ny, wrap, u, v, fetch2);
+}
+function sample(record, at, mode, channel, x, y, texel) {
+  let w = record[at], h = record[at + 1], c = record[at + 2], wrap = (record[at + 3] & LUT_WRAP) !== 0, u = coord(fround(fround(x - f(record[at + 4])) * f(record[at + 6]))), v = coord(fround(fround(y - f(record[at + 5])) * f(record[at + 6]))), fetch2 = (i, j) => texel((j * w + i) * c + channel);
+  if (mode === SAMPLE_NEAREST) return nearest(w, h, wrap, u, v, fetch2);
+  if (mode === SAMPLE_BILINEAR) return bilinear(w, h, wrap, u, v, fetch2);
+  let left = bilinear(w, h, wrap, coord(fround(u - 1)), v, fetch2), right = bilinear(w, h, wrap, coord(fround(u + 1)), v, fetch2), down = bilinear(w, h, wrap, u, coord(fround(v - 1)), fetch2), up = bilinear(w, h, wrap, u, coord(fround(v + 1)), fetch2), cell = f(record[at + SAMPLER_WORDS - 1]), nx = fround(left - right), ny = fround(cell + cell), nz = fround(down - up), len = fround(Math.sqrt(fround(fround(fround(nx * nx) + fround(ny * ny)) + fround(nz * nz)))), part2 = mode === SAMPLE_NORMAL_X ? nx : mode === SAMPLE_NORMAL_Y ? ny : nz;
+  return len > 0 ? fround(part2 / len) : 0;
+}
+function axis(value, n, wrap) {
+  return wrap ? (value % n + n) % n : Math.min(Math.max(value, 0), n - 1);
+}
+function signedByte(word, shift) {
+  let b = word >>> shift & 255;
+  return b >= 128 ? b - 256 : b;
+}
+function cellTarget(row, offset, w, h, d, count) {
+  if (w === 0 || h === 0 || d === 0) return -1;
+  let wrap = (offset & CELL_WRAP) !== 0, plane = w * h, x = row % w, y = Math.floor(row / w) % h, z = Math.floor(row / plane), target = axis(x + signedByte(offset, 0), w, wrap) + axis(y + signedByte(offset, 8), h, wrap) * w + axis(z + signedByte(offset, 16), d, wrap) * plane;
+  return target < count ? target : -1;
+}
+
+// src/game/kernel/grid.ts
+var fround2 = Math.fround;
+function axis2(value, inverse) {
+  return Math.floor(fround2(value * inverse));
+}
+var I32_MIN = -2147483648, I32_MAX = 2147483647;
+function saturate2(v) {
+  return Number.isNaN(v) ? 0 : Math.min(Math.max(v, (-2147483648)), (2147483647));
+}
+var CellGrid = class {
+  constructor(capacity) {
+    this.inverse = 1;
+    this.radiusSquared = 0;
+    this.radius = 0;
+    this.flat = true;
+    this.len = 0;
+    let table = 1024;
+    for (; table < capacity * 2; ) table *= 2;
+    this.mask = table - 1, this.starts = new Uint32Array(table + 1), this.bucket = new Uint32Array(capacity), this.rows = new Uint32Array(capacity), this.cells = new Int32Array(capacity * 3), this.xs = new Float32Array(capacity), this.ys = new Float32Array(capacity), this.zs = new Float32Array(capacity);
+  }
+  hash(x, y, z) {
+    return (y + Math.imul(x, 1021) + Math.imul(z, 65539) & this.mask) >>> 0;
+  }
+  rebuild(radius, xs, ys, zs, count) {
+    let r = fround2(radius);
+    if (this.len = 0, this.radius = r, !(r > 0) || !Number.isFinite(r)) return false;
+    let len = Math.min(count, this.rows.length);
+    this.inverse = fround2(1 / r), this.radiusSquared = fround2(r * r), this.flat = zs === null;
+    let inverse = this.inverse;
+    this.starts.fill(0);
+    for (let row = 0; row < len; row++) {
+      let z = zs === null ? 0 : zs[row], bucket = this.hash(axis2(xs[row], inverse), axis2(ys[row], inverse), axis2(z, inverse));
+      this.bucket[row] = bucket, this.starts[bucket + 1]++;
+    }
+    for (let at = 1; at < this.starts.length; at++) this.starts[at] += this.starts[at - 1];
+    for (let row = 0; row < len; row++) {
+      let bucket = this.bucket[row], slot = this.starts[bucket]++, z = zs === null ? 0 : zs[row];
+      this.rows[slot] = row, this.xs[slot] = xs[row], this.ys[slot] = ys[row], this.zs[slot] = z, this.cells[3 * slot] = axis2(xs[row], inverse), this.cells[3 * slot + 1] = axis2(ys[row], inverse), this.cells[3 * slot + 2] = axis2(z, inverse);
+    }
+    for (let at = this.starts.length - 1; at > 0; at--) this.starts[at] = this.starts[at - 1];
+    return this.starts[0] = 0, this.len = len, true;
+  }
+  get size() {
+    return this.len;
+  }
+  get isFlat() {
+    return this.flat;
+  }
+  cellOf(x, y, z, out) {
+    out[0] = saturate2(axis2(x, this.inverse)), out[1] = saturate2(axis2(y, this.inverse)), out[2] = this.flat ? 0 : saturate2(axis2(z, this.inverse));
+  }
+  bucketOf(x, y, z) {
+    return this.hash(x, y, z);
+  }
+  bucketStart(bucket) {
+    return this.starts[bucket];
+  }
+  bucketEnd(bucket) {
+    return this.starts[bucket + 1];
+  }
+  inCell(slot, x, y, z) {
+    return this.cells[3 * slot] === x && this.cells[3 * slot + 1] === y && this.cells[3 * slot + 2] === z;
+  }
+  rowAt(slot) {
+    return this.rows[slot];
+  }
+  xAt(slot) {
+    return this.xs[slot];
+  }
+  yAt(slot) {
+    return this.ys[slot];
+  }
+  zAt(slot) {
+    return this.zs[slot];
+  }
+  order() {
+    return this.rows.subarray(0, this.len);
+  }
+  walk(cx, cy, cz, exclude, out) {
+    if (out.length = 0, this.len === 0) return 0;
+    let r = this.radius, inverse = this.inverse, lowX = axis2(fround2(cx - r), inverse), lowY = axis2(fround2(cy - r), inverse), lowZ = this.flat ? 0 : axis2(fround2(cz - r), inverse), highX = axis2(fround2(cx + r), inverse), highY = axis2(fround2(cy + r), inverse), highZ = this.flat ? 0 : axis2(fround2(cz + r), inverse), r2 = this.radiusSquared;
+    for (let x = lowX; x <= highX; x++)
+      for (let y = lowY; y <= highY; y++)
+        for (let z = lowZ; z <= highZ; z++) {
+          let bucket = this.hash(x, y, z), end = this.starts[bucket + 1];
+          for (let slot = this.starts[bucket]; slot < end; slot++) {
+            if (this.cells[3 * slot] !== x || this.cells[3 * slot + 1] !== y || this.cells[3 * slot + 2] !== z) continue;
+            let dx = fround2(this.xs[slot] - cx), dy = fround2(this.ys[slot] - cy), dz = fround2(this.zs[slot] - cz), d2 = fround2(fround2(fround2(dx * dx) + fround2(dy * dy)) + fround2(dz * dz)), row = this.rows[slot];
+            d2 <= r2 && row !== exclude && out.push(row);
+          }
+        }
+    return out.length;
+  }
+};
+
+// src/game/kernel/graphops.ts
+var CROSS_WORDS = 4;
+function recordGraph(i, records, visit, n, lane, row) {
+  let aux = i.dst === XOP_COMPONENTS_EDGES ? i.c : 4294967295;
+  for (let k = 0; k < n; k++) {
+    let at = (visit + k) * (4);
+    records[at] = lane(i.a, k) >>> 0, records[at + 1] = aux === 4294967295 ? 0 : lane(aux, k) >>> 0, records[at + 2] = i.b === 4294967295 || lane(i.b, k) !== 0 ? 1 : 0, records[at + 3] = row(k);
+  }
+}
+function gridOf(host, word) {
+  let at = word & 2147483647, grid = { width: host.uniform(2147483648 | at), height: host.uniform(2147483648 | at + 1), depth: host.uniform(2147483648 | at + 2) }, cells = grid.width * grid.height * grid.depth;
+  return cells > 0 && cells <= host.capacity ? grid : null;
+}
+function finishGraph(host, i, ext, records, len) {
+  let cap = host.capacity, b0 = host.buffers.subarray(0, cap), b1 = host.buffers.subarray(cap, 2 * cap), b2 = host.buffers.subarray(2 * cap, 3 * cap), b3 = host.buffers.subarray(3 * cap, 4 * cap), rowAt = (v) => records[v * (4) + 3], result = 0;
+  if (i.dst === XOP_COMPONENTS_EDGES) {
+    let nodes = host.uniform(ext.b);
+    if (nodes > cap) result = 4294967295;
+    else {
+      for (let k = 0; k < nodes; k++) b0[k] = k;
+      for (let v = 0; v < len; v++) {
+        let at = v * (4);
+        records[at + 2] !== 0 && records[at] < nodes && records[at + 1] < nodes && unionNodes(b0, records[at], records[at + 1]);
+      }
+      let target = host.array(ext.dst);
+      for (let k = 0; k < nodes; k++) {
+        let root = findNode(b0, k);
+        root === k && result++, target[k] = root;
+      }
+    }
+    host.setUniform(ext.a, result >>> 0);
+    return;
+  }
+  let grid = gridOf(host, i.c), cells = grid === null ? 0 : grid.width * grid.height * grid.depth, inGrid = (row) => row < cells;
+  if (i.dst === XOP_COMPONENTS_GRID) {
+    if (grid !== null) {
+      b1.fill(GRAPH_EMPTY, 0, cells);
+      for (let v = 0; v < len; v++) {
+        let at = v * (4);
+        records[at + 2] !== 0 && inGrid(records[at + 3]) && (b1[records[at + 3]] = records[at]);
+      }
+      result = componentsGrid(grid, b1.subarray(0, cells), GRAPH_EMPTY, b0, b2);
+    }
+    for (let v = 0; v < len; v++) host.writeRow(ext.dst, rowAt(v), inGrid(rowAt(v)) ? b2[rowAt(v)] : GRAPH_EMPTY);
+  } else if (i.dst === XOP_REACH_GRID) {
+    if (grid !== null) {
+      b0.fill((4294967295), 0, cells), b1.fill((4294967295), 0, cells), b3.fill((4294967295), 0, cells);
+      for (let v = 0; v < len; v++) inGrid(rowAt(v)) && (b0[rowAt(v)] = records[v * (4)]);
+      let seeded = 0;
+      for (let v = 0; v < len; v++) {
+        let at = v * (4), row = records[at + 3];
+        records[at + 2] === 0 || !inGrid(row) || b0[row] === (4294967295) || (b1[row] === (4294967295) && (b1[row] = 0, b2[seeded++] = row), b3[row] = Math.min(b3[row], records[at]));
+      }
+      result = reachSeeded(grid, b0.subarray(0, cells), b1, b2, seeded, ext.b === 4294967295 ? null : b3);
+    }
+    for (let v = 0; v < len; v++) {
+      let row = rowAt(v);
+      host.writeRow(ext.dst, row, inGrid(row) ? b1[row] : (4294967295)), ext.b !== 4294967295 && host.writeRow(ext.b, row, inGrid(row) ? b3[row] : (4294967295));
+    }
+  } else {
+    if (grid !== null) {
+      b0.fill((4294967295), 0, cells);
+      for (let v = 0; v < len; v++) {
+        let at = v * (4);
+        records[at + 2] !== 0 && inGrid(records[at + 3]) && (b0[records[at + 3]] = records[at]);
+      }
+      result = propagateGrid(grid, b0.subarray(0, cells), b1.subarray(0, cells), host.uniform(ext.b));
+    }
+    for (let v = 0; v < len; v++) host.writeRow(ext.dst, rowAt(v), inGrid(rowAt(v)) ? b0[rowAt(v)] : (4294967295));
+  }
+  host.setUniform(ext.a, result >>> 0);
+}
+
+// src/game/kernel/query.ts
+var fround3 = Math.fround, I32_MIN2 = -2147483648, I32_MAX2 = 2147483647, NO_LIMIT = 4294967295, PARAMS = 11;
+var DELTA = new Float64Array(3), KEY = new Float32Array(1);
+function keyOfDelta(s, flat) {
+  let dx = DELTA[0], dy = DELTA[1], dz = DELTA[2];
+  if (s.kind === QUERY_SEGMENT) {
+    let t = fround3(fround3(fround3(dx * s.vx) + fround3(dy * s.vy)) + fround3(dz * s.vz)), tc = t > 0 ? t < s.reach ? t : s.reach : 0, ex = fround3(dx - fround3(s.vx * tc)), ey = fround3(dy - fround3(s.vy * tc)), ez = fround3(dz - fround3(s.vz * tc));
+    return fround3(fround3(fround3(ex * ex) + fround3(ey * ey)) + fround3(ez * ez)) <= fround3(s.p0 * s.p0) ? (KEY[0] = tc + 0, true) : false;
+  }
+  let d2 = fround3(fround3(fround3(dx * dx) + fround3(dy * dy)) + fround3(dz * dz));
+  if (!(d2 <= fround3(s.reach * s.reach))) return false;
+  if (s.kind === QUERY_CONE) {
+    if (!(fround3(fround3(fround3(dx * s.vx) + fround3(dy * s.vy)) + fround3(dz * s.vz)) >= fround3(s.p0 * fround3(Math.sqrt(d2))))) return false;
+  } else if (s.kind === QUERY_BOX) {
+    let along = fround3(fround3(fround3(dx * s.vx) + fround3(dy * s.vy)) + fround3(dz * s.vz)), side = fround3(flat ? fround3(dy * s.vx) - fround3(dx * s.vy) : fround3(dx * s.vz) - fround3(dz * s.vx)), up = flat ? 0 : dy;
+    if (!(Math.abs(along) <= s.p0 && Math.abs(side) <= s.p1 && Math.abs(up) <= s.p2)) return false;
+  }
+  return KEY[0] = d2, true;
+}
+var keyBits = new Float32Array(1); new Uint32Array(keyBits.buffer);
+function widen(v, by) {
+  return Math.min(Math.max(v + by, (-2147483648)), (2147483647));
+}
+var QuerySearch = class {
+  constructor(capacity) {
+    this.lo = new Int32Array(3);
+    this.hi = new Int32Array(3);
+    this.center = new Int32Array(3);
+    this.len = 0;
+    this.grid = null;
+    this.shape = { kind: 0, vx: 0, vy: 0, vz: 0, p0: 0, p1: 0, p2: 0, reach: 0 };
+    this.mode = 0;
+    this.mask = 0;
+    this.value = 0;
+    this.filterColumn = null;
+    this.cx = 0;
+    this.cy = 0;
+    this.cz = 0;
+    this.self = 0;
+    this.limit = 0;
+    this.keys = new Uint32Array(capacity), this.rows = new Uint32Array(capacity), this.floats = new Float32Array(this.keys.buffer);
+  }
+  accepts(row) {
+    let m = (this.filterColumn[row] & this.mask) >>> 0, mode = this.mode;
+    return mode === QFILTER_EQUAL ? m === this.value >>> 0 : mode === QFILTER_ANY ? m !== 0 : mode === QFILTER_NONE ? m === 0 : true;
+  }
+  test(slot) {
+    let grid = this.grid, row = grid.rowAt(slot);
+    row !== this.self && (this.mode !== 0 && !this.accepts(row) || (DELTA[0] = fround3(grid.xAt(slot) - this.cx), DELTA[1] = fround3(grid.yAt(slot) - this.cy), DELTA[2] = fround3(grid.zAt(slot) - this.cz), keyOfDelta(this.shape, grid.isFlat) && (this.floats[this.len] = KEY[0], this.rows[this.len] = row, this.len++)));
+  }
+  scanCell(x, y, z) {
+    let grid = this.grid, bucket = grid.bucketOf(x, y, z), end = grid.bucketEnd(bucket);
+    for (let slot = grid.bucketStart(bucket); slot < end; slot++) grid.inCell(slot, x, y, z) && this.test(slot);
+  }
+  full() {
+    this.len = 0;
+    let n = this.grid.size;
+    for (let slot = 0; slot < n; slot++) this.test(slot);
+  }
+  window() {
+    let grid = this.grid, s = this.shape, lx, ly, lz, hx, hy, hz;
+    if (s.kind === QUERY_SEGMENT) {
+      let ex = fround3(this.cx + fround3(s.vx * s.reach)), ey = fround3(this.cy + fround3(s.vy * s.reach)), ez = fround3(this.cz + fround3(s.vz * s.reach)), r = s.p0;
+      lx = fround3(Math.min(this.cx, ex) - r), ly = fround3(Math.min(this.cy, ey) - r), lz = fround3(Math.min(this.cz, ez) - r), hx = fround3(Math.max(this.cx, ex) + r), hy = fround3(Math.max(this.cy, ey) + r), hz = fround3(Math.max(this.cz, ez) + r);
+    } else {
+      let r = s.reach;
+      lx = fround3(this.cx - r), ly = fround3(this.cy - r), lz = fround3(this.cz - r), hx = fround3(this.cx + r), hy = fround3(this.cy + r), hz = fround3(this.cz + r);
+    }
+    grid.cellOf(lx, ly, lz, this.lo), grid.cellOf(hx, hy, hz, this.hi);
+    for (let k = 0; k < 3; k++)
+      this.lo[k] = widen(this.lo[k], -1), this.hi[k] = widen(this.hi[k], 1);
+    grid.isFlat && (this.lo[2] = 0, this.hi[2] = 0);
+  }
+  cells() {
+    let n = 1;
+    for (let k = 0; k < 3; k++) n *= Math.max(this.hi[k] - this.lo[k] + 1, 0);
+    return n;
+  }
+  ring(r) {
+    let { lo, hi, center: c } = this, z0 = Math.max(c[2] - r, lo[2]), z1 = Math.min(c[2] + r, hi[2]), x0 = Math.max(c[0] - r, lo[0]), x1 = Math.min(c[0] + r, hi[0]), y0 = Math.max(c[1] - r, lo[1]), y1 = Math.min(c[1] + r, hi[1]), visited = 0;
+    for (let z = z0; z <= z1; z++) {
+      if (Math.abs(z - c[2]) === r) {
+        for (let x = x0; x <= x1; x++)
+          for (let y = y0; y <= y1; y++)
+            this.scanCell(x, y, z), visited++;
+        continue;
+      }
+      for (let x = x0; x <= x1; x++)
+        if (Math.abs(x - c[0]) === r)
+          for (let y = y0; y <= y1; y++)
+            this.scanCell(x, y, z), visited++;
+        else {
+          let a = c[1] - r, b = c[1] + r;
+          a >= y0 && a <= y1 && (this.scanCell(x, a, z), visited++), b !== a && b >= y0 && b <= y1 && (this.scanCell(x, b, z), visited++);
+        }
+    }
+    return visited;
+  }
+  covers(r) {
+    for (let k = 0; k < 3; k++) if (this.center[k] - r > this.lo[k] || this.center[k] + r < this.hi[k]) return false;
+    return true;
+  }
+  rings() {
+    let limit = this.limit, grid = this.grid;
+    grid.cellOf(this.cx, this.cy, this.cz, this.center);
+    let budget = grid.size, visited = 0;
+    for (let r = 0; ; r++) {
+      if (visited += this.ring(r), visited > budget) return false;
+      if (this.covers(r)) return true;
+      if (this.len >= limit && r >= 1) {
+        let bound = fround3((r - 1) * grid.radius), b2 = fround3(bound * bound), below = 0;
+        for (let k = 0; k < this.len && below < limit; k++) this.floats[k] < b2 && below++;
+        if (below >= limit) return true;
+      }
+    }
+  }
+  less(a, b) {
+    let ka = this.keys[a], kb = this.keys[b];
+    return ka !== kb ? ka < kb : this.rows[a] < this.rows[b];
+  }
+  swap(a, b) {
+    let k = this.keys[a];
+    this.keys[a] = this.keys[b], this.keys[b] = k;
+    let r = this.rows[a];
+    this.rows[a] = this.rows[b], this.rows[b] = r;
+  }
+  sift(at, end) {
+    let root = at;
+    for (; ; ) {
+      let child = 2 * root + 1;
+      if (child >= end || (child + 1 < end && this.less(child, child + 1) && child++, !this.less(root, child))) return;
+      this.swap(root, child), root = child;
+    }
+  }
+  sort() {
+    let n = this.len;
+    for (let at = (n >> 1) - 1; at >= 0; at--) this.sift(at, n);
+    for (let end = n - 1; end > 0; end--)
+      this.swap(0, end), this.sift(0, end);
+  }
+  run(grid, shape, mode, mask, value, filterColumn, cx, cy, cz, self, limit) {
+    return this.len = 0, grid.size === 0 || limit === 0 || !(shape.reach >= 0) ? 0 : (this.mask = mask, this.value = value, this.cx = cx, this.cy = cy, this.cz = cz, this.limit = limit, this.search(grid, shape, mode, filterColumn, self));
+  }
+  runFrom(grid, shape, mode, words2, maskAt, valueAt, limitAt, filterColumn, xs, ys, zs, self) {
+    this.len = 0;
+    let limit = words2[limitAt];
+    return grid.size === 0 || limit === 0 || !(shape.reach >= 0) ? 0 : (this.mask = words2[maskAt], this.value = words2[valueAt], this.cx = xs[self], this.cy = ys[self], this.cz = zs === null ? 0 : zs[self], this.limit = limit, this.search(grid, shape, mode, filterColumn, self));
+  }
+  search(grid, shape, mode, filterColumn, self) {
+    let limit = this.limit;
+    if (this.grid = grid, this.shape = shape, this.mode = mode, this.filterColumn = filterColumn, this.self = self, this.window(), limit !== (4294967295) && shape.kind !== QUERY_SEGMENT)
+      this.rings() || this.full();
+    else if (this.cells() <= grid.size)
+      for (let x = this.lo[0]; x <= this.hi[0]; x++) for (let y = this.lo[1]; y <= this.hi[1]; y++) for (let z = this.lo[2]; z <= this.hi[2]; z++) this.scanCell(x, y, z);
+    else this.full();
+    return this.sort(), this.grid = null, this.filterColumn = null, Math.min(this.len, limit);
+  }
+}, QueryRunner = class {
+  constructor(capacity, tile, accumulators) {
+    this.shape = { kind: 0, vx: 0, vy: 0, vz: 0, p0: 0, p1: 0, p2: 0, reach: 0 };
+    this.f32 = new Float32Array(1);
+    this.u32 = new Uint32Array(this.f32.buffer);
+    this.dry = false;
+    this.search = new QuerySearch(capacity), this.params = new Uint32Array((11) * tile), this.stopped = new Uint8Array(tile), this.stop = new Uint8Array(tile), this.saved = new Uint32Array(accumulators * tile), this.accs = new Uint32Array(accumulators), this.ranks = new Uint32Array(tile);
+  }
+  float(bits) {
+    return this.u32[0] = bits, this.f32[0];
+  }
+  op(host, sub, a, n) {
+    if (!(sub !== XOP_QSTOP || !this.dry))
+      for (let p = 0; p < n; p++) host.lane(a, p) !== 0 && (this.stop[p] = 1);
+  }
+  run(host, pc, n) {
+    let code = host.code, i = code[pc], ext = code[pc + 1], start = pc + 2, end = ext.a, word = ext.c, filtered = (word & QUERY_FILTERED) !== 0, kind = word & QUERY_SHAPE, filterAt = filtered ? pc - 2 : -1, shapeAt = kind === QUERY_SPHERE ? -1 : filtered ? pc - 4 : pc - 2, stops = false;
+    for (let p = start; p < end; p++) code[p].op === XOP && code[p].dst === XOP_QSTOP && (stops = true);
+    let opt = (w, lane, fallback) => w === 4294967295 ? fallback : host.lane(w, lane) >>> 0, params = this.params;
+    for (let lane = 0; lane < n; lane++) {
+      let at = lane * (11);
+      params[at] = opt(ext.b, lane, 1), params[at + 1] = host.lane(i.b, lane), params[at + 2] = opt(i.c, lane, (4294967295));
+      for (let k = 3; k < 11; k++) params[at + k] = 0;
+      if (shapeAt >= 0) {
+        let s2 = code[shapeAt], se = code[shapeAt + 1];
+        [s2.a, s2.b, s2.c, se.a, se.b, se.c].forEach((w, k) => {
+          params[at + 3 + k] = opt(w, lane, 0);
+        });
+      }
+      filterAt >= 0 && (params[at + 9] = host.lane(code[filterAt].b, lane), params[at + 10] = host.lane(code[filterAt].c, lane));
+    }
+    let [x, y, z] = host.position, xs = new Float32Array(host.snapshot[x].buffer), ys = new Float32Array(host.snapshot[y].buffer), zs = z === 4294967295 ? null : new Float32Array(host.snapshot[z].buffer), mode = filterAt >= 0 ? code[filterAt + 1].a : 0, filterColumn = filterAt >= 0 ? host.snapshot[code[filterAt].a] : null;
+    this.stopped.fill(0, 0, n);
+    let s = this.shape;
+    s.kind = kind;
+    let pairs = 0;
+    for (let lane = 0; lane < n; lane++) {
+      let at = lane * (11);
+      if (params[at] === 0) continue;
+      let row = host.row(lane);
+      s.reach = this.float(params[at + 1]), s.vx = this.float(params[at + 3]), s.vy = this.float(params[at + 4]), s.vz = this.float(params[at + 5]), s.p0 = this.float(params[at + 6]), s.p1 = this.float(params[at + 7]), s.p2 = this.float(params[at + 8]);
+      let found = this.search.run(host.grid, s, mode, params[at + 9], params[at + 10], filterColumn, xs[row], ys[row], zs === null ? 0 : zs[row], row, params[at + 2]);
+      for (let k = 0; k < found && this.stopped[lane] === 0; k++)
+        host.pairLane[pairs] = lane, host.pairRow[pairs] = this.search.rows[k], this.ranks[pairs] = k, pairs++, pairs === host.tile && (this.flush(host, start, end, pairs, stops), pairs = 0);
+    }
+    pairs > 0 && this.flush(host, start, end, pairs, stops);
+  }
+  flush(host, start, end, pairs, stops) {
+    if (!stops) {
+      host.exec(start, end, pairs);
+      return;
+    }
+    let code = host.code, tile = host.tile, accs = 0;
+    for (let p = start; p < end; p++) {
+      let op = code[p].op;
+      if (op !== Op.ACC_FADD && op !== Op.ACC_FMIN && op !== Op.ACC_FMAX && op !== Op.ACC_IADD) continue;
+      let seen = false;
+      for (let k = 0; k < accs; k++) this.accs[k] === code[p].a && (seen = true);
+      seen || (this.accs[accs++] = code[p].a);
+    }
+    for (let k = 0; k < accs; k++) this.saved.set(host.bits.subarray(this.accs[k] * tile, this.accs[k] * tile + tile), k * tile);
+    this.stop.fill(0, 0, pairs), this.dry = true, host.exec(start, end, pairs), this.dry = false;
+    for (let k = 0; k < accs; k++) host.bits.set(this.saved.subarray(k * tile, k * tile + tile), this.accs[k] * tile);
+    let kept = 0;
+    for (let p = 0; p < pairs; p++) {
+      let lane = host.pairLane[p];
+      this.stopped[lane] === 0 && (host.pairLane[kept] = lane, host.pairRow[kept] = host.pairRow[p], this.ranks[kept] = this.ranks[p], this.stop[p] !== 0 && (this.stopped[lane] = 1), kept++);
+    }
+    kept > 0 && host.exec(start, end, kept);
+  }
+};
+
+// src/game/kernel/simd.ts
+var Op2 = Op, UNARY = /* @__PURE__ */ new Set([Op2.MOV, Op2.INEG, Op2.IABS, Op2.INOT, Op2.MNOT, Op2.ITOF, Op2.UTOF, Op2.FTOI, Op2.BTOF, Op2.BTOI, Op2.FTOB, Op2.ITOB]), BINARY = /* @__PURE__ */ new Set([Op2.FLEN2, Op2.NOISE2, Op2.HASH, Op2.RAND, Op2.UMULHI, Op2.MAND, Op2.MOR, Op2.MANDN]), TERNARY = /* @__PURE__ */ new Set([Op2.SEL, Op2.FMULADD, Op2.FMULSUB, Op2.FSUBMUL, Op2.FADDMUL, Op2.FCLAMP, Op2.FLERP, Op2.FLEN3, Op2.NOISE3, Op2.UADDC, Op2.USUBB]); /* @__PURE__ */ new Set([Op2.FADD, Op2.FMUL, Op2.FMIN, Op2.FMAX, Op2.IADD, Op2.IMUL, Op2.IMIN, Op2.IMAX, Op2.UMIN, Op2.UMAX, Op2.IAND, Op2.IOR, Op2.IXOR, Op2.MAND, Op2.MOR]);
+function simdArity(op) {
+  return UNARY.has(op) || op >= Op2.FLOG2 && op <= Op2.FLOG ? 1 : BINARY.has(op) || op >= Op2.FADD && op <= Op2.FATAN2 || op >= Op2.FLT && op <= Op2.FNE || op >= Op2.IADD && op <= Op2.UMAX || op >= Op2.ILT && op <= Op2.ULE ? 2 : TERNARY.has(op) ? 3 : 0;
+}
+function simdMapOp(sub) {
+  return sub >= SIMD_MAP && sub < SIMD_MAP + SIMD_MAP_OPS ? sub - SIMD_MAP : null;
+}
+function isSimd(i) {
+  return i.op === XOP && xopRange(i.dst) === XOP_RANGE.SIMD;
+}
+function simdForm(i, ext) {
+  let control = ext.a, width = control & SIMD_WIDTH_MASK, vector = (w) => w === 4294967295 ? "unused" : "vector", map = simdMapOp(i.dst);
+  if (map !== null) {
+    let arity = simdArity(map);
+    if (arity === 0) return null;
+    let role = (k, flag) => k < arity ? (control & flag) !== 0 ? "scalar" : "vector" : "unused";
+    return { width, roles: [role(0, SIMD_SCALAR_A), role(1, SIMD_SCALAR_B), role(2, SIMD_SCALAR_C), "unused"], vectorDst: true };
+  }
+  switch (i.dst) {
+    case SIMD_SHUFFLE:
+      return { width, roles: ["vector", vector(i.b), "unused", "immediate"], vectorDst: true };
+    case SIMD_EXTRACT:
+      return { width, roles: ["vector", "immediate", "unused", "unused"], vectorDst: false };
+    case SIMD_REPLACE:
+      return { width, roles: ["vector", "scalar", "immediate", "unused"], vectorDst: true };
+    case SIMD_PACK: {
+      let lane = (k) => k < width ? "scalar" : "unused";
+      return { width, roles: [lane(0), lane(1), lane(2), lane(3)], vectorDst: true };
+    }
+    case SIMD_DOT:
+      return { width, roles: ["vector", "vector", "immediate", "unused"], vectorDst: false };
+    case SIMD_REDUCE:
+      return { width, roles: ["vector", "immediate", "unused", "unused"], vectorDst: false };
+    case SIMD_LENGTH:
+      return { width, roles: ["vector", "unused", "unused", "unused"], vectorDst: false };
+    case SIMD_NORMALIZE:
+      return { width, roles: ["vector", "unused", "unused", "unused"], vectorDst: true };
+    case SIMD_CROSS:
+      return { width, roles: ["vector", "vector", "unused", "unused"], vectorDst: true };
+    default:
+      return null;
+  }
+}
+function simdWords(i, ext) {
+  return [i.a, i.b, i.c, ext.b];
+}
+function simdLane(word, role, k) {
+  return role === "vector" ? word + k >>> 0 : word;
+}
+function shuffleIndex(pattern, k) {
+  return pattern >>> SIMD_LANE_BITS * k & SIMD_LANE_MASK;
+}
+function simdSource(i, ext, k) {
+  let width = ext.a & SIMD_WIDTH_MASK;
+  switch (i.dst) {
+    case SIMD_SHUFFLE: {
+      let index2 = shuffleIndex(ext.b, k);
+      return index2 < width ? i.a + index2 >>> 0 : i.b + index2 - width >>> 0;
+    }
+    case SIMD_REPLACE:
+      return k === i.c ? i.b : i.a + k >>> 0;
+    case SIMD_EXTRACT:
+      return i.a + i.b >>> 0;
+    default:
+      return simdWords(i, ext)[k];
+  }
+}
+var CROSS_TERMS = [
+  [1, 2, 2, 1],
+  [2, 0, 0, 2],
+  [0, 1, 1, 0]
+], SIMD_TEMPS = 4;
+function simdScalarize(i, ext, temp) {
+  let form = simdForm(i, ext);
+  if (form === null) return null;
+  let w = form.width, out = [], N = 4294967295, put = (op, dst, a, b = N, c = N) => {
+    out.push({ op, dst, a, b, c });
+  }, [t, t2, zero, mask] = [temp, temp + 1, temp + 2, temp + 3], at = (word, k) => word + k >>> 0, dot = (a, b, float) => {
+    put(float ? Op2.FMUL : Op2.IMUL, t, a, b);
+    for (let k = 1; k < w; k++)
+      put(float ? Op2.FMUL : Op2.IMUL, t2, at(a, k), at(b, k)), put(float ? Op2.FADD : Op2.IADD, t, t, t2);
+  }, map = simdMapOp(i.dst);
+  if (map !== null) {
+    for (let k = 0; k < w; k++) out.push(laneInst(map, i, ext, form, k));
+    return out;
+  }
+  switch (i.dst) {
+    case SIMD_SHUFFLE:
+    case SIMD_REPLACE:
+    case SIMD_PACK:
+      for (let k = 0; k < w; k++) put(Op2.MOV, ext.dst + k, simdSource(i, ext, k));
+      return out;
+    case SIMD_EXTRACT:
+      return put(Op2.MOV, ext.dst, simdSource(i, ext, 0)), out;
+    case SIMD_DOT:
+      return dot(i.a, i.b, i.c === SIMD_DOT_F32), put(Op2.MOV, ext.dst, t), out;
+    case SIMD_LENGTH:
+      return dot(i.a, i.a, true), put(Op2.FSQRT, ext.dst, t), out;
+    case SIMD_NORMALIZE:
+      dot(i.a, i.a, true), put(Op2.FSQRT, t, t), put(Op2.IXOR, zero, t, t), put(Op2.FLT, mask, zero, t);
+      for (let k = 0; k < w; k++)
+        put(Op2.FDIV, t2, at(i.a, k), t), put(Op2.SEL, ext.dst + k, mask, t2, zero);
+      return out;
+    case SIMD_CROSS:
+      return CROSS_TERMS.forEach(([p, q, r, s], k) => {
+        put(Op2.FMUL, t, at(i.a, r), at(i.b, s)), put(Op2.FMULSUB, ext.dst + k, at(i.a, p), at(i.b, q), t);
+      }), out;
+    case SIMD_REDUCE:
+      put(i.b, ext.dst, i.a, at(i.a, 1));
+      for (let k = 2; k < w; k++) put(i.b, ext.dst, ext.dst, at(i.a, k));
+      return out;
+    default:
+      return null;
+  }
+}
+function laneInst(op, i, ext, form, k) {
+  let w = simdWords(i, ext);
+  return { op, dst: ext.dst + k, a: simdLane(w[0], form.roles[0], k), b: simdLane(w[1], form.roles[1], k), c: simdLane(w[2], form.roles[2], k) };
+}
+
+// src/game/kernel/recur.ts
+var fround4 = Math.fround, wide = new Float64Array(1), wideWords = new Uint32Array(wide.buffer), CANONICAL_NAN322 = 2143289344, CANONICAL_NAN64_HI = 2146959360, F32_ONE = 1065353216, F32_INF = 2139095040, F32_NEG_INF = 4286578688, I32_MAX3 = 2147483647, I32_MIN3 = 2147483648, U32_MAX = 4294967295;
+function recurWide(lo, hi) {
+  return wideWords[0] = lo >>> 0, wideWords[1] = hi >>> 0, wide[0];
+}
+function recurSplit(value, out) {
+  return Number.isNaN(value) ? (out[0] = 0, out[1] = (2146959360), out) : (wide[0] = value, out[0] = wideWords[0], out[1] = wideWords[1], out);
+}
+function recurIdentity(kind) {
+  switch (kind) {
+    case RECUR.MUL_F32:
+      return (1065353216);
+    case RECUR.MIN_F32:
+      return (2139095040);
+    case RECUR.MAX_F32:
+      return (4286578688);
+    case RECUR.MUL_INT:
+      return 1;
+    case RECUR.MIN_I32:
+      return (2147483647);
+    case RECUR.MAX_I32:
+      return (2147483648);
+    case RECUR.MIN_U32:
+    case RECUR.AND:
+      return (4294967295);
+    default:
+      return 0;
+  }
+}
+function minBits(a, b) {
+  let x = f32From(a), y = f32From(b);
+  return x < y ? a : y < x ? b : Number.isNaN(x) ? a : b;
+}
+function maxBits(a, b) {
+  let x = f32From(a), y = f32From(b);
+  return x > y ? a : y > x ? b : Number.isNaN(x) ? a : b;
+}
+function recurStep(kind, s, a, b, c) {
+  let y = s[0];
+  switch (kind) {
+    case RECUR.LINEAR_F32:
+      s[0] = f32Bits(fround4(fround4(f32From(a) * f32From(y)) + f32From(b)));
+      return;
+    case RECUR.LINEAR_U32:
+      s[0] = Math.imul(a, y) + b >>> 0;
+      return;
+    case RECUR.FEEDBACK_F32:
+      s[0] = f32Bits(fround4(fround4(f32From(b) - fround4(f32From(a) * f32From(y))) - fround4(f32From(c) * f32From(s[1])))), s[1] = y;
+      return;
+    case RECUR.PHASE_F64: {
+      let next = recurWide(s[0], s[1]) + f32From(b), period = f32From(a);
+      recurSplit(next >= period ? next - period : next, s);
+      return;
+    }
+    case RECUR.ADD_F32:
+      s[0] = f32Bits(fround4(f32From(y) + f32From(b)));
+      return;
+    case RECUR.MUL_F32:
+      s[0] = f32Bits(fround4(f32From(y) * f32From(b)));
+      return;
+    case RECUR.MIN_F32:
+      s[0] = minBits(y, b) >>> 0;
+      return;
+    case RECUR.MAX_F32:
+      s[0] = maxBits(y, b) >>> 0;
+      return;
+    case RECUR.ADD_INT:
+      s[0] = y + b >>> 0;
+      return;
+    case RECUR.MUL_INT:
+      s[0] = Math.imul(y, b) >>> 0;
+      return;
+    case RECUR.MIN_I32:
+      s[0] = ((y | 0) < (b | 0) ? y : b) >>> 0;
+      return;
+    case RECUR.MAX_I32:
+      s[0] = ((y | 0) > (b | 0) ? y : b) >>> 0;
+      return;
+    case RECUR.MIN_U32:
+      s[0] = Math.min(y >>> 0, b >>> 0);
+      return;
+    case RECUR.MAX_U32:
+      s[0] = Math.max(y >>> 0, b >>> 0);
+      return;
+    case RECUR.AND:
+      s[0] = (y & b) >>> 0;
+      return;
+    case RECUR.OR:
+      s[0] = (y | b) >>> 0;
+      return;
+    default:
+      s[0] = (y ^ b) >>> 0;
+  }
+}
+function recurOutput(kind, mode, s, out) {
+  if (kind !== RECUR.PHASE_F64 || (mode & RECUR_WIDE) !== 0)
+    return out[0] = s[0], out[1] = s[1], out;
+  let narrow = fround4(recurWide(s[0], s[1]));
+  return out[0] = Number.isNaN(narrow) ? (2143289344) : f32Bits(narrow), out[1] = 0, out;
+}
+
+// src/game/kernel/vm.ts
+var Op3 = Op, TILE = 256, CROSS_WORDS2 = 4, SORT_BUFFERS = 4, RECUR_PAIR = 2, TRUE = 4294967295, fround5 = Math.fround, f32From2 = f32From, f32Bits2 = f32Bits, STORAGE_F32 = 0, STORAGE_I32 = 1, STORAGE_U32 = 2, STORAGE_U8 = 3;
+function parseProgram(bytes) {
+  if (bytes.byteLength % 4 !== 0) throw new GameError("invalid_argument", "a kernel program is a whole number of words");
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), words2 = new Uint32Array(bytes.byteLength / 4);
+  for (let k = 0; k < words2.length; k++) words2[k] = view.getUint32(k * 4, true);
+  if (words2[0] !== 827345731) throw new GameError("invalid_argument", "this is not a kernel program");
+  if (words2[1] < 1 || words2[1] > 4) throw new GameError("unsupported_feature", `kernel instruction set ${words2[1]} is not supported`);
+  let slotCount = words2[4], args = words2[5], constants = words2[6], loops = words2[7], count = words2[8], groupCount = words2[9], at = 16, slots = Array.from({ length: slotCount }, (_, k) => ({ kind: words2[at + k] & 255, neighbour: (words2[at + k] & 1024) !== 0, scratch: (words2[at + k] & 2048) !== 0, spawn: (words2[at + k] & 8192) !== 0, indexed: (words2[at + k] & ACCESS_INDEXED) !== 0, write: (words2[at + k] & 512) !== 0, word: words2[at + k] }));
+  at += slotCount + args;
+  let uniforms = new Uint32Array(args + constants + loops);
+  uniforms.set(words2.subarray(at, at + constants), args), at += constants;
+  let groups = [];
+  for (let g = 0; g < groupCount; g++, at += 4) groups.push({ isDefault: (words2[at] & GROUP_DEFAULT) !== 0, value: words2[at + 1], start: words2[at + 2], end: words2[at + 3] });
+  let channelCount = words2[14];
+  if (channelCount > 64) throw new GameError("invalid_argument", "the kernel program is malformed");
+  let channels = [];
+  for (let c = 0; c < channelCount; c++, at += 4) channels.push(words2[at]);
+  let code = [];
+  for (let k = 0; k < count; k++, at += 4) code.push({ op: words2[at] & 255, dst: words2[at] >>> 8, a: words2[at + 1], b: words2[at + 2], c: words2[at + 3] });
+  if (at !== words2.length) throw new GameError("invalid_argument", "the kernel program is malformed");
+  let flags = words2[2], radius = -1;
+  for (let i of code) (i.op === Op3.NEIGHBOURS || i.op === XOP && i.dst === XOP_QUERY) && (radius = i.a);
+  let calls = [], cross = [];
+  return code.forEach((i, pc) => {
+    i.op === Op3.CALL && calls.push(pc), (crossRow(i.op) || stageEndingOp(i.op, i.dst)) && cross.push(pc);
+  }), {
+    registers: words2[3],
+    slots,
+    calls,
+    cross,
+    args,
+    loops,
+    uniforms,
+    code,
+    groups,
+    state: (flags & 2) !== 0 ? words2[10] : -1,
+    position: (flags & 1) !== 0 ? [words2[11], words2[12], words2[13]] : null,
+    radius,
+    channels
+  };
+}
+function toInt(x) {
+  return x | 0;
+}
+var TWO_16 = 65536, TWO_32 = 4294967296, LOW_16 = 65535;
+function mulHigh(x, y) {
+  let xl = x & (65535), xh = x >>> 16, yl = y & (65535), yh = y >>> 16, lh = xl * yh, hl = xh * yl, mid = (xl * yl >>> 16) + (lh & (65535)) + (hl & (65535));
+  return xh * yh + (lh >>> 16) + (hl >>> 16) + Math.floor(mid / (65536)) >>> 0;
+}
+var STATUS_RESULTS = [
+  [4, 3],
+  [5, 4]
+];
+function scratchColumn(program, slot, capacity) {
+  let narrow = program.calls.some((pc) => {
+    let i = program.code[pc];
+    return STATUS_RESULTS.some(([service, index2]) => service === serviceOf(i.dst) && i.c + index2 === slot);
+  });
+  switch (program.slots[slot].kind) {
+    case 0:
+      return { values: new Float32Array(capacity), storage: (0) };
+    case 1:
+      return { values: new Int32Array(capacity), storage: (1) };
+    case 2:
+      return narrow ? { values: new Uint8Array(capacity), storage: (3) } : { values: new Uint32Array(capacity), storage: (2) };
+    default:
+      return { values: new Uint8Array(capacity), storage: (3) };
+  }
+}
+function fmin(a, b) {
+  return a < b ? a : b < a ? b : Number.isNaN(a) ? a : b;
+}
+function fmax(a, b) {
+  return a > b ? a : b > a ? b : Number.isNaN(a) ? a : b;
+}
+function roundJs(x) {
+  let r = Math.floor(x);
+  return x - r >= 0.5 ? r + 1 : r;
+}
+function sign(x) {
+  return x > 0 ? 1 : x < 0 ? -1 : x;
+}
+var MIX_A = 2146121005, MIX_B = 2221713035;
+function mix32(value) {
+  let x = value >>> 0;
+  return x ^= x >>> 16, x = Math.imul(x, (2146121005)), x ^= x >>> 15, x = Math.imul(x, (2221713035)), x ^= x >>> 16, x >>> 0;
+}
+function hash(a, b) {
+  return mix32((a ^ mix32(b + 2654435769 >>> 0)) >>> 0);
+}
+function unit(a, b) {
+  return fround5((hash(a, b) >>> 8) * (1 / 16777216));
+}
+function lattice(x, y, z) {
+  return fround5((mix32(Math.imul(x, 2376512323) ^ Math.imul(y, 3625334849) ^ Math.imul(z, 3407524639)) >>> 8) * (1 / 16777216));
+}
+function smooth(t) {
+  return fround5(fround5(t * t) * fround5(3 - fround5(2 * t)));
+}
+function mixf(a, b, t) {
+  return fround5(a + fround5(fround5(b - a) * t));
+}
+function cellOf(x) {
+  let f2 = Math.floor(x);
+  return [f2 | 0, fround5(x - f2)];
+}
+function noise2(x, y) {
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return 0;
+  let [ix, fx] = cellOf(x), [iy, fy] = cellOf(y), u = smooth(fx), v = smooth(fy), a = mixf(lattice(ix, iy, 0), lattice(ix + 1, iy, 0), u), b = mixf(lattice(ix, iy + 1, 0), lattice(ix + 1, iy + 1, 0), u);
+  return fround5(fround5(mixf(a, b, v) * 2) - 1);
+}
+function noise3(x, y, z) {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return 0;
+  let [ix, fx] = cellOf(x), [iy, fy] = cellOf(y), [iz, fz] = cellOf(z), u = smooth(fx), v = smooth(fy), w = smooth(fz), a = mixf(lattice(ix, iy, iz), lattice(ix + 1, iy, iz), u), b = mixf(lattice(ix, iy + 1, iz), lattice(ix + 1, iy + 1, iz), u), c = mixf(lattice(ix, iy, iz + 1), lattice(ix + 1, iy, iz + 1), u), d = mixf(lattice(ix, iy + 1, iz + 1), lattice(ix + 1, iy + 1, iz + 1), u);
+  return fround5(fround5(mixf(mixf(a, b, v), mixf(c, d, v), w) * 2) - 1);
+}
+function readAs(kind, storage, raw) {
+  return kind === 0 ? f32Bits2(storage === (0) ? raw : fround5(storage === (1) ? raw | 0 : raw >>> 0)) : kind === 3 ? raw !== 0 && !Number.isNaN(raw) ? (4294967295) : 0 : storage === (0) ? toInt(raw) >>> 0 : raw >>> 0;
+}
+function writeAs(kind, storage, value) {
+  return storage === (0) ? kind === 0 ? f32From2(value) : kind === 3 ? value !== 0 ? 1 : 0 : fround5(kind === 1 ? value | 0 : value >>> 0) : kind === 0 ? toInt(f32From2(value)) : kind === 3 ? value !== 0 ? 1 : 0 : value;
+}
+var KernelVm = class {
+  constructor(program, capacity) {
+    this.program = program;
+    this.capacity = capacity;
+    this.rows = new Uint32Array((256));
+    this.pairLane = new Uint32Array((256));
+    this.pairRow = new Uint32Array((256));
+    this.columns = [];
+    this.scratch = new Uint32Array((256));
+    this.fscratch = new Float32Array(this.scratch.buffer);
+    this.found = [];
+    this.callArgs = new Float64Array(8);
+    this.mlpRow = new Uint32Array(MLP_MAX_OUTPUTS);
+    this.callOut = new Float64Array(8);
+    this.services = null;
+    this.dataHost = {
+      lane: (word, at) => this.lane(word, at),
+      row: (lane) => this.row(lane),
+      set: (register, at, value) => {
+        this.bits[register * (256) + at] = value;
+      }
+    };
+    this.pending = [];
+    this.marked = 0;
+    this.spawnStats = { spawned: 0, dropped: 0, killed: 0 };
+    this.base = 0;
+    this.listMode = false;
+    this.visit = 0;
+    this.runCount = 0;
+    this.sortCounts = new Uint32Array(1 << SORT_RADIX_BITS);
+    this.graphCache = null;
+    this.recurState = [0, 0];
+    this.recurBefore = [0, 0];
+    this.recurOut = [0, 0];
+    this.splats = [new Uint32Array((256)), new Uint32Array((256)), new Uint32Array((256))];
+    let buffer = new ArrayBuffer(Math.max(program.registers, 1) * (256) * 4);
+    this.bits = new Uint32Array(buffer), this.floats = new Float32Array(buffer), this.uniforms = new Uint32Array(program.uniforms.length), this.grid = new CellGrid(program.position === null ? 0 : capacity), this.snapshot = program.slots.map((s) => s.neighbour ? new Uint32Array(capacity) : new Uint32Array(0)), this.own = program.slots.map((s, k) => s.scratch ? scratchColumn(program, k, capacity) : null), this.deferred = program.calls.map((pc) => program.code[pc]).filter((i) => deferredService(serviceOf(i.dst))), this.marks = new Uint32Array(this.deferred.length > 0 ? capacity : 0), this.records = program.cross.map(() => new Uint32Array(capacity * (4))), this.sorting = program.cross.some((pc) => program.code[pc].op === XOP) ? new Uint32Array((4) * capacity) : new Uint32Array(0), this.indexed = program.slots.map((s) => s.indexed === true && s.write === true ? new Float64Array(capacity) : null), this.events = new Uint32Array(RING_HEADER_WORDS + (program.channels.length > 0 ? DEFAULT_EVENT_CAPACITY * 10 : 0)), this.data = new DataMachine(program.slots, program.code, capacity);
+    let mlp2 = program.code.some((i) => i.op === XOP && xopRange(i.dst) === XOP_RANGE.NEURAL);
+    this.mlpIn = new Uint32Array(mlp2 ? MLP_MAX_WIDTH * (256) : 0), this.mlpOut = new Uint32Array(mlp2 ? MLP_MAX_OUTPUTS * (256) : 0);
+    let accumulators = program.code.filter((i) => i.op === Op3.ACC_FADD || i.op === Op3.ACC_FMIN || i.op === Op3.ACC_FMAX || i.op === Op3.ACC_IADD).length;
+    this.queries = program.code.some((i) => i.op === XOP && i.dst === XOP_QUERY) ? new QueryRunner(capacity, (256), accumulators) : null, this.queryHost = {
+      code: program.code,
+      bits: this.bits,
+      pairLane: this.pairLane,
+      pairRow: this.pairRow,
+      snapshot: this.snapshot,
+      grid: this.grid,
+      position: program.position ?? [4294967295, 4294967295, 4294967295],
+      tile: (256),
+      lane: (word, at) => this.lane(word, at),
+      row: (lane) => this.row(lane),
+      exec: (start, end, n) => {
+        let savedList = this.listMode, savedBase = this.base;
+        this.exec(start, end, n), this.listMode = savedList, this.base = savedBase;
+      }
+    };
+  }
+  clearEvents() {
+    this.events[RING_COUNT] = 0, this.events[RING_DROPPED] = 0;
+  }
+  u(word) {
+    return this.uniforms[word & 2147483647];
+  }
+  isUniform(word) {
+    return (word & 2147483648) !== 0 && word !== 4294967295;
+  }
+  lane(word, at) {
+    return this.isUniform(word) ? this.u(word) : this.bits[word * (256) + at];
+  }
+  flane(word, at) {
+    return this.isUniform(word) ? f32From2(this.u(word)) : this.floats[word * (256) + at];
+  }
+  run(columns, count, rows, args) {
+    let p = this.program;
+    if (columns.length !== p.slots.length || count > this.capacity) throw new GameError("invalid_argument", "the kernel binding does not match its table");
+    if (p.calls.length > this.deferred.length && this.services === null) throw new GameError("unsupported_feature", "this kernel calls engine services; attach them with world.kernelServices({ physics, nav, flow, terrain, graphics })");
+    this.columns = p.calls.length > 0 || p.cross.length > 0 ? columns.map((c, k) => this.own[k] ?? c) : columns, this.runCount = count, this.indexed.forEach((copy, k) => {
+      if (copy !== null) for (let row = 0; row < count; row++) copy[row] = this.columns[k].values[row];
+    }), this.marked > 0 && (this.marks.fill(0, 0, Math.min(this.marked, this.marks.length)), this.marked = 0), this.uniforms.set(p.uniforms), this.uniforms.set(args.subarray(0, p.args)), this.data.prepare(this.columns, count);
+    let list = null;
+    if (rows !== null) {
+      let kept = [];
+      for (let r of rows) r < count && kept.push(r);
+      list = Uint32Array.from(kept);
+    }
+    if (p.position !== null) {
+      this.prepareNeighbours(count);
+      let order = this.grid.order();
+      list === null && p.state < 0 && order.length === count && (list = order.slice());
+    }
+    if (p.state >= 0) {
+      let all = list ?? Uint32Array.from({ length: count }, (_, k) => k), slot = p.slots[p.state], column = columns[p.state], buckets = p.groups.map(() => []), fallback = p.groups.findIndex((g) => g.isDefault);
+      for (let row of all) {
+        let value = readAs(slot.kind, column.storage, column.values[row]), g = p.groups.findIndex((group) => !group.isDefault && (slot.kind === 0 ? f32From2(value) === f32From2(group.value) : value === group.value));
+        g < 0 && (g = fallback), g >= 0 && buckets[g].push(row);
+      }
+      let total = 0;
+      return p.groups.forEach((group, g) => {
+        this.tiles(Uint32Array.from(buckets[g]), buckets[g].length, group.start, group.end), total += buckets[g].length;
+      }), this.data.finish(this.columns, this.uniforms), this.orderEvents(list), total;
+    }
+    let len = list === null ? count : list.length, start = 0, nextCall = 0, nextCross = 0;
+    for (; nextCall < p.calls.length || nextCross < p.cross.length; ) {
+      let callPc = nextCall < p.calls.length ? p.calls[nextCall] : 1 / 0, crossPc = nextCross < p.cross.length ? p.cross[nextCross] : 1 / 0;
+      if (crossPc < callPc) {
+        let width = (at) => p.code[at].op === CROSS_OP.SCATTER || p.code[at].op === XOP ? 2 : 1, first = nextCross, end = crossPc + width(crossPc);
+        for (nextCross++; nextCross < p.cross.length && p.cross[nextCross] === end; )
+          end += width(end), nextCross++;
+        this.tiles(list, len, start, end);
+        for (let k = first; k < nextCross; k++) this.finishCross(p.cross[k], k, len);
+        start = end;
+        continue;
+      }
+      this.tiles(list, len, start, callPc), this.call(p.code[callPc], list, len, count), nextCall++, start = callPc + 1;
+    }
+    return this.tiles(list, len, start, p.code.length), this.data.finish(this.columns, this.uniforms), this.orderEvents(list), len;
+  }
+  orderEvents(list) {
+    let events = this.events, pending = this.pending;
+    if (this.pending = [], events.length <= RING_HEADER_WORDS || pending.length === 0) return;
+    let ordinal = /* @__PURE__ */ new Map();
+    list !== null && list.forEach((row, k) => ordinal.set(row, k));
+    let keyed = pending.map((entry, k) => ({ entry, ordinal: list === null ? entry[1] : ordinal.get(entry[1]), k }));
+    keyed.sort((p, q) => p.ordinal - q.ordinal || p.k - q.k);
+    let capacity = (events.length - RING_HEADER_WORDS) / 10;
+    for (let { entry } of keyed) {
+      let count = events[RING_COUNT];
+      if (count >= capacity) {
+        events[RING_DROPPED]++;
+        continue;
+      }
+      events.set(entry, RING_HEADER_WORDS + count * 10), events[RING_COUNT] = count + 1;
+    }
+  }
+  call(i, list, len, count) {
+    let service = serviceOf(i.dst), columns = this.columns, mask = i.b === 4294967295 ? null : columns[i.b].values;
+    if (deferredService(service)) {
+      let bit = 1 << this.deferred.findIndex((d) => d.a === i.a && d.b === i.b && d.c === i.c && d.dst === i.dst);
+      for (let k = 0; k < len; k++) {
+        let row = list === null ? k : list[k];
+        row >= count || mask !== null && mask[row] === 0 || (this.marks[row] |= bit);
+      }
+      this.marked = Math.max(this.marked, count);
+      return;
+    }
+    let signature = SERVICE_SIGNATURES[service], port = this.services, args = this.callArgs, out = this.callOut;
+    port.begin?.(service);
+    for (let k = 0; k < len; k++) {
+      let row = list === null ? k : list[k];
+      if (!(row >= count || mask !== null && mask[row] === 0)) {
+        for (let a = 0; a < signature.args.length; a++) args[a] = columns[i.a + a].values[row];
+        if (!port.call(service, args, out)) throw new GameError("unsupported_feature", "the attached kernel services cannot answer this engine call");
+        for (let r = 0; r < signature.results.length; r++) columns[i.c + r].values[row] = signature.results[r] === 3 ? out[r] !== 0 ? 1 : 0 : out[r];
+      }
+    }
+    port.end?.(service);
+  }
+  get defers() {
+    return this.deferred.length > 0;
+  }
+  finish(own, target) {
+    let stats = this.spawnStats;
+    if (stats.spawned = 0, stats.dropped = 0, stats.killed = 0, this.deferred.length === 0) return stats;
+    let marks = this.marks, count = Math.min(this.marked, own.count, marks.length), killBits = 0;
+    this.deferred.forEach((d, site) => {
+      serviceOf(d.dst) === 23 && (killBits |= 1 << site);
+    });
+    let anyKill = false;
+    for (let row = 0; row < count && !anyKill; row++) anyKill = (marks[row] & killBits) !== 0;
+    if (anyKill) {
+      let total = own.count, all = own.columns, kept = 0;
+      for (let row = 0; row < total; row++)
+        if (!(row < count && (marks[row] & killBits) !== 0)) {
+          if (kept !== row) for (let column of all) column[kept] = column[row];
+          kept++;
+        }
+      stats.killed = total - kept, own.count = kept;
+    }
+    let spawnBits = ~killBits & (this.deferred.length >= 32 ? 4294967295 : (1 << this.deferred.length) - 1);
+    if (spawnBits !== 0) {
+      let into = target ?? own, slots = this.program.slots;
+      for (let row = 0; row < count; row++) {
+        let m = marks[row] & spawnBits;
+        if (m !== 0)
+          for (let site = 0; site < this.deferred.length; site++) {
+            if ((m & 1 << site) === 0) continue;
+            let d = this.deferred[site], at = into.count;
+            if (at >= into.capacity) {
+              stats.dropped++;
+              continue;
+            }
+            for (let column of into.columns) column[at] = 0;
+            let fields = operandCount(d.dst);
+            for (let k = 0; k < fields; k++) {
+              let source = this.columns[d.a + k], kind = slots[d.a + k].kind, dst = into.column(d.c + k);
+              dst.values[at] = writeAs(kind, dst.storage, readAs(kind, source.storage, source.values[row]));
+            }
+            into.count = at + 1, stats.spawned++;
+          }
+      }
+    }
+    return marks.fill(0, 0, Math.min(this.marked, marks.length)), this.marked = 0, stats;
+  }
+  prepareNeighbours(count) {
+    let p = this.program;
+    p.slots.forEach((slot, k) => {
+      if (!slot.neighbour) return;
+      let column = this.columns[k], out = this.snapshot[k];
+      for (let row = 0; row < count; row++) out[row] = readAs(slot.kind, column.storage, column.values[row]);
+    });
+    let [x, y, z] = p.position, view = (slot) => new Float32Array(this.snapshot[slot].buffer, 0, count);
+    this.grid.rebuild(f32From2(this.u(p.radius)), view(x), view(y), z === 4294967295 ? null : view(z), count);
+  }
+  tiles(list, len, start, end) {
+    for (let first = 0; first < len; first += (256)) {
+      let n = Math.min((256), len - first);
+      this.visit = first, list === null ? (this.listMode = false, this.base = first) : (this.listMode = true, this.rows.set(list.subarray(first, first + n))), this.exec(start, end, n);
+    }
+  }
+  row(lane) {
+    return this.listMode ? this.rows[lane] : this.base + lane;
+  }
+  exec(start, end, n) {
+    let code = this.program.code, bits = this.bits, floats = this.floats, pc = start;
+    for (; pc < end; ) {
+      let i = code[pc], d = i.dst * (256);
+      if (lookupOp(i.op)) {
+        this.lookup(pc, i, n), pc += i.op === LOOKUP_OP.SAMPLE ? 2 : 1;
+        continue;
+      }
+      if (i.op === XOP) {
+        if (i.dst === XOP_QUERY && this.queries !== null) {
+          this.queries.run(this.queryHost, pc, n), pc = code[pc + 1].a;
+          continue;
+        }
+        this.extended(pc, i, code[pc + 1], n), pc += 2;
+        continue;
+      }
+      if (crossRow(i.op)) {
+        this.record(pc, i, n), pc += i.op === CROSS_OP.SCATTER ? 2 : 1;
+        continue;
+      }
+      switch (i.op) {
+        case Op3.NOP:
+          break;
+        case Op3.LOAD: {
+          let slot = this.program.slots[i.a], column = this.columns[i.a];
+          for (let k = 0; k < n; k++) bits[d + k] = readAs(slot.kind, column.storage, column.values[this.row(k)]);
+          break;
+        }
+        case Op3.STORE: {
+          let slot = this.program.slots[i.a], column = this.columns[i.a], exact = slot.kind === 0 && column.storage === (0) || (slot.kind === 1 || slot.kind === 2) && (column.storage === (1) || column.storage === (2));
+          for (let k = 0; k < n; k++) {
+            let value = this.lane(i.b, k), row = this.row(k);
+            !exact && readAs(slot.kind, column.storage, column.values[row]) === value || (column.values[row] = writeAs(slot.kind, column.storage, value));
+          }
+          break;
+        }
+        case Op3.ROW:
+          for (let k = 0; k < n; k++) bits[d + k] = this.row(k);
+          break;
+        case Op3.JNONE: {
+          let any = false;
+          for (let k = 0; k < n && !any; k++) any = this.lane(i.a, k) !== 0;
+          if (!any) {
+            pc = i.b;
+            continue;
+          }
+          break;
+        }
+        case Op3.LOOP_INIT: {
+          if (this.uniforms[i.a] = 0, this.trips(i.b, i.dst) === 0) {
+            pc = i.c;
+            continue;
+          }
+          break;
+        }
+        case Op3.LOOP_NEXT: {
+          if (this.uniforms[i.a]++, this.uniforms[i.a] < this.trips(i.b, i.dst)) {
+            pc = i.c;
+            continue;
+          }
+          break;
+        }
+        case Op3.NEIGHBOURS:
+          this.neighbours(pc + 1, i.b, i.c, n), pc = i.b;
+          continue;
+        case Op3.NLOAD: {
+          let snap = this.snapshot[i.a];
+          for (let k = 0; k < n; k++) bits[d + k] = snap[this.pairRow[k]];
+          break;
+        }
+        case Op3.OUTER: {
+          let a = i.a * (256);
+          for (let k = 0; k < n; k++) bits[d + k] = bits[a + this.pairLane[k]];
+          break;
+        }
+        case Op3.NROW:
+          for (let k = 0; k < n; k++) bits[d + k] = this.pairRow[k];
+          break;
+        case Op3.ACC_FADD:
+        case Op3.ACC_FMIN:
+        case Op3.ACC_FMAX:
+        case Op3.ACC_IADD: {
+          let t = i.a * (256);
+          for (let k = 0; k < n; k++) {
+            if (i.c !== 4294967295 && bits[i.c * (256) + k] === 0) continue;
+            let at = t + this.pairLane[k];
+            if (i.op === Op3.ACC_IADD) bits[at] = bits[at] + this.lane(i.b, k) >>> 0;
+            else {
+              let v = this.flane(i.b, k);
+              floats[at] = i.op === Op3.ACC_FADD ? floats[at] + v : i.op === Op3.ACC_FMIN ? fmin(floats[at], v) : fmax(floats[at], v);
+            }
+          }
+          break;
+        }
+        case Op3.EMIT: {
+          let words2 = this.program.channels[i.dst], exts = Math.ceil(words2 / 3);
+          for (let k = 0; k < n; k++) {
+            if (i.a !== 4294967295 && this.lane(i.a, k) === 0) continue;
+            let entry = new Uint32Array(10);
+            entry[0] = i.dst, entry[1] = this.row(k);
+            for (let w = 0; w < 8; w++) {
+              let ext = code[pc + 1 + Math.floor(w / 3)];
+              entry[2 + w] = w < words2 ? this.lane([ext.a, ext.b, ext.c][w % 3], k) : 0;
+            }
+            this.pending.push(entry);
+          }
+          pc += 1 + exts;
+          continue;
+        }
+        case Op3.FDOT2:
+        case Op3.FDOT3: {
+          let e = code[pc + 1];
+          for (let k = 0; k < n; k++) {
+            let v = fround5(fround5(this.flane(i.a, k) * this.flane(i.b, k)) + fround5(this.flane(i.c, k) * this.flane(e.a, k)));
+            i.op === Op3.FDOT3 && (v = fround5(v + fround5(this.flane(e.b, k) * this.flane(e.c, k)))), floats[d + k] = v;
+          }
+          pc += 2;
+          continue;
+        }
+        default:
+          this.arith(i, n);
+      }
+      pc++;
+    }
+  }
+  extended(pc, i, ext, n) {
+    switch (xopRange(i.dst)) {
+      case XOP_RANGE.DATA:
+        this.data.exec(pc, i, ext, n, this.columns, this.dataHost);
+        return;
+      case XOP_RANGE.NARROW: {
+        let bits = this.bits;
+        runLanes(i.dst, [i.a, i.b, i.c, ext.a, ext.b], [ext.dst, ext.c, ext.b], n, (w, k) => this.lane(w, k), (r, k, v) => {
+          bits[r * (256) + k] = v;
+        });
+        return;
+      }
+      case XOP_RANGE.SAMPLING:
+        if (i.dst === XOP_QRANK && this.queries !== null) {
+          let bits = this.bits, ranks = this.queries.ranks;
+          for (let k = 0; k < n; k++) bits[ext.dst * (256) + k] = ranks[k];
+          return;
+        }
+        this.queries?.op(this.queryHost, i.dst, i.a, n);
+        return;
+      case XOP_RANGE.CROSS:
+        i.dst === XOP_GATHER || i.dst === XOP_FIELD ? this.gather(i, ext, n) : this.record(pc, i, n);
+        return;
+      case XOP_RANGE.NEURAL:
+        this.neural(i, ext, n);
+        return;
+      case XOP_RANGE.SIMD:
+        this.simd(i, ext, n);
+        return;
+      case XOP_RANGE.SYSTEMS:
+        recordGraph(i, this.records[this.program.cross.indexOf(pc)], this.visit, n, (w, k) => this.lane(w, k), (k) => this.row(k));
+        return;
+      default:
+        throw new GameError("unsupported_feature", `extended kernel op 0x${i.dst.toString(16)} (pc ${pc}, ext ${ext.op}, ${n} rows) is not supported by this SDK; update @cimplify/sdk`);
+    }
+  }
+  lookup(pc, i, n) {
+    let L = LOOKUP_OP, u = this.uniforms, floats = this.floats, bits = this.bits, d = i.dst * (256);
+    switch (i.op) {
+      case L.CURVE: {
+        let at = i.b & 2147483647;
+        for (let k = 0; k < n; k++) floats[d + k] = curve(u, at, i.c, this.flane(i.a, k));
+        return;
+      }
+      case L.LUT1: {
+        let at = i.b & 2147483647;
+        for (let k = 0; k < n; k++) floats[d + k] = lut1(u, at, this.flane(i.a, k));
+        return;
+      }
+      case L.LUT2: {
+        let at = i.c & 2147483647;
+        for (let k = 0; k < n; k++) floats[d + k] = lut2(u, at, this.flane(i.a, k), this.flane(i.b, k));
+        return;
+      }
+      case L.SAMPLE: {
+        let ext = this.program.code[pc + 1], at = ext.a & 2147483647, column = this.columns[i.a], values = this.indexed[i.a] ?? column.values, texel = (k) => f32From2(readAs(0, column.storage, values[k]));
+        for (let k = 0; k < n; k++) floats[d + k] = sample(u, at, ext.b, ext.c, this.flane(i.b, k), this.flane(i.c, k), texel);
+        return;
+      }
+      default: {
+        let column = this.columns[i.a], kind = this.program.slots[i.a].kind, values = this.indexed[i.a] ?? column.values, at = i.c & 2147483647, w = u[at], h = u[at + 1], depth = u[at + 2];
+        for (let k = 0; k < n; k++) {
+          let target = cellTarget(this.row(k), i.b, w, h, depth, this.runCount);
+          bits[d + k] = target < 0 ? 0 : readAs(kind, column.storage, values[target]);
+        }
+      }
+    }
+  }
+  dotRow(a, b, width, k) {
+    let acc = fround5(this.flane(a, k) * this.flane(b, k));
+    for (let l = 1; l < width; l++) acc = fround5(acc + fround5(this.flane(a + l >>> 0, k) * this.flane(b + l >>> 0, k)));
+    return acc;
+  }
+  simd(i, ext, n) {
+    let form = simdForm(i, ext);
+    if (form === null) throw new GameError("invalid_argument", `vector kernel op 0x${i.dst.toString(16)} is malformed`);
+    let w = form.width, map = simdMapOp(i.dst);
+    if (map !== null) {
+      for (let l = 0; l < w; l++) this.arith(laneInst(map, i, ext, form, l), n);
+      return;
+    }
+    let bits = this.bits, floats = this.floats, move = (dst, src) => this.arith({ op: Op3.MOV, dst, a: src, b: 4294967295, c: 4294967295 }, n);
+    switch (i.dst) {
+      case SIMD_SHUFFLE:
+      case SIMD_REPLACE:
+      case SIMD_PACK:
+        for (let l = 0; l < w; l++) move(ext.dst + l, simdSource(i, ext, l));
+        return;
+      case SIMD_EXTRACT:
+        move(ext.dst, simdSource(i, ext, 0));
+        return;
+      case SIMD_DOT: {
+        let d = ext.dst * (256);
+        if (i.c === SIMD_DOT_F32) {
+          for (let k = 0; k < n; k++) floats[d + k] = this.dotRow(i.a, i.b, w, k);
+          return;
+        }
+        for (let k = 0; k < n; k++) {
+          let acc = Math.imul(this.lane(i.a, k), this.lane(i.b, k));
+          for (let l = 1; l < w; l++) acc = acc + Math.imul(this.lane(i.a + l >>> 0, k), this.lane(i.b + l >>> 0, k)) | 0;
+          bits[d + k] = acc >>> 0;
+        }
+        return;
+      }
+      case SIMD_LENGTH: {
+        let d = ext.dst * (256);
+        for (let k = 0; k < n; k++) floats[d + k] = Math.sqrt(this.dotRow(i.a, i.a, w, k));
+        return;
+      }
+      case SIMD_NORMALIZE: {
+        for (let k = 0; k < n; k++) {
+          let l = fround5(Math.sqrt(this.dotRow(i.a, i.a, w, k)));
+          for (let m = 0; m < w; m++) {
+            let at = (ext.dst + m) * (256) + k;
+            0 < l ? floats[at] = this.flane(i.a + m >>> 0, k) / l : bits[at] = 0;
+          }
+        }
+        return;
+      }
+      case SIMD_CROSS:
+        for (let k = 0; k < n; k++)
+          CROSS_TERMS.forEach(([p, q, r, s], m) => {
+            let first = fround5(this.flane(i.a + p >>> 0, k) * this.flane(i.b + q >>> 0, k)), second = fround5(this.flane(i.a + r >>> 0, k) * this.flane(i.b + s >>> 0, k));
+            floats[(ext.dst + m) * (256) + k] = first - second;
+          });
+        return;
+      case SIMD_REDUCE:
+        this.arith({ op: i.b, dst: ext.dst, a: i.a, b: i.a + 1 >>> 0, c: 4294967295 }, n);
+        for (let l = 2; l < w; l++) this.arith({ op: i.b, dst: ext.dst, a: ext.dst, b: i.a + l >>> 0, c: 4294967295 }, n);
+        return;
+      default:
+        throw new GameError("invalid_argument", `vector kernel op 0x${i.dst.toString(16)} is not supported by this SDK; update @cimplify/sdk`);
+    }
+  }
+  neural(i, ext, n) {
+    if (i.dst === XOP_MLP_IN) {
+      let at = i.b * (256);
+      for (let k = 0; k < n; k++) this.mlpIn[at + k] = this.lane(i.a, k) >>> 0;
+      return;
+    }
+    if (i.dst === XOP_MLP_OUT) {
+      let at = i.a * (256), d = ext.dst * (256);
+      for (let k = 0; k < n; k++) this.bits[d + k] = this.mlpOut[at + k];
+      return;
+    }
+    let column = this.columns[i.a], words2 = column.storage === (2) || column.storage === (1) ? column.values : new Uint32Array(0), length = Math.min(this.lane(ext.a, 0) >>> 0, words2.length, this.capacity), row = this.mlpRow;
+    if (i.dst === XOP_MLP_MOE) {
+      let moe2 = parseMoe(words2, length, i.b, i.c);
+      for (let k = 0; k < n; k++) {
+        moe2 === null ? row.fill(0) : evalMoeLane(moe2, this.mlpIn, k, (256), row);
+        for (let j = 0; j < i.c; j++) this.mlpOut[j * (256) + k] = row[j];
+      }
+      return;
+    }
+    let net = parseMlp(words2, length, i.b, i.c);
+    for (let k = 0; k < n; k++) {
+      net === null ? row.fill(0) : evalMlpLane(net, this.mlpIn, k, (256), row);
+      for (let j = 0; j < i.c; j++) this.mlpOut[j * (256) + k] = row[j];
+    }
+  }
+  gather(i, ext, n) {
+    let out = this.bits, d = ext.dst * (256), field = i.dst === XOP_FIELD, slots = this.program.slots;
+    for (let k = 0; k < n; k++) {
+      if (ext.a !== 4294967295 && this.lane(ext.a, k) === 0) {
+        out[d + k] = 0;
+        continue;
+      }
+      let at = this.lane(i.b, k) >>> 0;
+      if (field)
+        if (at < i.c) {
+          let column = this.columns[i.a + at];
+          out[d + k] = readAs(slots[i.a + at].kind, column.storage, column.values[this.row(k)]);
+        } else out[d + k] = 0;
+      else {
+        let column = this.columns[i.a], length = this.lane(i.c, k) >>> 0;
+        out[d + k] = at < length && at < column.values.length ? readAs(slots[i.a].kind, column.storage, column.values[at]) : 0;
+      }
+    }
+  }
+  record(pc, i, n) {
+    let records = this.records[this.program.cross.indexOf(pc)], scatter = i.op === CROSS_OP.SCATTER, recur = i.op === XOP && recurSub(i.dst), value = i.op === CROSS_OP.COMPACT ? 4294967295 : i.a, aux = scatter || recur ? i.b : 4294967295, mask = scatter ? this.program.code[pc + 1].b : i.op === CROSS_OP.COMPACT ? i.a : recur ? i.c : i.b;
+    for (let k = 0; k < n; k++) {
+      let at = (this.visit + k) * (4);
+      records[at] = value === 4294967295 ? 0 : this.lane(value, k), records[at + 1] = aux === 4294967295 ? 0 : this.lane(aux, k), records[at + 2] = mask === 4294967295 || this.lane(mask, k) !== 0 ? 1 : 0, records[at + 3] = this.row(k);
+    }
+  }
+  finishExtended(pc, index2, len) {
+    switch (xopRange(this.program.code[pc].dst)) {
+      case XOP_RANGE.CROSS:
+        recurSub(this.program.code[pc].dst) ? this.finishRecurrence(pc, index2, len) : this.finishSort(pc, index2, len);
+        return;
+      case XOP_RANGE.SYSTEMS:
+        finishGraph(this.graphHost(), this.program.code[pc], this.program.code[pc + 1], this.records[index2], len);
+        return;
+      default:
+        throw new GameError("invalid_argument", `extended kernel op 0x${this.program.code[pc].dst.toString(16)} does not end a stage`);
+    }
+  }
+  graphHost() {
+    return this.graphCache !== null ? this.graphCache : (this.graphCache = {
+      capacity: this.capacity,
+      buffers: this.sorting,
+      lane: (w, k) => this.lane(w, k),
+      uniform: (w) => this.u(w),
+      setUniform: (index2, value) => {
+        this.uniforms[index2] = value;
+      },
+      writeRow: (slot, row, value) => {
+        let column = this.columns[slot];
+        column.values[row] = writeAs(this.program.slots[slot].kind, column.storage, value);
+      },
+      array: (slot) => this.columns[slot].values
+    }, this.graphCache);
+  }
+  finishRecurrence(pc, index2, len) {
+    if (this.program.code[pc].dst === XOP_RECUR_IN) return;
+    let ext = this.program.code[pc + 1], mode = ext.c, kind = mode & RECUR_KIND_MASK, pair = recurStateWords(kind) === (2), wideOut = (mode & RECUR_WIDE) !== 0, exclusive = (mode & RECUR_EXCLUSIVE) !== 0, u = this.uniforms, s = this.recurState, before = this.recurBefore, out = this.recurOut;
+    s[0] = ext.a === 4294967295 ? recurIdentity(kind) : this.u(ext.a), s[1] = ext.a !== 4294967295 && pair ? this.u(ext.a + 1) : 0;
+    let first = this.columns[ext.dst], firstKind = this.program.slots[ext.dst].kind, second = wideOut ? this.columns[ext.dst + 1] : first, secondKind = wideOut ? this.program.slots[ext.dst + 1].kind : firstKind, r = this.records[index2], coefficients = kind === RECUR.FEEDBACK_F32 ? this.records[index2 - 1] : null;
+    for (let v = 0; v < len; v++) {
+      let at = v * (4);
+      if (r[at + 2] === 0) continue;
+      before[0] = s[0], before[1] = s[1], recurStep(kind, s, r[at], r[at + 1], coefficients === null ? 0 : coefficients[at]), recurOutput(kind, mode, exclusive ? before : s, out);
+      let row = r[at + 3];
+      first.values[row] = writeAs(firstKind, first.storage, out[0]), wideOut && (second.values[row] = writeAs(secondKind, second.storage, out[1]));
+    }
+    ext.b !== 4294967295 && (u[ext.b] = s[0], pair && (u[ext.b + 1] = s[1]));
+  }
+  finishSort(pc, index2, len) {
+    let i = this.program.code[pc], ext = this.program.code[pc + 1], r = this.records[index2], cap = this.capacity, kind = i.c & SORT_KEY_MASK, flip = (i.c & SORT_DESCENDING) !== 0 ? 4294967295 : 0, keys = this.sorting.subarray(0, cap), rows = this.sorting.subarray(cap, 2 * cap), keysB = this.sorting.subarray(2 * cap, 3 * cap), rowsB = this.sorting.subarray(3 * cap, 4 * cap), n = 0;
+    for (let v = 0; v < len; v++) {
+      let at = v * (4);
+      r[at + 2] !== 0 && (keys[n] = (sortKey(kind, r[at]) ^ flip) >>> 0, rows[n] = r[at + 3], n++);
+    }
+    let radix = 1 << SORT_RADIX_BITS, counts = this.sortCounts;
+    for (let shift = 0; shift < 32; shift += SORT_RADIX_BITS) {
+      counts.fill(0);
+      for (let k = 0; k < n; k++) counts[keys[k] >>> shift & radix - 1]++;
+      let total = 0;
+      for (let b = 0; b < radix; b++) {
+        let here = counts[b];
+        counts[b] = total, total += here;
+      }
+      for (let k = 0; k < n; k++) {
+        let bucket = keys[k] >>> shift & radix - 1;
+        keysB[counts[bucket]] = keys[k], rowsB[counts[bucket]] = rows[k], counts[bucket]++;
+      }
+      let keysA = keys;
+      keys = keysB, keysB = keysA;
+      let rowsA = rows;
+      rows = rowsB, rowsB = rowsA;
+    }
+    let count;
+    if (i.dst === XOP_SORT || i.dst === XOP_TOPK) {
+      let keep = i.dst === XOP_TOPK ? Math.min(this.u(ext.b), n) : n, target = this.columns[ext.dst].values;
+      for (let k = 0; k < keep; k++) target[k] = rows[k];
+      count = keep;
+    } else {
+      let slot = this.program.slots[ext.dst], column = this.columns[ext.dst], groups = 0;
+      for (let k = 0; k < n; k++) {
+        let first = k === 0 || keys[k] !== keys[k - 1];
+        first && groups++, column.values[rows[k]] = writeAs(slot.kind, column.storage, i.dst === XOP_GROUP ? groups - 1 : first ? 1 : 0);
+      }
+      count = groups;
+    }
+    this.uniforms[ext.a] = count;
+  }
+  finishCross(pc, index2, len) {
+    let i = this.program.code[pc];
+    if (i.op === XOP) {
+      this.finishExtended(pc, index2, len);
+      return;
+    }
+    let r = this.records[index2], C = CROSS_OP, blockFold = (identity, fold) => {
+      let total = identity;
+      for (let block = 0; block < len; block += CROSS_BLOCK) {
+        let partial = identity;
+        for (let v = block; v < Math.min(len, block + CROSS_BLOCK); v++) r[v * (4) + 2] !== 0 && (partial = fold(partial, f32From2(r[v * (4)])));
+        total = fold(total, partial);
+      }
+      return total;
+    };
+    switch (i.op) {
+      case C.REDUCE: {
+        let result;
+        if (i.c === REDUCE_FSUM) result = f32Bits2(blockFold(0, (x, y) => fround5(x + y)));
+        else if (i.c === REDUCE_FMIN) result = f32Bits2(blockFold(1 / 0, fmin));
+        else if (i.c === REDUCE_FMAX) result = f32Bits2(blockFold(-1 / 0, fmax));
+        else {
+          let identity = [0, 0, 0, 0, 2147483647, 2147483648, 4294967295, 0][i.c], fold = (acc, v) => {
+            switch (i.c) {
+              case REDUCE_ISUM:
+                return acc + v >>> 0;
+              case REDUCE_IMIN:
+                return ((acc | 0) < (v | 0) ? acc : v) >>> 0;
+              case REDUCE_IMAX:
+                return ((acc | 0) > (v | 0) ? acc : v) >>> 0;
+              case REDUCE_UMIN:
+                return Math.min(acc >>> 0, v >>> 0);
+              default:
+                return Math.max(acc >>> 0, v >>> 0);
+            }
+          };
+          result = identity;
+          for (let v = 0; v < len; v++) r[v * (4) + 2] !== 0 && (result = fold(result, r[v * (4)]));
+        }
+        this.uniforms[i.dst] = result >>> 0;
+        return;
+      }
+      case C.ARG: {
+        let better = (x, y) => {
+          switch (i.c) {
+            case ARG_FMIN:
+              return f32From2(x) < f32From2(y);
+            case ARG_FMAX:
+              return f32From2(x) > f32From2(y);
+            case ARG_IMIN:
+              return (x | 0) < (y | 0);
+            case ARG_IMAX:
+              return (x | 0) > (y | 0);
+            case ARG_UMIN:
+              return x >>> 0 < y >>> 0;
+            default:
+              return x >>> 0 > y >>> 0;
+          }
+        }, float = i.c <= ARG_FMAX, bestValue = 0, bestRow = 4294967295;
+        for (let v = 0; v < len; v++) {
+          let at = v * (4);
+          r[at + 2] === 0 || float && Number.isNaN(f32From2(r[at])) || (bestRow === 4294967295 || better(r[at], bestValue)) && (bestValue = r[at], bestRow = r[at + 3]);
+        }
+        this.uniforms[i.dst] = bestRow;
+        return;
+      }
+      case C.HIST: {
+        let bins = this.u(i.c), target = this.columns[i.dst].values;
+        for (let v = 0; v < len; v++) {
+          let at = v * (4);
+          r[at + 2] !== 0 && r[at] < bins && (target[r[at]] = target[r[at]] + 1 >>> 0);
+        }
+        return;
+      }
+      case C.SCATTER: {
+        let size = this.u(this.program.code[pc + 1].a), target = this.columns[i.dst].values;
+        for (let v = 0; v < len; v++) {
+          let at = v * (4);
+          if (r[at + 2] === 0 || r[at] >= size) continue;
+          let cell = r[at];
+          target[cell] = i.c === SCATTER_FADD ? fround5(target[cell] + f32From2(r[at + 1])) : target[cell] + r[at + 1] >>> 0;
+        }
+        return;
+      }
+      case C.SCAN: {
+        let slot = this.program.slots[i.dst], column = this.columns[i.dst], inclusive = i.c === SCAN_F_INCLUSIVE || i.c === SCAN_I_INCLUSIVE;
+        if (i.c <= SCAN_F_EXCLUSIVE) {
+          let before = 0;
+          for (let block = 0; block < len; block += CROSS_BLOCK) {
+            let running = 0;
+            for (let v = block; v < Math.min(len, block + CROSS_BLOCK); v++) {
+              let at = v * (4);
+              if (r[at + 2] === 0) continue;
+              let previous = running;
+              running = fround5(running + f32From2(r[at])), column.values[r[at + 3]] = writeAs(slot.kind, column.storage, f32Bits2(fround5(before + (inclusive ? running : previous))));
+            }
+            before = fround5(before + running);
+          }
+        } else {
+          let running = 0;
+          for (let v = 0; v < len; v++) {
+            let at = v * (4);
+            if (r[at + 2] === 0) continue;
+            let previous = running;
+            running = running + r[at] >>> 0, column.values[r[at + 3]] = writeAs(slot.kind, column.storage, inclusive ? running : previous);
+          }
+        }
+        return;
+      }
+      case C.COMPACT: {
+        let target = this.columns[i.dst].values, count = 0;
+        for (let v = 0; v < len; v++) {
+          let at = v * (4);
+          r[at + 2] !== 0 && (target[count++] = r[at + 3]);
+        }
+        this.uniforms[i.b] = count;
+        return;
+      }
+    }
+  }
+  trips(word, flags) {
+    let raw = this.u(word), count;
+    if ((flags & LOOP_COUNT_F32) !== 0) {
+      let v = f32From2(raw);
+      count = v > 0 ? Math.min(Math.ceil(v), 65536) : 0;
+    } else count = Math.max(raw | 0, 0);
+    return Math.min(count, 65536);
+  }
+  neighbours(start, end, active, n) {
+    let [x, y, z] = this.program.position, xs = new Float32Array(this.snapshot[x].buffer), ys = new Float32Array(this.snapshot[y].buffer), zs = z === 4294967295 ? null : new Float32Array(this.snapshot[z].buffer), pairs = 0;
+    for (let lane = 0; lane < n; lane++) {
+      if (active !== 4294967295 && this.lane(active, lane) === 0) continue;
+      let row = this.row(lane);
+      this.grid.walk(xs[row], ys[row], zs === null ? 0 : zs[row], row, this.found);
+      for (let neighbour of this.found)
+        if (this.pairLane[pairs] = lane, this.pairRow[pairs] = neighbour, pairs++, pairs === (256)) {
+          let savedList = this.listMode, savedBase = this.base;
+          this.exec(start, end, (256)), this.listMode = savedList, this.base = savedBase, pairs = 0;
+        }
+    }
+    pairs > 0 && this.exec(start, end, pairs);
+  }
+  source(word, slot, n) {
+    return word === 4294967295 ? this.splats[slot] : this.isUniform(word) ? this.splats[slot].fill(this.u(word), 0, n) : this.bits.subarray(word * (256), word * (256) + (256));
+  }
+  arith(i, n) {
+    let bits = this.bits; this.floats; let d = i.dst * (256), UA = this.source(i.a, 0, n), UB = this.source(i.b, 1, n), UC = this.source(i.c, 2, n), FA = new Float32Array(UA.buffer, UA.byteOffset, (256)), FB = new Float32Array(UB.buffer, UB.byteOffset, (256)), FC = new Float32Array(UC.buffer, UC.byteOffset, (256)), fa = (k) => FA[k], fb = (k) => FB[k], fc = (k) => FC[k], ua = (k) => UA[k], ub = (k) => UB[k], uc = (k) => UC[k], out = this.scratch, fout = this.fscratch, f1 = (g) => {
+      for (let k = 0; k < n; k++) fout[k] = g(fa(k));
+    }, f2 = (g) => {
+      for (let k = 0; k < n; k++) fout[k] = g(fa(k), fb(k));
+    }, f3 = (g) => {
+      for (let k = 0; k < n; k++) fout[k] = g(fa(k), fb(k), fc(k));
+    }, i1 = (g) => {
+      for (let k = 0; k < n; k++) out[k] = g(ua(k));
+    }, i2 = (g) => {
+      for (let k = 0; k < n; k++) out[k] = g(ua(k), ub(k));
+    }, cmp = (g) => {
+      for (let k = 0; k < n; k++) out[k] = g(fa(k), fb(k)) ? (4294967295) : 0;
+    }, icmp = (g) => {
+      for (let k = 0; k < n; k++) out[k] = g(ua(k), ub(k)) ? (4294967295) : 0;
+    };
+    switch (i.op) {
+      case Op3.MOV:
+        i1((x) => x);
+        break;
+      case Op3.SEL:
+        for (let k = 0; k < n; k++) out[k] = ua(k) !== 0 ? ub(k) : uc(k);
+        break;
+      case Op3.FADD:
+        f2((x, y) => x + y);
+        break;
+      case Op3.FSUB:
+        f2((x, y) => x - y);
+        break;
+      case Op3.FMUL:
+        f2((x, y) => x * y);
+        break;
+      case Op3.FDIV:
+        f2((x, y) => x / y);
+        break;
+      case Op3.FMIN:
+        f2(fmin);
+        break;
+      case Op3.FMAX:
+        f2(fmax);
+        break;
+      case Op3.FMOD:
+        for (let k = 0; k < n; k++) {
+          let r = fa(k) % fb(k);
+          Number.isNaN(r) ? out[k] = CANONICAL_NAN32 : fout[k] = r;
+        }
+        break;
+      case Op3.FPOW:
+        f2(pow);
+        break;
+      case Op3.FATAN2:
+        f2(atan2);
+        break;
+      case Op3.FLEN2:
+        f2((x, y) => Math.sqrt(fround5(fround5(x * x) + fround5(y * y))));
+        break;
+      case Op3.FMULADD:
+        f3((x, y, z) => fround5(x * y) + z);
+        break;
+      case Op3.FMULSUB:
+        f3((x, y, z) => fround5(x * y) - z);
+        break;
+      case Op3.FSUBMUL:
+        f3((x, y, z) => fround5(x - y) * z);
+        break;
+      case Op3.FADDMUL:
+        f3((x, y, z) => fround5(x + y) * z);
+        break;
+      case Op3.FCLAMP:
+        f3((x, y, z) => fmin(fmax(x, y), z));
+        break;
+      case Op3.FLERP:
+        f3((x, y, z) => x + fround5(fround5(y - x) * z));
+        break;
+      case Op3.FLEN3:
+        f3((x, y, z) => Math.sqrt(fround5(fround5(fround5(x * x) + fround5(y * y)) + fround5(z * z))));
+        break;
+      case Op3.NOISE3:
+        f3(noise3);
+        break;
+      case Op3.FNEG:
+        i1((x) => (x ^ 2147483648) >>> 0);
+        break;
+      case Op3.FABS:
+        i1((x) => (x & 2147483647) >>> 0);
+        break;
+      case Op3.FSQRT:
+        f1(Math.sqrt);
+        break;
+      case Op3.FFLOOR:
+        f1(Math.floor);
+        break;
+      case Op3.FCEIL:
+        f1(Math.ceil);
+        break;
+      case Op3.FROUND:
+        f1(roundJs);
+        break;
+      case Op3.FTRUNC:
+        f1(Math.trunc);
+        break;
+      case Op3.FSIGN:
+        f1(sign);
+        break;
+      case Op3.FSIN:
+        f1(sin);
+        break;
+      case Op3.FCOS:
+        f1(cos);
+        break;
+      case Op3.FTAN:
+        f1(tan);
+        break;
+      case Op3.FASIN:
+        f1(asin);
+        break;
+      case Op3.FACOS:
+        f1(acos);
+        break;
+      case Op3.FATAN:
+        f1(atan);
+        break;
+      case Op3.FEXP:
+        f1(exp);
+        break;
+      case Op3.FLOG:
+        f1(log);
+        break;
+      case Op3.FLOG2:
+        f1(log2);
+        break;
+      case Op3.FLT:
+        cmp((x, y) => x < y);
+        break;
+      case Op3.FLE:
+        cmp((x, y) => x <= y);
+        break;
+      case Op3.FEQ:
+        cmp((x, y) => x === y);
+        break;
+      case Op3.FNE:
+        cmp((x, y) => x !== y);
+        break;
+      case Op3.IADD:
+        i2((x, y) => x + y >>> 0);
+        break;
+      case Op3.ISUB:
+        i2((x, y) => x - y >>> 0);
+        break;
+      case Op3.IMUL:
+        i2((x, y) => Math.imul(x, y) >>> 0);
+        break;
+      case Op3.IREM:
+        i2((x, y) => y === 0 ? 0 : ((x | 0) % (y | 0) | 0) >>> 0);
+        break;
+      case Op3.UREM:
+        i2((x, y) => y === 0 ? 0 : x % y);
+        break;
+      case Op3.IAND:
+        i2((x, y) => (x & y) >>> 0);
+        break;
+      case Op3.IOR:
+        i2((x, y) => (x | y) >>> 0);
+        break;
+      case Op3.IXOR:
+        i2((x, y) => (x ^ y) >>> 0);
+        break;
+      case Op3.ISHL:
+        i2((x, y) => x << (y & 31) >>> 0);
+        break;
+      case Op3.ISHR:
+        i2((x, y) => (x | 0) >> (y & 31) >>> 0);
+        break;
+      case Op3.IUSHR:
+        i2((x, y) => x >>> (y & 31));
+        break;
+      case Op3.IMIN:
+        i2((x, y) => Math.min(x | 0, y | 0) >>> 0);
+        break;
+      case Op3.IMAX:
+        i2((x, y) => Math.max(x | 0, y | 0) >>> 0);
+        break;
+      case Op3.UMIN:
+        i2(Math.min);
+        break;
+      case Op3.UMAX:
+        i2(Math.max);
+        break;
+      case Op3.INEG:
+        i1((x) => -x >>> 0);
+        break;
+      case Op3.IABS:
+        i1((x) => Math.abs(x | 0) >>> 0);
+        break;
+      case Op3.INOT:
+        i1((x) => ~x >>> 0);
+        break;
+      case Op3.ILT:
+        icmp((x, y) => (x | 0) < (y | 0));
+        break;
+      case Op3.ILE:
+        icmp((x, y) => (x | 0) <= (y | 0));
+        break;
+      case Op3.IEQ:
+        icmp((x, y) => x === y);
+        break;
+      case Op3.INE:
+        icmp((x, y) => x !== y);
+        break;
+      case Op3.ULT:
+        icmp((x, y) => x < y);
+        break;
+      case Op3.ULE:
+        icmp((x, y) => x <= y);
+        break;
+      case Op3.ITOF:
+        for (let k = 0; k < n; k++) fout[k] = ua(k) | 0;
+        break;
+      case Op3.UTOF:
+        for (let k = 0; k < n; k++) fout[k] = ua(k);
+        break;
+      case Op3.FTOI:
+        for (let k = 0; k < n; k++) out[k] = toInt(fa(k)) >>> 0;
+        break;
+      case Op3.BTOF:
+        for (let k = 0; k < n; k++) fout[k] = ua(k) !== 0 ? 1 : 0;
+        break;
+      case Op3.BTOI:
+        i1((x) => x !== 0 ? 1 : 0);
+        break;
+      case Op3.FTOB:
+        for (let k = 0; k < n; k++) out[k] = fa(k) !== 0 && !Number.isNaN(fa(k)) ? (4294967295) : 0;
+        break;
+      case Op3.ITOB:
+        i1((x) => x !== 0 ? (4294967295) : 0);
+        break;
+      case Op3.MAND:
+        i2((x, y) => (x & y) >>> 0);
+        break;
+      case Op3.MOR:
+        i2((x, y) => (x | y) >>> 0);
+        break;
+      case Op3.MANDN:
+        i2((x, y) => (x & ~y) >>> 0);
+        break;
+      case Op3.MNOT:
+        i1((x) => ~x >>> 0);
+        break;
+      case Op3.NOISE2:
+        f2(noise2);
+        break;
+      case Op3.HASH:
+        i2(hash);
+        break;
+      case Op3.RAND:
+        for (let k = 0; k < n; k++) fout[k] = unit(ua(k), ub(k));
+        break;
+      case Op3.UADDC:
+        for (let k = 0; k < n; k++) out[k] = ua(k) + ub(k) + (uc(k) & 1) >= (4294967296) ? 1 : 0;
+        break;
+      case Op3.USUBB:
+        for (let k = 0; k < n; k++) out[k] = ua(k) < ub(k) + (uc(k) & 1) ? 1 : 0;
+        break;
+      case Op3.UMULHI:
+        for (let k = 0; k < n; k++) out[k] = mulHigh(ua(k), ub(k));
+        break;
+      default:
+        throw new GameError("invalid_argument", `kernel opcode ${i.op} is not part of instruction set ${4}`);
+    }
+    bits.set(n === (256) ? out : out.subarray(0, n), d);
+  }
+};
+
+export { CellGrid, KernelSchedule, KernelVm, KernelWatch, MLP_ACC_LIMIT, MLP_ACT_LINEAR, MLP_ACT_RELU, MLP_MAX_LAYERS, MLP_MAX_SHIFT, MLP_MULTIPLIER_LIMIT, MOE_MAX_EXPERTS, MOE_MIN_EXPERTS, QuerySearch, SIMD_TEMPS, STORAGE_F32, STORAGE_I32, STORAGE_U32, STORAGE_U8, curve, evalMlp, evalMoeLane, isSimd, loadMlp, lut1, lut2, mlp, mlpBlob, mlpWords, moe, moeBlob, noise2, noise3, parseMlp, parseMoe, parseProgram, routeMlpLane, sample, setMlp, simdScalarize, toolkit_exports };