@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-X5A5FOWW.js

@@ -0,0 +1,615 @@
+'use strict';
+
+var chunk2O2CG465_js = require('./chunk-2O2CG465.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/cloth/engine.ts
+var CLOTH_FEATURE = "cloth_1", CLOTH_REGISTER_WORDS = 64, CLOTH_MASS = 0, CLOTH_STRETCH = 1, CLOTH_BEND = 2, CLOTH_TETHER_SLACK = 3, CLOTH_DAMPING = 4, CLOTH_GRAVITY = 5, CLOTH_SUBSTEPS = 8, CLOTH_THICKNESS = 9, CLOTH_FRICTION = 10, CLOTH_COLUMNS = 16, CLOTH_ROWS = 17, CLOTH_SPACING = 18, CLOTH_ORIGIN = 19, CLOTH_ACROSS = 22, CLOTH_DOWN = 25, CLOTH_PIN = 28, CLOTH_COUNT = 32, CLOTH_TRIANGLES = 33, CLOTH_COLOURS = 34;
+var CLOTH_PINS = 36;
+var CLOTH_DIGEST_LOW = 40, CLOTH_DIGEST_HIGH = 41, CLOTH_PIN_NONE = 0, CLOTH_PIN_TOP_ROW = 1, CLOTH_PIN_TOP_CORNERS = 2, CLOTH_COLLIDER_FLOATS = 8, CLOTH_COLLIDER_SPHERE = 0, CLOTH_COLLIDER_CAPSULE = 1, CLOTH_MAX_COLLIDERS = 32, CLOTH_ROW_FLOATS = 4, DEFAULT_CLOTHS = 32, DEFAULT_CLOTH_PARTICLES = 65536, ENGINE_CLOTH_EXPORT_NAMES = [
+  "engine_cloth_create",
+  "engine_cloth_create_in",
+  "engine_cloth_destroy",
+  "engine_cloth_registers",
+  "engine_cloth_add_grid",
+  "engine_cloth_add_mesh",
+  "engine_cloth_remove",
+  "engine_cloth_params",
+  "engine_cloth_colliders",
+  "engine_cloth_anchors",
+  "engine_cloth_step",
+  "engine_cloth_positions",
+  "engine_cloth_digest",
+  "engine_cloth_present"
+], ENGINE_RIGID_COUPLING_EXPORT_NAMES = [
+  "engine_cloth_couple",
+  "engine_cloth_rigid_mesh",
+  "engine_cloth_rigid_pose",
+  "engine_cloth_uncouple",
+  "engine_cloth_step_coupled",
+  "engine_soft_couple",
+  "engine_soft_rigid_mesh",
+  "engine_soft_rigid_pose",
+  "engine_soft_uncouple",
+  "engine_soft_step_coupled"
+];
+function engineCall(runtime, name) {
+  let fn = runtime.symbols[name];
+  if (typeof fn != "function") throw new chunk2V7IL4HC_js.GameError("unsupported_feature", `${name} needs an engine with feature rigid_coupling_1`);
+  return fn;
+}
+var NULL = 0, F32_BYTES = 4, MICROS = 1e6, HIGH_BITS = 32n, AXES = 3, TRIANGLE_INDICES = 3, SCRATCH_FLOATS = (8) * (32);
+function engineClothExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_CLOTH_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var EngineCloths = class {
+  constructor(runtime, exports, render, world = () => (0), maxCloths = (32), maxParticles = (65536)) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.world = world;
+    this.maxCloths = maxCloths;
+    this.maxParticles = maxParticles;
+    this.handle = (0);
+    this.scratch = (0);
+    this.buffer = null;
+    this.bytes = new Uint8Array(0);
+    this.words = new Uint32Array(0);
+    this.views = new Float32Array(0);
+    this.registers = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.rows = /* @__PURE__ */ new Map();
+    this.coupled = 0;
+  }
+  memory() {
+    let buffer = this.runtime.memory.buffer;
+    buffer !== this.buffer && (this.buffer = buffer, this.bytes = new Uint8Array(buffer), this.words = new Uint32Array(buffer), this.views = new Float32Array(buffer));
+  }
+  get engineHost() {
+    return this.open();
+  }
+  open() {
+    if (this.handle === (0)) {
+      let world = this.world();
+      if (this.handle = world === (0) ? this.exports.engine_cloth_create(this.maxCloths, this.maxParticles) : this.exports.engine_cloth_create_in(world, this.maxCloths, this.maxParticles), this.handle === (0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "the engine refused the cloth world");
+      if (this.scratch = this.runtime.exports.engine_alloc(SCRATCH_FLOATS * (4), chunk2O2CG465_js.COLUMN_ALIGN), this.scratch === (0)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "engine memory cannot hold cloth colliders");
+    }
+    return this.view(), this.handle;
+  }
+  view() {
+    this.memory();
+    let at = this.exports.engine_cloth_registers(this.handle);
+    (this.registers.buffer !== this.words.buffer || this.registers.byteOffset !== at) && (this.registers = new Uint32Array(this.words.buffer, at, (64)), this.floats = new Float32Array(this.words.buffer, at, (64)));
+  }
+  check(code, what) {
+    if (code === -1) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `the cloth world has no room for the ${what}`);
+    if (code === -3) throw new chunk2V7IL4HC_js.GameError("unknown_resource", `the cloth ${what} names a missing cloth`);
+    if (!(code >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the cloth ${what} (${code})`);
+    return code;
+  }
+  stage(bytes, what) {
+    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 cloth ${what}`);
+    return this.memory(), pointer;
+  }
+  release(pointer, bytes) {
+    pointer !== (0) && this.runtime.exports.engine_free(pointer, Math.max(bytes, (4)), chunk2O2CG465_js.COLUMN_ALIGN);
+  }
+  staged(values, what) {
+    if (values === null || values.length === 0) return (0);
+    let pointer = this.stage(values.byteLength, what);
+    return this.bytes.set(new Uint8Array(values.buffer, values.byteOffset, values.byteLength), pointer), pointer;
+  }
+  info(id) {
+    this.view();
+    let r = this.registers;
+    return { id, particles: r[(32)], triangles: r[(33)], pins: r[(36)], colours: r[(34)] };
+  }
+  prepare() {
+    return this.open(), this.floats;
+  }
+  grid(pins) {
+    let handle = this.open(), pointer = this.staged(pins, "pins"), id = this.exports.engine_cloth_add_grid(handle, pointer, pins?.length ?? 0);
+    return this.release(pointer, pins?.byteLength ?? 0), this.info(this.check(id, "grid"));
+  }
+  mesh(positions, triangles, pins) {
+    let handle = this.open(), vertices = this.staged(positions, "vertices"), indices = this.staged(triangles, "triangles"), pinned = this.staged(pins, "pins"), id = this.exports.engine_cloth_add_mesh(handle, vertices, positions.length / (3), indices, triangles.length / (3), pinned, pins?.length ?? 0);
+    return this.release(vertices, positions.byteLength), this.release(indices, triangles.byteLength), this.release(pinned, pins?.byteLength ?? 0), this.info(this.check(id, "mesh"));
+  }
+  remove(id) {
+    this.rows.delete(id), this.handle !== (0) && this.exports.engine_cloth_remove(this.handle, id);
+  }
+  params(id) {
+    this.check(this.exports.engine_cloth_params(this.open(), id), "parameters");
+  }
+  colliders(words, count) {
+    let handle = this.open();
+    if (count > (32)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `cloth collides with at most ${(32)} shapes`);
+    this.memory(), this.views.set(words.subarray(0, count * (8)), this.scratch >>> 2), this.check(this.exports.engine_cloth_colliders(handle, this.scratch, count), "colliders");
+  }
+  anchors(id, anchors) {
+    let handle = this.open(), pointer = this.staged(anchors, "anchors"), code = this.exports.engine_cloth_anchors(handle, id, pointer, anchors.length / (3));
+    this.release(pointer, anchors.byteLength), this.check(code, "anchors");
+  }
+  step(seconds) {
+    if (this.handle === (0)) return;
+    let micros = Math.max(0, Math.round(seconds * (1e6))), world = this.world();
+    if (this.coupled > 0 && world !== (0)) {
+      this.check(engineCall(this.runtime, "engine_cloth_step_coupled")(this.handle, world, micros), "coupled step");
+      return;
+    }
+    this.exports.engine_cloth_step(this.handle, micros);
+  }
+  couple(collider) {
+    let handle = this.open(), world = this.world();
+    if (world === (0)) throw new chunk2V7IL4HC_js.GameError("not_initialized", "cloth couples to rigid bodies only inside a physics world");
+    let slot = this.check(engineCall(this.runtime, "engine_cloth_couple")(handle, world, collider), "coupling");
+    return this.coupled++, slot;
+  }
+  uncouple(slot) {
+    this.check(engineCall(this.runtime, "engine_cloth_uncouple")(this.open(), slot), "uncoupling"), this.coupled = Math.max(0, this.coupled - 1);
+  }
+  positions(id, count) {
+    let at = this.exports.engine_cloth_positions(this.open(), id);
+    if (at === (0)) throw new chunk2V7IL4HC_js.GameError("unknown_resource", `cloth ${id} is gone`);
+    this.memory();
+    let held = this.rows.get(id);
+    if (held !== void 0 && held.buffer === this.views.buffer && held.byteOffset === at) return held;
+    let view = new Float32Array(this.views.buffer, at, count * (4));
+    return this.rows.set(id, view), view;
+  }
+  digest() {
+    let handle = this.open();
+    return this.exports.engine_cloth_digest(handle), this.view(), BigInt(this.registers[(41)]) << HIGH_BITS | BigInt(this.registers[(40)]);
+  }
+  present(id, geometry) {
+    let render = this.render();
+    return this.handle === (0) || render === (0) ? 0 : this.check(this.exports.engine_cloth_present(this.handle, id, render, geometry), "presentation");
+  }
+  dispose() {
+    this.handle !== (0) && (this.release(this.scratch, SCRATCH_FLOATS * (4)), this.exports.engine_cloth_destroy(this.handle), this.handle = (0), this.scratch = (0), this.rows.clear());
+  }
+};
+
+// src/game/softbody/engine.ts
+var SOFT_BODY_FEATURE = "soft_body_1", SOFT_REGISTER_WORDS = 64, SOFT_STRETCH = 0, SOFT_BEND = 1, SOFT_VOLUME = 2, SOFT_DAMPING = 3, SOFT_GRAVITY = 4, SOFT_SUBSTEPS = 7, SOFT_RADIUS = 8, SOFT_FRICTION = 9, SOFT_CONTRACTION = 10, SOFT_YIELD = 11, SOFT_CREEP = 12, SOFT_LIMIT = 13, SOFT_CELLS = 16, SOFT_SIZE = 19, SOFT_ORIGIN = 22, SOFT_DENSITY = 25, SOFT_MASS = 26, SOFT_PIN_FIRST = 27, SOFT_FIBRE = 28, SOFT_COUNT = 32, SOFT_SKIN = 33;
+var SOFT_DIGEST_LOW = 40, SOFT_DIGEST_HIGH = 41, SOFT_TETS = 42, SOFT_COLOURS = 43, SOFT_COLLIDER_FLOATS = 12, SOFT_MAX_COLLIDERS = 32, SOFT_ROW_FLOATS = 4, SOFT_COLLIDER_PLANE = 0, SOFT_COLLIDER_SPHERE = 1, SOFT_COLLIDER_CAPSULE = 2, SOFT_COLLIDER_BOX = 3, CRUMPLE_DESC_FLOATS = 14, CRUMPLE_IMPACT_FLOATS = 6, DEFAULT_SOFT_BODIES = 64, DEFAULT_SOFT_PARTICLES = 65536, ENGINE_SOFT_BODY_EXPORT_NAMES = [
+  "engine_soft_create",
+  "engine_soft_destroy",
+  "engine_soft_registers",
+  "engine_soft_add",
+  "engine_soft_add_lattice",
+  "engine_soft_add_rope",
+  "engine_soft_remove",
+  "engine_soft_params",
+  "engine_soft_colliders",
+  "engine_soft_anchors",
+  "engine_soft_activate",
+  "engine_soft_move",
+  "engine_soft_step",
+  "engine_soft_positions",
+  "engine_soft_digest",
+  "engine_soft_present",
+  "engine_soft_create_in"
+], ENGINE_CRUMPLE_EXPORT_NAMES = ["engine_craft_crumple", "engine_craft_impact", "engine_craft_damage", "engine_craft_crumple_present"], NULL2 = 0, F32_BYTES2 = 4, MICROS2 = 1e6, SCRATCH_FLOATS2 = (12) * (32);
+function engineSoftBodyExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_SOFT_BODY_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var Memory = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.buffer = null;
+    this.bytes = new Uint8Array(0);
+    this.floats = new Float32Array(0);
+    this.words = new Uint32Array(0);
+  }
+  views() {
+    let buffer = this.runtime.memory.buffer;
+    buffer !== this.buffer && (this.buffer = buffer, this.bytes = new Uint8Array(buffer), this.floats = new Float32Array(buffer), this.words = new Uint32Array(buffer));
+  }
+  allocate(bytes, what) {
+    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 ${what}`);
+    return this.views(), pointer;
+  }
+  release(pointer, bytes) {
+    this.runtime.exports.engine_free(pointer, Math.max(bytes, (4)), chunk2O2CG465_js.COLUMN_ALIGN);
+  }
+  floatsAt(values, what) {
+    let pointer = this.allocate(values.byteLength, what);
+    return this.floats.set(values, pointer >>> 2), pointer;
+  }
+}, EngineSoftBodies = class {
+  constructor(runtime, exports, render, world = () => (0), maxBodies = (64), maxParticles = (65536)) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.render = render;
+    this.world = world;
+    this.maxBodies = maxBodies;
+    this.maxParticles = maxParticles;
+    this.handle = (0);
+    this.scratch = (0);
+    this.registers = new Uint32Array(0);
+    this.floats = new Float32Array(0);
+    this.coupled = 0;
+    this.memory = new Memory(runtime);
+  }
+  open() {
+    if (this.handle === (0)) {
+      let world = this.world();
+      if (this.handle = world === (0) ? this.exports.engine_soft_create(this.maxBodies, this.maxParticles) : this.exports.engine_soft_create_in(world, this.maxBodies, this.maxParticles), this.handle === (0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "the engine refused the soft body world");
+      this.scratch = this.memory.allocate(SCRATCH_FLOATS2 * (4), "soft body colliders");
+    }
+    return this.view(), this.handle;
+  }
+  view() {
+    this.memory.views();
+    let at = this.exports.engine_soft_registers(this.handle);
+    (this.registers.buffer !== this.memory.words.buffer || this.registers.byteOffset !== at) && (this.registers = new Uint32Array(this.memory.words.buffer, at, (64)), this.floats = new Float32Array(this.memory.words.buffer, at, (64)));
+  }
+  check(code, what) {
+    if (!(code >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `the engine refused the soft body ${what} (${code})`);
+    return code;
+  }
+  info(id) {
+    this.view();
+    let r = this.registers;
+    return { id, particles: r[(32)], skinned: r[(33)], tets: r[(42)], colours: r[(43)] };
+  }
+  prepare() {
+    return this.open(), this.floats;
+  }
+  lattice(lattice, vertices) {
+    let handle = this.open(), r = this.registers, f = this.floats;
+    for (let k = 0; k < 3; k++)
+      r[(16) + k] = lattice.cells[k], f[(19) + k] = lattice.size[k], f[(22) + k] = lattice.origin[k];
+    f[(25)] = lattice.density;
+    let count = vertices === null ? 0 : vertices.length / 3, pointer = vertices === null ? (0) : this.memory.floatsAt(vertices, "soft body surface"), id = this.exports.engine_soft_add_lattice(handle, pointer, count);
+    return pointer !== (0) && vertices !== null && this.memory.release(pointer, vertices.byteLength), this.info(this.check(id, "lattice"));
+  }
+  rope(points, mass, pinFirst) {
+    let handle = this.open();
+    this.floats[(26)] = mass, this.registers[(27)] = pinFirst ? 1 : 0;
+    let pointer = this.memory.floatsAt(points, "rope points"), id = this.exports.engine_soft_add_rope(handle, pointer, points.length / 3);
+    return this.memory.release(pointer, points.byteLength), this.info(this.check(id, "rope"));
+  }
+  asset(bytes) {
+    let handle = this.open(), pointer = this.memory.allocate(bytes.byteLength, "soft body asset");
+    this.memory.bytes.set(bytes, pointer);
+    let id = this.exports.engine_soft_add(handle, pointer, bytes.byteLength);
+    return this.memory.release(pointer, bytes.byteLength), this.info(this.check(id, "asset (CSBT)"));
+  }
+  remove(id) {
+    this.handle !== (0) && this.exports.engine_soft_remove(this.handle, id);
+  }
+  params(id) {
+    this.check(this.exports.engine_soft_params(this.open(), id), "parameters");
+  }
+  colliders(words, count) {
+    let handle = this.open();
+    if (count > (32)) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `soft bodies collide with at most ${(32)} shapes`);
+    this.memory.views(), this.memory.floats.set(words.subarray(0, count * (12)), this.scratch >>> 2), this.check(this.exports.engine_soft_colliders(handle, this.scratch, count), "colliders");
+  }
+  anchors(id, anchors) {
+    let handle = this.open(), pointer = this.memory.floatsAt(anchors, "anchors"), code = this.exports.engine_soft_anchors(handle, id, pointer, anchors.length / 3);
+    this.memory.release(pointer, anchors.byteLength), this.check(code, "anchors");
+  }
+  activate(id, activation) {
+    this.check(this.exports.engine_soft_activate(this.open(), id, activation), "activation");
+  }
+  move(id, offset, velocity) {
+    let handle = this.open();
+    for (let k = 0; k < 3; k++)
+      this.floats[(22) + k] = offset[k], this.floats[(19) + k] = velocity[k];
+    this.check(this.exports.engine_soft_move(handle, id), "move");
+  }
+  step(seconds) {
+    if (this.handle === (0)) return;
+    let micros = Math.max(0, Math.round(seconds * (1e6))), world = this.world();
+    if (this.coupled > 0 && world !== (0)) {
+      this.check(engineCall(this.runtime, "engine_soft_step_coupled")(this.handle, world, micros), "coupled step");
+      return;
+    }
+    this.exports.engine_soft_step(this.handle, micros);
+  }
+  couple(collider) {
+    let handle = this.open(), world = this.world();
+    if (world === (0)) throw new chunk2V7IL4HC_js.GameError("not_initialized", "soft bodies couple to rigid bodies only inside a physics world");
+    let slot = this.check(engineCall(this.runtime, "engine_soft_couple")(handle, world, collider), "coupling");
+    return this.coupled++, slot;
+  }
+  uncouple(slot) {
+    this.check(engineCall(this.runtime, "engine_soft_uncouple")(this.open(), slot), "uncoupling"), this.coupled = Math.max(0, this.coupled - 1);
+  }
+  positions(id, count) {
+    let at = this.exports.engine_soft_positions(this.open(), id);
+    if (at === (0)) throw new chunk2V7IL4HC_js.GameError("unknown_resource", `soft body ${id} is gone`);
+    return this.memory.views(), new Float32Array(this.memory.floats.buffer, at, count * (4));
+  }
+  digest() {
+    let handle = this.open();
+    return this.exports.engine_soft_digest(handle), this.view(), BigInt(this.registers[(41)]) << 32n | BigInt(this.registers[(40)]);
+  }
+  present(id, geometry) {
+    let render = this.render();
+    return this.handle === (0) || render === (0) ? 0 : this.check(this.exports.engine_soft_present(this.handle, id, render, geometry), "presentation");
+  }
+  dispose() {
+    this.handle !== (0) && (this.memory.release(this.scratch, SCRATCH_FLOATS2 * (4)), this.exports.engine_soft_destroy(this.handle), this.handle = (0));
+  }
+};
+
+// src/game/audio/types.ts
+var DEFAULT_OCCLUSION = { radius: 0.5, occludedGain: 0.35, occludedCutoff: 900, smoothingSeconds: 0.08 }, OCCLUSION_WORDS = 4, QUANTIZE_NOW = 0, QUANTIZE_BEAT = 1, QUANTIZE_BAR = 2, MAX_STEMS = 8, PHRASE_QUANTIZE_SHIFT = 16, MUSIC_POSITION_WORDS = 3, DEFAULT_LIMITER_CEILING_DB = -1, DEFAULT_LIMITER_RELEASE_SECONDS = 0.1, MIN_PRIORITY = -128, MAX_PRIORITY = 127, DEFAULT_PRIORITY = 0, PLAY_PRIORITY_SHIFT = 8, PRIORITY_MASK = 255, UNLIMITED_VOICES = -1, STEAL_POLICIES = ["oldest", "quietest", "refuse"], AUDIO_PREVIEW_SUFFIX = ".preview.m4a", EMITTER_COLUMNS = 8, EMITTER_X = 0, EMITTER_VX = 3, EMITTER_GAIN = 6, EMITTER_PITCH = 7, NO_EMITTER_COLUMN = 4294967295, DEFAULT_EMITTER_CAPACITY = 1024, NO_AUDIO_CAPABILITIES = {
+  spatial: false,
+  filters: false,
+  meters: false,
+  analyser: false,
+  reverb: false,
+  sends: false,
+  loopPoints: false,
+  streaming: false,
+  detune: false,
+  procedural: false
+}, FULL_AUDIO_CAPABILITIES = {
+  spatial: true,
+  filters: true,
+  meters: true,
+  analyser: true,
+  reverb: true,
+  sends: true,
+  loopPoints: true,
+  streaming: true,
+  detune: true,
+  procedural: true
+}, FILTER_KINDS = ["lowpass", "highpass", "bandpass", "notch", "allpass", "peaking", "lowshelf", "highshelf"], FILTER_OFF = -1, DISTANCE_MODELS = ["linear", "inverse", "exponential"], SPATIAL_WORDS = 8, SPATIAL_MODEL = 0, SPATIAL_REF_DISTANCE = 1, SPATIAL_MAX_DISTANCE = 2, SPATIAL_ROLLOFF = 3, SPATIAL_CONE_INNER = 4, SPATIAL_CONE_OUTER = 5, SPATIAL_CONE_OUTER_GAIN = 6, SPATIAL_DOPPLER = 7, DEFAULT_PANNER = {
+  distanceModel: "inverse",
+  refDistance: 1,
+  maxDistance: 1e4,
+  rolloff: 1,
+  coneInnerAngle: 360,
+  coneOuterAngle: 360,
+  coneOuterGain: 0,
+  doppler: 0
+}, METER_PEAK = 0, METER_RMS = 1;
+var ANALYSER_FREQUENCY = 0, ANALYSER_TIME = 1, DEFAULT_FFT_SIZE = 2048, MIN_FFT_SIZE = 32, MAX_FFT_SIZE = 32768, DEFAULT_SMOOTHING = 0.8, DEFAULT_MIN_DECIBELS = -100, DEFAULT_MAX_DECIBELS = -30, STREAM_STOPPED = 0, STREAM_PLAYING = 1, STREAM_PAUSED = 2, CENTS_PER_OCTAVE = 1200;
+function detuneRate(rate, cents) {
+  return cents === 0 ? rate : rate * 2 ** (cents / (1200));
+}
+
+// src/game/destruction/fracture.ts
+var FRACTURE_VERTEX_FLOATS = 8, FRACTURE_OPTION_FLOATS = 9, FRACTURE_HEADER_FLOATS = 5, MAX_FRACTURE_PIECES = 4096, ENGINE_FRACTURE_EXPORT_NAMES = [
+  "engine_fracturer_open",
+  "engine_fracturer_close",
+  "engine_fracturer_run",
+  "engine_fracturer_asset",
+  "engine_fracturer_model",
+  "engine_fracturer_fragment"
+], NULL3 = 0, F32_BYTES3 = 4, U32_BYTES = 4, AXES2 = 3, UV = 2, TRI = 3, DEFAULT_ANCHOR_HEIGHT = 0.02, NORMAL_AT = 3, UV_AT = 6;
+function engineFractureExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_FRACTURE_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+var EngineFracturer = class {
+  constructor(runtime, exports) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.handle = (0);
+  }
+  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 mesh to break");
+    return pointer;
+  }
+  free(pointer, bytes) {
+    this.runtime.exports.engine_free(pointer, Math.max(bytes, (4)), chunk2O2CG465_js.COLUMN_ALIGN);
+  }
+  fracture(mesh, options) {
+    let vertices = mesh.positions.length / (3);
+    if (!Number.isInteger(vertices) || mesh.indices.length % (3) !== 0)
+      throw new chunk2V7IL4HC_js.GameError("invalid_argument", "fracture needs whole vertices and triangles");
+    if (!(options.pieces >= 1 && options.pieces <= (4096)))
+      throw new chunk2V7IL4HC_js.GameError(
+        "invalid_argument",
+        `pieces must be between 1 and ${(4096)}`
+      );
+    if (this.handle === (0) && (this.handle = this.exports.engine_fracturer_open(), this.handle === (0)))
+      throw new chunk2V7IL4HC_js.GameError("not_initialized", "the engine could not open a fracturer");
+    let interleaved = new Float32Array(vertices * (8));
+    for (let v = 0; v < vertices; v++) {
+      let at = v * (8);
+      for (let a = 0; a < (3); a++)
+        interleaved[at + a] = mesh.positions[v * (3) + a], interleaved[at + (3) + a] = mesh.normals?.[v * (3) + a] ?? 0;
+      interleaved[at + (6)] = mesh.uvs?.[v * (2)] ?? 0, interleaved[at + (6) + 1] = mesh.uvs?.[v * (2) + 1] ?? 0;
+    }
+    let option = new Float32Array((9));
+    option.set([
+      options.pieces,
+      options.seed ?? 1,
+      options.impact ? 1 : 0,
+      options.impact?.[0] ?? 0,
+      options.impact?.[1] ?? 0,
+      options.impact?.[2] ?? 0,
+      options.focus ?? 0,
+      options.interiorUvScale ?? 1,
+      options.anchorHeight ?? (0.02)
+    ]);
+    let meshBytes = interleaved.byteLength, indexBytes = mesh.indices.byteLength, optionBytes = option.byteLength, meshAt = this.allocate(meshBytes), indexAt = this.allocate(indexBytes), optionAt = this.allocate(optionBytes);
+    try {
+      new Float32Array(this.runtime.memory.buffer).set(interleaved, meshAt >>> 2), new Uint32Array(this.runtime.memory.buffer).set(mesh.indices, indexAt >>> 2), new Float32Array(this.runtime.memory.buffer).set(option, optionAt >>> 2);
+      let count = this.exports.engine_fracturer_run(
+        this.handle,
+        meshAt,
+        vertices,
+        indexAt,
+        mesh.indices.length,
+        optionAt
+      );
+      if (!(count >= 0))
+        throw new chunk2V7IL4HC_js.GameError(
+          "invalid_argument",
+          `the engine refused to break the mesh (${count}); it must be closed and finite`
+        );
+      return {
+        asset: this.bytes(this.exports.engine_fracturer_asset, "fracture asset"),
+        model: this.bytes(this.exports.engine_fracturer_model, "fracture model"),
+        pieces: Array.from({ length: count }, (_, i) => this.piece(i))
+      };
+    } finally {
+      this.free(meshAt, meshBytes), this.free(indexAt, indexBytes), this.free(optionAt, optionBytes);
+    }
+  }
+  bytes(read, what) {
+    let length = read(this.handle, (0), 0);
+    if (!(length >= 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", `${what} refused (${length})`);
+    let at = this.allocate(length);
+    try {
+      return read(this.handle, at, length), new Uint8Array(this.runtime.memory.buffer, at, length).slice();
+    } finally {
+      this.free(at, length);
+    }
+  }
+  piece(index) {
+    let floats = this.exports.engine_fracturer_fragment(this.handle, index, (0), 0);
+    if (!(floats >= (5)))
+      throw new chunk2V7IL4HC_js.GameError("invalid_argument", `fracture piece refused (${floats})`);
+    let bytes = floats * (4), at = this.allocate(bytes);
+    try {
+      this.exports.engine_fracturer_fragment(this.handle, index, at, floats);
+      let data = new Float32Array(this.runtime.memory.buffer, at, floats).slice(), outer = data[0], corners = (floats - (5)) / (8), positions = new Float32Array(corners * (3)), normals = new Float32Array(corners * (3)), uvs = new Float32Array(corners * (2)), indices = new Uint32Array(corners);
+      for (let c = 0; c < corners; c++) {
+        let from = (5) + c * (8);
+        positions.set(data.subarray(from, from + (3)), c * (3)), normals.set(data.subarray(from + (3), from + (3) + (3)), c * (3)), uvs.set(data.subarray(from + (6), from + (6) + (2)), c * (2)), indices[c] = c;
+      }
+      return {
+        centroid: [data[2], data[3], data[4]],
+        positions,
+        normals,
+        uvs,
+        indices,
+        interiorStart: outer * (3)
+      };
+    } finally {
+      this.free(at, bytes);
+    }
+  }
+  dispose() {
+    this.handle !== (0) && (this.exports.engine_fracturer_close(this.handle), this.handle = (0));
+  }
+};
+
+exports.ANALYSER_FREQUENCY = (0);
+exports.ANALYSER_TIME = (1);
+exports.AUDIO_PREVIEW_SUFFIX = AUDIO_PREVIEW_SUFFIX;
+exports.CLOTH_ACROSS = (22);
+exports.CLOTH_BEND = (2);
+exports.CLOTH_COLLIDER_CAPSULE = (1);
+exports.CLOTH_COLLIDER_FLOATS = (8);
+exports.CLOTH_COLLIDER_SPHERE = (0);
+exports.CLOTH_COLUMNS = (16);
+exports.CLOTH_DAMPING = (4);
+exports.CLOTH_DOWN = (25);
+exports.CLOTH_FEATURE = CLOTH_FEATURE;
+exports.CLOTH_FRICTION = (10);
+exports.CLOTH_GRAVITY = (5);
+exports.CLOTH_MASS = (0);
+exports.CLOTH_MAX_COLLIDERS = (32);
+exports.CLOTH_ORIGIN = (19);
+exports.CLOTH_PIN = (28);
+exports.CLOTH_PIN_NONE = (0);
+exports.CLOTH_PIN_TOP_CORNERS = (2);
+exports.CLOTH_PIN_TOP_ROW = (1);
+exports.CLOTH_ROWS = (17);
+exports.CLOTH_SPACING = (18);
+exports.CLOTH_STRETCH = (1);
+exports.CLOTH_SUBSTEPS = (8);
+exports.CLOTH_TETHER_SLACK = (3);
+exports.CLOTH_THICKNESS = (9);
+exports.CRUMPLE_DESC_FLOATS = (14);
+exports.CRUMPLE_IMPACT_FLOATS = (6);
+exports.DEFAULT_ANCHOR_HEIGHT = (0.02);
+exports.DEFAULT_EMITTER_CAPACITY = (1024);
+exports.DEFAULT_FFT_SIZE = (2048);
+exports.DEFAULT_LIMITER_CEILING_DB = (-1);
+exports.DEFAULT_LIMITER_RELEASE_SECONDS = (0.1);
+exports.DEFAULT_MAX_DECIBELS = (-30);
+exports.DEFAULT_MIN_DECIBELS = (-100);
+exports.DEFAULT_OCCLUSION = DEFAULT_OCCLUSION;
+exports.DEFAULT_PANNER = DEFAULT_PANNER;
+exports.DEFAULT_PRIORITY = (0);
+exports.DEFAULT_SMOOTHING = (0.8);
+exports.DISTANCE_MODELS = DISTANCE_MODELS;
+exports.EMITTER_COLUMNS = (8);
+exports.EMITTER_GAIN = (6);
+exports.EMITTER_PITCH = (7);
+exports.EMITTER_VX = (3);
+exports.EMITTER_X = (0);
+exports.ENGINE_CLOTH_EXPORT_NAMES = ENGINE_CLOTH_EXPORT_NAMES;
+exports.ENGINE_CRUMPLE_EXPORT_NAMES = ENGINE_CRUMPLE_EXPORT_NAMES;
+exports.ENGINE_RIGID_COUPLING_EXPORT_NAMES = ENGINE_RIGID_COUPLING_EXPORT_NAMES;
+exports.ENGINE_SOFT_BODY_EXPORT_NAMES = ENGINE_SOFT_BODY_EXPORT_NAMES;
+exports.EngineCloths = EngineCloths;
+exports.EngineFracturer = EngineFracturer;
+exports.EngineSoftBodies = EngineSoftBodies;
+exports.FILTER_KINDS = FILTER_KINDS;
+exports.FILTER_OFF = (-1);
+exports.FULL_AUDIO_CAPABILITIES = FULL_AUDIO_CAPABILITIES;
+exports.MAX_FFT_SIZE = (32768);
+exports.MAX_FRACTURE_PIECES = (4096);
+exports.MAX_PRIORITY = (127);
+exports.MAX_STEMS = (8);
+exports.METER_PEAK = (0);
+exports.METER_RMS = (1);
+exports.MIN_FFT_SIZE = (32);
+exports.MIN_PRIORITY = (-128);
+exports.MUSIC_POSITION_WORDS = (3);
+exports.NO_AUDIO_CAPABILITIES = NO_AUDIO_CAPABILITIES;
+exports.NO_EMITTER_COLUMN = (4294967295);
+exports.OCCLUSION_WORDS = (4);
+exports.PHRASE_QUANTIZE_SHIFT = (16);
+exports.PLAY_PRIORITY_SHIFT = (8);
+exports.PRIORITY_MASK = (255);
+exports.QUANTIZE_BAR = (2);
+exports.QUANTIZE_BEAT = (1);
+exports.QUANTIZE_NOW = (0);
+exports.SOFT_BEND = (1);
+exports.SOFT_BODY_FEATURE = SOFT_BODY_FEATURE;
+exports.SOFT_COLLIDER_BOX = (3);
+exports.SOFT_COLLIDER_CAPSULE = (2);
+exports.SOFT_COLLIDER_FLOATS = (12);
+exports.SOFT_COLLIDER_PLANE = (0);
+exports.SOFT_COLLIDER_SPHERE = (1);
+exports.SOFT_CONTRACTION = (10);
+exports.SOFT_CREEP = (12);
+exports.SOFT_DAMPING = (3);
+exports.SOFT_FIBRE = (28);
+exports.SOFT_FRICTION = (9);
+exports.SOFT_GRAVITY = (4);
+exports.SOFT_LIMIT = (13);
+exports.SOFT_MAX_COLLIDERS = (32);
+exports.SOFT_RADIUS = (8);
+exports.SOFT_STRETCH = (0);
+exports.SOFT_SUBSTEPS = (7);
+exports.SOFT_VOLUME = (2);
+exports.SOFT_YIELD = (11);
+exports.SPATIAL_CONE_INNER = (4);
+exports.SPATIAL_CONE_OUTER = (5);
+exports.SPATIAL_CONE_OUTER_GAIN = (6);
+exports.SPATIAL_DOPPLER = (7);
+exports.SPATIAL_MAX_DISTANCE = (2);
+exports.SPATIAL_MODEL = (0);
+exports.SPATIAL_REF_DISTANCE = (1);
+exports.SPATIAL_ROLLOFF = (3);
+exports.SPATIAL_WORDS = (8);
+exports.STEAL_POLICIES = STEAL_POLICIES;
+exports.STREAM_PAUSED = (2);
+exports.STREAM_PLAYING = (1);
+exports.STREAM_STOPPED = (0);
+exports.UNLIMITED_VOICES = (-1);
+exports.detuneRate = detuneRate;
+exports.engineClothExports = engineClothExports;
+exports.engineFractureExports = engineFractureExports;
+exports.engineSoftBodyExports = engineSoftBodyExports;