@zylem/behaviors 0.4.0 → 0.5.1

package/dist/chunk-E4X4YJZB.js

@@ -0,0 +1,841 @@
+// src/lib/runtime/wasm-stage-runtime.ts
+import {
+  loadStageFfi,
+  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
+};
+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]
+  };
+  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];
+  return result;
+}
+var WasmStageRuntime = class {
+  exports;
+  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.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);
+  }
+  // ─── 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;
+    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, 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 batched 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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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] };
+  }
+  attachTopDown(slot, opts) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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
+    ) !== 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) {
+    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
+    ) !== 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) {
+    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
+  });
+  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,
+  STAGE_INPUT_BUTTON_JUMP,
+  STAGE_INPUT_BUTTON_RUN,
+  readBehaviorSnapshot,
+  readStageRenderSlot,
+  WasmStageRuntime,
+  createWasmStageRuntime
+};
+//# sourceMappingURL=chunk-E4X4YJZB.js.map