@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-5PJEXSOW.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// src/interactives/game-ui/inspect.ts
+var UI_INSPECT_HOOK = "__cimplify_inspect", UI_CHECKS = ["text_overflow", "tap_target", "contrast", "safe_area", "text_size"], UI_EXEMPT_REASONS = {
+  text_overflow: ["intentional_clip", "marquee", "decorative"],
+  tap_target: ["expanded_hit_area", "dense_grid", "secondary_control", "decorative"],
+  contrast: ["decorative", "disabled", "logo", "inside_image"],
+  safe_area: ["full_bleed_background", "dismissible_overlay", "decorative"],
+  text_size: ["badge_counter", "legal_fine_print", "decorative"]
+};
+function hook() {
+  let found = globalThis[UI_INSPECT_HOOK];
+  return typeof found == "object" && found !== null ? found : null;
+}
+function uiSite(element, where, name) {
+  return hook()?.site(element.id, where, name ?? null), element;
+}
+function exemptUi(element, check, reason) {
+  if (!UI_EXEMPT_REASONS[check].includes(reason))
+    throw new RangeError(`${reason} is not a reason to exempt a node from ${check}; use one of ${UI_EXEMPT_REASONS[check].join(", ")}`);
+  return hook()?.exempt(element.id, check, reason), element;
+}
+var scenesApplied = /* @__PURE__ */ new WeakSet();
+function inspectScene(registered) {
+  let found = hook();
+  if (found === null || scenesApplied.has(found)) return null;
+  let requested = found.scene();
+  return requested === null || !registered(requested) ? null : (scenesApplied.add(found), found.sceneApplied(requested), requested);
+}
+function inspectSceneSwitch(target, registered) {
+  return inspectScene(registered) ?? target;
+}
+function inspectSceneEntered(name) {
+  hook()?.sceneEntered?.(name);
+}
+
+exports.UI_CHECKS = UI_CHECKS;
+exports.UI_EXEMPT_REASONS = UI_EXEMPT_REASONS;
+exports.UI_INSPECT_HOOK = UI_INSPECT_HOOK;
+exports.exemptUi = exemptUi;
+exports.inspectScene = inspectScene;
+exports.inspectSceneEntered = inspectSceneEntered;
+exports.inspectSceneSwitch = inspectSceneSwitch;
+exports.uiSite = uiSite;

package/dist/chunk-5SXDH3Y7.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var chunkVRBDAS5I_js = require('./chunk-VRBDAS5I.js');
+
+// src/interactives/game-ui/styling/vars.ts
+var FNV_OFFSET = 2166136261, FNV_PRIME = 16777619, VAR_ID_MASK = 1073741823;
+function varId(namespace, key) {
+  let text = `${namespace}.${key}`, hash = (2166136261);
+  for (let i = 0; i < text.length; i++)
+    hash ^= text.charCodeAt(i), hash = Math.imul(hash, (16777619));
+  return hash >>> 0 & (1073741823);
+}
+var UiVar = class {
+  constructor(id, name, fallback) {
+    this.id = id;
+    this.name = name;
+    this.fallback = fallback;
+  }
+}, UiSlot = class {
+  constructor(index, percent = false) {
+    this.index = index;
+    this.percent = percent;
+  }
+}, defaults = /* @__PURE__ */ new Map(), names = /* @__PURE__ */ new Map();
+function varDefault(id) {
+  return defaults.get(id);
+}
+function defineVars(namespace, values) {
+  let group = {};
+  for (let key of Object.keys(values)) {
+    let name = `${namespace}.${key}`, id = varId(namespace, key), known = names.get(id);
+    if (known !== void 0 && known !== name) throw new chunkVRBDAS5I_js.UiStyleError(`style variable ${name} collides with ${known}; rename one of them`);
+    names.set(id, name), defaults.set(id, values[key]), group[key] = new UiVar(id, name, values[key]);
+  }
+  return Object.freeze(group);
+}
+var UiTheme = class {
+  constructor(values) {
+    this.values = values;
+  }
+};
+function createTheme(group, overrides) {
+  let values = /* @__PURE__ */ new Map();
+  for (let key of Object.keys(overrides)) {
+    let variable = group[key];
+    if (variable === void 0) throw new chunkVRBDAS5I_js.UiStyleError(`theme sets ${key}, which the variable group does not define`);
+    let value = overrides[key];
+    value !== void 0 && values.set(variable.id, value);
+  }
+  return new UiTheme(values);
+}
+function mergeThemes(themes) {
+  let values = /* @__PURE__ */ new Map();
+  for (let theme of themes) for (let [id, value] of theme.values) values.set(id, value);
+  return new UiTheme(values);
+}
+
+// src/interactives/game-ui/styling/tokens.ts
+var TOKEN_NAMESPACE = "ui";
+function palette(theme) {
+  return {
+    surface: theme.surface,
+    raised: theme.raised,
+    border: theme.border,
+    accent: theme.accent,
+    onAccent: theme.on_accent,
+    text: theme.text,
+    muted: theme.muted,
+    track: theme.track,
+    danger: theme.danger,
+    success: theme.success,
+    gold: theme.gold
+  };
+}
+var tokens = defineVars(TOKEN_NAMESPACE, palette(chunkVRBDAS5I_js.DEFAULT_THEME));
+function themeTokens(theme) {
+  return createTheme(tokens, palette(theme));
+}
+
+exports.TOKEN_NAMESPACE = TOKEN_NAMESPACE;
+exports.UiSlot = UiSlot;
+exports.UiTheme = UiTheme;
+exports.UiVar = UiVar;
+exports.createTheme = createTheme;
+exports.defineVars = defineVars;
+exports.mergeThemes = mergeThemes;
+exports.themeTokens = themeTokens;
+exports.tokens = tokens;
+exports.varDefault = varDefault;
+exports.varId = varId;

