@zylem/behaviors 0.3.1 → 0.4.0

package/dist/platformer-2d.d.ts

@@ -0,0 +1,306 @@
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import { RigidBody, Collider } from '@dimforge/rapier3d-compat';
+import { Z as ZylemWorld, a as BehaviorDescriptor } from './behavior-system-DSNek0W9.js';
+import 'typescript-fsm';
+
+/**
+ * Platformer 2D Components
+ *
+ * Components for 2D platformer movement on the X/Y plane: walking/running on
+ * X, jumping with multi-jump support, and falling/landing states.
+ */
+interface Platformer2DMovementComponent {
+    /** Base walking speed */
+    walkSpeed: number;
+    /** Sprint/run speed */
+    runSpeed: number;
+    /** Initial jump force/velocity */
+    jumpForce: number;
+    /** Maximum number of jumps (1 = single jump, 2 = double jump, etc.) */
+    maxJumps: number;
+    /** Gravity force */
+    gravity: number;
+    /** Coyote time in seconds (grace period after leaving ground) */
+    coyoteTime: number;
+    /** Jump buffer time in seconds (queue jump input before landing) */
+    jumpBufferTime: number;
+    /** Velocity multiplier when releasing jump button early (0-1) */
+    jumpCutMultiplier: number;
+    /** Time in seconds before multi-jump becomes available (0 = after button release) */
+    multiJumpWindowTime: number;
+    /** Maximum slope angle (degrees) the character can walk up */
+    slopeClimbAngle: number;
+    /** Slope angle (degrees) past which the character slides down */
+    slopeSlideAngle: number;
+    /** Autostep configuration for SNES-style step-ups, or false to disable */
+    autostep: {
+        maxHeight: number;
+        minWidth: number;
+    } | false;
+    /** Snap-to-ground distance (keeps the character glued going downhill) */
+    snapToGroundDistance: number;
+    /** Character controller offset (small gap kept between collider and environment) */
+    characterOffset: number;
+}
+declare function createPlatformer2DMovementComponent(options?: Partial<Platformer2DMovementComponent>): Platformer2DMovementComponent;
+interface Platformer2DInputComponent {
+    /** Horizontal movement input (-1 to 1) */
+    moveX: number;
+    /** Jump button pressed */
+    jump: boolean;
+    /** Run/sprint button held */
+    run: boolean;
+}
+declare function createPlatformer2DInputComponent(): Platformer2DInputComponent;
+interface Platformer2DStateComponent {
+    /** Is the entity on the ground */
+    grounded: boolean;
+    /** Is currently in a jump arc */
+    jumping: boolean;
+    /** Is falling (not jumping) */
+    falling: boolean;
+    /** Current jump count (for multi-jump) */
+    jumpCount: number;
+    /** Y position when jump started */
+    jumpStartHeight: number;
+    /** Current movement speed being applied */
+    currentSpeed: number;
+    /** Last known ground Y position */
+    lastGroundedY: number;
+    /** Was jump button pressed last frame (for edge detection) */
+    jumpPressedLastFrame: boolean;
+    /** Time in seconds since last grounded */
+    timeSinceGrounded: number;
+    /** Is a jump allowed due to buffer? */
+    jumpBuffered: boolean;
+    /** Time remaining in jump buffer */
+    jumpBufferTimer: number;
+    /** Is jump button currently held */
+    jumpHeld: boolean;
+    /** Has the jump cut been applied for this jump? */
+    jumpCutApplied: boolean;
+    /** Has jump button been released since last jump (required for multi-jump) */
+    jumpReleasedSinceLastJump: boolean;
+    /** Time since current jump started (for multi-jump window) */
+    timeSinceJump: number;
+    /** True for the single frame on which a jump impulse was applied; prevents gravity from clobbering jump velocity. */
+    jumpedThisFrame: boolean;
+    /** Remaining seconds of jump-cut velocity ramp; while > 0, verticalVelocity lerps toward verticalVelocity * jumpCutMultiplier. */
+    jumpCutRampTimer: number;
+    /**
+     * Controller-owned vertical velocity (units/second).
+     * The body is kinematic, so `linvel()` is meaningless — this field is the
+     * single source of truth for jump/gravity motion on the Y axis.
+     */
+    verticalVelocity: number;
+}
+declare function createPlatformer2DStateComponent(): Platformer2DStateComponent;
+
+/**
+ * Platformer 2D Finite State Machine
+ *
+ * Manages state transitions for 2D platformer movement:
+ * - Idle: Standing still on ground
+ * - Walking: Moving on ground (slow)
+ * - Running: Moving on ground (fast)
+ * - Jumping: Ascending from jump
+ * - Falling: Descending (gravity)
+ * - Landing: Just touched ground
+ */
+
+/**
+ * Simplified collision context (normal in the X/Y plane).
+ */
+interface Platformer2DCollisionContext {
+    contact: {
+        normal: {
+            x: number;
+            y: number;
+        };
+    };
+}
+declare enum Platformer2DState {
+    Idle = "idle",
+    Walking = "walking",
+    Running = "running",
+    Jumping = "jumping",
+    Falling = "falling",
+    Landing = "landing"
+}
+declare enum Platformer2DEvent {
+    Walk = "walk",
+    Run = "run",
+    Jump = "jump",
+    Fall = "fall",
+    Land = "land",
+    Stop = "stop"
+}
+interface Platformer2DContext {
+    input: Platformer2DInputComponent;
+    state: Platformer2DStateComponent;
+}
+declare class Platformer2DFSM {
+    private ctx;
+    machine: SyncStateMachine<Platformer2DState, Platformer2DEvent, never>;
+    constructor(ctx: Platformer2DContext);
+    getState(): Platformer2DState;
+    dispatch(event: Platformer2DEvent): void;
+    isGrounded(): boolean;
+    getJumpCount(): number;
+    /**
+     * Update FSM based on current component state.
+     */
+    update(input: Platformer2DInputComponent, state: Platformer2DStateComponent): void;
+}
+
+/**
+ * Platformer 2D System
+ *
+ * Kinematic character controller (SNES-style) on the X/Y plane: the
+ * controller owns all motion and physics is only a collision database.
+ *
+ * - The entity's body is converted to `KinematicPositionBased` on first
+ *   update; Rapier never applies forces to it.
+ * - Each tick, desired displacement (X input + integrated vertical velocity,
+ *   z locked to 0) is run through Rapier's `KinematicCharacterController`
+ *   (collide-and-slide with autostep, slope limits, and snap-to-ground) and
+ *   the corrected movement is applied via `setNextKinematicTranslation`. The
+ *   z coordinate is re-pinned to its first-seen value every tick so slide
+ *   resolution can never drift the entity off the 2D plane.
+ * - Grounded comes from `controller.computedGrounded()` — no contact-pair or
+ *   raycast probing.
+ * - Vertical velocity lives in `state.verticalVelocity` (`linvel()` is
+ *   meaningless on kinematic bodies). Jump buffering, coyote time,
+ *   multi-jump, and the jump-cut ramp all operate on that field.
+ */
+
+/**
+ * Entity with 2D platformer components
+ */
+interface Platformer2DEntity {
+    uuid: string;
+    body: RigidBody;
+    collider?: Collider | null;
+    platformer2D: Platformer2DMovementComponent;
+    $platformer2D: Platformer2DInputComponent;
+    platformer2DState: Platformer2DStateComponent;
+}
+/**
+ * Platformer 2D movement system.
+ *
+ * Core kinematic controller for 2D platformer movement. Requires a live
+ * `ZylemWorld` with the raw Rapier `World` exposed on `.world` — without it
+ * the system is a no-op.
+ */
+declare class Platformer2DSystem {
+    private world;
+    /** Per-entity character controllers, keyed by entity uuid. */
+    private controllers;
+    /** Spawn-time z per entity; re-pinned every tick to hold the 2D plane. */
+    private planeZ;
+    constructor(world: ZylemWorld | null);
+    /**
+     * One-time per-entity physics setup: convert the body to a
+     * position-based kinematic body, record the plane z, and create the
+     * entity's character controller. Done lazily on the first update because
+     * the body isn't always available at construction time.
+     */
+    private ensurePhysicsConfigured;
+    /**
+     * Handle jump logic with multi-jump, coyote time, buffering, and jump-cut
+     * ramp. All vertical motion is written to `state.verticalVelocity`.
+     */
+    private handleJump;
+    /**
+     * Integrate gravity into `state.verticalVelocity`.
+     *
+     * While grounded (and not on the jump frame) vertical velocity is held at
+     * a small constant downward speed so the controller stays pressed into
+     * the ground. Skipped entirely on the frame a jump was applied — the
+     * grounded flag is still stale-true then and would clobber the jump.
+     */
+    private applyGravity;
+    /**
+     * Update entity state from the controller's grounded result.
+     */
+    private updateState;
+    /**
+     * Update one platformer entity. Invoked per linked entity by the
+     * Platformer2DBehaviorSystem adapter.
+     */
+    updateEntity(entity: Platformer2DEntity, delta: number): void;
+    destroy(): void;
+}
+
+/**
+ * Platformer 2D behavior options (typed for entity.use() autocomplete)
+ */
+interface Platformer2DBehaviorOptions {
+    /** Base walking speed (default: 8) */
+    walkSpeed?: number;
+    /** Sprint/run speed (default: 14) */
+    runSpeed?: number;
+    /** Initial jump force (default: 12) */
+    jumpForce?: number;
+    /** Maximum number of jumps (default: 1) */
+    maxJumps?: number;
+    /** Gravity force (default: 20) */
+    gravity?: number;
+    /** Coyote time in seconds (default: 0.1) */
+    coyoteTime?: number;
+    /** Jump buffer time in seconds (default: 0.1) */
+    jumpBufferTime?: number;
+    /** Velocity multiplier when releasing jump early (default: 0.5) */
+    jumpCutMultiplier?: number;
+    /** Maximum slope angle in degrees the character can walk up (default: 50) */
+    slopeClimbAngle?: number;
+    /** Slope angle in degrees past which the character slides (default: 40) */
+    slopeSlideAngle?: number;
+    /** Autostep over small step-ups, or false to disable (default: { maxHeight: 0.25, minWidth: 0.05 }) */
+    autostep?: {
+        maxHeight: number;
+        minWidth: number;
+    } | false;
+    /** Snap-to-ground distance for downhill/step-down stability (default: 0.2) */
+    snapToGroundDistance?: number;
+    /** Character controller collision offset (default: 0.05) */
+    characterOffset?: number;
+}
+/**
+ * Platformer2DBehavior - typed descriptor for 2D platformer movement
+ *
+ * Provides complete 2D platformer physics on the X/Y plane including:
+ * - Walking and running on X
+ * - Jumping with buffer, coyote time, multi-jump, and jump-cut
+ * - Gravity ownership and falling
+ * - Kinematic character controller (collide-and-slide, autostep, snap-to-ground)
+ *
+ * @example
+ * ```typescript
+ * import { Platformer2DBehavior } from "@zylem/behaviors/platformer-2d";
+ *
+ * const platformer = player.use(Platformer2DBehavior, {
+ *   walkSpeed: 8,
+ *   runSpeed: 14,
+ *   jumpForce: 12,
+ *   maxJumps: 2, // Double jump!
+ * });
+ *
+ * // In update loop
+ * player.onUpdate(({ inputs }) => {
+ *   player.$platformer2D.moveX = inputs.p1.axes.Horizontal.value;
+ *   player.$platformer2D.jump = inputs.p1.buttons.A.held > 0;
+ *   player.$platformer2D.run = inputs.p1.shoulders.LTrigger.held > 0;
+ *
+ *   const state = platformer.getState();
+ *   const grounded = platformer.isGrounded();
+ * });
+ * ```
+ */
+declare const Platformer2DBehavior: BehaviorDescriptor<Platformer2DBehaviorOptions, {
+    getState: () => Platformer2DState;
+    isGrounded: () => boolean;
+    getJumpCount: () => number;
+}, Platformer2DEntity>;
+
+export { Platformer2DBehavior, type Platformer2DBehaviorOptions, type Platformer2DCollisionContext, type Platformer2DContext, type Platformer2DEntity, Platformer2DEvent, Platformer2DFSM, type Platformer2DInputComponent, type Platformer2DMovementComponent, Platformer2DState, type Platformer2DStateComponent, Platformer2DSystem, createPlatformer2DInputComponent, createPlatformer2DMovementComponent, createPlatformer2DStateComponent };

