@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-RUVGVNOF.mjs

@@ -0,0 +1,2687 @@
+import { events, setEmitRow, setPoolEngine, COMPUTE_SPACE_CPU, listPoolAddress, writeWideArg, hasData, COMPUTE_DEFERRED, routeEvents, readDataReport, dataTables, COMPUTE_STOPPED } from './chunk-E65WCTIG.mjs';
+import { noise3, noise2, parseProgram, STORAGE_F32, STORAGE_I32, STORAGE_U32, STORAGE_U8, isSimd, SIMD_TEMPS, CellGrid, QuerySearch, simdScalarize } from './chunk-MOBSBXVE.mjs';
+import { FMATH_CONSTANTS, Op, evalLane, KERNEL_EXPORT_NAMES, KERNEL_DATA_EXPORT_NAMES, ATTACH_SPAWN_TABLE, SPAWN_STATS_WORDS, ATTACH_UI, ATTACH_AUDIO, ATTACH_VOXELS, ATTACH_CHEMISTRY_GRID, DATA_REPORT_HEADER, RING_HEADER_WORDS, DEFAULT_EVENT_CAPACITY, crossRow, stageEndingOp, f32From, f32Bits, RING_COUNT, RING_DROPPED, XOP, xopRange, XOP_RANGE, laneSignature, XOP_GATHER, XOP_FIELD, XOP_QUERY, XOP_QSHAPE, XOP_QFILTER, XOP_QSTOP, CROSS_OP, DATA_LIST, DATA_KEYOF, DATA_ROWOF, DATA_FLOAD, DATA_ROWS, DATA_PGET, DATA_PSET, DATA_TALLY, DATA_SEND, DATA_PICK, QUERY_FILTERED, QUERY_SHAPE, recurSub, XOP_COMPONENTS_EDGES, LOOP_COUNT_F32, QUERY_SPHERE } from './chunk-SMK6JU2F.mjs';
+import { instantiateApproved } from './chunk-N4RGGDEL.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/kernel/spawns.ts
+var WIDTHS = { vec2: 2, vec3: 3, vec4: 4 }, AXES = ["x", "y", "z", "w"], NO_ROW = 4294967295, spawnOverflow = events("kernel.spawnOverflow", { dropped: "u32", capacity: "u32", table: "u32" });
+function storageOf(values) {
+  return values instanceof Float32Array ? STORAGE_F32 : values instanceof Int32Array ? STORAGE_I32 : values instanceof Uint32Array ? STORAGE_U32 : STORAGE_U8;
+}
+function tableColumns(table) {
+  let out = [];
+  for (let field of Object.keys(table.schema)) {
+    let width = WIDTHS[table.schema[field]] ?? 1;
+    for (let k = 0; k < width; k++) out.push(table.values(field, k));
+  }
+  return out;
+}
+var TableSpawns = class {
+  constructor(table, meta) {
+    this.table = table;
+    this.bySlot = /* @__PURE__ */ new Map();
+    this.columns = tableColumns(table), meta !== null && meta.slots.forEach((slot, k) => {
+      if (slot.spawn !== true) return;
+      if (!(slot.field in table.schema)) throw new GameError("invalid_argument", `kernel ${meta.name} spawns ${slot.field}, which the spawn table does not have`);
+      let values = table.values(slot.field, slot.component);
+      this.bySlot.set(k, { values, storage: storageOf(values) });
+    });
+  }
+  get capacity() {
+    return this.table.capacity;
+  }
+  get count() {
+    return this.table.count;
+  }
+  set count(value) {
+    this.table.count = value;
+  }
+  column(slot) {
+    let column = this.bySlot.get(slot);
+    if (column === void 0) throw new GameError("invalid_argument", "the spawn table has no column for this kernel field");
+    return column;
+  }
+};
+function reportSpawns(stats, into, out) {
+  return out.spawned = stats.spawned, out.dropped = stats.dropped, out.killed = stats.killed, stats.dropped > 0 && (setEmitRow((4294967295)), spawnOverflow.emit({ dropped: stats.dropped, capacity: into.capacity, table: into.id >>> 0 })), out;
+}
+function flatten(prefix, value, out) {
+  if (typeof value == "number") out.push([prefix, 0, value]);
+  else if (typeof value == "boolean") out.push([prefix, 0, value ? 1 : 0]);
+  else if (value !== null && typeof value == "object") {
+    let record = value, keys = Object.keys(record);
+    if (keys.length >= 2 && keys.length <= 4 && keys.every((k, i) => k === AXES[i]) && keys.every((k) => typeof record[k] == "number")) {
+      keys.forEach((k, i) => out.push([prefix, i, record[k]]));
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((inner, i) => flatten(`${prefix}.${i}`, inner, out));
+      return;
+    }
+    for (let key of keys) flatten(prefix.length === 0 ? key : `${prefix}.${key}`, record[key], out);
+  }
+}
+var PlainSpawns = class {
+  constructor() {
+    this.pending = [];
+    this.kills = /* @__PURE__ */ new Set();
+    this.sequence = 0;
+  }
+  spawn(row, values) {
+    let fields = [];
+    flatten("", values, fields), this.pending.push({ row, order: this.sequence++, fields });
+  }
+  kill(row) {
+    this.kills.add(row);
+  }
+  get used() {
+    return this.pending.length > 0 || this.kills.size > 0;
+  }
+  finish(own, into, out) {
+    if (out.spawned = 0, out.dropped = 0, out.killed = 0, this.kills.size > 0) {
+      let columns2 = tableColumns(own), total = own.count, kept = 0;
+      for (let row = 0; row < total; row++)
+        if (!this.kills.has(row)) {
+          if (kept !== row) for (let column of columns2) column[kept] = column[row];
+          kept++;
+        }
+      out.killed = total - kept, own.count = kept;
+    }
+    let target = into ?? own, pending = this.pending.sort((a, b) => a.row - b.row || a.order - b.order), columns = tableColumns(target);
+    for (let p of pending) {
+      let at = target.count;
+      if (at >= target.capacity) {
+        out.dropped++;
+        continue;
+      }
+      for (let column of columns) column[at] = 0;
+      for (let [field, component, value] of p.fields) {
+        if (!(field in target.schema)) throw new GameError("invalid_argument", `spawn() sets ${field}, which the spawn table does not have`);
+        let column = target.values(field, component);
+        column[at] = column instanceof Float32Array ? value : Math.trunc(value);
+      }
+      target.count = at + 1, out.spawned++;
+    }
+    return this.pending = [], this.kills.clear(), this.sequence = 0, out;
+  }
+};
+
+// src/game/kernel/wasm-fmath.ts
+var WASM_FMATH = ["sin", "cos", "tan", "asin", "acos", "atan", "exp", "log", "log2", "pow", "atan2"], WASM_FMATH_BINARY = /* @__PURE__ */ new Set(["pow", "atan2"]), I32 = 127, I64 = 126, F32 = 125, F64 = 124, VOID = 64, BLOCK = 2, IF = 4, ELSE = 5, END = 11, BR = 12, BR_TABLE = 14, RETURN = 15, SELECT = 27, LOCAL_GET = 32, LOCAL_SET = 33, LOCAL_TEE = 34, I32_CONST = 65, I64_CONST = 66, F32_CONST = 67, F64_CONST = 68, I32_EQZ = 69, I32_EQ = 70, I32_NE = 71, I32_LT_U = 73, I32_GT_U = 75, I32_GE_U = 79, I64_LT_S = 83, F32_NE = 92, F64_EQ = 97, F64_NE = 98;
+var F64_GT = 100, F64_LE = 101, I32_ADD = 106, I32_SUB = 107, I32_AND = 113, I32_OR = 114, I32_SHL = 116, I32_SHR_S = 117, I32_SHR_U = 118, I64_ADD = 124, I64_SUB = 125, I64_MUL = 126, I64_AND = 131, I64_OR = 132, I64_SHL = 134, I64_SHR_U = 136, F64_ABS = 153, F64_NEG = 154, F64_SQRT = 159, F64_ADD = 160, F64_SUB = 161, F64_MUL = 162, F64_DIV = 163, F64_MIN = 164, F64_MAX = 165, I32_WRAP_I64 = 167, I32_TRUNC_F64_S = 170, I64_EXTEND_I32_U = 173, F32_DEMOTE_F64 = 182, F64_CONVERT_I32_S = 183, F64_CONVERT_I64_S = 185, F64_PROMOTE_F32 = 187, I32_REINTERPRET_F32 = 188, I64_REINTERPRET_F64 = 189, F32_REINTERPRET_I32 = 190, F64_REINTERPRET_I64 = 191, CANONICAL_NAN = 2143289344, SIGN = 2147483648, ABS = 2147483647, EXPONENT_MASK = 4286578688, INFINITY_SHIFTED = 4278190080, ZERO_INF_NAN = 4278190079, LOW_WORD = 4294967295, EXP_TABLE_SIZE = 32, LOG_TABLE_SIZE = 16, ATAN_TERMS = FMATH_CONSTANTS.ATAN_COEFFS.length;
+function uleb(out, value) {
+  let v = value >>> 0;
+  do {
+    let byte = v & 127;
+    v >>>= 7, v !== 0 && (byte |= 128), out.push(byte);
+  } while (v !== 0);
+}
+function slebBig(out, value) {
+  let v = value;
+  for (; ; ) {
+    let byte = Number(v & 0x7fn);
+    v >>= 7n;
+    let done = v === 0n && (byte & 64) === 0 || v === -1n && (byte & 64) !== 0;
+    if (out.push(done ? byte : byte | 128), done) return;
+  }
+}
+var Fn = class {
+  constructor(params) {
+    this.params = params;
+    this.code = [];
+    this.kinds = [];
+  }
+  local(kind) {
+    return this.kinds.push(kind), this.params + this.kinds.length - 1;
+  }
+  op(...bytes) {
+    for (let b of bytes) this.code.push(b);
+    return this;
+  }
+  get(l) {
+    return this.code.push((32)), uleb(this.code, l), this;
+  }
+  set(l) {
+    return this.code.push((33)), uleb(this.code, l), this;
+  }
+  tee(l) {
+    return this.code.push((34)), uleb(this.code, l), this;
+  }
+  i32(v) {
+    return this.code.push((65)), slebBig(this.code, BigInt(v | 0)), this;
+  }
+  i64(v) {
+    return this.code.push((66)), slebBig(this.code, BigInt.asIntN(64, v)), this;
+  }
+  f32bits(bits) {
+    this.code.push((67));
+    let word = bits >>> 0;
+    return this.code.push(word & 255, word >>> 8 & 255, word >>> 16 & 255, word >>> 24), this;
+  }
+  f64(v) {
+    this.code.push((68));
+    for (let b of new Uint8Array(new Float64Array([v]).buffer)) this.code.push(b);
+    return this;
+  }
+  when(kind, then, otherwise) {
+    return this.code.push((4), kind), then(), otherwise !== void 0 && (this.code.push((5)), otherwise()), this.code.push((11)), this;
+  }
+  returnNan() {
+    return this.f32bits((2143289344)).op((15));
+  }
+  table(index, kind, entries) {
+    let n = entries.length;
+    this.code.push((2), kind);
+    for (let k = 0; k < n; k++) this.code.push((2), (64));
+    this.get(index).op((14)), uleb(this.code, n - 1);
+    for (let k = 0; k < n; k++) uleb(this.code, k);
+    this.code.push((11));
+    for (let k = 0; k < n; k++)
+      entries[k](), k < n - 1 && (this.code.push((12)), uleb(this.code, n - 1 - k)), this.code.push((11));
+    return this;
+  }
+  f64Table(index, values) {
+    return this.table(
+      index,
+      (124),
+      values.map((v) => () => this.f64(v))
+    );
+  }
+  i64Table(index, values) {
+    return this.table(
+      index,
+      (126),
+      values.map((v) => () => this.i64(v))
+    );
+  }
+  finish() {
+    let out = [], groups = [];
+    for (let kind of this.kinds) {
+      let last = groups[groups.length - 1];
+      last !== void 0 && last[1] === kind ? last[0]++ : groups.push([1, kind]);
+    }
+    uleb(out, groups.length);
+    for (let [count, kind] of groups)
+      uleb(out, count), out.push(kind);
+    for (let b of this.code) out.push(b);
+    return out.push((11)), out;
+  }
+}, EXP2_BITS = FMATH_CONSTANTS.EXP2_HI.map((hi, i) => BigInt(hi >>> 0) << 32n | BigInt(FMATH_CONSTANTS.EXP2_LO[i] >>> 0)), PIO4 = FMATH_CONSTANTS.INV_PIO4.map((w) => BigInt(w >>> 0));
+function canonicalReturn(f3, result) {
+  f3.f32bits((2143289344)).get(result).get(result).get(result).op((92)).op((27));
+}
+function clamp(f3, value, low, high) {
+  value(), f3.f64(low).op((165)).f64(high).op((164));
+}
+function exp2Table(f3, xd, shift, poly, signBias) {
+  let shifted = f3.local((124)), ki = f3.local((127)), r = f3.local((124)), s = f3.local((124)), i = f3.local((127));
+  f3.get(xd).f64(shift).op((160)).set(shifted), f3.get(shifted).op((189), (167)).set(ki), f3.get(xd).get(shifted).f64(shift).op((161)).op((161)).set(r), f3.get(ki).i32((32) - 1).op((113)).set(i), f3.i64Table(i, EXP2_BITS), f3.get(ki), signBias(), f3.op((106)).i32(15).op((116)).op((173)).i64(32n).op((134)).op((124)).op((191)).set(s), f3.f64(poly[0]).get(r).op((162)).f64(poly[1]).op((160)), f3.get(r).get(r).op((162)).op((162)), f3.f64(poly[2]).get(r).op((162)).f64(1).op((160)), f3.op((160)).get(s).op((162));
+}
+function normalized(f3, ix, out) {
+  f3.get(ix).i32((2147483647)).op((113)).set(out), f3.get(out).i32(FMATH_CONSTANTS.MIN_NORMAL).op((73)), f3.when((64), () => {
+    f3.get(out).op((190), (187)).f64(FMATH_CONSTANTS.SUBNORMAL_SCALE).op((162)).op((182), (188)), f3.i32(FMATH_CONSTANTS.SUBNORMAL_BIAS).op((107)).set(out);
+  });
+}
+function split(f3, ix) {
+  let tmp = f3.local((127)), i = f3.local((127)), top = f3.local((127)), k = f3.local((127)), r = f3.local((124));
+  return f3.get(ix).i32(FMATH_CONSTANTS.LOG_OFF).op((107)).set(tmp), f3.get(tmp).i32(19).op((118)).i32((16) - 1).op((113)).set(i), f3.get(tmp).i32((4286578688)).op((113)).set(top), f3.get(top).i32(23).op((117)).set(k), f3.get(ix).get(top).op((107)).op((190), (187)), f3.f64Table(i, FMATH_CONSTANTS.INV_C).op((162)).f64(1).op((161)).set(r), { i, k, r };
+}
+function logSpecial(f3, y) {
+  let ix = f3.local((127));
+  f3.get(0).op((188)).set(ix), f3.get(ix).i32(1).op((116)).op((69)).when((64), () => f3.f32bits(4286578688).op((15))), f3.get(ix).i32(FMATH_CONSTANTS.INFINITY_BITS).op((70)).when((64), () => f3.get(0).op((15))), f3.get(ix).i32((2147483648)).op((113)).i32(0).op((71)), f3.get(ix).i32(1).op((116)).i32((4278190080)).op((79)).op((114)), f3.when((64), () => f3.returnNan()), f3.get(y);
+}
+function logFn(two) {
+  let f3 = new Fn(1), ix = f3.local((127)), y = f3.local((124)), r2 = f3.local((124)), out = f3.local((125));
+  f3.get(0).op((188)).set(ix), normalized(f3, ix, ix);
+  let { i, k, r } = split(f3, ix), y0 = f3.local((124));
+  if (two) {
+    f3.f64Table(i, FMATH_CONSTANTS.LOG2_C).get(k).op((183)).op((160)).set(y0), f3.get(r).get(r).op((162)).set(r2), f3.f64(FMATH_CONSTANTS.LOG2_POLY[1]).get(r).op((162)).f64(FMATH_CONSTANTS.LOG2_POLY[2]).op((160)).set(y), f3.f64(FMATH_CONSTANTS.LOG2_POLY[0]).get(r2).op((162)).get(y).op((160)).set(y);
+    let p = f3.local((124));
+    f3.f64(FMATH_CONSTANTS.LOG2_POLY[3]).get(r).op((162)).get(y0).op((160)).set(p), f3.get(y).get(r2).op((162)).get(p).op((160)).set(y);
+  } else
+    f3.f64Table(i, FMATH_CONSTANTS.LOG_C).get(k).op((183)).f64(FMATH_CONSTANTS.LN2).op((162)).op((160)).set(y0), f3.get(r).get(r).op((162)).set(r2), f3.f64(FMATH_CONSTANTS.LOG_POLY[1]).get(r).op((162)).f64(FMATH_CONSTANTS.LOG_POLY[2]).op((160)).set(y), f3.f64(FMATH_CONSTANTS.LOG_POLY[0]).get(r2).op((162)).get(y).op((160)).set(y), f3.get(y).get(r2).op((162)).get(y0).get(r).op((160)).op((160)).set(y);
+  return f3.get(y).op((182)).set(out), logSpecial(f3, out), f3.set(out), canonicalReturn(f3, out), f3.finish();
+}
+function expFn() {
+  let f3 = new Fn(1), xd = f3.local((124)), out = f3.local((125));
+  return f3.get(0).get(0).op((92)).when((64), () => f3.returnNan()), f3.f64(FMATH_CONSTANTS.INV_LN2_N), clamp(f3, () => f3.get(0).op((187)), FMATH_CONSTANTS.EXP_LOW, FMATH_CONSTANTS.EXP_HIGH), f3.op((162)).set(xd), exp2Table(f3, xd, FMATH_CONSTANTS.SHIFT, FMATH_CONSTANTS.EXP_POLY, () => f3.i32(0)), f3.op((182)).set(out), canonicalReturn(f3, out), f3.finish();
+}
+function zeroInfNan(f3, bits) {
+  f3.get(bits).i32(1).op((116)).i32(1).op((107)).i32((4278190079)).op((79));
+}
+function powFn() {
+  let f3 = new Fn(2), ix = f3.local((127)), iy = f3.local((127)), ax = f3.local((127)), yint = f3.local((127)), odd = f3.local((127)), e = f3.local((127)), shift = f3.local((127)), x2 = f3.local((124)), ylogx = f3.local((124)), norm = f3.local((127)), out = f3.local((125)), xf = () => f3.get(0).op((187)), yf = () => f3.get(1).op((187));
+  f3.get(0).op((188)).set(ix), f3.get(1).op((188)).set(iy), f3.get(ix).i32((2147483647)).op((113)).set(ax), zeroInfNan(f3, iy), f3.when((64), () => {
+    f3.get(iy).i32(1).op((116)).op((69)).get(ix).i32(FMATH_CONSTANTS.ONE_BITS).op((70)).op((114)), f3.when((64), () => f3.f32bits(FMATH_CONSTANTS.ONE_BITS).op((15))), f3.get(ix).i32(1).op((116)).i32((4278190080)).op((75)), f3.get(iy).i32(1).op((116)).i32((4278190080)).op((75)).op((114)), f3.when((64), () => f3.returnNan()), f3.get(ax).i32(FMATH_CONSTANTS.ONE_BITS).op((70)).when((64), () => f3.f32bits(FMATH_CONSTANTS.ONE_BITS).op((15))), f3.get(ax).i32(FMATH_CONSTANTS.ONE_BITS).op((73)).get(iy).i32((2147483648)).op((113)).op((69)).op((70)), f3.when((64), () => f3.f32bits(0).op((15))), yf().get(1).op((187)).op((162)).op((182)).op((15));
+  }), f3.get(iy).i32(23).op((118)).i32(255).op((113)).set(e), f3.get(e).i32(127).op((73)), f3.when(
+    (64),
+    () => f3.i32(0).set(yint),
+    () => {
+      f3.get(e).i32(150).op((75)), f3.when(
+        (64),
+        () => f3.i32(2).set(yint),
+        () => {
+          f3.i32(150).get(e).op((107)).set(shift), f3.get(iy).i32(1).get(shift).op((116)).i32(1).op((107)).op((113)).i32(0).op((71)), f3.when(
+            (64),
+            () => f3.i32(0).set(yint),
+            () => {
+              f3.i32(1).i32(2).get(iy).i32(1).get(shift).op((116)).op((113)).op((27)).set(yint);
+            }
+          );
+        }
+      );
+    }
+  ), f3.get(ix).i32((2147483648)).op((113)).i32(0).op((71)).get(yint).i32(1).op((70)).op((113)).set(odd), zeroInfNan(f3, ix), f3.when((64), () => {
+    f3.get(0).get(0).op((92)).when((64), () => f3.returnNan()), xf().get(0).op((187)).op((162)).op((182), (187)).set(x2), f3.get(odd).when((64), () => f3.get(x2).op((154)).set(x2)), f3.get(iy).i32((2147483648)).op((113)), f3.when((125), () => f3.f64(1).get(x2).op((163)).op((182)), () => f3.get(x2).op((182))), f3.op((15));
+  }), f3.get(ix).i32((2147483648)).op((113)).i32(0).op((71)).get(yint).op((69)).op((113)).when((64), () => f3.returnNan()), normalized(f3, ix, norm);
+  let { i, k, r } = split(f3, norm), y0 = f3.local((124)), r2 = f3.local((124)), q = f3.local((124));
+  f3.f64Table(i, FMATH_CONSTANTS.LOG2_C).get(k).op((183)).op((160)).set(y0), f3.get(r).get(r).op((162)).set(r2), yf(), f3.f64(FMATH_CONSTANTS.POW_POLY[0]).get(r).op((162)).f64(FMATH_CONSTANTS.POW_POLY[1]).op((160)), f3.get(r2).get(r2).op((162)).op((162)), f3.f64(FMATH_CONSTANTS.POW_POLY[4]).get(r).op((162)).get(y0).op((160)).set(q), f3.f64(FMATH_CONSTANTS.POW_POLY[2]).get(r).op((162)).f64(FMATH_CONSTANTS.POW_POLY[3]).op((160)).get(r2).op((162)).get(q).op((160)), f3.op((160)).op((162)).set(ylogx);
+  let signed = (bits) => {
+    f3.f32bits(bits | (2147483648)).f32bits(bits).get(odd).op((27)).op((15));
+  };
+  f3.get(ylogx).f64(FMATH_CONSTANTS.POW_OVERFLOW).op((100)).when((64), () => signed(FMATH_CONSTANTS.INFINITY_BITS)), f3.get(ylogx).f64(FMATH_CONSTANTS.POW_SATURATE).op((100)).when((64), () => signed(2139095039)), f3.get(ylogx).f64(FMATH_CONSTANTS.POW_UNDERFLOW).op((101)).when((64), () => signed(0));
+  let xd = f3.local((124));
+  return clamp(f3, () => f3.get(ylogx), FMATH_CONSTANTS.EXP2_LOW, FMATH_CONSTANTS.EXP2_HIGH), f3.set(xd), exp2Table(f3, xd, FMATH_CONSTANTS.SHIFT_SCALED, FMATH_CONSTANTS.EXP2_POLY, () => f3.i32(FMATH_CONSTANTS.POW_SIGN_BIAS).i32(0).get(odd).op((27))), f3.op((182)).set(out), canonicalReturn(f3, out), f3.finish();
+}
+function signFlip(f3, n, mask) {
+  f3.f64(-1).f64(1).get(n), mask === 1 && f3.i32(1).op((106)), f3.i32(2).op((113)).op((27));
+}
+function sincos(f3, first, second, which) {
+  let bits = f3.local((127)), x = f3.local((124)), n = f3.local((127)), q = f3.local((127)), flip = f3.local((124)), s = f3.local((124));
+  f3.get(0).op((188)).set(bits), f3.get(bits).i32(20).op((118)).i32(2047).op((113)).i32(FMATH_CONSTANTS.LARGE_TOP).op((73)), f3.when(
+    (64),
+    () => {
+      f3.get(0).op((187)).f64(FMATH_CONSTANTS.HPI_INV).op((162)).op((170)).i32(FMATH_CONSTANTS.QUADRANT_ROUND).op((106)).i32(24).op((117)).tee(n).set(q), f3.get(0).op((187)).get(n).op((183)).f64(FMATH_CONSTANTS.HPI).op((162)).op((161)).set(x);
+    },
+    () => {
+      f3.get(bits).i32(FMATH_CONSTANTS.INFINITY_BITS).op((113)).i32(FMATH_CONSTANTS.INFINITY_BITS).op((70)).when((64), () => f3.returnNan());
+      let at = f3.local((127)), m = f3.local((126)), res0 = f3.local((126)), res = f3.local((126)), t = f3.local((127)), n64 = f3.local((126));
+      f3.get(bits).i32(26).op((118)).i32(15).op((113)).set(at), f3.get(bits).i32(16777215).op((113)).i32(8388608).op((114)).get(bits).i32(23).op((118)).i32(7).op((113)).op((116)).op((173)).set(m), f3.get(m).get(at).set(t).i64Table(t, PIO4).op((126)).i64(BigInt((4294967295))).op((131)).set(res0), f3.get(at).i32(8).op((106)).set(t), f3.get(m).i64Table(t, PIO4).op((126)).i64(32n).op((136)).get(res0).i64(32n).op((134)).op((132)).set(res), f3.get(at).i32(4).op((106)).set(t), f3.get(res).get(m).i64Table(t, PIO4).op((126)).op((124)).set(res), f3.get(res).i64(1n << 61n).op((124)).i64(62n).op((136)).set(n64), f3.get(res).get(n64).i64(62n).op((134)).op((125)).set(res), f3.get(res).op((185)).f64(FMATH_CONSTANTS.PI63).op((162)).set(x), f3.get(n64).op((167)).tee(n).get(bits).i32(31).op((118)).op((106)).set(q);
+    }
+  ), signFlip(f3, q, 2), f3.set(flip), signFlip(f3, q, 1), f3.set(s);
+  let xs = f3.local((124)), x2 = f3.local((124)), x3 = f3.local((124)), x4 = f3.local((124));
+  f3.get(x).get(s).op((162)).set(xs), f3.get(x).get(x).op((162)).set(x2), f3.get(x2).get(xs).op((162)).set(x3), f3.get(x2).get(x2).op((162)).set(x4);
+  let sinePoly = () => {
+    f3.get(xs).get(x3).f64(FMATH_CONSTANTS.SIN_S1).op((162)).op((160)), f3.get(x3).get(x2).op((162)), f3.f64(FMATH_CONSTANTS.SIN_S2).get(x2).f64(FMATH_CONSTANTS.SIN_S3).op((162)).op((160)), f3.op((162)).op((160));
+  }, cosinePoly = () => {
+    f3.get(flip).get(x2).f64(FMATH_CONSTANTS.COS_C1).get(flip).op((162)).op((162)).op((160)), f3.get(x4).f64(FMATH_CONSTANTS.COS_C2).get(flip).op((162)).op((162)).op((160)), f3.get(x4).get(x2).op((162)), f3.f64(FMATH_CONSTANTS.COS_C3).get(flip).op((162)).get(x2).f64(FMATH_CONSTANTS.COS_C4).get(flip).op((162)).op((162)).op((160)), f3.op((162)).op((160));
+  }, odd = () => f3.get(n).i32(1).op((113));
+  which !== "cos" && (odd().when((124), cosinePoly, sinePoly), f3.set(first)), which !== "sin" && (odd().when((124), sinePoly, cosinePoly), f3.set(second));
+}
+function trigFn(which) {
+  let f3 = new Fn(1), first = f3.local((124)), second = f3.local((124)), out = f3.local((125));
+  return sincos(f3, first, second, which), which === "sin" ? f3.get(first) : which === "cos" ? f3.get(second) : f3.get(first).get(second).op((163)), f3.op((182)).set(out), canonicalReturn(f3, out), f3.finish();
+}
+function signBit(f3, value) {
+  f3.get(value).op((189)).i64(0n).op((83));
+}
+function atan2Wide(f3, y, x, v) {
+  f3.get(x).get(x).op((98)).get(y).get(y).op((98)).op((114)).when((64), () => f3.returnNan());
+  let ax = f3.local((124)), ay = f3.local((124)), high = f3.local((124)), low = f3.local((124)), t = f3.local((124)), u = f3.local((124)), u2 = f3.local((124)), p = f3.local((124)), big = f3.local((127));
+  f3.get(x).op((153)).set(ax), f3.get(y).op((153)).set(ay), f3.get(ax).get(ay).op((165)).set(high), f3.get(ax).get(ay).op((164)).set(low), f3.get(high).f64(0).op((97)), f3.when(
+    (124),
+    () => f3.f64(0),
+    () => {
+      f3.get(low).f64(Number.POSITIVE_INFINITY).op((97)), f3.when((124), () => f3.f64(1), () => f3.get(low).get(high).op((163)));
+    }
+  ), f3.set(t), f3.get(t).f64(FMATH_CONSTANTS.TAN_PI_8).op((100)).set(big), f3.get(big), f3.when((124), () => f3.get(t).f64(1).op((161)).get(t).f64(1).op((160)).op((163)), () => f3.get(t)), f3.set(u), f3.get(u).get(u).op((162)).set(u2), f3.f64(0).set(p);
+  for (let k = ATAN_TERMS - 1; k >= 0; k--) f3.f64(FMATH_CONSTANTS.ATAN_COEFFS[k]).get(u2).get(p).op((162)).op((160)).set(p);
+  f3.f64(FMATH_CONSTANTS.QUARTER_PI).f64(0).get(big).op((27)).get(u).get(p).op((162)).op((160)).set(v), f3.get(ay).get(ax).op((100)).when((64), () => f3.f64(FMATH_CONSTANTS.HALF_PI).get(v).op((161)).set(v)), signBit(f3, x), f3.when((64), () => f3.f64(Math.PI).get(v).op((161)).set(v)), signBit(f3, y), f3.when((64), () => f3.get(v).op((154)).set(v));
+}
+function atanFamily(which) {
+  let f3 = new Fn(which === "atan2" ? 2 : 1), y = f3.local((124)), x = f3.local((124)), v = f3.local((124)), out = f3.local((125));
+  if (which === "atan2")
+    f3.get(0).op((187)).set(y), f3.get(1).op((187)).set(x);
+  else if (which === "atan")
+    f3.get(0).op((187)).set(y), f3.f64(1).set(x);
+  else {
+    let a = f3.local((124));
+    f3.get(0).op((187)).set(a), f3.get(a).op((153)).f64(1).op((100)).when((64), () => f3.returnNan()), f3.f64(1).get(a).op((161)).f64(1).get(a).op((160)).op((162)).op((159)), which === "asin" ? f3.set(x).get(a).set(y) : f3.set(y).get(a).set(x);
+  }
+  return atan2Wide(f3, y, x, v), f3.get(v).op((182)).set(out), canonicalReturn(f3, out), f3.finish();
+}
+function build(name2) {
+  switch (name2) {
+    case "sin":
+    case "cos":
+    case "tan":
+      return trigFn(name2);
+    case "exp":
+      return expFn();
+    case "log":
+      return logFn(false);
+    case "log2":
+      return logFn(true);
+    case "pow":
+      return powFn();
+    default:
+      return atanFamily(name2);
+  }
+}
+var V128 = 123, SIMD = 253, CALL = 16, LANES = 4, V = {
+  shuffle: 13,
+  i32splat: 17,
+  f64splat: 20,
+  f32extract: 31,
+  f32replace: 32,
+  i32ne: 56,
+  i32ltU: 58,
+  and: 78,
+  bitselect: 82,
+  demoteZero: 94,
+  promoteLow: 95,
+  i32allTrue: 163,
+  i32shrS: 172,
+  i32shrU: 173,
+  i32add: 174,
+  i64extendLowS: 199,
+  f64add: 240,
+  f64sub: 241,
+  f64mul: 242,
+  truncSatZero: 252,
+  convertLow: 254
+}, HIGH_HALF = [8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15], JOIN_HALVES = [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23];
+function simd(f3, op) {
+  return f3.code.push((253)), uleb(f3.code, op), f3;
+}
+function splatF64(f3, value) {
+  return simd(f3.f64(value), V.f64splat);
+}
+function splatI32(f3, value) {
+  return simd(f3.i32(value), V.i32splat);
+}
+function laneMask(f3, n, add, bit) {
+  f3.get(n), add !== 0 && simd(splatI32(f3, add), V.i32add), simd(splatI32(f3, bit), V.and), simd(splatI32(f3, 0), V.i32ne), simd(f3, V.i64extendLowS);
+}
+function sincosHalf(f3, half, which, out) {
+  let n = f3.local((123)), x = f3.local((123)), flip = f3.local((123)), s = f3.local((123)), xs = f3.local((123)), x2 = f3.local((123)), x3 = f3.local((123)), x4 = f3.local((123)), mul = () => simd(f3, V.f64mul), add = () => simd(f3, V.f64add);
+  f3.get(half), simd(splatF64(f3, FMATH_CONSTANTS.HPI_INV), V.f64mul), simd(f3, V.truncSatZero), simd(splatI32(f3, FMATH_CONSTANTS.QUADRANT_ROUND), V.i32add), f3.i32(24), simd(f3, V.i32shrS).set(n), f3.get(half).get(n), simd(f3, V.convertLow), splatF64(f3, FMATH_CONSTANTS.HPI), mul(), simd(f3, V.f64sub).set(x), splatF64(f3, -1), splatF64(f3, 1), laneMask(f3, n, 0, 2), simd(f3, V.bitselect).set(flip), splatF64(f3, -1), splatF64(f3, 1), laneMask(f3, n, 1, 2), simd(f3, V.bitselect).set(s), f3.get(x).get(s), mul().set(xs), f3.get(x).get(x), mul().set(x2), f3.get(x2).get(xs), mul().set(x3), f3.get(x2).get(x2), mul().set(x4);
+  let sine = () => {
+    f3.get(xs).get(x3), splatF64(f3, FMATH_CONSTANTS.SIN_S1), mul(), add(), f3.get(x3).get(x2), mul(), splatF64(f3, FMATH_CONSTANTS.SIN_S2).get(x2), splatF64(f3, FMATH_CONSTANTS.SIN_S3), mul(), add(), mul(), add();
+  }, cosine = () => {
+    f3.get(flip).get(x2), splatF64(f3, FMATH_CONSTANTS.COS_C1).get(flip), mul(), mul(), add(), f3.get(x4), splatF64(f3, FMATH_CONSTANTS.COS_C2).get(flip), mul(), mul(), add(), f3.get(x4).get(x2), mul(), splatF64(f3, FMATH_CONSTANTS.COS_C3).get(flip), mul(), f3.get(x2), splatF64(f3, FMATH_CONSTANTS.COS_C4).get(flip), mul(), mul(), add(), mul(), add();
+  };
+  which === "sin" ? (cosine(), sine()) : (sine(), cosine()), laneMask(f3, n, 0, 1), simd(f3, V.bitselect), simd(f3, V.demoteZero).set(out);
+}
+function sincos4(which, scalar) {
+  let f3 = new Fn(1), lo = f3.local((123)), hi = f3.local((123)), rl = f3.local((123)), rh = f3.local((123)), fallback = f3.local((123));
+  f3.get(0).i32(20), simd(f3, V.i32shrU), simd(splatI32(f3, 2047), V.and), simd(splatI32(f3, FMATH_CONSTANTS.LARGE_TOP), V.i32ltU), simd(f3, V.i32allTrue).op((69)), f3.when((64), () => {
+    f3.get(0).set(fallback);
+    for (let lane = 0; lane < (4); lane++)
+      f3.get(fallback).get(0), simd(f3, V.f32extract).op(lane), f3.op((16)), uleb(f3.code, scalar), simd(f3, V.f32replace).op(lane).set(fallback);
+    f3.get(fallback).op((15));
+  }), f3.get(0), simd(f3, V.promoteLow).set(lo), f3.get(0).get(0), simd(f3, V.shuffle);
+  for (let b of HIGH_HALF) f3.code.push(b);
+  simd(f3, V.promoteLow).set(hi), sincosHalf(f3, lo, which, rl), sincosHalf(f3, hi, which, rh), f3.get(rl).get(rh), simd(f3, V.shuffle);
+  for (let b of JOIN_HALVES) f3.code.push(b);
+  return f3.finish();
+}
+var WASM_FMATH_SIMD = ["sin", "cos"];
+function wasmFmathSimdBodies(scalarBase) {
+  return WASM_FMATH_SIMD.map((name2) => sincos4(name2, scalarBase + WASM_FMATH.indexOf(name2)));
+}
+var cached = null;
+function wasmFmathBodies() {
+  return cached === null && (cached = WASM_FMATH.map(build)), cached;
+}
+
+// src/game/kernel/wasm-noise.ts
+var WASM_NOISE = ["fmod", "noise2", "noise3"], I322 = 127, F322 = 125, F642 = 124, VOID2 = 64, LOOP = 3, IF2 = 4, ELSE2 = 5, END2 = 11, BR2 = 12, RETURN2 = 15, I32_EQZ2 = 69, I32_XOR = 115, I32_OR2 = 114, I32_AND2 = 113, I32_ADD2 = 106, I32_MUL = 108, I32_SHR_U2 = 118, F32_EQ = 91, F32_NE2 = 92, F32_LT = 93, F32_GE = 96, F64_LT = 99, F64_LE2 = 101, F64_GE = 102, F32_ABS = 139, F32_FLOOR = 142, F32_ADD = 146, F32_SUB = 147, F32_MUL = 148, F64_SUB2 = 161, F64_MUL2 = 162, F64_COPYSIGN = 166, I32_WRAP_I642 = 167, F32_CONVERT_I32_U = 179, F32_DEMOTE_F642 = 182, F64_PROMOTE_F322 = 187, MISC = 252, I64_TRUNC_SAT_F32_S = 4, CANONICAL_NAN2 = 2143289344, INFINITY_BITS = 2139095040, ZERO_BITS = 0, ONE_BITS = 1065353216, TWO_BITS = 1073741824, THREE_BITS = 1077936128, TWO_POW_63_BITS = 1593835520, TWO_POW_MINUS_24_BITS = 864026624, DOUBLE = 2, HALF = 0.5, LATTICE_X = 2376512323, LATTICE_Y = 3625334849, LATTICE_Z = 3407524639, MIX_A = 2146121005, MIX_B = 2221713035, SHIFT_16 = 16, SHIFT_15 = 15, SHIFT_8 = 8;
+function fmodFn() {
+  let f3 = new Fn(2), x = 0, y = 1, ax = f3.local((124)), ay = f3.local((124)), r = f3.local((124)), t = f3.local((124));
+  return f3.get(x).get(x).op((92)), f3.get(y).get(y).op((92)).op((114)), f3.get(x).op((139)).f32bits((2139095040)).op((91)).op((114)), f3.get(y).f32bits((0)).op((91)).op((114)), f3.when((64), () => f3.f32bits((2143289344)).op((15))), f3.get(y).op((139)).f32bits((2139095040)).op((91)), f3.when((64), () => f3.get(x).op((15))), f3.get(x).op((139), (187)).set(ax), f3.get(y).op((139), (187)).set(ay), f3.get(ax).get(ay).op((99)), f3.when((64), () => f3.get(x).op((15))), f3.get(ay).set(t), f3.op((3), (64)), f3.get(t).f64((2)).op((162)).get(ax).op((101)), f3.when((64), () => {
+    f3.get(t).f64((2)).op((162)).set(t), f3.op((12), 1);
+  }), f3.op((11)), f3.get(ax).set(r), f3.op((3), (64)), f3.get(t).get(ay).op((102)), f3.when((64), () => {
+    f3.get(r).get(t).op((102)), f3.when((64), () => f3.get(r).get(t).op((161)).set(r)), f3.get(t).f64((0.5)).op((162)).set(t), f3.op((12), 1);
+  }), f3.op((11)), f3.get(r).get(x).op((187), (166), (182)), f3.finish();
+}
+function toInt32(f3, floor, out) {
+  f3.get(floor).op((139)).f32bits((1593835520)).op((96)), f3.op((4), (127)), f3.i32(0), f3.op((5)), f3.get(floor).op((252), (4), (167)), f3.op((11)), f3.set(out);
+}
+function cell(f3, value, index, fraction, floor) {
+  f3.get(value).op((142)).set(floor), f3.get(value).get(floor).op((147)).set(fraction), toInt32(f3, floor, index);
+}
+function smooth(f3, t, out) {
+  f3.get(t).get(t).op((148)), f3.f32bits((1077936128)).f32bits((1073741824)).get(t).op((148)).op((147)), f3.op((148)).set(out);
+}
+function lattice(f3, h, x, y, z) {
+  x(), f3.i32((2376512323)).op((108)), y(), f3.i32((3625334849)).op((108)).op((115)), z(), f3.i32((3407524639)).op((108)).op((115)).set(h), f3.get(h).get(h).i32((16)).op((118)).op((115)).set(h), f3.get(h).i32((2146121005)).op((108)).set(h), f3.get(h).get(h).i32((15)).op((118)).op((115)).set(h), f3.get(h).i32((2221713035)).op((108)).set(h), f3.get(h).get(h).i32((16)).op((118)).op((115)).set(h), f3.get(h).i32((8)).op((118)).op((179)).f32bits((864026624)).op((148));
+}
+function mixf(f3, a, b, t, out) {
+  f3.get(a).get(b).get(a).op((147)).get(t).op((148)).op((146)).set(out);
+}
+function noiseFn(dims) {
+  let f3 = new Fn(dims), finite = (p) => {
+    f3.get(p).op((139)).f32bits((2139095040)).op((93));
+  };
+  finite(0), finite(1), f3.op((113)), dims === 3 && (finite(2), f3.op((113))), f3.op((69)), f3.when((64), () => f3.f32bits((0)).op((15)));
+  let floor = f3.local((125)), ix = f3.local((127)), iy = f3.local((127)), iz = f3.local((127)), h = f3.local((127)), fx = f3.local((125)), fy = f3.local((125)), fz = f3.local((125)), u = f3.local((125)), v = f3.local((125)), w = f3.local((125)), la = f3.local((125)), lb = f3.local((125)), a = f3.local((125)), b = f3.local((125)), c = f3.local((125)), d = f3.local((125));
+  cell(f3, 0, ix, fx, floor), cell(f3, 1, iy, fy, floor), dims === 3 ? cell(f3, 2, iz, fz, floor) : f3.i32(0).set(iz), smooth(f3, fx, u), smooth(f3, fy, v), dims === 3 && smooth(f3, fz, w);
+  let at = (base, plus) => () => {
+    f3.get(base), plus !== 0 && f3.i32(plus).op((106));
+  }, pair = (dy, dz, out) => {
+    lattice(f3, h, at(ix, 0), at(iy, dy), at(iz, dz)), f3.set(la), lattice(f3, h, at(ix, 1), at(iy, dy), at(iz, dz)), f3.set(lb), mixf(f3, la, lb, u, out);
+  };
+  return pair(0, 0, a), pair(1, 0, b), dims === 2 ? mixf(f3, a, b, v, a) : (pair(0, 1, c), pair(1, 1, d), mixf(f3, a, b, v, a), mixf(f3, c, d, v, c), mixf(f3, a, c, w, a)), f3.get(a).f32bits((1073741824)).op((148)).f32bits((1065353216)).op((147)), f3.finish();
+}
+var cached2 = null;
+function wasmNoiseBodies() {
+  return cached2 === null && (cached2 = [fmodFn(), noiseFn(2), noiseFn(3)]), cached2;
+}
+
+// src/game/kernel/wasm.ts
+var Op2 = Op, I323 = 127, F323 = 125, V1282 = 123, VOID_BLOCK = 64, BLOCK2 = 2, LOOP2 = 3, IF3 = 4, ELSE3 = 5, END3 = 11, BR3 = 12, BR_IF = 13, CALL2 = 16, SELECT2 = 27, LOCAL_GET2 = 32, LOCAL_SET2 = 33, LOCAL_TEE2 = 34, I32_LOAD = 40, F32_LOAD = 42, I32_LOAD8_U = 45, I32_STORE = 54, I32_STORE8 = 58, F32_REINTERPRET = 190, I32_CONST2 = 65, F32_CONST2 = 67, I32_EQZ3 = 69, I32_EQ2 = 70, I32_NE2 = 71, I32_LT_S = 72, I32_LT_U2 = 73, I32_GT_U2 = 75, I32_GE_U2 = 79, F32_NE3 = 92, F32_LT2 = 93, F32_GT = 94, F32_LE = 95, I32_ADD3 = 106, I32_SUB2 = 107, I32_MUL2 = 108, I32_REM_S = 111, I32_REM_U = 112, I32_AND3 = 113, I32_OR3 = 114, I32_SHL2 = 116, I32_SHR_S2 = 117, I32_SHR_U3 = 118, I64_CONST2 = 66, I64_LT_U = 84, I64_ADD2 = 124, I64_MUL2 = 126, I64_SHR_U2 = 136, I32_WRAP_I643 = 167, I64_EXTEND_I32_U2 = 173, HALF_BITS = 32, F32_CEIL = 141, F32_FLOOR2 = 142, F32_ADD2 = 146, F32_SUB2 = 147, F32_MUL2 = 148, PREFIX_FC = 252, TRUNC_SAT_F32_S = 0, TRUNC_SAT_F32_U = 1, SIMD2 = 253, S = {
+  load: 0,
+  store: 11,
+  const: 12,
+  i32splat: 17,
+  i32extract: 27,
+  i32replace: 28,
+  f32extract: 31,
+  f32replace: 32,
+  i32eq: 55,
+  i32ne: 56,
+  i32lt_s: 57,
+  i32lt_u: 58,
+  i32le_s: 61,
+  i32le_u: 62,
+  f32eq: 65,
+  f32ne: 66,
+  f32lt: 67,
+  f32le: 69,
+  f32ge: 70,
+  not: 77,
+  and: 78,
+  andnot: 79,
+  or: 80,
+  xor: 81,
+  bitselect: 82,
+  anyTrue: 83,
+  load32lane: 86,
+  store32lane: 90,
+  f32ceil: 103,
+  f32floor: 104,
+  f32trunc: 105,
+  i32abs: 160,
+  i32neg: 161,
+  i32shl: 171,
+  i32shr_s: 172,
+  i32shr_u: 173,
+  i32add: 174,
+  i32sub: 177,
+  i32mul: 181,
+  i32min_s: 182,
+  i32min_u: 183,
+  i32max_s: 184,
+  i32max_u: 185,
+  f32abs: 224,
+  f32neg: 225,
+  f32sqrt: 227,
+  f32add: 228,
+  f32sub: 229,
+  f32mul: 230,
+  f32div: 231,
+  truncSatS: 248,
+  convertS: 250,
+  convertU: 251
+}, TWO_POW_31 = 2147483648, MIX_A2 = 2146121005, MIX_B2 = 2221713035, GOLDEN = 2654435769, UNIT_SCALE = 1 / 16777216, LANES2 = 4, STRIDE_X = 1021, STRIDE_Z = 65539, MIN_TABLE = 1024, TABLE_LOAD = 2, KEY_WORDS = 8, KEY_LOOPS = 3, STAGE_WORDS = 2 + (8) + 10, STAGE_HEADROOM = 2, WORD = 4, BYTE_MASK = 255, SHIFT_MASK = 31, INT_MIN = -2147483648, CTX_SNAPSHOT = 0, CTX_CAPACITY = 4, CTX_STARTS = 8, CTX_CELLS = 12, CTX_XS = 16, CTX_YS = 20, CTX_ZS = 24, CTX_ROWS = 28, CTX_MASK = 32, CTX_INVERSE = 36, CTX_RADIUS = 40, CTX_R2 = 44, CTX_LEN = 48, CTX_FLAT = 52, CTX_QUERY_LANES = 56, CTX_QUERY_ROWS = 60, CTX_STAGE = 64, CTX_STAGE_CAPACITY = 68, CTX_STAGED = 72, CTX_QUERY_PARAMS = 76, CTX_ENTITY_ROWS = 80, CTX_ENTITY_MASK = 96, CTX_OUTER = 112, CTX_PAIR_LANE = 128, CTX_PAIR_ROW = 144, CTX_ACC = 160, CTX_LANES = 192, CTX_BYTES = 208;
+var IMPORTS = ["toInt32", "fmod", "noise2", "noise3", "lanes", "data", "query", "queryKeep"], FN = Object.fromEntries(IMPORTS.map((n, k) => [n, k])), UNARY_TYPE = 2, BINARY_TYPE = 3, TERNARY_TYPE = 4, VECTOR_TYPE = 8, UNARY_FMATH = {
+  [Op2.FLOG2]: "log2",
+  [Op2.FSIN]: "sin",
+  [Op2.FCOS]: "cos",
+  [Op2.FTAN]: "tan",
+  [Op2.FASIN]: "asin",
+  [Op2.FACOS]: "acos",
+  [Op2.FATAN]: "atan",
+  [Op2.FEXP]: "exp",
+  [Op2.FLOG]: "log"
+}, FMATH_OPS = /* @__PURE__ */ new Set([...Object.keys(UNARY_FMATH).map(Number), Op2.FPOW, Op2.FATAN2]), NOISE_OPS = /* @__PURE__ */ new Set([Op2.FMOD, Op2.NOISE2, Op2.NOISE3]), IMPORT_TYPE = {
+  toInt32: 0,
+  fmod: 3,
+  noise2: 3,
+  noise3: 4,
+  lanes: 5,
+  data: 5,
+  query: 6,
+  queryKeep: 7
+}, DATA_HOOKS = /* @__PURE__ */ new Map(), QUERY_HOSTS = /* @__PURE__ */ new Map();
+function setWasmDataHook(ctx, hook) {
+  hook === null ? DATA_HOOKS.delete(ctx) : DATA_HOOKS.set(ctx, hook);
+}
+function wasmKernelImports(memory) {
+  let v = new Uint32Array((5)), r = new Uint32Array((3)), words = new Uint32Array(memory.buffer);
+  return {
+    env: {
+      memory,
+      toInt32: (x) => x | 0,
+      fmod: (x, y) => x % y,
+      noise2,
+      noise3,
+      lanes: (sub, input, output) => {
+        words.buffer !== memory.buffer && (words = new Uint32Array(memory.buffer));
+        for (let lane = 0; lane < (4); lane++) {
+          for (let k = 0; k < (5); k++) v[k] = words[(input >>> 2) + k * (4) + lane];
+          evalLane(sub, v, r);
+          for (let k = 0; k < (3); k++) words[(output >>> 2) + k * (4) + lane] = r[k];
+        }
+      },
+      data: (ctx, pc, chunk) => {
+        let hook = DATA_HOOKS.get(ctx >>> 0);
+        if (hook === void 0) throw new Error("a compiled kernel ran a data op without an engine data binding");
+        hook(pc, chunk);
+      },
+      query: (ctx, params, rows, kind, filter, mode) => QUERY_HOSTS.get(ctx >>> 0).query(params, rows, kind, filter | 0, mode),
+      queryKeep: (ctx, stops, p, out) => QUERY_HOSTS.get(ctx >>> 0).keep(stops, p, out)
+    }
+  };
+}
+var QUERY_PARAMS = 11, QUERY_SCRATCH_BYTES = ((11) + 3) * 16, LANE_INPUTS = 5, LANE_OUTPUTS = 3;
+function laneScratchOffset(program) {
+  return Math.ceil(Math.max(program.cross.length, 1) * (4) / (16)) * (16);
+}
+var LANE_SCRATCH_BYTES = ((5) + (3)) * 16, VECTOR_BYTES = 16;
+function uleb2(out, value) {
+  let v = value >>> 0;
+  do {
+    let byte = v & 127;
+    v >>>= 7, v !== 0 && (byte |= 128), out.push(byte);
+  } while (v !== 0);
+}
+function sleb(out, value) {
+  let v = value | 0;
+  for (; ; ) {
+    let byte = v & 127;
+    if (v >>= 7, v === 0 && (byte & 64) === 0 || v === -1 && (byte & 64) !== 0) {
+      out.push(byte);
+      return;
+    }
+    out.push(byte | 128);
+  }
+}
+function section(out, id, body) {
+  out.push(id), uleb2(out, body.length);
+  for (let b of body) out.push(b);
+}
+function name(out, text) {
+  uleb2(out, text.length);
+  for (let k = 0; k < text.length; k++) out.push(text.charCodeAt(k));
+}
+var KNOWN = new Set(Object.values(Op2)), UNROLL = 2, RECORD_SHIFT = 4;
+function known(op) {
+  return KNOWN.has(op) && op !== Op2.CALL;
+}
+function wasmStageName(stage) {
+  return `stage${stage}`;
+}
+function exactStorage(kind, storage) {
+  return kind === 0 ? storage === 0 : (kind === 1 || kind === 2) && (storage === 1 || storage === 2);
+}
+function narrowXop(op, sub) {
+  return op === XOP && xopRange(sub) === XOP_RANGE.NARROW && laneSignature(sub) !== null;
+}
+var DATA_SUBS = /* @__PURE__ */ new Set([DATA_LIST, DATA_KEYOF, DATA_ROWOF, DATA_FLOAD, DATA_ROWS, DATA_PGET, DATA_PSET, DATA_TALLY, DATA_SEND, DATA_PICK]);
+function dataXop(op, sub) {
+  return op === XOP && DATA_SUBS.has(sub);
+}
+function gatherXop(op, sub) {
+  return op === XOP && (sub === XOP_GATHER || sub === XOP_FIELD);
+}
+function queryXop(program, op, sub) {
+  return op === XOP && program.position !== null && (sub === XOP_QUERY || sub === XOP_QSHAPE || sub === XOP_QFILTER || sub === XOP_QSTOP);
+}
+function laneOps(program) {
+  return program.code.some((i) => narrowXop(i.op, i.dst) || dataXop(i.op, i.dst));
+}
+function hostState(program) {
+  return program.position !== null || program.channels.length > 0 || program.state >= 0;
+}
+function staged(program) {
+  return program.calls.length > 0 || program.cross.length > 0 || laneOps(program) && !hostState(program);
+}
+function wasmStaged(program) {
+  return staged(program);
+}
+function wasmNeedsHost(program) {
+  return program.position !== null || program.channels.length > 0 || !staged(program) && laneOps(program);
+}
+function wasmDataOps(program) {
+  return program.code.some((i) => dataXop(i.op, i.dst));
+}
+function wasmQueries(program) {
+  return program.code.some((i) => i.op === XOP && i.dst === XOP_QUERY);
+}
+function wasmStages(program) {
+  let out = [], width = (pc) => program.code[pc].op === CROSS_OP.SCATTER || program.code[pc].op === XOP ? 2 : 1, start = 0, nextCall = 0, nextCross = 0;
+  for (; nextCall < program.calls.length || nextCross < program.cross.length; ) {
+    let callPc = nextCall < program.calls.length ? program.calls[nextCall] : 1 / 0, crossPc = nextCross < program.cross.length ? program.cross[nextCross] : 1 / 0;
+    if (crossPc < callPc) {
+      let pcs = [], end = crossPc;
+      for (; nextCross < program.cross.length && program.cross[nextCross] === end; )
+        pcs.push(end), end += width(end), nextCross++;
+      out.push({ start, end, stage: { barrier: "cross", pcs } }), start = end;
+    } else
+      out.push({ start, end: callPc, stage: { barrier: "call", pcs: [callPc] } }), start = callPc + 1, nextCall++;
+  }
+  return out.push({ start, end: program.code.length, stage: { barrier: "end", pcs: [] } }), out;
+}
+function wasmSupports(program, storages) {
+  if (!(!staged(program) || program.position === null && program.channels.length === 0 && program.state < 0) || !staged(program) && program.slots.some((s) => s.scratch) || storages.length !== program.slots.length || storages.some((s) => s > 3)) return false;
+  if (program.state >= 0) {
+    let slot = program.slots[program.state];
+    if (slot === void 0 || !exactStorage(slot.kind, storages[program.state])) return false;
+  }
+  return program.code.every((i, pc) => known(i.op) || isSimd(i) || crossRow(i.op) || stageEndingOp(i.op, i.dst) || narrowXop(i.op, i.dst) || dataXop(i.op, i.dst) || gatherXop(i.op, i.dst) || !staged(program) && queryXop(program, i.op, i.dst) || i.op === Op2.CALL && program.calls.includes(pc));
+}
+var Body = class {
+  constructor() {
+    this.code = [];
+    this.mapper = (word) => word;
+  }
+  reg(word) {
+    return this.get(this.mapper(word));
+  }
+  op(...bytes) {
+    for (let b of bytes) this.code.push(b);
+    return this;
+  }
+  simd(opcode) {
+    return this.code.push((253)), uleb2(this.code, opcode), this;
+  }
+  get(local) {
+    return this.code.push((32)), uleb2(this.code, local), this;
+  }
+  set(local) {
+    return this.code.push((33)), uleb2(this.code, local), this;
+  }
+  tee(local) {
+    return this.code.push((34)), uleb2(this.code, local), this;
+  }
+  i32(value) {
+    return this.code.push((65)), sleb(this.code, value), this;
+  }
+  f32(value) {
+    this.code.push((67));
+    let bytes = new Uint8Array(new Float32Array([value]).buffer);
+    for (let b of bytes) this.code.push(b);
+    return this;
+  }
+  v128i(lanes) {
+    this.simd(S.const);
+    let bytes = new Uint8Array(new Uint32Array(lanes.map((x) => x >>> 0)).buffer);
+    for (let b of bytes) this.code.push(b);
+    return this;
+  }
+  v128f(value) {
+    this.simd(S.const);
+    let bytes = new Uint8Array(new Float32Array([value, value, value, value]).buffer);
+    for (let b of bytes) this.code.push(b);
+    return this;
+  }
+  mem(align, offset) {
+    return uleb2(this.code, align), uleb2(this.code, offset), this;
+  }
+  call(fn) {
+    return this.code.push((16)), uleb2(this.code, fn), this;
+  }
+  load(ctx, offset) {
+    return this.get(ctx).op((40)).mem(2, offset);
+  }
+};
+function functionBody(program, storages, start, end, fmathBase, noiseBase) {
+  let noise = (fn) => noiseBase + WASM_NOISE.indexOf(fn), fmath = (fn) => fmathBase + WASM_FMATH.indexOf(fn), fmathSimd = (fn) => fmathBase + WASM_FMATH.length + WASM_FMATH_SIMD.indexOf(fn), slotCount = program.slots.length, uniforms = program.uniforms.length, args = program.args, loopBase = program.uniforms.length - program.loops, P_COLS = 0, P_N = 1, P_ROWS = 2, P_ARGS = 3, P_CTX = 4, next = 5, L_I = next++, L_TMP = next++, L_COUNTERS = next;
+  next += uniforms;
+  let L_USCALAR = next;
+  next += uniforms;
+  let L_SLOT = next;
+  next += slotCount;
+  let L_LANE = next++, L_ROW = next++, L_GX = next++, L_GY = next++, L_GZ = next++, L_LY = next++, L_LZ = next++, L_HX = next++, L_HY = next++, L_HZ = next++, L_SLOT_AT = next++, L_END = next++, L_PCOUNT = next++, L_PN = next++, L_NROW = next++, L_IDX = next++, L_BASE = next++, L_A = next++, L_B = next++, L_QP = next++, L_QN = next++, HOISTED = [(0), (4), (8), (12), (16), (20), (24), (28), (32), (36), (40), (44)], L_FIELD = next;
+  next += HOISTED.length;
+  let i32Locals = next - 5, F_CX = next++, F_CY = next++, F_CZ = next++, F_DX = next++, F_DY = next++, F_DZ = next++, F_A = next++, F_B = next++, f32Locals = next - F_CX, V_REG = next, simdTemp = Math.max(program.registers, 1);
+  next += simdTemp + (program.code.some(isSimd) ? SIMD_TEMPS : 0);
+  let V_UNIFORM = next;
+  next += uniforms;
+  let V_TEMP = next;
+  next += 8;
+  let V_ROW = next++, V_VALID = next++, V_PLANE = next++, V_PROW = next++, V_STOP = next++, V_KEEP = next++, v128Locals = next - V_REG, snapshotIndex = [], snapshots = 0;
+  for (let slot of program.slots) snapshotIndex.push(slot.neighbour ? snapshots++ : -1);
+  let b = new Body();
+  for (let s = 0; s < slotCount; s++) b.get(P_COLS).op((40)).mem(2, s * 4).set(L_SLOT + s);
+  for (let u = 0; u < uniforms; u++)
+    u < args || u >= loopBase ? b.get(P_ARGS).op((40)).mem(2, u * 4) : b.i32(program.uniforms[u] | 0), b.tee(L_USCALAR + u).simd(S.i32splat).set(V_UNIFORM + u);
+  program.position !== null && HOISTED.forEach((offset, k) => b.load(P_CTX, offset).set(L_FIELD + k));
+  let field = (offset) => b.get(L_FIELD + HOISTED.indexOf(offset)), reg = (word) => (word & 2147483648) !== 0 ? V_UNIFORM + (word & 2147483647) : V_REG + word;
+  b.mapper = reg;
+  let get = (word) => b.reg(word), temp = (k) => V_TEMP + k, mode = "list", chunkRows = (next2) => {
+    if (mode = next2, b.get(L_I).simd(S.i32splat).v128i([0, 1, 2, 3]).simd(S.i32add).set(V_ROW), next2 === "full" ? b.v128i([-1, -1, -1, -1]).set(V_VALID) : b.get(V_ROW).get(P_N).simd(S.i32splat).simd(S.i32lt_u).set(V_VALID), next2 === "list")
+      for (let lane = 0; lane < (4); lane++)
+        b.get(V_ROW), b.get(L_I).i32(lane).op((106)).get(P_N).op((73)).op((4), (127)), b.get(P_ROWS).get(L_I).i32(lane).op((106)).i32(2).op((116)).op((106)).op((40)).mem(2, 0), b.op((5)).get(P_ROWS).get(L_I).i32(2).op((116)).op((106)).op((40)).mem(2, 0).op((11)), b.simd(S.i32replace).op(lane).set(V_ROW);
+  }, advance = () => {
+    b.get(L_I).i32((4)).op((106)).set(L_I);
+  }, laneInside = (lane) => {
+    b.get(L_I).i32(lane).op((106)).get(P_N).op((73));
+  }, byteSlot = (slot) => storages[slot] === 3, loadRaw = (slot) => {
+    if (byteSlot(slot)) {
+      b.v128i([0, 0, 0, 0]);
+      for (let lane = 0; lane < (4); lane++)
+        b.set(temp(7)), b.get(temp(7)), b.get(L_SLOT + slot).get(V_ROW).simd(S.i32extract).op(lane).op((106)).op((45)).mem(0, 0), b.simd(S.i32replace).op(lane);
+      return;
+    }
+    if (mode !== "list") {
+      b.get(L_SLOT + slot).get(L_I).i32(2).op((116)).op((106)).simd(S.load).mem(2, 0);
+      return;
+    }
+    b.v128i([0, 0, 0, 0]);
+    for (let lane = 0; lane < (4); lane++)
+      b.set(temp(7)), b.get(L_SLOT + slot).get(V_ROW).simd(S.i32extract).op(lane).i32(2).op((116)).op((106)), b.get(temp(7)).simd(S.load32lane).mem(2, 0).op(lane);
+  }, toInt = (source, out) => {
+    b.get(source).simd(S.truncSatS).set(out), b.get(source).simd(S.f32abs).v128f((2147483648)).simd(S.f32ge).simd(S.anyTrue).op((4), (64));
+    for (let lane = 0; lane < (4); lane++)
+      b.get(out).get(source).simd(S.f32extract).op(lane).call(FN.toInt32).simd(S.i32replace).op(lane).set(out);
+    b.op((11));
+  }, readAs = (kind, storage, raw, out) => {
+    if (kind === 0) {
+      storage === 0 ? b.get(raw).set(out) : storage === 1 ? b.get(raw).simd(S.convertS).set(out) : storage === 2 ? b.get(raw).simd(S.convertU).set(out) : b.get(raw).v128i([(255), (255), (255), (255)]).simd(S.and).simd(S.convertU).set(out);
+      return;
+    }
+    if (kind === 3) {
+      storage === 0 ? (b.get(raw).v128f(0).simd(S.f32ne), b.get(raw).get(raw).simd(S.f32eq).simd(S.and).set(out)) : storage === 3 ? b.get(raw).v128i([(255), (255), (255), (255)]).simd(S.and).v128i([0, 0, 0, 0]).simd(S.i32ne).set(out) : b.get(raw).v128i([0, 0, 0, 0]).simd(S.i32ne).set(out);
+      return;
+    }
+    storage === 0 ? toInt(raw, out) : storage === 3 ? b.get(raw).v128i([(255), (255), (255), (255)]).simd(S.and).set(out) : b.get(raw).set(out);
+  }, writeAs = (kind, storage, value, out) => {
+    if (kind === 0) {
+      storage === 0 ? b.get(value).set(out) : toInt(value, out);
+      return;
+    }
+    if (kind === 3) {
+      storage === 0 ? b.v128f(1).v128f(0) : b.v128i([1, 1, 1, 1]).v128i([0, 0, 0, 0]), b.get(value).v128i([0, 0, 0, 0]).simd(S.i32ne).simd(S.bitselect).set(out);
+      return;
+    }
+    storage === 0 ? b.get(value).simd(kind === 1 ? S.convertS : S.convertU).set(out) : b.get(value).set(out);
+  }, loadSlot = (slot, out) => {
+    loadRaw(slot), b.set(temp(6)), readAs(program.slots[slot].kind, storages[slot], temp(6), out);
+  }, writeLanes = (slot, value) => {
+    for (let lane = 0; lane < (4); lane++)
+      laneInside(lane), b.op((4), (64)), byteSlot(slot) ? (b.get(L_SLOT + slot).get(V_ROW).simd(S.i32extract).op(lane).op((106)), b.get(value).simd(S.i32extract).op(lane).op((58)).mem(0, 0)) : (b.get(L_SLOT + slot).get(V_ROW).simd(S.i32extract).op(lane).i32(2).op((116)).op((106)), b.get(value).simd(S.store32lane).mem(2, 0).op(lane)), b.op((11));
+  }, storeSlot = (slot, word) => {
+    let kind = program.slots[slot].kind, storage = storages[slot], value = temp(5);
+    if (exactStorage(kind, storage) ? get(word).set(value) : (loadRaw(slot), b.set(temp(6)), readAs(kind, storage, temp(6), temp(4)), get(word).set(temp(3)), writeAs(kind, storage, temp(3), temp(2)), b.get(temp(6)).get(temp(2)).get(temp(4)).get(temp(3)).simd(S.i32eq).simd(S.bitselect).set(value)), byteSlot(slot)) {
+      writeLanes(slot, value);
+      return;
+    }
+    if (mode === "list") {
+      writeLanes(slot, value);
+      return;
+    }
+    b.get(L_SLOT + slot).get(L_I).i32(2).op((116)).op((106)), mode === "full" ? b.get(value) : b.get(value).get(L_SLOT + slot).get(L_I).i32(2).op((116)).op((106)).simd(S.load).mem(2, 0).get(V_VALID).simd(S.bitselect), b.simd(S.store).mem(2, 0);
+  }, jsMin = (a, c, out, max) => {
+    a(), b.set(temp(0)), c(), b.set(temp(1)), b.get(temp(0)).get(temp(1)).get(temp(0)).get(temp(0)).simd(S.f32ne).simd(S.bitselect).set(temp(2)), b.get(temp(1)).get(temp(2)), max ? b.get(temp(0)).get(temp(1)).simd(S.f32lt) : b.get(temp(1)).get(temp(0)).simd(S.f32lt), b.simd(S.bitselect).set(temp(2)), b.get(temp(0)).get(temp(2)), max ? b.get(temp(1)).get(temp(0)).simd(S.f32lt) : b.get(temp(0)).get(temp(1)).simd(S.f32lt), b.simd(S.bitselect).set(out);
+  }, jsMinScalar = (max) => {
+    b.set(F_B).set(F_A), b.get(F_A), b.get(F_B), b.get(F_A).get(F_B).get(F_A).get(F_A).op((92)).op((27)), max ? b.get(F_B).get(F_A).op((94)) : b.get(F_B).get(F_A).op((93)), b.op((27)), max ? b.get(F_A).get(F_B).op((94)) : b.get(F_A).get(F_B).op((93)), b.op((27));
+  }, lanes = (fn, operands, out) => {
+    for (let k = 0; k < operands.length; k++) get(operands[k]).set(temp(k));
+    b.v128f(0).set(temp(4));
+    for (let lane = 0; lane < (4); lane++) {
+      b.get(temp(4));
+      for (let k = 0; k < operands.length; k++) b.get(temp(k)).simd(S.f32extract).op(lane);
+      b.call(fn).simd(S.f32replace).op(lane).set(temp(4));
+    }
+    b.get(temp(4)).set(out);
+  }, perLane = (a, c, out, op) => {
+    get(a).set(temp(0)), get(c).set(temp(1)), b.v128i([0, 0, 0, 0]).set(temp(2));
+    for (let lane = 0; lane < (4); lane++)
+      b.get(temp(2)), b.get(temp(0)).simd(S.i32extract).op(lane).set(L_A), b.get(temp(1)).simd(S.i32extract).op(lane).set(L_B), op(), b.simd(S.i32replace).op(lane).set(temp(2));
+    b.get(temp(2)).set(out);
+  }, mix2 = () => {
+    for (let [shift, mul] of [
+      [16, (2146121005)],
+      [15, (2221713035)],
+      [16, 0]
+    ])
+      b.tee(temp(5)).get(temp(5)).i32(shift).simd(S.i32shr_u).simd(S.xor), mul !== 0 && b.v128i([mul, mul, mul, mul]).simd(S.i32mul);
+  }, hashInto = (i) => {
+    get(i.b).v128i([(2654435769), (2654435769), (2654435769), (2654435769)]).simd(S.i32add), mix2(), get(i.a).simd(S.xor), mix2();
+  }, code = program.code, loopUniforms = new Set(code.filter((i) => i.op === Op2.LOOP_INIT).map((i) => i.a)), scalarLocal = (word) => {
+    let index = word & 2147483647;
+    return loopUniforms.has(index) ? L_COUNTERS + (index - args) : L_USCALAR + index;
+  }, loopsOf = (open) => open.filter((o) => o.kind === "loop"), emitEvent = (pc, open) => {
+    let i = code[pc], words = program.channels[i.dst], loops = loopsOf(open);
+    if (loops.length > (3)) return false;
+    let key = [];
+    for (let l of loops)
+      key.push(() => b.i32(l.pc)), key.push(() => b.get(L_COUNTERS + (l.counter - args)));
+    for (key.push(() => b.i32(pc)); key.length < (8); ) key.push(() => b.i32(0));
+    for (let lane = 0; lane < (4); lane++) {
+      laneInside(lane), i.a !== 4294967295 && get(i.a).simd(S.i32extract).op(lane).i32(0).op((71)).op((113)), b.op((4), (64)), b.load(P_CTX, (72)).tee(L_IDX), b.get(P_CTX).get(L_IDX).i32(1).op((106)).op((54)).mem(2, (72)), b.load(P_CTX, (68)).op((73)).op((4), (64)), b.load(P_CTX, (64)).get(L_IDX).i32(STAGE_WORDS * (4)).op((108)).op((106)).set(L_BASE);
+      let put = (at, value) => {
+        b.get(L_BASE), value(), b.op((54)).mem(2, at * (4));
+      };
+      put(0, () => b.get(L_I).i32(lane).op((106))), key.forEach((k, w) => put(1 + w, k)), put(1 + (8), () => b.i32(0)), put(2 + (8), () => b.i32(i.dst)), put(3 + (8), () => b.get(V_ROW).simd(S.i32extract).op(lane));
+      for (let w = 0; w < 8; w++)
+        if (w < words) {
+          let ext = code[pc + 1 + Math.floor(w / 3)], word = [ext.a, ext.b, ext.c][w % 3];
+          put(4 + (8) + w, () => get(word).simd(S.i32extract).op(lane));
+        } else put(4 + (8) + w, () => b.i32(0));
+      b.op((11)).op((11));
+    }
+    return true;
+  }, dry = false, keeping = false, accumulate = (i) => {
+    if (!dry) {
+      b.get(P_CTX).get(reg(i.a)).simd(S.store).mem(2, (160));
+      for (let lane = 0; lane < (4); lane++)
+        b.i32(lane).get(L_PN).op((73)), i.c !== 4294967295 && get(i.c).simd(S.i32extract).op(lane).i32(0).op((71)).op((113)), keeping && b.get(V_KEEP).simd(S.i32extract).op(lane).i32(0).op((71)).op((113)), b.op((4), (64)), b.get(P_CTX).get(V_PLANE).simd(S.i32extract).op(lane).i32(2).op((116)).op((106)).set(L_IDX), i.op === Op2.ACC_IADD ? (b.get(L_IDX), b.get(L_IDX).op((40)).mem(2, (160)), get(i.b).simd(S.i32extract).op(lane).op((106)), b.op((54)).mem(2, (160))) : (b.get(L_IDX), b.get(L_IDX).op((42)).mem(2, (160)), get(i.b).simd(S.f32extract).op(lane), i.op === Op2.ACC_FADD ? b.op((146)) : jsMinScalar(i.op === Op2.ACC_FMAX), b.op(56).mem(2, (160))), b.op((11));
+      b.get(P_CTX).simd(S.load).mem(2, (160)).set(reg(i.a));
+    }
+  }, wideCarry = (i) => {
+    let wide = (word, lane, low) => {
+      get(word).simd(S.i32extract).op(lane), low && b.i32(1).op((113)), b.op((173));
+    };
+    for (let lane = 0; lane < (4); lane++)
+      b.get(V_REG + i.dst), wide(i.a, lane, false), wide(i.b, lane, false), i.op === Op2.UMULHI ? b.op((126)).op((66), (32)).op((136)).op((167)) : i.op === Op2.UADDC ? (b.op((124)), wide(i.c, lane, true), b.op((124)).op((66), (32)).op((136)).op((167))) : (wide(i.c, lane, true), b.op((124)).op((84))), b.simd(S.i32replace).op(lane).set(V_REG + i.dst);
+  }, stagedBody = staged(program), laneBase = () => stagedBody ? b.get(P_CTX).i32(laneScratchOffset(program)).op((106)) : b.load(P_CTX, (192)), laneOp = (pc) => {
+    let i = code[pc], ext = code[pc + 1], [inputs, outputs] = laneSignature(i.dst);
+    [i.a, i.b, i.c, ext.a, ext.b].forEach((word, k) => {
+      laneBase(), (inputs & 1 << k) !== 0 ? get(word) : b.v128i([0, 0, 0, 0]), b.simd(S.store).mem(0, k * 16);
+    }), b.i32(i.dst), laneBase(), laneBase().i32((5) * 16).op((106)).call(FN.lanes);
+    let targets = [ext.dst, ext.c, ext.b];
+    for (let k = 0; k < outputs; k++) laneBase().simd(S.load).mem(0, ((5) + k) * 16).set(V_REG + targets[k]);
+  }, dataOp = (pc) => {
+    let i = code[pc], ext = code[pc + 1];
+    if (i.dst === DATA_LIST) return;
+    let N = 4294967295, plan = {
+      [DATA_KEYOF]: [[i.a, N, N, N], [false, false, false, false], true],
+      [DATA_ROWOF]: [[i.a, N, N, N], [false, false, false, false], true],
+      [DATA_FLOAD]: [[N, i.b, N, N], [false, false, false, false], true],
+      [DATA_ROWS]: [[N, N, N, N], [false, false, false, false], true],
+      [DATA_PGET]: [[N, i.b, i.c, N], [false, false, true, false], true],
+      [DATA_PICK]: [[N, i.b, i.c, N], [false, false, true, false], false],
+      [DATA_PSET]: [[N, i.b, i.c, ext.a], [false, false, false, true], false],
+      [DATA_SEND]: [[N, i.b, i.c, ext.a], [false, false, false, true], false],
+      [DATA_TALLY]: [[N, i.b, N, N], [false, true, false, false], false]
+    }, [inputs, masks, result] = plan[i.dst];
+    laneBase().get(V_ROW).simd(S.store).mem(0, 0), laneBase().get(V_VALID).simd(S.store).mem(0, 16), inputs.forEach((word, k) => {
+      laneBase(), word !== N ? get(word) : b.v128i(masks[k] ? [-1, -1, -1, -1] : [0, 0, 0, 0]), b.simd(S.store).mem(0, (2 + k) * 16);
+    }), b.get(P_CTX).i32(pc), laneBase().call(FN.data), result && laneBase().simd(S.load).mem(0, 96).set(V_REG + ext.dst);
+  }, query = (pc) => {
+    let i = code[pc], ext = code[pc + 1], from = pc + 2, to = ext.a, filtered = (ext.c & QUERY_FILTERED) !== 0, kind = ext.c & QUERY_SHAPE, filterAt = filtered ? pc - 2 : -1, shapeAt = kind === QUERY_SPHERE ? -1 : filtered ? pc - 4 : pc - 2, optional = (word, fallback) => {
+      word === 4294967295 ? b.v128i([fallback, fallback, fallback, fallback]) : get(word);
+    }, params = [
+      () => ext.b === 4294967295 ? b.get(V_VALID) : get(ext.b).get(V_VALID).simd(S.and),
+      () => get(i.b),
+      () => optional(i.c, -1)
+    ], shape = shapeAt < 0 ? null : [code[shapeAt].a, code[shapeAt].b, code[shapeAt].c, code[shapeAt + 1].a, code[shapeAt + 1].b, code[shapeAt + 1].c];
+    for (let k = 0; k < 6; k++) params.push(() => optional(shape === null ? 4294967295 : shape[k], 0));
+    params.push(() => optional(filterAt < 0 ? 4294967295 : code[filterAt].b, 0)), params.push(() => optional(filterAt < 0 ? 4294967295 : code[filterAt].c, 0)), params.forEach((emit, k) => {
+      b.load(P_CTX, (76)), emit(), b.simd(S.store).mem(0, k * 16);
+    }), b.load(P_CTX, (76)).get(V_ROW).simd(S.store).mem(0, (11) * 16), b.get(P_CTX).load(P_CTX, (76)).load(P_CTX, (76)).i32((11) * 16).op((106)), b.i32(kind).i32(filterAt < 0 ? -1 : code[filterAt].a).i32(filterAt < 0 ? 0 : code[filterAt + 1].a).call(FN.query).set(L_QN);
+    let stops = false;
+    for (let at = from; at < to; at++) code[at].op === XOP && code[at].dst === XOP_QSTOP && (stops = true);
+    if (b.i32(0).set(L_QP), b.op((2), (64)).op((3), (64)), b.get(L_QP).get(L_QN).op((79)).op((13), 1), b.get(L_QN).get(L_QP).op((107)).tee(L_PN).i32((4)).get(L_PN).i32((4)).op((73)).op((27)).set(L_PN), b.load(P_CTX, (56)).get(L_QP).i32(2).op((116)).op((106)).simd(S.load).mem(2, 0).set(V_PLANE), b.load(P_CTX, (60)).get(L_QP).i32(2).op((116)).op((106)).simd(S.load).mem(2, 0).set(V_PROW), stops) {
+      b.v128i([0, 0, 0, 0]).set(V_STOP), dry = true;
+      let ok2 = emitRange(from, to, true);
+      if (dry = false, !ok2) return false;
+      b.load(P_CTX, (76)).get(V_STOP).simd(S.store).mem(0, ((11) + 1) * 16), b.get(P_CTX).load(P_CTX, (76)).i32(((11) + 1) * 16).op((106)).get(L_QP).load(P_CTX, (76)).i32(((11) + 2) * 16).op((106)).call(FN.queryKeep), b.load(P_CTX, (76)).simd(S.load).mem(0, ((11) + 2) * 16).set(V_KEEP), keeping = true;
+    }
+    let ok = emitRange(from, to, true);
+    return keeping = false, ok ? (b.get(L_QP).i32((4)).op((106)).set(L_QP).op((12), 0).op((11)).op((11)), true) : false;
+  }, recordOp = (pc) => {
+    let i = code[pc], k = program.cross.indexOf(pc);
+    if (k < 0) return false;
+    let ext = i.op === CROSS_OP.SCATTER || i.op === XOP ? code[pc + 1] : i, recur = i.op === XOP && recurSub(i.dst), value = i.op === CROSS_OP.COMPACT ? 4294967295 : i.a, aux = i.op === CROSS_OP.SCATTER || recur ? i.b : i.op === XOP && i.dst === XOP_COMPONENTS_EDGES ? i.c : 4294967295, mask = i.op === CROSS_OP.SCATTER ? ext.b : i.op === CROSS_OP.COMPACT ? i.a : recur ? i.c : i.b;
+    b.get(P_CTX).op((40)).mem(2, k * (4)).set(L_BASE);
+    for (let lane = 0; lane < (4); lane++) {
+      laneInside(lane), b.op((4), (64)), b.get(L_BASE).get(L_I).i32(lane).op((106)).i32((4)).op((116)).op((106)).set(L_IDX);
+      let put = (at, word) => {
+        b.get(L_IDX), word(), b.op((54)).mem(2, at * (4));
+      };
+      put(0, () => value === 4294967295 ? b.i32(0) : get(value).simd(S.i32extract).op(lane)), put(1, () => aux === 4294967295 ? b.i32(0) : get(aux).simd(S.i32extract).op(lane)), put(2, () => mask === 4294967295 ? b.i32(1) : get(mask).simd(S.i32extract).op(lane).i32(0).op((71))), put(3, () => b.get(V_ROW).simd(S.i32extract).op(lane)), b.op((11));
+    }
+    return true;
+  }, emitRange = (from, to, pair) => {
+    let open = [], depthOf = (index) => open.length - 1 - index;
+    for (let pc = from; pc <= to; pc++) {
+      for (; open.length > 0 && open[open.length - 1].end === pc; )
+        open.pop(), b.op((11));
+      if (pc === to) break;
+      let i = code[pc]; V_REG + i.dst;
+      if (narrowXop(i.op, i.dst)) {
+        if (pair) return false;
+        laneOp(pc), pc++;
+        continue;
+      }
+      if (dataXop(i.op, i.dst)) {
+        if (pair) return false;
+        dataOp(pc), pc++;
+        continue;
+      }
+      if (gatherXop(i.op, i.dst)) {
+        let ext = code[pc + 1], field2 = i.dst === XOP_FIELD, span = field2 ? i.c : 1;
+        if (field2 && pair || span < 1 || i.a + span > slotCount) return false;
+        for (let s = i.a; s < i.a + span; s++) if (!exactStorage(program.slots[s].kind, storages[s])) return false;
+        b.v128i([0, 0, 0, 0]).set(temp(7));
+        for (let lane = 0; lane < (4); lane++)
+          get(i.b).simd(S.i32extract).op(lane).set(L_A), b.get(L_A), field2 ? b.i32(i.c) : get(i.c).simd(S.i32extract).op(lane), b.op((73)).op((4), (64)), b.get(temp(7)), field2 ? (b.get(P_COLS).get(L_A).i32(i.a).op((106)).i32(2).op((116)).op((106)).op((40)).mem(2, 0), b.get(V_ROW).simd(S.i32extract).op(lane).i32(2).op((116)).op((106))) : b.get(L_SLOT + i.a).get(L_A).i32(2).op((116)).op((106)), b.op((40)).mem(2, 0).simd(S.i32replace).op(lane).set(temp(7)), b.op((11));
+        ext.a !== 4294967295 ? b.get(temp(7)).reg(ext.a).simd(S.and).set(V_REG + ext.dst) : b.get(temp(7)).set(V_REG + ext.dst), pc++;
+        continue;
+      }
+      if (i.op === XOP && i.dst === XOP_QUERY) {
+        if (pair || !query(pc)) return false;
+        pc = code[pc + 1].a - 1;
+        continue;
+      }
+      if (i.op === XOP && (i.dst === XOP_QSHAPE || i.dst === XOP_QFILTER)) {
+        pc++;
+        continue;
+      }
+      if (i.op === XOP && i.dst === XOP_QSTOP) {
+        if (!pair) return false;
+        dry && get(i.a).get(V_STOP).simd(S.or).set(V_STOP), pc++;
+        continue;
+      }
+      if (crossRow(i.op) || stageEndingOp(i.op, i.dst)) {
+        if (pair || !recordOp(pc)) return false;
+        (i.op === CROSS_OP.SCATTER || i.op === XOP) && pc++;
+        continue;
+      }
+      let vector = isSimd(i), batch = vector ? simdScalarize(i, code[pc + 1], simdTemp) : [i];
+      if (batch === null) return false;
+      vector && pc++;
+      for (let one of batch) {
+        let i2 = one, d2 = V_REG + i2.dst;
+        switch (i2.op) {
+          case Op2.NOP:
+          case Op2.EXT:
+            break;
+          case Op2.MOV:
+            get(i2.a).set(d2);
+            break;
+          case Op2.LOAD:
+            loadSlot(i2.a, d2);
+            break;
+          case Op2.STORE:
+            storeSlot(i2.a, i2.b);
+            break;
+          case Op2.ROW:
+            b.get(V_ROW).set(d2);
+            break;
+          case Op2.SEL:
+            get(i2.b).reg(i2.c).reg(i2.a).simd(S.bitselect).set(d2);
+            break;
+          case Op2.JNONE: {
+            let known2 = open.findIndex((o) => o.kind === "block" && o.end === i2.b);
+            if (known2 >= 0)
+              get(i2.a).simd(S.anyTrue).op((69)).op((13)), uleb2(b.code, depthOf(known2));
+            else {
+              if (open.length > 0 && open[open.length - 1].end < i2.b || i2.b > to) return false;
+              b.op((2), (64)), open.push({ kind: "block", end: i2.b, pc, counter: -1 }), get(i2.a).simd(S.anyTrue).op((69)).op((13), 0);
+            }
+            break;
+          }
+          case Op2.LOOP_INIT: {
+            let counter = L_COUNTERS + (i2.a - args), nextPc = code.findIndex((c, k) => k > pc && c.op === Op2.LOOP_NEXT && c.a === i2.a && c.c === pc + 1);
+            if (nextPc < 0 || i2.c > to || open.length > 0 && open[open.length - 1].end < i2.c) return false;
+            b.i32(0).set(counter), b.op((2), (64)), open.push({ kind: "block", end: i2.c, pc, counter: i2.a }), trips(b, scalarLocal(i2.b), i2.dst, L_TMP), b.op((69)).op((13), 0), b.op((3), (64)), open.push({ kind: "loop", end: nextPc + 1, pc, counter: i2.a }), b.get(counter).simd(S.i32splat).set(V_UNIFORM + i2.a);
+            break;
+          }
+          case Op2.LOOP_NEXT: {
+            let counter = L_COUNTERS + (i2.a - args);
+            b.get(counter).i32(1).op((106)).tee(counter), b.simd(S.i32splat).set(V_UNIFORM + i2.a), b.get(counter), trips(b, scalarLocal(i2.b), i2.dst, L_TMP), b.op((72)).op((13), 0);
+            break;
+          }
+          case Op2.NEIGHBOURS: {
+            if (pair || !neighbours(pc + 1, i2.b, i2.c)) return false;
+            pc = i2.b - 1;
+            break;
+          }
+          case Op2.NLOAD: {
+            let index = snapshotIndex[i2.a];
+            b.v128i([0, 0, 0, 0]).set(d2);
+            for (let lane = 0; lane < (4); lane++)
+              b.get(d2), field((0)), field((4)).i32(index).op((108)).get(V_PROW).simd(S.i32extract).op(lane).op((106)).i32(2).op((116)).op((106)), b.op((40)).mem(2, 0).simd(S.i32replace).op(lane).set(d2);
+            break;
+          }
+          case Op2.OUTER: {
+            b.get(P_CTX).get(reg(i2.a)).simd(S.store).mem(2, (112)), b.v128i([0, 0, 0, 0]).set(temp(7));
+            for (let lane = 0; lane < (4); lane++)
+              b.get(temp(7)), b.get(P_CTX).get(V_PLANE).simd(S.i32extract).op(lane).i32(2).op((116)).op((106)).op((40)).mem(2, (112)), b.simd(S.i32replace).op(lane).set(temp(7));
+            b.get(temp(7)).set(d2);
+            break;
+          }
+          case Op2.NROW:
+            b.get(V_PROW).set(d2);
+            break;
+          case Op2.ACC_FADD:
+          case Op2.ACC_FMIN:
+          case Op2.ACC_FMAX:
+          case Op2.ACC_IADD:
+            accumulate(i2);
+            break;
+          case Op2.EMIT: {
+            if (pair || !emitEvent(pc, open)) return false;
+            pc += Math.ceil(program.channels[i2.dst] / 3);
+            break;
+          }
+          case Op2.FADD:
+          case Op2.FSUB:
+          case Op2.FMUL:
+          case Op2.FDIV:
+            get(i2.a).reg(i2.b).simd(i2.op === Op2.FADD ? S.f32add : i2.op === Op2.FSUB ? S.f32sub : i2.op === Op2.FMUL ? S.f32mul : S.f32div).set(d2);
+            break;
+          case Op2.FMIN:
+          case Op2.FMAX:
+            jsMin(() => get(i2.a), () => get(i2.b), d2, i2.op === Op2.FMAX);
+            break;
+          case Op2.FMOD:
+            lanes(noise("fmod"), [i2.a, i2.b], d2);
+            break;
+          case Op2.FPOW:
+            lanes(fmath("pow"), [i2.a, i2.b], d2);
+            break;
+          case Op2.FATAN2:
+            lanes(fmath("atan2"), [i2.a, i2.b], d2);
+            break;
+          case Op2.NOISE2:
+            lanes(noise("noise2"), [i2.a, i2.b], d2);
+            break;
+          case Op2.NOISE3:
+            lanes(noise("noise3"), [i2.a, i2.b, i2.c], d2);
+            break;
+          case Op2.FLOG2:
+          case Op2.FSIN:
+          case Op2.FCOS:
+          case Op2.FTAN:
+          case Op2.FASIN:
+          case Op2.FACOS:
+          case Op2.FATAN:
+          case Op2.FEXP:
+          case Op2.FLOG: {
+            i2.op === Op2.FSIN || i2.op === Op2.FCOS ? get(i2.a).call(fmathSimd(i2.op === Op2.FSIN ? "sin" : "cos")).set(d2) : lanes(fmath(UNARY_FMATH[i2.op]), [i2.a], d2);
+            break;
+          }
+          case Op2.FMULADD:
+            get(i2.a).reg(i2.b).simd(S.f32mul).reg(i2.c).simd(S.f32add).set(d2);
+            break;
+          case Op2.FMULSUB:
+            get(i2.a).reg(i2.b).simd(S.f32mul).reg(i2.c).simd(S.f32sub).set(d2);
+            break;
+          case Op2.FSUBMUL:
+            get(i2.a).reg(i2.b).simd(S.f32sub).reg(i2.c).simd(S.f32mul).set(d2);
+            break;
+          case Op2.FADDMUL:
+            get(i2.a).reg(i2.b).simd(S.f32add).reg(i2.c).simd(S.f32mul).set(d2);
+            break;
+          case Op2.FCLAMP:
+            jsMin(() => get(i2.a), () => get(i2.b), temp(3), true), jsMin(() => b.get(temp(3)), () => get(i2.c), d2, false);
+            break;
+          case Op2.FLERP:
+            get(i2.a).reg(i2.b).reg(i2.a).simd(S.f32sub).reg(i2.c).simd(S.f32mul).simd(S.f32add).set(d2);
+            break;
+          case Op2.FNEG:
+            get(i2.a).simd(S.f32neg).set(d2);
+            break;
+          case Op2.FABS:
+            get(i2.a).simd(S.f32abs).set(d2);
+            break;
+          case Op2.FSQRT:
+            get(i2.a).simd(S.f32sqrt).set(d2);
+            break;
+          case Op2.FFLOOR:
+            get(i2.a).simd(S.f32floor).set(d2);
+            break;
+          case Op2.FCEIL:
+            get(i2.a).simd(S.f32ceil).set(d2);
+            break;
+          case Op2.FTRUNC:
+            get(i2.a).simd(S.f32trunc).set(d2);
+            break;
+          case Op2.FROUND:
+            get(i2.a).simd(S.f32floor).set(temp(0)), b.get(temp(0)).v128f(1).simd(S.f32add).get(temp(0)), get(i2.a).get(temp(0)).simd(S.f32sub).v128f(0.5).simd(S.f32ge).simd(S.bitselect).set(d2);
+            break;
+          case Op2.FSIGN:
+            get(i2.a).set(temp(0)), b.v128f(1).v128f(-1).get(temp(0)).get(temp(0)).v128f(0).simd(S.f32lt).simd(S.bitselect), b.v128f(0).get(temp(0)).simd(S.f32lt).simd(S.bitselect).set(d2);
+            break;
+          case Op2.FLEN2:
+            get(i2.a).reg(i2.a).simd(S.f32mul).reg(i2.b).reg(i2.b).simd(S.f32mul).simd(S.f32add).simd(S.f32sqrt).set(d2);
+            break;
+          case Op2.FLEN3:
+            get(i2.a).reg(i2.a).simd(S.f32mul).reg(i2.b).reg(i2.b).simd(S.f32mul).simd(S.f32add).reg(i2.c).reg(i2.c).simd(S.f32mul).simd(S.f32add).simd(S.f32sqrt).set(d2);
+            break;
+          case Op2.FDOT2: {
+            let e = code[pc + 1];
+            get(i2.a).reg(i2.b).simd(S.f32mul).reg(i2.c).reg(e.a).simd(S.f32mul).simd(S.f32add).set(d2), pc++;
+            break;
+          }
+          case Op2.FDOT3: {
+            let e = code[pc + 1];
+            get(i2.a).reg(i2.b).simd(S.f32mul).reg(i2.c).reg(e.a).simd(S.f32mul).simd(S.f32add).reg(e.b).reg(e.c).simd(S.f32mul).simd(S.f32add).set(d2), pc++;
+            break;
+          }
+          case Op2.FLT:
+            get(i2.a).reg(i2.b).simd(S.f32lt).set(d2);
+            break;
+          case Op2.FLE:
+            get(i2.a).reg(i2.b).simd(S.f32le).set(d2);
+            break;
+          case Op2.FEQ:
+            get(i2.a).reg(i2.b).simd(S.f32eq).set(d2);
+            break;
+          case Op2.FNE:
+            get(i2.a).reg(i2.b).simd(S.f32ne).set(d2);
+            break;
+          case Op2.IADD:
+          case Op2.ISUB:
+          case Op2.IMUL:
+          case Op2.IAND:
+          case Op2.IOR:
+          case Op2.IXOR:
+          case Op2.IMIN:
+          case Op2.IMAX:
+          case Op2.UMIN:
+          case Op2.UMAX:
+          case Op2.ILT:
+          case Op2.ILE:
+          case Op2.IEQ:
+          case Op2.INE:
+          case Op2.ULT:
+          case Op2.ULE:
+          case Op2.MAND:
+          case Op2.MOR:
+          case Op2.MANDN: {
+            let table = {
+              [Op2.IADD]: S.i32add,
+              [Op2.ISUB]: S.i32sub,
+              [Op2.IMUL]: S.i32mul,
+              [Op2.IAND]: S.and,
+              [Op2.IOR]: S.or,
+              [Op2.IXOR]: S.xor,
+              [Op2.IMIN]: S.i32min_s,
+              [Op2.IMAX]: S.i32max_s,
+              [Op2.UMIN]: S.i32min_u,
+              [Op2.UMAX]: S.i32max_u,
+              [Op2.ILT]: S.i32lt_s,
+              [Op2.ILE]: S.i32le_s,
+              [Op2.IEQ]: S.i32eq,
+              [Op2.INE]: S.i32ne,
+              [Op2.ULT]: S.i32lt_u,
+              [Op2.ULE]: S.i32le_u,
+              [Op2.MAND]: S.and,
+              [Op2.MOR]: S.or,
+              [Op2.MANDN]: S.andnot
+            };
+            get(i2.a).reg(i2.b).simd(table[i2.op]).set(d2);
+            break;
+          }
+          case Op2.IREM:
+          case Op2.UREM: {
+            let signed = i2.op === Op2.IREM;
+            perLane(i2.a, i2.b, d2, () => {
+              b.i32(0), b.get(L_A), b.get(L_B).op((69)), signed && b.get(L_A).i32((-2147483648)).op((70)).get(L_B).i32(-1).op((70)).op((113)).op((114)), b.op((4), (127)).i32(1).op((5)).get(L_B).op((11)), b.op(signed ? (111) : (112)), b.get(L_B).op((69)), signed && b.get(L_A).i32((-2147483648)).op((70)).get(L_B).i32(-1).op((70)).op((113)).op((114)), b.op((27));
+            });
+            break;
+          }
+          case Op2.ISHL:
+          case Op2.ISHR:
+          case Op2.IUSHR: {
+            let vector2 = i2.op === Op2.ISHL ? S.i32shl : i2.op === Op2.ISHR ? S.i32shr_s : S.i32shr_u;
+            if ((i2.b & 2147483648) !== 0 && i2.b !== 4294967295)
+              get(i2.a).get(scalarLocal(i2.b)).i32((31)).op((113)).simd(vector2).set(d2);
+            else {
+              let scalar = i2.op === Op2.ISHL ? (116) : i2.op === Op2.ISHR ? (117) : (118);
+              perLane(i2.a, i2.b, d2, () => {
+                b.get(L_A).get(L_B).i32((31)).op((113)).op(scalar);
+              });
+            }
+            break;
+          }
+          case Op2.INEG:
+            get(i2.a).simd(S.i32neg).set(d2);
+            break;
+          case Op2.IABS:
+            get(i2.a).simd(S.i32abs).set(d2);
+            break;
+          case Op2.INOT:
+          case Op2.MNOT:
+            get(i2.a).simd(S.not).set(d2);
+            break;
+          case Op2.ITOF:
+            get(i2.a).simd(S.convertS).set(d2);
+            break;
+          case Op2.UTOF:
+            get(i2.a).simd(S.convertU).set(d2);
+            break;
+          case Op2.FTOI:
+            get(i2.a).set(temp(0)), toInt(temp(0), d2);
+            break;
+          case Op2.BTOF:
+            b.v128f(1).v128f(0), get(i2.a).v128i([0, 0, 0, 0]).simd(S.i32ne).simd(S.bitselect).set(d2);
+            break;
+          case Op2.BTOI:
+            b.v128i([1, 1, 1, 1]).v128i([0, 0, 0, 0]), get(i2.a).v128i([0, 0, 0, 0]).simd(S.i32ne).simd(S.bitselect).set(d2);
+            break;
+          case Op2.FTOB:
+            get(i2.a).v128f(0).simd(S.f32ne), get(i2.a).reg(i2.a).simd(S.f32eq).simd(S.and).set(d2);
+            break;
+          case Op2.ITOB:
+            get(i2.a).v128i([0, 0, 0, 0]).simd(S.i32ne).set(d2);
+            break;
+          case Op2.UADDC:
+          case Op2.USUBB:
+          case Op2.UMULHI:
+            wideCarry(i2);
+            break;
+          case Op2.HASH:
+            hashInto(i2), b.set(d2);
+            break;
+          case Op2.RAND:
+            hashInto(i2), b.i32(8).simd(S.i32shr_u).simd(S.convertU).v128f(UNIT_SCALE).simd(S.f32mul).set(d2);
+            break;
+          default:
+            return false;
+        }
+      }
+    }
+    return open.length === 0;
+  }, axis = (value) => {
+    value(), field((36)).op((190)).op((148)).op((142)).op((252)), uleb2(b.code, (0));
+  }, chunk = (from, to, count) => (count(), b.set(L_PN), b.get(P_CTX).simd(S.load).mem(2, (128)).set(V_PLANE), b.get(P_CTX).simd(S.load).mem(2, (144)).set(V_PROW), emitRange(from, to, true)), snapshotAt = (slot, row) => {
+    field((0)), field((4)).i32(snapshotIndex[slot]).op((108)).get(row).op((106)).i32(2).op((116)).op((106)).op((42)).mem(2, 0);
+  }, neighbours = (from, to, active) => {
+    let position = program.position;
+    if (position === null) return false;
+    let [px, py, pz] = position;
+    return b.get(P_CTX).get(V_ROW).simd(S.store).mem(2, (80)), b.get(P_CTX), active === 4294967295 ? b.get(V_VALID) : get(active).get(V_VALID).simd(S.and), b.simd(S.store).mem(2, (96)), b.i32(0).set(L_PCOUNT), b.op((2), (64)), b.load(P_CTX, (48)).op((69)).op((13), 0), b.i32(0).set(L_LANE), b.op((2), (64)).op((3), (64)), b.get(L_LANE).i32((4)).op((79)).op((13), 1), b.get(P_CTX).get(L_LANE).i32(2).op((116)).op((106)).op((40)).mem(2, (96)).op((4), (64)), b.get(P_CTX).get(L_LANE).i32(2).op((116)).op((106)).op((40)).mem(2, (80)).set(L_ROW), snapshotAt(px, L_ROW), b.set(F_CX), snapshotAt(py, L_ROW), b.set(F_CY), pz === 4294967295 ? b.f32(0).set(F_CZ) : (snapshotAt(pz, L_ROW), b.set(F_CZ)), walkCells(from, to, () => field((40)).op((190)), pz);
+  }, walkCells = (from, to, radius, pz) => {
+    let low = (center) => axis(() => {
+      b.get(center), radius(), b.op((147));
+    }), high = (center) => axis(() => {
+      b.get(center), radius(), b.op((146));
+    });
+    low(F_CX), b.set(L_GX), high(F_CX), b.set(L_HX), low(F_CY), b.set(L_LY), high(F_CY), b.set(L_HY), pz === 4294967295 ? (b.i32(0).set(L_LZ), b.i32(0).set(L_HZ)) : (low(F_CZ), b.set(L_LZ), high(F_CZ), b.set(L_HZ)), b.op((2), (64)).op((3), (64)), b.get(L_LY).set(L_GY), b.op((2), (64)).op((3), (64)), b.get(L_LZ).set(L_GZ), b.op((2), (64)).op((3), (64)), b.get(L_GY).get(L_GX).i32((1021)).op((108)).op((106)).get(L_GZ).i32((65539)).op((108)).op((106)), field((32)).op((113)).set(L_IDX), field((8)).get(L_IDX).i32(2).op((116)).op((106)).tee(L_BASE).op((40)).mem(2, 0).set(L_SLOT_AT), b.get(L_BASE).op((40)).mem(2, 4).set(L_END), b.op((2), (64)).op((3), (64)), b.get(L_SLOT_AT).get(L_END).op((79)).op((13), 1), field((12)).get(L_SLOT_AT).i32(12).op((108)).op((106)).set(L_BASE), b.get(L_BASE).op((40)).mem(2, 0).get(L_GX).op((70)), b.get(L_BASE).op((40)).mem(2, 4).get(L_GY).op((70)).op((113)), b.get(L_BASE).op((40)).mem(2, 8).get(L_GZ).op((70)).op((113)), b.op((4), (64));
+    let coordinate = (ctxOffset, center, out) => {
+      field(ctxOffset).get(L_SLOT_AT).i32(2).op((116)).op((106)).op((42)).mem(2, 0).get(center).op((147)).set(out);
+    };
+    return coordinate((16), F_CX, F_DX), coordinate((20), F_CY, F_DY), coordinate((24), F_CZ, F_DZ), field((28)).get(L_SLOT_AT).i32(2).op((116)).op((106)).op((40)).mem(2, 0).set(L_NROW), b.get(F_DX).get(F_DX).op((148)).get(F_DY).get(F_DY).op((148)).op((146)).get(F_DZ).get(F_DZ).op((148)).op((146)), field((44)).op((190)).op((95)), b.get(L_NROW).get(L_ROW).op((71)).op((113)), b.op((4), (64)), b.get(P_CTX).get(L_PCOUNT).i32(2).op((116)).op((106)).get(L_LANE).op((54)).mem(2, (128)), b.get(P_CTX).get(L_PCOUNT).i32(2).op((116)).op((106)).get(L_NROW).op((54)).mem(2, (144)), b.get(L_PCOUNT).i32(1).op((106)).tee(L_PCOUNT).i32((4)).op((70)).op((4), (64)), !chunk(from, to, () => b.i32((4))) || (b.i32(0).set(L_PCOUNT), b.op((11)), b.op((11)), b.op((11)), b.get(L_SLOT_AT).i32(1).op((106)).set(L_SLOT_AT).op((12), 0).op((11)).op((11)), b.get(L_GZ).get(L_HZ).op((70)).op((13), 1), b.get(L_GZ).i32(1).op((106)).set(L_GZ).op((12), 0).op((11)).op((11)), b.get(L_GY).get(L_HY).op((70)).op((13), 1), b.get(L_GY).i32(1).op((106)).set(L_GY).op((12), 0).op((11)).op((11)), b.get(L_GX).get(L_HX).op((70)).op((13), 1), b.get(L_GX).i32(1).op((106)).set(L_GX).op((12), 0).op((11)).op((11)), b.op((11)), b.get(L_LANE).i32(1).op((106)).set(L_LANE).op((12), 0).op((11)).op((11)), b.get(L_PCOUNT).op((4), (64)), !chunk(from, to, () => b.get(L_PCOUNT))) ? false : (b.op((11)), b.op((11)), true);
+  };
+  b.get(P_ROWS).op((69)).op((4), (64)), b.op((2), (64)).op((3), (64)), b.get(L_I).i32((4) * (2)).op((106)).get(P_N).op((75)).op((13), 1);
+  for (let copy = 0; copy < (2); copy++) {
+    if (chunkRows("full"), !emitRange(start, end, false)) return null;
+    advance();
+  }
+  if (b.op((12), 0).op((11)).op((11)), b.op((2), (64)).op((3), (64)), b.get(L_I).i32((4)).op((106)).get(P_N).op((75)).op((13), 1), chunkRows("full"), !emitRange(start, end, false) || (advance(), b.op((12), 0).op((11)).op((11)), b.get(L_I).get(P_N).op((73)).op((4), (64)), chunkRows("tail"), !emitRange(start, end, false)) || (b.op((11)), b.op((5)), b.op((2), (64)).op((3), (64)), b.get(L_I).get(P_N).op((73)).op((69)).op((13), 1), chunkRows("list"), !emitRange(start, end, false))) return null;
+  advance(), b.op((12), 0).op((11)).op((11)), b.op((11)).op((11));
+  let body = [];
+  uleb2(body, 3), uleb2(body, i32Locals), body.push((127)), uleb2(body, f32Locals), body.push((125)), uleb2(body, v128Locals), body.push((123));
+  for (let x of b.code) body.push(x);
+  return body;
+}
+var GROUP_VALUE = new Float32Array(1), GROUP_BITS = new Uint32Array(GROUP_VALUE.buffer), groupCursor = new Uint32Array(0);
+function groupOf(groups, isFloat, fallback, raw) {
+  for (let g = 0; g < groups.length; g++)
+    if (!groups[g].isDefault) {
+      if (isFloat) {
+        if (GROUP_BITS[0] = groups[g].value, raw === GROUP_VALUE[0]) return g;
+      } else if (raw >>> 0 === groups[g].value >>> 0) return g;
+    }
+  return fallback;
+}
+function bucketGroups(program, state, count, rows, offsets) {
+  let groups = program.groups, isFloat = program.slots[program.state].kind === 0, fallback = -1;
+  for (let g = 0; g < groups.length; g++)
+    if (groups[g].isDefault) {
+      fallback = g;
+      break;
+    }
+  offsets.fill(0);
+  for (let row = 0; row < count; row++) {
+    let g = groupOf(groups, isFloat, fallback, state[row]);
+    g >= 0 && offsets[g + 1]++;
+  }
+  for (let g = 1; g <= groups.length; g++) offsets[g] += offsets[g - 1];
+  groupCursor.length < groups.length && (groupCursor = new Uint32Array(groups.length));
+  let cursor = groupCursor;
+  for (let g = 0; g < groups.length; g++) cursor[g] = offsets[g];
+  for (let row = 0; row < count; row++) {
+    let g = groupOf(groups, isFloat, fallback, state[row]);
+    g >= 0 && (rows[cursor[g]++] = row);
+  }
+}
+function wasmExportName(group) {
+  return group < 0 ? "run" : `g${group}`;
+}
+function compileWasmKernel(program, storages, sharedMaxPages = null) {
+  if (!wasmSupports(program, storages)) return null;
+  let plan = staged(program) ? wasmStages(program) : null, ranges = plan !== null ? plan.map((p) => [p.start, p.end]) : program.state >= 0 ? program.groups.map((g) => [g.start, g.end]) : [[0, program.code.length]], bodies = [], fmathBase = IMPORTS.length + ranges.length, usesFmath = program.code.some((i) => FMATH_OPS.has(i.op)), usesNoise = program.code.some((i) => NOISE_OPS.has(i.op)), fmathCount = usesFmath ? WASM_FMATH.length + WASM_FMATH_SIMD.length : 0, noiseBase = fmathBase + fmathCount;
+  for (let [start, end] of ranges) {
+    let body = functionBody(program, storages, start, end, fmathBase, noiseBase);
+    if (body === null) return null;
+    bodies.push(body);
+  }
+  let internal = [...usesFmath ? [...wasmFmathBodies(), ...wasmFmathSimdBodies(fmathBase)] : [], ...usesNoise ? wasmNoiseBodies() : []], internalType = (k) => k >= fmathCount ? WASM_NOISE[k - fmathCount] === "noise3" ? (4) : (3) : k >= WASM_FMATH.length ? (8) : WASM_FMATH_BINARY.has(WASM_FMATH[k]) ? (3) : (2), out = [0, 97, 115, 109, 1, 0, 0, 0], types = [];
+  uleb2(types, 9), types.push(96, 1, (125), 1, (127)), types.push(96, 5, (127), (127), (127), (127), (127), 0), types.push(96, 1, (125), 1, (125)), types.push(96, 2, (125), (125), 1, (125)), types.push(96, 3, (125), (125), (125), 1, (125)), types.push(96, 3, (127), (127), (127), 0), types.push(96, 6, (127), (127), (127), (127), (127), (127), 1, (127)), types.push(96, 4, (127), (127), (127), (127), 0), types.push(96, 1, (123), 1, (123)), section(out, 1, types);
+  let imports = [];
+  uleb2(imports, IMPORTS.length + 1);
+  for (let fn of IMPORTS)
+    name(imports, "env"), name(imports, fn), imports.push(0), uleb2(imports, IMPORT_TYPE[fn]);
+  name(imports, "env"), name(imports, "memory"), sharedMaxPages === null ? imports.push(2, 0, 1) : (imports.push(2, 3, 1), uleb2(imports, sharedMaxPages)), section(out, 2, imports);
+  let functions = [];
+  uleb2(functions, bodies.length + internal.length);
+  for (let k = 0; k < bodies.length; k++) uleb2(functions, 1);
+  for (let k = 0; k < internal.length; k++) uleb2(functions, internalType(k));
+  section(out, 3, functions);
+  let exports = [];
+  uleb2(exports, bodies.length), bodies.forEach((_, k) => {
+    name(exports, plan !== null ? wasmStageName(k) : wasmExportName(program.state >= 0 ? k : -1)), exports.push(0), uleb2(exports, k + IMPORTS.length);
+  }), section(out, 7, exports);
+  let codeSection = [];
+  uleb2(codeSection, bodies.length + internal.length);
+  for (let body of [...bodies, ...internal]) {
+    uleb2(codeSection, body.length);
+    for (let x of body) codeSection.push(x);
+  }
+  return section(out, 10, codeSection), { bytes: new Uint8Array(out), slots: program.slots.length, groups: plan === null && program.state >= 0 ? bodies.length : 0, stages: plan === null ? [] : plan.map((p) => p.stage) };
+}
+function trips(b, local, flags, tmp) {
+  let get = () => b.get(local);
+  (flags & LOOP_COUNT_F32) !== 0 ? (get().op((190)).op((141)).op((252)), uleb2(b.code, (1)), b.i32(0), get().op((190)).f32(0).op((94)), b.op((27))) : b.i32(0).get(local).get(local).i32(0).op((72)).op((27)), b.tee(tmp).i32(65536).get(tmp).i32(65536).op((72)).op((27));
+}
+function readAsBits(kind, storage, raw) {
+  if (kind === 0)
+    return storage === 0 ? raw >>> 0 : storage === 1 ? f32Bits(Math.fround(raw | 0)) : storage === 2 ? f32Bits(Math.fround(raw >>> 0)) : f32Bits(raw & (255));
+  if (kind === 3) {
+    if (storage === 0) {
+      let f3 = f32From(raw);
+      return f3 !== 0 && !Number.isNaN(f3) ? 4294967295 : 0;
+    }
+    return (storage === 3 ? raw & (255) : raw) !== 0 ? 4294967295 : 0;
+  }
+  return storage === 0 ? f32From(raw) | 0 : (storage === 3 ? raw & (255) : raw) >>> 0;
+}
+var WasmKernelHost = class {
+  constructor(program, capacity, memory, alloc, eventCapacity = DEFAULT_EVENT_CAPACITY) {
+    this.program = program;
+    this.capacity = capacity;
+    this.memory = memory;
+    this.shape = { kind: 0, vx: 0, vy: 0, vz: 0, p0: 0, p1: 0, p2: 0, reach: 0 };
+    this.stopped = new Uint8Array((4));
+    this.pairs = 0;
+    this.heapBuffer = null;
+    this.u32 = new Uint32Array(0);
+    this.f32 = new Float32Array(0);
+    this.i32 = new Int32Array(0);
+    this.u8 = new Uint8Array(0);
+    this.ctxWords = new Uint32Array(0);
+    this.stageView = new Uint32Array(0);
+    this.snapshotColumns = [];
+    this.snapshotAxes = [];
+    this.neighbourIndex = null;
+    this.rowCells = new Int32Array(0);
+    this.eventOrder = new Uint32Array(0);
+    this.eventScratch = new Uint32Array(0);
+    let table = (1024);
+    for (; table < capacity * (2); ) table *= 2;
+    this.table = table, this.snapshots = program.slots.filter((s) => s.neighbour).length, this.stageCapacity = program.channels.length > 0 ? eventCapacity * (2) : 0, this.bucket = new Uint32Array(program.position === null ? 0 : capacity), this.ring = new Uint32Array(RING_HEADER_WORDS + (program.channels.length > 0 ? eventCapacity * 10 : 0));
+    let grid = program.position === null ? 0 : (table + 1 + capacity * 3 + capacity * 4) * (4), queries = program.position !== null && wasmQueries(program);
+    this.pairCapacity = queries ? (4) * capacity + (4) : 0, this.grid = queries ? new CellGrid(capacity) : null, this.search = queries ? new QuerySearch(capacity) : null;
+    let queryBytes = queries ? QUERY_SCRATCH_BYTES + 2 * this.pairCapacity * (4) : 0, lanes = !staged(program) && laneOps(program), bytes = (208) + this.snapshots * capacity * (4) + grid + this.stageCapacity * STAGE_WORDS * (4) + queryBytes + (lanes ? LANE_SCRATCH_BYTES : 0);
+    this.ctx = alloc(bytes);
+    let words = new Uint32Array(memory.buffer, this.ctx, (208) / (4));
+    words.fill(0);
+    let at = this.ctx + (208), take = (n) => {
+      let here = at;
+      return at += n * (4), here;
+    };
+    words[(0) / (4)] = take(this.snapshots * capacity), words[(4) / (4)] = capacity, program.position !== null && (words[(8) / (4)] = take(table + 1), words[(12) / (4)] = take(capacity * 3), words[(16) / (4)] = take(capacity), words[(20) / (4)] = take(capacity), words[(24) / (4)] = take(capacity), words[(28) / (4)] = take(capacity), words[(32) / (4)] = table - 1, words[(52) / (4)] = program.position[2] === 4294967295 ? 1 : 0), words[(64) / (4)] = take(this.stageCapacity * STAGE_WORDS), words[(68) / (4)] = this.stageCapacity, lanes && (words[(192) / (4)] = take(LANE_SCRATCH_BYTES / (4))), queries && (words[(76) / (4)] = take(QUERY_SCRATCH_BYTES / (4)), words[(56) / (4)] = take(this.pairCapacity), words[(60) / (4)] = take(this.pairCapacity), QUERY_HOSTS.set(this.ctx >>> 0, this));
+  }
+  dispose() {
+    QUERY_HOSTS.delete(this.ctx >>> 0);
+  }
+  heap() {
+    let buffer = this.memory.buffer;
+    if (buffer === this.heapBuffer) return;
+    this.heapBuffer = buffer, this.u32 = new Uint32Array(buffer), this.f32 = new Float32Array(buffer), this.i32 = new Int32Array(buffer), this.u8 = new Uint8Array(buffer);
+    let words = new Uint32Array(buffer, this.ctx, (208) / (4));
+    this.ctxWords = words;
+    let snapshot = words[(0) / (4)], columns = [], axes = [];
+    for (let k = 0; k < this.snapshots; k++) {
+      let at = snapshot + k * this.capacity * (4);
+      columns.push(new Uint32Array(buffer, at, this.capacity)), axes.push(new Float32Array(buffer, at, this.capacity));
+    }
+    this.snapshotColumns = columns, this.snapshotAxes = axes, this.stageView = this.stageCapacity === 0 ? new Uint32Array(0) : new Uint32Array(buffer, words[(64) / (4)], this.stageCapacity * STAGE_WORDS);
+  }
+  neighbourOf(slot) {
+    let index = this.neighbourIndex;
+    if (index === null) {
+      let slots = this.program.slots;
+      index = new Int32Array(slots.length + 1);
+      let k = 0;
+      for (let s = 0; s <= slots.length; s++)
+        index[s] = k, s < slots.length && slots[s].neighbour && k++;
+      this.neighbourIndex = index;
+    }
+    return index[slot];
+  }
+  snapshotColumn(slot) {
+    return this.heap(), this.snapshotColumns[this.neighbourOf(slot)];
+  }
+  axis(slot) {
+    return this.heap(), this.snapshotAxes[this.neighbourOf(slot)];
+  }
+  query(params, rows, kind, filter, mode) {
+    let grid = this.grid, search = this.search, position = this.program.position;
+    this.heap();
+    let u32 = this.u32, f32 = this.f32, at = params >>> 2, xs = this.axis(position[0]), ys = this.axis(position[1]), zs = position[2] === 4294967295 ? null : this.axis(position[2]), filterColumn = filter >>> 0 === 4294967295 ? null : this.snapshotColumn(filter >>> 0), words = this.words(), lanes = words[(56) / (4)] >>> 2, out = words[(60) / (4)] >>> 2, s = this.shape;
+    s.kind = kind, this.stopped.fill(0);
+    let pairs = 0;
+    for (let lane = 0; lane < (4); lane++) {
+      if (u32[at + lane] === 0) continue;
+      let row = u32[(rows >>> 2) + lane];
+      s.reach = f32[at + (4) + lane], s.vx = f32[at + 3 * (4) + lane], s.vy = f32[at + 4 * (4) + lane], s.vz = f32[at + 5 * (4) + lane], s.p0 = f32[at + 6 * (4) + lane], s.p1 = f32[at + 7 * (4) + lane], s.p2 = f32[at + 8 * (4) + lane];
+      let found = search.runFrom(grid, s, mode, u32, at + 9 * (4) + lane, at + 10 * (4) + lane, at + 2 * (4) + lane, filterColumn, xs, ys, zs, row);
+      for (let k = 0; k < found; k++)
+        u32[lanes + pairs] = lane, u32[out + pairs] = search.rows[k], pairs++;
+    }
+    if (this.pairs = pairs, pairs > 0)
+      for (let pad = pairs; pad % (4) !== 0; pad++)
+        u32[lanes + pad] = u32[lanes + pairs - 1], u32[out + pad] = u32[out + pairs - 1];
+    return pairs;
+  }
+  keep(stops, p, out) {
+    this.heap();
+    let u32 = this.u32, lanes = this.words()[(56) / (4)] >>> 2;
+    for (let q = 0; q < (4); q++) {
+      let at = p + q, keep = 0;
+      if (at < this.pairs) {
+        let lane = u32[lanes + at];
+        this.stopped[lane] === 0 && (keep = 4294967295, u32[(stops >>> 2) + q] !== 0 && (this.stopped[lane] = 1));
+      }
+      u32[(out >>> 2) + q] = keep;
+    }
+  }
+  words() {
+    return this.heap(), this.ctxWords;
+  }
+  prepare(columns, count, uniforms) {
+    let p = this.program, words = this.words();
+    if (words[(72) / (4)] = 0, p.position === null) return 0;
+    let u32 = this.u32, u8 = this.u8, snapshot = words[(0) / (4)] / (4), k = 0, slots = p.slots;
+    for (let index = 0; index < slots.length; index++) {
+      let slot = slots[index];
+      if (!slot.neighbour) continue;
+      let column = columns[index], base = snapshot + k * this.capacity;
+      for (let row = 0; row < count; row++) {
+        let raw = column.storage === 3 ? u8[column.at + row] : u32[column.at / (4) + row];
+        u32[base + row] = readAsBits(slot.kind, column.storage, raw);
+      }
+      k++;
+    }
+    let f32 = this.f32, radius = f32From(uniforms[p.radius & 2147483647]), position = p.position, x = position[0], y = position[1], z = position[2];
+    if (this.grid !== null && this.grid.rebuild(radius, this.axis(x), this.axis(y), z === 4294967295 ? null : this.axis(z), count), words[(48) / (4)] = 0, words[(40) / (4)] = f32Bits(radius), !(radius > 0) || !Number.isFinite(radius)) return 0;
+    let inverse = Math.fround(1 / radius);
+    words[(36) / (4)] = f32Bits(inverse), words[(44) / (4)] = f32Bits(Math.fround(radius * radius));
+    let xs = snapshot + this.neighbourOf(x) * this.capacity, ys = snapshot + this.neighbourOf(y) * this.capacity, zs = z === 4294967295 ? -1 : snapshot + this.neighbourOf(z) * this.capacity, mask = this.table - 1, starts = words[(8) / (4)] / (4), cells = words[(12) / (4)] / (4), gx = words[(16) / (4)] / (4), gy = words[(20) / (4)] / (4), gz = words[(24) / (4)] / (4), rows = words[(28) / (4)] / (4), i32 = this.i32;
+    u32.fill(0, starts, starts + this.table + 1), this.rowCells.length < count * 3 && (this.rowCells = new Int32Array(this.capacity * 3));
+    let rowCells = this.rowCells;
+    for (let row = 0; row < count; row++) {
+      let fx = Math.floor(Math.fround(f32[xs + row] * inverse)), fy = Math.floor(Math.fround(f32[ys + row] * inverse)), fz = Math.floor(Math.fround((zs < 0 ? 0 : f32[zs + row]) * inverse)), cx = fx !== fx ? 0 : fx >= (2147483648) ? (2147483648) - 1 : fx < -(2147483648) ? -(2147483648) : fx | 0, cy = fy !== fy ? 0 : fy >= (2147483648) ? (2147483648) - 1 : fy < -(2147483648) ? -(2147483648) : fy | 0, cz = fz !== fz ? 0 : fz >= (2147483648) ? (2147483648) - 1 : fz < -(2147483648) ? -(2147483648) : fz | 0;
+      rowCells[3 * row] = cx, rowCells[3 * row + 1] = cy, rowCells[3 * row + 2] = cz;
+      let bucket = cy + Math.imul(cx, (1021)) + Math.imul(cz, (65539)) & mask;
+      this.bucket[row] = bucket >>> 0, u32[starts + bucket + 1]++;
+    }
+    for (let at = 1; at <= this.table; at++) u32[starts + at] += u32[starts + at - 1];
+    for (let row = 0; row < count; row++) {
+      let bucket = this.bucket[row], slot = u32[starts + bucket]++, zv = zs < 0 ? 0 : f32[zs + row];
+      u32[rows + slot] = row, f32[gx + slot] = f32[xs + row], f32[gy + slot] = f32[ys + row], f32[gz + slot] = zv, i32[cells + 3 * slot] = rowCells[3 * row], i32[cells + 3 * slot + 1] = rowCells[3 * row + 1], i32[cells + 3 * slot + 2] = rowCells[3 * row + 2];
+    }
+    for (let at = this.table; at > 0; at--) u32[starts + at] = u32[starts + at - 1];
+    return u32[starts] = 0, words[(48) / (4)] = count, words[(28) / (4)];
+  }
+  flush() {
+    if (this.stageCapacity === 0) return;
+    let words = this.words(), attempted = words[(72) / (4)], stored = Math.min(attempted, this.stageCapacity), stage = this.stageView, order = this.sortedEvents(stage, stored), ring = this.ring, capacity = (ring.length - RING_HEADER_WORDS) / 10, count = ring[RING_COUNT], dropped = ring[RING_DROPPED] + (attempted - stored), payload = STAGE_WORDS - 2 - (8);
+    for (let i = 0; i < stored; i++) {
+      if (count >= capacity) {
+        dropped++;
+        continue;
+      }
+      let from = order[i] * STAGE_WORDS + 2 + (8), to = RING_HEADER_WORDS + count * 10;
+      for (let w = 0; w < payload; w++) ring[to + w] = stage[from + w];
+      count++;
+    }
+    ring[RING_COUNT] = count, ring[RING_DROPPED] = dropped, words[(72) / (4)] = 0;
+  }
+  eventBefore(stage, a, b) {
+    let pa = a * STAGE_WORDS, pb = b * STAGE_WORDS;
+    for (let w = 0; w < 2 + (8); w++) {
+      let d = stage[pa + w] - stage[pb + w];
+      if (d !== 0) return d < 0;
+    }
+    return false;
+  }
+  sortedEvents(stage, stored) {
+    this.eventOrder.length < stored && (this.eventOrder = new Uint32Array(this.stageCapacity), this.eventScratch = new Uint32Array(this.stageCapacity));
+    let from = this.eventOrder, into = this.eventScratch;
+    for (let k = 0; k < stored; k++) from[k] = k;
+    for (let width = 1; width < stored; width *= 2) {
+      for (let lo = 0; lo < stored; lo += 2 * width) {
+        let mid = Math.min(lo + width, stored), hi = Math.min(lo + 2 * width, stored), i = lo, j = mid, out = lo;
+        for (; i < mid && j < hi; ) into[out++] = this.eventBefore(stage, from[j], from[i]) ? from[j++] : from[i++];
+        for (; i < mid; ) into[out++] = from[i++];
+        for (; j < hi; ) into[out++] = from[j++];
+      }
+      let swap = from;
+      from = into, into = swap;
+    }
+    return from;
+  }
+  clearEvents() {
+    this.ring[RING_COUNT] = 0, this.ring[RING_DROPPED] = 0;
+  }
+};
+
+// src/game/kernel/native.ts
+var FEATURE_NAME_BYTES = 64, ADVERTISED = /* @__PURE__ */ new WeakMap();
+function kernelEngineFeatures(engine) {
+  let known2 = ADVERTISED.get(engine.exports);
+  if (known2 !== void 0) return known2;
+  let exports = engine.exports, count = exports.engine_feature_count, name2 = exports.engine_feature_name, found = /* @__PURE__ */ new Set();
+  if (typeof count == "function" && typeof name2 == "function") {
+    let scratch2 = engine.exports.engine_alloc((64), 1);
+    if (scratch2 !== 0) {
+      let decoder = new TextDecoder();
+      for (let i = 0; i < count(); i++) {
+        let length = name2(i, scratch2, (64));
+        length > 0 && length <= (64) && found.add(decoder.decode(new Uint8Array(engine.memory.buffer, scratch2, length).slice()));
+      }
+      engine.exports.engine_free(scratch2, (64), 1);
+    }
+  }
+  return ADVERTISED.set(engine.exports, found), found;
+}
+var NO_LIST = 255, WORD2 = 4, MAX_ARG_WORDS = 64, TRUE_BITS = 4294967295, AXES2 = ["x", "y", "z", "w"];
+function bindKernelEngine(symbols, memory) {
+  for (let name2 of KERNEL_EXPORT_NAMES) if (typeof symbols[name2] != "function") return null;
+  if (typeof symbols.engine_alloc != "function" || typeof symbols.engine_free != "function") return null;
+  let exports = symbols, isa = typeof symbols.engine_kernel_isa_max == "function" ? symbols.engine_kernel_isa_max() : exports.engine_kernel_isa();
+  if (isa < 1) return null;
+  let attach = typeof symbols.engine_kernel_attach == "function" ? symbols.engine_kernel_attach : null, attachHandle = typeof symbols.engine_kernel_attach_handle == "function" ? symbols.engine_kernel_attach_handle : null, spawns = typeof symbols.engine_kernel_spawns == "function" ? symbols.engine_kernel_spawns : null, data = KERNEL_DATA_EXPORT_NAMES.every((name2) => typeof symbols[name2] == "function") ? {
+    bindTable: symbols.engine_kernel_bind_table,
+    bindPool: symbols.engine_kernel_bind_pool,
+    report: symbols.engine_kernel_data
+  } : null, runRegion = typeof symbols.engine_kernel_run_region == "function" ? symbols.engine_kernel_run_region : null;
+  return { exports, memory, isa, attach, attachHandle, spawns, data, runRegion };
+}
+function check(code, what) {
+  if (code >= 0) return code;
+  throw code === -1 ? new GameError("capacity_exceeded", `${what}: the engine is out of kernel slots`) : code === -3 ? new GameError("unknown_resource", `${what}: the kernel or table is gone`) : code === -5 ? new GameError("unsupported_feature", `${what}: the engine does not run this kernel instruction set`) : code === COMPUTE_STOPPED ? new GameError("capacity_exceeded", `${what}: the kernel ran too long and was stopped so the game stays responsive; split the work across frames or lower its row count`) : new GameError("invalid_argument", `${what}: the engine refused the kernel (${code})`);
+}
+var H_COLUMN_TABLE = 32, MAX_SLOTS = 256, MAX_SHARED_PAGES = 65536, VECTOR_ALIGN = 16;
+function sharedBuffer(buffer) {
+  return Object.prototype.toString.call(buffer) === "[object SharedArrayBuffer]";
+}
+function sameTables(a, b) {
+  if (a === null || b === null) return a === b;
+  if (a.length !== b.length) return false;
+  for (let k = 0; k < a.length; k++) if (a[k] !== b[k] || !a[k].valid) return false;
+  return true;
+}
+function isEntityTable(value) {
+  return typeof value == "object" && value !== null && "schema" in value && "capacity" in value && "values" in value;
+}
+function allNative(tables) {
+  for (let k = 0; k < tables.length; k++) if (!tables[k].native) return false;
+  return true;
+}
+function slotsSpawnOrScratch(program) {
+  let slots = program.slots;
+  for (let k = 0; k < slots.length; k++) if (slots[k].spawn || slots[k].scratch) return true;
+  return false;
+}
+function sameStorages(known2, fresh) {
+  if (known2.length !== fresh.length) return false;
+  for (let k = 0; k < fresh.length; k++) if (known2[k] !== fresh[k]) return false;
+  return true;
+}
+var NativeKernels = class {
+  constructor(engine) {
+    this.engine = engine;
+    this.programs = /* @__PURE__ */ new Map();
+    this.bindings = /* @__PURE__ */ new Map();
+    this.argsAt = 0;
+    this.argsBuffer = null;
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.world = null;
+    this.into = null;
+    this.priority = 0;
+    this.compute = null;
+    this.report = { spawned: 0, dropped: 0, killed: 0 };
+    this.spawnStats = new Uint32Array(0);
+    this.spawnCounts = { spawned: 0, dropped: 0, killed: 0 };
+    this.columnsView = new Uint32Array(0);
+    this.recordsView = new Uint32Array(0);
+    this.hookBinding = 0;
+    this.hookDispatched = 0;
+    this.hookStage = null;
+    this.hookCtxs = /* @__PURE__ */ new Set();
+    this.dataHook = (pc, chunk) => {
+      let code = this.hookData(this.hookBinding, pc, this.hookDispatched, chunk);
+      code < 0 && check(code, "running a data op from a kernel");
+    };
+    this.hookData = null;
+    this.reportCopies = /* @__PURE__ */ new Map();
+    this.heapView = new Uint32Array(0);
+    this.joinedTables = /* @__PURE__ */ new Map();
+    this.scalarMaps = /* @__PURE__ */ new Map();
+    this.staged = /* @__PURE__ */ new Map();
+    this.stagedRuns = 0;
+    this.compiledRuns = 0;
+    this.recordsAt = 0;
+    this.recordsCapacity = 0;
+    this.compiled = /* @__PURE__ */ new Map();
+    this.columnsAt = 0;
+    this.compiling = /* @__PURE__ */ new Set();
+    this.groupRowsAt = 0;
+    this.groupRowsCapacity = 0;
+    this.groupRowsView = new Uint32Array(0);
+    this.rings = /* @__PURE__ */ new Map();
+    engine.data !== null && engine.data !== void 0 && setPoolEngine({ alloc: (bytes) => engine.exports.engine_alloc(bytes, (4)), memory: engine.memory });
+  }
+  acceptsData() {
+    return this.engine.data !== null && this.engine.data !== void 0;
+  }
+  accepts(program) {
+    let version = program.byteLength >= 8 ? program[4] : 0;
+    return version < 2 ? true : version >= 3 && (typeof this.engine.attachHandle != "function" || typeof this.engine.spawns != "function") ? false : (this.engine.isa ?? 1) >= version && typeof this.engine.attach == "function";
+  }
+  attach(world) {
+    this.world = world;
+  }
+  copyIn(bytes) {
+    let at = this.engine.exports.engine_alloc(Math.max(bytes.byteLength, (4)), (4));
+    if (at === 0) throw new GameError("capacity_exceeded", "engine memory cannot hold a kernel program");
+    return new Uint8Array(this.engine.memory.buffer, at, bytes.byteLength).set(bytes), at;
+  }
+  program(meta, bytes) {
+    let known2 = this.programs.get(bytes);
+    if (known2 !== void 0) return known2;
+    let exports = this.engine.exports, at = this.copyIn(bytes), id = exports.engine_kernel_load(at, bytes.byteLength);
+    return exports.engine_free(at, Math.max(bytes.byteLength, (4)), (4)), check(id, `loading kernel ${meta.name}`), this.programs.set(bytes, id), id;
+  }
+  binding(meta, bytes, program, table, joined) {
+    let bound = this.bindings.get(bytes);
+    bound === void 0 && (bound = [], this.bindings.set(bytes, bound));
+    let into = this.into !== null && this.into !== table ? this.into : null;
+    for (let k = 0; k < bound.length; k++) {
+      let entry = bound[k];
+      if (entry.table === table && entry.into === into && sameTables(entry.joined, joined) && table.valid && (into === null || into.valid)) return entry.binding;
+    }
+    return this.bindNew(meta, program, table, joined, into, bound);
+  }
+  bindNew(meta, program, table, joined, into, bound) {
+    let exports = this.engine.exports;
+    for (let k = bound.length - 1; k >= 0; k--)
+      bound[k].table.valid && (bound[k].into === null || bound[k].into.valid) || (exports.engine_kernel_unbind(bound[k].binding), this.compute?.unbound(COMPUTE_SPACE_CPU, bound[k].binding), bound.splice(k, 1));
+    let spawnTable = into ?? table, columns = new Uint32Array(meta.slots.length);
+    for (let k = 0; k < meta.slots.length; k++) {
+      let slot = meta.slots[k];
+      if (slot.scratch === true || slot.pool !== void 0) {
+        columns[k] = 4294967295;
+        continue;
+      }
+      let source = slot.spawn === true ? spawnTable : slot.table !== void 0 && slot.table > 0 && joined !== null ? joined[slot.table] : table;
+      if (!(slot.field in source.schema)) throw new GameError("invalid_argument", `kernel ${meta.name} ${slot.spawn === true ? "spawns" : "reads"} ${slot.field}, which the ${slot.spawn === true ? "spawn " : ""}table does not have`);
+      columns[k] = source.column(slot.field, slot.component);
+    }
+    let at = this.copyIn(new Uint8Array(columns.buffer)), binding = exports.engine_kernel_bind(program, table.id, at, columns.length);
+    if (exports.engine_free(at, Math.max(columns.byteLength, (4)), (4)), check(binding, `binding kernel ${meta.name}`), this.compute?.bound(COMPUTE_SPACE_CPU, binding, meta.name, this.priority), into !== null) {
+      let attach = this.engine.attachHandle;
+      if (attach == null) throw new GameError("unsupported_feature", `kernel ${meta.name} spawns into another table; this engine predates kernel_isa_3`);
+      check(attach(binding, ATTACH_SPAWN_TABLE, into.id), `attaching the spawn table to kernel ${meta.name}`);
+    }
+    if (joined !== null) {
+      let data = this.engine.data;
+      for (let t of meta.data?.tables ?? []) check(data.bindTable(binding, t.table, joined[t.table].id), `binding table ${t.name} to kernel ${meta.name}`);
+      meta.slots.forEach((slot, k) => {
+        if (slot.pool === void 0) return;
+        let owner = joined[slot.table ?? 0], pool = listPoolAddress(owner, slot.field, slot.pool, slot.kind, slot.component);
+        if (pool.at === 0) throw new GameError("unsupported_feature", `kernel ${meta.name} keeps the ${slot.field} list outside engine memory`);
+        check(data.bindPool(binding, k, pool.at, pool.words), `binding the ${slot.field} list to kernel ${meta.name}`);
+      });
+    }
+    return bound.push({ table, into, joined: joined === null ? null : joined.slice(), binding }), binding;
+  }
+  spawned(binding, table) {
+    let read = this.engine.spawns;
+    if (read == null) return;
+    let at = read(binding);
+    if (at === 0) return;
+    let buffer = this.engine.memory.buffer, stats = this.spawnStats;
+    (stats.length === 0 || stats.byteOffset !== at || stats.buffer !== buffer) && (stats = new Uint32Array(buffer, at, SPAWN_STATS_WORDS), this.spawnStats = stats);
+    let counts = this.spawnCounts;
+    counts.spawned = stats[0], counts.dropped = stats[1], counts.killed = stats[2];
+    let into = this.into !== null && this.into !== table ? this.into : table;
+    reportSpawns(counts, into, this.report);
+  }
+  columnPointers() {
+    let buffer = this.engine.memory.buffer, view = this.columnsView;
+    return (view.length === 0 || view.byteOffset !== this.columnsAt || view.buffer !== buffer) && (view = new Uint32Array(buffer, this.columnsAt, (256)), this.columnsView = view), view;
+  }
+  recordWords() {
+    let buffer = this.engine.memory.buffer, view = this.recordsView;
+    return (view.length === 0 || view.byteOffset !== this.recordsAt || view.buffer !== buffer) && (view = new Uint32Array(buffer, this.recordsAt, this.recordsCapacity / (4)), this.recordsView = view), view;
+  }
+  armDataHook(ctx, stage, binding) {
+    this.hookStage = stage, this.hookData = stage.engine_kernel_stage_data ?? null, this.hookBinding = binding, this.hookDispatched = 0, !this.hookCtxs.has(ctx) && (this.hookCtxs.add(ctx), setWasmDataHook(ctx, this.dataHook));
+  }
+  disarmDataHook(ctx) {
+    this.hookCtxs.delete(ctx) && setWasmDataHook(ctx, null);
+  }
+  argViews() {
+    let buffer = this.engine.memory.buffer;
+    if (this.argsAt === 0 && (this.argsAt = this.engine.exports.engine_alloc((64) * (4), (4)), this.argsAt === 0))
+      throw new GameError("capacity_exceeded", "engine memory cannot hold kernel arguments");
+    this.argsBuffer !== buffer && (this.words = new Uint32Array(buffer, this.argsAt, (64)), this.floats = new Float32Array(buffer, this.argsAt, (64)), this.argsBuffer = buffer);
+  }
+  writeArg(at, arg, value) {
+    if (arg.kind === "f64" || arg.kind === "u64") return writeWideArg(this.words, at, arg.kind, value);
+    if (arg.width > 1 && (Array.isArray(value) || ArrayBuffer.isView(value))) {
+      let items = value;
+      for (let k = 0; k < arg.width; k++)
+        arg.kind === "f32" ? this.floats[at + k] = items[k] : this.words[at + k] = items[k] >>> 0;
+      return at + arg.width;
+    }
+    if (arg.width > 1) {
+      let vector = value;
+      for (let k = 0; k < arg.width; k++) this.floats[at + k] = vector[AXES2[k]];
+      return at + arg.width;
+    }
+    switch (arg.kind) {
+      case "f32":
+        this.floats[at] = value;
+        break;
+      case "bool":
+        this.words[at] = value ? (4294967295) : 0;
+        break;
+      default:
+        this.words[at] = value >>> 0;
+    }
+    return at + 1;
+  }
+  run(meta, bytes, table, selection, args) {
+    if (!table.native) throw new GameError("unsupported_feature", "native kernels run on engine tables");
+    if (meta.argWords > (64)) throw new GameError("invalid_argument", `kernel ${meta.name} takes more than ${(64)} argument words`);
+    let joined = hasData(meta) ? this.joinedOf(meta, table, args) : null;
+    if (joined !== null && (!this.acceptsData() || !allNative(joined))) throw new GameError("unsupported_feature", `kernel ${meta.name} joins tables; this engine predates native data ops or a joined table is not an engine table`);
+    let scalars = joined === null ? null : this.scalarMap(meta), program = this.program(meta, bytes), binding = this.binding(meta, bytes, program, table, joined);
+    this.argViews();
+    let at = 0, metaArgs = meta.args;
+    for (let k = 0; k < metaArgs.length; k++) {
+      let arg = metaArgs[k], from = scalars === null ? k : scalars[k];
+      arg.width === 1 && arg.kind === "f32" ? this.floats[at++] = args[from] : arg.width === 1 && (arg.kind === "u32" || arg.kind === "i32") ? this.words[at++] = args[from] >>> 0 : at = this.writeArg(at, arg, args[from]);
+    }
+    let calls = bytes.byteLength >= 8 && bytes[4] >= 2, writes = bytes.byteLength >= 8 && bytes[4] >= 3;
+    if (calls) {
+      let h = this.world?.handles() ?? null;
+      if (h === null && !writes) throw new GameError("unsupported_feature", `kernel ${meta.name} calls engine services; attach them with world.kernelServices({ physics, nav, flow, terrain, graphics })`);
+      let attached = this.engine.attach(binding, h?.physics ?? 0, h?.nav ?? 0, h?.flow ?? 0, h?.render ?? 0);
+      if (attached < 0 && check(attached, `attaching services to kernel ${meta.name}`), writes) {
+        let attach = this.engine.attachHandle;
+        attach(binding, ATTACH_UI, h?.ui ?? 0), attach(binding, ATTACH_AUDIO, h?.audio ?? 0), attach(binding, ATTACH_VOXELS, h?.voxels ?? 0), attach(binding, ATTACH_CHEMISTRY_GRID, h?.chemistry ?? 0);
+      }
+    }
+    if (this.runStaged(bytes, table, binding, at, selection))
+      return joined !== null && this.readReport(meta, bytes, binding), writes && this.spawned(binding, table), selection === null ? table.count : selection.length;
+    if (selection === null && this.runCompiled(meta, bytes, table, binding, at))
+      return joined !== null && this.readReport(meta, bytes, binding), table.count;
+    let list = selection ? selection.index : (255);
+    this.compute?.prioritise(COMPUTE_SPACE_CPU, binding, this.priority);
+    let ran = this.engine.exports.engine_kernel_run(binding, list, this.argsAt, at);
+    return ran === COMPUTE_DEFERRED && this.priority !== 0 ? 0 : (ran >= 0 || check(ran, `running kernel ${meta.name}`), joined !== null && this.readReport(meta, bytes, binding), meta.channels !== void 0 && meta.channels.length > 0 && (routeEvents(this.ring(binding), meta.channels), this.engine.exports.engine_kernel_clear_events(binding)), writes && this.spawned(binding, table), ran);
+  }
+  readReport(meta, bytes, binding) {
+    let report = this.engine.data.report(binding);
+    if (report === 0) return;
+    let heap = this.heapWords(), base = report >>> 2, sites = heap[base + DATA_REPORT_HEADER - 1], words = DATA_REPORT_HEADER + sites;
+    for (let s = 0; s < sites; s++) words += heap[base + DATA_REPORT_HEADER + s];
+    let copy = this.reportCopies.get(bytes);
+    copy === void 0 && (copy = { meta, words: new Uint32Array(words), length: 0, report: null }, this.reportCopies.set(bytes, copy)), copy.words.length < words && (copy.words = new Uint32Array(Math.max(words, copy.words.length * 2)));
+    let into = copy.words;
+    for (let k = 0; k < words; k++) into[k] = heap[base + k];
+    copy.meta = meta, copy.length = words, copy.report = null;
+  }
+  dataReport(bytes) {
+    let copy = this.reportCopies.get(bytes);
+    return copy === void 0 ? null : (copy.report === null && (copy.report = readDataReport(copy.meta, copy.words.slice(0, copy.length))), copy.report);
+  }
+  heapWords() {
+    let buffer = this.engine.memory.buffer;
+    return (this.heapView.buffer !== buffer || this.heapView.length === 0) && (this.heapView = new Uint32Array(buffer)), this.heapView;
+  }
+  joinedOf(meta, own, args) {
+    let known2 = this.joinedTables.get(meta), list = meta.data?.tables;
+    if (known2 === void 0) {
+      let fresh = dataTables(meta, own, args);
+      return this.joinedTables.set(meta, fresh), fresh;
+    }
+    if (known2[0] = own, list === void 0) return known2;
+    for (let k = 0; k < list.length; k++) {
+      let t = list[k], value = args[t.position];
+      if (!isEntityTable(value)) return dataTables(meta, own, args);
+      known2[t.table] = value;
+    }
+    return known2;
+  }
+  scalarMap(meta) {
+    let map = this.scalarMaps.get(meta);
+    if (map === void 0) {
+      let skip = meta.data?.tables, positions = [];
+      for (let k = 0; positions.length < meta.args.length; k++) {
+        let table = false;
+        if (skip !== void 0) for (let s = 0; s < skip.length; s++) skip[s].position === k && (table = true);
+        table || positions.push(k);
+      }
+      map = Int32Array.from(positions), this.scalarMaps.set(meta, map);
+    }
+    return map;
+  }
+  runStaged(bytes, table, binding, argWords, selection) {
+    let memory = this.engine.memory, ex = this.engine.exports;
+    if (typeof WebAssembly > "u" || !(memory instanceof WebAssembly.Memory) || typeof ex.engine_kernel_stage_begin != "function") return false;
+    let stage = ex, entry = this.staged.get(bytes);
+    if (entry === void 0) {
+      let program2 = parseProgram(bytes);
+      entry = wasmStaged(program2) ? { program: program2, data: wasmDataOps(program2), storages: "", planned: false, storageWords: new Float64Array(program2.slots.length), probe: new Array(program2.slots.length).fill(0), runs: null, stages: [] } : null, this.staged.set(bytes, entry);
+    }
+    if (entry === null) return false;
+    let count = table.count, rowsAt = 0, n = count;
+    if (selection !== null) {
+      if (entry.program.calls.length > 0 || entry.program.cross.length > 0 || selection.rows.buffer !== memory.buffer) return false;
+      n = selection.length;
+      for (let k = 0; k < n; k++) if (selection.rows[k] >= count) return false;
+      rowsAt = selection.rows.byteOffset;
+    }
+    let stageData = stage.engine_kernel_stage_data;
+    if (entry.data && typeof stageData != "function") return false;
+    let program = entry.program;
+    check(stage.engine_kernel_stage_begin(binding, this.argsAt, argWords), "starting a staged kernel");
+    let probe = entry.probe;
+    for (let k = 0; k < probe.length; k++) probe[k] = stage.engine_kernel_stage_storage(binding, k);
+    if (!entry.planned || !sameStorages(entry.storageWords, probe)) {
+      let storages = probe.slice(), key = storages.join(",");
+      entry.planned = true, entry.storages = key, entry.storageWords.set(storages), entry.runs = null;
+      let plan = compileWasmKernel(program, storages, sharedBuffer(memory.buffer) ? (65536) : null);
+      if (plan !== null) {
+        let target = entry;
+        this.track(
+          instantiateApproved(plan.bytes, wasmKernelImports(memory)).then((instance) => {
+            target.storages === key && (target.stages = plan.stages, target.runs = plan.stages.map((_, k) => instance.exports[wasmStageName(k)]));
+          }).catch(() => {
+          })
+        );
+      }
+    }
+    if (entry.runs === null || this.columnsAt === 0 && (this.columnsAt = this.engine.exports.engine_alloc((256) * (4), (4)), this.columnsAt === 0))
+      return false;
+    let ctxBytes = laneScratchOffset(program) + LANE_SCRATCH_BYTES;
+    if (this.recordsCapacity < ctxBytes && (this.recordsAt !== 0 && (this.disarmDataHook(this.recordsAt), this.engine.exports.engine_free(this.recordsAt, this.recordsCapacity, (16))), this.recordsAt = this.engine.exports.engine_alloc(ctxBytes, (16)), this.recordsCapacity = this.recordsAt === 0 ? 0 : ctxBytes, this.recordsAt === 0))
+      return false;
+    let pointers = this.columnPointers();
+    for (let k = 0; k < program.slots.length; k++) pointers[k] = stage.engine_kernel_stage_column(binding, k);
+    let records = this.recordWords(), cross = program.cross;
+    for (let k = 0; k < cross.length; k++) records[k] = stage.engine_kernel_stage_records(binding, cross[k]);
+    let uniformsAt = stage.engine_kernel_stage_uniforms(binding);
+    entry.data && stageData !== void 0 && this.armDataHook(this.recordsAt, stage, binding);
+    let runs = entry.runs, stages = entry.stages;
+    for (let k = 0; k < stages.length; k++) {
+      let s = stages[k];
+      if (runs[k](this.columnsAt, n, rowsAt, uniformsAt, this.recordsAt), n > 0 && this.hookDispatched++, s.barrier === "call") check(stage.engine_kernel_stage_call(binding, s.pcs[0]), "calling the engine from a kernel");
+      else if (s.barrier === "cross") for (let p = 0; p < s.pcs.length; p++) check(stage.engine_kernel_stage_finish(binding, s.pcs[p]), "finishing a cross-row stage");
+    }
+    return check(stage.engine_kernel_stage_end(binding), "ending a staged kernel"), this.stagedRuns++, true;
+  }
+  compiledEntry(meta, bytes, stage) {
+    let known2 = this.compiled.get(bytes);
+    if (known2 !== void 0) return known2;
+    let program = parseProgram(bytes), data = wasmDataOps(program), usable = !wasmStaged(program) && !slotsSpawnOrScratch(program) && (!data || typeof stage.engine_kernel_stage_data == "function" && typeof stage.engine_kernel_stage_begin == "function"), slots = meta.slots.length, entry = usable ? {
+      runs: null,
+      storages: "",
+      planned: false,
+      program,
+      data,
+      needsHost: wasmNeedsHost(program),
+      offsets: new Uint32Array(program.groups.length + 1),
+      columns: new Int32Array(slots),
+      probe: new Array(slots).fill(0),
+      storageWords: new Float64Array(slots),
+      hostColumns: Array.from({ length: slots }, () => ({ at: 0, storage: 0 })),
+      uniforms: null,
+      host: null,
+      state: null
+    } : null;
+    return this.compiled.set(bytes, entry), entry;
+  }
+  planCompiled(entry, memory) {
+    entry.planned = true;
+    let storages = entry.probe.slice();
+    entry.storageWords.set(storages), entry.storages = storages.join(",");
+    let plan = compileWasmKernel(entry.program, storages, sharedBuffer(memory.buffer) ? (65536) : null);
+    plan !== null && this.track(
+      instantiateApproved(plan.bytes, wasmKernelImports(memory)).then((instance) => {
+        let names = plan.groups > 0 ? Array.from({ length: plan.groups }, (_, g) => wasmExportName(g)) : [wasmExportName(-1)];
+        entry.runs = names.map((name2) => instance.exports[name2]);
+      }).catch(() => {
+      })
+    );
+  }
+  track(job) {
+    this.compiling.add(job), job.finally(() => this.compiling.delete(job));
+  }
+  async settled() {
+    for (; this.compiling.size > 0; ) await Promise.all([...this.compiling]);
+  }
+  finishCompiled(entry, meta, exports, binding) {
+    let host = entry.host;
+    return entry.data && check(exports.engine_kernel_stage_end(binding), "ending a data kernel"), host !== null && meta.channels !== void 0 && meta.channels.length > 0 && (host.flush(), routeEvents(host.ring, meta.channels), host.clearEvents()), true;
+  }
+  stateView(entry, at, storage, capacity) {
+    let buffer = this.engine.memory.buffer, known2 = entry.state, float = storage === 0;
+    if (known2 !== null && known2.buffer === buffer && known2.byteOffset === at && known2.length === capacity && known2 instanceof Float32Array === float) return known2;
+    let view = float ? new Float32Array(buffer, at, capacity) : new Uint32Array(buffer, at, capacity);
+    return entry.state = view, view;
+  }
+  groupRows(capacity) {
+    let buffer = this.engine.memory.buffer, view = this.groupRowsView;
+    return (view.length !== capacity || view.byteOffset !== this.groupRowsAt || view.buffer !== buffer) && (view = new Uint32Array(buffer, this.groupRowsAt, capacity), this.groupRowsView = view), view;
+  }
+  runCompiled(meta, bytes, table, binding, argWords) {
+    let memory = this.engine.memory;
+    if (typeof WebAssembly > "u" || !(memory instanceof WebAssembly.Memory)) return false;
+    let stage = this.engine.exports, entry = this.compiledEntry(meta, bytes, stage);
+    if (entry === null) return false;
+    let exports = stage, data = entry.data;
+    data && check(exports.engine_kernel_stage_begin(binding, this.argsAt, argWords), "starting a data kernel");
+    let slots = meta.slots, columns = entry.columns, probe = entry.probe;
+    if (data) for (let k = 0; k < slots.length; k++) probe[k] = exports.engine_kernel_stage_storage(binding, k);
+    else
+      for (let k = 0; k < slots.length; k++) {
+        let c = table.column(slots[k].field, slots[k].component);
+        columns[k] = c, probe[k] = table.header[(32) + 2 * c + 1];
+      }
+    if (entry.planned || this.planCompiled(entry, memory), entry.runs === null || !sameStorages(entry.storageWords, probe) || this.columnsAt === 0 && (this.columnsAt = this.engine.exports.engine_alloc((256) * (4), (4)), this.columnsAt === 0))
+      return false;
+    let pointers = this.columnPointers();
+    for (let k = 0; k < slots.length; k++) pointers[k] = data ? exports.engine_kernel_stage_column(binding, k) : table.header[(32) + 2 * columns[k]];
+    let count = table.count, program = entry.program, ctx = 0, sorted = 0;
+    if (entry.needsHost) {
+      if (entry.host === null || entry.host.capacity !== table.capacity) {
+        entry.host !== null && (this.disarmDataHook(entry.host.ctx), entry.host.dispose());
+        let alloc = this.engine.exports;
+        entry.host = new WasmKernelHost(program, table.capacity, this.engine.memory, (bytes2) => alloc.engine_alloc(bytes2, (4)));
+      }
+      ctx = entry.host.ctx;
+      let uniforms = entry.uniforms;
+      uniforms === null && (uniforms = program.uniforms.slice(), entry.uniforms = uniforms);
+      let words = this.words;
+      for (let k = 0; k < program.args; k++) uniforms[k] = words[k];
+      let hostColumns = entry.hostColumns;
+      for (let k = 0; k < slots.length; k++)
+        hostColumns[k].at = pointers[k], hostColumns[k].storage = probe[k];
+      sorted = entry.host.prepare(hostColumns, count, uniforms);
+    }
+    this.compiledRuns++, data && this.armDataHook(ctx, exports, binding);
+    let runs = entry.runs;
+    if (program.state < 0)
+      return runs[0](this.columnsAt, count, sorted, this.argsAt, ctx), this.finishCompiled(entry, meta, exports, binding);
+    if (this.groupRowsCapacity < table.capacity && (this.groupRowsAt !== 0 && this.engine.exports.engine_free(this.groupRowsAt, this.groupRowsCapacity * (4), (4)), this.groupRowsAt = this.engine.exports.engine_alloc(table.capacity * (4), (4)), this.groupRowsCapacity = this.groupRowsAt === 0 ? 0 : table.capacity, this.groupRowsAt === 0))
+      return false;
+    let state = this.stateView(entry, pointers[program.state], probe[program.state], table.capacity);
+    bucketGroups(program, state, count, this.groupRows(table.capacity), entry.offsets);
+    let offsets = entry.offsets, flushes = entry.host !== null && meta.channels !== void 0 && meta.channels.length > 0;
+    for (let g = 0; g < runs.length; g++) {
+      let n = offsets[g + 1] - offsets[g];
+      n > 0 && (runs[g](this.columnsAt, n, this.groupRowsAt + offsets[g] * (4), this.argsAt, ctx), this.hookDispatched++, flushes && entry.host.flush());
+    }
+    return this.finishCompiled(entry, meta, exports, binding);
+  }
+  ring(binding) {
+    let known2 = this.rings.get(binding);
+    if (known2 !== void 0 && known2.buffer === this.engine.memory.buffer) return known2;
+    let at = this.engine.exports.engine_kernel_events(binding), view = new Uint32Array(this.engine.memory.buffer, at, RING_HEADER_WORDS + DEFAULT_EVENT_CAPACITY * 10);
+    return this.rings.set(binding, view), view;
+  }
+  dispose() {
+    let exports = this.engine.exports;
+    for (let bound of this.bindings.values()) for (let entry of bound) exports.engine_kernel_unbind(entry.binding);
+    for (let id of this.programs.values()) exports.engine_kernel_unload(id);
+    this.argsAt !== 0 && exports.engine_free(this.argsAt, (64) * (4), (4)), this.bindings.clear(), this.programs.clear(), this.argsAt = 0;
+  }
+};
+
+// src/game/nav/types.ts
+var AGENT_X = 0;
+var AGENT_STRIDE = 8, AGENT_IDLE = 0, AGENT_REQUESTING = 1, AGENT_MOVING = 2, AGENT_ARRIVED = 3, AGENT_LOST = 4, AGENT_ON_LINK = 5, NO_LINK = -1, POSE_X = 0;
+var POSE_Z = 2, POSE_DIR_X = 3, POSE_DIR_Z = 4, POSE_SPEED = 5, POSE_LANE = 6, POSE_STRIDE = 8, SIGNAL_GREEN = 0, SIGNAL_AMBER = 1, SIGNAL_RED = 2;
+var DEFAULT_EXTENTS = [2, 4, 2], MAX_CORNERS = 16;
+
+// src/game/physics/rules.ts
+var MAX_COLLIDER_CLASSES = 16, DEFAULT_COLLIDER_CLASS = 0;
+var RULE_IGNORE = 1, RULE_FRICTION = 2, RULE_RESTITUTION = 4, RULE_ONE_WAY = 8, RULE_CLASS_BITS = 8, RULE_FLAGS_SHIFT = 16, RULE_PAYLOAD_FRICTION = 0, RULE_PAYLOAD_RESTITUTION = 1, RULE_PAYLOAD_ONE_WAY = 2, NO_CONTACT_RULE = {};
+function checkColliderClass(value) {
+  if (!Number.isInteger(value) || value < 0 || value >= (16))
+    throw new GameError("invalid_argument", `collider classes are integers from 0 to ${(16) - 1}`);
+  return value;
+}
+function contactRuleFlags(rule) {
+  return (rule.ignore ? (1) : 0) | (rule.friction !== void 0 ? (2) : 0) | (rule.restitution !== void 0 ? (4) : 0) | (rule.oneWay !== void 0 ? (8) : 0);
+}
+function packContactRuleHeader(platform, other, rule) {
+  return (checkColliderClass(platform) | checkColliderClass(other) << (8) | contactRuleFlags(rule) << (16)) >>> 0;
+}
+function writeContactRulePayload(rule, floats, offset) {
+  floats[offset + (0)] = rule.friction ?? 0, floats[offset + (1)] = rule.restitution ?? 0;
+  let n = rule.oneWay;
+  if (n === void 0) {
+    floats[offset + (2)] = 0, floats[offset + (2) + 1] = 0, floats[offset + (2) + 2] = 0;
+    return;
+  }
+  let length = Math.hypot(n[0], n[1], n[2]);
+  if (!(length > 0)) throw new GameError("invalid_argument", "a one-way normal must be a non-zero vector");
+  floats[offset + (2)] = n[0] / length, floats[offset + (2) + 1] = n[1] / length, floats[offset + (2) + 2] = n[2] / length;
+}
+var TABLE = (16) * (16), NO_VALUE = Number.NaN, ContactRuleTable = class {
+  constructor() {
+    this.flags = new Uint8Array(TABLE);
+    this.friction = new Float32Array(TABLE).fill(NO_VALUE);
+    this.restitution = new Float32Array(TABLE).fill(NO_VALUE);
+    this.normal = new Float32Array(TABLE * 3);
+    this.active = 0;
+  }
+  get count() {
+    return this.active;
+  }
+  set(platform, other, rule) {
+    let a = checkColliderClass(platform), b = checkColliderClass(other);
+    this.write(a * (16) + b, rule, true), a !== b && this.write(b * (16) + a, rule, false);
+    let active = 0;
+    for (let i = 0; i < TABLE; i++) this.flags[i] !== 0 && active++;
+    this.active = active;
+  }
+  index(a, b) {
+    return a * (16) + b;
+  }
+  write(at, rule, oneWay) {
+    let flags = contactRuleFlags(rule) & (oneWay ? 255 : ~(8));
+    this.flags[at] = flags, this.friction[at] = rule.friction ?? NO_VALUE, this.restitution[at] = rule.restitution ?? NO_VALUE;
+    let n = oneWay ? rule.oneWay : void 0, length = n ? Math.hypot(n[0], n[1], n[2]) : 0;
+    this.normal[at * 3] = n && length > 0 ? n[0] / length : 0, this.normal[at * 3 + 1] = n && length > 0 ? n[1] / length : 0, this.normal[at * 3 + 2] = n && length > 0 ? n[2] / length : 0;
+  }
+};
+
+// src/game/physics/craft/types.ts
+var CRAFT_CHANNELS = 16, CRAFT_TELEMETRY_WORDS = 16;
+var NO_CHANNEL = 255, MAX_FOILS = 16, MAX_THRUSTERS = 8, MAX_ROTORS = 8, MAX_CRAFT_WHEELS = 8, MAX_HULL_POINTS = 512, MAX_HULL_RESOLUTION = 16, MAX_AERO_TABLE = 64, TELEMETRY_SPEED = 0, TELEMETRY_SUBMERGED = 1, TELEMETRY_PLANING = 2, TELEMETRY_BANK = 3, TELEMETRY_AIRSPEED = 4, TELEMETRY_ALPHA = 5, TELEMETRY_STALLED = 6, TELEMETRY_GROUND_EFFECT = 7, TELEMETRY_CONTACTS = 8, TELEMETRY_GEAR = 9, TELEMETRY_SPOOL = 10, TELEMETRY_ROTOR = 11, TELEMETRY_THRUST = 12, TELEMETRY_CLIMB = 13, TELEMETRY_APPARENT_WIND = 14, TELEMETRY_PITCH = 15, BOAT_THROTTLE = 0, BOAT_STEER = 1, BOAT_SHEET = 2, FLIGHT_PITCH = 0, FLIGHT_ROLL = 1, FLIGHT_YAW = 2, FLIGHT_THROTTLE = 3, FLIGHT_FLAPS = 4, FLIGHT_BRAKE = 5, FLIGHT_GEAR = 6, FLIGHT_TILT = 7, ROTOR_COLLECTIVE = 0, ROTOR_CYCLIC_PITCH = 1, ROTOR_CYCLIC_ROLL = 2, ROTOR_PEDAL = 3, ROTOR_ENGINE = 4, CRAFT_PRESETS = [
+  "canoe",
+  "speedboat",
+  "ferry",
+  "cargo_ship",
+  "sailboat",
+  "light_plane",
+  "jet",
+  "glider",
+  "helicopter",
+  "quadcopter",
+  "tiltrotor",
+  "blimp"
+];
+function mix(channel, gain, bias = 0) {
+  let gains = Array.from({ length: 16 }, (_, i) => i === channel ? gain : 0);
+  return { bias, gains };
+}
+function mixWith(base, channel, gain) {
+  let gains = Array.from({ length: 16 }, (_, i) => base.gains?.[i] ?? 0);
+  return gains[channel] = gain, { bias: base.bias ?? 0, gains };
+}
+function constant(bias) {
+  return { bias };
+}
+
+// src/game/physics/craft/dmath.ts
+var f = Math.fround, PI = f(Math.PI), TAU = f(Math.PI * 2), FRAC_PI_2 = f(Math.PI / 2), INV_TAU = f(1 / TAU), FRAC_2_PI = f(2 / Math.PI), ROUND_MAGIC = 12582912, ROUND_LIMIT = 4194304, HALF_PI_A = f(1.5703125), HALF_PI_B = f(4837513e-10), HALF_PI_C = f(754979e-13), SIN_1 = f(-0.16666655), SIN_2 = f(8332161e-9), SIN_3 = f(-19515296e-11), COS_1 = f(0.041666646), COS_2 = f(-0.0013887316), COS_3 = f(24433157e-12), QUADRANT = 0.25, QUADRANT_LOW = 0.125, QUADRANT_HIGH = 0.375, ATAN_0 = f(0.99997726), ATAN_1 = f(-0.33262347), ATAN_2 = f(0.19354346), ATAN_3 = f(-0.11643287), ATAN_4 = f(0.05265332), ATAN_5 = f(-0.0117212), LOG2_E = f(Math.LOG2E), LN2_HI = f(0.69314575), LN2_LO = f(14286068e-13), EXP_2 = 0.5, EXP_3 = f(0.16666667), EXP_4 = f(0.041666668), EXP_5 = f(8333334e-9), EXP_6 = f(0.0013888889), EXP_LIMIT = 87, TANH_LIMIT = 9;
+function clamp2(x, low, high) {
+  let lifted = x > low ? x : low;
+  return lifted < high ? lifted : high;
+}
+function round(x) {
+  return Math.abs(x) < (4194304) ? f(f(x + (12582912)) - (12582912)) : x;
+}
+function wrapAngle(x) {
+  return f(x - f(round(f(x * INV_TAU)) * TAU));
+}
+function sinCos(x, out) {
+  let n = round(f(x * FRAC_2_PI)), r = f(f(f(x - f(n * HALF_PI_A)) - f(n * HALF_PI_B)) - f(n * HALF_PI_C)), z = f(r * r), s = f(f(f(f(f(f(f(SIN_3 * z) + SIN_2) * z) + SIN_1) * z) * r) + r), c = f(f(1 - f(0.5 * z)) + f(f(z * z) * f(f(f(f(COS_3 * z) + COS_2) * z) + COS_1))), quarter = f(n * (0.25)), q = f(quarter - round(quarter)), aq = Math.abs(q), swap = aq > (0.125) && aq < (0.375), sinNegative = q < -(0.125) || q > (0.375), cosNegative = q > (0.125) || q < -(0.375), sin2 = swap ? c : s, cos = swap ? s : c;
+  return out.sin = sinNegative ? -sin2 : sin2, out.cos = cosNegative ? -cos : cos, out;
+}
+var scratch = { sin: 0, cos: 0 };
+function sin(x) {
+  return sinCos(x, scratch).sin;
+}
+function atan2(y, x) {
+  let ax = Math.abs(x), ay = Math.abs(y), big = ax > ay ? ax : ay, small = ax < ay ? ax : ay, a = big > 0 ? f(small / big) : 0, s = f(a * a), r = f(
+    f(f(f(f(f(f(f(f(f(f(ATAN_5 * s) + ATAN_4) * s) + ATAN_3) * s) + ATAN_2) * s) + ATAN_1) * s) + ATAN_0) * a
+  );
+  return ay > ax && (r = f(FRAC_PI_2 - r)), x < 0 && (r = f(PI - r)), y < 0 ? -r : r;
+}
+var exponentView = new DataView(new ArrayBuffer(4));
+function exp(input) {
+  let x = clamp2(f(input), -(87), (87)), n = round(f(x * LOG2_E)), r = f(f(x - f(n * LN2_HI)) - f(n * LN2_LO)), p = f(
+    f(f(f(f(f(f(f(f(f(f(f(EXP_6 * r) + EXP_5) * r) + EXP_4) * r) + EXP_3) * r) + (0.5)) * r) * r) + r) + 1
+  );
+  return exponentView.setUint32(0, n + 127 << 23 >>> 0), f(p * exponentView.getFloat32(0));
+}
+function tanh(x) {
+  if (x > (9)) return 1;
+  if (x < -(9)) return -1;
+  let e = exp(f(x + x));
+  return f(f(e - 1) / f(e + 1));
+}
+var Basis = class {
+  constructor() {
+    this.rx = 1;
+    this.ry = 0;
+    this.rz = 0;
+    this.ux = 0;
+    this.uy = 1;
+    this.uz = 0;
+    this.bx = 0;
+    this.by = 0;
+    this.bz = 1;
+  }
+  fromQuaternion(x, y, z, w) {
+    let x2 = x + x, y2 = y + y, z2 = z + z, xx = x * x2, xy = x * y2, xz = x * z2, yy = y * y2, yz = y * z2, zz = z * z2, wx = w * x2, wy = w * y2, wz = w * z2;
+    return this.rx = 1 - (yy + zz), this.ry = xy + wz, this.rz = xz - wy, this.ux = xy - wz, this.uy = 1 - (xx + zz), this.uz = yz + wx, this.bx = xz + wy, this.by = yz - wx, this.bz = 1 - (xx + yy), this;
+  }
+  toWorld(x, y, z, out, at = 0) {
+    return out[at] = this.rx * x + this.ux * y + this.bx * z, out[at + 1] = this.ry * x + this.uy * y + this.by * z, out[at + 2] = this.rz * x + this.uz * y + this.bz * z, out;
+  }
+  toLocal(x, y, z, out, at = 0) {
+    return out[at] = this.rx * x + this.ry * y + this.rz * z, out[at + 1] = this.ux * x + this.uy * y + this.uz * z, out[at + 2] = this.bx * x + this.by * y + this.bz * z, out;
+  }
+};
+
+// src/game/physics/water.ts
+var f2 = Math.fround, MAX_WAVES = 16, SEA_WATER_DENSITY = 1025, FRESH_WATER_DENSITY = 1e3, AIR_DENSITY = f2(1.225), DEFAULT_WATER_GRAVITY = f2(9.81), DEFAULT_WATER_ITERATIONS = 2, MAX_WATER_ITERATIONS = 8, WATER_SAMPLE_WORDS = 7, MIN_WAVELENGTH = f2(0.05), MIN_DIRECTION = f2(1e-6), PEAK_FACTOR = f2(0.877), SIGNIFICANT_HEIGHT = f2(0.21), WAVES_PER_SEA = 8, SPREAD_RADIANS = f2(0.7), SHORTEST = f2(0.35), LONGEST = f2(1.6), LAKE_FETCH_CAP = 6, LAKE_DEPTH = 8, UNIT_SHIFT = 40n, UNIT_SCALE2 = 16777216, MASK_64 = (1n << 64n) - 1n, SPLITMIX_INCREMENT = 0x9e3779b97f4a7c15n, SPLITMIX_MUL_A = 0xbf58476d1ce4e5b9n, SPLITMIX_MUL_B = 0x94d049bb133111ebn, SEA_STATES = ["mirror", "lake", "calm", "moderate", "rough", "storm"], SEA_WIND = { mirror: 0, lake: 4, calm: 5, moderate: 9, rough: 14, storm: 22 }, SEA_STEEPNESS = {
+  mirror: 0,
+  lake: f2(0.25),
+  calm: f2(0.3),
+  moderate: f2(0.45),
+  rough: f2(0.6),
+  storm: f2(0.75)
+}, WaterSample = class {
+  constructor() {
+    this.height = 0;
+    this.normalX = 0;
+    this.normalY = 1;
+    this.normalZ = 0;
+    this.velocityX = 0;
+    this.velocityY = 0;
+    this.velocityZ = 0;
+  }
+}, SplitMix64 = class {
+  constructor(seed) {
+    this.state = BigInt(seed) & MASK_64;
+  }
+  next() {
+    this.state = this.state + SPLITMIX_INCREMENT & MASK_64;
+    let z = this.state;
+    return z = (z ^ z >> 30n) * SPLITMIX_MUL_A & MASK_64, z = (z ^ z >> 27n) * SPLITMIX_MUL_B & MASK_64, z ^ z >> 31n;
+  }
+  unit() {
+    return f2(Number(this.next() >> UNIT_SHIFT) / (16777216));
+  }
+  range(low, high) {
+    return f2(low + f2(f2(high - low) * this.unit()));
+  }
+};
+function seaDesc(state, windRadians, seed) {
+  let speed = SEA_WIND[state], angle = f2(windRadians), sc = { sin: 0, cos: 0 };
+  sinCos(angle, sc);
+  let wind = [f2(sc.cos * speed), f2(sc.sin * speed)];
+  if (state === "mirror") return { wind };
+  let g = DEFAULT_WATER_GRAVITY, omegaPeak = f2(f2(PEAK_FACTOR * g) / speed), peak = f2(f2(TAU * g) / f2(omegaPeak * omegaPeak)), depth = Number.POSITIVE_INFINITY, density = (1025);
+  state === "lake" && (depth = (8), density = (1e3), peak = clamp2(peak, 0, (6)));
+  let height = f2(f2(f2(SIGNIFICANT_HEIGHT * speed) * speed) / g), random = new SplitMix64(seed), count = Math.min((8), (16)), share = f2(1 / f2(Math.sqrt(count))), waves = [];
+  for (let i = 0; i < count; i++) {
+    let t = f2(f2(i + random.unit()) / count), wavelength = f2(peak * f2(SHORTEST + f2(f2(LONGEST - SHORTEST) * t))), direction = f2(angle + random.range(-SPREAD_RADIANS, SPREAD_RADIANS));
+    sinCos(direction, sc);
+    let amplitude = f2(f2(f2(f2(0.5 * height) * share)) * f2(wavelength / peak));
+    waves.push({
+      direction: [sc.cos, sc.sin],
+      wavelength,
+      amplitude,
+      steepness: f2(f2(f2(SEA_STEEPNESS[state] / count)) * 2),
+      phase: random.range(0, TAU)
+    });
+  }
+  return { wind, depth, density, waves };
+}
+var Water = class {
+  constructor(desc = {}) {
+    this.kx = new Float32Array((16));
+    this.kz = new Float32Array((16));
+    this.phase = new Float32Array((16));
+    this.amplitude = new Float32Array((16));
+    this.qax = new Float32Array((16));
+    this.qaz = new Float32Array((16));
+    this.kax = new Float32Array((16));
+    this.kaz = new Float32Array((16));
+    this.kqa = new Float32Array((16));
+    this.wqax = new Float32Array((16));
+    this.wqaz = new Float32Array((16));
+    this.wa = new Float32Array((16));
+    this.omega = new Float32Array((16));
+    this.sc = { sin: 0, cos: 0 };
+    this.seconds = new Float64Array(1);
+    this.count = 0;
+    this.iterations = (2);
+    this.currentX = 0;
+    this.currentZ = 0;
+    this.windX = 0;
+    this.windZ = 0;
+    this.gust = 0;
+    this.gustOmega = 0;
+    this.gustPhase = 0;
+    this.time = 0;
+    this.level = 0;
+    this.density = (1025);
+    this.gravity = DEFAULT_WATER_GRAVITY;
+    this.batchSample = new WaterSample();
+    this.px = 0;
+    this.pz = 0;
+    this.configure(desc);
+  }
+  configure(desc) {
+    let waves = desc.waves ?? [], gravity = f2(desc.gravity ?? DEFAULT_WATER_GRAVITY), density = f2(desc.density ?? (1025)), depth = desc.depth ?? Number.POSITIVE_INFINITY, iterations = desc.iterations ?? (2);
+    if (waves.length > (16) || iterations > (8) || !(gravity > 0) || !(density > 0) || Number.isNaN(depth) || depth <= 0)
+      throw new GameError("invalid_argument", "water description is out of range");
+    let total = 0;
+    for (let wave of waves) {
+      let length = f2(Math.sqrt(f2(f2(f2(wave.direction[0]) * f2(wave.direction[0])) + f2(f2(wave.direction[1]) * f2(wave.direction[1])))));
+      if (!(f2(wave.wavelength) >= MIN_WAVELENGTH) || !(wave.amplitude >= 0) || !(length > MIN_DIRECTION))
+        throw new GameError("invalid_argument", "wave description is out of range");
+      total = f2(total + clamp2(f2(wave.steepness), 0, 1));
+    }
+    let normalizer = total > 1 ? f2(1 / total) : 1;
+    for (let i = 0; i < (16); i++) {
+      let wave = waves[i];
+      if (!wave) {
+        this.kx[i] = this.kz[i] = this.phase[i] = this.amplitude[i] = 0, this.qax[i] = this.qaz[i] = this.kax[i] = this.kaz[i] = this.kqa[i] = 0, this.wqax[i] = this.wqaz[i] = this.wa[i] = this.omega[i] = 0;
+        continue;
+      }
+      let x = f2(wave.direction[0]), z = f2(wave.direction[1]), length = f2(Math.sqrt(f2(f2(x * x) + f2(z * z)))), dx = f2(x / length), dz = f2(z / length), k = f2(TAU / f2(wave.wavelength)), deep = f2(gravity * k), omega = Number.isFinite(depth) ? f2(Math.sqrt(f2(deep * tanh(f2(k * f2(depth)))))) : f2(Math.sqrt(deep)), a = f2(wave.amplitude), ka = f2(k * a), q = ka > 0 ? f2(f2(clamp2(f2(wave.steepness), 0, 1) * normalizer) / ka) : 0, qa = f2(q * a);
+      this.kx[i] = f2(k * dx), this.kz[i] = f2(k * dz), this.phase[i] = wrapAngle(f2(wave.phase)), this.amplitude[i] = a, this.qax[i] = f2(dx * qa), this.qaz[i] = f2(dz * qa), this.kax[i] = f2(dx * ka), this.kaz[i] = f2(dz * ka), this.kqa[i] = f2(k * qa), this.wqax[i] = f2(omega * f2(dx * qa)), this.wqaz[i] = f2(omega * f2(dz * qa)), this.wa[i] = f2(omega * a), this.omega[i] = omega;
+    }
+    this.count = waves.length, this.iterations = iterations, this.level = f2(desc.level ?? 0), this.density = density, this.gravity = gravity, this.currentX = f2(desc.current?.[0] ?? 0), this.currentZ = f2(desc.current?.[1] ?? 0), this.setWind(desc.wind?.[0] ?? 0, desc.wind?.[1] ?? 0, desc.gust ?? 0, desc.gustPeriod ?? 0), this.gustPhase = 0, this.time = 0;
+  }
+  setWind(x, z, gust = 0, gustPeriod = 0) {
+    this.windX = f2(x), this.windZ = f2(z), this.gust = f2(gust), this.gustOmega = gustPeriod > 0 ? f2(TAU / f2(gustPeriod)) : 0;
+  }
+  setCurrent(x, z) {
+    this.currentX = f2(x), this.currentZ = f2(z);
+  }
+  crest() {
+    let swell = 0;
+    for (let i = 0; i < this.count; i++) swell += this.amplitude[i];
+    return this.level + swell;
+  }
+  get elapsed() {
+    return this.time;
+  }
+  advance(dt) {
+    this.seconds[0] = dt, this.advanceFrom(this.seconds, 0);
+  }
+  advanceFrom(values, at) {
+    let step = f2(values[at]);
+    for (let i = 0; i < this.count; i++) this.phase[i] = wrapAngle(f2(this.phase[i] - f2(this.omega[i] * step)));
+    this.gustPhase = wrapAngle(f2(this.gustPhase + f2(this.gustOmega * step))), this.time += step;
+  }
+  windInto(out, at = 0) {
+    let gain = f2(1 + f2(this.gust * sin(this.gustPhase)));
+    return out[at] = f2(this.windX * gain), out[at + 1] = 0, out[at + 2] = f2(this.windZ * gain), out;
+  }
+  height(x, z) {
+    this.undisplace(f2(x), f2(z));
+    let height = 0;
+    for (let i = 0; i < this.count; i++)
+      sinCos(this.theta(i), this.sc), height = f2(height + f2(this.amplitude[i] * this.sc.sin));
+    return f2(this.level + height);
+  }
+  sample(x, z, out) {
+    this.undisplace(f2(x), f2(z));
+    let height = 0, nx = 0, ny = 0, nz = 0, vx = 0, vy = 0, vz = 0;
+    for (let i = 0; i < this.count; i++) {
+      sinCos(this.theta(i), this.sc);
+      let s = this.sc.sin, c = this.sc.cos;
+      height = f2(height + f2(this.amplitude[i] * s)), nx = f2(nx + f2(this.kax[i] * c)), ny = f2(ny + f2(this.kqa[i] * s)), nz = f2(nz + f2(this.kaz[i] * c)), vx = f2(vx + f2(this.wqax[i] * s)), vy = f2(vy + f2(this.wa[i] * c)), vz = f2(vz + f2(this.wqaz[i] * s));
+    }
+    let gx = -nx, gy = f2(1 - ny), gz = -nz, inverse = f2(1 / f2(Math.sqrt(f2(f2(f2(gx * gx) + f2(gy * gy)) + f2(gz * gz)))));
+    return out.height = f2(this.level + height), out.normalX = f2(gx * inverse), out.normalY = f2(gy * inverse), out.normalZ = f2(gz * inverse), out.velocityX = f2(vx + this.currentX), out.velocityY = -vy, out.velocityZ = f2(vz + this.currentZ), out;
+  }
+  sampleBatch(points, count, out) {
+    let sample = this.batchSample;
+    for (let i = 0; i < count; i++) {
+      this.sample(points[i * 2], points[i * 2 + 1], sample);
+      let o = i * (7);
+      out[o] = sample.height, out[o + 1] = sample.normalX, out[o + 2] = sample.normalY, out[o + 3] = sample.normalZ, out[o + 4] = sample.velocityX, out[o + 5] = sample.velocityY, out[o + 6] = sample.velocityZ;
+    }
+  }
+  theta(i) {
+    return f2(f2(f2(this.kx[i] * this.px) + f2(this.kz[i] * this.pz)) + this.phase[i]);
+  }
+  undisplace(x, z) {
+    this.px = x, this.pz = z;
+    for (let n = 0; n < this.iterations; n++) {
+      let dx = 0, dz = 0;
+      for (let i = 0; i < this.count; i++)
+        sinCos(this.theta(i), this.sc), dx = f2(dx + f2(this.qax[i] * this.sc.cos)), dz = f2(dz + f2(this.qaz[i] * this.sc.cos));
+      this.px = f2(x - dx), this.pz = f2(z - dz);
+    }
+  }
+};
+
+// src/game/physics/curves.ts
+function validateCurve(curve, maxPoints, what) {
+  let n = curve.x.length;
+  if (n < 1 || n > maxPoints || curve.y.length !== n)
+    throw new GameError("invalid_argument", `${what} needs 1 to ${maxPoints} matching x and y points`);
+  for (let k = 0; k < n; k++) {
+    if (!Number.isFinite(curve.x[k]) || !Number.isFinite(curve.y[k])) throw new GameError("invalid_argument", `${what} has a non-finite point`);
+    if (k > 0 && !(curve.x[k] > curve.x[k - 1])) throw new GameError("invalid_argument", `${what} x values must increase`);
+  }
+}
+function sampleCurve(curve, x) {
+  let n = curve.x.length;
+  if (x <= curve.x[0]) return curve.y[0];
+  for (let k = 1; k < n; k++)
+    if (x < curve.x[k]) {
+      let t = (x - curve.x[k - 1]) / (curve.x[k] - curve.x[k - 1]);
+      return curve.y[k - 1] + (curve.y[k] - curve.y[k - 1]) * t;
+    }
+  return curve.y[n - 1];
+}
+function peakCurve(peakSlip, peakValue, slideSlip, slideValue) {
+  return { x: [0, peakSlip, slideSlip], y: [0, peakValue, slideValue] };
+}
+
+// src/game/physics/vehicle.ts
+var MAX_WHEELS = 16, MAX_GEARS = 8, MAX_TORQUE_POINTS = 8, MAX_CURVE_POINTS = 8, GEAR_AUTO = 100, GEAR_REVERSE = -1, GEAR_NEUTRAL = 0, NO_AXLE = -1, RAY_WHEEL = 0, STEER_LIMIT = 1.2, INPUT_THROTTLE = 0, INPUT_BRAKE = 1, INPUT_STEER = 2, INPUT_HANDBRAKE = 3, INPUT_GEAR = 4, INPUT_STRIDE = 8, STATE_SPEED = 0, STATE_RPM = 1, STATE_GEAR = 2, STATE_STEER = 3, STATE_GROUNDED = 4, STATE_SHIFTING = 5, STATE_HEADER = 8, WHEEL_CENTER = 0, WHEEL_SPIN = 3, WHEEL_STEER = 4, WHEEL_LENGTH = 5, WHEEL_GROUND = 6, WHEEL_POINT = 7, WHEEL_SLIP = 10, WHEEL_SLIP_ANGLE = 11, WHEEL_LOAD = 12, WHEEL_OMEGA = 13, WHEEL_FORCE_LONG = 14, WHEEL_FORCE_LAT = 15, WHEEL_STRIDE = 16, NO_GROUND = -1, STATE_STRIDE = (8) + (16) * (16), DESC_WHEEL_COUNT = 0, DESC_MAX_STEER = 1, DESC_STEER_RATE = 2, DESC_ANTI_ROLL = 3, DESC_DOWNFORCE = 4, DESC_DRAG = 5, DESC_ROLLING = 6, DESC_HANDBRAKE_GRIP = 7, DESC_IDLE_RPM = 8, DESC_MAX_RPM = 9, DESC_ENGINE_BRAKING = 10, DESC_TORQUE_POINTS = 11, DESC_TORQUE_RPM = 12, DESC_TORQUE = (12) + (8), DESC_GEAR_COUNT = DESC_TORQUE + (8), DESC_REVERSE = DESC_GEAR_COUNT + 1, DESC_FINAL_DRIVE = DESC_GEAR_COUNT + 2, DESC_EFFICIENCY = DESC_GEAR_COUNT + 3, DESC_SHIFT_UP = DESC_GEAR_COUNT + 4, DESC_SHIFT_DOWN = DESC_GEAR_COUNT + 5, DESC_SHIFT_SECONDS = DESC_GEAR_COUNT + 6, DESC_RATIOS = DESC_GEAR_COUNT + 7, DESC_ENGINE_INERTIA = DESC_RATIOS + (8), DESC_DIFFERENTIAL_LOCK = DESC_ENGINE_INERTIA + 1, DESC_CENTER_LOCK = DESC_ENGINE_INERTIA + 2, DESC_SKID_TORQUE = DESC_ENGINE_INERTIA + 3, DESC_LEAN_MAX = DESC_ENGINE_INERTIA + 4, DESC_LEAN_STIFFNESS = DESC_ENGINE_INERTIA + 5, DESC_LEAN_DAMPING = DESC_ENGINE_INERTIA + 6, DESC_LEAN_SPEED = DESC_ENGINE_INERTIA + 7, DESC_FORCE_HEIGHT = DESC_ENGINE_INERTIA + 8, DESC_ACKERMANN = DESC_ENGINE_INERTIA + 9, DESC_HEADER = 56, WHEEL_DESC_POSITION = 0, WHEEL_DESC_RADIUS = 3, WHEEL_DESC_INERTIA = 4, WHEEL_DESC_REST = 5, WHEEL_DESC_TRAVEL = 6, WHEEL_DESC_STIFFNESS = 7, WHEEL_DESC_COMPRESSION = 8, WHEEL_DESC_RELAXATION = 9, WHEEL_DESC_MAX_FORCE = 10, WHEEL_DESC_STEER = 11, WHEEL_DESC_DRIVE = 12, WHEEL_DESC_BRAKE = 13, WHEEL_DESC_HANDBRAKE = 14, WHEEL_DESC_GRIP = 15, WHEEL_DESC_AXLE = 16, WHEEL_DESC_SIDE = 17, CURVE_POINTS = 0, CURVE_SLIP = 1, CURVE_VALUE = (1) + (8), CURVE_WORDS = CURVE_VALUE + (8), WHEEL_DESC_LONGITUDINAL = 18, WHEEL_DESC_LATERAL = (18) + CURVE_WORDS, WHEEL_DESC_WIDTH = WHEEL_DESC_LATERAL + CURVE_WORDS, WHEEL_DESC_WORDS = 56, VEHICLE_DESC_WORDS = (56) + (16) * (56), DEFAULT_LONGITUDINAL = peakCurve(0.12, 1.1, 0.8, 0.85), DEFAULT_LATERAL = peakCurve(0.2, 1.05, 0.9, 0.8), DEFAULT_INERTIA = 1.2, DEFAULT_REST = 0.35, DEFAULT_TRAVEL = 0.15, DEFAULT_STIFFNESS = 35e3, DEFAULT_DAMPING = 3500, DEFAULT_MAX_FORCE = 4e4, DEFAULT_BRAKE = 1500, DEFAULT_ENGINE_BRAKING = 60, DEFAULT_ENGINE_INERTIA = 0.2, DEFAULT_EFFICIENCY = 0.9, DEFAULT_SHIFT_SECONDS = 0.18, DEFAULT_STEER_RATE = 3, DEFAULT_DRAG = 0.4, DEFAULT_ROLLING = 0.02, DEFAULT_HANDBRAKE_GRIP = 0.5, DEFAULT_LEAN_SPEED = 8;
+function writeCurve(out, at, curve, what) {
+  validateCurve(curve, (8), what), out[at + (0)] = curve.x.length;
+  for (let k = 0; k < curve.x.length; k++)
+    out[at + (1) + k] = curve.x[k], out[at + CURVE_VALUE + k] = curve.y[k];
+}
+function encodeVehicleDesc(desc, out = new Float32Array(VEHICLE_DESC_WORDS)) {
+  let wheels = desc.wheels.length;
+  if (wheels < 1 || wheels > (16)) throw new GameError("invalid_argument", `vehicles take 1 to ${(16)} wheels`);
+  validateCurve(desc.engine.torque, (8), "engine torque curve");
+  let forceHeight = desc.forceHeight ?? 0;
+  if (!(forceHeight >= 0 && forceHeight <= 1)) throw new GameError("invalid_argument", "forceHeight must be between 0 and 1");
+  let ackermann = desc.ackermann ?? 0;
+  if (!(ackermann >= 0 && ackermann <= 1)) throw new GameError("invalid_argument", "ackermann must be between 0 and 1");
+  let gears = desc.gearbox.ratios.length;
+  if (gears < 1 || gears > (8)) throw new GameError("invalid_argument", `gearboxes take 1 to ${(8)} ratios`);
+  out.fill(0), out[(0)] = wheels, out[(1)] = desc.maxSteerRadians, out[(2)] = desc.steerRate ?? (3), out[(3)] = desc.antiRoll ?? 0, out[(4)] = desc.downforce ?? 0, out[(5)] = desc.drag ?? (0.4), out[(6)] = desc.rollingResistance ?? (0.02), out[(7)] = desc.handbrakeGrip ?? (0.5), out[(8)] = desc.engine.idleRpm, out[(9)] = desc.engine.maxRpm, out[(10)] = desc.engine.engineBraking ?? (60), out[DESC_ENGINE_INERTIA] = desc.engine.inertia ?? (0.2);
+  let torque = desc.engine.torque;
+  out[(11)] = torque.x.length;
+  for (let k = 0; k < torque.x.length; k++)
+    out[(12) + k] = torque.x[k], out[DESC_TORQUE + k] = torque.y[k];
+  out[DESC_GEAR_COUNT] = gears, out[DESC_REVERSE] = desc.gearbox.reverse, out[DESC_FINAL_DRIVE] = desc.gearbox.finalDrive, out[DESC_EFFICIENCY] = desc.gearbox.efficiency ?? (0.9), out[DESC_SHIFT_UP] = desc.gearbox.shiftUpRpm, out[DESC_SHIFT_DOWN] = desc.gearbox.shiftDownRpm, out[DESC_SHIFT_SECONDS] = desc.gearbox.shiftSeconds ?? (0.18);
+  for (let k = 0; k < gears; k++) out[DESC_RATIOS + k] = desc.gearbox.ratios[k];
+  out[DESC_DIFFERENTIAL_LOCK] = desc.differentialLock ?? 0, out[DESC_CENTER_LOCK] = desc.centerLock ?? 0, out[DESC_SKID_TORQUE] = desc.skidTorque ?? 0, out[DESC_FORCE_HEIGHT] = desc.forceHeight ?? 0, out[DESC_ACKERMANN] = desc.ackermann ?? 0, out[DESC_LEAN_MAX] = desc.lean?.maxAngle ?? 0, out[DESC_LEAN_STIFFNESS] = desc.lean?.stiffness ?? 0, out[DESC_LEAN_DAMPING] = desc.lean?.damping ?? 0, out[DESC_LEAN_SPEED] = desc.lean?.fullSpeed ?? (8);
+  for (let w = 0; w < wheels; w++) {
+    let wheel = desc.wheels[w], at = (56) + w * (56);
+    out[at + (0)] = wheel.position[0], out[at + (0) + 1] = wheel.position[1], out[at + (0) + 2] = wheel.position[2], out[at + (3)] = wheel.radius, out[at + (4)] = wheel.inertia ?? (1.2), out[at + (5)] = wheel.restLength ?? (0.35), out[at + (6)] = wheel.travel ?? (0.15), out[at + (7)] = wheel.stiffness ?? (35e3), out[at + (8)] = wheel.compressionDamping ?? (3500), out[at + (9)] = wheel.relaxationDamping ?? wheel.compressionDamping ?? (3500), out[at + (10)] = wheel.maxSuspensionForce ?? (4e4), out[at + (11)] = wheel.steer ?? 0, out[at + (12)] = wheel.drive ?? 0, out[at + (13)] = wheel.brakeTorque ?? (1500), out[at + (14)] = wheel.handbrakeTorque ?? 0, out[at + (15)] = wheel.grip ?? 1, out[at + (16)] = wheel.axle ?? (-1), out[at + (17)] = wheel.side ?? 0, out[at + WHEEL_DESC_WIDTH] = wheel.width ?? (0), writeCurve(out, at + (18), wheel.longitudinal ?? DEFAULT_LONGITUDINAL, "longitudinal tyre curve"), writeCurve(out, at + WHEEL_DESC_LATERAL, wheel.lateral ?? DEFAULT_LATERAL, "lateral tyre curve");
+  }
+  return out;
+}
+var Vehicle = class {
+  constructor(port, id, entity, wheelCount) {
+    this.port = port, this.id = id, this.entity = entity, this.wheelCount = wheelCount, this.inputs = port.vehicleInputs(), this.states = port.vehicleStates(), this.input = id * (8), this.state = id * STATE_STRIDE;
+  }
+  refresh() {
+    this.inputs = this.port.vehicleInputs(), this.states = this.port.vehicleStates();
+  }
+  drive(throttle, brake, steer, handbrake = 0, gear = (100)) {
+    let i = this.inputs, o = this.input;
+    i[o + (0)] = throttle, i[o + (1)] = brake, i[o + (2)] = steer, i[o + (3)] = handbrake, i[o + (4)] = gear;
+  }
+  driveFrom(source, at) {
+    let i = this.inputs, o = this.input;
+    i[o + (0)] = source[at + (0)], i[o + (1)] = source[at + (1)], i[o + (2)] = source[at + (2)], i[o + (3)] = source[at + (3)], i[o + (4)] = source[at + (4)];
+  }
+  get speed() {
+    return this.states[this.state + (0)];
+  }
+  get rpm() {
+    return this.states[this.state + (1)];
+  }
+  get gear() {
+    return this.states[this.state + (2)];
+  }
+  get steer() {
+    return this.states[this.state + (3)];
+  }
+  get groundedWheels() {
+    return this.states[this.state + (4)];
+  }
+  get shifting() {
+    return this.states[this.state + (5)] !== 0;
+  }
+  wheel(index, field) {
+    return this.states[this.state + (8) + index * (16) + field];
+  }
+  get stateView() {
+    return this.states;
+  }
+  get stateOffset() {
+    return this.state;
+  }
+};
+
+// src/game/ai/types.ts
+var AI_EVENT_WORDS = 5, AI_NONE = 4294967295;
+var AI_MAX_GAME_SLOTS = 16;
+var BUILTIN_INPUTS = [
+  "focus_distance",
+  "focus_visible",
+  "focus_since_seen",
+  "focus_confidence",
+  "focus_threat",
+  "hostiles_known",
+  "allies_near",
+  "attack_token_free",
+  "action_seconds",
+  "goal_distance",
+  "lateness",
+  "best_object"
+];
+var PHASE_IDLE = 0, PHASE_WINDUP = 1, PHASE_STRIKE = 2, PHASE_RECOVER = 3, AiEventKind = {
+  actionChanged: 1,
+  focusAcquired: 2,
+  focusLost: 3,
+  heard: 4,
+  arrived: 5,
+  attackWindup: 6,
+  attackStrike: 7,
+  attackDone: 8,
+  bark: 9,
+  objectUsed: 10,
+  coverTaken: 11
+}, ENGINE_AI_EXPORT_NAMES = [
+  "engine_ai_create",
+  "engine_ai_destroy",
+  "engine_ai_registers",
+  "engine_ai_view",
+  "engine_ai_slots",
+  "engine_ai_archetype",
+  "engine_ai_spawn",
+  "engine_ai_despawn",
+  "engine_ai_target_add",
+  "engine_ai_target_remove",
+  "engine_ai_target_move",
+  "engine_ai_target_threat",
+  "engine_ai_agent_target",
+  "engine_ai_noise",
+  "engine_ai_goal",
+  "engine_ai_focus",
+  "engine_ai_skill",
+  "engine_ai_need",
+  "engine_ai_speed",
+  "engine_ai_place",
+  "engine_ai_step",
+  "engine_ai_events",
+  "engine_ai_doing",
+  "engine_ai_aim",
+  "engine_ai_digest",
+  "engine_ai_squad",
+  "engine_ai_join",
+  "engine_ai_leave",
+  "engine_ai_object_add",
+  "engine_ai_object_remove",
+  "engine_ai_cover_add",
+  "engine_ai_cover_remove"
+], ENGINE_AI_WORLD_STEP = "engine_ai_step_world";
+
+// src/game/story/engine.ts
+var STORY_REGISTER_WORDS = 20, STORY_BEAT = 0, STORY_SCENE = 1, STORY_BEAT_TICK = 2, STORY_SCENE_TICK = 4, STORY_SCENE_LENGTH = 6, STORY_FLAGS = 8, STORY_EVENT_COUNT = 9, STORY_SAMPLE_COUNT = 10;
+var STORY_DIGEST = 12, STORY_VARIABLES = 14, STORY_TICK_RATE = 15, STORY_SAMPLE_CAPACITY = 16, STORY_MAX_EVENTS = 1024, STORY_STARTED = 1, STORY_FINISHED = 2, STORY_EVENT_WORDS = 4, STORY_INPUT_WORDS = 3, STORY_SAMPLE_WORDS = 8, STORY_MAX_INPUTS = 64, STORY_PERSIST_SHIFT = 8, STORY_TYPE_MASK = 255, STORY_NONE = 4294967295, STORY_EVENT_ENTERED = 1, STORY_EVENT_OFFERED = 2, STORY_EVENT_TAKEN = 3, STORY_EVENT_REFUSED = 4, STORY_EVENT_LOGIC = 5, STORY_EVENT_KEY = 6, STORY_EVENT_FINISHED = 7, STORY_EVENT_RULE = 8, STORY_INPUT_CHOOSE = 1, STORY_INPUT_INTERACT = 2, STORY_INPUT_GIFT = 3, ENGINE_STORY_EXPORT_NAMES = [
+  "engine_story_create",
+  "engine_story_destroy",
+  "engine_story_registers",
+  "engine_story_events",
+  "engine_story_samples",
+  "engine_story_start",
+  "engine_story_step",
+  "engine_story_seek",
+  "engine_story_available",
+  "engine_story_variable",
+  "engine_story_get",
+  "engine_story_set",
+  "engine_story_set_text",
+  "engine_story_variable_text",
+  "engine_story_program_text",
+  "engine_story_text_index",
+  "engine_story_text_of",
+  "engine_story_id_of"
+], STORY_ID = 17, STORY_ID_TRACK = 4, STORY_TEXT_VARIABLE = 0, STORY_TEXT_CHOICE = 1, STORY_TEXT_BEAT = 2, STORY_TEXT_SCENE = 3, STORY_TEXT_KEY = 4, STORY_TEXT_ACTOR = 5, STORY_TEXT_RULE = 6, STORY_TEXT_ACTION = 7, NULL = 0, BYTE_ALIGN = 1, CAPACITY = -1, UNKNOWN = -3, INVALID = -4, DOUBLE_BYTES = 8, WORD_BYTES = 4, INPUT_SCRATCH_BYTES = (64) * (3) * (4), TEXT_SCRATCH_BYTES = 4096, WORD_BITS = 32n;
+function engineStoryExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_STORY_EXPORT_NAMES.every((name2) => typeof symbols[name2] == "function") ? symbols : null;
+}
+function check2(code, what) {
+  if (code >= 0) return code;
+  throw code === (-1) ? new GameError("capacity_exceeded", `the story ${what} is too large`) : code === (-3) ? new GameError("unknown_resource", `the story ${what} names nothing in this story`) : code === (-4) ? new GameError("invalid_argument", `the engine refused the story ${what}`) : new GameError("invalid_argument", `the engine refused the story ${what} (${code})`);
+}
+var EngineStory = class {
+  constructor(runtime, exports) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.inputs = (0);
+    this.text = (0);
+    this.textBytes = 0;
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder();
+  }
+  alloc(bytes, align) {
+    let at = this.runtime.exports.engine_alloc(bytes, align);
+    if (at === (0)) throw new GameError("capacity_exceeded", "engine memory cannot hold the story's working space");
+    return at;
+  }
+  textScratch(bytes) {
+    return bytes > this.textBytes && (this.text !== (0) && this.runtime.exports.engine_free(this.text, this.textBytes, (1)), this.textBytes = Math.max(bytes, (4096)), this.text = this.alloc(this.textBytes, (1))), this.text;
+  }
+  bytes() {
+    return new Uint8Array(this.runtime.memory.buffer);
+  }
+  create(program) {
+    let at = this.alloc(Math.max(program.length, 1), (1));
+    try {
+      this.bytes().set(program, at);
+      let story = this.exports.engine_story_create(at, program.length);
+      if (story === (0)) throw new GameError("invalid_argument", "the engine refused the story program");
+      return story;
+    } finally {
+      this.runtime.exports.engine_free(at, Math.max(program.length, 1), (1));
+    }
+  }
+  destroy(story) {
+    this.exports.engine_story_destroy(story);
+  }
+  start(story) {
+    check2(this.exports.engine_story_start(story), "start");
+  }
+  step(story, inputs, count) {
+    if (count > (64)) throw new GameError("capacity_exceeded", `a story step takes at most ${(64)} inputs`);
+    this.inputs === (0) && (this.inputs = this.alloc(INPUT_SCRATCH_BYTES, (4))), count > 0 && new Uint32Array(this.runtime.memory.buffer, this.inputs, count * (3)).set(inputs.subarray(0, count * (3))), check2(this.exports.engine_story_step(story, this.inputs, count), "step");
+  }
+  seek(story, tick) {
+    check2(this.exports.engine_story_seek(story, Math.round(tick)), "seek");
+  }
+  available(story, choice) {
+    return check2(this.exports.engine_story_available(story, choice), "choice") === 1;
+  }
+  variable(story, variable) {
+    return check2(this.exports.engine_story_variable(story, variable), "variable");
+  }
+  get(story, variable) {
+    return this.exports.engine_story_get(story, variable);
+  }
+  set(story, variable, value) {
+    check2(this.exports.engine_story_set(story, variable, value), "variable value");
+  }
+  setText(story, variable, text) {
+    let encoded = this.encoder.encode(text), at = this.textScratch(encoded.length);
+    this.bytes().set(encoded, at), check2(this.exports.engine_story_set_text(story, variable, at, encoded.length), "variable text");
+  }
+  readText(read, what) {
+    let length = check2(read(this.textScratch((4096)), this.textBytes), what);
+    return length > this.textBytes && (length = check2(read(this.textScratch(length), this.textBytes), what)), this.decoder.decode(this.bytes().subarray(this.text, this.text + length));
+  }
+  variableText(story, variable) {
+    return this.readText((out, capacity) => this.exports.engine_story_variable_text(story, variable, out, capacity), "variable text");
+  }
+  programText(story, index) {
+    return this.readText((out, capacity) => this.exports.engine_story_program_text(story, index, out, capacity), "text");
+  }
+  textIndex(story, text) {
+    let encoded = this.encoder.encode(text), at = this.textScratch(encoded.length);
+    this.bytes().set(encoded, at);
+    let index = this.exports.engine_story_text_index(story, at, encoded.length);
+    return index === (-3) ? (4294967295) : check2(index, "text");
+  }
+  textOf(story, what, index, key) {
+    let at = this.exports.engine_story_text_of(story, what, index, key);
+    return at === (-3) ? (4294967295) : check2(at, "text");
+  }
+  idOf(story, what, index) {
+    let code = this.exports.engine_story_id_of(story, what, index);
+    if (code === (-3)) return null;
+    check2(code, "id");
+    let registers = new Uint32Array(this.runtime.memory.buffer, this.exports.engine_story_registers(story), (20));
+    return (BigInt(registers[(17) + 1]) << WORD_BITS | BigInt(registers[(17)])).toString();
+  }
+  buffer() {
+    return this.runtime.memory.buffer;
+  }
+  views(story) {
+    let buffer = this.runtime.memory.buffer, registers = new Uint32Array(buffer, this.exports.engine_story_registers(story), (20)), samples = this.exports.engine_story_samples(story);
+    if (samples % (8) !== 0) throw new GameError("invalid_argument", "the engine's story samples are misaligned");
+    return {
+      registers,
+      events: new Uint32Array(buffer, this.exports.engine_story_events(story), (1024) * (4)),
+      samples: samples === (0) ? new Float64Array(0) : new Float64Array(buffer, samples, registers[(16)] * (8))
+    };
+  }
+};
+
+export { AGENT_ARRIVED, AGENT_IDLE, AGENT_LOST, AGENT_MOVING, AGENT_ON_LINK, AGENT_REQUESTING, AGENT_STRIDE, AGENT_X, AIR_DENSITY, AI_EVENT_WORDS, AI_MAX_GAME_SLOTS, AI_NONE, AiEventKind, BOAT_SHEET, BOAT_STEER, BOAT_THROTTLE, BUILTIN_INPUTS, Basis, CRAFT_CHANNELS, CRAFT_PRESETS, CRAFT_TELEMETRY_WORDS, CURVE_POINTS, CURVE_SLIP, CURVE_VALUE, ContactRuleTable, DEFAULT_COLLIDER_CLASS, DEFAULT_EXTENTS, DESC_ACKERMANN, DESC_ANTI_ROLL, DESC_CENTER_LOCK, DESC_DIFFERENTIAL_LOCK, DESC_DOWNFORCE, DESC_DRAG, DESC_EFFICIENCY, DESC_ENGINE_BRAKING, DESC_ENGINE_INERTIA, DESC_FINAL_DRIVE, DESC_FORCE_HEIGHT, DESC_GEAR_COUNT, DESC_HANDBRAKE_GRIP, DESC_HEADER, DESC_IDLE_RPM, DESC_LEAN_DAMPING, DESC_LEAN_MAX, DESC_LEAN_SPEED, DESC_LEAN_STIFFNESS, DESC_MAX_RPM, DESC_MAX_STEER, DESC_RATIOS, DESC_REVERSE, DESC_ROLLING, DESC_SHIFT_DOWN, DESC_SHIFT_SECONDS, DESC_SHIFT_UP, DESC_SKID_TORQUE, DESC_STEER_RATE, DESC_TORQUE, DESC_TORQUE_POINTS, DESC_TORQUE_RPM, DESC_WHEEL_COUNT, ENGINE_AI_EXPORT_NAMES, ENGINE_AI_WORLD_STEP, EngineStory, FLIGHT_BRAKE, FLIGHT_FLAPS, FLIGHT_GEAR, FLIGHT_PITCH, FLIGHT_ROLL, FLIGHT_THROTTLE, FLIGHT_TILT, FLIGHT_YAW, GEAR_AUTO, GEAR_NEUTRAL, GEAR_REVERSE, INPUT_BRAKE, INPUT_GEAR, INPUT_HANDBRAKE, INPUT_STEER, INPUT_STRIDE, INPUT_THROTTLE, MAX_AERO_TABLE, MAX_COLLIDER_CLASSES, MAX_CORNERS, MAX_CRAFT_WHEELS, MAX_FOILS, MAX_HULL_POINTS, MAX_HULL_RESOLUTION, MAX_ROTORS, MAX_THRUSTERS, MAX_WAVES, MAX_WHEELS, NO_AXLE, NO_CHANNEL, NO_CONTACT_RULE, NO_GROUND, NO_LINK, NativeKernels, PHASE_IDLE, PHASE_RECOVER, PHASE_STRIKE, PHASE_WINDUP, PI, POSE_DIR_X, POSE_DIR_Z, POSE_LANE, POSE_SPEED, POSE_STRIDE, POSE_X, POSE_Z, PlainSpawns, ROTOR_COLLECTIVE, ROTOR_CYCLIC_PITCH, ROTOR_CYCLIC_ROLL, ROTOR_ENGINE, ROTOR_PEDAL, RULE_FRICTION, RULE_IGNORE, RULE_ONE_WAY, RULE_RESTITUTION, SEA_STATES, SIGNAL_AMBER, SIGNAL_GREEN, SIGNAL_RED, STATE_GEAR, STATE_GROUNDED, STATE_HEADER, STATE_RPM, STATE_SHIFTING, STATE_SPEED, STATE_STEER, STATE_STRIDE, STEER_LIMIT, STORY_BEAT, STORY_BEAT_TICK, STORY_DIGEST, STORY_EVENT_COUNT, STORY_EVENT_ENTERED, STORY_EVENT_FINISHED, STORY_EVENT_KEY, STORY_EVENT_LOGIC, STORY_EVENT_OFFERED, STORY_EVENT_REFUSED, STORY_EVENT_RULE, STORY_EVENT_TAKEN, STORY_EVENT_WORDS, STORY_FINISHED, STORY_FLAGS, STORY_ID_TRACK, STORY_INPUT_CHOOSE, STORY_INPUT_GIFT, STORY_INPUT_INTERACT, STORY_INPUT_WORDS, STORY_MAX_INPUTS, STORY_NONE, STORY_PERSIST_SHIFT, STORY_SAMPLE_COUNT, STORY_SAMPLE_WORDS, STORY_SCENE, STORY_SCENE_LENGTH, STORY_SCENE_TICK, STORY_STARTED, STORY_TEXT_ACTION, STORY_TEXT_ACTOR, STORY_TEXT_BEAT, STORY_TEXT_CHOICE, STORY_TEXT_KEY, STORY_TEXT_RULE, STORY_TEXT_SCENE, STORY_TEXT_VARIABLE, STORY_TICK_RATE, STORY_TYPE_MASK, STORY_VARIABLES, TAU, TELEMETRY_AIRSPEED, TELEMETRY_ALPHA, TELEMETRY_APPARENT_WIND, TELEMETRY_BANK, TELEMETRY_CLIMB, TELEMETRY_CONTACTS, TELEMETRY_GEAR, TELEMETRY_GROUND_EFFECT, TELEMETRY_PITCH, TELEMETRY_PLANING, TELEMETRY_ROTOR, TELEMETRY_SPEED, TELEMETRY_SPOOL, TELEMETRY_STALLED, TELEMETRY_SUBMERGED, TELEMETRY_THRUST, TableSpawns, VEHICLE_DESC_WORDS, Vehicle, WATER_SAMPLE_WORDS, WHEEL_CENTER, WHEEL_DESC_AXLE, WHEEL_DESC_BRAKE, WHEEL_DESC_COMPRESSION, WHEEL_DESC_DRIVE, WHEEL_DESC_GRIP, WHEEL_DESC_HANDBRAKE, WHEEL_DESC_INERTIA, WHEEL_DESC_LATERAL, WHEEL_DESC_LONGITUDINAL, WHEEL_DESC_MAX_FORCE, WHEEL_DESC_POSITION, WHEEL_DESC_RADIUS, WHEEL_DESC_RELAXATION, WHEEL_DESC_REST, WHEEL_DESC_SIDE, WHEEL_DESC_STEER, WHEEL_DESC_STIFFNESS, WHEEL_DESC_TRAVEL, WHEEL_DESC_WORDS, WHEEL_FORCE_LAT, WHEEL_FORCE_LONG, WHEEL_GROUND, WHEEL_LENGTH, WHEEL_LOAD, WHEEL_OMEGA, WHEEL_POINT, WHEEL_SLIP, WHEEL_SLIP_ANGLE, WHEEL_SPIN, WHEEL_STEER, WHEEL_STRIDE, Water, WaterSample, atan2, bindKernelEngine, checkColliderClass, compileWasmKernel, constant, encodeVehicleDesc, engineStoryExports, kernelEngineFeatures, mix, mixWith, packContactRuleHeader, peakCurve, reportSpawns, sampleCurve, seaDesc, sinCos, spawnOverflow, validateCurve, wasmKernelImports, wrapAngle, writeContactRulePayload };