@zylem/behaviors 0.4.1 → 0.5.2

package/README.md

@@ -1,6 +1,18 @@
 # Zylem Behaviors
 
-Tree-shakable Zylem behavior descriptors, systems, coordinators, and shared behavior helpers.
+The simulation layer of the Zylem framework: tree-shakable behavior descriptors, FSMs, coordinators, and the `Simulation` API that owns the `@zylem/runtime` WASM module (ECS + Rapier physics).
+
+`@zylem/behaviors` sits between the game framework and the runtime:
+
+```
+@zylem/game-lib  →  @zylem/behaviors  →  @zylem/runtime (WASM)
+```
+
+- **`createSimulation()` / `Simulation`** — loads and owns the WASM stage, exposes `spawn`/`despawn` with opaque `EntityHandle`s, a fixed-timestep `update(delta)` loop, snapshot/pose accessors, raycasts, debug rendering, and translated `SimulationEvent`s (collision start/stop with handles instead of raw slots).
+- **Behavior descriptors** (`Platformer3DBehavior`, `TopDownMovementBehavior`, …) — attach WASM-side controllers to entities and forward per-frame input through slot-indexed buffers; FSM state is read back from snapshots.
+- **`MockBehaviorRuntime`** — in-memory `BehaviorRuntime` implementation for unit-testing behaviors without loading WASM.
+
+Physics simulation is WASM-only; there is no TypeScript physics fallback. Disposal chains downward: `Simulation.dispose()` destroys the WASM stage.
 
 Use per-behavior entrypoints when you want bundlers to pull only the behavior family you import:
 

package/dist/{behavior-system-y8SGrGWy.d.ts → behavior-system-CldqNUgr.d.ts}

@@ -1,4 +1,4 @@
-import { RigidBody, Collider, World } from '@dimforge/rapier3d-compat';
+import { StageWasmExports } from '@zylem/runtime';
 
 /**
  * BehaviorDescriptor
@@ -113,7 +113,7 @@ interface VelocityIntent {
     priority?: number;
 }
 /**
- * Transform state managed by Valtio for batched physics updates.
+ * Transform state managed by Valtio for per-frame physics intent accumulation.
  *
  * This store accumulates transformation intents during the frame,
  * then applies them all at once after onUpdate() callbacks complete.
@@ -199,8 +199,9 @@ declare class GameEntity<TOptions = unknown> {
     group: any;
     mesh?: any;
     materials?: any[];
-    body: RigidBody | null;
-    collider: Collider | null;
+    /** Opaque host-owned physics references (never inspected by behaviors). */
+    body: unknown | null;
+    collider: unknown | null;
     colliderDesc?: any;
     colliderDescs: any[];
     bodyDesc?: any;