package/dist/platformer-2d.js

@@ -0,0 +1,23 @@
+import {
+  Platformer2DBehavior,
+  Platformer2DEvent,
+  Platformer2DFSM,
+  Platformer2DState,
+  Platformer2DSystem,
+  createPlatformer2DInputComponent,
+  createPlatformer2DMovementComponent,
+  createPlatformer2DStateComponent
+} from "./chunk-RTRFJVCZ.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  Platformer2DBehavior,
+  Platformer2DEvent,
+  Platformer2DFSM,
+  Platformer2DState,
+  Platformer2DSystem,
+  createPlatformer2DInputComponent,
+  createPlatformer2DMovementComponent,
+  createPlatformer2DStateComponent
+};
+//# sourceMappingURL=platformer-2d.js.map

package/dist/platformer-3d.d.ts

@@ -1,5 +1,6 @@
 import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
-import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { RigidBody, Collider } from '@dimforge/rapier3d-compat';
+import { Z as ZylemWorld, a as BehaviorDescriptor } from './behavior-system-DSNek0W9.js';
 import 'typescript-fsm';
 
 /**
@@ -19,8 +20,6 @@ interface Platformer3DMovementComponent {
     maxJumps: number;
     /** Gravity force (optional override) */
     gravity: number;
-    /** Ray length for ground detection */
-    groundRayLength: number;
     /** Coyote time in seconds (grace period after leaving ground) */
     coyoteTime: number;
     /** Jump buffer time in seconds (queue jump input before landing) */
