@zylem/behaviors 0.3.1 → 0.4.1

package/dist/behavior-system-y8SGrGWy.d.ts

@@ -0,0 +1,580 @@
+import { RigidBody, Collider, World } from '@dimforge/rapier3d-compat';
+
+/**
+ * BehaviorDescriptor
+ *
+ * Type-safe behavior descriptors that provide options inference.
+ * Used with entity.use() to declaratively attach behaviors to entities.
+ *
+ * Each behavior can define its own handle type via `createHandle`,
+ * providing behavior-specific methods with full type safety.
+ */
+
+/**
+ * Base handle returned by entity.use() for lazy access to behavior runtime.
+ * FSM is null until entity is spawned and components are initialized.
+ */
+interface BaseBehaviorHandle<O extends Record<string, any> = Record<string, any>> {
+    /** Get the FSM instance (null until entity is spawned) */
+    getFSM(): any | null;
+    /** Get the current options */
+    getOptions(): O;
+    /** Access the underlying behavior ref */
+    readonly ref: BehaviorRef<O>;
+}
+/**
+ * Reference to a behavior stored on an entity
+ */
+interface BehaviorRef<O extends Record<string, any> = Record<string, any>> {
+    /** The behavior descriptor */
+    descriptor: BehaviorDescriptor<O, any>;
+    /** Merged options (defaults + overrides) */
+    options: O;
+    /** Optional FSM instance - set lazily when entity is spawned */
+    fsm?: any;
+}
+/**
+ * A typed behavior descriptor that associates a symbol key with:
+ * - Default options (providing type inference)
+ * - A system factory to create the behavior system
+ * - An optional handle factory for behavior-specific methods
+ */
+interface BehaviorDescriptor<O extends Record<string, any> = Record<string, any>, H extends Record<string, any> = Record<string, never>, I = unknown> {
+    /** Unique symbol identifying this behavior */
+    readonly key: symbol;
+    /** Default options (used for type inference) */
+    readonly defaultOptions: O;
+    /** Factory to create the behavior system */
+    readonly systemFactory: any;
+    /**
+     * Optional factory to create behavior-specific handle methods.
+     * These methods are merged into the handle returned by entity.use().
+     */
+    readonly createHandle?: (ref: any) => H;
+}
+/**
+ * The full handle type returned by entity.use().
+ * Combines base handle with behavior-specific methods.
+ */
+type BehaviorHandle<O extends Record<string, any> = Record<string, any>, H extends Record<string, any> = Record<string, never>> = BaseBehaviorHandle<O> & H;
+/**
+ * Configuration for defining a new behavior
+ */
+interface DefineBehaviorConfig<O extends Record<string, any>, H extends Record<string, any> = Record<string, never>, I = unknown> {
+    /** Human-readable name for debugging */
+    name: string;
+    /** Default options - these define the type */
+    defaultOptions: O;
+    /** Factory function to create the system */
+    systemFactory: BehaviorSystemFactory;
+    /**
+     * Optional factory to create behavior-specific handle methods.
+     * The returned object is merged into the handle returned by entity.use().
+     *
+     * @example
+     * ```typescript
+     * createHandle: (ref) => ({
+     *   getLastHits: () => ref.fsm?.getLastHits() ?? null,
+     *   getMovement: (moveX, moveY) => ref.fsm?.getMovement(moveX, moveY) ?? { moveX, moveY },
+     * }),
+     * ```
+     */
+    createHandle?: (ref: BehaviorRef<O>) => H;
+}
+/**
+ * Define a typed behavior descriptor.
+ *
+ * @example
+ * ```typescript
+ * export const WorldBoundary2DBehavior = defineBehavior({
+ *   name: 'world-boundary-2d',
+ *   defaultOptions: { boundaries: { top: 0, bottom: 0, left: 0, right: 0 } },
+ *   systemFactory: (ctx) => new WorldBoundary2DSystem(ctx.world),
+ *   createHandle: (ref) => ({
+ *     getLastHits: () => ref.fsm?.getLastHits() ?? null,
+ *     getMovement: (moveX: number, moveY: number) =>
+ *       ref.fsm?.getMovement(moveX, moveY) ?? { moveX, moveY },
+ *   }),
+ * });
+ *
+ * // Usage - handle has getLastHits and getMovement with full types
+ * const boundary = ship.use(WorldBoundary2DBehavior, { ... });
+ * const hits = boundary.getLastHits(); // Fully typed!
+ * ```
+ */
+declare function defineBehavior<O extends Record<string, any>, H extends Record<string, any> = Record<string, never>, I = unknown>(config: DefineBehaviorConfig<O, H, I>): BehaviorDescriptor<O, H, I>;
+
+type VelocityIntentMode = 'replace' | 'add';
+interface VelocityIntent {
+    x?: number;
+    y?: number;
+    z?: number;
+    mode: VelocityIntentMode;
+    priority?: number;
+}
+/**
+ * Transform state managed by Valtio for batched physics updates.
+ *
+ * This store accumulates transformation intents during the frame,
+ * then applies them all at once after onUpdate() callbacks complete.
+ *
+ * Design decisions:
+ * - Position: Accumulated deltas (additive)
+ * - Rotation: Last value wins (replacement)
+ * - Velocity: Accumulated deltas (additive)
+ * - Angular velocity: Accumulated deltas (additive)
+ */
+interface TransformState {
+    /** Position deltas to be applied (accumulated) */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Rotation quaternion (last value wins) */
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    /** Linear velocity (accumulated) */
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Angular velocity (accumulated) */
+    angularVelocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Per-source velocity intents composed once per frame */
+    velocityChannels: Record<string, VelocityIntent>;
+    /** Dirty flags to track what needs to be applied */
+    dirty: {
+        position: boolean;
+        rotation: boolean;
+        velocityX: boolean;
+        velocityY: boolean;
+        velocityZ: boolean;
+        velocityChannels: boolean;
+        angularVelocity: boolean;
+    };
+}
+/**
+ * Create a new transform store with optional initial values.
+ * The store is a Valtio proxy, making it reactive for debugging/visualization.
+ *
+ * @param initial Optional initial state values
+ * @returns Reactive transform state
+ */
+declare function createTransformStore(initial?: Partial<TransformState>): TransformState;
+
+/**
+ * Minimal, runtime-agnostic entity options contract.
+ *
+ * The full engine entity (in `@zylem/game-lib`) provides a richer options type,
+ * but behaviors only rely on this loose shape.
+ */
+interface GameEntityOptions {
+    [key: string]: any;
+    name?: string;
+}
+/**
+ * Structural stand-in for the engine `GameEntity`.
+ *
+ * Behaviors annotate against this loose contract so that `@zylem/behaviors`
+ * (and its `@zylem/behaviors/core` surface) never has to depend on the concrete
+ * `@zylem/game-lib` entity implementation. The real engine entity is
+ * structurally assignable to this type.
+ */
+declare class GameEntity<TOptions = unknown> {
+    [key: string]: any;
+    uuid: string;
+    name: string;
+    type: string;
+    options?: TOptions & Record<string, unknown>;
+    group: any;
+    mesh?: any;
+    materials?: any[];
+    body: RigidBody | null;
+    collider: Collider | null;
+    colliderDesc?: any;
+    colliderDescs: any[];
+    bodyDesc?: any;
+    physicsAttached: boolean;
+    runtimeHandle?: number;
+    transformStore?: TransformState;
+    nodeDestroy?: any;
+    isInstanced?: boolean;
+    private __behaviorRefs;
+    create(): this;
+    onCleanup(callback: () => void): this;
+    setPosition(_x: number, _y: number, _z: number): void;
+    setRotation(_x: number, _y: number, _z: number): void;
+    setRotationZ(_z: number): void;
+    setScale(_x: number, _y: number, _z: number): void;
+    /**
+     * Attach a behavior to this entity. The real engine entity does substantially
+     * more, but this functional stub stores the merged ref and builds the handle
+     * so descriptor/handle logic (and tests that drive behaviors directly) work
+     * without the full engine.
+     */
+    use<O extends Record<string, any>, H extends Record<string, any> = Record<string, never>>(descriptor: BehaviorDescriptor<O, H>, options?: Partial<O>): BehaviorHandle<O, H>;
+    /** Live behavior refs attached via {@link use}. */
+    getBehaviorRefs(): BehaviorRef<any>[];
+}
+/**
+ * Factory contract injected into behavior systems via
+ * {@link BehaviorSystemContext.createEntity}. The host engine supplies the real
+ * entity factory at stage-construction time.
+ */
+type CreateEntityFn = (options?: Partial<GameEntityOptions>) => GameEntity<GameEntityOptions>;
+
+declare const StageBodyKind: {
+    readonly Dynamic: 0;
+    readonly Static: 1;
+    readonly KinematicPosition: 2;
+    readonly KinematicVelocity: 3;
+};
+declare const StageBoundaryDim: {
+    readonly Two: 2;
+    readonly Three: 3;
+};
+declare const StageRicochetDim: {
+    readonly Two: 2;
+    readonly Three: 3;
+};
+declare const StageRicochetReflection: {
+    readonly Mirror: 0;
+    readonly Angled: 1;
+};
+declare const StageTopDownPlane: {
+    readonly Xy: 0;
+    readonly Xz: 1;
+};
+declare const StageEventType: {
+    readonly CollisionStarted: 1;
+    readonly CollisionStopped: 2;
+    readonly BoundaryHit: 3;
+    readonly Ricochet: 4;
+    readonly RegionEntered: 5;
+    readonly JumpStarted: 6;
+    readonly Landed: 7;
+    readonly Wrapped: 8;
+    readonly CooldownFired: 9;
+};
+type StageBoundaryDimValue = (typeof StageBoundaryDim)[keyof typeof StageBoundaryDim];
+type StageRicochetDimValue = (typeof StageRicochetDim)[keyof typeof StageRicochetDim];
+type StageRicochetReflectionValue = (typeof StageRicochetReflection)[keyof typeof StageRicochetReflection];
+type StageTopDownPlaneValue = (typeof StageTopDownPlane)[keyof typeof StageTopDownPlane];
+/** Position + rotation snapshot for one runtime slot. */
+interface StagePose {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+}
+interface StageWorldBoundaryOptions {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    front?: number;
+    back?: number;
+    padding?: number;
+}
+interface StageScreenWrapOptions {
+    width: number;
+    height: number;
+    centerX?: number;
+    centerY?: number;
+    edgeThreshold?: number;
+}
+interface StageRicochetOptions {
+    minSpeed: number;
+    maxSpeed: number;
+    speedMultiplier: number;
+    maxAngleDeg: number;
+    reflectionMode: StageRicochetReflectionValue;
+}
+interface StageThrusterOptions {
+    maxSpeed: number;
+    acceleration: number;
+    turnRateRadPerSec: number;
+    linearDamping: number;
+}
+interface StageTopDownOptions {
+    plane: StageTopDownPlaneValue;
+    speed: number;
+    faceMovement?: boolean;
+}
+interface StageShooter2DOptions {
+    fireRateHz: number;
+    muzzleOffsetX: number;
+    muzzleOffsetY: number;
+    muzzleSpeed: number;
+}
+interface StageJumper2DOptions {
+    jumpForce: number;
+    maxJumps: number;
+    jumpBufferTime: number;
+    coyoteTime: number;
+    gravity: number;
+}
+interface StageJumper3DOptions {
+    jumpForce: number;
+    maxJumps: number;
+    gravity: number;
+    /** Coyote time in seconds (default 0.1). */
+    coyoteTime?: number;
+    /** Jump buffer window in seconds (default 0.08). */
+    jumpBufferTime?: number;
+}
+interface StagePlatformer3DOptions {
+    halfHeight: number;
+    radius: number;
+    walkSpeed: number;
+    runSpeed: number;
+    jumpForce: number;
+    maxJumps: number;
+    gravity: number;
+    /** Coyote time in seconds (default 0.1). */
+    coyoteTime?: number;
+    /** Jump buffer window in seconds (default 0.1). */
+    jumpBufferTime?: number;
+    /** Velocity multiplier applied on early jump release (default 0.5). */
+    jumpCutMultiplier?: number;
+    /** Seconds before a multi-jump becomes available (default 0.15). */
+    multiJumpWindow?: number;
+    /** Max slope angle in degrees the KCC can climb (default 50). */
+    slopeClimbAngle?: number;
+    /** Slope angle in degrees past which the character slides (default 40). */
+    slopeSlideAngle?: number;
+    /** Autostep max height in world units; 0 disables (default 0.3). */
+    autostepHeight?: number;
+    /** Minimum unobstructed width for an autostep (default 0.1). */
+    autostepMinWidth?: number;
+    /** Snap-to-ground distance in world units; 0 disables (default 0.3). */
+    snapToGroundDistance?: number;
+    /** KCC collision offset between collider and environment (default 0.05). */
+    characterOffset?: number;
+}
+interface StagePlatformer2DOptions {
+    halfHeight: number;
+    radius: number;
+    walkSpeed: number;
+    runSpeed: number;
+    jumpForce: number;
+    maxJumps: number;
+    gravity: number;
+    /** Coyote time in seconds (default 0.1). */
+    coyoteTime?: number;
+    /** Jump buffer window in seconds (default 0.1). */
+    jumpBufferTime?: number;
+    /** Velocity multiplier applied on early jump release (default 0.5). */
+    jumpCutMultiplier?: number;
+    /** Seconds before a multi-jump becomes available (default 0.15). */
+    multiJumpWindow?: number;
+    /** Max slope angle in degrees the KCC can climb (default 50). */
+    slopeClimbAngle?: number;
+    /** Slope angle in degrees past which the character slides (default 40). */
+    slopeSlideAngle?: number;
+    /** Autostep max height in world units; 0 disables (default 0.25). */
+    autostepHeight?: number;
+    /** Minimum unobstructed width for an autostep (default 0.05). */
+    autostepMinWidth?: number;
+    /** Snap-to-ground distance in world units; 0 disables (default 0.2). */
+    snapToGroundDistance?: number;
+    /** KCC collision offset between collider and environment (default 0.05). */
+    characterOffset?: number;
+}
+interface StageFirstPersonOptions {
+    walkSpeed: number;
+    runSpeed: number;
+    eyeHeight: number;
+    lookSensitivity: number;
+}
+interface StageFirstPersonInput {
+    moveX: number;
+    moveZ: number;
+    lookYawDelta: number;
+    lookPitchDelta: number;
+    run: boolean;
+}
+/** Button bits for the batched input buffer's bitmask field. */
+declare const STAGE_INPUT_BUTTON_JUMP = 1;
+declare const STAGE_INPUT_BUTTON_RUN = 2;
+/**
+ * Decoded per-slot behavior snapshot written by the runtime after every
+ * step: movement fields come from whichever character behavior the entity
+ * has (platformer 3D/2D, jumper 3D/2D); first-person fills yaw/pitch.
+ * Values reflect the end of the previous `step()` (one-frame read lag).
+ */
+interface StageBehaviorSnapshot {
+    grounded: boolean;
+    fsmState: number;
+    jumpCount: number;
+    verticalVelocity: number;
+    speed: number;
+    yaw: number;
+    pitch: number;
+}
+/**
+ * Wasm fast-path backrefs a behavior system stores on its `BehaviorRef` every
+ * frame so descriptor handles can read the runtime snapshot buffer instead of
+ * a duplicate TS FSM (or hardcoded defaults).
+ */
+interface WasmSnapshotBackref {
+    __wasmStage?: WasmStageRuntime | null;
+    __entity?: {
+        runtimeHandle?: number;
+    } | null;
+}
+/**
+ * Read the behavior snapshot for the entity a `BehaviorRef` is linked to.
+ * Returns `null` off the wasm fast path (no stage runtime / no
+ * `runtimeHandle` / no snapshot yet), in which case handles should fall back
+ * to their TS FSM.
+ */
+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.
+ */
+interface WasmStageRuntime {
+    getPose(handle: number, out?: StagePose): StagePose | null;
+    writeInputAxes(handle: number, axisA: number, axisB: number): boolean;
+    writeInputLook(handle: number, yawDelta: number, pitchDelta: 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;
+    attachTopDown(handle: number, opts: StageTopDownOptions): boolean;
+    setTopDownInput(handle: number, moveX: number, moveY: number): void;
+    attachShooter2D(handle: number, opts: StageShooter2DOptions): boolean;
+    attachScreenWrap(handle: number, opts: StageScreenWrapOptions): boolean;
+    queryScreenWrap(handle: number): {
+        fsm: number;
+        lastWrappedAxes: number;
+    } | null;
+    attachWorldBoundary(handle: number, dim: StageBoundaryDimValue, opts: StageWorldBoundaryOptions): boolean;
+    queryWorldBoundary(handle: number): {
+        hits: number;
+        clamped: [number, number, number];
+    } | null;
+    attachRicochet(handle: number, dim: StageRicochetDimValue, opts: StageRicochetOptions): boolean;
+    attachPlatformer3D(handle: number, opts: StagePlatformer3DOptions): boolean;
+    setPlatformer3DInputAxes(handle: number, moveX: number, moveZ: number): void;
+    setPlatformer3DInputButtons(handle: number, jump: boolean, run: boolean): void;
+    attachPlatformer2D(handle: number, opts: StagePlatformer2DOptions): boolean;
+    setPlatformer2DInputAxes(handle: number, moveX: number): void;
+    setPlatformer2DInputButtons(handle: number, jump: boolean, run: boolean): void;
+    attachFirstPerson(handle: number, opts: StageFirstPersonOptions): boolean;
+    setFirstPersonInput(handle: number, input: StageFirstPersonInput): void;
+    attachJumper2D(handle: number, opts: StageJumper2DOptions): boolean;
+    setJumper2DInput(handle: number, jumpPressed: boolean): void;
+    attachJumper3D(handle: number, opts: StageJumper3DOptions): boolean;
+    setJumper3DInput(handle: number, jumpPressed: boolean): void;
+}
+/** Default options used when constructing a wasm-backed Stage runtime. */
+interface WasmStageRuntimeOptions {
+    initialCapacity?: number;
+    gravity?: readonly [number, number, number];
+    imports?: WebAssembly.Imports;
+}
+
+/**
+ * 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.
+ *
+ * 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>;
+}
+
+/**
+ * BehaviorSystem Interface
+ *
+ * Legacy behavior systems reserved the first `update` argument for an ECS world
+ * handle; it is always `undefined` now.
+ */
+/**
+ * A behavior system that processes entities with specific components.
+ *
+ * @example
+ * ```typescript
+ * class ThrusterSystem implements BehaviorSystem {
+ *   update(_ecs: unknown, delta: number): void {
+ *     // Iterate behavior links, push intent into wasm runtime, etc.
+ *   }
+ * }
+ * ```
+ */
+interface BehaviorSystem {
+    /** Optional eager initialization when a behavior link is registered on a live entity */
+    attach?(link: BehaviorEntityLink): void;
+    /** Called once per frame. The first argument is always `undefined` (reserved legacy slot). */
+    update(ecs: unknown, delta: number): void;
+    /** Optional cleanup when a behavior link is detached from a live entity */
+    detach?(link: BehaviorEntityLink): void;
+    /** Optional cleanup when stage is destroyed */
+    destroy?(ecs?: unknown): void;
+}
+/**
+ * Runtime link between a spawned entity and one of its behavior refs.
+ * Systems can iterate these links to avoid scanning all world entities.
+ */
+interface BehaviorEntityLink {
+    entity: any;
+    ref: any;
+}
+/**
+ * Context provided to behavior-system factories.
+ *
+ * After the runtime-only stage migration, `wasmStage` is the source of
+ * truth — descriptors should call `wasmStage.attach<X>(handle, opts)` /
+ * `wasmStage.query<X>(handle)` from inside the system instead of touching
+ * `entity.body` directly. The legacy `world` / `scene` fields remain for
+ * unmigrated descriptors.
+ */
+interface BehaviorSystemContext {
+    world: ZylemWorld | null;
+    /** 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;
+    /**
+     * Returns live behavior links for a descriptor key.
+     * O(1) lookup into a pre-built stage index.
+     */
+    getBehaviorLinks?: (key: symbol) => Iterable<BehaviorEntityLink>;
+    /**
+     * Host-injected entity factory. Behaviors that spawn entities at runtime
+     * (e.g. destructible-3d fragments) use this instead of importing the engine
+     * entity factory directly, keeping the behavior layer decoupled.
+     */
+    createEntity?: CreateEntityFn;
+    /**
+     * Host-injected accessor for the global game-state bag, passed to entity
+     * lifecycle hooks (e.g. `nodeDestroy`).
+     */
+    getGlobals?: () => any;
+}
+/**
+ * Factory function that creates a BehaviorSystem.
+ * Receives the stage for access to world, scene, etc.
+ */
+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 };

