@zylem/behaviors 0.2.0

package/dist/spark-DDlIg1nM.d.ts

@@ -0,0 +1,148 @@
+import { Texture, Blending, ColorRepresentation } from 'three';
+import { ParticleSystem, RenderMode, RendererEmitterSettings } from 'three.quarks';
+
+interface ParticleEffectDefinition {
+    create(): ParticleSystem;
+}
+interface ParticlePresetMaterialOptions {
+    texture?: Texture;
+    opacity?: number;
+    depthWrite?: boolean;
+    alphaTest?: number;
+    blending?: Blending;
+    uTileCount?: number;
+    vTileCount?: number;
+    blendTiles?: boolean;
+}
+type NumericRange = number | readonly [number, number];
+type CurvePoints = readonly [number, number, number, number];
+type ColorStop = readonly [ColorRepresentation, number];
+type AlphaStop = readonly [number, number];
+interface ParticleColorOverLifeConfig {
+    colors: readonly ColorStop[];
+    alpha: readonly AlphaStop[];
+}
+interface ParticleForceOverLifeConfig {
+    x?: NumericRange;
+    y?: NumericRange;
+    z?: NumericRange;
+}
+interface ParticleNoiseConfig {
+    frequency: NumericRange;
+    power: NumericRange;
+    positionAmount?: NumericRange;
+    rotationAmount?: NumericRange;
+}
+interface ParticleOrbitConfig {
+    speed: NumericRange;
+    axis?: readonly [number, number, number];
+}
+interface ParticleBehaviorOverrides {
+    colorOverLife?: ParticleColorOverLifeConfig | null;
+    sizeOverLife?: CurvePoints | null;
+    speedOverLife?: CurvePoints | null;
+    rotationOverLife?: NumericRange | null;
+    forceOverLife?: Partial<ParticleForceOverLifeConfig> | null;
+    noise?: Partial<ParticleNoiseConfig> | null;
+    orbitOverLife?: Partial<ParticleOrbitConfig> | null;
+}
+type ParticleShapeConfig = {
+    type: 'point';
+} | {
+    type: 'cone';
+    radius?: number;
+    thickness?: number;
+    angle?: number;
+    speed?: NumericRange;
+} | {
+    type: 'sphere';
+    radius?: number;
+    thickness?: number;
+    speed?: NumericRange;
+};
+type ParticleMagicAlignment = 'arcane' | 'holy' | 'corrupted' | 'nature' | 'void' | 'psychic';
+type ParticleMagicTemperament = 'calm' | 'ominous' | 'playful' | 'regal' | 'predatory';
+type ParticleMagicAgency = 'passive' | 'reactive' | 'seeking' | 'sentient-feeling';
+type ParticleMagicOrder = 'geometric' | 'organic' | 'chaotic';
+type ParticleMagicRealityEffect = 'warping' | 'illuminating' | 'binding' | 'decaying' | 'healing';
+interface ParticleMagicModifierOptions {
+    alignment: ParticleMagicAlignment;
+    temperament?: ParticleMagicTemperament;
+    agency?: ParticleMagicAgency;
+    order?: ParticleMagicOrder;
+    realityEffect?: ParticleMagicRealityEffect;
+    intensity?: number;
+}
+type ParticleMagicModifierInput = ParticleMagicAlignment | ParticleMagicModifierOptions;
+interface SemanticParticlePresetOptions extends ParticlePresetMaterialOptions {
+    behaviors?: ParticleBehaviorOverrides;
+    color?: ColorRepresentation;
+    count?: number;
+    duration?: number;
+    emissionRate?: number;
+    life?: NumericRange;
+    looping?: boolean;
+    magic?: ParticleMagicModifierInput;
+    renderMode?: RenderMode;
+    rendererEmitterSettings?: Partial<RendererEmitterSettings>;
+    rotation?: NumericRange;
+    shape?: ParticleShapeConfig;
+    size?: NumericRange;
+    speed?: NumericRange;
+    worldSpace?: boolean;
+}
+declare function particleEffect(create: () => ParticleSystem): ParticleEffectDefinition;
+
+declare function arcane(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function corrupted(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function holy(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function nature(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function psychic(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function voidMagic(options?: Omit<ParticleMagicModifierOptions, 'alignment'>): ParticleMagicModifierOptions;
+
+declare function arc(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function pulse(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function spark$1(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function storm(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function surge(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function haze(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function miasma(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function plume(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function smoke(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function vapor(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function drizzle(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function mist(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function splash(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function spray(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function torrent(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function blaze(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function ember(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function flamelet(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function smolder(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+declare function spark(options?: SemanticParticlePresetOptions): ParticleEffectDefinition;
+
+export { spark$1 as A, spark as B, splash as C, spray as D, storm as E, surge as F, torrent as G, vapor as H, voidMagic as I, type ParticleEffectDefinition as P, type SemanticParticlePresetOptions as S, type ParticleMagicAgency as a, type ParticleMagicAlignment as b, type ParticleMagicModifierInput as c, type ParticleMagicModifierOptions as d, type ParticleMagicOrder as e, type ParticleMagicRealityEffect as f, type ParticleMagicTemperament as g, type ParticlePresetMaterialOptions as h, arc as i, arcane as j, blaze as k, corrupted as l, drizzle as m, ember as n, flamelet as o, haze as p, holy as q, miasma as r, mist as s, nature as t, particleEffect as u, plume as v, psychic as w, pulse as x, smoke as y, smolder as z };

package/dist/sync-state-machine-CZyspBpj.d.ts

@@ -0,0 +1,16 @@
+import { SyncCallback, StateMachine, ITransition, ILogger } from 'typescript-fsm';
+
+/**
+ * Local wrapper around typescript-fsm's SyncStateMachine.
+ *
+ * typescript-fsm@1.6.0 incorrectly reports callback-less transitions as
+ * unhandled even after moving to the next state, which causes noisy
+ * `No transition...` console errors for valid FSM dispatches.
+ */
+declare class SyncStateMachine<STATE extends string | number | symbol, EVENT extends string | number | symbol, CALLBACK extends Record<EVENT, SyncCallback> = Record<EVENT, SyncCallback>> extends StateMachine<STATE, EVENT, CALLBACK> {
+    constructor(init: STATE, transitions?: ITransition<STATE, EVENT, CALLBACK[EVENT]>[], logger?: ILogger);
+    dispatch<E extends EVENT>(_event: E, ..._args: unknown[]): Promise<void>;
+    syncDispatch<E extends EVENT>(event: E, ...args: unknown[]): boolean;
+}
+
+export { SyncStateMachine as S };

package/dist/thruster.d.ts

@@ -0,0 +1,132 @@
+import { T as ThrusterInputComponent, a as ThrusterMovementComponent } from './components-B29WHGQN.js';
+export { b as ThrusterStateComponent, c as createThrusterInputComponent, d as createThrusterMovementComponent, e as createThrusterStateComponent } from './components-B29WHGQN.js';
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import { G as GameEntity, a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { P as PhysicsBodyComponent } from './components-BWG1GkZA.js';
+import 'typescript-fsm';
+import '@dimforge/rapier3d-compat';
+import 'three';
+
+/**
+ * ThrusterFSM
+ *
+ * State machine controller for thruster behavior.
+ * FSM does NOT touch physics or ThrusterMovementBehavior - it only writes ThrusterInputComponent.
+ */
+
+declare enum ThrusterState {
+    Idle = "idle",
+    Active = "active",
+    Boosting = "boosting",
+    Disabled = "disabled",
+    Docked = "docked"
+}
+declare enum ThrusterEvent {
+    Activate = "activate",
+    Deactivate = "deactivate",
+    Boost = "boost",
+    EndBoost = "endBoost",
+    Disable = "disable",
+    Enable = "enable",
+    Dock = "dock",
+    Undock = "undock"
+}
+interface ThrusterFSMContext {
+    input: ThrusterInputComponent;
+}
+interface PlayerInput {
+    thrust: number;
+    rotate: number;
+    thrustX?: number;
+    thrustY?: number;
+}
+declare class ThrusterFSM {
+    private ctx;
+    machine: SyncStateMachine<ThrusterState, ThrusterEvent, never>;
+    constructor(ctx: ThrusterFSMContext);
+    /**
+     * Get current state
+     */
+    getState(): ThrusterState;
+    /**
+     * Dispatch an event to transition state
+     */
+    dispatch(event: ThrusterEvent): void;
+    /**
+     * Update FSM state based on player input.
+     * Auto-transitions between Idle/Active to report current state.
+     * Does NOT modify input - just observes and reports.
+     */
+    update(playerInput: PlayerInput): void;
+}
+
+interface ZylemWorld {
+    collisionMap?: Map<string, GameEntity<any>>;
+}
+
+/**
+ * ThrusterMovementBehavior
+ *
+ * This is the heart of the thruster movement system - a pure, stateless force generator.
+ * Works identically for player, AI, and replay.
+ */
+
+/**
+ * Zylem-style Behavior interface
+ */
+interface Behavior {
+    update(dt: number): void;
+}
+/**
+ * Entity with thruster components
+ */
+interface ThrusterEntity {
+    physics: PhysicsBodyComponent;
+    thruster: ThrusterMovementComponent;
+    $thruster: ThrusterInputComponent;
+}
+/**
+ * ThrusterMovementBehavior - Force generator for thruster-equipped entities
+ *
+ * Responsibilities:
+ * - Query entities with PhysicsBody, ThrusterMovement, and ThrusterInput components
+ * - Apply velocities based on thrust input (2D mode)
+ * - Apply angular velocity based on rotation input
+ */
+declare class ThrusterMovementBehavior implements Behavior {
+    private world;
+    constructor(world: ZylemWorld);
+    /**
+     * Update a single thruster-enabled entity.
+     */
+    updateEntity(gameEntity: any, _dt: number): void;
+    update(dt: number): void;
+}
+
+/**
+ * Thruster behavior options (typed for entity.use() autocomplete)
+ */
+interface ThrusterBehaviorOptions {
+    /** Forward thrust force (default: 10) */
+    linearThrust: number;
+    /** Rotation torque (default: 5) */
+    angularThrust: number;
+    /** Optional linear damping override */
+    linearDamping?: number;
+}
+/**
+ * ThrusterBehavior - typed descriptor for thruster movement.
+ *
+ * Uses the existing ThrusterMovementBehavior under the hood.
+ *
+ * @example
+ * ```typescript
+ * import { ThrusterBehavior } from "@zylem/game-lib/behavior";
+ *
+ * const ship = createSprite({ ... });
+ * ship.use(ThrusterBehavior, { linearThrust: 15, angularThrust: 8 });
+ * ```
+ */
+declare const ThrusterBehavior: BehaviorDescriptor<ThrusterBehaviorOptions, Record<string, never>, ThrusterEntity>;
+
+export { type Behavior, type PlayerInput, ThrusterBehavior, type ThrusterBehaviorOptions, type ThrusterEntity, ThrusterEvent, ThrusterFSM, type ThrusterFSMContext, ThrusterInputComponent, ThrusterMovementBehavior, ThrusterMovementComponent, ThrusterState };

package/dist/thruster.js

@@ -0,0 +1,26 @@
+import {
+  ThrusterBehavior,
+  ThrusterEvent,
+  ThrusterFSM,
+  ThrusterMovementBehavior,
+  ThrusterState
+} from "./chunk-2CLT36VB.js";
+import {
+  createThrusterInputComponent,
+  createThrusterMovementComponent,
+  createThrusterStateComponent
+} from "./chunk-KS72RZHX.js";
+import "./chunk-ID5QJYF5.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  ThrusterBehavior,
+  ThrusterEvent,
+  ThrusterFSM,
+  ThrusterMovementBehavior,
+  ThrusterState,
+  createThrusterInputComponent,
+  createThrusterMovementComponent,
+  createThrusterStateComponent
+};
+//# sourceMappingURL=thruster.js.map

package/dist/thruster.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/top-down-movement.d.ts

@@ -0,0 +1,40 @@
+import { T as TopDownMovementComponent, a as TopDownMovementInputComponent, b as TopDownMovementStateComponent } from './components-XCpL6IYt.js';
+export { c as createTopDownMovementComponent, d as createTopDownMovementInputComponent, e as createTopDownMovementStateComponent } from './components-XCpL6IYt.js';
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+
+interface TopDownMovementEntity {
+    body: {
+        linvel(): {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    transformStore?: {
+        velocity: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        dirty: {
+            velocity: boolean;
+        };
+    };
+    setRotationZ?: (angle: number) => void;
+    topDownMovement: TopDownMovementComponent;
+    $topDownMovement: TopDownMovementInputComponent;
+    topDownMovementState: TopDownMovementStateComponent;
+}
+declare class TopDownMovementRuntimeBehavior {
+    updateEntity(entity: TopDownMovementEntity, _delta: number): void;
+}
+
+interface TopDownMovementBehaviorOptions {
+    moveSpeed?: number;
+}
+interface TopDownMovementHandle {
+    getFacingAngle(): number;
+}
+declare const TopDownMovementBehavior: BehaviorDescriptor<TopDownMovementBehaviorOptions, TopDownMovementHandle, TopDownMovementEntity>;
+
+export { TopDownMovementBehavior, type TopDownMovementBehaviorOptions, TopDownMovementComponent, type TopDownMovementEntity, type TopDownMovementHandle, TopDownMovementInputComponent, TopDownMovementRuntimeBehavior, TopDownMovementStateComponent };

package/dist/top-down-movement.js

@@ -0,0 +1,20 @@
+import {
+  TopDownMovementBehavior,
+  TopDownMovementRuntimeBehavior
+} from "./chunk-OYWFPIHF.js";
+import {
+  createTopDownMovementComponent,
+  createTopDownMovementInputComponent,
+  createTopDownMovementStateComponent
+} from "./chunk-EIWQM6U3.js";
+import "./chunk-ID5QJYF5.js";
+import "./chunk-Y6UJOUE5.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  TopDownMovementBehavior,
+  TopDownMovementRuntimeBehavior,
+  createTopDownMovementComponent,
+  createTopDownMovementInputComponent,
+  createTopDownMovementStateComponent
+};
+//# sourceMappingURL=top-down-movement.js.map

package/dist/top-down-movement.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/use-behavior-D_82jAL3.d.ts

@@ -0,0 +1,13 @@
+import { G as GameEntity, a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+
+/**
+ * Type-safe helper to apply a behavior to an entity and return the entity cast to the behavior's interface.
+ *
+ * @param entity The entity to apply the behavior to
+ * @param descriptor The behavior descriptor
+ * @param options Behavior options
+ * @returns The entity, cast to E & I (where I is the behavior's interface)
+ */
+declare function useBehavior<E extends GameEntity<any>, O extends Record<string, any>, H extends Record<string, any>, I>(entity: E, descriptor: BehaviorDescriptor<O, H, I>, options?: Partial<O>): E & I;
+
+export { useBehavior as u };

package/dist/vector-Bm65-FOG.d.ts

@@ -0,0 +1,45 @@
+import { Vector3, Vector2 } from 'three';
+import { Vector3 as Vector3$1 } from '@dimforge/rapier3d-compat';
+
+type Vec2 = Vector2;
+type Vec3 = Vector3 | Vector3$1;
+type Vec2Components = {
+    x: number;
+    y: number;
+};
+type Vec3Components = {
+    x: number;
+    y: number;
+    z: number;
+};
+type Vec2Tuple = readonly [number?, number?] & {
+    x?: number;
+    y?: number;
+};
+type Vec3Tuple = readonly [number?, number?, number?] & {
+    x?: number;
+    y?: number;
+    z?: number;
+};
+type Vec2Input = Vec2 | {
+    x?: number;
+    y?: number;
+} | Vec2Tuple;
+type Vec3Input = Vec3 | {
+    x?: number;
+    y?: number;
+    z?: number;
+} | Vec3Tuple;
+declare const VEC2_ZERO: Readonly<Vec2Components>;
+declare const VEC2_ONE: Readonly<Vec2Components>;
+declare const VEC3_ZERO: Readonly<Vec3Components>;
+declare const VEC3_ONE: Readonly<Vec3Components>;
+declare function isVec2Input(value: unknown): value is Vec2Input;
+declare function isVec3Input(value: unknown): value is Vec3Input;
+declare function normalizeVec2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vec2Components;
+declare function normalizeVec3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vec3Components;
+declare function toThreeVector2(input?: Vec2Input | null, defaults?: Vec2Input | Partial<Vec2Components>): Vector2;
+declare function toThreeVector3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vector3;
+declare function toRapierVector3(input?: Vec3Input | null, defaults?: Vec3Input | Partial<Vec3Components>): Vector3$1;
+
+export { VEC2_ONE as V, VEC2_ZERO as a, VEC3_ONE as b, VEC3_ZERO as c, type Vec2 as d, type Vec2Components as e, type Vec2Input as f, type Vec3 as g, type Vec3Components as h, type Vec3Input as i, isVec2Input as j, isVec3Input as k, normalizeVec3 as l, toThreeVector2 as m, normalizeVec2 as n, toThreeVector3 as o, toRapierVector3 as t };

package/dist/world-boundary-2d.d.ts

@@ -0,0 +1,141 @@
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import 'typescript-fsm';
+
+/**
+ * WorldBoundary2DFSM
+ *
+ * Minimal FSM + extended state to track which world boundaries were hit.
+ *
+ * Notes:
+ * - "Hit boundaries" is inherently a *set* (can hit left+bottom in one frame),
+ *   so we store it as extended state (`lastHits`) rather than a single FSM state.
+ * - The FSM state is still useful for coarse status like "inside" vs "touching".
+ */
+
+type WorldBoundary2DHit = 'top' | 'bottom' | 'left' | 'right';
+type WorldBoundary2DHits = Record<WorldBoundary2DHit, boolean>;
+interface WorldBoundary2DPosition {
+    x: number;
+    y: number;
+}
+interface WorldBoundary2DBounds {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+declare enum WorldBoundary2DState {
+    Inside = "inside",
+    Touching = "touching"
+}
+declare enum WorldBoundary2DEvent {
+    EnterInside = "enter-inside",
+    TouchBoundary = "touch-boundary"
+}
+/**
+ * Compute which boundaries are being hit for a position and bounds.
+ * This matches the semantics of the legacy `boundary2d` behavior:
+ * - left hit if x <= left
+ * - right hit if x >= right
+ * - bottom hit if y <= bottom
+ * - top hit if y >= top
+ */
+declare function computeWorldBoundary2DHits(position: WorldBoundary2DPosition, bounds: WorldBoundary2DBounds): WorldBoundary2DHits;
+declare function hasAnyWorldBoundary2DHit(hits: WorldBoundary2DHits): boolean;
+/**
+ * FSM wrapper with "extended state" (lastHits / lastPosition).
+ * Systems should call `update(...)` once per frame.
+ */
+declare class WorldBoundary2DFSM {
+    readonly machine: SyncStateMachine<WorldBoundary2DState, WorldBoundary2DEvent, never>;
+    private lastHits;
+    private lastPosition;
+    private lastUpdatedAtMs;
+    constructor();
+    getState(): WorldBoundary2DState;
+    /**
+     * Returns the last computed hits (always available after first update call).
+     */
+    getLastHits(): WorldBoundary2DHits;
+    /**
+     * Returns adjusted movement values based on boundary hits.
+     * If the entity is touching a boundary and trying to move further into it,
+     * that axis component is zeroed out.
+     *
+     * @param moveX - The desired X movement
+     * @param moveY - The desired Y movement
+     * @returns Adjusted { moveX, moveY } with boundary-blocked axes zeroed
+     */
+    getMovement(moveX: number, moveY: number): {
+        moveX: number;
+        moveY: number;
+    };
+    /**
+     * Returns the last position passed to `update`, if any.
+     */
+    getLastPosition(): WorldBoundary2DPosition | null;
+    /**
+     * Best-effort timestamp (ms) of the last `update(...)` call.
+     * This is optional metadata; systems can ignore it.
+     */
+    getLastUpdatedAtMs(): number | null;
+    /**
+     * Update FSM + extended state based on current position and bounds.
+     * Returns the computed hits for convenience.
+     */
+    update(position: WorldBoundary2DPosition, bounds: WorldBoundary2DBounds): WorldBoundary2DHits;
+    private dispatch;
+}
+
+interface WorldBoundary2DOptions {
+    /**
+     * World boundaries (in world units).
+     * - left hit if x <= left
+     * - right hit if x >= right
+     * - bottom hit if y <= bottom
+     * - top hit if y >= top
+     */
+    boundaries: WorldBoundary2DBounds;
+}
+/**
+ * Handle methods provided by WorldBoundary2DBehavior
+ */
+interface WorldBoundary2DHandle {
+    /**
+     * Get the last computed boundary hits.
+     * Returns null until entity is spawned and FSM is initialized.
+     */
+    getLastHits(): WorldBoundary2DHits | null;
+    /**
+     * Get adjusted movement values based on boundary hits.
+     * Zeros out movement into boundaries the entity is touching.
+     */
+    getMovement(moveX: number, moveY: number): {
+        moveX: number;
+        moveY: number;
+    };
+}
+/**
+ * WorldBoundary2DBehavior
+ *
+ * @example
+ * ```ts
+ * import { WorldBoundary2DBehavior } from "@zylem/game-lib/behavior";
+ *
+ * const ship = createSprite({ ... });
+ * const boundary = ship.use(WorldBoundary2DBehavior, {
+ *   boundaries: { left: -10, right: 10, bottom: -7.5, top: 7.5 },
+ * });
+ *
+ * ship.onUpdate(({ me }) => {
+ *   let moveX = ..., moveY = ...;
+ *   const hits = boundary.getLastHits(); // Fully typed!
+ *   ({ moveX, moveY } = boundary.getMovement(moveX, moveY));
+ *   me.moveXY(moveX, moveY);
+ * });
+ * ```
+ */
+declare const WorldBoundary2DBehavior: BehaviorDescriptor<WorldBoundary2DOptions, WorldBoundary2DHandle, unknown>;
+
+export { WorldBoundary2DBehavior, type WorldBoundary2DBounds, WorldBoundary2DEvent, WorldBoundary2DFSM, type WorldBoundary2DHandle, type WorldBoundary2DHit, type WorldBoundary2DHits, type WorldBoundary2DOptions, type WorldBoundary2DPosition, WorldBoundary2DState, computeWorldBoundary2DHits, hasAnyWorldBoundary2DHit };

package/dist/world-boundary-2d.js

@@ -0,0 +1,21 @@
+import {
+  WorldBoundary2DBehavior,
+  WorldBoundary2DEvent,
+  WorldBoundary2DFSM,
+  WorldBoundary2DState,
+  computeWorldBoundary2DHits,
+  hasAnyWorldBoundary2DHit
+} from "./chunk-XG2YMCJW.js";
+import "./chunk-KDY5N6J4.js";
+import "./chunk-Y6UJOUE5.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  WorldBoundary2DBehavior,
+  WorldBoundary2DEvent,
+  WorldBoundary2DFSM,
+  WorldBoundary2DState,
+  computeWorldBoundary2DHits,
+  hasAnyWorldBoundary2DHit
+};
+//# sourceMappingURL=world-boundary-2d.js.map

package/dist/world-boundary-2d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}