@@ -29,8 +28,19 @@ interface Platformer3DMovementComponent {
     jumpCutMultiplier: number;
     /** Time in seconds before multi-jump becomes available (0 = after button release) */
     multiJumpWindowTime: number;
-    /** Enable ground-ray debug visualization */
-    debugGroundProbe: boolean;
+    /** Maximum slope angle (degrees) the character can walk up */
+    slopeClimbAngle: number;
+    /** Slope angle (degrees) past which the character slides down */
+    slopeSlideAngle: number;
+    /** Autostep configuration for small ledges, or false to disable */
+    autostep: {
+        maxHeight: number;
+        minWidth: number;
+    } | false;
+    /** Snap-to-ground distance (keeps the character glued going downhill) */
+    snapToGroundDistance: number;
+    /** Character controller offset (small gap kept between collider and environment) */
+    characterOffset: number;
 }
 declare function createPlatformer3DMovementComponent(options?: Partial<Platformer3DMovementComponent>): Platformer3DMovementComponent;
 interface Platformer3DInputComponent {
@@ -81,10 +91,14 @@ interface Platformer3DStateComponent {
     timeSinceJump: number;
     /** True for the single frame on which a jump impulse was applied; prevents gravity from clobbering jump velocity. */
     jumpedThisFrame: boolean;
-    /** Remaining seconds of jump-cut velocity ramp; while > 0, velocity.y lerps toward velocity.y * jumpCutMultiplier. */
+    /** Remaining seconds of jump-cut velocity ramp; while > 0, verticalVelocity lerps toward verticalVelocity * jumpCutMultiplier. */
     jumpCutRampTimer: number;
-    /** Remaining seconds of grounded-hysteresis grace (keeps `grounded` true briefly after ground probe misses, to absorb edge/ray flicker). */
-    groundedGraceTimer: number;
+    /**
+     * Controller-owned vertical velocity (units/second).
+     * The body is kinematic, so `linvel()` is meaningless — this field is the
+     * single source of truth for jump/gravity motion on the Y axis.
+     */
+    verticalVelocity: number;
 }
 declare function createPlatformer3DStateComponent(): Platformer3DStateComponent;
 
@@ -175,18 +189,22 @@ declare class Platformer3DFSM {
 }
 
 /**
- * Platformer 3D Behavior System
+ * Platformer 3D System
  *
- * Handles 3D platformer physics including:
- * - Contact-based ground detection (uses the actual capsule collider — no
- *   raycast/shapecast probe). The bottom of the body's collider is the
- *   single source of truth for "is grounded".
- * - Horizontal movement (walk/run)
- * - Jumping with multi-jump support
- * - Gravity application (Rapier's internal gravity is disabled per-body so
- *   `movement.gravity` is the only fall acceleration — previously the two
- *   stacked, doubling the airborne fall rate).
- * - State synchronization with FSM
+ * Kinematic character controller (N64-style): the controller owns all motion
+ * and physics is only a collision database.
+ *
+ * - The entity's body is converted to `KinematicPositionBased` on first
+ *   update; Rapier never applies forces to it.
+ * - Each tick, desired displacement (horizontal input + integrated vertical
+ *   velocity) is run through Rapier's `KinematicCharacterController`
+ *   (collide-and-slide with autostep, slope limits, and snap-to-ground) and
+ *   the corrected movement is applied via `setNextKinematicTranslation`.
+ * - Grounded comes from `controller.computedGrounded()` — no contact-pair or
+ *   raycast probing.
+ * - Vertical velocity lives in `state.verticalVelocity` (`linvel()` is
+ *   meaningless on kinematic bodies). Jump buffering, coyote time,
+ *   multi-jump, and the jump-cut ramp all operate on that field.
  */
 
 /**
@@ -194,94 +212,54 @@ declare class Platformer3DFSM {
  */
 interface Platformer3DEntity {
     uuid: string;
-    body: any;
+    body: RigidBody;
+    collider?: Collider | null;
     platformer: Platformer3DMovementComponent;
     $platformer: Platformer3DInputComponent;
     platformerState: Platformer3DStateComponent;
-    transformStore?: any;
 }
 /**
- * Platformer 3D Movement Behavior
+ * Platformer 3D movement system.
  *
- * Core physics system for 3D platformer movement.
- *
- * Ground detection uses Rapier's narrow-phase contacts on the entity's
- * collider (`world.contactsWith` + `contactPair`). This eliminates the old
- * shape/ray probe and aligns "grounded" with the same surface the body
- * physically rests on, which removes the jitter that happened on heightmap
- * terrain (the probe and the contact resolver could disagree by a frame).
+ * Core kinematic controller for 3D platformer movement. Requires a live
+ * `ZylemWorld` with the raw Rapier `World` exposed on `.world` — without it
+ * the system is a no-op (the WASM fast path handles that case upstream).
  */
-declare class Platformer3DBehavior$1 {
+declare class Platformer3DSystem {
     private world;
-    private scene;
-    /**
-     * Tracks entities whose Rapier `gravityScale` has been zeroed so that
-     * `applyGravity` is the sole writer of vertical velocity. We do this
-     * lazily on the first update because the body isn't always available at
-     * construction time.
-     */
-    private gravityConfiguredUUIDs;
-    constructor(world: any, scene: any);
+    /** Per-entity character controllers, keyed by entity uuid. */
+    private controllers;
+    constructor(world: ZylemWorld | null);
     /**
-     * Detect "grounded" using the actual capsule collider's contact pairs.
-     *
-     * A contact is treated as ground when its solver point lies below the
-     * body center (i.e., it sits on the bottom hemisphere/cylinder). We
-     * deliberately don't filter by normal direction: the contact point's
-     * position alone is robust against the various normal-flip conventions
-     * Rapier uses for `flipped` manifolds and against rolling-bottom edges
-     * on heightmap terrain.
-     */
-    private detectGroundedFromContacts;
-    /**
-     * One-time per-entity physics setup: take over gravity from Rapier's
-     * world so that `applyGravity` controls the entire airborne fall curve.
-     * Without this, gravity was effectively doubled (Rapier's world gravity
-     * + this behavior's explicit gravity were both pulling the body down).
+     * One-time per-entity physics setup: convert the body to a
+     * position-based kinematic body and create its character controller.
+     * Done lazily on the first update because the body isn't always
+     * available at construction time.
      */
     private ensurePhysicsConfigured;
     /**
-     * Apply horizontal movement based on input.
-     *
-     * Only writes X/Z axes — Y is left untouched so Rapier's contact resolution
-     * can damp vertical motion correctly while grounded. Jump and gravity are
-     * the sole writers of Y velocity (see handleJump / applyGravity).
-     */
-    private applyMovement;
-    /**
-     * Handle jump logic with multi-jump, coyote time, buffering, and jump-cut ramp.
+     * Handle jump logic with multi-jump, coyote time, buffering, and jump-cut
+     * ramp. All vertical motion is written to `state.verticalVelocity`.
      */
     private handleJump;
     /**
-     * Apply gravity when not grounded.
+     * Integrate gravity into `state.verticalVelocity`.
      *
-     * Skipped on the single frame immediately after a jump impulse is applied
-     * (tracked via `state.jumpedThisFrame`) so gravity never overwrites a
-     * just-applied jump velocity. The flag is cleared here regardless, so it
-     * only suppresses exactly one gravity step — independent of frame rate.
+     * While grounded (and not on the jump frame) vertical velocity is held at
+     * a small constant downward speed so the controller stays pressed into
+     * the ground. Skipped entirely on the frame a jump was applied — the
+     * grounded flag is still stale-true then and would clobber the jump.
      */
     private applyGravity;
     /**
-     * Update entity state based on physics.
-     *
-     * Grounded is determined purely by Rapier's contact pairs on the entity's
-     * collider. This removes a whole class of slope/heightmap jitter caused
-     * by the previous shape probe disagreeing with the contact resolver — the
-     * probe could report grounded while a contact impulse had just nudged the
-     * body off the ground, producing visible micro-bouncing.
-     *
-     * While grounded, vertical velocity is held at 0 each frame. This stops
-     * residual upward kicks from slope-contact resolution from accumulating
-     * across frames (which previously caused the character to "ride up"
-     * slopes and lose contact briefly, then fall back, then re-contact, in a
-     * tight oscillation).
+     * Update entity state from the controller's grounded result.
      */
     private updateState;
     /**
      * Update one platformer entity. Invoked per linked entity by the
      * Platformer3DBehaviorSystem adapter.
      */
-    updateEntity(entity: any, delta: number): void;
+    updateEntity(entity: Platformer3DEntity, delta: number): void;
     destroy(): void;
 }
 
@@ -299,10 +277,19 @@ interface Platformer3DBehaviorOptions {
     maxJumps?: number;
     /** Gravity force (default: 9.82) */
     gravity?: number;
-    /** Ray length for ground detection (default: 1.0) */
-    groundRayLength?: number;
-    /** Enable debug visualization for ground probe rays (default: false) */
-    debugGroundProbe?: boolean;
+    /** Maximum slope angle in degrees the character can walk up (default: 50) */
+    slopeClimbAngle?: number;
+    /** Slope angle in degrees past which the character slides (default: 40) */
+    slopeSlideAngle?: number;
+    /** Autostep over small ledges, or false to disable (default: { maxHeight: 0.3, minWidth: 0.1 }) */
+    autostep?: {
+        maxHeight: number;
+        minWidth: number;
+    } | false;
+    /** Snap-to-ground distance for downhill/step-down stability (default: 0.3) */
+    snapToGroundDistance?: number;
+    /** Character controller collision offset (default: 0.05) */
+    characterOffset?: number;
 }
 /**
  * Platformer3DBehavior - typed descriptor for 3D platformer movement
@@ -344,4 +331,4 @@ declare const Platformer3DBehavior: BehaviorDescriptor<Platformer3DBehaviorOptio
     onPlatformCollision: (ctx: PlatformerCollisionContext) => void;
 }, Platformer3DEntity>;
 
-export { Platformer3DBehavior, type Platformer3DBehaviorOptions, type Platformer3DContext, type Platformer3DEntity, Platformer3DEvent, Platformer3DFSM, type Platformer3DInputComponent, Platformer3DBehavior$1 as Platformer3DMovementBehavior, type Platformer3DMovementComponent, Platformer3DState, type Platformer3DStateComponent, type PlatformerCollisionContext, createPlatformer3DInputComponent, createPlatformer3DMovementComponent, createPlatformer3DStateComponent };
+export { Platformer3DBehavior, type Platformer3DBehaviorOptions, type Platformer3DContext, type Platformer3DEntity, Platformer3DEvent, Platformer3DFSM, type Platformer3DInputComponent, type Platformer3DMovementComponent, Platformer3DState, type Platformer3DStateComponent, Platformer3DSystem, type PlatformerCollisionContext, createPlatformer3DInputComponent, createPlatformer3DMovementComponent, createPlatformer3DStateComponent };

package/dist/platformer-3d.js

@@ -1,21 +1,21 @@
 import {
   Platformer3DBehavior,
-  Platformer3DBehavior2,
   Platformer3DEvent,
   Platformer3DFSM,
   Platformer3DState,
+  Platformer3DSystem,
   createPlatformer3DInputComponent,
   createPlatformer3DMovementComponent,
   createPlatformer3DStateComponent
-} from "./chunk-JAN34G6S.js";
+} from "./chunk-FRJDQM23.js";
 import "./chunk-4URF65BR.js";
 import "./chunk-EZNCCO4L.js";
 export {
-  Platformer3DBehavior2 as Platformer3DBehavior,
+  Platformer3DBehavior,
   Platformer3DEvent,
   Platformer3DFSM,
-  Platformer3DBehavior as Platformer3DMovementBehavior,
   Platformer3DState,
+  Platformer3DSystem,
   createPlatformer3DInputComponent,
   createPlatformer3DMovementComponent,
   createPlatformer3DStateComponent

package/dist/ricochet-2d.d.ts

@@ -1,6 +1,6 @@
 import { B as BaseEntityInterface } from './entity-types-CmtQ-IBp.js';
 import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
-import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { a as BehaviorDescriptor } from './behavior-system-DSNek0W9.js';
 import 'three';
 import '@dimforge/rapier3d-compat';
 import 'typescript-fsm';

package/dist/ricochet-2d.js

@@ -3,8 +3,8 @@ import {
   Ricochet2DEvent,
   Ricochet2DFSM,
   Ricochet2DState
-} from "./chunk-KOZUNIIE.js";
-import "./chunk-Y6UJOUE5.js";
+} from "./chunk-V74N7D6Q.js";
+import "./chunk-4V7TIRO2.js";
 import "./chunk-4URF65BR.js";
 import "./chunk-EZNCCO4L.js";
 export {

package/dist/ricochet-3d.d.ts

@@ -1,6 +1,6 @@
 import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
 import { B as BaseEntityInterface } from './entity-types-CmtQ-IBp.js';
-import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { a as BehaviorDescriptor } from './behavior-system-DSNek0W9.js';
 import 'typescript-fsm';
 import 'three';
 import '@dimforge/rapier3d-compat';

package/dist/ricochet-3d.js

@@ -3,8 +3,8 @@ import {
   Ricochet3DEvent,
   Ricochet3DFSM,
   Ricochet3DState
-} from "./chunk-ARJWUNRE.js";
-import "./chunk-Y6UJOUE5.js";
+} from "./chunk-XLUJDKCT.js";
+import "./chunk-4V7TIRO2.js";
 import "./chunk-4URF65BR.js";
 import "./chunk-EZNCCO4L.js";
 export {