package/dist/{chunk-ARJWUNRE.js → chunk-27UPCP5B.js}

@@ -1,11 +1,11 @@
-import {
-  StageRicochetDim,
-  StageRicochetReflection
-} from "./chunk-Y6UJOUE5.js";
 import {
   SyncStateMachine,
   t
 } from "./chunk-4URF65BR.js";
+import {
+  StageRicochetDim,
+  StageRicochetReflection
+} from "./chunk-Q75LKHDF.js";
 import {
   defineBehavior
 } from "./chunk-EZNCCO4L.js";
@@ -332,7 +332,9 @@ function createRicochet3DHandle(ref) {
         entity.transformStore.velocity.x = result.velocity.x;
         entity.transformStore.velocity.y = result.velocity.y;
         entity.transformStore.velocity.z = result.velocity.z;
-        entity.transformStore.dirty.velocity = true;
+        entity.transformStore.dirty.velocityX = true;
+        entity.transformStore.dirty.velocityY = true;
+        entity.transformStore.dirty.velocityZ = true;
       }
       return true;
     },
@@ -358,12 +360,10 @@ function createRicochet3DHandle(ref) {
   };
 }
 var Ricochet3DSystem = class {
-  constructor(world, wasmStage, getBehaviorLinks) {
-    this.world = world;
+  constructor(wasmStage, getBehaviorLinks) {
     this.wasmStage = wasmStage;
     this.getBehaviorLinks = getBehaviorLinks;
   }
-  world;
   wasmStage;
   getBehaviorLinks;
   elapsedMs = 0;
@@ -418,7 +418,7 @@ var Ricochet3DSystem = class {
 var Ricochet3DBehavior = defineBehavior({
   name: "ricochet-3d",
   defaultOptions,
-  systemFactory: (ctx) => new Ricochet3DSystem(ctx.world, ctx.wasmStage ?? null, ctx.getBehaviorLinks),
+  systemFactory: (ctx) => new Ricochet3DSystem(ctx.wasmStage ?? null, ctx.getBehaviorLinks),
   createHandle: createRicochet3DHandle
 });
 
@@ -428,4 +428,4 @@ export {
   Ricochet3DFSM,
   Ricochet3DBehavior
 };
-//# sourceMappingURL=chunk-ARJWUNRE.js.map
+//# sourceMappingURL=chunk-27UPCP5B.js.map