blecsd 0.1.0

package/dist/systems/index.d.ts

@@ -0,0 +1,4036 @@
+import { S as Scheduler } from '../scheduler-DcfoFuum.js';
+import { S as System, W as World, E as Entity, L as LoopPhase } from '../types-BcsvoKzf.js';
+import { d as CollisionPair, f as EmitterAppearance, R as RenderedTileCell } from '../tilemap-D1HJvKy3.js';
+import { E as EventBus, U as UIEventMap } from '../events-BbbxkgvX.js';
+import { b as KeyEvent } from '../keyParser-Bwm8-l7v.js';
+import { M as MouseEvent } from '../mouseParser-Cfrbn3AX.js';
+import { Writable } from 'node:stream';
+import { c as CellChange, S as ScreenBufferData, C as Cell } from '../cell-DwIu2ryP.js';
+import { D as DoubleBufferData } from '../doubleBuffer-CKQFmlPN.js';
+import { z } from 'zod';
+import { V as VirtualizedLineStore } from '../virtualizedLineStore-DwPEvPkk.js';
+import 'bitecs';
+
+/**
+ * Animation system for updating sprite animations.
+ * Processes all entities with Animation component.
+ * @module systems/animationSystem
+ */
+
+/**
+ * Query all entities with the Animation component.
+ *
+ * @param world - The ECS world
+ * @returns Array of entity IDs with Animation component
+ */
+declare function queryAnimation(world: World): number[];
+/**
+ * Checks if an entity has the Animation component (via system store).
+ *
+ * @param world - The ECS world
+ * @param eid - Entity to check
+ * @returns true if entity has Animation component
+ */
+declare function hasAnimationSystem(world: World, eid: number): boolean;
+/**
+ * Animation system that updates all entities with Animation component.
+ *
+ * This system should be registered in the UPDATE phase of the game loop.
+ * It reads delta time from getDeltaTime() which is set by the scheduler.
+ *
+ * For each playing animation, the system:
+ * 1. Adds elapsed time (scaled by speed)
+ * 2. Checks if current frame duration exceeded
+ * 3. Advances to next frame (respecting direction)
+ * 4. Handles loop/stop when animation completes
+ * 5. Updates the entity's Sprite component frame
+ *
+ * @param world - The ECS world to process
+ * @returns The world (unchanged reference)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, LoopPhase, animationSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.UPDATE, animationSystem);
+ *
+ * // In game loop
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare const animationSystem: System;
+/**
+ * Creates a new animation system.
+ *
+ * Factory function that returns the animationSystem.
+ * Useful for cases where you need a fresh reference.
+ *
+ * @returns The animation system function
+ *
+ * @example
+ * ```typescript
+ * import { createAnimationSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * const system = createAnimationSystem();
+ * scheduler.registerSystem(LoopPhase.UPDATE, system);
+ * ```
+ */
+declare function createAnimationSystem(): System;
+/**
+ * Registers the animation system with a scheduler.
+ *
+ * Convenience function that registers animationSystem in the UPDATE phase.
+ *
+ * @param scheduler - The scheduler to register with
+ * @param priority - Optional priority within the UPDATE phase (default: 0)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, registerAnimationSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * registerAnimationSystem(scheduler);
+ *
+ * // Animation updates will now happen in UPDATE phase
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare function registerAnimationSystem(scheduler: Scheduler, priority?: number): void;
+/**
+ * Manually update animations for specific entities.
+ *
+ * Useful when you need to update animations outside of the system,
+ * such as in tests or custom update loops.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entity IDs to update
+ * @param deltaTime - Time elapsed in seconds
+ *
+ * @example
+ * ```typescript
+ * import { updateAnimations, queryAnimation } from 'blecsd';
+ *
+ * // Manual update (typically use the system instead)
+ * const entities = queryAnimation(world);
+ * updateAnimations(world, entities, 0.016); // ~60fps frame
+ * ```
+ */
+declare function updateAnimations(world: World, entities: readonly number[], deltaTime: number): void;
+
+/**
+ * Behavior system for processing AI behaviors each frame.
+ *
+ * Integrates with the Behavior component to update patrol movement,
+ * chase/flee logic, custom behaviors, and wait timers.
+ *
+ * @module systems/behaviorSystem
+ */
+
+/**
+ * Position resolver function for getting entity positions.
+ * Allows the behavior system to work with any position storage.
+ */
+type PositionResolver = (world: World, eid: Entity) => {
+    x: number;
+    y: number;
+} | undefined;
+/**
+ * Movement applier function for applying computed movement.
+ * Allows the behavior system to work with any movement system.
+ */
+type MovementApplier = (world: World, eid: Entity, dx: number, dy: number, delta: number) => void;
+/**
+ * Configuration for the behavior system.
+ */
+interface BehaviorSystemConfig {
+    /** Function to resolve entity positions (default: uses Position component) */
+    getPosition?: PositionResolver;
+    /** Function to apply movement (default: directly modifies Position) */
+    applyMovement?: MovementApplier;
+    /** Function to get delta time */
+    getDelta: () => number;
+}
+/**
+ * Creates a behavior system that processes all entities with Behavior components.
+ *
+ * The system computes movement directions for patrol, chase, and flee behaviors,
+ * and applies them via the configured movement applier.
+ *
+ * @param config - System configuration
+ * @param entities - Function returning entity IDs to process
+ * @returns A system function
+ *
+ * @example
+ * ```typescript
+ * import { createBehaviorSystem } from 'blecsd';
+ *
+ * const behaviorSystem = createBehaviorSystem({
+ *   getDelta: () => 1/60,
+ * }, () => behaviorEntities);
+ *
+ * // In update loop
+ * behaviorSystem(world);
+ * ```
+ */
+declare function createBehaviorSystem(config: BehaviorSystemConfig, entities: (world: World) => readonly Entity[]): System;
+
+/**
+ * Camera system for updating camera positions.
+ * Processes all entities with Camera component.
+ * @module systems/cameraSystem
+ */
+
+/**
+ * Query all entities with the Camera component.
+ *
+ * @param world - The ECS world
+ * @returns Array of entity IDs with Camera component
+ */
+declare function queryCameras(world: World): number[];
+/**
+ * Camera system that updates all cameras with follow targets.
+ *
+ * This system should be registered in the UPDATE phase, after movement.
+ * It updates camera positions to follow their targets with smoothing
+ * and dead zone support.
+ *
+ * @param world - The ECS world to process
+ * @returns The world (unchanged reference)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, LoopPhase, cameraSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.UPDATE, cameraSystem, 20); // After movement and collision
+ *
+ * // In game loop
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare const cameraSystem: System;
+/**
+ * Creates a new camera system.
+ *
+ * Factory function that returns the cameraSystem.
+ *
+ * @returns The camera system function
+ *
+ * @example
+ * ```typescript
+ * import { createCameraSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * const system = createCameraSystem();
+ * scheduler.registerSystem(LoopPhase.UPDATE, system, 20);
+ * ```
+ */
+declare function createCameraSystem(): System;
+/**
+ * Registers the camera system with a scheduler.
+ *
+ * Convenience function that registers cameraSystem in the UPDATE phase.
+ * Uses priority 20 by default to run after movement (priority 0) and collision (priority 10).
+ *
+ * @param scheduler - The scheduler to register with
+ * @param priority - Optional priority within the UPDATE phase (default: 20)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, registerCameraSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * registerCameraSystem(scheduler);
+ *
+ * // Camera updates will happen in UPDATE phase after movement
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare function registerCameraSystem(scheduler: Scheduler, priority?: number): void;
+/**
+ * Manually updates all cameras.
+ *
+ * Useful when you need to update cameras outside of the system,
+ * such as in tests or custom update loops.
+ *
+ * @param world - The ECS world
+ * @param deltaTime - Time elapsed in seconds
+ *
+ * @example
+ * ```typescript
+ * import { updateCameras } from 'blecsd';
+ *
+ * // Manual camera update (typically use the system instead)
+ * updateCameras(world, 0.016);
+ * ```
+ */
+declare function updateCameras(world: World, deltaTime: number): void;
+
+/**
+ * Collision system for detecting entity collisions.
+ * Processes all entities with Collider component.
+ * @module systems/collisionSystem
+ */
+
+/**
+ * Collision event data.
+ */
+interface CollisionEventData {
+    /** First entity in collision */
+    readonly entityA: number;
+    /** Second entity in collision */
+    readonly entityB: number;
+}
+/**
+ * Collision event map for the EventBus.
+ */
+interface CollisionEventMap {
+    /** Fired when two solid colliders start colliding */
+    collisionStart: CollisionEventData;
+    /** Fired when two solid colliders stop colliding */
+    collisionEnd: CollisionEventData;
+    /** Fired when an entity enters a trigger zone */
+    triggerEnter: CollisionEventData;
+    /** Fired when an entity exits a trigger zone */
+    triggerExit: CollisionEventData;
+}
+/**
+ * Collision system state.
+ */
+interface CollisionSystemState {
+    /** Event bus for collision events */
+    readonly eventBus: EventBus<CollisionEventMap>;
+    /** Currently active collision pairs */
+    readonly activePairs: Map<string, CollisionPair>;
+    /** Currently active trigger pairs */
+    readonly activeTriggers: Map<string, CollisionPair>;
+}
+/**
+ * Gets the collision event bus.
+ *
+ * @returns The collision event bus
+ *
+ * @example
+ * ```typescript
+ * import { getCollisionEventBus } from 'blecsd';
+ *
+ * const bus = getCollisionEventBus();
+ * bus.on('collisionStart', ({ entityA, entityB }) => {
+ *   console.log(`Collision between ${entityA} and ${entityB}`);
+ * });
+ * ```
+ */
+declare function getCollisionEventBus(): EventBus<CollisionEventMap>;
+/**
+ * Gets the current active collision pairs.
+ *
+ * @returns Map of active collision pairs
+ */
+declare function getActiveCollisions(): ReadonlyMap<string, CollisionPair>;
+/**
+ * Gets the current active trigger pairs.
+ *
+ * @returns Map of active trigger pairs
+ */
+declare function getActiveTriggers(): ReadonlyMap<string, CollisionPair>;
+/**
+ * Resets the collision system state.
+ * Useful for testing or scene changes.
+ */
+declare function resetCollisionState(): void;
+/**
+ * Query all entities with the Collider component.
+ *
+ * @param world - The ECS world
+ * @returns Array of entity IDs with Collider component
+ */
+declare function queryColliders(world: World): number[];
+/**
+ * Detects all collisions between entities in the world.
+ * Uses a simple O(n^2) broad phase (suitable for small entity counts).
+ *
+ * @param world - The ECS world
+ * @returns Array of collision pairs
+ */
+declare function detectCollisions(world: World): CollisionPair[];
+/**
+ * Collision system that detects collisions and emits events.
+ *
+ * This system should be registered in the UPDATE phase, after movement.
+ * It detects all collisions between entities with Collider and Position
+ * components, and emits events for collision start/end and trigger enter/exit.
+ *
+ * @param world - The ECS world to process
+ * @returns The world (unchanged reference)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, LoopPhase, collisionSystem, getCollisionEventBus } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.UPDATE, collisionSystem, 10); // After movement
+ *
+ * // Listen for collisions
+ * const bus = getCollisionEventBus();
+ * bus.on('collisionStart', ({ entityA, entityB }) => {
+ *   console.log(`Collision: ${entityA} hit ${entityB}`);
+ * });
+ * ```
+ */
+declare const collisionSystem: System;
+/**
+ * Creates a new collision system.
+ *
+ * Factory function that returns the collisionSystem.
+ *
+ * @returns The collision system function
+ *
+ * @example
+ * ```typescript
+ * import { createCollisionSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * const system = createCollisionSystem();
+ * scheduler.registerSystem(LoopPhase.UPDATE, system, 10);
+ * ```
+ */
+declare function createCollisionSystem(): System;
+/**
+ * Registers the collision system with a scheduler.
+ *
+ * Convenience function that registers collisionSystem in the UPDATE phase.
+ * Uses priority 10 by default to run after movement (priority 0).
+ *
+ * @param scheduler - The scheduler to register with
+ * @param priority - Optional priority within the UPDATE phase (default: 10)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, registerCollisionSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * registerCollisionSystem(scheduler);
+ *
+ * // Collisions will be detected after movement
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare function registerCollisionSystem(scheduler: Scheduler, priority?: number): void;
+/**
+ * Checks if an entity is currently colliding with any other entity.
+ *
+ * @param eid - The entity to check
+ * @returns true if entity is in any active collision
+ *
+ * @example
+ * ```typescript
+ * import { isColliding } from 'blecsd';
+ *
+ * if (isColliding(player)) {
+ *   console.log('Player is touching something!');
+ * }
+ * ```
+ */
+declare function isColliding(eid: number): boolean;
+/**
+ * Checks if an entity is currently in any trigger zone.
+ *
+ * @param eid - The entity to check
+ * @returns true if entity is in any active trigger
+ *
+ * @example
+ * ```typescript
+ * import { isInTrigger } from 'blecsd';
+ *
+ * if (isInTrigger(player)) {
+ *   console.log('Player is in a trigger zone!');
+ * }
+ * ```
+ */
+declare function isInTrigger(eid: number): boolean;
+/**
+ * Gets all entities currently colliding with a specific entity.
+ *
+ * @param eid - The entity to check
+ * @returns Array of entity IDs colliding with this entity
+ *
+ * @example
+ * ```typescript
+ * import { getCollidingEntities } from 'blecsd';
+ *
+ * const enemies = getCollidingEntities(player);
+ * for (const enemy of enemies) {
+ *   // Handle collision with each enemy
+ * }
+ * ```
+ */
+declare function getCollidingEntities(eid: number): number[];
+/**
+ * Gets all trigger zones an entity is currently in.
+ *
+ * @param eid - The entity to check
+ * @returns Array of entity IDs of triggers this entity is in
+ *
+ * @example
+ * ```typescript
+ * import { getTriggerZones } from 'blecsd';
+ *
+ * const zones = getTriggerZones(player);
+ * for (const zone of zones) {
+ *   // Handle being in each zone
+ * }
+ * ```
+ */
+declare function getTriggerZones(eid: number): number[];
+/**
+ * Checks if two specific entities are currently colliding.
+ *
+ * @param eidA - First entity
+ * @param eidB - Second entity
+ * @returns true if the entities are colliding
+ *
+ * @example
+ * ```typescript
+ * import { areColliding } from 'blecsd';
+ *
+ * if (areColliding(player, enemy)) {
+ *   // Handle player-enemy collision
+ * }
+ * ```
+ */
+declare function areColliding(eidA: number, eidB: number): boolean;
+
+/**
+ * Drag and drop system for interactive entities.
+ *
+ * Handles drag initiation, position updates during drag, and drop handling.
+ * Supports constraints like parent bounds, axis locking, and grid snapping.
+ *
+ * @module systems/dragSystem
+ */
+
+/**
+ * Drag constraint configuration.
+ */
+interface DragConstraints {
+    /** Constrain to parent bounds */
+    constrainToParent?: boolean;
+    /** Lock to a single axis */
+    constrainAxis?: 'x' | 'y' | null;
+    /** Snap to grid */
+    snapToGrid?: {
+        x: number;
+        y: number;
+    } | null;
+    /** Minimum X position */
+    minX?: number;
+    /** Maximum X position */
+    maxX?: number;
+    /** Minimum Y position */
+    minY?: number;
+    /** Maximum Y position */
+    maxY?: number;
+    /** Bring entity to front (highest z-index) when dragging starts */
+    bringToFront?: boolean;
+    /** Z-index to use when bringing to front */
+    frontZIndex?: number;
+}
+/**
+ * Drag verification callback.
+ * Return false to cancel the drag movement.
+ */
+type DragVerifyCallback = (entity: Entity, dx: number, dy: number) => boolean;
+/**
+ * Drag start event data.
+ */
+interface DragStartEvent {
+    /** Entity being dragged */
+    entity: Entity;
+    /** Starting X position */
+    startX: number;
+    /** Starting Y position */
+    startY: number;
+    /** Mouse X at drag start */
+    mouseX: number;
+    /** Mouse Y at drag start */
+    mouseY: number;
+}
+/**
+ * Drag move event data.
+ */
+interface DragMoveEvent {
+    /** Entity being dragged */
+    entity: Entity;
+    /** Current X position */
+    x: number;
+    /** Current Y position */
+    y: number;
+    /** Change in X since last move */
+    dx: number;
+    /** Change in Y since last move */
+    dy: number;
+    /** Current mouse X */
+    mouseX: number;
+    /** Current mouse Y */
+    mouseY: number;
+}
+/**
+ * Drag end event data.
+ */
+interface DragEndEvent {
+    /** Entity that was dragged */
+    entity: Entity;
+    /** Final X position */
+    x: number;
+    /** Final Y position */
+    y: number;
+    /** Total change in X */
+    totalDx: number;
+    /** Total change in Y */
+    totalDy: number;
+    /** Whether drag was cancelled */
+    cancelled: boolean;
+}
+/**
+ * Drop event data.
+ */
+interface DropEvent {
+    /** Entity that was dropped */
+    entity: Entity;
+    /** Drop X position */
+    x: number;
+    /** Drop Y position */
+    y: number;
+    /** Entity under drop point (if any) */
+    dropTarget: Entity | null;
+}
+/**
+ * Drag system event map.
+ */
+interface DragEventMap {
+    dragstart: DragStartEvent;
+    drag: DragMoveEvent;
+    dragend: DragEndEvent;
+    drop: DropEvent;
+}
+/**
+ * Current drag state.
+ */
+interface DragState {
+    /** Entity currently being dragged */
+    dragging: Entity | null;
+    /** Starting position of drag */
+    startX: number;
+    startY: number;
+    /** Mouse offset from entity origin at drag start */
+    offsetX: number;
+    offsetY: number;
+    /** Last known position during drag */
+    lastX: number;
+    lastY: number;
+    /** Constraints for current drag */
+    constraints: DragConstraints;
+    /** Verification callback */
+    verifyCallback: DragVerifyCallback | null;
+}
+/**
+ * Sets drag constraints for an entity.
+ *
+ * @param eid - The entity ID
+ * @param constraints - Drag constraints
+ *
+ * @example
+ * ```typescript
+ * import { setDragConstraints } from 'blecsd';
+ *
+ * // Constrain to parent bounds
+ * setDragConstraints(entity, { constrainToParent: true });
+ *
+ * // Lock to horizontal axis with grid snap
+ * setDragConstraints(entity, {
+ *   constrainAxis: 'x',
+ *   snapToGrid: { x: 10, y: 10 }
+ * });
+ * ```
+ */
+declare function setDragConstraints(eid: Entity, constraints: DragConstraints): void;
+/**
+ * Gets drag constraints for an entity.
+ *
+ * @param eid - The entity ID
+ * @returns Drag constraints or empty object
+ */
+declare function getDragConstraints(eid: Entity): DragConstraints;
+/**
+ * Clears drag constraints for an entity.
+ *
+ * @param eid - The entity ID
+ */
+declare function clearDragConstraints(eid: Entity): void;
+/**
+ * Sets a drag verification callback for an entity.
+ *
+ * @param eid - The entity ID
+ * @param callback - Verification callback (return false to cancel movement)
+ *
+ * @example
+ * ```typescript
+ * import { setDragVerifyCallback } from 'blecsd';
+ *
+ * // Prevent dragging into certain areas
+ * setDragVerifyCallback(entity, (entity, dx, dy) => {
+ *   const newX = Position.x[entity] + dx;
+ *   const newY = Position.y[entity] + dy;
+ *
+ *   // Don't allow dragging into forbidden zone
+ *   if (newX > 50 && newX < 60) return false;
+ *
+ *   return true;
+ * });
+ * ```
+ */
+declare function setDragVerifyCallback(eid: Entity, callback: DragVerifyCallback | null): void;
+/**
+ * Gets the drag verification callback for an entity.
+ *
+ * @param eid - The entity ID
+ * @returns The verification callback or null
+ */
+declare function getDragVerifyCallback(eid: Entity): DragVerifyCallback | null;
+/**
+ * Creates a drag system with event handling.
+ *
+ * @param eventBus - Event bus for drag events
+ * @returns Drag system API
+ *
+ * @example
+ * ```typescript
+ * import { createDragSystem, createEventBus } from 'blecsd';
+ *
+ * const dragEvents = createEventBus<DragEventMap>();
+ * const dragSystem = createDragSystem(dragEvents);
+ *
+ * // Listen for drag events
+ * dragEvents.on('dragstart', (e) => {
+ *   console.log(`Started dragging entity ${e.entity}`);
+ * });
+ *
+ * dragEvents.on('drag', (e) => {
+ *   console.log(`Dragged to ${e.x}, ${e.y}`);
+ * });
+ *
+ * dragEvents.on('dragend', (e) => {
+ *   console.log(`Drag ended, cancelled: ${e.cancelled}`);
+ * });
+ *
+ * // In mouse event handler
+ * function onMouseDown(x: number, y: number, entity: Entity) {
+ *   if (dragSystem.canDrag(world, entity)) {
+ *     dragSystem.startDrag(world, entity, x, y);
+ *   }
+ * }
+ *
+ * function onMouseMove(x: number, y: number) {
+ *   dragSystem.updateDrag(world, x, y);
+ * }
+ *
+ * function onMouseUp(x: number, y: number, dropTarget: Entity | null) {
+ *   dragSystem.endDrag(world, dropTarget);
+ * }
+ * ```
+ */
+declare function createDragSystem(eventBus: EventBus<DragEventMap>): {
+    /**
+     * Gets the current drag state.
+     */
+    getState(): Readonly<DragState>;
+    /**
+     * Checks if an entity is currently being dragged.
+     */
+    isDragging(): boolean;
+    /**
+     * Gets the entity currently being dragged.
+     */
+    getDraggingEntity(): Entity | null;
+    /**
+     * Checks if an entity can be dragged.
+     *
+     * @param world - The ECS world
+     * @param eid - The entity to check
+     */
+    canDrag(world: World, eid: Entity): boolean;
+    /**
+     * Starts dragging an entity.
+     *
+     * @param world - The ECS world
+     * @param eid - The entity to drag
+     * @param mouseX - Current mouse X
+     * @param mouseY - Current mouse Y
+     * @returns True if drag started successfully
+     */
+    startDrag(world: World, eid: Entity, mouseX: number, mouseY: number): boolean;
+    /**
+     * Updates the drag position based on mouse movement.
+     *
+     * @param world - The ECS world
+     * @param mouseX - Current mouse X
+     * @param mouseY - Current mouse Y
+     * @returns True if position was updated
+     */
+    updateDrag(world: World, mouseX: number, mouseY: number): boolean;
+    /**
+     * Ends the current drag operation.
+     *
+     * @param world - The ECS world
+     * @param dropTarget - Entity under the drop point (if any)
+     * @param cancelled - Whether the drag was cancelled
+     */
+    endDrag(world: World, dropTarget?: Entity | null, cancelled?: boolean): void;
+    /**
+     * Cancels the current drag and restores original position.
+     *
+     * @param world - The ECS world
+     */
+    cancelDrag(world: World): void;
+};
+/**
+ * Resets all drag-related stores.
+ * Useful for testing.
+ */
+declare function resetDragStores(): void;
+
+/**
+ * Focus Management System
+ *
+ * Handles keyboard focus navigation and focus state management.
+ * Tracks which entity is focused and provides tab/arrow navigation.
+ *
+ * @module systems/focusSystem
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   focusSystem,
+ *   focusNext,
+ *   focusPrev,
+ *   focusEntity,
+ *   getFocused,
+ *   blurAll,
+ * } from 'blecsd';
+ *
+ * // Register with scheduler
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.INPUT, focusSystem);
+ *
+ * // Navigate focus
+ * focusNext(world);  // Focus next element
+ * focusPrev(world);  // Focus previous element
+ *
+ * // Direct focus
+ * focusEntity(world, buttonEntity);
+ *
+ * // Check current focus
+ * const focused = getFocused(world);
+ * ```
+ */
+
+/**
+ * Focus event types.
+ */
+type FocusEventType = 'focus' | 'blur';
+/**
+ * Focus event data.
+ */
+interface FocusEventData {
+    /** The entity gaining/losing focus */
+    readonly entity: Entity;
+    /** The previously focused entity (for focus events) */
+    readonly previousEntity: Entity | null;
+    /** The next focused entity (for blur events) */
+    readonly nextEntity: Entity | null;
+}
+/**
+ * Focus event map for type-safe event handling.
+ */
+interface FocusEventMap {
+    focus: FocusEventData;
+    blur: FocusEventData;
+}
+/**
+ * Gets the focus event bus, creating if needed.
+ *
+ * @returns The focus event bus
+ *
+ * @example
+ * ```typescript
+ * const bus = getFocusEventBus();
+ * bus.on('focus', (data) => {
+ *   console.log(`Entity ${data.entity} focused`);
+ * });
+ * ```
+ */
+declare function getFocusEventBus(): EventBus<FocusEventMap>;
+/**
+ * Resets the focus event bus. Used for testing.
+ * @internal
+ */
+declare function resetFocusEventBus(): void;
+/**
+ * Gets all focusable entities sorted by tab order.
+ *
+ * @param world - The ECS world
+ * @returns Sorted array of focusable entity IDs
+ */
+declare function getFocusableEntities(world: World): Entity[];
+/**
+ * Gets the currently focused entity.
+ *
+ * @param world - The ECS world
+ * @returns The focused entity or null if none focused
+ *
+ * @example
+ * ```typescript
+ * const focused = getFocused(world);
+ * if (focused) {
+ *   console.log(`Entity ${focused} is focused`);
+ * }
+ * ```
+ */
+declare function getFocused(world: World): Entity | null;
+/**
+ * Focuses a specific entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to focus
+ * @returns true if focus was set successfully
+ *
+ * @example
+ * ```typescript
+ * focusEntity(world, buttonEntity);
+ * ```
+ */
+declare function focusEntity(world: World, eid: Entity): boolean;
+/**
+ * Removes focus from all entities.
+ *
+ * @param world - The ECS world
+ *
+ * @example
+ * ```typescript
+ * blurAll(world);
+ * ```
+ */
+declare function blurAll(world: World): void;
+/**
+ * Focuses the next focusable entity in tab order.
+ *
+ * @param world - The ECS world
+ * @returns The newly focused entity, or null if none available
+ *
+ * @example
+ * ```typescript
+ * // Handle Tab key
+ * if (key === 'Tab') {
+ *   focusNext(world);
+ * }
+ * ```
+ */
+declare function focusNext(world: World): Entity | null;
+/**
+ * Focuses the previous focusable entity in tab order.
+ *
+ * @param world - The ECS world
+ * @returns The newly focused entity, or null if none available
+ *
+ * @example
+ * ```typescript
+ * // Handle Shift+Tab key
+ * if (key === 'Tab' && shiftKey) {
+ *   focusPrev(world);
+ * }
+ * ```
+ */
+declare function focusPrev(world: World): Entity | null;
+/**
+ * Focuses the first focusable entity.
+ *
+ * @param world - The ECS world
+ * @returns The focused entity, or null if none available
+ */
+declare function focusFirst(world: World): Entity | null;
+/**
+ * Focuses the last focusable entity.
+ *
+ * @param world - The ECS world
+ * @returns The focused entity, or null if none available
+ */
+declare function focusLast(world: World): Entity | null;
+/**
+ * Pushes current focus onto the stack and focuses a new entity.
+ *
+ * Use this when opening modals or popups to preserve the previous focus
+ * state for restoration later.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to focus (e.g., modal or popup)
+ * @returns true if push was successful
+ *
+ * @example
+ * ```typescript
+ * import { focusPush, focusPop } from 'blecsd';
+ *
+ * // Open modal - save current focus and focus modal
+ * function openModal(world: World, modalEntity: Entity): void {
+ *   focusPush(world, modalEntity);
+ * }
+ *
+ * // Close modal - restore previous focus
+ * function closeModal(world: World): void {
+ *   focusPop(world);
+ * }
+ * ```
+ */
+declare function focusPush(world: World, eid: Entity): boolean;
+/**
+ * Pops the focus stack and restores the previous focus.
+ *
+ * Use this when closing modals or popups to restore focus to the
+ * element that was focused before.
+ *
+ * @param world - The ECS world
+ * @returns The restored entity, or null if stack was empty
+ *
+ * @example
+ * ```typescript
+ * import { focusPop } from 'blecsd';
+ *
+ * // Close modal and restore focus
+ * const previousFocus = focusPop(world);
+ * if (previousFocus) {
+ *   console.log(`Focus restored to entity ${previousFocus}`);
+ * }
+ * ```
+ */
+declare function focusPop(world: World): Entity | null;
+/**
+ * Saves the current focus without affecting the stack.
+ *
+ * Use this for temporary focus changes that need to be restored
+ * without the full stack mechanism.
+ *
+ * @param world - The ECS world
+ *
+ * @example
+ * ```typescript
+ * import { saveFocus, restoreFocus } from 'blecsd';
+ *
+ * // Save current focus before temporary change
+ * saveFocus(world);
+ *
+ * // ... do something that changes focus ...
+ *
+ * // Restore the saved focus
+ * restoreFocus(world);
+ * ```
+ */
+declare function saveFocus(world: World): void;
+/**
+ * Restores the previously saved focus.
+ *
+ * @param world - The ECS world
+ * @returns The restored entity, or null if no saved focus or entity invalid
+ *
+ * @example
+ * ```typescript
+ * import { restoreFocus } from 'blecsd';
+ *
+ * const restored = restoreFocus(world);
+ * ```
+ */
+declare function restoreFocus(world: World): Entity | null;
+/**
+ * Rewinds focus to the last valid entity in the stack.
+ *
+ * This is useful when the currently focused entity is destroyed or
+ * becomes unfocusable. It searches backwards through the focus stack
+ * to find an entity that still exists and is focusable.
+ *
+ * @param world - The ECS world
+ * @returns The entity that received focus, or null if none found
+ *
+ * @example
+ * ```typescript
+ * import { rewindFocus } from 'blecsd';
+ *
+ * // After destroying a focused entity
+ * rewindFocus(world);
+ * ```
+ */
+declare function rewindFocus(world: World): Entity | null;
+/**
+ * Moves focus by a specified offset in the tab order.
+ *
+ * Positive offset moves forward (like Tab), negative moves backward
+ * (like Shift+Tab). The offset wraps around at the ends.
+ *
+ * @param world - The ECS world
+ * @param offset - Number of positions to move (positive=forward, negative=backward)
+ * @returns The newly focused entity, or null if none available
+ *
+ * @example
+ * ```typescript
+ * import { focusOffset } from 'blecsd';
+ *
+ * // Move focus forward by 2
+ * focusOffset(world, 2);
+ *
+ * // Move focus backward by 1
+ * focusOffset(world, -1);
+ * ```
+ */
+declare function focusOffset(world: World, offset: number): Entity | null;
+/**
+ * Gets the current focus stack depth.
+ *
+ * @param world - The ECS world
+ * @returns Number of entries in the focus stack
+ */
+declare function getFocusStackDepth(world: World): number;
+/**
+ * Clears the focus stack.
+ *
+ * Use with caution - this removes all saved focus states.
+ *
+ * @param world - The ECS world
+ */
+declare function clearFocusStack(world: World): void;
+/**
+ * Peeks at the top of the focus stack without popping.
+ *
+ * @param world - The ECS world
+ * @returns The entity at the top of the stack, or null if empty
+ */
+declare function peekFocusStack(world: World): Entity | null;
+/**
+ * Focus system that processes focus-related input.
+ *
+ * Currently this system validates focus state (ensuring focused entity
+ * is still focusable and visible). Tab key handling should be done
+ * in the input system or user code.
+ *
+ * @param world - The ECS world
+ * @returns The world
+ *
+ * @example
+ * ```typescript
+ * import { focusSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.INPUT, focusSystem);
+ * ```
+ */
+declare const focusSystem: System;
+/**
+ * Creates a focus system.
+ *
+ * @returns A new focus system function
+ */
+declare function createFocusSystem(): System;
+
+/**
+ * Frame budget manager and profiling.
+ *
+ * Measures per-system timing, tracks rolling statistics, and enforces
+ * configurable frame time budgets per phase. Optional on-screen debug overlay.
+ *
+ * @module systems/frameBudget
+ */
+
+/**
+ * Configuration for the frame budget manager.
+ */
+interface FrameBudgetConfig {
+    /** Target frame time in ms (default: 16.67 = 60fps) */
+    readonly targetFrameMs: number;
+    /** Per-phase budget overrides in ms (phase -> budget) */
+    readonly phaseBudgets: Readonly<Partial<Record<LoopPhase, number>>>;
+    /** Number of frames to keep in rolling stats (default: 120) */
+    readonly rollingWindowSize: number;
+    /** Whether to emit warnings on budget overruns (default: true) */
+    readonly warnOnOverrun: boolean;
+}
+/**
+ * Per-system timing record.
+ */
+interface SystemTiming {
+    readonly name: string;
+    readonly lastMs: number;
+    readonly avgMs: number;
+    readonly minMs: number;
+    readonly maxMs: number;
+    readonly p50Ms: number;
+    readonly p95Ms: number;
+    readonly p99Ms: number;
+    readonly count: number;
+}
+/**
+ * Frame-level statistics.
+ */
+interface FrameStats {
+    readonly frameTimeMs: number;
+    readonly avgFrameMs: number;
+    readonly p50FrameMs: number;
+    readonly p95FrameMs: number;
+    readonly p99FrameMs: number;
+    readonly fps: number;
+    readonly avgFps: number;
+    readonly totalFrames: number;
+    readonly budgetOverruns: number;
+    readonly systemTimings: readonly SystemTiming[];
+    readonly phaseTimings: Readonly<Record<string, number>>;
+}
+/**
+ * Budget alert emitted when a phase exceeds its budget.
+ */
+interface BudgetAlert {
+    readonly phase: LoopPhase;
+    readonly budgetMs: number;
+    readonly actualMs: number;
+    readonly frame: number;
+}
+/**
+ * Frame budget manager state.
+ */
+interface FrameBudgetManager {
+    readonly config: FrameBudgetConfig;
+    readonly stats: FrameStats;
+    readonly alerts: readonly BudgetAlert[];
+}
+/**
+ * Creates and activates the frame budget manager.
+ *
+ * @param config - Optional configuration overrides
+ * @returns The frame budget manager
+ *
+ * @example
+ * ```typescript
+ * import { createFrameBudgetManager } from 'blecsd';
+ *
+ * const manager = createFrameBudgetManager({ targetFrameMs: 16.67 });
+ * ```
+ */
+declare function createFrameBudgetManager(config?: Partial<FrameBudgetConfig>): FrameBudgetManager;
+/**
+ * Records the execution time of a named system.
+ *
+ * @param name - The system name
+ * @param timeMs - Execution time in milliseconds
+ */
+declare function recordFrameBudgetSystemTime(name: string, timeMs: number): void;
+/**
+ * Records phase completion time and checks budget.
+ *
+ * @param phase - The loop phase
+ * @param timeMs - Phase execution time in milliseconds
+ */
+declare function recordPhaseTime(phase: LoopPhase, timeMs: number): void;
+/**
+ * Records a complete frame time.
+ *
+ * @param frameTimeMs - Total frame time in milliseconds
+ */
+declare function recordFrameTime(frameTimeMs: number): void;
+/**
+ * Wraps a system with automatic timing.
+ *
+ * @param name - The system name for profiling
+ * @param system - The system function to wrap
+ * @returns A wrapped system that records its execution time
+ *
+ * @example
+ * ```typescript
+ * import { profiledSystem } from 'blecsd';
+ *
+ * const timedMovement = profiledSystem('movement', movementSystem);
+ * scheduler.registerSystem(LoopPhase.UPDATE, timedMovement);
+ * ```
+ */
+declare function profiledSystem(name: string, system: System): System;
+/**
+ * Gets current frame budget statistics.
+ *
+ * @returns The current stats snapshot
+ */
+declare function getFrameBudgetStats(): FrameBudgetManager;
+/**
+ * Registers a callback for budget overrun alerts.
+ *
+ * @param callback - Alert handler
+ */
+declare function onBudgetAlert(callback: (alert: BudgetAlert) => void): void;
+/**
+ * Resets all profiling data.
+ */
+declare function resetFrameBudget(): void;
+/**
+ * Destroys the frame budget manager.
+ */
+declare function destroyFrameBudgetManager(): void;
+/**
+ * Exports metrics as a JSON-serializable object for external analysis.
+ *
+ * @returns Metrics data
+ */
+declare function exportFrameBudgetMetrics(): Record<string, unknown>;
+
+/**
+ * Input system for processing keyboard and mouse events.
+ * Handles hit testing, focus management, and event dispatch.
+ * @module systems/inputSystem
+ */
+
+/**
+ * Input event types that can be queued.
+ */
+type InputEventType = 'key' | 'mouse';
+/**
+ * Queued key event.
+ */
+interface QueuedKeyEvent {
+    type: 'key';
+    event: KeyEvent;
+    timestamp: number;
+}
+/**
+ * Queued mouse event.
+ */
+interface QueuedMouseEvent {
+    type: 'mouse';
+    event: MouseEvent;
+    timestamp: number;
+}
+/**
+ * Union of all queued input events.
+ */
+type QueuedInputEvent = QueuedKeyEvent | QueuedMouseEvent;
+/**
+ * Result of hit testing a point.
+ */
+interface HitTestResult {
+    /** Entity that was hit */
+    entity: Entity;
+    /** Local X coordinate within the entity */
+    localX: number;
+    /** Local Y coordinate within the entity */
+    localY: number;
+    /** Z-index of the entity */
+    zIndex: number;
+}
+/**
+ * Input system state and configuration.
+ */
+interface InputSystemState {
+    /** Queue of pending input events */
+    eventQueue: QueuedInputEvent[];
+    /** Entity that currently has mouse capture (for drag operations) */
+    capturedEntity: Entity | null;
+    /** Last known mouse position */
+    lastMouseX: number;
+    lastMouseY: number;
+    /** Entity under the mouse last frame */
+    lastHoveredEntity: Entity | null;
+    /** Global event bus for dispatching UI events */
+    eventBus: EventBus<UIEventMap>;
+}
+/**
+ * Global input system state.
+ * Can be accessed and modified for testing or custom input handling.
+ */
+declare const inputState: InputSystemState;
+/**
+ * Resets input system state.
+ * Useful for testing or when reinitializing the input system.
+ *
+ * @example
+ * ```typescript
+ * import { resetInputState } from 'blecsd';
+ *
+ * // Clear all pending events and state
+ * resetInputState();
+ * ```
+ */
+declare function resetInputState(): void;
+/**
+ * Queues a keyboard event for processing.
+ *
+ * @param event - The parsed key event from the input stream
+ *
+ * @example
+ * ```typescript
+ * import { queueKeyEvent } from 'blecsd';
+ *
+ * // Queue a key event for next frame
+ * queueKeyEvent({ name: 'a', ctrl: false, meta: false, shift: false, raw: 'a' });
+ * ```
+ */
+declare function queueKeyEvent(event: KeyEvent): void;
+/**
+ * Queues a mouse event for processing.
+ *
+ * @param event - The parsed mouse event from the input stream
+ *
+ * @example
+ * ```typescript
+ * import { queueMouseEvent } from 'blecsd';
+ *
+ * // Queue a mouse event for next frame
+ * queueMouseEvent({ x: 10, y: 5, button: 'left', action: 'press', raw: '' });
+ * ```
+ */
+declare function queueMouseEvent(event: MouseEvent): void;
+/**
+ * Gets the current event queue.
+ * Mainly useful for debugging and testing.
+ */
+declare function getEventQueue(): readonly QueuedInputEvent[];
+/**
+ * Clears all queued events.
+ */
+declare function clearEventQueue(): void;
+/**
+ * Gets the global input event bus.
+ * Use this to subscribe to UI events from anywhere.
+ *
+ * @returns The global UI event bus
+ *
+ * @example
+ * ```typescript
+ * import { getInputEventBus } from 'blecsd';
+ *
+ * const eventBus = getInputEventBus();
+ * eventBus.on('click', (event) => {
+ *   console.log(`Clicked at ${event.x}, ${event.y}`);
+ * });
+ * ```
+ */
+declare function getInputEventBus(): EventBus<UIEventMap>;
+/**
+ * Captures mouse events to a specific entity.
+ * While captured, all mouse events are sent to this entity
+ * regardless of hit testing. Used for drag operations.
+ *
+ * @param entity - Entity to capture events to, or null to release
+ *
+ * @example
+ * ```typescript
+ * import { captureMouseTo, releaseMouse } from 'blecsd';
+ *
+ * // Start drag
+ * captureMouseTo(entityId);
+ *
+ * // End drag
+ * releaseMouse();
+ * ```
+ */
+declare function captureMouseTo(entity: Entity | null): void;
+/**
+ * Releases mouse capture.
+ */
+declare function releaseMouse(): void;
+/**
+ * Checks if an entity is currently capturing mouse events.
+ */
+declare function isMouseCaptured(): boolean;
+/**
+ * Gets the entity currently capturing mouse events.
+ */
+declare function getMouseCaptureEntity(): Entity | null;
+/**
+ * Tests if a point is inside an entity's bounding box.
+ * Uses Position and Dimensions components.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity to test
+ * @param x - X coordinate to test
+ * @param y - Y coordinate to test
+ * @returns true if point is inside entity bounds
+ *
+ * @example
+ * ```typescript
+ * import { pointInEntity } from 'blecsd';
+ *
+ * if (pointInEntity(world, entity, mouseX, mouseY)) {
+ *   console.log('Mouse is over entity');
+ * }
+ * ```
+ */
+declare function pointInEntity(world: World, eid: Entity, x: number, y: number): boolean;
+/**
+ * Performs hit testing at a point to find all entities under it.
+ * Returns entities sorted by z-index (highest first).
+ *
+ * @param world - The ECS world
+ * @param x - X coordinate to test
+ * @param y - Y coordinate to test
+ * @returns Array of hit test results, sorted by z-index (highest first)
+ *
+ * @example
+ * ```typescript
+ * import { hitTest } from 'blecsd';
+ *
+ * const hits = hitTest(world, mouseX, mouseY);
+ * if (hits.length > 0) {
+ *   const topEntity = hits[0].entity;
+ *   console.log(`Top entity at click: ${topEntity}`);
+ * }
+ * ```
+ */
+declare function hitTest(world: World, x: number, y: number): HitTestResult[];
+/**
+ * Gets the topmost interactive entity at a point.
+ * Only returns entities that can receive input.
+ *
+ * @param world - The ECS world
+ * @param x - X coordinate to test
+ * @param y - Y coordinate to test
+ * @returns The topmost interactive entity or null
+ */
+declare function getInteractiveEntityAt(world: World, x: number, y: number): Entity | null;
+/**
+ * The input system processes all queued input events.
+ * This system should be registered in the INPUT phase (automatically protected).
+ *
+ * The system:
+ * 1. Processes all queued key and mouse events
+ * 2. Updates KeyboardInput and MouseInput components
+ * 3. Performs hit testing for mouse events
+ * 4. Updates Interactive component state (hovered, pressed)
+ * 5. Manages focus changes (click to focus, Tab navigation)
+ * 6. Dispatches UI events to the event bus
+ *
+ * @param world - The ECS world to process
+ * @returns The world (unchanged reference)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, inputSystem, registerInputSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * registerInputSystem(scheduler);
+ *
+ * // In game loop
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare const inputSystem: System;
+/**
+ * Creates a new input system.
+ *
+ * Factory function that returns the inputSystem.
+ * Useful for cases where you need a fresh reference.
+ *
+ * @returns The input system function
+ *
+ * @example
+ * ```typescript
+ * import { createInputSystem, createScheduler } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * const system = createInputSystem();
+ * // Note: Use registerInputSystem instead for proper INPUT phase registration
+ * ```
+ */
+declare function createInputSystem(): System;
+/**
+ * Registers the input system with a scheduler.
+ *
+ * Registers inputSystem in the protected INPUT phase.
+ * This ensures input is always processed first.
+ *
+ * @param scheduler - The scheduler to register with
+ * @param priority - Optional priority within the INPUT phase (default: 0)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, registerInputSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * registerInputSystem(scheduler);
+ *
+ * // Input events will now be processed in INPUT phase
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare function registerInputSystem(scheduler: Scheduler, priority?: number): void;
+/**
+ * Clears input state for an entity.
+ * Resets KeyboardInput and MouseInput components to default state.
+ *
+ * @param world - The ECS world
+ * @param eid - Entity to clear input state for
+ *
+ * @example
+ * ```typescript
+ * import { clearEntityInput } from 'blecsd';
+ *
+ * // Clear all input state when entity loses focus
+ * clearEntityInput(world, entity);
+ * ```
+ */
+declare function clearEntityInput(world: World, eid: Entity): void;
+/**
+ * Query all entities that can receive input.
+ * Returns entities with either Interactive or Focusable components.
+ *
+ * @param world - The ECS world
+ * @returns Array of entity IDs that can receive input
+ */
+declare function queryInputReceivers(world: World): number[];
+
+/**
+ * Layout system for computing entity positions and dimensions.
+ * Runs in the LAYOUT phase to pre-compute absolute positions in tree order.
+ * @module systems/layoutSystem
+ */
+
+/**
+ * Computed Layout component stores the final computed positions and dimensions.
+ * This component is written by the layout system and read by the render system.
+ *
+ * @example
+ * ```typescript
+ * import { ComputedLayout, getComputedLayout } from 'blecsd';
+ *
+ * // After layout system runs, computed values are available
+ * const layout = getComputedLayout(world, entity);
+ * if (layout) {
+ *   console.log(`Absolute: (${layout.x}, ${layout.y})`);
+ *   console.log(`Size: ${layout.width}x${layout.height}`);
+ * }
+ * ```
+ */
+declare const ComputedLayout: {
+    /** Computed absolute X position (screen column) */
+    x: Float32Array<ArrayBuffer>;
+    /** Computed absolute Y position (screen row) */
+    y: Float32Array<ArrayBuffer>;
+    /** Computed width in cells */
+    width: Float32Array<ArrayBuffer>;
+    /** Computed height in cells */
+    height: Float32Array<ArrayBuffer>;
+    /** Whether layout is valid (0 = needs recompute, 1 = valid) */
+    valid: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Computed layout data returned by getComputedLayout.
+ */
+interface ComputedLayoutData {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Gets the computed layout of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Computed layout data or undefined if not available
+ *
+ * @example
+ * ```typescript
+ * const layout = getComputedLayout(world, entity);
+ * if (layout) {
+ *   console.log(`Position: (${layout.x}, ${layout.y})`);
+ * }
+ * ```
+ */
+declare function getComputedLayout(world: World, eid: Entity): ComputedLayoutData | undefined;
+/**
+ * Checks if an entity has a valid computed layout.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if the entity has a valid computed layout
+ */
+declare function hasComputedLayout(world: World, eid: Entity): boolean;
+/**
+ * Invalidates the computed layout of an entity.
+ * Call this when position or dimensions change to trigger recalculation.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ */
+declare function invalidateLayout(world: World, eid: Entity): void;
+/**
+ * Layout system that computes absolute positions for all entities.
+ * Runs in tree order (parents before children) to support relative positioning.
+ *
+ * The system:
+ * 1. Finds all root entities (no parent)
+ * 2. Computes layout for each root and its descendants
+ * 3. Handles percentage dimensions relative to parent
+ * 4. Respects min/max constraints
+ * 5. Stores results in ComputedLayout component
+ *
+ * @param world - The ECS world
+ * @returns The world (unchanged)
+ *
+ * @example
+ * ```typescript
+ * import { layoutSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.LAYOUT, layoutSystem);
+ * ```
+ */
+declare const layoutSystem: System;
+/**
+ * Creates the layout system function.
+ * This is an alternative to using the layoutSystem directly for custom configuration.
+ *
+ * @returns A new layout system function
+ *
+ * @example
+ * ```typescript
+ * import { createLayoutSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.LAYOUT, createLayoutSystem());
+ * ```
+ */
+declare function createLayoutSystem(): System;
+/**
+ * Forces a full layout recalculation for all entities.
+ * Call this after major changes like screen resize.
+ *
+ * @param world - The ECS world
+ *
+ * @example
+ * ```typescript
+ * import { invalidateAllLayouts } from 'blecsd';
+ *
+ * // After terminal resize
+ * invalidateAllLayouts(world);
+ * ```
+ */
+declare function invalidateAllLayouts(world: World): void;
+/**
+ * Computes layout for a single entity immediately.
+ * Useful for getting layout outside the normal system loop.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Computed layout data or undefined if entity lacks Position
+ *
+ * @example
+ * ```typescript
+ * import { computeLayoutNow } from 'blecsd';
+ *
+ * const layout = computeLayoutNow(world, entity);
+ * if (layout) {
+ *   console.log(`Position: (${layout.x}, ${layout.y})`);
+ * }
+ * ```
+ */
+declare function computeLayoutNow(world: World, eid: Entity): ComputedLayoutData | undefined;
+/**
+ * Gets the computed content bounds for an entity (position + dimensions).
+ * Returns the bounding rectangle in screen coordinates.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Bounding rectangle or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getComputedBounds } from 'blecsd';
+ *
+ * const bounds = getComputedBounds(world, entity);
+ * if (bounds) {
+ *   console.log(`Bounds: (${bounds.left}, ${bounds.top}) to (${bounds.right}, ${bounds.bottom})`);
+ * }
+ * ```
+ */
+declare function getComputedBounds(world: World, eid: Entity): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+} | undefined;
+
+/**
+ * Movement system for updating entity positions based on velocity.
+ * Processes all entities with Velocity component.
+ * @module systems/movementSystem
+ */
+
+/**
+ * Query all entities with the Velocity component.
+ *
+ * @param world - The ECS world
+ * @returns Array of entity IDs with Velocity component
+ */
+declare function queryMovement(world: World): number[];
+/**
+ * Checks if an entity has the Velocity component (via system store).
+ *
+ * @param world - The ECS world
+ * @param eid - Entity to check
+ * @returns true if entity has Velocity component
+ */
+declare function hasMovementSystem(world: World, eid: number): boolean;
+/**
+ * Movement system that updates all entities with Velocity component.
+ *
+ * This system should be registered in the PHYSICS phase of the game loop.
+ * It reads delta time from getDeltaTime() which is set by the scheduler.
+ *
+ * For each entity with Velocity, the system:
+ * 1. Applies acceleration to velocity (if Acceleration component present)
+ * 2. Applies friction to velocity
+ * 3. Clamps velocity to max speed
+ * 4. Applies velocity to position (if Position component present)
+ *
+ * @param world - The ECS world to process
+ * @returns The world (unchanged reference)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, LoopPhase, movementSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.PHYSICS, movementSystem);
+ *
+ * // In game loop
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare const movementSystem: System;
+/**
+ * Creates a new movement system.
+ *
+ * Factory function that returns the movementSystem.
+ *
+ * @returns The movement system function
+ *
+ * @example
+ * ```typescript
+ * import { createMovementSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * const system = createMovementSystem();
+ * scheduler.registerSystem(LoopPhase.PHYSICS, system);
+ * ```
+ */
+declare function createMovementSystem(): System;
+/**
+ * Registers the movement system with a scheduler.
+ *
+ * Convenience function that registers movementSystem in the PHYSICS phase.
+ *
+ * @param scheduler - The scheduler to register with
+ * @param priority - Optional priority within the PHYSICS phase (default: 0)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, registerMovementSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * registerMovementSystem(scheduler);
+ *
+ * // Movement updates will now happen in PHYSICS phase
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare function registerMovementSystem(scheduler: Scheduler, priority?: number): void;
+/**
+ * Manually update movement for specific entities.
+ *
+ * Useful when you need to update movement outside of the system,
+ * such as in tests or custom update loops.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entity IDs to update
+ * @param deltaTime - Time elapsed in seconds
+ *
+ * @example
+ * ```typescript
+ * import { updateMovements, queryMovement } from 'blecsd';
+ *
+ * // Manual update (typically use the system instead)
+ * const entities = queryMovement(world);
+ * updateMovements(world, entities, 0.016);
+ * ```
+ */
+declare function updateMovements(world: World, entities: readonly number[], deltaTime: number): void;
+
+/**
+ * Output system for writing rendered buffer to terminal.
+ * Runs in the POST_RENDER phase after all rendering is complete.
+ * @module systems/outputSystem
+ */
+
+/**
+ * Output state maintained across frames.
+ */
+interface OutputState {
+    /** Last cursor X position (0-indexed) */
+    lastX: number;
+    /** Last cursor Y position (0-indexed) */
+    lastY: number;
+    /** Last foreground color */
+    lastFg: number;
+    /** Last background color */
+    lastBg: number;
+    /** Last attributes */
+    lastAttrs: number;
+    /** Whether we're in alternate screen mode */
+    alternateScreen: boolean;
+}
+/**
+ * Creates initial output state.
+ */
+declare function createOutputState(): OutputState;
+/**
+ * Generates optimized output for all cell changes.
+ *
+ * @param state - Output state
+ * @param changes - Array of cell changes
+ * @returns ANSI output string
+ *
+ * @example
+ * ```typescript
+ * import { generateOutput, createOutputState } from 'blecsd';
+ *
+ * const state = createOutputState();
+ * const output = generateOutput(state, changes);
+ * process.stdout.write(output);
+ * ```
+ */
+declare function generateOutput(state: OutputState, changes: readonly CellChange[]): string;
+/**
+ * Sets the output stream for the output system.
+ *
+ * @param stream - Writable stream (typically process.stdout)
+ *
+ * @example
+ * ```typescript
+ * import { setOutputStream } from 'blecsd';
+ *
+ * setOutputStream(process.stdout);
+ * ```
+ */
+declare function setOutputStream(stream: Writable): void;
+/**
+ * Gets the current output stream.
+ *
+ * @returns The current output stream or null
+ */
+declare function getOutputStream(): Writable | null;
+/**
+ * Clears the output stream reference.
+ */
+declare function clearOutputStream(): void;
+/**
+ * Sets the double buffer for the output system.
+ *
+ * @param db - The double buffer
+ *
+ * @example
+ * ```typescript
+ * import { setOutputBuffer, createDoubleBuffer } from 'blecsd';
+ *
+ * const db = createDoubleBuffer(80, 24);
+ * setOutputBuffer(db);
+ * ```
+ */
+declare function setOutputBuffer(db: DoubleBufferData): void;
+/**
+ * Gets the current output buffer.
+ *
+ * @returns The current double buffer or null
+ */
+declare function getOutputBuffer(): DoubleBufferData | null;
+/**
+ * Clears the output buffer reference.
+ */
+declare function clearOutputBuffer(): void;
+/**
+ * Gets or creates the output state.
+ *
+ * @returns The output state
+ */
+declare function getOutputState(): OutputState;
+/**
+ * Resets the output state.
+ */
+declare function resetOutputState(): void;
+/**
+ * Output system that writes rendered content to the terminal.
+ *
+ * The system:
+ * 1. Gets minimal updates from the double buffer
+ * 2. Generates optimized ANSI sequences
+ * 3. Writes to the output stream
+ * 4. Swaps buffers and clears dirty regions
+ *
+ * @param world - The ECS world
+ * @returns The world (unchanged)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   outputSystem,
+ *   setOutputStream,
+ *   setOutputBuffer,
+ *   createScheduler,
+ *   LoopPhase,
+ * } from 'blecsd';
+ *
+ * // Setup
+ * setOutputStream(process.stdout);
+ * setOutputBuffer(doubleBuffer);
+ *
+ * // Register in POST_RENDER phase
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.POST_RENDER, outputSystem);
+ * ```
+ */
+declare const outputSystem: System;
+/**
+ * Creates the output system function.
+ *
+ * @returns A new output system function
+ *
+ * @example
+ * ```typescript
+ * import { createOutputSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.POST_RENDER, createOutputSystem());
+ * ```
+ */
+declare function createOutputSystem(): System;
+/**
+ * Writes raw output to the stream.
+ * Bypasses the double buffer for immediate output.
+ *
+ * @param data - String data to write
+ *
+ * @example
+ * ```typescript
+ * import { writeRaw } from 'blecsd';
+ *
+ * // Write raw ANSI sequence
+ * writeRaw('\x1b[2J'); // Clear screen
+ * ```
+ */
+declare function writeRaw(data: string): void;
+/**
+ * Hides the terminal cursor.
+ *
+ * @example
+ * ```typescript
+ * import { hideCursor } from 'blecsd';
+ *
+ * hideCursor();
+ * ```
+ */
+declare function hideCursor(): void;
+/**
+ * Shows the terminal cursor.
+ *
+ * @example
+ * ```typescript
+ * import { showCursor } from 'blecsd';
+ *
+ * showCursor();
+ * ```
+ */
+declare function showCursor(): void;
+/**
+ * Enters alternate screen buffer mode.
+ *
+ * @example
+ * ```typescript
+ * import { enterAlternateScreen } from 'blecsd';
+ *
+ * enterAlternateScreen();
+ * // ... render application ...
+ * leaveAlternateScreen();
+ * ```
+ */
+declare function enterAlternateScreen(): void;
+/**
+ * Leaves alternate screen buffer mode.
+ *
+ * @example
+ * ```typescript
+ * import { leaveAlternateScreen } from 'blecsd';
+ *
+ * leaveAlternateScreen();
+ * ```
+ */
+declare function leaveAlternateScreen(): void;
+/**
+ * Clears the entire screen.
+ *
+ * @example
+ * ```typescript
+ * import { clearScreen } from 'blecsd';
+ *
+ * clearScreen();
+ * ```
+ */
+declare function clearScreen(): void;
+/**
+ * Moves cursor to home position (0, 0).
+ *
+ * @example
+ * ```typescript
+ * import { cursorHome } from 'blecsd';
+ *
+ * cursorHome();
+ * ```
+ */
+declare function cursorHome(): void;
+/**
+ * Resets all terminal attributes.
+ *
+ * @example
+ * ```typescript
+ * import { resetAttributes } from 'blecsd';
+ *
+ * resetAttributes();
+ * ```
+ */
+declare function resetAttributes(): void;
+/**
+ * Flushes output and resets terminal state.
+ * Call this before exiting the application.
+ *
+ * @example
+ * ```typescript
+ * import { cleanup } from 'blecsd';
+ *
+ * // Before exiting
+ * cleanup();
+ * ```
+ */
+declare function cleanup(): void;
+
+/**
+ * Fast panel movement and resizing system.
+ *
+ * Provides instant panel position updates on input with deferred
+ * content re-layout. Uses dirty rect optimization and optional
+ * content simplification during drag for 60fps movement.
+ *
+ * @module systems/panelMovement
+ */
+
+/**
+ * Resize handle positions.
+ */
+type ResizeHandle = 'top' | 'bottom' | 'left' | 'right' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+/**
+ * Panel movement constraints.
+ */
+interface PanelConstraints {
+    /** Minimum panel width (default: 4) */
+    readonly minWidth: number;
+    /** Minimum panel height (default: 2) */
+    readonly minHeight: number;
+    /** Maximum panel width (0 = no limit) */
+    readonly maxWidth: number;
+    /** Maximum panel height (0 = no limit) */
+    readonly maxHeight: number;
+    /** Constrain movement to screen bounds */
+    readonly constrainToScreen: boolean;
+    /** Screen width for constraining */
+    readonly screenWidth: number;
+    /** Screen height for constraining */
+    readonly screenHeight: number;
+    /** Snap to grid size (0 = no snap) */
+    readonly snapGrid: number;
+}
+/**
+ * Panel movement/resize state.
+ */
+interface PanelMoveState {
+    /** Currently moving entity */
+    readonly entity: Entity | undefined;
+    /** Whether a move is in progress */
+    readonly isMoving: boolean;
+    /** Whether a resize is in progress */
+    readonly isResizing: boolean;
+    /** Active resize handle */
+    readonly resizeHandle: ResizeHandle | undefined;
+    /** Starting mouse/cursor position */
+    readonly startX: number;
+    readonly startY: number;
+    /** Starting panel position */
+    readonly panelStartX: number;
+    readonly panelStartY: number;
+    /** Starting panel dimensions */
+    readonly panelStartWidth: number;
+    readonly panelStartHeight: number;
+    /** Whether content layout is deferred (simplified rendering during move) */
+    readonly layoutDeferred: boolean;
+}
+/**
+ * Configuration for panel movement behavior.
+ */
+interface PanelMoveConfig {
+    /** Defer content layout during move for performance (default: true) */
+    readonly deferLayout: boolean;
+    /** Show resize outline instead of live resize (default: false) */
+    readonly outlineResize: boolean;
+    /** Number of pixels to move with keyboard (default: 1) */
+    readonly keyboardStep: number;
+    /** Number of pixels to resize with keyboard (default: 1) */
+    readonly keyboardResizeStep: number;
+}
+/**
+ * Dirty rectangle representing changed area.
+ */
+interface DirtyRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Result of a panel move or resize operation.
+ */
+interface MoveResult {
+    /** New position X */
+    readonly x: number;
+    /** New position Y */
+    readonly y: number;
+    /** New width (for resize) */
+    readonly width: number;
+    /** New height (for resize) */
+    readonly height: number;
+    /** Dirty rectangles that need redrawing */
+    readonly dirtyRects: readonly DirtyRect[];
+    /** Whether the operation was clamped by constraints */
+    readonly clamped: boolean;
+}
+/**
+ * Creates initial panel move state.
+ *
+ * @returns Fresh move state
+ *
+ * @example
+ * ```typescript
+ * import { createPanelMoveState } from 'blecsd';
+ *
+ * const moveState = createPanelMoveState();
+ * ```
+ */
+declare function createPanelMoveState(): PanelMoveState;
+/**
+ * Creates panel move configuration with defaults.
+ *
+ * @param config - Partial overrides
+ * @returns Full configuration
+ */
+declare function createPanelMoveConfig(config?: Partial<PanelMoveConfig>): PanelMoveConfig;
+/**
+ * Creates panel constraints with defaults.
+ *
+ * @param constraints - Partial overrides
+ * @returns Full constraints
+ */
+declare function createPanelConstraints(constraints?: Partial<PanelConstraints>): PanelConstraints;
+/**
+ * Begins a panel move operation.
+ *
+ * @param state - Current move state
+ * @param entity - Entity to move
+ * @param mouseX - Starting mouse X
+ * @param mouseY - Starting mouse Y
+ * @param panelX - Current panel X position
+ * @param panelY - Current panel Y position
+ * @param panelWidth - Current panel width
+ * @param panelHeight - Current panel height
+ * @param config - Move configuration
+ * @returns Updated state
+ *
+ * @example
+ * ```typescript
+ * import { createPanelMoveState, beginMove } from 'blecsd';
+ *
+ * let state = createPanelMoveState();
+ * state = beginMove(state, eid, mouseX, mouseY, panelX, panelY, 30, 10);
+ * ```
+ */
+declare function beginMove(state: PanelMoveState, entity: Entity, mouseX: number, mouseY: number, panelX: number, panelY: number, panelWidth: number, panelHeight: number, config?: Partial<PanelMoveConfig>): PanelMoveState;
+/**
+ * Begins a panel resize operation.
+ *
+ * @param state - Current move state
+ * @param entity - Entity to resize
+ * @param handle - Resize handle being dragged
+ * @param mouseX - Starting mouse X
+ * @param mouseY - Starting mouse Y
+ * @param panelX - Current panel X
+ * @param panelY - Current panel Y
+ * @param panelWidth - Current panel width
+ * @param panelHeight - Current panel height
+ * @param config - Move configuration
+ * @returns Updated state
+ */
+declare function beginResize(state: PanelMoveState, entity: Entity, handle: ResizeHandle, mouseX: number, mouseY: number, panelX: number, panelY: number, panelWidth: number, panelHeight: number, config?: Partial<PanelMoveConfig>): PanelMoveState;
+/**
+ * Updates a panel move with new cursor position.
+ * Returns the new panel position with constraints applied.
+ *
+ * @param state - Current move state
+ * @param mouseX - Current mouse X
+ * @param mouseY - Current mouse Y
+ * @param constraints - Panel constraints
+ * @returns Move result with new position and dirty rects
+ *
+ * @example
+ * ```typescript
+ * import { updateMove, createPanelConstraints } from 'blecsd';
+ *
+ * const result = updateMove(state, mouseX, mouseY, createPanelConstraints());
+ * setPosition(world, eid, result.x, result.y);
+ * ```
+ */
+declare function updateMove(state: PanelMoveState, mouseX: number, mouseY: number, constraints?: Partial<PanelConstraints>): MoveResult;
+declare function updateResize(state: PanelMoveState, mouseX: number, mouseY: number, constraints?: Partial<PanelConstraints>): MoveResult;
+/**
+ * Ends the current move or resize operation.
+ *
+ * @param state - Current move state
+ * @returns Reset state
+ */
+declare function endMoveOrResize(state: PanelMoveState): PanelMoveState;
+/**
+ * Cancels the current move or resize, returning to original position.
+ *
+ * @param state - Current move state
+ * @returns Object with original position and reset state
+ */
+declare function cancelMoveOrResize(state: PanelMoveState): {
+    state: PanelMoveState;
+    restoreX: number;
+    restoreY: number;
+    restoreWidth: number;
+    restoreHeight: number;
+};
+/**
+ * Moves a panel by keyboard step amount.
+ *
+ * @param x - Current X position
+ * @param y - Current Y position
+ * @param width - Panel width
+ * @param height - Panel height
+ * @param direction - Movement direction
+ * @param step - Step amount
+ * @param constraints - Panel constraints
+ * @returns New position
+ */
+declare function keyboardMove(x: number, y: number, width: number, height: number, direction: 'up' | 'down' | 'left' | 'right', step: number, constraints?: Partial<PanelConstraints>): {
+    x: number;
+    y: number;
+};
+/**
+ * Resizes a panel by keyboard step amount.
+ *
+ * @param width - Current width
+ * @param height - Current height
+ * @param direction - Resize direction
+ * @param step - Step amount
+ * @param constraints - Panel constraints
+ * @returns New dimensions
+ */
+declare function keyboardResize(width: number, height: number, direction: 'grow-horizontal' | 'shrink-horizontal' | 'grow-vertical' | 'shrink-vertical', step: number, constraints?: Partial<PanelConstraints>): {
+    width: number;
+    height: number;
+};
+/**
+ * Detects which resize handle a click position corresponds to.
+ *
+ * @param clickX - Click X relative to panel
+ * @param clickY - Click Y relative to panel
+ * @param panelWidth - Panel width
+ * @param panelHeight - Panel height
+ * @param borderSize - Size of the resize border area (default: 1)
+ * @returns The resize handle, or undefined if not on a border
+ */
+declare function detectResizeHandle(clickX: number, clickY: number, panelWidth: number, panelHeight: number, borderSize?: number): ResizeHandle | undefined;
+/**
+ * Merges overlapping dirty rectangles for efficient redraw.
+ *
+ * @param rects - Array of dirty rectangles
+ * @returns Merged bounding rectangle
+ */
+declare function mergeDirtyRects(rects: readonly DirtyRect[]): DirtyRect | undefined;
+
+/**
+ * Particle system for spawning, updating, and removing particles.
+ *
+ * Processes emitters (rate-based and burst-based spawning) and
+ * updates particle age, position, and velocity each frame.
+ *
+ * @module systems/particleSystem
+ */
+
+/**
+ * Function that provides entity IDs to iterate over.
+ * User supplies this because blECSd doesn't own a global query registry.
+ */
+type EntityProvider = (world: World) => ReadonlyArray<Entity>;
+/**
+ * Configuration for the particle system.
+ */
+interface ParticleSystemConfig {
+    /** Provides emitter entities each frame */
+    readonly emitters: EntityProvider;
+    /** Provides particle entities each frame */
+    readonly particles: EntityProvider;
+    /** Maximum concurrent particles (default: 1000) */
+    readonly maxParticles?: number;
+}
+/**
+ * Spawns a single particle from an emitter at a random angle within the spread.
+ *
+ * @param world - The ECS world
+ * @param emitterId - The emitter entity ID
+ * @param appearance - Visual appearance config
+ * @returns The spawned particle entity ID, or -1 if spawn failed
+ */
+declare function spawnParticle(world: World, emitterId: Entity, appearance: EmitterAppearance): Entity;
+/**
+ * Triggers a burst of particles from an emitter.
+ *
+ * @param world - The ECS world
+ * @param emitterId - The emitter entity ID
+ * @param count - Number of particles to emit (default: emitter's burstCount)
+ * @param maxParticles - Maximum total particles allowed (default: 1000)
+ * @param currentCount - Current total particle count
+ * @returns Array of spawned particle entity IDs
+ *
+ * @example
+ * ```typescript
+ * import { burstParticles } from 'blecsd';
+ *
+ * const particles = burstParticles(world, emitterEntity, 20);
+ * ```
+ */
+declare function burstParticles(world: World, emitterId: Entity, count?: number, maxParticles?: number, currentCount?: number): Entity[];
+/**
+ * Ages a particle and updates its velocity for gravity.
+ *
+ * @param world - The ECS world
+ * @param eid - The particle entity ID
+ * @param delta - Time elapsed in seconds
+ */
+declare function ageParticle(world: World, eid: Entity, delta: number): void;
+/**
+ * Updates a particle's position based on its velocity.
+ *
+ * @param world - The ECS world
+ * @param eid - The particle entity ID
+ * @param delta - Time elapsed in seconds
+ */
+declare function moveParticle(world: World, eid: Entity, delta: number): void;
+/**
+ * Removes a dead particle and cleans up tracking.
+ *
+ * @param world - The ECS world
+ * @param eid - The particle entity ID
+ */
+declare function killParticle(world: World, eid: Entity): void;
+declare function createParticleSystem(config: ParticleSystemConfig): System;
+
+/**
+ * Render system for drawing entities to the screen buffer.
+ * Runs in the RENDER phase after layout computation.
+ * @module systems/renderSystem
+ */
+
+/**
+ * Render context passed to render functions.
+ */
+interface RenderContext {
+    /** The ECS world */
+    readonly world: World;
+    /** The screen buffer to render to */
+    readonly buffer: ScreenBufferData;
+    /** The double buffer for dirty tracking */
+    readonly doubleBuffer: DoubleBufferData;
+}
+/**
+ * Computed bounds for an entity.
+ */
+interface EntityBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Renders the background fill for an entity.
+ *
+ * @param ctx - Render context
+ * @param eid - Entity ID
+ * @param bounds - Entity bounds
+ *
+ * @example
+ * ```typescript
+ * import { renderBackground } from 'blecsd';
+ *
+ * renderBackground(ctx, entity, bounds);
+ * ```
+ */
+declare function renderBackground(ctx: RenderContext, eid: Entity, bounds: EntityBounds): void;
+/**
+ * Renders the border for an entity.
+ *
+ * @param ctx - Render context
+ * @param eid - Entity ID
+ * @param bounds - Entity bounds
+ *
+ * @example
+ * ```typescript
+ * import { renderBorder } from 'blecsd';
+ *
+ * renderBorder(ctx, entity, bounds);
+ * ```
+ */
+declare function renderBorder(ctx: RenderContext, eid: Entity, bounds: EntityBounds): void;
+/**
+ * Renders the content area of an entity.
+ * This is a placeholder that can be extended for specific content types.
+ *
+ * @param ctx - Render context
+ * @param eid - Entity ID
+ * @param contentBounds - Content area bounds (inside border)
+ *
+ * @example
+ * ```typescript
+ * import { renderContent } from 'blecsd';
+ *
+ * renderContent(ctx, entity, contentBounds);
+ * ```
+ */
+declare function renderContent(_ctx: RenderContext, _eid: Entity, _contentBounds: EntityBounds): void;
+/**
+ * Renders a scrollbar for an entity.
+ * Currently a placeholder for future scrollable content support.
+ *
+ * @param ctx - Render context
+ * @param eid - Entity ID
+ * @param bounds - Entity bounds
+ *
+ * @example
+ * ```typescript
+ * import { renderScrollbar } from 'blecsd';
+ *
+ * renderScrollbar(ctx, entity, bounds);
+ * ```
+ */
+declare function renderScrollbar(_ctx: RenderContext, _eid: Entity, _bounds: EntityBounds): void;
+/**
+ * Sets the double buffer for the render system.
+ * Must be called before running the render system.
+ *
+ * @param db - The double buffer to render to
+ *
+ * @example
+ * ```typescript
+ * import { setRenderBuffer, createDoubleBuffer } from 'blecsd';
+ *
+ * const db = createDoubleBuffer(80, 24);
+ * setRenderBuffer(db);
+ * ```
+ */
+declare function setRenderBuffer(db: DoubleBufferData): void;
+/**
+ * Gets the current render buffer.
+ *
+ * @returns The current double buffer or null
+ */
+declare function getRenderBuffer(): DoubleBufferData | null;
+/**
+ * Clears the render buffer reference.
+ */
+declare function clearRenderBuffer(): void;
+/**
+ * Render system that draws visible, dirty entities to the screen buffer.
+ * Entities are rendered in z-index order (lower z first, higher z on top).
+ *
+ * The system:
+ * 1. Queries all entities with Position and Renderable
+ * 2. Filters to visible, dirty entities
+ * 3. Sorts by z-index
+ * 4. Renders each entity (background, border, content)
+ * 5. Marks entities as clean
+ *
+ * @param world - The ECS world
+ * @returns The world (unchanged)
+ *
+ * @example
+ * ```typescript
+ * import { renderSystem, setRenderBuffer, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.RENDER, renderSystem);
+ *
+ * // Before running, set the render buffer
+ * setRenderBuffer(doubleBuffer);
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare const renderSystem: System;
+/**
+ * Creates the render system function.
+ * This is an alternative to using the renderSystem directly for custom configuration.
+ *
+ * @returns A new render system function
+ *
+ * @example
+ * ```typescript
+ * import { createRenderSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.RENDER, createRenderSystem());
+ * ```
+ */
+declare function createRenderSystem(): System;
+/**
+ * Renders text to a buffer at the specified position.
+ * Utility function for widgets to render text content.
+ *
+ * @param buffer - Screen buffer
+ * @param x - X position
+ * @param y - Y position
+ * @param text - Text to render
+ * @param fg - Foreground color
+ * @param bg - Background color
+ * @param attrs - Text attributes
+ * @returns Number of characters written
+ *
+ * @example
+ * ```typescript
+ * import { renderText, Attr } from 'blecsd';
+ *
+ * renderText(buffer, 10, 5, 'Hello', 0xffffffff, 0x000000ff, Attr.BOLD);
+ * ```
+ */
+declare function renderText(buffer: ScreenBufferData, x: number, y: number, text: string, fg: number, bg: number, attrs?: number): number;
+/**
+ * Renders a filled rectangle to a buffer.
+ * Utility function for widgets.
+ *
+ * @param buffer - Screen buffer
+ * @param x - X position
+ * @param y - Y position
+ * @param width - Rectangle width
+ * @param height - Rectangle height
+ * @param cell - Cell to fill with
+ *
+ * @example
+ * ```typescript
+ * import { renderRect, createCell } from 'blecsd';
+ *
+ * renderRect(buffer, 10, 5, 20, 10, createCell(' ', 0xffffffff, 0x0000ffff));
+ * ```
+ */
+declare function renderRect(buffer: ScreenBufferData, x: number, y: number, width: number, height: number, cell: Cell): void;
+/**
+ * Marks all entities as dirty, forcing a full re-render.
+ *
+ * @param world - The ECS world
+ *
+ * @example
+ * ```typescript
+ * import { markAllDirty } from 'blecsd';
+ *
+ * // Force re-render of all entities
+ * markAllDirty(world);
+ * ```
+ */
+declare function markAllDirty(world: World): void;
+
+/**
+ * Smooth Animated Scrolling
+ *
+ * Provides butter-smooth scroll animations with momentum/inertia physics.
+ * Supports velocity-based scrolling, spring-to-boundary behavior, and
+ * graceful frame skipping under load.
+ *
+ * @module systems/smoothScroll
+ */
+
+/**
+ * Scroll physics configuration.
+ */
+interface ScrollPhysicsConfig {
+    /** Friction coefficient (0-1, lower = more momentum, default: 0.92) */
+    readonly friction: number;
+    /** Minimum velocity before stopping (default: 0.1) */
+    readonly minVelocity: number;
+    /** Maximum velocity (default: 200) */
+    readonly maxVelocity: number;
+    /** Velocity multiplier for input (default: 1) */
+    readonly sensitivity: number;
+    /** Spring stiffness for overscroll bounce (default: 0.3) */
+    readonly springStiffness: number;
+    /** Spring damping for overscroll bounce (default: 0.8) */
+    readonly springDamping: number;
+    /** Maximum overscroll distance (default: 50) */
+    readonly maxOverscroll: number;
+    /** Whether to enable momentum scrolling (default: true) */
+    readonly enableMomentum: boolean;
+    /** Whether to enable overscroll bounce (default: true) */
+    readonly enableBounce: boolean;
+}
+/**
+ * Scroll animation state for a single entity.
+ */
+interface ScrollAnimationState {
+    /** Current scroll position */
+    scrollX: number;
+    scrollY: number;
+    /** Current scroll velocity */
+    velocityX: number;
+    velocityY: number;
+    /** Content bounds */
+    contentWidth: number;
+    contentHeight: number;
+    /** Viewport bounds */
+    viewportWidth: number;
+    viewportHeight: number;
+    /** Whether currently animating */
+    isAnimating: boolean;
+    /** Whether user is actively scrolling (input held) */
+    isUserScrolling: boolean;
+    /** Target scroll position (for smooth scrollTo) */
+    targetX: number | null;
+    targetY: number | null;
+}
+/**
+ * Scroll event data.
+ */
+interface ScrollEvent {
+    /** Entity being scrolled */
+    readonly eid: Entity;
+    /** Scroll delta X */
+    readonly deltaX: number;
+    /** Scroll delta Y */
+    readonly deltaY: number;
+    /** Current scroll position X */
+    readonly scrollX: number;
+    /** Current scroll position Y */
+    readonly scrollY: number;
+    /** Whether momentum is active */
+    readonly isMomentum: boolean;
+}
+/**
+ * Creates or gets scroll animation state for an entity.
+ *
+ * @param eid - Entity ID
+ * @param contentWidth - Total content width
+ * @param contentHeight - Total content height
+ * @param viewportWidth - Viewport width
+ * @param viewportHeight - Viewport height
+ * @returns Scroll animation state
+ *
+ * @example
+ * ```typescript
+ * const state = getScrollState(entity, 1000, 5000, 80, 24);
+ * ```
+ */
+declare function getScrollState(eid: Entity, contentWidth: number, contentHeight: number, viewportWidth: number, viewportHeight: number): ScrollAnimationState;
+/**
+ * Removes scroll state for an entity.
+ *
+ * @param eid - Entity ID
+ */
+declare function removeScrollState(eid: Entity): void;
+/**
+ * Clears all scroll states. Used for testing.
+ * @internal
+ */
+declare function clearAllScrollStates(): void;
+/**
+ * Applies a scroll impulse (e.g., from mouse wheel or keyboard).
+ *
+ * @param eid - Entity to scroll
+ * @param deltaX - Horizontal scroll amount
+ * @param deltaY - Vertical scroll amount
+ * @param physics - Physics configuration
+ *
+ * @example
+ * ```typescript
+ * // Mouse wheel scroll
+ * applyScrollImpulse(entity, 0, -3, physicsConfig);
+ *
+ * // Page down
+ * applyScrollImpulse(entity, 0, 24, physicsConfig);
+ * ```
+ */
+declare function applyScrollImpulse(eid: Entity, deltaX: number, deltaY: number, physics?: Partial<ScrollPhysicsConfig>): void;
+/**
+ * Smoothly scrolls to a target position.
+ *
+ * @param eid - Entity to scroll
+ * @param targetX - Target X scroll position (null = don't change)
+ * @param targetY - Target Y scroll position (null = don't change)
+ *
+ * @example
+ * ```typescript
+ * // Scroll to top
+ * smoothScrollTo(entity, null, 0);
+ *
+ * // Scroll to bottom
+ * smoothScrollTo(entity, null, maxScroll);
+ * ```
+ */
+declare function smoothScrollTo(eid: Entity, targetX: number | null, targetY: number | null): void;
+/**
+ * Sets scroll position immediately without animation.
+ *
+ * @param eid - Entity to scroll
+ * @param x - X scroll position
+ * @param y - Y scroll position
+ */
+declare function setScrollImmediate(eid: Entity, x: number, y: number): void;
+/**
+ * Marks the start of user scrolling (e.g., mouse drag).
+ *
+ * @param eid - Entity being scrolled
+ */
+declare function startUserScroll(eid: Entity): void;
+/**
+ * Marks the end of user scrolling, enabling momentum.
+ *
+ * @param eid - Entity being scrolled
+ * @param velocityX - Release velocity X
+ * @param velocityY - Release velocity Y
+ */
+declare function endUserScroll(eid: Entity, velocityX: number, velocityY: number): void;
+declare function updateScrollPhysics(state: ScrollAnimationState, dt: number, physics?: Partial<ScrollPhysicsConfig>): boolean;
+/**
+ * Checks if an entity has an active scroll animation.
+ *
+ * @param eid - Entity to check
+ * @returns True if the entity is currently scrolling
+ */
+declare function isScrolling(eid: Entity): boolean;
+/**
+ * Gets the current scroll position of an entity.
+ *
+ * @param eid - Entity to query
+ * @returns Scroll position or null if no scroll state
+ */
+declare function getScrollPosition(eid: Entity): {
+    x: number;
+    y: number;
+} | null;
+/**
+ * Creates a smooth scroll system that updates all active scroll animations.
+ *
+ * @param physics - Physics configuration
+ * @returns System function
+ *
+ * @example
+ * ```typescript
+ * import { createSmoothScrollSystem } from 'blecsd';
+ *
+ * const scrollSystem = createSmoothScrollSystem({
+ *   friction: 0.92,
+ *   enableMomentum: true,
+ *   enableBounce: true,
+ * });
+ *
+ * scheduler.registerSystem(LoopPhase.ANIMATION, scrollSystem);
+ * ```
+ */
+declare function createSmoothScrollSystem(physics?: Partial<ScrollPhysicsConfig>): System;
+
+/**
+ * Spatial hash grid for O(1) collision lookups.
+ *
+ * Partitions 2D space into a uniform grid where each cell tracks
+ * which entities overlap it. Enables efficient broad-phase collision
+ * detection by only checking entities in the same or adjacent cells.
+ *
+ * @module systems/spatialHash
+ */
+
+/**
+ * Configuration for the spatial hash grid.
+ */
+interface SpatialHashConfig {
+    /** Width of each cell in world units (default: 8) */
+    readonly cellSize: number;
+    /** Initial number of cells in the grid (default: 256) */
+    readonly initialCapacity: number;
+}
+/**
+ * A cell coordinate in the spatial hash grid.
+ */
+interface CellCoord {
+    readonly cx: number;
+    readonly cy: number;
+}
+/**
+ * Spatial hash grid data structure.
+ */
+interface SpatialHashGrid {
+    /** Cell size in world units */
+    readonly cellSize: number;
+    /** Map from cell key to set of entity IDs */
+    readonly cells: Map<number, Set<number>>;
+    /** Map from entity ID to set of cell keys it occupies */
+    readonly entityCells: Map<number, Set<number>>;
+}
+/**
+ * Statistics about the spatial hash grid.
+ */
+interface SpatialHashStats {
+    readonly cellCount: number;
+    readonly entityCount: number;
+    readonly averageEntitiesPerCell: number;
+    readonly maxEntitiesInCell: number;
+}
+/** Default cell size */
+declare const DEFAULT_CELL_SIZE = 8;
+/**
+ * Creates a new spatial hash grid.
+ *
+ * @param config - Optional configuration
+ * @returns A new spatial hash grid
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash } from 'blecsd';
+ *
+ * const grid = createSpatialHash({ cellSize: 4 });
+ * ```
+ */
+declare function createSpatialHash(config?: Partial<SpatialHashConfig>): SpatialHashGrid;
+/**
+ * Gets the cell coordinate for a world position.
+ *
+ * @param grid - The spatial hash grid
+ * @param x - World X coordinate
+ * @param y - World Y coordinate
+ * @returns The cell coordinate
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, worldToCell } from 'blecsd';
+ *
+ * const grid = createSpatialHash({ cellSize: 8 });
+ * const cell = worldToCell(grid, 15, 23);
+ * // cell = { cx: 1, cy: 2 }
+ * ```
+ */
+declare function worldToCell(grid: SpatialHashGrid, x: number, y: number): CellCoord;
+/**
+ * Inserts an entity into the spatial hash at the given position and size.
+ *
+ * @param grid - The spatial hash grid
+ * @param eid - Entity ID
+ * @param x - Entity X position
+ * @param y - Entity Y position
+ * @param width - Entity width (default: 1)
+ * @param height - Entity height (default: 1)
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, insertEntity } from 'blecsd';
+ *
+ * const grid = createSpatialHash();
+ * insertEntity(grid, entity, 10, 20, 2, 3);
+ * ```
+ */
+declare function insertEntity(grid: SpatialHashGrid, eid: Entity, x: number, y: number, width?: number, height?: number): void;
+/**
+ * Removes an entity from the spatial hash.
+ *
+ * @param grid - The spatial hash grid
+ * @param eid - Entity ID to remove
+ *
+ * @example
+ * ```typescript
+ * import { removeEntityFromGrid } from 'blecsd';
+ *
+ * removeEntityFromGrid(grid, entity);
+ * ```
+ */
+declare function removeEntityFromGrid(grid: SpatialHashGrid, eid: Entity): void;
+/**
+ * Gets all entities in the same cell(s) as the given position/area.
+ * This is the core broad-phase query for collision detection.
+ *
+ * @param grid - The spatial hash grid
+ * @param x - Query X position
+ * @param y - Query Y position
+ * @param width - Query width (default: 1)
+ * @param height - Query height (default: 1)
+ * @returns Set of entity IDs that may overlap the query area
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, queryArea } from 'blecsd';
+ *
+ * const nearby = queryArea(grid, playerX, playerY, 2, 2);
+ * for (const eid of nearby) {
+ *   // Check narrow-phase collision
+ * }
+ * ```
+ */
+declare function queryArea(grid: SpatialHashGrid, x: number, y: number, width?: number, height?: number): ReadonlySet<number>;
+/**
+ * Gets potential collision candidates for an entity.
+ * Returns all entities in the same cells, excluding the entity itself.
+ *
+ * @param grid - The spatial hash grid
+ * @param eid - Entity to find candidates for
+ * @returns Set of entity IDs that may collide with the given entity
+ *
+ * @example
+ * ```typescript
+ * import { getNearbyEntities } from 'blecsd';
+ *
+ * const candidates = getNearbyEntities(grid, player);
+ * for (const other of candidates) {
+ *   // Narrow-phase collision check
+ * }
+ * ```
+ */
+declare function getNearbyEntities(grid: SpatialHashGrid, eid: Entity): ReadonlySet<number>;
+/**
+ * Gets all entities at a specific cell coordinate.
+ *
+ * @param grid - The spatial hash grid
+ * @param cx - Cell X coordinate
+ * @param cy - Cell Y coordinate
+ * @returns Set of entity IDs in that cell
+ *
+ * @example
+ * ```typescript
+ * import { getEntitiesInCell } from 'blecsd';
+ *
+ * const entities = getEntitiesInCell(grid, 3, 5);
+ * ```
+ */
+declare function getEntitiesInCell(grid: SpatialHashGrid, cx: number, cy: number): ReadonlySet<number>;
+/**
+ * Gets all entities at a world position.
+ *
+ * @param grid - The spatial hash grid
+ * @param x - World X coordinate
+ * @param y - World Y coordinate
+ * @returns Set of entity IDs at that position
+ *
+ * @example
+ * ```typescript
+ * import { getEntitiesAtPoint } from 'blecsd';
+ *
+ * const entities = getEntitiesAtPoint(grid, 10, 20);
+ * ```
+ */
+declare function getEntitiesAtPoint(grid: SpatialHashGrid, x: number, y: number): ReadonlySet<number>;
+/**
+ * Clears all entities from the spatial hash grid.
+ *
+ * @param grid - The spatial hash grid to clear
+ *
+ * @example
+ * ```typescript
+ * import { clearSpatialHash } from 'blecsd';
+ *
+ * clearSpatialHash(grid);
+ * ```
+ */
+declare function clearSpatialHash(grid: SpatialHashGrid): void;
+/**
+ * Gets statistics about the spatial hash grid.
+ *
+ * @param grid - The spatial hash grid
+ * @returns Grid statistics
+ *
+ * @example
+ * ```typescript
+ * import { getSpatialHashStats } from 'blecsd';
+ *
+ * const stats = getSpatialHashStats(grid);
+ * console.log(`Cells: ${stats.cellCount}, Entities: ${stats.entityCount}`);
+ * ```
+ */
+declare function getSpatialHashStats(grid: SpatialHashGrid): SpatialHashStats;
+/**
+ * Rebuilds the spatial hash from all entities with Position and Collider components.
+ *
+ * @param grid - The spatial hash grid to rebuild
+ * @param world - The ECS world
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, rebuildSpatialHash } from 'blecsd';
+ *
+ * const grid = createSpatialHash({ cellSize: 4 });
+ * rebuildSpatialHash(grid, world);
+ * ```
+ */
+declare function rebuildSpatialHash(grid: SpatialHashGrid, world: World): void;
+/**
+ * Sets the spatial hash grid for the system to use.
+ *
+ * @param grid - The spatial hash grid
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, setSpatialHashGrid } from 'blecsd';
+ *
+ * const grid = createSpatialHash({ cellSize: 4 });
+ * setSpatialHashGrid(grid);
+ * ```
+ */
+declare function setSpatialHashGrid(grid: SpatialHashGrid): void;
+/**
+ * Gets the current system spatial hash grid.
+ *
+ * @returns The grid, or null if not set
+ */
+declare function getSpatialHashGrid(): SpatialHashGrid | null;
+/**
+ * Spatial hash system that rebuilds the grid each frame.
+ *
+ * Register this in the EARLY_UPDATE phase to ensure collision queries
+ * use up-to-date spatial data.
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, setSpatialHashGrid, spatialHashSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const grid = createSpatialHash({ cellSize: 4 });
+ * setSpatialHashGrid(grid);
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.EARLY_UPDATE, spatialHashSystem);
+ * ```
+ */
+declare const spatialHashSystem: System;
+/**
+ * Creates a new spatial hash system.
+ *
+ * @returns The system function
+ */
+declare function createSpatialHashSystem(): System;
+
+/**
+ * State machine system for updating entity state age.
+ * Processes all entities with StateMachine component.
+ * @module systems/stateMachineSystem
+ */
+
+/**
+ * Query all entities with the StateMachine component.
+ *
+ * @param world - The ECS world
+ * @returns Array of entity IDs with StateMachine component
+ */
+declare function queryStateMachine(world: World): number[];
+/**
+ * Gets the state age store for direct access.
+ * Use with caution; primarily for testing.
+ *
+ * @returns The state age array
+ */
+declare function getStateAgeStore(): Float32Array;
+/**
+ * State machine system that updates the stateAge for all entities
+ * with a StateMachine component.
+ *
+ * This system should be registered in the UPDATE phase of the game loop.
+ * It reads delta time from getDeltaTime() which is set by the scheduler.
+ *
+ * The system updates each entity's stateAge by adding the frame's delta time.
+ * This allows game logic to check how long an entity has been in its current
+ * state for time-based transitions or animations.
+ *
+ * @param world - The ECS world to process
+ * @returns The world (unchanged reference, but stateAge values updated)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, LoopPhase, stateMachineSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.UPDATE, stateMachineSystem);
+ *
+ * // In game loop
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare const stateMachineSystem: System;
+/**
+ * Creates a new state machine system.
+ *
+ * Factory function that returns the stateMachineSystem.
+ * Useful for cases where you need a fresh reference or want to
+ * match the factory pattern used elsewhere in the codebase.
+ *
+ * @returns The state machine system function
+ *
+ * @example
+ * ```typescript
+ * import { createStateMachineSystem, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * const system = createStateMachineSystem();
+ * scheduler.registerSystem(LoopPhase.UPDATE, system);
+ * ```
+ */
+declare function createStateMachineSystem(): System;
+/**
+ * Registers the state machine system with a scheduler.
+ *
+ * Convenience function that registers stateMachineSystem in the UPDATE phase.
+ *
+ * @param scheduler - The scheduler to register with
+ * @param priority - Optional priority within the UPDATE phase (default: 0)
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, registerStateMachineSystem } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * registerStateMachineSystem(scheduler);
+ *
+ * // State machine updates will now happen in UPDATE phase
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare function registerStateMachineSystem(scheduler: Scheduler, priority?: number): void;
+/**
+ * Manually update state age for specific entities.
+ *
+ * Useful when you need to update state age outside of the system,
+ * such as in tests or custom update loops.
+ *
+ * @param entities - Array of entity IDs to update
+ * @param deltaTime - Time elapsed in seconds
+ *
+ * @example
+ * ```typescript
+ * import { updateStateAges, queryStateMachine } from 'blecsd';
+ *
+ * // Manual update (typically use the system instead)
+ * const entities = queryStateMachine(world);
+ * updateStateAges(entities, 0.016); // ~60fps frame
+ * ```
+ */
+declare function updateStateAges(entities: readonly number[], deltaTime: number): void;
+/**
+ * Resets the state age for an entity to zero.
+ *
+ * Typically called when a state transition occurs (handled by
+ * sendEvent in components/stateMachine.ts), but can be called
+ * manually for custom state management.
+ *
+ * @param eid - Entity ID to reset
+ *
+ * @example
+ * ```typescript
+ * import { resetStateAge } from 'blecsd';
+ *
+ * // After a manual state transition
+ * resetStateAge(entityId);
+ * ```
+ */
+declare function resetStateAge(eid: number): void;
+/**
+ * Gets the state age for an entity from the system store.
+ *
+ * @param eid - Entity ID to query
+ * @returns Time in seconds the entity has been in current state
+ *
+ * @example
+ * ```typescript
+ * import { getSystemStateAge } from 'blecsd';
+ *
+ * const age = getSystemStateAge(entityId);
+ * if (age > 5.0) {
+ *   // Entity has been in state for over 5 seconds
+ * }
+ * ```
+ */
+declare function getSystemStateAge(eid: number): number;
+
+/**
+ * TileMap rendering system for rendering tile maps to a buffer.
+ *
+ * Queries entities with TileMap and Position components, then renders
+ * visible tiles to a 2D buffer. Supports camera offset for scrolling
+ * and dirty region tracking for efficient updates.
+ *
+ * @module systems/tilemapRenderer
+ */
+
+/**
+ * A rendered tile map buffer.
+ * Stores the final composited output from all tile map entities.
+ */
+interface TileMapBuffer {
+    /** Buffer width in cells */
+    readonly width: number;
+    /** Buffer height in cells */
+    readonly height: number;
+    /** 2D array of rendered cells (row-major: [y][x]) */
+    readonly cells: RenderedTileCell[][];
+}
+/**
+ * Camera offset for tile map rendering.
+ */
+interface TileMapCamera {
+    /** Camera X offset in world units (pixels/cells) */
+    x: number;
+    /** Camera Y offset in world units (pixels/cells) */
+    y: number;
+}
+/**
+ * Configuration for the tile map renderer.
+ */
+interface TileMapRendererConfig {
+    /** Viewport width in cells */
+    viewportWidth: number;
+    /** Viewport height in cells */
+    viewportHeight: number;
+    /** Camera offset */
+    camera: TileMapCamera;
+}
+/**
+ * Sets the tile map renderer configuration.
+ *
+ * @param config - The renderer configuration
+ *
+ * @example
+ * ```typescript
+ * import { setTileMapRendererConfig } from 'blecsd';
+ *
+ * setTileMapRendererConfig({
+ *   viewportWidth: 80,
+ *   viewportHeight: 24,
+ *   camera: { x: 0, y: 0 },
+ * });
+ * ```
+ */
+declare function setTileMapRendererConfig(config: TileMapRendererConfig): void;
+/**
+ * Gets the current tile map renderer configuration.
+ *
+ * @returns The renderer config or null if not set
+ */
+declare function getTileMapRendererConfig(): TileMapRendererConfig | null;
+/**
+ * Gets the current render buffer.
+ *
+ * @returns The render buffer or null if not rendered yet
+ *
+ * @example
+ * ```typescript
+ * import { getTileMapRenderBuffer } from 'blecsd';
+ *
+ * const buffer = getTileMapRenderBuffer();
+ * if (buffer) {
+ *   for (let y = 0; y < buffer.height; y++) {
+ *     for (let x = 0; x < buffer.width; x++) {
+ *       const cell = buffer.cells[y][x];
+ *       // Use cell.char, cell.fg, cell.bg
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare function getTileMapRenderBuffer(): TileMapBuffer | null;
+/**
+ * Clears the render buffer.
+ */
+declare function clearTileMapRenderBuffer(): void;
+/**
+ * Resets the tile map renderer state (config and buffer).
+ * Useful for testing.
+ *
+ * @example
+ * ```typescript
+ * import { resetTileMapRenderer } from 'blecsd';
+ *
+ * resetTileMapRenderer();
+ * ```
+ */
+declare function resetTileMapRenderer(): void;
+/**
+ * Creates an empty tile map buffer filled with empty cells.
+ *
+ * @param width - Buffer width in cells
+ * @param height - Buffer height in cells
+ * @returns A new empty buffer
+ */
+declare function createEmptyBuffer(width: number, height: number): TileMapBuffer;
+/**
+ * Renders a single tile map entity into a buffer.
+ * Takes into account entity position and camera offset.
+ *
+ * @param buffer - The target buffer
+ * @param eid - The entity ID
+ * @param cameraX - Camera X offset in world units
+ * @param cameraY - Camera Y offset in world units
+ *
+ * @example
+ * ```typescript
+ * import { createEmptyBuffer, renderTileMapToBuffer } from 'blecsd';
+ *
+ * const buffer = createEmptyBuffer(80, 24);
+ * renderTileMapToBuffer(buffer, mapEntity, 0, 0);
+ * ```
+ */
+declare function renderTileMapToBuffer(buffer: TileMapBuffer, eid: Entity, cameraX: number, cameraY: number): void;
+/**
+ * Renders all tile map entities in the world to the render buffer.
+ * Uses the configured viewport and camera offset.
+ *
+ * @param world - The ECS world
+ * @returns The render buffer
+ *
+ * @example
+ * ```typescript
+ * import { setTileMapRendererConfig, renderAllTileMaps } from 'blecsd';
+ *
+ * setTileMapRendererConfig({
+ *   viewportWidth: 80,
+ *   viewportHeight: 24,
+ *   camera: { x: 0, y: 0 },
+ * });
+ *
+ * const buffer = renderAllTileMaps(world);
+ * ```
+ */
+declare function renderAllTileMaps(world: World): TileMapBuffer | null;
+/**
+ * TileMap rendering system that renders all tile maps each frame.
+ *
+ * Requires renderer config to be set via setTileMapRendererConfig()
+ * before the system runs. Queries all entities with TileMap and Position
+ * components and composites them into a single render buffer.
+ *
+ * Register this in the RENDER phase.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   setTileMapRendererConfig,
+ *   tilemapRenderSystem,
+ *   createScheduler,
+ *   LoopPhase,
+ * } from 'blecsd';
+ *
+ * setTileMapRendererConfig({
+ *   viewportWidth: 80,
+ *   viewportHeight: 24,
+ *   camera: { x: 0, y: 0 },
+ * });
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.RENDER, tilemapRenderSystem);
+ * ```
+ */
+declare const tilemapRenderSystem: System;
+/**
+ * Creates a new tilemap render system.
+ *
+ * @returns The system function
+ */
+declare function createTilemapRenderSystem(): System;
+
+/**
+ * Virtualized Render System for Large Content
+ *
+ * Renders only visible lines from VirtualViewport-enabled entities.
+ * Achieves 60fps scroll performance with 10M+ lines by skipping off-screen content.
+ *
+ * @module systems/virtualizedRenderSystem
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   virtualizedRenderSystem,
+ *   setVirtualizedRenderBuffer,
+ *   registerLineStore,
+ * } from 'blecsd';
+ *
+ * // Set up the render buffer
+ * setVirtualizedRenderBuffer(doubleBuffer);
+ *
+ * // Associate a line store with an entity
+ * registerLineStore(entity, lineStore);
+ *
+ * // Run the system
+ * virtualizedRenderSystem(world);
+ * ```
+ */
+
+/**
+ * Schema for line render configuration with defaults (for full config).
+ *
+ * @example
+ * ```typescript
+ * import { LineRenderConfigSchema } from 'blecsd';
+ *
+ * const config = LineRenderConfigSchema.parse({
+ *   fg: 0xffffffff,
+ *   bg: 0x000000ff,
+ *   showLineNumbers: true,
+ *   lineNumberWidth: 5,
+ * });
+ * ```
+ */
+declare const LineRenderConfigSchema: z.ZodObject<{
+    fg: z.ZodDefault<z.ZodNumber>;
+    bg: z.ZodDefault<z.ZodNumber>;
+    selectedFg: z.ZodDefault<z.ZodNumber>;
+    selectedBg: z.ZodDefault<z.ZodNumber>;
+    cursorFg: z.ZodDefault<z.ZodNumber>;
+    cursorBg: z.ZodDefault<z.ZodNumber>;
+    showLineNumbers: z.ZodDefault<z.ZodBoolean>;
+    lineNumberWidth: z.ZodDefault<z.ZodNumber>;
+    attrs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Render context for virtualized rendering.
+ */
+interface VirtualizedRenderContext {
+    /** The ECS world */
+    readonly world: World;
+    /** The screen buffer to render to */
+    readonly buffer: ScreenBufferData;
+    /** The double buffer for dirty tracking */
+    readonly doubleBuffer: DoubleBufferData;
+}
+/**
+ * Line render configuration.
+ */
+interface LineRenderConfig {
+    /** Foreground color for normal lines */
+    readonly fg: number;
+    /** Background color for normal lines */
+    readonly bg: number;
+    /** Foreground color for selected line */
+    readonly selectedFg: number;
+    /** Background color for selected line */
+    readonly selectedBg: number;
+    /** Foreground color for cursor line */
+    readonly cursorFg: number;
+    /** Background color for cursor line */
+    readonly cursorBg: number;
+    /** Whether to show line numbers */
+    readonly showLineNumbers: boolean;
+    /** Width reserved for line numbers (0 if not shown) */
+    readonly lineNumberWidth: number;
+    /** Attributes for text */
+    readonly attrs: number;
+}
+/**
+ * Sets the double buffer for the virtualized render system.
+ *
+ * @param db - The double buffer to render to
+ *
+ * @example
+ * ```typescript
+ * import { setVirtualizedRenderBuffer, createDoubleBuffer } from 'blecsd';
+ *
+ * const db = createDoubleBuffer(80, 24);
+ * setVirtualizedRenderBuffer(db);
+ * ```
+ */
+declare function setVirtualizedRenderBuffer(db: DoubleBufferData): void;
+/**
+ * Gets the current virtualized render buffer.
+ *
+ * @returns The current double buffer or null
+ */
+declare function getVirtualizedRenderBuffer(): DoubleBufferData | null;
+/**
+ * Clears the virtualized render buffer reference.
+ */
+declare function clearVirtualizedRenderBuffer(): void;
+/**
+ * Registers a line store for an entity.
+ * The virtualized render system will use this store to get content.
+ *
+ * @param eid - Entity ID
+ * @param store - The line store containing content
+ *
+ * @example
+ * ```typescript
+ * import { registerLineStore, createLineStore } from 'blecsd';
+ *
+ * const store = createLineStore(largeContent);
+ * registerLineStore(entity, store);
+ * ```
+ */
+declare function registerLineStore(eid: Entity, store: VirtualizedLineStore): void;
+/**
+ * Gets the line store for an entity.
+ *
+ * @param eid - Entity ID
+ * @returns The line store or undefined
+ */
+declare function getLineStore(eid: Entity): VirtualizedLineStore | undefined;
+/**
+ * Unregisters a line store for an entity.
+ *
+ * @param eid - Entity ID
+ */
+declare function unregisterLineStore(eid: Entity): void;
+/**
+ * Updates the line store for an entity.
+ * Use this when content changes (e.g., streaming append).
+ *
+ * @param eid - Entity ID
+ * @param store - The new line store
+ */
+declare function updateLineStore(eid: Entity, store: VirtualizedLineStore): void;
+/**
+ * Sets the line render configuration for an entity.
+ * Input is validated against LineRenderConfigSchema.
+ *
+ * @param eid - Entity ID
+ * @param config - Partial config (merged with defaults)
+ * @throws {z.ZodError} If config values are invalid
+ *
+ * @example
+ * ```typescript
+ * import { setLineRenderConfig } from 'blecsd';
+ *
+ * setLineRenderConfig(entity, {
+ *   showLineNumbers: true,
+ *   lineNumberWidth: 5,
+ *   selectedBg: 0x0000ffff, // Blue selection
+ * });
+ * ```
+ */
+declare function setLineRenderConfig(eid: Entity, config: Partial<LineRenderConfig>): void;
+/**
+ * Gets the line render configuration for an entity.
+ *
+ * @param eid - Entity ID
+ * @returns The line render config
+ */
+declare function getLineRenderConfig(eid: Entity): LineRenderConfig;
+/**
+ * Clears the line render configuration for an entity.
+ *
+ * @param eid - Entity ID
+ */
+declare function clearLineRenderConfig(eid: Entity): void;
+/**
+ * Virtualized render system that only renders visible lines.
+ *
+ * The system:
+ * 1. Queries all entities with VirtualViewport
+ * 2. Filters to visible, dirty entities
+ * 3. Gets visible line range from viewport
+ * 4. Retrieves only visible lines from line store
+ * 5. Renders to screen buffer
+ * 6. Marks entities as clean
+ *
+ * @param world - The ECS world
+ * @returns The world (unchanged)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   virtualizedRenderSystem,
+ *   setVirtualizedRenderBuffer,
+ *   registerLineStore,
+ *   createScheduler,
+ *   LoopPhase,
+ * } from 'blecsd';
+ *
+ * // Set up
+ * setVirtualizedRenderBuffer(doubleBuffer);
+ * registerLineStore(entity, lineStore);
+ *
+ * // Register system
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.RENDER, virtualizedRenderSystem);
+ *
+ * // Run
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare const virtualizedRenderSystem: System;
+/**
+ * Creates a new virtualized render system.
+ *
+ * @returns A new render system function
+ */
+declare function createVirtualizedRenderSystem(): System;
+/**
+ * Cleans up all resources for the virtualized render system.
+ * Call this when shutting down.
+ */
+declare function cleanupVirtualizedRenderSystem(): void;
+/**
+ * Cleans up resources for a specific entity.
+ *
+ * @param eid - Entity ID
+ */
+declare function cleanupEntityResources(eid: Entity): void;
+
+/**
+ * Visibility Culling: Efficient entity visibility determination using spatial indexing
+ *
+ * Uses the spatial hash grid for O(1) visibility queries, determining which
+ * entities overlap the current viewport. Supports incremental updates for
+ * moving entities.
+ *
+ * @module systems/visibilityCulling
+ */
+
+/**
+ * Viewport definition for culling.
+ */
+interface Viewport {
+    /** Viewport left edge */
+    readonly x: number;
+    /** Viewport top edge */
+    readonly y: number;
+    /** Viewport width */
+    readonly width: number;
+    /** Viewport height */
+    readonly height: number;
+}
+/**
+ * Visibility culling result.
+ */
+interface CullingResult {
+    /** Entities visible in the viewport */
+    readonly visible: readonly Entity[];
+    /** Total entities considered */
+    readonly total: number;
+    /** Number of entities culled (not visible) */
+    readonly culled: number;
+}
+/**
+ * Entity position cache for incremental updates.
+ */
+interface PositionCache {
+    /** Previous x position per entity */
+    readonly prevX: Map<number, number>;
+    /** Previous y position per entity */
+    readonly prevY: Map<number, number>;
+    /** Previous width per entity */
+    readonly prevW: Map<number, number>;
+    /** Previous height per entity */
+    readonly prevH: Map<number, number>;
+}
+/**
+ * Creates a position cache for tracking entity movement.
+ *
+ * @returns Empty position cache
+ *
+ * @example
+ * ```typescript
+ * import { createPositionCache } from 'blecsd';
+ *
+ * const cache = createPositionCache();
+ * ```
+ */
+declare function createPositionCache(): PositionCache;
+/**
+ * Updates a single entity in the spatial hash only if it has moved.
+ * Returns true if the entity was updated.
+ *
+ * @param grid - Spatial hash grid
+ * @param cache - Position cache
+ * @param eid - Entity to check
+ * @param x - Current x position
+ * @param y - Current y position
+ * @param w - Current width
+ * @param h - Current height
+ * @returns True if entity was updated in the grid
+ */
+declare function updateEntityIfMoved(grid: SpatialHashGrid, cache: PositionCache, eid: Entity, x: number, y: number, w: number, h: number): boolean;
+/**
+ * Removes an entity from the position cache.
+ *
+ * @param cache - Position cache
+ * @param eid - Entity to remove
+ */
+declare function removeFromCache(cache: PositionCache, eid: Entity): void;
+/**
+ * Clears the entire position cache.
+ *
+ * @param cache - Position cache to clear
+ */
+declare function clearPositionCache(cache: PositionCache): void;
+/**
+ * Queries which entities are visible within the given viewport.
+ *
+ * @param grid - Spatial hash grid with entities inserted
+ * @param viewport - Viewport to check visibility against
+ * @returns Set of entity IDs visible in the viewport
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, queryVisibleEntities } from 'blecsd';
+ *
+ * const grid = createSpatialHash({ cellSize: 8 });
+ * // ... insert entities ...
+ *
+ * const visible = queryVisibleEntities(grid, {
+ *   x: 0, y: 0, width: 80, height: 24,
+ * });
+ * ```
+ */
+declare function queryVisibleEntities(grid: SpatialHashGrid, viewport: Viewport): ReadonlySet<number>;
+/**
+ * Performs full visibility culling: queries the spatial hash and returns
+ * a categorized result of visible vs culled entities.
+ *
+ * @param grid - Spatial hash grid
+ * @param viewport - Current viewport
+ * @param totalEntities - Total entity count for stats
+ * @returns Culling result with visible entities and statistics
+ *
+ * @example
+ * ```typescript
+ * const result = performCulling(grid, viewport, 10000);
+ * console.log(`Visible: ${result.visible.length}, Culled: ${result.culled}`);
+ * ```
+ */
+declare function performCulling(grid: SpatialHashGrid, viewport: Viewport, totalEntities: number): CullingResult;
+/**
+ * Creates an incremental spatial hash update system.
+ *
+ * Instead of rebuilding the entire grid each frame, this system only
+ * updates entities that have moved. Much faster for scenes where most
+ * entities are static.
+ *
+ * @param grid - Spatial hash grid to update
+ * @param cache - Position cache for change detection
+ * @returns System function
+ *
+ * @example
+ * ```typescript
+ * import { createSpatialHash, createPositionCache, createIncrementalSpatialSystem } from 'blecsd';
+ *
+ * const grid = createSpatialHash({ cellSize: 4 });
+ * const cache = createPositionCache();
+ * const system = createIncrementalSpatialSystem(grid, cache);
+ *
+ * // Register in scheduler
+ * scheduler.registerSystem(LoopPhase.EARLY_UPDATE, system);
+ * ```
+ */
+declare function createIncrementalSpatialSystem(grid: SpatialHashGrid, cache: PositionCache): System;
+/**
+ * Creates a visibility culling system that marks entities as visible/not visible.
+ *
+ * @param grid - Spatial hash grid
+ * @param getViewport - Function to get the current viewport
+ * @returns System function
+ *
+ * @example
+ * ```typescript
+ * const cullSystem = createVisibilityCullingSystem(grid, () => ({
+ *   x: scrollX, y: scrollY,
+ *   width: terminalCols, height: terminalRows,
+ * }));
+ * ```
+ */
+declare function createVisibilityCullingSystem(grid: SpatialHashGrid, getViewport: () => Viewport): System;
+
+/**
+ * Concurrent rendering with worker thread pool.
+ *
+ * Provides a lightweight worker pool abstraction for offloading
+ * heavy text processing (syntax highlighting, search, diffing)
+ * to background threads. Gracefully degrades on single-core systems
+ * or environments without worker support.
+ *
+ * @module systems/workerPool
+ */
+/**
+ * Configuration for the worker pool.
+ */
+interface WorkerPoolConfig {
+    /** Maximum number of worker threads (default: navigator.hardwareConcurrency - 1 or 2) */
+    readonly maxWorkers: number;
+    /** Task timeout in milliseconds (default: 5000) */
+    readonly taskTimeout: number;
+    /** Whether to enable the pool (false = run everything synchronously) */
+    readonly enabled: boolean;
+}
+/**
+ * Priority levels for tasks.
+ */
+type TaskPriority = 'high' | 'normal' | 'low';
+/**
+ * A task to be executed in the pool.
+ */
+interface PoolTask<TInput = unknown> {
+    /** Unique task ID */
+    readonly id: string;
+    /** Task type identifier */
+    readonly type: string;
+    /** Input data for the task */
+    readonly input: TInput;
+    /** Task priority */
+    readonly priority: TaskPriority;
+    /** Timestamp when task was queued */
+    readonly queuedAt: number;
+}
+/**
+ * Result of a completed pool task.
+ */
+interface TaskResult<TOutput = unknown> {
+    /** Task ID */
+    readonly id: string;
+    /** Task type */
+    readonly type: string;
+    /** Output data (undefined if cancelled or failed) */
+    readonly output: TOutput | undefined;
+    /** Whether the task was cancelled */
+    readonly cancelled: boolean;
+    /** Error message if failed */
+    readonly error: string | undefined;
+    /** Execution time in milliseconds */
+    readonly durationMs: number;
+}
+/**
+ * Worker pool statistics.
+ */
+interface PoolStats {
+    /** Number of active workers */
+    readonly activeWorkers: number;
+    /** Number of idle workers */
+    readonly idleWorkers: number;
+    /** Tasks currently queued */
+    readonly queuedTasks: number;
+    /** Tasks currently running */
+    readonly runningTasks: number;
+    /** Total tasks completed */
+    readonly completedTasks: number;
+    /** Total tasks cancelled */
+    readonly cancelledTasks: number;
+    /** Total tasks failed */
+    readonly failedTasks: number;
+    /** Average task duration in ms */
+    readonly avgDurationMs: number;
+    /** Whether the pool is enabled */
+    readonly enabled: boolean;
+}
+/**
+ * A synchronous task handler for fallback execution.
+ */
+type SyncHandler<TInput = unknown, TOutput = unknown> = (input: TInput) => TOutput;
+/**
+ * Worker pool state object.
+ */
+interface WorkerPoolState {
+    /** Pool configuration */
+    readonly config: WorkerPoolConfig;
+    /** Current pool statistics */
+    readonly stats: PoolStats;
+}
+/**
+ * Creates and initializes the worker pool.
+ *
+ * In this implementation, the pool uses synchronous fallback handlers
+ * running on the main thread with a priority queue. True worker thread
+ * support can be added when node:worker_threads integration is needed.
+ *
+ * @param config - Optional pool configuration
+ * @returns Pool state
+ *
+ * @example
+ * ```typescript
+ * import { createWorkerPool, registerTaskHandler, submitTask } from 'blecsd';
+ *
+ * createWorkerPool({ maxWorkers: 4 });
+ * registerTaskHandler('highlight', (input) => highlightSync(input));
+ * const result = await submitTask('highlight', sourceCode);
+ * ```
+ */
+declare function createWorkerPool(config?: Partial<WorkerPoolConfig>): WorkerPoolState;
+/**
+ * Registers a synchronous handler for a task type.
+ * This handler will be used to process tasks of the given type.
+ *
+ * @param type - Task type identifier
+ * @param handler - Synchronous processing function
+ *
+ * @example
+ * ```typescript
+ * import { registerTaskHandler } from 'blecsd';
+ *
+ * registerTaskHandler('search', (input: { query: string; text: string }) => {
+ *   return input.text.indexOf(input.query);
+ * });
+ * ```
+ */
+declare function registerTaskHandler<TInput = unknown, TOutput = unknown>(type: string, handler: SyncHandler<TInput, TOutput>): void;
+/**
+ * Submits a task to the worker pool.
+ * Returns a promise that resolves when the task completes.
+ *
+ * @param type - Task type (must have a registered handler)
+ * @param input - Input data for the task
+ * @param priority - Task priority (default: 'normal')
+ * @returns Promise resolving to the task result
+ *
+ * @example
+ * ```typescript
+ * import { submitTask } from 'blecsd';
+ *
+ * const result = await submitTask('highlight', { code: 'const x = 1;', lang: 'js' });
+ * if (!result.cancelled && !result.error) {
+ *   console.log(result.output);
+ * }
+ * ```
+ */
+declare function submitTask<TInput = unknown, TOutput = unknown>(type: string, input: TInput, priority?: TaskPriority): Promise<TaskResult<TOutput>>;
+/**
+ * Cancels a pending task by ID.
+ *
+ * @param taskId - ID of the task to cancel
+ * @returns Whether the task was found and cancelled
+ */
+declare function cancelTask(taskId: string): boolean;
+/**
+ * Cancels all pending tasks of a given type.
+ *
+ * @param type - Task type to cancel
+ * @returns Number of tasks cancelled
+ */
+declare function cancelAllOfType(type: string): number;
+/**
+ * Gets the current worker pool state and statistics.
+ *
+ * @returns Current pool state
+ */
+declare function getWorkerPoolState(): WorkerPoolState;
+/**
+ * Destroys the worker pool and cancels all pending tasks.
+ */
+declare function destroyWorkerPool(): void;
+
+export { type BehaviorSystemConfig, type BudgetAlert, type CellCoord, type CollisionEventData, type CollisionEventMap, type CollisionSystemState, ComputedLayout, type ComputedLayoutData, type CullingResult, DEFAULT_CELL_SIZE, type DirtyRect, type DragConstraints, type DragEndEvent, type DragEventMap, type DragMoveEvent, type DragStartEvent, type DragState, type DragVerifyCallback, type DropEvent, type EntityProvider, type FocusEventData, type FocusEventMap, type FocusEventType, type FrameBudgetConfig, type FrameBudgetManager, type FrameStats, type HitTestResult, type InputEventType, type InputSystemState, type LineRenderConfig, LineRenderConfigSchema, type MoveResult, type MovementApplier, type OutputState, type PanelConstraints, type PanelMoveConfig, type PanelMoveState, type ParticleSystemConfig, type PoolStats, type PoolTask, type PositionCache, type PositionResolver, type QueuedInputEvent, type QueuedKeyEvent, type QueuedMouseEvent, type RenderContext, type ResizeHandle, type ScrollAnimationState, type ScrollEvent, type ScrollPhysicsConfig, type SpatialHashConfig, type SpatialHashGrid, type SpatialHashStats, type SyncHandler, type SystemTiming, type TaskPriority, type TaskResult, type TileMapBuffer, type TileMapCamera, type TileMapRendererConfig, type Viewport, type VirtualizedRenderContext, type WorkerPoolConfig, type WorkerPoolState, ageParticle, animationSystem, applyScrollImpulse, areColliding, beginMove, beginResize, blurAll, burstParticles, cameraSystem, cancelAllOfType, cancelMoveOrResize, cancelTask, captureMouseTo, cleanup, cleanupEntityResources, cleanupVirtualizedRenderSystem, clearAllScrollStates, clearDragConstraints, clearEntityInput, clearEventQueue, clearFocusStack, clearLineRenderConfig, clearOutputBuffer, clearOutputStream, clearPositionCache, clearRenderBuffer, clearScreen, clearSpatialHash, clearTileMapRenderBuffer, clearVirtualizedRenderBuffer, collisionSystem, computeLayoutNow, createAnimationSystem, createBehaviorSystem, createCameraSystem, createCollisionSystem, createDragSystem, createEmptyBuffer, createFocusSystem, createFrameBudgetManager, createIncrementalSpatialSystem, createInputSystem, createLayoutSystem, createMovementSystem, createOutputState, createOutputSystem, createPanelConstraints, createPanelMoveConfig, createPanelMoveState, createParticleSystem, createPositionCache, createRenderSystem, createSmoothScrollSystem, createSpatialHash, createSpatialHashSystem, createStateMachineSystem, createTilemapRenderSystem, createVirtualizedRenderSystem, createVisibilityCullingSystem, createWorkerPool, cursorHome, destroyFrameBudgetManager, destroyWorkerPool, detectCollisions, detectResizeHandle, endMoveOrResize, endUserScroll, enterAlternateScreen, exportFrameBudgetMetrics, focusEntity, focusFirst, focusLast, focusNext, focusOffset, focusPop, focusPrev, focusPush, focusSystem, generateOutput, getActiveCollisions, getActiveTriggers, getCollidingEntities, getCollisionEventBus, getComputedBounds, getComputedLayout, getDragConstraints, getDragVerifyCallback, getEntitiesAtPoint, getEntitiesInCell, getEventQueue, getFocusEventBus, getFocusStackDepth, getFocusableEntities, getFocused, getFrameBudgetStats, getInputEventBus, getInteractiveEntityAt, getLineRenderConfig, getLineStore, getMouseCaptureEntity, getNearbyEntities, getOutputBuffer, getOutputState, getOutputStream, getRenderBuffer, getScrollPosition, getScrollState, getSpatialHashGrid, getSpatialHashStats, getStateAgeStore, getSystemStateAge, getTileMapRenderBuffer, getTileMapRendererConfig, getTriggerZones, getVirtualizedRenderBuffer, getWorkerPoolState, hasAnimationSystem, hasComputedLayout, hasMovementSystem, hideCursor, hitTest, inputState, inputSystem, insertEntity, invalidateAllLayouts, invalidateLayout, isColliding, isInTrigger, isMouseCaptured, isScrolling, keyboardMove, keyboardResize, killParticle, layoutSystem, leaveAlternateScreen, markAllDirty, mergeDirtyRects, moveParticle, movementSystem, onBudgetAlert, outputSystem, peekFocusStack, performCulling, pointInEntity, profiledSystem, queryAnimation, queryArea, queryCameras, queryColliders, queryInputReceivers, queryMovement, queryStateMachine, queryVisibleEntities, queueKeyEvent, queueMouseEvent, rebuildSpatialHash, recordFrameBudgetSystemTime, recordFrameTime, recordPhaseTime, registerAnimationSystem, registerCameraSystem, registerCollisionSystem, registerInputSystem, registerLineStore, registerMovementSystem, registerStateMachineSystem, registerTaskHandler, releaseMouse, removeEntityFromGrid, removeFromCache, removeScrollState, renderAllTileMaps, renderBackground, renderBorder, renderContent, renderRect, renderScrollbar, renderSystem, renderText, renderTileMapToBuffer, resetAttributes, resetCollisionState, resetDragStores, resetFocusEventBus, resetFrameBudget, resetInputState, resetOutputState, resetStateAge, resetTileMapRenderer, restoreFocus, rewindFocus, saveFocus, setDragConstraints, setDragVerifyCallback, setLineRenderConfig, setOutputBuffer, setOutputStream, setRenderBuffer, setScrollImmediate, setSpatialHashGrid, setTileMapRendererConfig, setVirtualizedRenderBuffer, showCursor, smoothScrollTo, spatialHashSystem, spawnParticle, startUserScroll, stateMachineSystem, submitTask, tilemapRenderSystem, unregisterLineStore, updateAnimations, updateCameras, updateEntityIfMoved, updateLineStore, updateMove, updateMovements, updateResize, updateScrollPhysics, updateStateAges, virtualizedRenderSystem, worldToCell, writeRaw };