@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-GXKI64OT.mjs

@@ -0,0 +1,1138 @@
+import { JOINT_AXES, POSE_STRIDE, NO_PARENT } from './chunk-NHJUGZUR.mjs';
+import { VECTOR_SURFACE_CAPS, VECTOR_SURFACE_TIERS, FftAnalyser } from './chunk-E65WCTIG.mjs';
+import { OCCLUSION_WORDS, MUSIC_POSITION_WORDS, MAX_STEMS, SPATIAL_WORDS, EMITTER_COLUMNS, METER_PEAK, METER_RMS, detuneRate, ANALYSER_FREQUENCY, AUDIO_PREVIEW_SUFFIX, DEFAULT_PRIORITY, PRIORITY_MASK, PLAY_PRIORITY_SHIFT, PHRASE_QUANTIZE_SHIFT } from './chunk-5YFBGGCK.mjs';
+import { COLUMN_ALIGN, ERROR_UNSUPPORTED, ERROR_UNKNOWN_RESOURCE, ERROR_DEAD_ENTITY, ERROR_CAPACITY_EXCEEDED } from './chunk-A33OORT7.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/backends/engine/vector-surfaces.ts
+var ENGINE_VECTOR_SURFACE_EXPORT_NAMES = [
+  "engine_render_vector_load",
+  "engine_render_vector_unload",
+  "engine_render_vector_surface",
+  "engine_render_vector_surface_destroy",
+  "engine_render_vector_surface_node",
+  "engine_render_vector_surface_play",
+  "engine_render_vector_surface_input_index",
+  "engine_render_vector_surface_input",
+  "engine_render_vector_surface_data_index",
+  "engine_render_vector_surface_data_set",
+  "engine_render_vector_surface_pointer",
+  "engine_render_vector_surface_pick",
+  "engine_render_vector_frame",
+  "engine_render_vector_events",
+  "engine_render_vector_event_count",
+  "engine_render_vector_surface_tier",
+  "engine_render_vector_surface_stats"
+], ENGINE_VECTOR_SURFACE_SEEK_EXPORT = "engine_render_vector_surface_seek";
+function engineVectorSurfaceExports(symbols) {
+  for (let name of ENGINE_VECTOR_SURFACE_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return symbols;
+}
+var VECTOR_SURFACE_PHASES = { down: 0, move: 1, up: 2, cancel: 3 }, VECTOR_SURFACE_PLAYS = { machine: 0, animation: 1, stop: 2 }, VECTOR_SURFACE_SEEKS = { machine: 0, animation: 1 }, VECTOR_SURFACE_DATA_KINDS = { number: 0, bool: 1, color: 2, id: 3, fire: 4 }, VECTOR_SURFACE_EVENT_BYTES = 32, VECTOR_SURFACE_EVENT_KIND = 14, VECTOR_SURFACE_STATS_WORDS = 8, VECTOR_SURFACE_RAY_WORDS = 7, EVENT_KIND_OFFSET = 0, EVENT_NODE_OFFSET = 4, EVENT_VALUE_OFFSET = 24, STAT_CAP = 0, STAT_LIVE = 1, STAT_ENCODED = 2, STAT_UNCHANGED = 3, STAT_OFFSCREEN = 4, STAT_OCCLUDED = 5, STAT_OVER_CAP = 6, STAT_DROPPED = 7, NO_NODE = 0, NO_SURFACE = 0, CONSUMED = 1, MICROS_PER_SECOND = 1e6, RAY_FAR = 6, UTF8 = new TextEncoder();
+function failure(code, what) {
+  switch (code) {
+    case ERROR_CAPACITY_EXCEEDED:
+      return new GameError("capacity_exceeded", `${what}: capacity exceeded`);
+    case ERROR_DEAD_ENTITY:
+    case ERROR_UNKNOWN_RESOURCE:
+      return new GameError("unknown_resource", `${what}: unknown resource`);
+    case ERROR_UNSUPPORTED:
+      return new GameError("unsupported_feature", `${what}: unsupported`);
+    default:
+      return new GameError("invalid_argument", `${what}: invalid argument`);
+  }
+}
+function checked(code, what) {
+  if (code < 0) throw failure(code, what);
+  return code;
+}
+var EngineVectorSurfaces = class {
+  constructor(exports, host) {
+    this.exports = exports;
+    this.host = host;
+    this.surfaces = 0;
+    this.tier = "mid";
+    this.ray = new Float32Array((7));
+    this.rayBytes = new Uint8Array(this.ray.buffer);
+  }
+  get cap() {
+    return VECTOR_SURFACE_CAPS[this.tier];
+  }
+  get handle() {
+    return this.host.handle;
+  }
+  load(bytes) {
+    if (bytes.byteLength === 0) throw new GameError("invalid_argument", "a vector asset needs its bytes");
+    let at = this.host.stage(bytes);
+    return checked(this.exports.engine_render_vector_load(this.handle, at, bytes.byteLength), "load vector");
+  }
+  unload(asset) {
+    checked(this.exports.engine_render_vector_unload(this.handle, asset), "unload vector");
+  }
+  create(desc) {
+    this.host.flush();
+    let surface = checked(
+      this.exports.engine_render_vector_surface(this.handle, desc.asset, desc.artboard ?? 0, desc.target, desc.node ?? (0)),
+      "create vector surface"
+    );
+    return this.surfaces++, surface;
+  }
+  destroy(surface) {
+    checked(this.exports.engine_render_vector_surface_destroy(this.handle, surface), "destroy vector surface"), this.surfaces--;
+  }
+  setNode(surface, node) {
+    this.host.flush(), checked(this.exports.engine_render_vector_surface_node(this.handle, surface, node ?? (0)), "vector surface node");
+  }
+  play(surface, kind, index) {
+    checked(this.exports.engine_render_vector_surface_play(this.handle, surface, VECTOR_SURFACE_PLAYS[kind], index), "play vector surface");
+  }
+  seek(surface, kind, index, seconds) {
+    let seekExport = this.exports[ENGINE_VECTOR_SURFACE_SEEK_EXPORT];
+    if (seekExport === void 0) throw new GameError("unsupported_feature", "this engine cannot seek vector surfaces");
+    checked(seekExport(this.handle, surface, VECTOR_SURFACE_SEEKS[kind], index, seconds), "seek vector surface");
+  }
+  inputIndex(surface, name) {
+    let bytes = UTF8.encode(name);
+    if (bytes.byteLength === 0) throw new GameError("invalid_argument", "a vector input needs a name");
+    let at = this.host.stage(bytes);
+    return checked(this.exports.engine_render_vector_surface_input_index(this.handle, surface, at, bytes.byteLength), `vector input ${name}`);
+  }
+  setInput(surface, input, value) {
+    checked(this.exports.engine_render_vector_surface_input(this.handle, surface, input, value), "vector input");
+  }
+  dataIndex(surface, path) {
+    let bytes = UTF8.encode(path);
+    if (bytes.byteLength === 0) throw new GameError("invalid_argument", "vector data needs a path");
+    let at = this.host.stage(bytes);
+    return checked(this.exports.engine_render_vector_surface_data_index(this.handle, surface, at, bytes.byteLength), `vector data ${path}`);
+  }
+  setData(surface, handle, kind, value) {
+    let bits = kind === "color" || kind === "id" ? value >>> 0 : 0;
+    checked(
+      this.exports.engine_render_vector_surface_data_set(this.handle, surface, handle, VECTOR_SURFACE_DATA_KINDS[kind], value, bits),
+      "vector data"
+    );
+  }
+  pointer(surface, phase, u, v) {
+    return checked(this.exports.engine_render_vector_surface_pointer(this.handle, surface, VECTOR_SURFACE_PHASES[phase], u, v), "vector pointer") === (1);
+  }
+  pick(origin, direction, far, phase) {
+    this.host.flush();
+    let ray = this.ray;
+    ray[0] = origin[0], ray[1] = origin[1], ray[2] = origin[2], ray[3] = direction[0], ray[4] = direction[1], ray[5] = direction[2], ray[(6)] = far;
+    let at = this.host.stage(this.rayBytes), surface = checked(this.exports.engine_render_vector_surface_pick(this.handle, VECTOR_SURFACE_PHASES[phase], at), "pick vector surface");
+    return surface === (0) ? null : surface;
+  }
+  events(out) {
+    let count = this.exports.engine_render_vector_event_count(this.handle);
+    if (count === 0)
+      return out.length = 0, 0;
+    let view2 = new DataView(this.host.buffer(), this.exports.engine_render_vector_events(this.handle), count * (32)), written = 0;
+    for (let k = 0; k < count; k++) {
+      let at = k * (32);
+      if (view2.getUint8(at + (0)) !== (14)) continue;
+      let surface = view2.getUint32(at + (4), true), event = view2.getFloat32(at + (24), true), slot = out[written];
+      slot === void 0 ? out.push({ surface, event }) : (slot.surface = surface, slot.event = event), written++;
+    }
+    return out.length = written, written;
+  }
+  stats(out) {
+    let at = this.exports.engine_render_vector_surface_stats(this.handle);
+    if (at === 0) throw new GameError("unknown_resource", "vector surface stats are unavailable");
+    let words = new Uint32Array(this.host.buffer(), at, (8));
+    out.cap = words[(0)], out.live = words[(1)], out.encoded = words[(2)], out.unchanged = words[(3)], out.offscreen = words[(4)], out.occluded = words[(5)], out.overCap = words[(6)], out.droppedEvents = words[(7)];
+  }
+  setTier(tier) {
+    checked(this.exports.engine_render_vector_surface_tier(this.handle, VECTOR_SURFACE_TIERS[tier]), "vector surface tier"), this.tier = tier;
+  }
+  frame(seconds) {
+    this.surfaces !== 0 && checked(this.exports.engine_render_vector_frame(this.handle, Math.round(seconds * (1e6))), "vector surface frame");
+  }
+};
+
+// src/game/backends/engine/memory.ts
+var NULL_POINTER = 0;
+function view(buffer, scalar, pointer, length) {
+  switch (scalar) {
+    case "f32":
+      return new Float32Array(buffer, pointer, length);
+    case "f64":
+      return new Float64Array(buffer, pointer, length);
+    case "i8":
+      return new Int8Array(buffer, pointer, length);
+    case "i16":
+      return new Int16Array(buffer, pointer, length);
+    case "i32":
+      return new Int32Array(buffer, pointer, length);
+    case "u8":
+      return new Uint8Array(buffer, pointer, length);
+    case "u16":
+      return new Uint16Array(buffer, pointer, length);
+    case "u32":
+      return new Uint32Array(buffer, pointer, length);
+  }
+}
+var SCALAR_BYTES = { f32: 4, f64: 8, i8: 1, i16: 2, i32: 4, u8: 1, u16: 2, u32: 4 }, ENGINE_ARENA_EXPORT_NAMES = ["engine_arena_committed", "engine_arena_ceiling", "engine_arena_set_ceiling", "engine_arena_release"], NOTHING_RELEASED = 0;
+function sizeQuery(symbols, name) {
+  let query = symbols[name];
+  return typeof query == "function" ? query : null;
+}
+function engineArenaStats(symbols) {
+  let used = sizeQuery(symbols, "engine_memory_used"), committed = sizeQuery(symbols, "engine_arena_committed"), ceiling = sizeQuery(symbols, "engine_arena_ceiling");
+  return used === null || committed === null || ceiling === null ? null : { used: used(), committed: committed(), ceiling: ceiling() };
+}
+function releaseEngineArena(symbols) {
+  return sizeQuery(symbols, "engine_arena_release")?.() ?? (0);
+}
+function arenaDetail(symbols) {
+  let stats = engineArenaStats(symbols);
+  return stats === null ? "" : ` (using ${stats.used} of a ${stats.ceiling} byte ceiling, ${stats.committed} committed)`;
+}
+var EngineMemory = class {
+  constructor(runtime) {
+    this.pointers = [];
+    this.sizes = [];
+    this.runtime = runtime;
+  }
+  owns(array) {
+    return array.buffer === this.runtime.memory.buffer;
+  }
+  allocate(scalar, length) {
+    let bytes = Math.max(length * SCALAR_BYTES[scalar], COLUMN_ALIGN), pointer = this.runtime.exports.engine_alloc(bytes, COLUMN_ALIGN);
+    if (pointer === (0)) throw new GameError("capacity_exceeded", `engine memory cannot hold ${bytes} more bytes${arenaDetail(this.runtime.symbols)}`);
+    return this.pointers.push(pointer), this.sizes.push(bytes), view(this.runtime.memory.buffer, scalar, pointer, length);
+  }
+  release() {
+    for (let i = 0; i < this.pointers.length; i++)
+      this.runtime.exports.engine_free(this.pointers[i], this.sizes[i], COLUMN_ALIGN);
+    this.pointers.length = 0, this.sizes.length = 0;
+  }
+};
+
+// src/game/rollback-state.ts
+function bytesOf(view2) {
+  return new Uint8Array(view2.buffer, view2.byteOffset, view2.byteLength);
+}
+var StateRing = class {
+  constructor(frames, engine = null) {
+    this.states = [];
+    this.known = [];
+    this.copies = [];
+    this.stride = 0;
+    this.slots = new Uint8Array(0);
+    this.slices = [];
+    this.stale = true;
+    this.breaks = 0;
+    this.frames = frames, this.engine = engine, this.ticks = new Float64Array(frames).fill(-1);
+  }
+  attach(state) {
+    this.states.includes(state) || (this.states.push(state), this.stale = true);
+  }
+  save(tick) {
+    this.changed() && this.relayout();
+    let slot = this.slot(tick), copies = this.copies, slices = this.slices, base = slot * copies.length;
+    for (let i = 0; i < copies.length; i++) slices[base + i].set(copies[i]);
+    this.ticks[slot] = tick;
+  }
+  has(tick) {
+    return !this.changed() && this.ticks[this.slot(tick)] === tick;
+  }
+  restore(tick) {
+    if (!this.has(tick)) return false;
+    let copies = this.copies, slices = this.slices, base = this.slot(tick) * copies.length;
+    for (let i = 0; i < copies.length; i++) copies[i].set(slices[base + i]);
+    for (let s = 0; s < this.frames; s++) this.ticks[s] > tick && (this.ticks[s] = -1);
+    return true;
+  }
+  clear() {
+    this.ticks.fill(-1);
+  }
+  dropAfter(tick) {
+    for (let s = 0; s < this.frames; s++) this.ticks[s] > tick && (this.ticks[s] = -1);
+  }
+  slot(tick) {
+    return (tick % this.frames + this.frames) % this.frames;
+  }
+  changed() {
+    if (this.stale) return true;
+    let index = 0, known = this.known, states = this.states;
+    for (let s = 0; s < states.length; s++) {
+      let views = states[s].rollbackViews();
+      for (let v = 0; v < views.length; v++) {
+        if (known[index] !== views[v]) return true;
+        index++;
+      }
+    }
+    return index !== known.length;
+  }
+  relayout() {
+    let known = [], copies = [], stride = 0;
+    for (let state of this.states)
+      for (let view2 of state.rollbackViews()) {
+        if (known.push(view2), this.engine !== null && this.engine.owns(view2)) {
+          this.engine.adopt(view2);
+          continue;
+        }
+        let bytes = bytesOf(view2);
+        copies.push(bytes), stride += bytes.byteLength;
+      }
+    this.known = known, this.copies = copies, (stride !== this.stride || this.slots.byteLength !== stride * this.frames) && (this.stride = stride, this.slots = new Uint8Array(stride * this.frames));
+    let slices = [];
+    for (let slot = 0, at = 0; slot < this.frames; slot++)
+      for (let bytes of copies)
+        slices.push(this.slots.subarray(at, at + bytes.byteLength)), at += bytes.byteLength;
+    this.slices = slices, (!this.stale || this.ticks.some((tick) => tick !== -1)) && this.breaks++, this.ticks.fill(-1), this.stale = false;
+  }
+};
+
+// src/game/physics/rollback.ts
+var ENGINE_ROLLBACK_EXPORT_NAMES = [
+  "engine_world_rollback_create",
+  "engine_world_snapshot_save",
+  "engine_world_snapshot_restore",
+  "engine_world_snapshot_clear",
+  "engine_world_snapshot_track",
+  "engine_world_snapshot_track_table",
+  "engine_world_snapshot_untrack",
+  "engine_world_snapshot_mark",
+  "engine_world_snapshot_registers",
+  "engine_world_snapshot_digest"
+], ROLLBACK_CONFIG_WORDS = 4, ROLLBACK_CONFIG_REGION = 0, ROLLBACK_CONFIG_TRACKED = 1, ROLLBACK_CONFIG_JOURNAL = 2, ROLLBACK_CONFIG_FRAMES = 3, SNAPSHOT_POLICY_SCAN = 0, SNAPSHOT_POLICY_MARKED = 1, SNAPSHOT_REGISTER_WORDS = 16, SNAPSHOT_NO_FRAME = 4294967295, DEFAULT_ROLLBACK_REGION_BYTES = 16 * 1024 * 1024, DEFAULT_ROLLBACK_TRACKED_BYTES = 4 * 1024 * 1024, DEFAULT_ROLLBACK_JOURNAL_BYTES = 8 * 1024 * 1024, DEFAULT_ROLLBACK_FRAMES = 8, MAX_ROLLBACK_FRAMES = 64, REG_DEPTH = 0, REG_NEWEST = 1, REG_OLDEST = 2, REG_DIRTY = 3, REG_SCANNED = 4, REG_RESTORED = 5, REG_SAVE_NS = 6, REG_RESTORE_NS = 7, REG_EVICTED = 8, REG_HEAP_BYTES = 9, REG_TRACKED = 10, REG_SPILLS = 11, REG_BREAKS = 12, REG_RESIDENTS = 13, REG_QUIET = 14, REG_MISSED = 15, ERROR_UNKNOWN_RESOURCE2 = -3, ERROR_CAPACITY_EXCEEDED2 = -1, NANOS_PER_MS = 1e6, DIGEST_BYTES = 8, DIGEST_ALIGN = 8;
+function hasRollback(symbols) {
+  return ENGINE_ROLLBACK_EXPORT_NAMES.every((name) => typeof symbols[name] == "function");
+}
+function writeRollbackConfig(out, desc) {
+  let frames = desc.frames ?? (8);
+  if (!Number.isInteger(frames) || frames < 2 || frames > (64)) throw new GameError("invalid_argument", `rollback frames must be 2..${(64)}`);
+  out[(0)] = desc.regionBytes ?? DEFAULT_ROLLBACK_REGION_BYTES, out[(1)] = desc.trackedBytes ?? DEFAULT_ROLLBACK_TRACKED_BYTES, out[(2)] = desc.journalBytes ?? DEFAULT_ROLLBACK_JOURNAL_BYTES, out[(3)] = frames;
+}
+function policyCode(policy) {
+  return policy === "marked" ? (1) : (0);
+}
+function optionalFrame(word) {
+  return word === (4294967295) ? null : word;
+}
+var ENGINE_KEYFRAME_EXPORT_NAMES = [
+  "engine_world_keyframes_enable",
+  "engine_world_keyframe_save",
+  "engine_world_keyframe_seek",
+  "engine_world_keyframe_nearest",
+  "engine_world_keyframe_truncate",
+  "engine_world_keyframe_registers"
+], KEYFRAME_REGISTER_WORDS = 8, DEFAULT_KEYFRAME_EVERY = 60, DEFAULT_KEYFRAME_SLOTS = 64, DEFAULT_KEYFRAME_LEAVES = 16384, KEY_COUNT = 0, KEY_OLDEST = 1, KEY_NEWEST = 2, KEY_LEAVES_USED = 3, KEY_LEAVES_SHARED = 4, KEY_CAPTURES = 5, KEY_EVICTED = 6, KEY_INSTALLS = 7;
+function keyframeExports(symbols) {
+  let s = symbols;
+  return ENGINE_KEYFRAME_EXPORT_NAMES.every((name) => typeof s[name] == "function") ? symbols : null;
+}
+var WorldSnapshots = class _WorldSnapshots {
+  constructor(exports, memory, world, beforeRestore, frames) {
+    this.exports = exports;
+    this.memory = memory;
+    this.world = world;
+    this.beforeRestore = beforeRestore;
+    this.view = new Uint32Array(0);
+    this.digestAt = 0;
+    this.keyRing = null;
+    this.keyframes = null;
+    this.every = (60);
+    this.states = [];
+    this.ring = new StateRing(frames, {
+      owns: (view2) => view2.buffer === this.memory.buffer,
+      adopt: (view2) => this.adopt(view2)
+    });
+  }
+  static bind(symbols, memory, world, beforeRestore = () => {
+  }, frames = (8)) {
+    if (!hasRollback(symbols) || typeof symbols.engine_alloc != "function") return null;
+    let exports = symbols;
+    return exports.engine_world_snapshot_registers(world) === 0 ? null : new _WorldSnapshots(exports, memory, world, beforeRestore, frames);
+  }
+  attach(state) {
+    this.ring.attach(state), this.keyRing?.attach(state), this.states.push(state);
+  }
+  enableKeyframes(desc) {
+    let keyframes = keyframeExports(this.exports);
+    if (keyframes === null) return false;
+    let every = desc.every ?? (60), slots = desc.slots ?? (64);
+    if (!Number.isInteger(every) || every < 1) throw new GameError("invalid_argument", "keyframes come every whole number of ticks");
+    this.check(keyframes.engine_world_keyframes_enable(this.world, desc.leaves ?? (16384), slots), "keyframes enable"), this.keyframes = keyframes, this.every = every, this.keyRing = new StateRing(slots, {
+      owns: (view2) => view2.buffer === this.memory.buffer,
+      adopt: (view2) => this.adopt(view2)
+    });
+    for (let state of this.states) this.keyRing.attach(state);
+    return true;
+  }
+  get keyframeEvery() {
+    return this.every;
+  }
+  keyframe(tick) {
+    let keyframes = this.keyframes, ring = this.keyRing;
+    return keyframes === null || ring === null || tick % this.every !== 0 ? false : (this.check(keyframes.engine_world_keyframe_save(this.world, tick >>> 0), "keyframe save"), ring.save(tick / this.every), true);
+  }
+  nearestKeyframe(at) {
+    let keyframes = this.keyframes;
+    if (keyframes === null) return null;
+    let label = keyframes.engine_world_keyframe_nearest(this.world, at >>> 0);
+    return label === (-3) ? null : this.check(label, "keyframe nearest");
+  }
+  seekKeyframe(tick) {
+    let keyframes = this.keyframes, ring = this.keyRing;
+    if (keyframes === null || ring === null || tick % this.every !== 0 || (this.beforeRestore(), !ring.has(tick / this.every))) return false;
+    let code = keyframes.engine_world_keyframe_seek(this.world, tick >>> 0);
+    return code === (-3) ? false : (this.check(code, "keyframe seek"), ring.restore(tick / this.every), this.ring.clear(), this.truncateKeyframes(tick), true);
+  }
+  truncateKeyframes(after) {
+    this.keyframes !== null && (this.check(this.keyframes.engine_world_keyframe_truncate(this.world, after >>> 0), "keyframe truncate"), this.keyRing?.dropAfter(Math.floor(after / this.every)));
+  }
+  clearKeyframes() {
+    this.keyframes !== null && (this.clear(), this.keyRing?.clear());
+  }
+  keyframeStats() {
+    if (this.keyframes === null) return null;
+    let at = this.keyframes.engine_world_keyframe_registers(this.world), r = new Uint32Array(this.memory.buffer, at, (8));
+    return {
+      frames: r[(0)],
+      oldest: optionalFrame(r[(1)]),
+      newest: optionalFrame(r[(2)]),
+      leavesUsed: r[(3)],
+      leavesShared: r[(4)],
+      captures: r[(5)],
+      evicted: r[(6)],
+      installs: r[(7)]
+    };
+  }
+  get stateBreaks() {
+    return this.ring.breaks;
+  }
+  save(tick) {
+    let dirty = this.check(this.exports.engine_world_snapshot_save(this.world, tick >>> 0), "snapshot save");
+    return this.ring.save(tick >>> 0), dirty;
+  }
+  restore(tick) {
+    if (this.beforeRestore(), !this.ring.has(tick >>> 0)) return false;
+    let code = this.exports.engine_world_snapshot_restore(this.world, tick >>> 0);
+    return code === (-3) ? false : (this.check(code, "snapshot restore"), this.ring.restore(tick >>> 0));
+  }
+  clear() {
+    this.check(this.exports.engine_world_snapshot_clear(this.world), "snapshot clear"), this.ring.clear();
+  }
+  adopt(view2) {
+    if (this.exports.engine_world_snapshot_track(this.world, view2.byteOffset, view2.byteLength, (0)) === (-1)) throw new GameError("capacity_exceeded", "rollback trackedBytes is too small for the game's engine-memory state");
+  }
+  track(view2, policy = "scan") {
+    this.owned(view2), this.check(this.exports.engine_world_snapshot_track(this.world, view2.byteOffset, view2.byteLength, policyCode(policy)), "snapshot track");
+  }
+  trackTable(table, policy = "scan") {
+    this.check(this.exports.engine_world_snapshot_track_table(this.world, table, policyCode(policy)), "snapshot track table");
+  }
+  untrack(view2) {
+    this.owned(view2), this.check(this.exports.engine_world_snapshot_untrack(this.world, view2.byteOffset), "snapshot untrack");
+  }
+  mark(view2, from = 0, to) {
+    let stride = view2.BYTES_PER_ELEMENT, end = Math.min(to ?? view2.byteLength / stride, view2.byteLength / stride);
+    return end <= from ? false : this.exports.engine_world_snapshot_mark(this.world, view2.byteOffset + from * stride, (end - from) * stride) === 1;
+  }
+  digest() {
+    return this.digestAt === 0 && (this.digestAt = this.exports.engine_alloc((8), (8))), this.check(this.exports.engine_world_snapshot_digest(this.world, this.digestAt), "snapshot digest"), new DataView(this.memory.buffer, this.digestAt, (8)).getBigUint64(0, true);
+  }
+  stats() {
+    let r = this.registers();
+    return {
+      depth: r[(0)],
+      newest: optionalFrame(r[(1)]),
+      oldest: optionalFrame(r[(2)]),
+      dirtyPages: r[(3)],
+      scannedPages: r[(4)],
+      restoredPages: r[(5)],
+      saveMs: r[(6)] / (1e6),
+      restoreMs: r[(7)] / (1e6),
+      evicted: r[(8)],
+      heapBytes: r[(9)],
+      trackedPages: r[(10)],
+      spilled: r[(11)] !== 0,
+      breaks: r[(12)] + this.ring.breaks,
+      residents: r[(13)],
+      quietPages: r[(14)],
+      missedPages: r[(15)]
+    };
+  }
+  registers() {
+    let at = this.exports.engine_world_snapshot_registers(this.world), buffer = this.memory.buffer;
+    return (this.view.buffer !== buffer || this.view.byteOffset !== at) && (this.view = new Uint32Array(buffer, at, (16))), this.view;
+  }
+  owned(view2) {
+    if (view2.buffer !== this.memory.buffer) throw new GameError("invalid_argument", "rolled-back views must live in engine memory");
+  }
+  check(code, what) {
+    if (code >= 0) return code;
+    throw new GameError(code === (-3) ? "unknown_resource" : "invalid_argument", `${what} failed (${code})`);
+  }
+};
+
+// src/game/audio/engine.ts
+var MUSIC_EXPORTS = [
+  "engine_audio_music_tempo",
+  "engine_audio_music_play",
+  "engine_audio_music_layer",
+  "engine_audio_music_stinger",
+  "engine_audio_music_stop",
+  "engine_audio_music_position"
+], WORD_BYTES = 4, DOUBLE_WORD_BYTES = 8, MUSIC_POSITION_OFFSET = 2 * MAX_STEMS * (4), MUSIC_OCCLUSION_OFFSET = MUSIC_POSITION_OFFSET + MUSIC_POSITION_WORDS * (8), MUSIC_STAGING_BYTES = MUSIC_OCCLUSION_OFFSET + OCCLUSION_WORDS * (4), ENGINE_SAMPLE_RATE = 48e3, ENGINE_AUDIO_EXPORT_NAMES = [
+  "engine_audio_bound",
+  "engine_audio_load_pcm",
+  "engine_audio_load_wav",
+  "engine_audio_release",
+  "engine_audio_create_bus",
+  "engine_audio_set_bus_gain",
+  "engine_audio_set_bus_filter",
+  "engine_audio_set_duck",
+  "engine_audio_play",
+  "engine_audio_stop",
+  "engine_audio_set_voice_gain",
+  "engine_audio_set_voice_rate",
+  "engine_audio_is_playing",
+  "engine_audio_set_listener",
+  "engine_audio_place",
+  "engine_audio_set_voice_spatial",
+  "engine_audio_registers",
+  "engine_audio_update",
+  "engine_audio_meter",
+  "engine_audio_suspend",
+  "engine_audio_resume",
+  "engine_audio_reset"
+];
+var ENGINE_AUDIO_LOCKSTEP_EXPORTS = [
+  "engine_audio_lockstep",
+  "engine_audio_clock",
+  "engine_audio_create_emitters",
+  "engine_audio_feed_emitters",
+  "engine_audio_release_emitters"
+], ENGINE_AUDIO_WORKLET_EXPORTS = ["engine_audio_relay_create", "engine_audio_relay_pump", "engine_audio_relay_receive"], STREAM_EXPORTS = [
+  "engine_audio_stream_open",
+  "engine_audio_stream_feed",
+  "engine_audio_stream_space",
+  "engine_audio_stream_play",
+  "engine_audio_stream_gain",
+  "engine_audio_stream_flush",
+  "engine_audio_stream_time",
+  "engine_audio_stream_close"
+], COMPRESSED_STREAM_EXPORTS = [
+  "engine_audio_stream_open_opus",
+  "engine_audio_stream_seek",
+  "engine_audio_stream_loop",
+  "engine_audio_stream_duration",
+  "engine_audio_stream_time"
+], STREAM_BUFFER_SECONDS = 2, STREAM_CHUNK_FRAMES = 4096, STREAM_FADE_SECONDS = 0.02, DOUBLE_BYTES = 8, OPUS_RATE = 48e3, OGG_MAGIC = 1399285583;
+function isOgg(bytes) {
+  return bytes.byteLength >= (4) && new DataView(bytes.buffer, bytes.byteOffset).getUint32(0, true) === (1399285583);
+}
+var FULL_SOUND_PRIORITY = 1, PREVIEW_HANDOVER_SECONDS = 0.03, PREVIEW_RELEASE_MS = 1e3;
+function decodeWith(decoder, bytes) {
+  return new Promise((resolve, reject) => {
+    decoder(bytes, (samples, channels, sampleRate) => {
+      if (samples === null || channels < 1 || sampleRate <= 0 || samples.length % channels !== 0) {
+        reject(new GameError("asset_load_failed", "the host could not decode the sound"));
+        return;
+      }
+      resolve({ samples, channels, sampleRate });
+    });
+  });
+}
+var NO_HANDLE = 0, NO_VOICE = -1, SILENT = -1, MASTER_BUS = 0, MASTER_PARENT = -1, PLAY_LOOP = 1, PLAY_SPATIAL = 2, FLOAT_BYTES = 4, WAV_MAGIC = 1179011410, REGISTERS = 4, REGISTER_DELTA_SECONDS = 0, EngineAudioPort = class {
+  constructor(host, maxVoices = 64) {
+    this.name = "cimplify-audio";
+    this.pending = 0;
+    this.unlockedValue = false;
+    this.busCount = 0;
+    this.sampleRate = (48e3);
+    this.analysers = [];
+    this.analyserBus = [];
+    this.capture = 0;
+    this.captureBytes = 0;
+    this.captureFloats = null;
+    this.streams = /* @__PURE__ */ new Map();
+    /** Each previewed sound's full file, once decoded: plays use it in place of the preview. */
+    this.refined = /* @__PURE__ */ new Map();
+    this.streamList = [];
+    this.streamPointer = 0;
+    this.streamBytes = 0;
+    this.streamFloats = null;
+    this.emitterColumns = 0;
+    this.musicStaging = 0;
+    this.occlusionWorld = null;
+    if (this.host = host, this.handle = host.handle ?? host.exports.engine_audio_bound(), this.handle === (0)) throw new GameError("unsupported_feature", "the host has no native audio engine bound");
+    this.maxVoices = maxVoices;
+    let floats = 16 * (maxVoices + 1);
+    this.stagingBytes = (floats + 2 * maxVoices) * (4), this.staging = host.allocate(this.stagingBytes);
+    let buffer = host.memory.buffer;
+    this.listener = new Float32Array(buffer, this.staging, 16), this.column = new Float32Array(buffer, this.staging + 16 * (4), 16 * maxVoices), this.voices = new Int32Array(buffer, this.staging + floats * (4), maxVoices), this.offsets = new Uint32Array(buffer, this.staging + (floats + maxVoices) * (4), maxVoices);
+    for (let i = 0; i < maxVoices; i++) this.offsets[i] = i * 16;
+    this.registers = new Float32Array(buffer, host.exports.engine_audio_registers(this.handle), (4));
+    let has = (name) => typeof host.exports[name] == "function";
+    this.caps = {
+      spatial: true,
+      filters: true,
+      meters: true,
+      analyser: has("engine_audio_capture"),
+      reverb: has("engine_audio_create_convolver"),
+      sends: has("engine_audio_set_bus_send"),
+      loopPoints: has("engine_audio_set_voice_loop"),
+      streaming: STREAM_EXPORTS.every(has) && (host.decode !== void 0 && host.decode !== null || COMPRESSED_STREAM_EXPORTS.every(has)),
+      detune: true,
+      procedural: true,
+      emitters: ENGINE_AUDIO_LOCKSTEP_EXPORTS.every(has),
+      lockstep: ENGINE_AUDIO_LOCKSTEP_EXPORTS.every(has),
+      voiceLimits: has("engine_audio_set_sound_limit") && has("engine_audio_set_voice_budget"),
+      voiceFilters: has("engine_audio_set_voice_filter"),
+      limiter: has("engine_audio_set_limiter"),
+      scheduling: has("engine_audio_now") && has("engine_audio_play_at") && has("engine_audio_stop_at"),
+      music: MUSIC_EXPORTS.every(has),
+      binaural: has("engine_audio_set_voice_binaural"),
+      occlusion: has("engine_audio_set_voice_occlusion") && has("engine_audio_occlude")
+    };
+  }
+  /** The physics world occlusion rays are cast against, read once per frame. */
+  bindOcclusionWorld(world) {
+    this.occlusionWorld = world;
+  }
+  musicView() {
+    this.musicStaging === 0 && (this.musicStaging = this.host.allocate(MUSIC_STAGING_BYTES));
+    let buffer = this.host.memory.buffer, base = this.musicStaging;
+    return {
+      sounds: new Int32Array(buffer, base, MAX_STEMS),
+      gains: new Float32Array(buffer, base + MAX_STEMS * (4), MAX_STEMS),
+      position: new Float64Array(buffer, base + MUSIC_POSITION_OFFSET, MUSIC_POSITION_WORDS),
+      occlusion: new Float32Array(buffer, base + MUSIC_OCCLUSION_OFFSET, OCCLUSION_WORDS)
+    };
+  }
+  nowFrame() {
+    let now = this.host.exports.engine_audio_now;
+    if (!now) throw unsupported("sample-accurate scheduling");
+    let view2 = this.musicView().position;
+    if (now(this.handle, view2.byteOffset) < 0) throw new GameError("invalid_argument", "the audio clock could not be read");
+    return view2[0];
+  }
+  playOn(previewed, bus, gain, rate, loop, spatial, priority, frame) {
+    let playAt = this.host.exports.engine_audio_play_at;
+    if (!playAt) throw unsupported("sample-accurate scheduling");
+    let sound = this.refined.get(previewed) ?? previewed;
+    if (sound === (-1)) return (-1);
+    let flags = (loop ? (1) : 0) | (spatial ? (2) : 0) | (priority & PRIORITY_MASK) << PLAY_PRIORITY_SHIFT, voice = playAt(this.handle, sound, bus, gain, rate, flags, frame);
+    return voice < 0 ? (-1) : voice;
+  }
+  stopOn(voice, frame, fadeSeconds) {
+    voice !== (-1) && this.host.exports.engine_audio_stop_at?.(this.handle, voice, frame, fadeSeconds);
+  }
+  setVoiceBinaural(voice, binaural) {
+    let set = this.host.exports.engine_audio_set_voice_binaural;
+    if (!set) throw unsupported("binaural rendering");
+    if (voice !== (-1) && set(this.handle, voice, binaural ? 1 : 0) < 0) throw new GameError("unsupported_feature", "this engine build has no HRTF set");
+  }
+  setVoiceOcclusion(voice, params) {
+    let set = this.host.exports.engine_audio_set_voice_occlusion;
+    if (!set) throw unsupported("occlusion");
+    if (voice === (-1)) return;
+    if (params === null) {
+      set(this.handle, voice, 0);
+      return;
+    }
+    let view2 = this.musicView().occlusion;
+    view2.set(params.subarray(0, OCCLUSION_WORDS)), set(this.handle, voice, view2.byteOffset);
+  }
+  musicTempo(bpm, beatsPerBar, quantize) {
+    return this.host.exports.engine_audio_music_tempo?.(this.handle, bpm, beatsPerBar, quantize) ?? -1;
+  }
+  musicPlay(sounds, gains, bars, bus, quantize, fadeSeconds) {
+    let play = this.host.exports.engine_audio_music_play;
+    if (!play) return -1;
+    let view2 = this.musicView();
+    for (let i = 0; i < sounds.length; i++) view2.sounds[i] = this.refined.get(sounds[i]) ?? sounds[i];
+    view2.gains.set(gains);
+    let phrase = bars | quantize << PHRASE_QUANTIZE_SHIFT;
+    return play(this.handle, view2.sounds.byteOffset, view2.gains.byteOffset, sounds.length, phrase, bus, fadeSeconds);
+  }
+  musicLayer(layer, gain, rampSeconds) {
+    this.host.exports.engine_audio_music_layer?.(this.handle, layer, gain, rampSeconds);
+  }
+  musicStinger(previewed, bus, gain, quantize) {
+    let sound = this.refined.get(previewed) ?? previewed;
+    return this.host.exports.engine_audio_music_stinger?.(this.handle, sound, bus, gain, quantize) ?? -1;
+  }
+  musicStop(quantize, fadeSeconds) {
+    return this.host.exports.engine_audio_music_stop?.(this.handle, quantize, fadeSeconds) ?? -1;
+  }
+  musicPosition(out) {
+    let position = this.host.exports.engine_audio_music_position;
+    if (!position) return false;
+    let view2 = this.musicView().position;
+    return position(this.handle, view2.byteOffset) < 0 ? false : (out.set(view2), true);
+  }
+  setVoiceFilter(voice, kind, frequency, q, gainDb) {
+    let filter = this.host.exports.engine_audio_set_voice_filter;
+    if (!filter) throw unsupported("voice filters");
+    if (voice !== (-1) && filter(this.handle, voice, kind, frequency, q, gainDb) < 0) throw new GameError("invalid_argument", `voice ${voice} filter was rejected`);
+  }
+  setLimiter(enabled, ceilingDb, releaseSeconds) {
+    let limiter = this.host.exports.engine_audio_set_limiter;
+    if (!limiter) throw unsupported("a master limiter");
+    if (limiter(this.handle, enabled ? 1 : 0, ceilingDb, releaseSeconds) < 0) throw new GameError("invalid_argument", "the master limiter settings were rejected");
+  }
+  setSoundLimit(sound, voices, steal) {
+    let limit = this.host.exports.engine_audio_set_sound_limit;
+    if (!limit) throw unsupported("sound voice limits");
+    if (limit(this.handle, sound, voices, steal) < 0) throw new GameError("invalid_argument", `sound ${sound} cannot take that voice limit`);
+  }
+  setVoiceBudget(voices) {
+    let budget = this.host.exports.engine_audio_set_voice_budget;
+    if (!budget) throw unsupported("a voice budget");
+    if (budget(this.handle, voices) < 0) throw new GameError("invalid_argument", `the mixer cannot take a budget of ${voices} voices`);
+  }
+  lockstep(step, stepsPerSecond) {
+    this.host.exports.engine_audio_lockstep?.(this.handle, step >>> 0, stepsPerSecond);
+  }
+  flush() {
+    this.host.relay?.pump();
+  }
+  createEmitters(sound, bus, capacity, params) {
+    let create = this.host.exports.engine_audio_create_emitters;
+    if (!create) throw unsupported("emitter tables");
+    let pointer = 0;
+    if (params !== null) {
+      for (let i = 0; i < SPATIAL_WORDS; i++) this.listener[i] = params[i];
+      pointer = this.listener.byteOffset;
+    }
+    return create(this.handle, sound, bus, capacity, pointer);
+  }
+  feedEmitters(bank, table, columns) {
+    let feed = this.host.exports.engine_audio_feed_emitters;
+    return feed ? (this.emitterColumns === 0 && (this.emitterColumns = this.host.allocate(EMITTER_COLUMNS * (4))), new Uint32Array(this.host.memory.buffer, this.emitterColumns, EMITTER_COLUMNS).set(columns), feed(this.handle, bank, table, this.emitterColumns)) : 0;
+  }
+  releaseEmitters(bank) {
+    this.host.exports.engine_audio_release_emitters?.(this.handle, bank);
+  }
+  meter(bus, out) {
+    let pointer = this.listener.byteOffset;
+    this.host.exports.engine_audio_meter(this.handle, bus, pointer), out[METER_PEAK] = this.listener[0], out[METER_RMS] = this.listener[1];
+  }
+  get capabilities() {
+    return this.caps;
+  }
+  createSound(samples, channels, sampleRate) {
+    if (channels < 1 || sampleRate <= 0 || samples.length % channels !== 0) throw new GameError("invalid_argument", "sound PCM must be interleaved whole frames");
+    let pointer = this.host.allocate(samples.byteLength);
+    try {
+      return new Float32Array(this.host.memory.buffer, pointer, samples.length).set(samples), this.check(this.host.exports.engine_audio_load_pcm(this.handle, pointer, samples.length / channels, channels, sampleRate), "load sound");
+    } finally {
+      this.host.release(pointer, samples.byteLength);
+    }
+  }
+  setVoiceGain(voice, gain, rampSeconds) {
+    voice !== (-1) && this.host.exports.engine_audio_set_voice_gain(this.handle, voice, gain, rampSeconds);
+  }
+  setVoiceRate(voice, rate, detuneCents) {
+    voice !== (-1) && this.host.exports.engine_audio_set_voice_rate(this.handle, voice, detuneRate(rate, detuneCents));
+  }
+  setVoiceSpatial(voice, params) {
+    if (voice !== (-1)) {
+      for (let i = 0; i < SPATIAL_WORDS; i++) this.listener[i] = params[i];
+      this.host.exports.engine_audio_set_voice_spatial(this.handle, voice, this.listener.byteOffset);
+    }
+  }
+  setVoiceLoop(voice, loop, startSeconds, endSeconds) {
+    let setLoop = this.host.exports.engine_audio_set_voice_loop;
+    if (!setLoop) throw unsupported("loop points");
+    voice !== (-1) && setLoop(this.handle, voice, loop ? 1 : 0, startSeconds, endSeconds);
+  }
+  setBusFilter(bus, kind, frequency, q, gainDb) {
+    if (this.host.exports.engine_audio_set_bus_filter(this.handle, bus, kind, frequency, q, gainDb) < 0) throw new GameError("invalid_argument", `bus ${bus} filter was rejected`);
+  }
+  createAnalyser(bus, settings) {
+    if (!this.host.exports.engine_audio_capture) throw unsupported("the analyser");
+    let bytes = settings.fftSize * (4);
+    return bytes > this.captureBytes && (this.capture !== 0 && this.host.release(this.capture, this.captureBytes), this.capture = this.host.allocate(bytes), this.captureBytes = bytes), this.analysers.push(new FftAnalyser(settings)), this.analyserBus.push(bus), this.analysers.length - 1;
+  }
+  readAnalyser(analyser, mode, out) {
+    let capture = this.host.exports.engine_audio_capture, found = this.analysers[analyser];
+    if (!capture || !found) throw new GameError("unknown_resource", `analyser ${analyser} does not exist`);
+    let frames = capture(this.handle, this.analyserBus[analyser], this.capture, found.fftSize);
+    frames > 0 && found.push(this.captureView(), 0, Math.min(frames, found.fftSize)), mode === ANALYSER_FREQUENCY ? found.frequency(out) : found.timeDomain(out);
+  }
+  captureView() {
+    let buffer = this.host.memory.buffer, view2 = this.captureFloats;
+    return (view2 === null || view2.buffer !== buffer || view2.byteOffset !== this.capture) && (view2 = new Float32Array(buffer, this.capture, this.captureBytes / (4)), this.captureFloats = view2), view2;
+  }
+  createReverb(parent, impulse) {
+    let create = this.host.exports.engine_audio_create_convolver;
+    if (!create) throw unsupported("convolution reverb");
+    let bus = create(this.handle, parent, impulse);
+    if (bus < 0) throw new GameError("capacity_exceeded", "the audio mixer has no free reverb bus");
+    return this.busCount++, bus;
+  }
+  setBusSend(bus, target, gain) {
+    let send = this.host.exports.engine_audio_set_bus_send;
+    if (!send) throw unsupported("bus sends");
+    if (send(this.handle, bus, target, gain, 0) < 0) throw new GameError("invalid_argument", `bus ${bus} cannot send to ${target}`);
+  }
+  async openStream(source, bus) {
+    let exports = this.host.exports, open = exports.engine_audio_stream_open;
+    if (!this.caps.streaming || !open) throw unsupported("streaming music");
+    let bytes = await this.bytes(source);
+    if (isOgg(bytes) && COMPRESSED_STREAM_EXPORTS.every((name) => typeof exports[name] == "function")) return this.openCompressed(bytes, bus);
+    if (!this.host.decode) throw unsupported("streaming music");
+    let pcm = await decodeWith(this.host.decode, bytes), id = open(this.handle, bus, pcm.channels, pcm.sampleRate, Math.ceil(pcm.sampleRate * (2)));
+    if (id < 0) throw new GameError("capacity_exceeded", "the audio mixer has no free stream");
+    let entry = {
+      id,
+      pcm,
+      frames: pcm.samples.length / pcm.channels,
+      sampleRate: pcm.sampleRate,
+      cursor: 0,
+      loop: false,
+      playing: false,
+      fed: 0,
+      baseSeconds: 0,
+      baseFed: 0
+    };
+    return this.streams.set(id, entry), this.streamList.push(entry), this.streamStaging((4096) * pcm.channels), this.feedStream(this.stream(id)), id;
+  }
+  /** An Ogg Opus file the engine keeps compressed and decodes a buffer ahead of the mixer. */
+  openCompressed(bytes, bus) {
+    let exports = this.host.exports, open = exports.engine_audio_stream_open_opus, duration = exports.engine_audio_stream_duration;
+    if (!open || !duration) throw unsupported("compressed streaming");
+    let pointer = this.host.allocate(bytes.byteLength), id;
+    try {
+      new Uint8Array(this.host.memory.buffer, pointer, bytes.byteLength).set(bytes), id = open(this.handle, bus, pointer, bytes.byteLength, Math.ceil((48e3) * (2)));
+    } finally {
+      this.host.release(pointer, bytes.byteLength);
+    }
+    if (id < 0) throw new GameError("asset_load_failed", `the stream could not open (${id})`);
+    this.streamStaging((4096)), duration(this.handle, id, this.streamPointer);
+    let seconds = new DataView(this.host.memory.buffer).getFloat64(this.streamPointer, true), entry = {
+      id,
+      pcm: null,
+      frames: Math.round(seconds * (48e3)),
+      sampleRate: (48e3),
+      cursor: 0,
+      loop: false,
+      playing: false,
+      fed: 0,
+      baseSeconds: 0,
+      baseFed: 0
+    };
+    return this.streams.set(id, entry), this.streamList.push(entry), id;
+  }
+  stream(id) {
+    let found = this.streams.get(id);
+    if (!found) throw new GameError("unknown_resource", `stream ${id} is not open`);
+    return found;
+  }
+  streamStaging(floats) {
+    let bytes = Math.max(floats * (4), (8));
+    bytes <= this.streamBytes || (this.streamPointer !== 0 && this.host.release(this.streamPointer, this.streamBytes), this.streamPointer = this.host.allocate(bytes), this.streamBytes = bytes);
+  }
+  streamView() {
+    let buffer = this.host.memory.buffer, view2 = this.streamFloats;
+    return (view2 === null || view2.buffer !== buffer || view2.byteOffset !== this.streamPointer || view2.byteLength !== this.streamBytes) && (view2 = new Float32Array(buffer, this.streamPointer, this.streamBytes / (4)), this.streamFloats = view2), view2;
+  }
+  feedStream(stream) {
+    let exports = this.host.exports, feed = exports.engine_audio_stream_feed, space = exports.engine_audio_stream_space, pcm = stream.pcm;
+    if (!feed || !space || pcm === null) return;
+    let channels = pcm.channels, room = space(this.handle, stream.id);
+    for (; room > 0; ) {
+      if (stream.cursor >= stream.frames) {
+        if (!stream.loop) return;
+        stream.cursor = 0;
+      }
+      let frames = Math.min(room, (4096), stream.frames - stream.cursor), view2 = this.streamView(), source = pcm.samples, from = stream.cursor * channels;
+      for (let i = 0; i < frames * channels; i++) view2[i] = source[from + i];
+      let accepted = feed(this.handle, stream.id, this.streamPointer, frames, channels);
+      if (accepted <= 0) return;
+      stream.cursor += accepted, stream.fed += accepted, room -= accepted;
+    }
+  }
+  playStream(stream, gain, loop) {
+    let found = this.stream(stream);
+    found.loop = loop, found.playing = true, found.pcm === null && this.host.exports.engine_audio_stream_loop?.(this.handle, stream, loop ? 1 : 0), this.feedStream(found), this.host.exports.engine_audio_stream_gain?.(this.handle, stream, gain, 0), this.host.exports.engine_audio_stream_play?.(this.handle, stream, 1, (0.02));
+  }
+  pauseStream(stream) {
+    this.stream(stream).playing = false, this.host.exports.engine_audio_stream_play?.(this.handle, stream, 0, (0.02));
+  }
+  seekStream(stream, seconds) {
+    let found = this.stream(stream), clamped = Math.min(Math.max(seconds, 0), found.frames / found.sampleRate);
+    if (found.pcm === null) {
+      this.host.exports.engine_audio_stream_seek?.(this.handle, stream, clamped);
+      return;
+    }
+    this.host.exports.engine_audio_stream_flush?.(this.handle, stream), found.cursor = Math.floor(clamped * found.sampleRate), found.baseSeconds = clamped, found.baseFed = found.fed, this.feedStream(found);
+  }
+  streamTime(stream) {
+    let found = this.stream(stream), time = this.host.exports.engine_audio_stream_time;
+    if (!time) return found.baseSeconds;
+    time(this.handle, stream, this.streamPointer);
+    let consumed = new DataView(this.host.memory.buffer).getFloat64(this.streamPointer, true), duration = found.frames / found.sampleRate;
+    if (found.pcm === null) return Math.min(consumed, duration);
+    let played = found.baseSeconds + Math.max(0, consumed - found.baseFed / found.sampleRate);
+    return found.loop && duration > 0 ? played % duration : Math.min(played, duration);
+  }
+  streamDuration(stream) {
+    let found = this.stream(stream);
+    return found.frames / found.sampleRate;
+  }
+  closeStream(stream) {
+    let found = this.stream(stream);
+    this.host.exports.engine_audio_stream_close?.(this.handle, stream), this.streams.delete(stream), this.streamList.splice(this.streamList.indexOf(found), 1);
+  }
+  get unlocked() {
+    return this.unlockedValue;
+  }
+  unlock() {
+    this.unlockedValue = true;
+  }
+  async decode(source) {
+    let assets = this.host.assets;
+    if ("url" in source && assets?.has?.(source.url + AUDIO_PREVIEW_SUFFIX) === true) {
+      let preview = await this.decodeBytes(await assets.take(source.url + AUDIO_PREVIEW_SUFFIX));
+      return this.refine(preview, assets, source.url), preview;
+    }
+    return this.decodeBytes(await this.bytes(source));
+  }
+  /**
+   * Decodes a sound's full file after its preview, moves every voice playing the preview onto it at the same moment
+   * with a short crossfade, and plays the full file from then on. The preview is freed once its fade has finished.
+   */
+  async refine(preview, assets, url) {
+    let full;
+    try {
+      full = await this.decodeBytes(await assets.take(url, (1), !1));
+    } catch {
+      return;
+    }
+    this.refined.set(preview, full);
+    let replace = this.host.exports.engine_audio_replace;
+    replace === void 0 || replace(this.handle, preview, full, (0.03)) < 0 || setTimeout(() => this.host.exports.engine_audio_release(this.handle, preview), (1e3));
+  }
+  async decodeBytes(bytes) {
+    if (bytes.byteLength >= (4) && new DataView(bytes.buffer, bytes.byteOffset).getUint32(0, true) === (1179011410)) return this.loadWave(bytes);
+    if (!this.host.decode) throw new GameError("asset_load_failed", "compressed audio needs the host decoder");
+    let pcm = await decodeWith(this.host.decode, bytes), frames = pcm.samples.length / pcm.channels, pointer = this.host.allocate(pcm.samples.byteLength);
+    try {
+      return new Float32Array(this.host.memory.buffer, pointer, pcm.samples.length).set(pcm.samples), this.check(this.host.exports.engine_audio_load_pcm(this.handle, pointer, frames, pcm.channels, pcm.sampleRate), "load sound");
+    } finally {
+      this.host.release(pointer, pcm.samples.byteLength);
+    }
+  }
+  loadWave(bytes) {
+    let pointer = this.host.allocate(bytes.byteLength);
+    try {
+      return new Uint8Array(this.host.memory.buffer, pointer, bytes.byteLength).set(bytes), this.check(this.host.exports.engine_audio_load_wav(this.handle, pointer, bytes.byteLength), "load sound");
+    } finally {
+      this.host.release(pointer, bytes.byteLength);
+    }
+  }
+  async bytes(source) {
+    if ("bytes" in source) return new Uint8Array(source.bytes);
+    if (!("url" in source)) throw new GameError("asset_load_failed", "sounds load from bytes or a url");
+    if (this.host.assets) return this.host.assets.take(source.url);
+    let response = await fetch(source.url);
+    if (!response.ok) throw new GameError("asset_load_failed", `sound ${source.url} failed with ${response.status}`);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  check(code, what) {
+    if (code < 0) throw new GameError("asset_load_failed", `${what} failed with ${code}`);
+    return code;
+  }
+  createBus(_name, parent) {
+    if (parent === (-1))
+      return this.busCount = Math.max(this.busCount, 1), (0);
+    let bus = this.host.exports.engine_audio_create_bus(this.handle, parent);
+    if (bus < 0) throw new GameError("capacity_exceeded", "the audio mixer has no free bus");
+    return this.busCount++, bus;
+  }
+  setBusGain(bus, gain, rampSeconds) {
+    this.host.exports.engine_audio_set_bus_gain(this.handle, bus, gain, rampSeconds);
+  }
+  play(previewed, bus, gain, rate, loop, spatial, priority = DEFAULT_PRIORITY) {
+    let sound = this.refined.get(previewed) ?? previewed;
+    if (sound === (-1)) return (-1);
+    let flags = (loop ? (1) : 0) | (spatial ? (2) : 0) | (priority & PRIORITY_MASK) << PLAY_PRIORITY_SHIFT, voice = this.host.exports.engine_audio_play(this.handle, sound, bus, gain, rate, flags);
+    return voice < 0 ? (-1) : voice;
+  }
+  stop(voice, fadeSeconds) {
+    voice !== (-1) && this.host.exports.engine_audio_stop(this.handle, voice, fadeSeconds);
+  }
+  isPlaying(voice) {
+    return voice !== (-1) && this.host.exports.engine_audio_is_playing(this.handle, voice) === 1;
+  }
+  setVoicePosition(voice, matrix, offset) {
+    if (voice === (-1) || this.pending === this.maxVoices) return;
+    let slot = this.pending++;
+    this.voices[slot] = voice;
+    for (let i = 0; i < 16; i++) this.column[slot * 16 + i] = matrix[offset + i];
+  }
+  setListener(matrix, offset) {
+    for (let i = 0; i < 16; i++) this.listener[i] = matrix[offset + i];
+    this.host.exports.engine_audio_set_listener(this.handle, this.listener.byteOffset);
+  }
+  commit(frame, at) {
+    let exports = this.host.exports;
+    this.pending > 0 && (exports.engine_audio_place(this.handle, this.voices.byteOffset, this.offsets.byteOffset, this.pending, this.column.byteOffset, this.pending * 16), this.pending = 0), this.registers[(0)] = frame[at];
+    let world = this.occlusionWorld?.() ?? (0);
+    world !== (0) && exports.engine_audio_occlude?.(this.handle, world), exports.engine_audio_update(this.handle);
+    let list = this.streamList;
+    for (let i = 0; i < list.length; i++) list[i].playing && this.feedStream(list[i]);
+  }
+  suspend() {
+    this.host.exports.engine_audio_suspend(this.handle), this.host.relay?.pump(), this.host.relay?.suspend?.();
+  }
+  resume() {
+    this.host.exports.engine_audio_resume(this.handle), this.host.relay?.resume?.(), this.host.relay?.pump();
+  }
+  dispose() {
+    this.host.exports.engine_audio_reset(this.handle), this.host.release(this.staging, this.stagingBytes), this.capture !== 0 && this.host.release(this.capture, this.captureBytes), this.streamPointer !== 0 && this.host.release(this.streamPointer, this.streamBytes), this.emitterColumns !== 0 && this.host.release(this.emitterColumns, EMITTER_COLUMNS * (4)), this.musicStaging !== 0 && this.host.release(this.musicStaging, MUSIC_STAGING_BYTES), this.musicStaging = 0, this.emitterColumns = 0, this.capture = 0, this.captureBytes = 0, this.streamPointer = 0, this.streamBytes = 0, this.streams.clear(), this.streamList.length = 0;
+  }
+};
+function unsupported(feature) {
+  return new GameError("unsupported_feature", `this engine build has no ${feature}; update the app to use it`);
+}
+
+// src/game/backends/engine/joints.ts
+var ENGINE_JOINT_EXPORT_NAMES = [
+  "engine_joint_drive",
+  "engine_joint_drive_clear",
+  "engine_joint_target",
+  "engine_joint_breakable",
+  "engine_joint_enable",
+  "engine_joint_contacts",
+  "engine_joint_broken",
+  "engine_joint_load",
+  "engine_joint_break_count",
+  "engine_joint_breaks"
+], ENGINE_RAGDOLL_EXPORT_NAMES = [
+  "engine_ragdoll_create",
+  "engine_ragdoll_destroy",
+  "engine_ragdoll_drive",
+  "engine_ragdoll_place",
+  "engine_ragdoll_read",
+  "engine_ragdoll_root",
+  "engine_ragdoll_bodies",
+  "engine_ragdoll_bone_count"
+], DRIVE_TARGET = 0, DRIVE_VELOCITY = 1, DRIVE_STIFFNESS = 2, DRIVE_DAMPING = 3, DRIVE_MAX_FORCE = 4, TARGET_ROTATION = 0, TARGET_STIFFNESS = 4, TARGET_DAMPING = 5, TARGET_MAX_TORQUE = 6, BREAK_FORCE = 0, BREAK_TORQUE = 1, LOAD_FORCE = 0, LOAD_TORQUE = 1, RAGDOLL_BONE_COUNT = 0, RAGDOLL_JOINT_COUNT = 1, RAGDOLL_ROOT_POSITION = 2;
+var RAGDOLL_LINEAR_DAMPING = 12, RAGDOLL_ANGULAR_DAMPING = 13, RAGDOLL_FRICTION = 14, RAGDOLL_FLAGS = 15, RAGDOLL_HEADER = 16, RAGDOLL_FLAG_ENTITIES = 1, RAGDOLL_NO_PARENT = 4294967295, RAGDOLL_BONE_JOINT = 0, RAGDOLL_BONE_AXIS = 1, RAGDOLL_BONE_LENGTH = 4, RAGDOLL_BONE_RADIUS = 5, RAGDOLL_BONE_DENSITY = 6, RAGDOLL_BONE_SWING = 7, RAGDOLL_BONE_TWIST = 8, RAGDOLL_BONE_ENTITY = 10, RAGDOLL_BONE_WORDS = 11, RAGDOLL_DRIVE_STIFFNESS = 0, RAGDOLL_DRIVE_DAMPING = 1, RAGDOLL_DRIVE_MAX_TORQUE = 2, RAGDOLL_ROOT_OUT = 0, NO_POINTER = 0, UNLIMITED = Number.MAX_VALUE, DEFAULT_DENSITY = 1e3, DEFAULT_SWING = Math.PI / 4, DEFAULT_TWIST = [-Math.PI / 8, Math.PI / 8], DEFAULT_AXIS = [0, 1, 0], ORIGIN = [0, 0, 0], IDENTITY = [0, 0, 0, 1], UNIT_SCALE = [1, 1, 1], AXES = 3, QUATERNION = 4, EMPTY_BREAKS = new Uint32Array(0);
+function engineJointExports(symbols) {
+  for (let name of [...ENGINE_JOINT_EXPORT_NAMES, ...ENGINE_RAGDOLL_EXPORT_NAMES]) if (typeof symbols[name] != "function") return null;
+  return symbols;
+}
+function engineJoints(session) {
+  let exports = engineJointExports(session.symbols);
+  return exports ? new EngineJoints(session, exports) : null;
+}
+function writeRoot(floats, at, root) {
+  let position = root.position ?? ORIGIN, rotation = root.rotation ?? IDENTITY, scale = root.scale ?? UNIT_SCALE;
+  for (let k = 0; k < (3); k++) floats[at + k] = position[k];
+  for (let k = 0; k < (4); k++) floats[at + (3) + k] = rotation[k];
+  for (let k = 0; k < (3); k++) floats[at + (3) + (4) + k] = scale[k];
+}
+var EngineRagdoll = class {
+  constructor(session, exports, id, pose, bones) {
+    this.live = true;
+    this.session = session, this.exports = exports, this.id = id, this.pose = pose;
+    let bodies = exports.engine_ragdoll_bodies(session.require(), id);
+    if (bodies === (0)) throw new GameError("unknown_resource", `ragdoll ${id} has no bodies`);
+    this.bodies = new Uint32Array(session.buffer, bodies, bones);
+  }
+  world() {
+    if (!this.live) throw new GameError("unknown_resource", `ragdoll ${this.id} was destroyed`);
+    let s = this.session;
+    return s.flush(), s.require();
+  }
+  drive(drive) {
+    let world = this.world(), floats = this.session.registerFloats;
+    floats[(0)] = drive.stiffness, floats[(1)] = drive.damping, floats[(2)] = drive.maxTorque, this.session.check(this.exports.engine_ragdoll_drive(world, this.id, this.pose.byteOffset, this.pose.length), "drive ragdoll");
+  }
+  place() {
+    let world = this.world();
+    this.session.check(this.exports.engine_ragdoll_place(world, this.id, this.pose.byteOffset, this.pose.length), "place ragdoll");
+  }
+  read() {
+    let world = this.world();
+    return this.session.check(this.exports.engine_ragdoll_read(world, this.id, this.pose.byteOffset, this.pose.length), "read ragdoll"), this.pose;
+  }
+  setRoot(root) {
+    let world = this.world();
+    writeRoot(this.session.registerFloats, (0), root), this.session.check(this.exports.engine_ragdoll_root(world, this.id), "ragdoll root");
+  }
+  destroy() {
+    let world = this.world();
+    this.session.check(this.exports.engine_ragdoll_destroy(world, this.id), "destroy ragdoll"), this.live = false;
+  }
+}, EngineJoints = class {
+  constructor(session, exports) {
+    this.breakView = EMPTY_BREAKS;
+    this.session = session, this.exports = exports;
+  }
+  world() {
+    let s = this.session;
+    return s.flush(), s.require();
+  }
+  setDrive(joint, axis, drive) {
+    let world = this.world(), floats = this.session.registerFloats;
+    floats[(0)] = drive.targetPosition ?? 0, floats[(1)] = drive.targetVelocity ?? 0, floats[(2)] = drive.stiffness, floats[(3)] = drive.damping, floats[(4)] = drive.maxForce ?? UNLIMITED, this.session.check(this.exports.engine_joint_drive(world, joint, JOINT_AXES[axis]), "joint drive");
+  }
+  clearDrive(joint, axis) {
+    this.session.check(this.exports.engine_joint_drive_clear(this.world(), joint, JOINT_AXES[axis]), "clear joint drive");
+  }
+  setTarget(joint, rotation, drive) {
+    let world = this.world(), floats = this.session.registerFloats;
+    for (let k = 0; k < (4); k++) floats[(0) + k] = rotation[k];
+    floats[(4)] = drive.stiffness, floats[(5)] = drive.damping, floats[(6)] = drive.maxTorque, this.session.check(this.exports.engine_joint_target(world, joint), "joint target");
+  }
+  setBreakable(joint, force, torque) {
+    let world = this.world(), floats = this.session.registerFloats;
+    floats[(0)] = force, floats[(1)] = torque, this.session.check(this.exports.engine_joint_breakable(world, joint), "breakable joint");
+  }
+  setEnabled(joint, enabled) {
+    this.session.check(this.exports.engine_joint_enable(this.world(), joint, enabled ? 1 : 0), "enable joint");
+  }
+  setContacts(joint, enabled) {
+    this.session.check(this.exports.engine_joint_contacts(this.world(), joint, enabled ? 1 : 0), "joint contacts");
+  }
+  broken(joint) {
+    return this.session.check(this.exports.engine_joint_broken(this.world(), joint), "joint broken") !== 0;
+  }
+  load(joint, out) {
+    this.session.check(this.exports.engine_joint_load(this.world(), joint), "joint load");
+    let floats = this.session.registerFloats;
+    out.force = floats[(0)], out.torque = floats[(1)];
+  }
+  breaks() {
+    let world = this.world(), count = this.exports.engine_joint_break_count(world);
+    if (count === 0) return EMPTY_BREAKS;
+    let pointer = this.exports.engine_joint_breaks(world), buffer = this.session.buffer;
+    return (this.breakView.byteOffset !== pointer || this.breakView.buffer !== buffer || this.breakView.length !== count) && (this.breakView = new Uint32Array(buffer, pointer, count)), this.breakView;
+  }
+  createRagdoll(desc) {
+    let joints = desc.parents.length;
+    if (desc.pose.length < joints * POSE_STRIDE) throw new GameError("invalid_argument", `a ragdoll pose needs ${POSE_STRIDE} floats per joint`);
+    let bones = desc.bones.length, words = (16) + joints + joints * POSE_STRIDE + bones * (11), s = this.session, scratch = s.memory.allocate("u32", words), floats = new Float32Array(scratch.buffer, scratch.byteOffset, words);
+    scratch[(0)] = bones, scratch[(1)] = joints, writeRoot(floats, (2), desc.root ?? {}), floats[(12)] = desc.linearDamping ?? 0, floats[(13)] = desc.angularDamping ?? 0, floats[(14)] = desc.friction ?? Number.NaN;
+    let entities = desc.bones.some((bone) => bone.entity !== void 0);
+    scratch[(15)] = entities ? (1) : 0;
+    for (let j = 0; j < joints; j++) {
+      let parent = desc.parents[j];
+      scratch[(16) + j] = parent === NO_PARENT ? (4294967295) : parent;
+    }
+    let poseAt = (16) + joints;
+    floats.set(desc.pose.subarray(0, joints * POSE_STRIDE), poseAt);
+    let bonesAt = poseAt + joints * POSE_STRIDE;
+    for (let b = 0; b < bones; b++) {
+      let bone = desc.bones[b], at = bonesAt + b * (11), axis = bone.axis ?? DEFAULT_AXIS, twist = bone.twist ?? DEFAULT_TWIST;
+      scratch[at + (0)] = bone.joint;
+      for (let k = 0; k < (3); k++) floats[at + (1) + k] = axis[k];
+      floats[at + (4)] = bone.length, floats[at + (5)] = bone.radius, floats[at + (6)] = bone.density ?? (1e3), floats[at + (7)] = bone.swing ?? DEFAULT_SWING, floats[at + (8)] = twist[0], floats[at + (8) + 1] = twist[1], scratch[at + (10)] = bone.entity ?? (4294967295);
+    }
+    let world = this.world(), id = s.check(this.exports.engine_ragdoll_create(world, scratch.byteOffset, words), "create ragdoll"), pose = s.memory.allocate("f32", joints * POSE_STRIDE);
+    return pose.set(desc.pose.subarray(0, joints * POSE_STRIDE)), new EngineRagdoll(s, this.exports, id, pose, bones);
+  }
+};
+
+export { DEFAULT_ROLLBACK_FRAMES, ENGINE_ARENA_EXPORT_NAMES, ENGINE_AUDIO_EXPORT_NAMES, ENGINE_AUDIO_LOCKSTEP_EXPORTS, ENGINE_AUDIO_WORKLET_EXPORTS, ENGINE_JOINT_EXPORT_NAMES, ENGINE_RAGDOLL_EXPORT_NAMES, ENGINE_ROLLBACK_EXPORT_NAMES, ENGINE_VECTOR_SURFACE_EXPORT_NAMES, EngineAudioPort, EngineMemory, EngineVectorSurfaces, ROLLBACK_CONFIG_WORDS, WorldSnapshots, engineJoints, engineVectorSurfaceExports, hasRollback, releaseEngineArena, writeRollbackConfig };