package/dist/chunk-5YFBGGCK.mjs

@@ -0,0 +1,502 @@
+import { COLUMN_ALIGN } from './chunk-A33OORT7.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// 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 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 GameError("invalid_argument", "the engine refused the cloth world");
+      if (this.scratch = this.runtime.exports.engine_alloc(SCRATCH_FLOATS * (4), COLUMN_ALIGN), this.scratch === (0)) throw new 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 GameError("capacity_exceeded", `the cloth world has no room for the ${what}`);
+    if (code === -3) throw new GameError("unknown_resource", `the cloth ${what} names a missing cloth`);
+    if (!(code >= 0)) throw new 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)), COLUMN_ALIGN);
+    if (pointer === (0)) throw new 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)), 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 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 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 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)), COLUMN_ALIGN);
+    if (pointer === (0)) throw new 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)), 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 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 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 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 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 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)), COLUMN_ALIGN);
+    if (pointer === (0))
+      throw new 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)), COLUMN_ALIGN);
+  }
+  fracture(mesh, options) {
+    let vertices = mesh.positions.length / (3);
+    if (!Number.isInteger(vertices) || mesh.indices.length % (3) !== 0)
+      throw new GameError("invalid_argument", "fracture needs whole vertices and triangles");
+    if (!(options.pieces >= 1 && options.pieces <= (4096)))
+      throw new 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 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 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 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 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));
+  }
+};
+
+export { ANALYSER_FREQUENCY, ANALYSER_TIME, AUDIO_PREVIEW_SUFFIX, CLOTH_ACROSS, CLOTH_BEND, CLOTH_COLLIDER_CAPSULE, CLOTH_COLLIDER_FLOATS, CLOTH_COLLIDER_SPHERE, CLOTH_COLUMNS, CLOTH_DAMPING, CLOTH_DOWN, CLOTH_FEATURE, CLOTH_FRICTION, CLOTH_GRAVITY, CLOTH_MASS, CLOTH_MAX_COLLIDERS, CLOTH_ORIGIN, CLOTH_PIN, CLOTH_PIN_NONE, CLOTH_PIN_TOP_CORNERS, CLOTH_PIN_TOP_ROW, CLOTH_ROWS, CLOTH_SPACING, CLOTH_STRETCH, CLOTH_SUBSTEPS, CLOTH_TETHER_SLACK, CLOTH_THICKNESS, CRUMPLE_DESC_FLOATS, CRUMPLE_IMPACT_FLOATS, DEFAULT_ANCHOR_HEIGHT, DEFAULT_EMITTER_CAPACITY, DEFAULT_FFT_SIZE, DEFAULT_LIMITER_CEILING_DB, DEFAULT_LIMITER_RELEASE_SECONDS, DEFAULT_MAX_DECIBELS, DEFAULT_MIN_DECIBELS, DEFAULT_OCCLUSION, DEFAULT_PANNER, DEFAULT_PRIORITY, DEFAULT_SMOOTHING, DISTANCE_MODELS, EMITTER_COLUMNS, EMITTER_GAIN, EMITTER_PITCH, EMITTER_VX, EMITTER_X, ENGINE_CLOTH_EXPORT_NAMES, ENGINE_CRUMPLE_EXPORT_NAMES, ENGINE_RIGID_COUPLING_EXPORT_NAMES, ENGINE_SOFT_BODY_EXPORT_NAMES, EngineCloths, EngineFracturer, EngineSoftBodies, FILTER_KINDS, FILTER_OFF, FULL_AUDIO_CAPABILITIES, MAX_FFT_SIZE, MAX_FRACTURE_PIECES, MAX_PRIORITY, MAX_STEMS, METER_PEAK, METER_RMS, MIN_FFT_SIZE, MIN_PRIORITY, MUSIC_POSITION_WORDS, NO_AUDIO_CAPABILITIES, NO_EMITTER_COLUMN, OCCLUSION_WORDS, PHRASE_QUANTIZE_SHIFT, PLAY_PRIORITY_SHIFT, PRIORITY_MASK, QUANTIZE_BAR, QUANTIZE_BEAT, QUANTIZE_NOW, SOFT_BEND, SOFT_BODY_FEATURE, SOFT_COLLIDER_BOX, SOFT_COLLIDER_CAPSULE, SOFT_COLLIDER_FLOATS, SOFT_COLLIDER_PLANE, SOFT_COLLIDER_SPHERE, SOFT_CONTRACTION, SOFT_CREEP, SOFT_DAMPING, SOFT_FIBRE, SOFT_FRICTION, SOFT_GRAVITY, SOFT_LIMIT, SOFT_MAX_COLLIDERS, SOFT_RADIUS, SOFT_STRETCH, SOFT_SUBSTEPS, SOFT_VOLUME, SOFT_YIELD, SPATIAL_CONE_INNER, SPATIAL_CONE_OUTER, SPATIAL_CONE_OUTER_GAIN, SPATIAL_DOPPLER, SPATIAL_MAX_DISTANCE, SPATIAL_MODEL, SPATIAL_REF_DISTANCE, SPATIAL_ROLLOFF, SPATIAL_WORDS, STEAL_POLICIES, STREAM_PAUSED, STREAM_PLAYING, STREAM_STOPPED, UNLIMITED_VOICES, detuneRate, engineClothExports, engineFractureExports, engineSoftBodyExports };