@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-7AAIAVAA.js

@@ -0,0 +1,1531 @@
+'use strict';
+
+var chunkX5A5FOWW_js = require('./chunk-X5A5FOWW.js');
+var chunkIR74FJHU_js = require('./chunk-IR74FJHU.js');
+var chunk2O2CG465_js = require('./chunk-2O2CG465.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/kernel/compute.ts
+var ENGINE_COMPUTE_EXPORT_NAMES = ["engine_compute_frame", "engine_compute_priority", "engine_compute_registers", "engine_compute_clear"], KERNEL_PRIORITIES = ["simulation", "presentation", "optional"], PRIORITY_LEVEL = { simulation: 0, presentation: 1, optional: 2 };
+function priorityLevel(priority) {
+  return priority === void 0 ? 0 : PRIORITY_LEVEL[priority];
+}
+var COMPUTE_SPACE_CPU = 0, COMPUTE_SPACE_GPU = 1, COMPUTE_DEFERRED = -7, COMPUTE_STOPPED = -8, COMPUTE_HEADER_WORDS = 16, COMPUTE_DIAGNOSTIC_WORDS = 8, COMPUTE_DIAGNOSTIC_CAPACITY = 32, COMPUTE_REGISTER_WORDS = (16) + (32) * (8), REG_CPU_BUDGET_NS = 1, REG_CPU_SPENT_NS = 2, REG_DEFERRED = 5, REG_STOPPED = 6, REG_COUNT = 8, DIAG_CODE = 0, DIAG_SPACE = 1, DIAG_BINDING = 2, DIAG_ROUTE = 4, DIAG_NS = 5, DIAG_ROWS = 6, DIAG_FRAME = 7, NANOS_PER_MS = 1e6, MAX_TIER = 2, SPACE_SHIFT = 2 ** 32, CPU_SLOT_MASK = 1023;
+function keyOf(space, binding) {
+  return space * SPACE_SHIFT + (space === (0) ? binding & (1023) : binding);
+}
+var CODES = [null, "frame_over", "kernel_heavy", "kernel_deferred", "kernel_stopped", "gpu_deferred", "gpu_stall"], ROUTES = ["interpreter", "jit", "prebuilt", "native", "gpu"], MESSAGES = {
+  frame_over: "Kernels used more time this frame than some phones can spare.",
+  kernel_heavy: "This kernel is too heavy for some phones.",
+  kernel_deferred: "This kernel waited for the next frame so the game stays smooth.",
+  kernel_stopped: "This kernel ran too long and was stopped so the game stays responsive.",
+  gpu_deferred: "This GPU kernel waited for the next frame so the game stays smooth.",
+  gpu_stall: "GPU work took longer than a frame."
+};
+function computeLogLine(d) {
+  let who = d.kernel === null ? "" : ` kernel ${d.kernel}`, rows = d.rows > 0 ? ` on ${d.rows} rows` : "";
+  return `[compute ${d.code}]${who} ${d.ms.toFixed(2)} ms${rows} via ${d.route}: ${d.message}`;
+}
+function decodeComputeDiagnostics(registers, names) {
+  let out = [], count = Math.min(registers[(8)], (32));
+  for (let k = 0; k < count; k++) {
+    let at = (16) + k * (8), code = CODES[registers[at + (0)]] ?? null;
+    code !== null && out.push({
+      code,
+      kernel: names(registers[at + (1)], registers[at + (2)]),
+      route: ROUTES[registers[at + (4)]] ?? "interpreter",
+      ms: registers[at + (5)] / (1e6),
+      rows: registers[at + (6)],
+      frame: registers[at + (7)],
+      message: MESSAGES[code]
+    });
+  }
+  return out;
+}
+var ComputeMonitor = class _ComputeMonitor {
+  constructor(exports, memory) {
+    this.exports = exports;
+    this.memory = memory;
+    this.names = /* @__PURE__ */ new Map();
+    this.kernels = /* @__PURE__ */ new Map();
+    this.levels = /* @__PURE__ */ new Map();
+    this.view = new Uint32Array(0);
+    this.readout = { budgetMs: 0, spentMs: 0, deferred: 0, stopped: 0 };
+    this.nameOf = (space, binding) => this.names.get(keyOf(space, binding)) ?? null;
+    this.onBound = null;
+  }
+  get last() {
+    return this.readout;
+  }
+  static bind(symbols, memory) {
+    for (let name of ENGINE_COMPUTE_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+    return new _ComputeMonitor(symbols, memory);
+  }
+  bound(space, binding, kernel, priority) {
+    let key = keyOf(space, binding);
+    this.names.set(key, kernel), this.kernels.set(key, [space, binding, kernel]), this.levels.set(key, 0), this.prioritise(space, binding, priority), this.onBound?.(space, binding, kernel);
+  }
+  unbound(space, binding) {
+    let key = keyOf(space, binding);
+    this.names.delete(key), this.kernels.delete(key), this.levels.delete(key);
+  }
+  boundKernels() {
+    return this.kernels.values();
+  }
+  prioritise(space, binding, priority) {
+    let key = keyOf(space, binding);
+    (this.levels.get(key) ?? 0) !== priority && this.exports.engine_compute_priority(space, binding, priority) >= 0 && this.levels.set(key, priority);
+  }
+  frame(tier, frameMicros, sink) {
+    this.exports.engine_compute_frame(Math.min(Math.max(Math.trunc(tier), 0), (2)), Math.max(Math.trunc(frameMicros), 0));
+    let at = this.exports.engine_compute_registers();
+    if (at === 0) return;
+    let buffer = this.memory.buffer;
+    (this.view.buffer !== buffer || this.view.byteOffset !== at) && (this.view = new Uint32Array(buffer, at, COMPUTE_REGISTER_WORDS));
+    let registers = this.view, readout = this.readout;
+    if (readout.budgetMs = registers[(1)] / (1e6), readout.spentMs = registers[(2)] / (1e6), readout.deferred = registers[(5)], readout.stopped = registers[(6)], registers[(8)] === 0) return;
+    let found = decodeComputeDiagnostics(registers, this.nameOf);
+    this.exports.engine_compute_clear();
+    for (let diagnostic of found) sink(diagnostic);
+  }
+};
+
+// src/game/kernel/events.ts
+var TRUE_BITS = 4294967295, channels = /* @__PURE__ */ new Map(), currentRow = -1;
+function setEmitRow(row) {
+  currentRow = row;
+}
+function emitRow() {
+  return currentRow;
+}
+var EventChannel = class {
+  constructor(name, fields, capacity) {
+    this.name = name;
+    this.fields = fields;
+    this.capacity = capacity;
+    this.count = 0;
+    this.lost = 0;
+    this.at = 0;
+    if (this.names = Object.keys(fields), this.kinds = this.names.map((n) => fields[n]), this.names.length > 8) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `events carry at most ${8} fields`);
+    this.ring = new Uint32Array(capacity * 10), this.floats = new Float32Array(this.ring.buffer), this.ints = new Int32Array(this.ring.buffer);
+    let event = {}, channel = this;
+    Object.defineProperty(event, "row", { get: () => channel.ring[channel.at + 1], enumerable: true }), this.names.forEach((name2, k) => {
+      let word = 2 + k, kind = this.kinds[k];
+      Object.defineProperty(event, name2, {
+        get: () => kind === "f32" ? channel.floats[channel.at + word] : kind === "i32" ? channel.ints[channel.at + word] : kind === "bool" ? channel.ring[channel.at + word] !== 0 : channel.ring[channel.at + word],
+        enumerable: true
+      });
+    }), this.event = Object.freeze(event);
+  }
+  get pending() {
+    return this.count;
+  }
+  get dropped() {
+    return this.lost;
+  }
+  emit(payload) {
+    let values = payload;
+    if (this.count >= this.capacity) {
+      this.lost++;
+      return;
+    }
+    let at = this.count * 10;
+    this.ring[at + 1] = currentRow >>> 0;
+    for (let k = 0; k < this.names.length; k++) {
+      let value = values[this.names[k]], word = at + 2 + k, kind = this.kinds[k];
+      kind === "f32" ? this.floats[word] = value : kind === "bool" ? this.ring[word] = value ? (4294967295) : 0 : this.ring[word] = value >>> 0;
+    }
+    this.count++;
+  }
+  accept(source, entry) {
+    if (this.count >= this.capacity) {
+      this.lost++;
+      return;
+    }
+    this.ring.set(source.subarray(entry, entry + 10), this.count * 10), this.count++;
+  }
+  addLost(count) {
+    this.lost += count;
+  }
+  drain(visit) {
+    let total = this.count;
+    for (let k = 0; k < total; k++)
+      this.at = k * 10, visit(this.event);
+    return this.count = 0, this.lost = 0, total;
+  }
+};
+function events(name, fields, capacity = chunkIR74FJHU_js.DEFAULT_EVENT_CAPACITY) {
+  if (channels.has(name)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `an event channel named ${name} already exists`);
+  let channel = new EventChannel(name, fields, capacity);
+  return channels.set(name, channel), channel;
+}
+function registerChannel(channel) {
+  if (channels.has(channel.name)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `an event channel named ${channel.name} already exists`);
+  channels.set(channel.name, channel);
+}
+function routeEvents(ring, metas) {
+  let count = ring[chunkIR74FJHU_js.RING_COUNT], dropped = ring[chunkIR74FJHU_js.RING_DROPPED];
+  if (!(metas === void 0 || count === 0 && dropped === 0)) {
+    for (let k = 0; k < count; k++) {
+      let entry = chunkIR74FJHU_js.RING_HEADER_WORDS + k * 10, meta = metas[ring[entry]];
+      (meta === void 0 ? void 0 : channels.get(meta.name))?.accept(ring, entry);
+    }
+    if (dropped > 0) for (let meta of metas) channels.get(meta.name)?.addLost(dropped);
+  }
+}
+
+// src/game/kernel/joins.ts
+var NO_REF = 4294967295;
+function symbol2(name) {
+  return chunkIR74FJHU_js.symbol(name);
+}
+function pickRows(n, when, seed, tick, weight) {
+  throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "pickRows() runs inside compiled kernels; build the game (cimplify build or cimplify dev) so the kernel has bytecode");
+}
+function list(kind, capacity) {
+  if (!Number.isInteger(capacity) || capacity < 1 || capacity > chunkIR74FJHU_js.DATA_LIST_MAX) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `lists hold 1..${chunkIR74FJHU_js.DATA_LIST_MAX} elements per row`);
+  return Object.freeze({ at: "u32", len: "u32" });
+}
+var pools = /* @__PURE__ */ new WeakMap(), poolEngine = null, WORD_BYTES = 4;
+function setPoolEngine(engine) {
+  poolEngine = engine;
+}
+function poolEntry(table, field, capacity, kind, component) {
+  let byField = pools.get(table);
+  byField === void 0 && (byField = /* @__PURE__ */ new Map(), pools.set(table, byField));
+  let key = `${field}#${component}`, words = table.capacity * capacity, entry = byField.get(key);
+  if (entry === void 0 || entry.words !== words || entry.kind !== kind) {
+    let engine = table.native ? poolEngine : null, at = engine === null ? 0 : engine.alloc(words * (4));
+    if (engine !== null && at === 0) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `engine memory cannot hold the ${field} list pool`);
+    at !== 0 && engine !== null && new Uint32Array(engine.memory.buffer, at, words).fill(0), entry = { at, words, kind, array: null }, byField.set(key, entry);
+  }
+  return entry;
+}
+function view(entry) {
+  if (entry.at === 0)
+    return entry.array ?? (entry.array = entry.kind === "f32" ? new Float32Array(entry.words) : entry.kind === "i32" ? new Int32Array(entry.words) : new Uint32Array(entry.words)), entry.array;
+  let buffer = poolEngine.memory.buffer;
+  return (entry.array === null || entry.array.buffer !== buffer) && (entry.array = entry.kind === "f32" ? new Float32Array(buffer, entry.at, entry.words) : entry.kind === "i32" ? new Int32Array(buffer, entry.at, entry.words) : new Uint32Array(buffer, entry.at, entry.words)), entry.array;
+}
+function listPool(table, field, capacity, kind = "u32", component = 0) {
+  return view(poolEntry(table, field, capacity, kind === "bool" ? "u32" : kind, component));
+}
+function listPoolAddress(table, field, capacity, kind = "u32", component = 0) {
+  let entry = poolEntry(table, field, capacity, kind === "bool" ? "u32" : kind, component);
+  return { at: entry.at, words: entry.words };
+}
+function readDataReport(meta, words) {
+  let tallies = {};
+  (meta.data?.tallies ?? []).forEach((name, k) => {
+    tallies[name] = words[k];
+  });
+  let sites = words[chunkIR74FJHU_js.DATA_TALLIES + 5], picks = [], at = chunkIR74FJHU_js.DATA_TALLIES + 6 + sites;
+  for (let site = 0; site < sites; site++) {
+    let n = words[chunkIR74FJHU_js.DATA_TALLIES + 6 + site];
+    picks.push(words.slice(at, at + n)), at += n;
+  }
+  let t = chunkIR74FJHU_js.DATA_TALLIES;
+  return { picks, tallies, commands: { sent: words[t], applied: words[t + 1], dropped: words[t + 2], overflow: words[t + 3] }, unplaced: words[t + 4] };
+}
+var STORAGE = { f32: 0, i32: 1, u32: 2, u8: 3, vec2: 0, vec3: 0, vec4: 0 };
+function column(table, field, component, kernel) {
+  if (!(field in table.schema)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `kernel ${kernel} reads ${field}, which its table does not have`);
+  return { values: table.values(field, component), storage: STORAGE[table.schema[field]] };
+}
+function readList(table, field, capacity, row, kind = "u32") {
+  let at = column(table, `${field}.at`, 0, "readList"), len = column(table, `${field}.len`, 0, "readList"), pool = listPool(table, field, capacity, kind), sweep = new chunkIR74FJHU_js.ListSweep(0, 0, 0, capacity);
+  sweep.bind(table.capacity), sweep.run(at, len, 2, table.count);
+  let base = chunkIR74FJHU_js.readAs(2, at.storage, at.values[row]), n = chunkIR74FJHU_js.readAs(2, len.storage, len.values[row]);
+  return base === 0 ? [] : Array.from(pool.subarray(base - 1, base - 1 + n));
+}
+function isTable(value) {
+  return typeof value == "object" && value !== null && "schema" in value && "capacity" in value && "values" in value;
+}
+function hasData(meta) {
+  if (meta.data !== void 0) return true;
+  let slots = meta.slots;
+  for (let k = 0; k < slots.length; k++) if (slots[k].table !== void 0) return true;
+  return false;
+}
+function dataTables(meta, own, args) {
+  let tables = [own];
+  for (let t of meta.data?.tables ?? []) {
+    let value = args[t.position];
+    if (!isTable(value)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `kernel ${meta.name} takes the table for ${t.name} as argument ${t.position + 1}; pass an entity table`);
+    tables[t.table] = value;
+  }
+  return tables;
+}
+function scalarArgs(meta, args) {
+  let skip = new Set((meta.data?.tables ?? []).map((t) => t.position));
+  return args.filter((_, k) => !skip.has(k));
+}
+function dataColumn(meta, tables, slot) {
+  if (slot.table === void 0) return null;
+  let table = tables[slot.table];
+  return slot.pool !== void 0 ? { values: listPool(table, slot.field, slot.pool, slot.kind, slot.component), storage: slot.kind === "f32" ? 0 : slot.kind === "i32" ? 1 : 2 } : column(table, slot.field, slot.component, meta.name);
+}
+function bindData(machine, meta, tables, columns, bound) {
+  for (let t of meta.data?.tables ?? []) {
+    let table = tables[t.table];
+    bound.get(t.table) !== table.capacity && (machine.bindTable(t.table, table.capacity), bound.set(t.table, table.capacity)), machine.setCount(t.table, table.count);
+  }
+  meta.slots.forEach((slot, k) => {
+    slot.pool !== void 0 && bound.get(-1 - k) !== columns[k].values.length && (machine.bindPool(k, columns[k].values.length), bound.set(-1 - k, columns[k].values.length));
+  });
+}
+function reportData(machine, meta) {
+  let tallies = {};
+  return (meta.data?.tallies ?? []).forEach((name, k) => {
+    tallies[name] = machine.tallies[k];
+  }), {
+    picks: Array.from({ length: meta.data?.picks ?? 0 }, (_, k) => machine.pickRows(k).slice()),
+    tallies,
+    commands: { ...machine.stats },
+    unplaced: machine.unplaced
+  };
+}
+var bits = new Uint32Array(1), floats = new Float32Array(bits.buffer), Queue = class extends EventChannel {
+  constructor(name, fields, table) {
+    super(name, fields, table.capacity);
+    this.table = table;
+    this.overflow = 0;
+    for (let field of Object.keys(fields))
+      if (!(field in table.schema)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `queue ${name} needs a ${field} column in its table`);
+  }
+  accept(source, entry) {
+    let table = this.table;
+    if (table.count >= table.capacity) {
+      this.overflow++;
+      return;
+    }
+    let row = table.spawn();
+    this.names.forEach((name, k) => {
+      let raw = source[entry + 2 + k], values = table.values(name), kind = this.kinds[k];
+      kind === "f32" ? (bits[0] = raw, values[row] = floats[0]) : kind === "i32" ? values[row] = raw | 0 : kind === "bool" ? values[row] = raw !== 0 ? 1 : 0 : values[row] = raw >>> 0;
+    });
+  }
+  emit(payload) {
+    let table = this.table;
+    if (table.count >= table.capacity) {
+      this.overflow++;
+      return;
+    }
+    let row = table.spawn(), values = payload;
+    for (let name of this.names) {
+      let value = values[name];
+      table.values(name)[row] = typeof value == "boolean" ? value ? 1 : 0 : value;
+    }
+  }
+  push(payload) {
+    this.emit(payload);
+  }
+  get dropped() {
+    return super.dropped + this.overflow;
+  }
+  clear() {
+    this.table.count = 0, this.overflow = 0;
+  }
+};
+function queue(name, fields, table) {
+  let q = new Queue(name, fields, table);
+  return registerChannel(q), q;
+}
+
+// src/game/kernel/wide.ts
+var MASK64 = (1n << 64n) - 1n, MASK32 = 0xffffffffn;
+function f64(x) {
+  return typeof x == "bigint" ? Number(BigInt.asUintN(64, x)) : typeof x == "boolean" ? x ? 1 : 0 : x;
+}
+function u64(x) {
+  return typeof x == "bigint" ? BigInt.asUintN(64, x) : typeof x == "boolean" ? x ? 1n : 0n : chunkIR74FJHU_js.toUint64(x);
+}
+function toU32(x) {
+  return typeof x == "bigint" ? Number(BigInt.asUintN(64, x) & MASK32) : typeof x == "boolean" ? x ? 1 : 0 : chunkIR74FJHU_js.toUint32(x);
+}
+function f64Bits(lo, hi) {
+  return chunkIR74FJHU_js.joinF64(lo, hi);
+}
+function u64Words(lo, hi) {
+  return chunkIR74FJHU_js.joinU64(lo, hi);
+}
+var argView = new Float64Array(1), argHalves = new Uint32Array(argView.buffer);
+function writeWideArg(words, at, kind, value) {
+  if (kind === "u64") {
+    let v = typeof value == "bigint" ? BigInt.asUintN(64, value) : chunkIR74FJHU_js.toUint64(Number(value));
+    return words[at] = Number(v & MASK32), words[at + 1] = Number(v >> 32n), at + 2;
+  }
+  argView[0] = typeof value == "bigint" ? Number(value) : value;
+  let nan = Number.isNaN(argView[0]);
+  return words[at] = nan ? 0 : argHalves[0], words[at + 1] = nan ? 2146959360 : argHalves[1], at + 2;
+}
+function width(x) {
+  return typeof x == "bigint" ? 64 : 32;
+}
+function big(x) {
+  return typeof x == "bigint" ? BigInt.asUintN(64, x) : BigInt(x >>> 0);
+}
+function back(like, v) {
+  return typeof like == "bigint" ? v & MASK64 : Number(v & MASK32);
+}
+function ones(n, bits2) {
+  return n >= bits2 ? (1n << BigInt(bits2)) - 1n : (1n << BigInt(Math.max(0, n))) - 1n;
+}
+function popcnt(x) {
+  let v = big(x), n = 0;
+  for (; v > 0n; )
+    n += Number(v & 1n), v >>= 1n;
+  return n;
+}
+function clz(x) {
+  let bits2 = width(x), v = big(x), n = 0;
+  for (let k = bits2 - 1; k >= 0 && (v >> BigInt(k) & 1n) === 0n; k--) n++;
+  return n;
+}
+function ctz(x) {
+  let bits2 = width(x), v = big(x), n = 0;
+  for (let k = 0; k < bits2 && (v >> BigInt(k) & 1n) === 0n; k++) n++;
+  return n;
+}
+function rotl(x, by) {
+  let bits2 = width(x), s = BigInt(by & bits2 - 1), v = big(x);
+  return back(x, (v << s | v >> BigInt(bits2) - s) & ones(bits2, bits2));
+}
+function rotr(x, by) {
+  let bits2 = width(x);
+  return rotl(x, bits2 - (by & bits2 - 1) & bits2 - 1);
+}
+function bitExtract(x, offset, count) {
+  let bits2 = width(x);
+  return back(x, big(x) >> BigInt(offset & bits2 - 1) & ones(count >>> 0, bits2));
+}
+function bitInsert(base, value, offset, count) {
+  let bits2 = width(base), at = BigInt(offset & bits2 - 1), field = ones(count >>> 0, bits2) << at;
+  return back(base, (big(base) & ~field | big(value) << at & field) & ones(bits2, bits2));
+}
+function spread(v, bits2, step) {
+  let out = 0n;
+  for (let k = 0; k < bits2; k++) out |= (v >> BigInt(k) & 1n) << BigInt(k * step);
+  return out;
+}
+function gather(v, bits2, step, at) {
+  let out = 0n;
+  for (let k = 0; k < bits2; k++) out |= (v >> BigInt(k * step + at) & 1n) << BigInt(k);
+  return Number(out);
+}
+function morton2(x, y) {
+  return Number(spread(big(x), 16, 2) | spread(big(y), 16, 2) << 1n);
+}
+function morton3(x, y, z) {
+  return Number(spread(big(x), 10, 3) | spread(big(y), 10, 3) << 1n | spread(big(z), 10, 3) << 2n);
+}
+function morton2Wide(x, y) {
+  return spread(big(x), 32, 2) | spread(big(y), 32, 2) << 1n;
+}
+function morton3Wide(x, y, z) {
+  return spread(big(x), 21, 3) | spread(big(y), 21, 3) << 1n | spread(big(z), 21, 3) << 2n;
+}
+function unmorton2(code) {
+  let bits2 = typeof code == "bigint" ? 32 : 16, v = big(code);
+  return { x: gather(v, bits2, 2, 0), y: gather(v, bits2, 2, 1) };
+}
+function unmorton3(code) {
+  let bits2 = typeof code == "bigint" ? 21 : 10, v = big(code);
+  return { x: gather(v, bits2, 3, 0), y: gather(v, bits2, 3, 1), z: gather(v, bits2, 3, 2) };
+}
+
+// src/game/fluid/engine.ts
+var FLUID_DESC_FLOATS = 18, FLUID_SURFACE_FLOATS = 17, FLUID_EMITTER_FLOATS = 12, FLUID_COLLIDER_FLOATS = 19, FLUID_COLLIDER_VOLUME = 18, FLUID_MAX_COLLIDERS = 64;
+var FLUID_MAX_EMITTERS = 8, FLUID_FORCE_WORDS = 6, FLUID_FORCE_FLOATS = (64) * (6), FLUID_CAP_SIMULATION = 1, FLUID_CAP_SURFACE = 2, ENGINE_FLUID_EXPORT_NAMES = [
+  "engine_fluid_caps",
+  "engine_fluid_create",
+  "engine_fluid_destroy",
+  "engine_fluid_parameters",
+  "engine_fluid_surface",
+  "engine_fluid_emitter",
+  "engine_fluid_colliders",
+  "engine_fluid_step",
+  "engine_fluid_pause",
+  "engine_fluid_clear",
+  "engine_fluid_count",
+  "engine_fluid_forces",
+  "engine_fluid_volume",
+  "engine_fluid_volume_info",
+  "engine_fluid_volumes_clear"
+], NULL = 0, F32_BYTES = 4, U32_BYTES = 4, MICROS = 1e6, SCRATCH_FLOATS = (19) * (64) + FLUID_FORCE_FLOATS;
+function engineFluidExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_FLUID_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var EngineFluids = class {
+  constructor(runtime, exports, render) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.pointer = (0);
+    this.buffer = null;
+    this.floats = new Float32Array(0);
+    this.caps = exports.engine_fluid_caps();
+  }
+  scratch() {
+    if (this.pointer === (0) && (this.pointer = this.runtime.exports.engine_alloc(SCRATCH_FLOATS * (4), chunk2O2CG465_js.COLUMN_ALIGN), this.pointer === (0)))
+      throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold fluid parameters");
+    let buffer = this.runtime.memory.buffer;
+    return buffer !== this.buffer && (this.buffer = buffer, this.floats = new Float32Array(buffer)), this.pointer;
+  }
+  put(values, count = values.length) {
+    let pointer = this.scratch();
+    return this.floats.set(values.subarray(0, count), pointer >>> 2), pointer;
+  }
+  check(code, what) {
+    if (!(code >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the fluid ${what} (${code})`);
+    return code;
+  }
+  create(desc, surface) {
+    let descPointer = this.put(desc), surfacePointer = descPointer + (18) * (4);
+    return this.floats.set(surface, surfacePointer >>> 2), this.check(this.exports.engine_fluid_create(this.render(), descPointer, surfacePointer), "description");
+  }
+  destroy(fluid) {
+    this.exports.engine_fluid_destroy(this.render(), fluid);
+  }
+  parameters(fluid, desc) {
+    this.check(this.exports.engine_fluid_parameters(this.render(), fluid, this.put(desc)), "parameters");
+  }
+  surface(fluid, surface) {
+    this.check(this.exports.engine_fluid_surface(this.render(), fluid, this.put(surface)), "surface");
+  }
+  emitter(fluid, index, emitter) {
+    this.check(this.exports.engine_fluid_emitter(this.render(), fluid, index, this.put(emitter)), "emitter");
+  }
+  colliders(fluid, colliders, count) {
+    this.check(this.exports.engine_fluid_colliders(this.render(), fluid, this.put(colliders, count * (19)), count), "colliders");
+  }
+  step(fluid, seconds) {
+    this.exports.engine_fluid_step(this.render(), fluid, Math.max(0, Math.round(seconds * (1e6))));
+  }
+  pause(fluid, paused) {
+    this.exports.engine_fluid_pause(this.render(), fluid, paused ? 1 : 0);
+  }
+  clear(fluid) {
+    this.exports.engine_fluid_clear(this.render(), fluid);
+  }
+  count(fluid) {
+    return Math.max(0, this.exports.engine_fluid_count(this.render(), fluid));
+  }
+  forces(fluid, out) {
+    let pointer = this.scratch() + (19) * (64) * (4);
+    if (!(this.exports.engine_fluid_forces(this.render(), fluid, pointer) >= 0)) return;
+    let at = pointer >>> 2;
+    for (let i = 0; i < FLUID_FORCE_FLOATS; i++) out[i] = this.floats[at + i];
+  }
+  volume(fluid, positions, indices, resolution, padding) {
+    let vertices = Math.floor(positions.length / 3), triangles = Math.floor(indices.length / 3), positionBytes = vertices * 3 * (4), indexBytes = triangles * 3 * (4), bytes = positionBytes + indexBytes, block = this.runtime.exports.engine_alloc(bytes, chunk2O2CG465_js.COLUMN_ALIGN);
+    if (block === (0)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold the collider mesh");
+    try {
+      let memory = this.runtime.memory.buffer;
+      new Float32Array(memory, block, vertices * 3).set(positions.subarray(0, vertices * 3)), new Uint32Array(memory, block + positionBytes, triangles * 3).set(indices.subarray(0, triangles * 3));
+      let index = this.check(
+        this.exports.engine_fluid_volume(this.render(), fluid, block, vertices, block + positionBytes, triangles, resolution, padding),
+        "collider mesh"
+      ), info = this.scratch();
+      this.check(this.exports.engine_fluid_volume_info(this.render(), fluid, index, info), "volume");
+      let at = info >>> 2, f = this.floats;
+      return { index, half: [f[at + 3], f[at + 4], f[at + 5]], centre: [f[at + 6], f[at + 7], f[at + 8]] };
+    } finally {
+      this.runtime.exports.engine_free(block, bytes, chunk2O2CG465_js.COLUMN_ALIGN);
+    }
+  }
+  clearVolumes(fluid) {
+    this.exports.engine_fluid_volumes_clear(this.render(), fluid);
+  }
+};
+
+// src/game/chemistry/engine.ts
+var CHEMISTRY_EXPORT_NAMES = [
+  "engine_chemistry_open",
+  "engine_chemistry_close",
+  "engine_chemistry_define",
+  "engine_chemistry_find",
+  "engine_chemistry_catalog",
+  "engine_chemistry_text",
+  "engine_chemistry_counts",
+  "engine_chemistry_species_info",
+  "engine_chemistry_reaction_info",
+  "engine_chemistry_grid_open",
+  "engine_chemistry_grid_close",
+  "engine_chemistry_grid_step",
+  "engine_chemistry_grid_paint",
+  "engine_chemistry_grid_set",
+  "engine_chemistry_grid_heat",
+  "engine_chemistry_grid_power",
+  "engine_chemistry_grid_columns",
+  "engine_chemistry_grid_colours",
+  "engine_chemistry_grid_events",
+  "engine_chemistry_grid_clear_events",
+  "engine_chemistry_grid_watch",
+  "engine_chemistry_grid_threshold",
+  "engine_chemistry_grid_unthreshold",
+  "engine_chemistry_grid_fired",
+  "engine_chemistry_grid_stats",
+  "engine_chemistry_grid_probe",
+  "engine_chemistry_grid_save",
+  "engine_chemistry_grid_saved",
+  "engine_chemistry_grid_load",
+  "engine_chemistry_vessel_open",
+  "engine_chemistry_vessel_close",
+  "engine_chemistry_vessel_add",
+  "engine_chemistry_vessel_take",
+  "engine_chemistry_vessel_heat",
+  "engine_chemistry_vessel_power",
+  "engine_chemistry_vessel_step",
+  "engine_chemistry_vessel_vent",
+  "engine_chemistry_vessel_state",
+  "engine_chemistry_particles_open",
+  "engine_chemistry_particles_close",
+  "engine_chemistry_particles_spawn",
+  "engine_chemistry_particles_step",
+  "engine_chemistry_particles_columns",
+  "engine_chemistry_particles_events"
+], CHEMISTRY_NATURE_WORDS = 8, CHEMISTRY_BOX_WORDS = 6, CHEMISTRY_SPECIES_WORDS = 16, CHEMISTRY_REACTION_WORDS = 24, CHEMISTRY_COLUMNS = 16, CHEMISTRY_STATS_WORDS = 16, CHEMISTRY_PROBE_WORDS = 16, CHEMISTRY_EVENT_HEADER = 2, CHEMISTRY_EVENT_WORDS = 4, CHEMISTRY_VESSEL_SLOTS = 16, CHEMISTRY_VESSEL_WORDS = 36, CHEMISTRY_ATMOSPHERE = 0, CHEMISTRY_VACUUM = 4294967295, CHEMISTRY_REFUSED = 65536, CHEMISTRY_SLOTS = 4, CHEMISTRY_TQ = 16, CHEMISTRY_UNSET = 4294967295;
+function bindChemistryEngine(symbols, memory) {
+  for (let name of CHEMISTRY_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return typeof symbols.engine_alloc != "function" || typeof symbols.engine_free != "function" ? null : { exports: symbols, memory };
+}
+
+// src/game/scenery/port.ts
+var SCENERY_REQUEST_SLOTS = 8, SCENERY_REGISTER_WORDS = 20;
+var SCENERY_REGISTER = {
+  chunks: 0,
+  resident: 1,
+  requested: 2,
+  installed: 3,
+  evicted: 4,
+  deferred: 5,
+  failed: 6,
+  installedKib: 7,
+  residentSplats: 8,
+  drawnSplats: 9,
+  listedPages: 10,
+  poolCapacity: 11,
+  poolFreePages: 12,
+  tier: 13,
+  updates: 14,
+  heroSplats: 15,
+  heroShed: 16,
+  standIn: 17,
+  deformedSplats: 18
+};
+
+// src/game/world/port.ts
+var STREAM_REGISTER = {
+  live: 0,
+  loading: 1,
+  waiting: 2,
+  failed: 3,
+  inflight: 4,
+  installed: 5,
+  installedBytes: 6,
+  admitted: 7,
+  evicted: 8,
+  residentKib: 9,
+  poolKib: 10,
+  proxyKib: 11,
+  sourceKib: 12,
+  starved: 13,
+  frames: 14,
+  totalInstalls: 15
+}, STREAM_PACK_REQUESTS = 16, STREAM_PACK_RELEASES = 17, STREAM_MAX_PACK_REQUESTS = 16, STREAM_MAX_PACK_RELEASES = 16, STREAM_REQUEST_LIST = 18, STREAM_RELEASE_LIST = (18) + (16), STREAM_REGISTER_BLOCK_WORDS = STREAM_RELEASE_LIST + (16), STREAM_LAZY_PACKS_FLAG = 256, STREAM_PRIORITY_SHIFT = 24, STREAM_PRIORITY_NOW = 0, STREAM_PRIORITY_SOON = 1, STREAM_START_PACK = 0, AssetPriority = { now: (0), soon: (1) }, STREAM_PACK_MASK = (1 << (24)) - 1, STREAM_EYE_FLOATS = 6, STREAM_ACTOR_FLOATS = 2, STREAM_COLLIDER_FLOATS = 8, STREAM_OP_INSERT = 1, TIER_INDEX = { low: 0, mid: 1, high: 2 }, STREAM_PACK_CONTENDED = -6;
+
+// src/game/backends/engine/render-abi.ts
+var RENDER_KERNEL_INSTANCES_FEATURE = "render_kernel_instances_1";
+var MEDIA_VOLUME_FEATURE = "media_volume_1";
+var RENDER_FEED_POSE_FEATURE = "render_feed_pose_1";
+var COMPARE_FUNCTIONS = [
+  "never",
+  "less",
+  "equal",
+  "lessEqual",
+  "greater",
+  "notEqual",
+  "greaterEqual",
+  "always"
+], BLEND_EQUATIONS = ["add", "subtract", "reverseSubtract", "min", "max"], BLEND_FACTORS = [
+  "zero",
+  "one",
+  "srcColor",
+  "oneMinusSrcColor",
+  "srcAlpha",
+  "oneMinusSrcAlpha",
+  "dstColor",
+  "oneMinusDstColor",
+  "dstAlpha",
+  "oneMinusDstAlpha",
+  "srcAlphaSaturate"
+], STENCIL_OPERATIONS = [
+  "keep",
+  "zero",
+  "replace",
+  "increment",
+  "decrement",
+  "invert",
+  "incrementWrap",
+  "decrementWrap"
+];
+var EMITTER_SHAPES = ["point", "sphere", "cone", "box", "disc"], EMITTER_COLLISIONS = ["none", "plane", "depth"];
+var FOG_MODES = ["linear", "exp2", "height"];
+var BUFFER_OWNER_CAPABILITIES = {
+  12: 4194304,
+  13: 8388608,
+  14: -2147483648
+}, STAT_GPU_LAST_NS = 17, STAT_GPU_P50_NS = 18, STAT_GPU_P95_NS = 19, STAT_GPU_BYTES_LOW = 20, STAT_GPU_BYTES_HIGH = 21;
+var STAT_THERMAL_TIER = 23, STAT_PARTICLES_ALIVE = 24, STAT_RAW_DISPATCHES = 25, STAT_RAW_GPU_NS = 26, STAT_RAW_DISABLED = 27, STAT_TRANSPARENT_SORTED = 28, STAT_TEXT_GLYPHS = 29, STAT_DRAW_CALLS = 32;
+var STAT_TRIANGLES = 33, OP_SET_RENDER_ORDER = 31, OP_EMIT = 32, OP_SET_EMITTER_RATE = 33, OP_MARK_EMITTER = 34, OP_DESTROY_EMITTER = 35, OP_RAW_DISPATCH = 36, OP_RAW_COPY = 37, OP_RAW_DESTROY_BUFFER = 38, OP_RAW_MARK_BUFFER = 39, OP_SET_SHADOW = 40, OP_SET_MATERIAL_WORD = 41, OP_RAW_DRAW = 42, OP_RAW_DESTROY_TEXTURE = 43, OP_RAW_MARK_TEXTURE = 44, OP_RAW_COPY_TEXTURE = 45, OP_SET_LOD = 46, OP_CLEAR_EMITTER = 50, OP_SET_WEATHER = 51, OP_SET_TIME_OF_DAY = 52, OP_MARK_TEXTURE_REGION = 54, OP_SET_EFFECT = 55, OP_SET_EFFECT_TEXTURE = 60, OP_SET_VOLUMETRICS = 61, TEXTURE_FORMAT_R8 = 3, TEXTURE_FORMAT_RG8 = 4, TEXTURE_FORMAT_R16F = 5, TEXTURE_FORMAT_RG16F = 6, TEXTURE_FORMAT_R32F = 7, TEXTURE_FORMAT_RG32F = 8, TEXTURE_FORMAT_R8UI = 9, TEXTURE_FORMAT_R16UI = 10, TEXTURE_FORMAT_R32UI = 11, TEXTURE_FORMAT_RG32UI = 12, TEXTURE_FORMAT_RGBA8UI = 13, TEXTURE_FORMAT_RGBA16UI = 14, TEXTURE_FORMAT_RGBA32UI = 15, TEXTURE_FORMAT_R32I = 16, TEXTURE_FORMAT_RGBA32I = 17, TEXTURE_KIND_2D_ARRAY = 3, TEXTURE_KIND_3D = 4, TEXTURE_KIND_EXTERNAL = 5;
+var TEXTURE_ENCODE_AUTO = 1, TEXTURE_ENCODE_ASTC_4X4 = 2, TEXTURE_ENCODE_BC7 = 3, TARGET_COLORS = 7, TARGET_KIND = 5, TARGET_LAYERS = 6, TARGET_SAMPLED_DEPTH = 8, TARGET_TEXTURES = 16, TARGET_MAX_COLORS = 4, TARGET_KIND_2D = 0, TARGET_KIND_CUBE = 1, TARGET_KIND_ARRAY = 2, PASS_SLICE = 11, PASS_FLAGS = 12, PASS_PLANE = 13, PASS_FLAG_CUBE_FACE = 1, PASS_FLAG_REFLECT = 2, PASS_FLAG_ONCE = 4, ENV_TONE_CURVE = 29, ENV_GI = 30, ENV_GI_INTENSITY = 31, ENV_GI_SPACING = 32, ENV_GI_SUN_ANGLE = 33, GI_MODES = ["off", "field", "full"], EFFECT_LENS_FLARE = 20;
+var MAX_CHAIN_EFFECTS = 64, POST_EFFECT_TEXTURES = 4, OP_SET_CLIP_ADDITIVE = 47, OP_SET_CLIP_MASK = 48, OP_ANIMATION = 53, ANIM_SET_TIME = 1, ANIM_SET_SPEED = 2, ANIM_SET_LOOP = 3, ANIM_SET_PAUSED = 4, ANIM_CROSSFADE = 5, ANIM_SET_SYNC = 6, ANIM_SET_RANGE = 7, ANIM_SET_EVENTS = 8, ANIM_SET_BLEND = 9, ANIM_SET_IK_TARGET = 10, ANIM_SET_IK_POLE = 11;
+var ANIM_FADE = 13, ANIM_DESTROY = 14, ANIM_INERTIALIZE = 15, ANIM_SET_SYNC_MODE = 16, ANIM_CREATE_MASK = 32, ANIM_SET_CLIP_EVENTS = 33, ANIM_CREATE_BLEND = 34, ANIM_CREATE_IK = 35, ANIM_RETARGET = 36, ANIM_HUMANOID = 37, ANIM_CLIP_INFO = 38, ANIM_ROOT_MOTION = 39, ANIM_BAKE_RETARGET = 45, ANIM_SET_SYNC_MARKERS = 46;
+var ANIM_SET_LOD = 47, NODE_POSE_FLOATS = 7, ROOT_MOTION_XZ = 1, ROOT_MOTION_Y = 2, ROOT_MOTION_YAW = 4, ROOT_MOTION_APPLY = 8, ANIM_KIND_MASK = 0, ANIM_KIND_BLEND = 1, ANIM_KIND_IK = 2, ANIM_KIND_RETARGET = 3, ANIM_KIND_ROOT_MOTION = 4, ANIM_EVENT_WORDS = 4, ANIM_MAX_EVENTS = 256, ANIM_ACTION_WORDS = 4, ANIM_ACTION_RUNNING = 1, ANIM_ACTION_PAUSED = 2, ANIM_ACTION_FINISHED = 4, ANIMATION_BUFFER_EVENTS = 0, ANIMATION_BUFFER_ACTIONS = 1, ANIMATION_BUFFER_ROOT_MOTION = 2, TONE_MAPPINGS = ["none", "linear", "reinhard", "aces", "agx", "neutral", "cineon", "custom"], MATERIAL_SLOTS = [
+  "map",
+  "normalMap",
+  "roughnessMap",
+  "metalnessMap",
+  "emissiveMap",
+  "aoMap",
+  "clearcoatMap",
+  "clearcoatRoughnessMap",
+  "clearcoatNormalMap",
+  "sheenColorMap",
+  "sheenRoughnessMap",
+  "specularIntensityMap",
+  "specularColorMap",
+  "transmissionMap"
+], CORE_MATERIAL_SLOTS = 6, RENDER_CORE_EXPORTS = [
+  "engine_render_create",
+  "engine_render_destroy",
+  "engine_render_registers",
+  "engine_render_desc",
+  "engine_render_commands",
+  "engine_render_capabilities",
+  "engine_render_flush",
+  "engine_render_create_geometry",
+  "engine_render_commit_geometry",
+  "engine_render_create_texture",
+  "engine_render_decode_texture",
+  "engine_render_create_material",
+  "engine_render_create_node",
+  "engine_render_create_target",
+  "engine_render_create_chain",
+  "engine_render_create_pass",
+  "engine_render_set_environment",
+  "engine_render_load_model",
+  "engine_render_install_shaders",
+  "engine_render_instantiate",
+  "engine_render_find_node",
+  "engine_render_play_clip",
+  "engine_render_buffer",
+  "engine_render_sync",
+  "engine_render_animate",
+  "engine_render_frame",
+  "engine_render_stats",
+  "engine_render_node_matrix"
+], RENDER_FEATURE_EXPORTS = {
+  engine_render_create_emitter: 1024,
+  engine_render_raw_buffer: 8192,
+  engine_render_raw_pipeline: 8192,
+  engine_render_raw_bindings: 8192,
+  engine_render_raw_read: 8192,
+  engine_render_raw_poll: 8192,
+  engine_render_raw_texture: 131072,
+  engine_render_raw_sampler: 131072,
+  engine_render_raw_read_texture: 131072,
+  engine_render_load_font: 1048576,
+  engine_render_set_text: 1048576,
+  engine_render_set_text_style: 1048576,
+  engine_render_text_bounds: 1048576,
+  engine_render_raycast: 2097152,
+  engine_render_set_chain_shader: 256,
+  engine_render_animation: -2147483648,
+  engine_render_load_clips: -2147483648,
+  engine_render_node_poses: -2147483648,
+  engine_render_read_target: 32,
+  engine_render_texture_object: 32,
+  engine_render_reload_model: 128,
+  engine_render_reload_texture: 1,
+  engine_render_encode_texture: 1
+}, ENGINE_RELOAD_EXPORT_NAMES = ["engine_render_reload_model", "engine_render_reload_texture"], ENGINE_ENCODE_EXPORT_NAMES = ["engine_render_encode_texture"]; [
+  ...RENDER_CORE_EXPORTS,
+  ...Object.keys(RENDER_FEATURE_EXPORTS)
+];
+
+// src/game/render/vector-surfaces.ts
+var VECTOR_SURFACE_TIERS = { low: 0, mid: 1, high: 2 }, VECTOR_SURFACE_CAPS = { low: 4, mid: 8, high: 16 }, VECTOR_SURFACE_EDGES = { low: 512, mid: 1024, high: 2048 };
+function createVectorSurfaceStats() {
+  return { cap: 0, live: 0, encoded: 0, unchanged: 0, offscreen: 0, occluded: 0, overCap: 0, droppedEvents: 0 };
+}
+
+// src/game/audio/analyser.ts
+var BLACKMAN_A0 = 0.42, BLACKMAN_A1 = 0.5, BLACKMAN_A2 = 0.08, DECIBELS_PER_LOG = 20, BYTE_MAX = 255, BYTE_CENTER = 128, SILENCE = 1e-12;
+function analyserSettings(desc = {}) {
+  let fftSize = desc.fftSize ?? chunkX5A5FOWW_js.DEFAULT_FFT_SIZE;
+  if (!Number.isInteger(fftSize) || fftSize < chunkX5A5FOWW_js.MIN_FFT_SIZE || fftSize > chunkX5A5FOWW_js.MAX_FFT_SIZE || (fftSize & fftSize - 1) !== 0)
+    throw new chunk2V7IL4HC_js.GameError("invalid_argument", `fftSize must be a power of two from ${chunkX5A5FOWW_js.MIN_FFT_SIZE} to ${chunkX5A5FOWW_js.MAX_FFT_SIZE}`);
+  let smoothing = desc.smoothing ?? chunkX5A5FOWW_js.DEFAULT_SMOOTHING;
+  if (!(smoothing >= 0 && smoothing <= 1)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "smoothing must be between 0 and 1");
+  let minDecibels = desc.minDecibels ?? chunkX5A5FOWW_js.DEFAULT_MIN_DECIBELS, maxDecibels = desc.maxDecibels ?? chunkX5A5FOWW_js.DEFAULT_MAX_DECIBELS;
+  if (!(minDecibels < maxDecibels)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "minDecibels must be below maxDecibels");
+  return { fftSize, smoothing, minDecibels, maxDecibels };
+}
+var FftAnalyser = class {
+  constructor(settings) {
+    this.head = 0;
+    let n = settings.fftSize;
+    this.fftSize = n, this.binCount = n / 2, this.smoothing = settings.smoothing, this.minDecibels = settings.minDecibels, this.maxDecibels = settings.maxDecibels, this.ring = new Float32Array(n), this.real = new Float64Array(n), this.imag = new Float64Array(n), this.window = new Float64Array(n), this.smoothed = new Float64Array(n / 2), this.bitReverse = new Uint32Array(n), this.cos = new Float64Array(n / 2), this.sin = new Float64Array(n / 2);
+    for (let i = 0; i < n; i++) {
+      let phase = 2 * Math.PI * i / n;
+      this.window[i] = (0.42) - (0.5) * Math.cos(phase) + (0.08) * Math.cos(2 * phase);
+    }
+    let bits2 = Math.log2(n);
+    for (let i = 0; i < n; i++) {
+      let r = 0;
+      for (let b = 0; b < bits2; b++) r |= (i >>> b & 1) << bits2 - 1 - b;
+      this.bitReverse[i] = r;
+    }
+    for (let i = 0; i < n / 2; i++)
+      this.cos[i] = Math.cos(-2 * Math.PI * i / n), this.sin[i] = Math.sin(-2 * Math.PI * i / n);
+  }
+  push(samples, start, count) {
+    let ring = this.ring, n = this.fftSize, head = this.head;
+    for (let i = 0; i < count; i++)
+      ring[head] = samples[start + i], head = head + 1 === n ? 0 : head + 1;
+    this.head = head;
+  }
+  reset() {
+    this.ring.fill(0), this.smoothed.fill(0), this.head = 0;
+  }
+  timeDomain(out) {
+    let ring = this.ring, n = Math.min(out.length, this.fftSize), start = this.head + this.fftSize - n, bytes = out instanceof Uint8Array;
+    for (let i = 0; i < n; i++) {
+      let v = ring[(start + i) % this.fftSize];
+      bytes ? out[i] = clampByte((128) * (1 + v)) : out[i] = v;
+    }
+  }
+  frequency(out) {
+    this.transform();
+    let n = Math.min(out.length, this.binCount), smoothed = this.smoothed;
+    if (out instanceof Uint8Array) {
+      let scale = (255) / (this.maxDecibels - this.minDecibels);
+      for (let i = 0; i < n; i++) out[i] = clampByte((decibels(smoothed[i]) - this.minDecibels) * scale);
+    } else
+      for (let i = 0; i < n; i++) out[i] = decibels(smoothed[i]);
+  }
+  transform() {
+    let n = this.fftSize, real = this.real, imag = this.imag, ring = this.ring, head = this.head;
+    for (let i = 0; i < n; i++) {
+      let j = this.bitReverse[i];
+      real[j] = ring[(head + i) % n] * this.window[i], imag[j] = 0;
+    }
+    for (let size = 2; size <= n; size <<= 1) {
+      let half = size >>> 1, stride = n / size;
+      for (let block = 0; block < n; block += size)
+        for (let k = 0; k < half; k++) {
+          let wr = this.cos[k * stride], wi = this.sin[k * stride], a = block + k, b = a + half, tr = real[b] * wr - imag[b] * wi, ti = real[b] * wi + imag[b] * wr;
+          real[b] = real[a] - tr, imag[b] = imag[a] - ti, real[a] += tr, imag[a] += ti;
+        }
+    }
+    let tau = this.smoothing, inverse = 1 / n, smoothed = this.smoothed;
+    for (let i = 0; i < this.binCount; i++) {
+      let magnitude = Math.sqrt(real[i] * real[i] + imag[i] * imag[i]) * inverse;
+      smoothed[i] = tau * smoothed[i] + (1 - tau) * magnitude;
+    }
+  }
+};
+function decibels(magnitude) {
+  return (20) * Math.log10(magnitude > (1e-12) ? magnitude : (1e-12));
+}
+function clampByte(value) {
+  return value <= 0 ? 0 : value >= (255) ? (255) : Math.floor(value);
+}
+
+// src/game/reactive/engine.ts
+var REACTIVE_FEATURE = "reactive_fluid_1", REACTIVE_DESC_WORDS = 32, REACTIVE_GRID = 0, REACTIVE_ORIGIN = 3, REACTIVE_CELL = 6, REACTIVE_LIQUID = 7, REACTIVE_LIQUID_KELVIN = 8, REACTIVE_PARCELS = 9, REACTIVE_CONTACT = 10, REACTIVE_COUPLING = 11, REACTIVE_MAX_PAIRS = 12, REACTIVE_SEED_LOW = 13, REACTIVE_SEED_HIGH = 14, REACTIVE_SMOKE = 16, REACTIVE_SMOKE_SPECIES = 4, REACTIVE_GLOW_FROM_K = 20, REACTIVE_GLOW_FULL_K = 21, REACTIVE_SMOKE_FULL = 22, REACTIVE_FLAME_EXTINCTION = 23, REACTIVE_PLUME_FROM_K = 24, HOB_DESC_WORDS = 12, HOB_FIRST = 0, HOB_LAST = 2, HOB_LAYERS = 4, HOB_METAL = 5, HOB_START_K = 6, HOB_PAN_K = 7, HOB_PAN_JOULES = 8, HOB_FLAME_K = 9, HOB_FLAME_JOULES = 10, HOB_FLAME_LAYERS = 11, REACTIVE_REGISTER_WORDS = 96, REACTIVE_TICK_LOW = 0, REACTIVE_TICK_HIGH = 1;
+var REACTIVE_PAIRS = 3, REACTIVE_DROPPED_PAIRS = 4;
+var REACTIVE_VENTED = 7, REACTIVE_RETIRED = 8, REACTIVE_PARTICLES = 9, REACTIVE_FIRED = 10, REACTIVE_PAN_K = 11, REACTIVE_BURNING = 12, REACTIVE_SMOKY = 13, REACTIVE_HOTTEST_K = 14, REACTIVE_PLUME_COUNT = 15, REACTIVE_DIGEST_LOW = 16, REACTIVE_DIGEST_HIGH = 17;
+var REACTIVE_CAPACITY = 21, REACTIVE_LIT = 22, REACTIVE_SECONDS = 23, REACTIVE_PLUMES = 32, REACTIVE_PLUME_WORDS = 8, REACTIVE_MAX_PLUMES = 8, PLUME_CELL = 0, PLUME_KELVIN = 3, PLUME_SMOKE = 4, PLUME_WORLD = 5, REACTIVE_MAX_PREHEAT_TICKS = 4096, REACTIVE_MAX_STEP_SECONDS = 0.1, REACTIVE_MAX_EDGE = 64, ENGINE_REACTIVE_EXPORT_NAMES = [
+  "engine_reactive_create",
+  "engine_reactive_destroy",
+  "engine_reactive_registers",
+  "engine_reactive_hob",
+  "engine_reactive_lit",
+  "engine_reactive_emitter",
+  "engine_reactive_preheat",
+  "engine_reactive_step",
+  "engine_reactive_media",
+  "engine_reactive_texels",
+  "engine_reactive_positions",
+  "engine_reactive_digest"
+], NULL2 = 0, WORD = 4, NO_MEDIUM = 0, POSITION_FLOATS = 3, FLOAT = new Float32Array(1), BITS = new Uint32Array(FLOAT.buffer), HIGH_BITS = 32n, SCRATCH_WORDS = (32) + (18) + (12), FLUID_AT = (32), EMITTER_AT = (32) + (18);
+function engineReactiveExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_REACTIVE_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+function failure(code, what) {
+  throw code === -1 ? new chunk2V7IL4HC_js.GameError("capacity_exceeded", `the engine has no room for the reactive fluid ${what}`) : code === -3 ? new chunk2V7IL4HC_js.GameError("unknown_resource", `the reactive fluid ${what} names an unknown material or a missing hob`) : new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the reactive fluid ${what} (${code})`);
+}
+function check(code, what) {
+  return code >= 0 ? code : failure(code, what);
+}
+var EngineReactive = class {
+  constructor(runtime, exports, render) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.scratch = (0);
+    this.buffer = null;
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.registerViews = /* @__PURE__ */ new Map();
+    this.texelViews = /* @__PURE__ */ new Map();
+    this.positionViews = /* @__PURE__ */ new Map();
+  }
+  views() {
+    let buffer = this.runtime.memory.buffer;
+    buffer !== this.buffer && (this.buffer = buffer, this.words = new Uint32Array(buffer), this.floats = new Float32Array(buffer));
+  }
+  at() {
+    if (this.scratch === (0) && (this.scratch = this.runtime.exports.engine_alloc(SCRATCH_WORDS * (4), chunk2O2CG465_js.COLUMN_ALIGN), this.scratch === (0)))
+      throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold reactive fluid parameters");
+    return this.views(), this.scratch >>> 2;
+  }
+  open(chemistry, fluid, desc) {
+    let at = this.at();
+    this.words.set(desc.subarray(0, (32)), at), this.floats.set(fluid.subarray(0, (18)), at + FLUID_AT);
+    let handle = this.exports.engine_reactive_create(chemistry, this.scratch + FLUID_AT * (4), this.scratch);
+    if (handle === (0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "the engine refused this reactive fluid (check the liquid, the grids and the contact radius)");
+    return handle;
+  }
+  registers(reactive) {
+    this.views();
+    let held = this.registerViews.get(reactive);
+    if (held !== void 0 && held.buffer === this.buffer) return held;
+    let pointer = this.exports.engine_reactive_registers(reactive);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("unknown_resource", "this reactive fluid was disposed");
+    let view2 = new Uint32Array(this.words.buffer, pointer, (96));
+    return this.registerViews.set(reactive, view2), view2;
+  }
+  hob(reactive, desc) {
+    let at = this.at();
+    this.words.set(desc.subarray(0, (12)), at), check(this.exports.engine_reactive_hob(reactive, this.scratch), "hob");
+  }
+  lit(reactive, on) {
+    check(this.exports.engine_reactive_lit(reactive, on ? 1 : 0), "burner");
+  }
+  emitter(reactive, index, emitter) {
+    let at = this.at();
+    this.floats.set(emitter.subarray(0, (12)), at + EMITTER_AT), check(this.exports.engine_reactive_emitter(reactive, index, this.scratch + EMITTER_AT * (4)), "pour");
+  }
+  preheat(reactive, targetK, maxTicks) {
+    return check(this.exports.engine_reactive_preheat(reactive, targetK, maxTicks), "preheat");
+  }
+  step(reactive, seconds, tick) {
+    FLOAT[0] = seconds, this.registers(reactive)[(23)] = BITS[0], check(this.exports.engine_reactive_step(reactive, tick ? 1 : 0), "step");
+  }
+  media(reactive, medium) {
+    let render = medium === (0) ? (0) : this.render();
+    if (medium !== (0) && render === (0)) throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "writing a media volume needs the engine renderer");
+    return check(this.exports.engine_reactive_media(reactive, render, medium), "media volume");
+  }
+  texels(reactive, count) {
+    this.views();
+    let held = this.texelViews.get(reactive);
+    if (held !== void 0 && held.buffer === this.buffer) return held;
+    let pointer = this.exports.engine_reactive_texels(reactive);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("unknown_resource", "this reactive fluid was disposed");
+    let view2 = new Uint32Array(this.words.buffer, pointer, count);
+    return this.texelViews.set(reactive, view2), view2;
+  }
+  positions(reactive, capacity) {
+    let pointer = this.exports.engine_reactive_positions(reactive);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("unknown_resource", "this reactive fluid was disposed");
+    this.views();
+    let held = this.positionViews.get(reactive);
+    if (held !== void 0 && held.buffer === this.buffer && held.byteOffset === pointer) return held;
+    let view2 = new Float32Array(this.floats.buffer, pointer, capacity * (3));
+    return this.positionViews.set(reactive, view2), view2;
+  }
+  digest(reactive) {
+    check(this.exports.engine_reactive_digest(reactive), "digest");
+    let r = this.registers(reactive);
+    return BigInt(r[(17)]) << HIGH_BITS | BigInt(r[(16)]);
+  }
+  close(reactive) {
+    this.registerViews.delete(reactive), this.texelViews.delete(reactive), this.positionViews.delete(reactive), this.exports.engine_reactive_destroy(reactive);
+  }
+};
+
+// src/game/destruction/engine.ts
+var DESTRUCT_DESC_FLOATS = 24, DESTRUCT_DAMAGE_FLOATS = 5, DESTRUCT_EVENT_WORDS = 8, DESTRUCT_KIND_BREAK = 1, DESTRUCT_KIND_RETIRE = 2, DESTRUCT_KIND_INTACT_LOST = 3, DESTRUCT_KIND_REMOVE = 4, ENGINE_DESTRUCTION_EXPORT_NAMES = [
+  "engine_destruction_open",
+  "engine_destruction_close",
+  "engine_destructible_create",
+  "engine_destructible_destroy",
+  "engine_destructible_damage",
+  "engine_destructible_attached",
+  "engine_destruction_update",
+  "engine_destruction_events",
+  "engine_destruction_dropped"
+], ENGINE_DESTRUCTION_STRUCTURE_EXPORT_NAMES = ["engine_destructible_configure"], DESTRUCT_STRUCTURE_FLOATS = 8, STRUCTURE_PROPAGATION = 0, STRUCTURE_BOND_STRENGTH = 1, STRUCTURE_STRESS = 2, STRUCTURE_CLUSTERS = 3, STRUCTURE_LEVELS = 4, STRUCTURE_LEVEL_STRENGTH = 5, DESTRUCT_KIND_BOND = 5;
+var NULL3 = 0, F32_BYTES2 = 4, MICROS2 = 1e6;
+function engineDestructionExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_DESTRUCTION_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var EngineDestruction = class {
+  constructor(runtime, exports, world) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.world = world;
+    this.handle = (0);
+    this.scratch = (0);
+    this.fracturer = null;
+    this.buffer = null;
+    this.words = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.bytes = new Uint8Array(0);
+    this.events = { words: this.words, floats: this.floats, offset: 0, count: 0 };
+  }
+  views() {
+    let buffer = this.runtime.memory.buffer;
+    buffer !== this.buffer && (this.buffer = buffer, this.words = new Uint32Array(buffer), this.floats = new Float32Array(buffer), this.bytes = new Uint8Array(buffer), this.events.words = this.words, this.events.floats = this.floats);
+  }
+  open() {
+    if (this.handle === (0)) {
+      if (this.handle = this.exports.engine_destruction_open(this.world()), this.handle === (0)) throw new chunk2V7IL4HC_js.GameError("not_initialized", "destruction needs an engine physics world");
+      if (this.scratch = this.runtime.exports.engine_alloc(Math.max((24), (5)) * (4), chunk2O2CG465_js.COLUMN_ALIGN), this.scratch === (0)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold destruction parameters");
+    }
+    return this.handle;
+  }
+  allocate(bytes) {
+    let pointer = this.runtime.exports.engine_alloc(Math.max(bytes, 4), chunk2O2CG465_js.COLUMN_ALIGN);
+    if (pointer === (0)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold the fracture asset");
+    return pointer;
+  }
+  create(asset, entities, intact, desc) {
+    let handle = this.open(), assetPointer = this.allocate(asset.byteLength), entityPointer = this.allocate(entities.byteLength);
+    this.views(), this.bytes.set(asset, assetPointer), this.words.set(entities, entityPointer >>> 2), this.floats.set(desc, this.scratch >>> 2);
+    let id = this.exports.engine_destructible_create(
+      handle,
+      this.world(),
+      assetPointer,
+      asset.byteLength,
+      entityPointer,
+      entities.length,
+      intact,
+      this.scratch
+    );
+    if (this.runtime.exports.engine_free(assetPointer, Math.max(asset.byteLength, 4), chunk2O2CG465_js.COLUMN_ALIGN), this.runtime.exports.engine_free(entityPointer, Math.max(entities.byteLength, 4), chunk2O2CG465_js.COLUMN_ALIGN), !(id >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the destructible (${id}); check the fracture asset and that every entity has a transform`);
+    return id;
+  }
+  destroy(destructible) {
+    this.handle !== (0) && this.exports.engine_destructible_destroy(this.handle, this.world(), destructible);
+  }
+  configure(destructible, structure) {
+    let handle = this.open(), call = this.runtime.symbols.engine_destructible_configure;
+    if (typeof call != "function") throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "structural destruction needs an engine with feature destruction_2");
+    this.views();
+    let at = this.scratch >>> 2;
+    this.floats.fill(0, at, at + (8)), this.floats[at + (0)] = structure.propagation ?? 0, this.floats[at + (1)] = structure.bondStrength, this.floats[at + (2)] = structure.stress ? 1 : 0, this.floats[at + (3)] = structure.clusters ? 1 : 0, this.floats[at + (4)] = structure.levels ?? 0, this.floats[at + (5)] = structure.levelStrength ?? 1;
+    let code = call(handle, this.world(), destructible, this.scratch);
+    if (!(code >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the structure (${code}); configure before any damage, with bondStrength above 0 for stress or clusters`);
+  }
+  damage(destructible, x, y, z, radius, amount) {
+    let handle = this.open();
+    this.views();
+    let at = this.scratch >>> 2;
+    this.floats[at] = x, this.floats[at + 1] = y, this.floats[at + 2] = z, this.floats[at + 3] = radius, this.floats[at + 4] = amount;
+    let hit = this.exports.engine_destructible_damage(handle, destructible, this.scratch);
+    if (!(hit >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `damage refused (${hit})`);
+    return hit;
+  }
+  attached(destructible) {
+    if (this.handle === (0)) return 0;
+    let attached = this.exports.engine_destructible_attached(this.handle, destructible);
+    if (!(attached >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `attached refused (${attached})`);
+    return attached;
+  }
+  update(seconds) {
+    if (this.events.count = 0, this.handle === (0)) return this.events;
+    let count = this.exports.engine_destruction_update(this.handle, this.world(), Math.max(0, Math.round(seconds * (1e6))));
+    if (!(count >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `destruction update refused (${count})`);
+    return count === 0 ? this.events : (this.views(), this.events.offset = this.exports.engine_destruction_events(this.handle) >>> 2, this.events.count = count, this.events);
+  }
+  fracture(mesh, options) {
+    if (this.fracturer === null) {
+      let exports = chunkX5A5FOWW_js.engineFractureExports(this.runtime);
+      if (exports === null) throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "breaking a made thing needs an engine with live fracture");
+      this.fracturer = new chunkX5A5FOWW_js.EngineFracturer(this.runtime, exports);
+    }
+    return this.fracturer.fracture(mesh, options);
+  }
+  dispose() {
+    this.fracturer?.dispose(), this.fracturer = null, this.handle !== (0) && (this.exports.engine_destruction_close(this.handle), this.handle = (0));
+  }
+};
+
+// src/game/kernel/transforms-engine.ts
+var TRANSFORM_EXPORT_NAMES = [
+  "engine_transform_fft_open",
+  "engine_transform_fft_close",
+  "engine_transform_fft_run",
+  "engine_transform_convolver_open",
+  "engine_transform_convolver_close",
+  "engine_transform_convolve",
+  "engine_transform_sat_open",
+  "engine_transform_sat_close",
+  "engine_transform_sat_build",
+  "engine_transform_distance_open",
+  "engine_transform_distance_close",
+  "engine_transform_distance_mask",
+  "engine_transform_distance_signed",
+  "engine_transform_jump_flood",
+  "engine_transform_multigrid_open",
+  "engine_transform_multigrid_close",
+  "engine_transform_multigrid_solve"
+];
+function bindTransformEngine(symbols, memory) {
+  for (let name of TRANSFORM_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return typeof symbols.engine_alloc != "function" || typeof symbols.engine_free != "function" ? null : { exports: symbols, memory };
+}
+var current = null;
+function useTransformEngine(engine) {
+  current = engine;
+}
+function transformEngine() {
+  return current;
+}
+var EngineBuffer = class {
+  constructor(engine, bytes) {
+    this.engine = engine;
+    this.bytes = bytes;
+    this.pointer = engine.exports.engine_alloc(Math.max(bytes, 4), 16);
+  }
+  floats(length) {
+    return new Float32Array(this.engine.memory.buffer, this.pointer, length);
+  }
+  words(length) {
+    return new Uint32Array(this.engine.memory.buffer, this.pointer, length);
+  }
+  bytesView(length) {
+    return new Uint8Array(this.engine.memory.buffer, this.pointer, length);
+  }
+  free() {
+    this.engine.exports.engine_free(this.pointer, Math.max(this.bytes, 4), 16);
+  }
+};
+
+// src/game/smoke/engine.ts
+var SMOKE_DESC_FLOATS = 24, SMOKE_EMITTER_FLOATS = 11, SMOKE_TINTED_EMITTER_FLOATS = 14, SMOKE_TINT_AT = 11, SMOKE_MAX_EMITTERS = 8, SMOKE_AXES = 3, ENGINE_SMOKE_TINT_EXPORT = "engine_smoke_emitters_tinted", ENGINE_SMOKE_FOLLOW_EXPORT = "engine_smoke_follow", SMOKE_MICROS_PER_SECOND = 1e6, SMOKE_MAX_STEP_MICROS = 1e5, ENGINE_SMOKE_EXPORT_NAMES = ["engine_smoke_create", "engine_smoke_destroy", "engine_smoke_emitters", "engine_smoke_step"], NULL4 = 0, WORD2 = 4, CAPACITY = -1, UNKNOWN = -3, WHITE = 1, SCRATCH_FLOATS2 = (24) + (8) * (14), EMITTERS_AT = (24);
+function tinted(floats2, count) {
+  for (let e = 0; e < count; e++)
+    for (let k = 0; k < (3); k++) if (floats2[e * (14) + (11) + k] !== (1)) return true;
+  return false;
+}
+function engineSmokeExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_SMOKE_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+function check2(code, what) {
+  if (code >= 0) return code;
+  throw code === (-1) ? new chunk2V7IL4HC_js.GameError("capacity_exceeded", `the engine has no room for the smoke ${what}`) : code === (-3) ? new chunk2V7IL4HC_js.GameError("unknown_resource", `the smoke ${what} names a disposed smoke volume or a missing medium`) : new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the smoke ${what} (${code})`);
+}
+var EngineSmoke = class {
+  constructor(runtime, exports, render) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.scratch = (0);
+    this.buffer = null;
+    this.floats = new Float32Array(0);
+  }
+  at() {
+    if (this.scratch === (0) && (this.scratch = this.runtime.exports.engine_alloc(SCRATCH_FLOATS2 * (4), chunk2O2CG465_js.COLUMN_ALIGN), this.scratch === (0)))
+      throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold smoke parameters");
+    let buffer = this.runtime.memory.buffer;
+    return buffer !== this.buffer && (this.buffer = buffer, this.floats = new Float32Array(buffer)), this.scratch >>> 2;
+  }
+  renderHandle() {
+    let render = this.render();
+    if (render === (0)) throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "smoke volumes need the engine renderer");
+    return render;
+  }
+  create(desc, medium) {
+    let at = this.at();
+    return this.floats.set(desc.subarray(0, (24)), at), check2(this.exports.engine_smoke_create(this.renderHandle(), this.scratch, medium), "description");
+  }
+  emitters(smoke, floats2, count) {
+    let at = this.at() + EMITTERS_AT, pointer = this.scratch + EMITTERS_AT * (4), tint = this.runtime.symbols[ENGINE_SMOKE_TINT_EXPORT];
+    if (typeof tint == "function") {
+      this.floats.set(floats2.subarray(0, count * (14)), at), check2(tint(this.renderHandle(), smoke, pointer, count), "emitters");
+      return;
+    }
+    if (tinted(floats2, count)) throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "tinted flames need an engine with smoke emitter tints");
+    for (let e = 0; e < count; e++)
+      this.floats.set(floats2.subarray(e * (14), e * (14) + (11)), at + e * (11));
+    check2(this.exports.engine_smoke_emitters(this.renderHandle(), smoke, pointer, count), "emitters");
+  }
+  follow(smoke, x, y, z) {
+    let call = this.runtime.symbols[ENGINE_SMOKE_FOLLOW_EXPORT];
+    if (typeof call != "function") throw new chunk2V7IL4HC_js.GameError("unsupported_feature", "a smoke volume that follows a moving thing needs an engine with smoke follow");
+    let at = this.at();
+    this.floats[at] = x, this.floats[at + 1] = y, this.floats[at + 2] = z, check2(call(this.renderHandle(), smoke, this.scratch), "follow");
+  }
+  step(smoke, seconds) {
+    let micros = Math.min(Math.max(Math.round(seconds * (1e6)), 0), (1e5));
+    return check2(this.exports.engine_smoke_step(this.renderHandle(), smoke, micros), "step");
+  }
+  destroy(smoke) {
+    this.exports.engine_smoke_destroy(this.renderHandle(), smoke);
+  }
+};
+
+exports.ANIMATION_BUFFER_ACTIONS = (1);
+exports.ANIMATION_BUFFER_EVENTS = (0);
+exports.ANIMATION_BUFFER_ROOT_MOTION = (2);
+exports.ANIM_ACTION_FINISHED = (4);
+exports.ANIM_ACTION_PAUSED = (2);
+exports.ANIM_ACTION_RUNNING = (1);
+exports.ANIM_ACTION_WORDS = (4);
+exports.ANIM_BAKE_RETARGET = (45);
+exports.ANIM_CLIP_INFO = (38);
+exports.ANIM_CREATE_BLEND = (34);
+exports.ANIM_CREATE_IK = (35);
+exports.ANIM_CREATE_MASK = (32);
+exports.ANIM_CROSSFADE = (5);
+exports.ANIM_DESTROY = (14);
+exports.ANIM_EVENT_WORDS = (4);
+exports.ANIM_FADE = (13);
+exports.ANIM_HUMANOID = (37);
+exports.ANIM_INERTIALIZE = (15);
+exports.ANIM_KIND_BLEND = (1);
+exports.ANIM_KIND_IK = (2);
+exports.ANIM_KIND_MASK = (0);
+exports.ANIM_KIND_RETARGET = (3);
+exports.ANIM_KIND_ROOT_MOTION = (4);
+exports.ANIM_MAX_EVENTS = (256);
+exports.ANIM_RETARGET = (36);
+exports.ANIM_ROOT_MOTION = (39);
+exports.ANIM_SET_BLEND = (9);
+exports.ANIM_SET_CLIP_EVENTS = (33);
+exports.ANIM_SET_EVENTS = (8);
+exports.ANIM_SET_IK_POLE = (11);
+exports.ANIM_SET_IK_TARGET = (10);
+exports.ANIM_SET_LOD = (47);
+exports.ANIM_SET_LOOP = (3);
+exports.ANIM_SET_PAUSED = (4);
+exports.ANIM_SET_RANGE = (7);
+exports.ANIM_SET_SPEED = (2);
+exports.ANIM_SET_SYNC = (6);
+exports.ANIM_SET_SYNC_MARKERS = (46);
+exports.ANIM_SET_SYNC_MODE = (16);
+exports.ANIM_SET_TIME = (1);
+exports.AssetPriority = AssetPriority;
+exports.BLEND_EQUATIONS = BLEND_EQUATIONS;
+exports.BLEND_FACTORS = BLEND_FACTORS;
+exports.BUFFER_OWNER_CAPABILITIES = BUFFER_OWNER_CAPABILITIES;
+exports.CHEMISTRY_ATMOSPHERE = (0);
+exports.CHEMISTRY_BOX_WORDS = (6);
+exports.CHEMISTRY_COLUMNS = (16);
+exports.CHEMISTRY_EVENT_HEADER = (2);
+exports.CHEMISTRY_EVENT_WORDS = (4);
+exports.CHEMISTRY_EXPORT_NAMES = CHEMISTRY_EXPORT_NAMES;
+exports.CHEMISTRY_NATURE_WORDS = (8);
+exports.CHEMISTRY_PROBE_WORDS = (16);
+exports.CHEMISTRY_REACTION_WORDS = (24);
+exports.CHEMISTRY_REFUSED = (65536);
+exports.CHEMISTRY_SLOTS = (4);
+exports.CHEMISTRY_SPECIES_WORDS = (16);
+exports.CHEMISTRY_STATS_WORDS = (16);
+exports.CHEMISTRY_TQ = (16);
+exports.CHEMISTRY_UNSET = (4294967295);
+exports.CHEMISTRY_VACUUM = (4294967295);
+exports.CHEMISTRY_VESSEL_SLOTS = (16);
+exports.CHEMISTRY_VESSEL_WORDS = (36);
+exports.COMPARE_FUNCTIONS = COMPARE_FUNCTIONS;
+exports.COMPUTE_DEFERRED = (-7);
+exports.COMPUTE_SPACE_CPU = (0);
+exports.COMPUTE_SPACE_GPU = (1);
+exports.COMPUTE_STOPPED = (-8);
+exports.CORE_MATERIAL_SLOTS = (6);
+exports.ComputeMonitor = ComputeMonitor;
+exports.DESTRUCT_DESC_FLOATS = (24);
+exports.DESTRUCT_EVENT_WORDS = (8);
+exports.DESTRUCT_KIND_BOND = (5);
+exports.DESTRUCT_KIND_BREAK = (1);
+exports.DESTRUCT_KIND_INTACT_LOST = (3);
+exports.DESTRUCT_KIND_REMOVE = (4);
+exports.DESTRUCT_KIND_RETIRE = (2);
+exports.EFFECT_LENS_FLARE = (20);
+exports.EMITTER_COLLISIONS = EMITTER_COLLISIONS;
+exports.EMITTER_SHAPES = EMITTER_SHAPES;
+exports.ENGINE_COMPUTE_EXPORT_NAMES = ENGINE_COMPUTE_EXPORT_NAMES;
+exports.ENGINE_DESTRUCTION_EXPORT_NAMES = ENGINE_DESTRUCTION_EXPORT_NAMES;
+exports.ENGINE_DESTRUCTION_STRUCTURE_EXPORT_NAMES = ENGINE_DESTRUCTION_STRUCTURE_EXPORT_NAMES;
+exports.ENGINE_ENCODE_EXPORT_NAMES = ENGINE_ENCODE_EXPORT_NAMES;
+exports.ENGINE_FLUID_EXPORT_NAMES = ENGINE_FLUID_EXPORT_NAMES;
+exports.ENGINE_REACTIVE_EXPORT_NAMES = ENGINE_REACTIVE_EXPORT_NAMES;
+exports.ENGINE_RELOAD_EXPORT_NAMES = ENGINE_RELOAD_EXPORT_NAMES;
+exports.ENGINE_SMOKE_EXPORT_NAMES = ENGINE_SMOKE_EXPORT_NAMES;
+exports.ENV_GI = (30);
+exports.ENV_GI_INTENSITY = (31);
+exports.ENV_GI_SPACING = (32);
+exports.ENV_GI_SUN_ANGLE = (33);
+exports.ENV_TONE_CURVE = (29);
+exports.EngineBuffer = EngineBuffer;
+exports.EngineDestruction = EngineDestruction;
+exports.EngineFluids = EngineFluids;
+exports.EngineReactive = EngineReactive;
+exports.EngineSmoke = EngineSmoke;
+exports.EventChannel = EventChannel;
+exports.FLUID_CAP_SIMULATION = (1);
+exports.FLUID_CAP_SURFACE = (2);
+exports.FLUID_COLLIDER_FLOATS = (19);
+exports.FLUID_COLLIDER_VOLUME = (18);
+exports.FLUID_DESC_FLOATS = (18);
+exports.FLUID_EMITTER_FLOATS = (12);
+exports.FLUID_FORCE_FLOATS = FLUID_FORCE_FLOATS;
+exports.FLUID_FORCE_WORDS = (6);
+exports.FLUID_MAX_COLLIDERS = (64);
+exports.FLUID_MAX_EMITTERS = (8);
+exports.FLUID_SURFACE_FLOATS = (17);
+exports.FOG_MODES = FOG_MODES;
+exports.FftAnalyser = FftAnalyser;
+exports.GI_MODES = GI_MODES;
+exports.HOB_DESC_WORDS = (12);
+exports.HOB_FIRST = (0);
+exports.HOB_FLAME_JOULES = (10);
+exports.HOB_FLAME_K = (9);
+exports.HOB_FLAME_LAYERS = (11);
+exports.HOB_LAST = (2);
+exports.HOB_LAYERS = (4);
+exports.HOB_METAL = (5);
+exports.HOB_PAN_JOULES = (8);
+exports.HOB_PAN_K = (7);
+exports.HOB_START_K = (6);
+exports.KERNEL_PRIORITIES = KERNEL_PRIORITIES;
+exports.MATERIAL_SLOTS = MATERIAL_SLOTS;
+exports.MAX_CHAIN_EFFECTS = (64);
+exports.MEDIA_VOLUME_FEATURE = MEDIA_VOLUME_FEATURE;
+exports.NODE_POSE_FLOATS = (7);
+exports.NO_REF = (4294967295);
+exports.OP_ANIMATION = (53);
+exports.OP_CLEAR_EMITTER = (50);
+exports.OP_DESTROY_EMITTER = (35);
+exports.OP_EMIT = (32);
+exports.OP_MARK_EMITTER = (34);
+exports.OP_MARK_TEXTURE_REGION = (54);
+exports.OP_RAW_COPY = (37);
+exports.OP_RAW_COPY_TEXTURE = (45);
+exports.OP_RAW_DESTROY_BUFFER = (38);
+exports.OP_RAW_DESTROY_TEXTURE = (43);
+exports.OP_RAW_DISPATCH = (36);
+exports.OP_RAW_DRAW = (42);
+exports.OP_RAW_MARK_BUFFER = (39);
+exports.OP_RAW_MARK_TEXTURE = (44);
+exports.OP_SET_CLIP_ADDITIVE = (47);
+exports.OP_SET_CLIP_MASK = (48);
+exports.OP_SET_EFFECT = (55);
+exports.OP_SET_EFFECT_TEXTURE = (60);
+exports.OP_SET_EMITTER_RATE = (33);
+exports.OP_SET_LOD = (46);
+exports.OP_SET_MATERIAL_WORD = (41);
+exports.OP_SET_RENDER_ORDER = (31);
+exports.OP_SET_SHADOW = (40);
+exports.OP_SET_TIME_OF_DAY = (52);
+exports.OP_SET_VOLUMETRICS = (61);
+exports.OP_SET_WEATHER = (51);
+exports.PASS_FLAGS = (12);
+exports.PASS_FLAG_CUBE_FACE = (1);
+exports.PASS_FLAG_ONCE = (4);
+exports.PASS_FLAG_REFLECT = (2);
+exports.PASS_PLANE = (13);
+exports.PASS_SLICE = (11);
+exports.PLUME_CELL = (0);
+exports.PLUME_KELVIN = (3);
+exports.PLUME_SMOKE = (4);
+exports.PLUME_WORLD = (5);
+exports.POST_EFFECT_TEXTURES = (4);
+exports.Queue = Queue;
+exports.REACTIVE_BURNING = (12);
+exports.REACTIVE_CAPACITY = (21);
+exports.REACTIVE_CELL = (6);
+exports.REACTIVE_CONTACT = (10);
+exports.REACTIVE_COUPLING = (11);
+exports.REACTIVE_DESC_WORDS = (32);
+exports.REACTIVE_DROPPED_PAIRS = (4);
+exports.REACTIVE_FEATURE = REACTIVE_FEATURE;
+exports.REACTIVE_FIRED = (10);
+exports.REACTIVE_FLAME_EXTINCTION = (23);
+exports.REACTIVE_GLOW_FROM_K = (20);
+exports.REACTIVE_GLOW_FULL_K = (21);
+exports.REACTIVE_GRID = (0);
+exports.REACTIVE_HOTTEST_K = (14);
+exports.REACTIVE_LIQUID = (7);
+exports.REACTIVE_LIQUID_KELVIN = (8);
+exports.REACTIVE_LIT = (22);
+exports.REACTIVE_MAX_EDGE = (64);
+exports.REACTIVE_MAX_PAIRS = (12);
+exports.REACTIVE_MAX_PLUMES = (8);
+exports.REACTIVE_MAX_PREHEAT_TICKS = (4096);
+exports.REACTIVE_MAX_STEP_SECONDS = (0.1);
+exports.REACTIVE_ORIGIN = (3);
+exports.REACTIVE_PAIRS = (3);
+exports.REACTIVE_PAN_K = (11);
+exports.REACTIVE_PARCELS = (9);
+exports.REACTIVE_PARTICLES = (9);
+exports.REACTIVE_PLUMES = (32);
+exports.REACTIVE_PLUME_COUNT = (15);
+exports.REACTIVE_PLUME_FROM_K = (24);
+exports.REACTIVE_PLUME_WORDS = (8);
+exports.REACTIVE_RETIRED = (8);
+exports.REACTIVE_SEED_HIGH = (14);
+exports.REACTIVE_SEED_LOW = (13);
+exports.REACTIVE_SMOKE = (16);
+exports.REACTIVE_SMOKE_FULL = (22);
+exports.REACTIVE_SMOKE_SPECIES = (4);
+exports.REACTIVE_SMOKY = (13);
+exports.REACTIVE_TICK_HIGH = (1);
+exports.REACTIVE_TICK_LOW = (0);
+exports.REACTIVE_VENTED = (7);
+exports.RENDER_CORE_EXPORTS = RENDER_CORE_EXPORTS;
+exports.RENDER_FEATURE_EXPORTS = RENDER_FEATURE_EXPORTS;
+exports.RENDER_FEED_POSE_FEATURE = RENDER_FEED_POSE_FEATURE;
+exports.RENDER_KERNEL_INSTANCES_FEATURE = RENDER_KERNEL_INSTANCES_FEATURE;
+exports.ROOT_MOTION_APPLY = (8);
+exports.ROOT_MOTION_XZ = (1);
+exports.ROOT_MOTION_Y = (2);
+exports.ROOT_MOTION_YAW = (4);
+exports.SCENERY_REGISTER = SCENERY_REGISTER;
+exports.SCENERY_REGISTER_WORDS = (20);
+exports.SCENERY_REQUEST_SLOTS = (8);
+exports.SMOKE_DESC_FLOATS = (24);
+exports.SMOKE_MAX_EMITTERS = (8);
+exports.SMOKE_TINTED_EMITTER_FLOATS = (14);
+exports.SMOKE_TINT_AT = (11);
+exports.STAT_DRAW_CALLS = (32);
+exports.STAT_GPU_BYTES_HIGH = (21);
+exports.STAT_GPU_BYTES_LOW = (20);
+exports.STAT_GPU_LAST_NS = (17);
+exports.STAT_GPU_P50_NS = (18);
+exports.STAT_GPU_P95_NS = (19);
+exports.STAT_PARTICLES_ALIVE = (24);
+exports.STAT_RAW_DISABLED = (27);
+exports.STAT_RAW_DISPATCHES = (25);
+exports.STAT_RAW_GPU_NS = (26);
+exports.STAT_TEXT_GLYPHS = (29);
+exports.STAT_THERMAL_TIER = (23);
+exports.STAT_TRANSPARENT_SORTED = (28);
+exports.STAT_TRIANGLES = (33);
+exports.STENCIL_OPERATIONS = STENCIL_OPERATIONS;
+exports.STREAM_ACTOR_FLOATS = (2);
+exports.STREAM_COLLIDER_FLOATS = (8);
+exports.STREAM_EYE_FLOATS = (6);
+exports.STREAM_LAZY_PACKS_FLAG = (256);
+exports.STREAM_MAX_PACK_RELEASES = (16);
+exports.STREAM_MAX_PACK_REQUESTS = (16);
+exports.STREAM_OP_INSERT = (1);
+exports.STREAM_PACK_CONTENDED = (-6);
+exports.STREAM_PACK_MASK = STREAM_PACK_MASK;
+exports.STREAM_PACK_RELEASES = (17);
+exports.STREAM_PACK_REQUESTS = (16);
+exports.STREAM_PRIORITY_NOW = (0);
+exports.STREAM_PRIORITY_SHIFT = (24);
+exports.STREAM_PRIORITY_SOON = (1);
+exports.STREAM_REGISTER = STREAM_REGISTER;
+exports.STREAM_REGISTER_BLOCK_WORDS = STREAM_REGISTER_BLOCK_WORDS;
+exports.STREAM_RELEASE_LIST = STREAM_RELEASE_LIST;
+exports.STREAM_REQUEST_LIST = (18);
+exports.STREAM_START_PACK = (0);
+exports.TARGET_COLORS = (7);
+exports.TARGET_KIND = (5);
+exports.TARGET_KIND_2D = (0);
+exports.TARGET_KIND_ARRAY = (2);
+exports.TARGET_KIND_CUBE = (1);
+exports.TARGET_LAYERS = (6);
+exports.TARGET_MAX_COLORS = (4);
+exports.TARGET_SAMPLED_DEPTH = (8);
+exports.TARGET_TEXTURES = (16);
+exports.TEXTURE_ENCODE_ASTC_4X4 = (2);
+exports.TEXTURE_ENCODE_AUTO = (1);
+exports.TEXTURE_ENCODE_BC7 = (3);
+exports.TEXTURE_FORMAT_R16F = (5);
+exports.TEXTURE_FORMAT_R16UI = (10);
+exports.TEXTURE_FORMAT_R32F = (7);
+exports.TEXTURE_FORMAT_R32I = (16);
+exports.TEXTURE_FORMAT_R32UI = (11);
+exports.TEXTURE_FORMAT_R8 = (3);
+exports.TEXTURE_FORMAT_R8UI = (9);
+exports.TEXTURE_FORMAT_RG16F = (6);
+exports.TEXTURE_FORMAT_RG32F = (8);
+exports.TEXTURE_FORMAT_RG32UI = (12);
+exports.TEXTURE_FORMAT_RG8 = (4);
+exports.TEXTURE_FORMAT_RGBA16UI = (14);
+exports.TEXTURE_FORMAT_RGBA32I = (17);
+exports.TEXTURE_FORMAT_RGBA32UI = (15);
+exports.TEXTURE_FORMAT_RGBA8UI = (13);
+exports.TEXTURE_KIND_2D_ARRAY = (3);
+exports.TEXTURE_KIND_3D = (4);
+exports.TEXTURE_KIND_EXTERNAL = (5);
+exports.TIER_INDEX = TIER_INDEX;
+exports.TONE_MAPPINGS = TONE_MAPPINGS;
+exports.TRANSFORM_EXPORT_NAMES = TRANSFORM_EXPORT_NAMES;
+exports.VECTOR_SURFACE_CAPS = VECTOR_SURFACE_CAPS;
+exports.VECTOR_SURFACE_EDGES = VECTOR_SURFACE_EDGES;
+exports.VECTOR_SURFACE_TIERS = VECTOR_SURFACE_TIERS;
+exports.analyserSettings = analyserSettings;
+exports.bindChemistryEngine = bindChemistryEngine;
+exports.bindData = bindData;
+exports.bindTransformEngine = bindTransformEngine;
+exports.bitExtract = bitExtract;
+exports.bitInsert = bitInsert;
+exports.clz = clz;
+exports.computeLogLine = computeLogLine;
+exports.createVectorSurfaceStats = createVectorSurfaceStats;
+exports.ctz = ctz;
+exports.dataColumn = dataColumn;
+exports.dataTables = dataTables;
+exports.emitRow = emitRow;
+exports.engineDestructionExports = engineDestructionExports;
+exports.engineFluidExports = engineFluidExports;
+exports.engineReactiveExports = engineReactiveExports;
+exports.engineSmokeExports = engineSmokeExports;
+exports.events = events;
+exports.f64 = f64;
+exports.f64Bits = f64Bits;
+exports.hasData = hasData;
+exports.list = list;
+exports.listPool = listPool;
+exports.listPoolAddress = listPoolAddress;
+exports.morton2 = morton2;
+exports.morton2Wide = morton2Wide;
+exports.morton3 = morton3;
+exports.morton3Wide = morton3Wide;
+exports.pickRows = pickRows;
+exports.popcnt = popcnt;
+exports.priorityLevel = priorityLevel;
+exports.queue = queue;
+exports.readDataReport = readDataReport;
+exports.readList = readList;
+exports.reportData = reportData;
+exports.rotl = rotl;
+exports.rotr = rotr;
+exports.routeEvents = routeEvents;
+exports.scalarArgs = scalarArgs;
+exports.setEmitRow = setEmitRow;
+exports.setPoolEngine = setPoolEngine;
+exports.symbol = symbol2;
+exports.toU32 = toU32;
+exports.transformEngine = transformEngine;
+exports.u64 = u64;
+exports.u64Words = u64Words;
+exports.unmorton2 = unmorton2;
+exports.unmorton3 = unmorton3;
+exports.useTransformEngine = useTransformEngine;
+exports.writeWideArg = writeWideArg;