@zylem/behaviors 0.8.9 → 0.8.11

package/dist/chunk-BR33KT4Z.js

@@ -0,0 +1,3186 @@
+import {
+  PUZZLE_ABILITIES,
+  puzzleCommandData,
+  puzzleData
+} from "./chunk-XNRY6NOC.js";
+import {
+  ADVENTURE_ABILITIES,
+  ADVENTURE_BUTTONS,
+  ADVENTURE_FLAGS
+} from "./chunk-Y5CCNMJI.js";
+import {
+  ENVIRONMENT_ABILITIES
+} from "./chunk-DDLZLJ7W.js";
+import {
+  TRAVERSAL_ABILITIES
+} from "./chunk-WF6HC5U3.js";
+import {
+  SPORTS_ABILITIES,
+  sportsData,
+  sportsOperation
+} from "./chunk-7IOQEXYR.js";
+import {
+  SKATE_ABILITIES,
+  skateData,
+  skateOperation
+} from "./chunk-3J3ISPFQ.js";
+import {
+  RACING_ABILITIES,
+  racingData,
+  racingOperation
+} from "./chunk-2UGT4MIF.js";
+import {
+  SURVIVAL_ABILITIES,
+  survivalData,
+  survivalOperation
+} from "./chunk-PDHHOVVQ.js";
+import {
+  CITY_ABILITIES,
+  CITY_EVENTS,
+  CITY_INTENTS,
+  cityData
+} from "./chunk-5VJIP535.js";
+import {
+  ENCOUNTER_ABILITIES,
+  ENCOUNTER_EVENTS,
+  ENCOUNTER_INTENTS,
+  encounterData
+} from "./chunk-73MHJY6R.js";
+import {
+  WEAPON_ABILITIES,
+  WEAPON_EVENTS,
+  WEAPON_PHASES,
+  weaponButtons,
+  weaponData,
+  weaponModeData,
+  weaponProjectileData
+} from "./chunk-GYEKT5AY.js";
+import {
+  COMBAT_ABILITIES,
+  COMBAT_EVENTS,
+  COMBAT_PHASES,
+  combatAttackData,
+  combatButtons,
+  combatData,
+  combatHitData
+} from "./chunk-V4M46BF6.js";
+import {
+  RHYTHM_ABILITIES,
+  rhythmData,
+  rhythmOperation
+} from "./chunk-LWGJ3QQZ.js";
+import {
+  MATCHING_ABILITIES,
+  matchingData,
+  matchingOperation
+} from "./chunk-5AJJ44QK.js";
+import {
+  LIFE_ABILITIES,
+  lifeData,
+  lifeOperation
+} from "./chunk-TZHO6P22.js";
+import {
+  DEFENSE_ABILITIES,
+  defenseData,
+  defenseOperation
+} from "./chunk-SFMJNAW3.js";
+import {
+  SQUAD_ABILITIES,
+  squadData,
+  squadOperation
+} from "./chunk-TSYXRRS4.js";
+import {
+  TACTICS_ABILITIES,
+  tacticsData,
+  tacticsOperation
+} from "./chunk-6DTIJB7B.js";
+import {
+  BATTLE_ABILITIES,
+  battleData,
+  battleOperation
+} from "./chunk-LMMF7KXF.js";
+import {
+  RPG_ABILITIES,
+  rpgData,
+  rpgOperation
+} from "./chunk-VU4LTE2X.js";
+
+// src/lib/runtime/wasm-stage-runtime.ts
+import {
+  loadStageFfi,
+  assertRuntimeCompatibility,
+  assertRuntimeBehavior,
+  STAGE_RENDER_STRIDE,
+  STAGE_INPUT_STRIDE,
+  STAGE_SNAPSHOT_STRIDE,
+  STAGE_EVENT_STRIDE
+} from "@zylem/runtime";
+var STAGE_INVALID_SLOT = 4294967295;
+var StageBodyKind = {
+  Dynamic: 0,
+  Static: 1,
+  KinematicPosition: 2,
+  KinematicVelocity: 3
+};
+var StageBoundaryDim = {
+  Two: 2,
+  Three: 3
+};
+var StageRicochetDim = {
+  Two: 2,
+  Three: 3
+};
+var StageRicochetReflection = {
+  Mirror: 0,
+  Angled: 1
+};
+var StageTopDownPlane = {
+  Xy: 0,
+  Xz: 1
+};
+var StageEventType = {
+  CollisionStarted: 1,
+  CollisionStopped: 2,
+  BoundaryHit: 3,
+  Ricochet: 4,
+  RegionEntered: 5,
+  JumpStarted: 6,
+  Landed: 7,
+  Wrapped: 8,
+  CooldownFired: 9,
+  GroundPoundImpact: 10,
+  DrowningDamage: 11,
+  Adventure: 12,
+  Puzzle: 13,
+  Combat: 14,
+  Weapon: 15,
+  Encounter: 16,
+  City: 17,
+  Survival: 18,
+  Racing: 19,
+  Skate: 20,
+  Sports: 21,
+  Rpg: 22,
+  Matching: 28,
+  Rhythm: 29,
+  Life: 27,
+  Defense: 26,
+  Squad: 25,
+  Tactics: 24,
+  Battle: 23
+};
+var StagePlatformerShapeSource = {
+  Auto: 0,
+  Override: 1
+};
+var STAGE_INPUT_BUTTON_JUMP = 1;
+var STAGE_INPUT_BUTTON_RUN = 2;
+function readBehaviorSnapshot(ref) {
+  const backref = ref;
+  const wasmStage = backref.__wasmStage;
+  const handle = backref.__entity?.runtimeHandle ?? -1;
+  if (!wasmStage || handle < 0) return null;
+  return wasmStage.readSnapshot(handle);
+}
+function readStageRenderSlot(view, slot, out) {
+  const base = slot * STAGE_RENDER_STRIDE;
+  if (slot < 0 || base + STAGE_RENDER_STRIDE > view.length) {
+    return null;
+  }
+  const result = out ?? {
+    position: [0, 0, 0],
+    rotation: [0, 0, 0, 1],
+    scale: 1,
+    custom: [0, 0, 0, 0],
+    isSleeping: false
+  };
+  result.position[0] = view[base];
+  result.position[1] = view[base + 1];
+  result.position[2] = view[base + 2];
+  result.rotation[0] = view[base + 3];
+  result.rotation[1] = view[base + 4];
+  result.rotation[2] = view[base + 5];
+  result.rotation[3] = view[base + 6];
+  const scale = view[base + 7];
+  result.scale = scale === 0 ? 1 : scale;
+  result.custom[0] = view[base + 8];
+  result.custom[1] = view[base + 9];
+  result.custom[2] = view[base + 10];
+  result.custom[3] = view[base + 11];
+  result.isSleeping = result.custom[3] > 0.5;
+  return result;
+}
+var WasmStageRuntime = class {
+  exports;
+  compatibility;
+  memory;
+  renderView = new Float32Array(0);
+  inputView = new Float32Array(0);
+  snapshotView = new Float32Array(0);
+  eventView = new Float32Array(0);
+  poseView = new Float32Array(0);
+  vec3View = new Float32Array(0);
+  queryView = new Float32Array(0);
+  scratchView = new Float32Array(0);
+  constructor(exports, options = {}) {
+    this.compatibility = assertRuntimeCompatibility(exports, options.requiredBehaviors);
+    this.exports = exports;
+    this.memory = exports.memory;
+    const capacity = Math.max(options.initialCapacity ?? 64, 8);
+    exports.zylem_stage_create(capacity);
+    if (options.gravity) {
+      exports.zylem_stage_set_gravity(
+        options.gravity[0],
+        options.gravity[1],
+        options.gravity[2]
+      );
+    }
+    this.refreshViews();
+  }
+  /** Recreate typed views over wasm memory. Call after step() or whenever memory may have grown. */
+  refreshViews() {
+    const buffer = this.memory.buffer;
+    const renderPtr = this.exports.zylem_stage_render_ptr();
+    const renderLen = this.exports.zylem_stage_render_len();
+    const inputPtr = this.exports.zylem_stage_input_ptr();
+    const inputLen = this.exports.zylem_stage_input_len();
+    const snapshotPtr = this.exports.zylem_stage_snapshot_ptr();
+    const snapshotLen = this.exports.zylem_stage_snapshot_len();
+    const eventPtr = this.exports.zylem_stage_event_ptr();
+    const eventLen = this.exports.zylem_stage_event_len();
+    const posePtr = this.exports.zylem_stage_pose_ptr();
+    const poseLen = this.exports.zylem_stage_pose_len();
+    const vec3Ptr = this.exports.zylem_stage_vec3_ptr();
+    const queryPtr = this.exports.zylem_stage_query_ptr();
+    const queryLen = this.exports.zylem_stage_query_len();
+    const scratchPtr = this.exports.zylem_stage_scratch_ptr();
+    const scratchCap = this.exports.zylem_stage_scratch_capacity();
+    this.renderView = renderLen > 0 ? new Float32Array(buffer, renderPtr, renderLen) : new Float32Array(0);
+    this.inputView = inputLen > 0 ? new Float32Array(buffer, inputPtr, inputLen) : new Float32Array(0);
+    this.snapshotView = snapshotLen > 0 ? new Float32Array(buffer, snapshotPtr, snapshotLen) : new Float32Array(0);
+    this.eventView = eventLen > 0 ? new Float32Array(buffer, eventPtr, eventLen) : new Float32Array(0);
+    this.poseView = poseLen > 0 ? new Float32Array(buffer, posePtr, poseLen) : new Float32Array(0);
+    this.vec3View = vec3Ptr !== 0 ? new Float32Array(buffer, vec3Ptr, 3) : new Float32Array(0);
+    this.queryView = queryLen > 0 ? new Float32Array(buffer, queryPtr, queryLen) : new Float32Array(0);
+    this.scratchView = scratchCap > 0 ? new Float32Array(buffer, scratchPtr, scratchCap) : new Float32Array(0);
+  }
+  /** Step the simulation by `dt` seconds. Refreshes views afterwards. */
+  step(dt) {
+    const active = this.exports.zylem_stage_step(dt);
+    this.refreshViews();
+    return active;
+  }
+  dispose() {
+    this.exports.zylem_stage_destroy();
+  }
+  get tickCount() {
+    return this.exports.zylem_stage_tick_count() >>> 0;
+  }
+  get activeCount() {
+    return this.exports.zylem_stage_active_count() >>> 0;
+  }
+  setGravity(x, y, z) {
+    this.exports.zylem_stage_set_gravity(x, y, z);
+  }
+  /**
+   * Toggle per-step collision-event collection in the wasm stage. Hosts
+   * with no collision listeners should disable it — with thousands of
+   * touching bodies the per-step contact-pair hashing is a significant
+   * fraction of `step()`.
+   */
+  setEventsEnabled(enabled) {
+    this.exports.zylem_stage_set_events_enabled(enabled ? 1 : 0);
+  }
+  /** Cap Rapier contact solver iterations (default 4). */
+  setSolverIterations(iterations) {
+    this.exports.zylem_stage_set_solver_iterations(Math.max(1, iterations | 0));
+  }
+  /**
+   * Override sleep activation thresholds for sleep-capable dynamic bodies.
+   * Higher velocity thresholds / lower `timeUntilSleep` put piles to sleep
+   * sooner.
+   */
+  setSleepThresholds(normalizedLinearThreshold, angularThreshold, timeUntilSleep) {
+    this.exports.zylem_stage_set_sleep_thresholds(
+      normalizedLinearThreshold,
+      angularThreshold,
+      timeUntilSleep
+    );
+  }
+  /** Number of awake (non-sleeping) dynamic rigid bodies. */
+  awakeDynamicCount() {
+    return this.exports.zylem_stage_awake_dynamic_count();
+  }
+  // ─── Entity lifecycle ───────────────────────────────────────────────
+  createEntity() {
+    const slot = this.exports.zylem_stage_create_entity() >>> 0;
+    this.refreshViews();
+    return slot;
+  }
+  destroyEntity(slot) {
+    return this.exports.zylem_stage_destroy_entity(slot) !== 0;
+  }
+  // ─── Body / collider attach ────────────────────────────────────────
+  attachBody(slot, config) {
+    const ok = this.exports.zylem_stage_attach_body(
+      slot,
+      config.kind,
+      config.position[0],
+      config.position[1],
+      config.position[2],
+      config.rotation[0],
+      config.rotation[1],
+      config.rotation[2],
+      config.rotation[3],
+      config.linearDamping,
+      config.angularDamping,
+      config.gravityScale,
+      config.canSleep ? 1 : 0,
+      config.ccdEnabled ? 1 : 0,
+      config.lockRotation[0] ? 1 : 0,
+      config.lockRotation[1] ? 1 : 0,
+      config.lockRotation[2] ? 1 : 0,
+      config.lockTranslation[0] ? 1 : 0,
+      config.lockTranslation[1] ? 1 : 0,
+      config.lockTranslation[2] ? 1 : 0
+    );
+    return ok !== 0;
+  }
+  addCollider(slot, config) {
+    const offset = config.offset;
+    const sensor = config.sensor ? 1 : 0;
+    const groups = config.collisionGroups >>> 0;
+    const friction = config.friction;
+    const restitution = config.restitution;
+    switch (config.shape.type) {
+      case "box": {
+        const [hx, hy, hz] = config.shape.halfExtents;
+        return this.exports.zylem_stage_add_collider_box(
+          slot,
+          hx,
+          hy,
+          hz,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      case "sphere": {
+        return this.exports.zylem_stage_add_collider_sphere(
+          slot,
+          config.shape.radius,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      case "capsule": {
+        return this.exports.zylem_stage_add_collider_capsule(
+          slot,
+          config.shape.halfHeight,
+          config.shape.radius,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      case "cylinder": {
+        return this.exports.zylem_stage_add_collider_cylinder(
+          slot,
+          config.shape.halfHeight,
+          config.shape.radius,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      case "cone": {
+        return this.exports.zylem_stage_add_collider_cone(
+          slot,
+          config.shape.halfHeight,
+          config.shape.radius,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      case "convexHull": {
+        const verts = config.shape.vertices;
+        if (verts.length % 3 !== 0) return false;
+        const offsetFloats = this.stageScratch(verts);
+        return this.exports.zylem_stage_add_collider_convex_hull(
+          slot,
+          offsetFloats,
+          verts.length / 3,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      case "trimesh": {
+        const verts = config.shape.vertices;
+        const indices = config.shape.indices;
+        if (verts.length % 3 !== 0 || indices.length % 3 !== 0) return false;
+        const vertOffset = this.stageScratch(verts);
+        const indexOffset = this.stageScratchIndices(indices, vertOffset + verts.length);
+        return this.exports.zylem_stage_add_collider_trimesh(
+          slot,
+          vertOffset,
+          verts.length / 3,
+          indexOffset,
+          indices.length,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      case "heightfield": {
+        const heights = config.shape.heights;
+        const heightOffset = this.stageScratch(heights);
+        return this.exports.zylem_stage_add_collider_heightfield(
+          slot,
+          config.shape.rows,
+          config.shape.cols,
+          config.shape.scale[0],
+          config.shape.scale[1],
+          config.shape.scale[2],
+          heightOffset,
+          offset[0],
+          offset[1],
+          offset[2],
+          friction,
+          restitution,
+          sensor,
+          groups
+        ) !== 0;
+      }
+      default: {
+        const _exhaustive = config.shape;
+        void _exhaustive;
+        return false;
+      }
+    }
+  }
+  stageScratch(values, baseOffset = 0) {
+    this.scratchView.set(values, baseOffset);
+    return baseOffset;
+  }
+  stageScratchIndices(indices, baseOffset) {
+    for (let i = 0; i < indices.length; i++) {
+      this.scratchView[baseOffset + i] = indices[i];
+    }
+    return baseOffset;
+  }
+  // ─── Pose / velocity ───────────────────────────────────────────────
+  getPose(slot, out) {
+    const ok = this.exports.zylem_stage_get_pose(slot) !== 0;
+    if (!ok) return null;
+    const v = this.poseView;
+    const result = out ?? {
+      position: [0, 0, 0],
+      rotation: [0, 0, 0, 1]
+    };
+    result.position[0] = v[0];
+    result.position[1] = v[1];
+    result.position[2] = v[2];
+    result.rotation[0] = v[3];
+    result.rotation[1] = v[4];
+    result.rotation[2] = v[5];
+    result.rotation[3] = v[6];
+    return result;
+  }
+  setPosition(slot, x, y, z) {
+    return this.exports.zylem_stage_set_position(slot, x, y, z) !== 0;
+  }
+  setRotation(slot, x, y, z, w) {
+    return this.exports.zylem_stage_set_rotation(slot, x, y, z, w) !== 0;
+  }
+  setLinearVelocity(slot, x, y, z) {
+    return this.exports.zylem_stage_set_linvel(slot, x, y, z) !== 0;
+  }
+  getLinearVelocity(slot, out) {
+    if (this.exports.zylem_stage_get_linvel(slot) === 0) return null;
+    const v = this.vec3View;
+    const result = out ?? [0, 0, 0];
+    result[0] = v[0];
+    result[1] = v[1];
+    result[2] = v[2];
+    return result;
+  }
+  setAngularVelocity(slot, x, y, z) {
+    return this.exports.zylem_stage_set_angvel(slot, x, y, z) !== 0;
+  }
+  getAngularVelocity(slot, out) {
+    if (this.exports.zylem_stage_get_angvel(slot) === 0) return null;
+    const v = this.vec3View;
+    const result = out ?? [0, 0, 0];
+    result[0] = v[0];
+    result[1] = v[1];
+    result[2] = v[2];
+    return result;
+  }
+  applyImpulse(slot, x, y, z) {
+    return this.exports.zylem_stage_apply_impulse(slot, x, y, z) !== 0;
+  }
+  // ─── Queries / diagnostics ─────────────────────────────────────────
+  /** Cast a ray against the physics world. Returns the closest hit or `null`. */
+  castRay(origin, dir, maxDistance, solidOnly = true) {
+    const hit = this.exports.zylem_stage_cast_ray(
+      origin[0],
+      origin[1],
+      origin[2],
+      dir[0],
+      dir[1],
+      dir[2],
+      maxDistance,
+      solidOnly ? 1 : 0
+    );
+    if (hit === 0) return null;
+    const v = this.queryView;
+    return {
+      slot: v[0] >>> 0,
+      distance: v[1],
+      normal: [v[2], v[3], v[4]]
+    };
+  }
+  /** Body introspection for debug tooling. */
+  getBodyInfo(slot) {
+    if (this.exports.zylem_stage_body_info(slot) === 0) return null;
+    const v = this.queryView;
+    return {
+      bodyType: v[0] | 0,
+      mass: v[1],
+      isSleeping: v[2] > 0.5,
+      isEnabled: v[3] > 0.5,
+      linearVelocity: [v[4], v[5], v[6]]
+    };
+  }
+  /** Wireframe debug render of every collider (all shapes). */
+  getDebugRender() {
+    const vertexCount = this.exports.zylem_stage_debug_render() >>> 0;
+    this.refreshViews();
+    if (vertexCount === 0) return null;
+    const buffer = this.memory.buffer;
+    const vertices = new Float32Array(
+      buffer,
+      this.exports.zylem_stage_debug_vertices_ptr(),
+      this.exports.zylem_stage_debug_vertices_len()
+    );
+    const colors = new Float32Array(
+      buffer,
+      this.exports.zylem_stage_debug_colors_ptr(),
+      this.exports.zylem_stage_debug_colors_len()
+    );
+    return {
+      vertices: new Float32Array(vertices),
+      colors: new Float32Array(colors)
+    };
+  }
+  // ─── Render / event reads ──────────────────────────────────────────
+  /** Read-only view over the render buffer; one slot occupies {@link STAGE_RENDER_STRIDE} floats. */
+  get render() {
+    return this.renderView;
+  }
+  get renderStride() {
+    return STAGE_RENDER_STRIDE;
+  }
+  /**
+   * Decode a single entity slot from the live render buffer. Convenience
+   * wrapper over {@link readStageRenderSlot} bound to this runtime's view.
+   */
+  readRenderSlot(slot, out) {
+    return readStageRenderSlot(this.renderView, slot, out);
+  }
+  /** Drain the wasm event buffer into a fresh array of typed events. */
+  drainEvents() {
+    const count = this.exports.zylem_stage_event_count() >>> 0;
+    if (count === 0) return [];
+    const view = this.eventView;
+    const events = new Array(count);
+    for (let i = 0; i < count; i++) {
+      const base = i * STAGE_EVENT_STRIDE;
+      const primaryRaw = view[base + 1];
+      const secondaryRaw = view[base + 2];
+      events[i] = {
+        type: view[base] | 0,
+        primarySlot: Number.isNaN(primaryRaw) ? null : primaryRaw >>> 0,
+        secondarySlot: Number.isNaN(secondaryRaw) ? null : secondaryRaw >>> 0,
+        payload: [view[base + 3], view[base + 4], view[base + 5]]
+      };
+    }
+    return events;
+  }
+  // ─── Batched input / snapshot buffers ─────────────────────────────
+  /** Writable view over the slot-indexed input buffer ({@link STAGE_INPUT_STRIDE} floats/slot). */
+  get input() {
+    return this.inputView;
+  }
+  get inputStride() {
+    return STAGE_INPUT_STRIDE;
+  }
+  /** Read-only view over the per-slot behavior snapshot buffer ({@link STAGE_SNAPSHOT_STRIDE} floats/slot). */
+  get snapshot() {
+    return this.snapshotView;
+  }
+  get snapshotStride() {
+    return STAGE_SNAPSHOT_STRIDE;
+  }
+  /**
+   * Write the primary movement axes for a slot into the slot-indexed input
+   * buffer and mark the slot dirty. Field-scoped (doesn't touch look
+   * deltas or buttons) so multiple behaviors composed on one entity can
+   * each write their part.
+   */
+  writeInputAxes(slot, axisA, axisB) {
+    const base = slot * STAGE_INPUT_STRIDE;
+    const view = this.inputView;
+    if (slot < 0 || base + STAGE_INPUT_STRIDE > view.length) return false;
+    view[base] = axisA;
+    view[base + 1] = axisB;
+    view[base + 7] = 1;
+    return true;
+  }
+  /** Write the look deltas (first-person yaw/pitch) for a slot. */
+  writeInputLook(slot, yawDelta, pitchDelta) {
+    const base = slot * STAGE_INPUT_STRIDE;
+    const view = this.inputView;
+    if (slot < 0 || base + STAGE_INPUT_STRIDE > view.length) return false;
+    view[base + 2] = yawDelta;
+    view[base + 3] = pitchDelta;
+    view[base + 7] = 1;
+    return true;
+  }
+  /** Write reserved input slots (thruster world-space vector X/Y). */
+  writeInputReserved(slot, reservedA, reservedB) {
+    const base = slot * STAGE_INPUT_STRIDE;
+    const view = this.inputView;
+    if (slot < 0 || base + STAGE_INPUT_STRIDE > view.length) return false;
+    view[base + 5] = reservedA;
+    view[base + 6] = reservedB;
+    view[base + 7] = 1;
+    return true;
+  }
+  /**
+   * Set or clear one button bit ({@link STAGE_INPUT_BUTTON_JUMP} /
+   * {@link STAGE_INPUT_BUTTON_RUN}) in a slot's input bitmask.
+   */
+  writeInputButton(slot, buttonMask, pressed) {
+    const base = slot * STAGE_INPUT_STRIDE;
+    const view = this.inputView;
+    if (slot < 0 || base + STAGE_INPUT_STRIDE > view.length) return false;
+    const current = view[base + 4] | 0;
+    view[base + 4] = pressed ? current | buttonMask : current & ~buttonMask;
+    view[base + 7] = 1;
+    return true;
+  }
+  /**
+   * Decode a slot's behavior snapshot from the buffer written at the end of
+   * the previous step. Returns `null` when the slot has no behavior data.
+   */
+  readSnapshot(slot, out) {
+    const base = slot * STAGE_SNAPSHOT_STRIDE;
+    const view = this.snapshotView;
+    if (slot < 0 || base + STAGE_SNAPSHOT_STRIDE > view.length) return null;
+    if (view[base + 7] === 0) return null;
+    const result = out ?? {
+      grounded: false,
+      fsmState: 0,
+      jumpCount: 0,
+      verticalVelocity: 0,
+      speed: 0,
+      yaw: 0,
+      pitch: 0
+    };
+    result.grounded = view[base] > 0.5;
+    result.fsmState = view[base + 1] | 0;
+    result.jumpCount = view[base + 2] | 0;
+    result.verticalVelocity = view[base + 3];
+    result.speed = view[base + 4];
+    result.yaw = view[base + 5];
+    result.pitch = view[base + 6];
+    return result;
+  }
+  // ─── Behavior helpers ─────────────────────────────────────────────
+  get queryScratch() {
+    return this.queryView;
+  }
+  attachCooldown(slot) {
+    assertRuntimeBehavior(this.compatibility, "cooldown");
+    return this.exports.zylem_stage_attach_cooldown(slot) !== 0;
+  }
+  registerCooldown(slot, id, durationSeconds, immediate = false) {
+    return this.exports.zylem_stage_cooldown_register(slot, id >>> 0, durationSeconds, immediate ? 1 : 0) !== 0;
+  }
+  fireCooldown(slot, id) {
+    return this.exports.zylem_stage_cooldown_fire(slot, id >>> 0) !== 0;
+  }
+  resetCooldown(slot, id) {
+    return this.exports.zylem_stage_cooldown_reset(slot, id >>> 0) !== 0;
+  }
+  cooldownRemaining(slot, id) {
+    return this.exports.zylem_stage_cooldown_remaining(slot, id >>> 0);
+  }
+  attachWorldBoundary(slot, dim, bounds) {
+    assertRuntimeBehavior(this.compatibility, "world-boundary");
+    return this.exports.zylem_stage_attach_world_boundary(
+      slot,
+      dim,
+      bounds.top,
+      bounds.bottom,
+      bounds.left,
+      bounds.right,
+      bounds.front ?? 0,
+      bounds.back ?? 0,
+      bounds.padding ?? 0
+    ) !== 0;
+  }
+  queryWorldBoundary(slot) {
+    if (this.exports.zylem_stage_query_world_boundary(slot) === 0) return null;
+    const v = this.queryView;
+    return {
+      hits: v[0] | 0,
+      clamped: [v[1], v[2], v[3]]
+    };
+  }
+  attachScreenWrap(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "screen-wrap");
+    return this.exports.zylem_stage_attach_screen_wrap(
+      slot,
+      opts.width,
+      opts.height,
+      opts.centerX ?? 0,
+      opts.centerY ?? 0,
+      opts.edgeThreshold ?? 0
+    ) !== 0;
+  }
+  queryScreenWrap(slot) {
+    if (this.exports.zylem_stage_query_screen_wrap(slot) === 0) return null;
+    const v = this.queryView;
+    return { fsm: v[0] | 0, lastWrappedAxes: v[1] | 0 };
+  }
+  attachRicochet(slot, dim, opts) {
+    assertRuntimeBehavior(this.compatibility, "ricochet");
+    return this.exports.zylem_stage_attach_ricochet(
+      slot,
+      dim,
+      opts.minSpeed,
+      opts.maxSpeed,
+      opts.speedMultiplier,
+      opts.maxAngleDeg,
+      opts.reflectionMode
+    ) !== 0;
+  }
+  queryRicochet(slot) {
+    if (this.exports.zylem_stage_query_ricochet(slot) === 0) return null;
+    const v = this.queryView;
+    return { bounces: v[0] | 0, lastKind: v[1] | 0 };
+  }
+  attachThruster(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "thruster");
+    return this.exports.zylem_stage_attach_thruster(
+      slot,
+      opts.maxSpeed,
+      opts.acceleration,
+      opts.turnRateRadPerSec,
+      opts.linearDamping
+    ) !== 0;
+  }
+  setThrusterInput(slot, thrust, turn, vectorX = 0, vectorY = 0) {
+    this.exports.zylem_stage_set_thruster_input(slot, thrust, turn, vectorX, vectorY);
+  }
+  queryThruster(slot) {
+    if (this.exports.zylem_stage_query_thruster(slot) === 0) return null;
+    const v = this.queryView;
+    return { headingRad: v[0], speed: v[1] };
+  }
+  attachRhythm(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = RHYTHM_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = rhythmData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_rhythm?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachRhythm(slot) {
+    const ok = this.exports.zylem_stage_detach_rhythm?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  rhythmAction(slot, action) {
+    const encoded = rhythmOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    if (op < 40)
+      assertRuntimeBehavior(this.compatibility, RHYTHM_ABILITIES[index]);
+    const target = 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.length > 16 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_rhythm_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryRhythm(slot) {
+    const page = (n) => {
+      if (this.exports.zylem_stage_query_rhythm?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      return Array.from(this.queryView);
+    };
+    const a = page(0), b = page(1);
+    if (!a || !b) return null;
+    const notes = [];
+    for (let i = 0; i < a[9]; i++) {
+      const n = page(i + 2);
+      if (!n) return null;
+      notes.push({
+        kind: n[0],
+        timestamp: n[1],
+        end: n[2],
+        lanes: n[3],
+        scene: n[4],
+        eligible: !!n[5],
+        phase: n[6],
+        result: n[7],
+        headResult: n[8],
+        offset: n[9],
+        releaseOffset: n[10],
+        ticks: n[11],
+        cue: n[12],
+        responseCue: !!n[13]
+      });
+    }
+    return {
+      abilities: RHYTHM_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      clock: a[3],
+      started: !!a[4],
+      paused: !!a[5],
+      score: a[6],
+      hits: a[7],
+      misses: a[8],
+      scene: a[10],
+      held: a[11],
+      chain: !!a[12],
+      meter: a[13],
+      powerUntil: a[14],
+      failed: !!a[15],
+      performance: b[0],
+      transitions: b[1],
+      cues: b[2],
+      tempoSegments: b[3],
+      settledPhrases: b[4],
+      callPhase: b[5],
+      chartCursor: b[6],
+      patternResult: b[7],
+      notes
+    };
+  }
+  attachMatching(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = MATCHING_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = matchingData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_matching?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachMatching(slot) {
+    const ok = this.exports.zylem_stage_detach_matching?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  matchingAction(slot, action) {
+    const encoded = matchingOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    if (op < 40)
+      assertRuntimeBehavior(
+        this.compatibility,
+        MATCHING_ABILITIES[index]
+      );
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.length > 16 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_matching_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryMatching(slot) {
+    const pages = [];
+    for (let n = 0; n < 27; n++) {
+      if (this.exports.zylem_stage_query_matching?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      pages.push(Array.from(this.queryView));
+    }
+    const a = pages[0], b = pages[1];
+    return {
+      abilities: MATCHING_ABILITIES.filter(
+        (_, i) => !!(a[0] & 1 << i)
+      ),
+      lastRequest: a[1],
+      revision: a[2],
+      clock: a[3],
+      width: a[4],
+      height: a[5],
+      started: !!a[6],
+      chain: a[7],
+      score: a[8],
+      cleared: a[9],
+      lastMatch: a[10],
+      rows: a[11],
+      riseProgress: a[12],
+      dangerElapsed: a[13],
+      lost: !!a[14],
+      generation: a[15],
+      flipperConfigured: !!b[0],
+      flipperPressed: !!b[1],
+      flipperAngle: b[2],
+      charge: b[3],
+      staged: !!b[4],
+      launches: b[5],
+      bumperHits: b[6],
+      bumperReadyAt: b[7],
+      modePhase: b[8],
+      modeCursor: b[9],
+      modeDeadline: b[10],
+      wins: b[11],
+      patternLength: b[12],
+      pressure: !!b[13],
+      pauseUntil: b[14],
+      chainUntil: b[15],
+      cells: Array.from({ length: 96 }, (_, i) => {
+        const u = pages[2 + Math.floor(i / 4)], j = i % 4 * 4;
+        return {
+          color: u[j],
+          phase: u[j + 1],
+          generation: u[j + 2],
+          garbage: u[j + 3]
+        };
+      }),
+      pattern: pages[26].slice(0, 8),
+      targets: pages[26].slice(8, 16).map(Boolean)
+    };
+  }
+  attachLife(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = LIFE_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = lifeData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_life?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachLife(slot) {
+    const ok = this.exports.zylem_stage_detach_life?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  lifeAction(slot, action) {
+    const encoded = lifeOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    if (op < 40)
+      assertRuntimeBehavior(this.compatibility, LIFE_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.length > 16 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_life_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryLife(slot) {
+    const pages = [];
+    for (let n = 0; n < 74; n++) {
+      if (this.exports.zylem_stage_query_life?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      pages.push(Array.from(this.queryView));
+    }
+    const a = pages[0], b = pages[1];
+    return {
+      abilities: LIFE_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      day: a[3],
+      season: a[4],
+      minute: a[5],
+      rain: a[6],
+      stamina: a[7],
+      fatigue: a[8],
+      route: a[9],
+      activity: a[10],
+      destinationX: a[11],
+      destinationY: a[12],
+      destinationZ: a[13],
+      overrideUntil: a[14],
+      roomScore: a[15],
+      fishPhase: b[0],
+      fishClock: b[1],
+      biteAt: b[2],
+      deadline: b[3],
+      catches: b[4],
+      castX: b[5],
+      castY: b[6],
+      castZ: b[7],
+      fruitSerial: b[8],
+      memoryCount: b[9],
+      roomWidth: b[10],
+      roomHeight: b[11],
+      slept: !!b[12],
+      plots: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[2 + i];
+        return {
+          configured: !!u[0],
+          phase: u[1],
+          stage: u[2],
+          progress: u[3],
+          moisture: u[4],
+          seasons: u[5],
+          harvests: u[6],
+          capacity: u[7],
+          moistureRequired: u[8],
+          regrowDays: u[9],
+          regrowing: !!u[10]
+        };
+      }),
+      animals: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[10 + i];
+        return {
+          configured: !!u[0],
+          health: u[1],
+          affection: u[2],
+          care: u[3],
+          product: u[4],
+          collected: u[5]
+        };
+      }),
+      people: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[18 + i];
+        return {
+          configured: !!u[0],
+          score: u[1],
+          eventSerial: u[2],
+          rewards: u[3]
+        };
+      }),
+      memories: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[26 + i];
+        return {
+          eventSerial: u[0],
+          row: u[1],
+          kind: u[2],
+          delta: u[3],
+          day: u[4]
+        };
+      }),
+      trees: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[34 + i];
+        return {
+          configured: !!u[0],
+          fruit: u[1],
+          capacity: u[2],
+          due: u[3],
+          receipt: u[4],
+          pending: !!u[5],
+          bound: !!u[6],
+          x: u[7],
+          y: u[8],
+          z: u[9],
+          regrowDays: u[10]
+        };
+      }),
+      furniture: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[42 + i];
+        return {
+          configured: !!u[0],
+          placed: !!u[1],
+          width: u[2],
+          height: u[3],
+          x: u[4],
+          y: u[5],
+          rotation: u[6],
+          score: u[7],
+          style: u[8]
+        };
+      }),
+      schedules: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[50 + i];
+        return {
+          configured: !!u[0],
+          start: u[1],
+          end: u[2],
+          weekdays: u[3],
+          seasons: u[4],
+          activity: u[5],
+          x: u[6],
+          y: u[7],
+          z: u[8],
+          priority: u[9]
+        };
+      }),
+      blocked: pages.slice(58, 74).flat().map(Boolean)
+    };
+  }
+  attachDefense(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = DEFENSE_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = defenseData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_defense?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachDefense(slot) {
+    const ok = this.exports.zylem_stage_detach_defense?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  defenseAction(slot, action) {
+    const encoded = defenseOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    if (op < 40)
+      assertRuntimeBehavior(
+        this.compatibility,
+        DEFENSE_ABILITIES[index]
+      );
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.length > 16 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_defense_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryDefense(slot) {
+    const pages = [];
+    for (let n = 0; n < 37; n++) {
+      if (this.exports.zylem_stage_query_defense?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      pages.push(Array.from(this.queryView));
+    }
+    const a = pages[0], b = pages[1], c = pages[2];
+    return {
+      abilities: DEFENSE_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      bank: a[3],
+      health: a[4],
+      direction: a[5],
+      speed: a[6],
+      blocked: a[7],
+      selected: a[8],
+      shots: a[9],
+      chewed: a[10],
+      bites: a[11],
+      breaks: a[12],
+      damageSerial: a[13],
+      firing: !!a[14],
+      advancing: !!a[15],
+      minePhase: b[0],
+      mineRemaining: b[1],
+      detonations: b[2],
+      producing: !!b[3],
+      productionClock: b[4],
+      resourceSerial: b[5],
+      collected: b[6],
+      wavePhase: b[7],
+      waveSerial: b[8],
+      budget: b[9],
+      spawnSerial: b[10],
+      spawnCount: b[11],
+      deploymentSerial: b[12],
+      sweepPhase: b[13],
+      sweepHits: b[14],
+      outstandingResources: b[15],
+      x: c[0],
+      y: c[1],
+      z: c[2],
+      vaultUsed: !!c[3],
+      vaultPhase: c[4],
+      vaultTime: c[5],
+      vaultDuration: c[6],
+      burrowPhase: c[7],
+      burrowGoal: c[8],
+      emergeRemaining: c[9],
+      sweepEnd: c[10],
+      activeSpawns: c[11],
+      shotClock: c[12],
+      chewClock: c[13],
+      waveClock: c[14],
+      creditSerial: c[15],
+      targets: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[3 + i];
+        return {
+          present: !!u[0],
+          kind: u[1],
+          lane: u[2],
+          health: u[3],
+          flags: u[4],
+          x: u[5],
+          y: u[6],
+          z: u[7]
+        };
+      }),
+      resources: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[11 + i];
+        return {
+          receipt: u[0],
+          phase: u[1],
+          value: u[2],
+          lane: u[3],
+          bound: !!u[4]
+        };
+      }),
+      spawns: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[19 + i];
+        return {
+          receipt: u[0],
+          phase: u[1],
+          value: u[2],
+          lane: u[3],
+          bound: !!u[4]
+        };
+      }),
+      tiles: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[27 + i];
+        return {
+          configured: !!u[0],
+          terrainMask: u[1],
+          x: u[2],
+          y: u[3],
+          z: u[4],
+          phase: u[5],
+          receipt: u[6],
+          card: u[7],
+          cost: u[8],
+          bound: !!u[9]
+        };
+      }),
+      cards: Array.from({ length: 4 }, (_, i) => ({
+        configured: !!pages[35][i * 4],
+        cost: pages[35][i * 4 + 1],
+        remaining: pages[35][i * 4 + 2],
+        terrainMask: pages[35][i * 4 + 3]
+      })),
+      armor: Array.from({ length: 3 }, (_, i) => ({
+        health: pages[36][i * 2],
+        damageMask: pages[36][i * 2 + 1]
+      }))
+    };
+  }
+  attachSquad(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = SQUAD_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = squadData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_squad?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachSquad(slot) {
+    const ok = this.exports.zylem_stage_detach_squad?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  squadAction(slot, action) {
+    const encoded = squadOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    if (op < 40)
+      assertRuntimeBehavior(this.compatibility, SQUAD_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.length > 16 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_squad_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  querySquad(slot) {
+    const pages = [];
+    for (let n = 0; n < 28; n++) {
+      if (this.exports.zylem_stage_query_squad?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      pages.push(Array.from(this.queryView));
+    }
+    const a = pages[0], b = pages[1];
+    return {
+      abilities: SQUAD_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      whistling: !!a[3],
+      radius: a[4],
+      maximumRadius: a[5],
+      recalls: a[6],
+      flightSerial: a[7],
+      completed: a[8],
+      hitSerial: a[9],
+      lossSerial: a[10],
+      deliverySerial: a[11],
+      spawnSerial: a[12],
+      daySerial: a[13],
+      dayPhase: a[14],
+      dayRemaining: a[15],
+      dayBase: b[0],
+      safeRadius: b[1],
+      safe: b[2],
+      lost: b[3],
+      blocked: b[4],
+      workers: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[2 + i], p = pages[10 + i];
+        return {
+          present: !!u[0],
+          mode: u[1],
+          species: u[2],
+          growth: u[3],
+          task: u[4],
+          speed: u[5],
+          workRate: u[6],
+          strength: u[7],
+          damage: u[8],
+          recallable: !!u[9],
+          protected: !!u[10],
+          hazard: u[11],
+          panicRemaining: u[12],
+          flightResult: u[13],
+          growthReceipt: u[14],
+          lossReceipt: u[15],
+          x: p[0],
+          y: p[1],
+          z: p[2],
+          goalX: p[3],
+          goalY: p[4],
+          goalZ: p[5],
+          slotX: p[6],
+          slotY: p[7],
+          slotZ: p[8],
+          flightTime: p[9],
+          flightDuration: p[10],
+          attackClock: p[11],
+          dealt: p[12],
+          landedTask: p[13]
+        };
+      }),
+      tasks: Array.from({ length: 4 }, (_, i) => {
+        const u = pages[18 + i], p = pages[22 + i];
+        return {
+          present: !!u[0],
+          kind: u[1],
+          phase: u[2],
+          required: u[3],
+          progress: u[4],
+          capacity: u[5],
+          value: u[6],
+          health: u[7],
+          stored: u[8],
+          active: u[9],
+          populationCapacity: u[10],
+          activeLimit: u[11],
+          receipt: u[12],
+          assigned: u[13],
+          strength: u[14],
+          speed: u[15],
+          x: p[0],
+          y: p[1],
+          z: p[2],
+          destinationX: p[3],
+          destinationY: p[4],
+          destinationZ: p[5],
+          routed: !!p[6]
+        };
+      }),
+      growth: Array.from({ length: 3 }, (_, i) => ({
+        speed: pages[26][i * 2],
+        work: pages[26][i * 2 + 1]
+      })),
+      affinities: Array.from({ length: 4 }, (_, i) => ({
+        immuneMask: pages[27][i * 3],
+        rescueMask: pages[27][i * 3 + 1],
+        panicDuration: pages[27][i * 3 + 2]
+      }))
+    };
+  }
+  attachTactics(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = TACTICS_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = tacticsData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_tactics?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachTactics(slot) {
+    const ok = this.exports.zylem_stage_detach_tactics?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  tacticsAction(slot, action) {
+    const encoded = tacticsOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    if (op < 40)
+      assertRuntimeBehavior(
+        this.compatibility,
+        TACTICS_ABILITIES[index]
+      );
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.length > 16 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_tactics_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryTactics(slot) {
+    const pages = [];
+    for (let n = 0; n < 34; n++) {
+      if (this.exports.zylem_stage_query_tactics?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      pages.push(Array.from(this.queryView));
+    }
+    const a = pages[0], b = pages[1];
+    return {
+      abilities: TACTICS_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      width: a[3],
+      height: a[4],
+      phase: a[5],
+      team: a[6],
+      movementUnit: a[7],
+      rangeUnit: a[8],
+      rangeAllowed: !!a[9],
+      rangeDistance: a[10],
+      terrainDefense: a[11],
+      terrainAvoid: a[12],
+      healed: a[13],
+      previewDamage: a[14],
+      lastCost: a[15],
+      combatSerial: b[0],
+      combatPhase: b[1],
+      cursor: b[2],
+      strikeCount: b[3],
+      lastAttacker: b[4],
+      lastDefender: b[5],
+      damage: b[6],
+      hit: !!b[7],
+      lossSerial: b[8],
+      captureSerial: b[9],
+      supplySerial: b[10],
+      transportSerial: b[11],
+      advantageDamage: b[12],
+      advantageHit: b[13],
+      powerSerial: b[14],
+      units: Array.from({ length: 8 }, (_, i) => {
+        const u = [...pages[2 + i], ...pages[10 + i]];
+        return {
+          present: !!u[0],
+          x: u[1],
+          y: u[2],
+          team: u[3],
+          unitClass: u[4],
+          health: u[5],
+          maximumHealth: u[6],
+          movementRemaining: u[7],
+          attack: u[8],
+          defense: u[9],
+          speed: u[10],
+          weapon: u[11],
+          minimumRange: u[12],
+          maximumRange: u[13],
+          fuel: u[14],
+          ammo: u[15],
+          loss: u[16],
+          lossSerial: u[17],
+          exempt: !!u[18],
+          carrier: u[19],
+          size: u[20],
+          capacity: u[21],
+          cargoMask: u[22],
+          supplyMask: u[23],
+          durability: u[24],
+          acted: !!u[25],
+          spent: u[26],
+          resourceSerial: u[27],
+          healPhase: u[28],
+          maximumFuel: u[29],
+          maximumAmmo: u[30],
+          lineOfSight: !!u[31]
+        };
+      }),
+      structures: Array.from({ length: 8 }, (_, i) => {
+        const u = pages[26 + Math.floor(i / 2)].slice(
+          i % 2 * 8,
+          i % 2 * 8 + 8
+        );
+        return {
+          present: !!u[0],
+          x: u[1],
+          y: u[2],
+          owner: u[3],
+          progress: u[4],
+          maximum: u[5],
+          fuel: u[6],
+          ammo: u[7]
+        };
+      }),
+      powers: Array.from({ length: 4 }, (_, i) => {
+        const u = pages[30 + i];
+        return {
+          charge: u[0],
+          threshold: u[1],
+          duration: u[2],
+          active: !!u[3],
+          remainingTurns: u[4],
+          attack: u[5],
+          defense: u[6],
+          movement: u[7],
+          chargeSerial: u[8],
+          turns: u[9]
+        };
+      }),
+      cells: Array.from({ length: 64 }, (_, i) => {
+        const p = pages[18 + Math.floor(i / 8)], code = p[i % 8];
+        return {
+          x: i % 8,
+          y: Math.floor(i / 8),
+          terrain: code & 7,
+          blocked: !!(code & 8),
+          occupant: code >> 4 & 15,
+          structure: code >> 8 & 15,
+          inRange: !!(code & 4096),
+          cost: p[i % 8 + 8]
+        };
+      }).filter((c) => c.x < a[3] && c.y < a[4])
+    };
+  }
+  attachBattle(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = BATTLE_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = battleData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_battle?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachBattle(slot) {
+    const ok = this.exports.zylem_stage_detach_battle?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  battleAction(slot, action) {
+    const encoded = battleOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    assertRuntimeBehavior(this.compatibility, BATTLE_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.length > 16 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_battle_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryBattle(slot) {
+    const pages = [];
+    for (let n = 0; n < 10; n++) {
+      if (this.exports.zylem_stage_query_battle?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      pages.push(Array.from(this.queryView));
+    }
+    const [a, b, c, d, e, f, g, h, i, j] = pages;
+    const v = (p, i2) => [
+      p[i2],
+      p[i2 + 1],
+      p[i2 + 2]
+    ];
+    const q = (p, i2) => [
+      p[i2],
+      p[i2 + 1],
+      p[i2 + 2],
+      p[i2 + 3]
+    ];
+    return {
+      abilities: BATTLE_ABILITIES.filter((_, i2) => !!(a[0] & 1 << i2)),
+      lastRequest: a[1],
+      revision: a[2],
+      outcome: a[3],
+      points: a[4],
+      budgetTurn: a[5],
+      turn: a[6],
+      frozen: !!a[7],
+      orderCount: a[8],
+      cursor: a[9],
+      lastAction: a[10],
+      canceled: a[11],
+      typeSerial: a[12],
+      multiplier: a[13],
+      damage: a[14],
+      reaction: a[15],
+      hook: b[0],
+      tickAmount: b[1],
+      blocked: !!b[2],
+      captureSerial: b[3],
+      captureResult: b[4],
+      captureChance: b[5],
+      captureRoll: b[6],
+      captureStock: b[7],
+      captureItem: b[8],
+      species: b[9],
+      level: b[10],
+      friendship: b[11],
+      evolutionSerial: b[12],
+      usedItem: b[13],
+      stats: v(c, 0),
+      moves: q(c, 3),
+      moveSerial: c[7],
+      timingPhase: c[8],
+      clock: c[9],
+      inputCount: c[10],
+      inputNext: c[11],
+      hits: c[12],
+      quality: c[13],
+      actionMultiplier: c[14],
+      window: c[15],
+      times: q(d, 0),
+      buttons: q(d, 4),
+      activePartner: d[8],
+      swapSerial: d[9],
+      passiveBudget: d[10],
+      spent: d[11],
+      modifiers: v(d, 12),
+      bonus: d[15],
+      openingPhase: e[0],
+      openingSide: e[1],
+      openingAttack: e[2],
+      openingSerial: e[3],
+      escapeAttempts: e[4],
+      escapeResult: e[5],
+      escapeChance: e[6],
+      escapeRoll: e[7],
+      order: f.slice(0, 8),
+      queued: f.slice(8).map(Boolean),
+      partnerHealth: g.slice(0, 8),
+      partnerMaximum: g.slice(8),
+      passiveCounts: h.slice(0, 8),
+      passiveIds: h.slice(8),
+      statusIds: i.slice(0, 4),
+      statusTurns: i.slice(4, 8),
+      statusAmounts: i.slice(8, 12),
+      statusPhases: i.slice(12),
+      typeMatrix: j
+    };
+  }
+  attachRpg(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = RPG_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = rpgData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_rpg?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachRpg(slot) {
+    const ok = this.exports.zylem_stage_detach_rpg?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  rpgAction(slot, action) {
+    const encoded = rpgOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    assertRuntimeBehavior(this.compatibility, RPG_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_rpg_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryRpg(slot) {
+    const pages = [];
+    for (let n = 0; n < 14; n++) {
+      if (this.exports.zylem_stage_query_rpg?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      pages.push(Array.from(this.queryView));
+    }
+    const [a, b, c, d] = pages;
+    const v = (p, i) => [
+      p[i],
+      p[i + 1],
+      p[i + 2]
+    ];
+    const affixes = (p) => Array.from({ length: 4 }, (_, i) => ({
+      id: p[i * 4],
+      stat: p[i * 4 + 1],
+      amount: p[i * 4 + 2],
+      cost: p[i * 4 + 3]
+    })).filter((f) => f.id > 0);
+    return {
+      abilities: RPG_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      base: v(a, 3),
+      derived: v(a, 6),
+      health: a[9],
+      mana: a[10],
+      currency: a[11],
+      repairCost: a[12],
+      beltSerial: a[13],
+      healthGained: a[14],
+      manaGained: a[15],
+      affixSerial: b[0],
+      affixCount: b[1],
+      affixSpent: b[2],
+      affixSeed: b[3],
+      lootSerial: b[4],
+      lootType: b[5],
+      lootRarity: b[6],
+      lootSeed: b[7],
+      dropPhase: b[8],
+      deathSerial: b[9],
+      dropType: b[10],
+      dropRarity: b[11],
+      reservation: b[12],
+      dropAffixCount: b[13],
+      leechSerial: b[14],
+      damageSerial: c[0],
+      damage: c[1],
+      damageType: c[2],
+      damageFlags: c[3],
+      reaction: c[4],
+      familiarPhase: c[5],
+      destination: v(c, 6),
+      actionSerial: c[9],
+      cooldown: c[10],
+      form: c[11],
+      formPhase: c[12],
+      formRadius: c[13],
+      formSpeed: c[14],
+      formSerial: c[15],
+      equipmentSlots: d.slice(0, 4),
+      beltSlots: d.slice(4, 8),
+      resistances: d.slice(8, 12),
+      immunities: d.slice(12, 16).map(Boolean),
+      items: pages.slice(4, 12).map((i) => ({
+        owned: !!i[0],
+        equipment: !!i[1],
+        slotMask: i[2],
+        requiredStrength: i[3],
+        flat: v(i, 4),
+        percent: v(i, 7),
+        durability: i[10],
+        maximumDurability: i[11],
+        count: i[12],
+        kind: i[13],
+        potency: i[14],
+        lastWear: i[15]
+      })),
+      affixes: affixes(pages[12]),
+      dropAffixes: affixes(pages[13])
+    };
+  }
+  attachSports(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = SPORTS_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = sportsData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_sports?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachSports(slot) {
+    const ok = this.exports.zylem_stage_detach_sports?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  sportsAction(slot, action) {
+    const encoded = sportsOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    assertRuntimeBehavior(this.compatibility, SPORTS_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_sports_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  querySports(slot) {
+    const page = (n) => {
+      if (this.exports.zylem_stage_query_sports?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      return Array.from(this.queryView);
+    };
+    const a = page(0), b = page(1), c = page(2), d = page(3);
+    if (!a || !b || !c || !d) return null;
+    const v = (p, i) => [
+      p[i],
+      p[i + 1],
+      p[i + 2]
+    ];
+    return {
+      abilities: SPORTS_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      swingPhase: a[3],
+      swingTime: a[4],
+      power: a[5],
+      directionError: a[6],
+      swingSerial: a[7],
+      shotSerial: a[8],
+      shotVelocity: v(a, 9),
+      shotSpin: v(a, 12),
+      flightPhase: a[15],
+      destination: v(b, 0),
+      velocity: v(b, 3),
+      spin: v(b, 6),
+      collisionSerial: b[9],
+      impactSerial: b[10],
+      impactVelocity: v(b, 11),
+      puttPhase: b[14],
+      bounceEpoch: b[15],
+      racketPhase: c[0],
+      racketTime: c[1],
+      contactQuality: c[2],
+      contactSerial: c[3],
+      contactAge: c[4],
+      placementTime: c[5],
+      placement: v(c, 6),
+      servePhase: c[9],
+      attempt: c[10],
+      server: c[11],
+      netTouched: !!c[12],
+      lets: c[13],
+      rallyPhase: c[14],
+      lastHitter: c[15],
+      bounceCount: d[0],
+      crossedNet: !!d[1],
+      winner: d[2],
+      pointSerial: d[3],
+      pointReason: d[4],
+      supported: !!d[5],
+      wind: v(d, 6),
+      consumedShot: d[9],
+      consumedSwing: d[10],
+      consumedContact: d[11],
+      adjudicatedContact: d[12],
+      adjudicatedBounce: d[13]
+    };
+  }
+  attachSkate(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = SKATE_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = skateData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_skate?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachSkate(slot) {
+    const ok = this.exports.zylem_stage_detach_skate?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  skateAction(slot, action) {
+    const encoded = skateOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    assertRuntimeBehavior(this.compatibility, SKATE_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_skate_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  querySkate(slot) {
+    const page = (n) => {
+      if (this.exports.zylem_stage_query_skate?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      return Array.from(this.queryView);
+    };
+    const a = page(0), b = page(1), c = page(2);
+    if (!a || !b || !c) return null;
+    const phases = [
+      "idle",
+      "active",
+      "ended",
+      "bailed",
+      "blocked"
+    ];
+    return {
+      abilities: SKATE_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      railPhase: phases[a[3]],
+      railCoordinate: a[4],
+      balance: a[5],
+      balanceTime: a[6],
+      wallPhase: phases[a[7]],
+      wallRemaining: a[8],
+      manualPhase: phases[a[9]],
+      destination: [a[10], a[11], a[12]],
+      velocity: [a[13], a[14], a[15]],
+      launchSerial: b[0],
+      launchVelocity: [b[1], b[2], b[3]],
+      flight: b[4],
+      comboOpen: !!b[5],
+      landing: ["none", "landed", "bailed"][b[6]],
+      resolvedFlight: b[7],
+      pendingBase: b[8],
+      trickCount: b[9],
+      totalScore: b[10],
+      lastBank: b[11],
+      bankSerial: b[12],
+      repeatFactor: b[13],
+      repeatCount: b[14],
+      historySize: b[15],
+      grab: c[0],
+      grabHeld: !!c[1],
+      grabTime: c[2],
+      releaseAge: c[3],
+      grabValid: !!c[4],
+      windup: c[5],
+      spinRate: c[6],
+      spinAngle: c[7],
+      energy: c[8],
+      boosting: !!c[9],
+      boostFraction: c[10],
+      touchdownCaptured: !!c[11],
+      wallNormal: [c[12], c[13], c[14]],
+      lipRemaining: c[15]
+    };
+  }
+  attachRacing(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = RACING_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = racingData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_racing?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachRacing(slot) {
+    const ok = this.exports.zylem_stage_detach_racing?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  racingAction(slot, action) {
+    const encoded = racingOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = Math.floor(op / 4);
+    assertRuntimeBehavior(this.compatibility, RACING_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_racing_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryRacing(slot) {
+    const page = (n) => {
+      if (this.exports.zylem_stage_query_racing?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      return Array.from(this.queryView);
+    };
+    const a = page(0), b = page(1), c = page(2);
+    if (!a || !b || !c) return null;
+    return {
+      abilities: RACING_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      lastRequest: a[1],
+      revision: a[2],
+      driftCharge: a[3],
+      driftTier: a[4],
+      driftBoost: a[5],
+      draftDwell: a[6],
+      draftBoost: a[7],
+      item: a[8],
+      itemRank: a[9],
+      routeIndex: a[10],
+      homing: ["idle", "following", "hit", "arrived", "cancelled"][a[11]],
+      destination: [a[12], a[13], a[14]],
+      randomState: a[15],
+      nextCheckpoint: b[0],
+      lap: b[1],
+      laps: b[2],
+      racing: !!b[3],
+      supportProbes: b[4],
+      hoverAcceleration: [b[5], b[6], b[7]],
+      trackUp: [b[8], b[9], b[10]],
+      energy: b[11],
+      boostFraction: b[12],
+      attackRemaining: b[13],
+      attackCooldown: b[14],
+      attackHits: b[15],
+      integrity: c[0],
+      damage: ["healthy", "smoke", "fire", "destroyed"][c[1]],
+      burnElapsed: c[2],
+      handlingMultiplier: c[3],
+      seatPhase: ["free", "entering", "occupied", "exiting"][c[4]],
+      seat: c[5],
+      seatDestination: [c[6], c[7], c[8]],
+      seatRemaining: c[9],
+      weightCount: c[10],
+      routePoints: c[11],
+      checkpointCount: c[12],
+      drifting: !!c[13],
+      boosting: !!c[14],
+      attackDirection: c[15]
+    };
+  }
+  attachSurvival(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = SURVIVAL_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = survivalData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_survival?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachSurvival(slot) {
+    const ok = this.exports.zylem_stage_detach_survival?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  survivalAction(slot, action) {
+    const encoded = survivalOperation(action);
+    if (!encoded) return false;
+    const { op, data } = encoded;
+    const index = op <= 2 ? 0 : op <= 4 ? 1 : op <= 6 ? 2 : op <= 8 ? 3 : op <= 10 ? 4 : op <= 13 ? 5 : op <= 16 ? 6 : op <= 19 ? 7 : op <= 23 ? 8 : 9;
+    assertRuntimeBehavior(this.compatibility, SURVIVAL_ABILITIES[index]);
+    const target = "target" in action ? action.target : 4294967295;
+    if (!Number.isInteger(action.requestId) || action.requestId < 1 || action.requestId > 16777215 || !Number.isInteger(target) || target < 0 || target > 4294967295 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_survival_action?.(
+      slot,
+      target,
+      op,
+      action.requestId
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  querySurvival(slot) {
+    const page = (n) => {
+      if (this.exports.zylem_stage_query_survival?.(slot, n) !== 1)
+        return null;
+      this.refreshEnvironmentViews();
+      return Array.from(this.queryView);
+    };
+    const a = page(0), b = page(1);
+    if (!a || !b) return null;
+    const item = (v) => ({
+      id: v[0],
+      kind: v[1],
+      quantity: v[2],
+      limit: v[3],
+      shape: v[4],
+      x: v[5],
+      y: v[6],
+      rotated: !!v[7]
+    });
+    const items = [];
+    for (let i = 0; i < b[0]; i++) {
+      const v = page(2 + i);
+      if (!v) return null;
+      items.push(item(v));
+    }
+    let checkpoint = null;
+    if (b[7]) {
+      const v = page(34);
+      if (!v) return null;
+      const saved = [];
+      for (let i = 0; i < v[8]; i++) {
+        const q = page(35 + i);
+        if (!q) return null;
+        saved.push(item(q));
+      }
+      checkpoint = {
+        version: 1,
+        checkpoint: v[1],
+        requestId: v[2],
+        revision: v[3],
+        currency: v[4],
+        upgradeLevel: v[5],
+        weaponValue: v[6],
+        pressure: v[7],
+        items: saved
+      };
+    }
+    return {
+      abilities: SURVIVAL_ABILITIES.filter(
+        (_, i) => !!(a[0] & 1 << i)
+      ),
+      lastRequest: a[1],
+      revision: a[2],
+      escortMode: ["wait", "follow", "safe"][a[3]],
+      intent: ["hold", "move", "transport", "vault"][a[4]],
+      destination: [a[5], a[6], a[7]],
+      capture: ["free", "captured", "failed"][a[8]],
+      vault: ["idle", "active", "completed", "cancelled"][a[9]],
+      finisherRemaining: a[10],
+      staggerClass: a[11],
+      finisherConsumed: !!a[12],
+      pressure: a[13],
+      nextPressure: a[14],
+      sampleCount: a[15],
+      items,
+      currency: b[1],
+      upgradeLevel: b[2],
+      weaponValue: b[3],
+      spawnObligations: b[4],
+      unresolvedEnemies: b[5],
+      locked: !!b[6],
+      savePending: !!b[7],
+      lastCheckpoint: b[8],
+      gateCount: b[9],
+      vaultElapsed: b[10],
+      vaultDuration: b[11],
+      recipeCount: b[12],
+      columns: b[13],
+      rows: b[14],
+      saveAllowed: !!b[15],
+      checkpoint
+    };
+  }
+  attachCity(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = CITY_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = cityData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_city?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachCity(slot) {
+    const ok = this.exports.zylem_stage_detach_city?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  cityData(data) {
+    if (data.length > 8 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    return true;
+  }
+  cityLink(slot, other, kind, data) {
+    if (!Number.isInteger(kind) || kind < 0 || kind > 4 || !this.cityData(data))
+      return false;
+    const ok = this.exports.zylem_stage_city_link?.(slot, other, kind) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  cityUnlink(slot, other, kind) {
+    if (!Number.isInteger(kind) || kind < 0 || kind > 4) return false;
+    const ok = this.exports.zylem_stage_city_unlink?.(slot, other, kind) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  cityCommand(slot, kind, data) {
+    if (!Number.isInteger(kind) || kind < 0 || kind > 6 || !this.cityData(data))
+      return false;
+    const ok = this.exports.zylem_stage_city_command?.(slot, kind) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  citySignal(slot, source, kind, sequence, data) {
+    if (!Number.isInteger(kind) || kind < 0 || kind > 4 || !Number.isInteger(sequence) || sequence < 1 || sequence > 16777215 || !this.cityData(data))
+      return false;
+    const ok = this.exports.zylem_stage_city_signal?.(
+      slot,
+      source,
+      kind,
+      sequence
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryCity(slot) {
+    if (this.exports.zylem_stage_query_city?.(slot, 0) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const a = Array.from(this.queryView);
+    if (this.exports.zylem_stage_query_city?.(slot, 1) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const b = this.queryView;
+    return {
+      abilities: CITY_ABILITIES.filter((_, i) => !!(a[0] & 1 << i)),
+      suspicion: a[1],
+      visible: !!a[2],
+      intent: CITY_INTENTS[a[3]],
+      destination: [a[4], a[5], a[6]],
+      disguiseModifier: a[7],
+      searchRemaining: a[8],
+      noiseRemaining: a[9],
+      trailCount: a[10],
+      alert: !!a[11],
+      reportRemaining: a[12],
+      wantedLevel: a[13],
+      pursuitScore: a[14],
+      targetSlot: a[15] < 0 ? null : a[15],
+      responseMask: b[0],
+      unseenFor: b[1],
+      panicRemaining: b[2],
+      reserved: !!b[3],
+      desiredSpeed: b[4],
+      trafficReason: ["clear", "no-request", "red", "blocked", "conflict"][b[5]],
+      trailSequence: b[6],
+      reportsSent: b[7],
+      lastEvent: CITY_EVENTS[b[8]],
+      lastSeen: [b[9], b[10], b[11]],
+      searchIndex: b[12],
+      noiseCategory: ["footstep", "impact", "gunshot"][b[13]],
+      receiptCount: b[14],
+      linkCount: b[15]
+    };
+  }
+  attachEncounters(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const i = ENCOUNTER_ABILITIES.indexOf(ability);
+      if (i < 0) return false;
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << i;
+    }
+    const data = encounterData(options);
+    if (!mask || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_encounters?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachEncounters(slot) {
+    const ok = this.exports.zylem_stage_detach_encounters?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  encounterLink(slot, other, kind, data) {
+    if (!Number.isInteger(kind) || kind < 0 || kind > 5 || data.length > 8 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_encounter_link?.(slot, other, kind) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  encounterUnlink(slot, other, kind) {
+    if (!Number.isInteger(kind) || kind < 0 || kind > 5) return false;
+    const ok = this.exports.zylem_stage_encounter_unlink?.(slot, other, kind) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  encounterCommand(slot, kind, value, data = []) {
+    if (!Number.isInteger(kind) || kind < 0 || kind > 3 || !Number.isInteger(value) || value < 0 || value > 1e4 || data.length > 8 || data.some((x) => !Number.isFinite(x)))
+      return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_encounter_command?.(slot, kind, value) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  encounterHit(slot, source, region, hit) {
+    if (!Number.isFinite(hit.damage) || !Number.isInteger(hit.team) || hit.team < 0 || hit.team > 1e4 || !Number.isInteger(hit.sequence) || hit.sequence < 1 || hit.sequence > 4294967295)
+      return false;
+    const ok = this.exports.zylem_stage_encounter_hit?.(
+      slot,
+      source,
+      region ?? -1,
+      hit.damage,
+      hit.team,
+      hit.sequence,
+      hit.impact ? 1 : 0
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryEncounters(slot) {
+    if (this.exports.zylem_stage_query_encounters?.(slot, 0) !== 1)
+      return null;
+    this.refreshEnvironmentViews();
+    const a = Array.from(this.queryView);
+    if (this.exports.zylem_stage_query_encounters?.(slot, 1) !== 1)
+      return null;
+    this.refreshEnvironmentViews();
+    const b = this.queryView;
+    return {
+      abilities: ENCOUNTER_ABILITIES.filter(
+        (_, i) => !!(a[0] & 1 << i)
+      ),
+      health: a[1],
+      morale: a[2],
+      intent: ENCOUNTER_INTENTS[a[3]],
+      destination: [a[4], a[5], a[6]],
+      targetSlot: a[7] < 0 ? null : a[7],
+      flankSlot: a[8] < 0 ? null : a[8],
+      coverPhase: ["concealed", "observing", "attacking"][a[9]],
+      activation: ["dormant", "activating", "active"][a[10]],
+      bossPhase: a[11],
+      attackMask: a[12],
+      vulnerability: a[13],
+      shotSequence: a[14],
+      terminal: ["live", "intercepted", "impact"][a[15]],
+      burstRemaining: b[0],
+      shotBudget: b[1],
+      activationRemaining: b[2],
+      staggerRemaining: b[3],
+      lastDamage: b[4],
+      lastEvent: ENCOUNTER_EVENTS[b[5]],
+      retiredAttackMask: b[6],
+      attackEpoch: b[7],
+      leaderLost: !!b[8],
+      coverElapsed: b[9],
+      targetScore: b[10]
+    };
+  }
+  attachWeapons(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const a of abilities) {
+      const index = WEAPON_ABILITIES.indexOf(a);
+      if (index < 0) return false;
+      assertRuntimeBehavior(this.compatibility, a);
+      mask |= 1 << index;
+    }
+    const data = weaponData(options), secondary = options.secondaryAmmo ?? 5;
+    if (data.some((x) => !Number.isFinite(x)) || !Number.isInteger(secondary) || secondary < 0 || secondary > 1e4) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_weapons?.(slot, mask, secondary) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachWeapons(slot) {
+    const ok = this.exports.zylem_stage_detach_weapons?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  weaponInput(slot, input) {
+    const ok = this.exports.zylem_stage_weapon_input?.(slot, input.moveX ?? 0, input.moveZ ?? 0, input.turnYaw ?? 0, input.turnPitch ?? 0, weaponButtons(input)) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  weaponMode(slot, index, mode) {
+    if (index !== 0 && index !== 1) return false;
+    const data = weaponModeData(mode);
+    if (data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_weapon_mode?.(slot, index) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  weaponDamage(slot, amount, source) {
+    const ok = this.exports.zylem_stage_weapon_damage?.(slot, source ?? -1, amount) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  weaponSurface(slot, surface) {
+    const ok = this.exports.zylem_stage_weapon_surface?.(slot, (surface.penetrable ? 1 : 0) | (surface.sticky ? 2 : 0), surface.resistance ?? 1) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  launchWeaponProjectile(owner, slot, kind, options = {}) {
+    if (kind !== "sticky" && kind !== "guided") return false;
+    assertRuntimeBehavior(this.compatibility, kind === "sticky" ? "sticky-grenade-attachment" : "remote-guided-projectile");
+    const data = weaponProjectileData(options);
+    if (data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_launch_weapon_projectile?.(owner, slot, kind === "sticky" ? 0 : 1) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryWeapons(slot) {
+    if (this.exports.zylem_stage_query_weapons?.(slot, 0) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const a = Array.from(this.queryView);
+    if (this.exports.zylem_stage_query_weapons?.(slot, 1) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const b = this.queryView;
+    return {
+      abilities: WEAPON_ABILITIES.filter((_, i) => (a[0] & 1 << i) !== 0),
+      phase: WEAPON_PHASES[a[1]],
+      health: a[2],
+      shield: a[3],
+      heat: a[4],
+      magazine: a[5],
+      reserve: a[6],
+      secondaryAmmo: a[7],
+      mode: a[8],
+      charge: a[9],
+      cooldown: a[10],
+      reloadTime: a[11] < 0 ? null : a[11],
+      reloadCommitted: a[12] === 1,
+      yaw: a[13],
+      pitch: a[14],
+      lastEvent: WEAPON_EVENTS[a[15]],
+      shot: { sequence: b[0], kind: ["normal", "charged", "combo"][b[1]], damage: b[2], from: [b[3], b[4], b[5]], to: [b[6], b[7], b[8]], intersections: b[9] },
+      aiming: b[10] === 1,
+      guidedSlot: b[11] < 0 ? null : b[11],
+      overheated: b[12] === 1,
+      ventTime: b[13],
+      switchTime: b[14],
+      timeSinceDamage: b[15]
+    };
+  }
+  queryWeaponProjectile(slot) {
+    if (this.exports.zylem_stage_query_weapon_projectile?.(slot) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const v = this.queryView;
+    return { kind: v[0] === 0 ? "sticky" : "guided", phase: ["flying", "attached", "detonated", "cancelled"][v[1]], remaining: v[2], position: [v[3], v[4], v[5]], yaw: v[6], pitch: v[7], ownerSlot: v[8] < 0 ? null : v[8], hostSlot: v[9] < 0 ? null : v[9], radius: v[10] };
+  }
+  weaponCameraIntent(slot) {
+    const s = this.queryWeapons(slot);
+    if (!s) return null;
+    const q = s.guidedSlot === null ? null : this.queryWeaponProjectile(s.guidedSlot);
+    return q ? { mode: "projectile", slot: s.guidedSlot, yaw: q.yaw, pitch: q.pitch } : { mode: s.aiming ? "precision" : "actor", slot, yaw: s.yaw, pitch: s.pitch };
+  }
+  attachCombat(slot, abilities, options = {}) {
+    let mask = 0;
+    for (const a of abilities) {
+      const index = COMBAT_ABILITIES.indexOf(a);
+      if (index < 0) return false;
+      assertRuntimeBehavior(this.compatibility, a);
+      mask |= 1 << index;
+    }
+    const data = combatData(options);
+    if (data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_combat?.(slot, mask) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachCombat(slot) {
+    const ok = this.exports.zylem_stage_detach_combat?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  combatInput(slot, input) {
+    const ok = this.exports.zylem_stage_combat_input?.(slot, input.moveX ?? 0, input.moveY ?? 0, combatButtons(input)) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  combatAttack(slot, index, attack) {
+    if (!Number.isInteger(index) || index < 0 || index >= 8) return false;
+    const data = combatAttackData(attack);
+    if (data.length !== 16 || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_combat_attack?.(slot, index) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  combatHit(slot, hit, source) {
+    const data = combatHitData(hit);
+    if (data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.fill(0);
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_combat_hit?.(slot, source ?? -1) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryCombat(slot) {
+    if (this.exports.zylem_stage_query_combat?.(slot) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const v = this.queryView;
+    return { abilities: COMBAT_ABILITIES.filter((_, i) => (v[0] & 1 << i) !== 0), phase: COMBAT_PHASES[v[1]], attackIndex: v[2] < 0 ? null : v[2], actionTime: v[3], damage: v[4], shield: v[5], hitstop: v[6], hitstun: v[7], dodge: v[8], recovery: v[9], partnerSlot: v[10] < 0 ? null : v[10], confirmedHits: v[11], lastEvent: COMBAT_EVENTS[v[12]], launch: [v[13], v[14], 0], grounded: (v[15] & 1) !== 0, facing: (v[15] & 2) !== 0 ? -1 : 1 };
+  }
+  attachPuzzle(slot, ability, options = {}) {
+    const index = PUZZLE_ABILITIES.indexOf(ability);
+    if (index < 0) return false;
+    assertRuntimeBehavior(this.compatibility, ability);
+    const data = puzzleData(ability, options);
+    if (data.length !== 16 || data.some((x) => !Number.isFinite(x))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_attach_puzzle?.(slot, index + 1) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachPuzzle(slot) {
+    const ok = this.exports.zylem_stage_detach_puzzle?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryPuzzle(slot) {
+    if (this.exports.zylem_stage_query_puzzle?.(slot) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const v = this.queryView;
+    return { ability: PUZZLE_ABILITIES[v[0] - 1], active: v[1] === 1, value: v[2], remaining: v[3], blocked: v[4] === 1, transitions: v[5], auxiliary: v[6], storedImpulse: [v[7], v[8], v[9]], target: [v[10], v[11], v[12]], segmentCount: v[13] };
+  }
+  puzzleCommand(slot, command) {
+    const data = puzzleCommandData(command);
+    if (!data || data.length !== 4 || data.some((x) => !Number.isFinite(x))) return false;
+    const ok = this.exports.zylem_stage_puzzle_command?.(slot, ...data) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  puzzleLink(slot, other) {
+    const ok = this.exports.zylem_stage_puzzle_link?.(slot, other ?? -1) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  puzzleSegments(slot) {
+    const n = this.queryPuzzle(slot)?.segmentCount ?? 0, result = [];
+    for (let i = 0; i < Math.min(n, 16); i++) {
+      if (this.exports.zylem_stage_puzzle_segment?.(slot, i) !== 1) break;
+      this.refreshEnvironmentViews();
+      const v = this.queryView;
+      result.push({ from: [v[0], v[1], v[2]], to: [v[3], v[4], v[5]] });
+    }
+    return result;
+  }
+  attachAdventure(slot, abilities, o = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const index = ADVENTURE_ABILITIES.indexOf(ability);
+      if (index < 0) throw new Error(`Unknown adventure ability: ${ability}`);
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << index;
+    }
+    const ok = this.exports.zylem_stage_attach_adventure?.(slot, mask, o.speed ?? 6, o.gravity ?? 9.81, o.range ?? 12, o.scanDuration ?? 1, o.maxCarryMass ?? 10) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  detachAdventure(slot) {
+    const ok = this.exports.zylem_stage_detach_adventure?.(slot) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryAdventure(slot) {
+    if (this.exports.zylem_stage_query_adventure?.(slot) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const v = this.queryView;
+    return { mode: v[0], targetSlot: v[1] < 0 ? null : v[1], ball: v[2] === 1, scanProgress: v[3], discoveries: v[4], hits: v[5], unlocks: v[6], heldSlot: v[7] < 0 ? null : v[7], projectile: [v[8], v[9], v[10]], projectilePhase: v[11], ropeLength: v[12], blocked: v[13] === 1, detonations: v[14], hookPhase: v[15] };
+  }
+  writeAdventureInput(slot, input) {
+    this.refreshEnvironmentViews();
+    const base = slot * 8;
+    if (base + 8 > this.inputView.length) return;
+    const buttons = ADVENTURE_BUTTONS.reduce((m, key, i) => m | (input[key] ? 1 << i : 0), 0);
+    this.inputView.set([input.moveX ?? 0, input.moveY ?? 0, input.moveZ ?? 0, input.yaw ?? 0, buttons, input.pitch ?? 0, 0, 1], base);
+  }
+  setAdventureObject(slot, object) {
+    if (!this.exports.zylem_stage_set_adventure_object) return false;
+    let flags = 0;
+    for (const role of object?.roles ?? []) {
+      if (!Object.hasOwn(ADVENTURE_FLAGS, role)) return false;
+      flags |= ADVENTURE_FLAGS[role];
+    }
+    const data = [object?.key ?? 0, object?.consumeToken === false ? 0 : 1, object?.fuse ?? 2, object?.blastRadius ?? 3, ...object?.trackEnd ?? [1, 0, 0], ...object?.trackNormal ?? [0, 1, 0], 0, 0, 0, 0, 0, 0];
+    if (data.length !== 16 || data.some((v) => !Number.isFinite(v))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const ok = this.exports.zylem_stage_set_adventure_object(slot, flags) === 1;
+    this.refreshEnvironmentViews();
+    return ok;
+  }
+  queryAdventureObject(slot) {
+    if (this.exports.zylem_stage_query_adventure_object?.(slot) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const v = this.queryView;
+    return { flags: v[0], key: v[1], opened: v[2] === 1, armed: v[3] === 1, fuse: v[4], detonated: v[5] === 1, ownerSlot: v[6] < 0 ? null : v[6], hits: v[7] };
+  }
+  adventureProgress(slot, kind, key, value = 0) {
+    if (!Number.isInteger(key) || key <= 0 || key > 16777215 || !Number.isInteger(value) || value < 0 || value > 1e6) return 0;
+    const result = this.exports.zylem_stage_adventure_progress?.(slot, kind, key, value) ?? 0;
+    this.refreshEnvironmentViews();
+    return result;
+  }
+  refreshEnvironmentViews() {
+    if (this.queryView.buffer !== this.memory.buffer) this.refreshViews();
+  }
+  attachEnvironment(slot, abilities, o = {}) {
+    let mask = 0;
+    for (const ability of abilities) {
+      const index = ENVIRONMENT_ABILITIES.indexOf(ability);
+      if (index < 0) throw new Error(`Unknown environmental ability: ${ability}`);
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << index;
+    }
+    const attached = this.exports.zylem_stage_attach_environment?.(
+      slot,
+      mask,
+      o.gravity ?? 9.81,
+      o.speed ?? 6,
+      o.drag ?? 1.5,
+      o.buoyancy ?? 1.6,
+      o.turnRate ?? Math.PI,
+      o.breathCapacity ?? 8,
+      o.staminaCapacity ?? 5
+    ) === 1;
+    this.refreshEnvironmentViews();
+    return attached;
+  }
+  detachEnvironment(slot) {
+    return this.exports.zylem_stage_detach_environment?.(slot) === 1;
+  }
+  queryEnvironment(slot) {
+    if (this.exports.zylem_stage_query_environment?.(slot) !== 1) return null;
+    this.refreshEnvironmentViews();
+    const v = this.queryView;
+    return {
+      mode: v[0],
+      submerged: v[1],
+      breath: v[2],
+      stamina: v[3],
+      strokes: v[4],
+      breaches: v[5],
+      damage: v[6],
+      railDistance: v[7],
+      railAngle: v[8],
+      up: [v[9], v[10], v[11]],
+      velocity: [v[12], v[13], v[14]],
+      blocked: v[15] > 0.5
+    };
+  }
+  writeEnvironmentInput(slot, input) {
+    this.refreshEnvironmentViews();
+    this.writeInputAxes(slot, input.moveX ?? 0, input.moveY ?? 0);
+    this.writeInputLook(slot, input.moveZ ?? 0, input.sailTrim ?? 0);
+    [input.stroke, input.breach, input.glide, input.sail, input.ride, input.release].forEach((value, i) => this.writeInputButton(slot, 1 << i, !!value));
+  }
+  setEnvironmentVolume(slot, volume) {
+    if (!this.exports.zylem_stage_set_environment_volume) return false;
+    if (!volume) return this.exports.zylem_stage_set_environment_volume(slot, 0) === 1;
+    const kinds = ["directional-gravity", "point-gravity", "segment-gravity", "water", "wind", "updraft"];
+    const kind = kinds.indexOf(volume.kind) + 1;
+    if (!kind) return false;
+    const vector = volume.kind === "directional-gravity" ? volume.direction : volume.kind === "point-gravity" ? volume.point : volume.kind === "segment-gravity" ? volume.start : volume.kind === "water" ? volume.current ?? [0, 0, 0] : volume.velocity;
+    const end = volume.kind === "segment-gravity" ? volume.end : volume.kind === "water" ? [volume.falloff ?? 0, 0, 0] : [0, 0, 0];
+    const data = [
+      ...volume.min,
+      ...volume.max,
+      ...vector,
+      ...end,
+      volume.kind === "water" ? volume.density ?? 1 : volume.strength ?? (kind <= 3 ? 9.81 : 1),
+      volume.priority ?? 0,
+      volume.kind === "water" ? volume.waveAmplitude ?? 0 : 0,
+      volume.kind === "water" ? volume.waveFrequency ?? 0 : 0
+    ];
+    if (data.length !== 16 || data.some((n) => !Number.isFinite(n))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const accepted = this.exports.zylem_stage_set_environment_volume(slot, kind) === 1;
+    this.refreshEnvironmentViews();
+    return accepted;
+  }
+  setTubeRail(slot, rail) {
+    if (!this.exports.zylem_stage_set_tube_rail) return false;
+    if (!rail) return this.exports.zylem_stage_set_tube_rail(slot, 0) === 1;
+    assertRuntimeBehavior(this.compatibility, "tube-slide-steering");
+    const data = [...rail.points.flat(), rail.radius, ...rail.up ?? [0, 1, 0]];
+    if (data.length !== 16 || data.some((n) => !Number.isFinite(n))) return false;
+    this.refreshEnvironmentViews();
+    this.queryView.set(data);
+    const accepted = this.exports.zylem_stage_set_tube_rail(slot, 1) === 1;
+    this.refreshEnvironmentViews();
+    return accepted;
+  }
+  attachAcrobatics(slot, abilities, opts = {}) {
+    const names = TRAVERSAL_ABILITIES;
+    let mask = 0;
+    for (const ability of abilities) {
+      if (!names.includes(ability)) throw new Error(`Unknown acrobatics ability: ${ability}`);
+      assertRuntimeBehavior(this.compatibility, ability);
+      mask |= 1 << names.indexOf(ability);
+    }
+    return this.exports.zylem_stage_attach_acrobatics?.(
+      slot,
+      mask,
+      opts.moveSpeed ?? 6,
+      opts.jumpSpeed ?? 10,
+      opts.gravity ?? 24,
+      opts.chainWindow ?? 0.25
+    ) === 1;
+  }
+  queryAcrobatics(slot) {
+    const query = this.exports.zylem_stage_query_traversal ?? this.exports.zylem_stage_query_acrobatics;
+    if (query?.(slot) !== 1) return null;
+    const extended = !!this.exports.zylem_stage_query_traversal;
+    const v = this.queryView;
+    return {
+      grounded: v[0] > 0.5,
+      action: v[1],
+      chain: v[2],
+      remaining: v[3],
+      facing: v[4],
+      launches: v[5],
+      velocity: [v[6], v[7]],
+      impacts: extended ? v[8] : 0,
+      phaseRemaining: extended ? v[9] : 0,
+      poleAngle: extended ? v[10] : 0,
+      wallWindow: extended ? v[11] : 0,
+      reattachLockout: extended ? v[12] : 0,
+      velocityZ: extended ? v[13] : 0,
+      impactThisStep: extended && v[14] > 0.5,
+      impactSpeed: extended ? v[15] : 0
+    };
+  }
+  detachAcrobatics(slot) {
+    return this.exports.zylem_stage_detach_acrobatics?.(slot) === 1;
+  }
+  setTraversalSurface(slot, kind) {
+    if (kind) assertRuntimeBehavior(this.compatibility, kind === "pole" ? "pole-climb" : "ceiling-hang-traverse");
+    return this.exports.zylem_stage_set_traversal_surface?.(slot, kind === "pole" ? 1 : kind === "ceiling" ? 2 : 0) === 1;
+  }
+  setPossessable(slot, enabled) {
+    assertRuntimeBehavior(this.compatibility, "temporary-actor-possession");
+    return this.exports.zylem_stage_set_possessable?.(slot, Number(enabled)) === 1;
+  }
+  startPossession(owner, target, seconds = 5) {
+    assertRuntimeBehavior(this.compatibility, "temporary-actor-possession");
+    return this.exports.zylem_stage_start_possession?.(owner, target, seconds) === 1;
+  }
+  endPossession(owner) {
+    return this.exports.zylem_stage_end_possession?.(owner) === 1;
+  }
+  queryPossession(owner) {
+    if (this.exports.zylem_stage_query_possession?.(owner) !== 1) return null;
+    return { targetSlot: this.queryView[0], remaining: this.queryView[1] };
+  }
+  attachTopDown(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "top-down-movement");
+    return this.exports.zylem_stage_attach_top_down(slot, opts.plane, opts.speed, opts.faceMovement ? 1 : 0) !== 0;
+  }
+  setTopDownInput(slot, axisA, axisB) {
+    this.exports.zylem_stage_set_top_down_input(slot, axisA, axisB);
+  }
+  attachJumper2D(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "jumper-2d");
+    return this.exports.zylem_stage_attach_jumper_2d(
+      slot,
+      opts.jumpForce,
+      opts.maxJumps >>> 0,
+      opts.jumpBufferTime,
+      opts.coyoteTime,
+      opts.gravity
+    ) !== 0;
+  }
+  setJumper2DInput(slot, jumpPressed) {
+    this.exports.zylem_stage_set_jumper_2d_input(slot, jumpPressed ? 1 : 0);
+  }
+  queryJumper2D(slot) {
+    if (this.exports.zylem_stage_query_jumper_2d(slot) === 0) return null;
+    const v = this.queryView;
+    return {
+      grounded: v[0] > 0.5,
+      jumpCount: v[1] | 0,
+      coyote: v[2],
+      jumpBuffer: v[3]
+    };
+  }
+  attachJumper3D(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "jumper-3d");
+    return this.exports.zylem_stage_attach_jumper_3d(
+      slot,
+      opts.jumpForce,
+      opts.maxJumps >>> 0,
+      opts.gravity,
+      opts.coyoteTime ?? 0.1,
+      opts.jumpBufferTime ?? 0.08
+    ) !== 0;
+  }
+  setJumper3DInput(slot, jump) {
+    this.exports.zylem_stage_set_jumper_3d_input(slot, jump ? 1 : 0);
+  }
+  queryJumper3D(slot) {
+    if (this.exports.zylem_stage_query_jumper_3d(slot) === 0) return null;
+    const v = this.queryView;
+    return { grounded: v[0] > 0.5, jumpCount: v[1] | 0, verticalVelocity: v[2] };
+  }
+  attachShooter2D(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "shooter-2d");
+    return this.exports.zylem_stage_attach_shooter_2d(
+      slot,
+      opts.fireRateHz,
+      opts.muzzleOffsetX,
+      opts.muzzleOffsetY,
+      opts.muzzleSpeed
+    ) !== 0;
+  }
+  fireShooter2D(slot, x, y, z, yaw) {
+    return this.exports.zylem_stage_shooter_2d_fire(slot, x, y, z, yaw) !== 0;
+  }
+  queryShooter2D(slot) {
+    if (this.exports.zylem_stage_query_shooter_2d(slot) === 0) return null;
+    const v = this.queryView;
+    return { cooldown: v[0], firedCount: v[1] | 0 };
+  }
+  attachPlatformer3D(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "platformer-3d");
+    return this.exports.zylem_stage_attach_platformer_3d(
+      slot,
+      opts.halfHeight,
+      opts.radius,
+      opts.walkSpeed,
+      opts.runSpeed,
+      opts.jumpForce,
+      opts.maxJumps >>> 0,
+      opts.gravity,
+      opts.coyoteTime ?? 0.1,
+      opts.jumpBufferTime ?? 0.1,
+      opts.jumpCutMultiplier ?? 0.5,
+      opts.multiJumpWindow ?? 0.15,
+      opts.slopeClimbAngle ?? 50,
+      opts.slopeSlideAngle ?? 40,
+      opts.autostepHeight ?? 0.3,
+      opts.autostepMinWidth ?? 0.1,
+      opts.snapToGroundDistance ?? 0.3,
+      opts.characterOffset ?? 0.05,
+      opts.offsetX ?? 0,
+      opts.offsetY ?? 0,
+      opts.offsetZ ?? 0,
+      opts.shapeSource ?? StagePlatformerShapeSource.Auto
+    ) !== 0;
+  }
+  setPlatformer3DInputAxes(slot, moveX, moveZ) {
+    this.exports.zylem_stage_set_platformer_3d_input_axes(slot, moveX, moveZ);
+  }
+  setPlatformer3DInputButtons(slot, jump, run) {
+    this.exports.zylem_stage_set_platformer_3d_input_buttons(slot, jump ? 1 : 0, run ? 1 : 0);
+  }
+  queryPlatformer3D(slot) {
+    if (this.exports.zylem_stage_query_platformer_3d(slot) === 0) return null;
+    const v = this.queryView;
+    return {
+      grounded: v[0] > 0.5,
+      jumpCount: v[1] | 0,
+      fsmState: v[2] | 0,
+      speed: v[3]
+    };
+  }
+  attachPlatformer2D(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "platformer-2d");
+    return this.exports.zylem_stage_attach_platformer_2d(
+      slot,
+      opts.halfHeight,
+      opts.radius,
+      opts.walkSpeed,
+      opts.runSpeed,
+      opts.jumpForce,
+      opts.maxJumps >>> 0,
+      opts.gravity,
+      opts.coyoteTime ?? 0.1,
+      opts.jumpBufferTime ?? 0.1,
+      opts.jumpCutMultiplier ?? 0.5,
+      opts.multiJumpWindow ?? 0.15,
+      opts.slopeClimbAngle ?? 50,
+      opts.slopeSlideAngle ?? 40,
+      opts.autostepHeight ?? 0.25,
+      opts.autostepMinWidth ?? 0.05,
+      opts.snapToGroundDistance ?? 0.2,
+      opts.characterOffset ?? 0.05,
+      opts.offsetX ?? 0,
+      opts.offsetY ?? 0,
+      opts.offsetZ ?? 0,
+      opts.shapeSource ?? StagePlatformerShapeSource.Auto
+    ) !== 0;
+  }
+  setPlatformer2DInputAxes(slot, moveX) {
+    this.exports.zylem_stage_set_platformer_2d_input_axes(slot, moveX);
+  }
+  setPlatformer2DInputButtons(slot, jump, run) {
+    this.exports.zylem_stage_set_platformer_2d_input_buttons(slot, jump ? 1 : 0, run ? 1 : 0);
+  }
+  queryPlatformer2D(slot) {
+    if (this.exports.zylem_stage_query_platformer_2d(slot) === 0) return null;
+    const v = this.queryView;
+    return {
+      grounded: v[0] > 0.5,
+      jumpCount: v[1] | 0,
+      fsmState: v[2] | 0,
+      verticalVelocity: v[3]
+    };
+  }
+  attachFirstPerson(slot, opts) {
+    assertRuntimeBehavior(this.compatibility, "first-person");
+    return this.exports.zylem_stage_attach_first_person(
+      slot,
+      opts.walkSpeed,
+      opts.runSpeed,
+      opts.eyeHeight,
+      opts.lookSensitivity
+    ) !== 0;
+  }
+  setFirstPersonInput(slot, input) {
+    this.exports.zylem_stage_set_first_person_input(
+      slot,
+      input.moveX,
+      input.moveZ,
+      input.lookYawDelta,
+      input.lookPitchDelta,
+      input.run ? 1 : 0
+    );
+  }
+  queryFirstPerson(slot) {
+    if (this.exports.zylem_stage_query_first_person(slot) === 0) return null;
+    const v = this.queryView;
+    return { yaw: v[0], pitch: v[1], speed: v[2], eyeHeight: v[3] };
+  }
+};
+async function createWasmStageRuntime(options = {}) {
+  const { exports } = await loadStageFfi({
+    source: options.source,
+    imports: options.imports,
+    requiredBehaviors: options.requiredBehaviors
+  });
+  return new WasmStageRuntime(exports, options);
+}
+
+export {
+  STAGE_RENDER_STRIDE,
+  STAGE_INPUT_STRIDE,
+  STAGE_SNAPSHOT_STRIDE,
+  STAGE_EVENT_STRIDE,
+  STAGE_INVALID_SLOT,
+  StageBodyKind,
+  StageBoundaryDim,
+  StageRicochetDim,
+  StageRicochetReflection,
+  StageTopDownPlane,
+  StageEventType,
+  StagePlatformerShapeSource,
+  STAGE_INPUT_BUTTON_JUMP,
+  STAGE_INPUT_BUTTON_RUN,
+  readBehaviorSnapshot,
+  readStageRenderSlot,
+  WasmStageRuntime,
+  createWasmStageRuntime
+};