cubeforge 0.1.8 → 0.2.0

package/dist/index.d.mts

@@ -1,14 +1,17 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
 import React__default, { CSSProperties, ReactNode } from 'react';
-import { Plugin, EntityId, System, ECSWorld, ScriptUpdateFn, EventBus, AssetManager, GameLoop, WorldSnapshot } from '@cubeforge/core';
-export { Component, ECSWorld, Ease, EntityId, Plugin, ScriptUpdateFn, TransformComponent, TweenHandle, WorldSnapshot, createTag, createTransform, definePlugin, findByTag, tween } from '@cubeforge/core';
-import { InputManager, ActionBindings } from '@cubeforge/input';
-export { ActionBindings, InputManager, InputMap, createInputMap } from '@cubeforge/input';
-import { Canvas2DRenderer, RenderSystem } from '@cubeforge/renderer';
-export { AnimationStateComponent, ParallaxLayerComponent, Particle, ParticlePoolComponent, SpriteComponent, SquashStretchComponent, TextComponent, createSprite } from '@cubeforge/renderer';
-import { PhysicsSystem } from '@cubeforge/physics';
-export { BoxColliderComponent, CircleColliderComponent, RaycastHit, RigidBodyComponent, overlapBox, raycast } from '@cubeforge/physics';
+import { Plugin, EntityId, System, ECSWorld, ScriptUpdateFn, NavGrid, WorldSnapshot, EventBus } from '@cubeforge/core';
+export { AssetProgress, Component, ECSWorld, Ease, EntityId, GameTimer, NavGrid, Plugin, PreloadManifest, ScriptUpdateFn, TransformComponent, TweenHandle, Vec2Like, WorldSnapshot, arrive, createTag, createTimer, createTransform, definePlugin, findByTag, flee, patrol, preloadManifest, seek, tween, wander } from '@cubeforge/core';
+import { InputManager, ActionBindings, InputContextName, PlayerInput, InputRecorderControls } from '@cubeforge/input';
+export { ActionBindings, AxisBinding, InputContextName, InputManager, InputMap, InputRecorderControls, InputRecording, InputRecording as InputRecordingData, PlayerInput, createInputMap, createInputRecorder, createPlayerInput, globalInputContext } from '@cubeforge/input';
+import { EngineState } from '@cubeforge/context';
+export { EngineState, useCircleEnter, useCircleExit, useCircleStay, useCollisionEnter, useCollisionExit, useCollisionStay, useTriggerEnter, useTriggerExit, useTriggerStay } from '@cubeforge/context';
+export { AISteering, AnimationClip, AnimationControllerResult, BindingControls, GameState as GameStateDefinition, GameStateMachineResult, HealthControls, HealthOptions, KinematicBodyControls, LevelTransitionControls, PathfindingControls, PlatformerControllerOptions, RestartControls, SaveControls, SaveOptions, TopDownMovementOptions, TransitionOptions, TransitionType, useAISteering, useAnimationController, useDamageZone, useDropThrough, useGameStateMachine, useHealth, useKinematicBody, useLevelTransition, usePathfinding, usePersistedBindings, usePlatformerController, useRestart, useSave, useTopDownMovement } from '@cubeforge/gameplay';
+export { AudioGroup, SoundControls, duck, getGroupVolume, setGroupMute, setGroupVolume, setMasterVolume, stopGroup, useSound } from '@cubeforge/audio';
+export { DevToolsHandle } from '@cubeforge/devtools';
+export { BoxColliderComponent, CapsuleColliderComponent, CircleColliderComponent, RaycastHit, RigidBodyComponent, overlapBox, overlapCircle, raycast, raycastAll, sweepBox } from '@cubeforge/physics';
+export { AnimationStateComponent, ParallaxLayerComponent, Particle, ParticlePoolComponent, SpriteComponent, SquashStretchComponent, TextComponent, TrailComponent, createSprite } from '@cubeforge/renderer';
 
 interface GameControls {
     pause(): void;
@@ -177,6 +180,17 @@ interface CircleColliderProps {
 }
 declare function CircleCollider({ radius, offsetX, offsetY, isTrigger, layer, mask, }: CircleColliderProps): null;
 
+interface CapsuleColliderProps {
+    width: number;
+    height: number;
+    offsetX?: number;
+    offsetY?: number;
+    isTrigger?: boolean;
+    layer?: string;
+    mask?: string | string[];
+}
+declare function CapsuleCollider({ width, height, offsetX, offsetY, isTrigger, layer, mask, }: CapsuleColliderProps): null;
+
 interface ScriptProps {
     /** Called once when the entity is mounted — use to attach extra components */
     init?: (entityId: EntityId, world: ECSWorld) => void;
@@ -223,8 +237,16 @@ interface AnimationProps {
     playing?: boolean;
     /** Called once when a non-looping animation finishes playing */
     onComplete?: () => void;
+    /**
+     * Callbacks fired when the animation advances to specific frame indices.
+     * Key = 0-based position in the `frames` array.
+     *
+     * @example
+     * frameEvents={{ 2: () => playFootstep(), 5: () => playFootstep() }}
+     */
+    frameEvents?: Record<number, () => void>;
 }
-declare function Animation({ frames, fps, loop, playing, onComplete }: AnimationProps): null;
+declare function Animation({ frames, fps, loop, playing, onComplete, frameEvents }: AnimationProps): null;
 
 interface SquashStretchProps {
     /** How much to squash/stretch (default 0.2) */
@@ -261,6 +283,40 @@ interface ParticleEmitterProps {
 }
 declare function ParticleEmitter({ active, preset, rate, speed, spread, angle, particleLife, particleSize, color, gravity, maxParticles, }: ParticleEmitterProps): null;
 
+interface VirtualJoystickProps {
+    /** Diameter of the joystick base in pixels (default 120) */
+    size?: number;
+    /** Screen corner to anchor to (default 'left') */
+    position?: 'left' | 'right';
+    /** Extra CSS applied to the outer container */
+    style?: React__default.CSSProperties;
+    /** Show an action button (e.g. jump) alongside the joystick (default false) */
+    actionButton?: boolean;
+    /** Label shown on the action button (default 'A') */
+    actionLabel?: string;
+    /** Name of the virtual button to set (default 'action') */
+    actionName?: string;
+}
+/**
+ * On-screen virtual joystick for touch / mobile. Place it as a sibling of the
+ * `<Game>` canvas (inside a `position: relative` container).
+ *
+ * Read the joystick state with `useVirtualInput()`.
+ *
+ * @example
+ * <div style={{ position: 'relative' }}>
+ *   <Game ...>...</Game>
+ *   <VirtualJoystick position="left" actionButton />
+ * </div>
+ *
+ * // Inside an entity:
+ * function MobilePlayer() {
+ *   const virt = useVirtualInput()
+ *   // virt.axisX, virt.axisY, virt.button('action')
+ * }
+ */
+declare function VirtualJoystick({ size, position, style, actionButton, actionLabel, actionName, }: VirtualJoystickProps): react_jsx_runtime.JSX.Element;
+
 interface MovingPlatformProps {
     /** Start position */
     x1: number;
@@ -353,8 +409,21 @@ interface TilemapProps {
      * Receives the global tile ID, the property map, and the tile's world position.
      */
     onTileProperty?: (tileId: number, properties: Record<string, unknown>, x: number, y: number) => void;
+    /**
+     * If provided, collision-layer tiles automatically mark the corresponding
+     * NavGrid cells as non-walkable. The grid must already be created with the
+     * correct dimensions (map.width × map.height) and cellSize (map.tilewidth).
+     */
+    navGrid?: NavGrid;
+    /**
+     * Name of the object layer that contains spawn markers.
+     * Objects in this layer are forwarded to `onSpawnObject` just like any
+     * other object layer, but they are also identified as spawn points so you
+     * can filter them by `layer.name === spawnLayer` inside the callback.
+     */
+    spawnLayer?: string;
 }
-declare function Tilemap({ src, onSpawnObject, layerFilter, zIndex, collisionLayer, triggerLayer: triggerLayerName, onTileProperty, }: TilemapProps): React__default.ReactElement | null;
+declare function Tilemap({ src, onSpawnObject, layerFilter, zIndex, collisionLayer, triggerLayer: triggerLayerName, onTileProperty, navGrid, }: TilemapProps): React__default.ReactElement | null;
 
 interface ParallaxLayerProps {
     /** Image URL to use as the background layer */
@@ -388,21 +457,94 @@ interface ScreenFlashHandle {
 }
 declare const ScreenFlash: React.ForwardRefExoticComponent<React.RefAttributes<ScreenFlashHandle>>;
 
-interface EngineState {
-    ecs: ECSWorld;
-    input: InputManager;
-    /** Canvas2D renderer. Undefined when a custom WebGL renderer is used via the `renderer` Game prop. */
-    renderer?: Canvas2DRenderer;
-    /** The active render system. Undefined when a custom renderer is used. */
-    renderSystem?: RenderSystem;
-    physics: PhysicsSystem;
-    events: EventBus;
-    assets: AssetManager;
-    loop: GameLoop;
-    canvas: HTMLCanvasElement;
-    /** Maps string entity IDs (e.g. "player") to numeric ECS EntityIds */
-    entityIds: Map<string, EntityId>;
+interface CameraZoneProps {
+    /** World-space center X of the trigger zone */
+    x: number;
+    /** World-space center Y of the trigger zone */
+    y: number;
+    /** Half-width of the trigger zone */
+    width: number;
+    /** Half-height of the trigger zone */
+    height: number;
+    /**
+     * When an entity with this tag enters the zone, the camera stops following
+     * its entity and locks to the fixed position (targetX, targetY).
+     */
+    watchTag?: string;
+    /** Fixed world-space X the camera moves to when activated (defaults to zone center) */
+    targetX?: number;
+    /** Fixed world-space Y the camera moves to when activated (defaults to zone center) */
+    targetY?: number;
+    children?: React__default.ReactNode;
+}
+/**
+ * Invisible trigger area. When the player (or another tagged entity) enters
+ * the zone, the camera follow entity is cleared and the camera locks to the
+ * zone's center (or a custom target). On exit, the camera resumes following.
+ *
+ * Zone detection runs inside the ScriptSystem tick — it respects pause and
+ * deterministic stepping.
+ *
+ * @example
+ * ```tsx
+ * <CameraZone x={500} y={300} width={200} height={150} watchTag="player" />
+ * ```
+ */
+declare function CameraZone({ x, y, width, height, watchTag, targetX, targetY, children, }: CameraZoneProps): react_jsx_runtime.JSX.Element;
+
+interface TrailProps {
+    /** Maximum number of trail points (default 20) */
+    length?: number;
+    /** CSS color string (default '#ffffff') */
+    color?: string;
+    /** Trail width in pixels (default 3) */
+    width?: number;
 }
+/**
+ * Renders a fading polyline that follows the entity's position.
+ *
+ * The trail is drawn in the render pass — it uses the entity's Transform
+ * history collected each frame.
+ *
+ * Must be used inside an `<Entity>` with a `<Transform>`.
+ *
+ * @example
+ * ```tsx
+ * <Entity id="bullet">
+ *   <Transform x={x} y={y} />
+ *   <Sprite width={6} height={6} color="#ff0" />
+ *   <Trail length={15} color="#ff0" width={2} />
+ * </Entity>
+ * ```
+ */
+declare function Trail({ length, color, width }: TrailProps): null;
+
+interface AssetLoaderProps {
+    /** List of asset URLs to preload */
+    assets: string[];
+    /** Shown while assets are loading */
+    fallback?: React__default.ReactNode;
+    /** Called if any asset fails to load */
+    onError?: (err: Error) => void;
+    children: React__default.ReactNode;
+}
+/**
+ * Suspense-style asset loading boundary.
+ *
+ * Shows `fallback` until all assets in the list are loaded (or errored).
+ * Once loaded, renders `children`.
+ *
+ * @example
+ * ```tsx
+ * <AssetLoader
+ *   assets={['/hero.png', '/tiles.png', '/jump.wav']}
+ *   fallback={<div>Loading…</div>}
+ * >
+ *   <GameScene />
+ * </AssetLoader>
+ * ```
+ */
+declare function AssetLoader({ assets, fallback, onError, children }: AssetLoaderProps): react_jsx_runtime.JSX.Element;
 
 declare function useGame(): EngineState;
 
@@ -507,6 +649,35 @@ declare function useEntity(): EntityId;
  */
 declare function useDestroyEntity(): () => void;
 
+interface VirtualInputState {
+    /** Left–right axis in [−1, 1]. Positive = right. */
+    readonly axisX: number;
+    /** Up–down axis in [−1, 1]. Positive = down. */
+    readonly axisY: number;
+    /** Whether a named virtual button is currently pressed. */
+    button(name: string): boolean;
+}
+/**
+ * Returns the current state of the on-screen virtual joystick and buttons.
+ * Reads synchronously from the module-level store — safe to call in a Script
+ * update function every frame without triggering React re-renders.
+ *
+ * Combine with keyboard or gamepad input for multi-input support:
+ *
+ * @example
+ * function MobilePlayer() {
+ *   const input = useInput()
+ *   const virt  = useVirtualInput()
+ *
+ *   // Script update:
+ *   const moveX = input.isHeld('ArrowRight') ? 1
+ *               : input.isHeld('ArrowLeft')  ? -1
+ *               : virt.axisX
+ *   const jump  = input.isPressed('Space') || virt.button('action')
+ * }
+ */
+declare function useVirtualInput(): VirtualInputState;
+
 declare function useInput(): InputManager;
 
 interface BoundInputMap {
@@ -516,6 +687,16 @@ interface BoundInputMap {
     isActionPressed(action: string): boolean;
     /** True only on the frame any bound key was released. */
     isActionReleased(action: string): boolean;
+    /**
+     * Returns -1..1 for axis bindings. For key bindings, 1 if down, 0 otherwise.
+     * @see {@link AxisBinding}
+     */
+    getAxis(action: string): number;
+    /**
+     * Alias for `getAxis`. Matches the `PlayerInput` naming convention — use this
+     * when writing code that needs to work with both `useInputMap` and `usePlayerInput`.
+     */
+    getActionAxis(action: string): number;
 }
 /**
  * React hook that returns a pre-bound action map for use inside `<Game>`.
@@ -537,141 +718,146 @@ declare function useInputMap(bindings: ActionBindings): BoundInputMap;
 declare function useEvents(): EventBus;
 declare function useEvent<T>(event: string, handler: (data: T) => void): void;
 
-interface PlatformerControllerOptions {
-    /** Horizontal move speed in px/s (default 200) */
-    speed?: number;
-    /** Upward impulse on jump (default -500) */
-    jumpForce?: number;
-    /** Max consecutive jumps, e.g. 2 for double jump (default 1) */
-    maxJumps?: number;
-    /** Seconds after leaving ground the player can still jump (default 0.08) */
-    coyoteTime?: number;
-    /** Seconds to buffer a jump input before landing (default 0.08) */
-    jumpBuffer?: number;
+interface CoordinateHelpers {
     /**
-     * Minimum seconds between jumps — prevents multi-jump spam when holding the
-     * jump key with double-jump enabled (default 0.18)
+     * Convert a world-space position to canvas pixel coordinates.
+     * Takes current camera position and zoom into account.
      */
-    jumpCooldown?: number;
+    worldToScreen(wx: number, wy: number): {
+        x: number;
+        y: number;
+    };
     /**
-     * Override the default key bindings. Each action accepts a single key code
-     * or an array of key codes.
-     *
-     * Defaults:
-     *   left:  ['ArrowLeft', 'KeyA', 'a']
-     *   right: ['ArrowRight', 'KeyD', 'd']
-     *   jump:  ['Space', 'ArrowUp', 'KeyW', 'w']
+     * Convert canvas pixel coordinates to world-space position.
+     * Takes current camera position and zoom into account.
      */
-    bindings?: {
-        left?: string | string[];
-        right?: string | string[];
-        jump?: string | string[];
+    screenToWorld(sx: number, sy: number): {
+        x: number;
+        y: number;
     };
 }
 /**
- * Attaches platformer movement (customisable keys + Space/Up to jump) to an entity.
- * The entity must already have a RigidBody component.
+ * Returns helpers for converting between world-space and screen (canvas pixel) coordinates.
  *
  * @example
- * function Player() {
- *   const id = useEntity()
- *   usePlatformerController(id, { speed: 220, maxJumps: 2 })
- *   return (
- *     <Entity id="player">
- *       <Transform x={100} y={300} />
- *       <Sprite width={28} height={40} color="#4fc3f7" />
- *       <RigidBody />
- *       <BoxCollider width={26} height={40} />
- *     </Entity>
- *   )
+ * ```tsx
+ * function Minimap() {
+ *   const { worldToScreen, screenToWorld } = useCoordinates()
+ *   // worldToScreen(player.x, player.y) → canvas pixel position of player
  * }
+ * ```
  */
-declare function usePlatformerController(entityId: EntityId, opts?: PlatformerControllerOptions): void;
+declare function useCoordinates(): CoordinateHelpers;
 
-interface TopDownMovementOptions {
-    /** Movement speed in px/s (default 200) */
-    speed?: number;
-    /** Normalize diagonal movement to avoid faster diagonal movement (default true) */
-    normalizeDiagonal?: boolean;
+interface PreloadState {
+    /** 0–1 loading progress */
+    progress: number;
+    /** True when all assets have finished loading (or errored) */
+    loaded: boolean;
+    /** First error encountered, if any */
+    error: Error | null;
 }
 /**
- * Attaches 4-directional top-down movement (WASD/Arrows) to an entity.
- * The entity must have a RigidBody with gravityScale=0 for top-down games.
+ * Preloads a list of asset URLs using the engine's AssetManager.
+ * Returns loading progress and a `loaded` flag.
+ *
+ * Works with images (any extension) — audio goes through the engine's audio API.
  *
  * @example
- * <Entity id="player">
- *   <Transform x={100} y={100} />
- *   <Sprite width={24} height={24} color="#4fc3f7" />
- *   <RigidBody gravityScale={0} />
- *   <BoxCollider width={24} height={24} />
- * </Entity>
- * // In a Script or parent component:
- * useTopDownMovement(playerId, { speed: 180 })
+ * ```tsx
+ * function Level() {
+ *   const { progress, loaded } = usePreload(['/hero.png', '/tiles.png'])
+ *   if (!loaded) return <LoadingBar progress={progress} />
+ *   return <GameScene />
+ * }
+ * ```
  */
-declare function useTopDownMovement(entityId: EntityId, opts?: TopDownMovementOptions): void;
+declare function usePreload(assets: string[]): PreloadState;
 
-interface SoundControls {
-    /** Start playing. If already playing and loop=false, restarts from the beginning. */
-    play(): void;
-    /** Stop the current playback. */
-    stop(): void;
-    /** Change the volume (0–1). */
-    setVolume(v: number): void;
+interface InputContextControls {
+    push(ctx: InputContextName): void;
+    pop(ctx: InputContextName): void;
+    readonly active: InputContextName;
 }
 /**
- * Loads and plays an audio file via the Web Audio API.
+ * Access and manipulate the global input context stack.
+ *
+ * If you pass a `ctx` argument, that context is automatically pushed on mount
+ * and popped on unmount — ideal for pause menus, cutscenes, etc.
+ *
+ * @example
+ * ```tsx
+ * function PauseMenu() {
+ *   useInputContext('pause') // auto-push/pop
+ *   return <div>Paused</div>
+ * }
+ * ```
+ */
+declare function useInputContext(ctx?: InputContextName): InputContextControls;
+
+/**
+ * Returns a `PlayerInput` bound to the shared InputManager for the given player ID.
  *
- * The AudioContext is created lazily — the first call to `play()` resumes it
- * if the browser suspended it before a user gesture.
+ * @param playerId  - Player number (1-based).
+ * @param bindings  - Action bindings for this player.
  *
  * @example
- * function JumpSfx() {
- *   const { play } = useSound('/jump.wav')
- *   // call play() on jump event
+ * ```tsx
+ * function P1({ x, y }: Props) {
+ *   const p1 = usePlayerInput(1, { jump: 'Space', left: 'ArrowLeft', right: 'ArrowRight' })
+ *   return (
+ *     <Entity id="p1">
+ *       <Script update={(id, world, input, dt) => {
+ *         if (p1.isActionPressed('jump')) rb.vy = -400
+ *       }} />
+ *     </Entity>
+ *   )
  * }
+ * ```
  */
-declare function useSound(src: string, opts?: {
-    volume?: number;
-    loop?: boolean;
-}): SoundControls;
+declare function usePlayerInput(playerId: number, bindings: ActionBindings): PlayerInput;
+
+/**
+ * Returns an array of `PlayerInput` objects for local multiplayer.
+ * Each player gets their own action bindings.
+ *
+ * @param bindingsPerPlayer - Array of binding objects, one per player.
+ *
+ * @example
+ * ```tsx
+ * const [p1, p2] = useLocalMultiplayer([
+ *   { jump: 'Space', left: 'ArrowLeft', right: 'ArrowRight' },
+ *   { jump: 'KeyW',  left: 'KeyA',      right: 'KeyD' },
+ * ])
+ * ```
+ */
+declare function useLocalMultiplayer(bindingsPerPlayer: ActionBindings[]): PlayerInput[];
 
 /**
- * A lightweight game-loop timer for use inside Script update functions.
+ * Returns an `InputRecorderControls` instance that persists across renders.
+ *
+ * Use inside a `<Script update>` to drive recording/playback:
  *
  * @example
- * // Create once outside the update function (e.g. in playerInit):
- * const invincibleTimer = createTimer(2.0, () => { state.isInvincible = false })
- *
- * // Call update(dt) inside the Script update function each frame:
- * function playerUpdate(id, world, input, dt) {
- *   invincibleTimer.update(dt)
- *   if (someHitCondition) {
- *     state.isInvincible = true
- *     invincibleTimer.restart()
- *   }
+ * ```tsx
+ * function DemoPlayer() {
+ *   const recorder = useInputRecorder()
+ *
+ *   return (
+ *     <Script update={(id, world, input, dt) => {
+ *       if (recorder.isRecording) {
+ *         recorder.captureFrame([...downKeys])
+ *       }
+ *       if (recorder.isPlaying) {
+ *         const frame = recorder.advancePlayback()
+ *         // apply frame.pressedKeys to player controller
+ *       }
+ *     }} />
+ *   )
  * }
+ * ```
  */
-interface GameTimer {
-    /** Advance the timer by dt seconds. Calls onComplete when it reaches zero. */
-    update(dt: number): void;
-    /** Start (or resume) counting down. */
-    start(): void;
-    /** Pause counting without resetting. */
-    stop(): void;
-    /** Reset elapsed time to 0 and stop. Optionally change the duration. */
-    reset(newDuration?: number): void;
-    /** Reset elapsed time to 0 and immediately start. */
-    restart(): void;
-    /** Whether the timer is currently counting. */
-    readonly running: boolean;
-    /** Elapsed seconds since last reset/restart. */
-    readonly elapsed: number;
-    /** Remaining seconds (clamped to 0). */
-    readonly remaining: number;
-    /** Progress from 0 (just started) to 1 (complete). */
-    readonly progress: number;
-}
-declare function createTimer(duration: number, onComplete?: () => void, autoStart?: boolean): GameTimer;
+declare function useInputRecorder(): InputRecorderControls;
 
 interface GamepadState {
     /** Whether a gamepad is connected at this player index. */
@@ -720,65 +906,4 @@ interface PauseControls {
  */
 declare function usePause(): PauseControls;
 
-interface ContactOpts {
-    /** Only fire if the other entity has this tag */
-    tag?: string;
-    /** Only fire if the other entity's BoxCollider is on this layer */
-    layer?: string;
-}
-/**
- * Fires once when another entity's collider first overlaps this entity's trigger.
- * Must be used inside an `<Entity>`.
- *
- * @example
- * function CoinPickup() {
- *   useTriggerEnter((other) => collectCoin(), { tag: 'player' })
- *   return null
- * }
- */
-declare function useTriggerEnter(handler: (other: EntityId) => void, opts?: ContactOpts): void;
-/**
- * Fires once when an overlapping entity's collider leaves this entity's trigger.
- * Must be used inside an `<Entity>`.
- */
-declare function useTriggerExit(handler: (other: EntityId) => void, opts?: ContactOpts): void;
-/**
- * Fires once on the first frame two solid dynamic bodies touch.
- * Must be used inside an `<Entity>`.
- *
- * @example
- * function Enemy() {
- *   useCollisionEnter((other) => takeDamage(), { tag: 'player' })
- *   return null
- * }
- */
-declare function useCollisionEnter(handler: (other: EntityId) => void, opts?: ContactOpts): void;
-/**
- * Fires once when two solid dynamic bodies separate.
- * Must be used inside an `<Entity>`.
- */
-declare function useCollisionExit(handler: (other: EntityId) => void, opts?: ContactOpts): void;
-/**
- * Fires once when another entity's CircleCollider first overlaps this entity's CircleCollider.
- * Also fires when a CircleCollider overlaps a BoxCollider.
- * Must be used inside an `<Entity>`.
- *
- * @example
- * function Asteroid() {
- *   useCircleEnter((other) => onHit(other), { tag: 'bullet' })
- *   return null
- * }
- */
-declare function useCircleEnter(handler: (other: EntityId) => void, opts?: ContactOpts): void;
-/**
- * Fires once when two CircleCollider entities stop overlapping.
- * Must be used inside an `<Entity>`.
- */
-declare function useCircleExit(handler: (other: EntityId) => void, opts?: ContactOpts): void;
-
-interface DevToolsHandle {
-    buffer: WorldSnapshot[];
-    onFrame?: () => void;
-}
-
-export { Animation, type BoundInputMap, BoxCollider, Camera2D, type CameraControls, Checkpoint, CircleCollider, type DevToolsHandle, type EngineState, Entity, Game, type GameControls, type GameTimer, type GamepadState, MovingPlatform, ParallaxLayer, ParticleEmitter, type ParticlePreset, type PauseControls, type PlatformerControllerOptions, RigidBody, ScreenFlash, type ScreenFlashHandle, Script, type SnapshotControls, type SoundControls, Sprite, type SpriteAtlas, SquashStretch, Text, type TiledLayer, type TiledObject, Tilemap, type TopDownMovementOptions, Transform, World, createAtlas, createTimer, useCamera, useCircleEnter, useCircleExit, useCollisionEnter, useCollisionExit, useDestroyEntity, useEntity, useEvent, useEvents, useGame, useGamepad, useInput, useInputMap, usePause, usePlatformerController, useSnapshot, useSound, useTopDownMovement, useTriggerEnter, useTriggerExit };
+export { Animation, AssetLoader, type BoundInputMap, BoxCollider, Camera2D, type CameraControls, CameraZone, CapsuleCollider, Checkpoint, CircleCollider, type CoordinateHelpers, Entity, Game, type GameControls, type GamepadState, type InputContextControls, MovingPlatform, ParallaxLayer, ParticleEmitter, type ParticlePreset, type PauseControls, type PreloadState, RigidBody, ScreenFlash, type ScreenFlashHandle, Script, type SnapshotControls, Sprite, type SpriteAtlas, SquashStretch, Text, type TiledLayer, type TiledObject, Tilemap, Trail, Transform, type VirtualInputState, VirtualJoystick, type VirtualJoystickProps, World, createAtlas, useCamera, useCoordinates, useDestroyEntity, useEntity, useEvent, useEvents, useGame, useGamepad, useInput, useInputContext, useInputMap, useInputRecorder, useLocalMultiplayer, usePause, usePlayerInput, usePreload, useSnapshot, useVirtualInput };