@@ -233,12 +234,24 @@ declare class GameEntity<TOptions = unknown> {
  */
 type CreateEntityFn = (options?: Partial<GameEntityOptions>) => GameEntity<GameEntityOptions>;
 
+/**
+ * `WasmStageRuntime` — owns one wasm `WebAssembly.Instance` of
+ * `@zylem/runtime` and exposes the unified-Stage FFI as typed TypeScript
+ * methods. This is the single simulation adapter for the whole framework:
+ * behavior systems talk to it through the {@link BehaviorRuntime} contract,
+ * and hosts (e.g. `@zylem/game-lib`) drive it through
+ * {@link createSimulation} in `./simulation`.
+ */
+
+/** Sentinel handle for "no entity / failed allocation". Mirrors `INVALID_SLOT` in Rust. */
+declare const STAGE_INVALID_SLOT = 4294967295;
 declare const StageBodyKind: {
     readonly Dynamic: 0;
     readonly Static: 1;
     readonly KinematicPosition: 2;
     readonly KinematicVelocity: 3;
 };
+type StageBodyKindValue = (typeof StageBodyKind)[keyof typeof StageBodyKind];
 declare const StageBoundaryDim: {
     readonly Two: 2;
     readonly Three: 3;
@@ -359,7 +372,19 @@ interface StagePlatformer3DOptions {
     snapToGroundDistance?: number;
     /** KCC collision offset between collider and environment (default 0.05). */
     characterOffset?: number;
+    /** Collider local offset X (fallback / override). */
+    offsetX?: number;
+    /** Collider local offset Y (fallback / override). */
+    offsetY?: number;
+    /** Collider local offset Z (fallback / override). */
+    offsetZ?: number;
+    /** 0 = auto-read attached collider; 1 = use stored shape fields. */
+    shapeSource?: number;
 }
+declare const StagePlatformerShapeSource: {
+    readonly Auto: 0;
+    readonly Override: 1;
+};
 interface StagePlatformer2DOptions {
     halfHeight: number;
     radius: number;
@@ -388,6 +413,14 @@ interface StagePlatformer2DOptions {
     snapToGroundDistance?: number;
     /** KCC collision offset between collider and environment (default 0.05). */
     characterOffset?: number;
+    /** Collider local offset X (fallback / override). */
+    offsetX?: number;
+    /** Collider local offset Y (fallback / override). */
+    offsetY?: number;
+    /** Collider local offset Z (fallback / override). */
+    offsetZ?: number;
+    /** 0 = auto-read attached collider; 1 = use stored shape fields. */
+    shapeSource?: number;
 }
 interface StageFirstPersonOptions {
     walkSpeed: number;
@@ -402,7 +435,7 @@ interface StageFirstPersonInput {
     lookPitchDelta: number;
     run: boolean;
 }
-/** Button bits for the batched input buffer's bitmask field. */
+/** Button bits for the slot-indexed input buffer's bitmask field. */
 declare const STAGE_INPUT_BUTTON_JUMP = 1;
 declare const STAGE_INPUT_BUTTON_RUN = 2;
 /**
@@ -426,7 +459,7 @@ interface StageBehaviorSnapshot {
  * a duplicate TS FSM (or hardcoded defaults).
  */
 interface WasmSnapshotBackref {
-    __wasmStage?: WasmStageRuntime | null;
+    __wasmStage?: BehaviorRuntime | null;
     __entity?: {
         runtimeHandle?: number;
     } | null;
@@ -439,21 +472,24 @@ interface WasmSnapshotBackref {
  */
 declare function readBehaviorSnapshot(ref: object): StageBehaviorSnapshot | null;
 /**
- * Typed FFI surface of the wasm unified Stage runtime that behaviors rely on.
- *
- * The concrete implementation lives in `@zylem/game-lib`
- * (`wasm-stage-runtime.ts`); this contract mirrors the slice of its methods
- * that behavior systems call so descriptors stay runtime-agnostic.
+ * Runtime surface behavior systems rely on. `WasmStageRuntime` is the real
+ * wasm-backed implementation; `MockBehaviorRuntime` (see
+ * `./mock-behavior-runtime`) implements the same contract for unit tests, so
+ * descriptors stay runtime-agnostic.
  */
-interface WasmStageRuntime {
+interface BehaviorRuntime {
     getPose(handle: number, out?: StagePose): StagePose | null;
+    setPosition(handle: number, x: number, y: number, z: number): boolean;
+    setRotation(handle: number, x: number, y: number, z: number, w: number): boolean;
     writeInputAxes(handle: number, axisA: number, axisB: number): boolean;
     writeInputLook(handle: number, yawDelta: number, pitchDelta: number): boolean;
+    /** Write reserved input slots (thruster world-space vector X/Y). */
+    writeInputReserved(handle: number, reservedA: number, reservedB: number): boolean;
     writeInputButton(handle: number, buttonMask: number, pressed: boolean): boolean;
     /** Read the per-slot behavior snapshot written at the end of the previous step. */
     readSnapshot(handle: number, out?: StageBehaviorSnapshot): StageBehaviorSnapshot | null;
     attachThruster(handle: number, opts: StageThrusterOptions): boolean;
-    setThrusterInput(handle: number, thrust: number, rotate: number): void;
+    setThrusterInput(handle: number, thrust: number, rotate: number, vectorX?: number, vectorY?: number): void;
     attachTopDown(handle: number, opts: StageTopDownOptions): boolean;
     setTopDownInput(handle: number, moveX: number, moveY: number): void;
     attachShooter2D(handle: number, opts: StageShooter2DOptions): boolean;
@@ -486,20 +522,299 @@ interface WasmStageRuntimeOptions {
     initialCapacity?: number;
     gravity?: readonly [number, number, number];
     imports?: WebAssembly.Imports;
+    /**
+     * Custom wasm source. Defaults to the `zylem_runtime.wasm` bundled with
+     * `@zylem/runtime`.
+     */
+    source?: RequestInfo | URL | ArrayBuffer | Uint8Array;
+}
+type StageEventTypeValue = (typeof StageEventType)[keyof typeof StageEventType];
+/** One decoded event drained from the runtime's per-step event buffer. */
+interface StageEvent {
+    type: StageEventTypeValue;
+    primarySlot: number | null;
+    secondarySlot: number | null;
+    payload: [number, number, number];
+}
+/**
+ * Decoded view of one entity's slot in the unified render buffer.
+ *
+ * Mirrors the `STAGE_RENDER_STRIDE` (12-float) packing documented in
+ * `runtime/stage/render.rs`:
+ * `[0..3]` position, `[3..7]` rotation xyzw, `[7]` uniform scale,
+ * `[8..12]` custom0..custom3 (per-behavior shading hints).
+ */
+interface StageRenderSlot {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: number;
+    custom: [number, number, number, number];
+}
+/**
+ * Read a single entity slot out of a unified-Stage render buffer view.
+ *
+ * @param view   The `Float32Array` over wasm memory (e.g. `WasmStageRuntime.render`).
+ * @param slot   The entity's wasm slot id (its `runtimeHandle`).
+ * @param out    Optional target object to write into (avoids per-call allocation).
+ * @returns The decoded slot, or `null` when the slot is out of range.
+ */
+declare function readStageRenderSlot(view: Float32Array, slot: number, out?: StageRenderSlot): StageRenderSlot | null;
+interface StageBodyConfig {
+    kind: StageBodyKindValue;
+    position: readonly [number, number, number];
+    rotation: readonly [number, number, number, number];
+    linearDamping: number;
+    angularDamping: number;
+    gravityScale: number;
+    canSleep: boolean;
+    ccdEnabled: boolean;
+    lockRotation: readonly [boolean, boolean, boolean];
+    lockTranslation: readonly [boolean, boolean, boolean];
+}
+type StageColliderShape = {
+    type: 'box';
+    halfExtents: readonly [number, number, number];
+} | {
+    type: 'sphere';
+    radius: number;
+} | {
+    type: 'capsule';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'cylinder';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'cone';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'convexHull';
+    vertices: Float32Array;
+} | {
+    type: 'trimesh';
+    vertices: Float32Array;
+    indices: Uint32Array;
+} | {
+    type: 'heightfield';
+    rows: number;
+    cols: number;
+    scale: readonly [number, number, number];
+    heights: Float32Array;
+};
+interface StageColliderConfig {
+    shape: StageColliderShape;
+    offset: readonly [number, number, number];
+    friction: number;
+    restitution: number;
+    sensor: boolean;
+    /** Packed interaction-groups: high 16 bits = membership, low 16 bits = filter. */
+    collisionGroups: number;
+}
+/** Result of a physics raycast against the stage. */
+interface StageRaycastHit {
+    slot: number;
+    distance: number;
+    normal: [number, number, number];
+}
+/** Body introspection payload for debug tooling. */
+interface StageBodyInfo {
+    bodyType: number;
+    mass: number;
+    isSleeping: boolean;
+    isEnabled: boolean;
+    linearVelocity: [number, number, number];
 }
+/** Line-list wireframe for physics debug rendering. */
+interface StageDebugRender {
+    /** `[x, y, z]` per vertex, two vertices per line. */
+    vertices: Float32Array;
+    /** RGBA per vertex. */
+    colors: Float32Array;
+}
+/**
+ * Owns the wasm instance plus the live float-views over its render / event /
+ * pose / scratch buffers. One instance per logical stage; each stage gets
+ * its own `WebAssembly.Instance` so the singleton inside `stage_ffi.rs`
+ * stays single-stage scoped (today's `thread_local!` contract).
+ */
+declare class WasmStageRuntime implements BehaviorRuntime {
+    readonly exports: StageWasmExports;
+    private readonly memory;
+    private renderView;
+    private inputView;
+    private snapshotView;
+    private eventView;
+    private poseView;
+    private vec3View;
+    private queryView;
+    private scratchView;
+    constructor(exports: StageWasmExports, options?: WasmStageRuntimeOptions);
+    /** Recreate typed views over wasm memory. Call after step() or whenever memory may have grown. */
+    refreshViews(): void;
+    /** Step the simulation by `dt` seconds. Refreshes views afterwards. */
+    step(dt: number): number;
+    dispose(): void;
+    get tickCount(): number;
+    get activeCount(): number;
+    setGravity(x: number, y: number, z: number): void;
+    /**
+     * 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: boolean): void;
+    createEntity(): number;
+    destroyEntity(slot: number): boolean;
+    attachBody(slot: number, config: StageBodyConfig): boolean;
+    addCollider(slot: number, config: StageColliderConfig): boolean;
+    private stageScratch;
+    private stageScratchIndices;
+    getPose(slot: number, out?: StagePose): StagePose | null;
+    setPosition(slot: number, x: number, y: number, z: number): boolean;
+    setRotation(slot: number, x: number, y: number, z: number, w: number): boolean;
+    setLinearVelocity(slot: number, x: number, y: number, z: number): boolean;
+    getLinearVelocity(slot: number, out?: [number, number, number]): [number, number, number] | null;
+    setAngularVelocity(slot: number, x: number, y: number, z: number): boolean;
+    getAngularVelocity(slot: number, out?: [number, number, number]): [number, number, number] | null;
+    applyImpulse(slot: number, x: number, y: number, z: number): boolean;
+    /** Cast a ray against the physics world. Returns the closest hit or `null`. */
+    castRay(origin: readonly [number, number, number], dir: readonly [number, number, number], maxDistance: number, solidOnly?: boolean): StageRaycastHit | null;
+    /** Body introspection for debug tooling. */
+    getBodyInfo(slot: number): StageBodyInfo | null;
+    /** Wireframe debug render of every collider (all shapes). */
+    getDebugRender(): StageDebugRender | null;
+    /** Read-only view over the render buffer; one slot occupies {@link STAGE_RENDER_STRIDE} floats. */
+    get render(): Float32Array;
+    get renderStride(): number;
+    /**
+     * Decode a single entity slot from the live render buffer. Convenience
+     * wrapper over {@link readStageRenderSlot} bound to this runtime's view.
+     */
+    readRenderSlot(slot: number, out?: StageRenderSlot): StageRenderSlot | null;
+    /** Drain the wasm event buffer into a fresh array of typed events. */
+    drainEvents(): StageEvent[];
+    /** Writable view over the slot-indexed input buffer ({@link STAGE_INPUT_STRIDE} floats/slot). */
+    get input(): Float32Array;
+    get inputStride(): number;
+    /** Read-only view over the per-slot behavior snapshot buffer ({@link STAGE_SNAPSHOT_STRIDE} floats/slot). */
+    get snapshot(): Float32Array;
+    get snapshotStride(): number;
+    /**
+     * 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: number, axisA: number, axisB: number): boolean;
+    /** Write the look deltas (first-person yaw/pitch) for a slot. */
+    writeInputLook(slot: number, yawDelta: number, pitchDelta: number): boolean;
+    /** Write reserved input slots (thruster world-space vector X/Y). */
+    writeInputReserved(slot: number, reservedA: number, reservedB: number): boolean;
+    /**
+     * Set or clear one button bit ({@link STAGE_INPUT_BUTTON_JUMP} /
+     * {@link STAGE_INPUT_BUTTON_RUN}) in a slot's input bitmask.
+     */
+    writeInputButton(slot: number, buttonMask: number, pressed: boolean): boolean;
+    /**
+     * 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: number, out?: StageBehaviorSnapshot): StageBehaviorSnapshot | null;
+    get queryScratch(): Float32Array;
+    attachCooldown(slot: number): boolean;
+    registerCooldown(slot: number, id: number, durationSeconds: number, immediate?: boolean): boolean;
+    fireCooldown(slot: number, id: number): boolean;
+    resetCooldown(slot: number, id: number): boolean;
+    cooldownRemaining(slot: number, id: number): number;
+    attachWorldBoundary(slot: number, dim: StageBoundaryDimValue, bounds: StageWorldBoundaryOptions): boolean;
+    queryWorldBoundary(slot: number): {
+        hits: number;
+        clamped: [number, number, number];
+    } | null;
+    attachScreenWrap(slot: number, opts: StageScreenWrapOptions): boolean;
+    queryScreenWrap(slot: number): {
+        fsm: number;
+        lastWrappedAxes: number;
+    } | null;
+    attachRicochet(slot: number, dim: StageRicochetDimValue, opts: StageRicochetOptions): boolean;
+    queryRicochet(slot: number): {
+        bounces: number;
+        lastKind: number;
+    } | null;
+    attachThruster(slot: number, opts: StageThrusterOptions): boolean;
+    setThrusterInput(slot: number, thrust: number, turn: number, vectorX?: number, vectorY?: number): void;
+    queryThruster(slot: number): {
+        headingRad: number;
+        speed: number;
+    } | null;
+    attachTopDown(slot: number, opts: StageTopDownOptions): boolean;
+    setTopDownInput(slot: number, axisA: number, axisB: number): void;
+    attachJumper2D(slot: number, opts: StageJumper2DOptions): boolean;
+    setJumper2DInput(slot: number, jumpPressed: boolean): void;
+    queryJumper2D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        coyote: number;
+        jumpBuffer: number;
+    } | null;
+    attachJumper3D(slot: number, opts: StageJumper3DOptions): boolean;
+    setJumper3DInput(slot: number, jump: boolean): void;
+    queryJumper3D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        verticalVelocity: number;
+    } | null;
+    attachShooter2D(slot: number, opts: StageShooter2DOptions): boolean;
+    fireShooter2D(slot: number, x: number, y: number, z: number, yaw: number): boolean;
+    queryShooter2D(slot: number): {
+        cooldown: number;
+        firedCount: number;
+    } | null;
+    attachPlatformer3D(slot: number, opts: StagePlatformer3DOptions): boolean;
+    setPlatformer3DInputAxes(slot: number, moveX: number, moveZ: number): void;
+    setPlatformer3DInputButtons(slot: number, jump: boolean, run: boolean): void;
+    queryPlatformer3D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        fsmState: number;
+        speed: number;
+    } | null;
+    attachPlatformer2D(slot: number, opts: StagePlatformer2DOptions): boolean;
+    setPlatformer2DInputAxes(slot: number, moveX: number): void;
+    setPlatformer2DInputButtons(slot: number, jump: boolean, run: boolean): void;
+    queryPlatformer2D(slot: number): {
+        grounded: boolean;
+        jumpCount: number;
+        fsmState: number;
+        verticalVelocity: number;
+    } | null;
+    attachFirstPerson(slot: number, opts: StageFirstPersonOptions): boolean;
+    setFirstPersonInput(slot: number, input: StageFirstPersonInput): void;
+    queryFirstPerson(slot: number): {
+        yaw: number;
+        pitch: number;
+        speed: number;
+        eyeHeight: number;
+    } | null;
+}
+/**
+ * Load the bundled `@zylem/runtime` wasm (or a custom `source`), instantiate
+ * it, and construct a `WasmStageRuntime` around the exports.
+ */
+declare function createWasmStageRuntime(options?: WasmStageRuntimeOptions): Promise<WasmStageRuntime>;
 
 /**
  * Structural stand-in for the engine world wrapper. The engine's world
- * delegate exposes the raw Rapier world plus an entity lookup map; behaviors
- * only rely on this slice.
+ * delegate exposes an entity lookup map; behaviors only rely on this slice.
  *
  * The map value is intentionally `unknown` (not the `GameEntity` stub class):
  * the engine's concrete entity class is a different nominal type, and systems
  * that iterate the map narrow entities themselves.
  */
 interface ZylemWorld {
-    /** Raw Rapier physics world (present when the Rapier path is active). */
-    world?: World;
     collisionMap?: Map<string, unknown>;
 }
 
@@ -553,7 +868,7 @@ interface BehaviorSystemContext {
     /** Host scene wrapper (engine-specific); behaviors only call `add`/`remove`-style methods on it. */
     scene: any;
     /** Wasm-driven Stage runtime; omitted when the stage has no wasm module. */
-    wasmStage?: WasmStageRuntime | null;
+    wasmStage?: BehaviorRuntime | null;
     /**
      * Returns live behavior links for a descriptor key.
      * O(1) lookup into a pre-built stage index.
@@ -577,4 +892,4 @@ interface BehaviorSystemContext {
  */
 type BehaviorSystemFactory<T extends BehaviorSystem = BehaviorSystem> = (stage: BehaviorSystemContext) => T;
 
-export { type StageScreenWrapOptions as A, type BaseBehaviorHandle as B, type CreateEntityFn as C, type DefineBehaviorConfig as D, type StageShooter2DOptions as E, type StageThrusterOptions as F, GameEntity as G, type StageTopDownOptions as H, StageTopDownPlane as I, type StageTopDownPlaneValue as J, type StageWorldBoundaryOptions as K, type VelocityIntentMode as L, type WasmStageRuntime as M, type WasmStageRuntimeOptions as N, createTransformStore as O, defineBehavior as P, readBehaviorSnapshot as Q, STAGE_INPUT_BUTTON_JUMP as S, type TransformState as T, type VelocityIntent as V, type WasmSnapshotBackref as W, type ZylemWorld as Z, type BehaviorDescriptor as a, type BehaviorEntityLink as b, type BehaviorHandle as c, type BehaviorRef as d, type BehaviorSystem as e, type BehaviorSystemContext as f, type BehaviorSystemFactory as g, type GameEntityOptions as h, STAGE_INPUT_BUTTON_RUN as i, type StageBehaviorSnapshot as j, StageBodyKind as k, StageBoundaryDim as l, type StageBoundaryDimValue as m, StageEventType as n, type StageFirstPersonInput as o, type StageFirstPersonOptions as p, type StageJumper2DOptions as q, type StageJumper3DOptions as r, type StagePlatformer2DOptions as s, type StagePlatformer3DOptions as t, type StagePose as u, StageRicochetDim as v, type StageRicochetDimValue as w, type StageRicochetOptions as x, StageRicochetReflection as y, type StageRicochetReflectionValue as z };
+export { type VelocityIntentMode as $, type StageJumper2DOptions as A, type BaseBehaviorHandle as B, type CreateEntityFn as C, type DefineBehaviorConfig as D, type StageJumper3DOptions as E, type StagePlatformer2DOptions as F, GameEntity as G, type StagePlatformer3DOptions as H, StagePlatformerShapeSource as I, type StagePose as J, type StageRaycastHit as K, type StageRenderSlot as L, StageRicochetDim as M, type StageRicochetDimValue as N, type StageRicochetOptions as O, StageRicochetReflection as P, type StageRicochetReflectionValue as Q, type StageScreenWrapOptions as R, STAGE_INPUT_BUTTON_JUMP as S, type StageShooter2DOptions as T, type StageThrusterOptions as U, type StageTopDownOptions as V, StageTopDownPlane as W, type StageTopDownPlaneValue as X, type StageWorldBoundaryOptions as Y, type TransformState as Z, type VelocityIntent as _, type BehaviorDescriptor as a, type WasmSnapshotBackref as a0, WasmStageRuntime as a1, type WasmStageRuntimeOptions as a2, createTransformStore as a3, createWasmStageRuntime as a4, defineBehavior as a5, readBehaviorSnapshot as a6, readStageRenderSlot as a7, type BehaviorEntityLink as b, type BehaviorHandle as c, type BehaviorRef as d, type BehaviorRuntime as e, type BehaviorSystem as f, type BehaviorSystemContext as g, type BehaviorSystemFactory as h, type GameEntityOptions as i, STAGE_INPUT_BUTTON_RUN as j, STAGE_INVALID_SLOT as k, type StageBehaviorSnapshot as l, type StageBodyConfig as m, type StageBodyInfo as n, StageBodyKind as o, type StageBodyKindValue as p, StageBoundaryDim as q, type StageBoundaryDimValue as r, type StageColliderConfig as s, type StageColliderShape as t, type StageDebugRender as u, type StageEvent as v, StageEventType as w, type StageEventTypeValue as x, type StageFirstPersonInput as y, type StageFirstPersonOptions as z };

package/dist/{chunk-GFARAJV2.js → chunk-2PAHQZZD.js}

@@ -1,11 +1,10 @@
 import {
-  createBounds2DRect,
-  wrapPoint2D
-} from "./chunk-KDY5N6J4.js";
+  createBounds2DRect
+} from "./chunk-OPZ2LVS2.js";
 import {
   SyncStateMachine,
-  t
-} from "./chunk-4URF65BR.js";
+  import_typescript_fsm
+} from "./chunk-AS3HR7AS.js";
 import {
   defineBehavior
 } from "./chunk-EZNCCO4L.js";
@@ -36,33 +35,33 @@ var ScreenWrapFSM = class {
       "center" /* Center */,
       [
         // From Center
-        t("center" /* Center */, "approach-left" /* ApproachLeft */, "near-edge-left" /* NearEdgeLeft */),
-        t("center" /* Center */, "approach-right" /* ApproachRight */, "near-edge-right" /* NearEdgeRight */),
-        t("center" /* Center */, "approach-top" /* ApproachTop */, "near-edge-top" /* NearEdgeTop */),
-        t("center" /* Center */, "approach-bottom" /* ApproachBottom */, "near-edge-bottom" /* NearEdgeBottom */),
+        (0, import_typescript_fsm.t)("center" /* Center */, "approach-left" /* ApproachLeft */, "near-edge-left" /* NearEdgeLeft */),
+        (0, import_typescript_fsm.t)("center" /* Center */, "approach-right" /* ApproachRight */, "near-edge-right" /* NearEdgeRight */),
+        (0, import_typescript_fsm.t)("center" /* Center */, "approach-top" /* ApproachTop */, "near-edge-top" /* NearEdgeTop */),
+        (0, import_typescript_fsm.t)("center" /* Center */, "approach-bottom" /* ApproachBottom */, "near-edge-bottom" /* NearEdgeBottom */),
         // From NearEdge to Wrapped
-        t("near-edge-left" /* NearEdgeLeft */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
-        t("near-edge-right" /* NearEdgeRight */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
-        t("near-edge-top" /* NearEdgeTop */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
-        t("near-edge-bottom" /* NearEdgeBottom */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
+        (0, import_typescript_fsm.t)("near-edge-left" /* NearEdgeLeft */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
+        (0, import_typescript_fsm.t)("near-edge-right" /* NearEdgeRight */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
+        (0, import_typescript_fsm.t)("near-edge-top" /* NearEdgeTop */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
+        (0, import_typescript_fsm.t)("near-edge-bottom" /* NearEdgeBottom */, "wrap" /* Wrap */, "wrapped" /* Wrapped */),
         // From NearEdge back to Center
-        t("near-edge-left" /* NearEdgeLeft */, "enter-center" /* EnterCenter */, "center" /* Center */),
-        t("near-edge-right" /* NearEdgeRight */, "enter-center" /* EnterCenter */, "center" /* Center */),
-        t("near-edge-top" /* NearEdgeTop */, "enter-center" /* EnterCenter */, "center" /* Center */),
-        t("near-edge-bottom" /* NearEdgeBottom */, "enter-center" /* EnterCenter */, "center" /* Center */),
+        (0, import_typescript_fsm.t)("near-edge-left" /* NearEdgeLeft */, "enter-center" /* EnterCenter */, "center" /* Center */),
+        (0, import_typescript_fsm.t)("near-edge-right" /* NearEdgeRight */, "enter-center" /* EnterCenter */, "center" /* Center */),
+        (0, import_typescript_fsm.t)("near-edge-top" /* NearEdgeTop */, "enter-center" /* EnterCenter */, "center" /* Center */),
+        (0, import_typescript_fsm.t)("near-edge-bottom" /* NearEdgeBottom */, "enter-center" /* EnterCenter */, "center" /* Center */),
         // From Wrapped back to Center
-        t("wrapped" /* Wrapped */, "enter-center" /* EnterCenter */, "center" /* Center */),
+        (0, import_typescript_fsm.t)("wrapped" /* Wrapped */, "enter-center" /* EnterCenter */, "center" /* Center */),
         // From Wrapped to NearEdge (landed near opposite edge)
-        t("wrapped" /* Wrapped */, "approach-left" /* ApproachLeft */, "near-edge-left" /* NearEdgeLeft */),
-        t("wrapped" /* Wrapped */, "approach-right" /* ApproachRight */, "near-edge-right" /* NearEdgeRight */),
-        t("wrapped" /* Wrapped */, "approach-top" /* ApproachTop */, "near-edge-top" /* NearEdgeTop */),
-        t("wrapped" /* Wrapped */, "approach-bottom" /* ApproachBottom */, "near-edge-bottom" /* NearEdgeBottom */),
+        (0, import_typescript_fsm.t)("wrapped" /* Wrapped */, "approach-left" /* ApproachLeft */, "near-edge-left" /* NearEdgeLeft */),
+        (0, import_typescript_fsm.t)("wrapped" /* Wrapped */, "approach-right" /* ApproachRight */, "near-edge-right" /* NearEdgeRight */),
+        (0, import_typescript_fsm.t)("wrapped" /* Wrapped */, "approach-top" /* ApproachTop */, "near-edge-top" /* NearEdgeTop */),
+        (0, import_typescript_fsm.t)("wrapped" /* Wrapped */, "approach-bottom" /* ApproachBottom */, "near-edge-bottom" /* NearEdgeBottom */),
         // Self-transitions (no-ops for redundant events)
-        t("center" /* Center */, "enter-center" /* EnterCenter */, "center" /* Center */),
-        t("near-edge-left" /* NearEdgeLeft */, "approach-left" /* ApproachLeft */, "near-edge-left" /* NearEdgeLeft */),
-        t("near-edge-right" /* NearEdgeRight */, "approach-right" /* ApproachRight */, "near-edge-right" /* NearEdgeRight */),
-        t("near-edge-top" /* NearEdgeTop */, "approach-top" /* ApproachTop */, "near-edge-top" /* NearEdgeTop */),
-        t("near-edge-bottom" /* NearEdgeBottom */, "approach-bottom" /* ApproachBottom */, "near-edge-bottom" /* NearEdgeBottom */)
+        (0, import_typescript_fsm.t)("center" /* Center */, "enter-center" /* EnterCenter */, "center" /* Center */),
+        (0, import_typescript_fsm.t)("near-edge-left" /* NearEdgeLeft */, "approach-left" /* ApproachLeft */, "near-edge-left" /* NearEdgeLeft */),
+        (0, import_typescript_fsm.t)("near-edge-right" /* NearEdgeRight */, "approach-right" /* ApproachRight */, "near-edge-right" /* NearEdgeRight */),
+        (0, import_typescript_fsm.t)("near-edge-top" /* NearEdgeTop */, "approach-top" /* ApproachTop */, "near-edge-top" /* NearEdgeTop */),
+        (0, import_typescript_fsm.t)("near-edge-bottom" /* NearEdgeBottom */, "approach-bottom" /* ApproachBottom */, "near-edge-bottom" /* NearEdgeBottom */)
       ]
     );
   }
@@ -130,41 +129,24 @@ var ScreenWrapSystem = class {
         wrapRef.fsm = new ScreenWrapFSM();
       }
       const handle = gameEntity.runtimeHandle ?? -1;
-      if (this.wasmStage && handle >= 0) {
-        this.ensureWasmAttached(handle, options);
-        const pose = this.wasmStage.getPose(handle);
-        const query = this.wasmStage.queryScreenWrap(handle);
-        if (pose && query) {
-          const bounds2 = createBounds2DRect(options);
-          wrapRef.fsm.update(
-            { x: pose.position[0], y: pose.position[1] },
-            {
-              minX: bounds2.minX,
-              maxX: bounds2.maxX,
-              minY: bounds2.minY,
-              maxY: bounds2.maxY,
-              edgeThreshold: options.edgeThreshold
-            },
-            query.lastWrappedAxes !== 0
-          );
-          continue;
-        }
+      if (!this.wasmStage || handle < 0) continue;
+      this.ensureWasmAttached(handle, options);
+      const pose = this.wasmStage.getPose(handle);
+      const query = this.wasmStage.queryScreenWrap(handle);
+      if (pose && query) {
+        const bounds = createBounds2DRect(options);
+        wrapRef.fsm.update(
+          { x: pose.position[0], y: pose.position[1] },
+          {
+            minX: bounds.minX,
+            maxX: bounds.maxX,
+            minY: bounds.minY,
+            maxY: bounds.maxY,
+            edgeThreshold: options.edgeThreshold
+          },
+          query.lastWrappedAxes !== 0
+        );
       }
-      if (!gameEntity.body) continue;
-      const wrapped = this.wrapEntity(gameEntity, options);
-      const pos = gameEntity.body.translation();
-      const bounds = createBounds2DRect(options);
-      wrapRef.fsm.update(
-        { x: pos.x, y: pos.y },
-        {
-          minX: bounds.minX,
-          maxX: bounds.maxX,
-          minY: bounds.minY,
-          maxY: bounds.maxY,
-          edgeThreshold: options.edgeThreshold
-        },
-        wrapped
-      );
     }
   }
   ensureWasmAttached(handle, options) {
@@ -178,17 +160,6 @@ var ScreenWrapSystem = class {
     });
     this.attachedRuntimeSlots.add(handle);
   }
-  wrapEntity(entity, options) {
-    const body = entity.body;
-    if (!body) return false;
-    const pos = body.translation();
-    const bounds = createBounds2DRect(options);
-    const result = wrapPoint2D({ x: pos.x, y: pos.y }, bounds);
-    if (result.wrapped) {
-      body.setTranslation({ x: result.x, y: result.y, z: pos.z }, true);
-    }
-    return result.wrapped;
-  }
   destroy(_ecs) {
     this.attachedRuntimeSlots.clear();
   }
@@ -205,4 +176,4 @@ export {
   ScreenWrapFSM,
   ScreenWrapBehavior
 };
-//# sourceMappingURL=chunk-GFARAJV2.js.map
+//# sourceMappingURL=chunk-2PAHQZZD.js.map