blecsd 0.4.0 → 0.6.2

package/dist/panelMovement-DSLYdNOL.d.ts

@@ -0,0 +1,1909 @@
+import { S as Scheduler } from './scheduler-NbHT3-D2.js';
+import { S as System, W as World, E as Entity } from './types-B8LmNkzG.js';
+import { a as EventBus, U as UIEventMap } from './events-CGqK6LGt.js';
+import { K as KeyEvent } from './keyParser-DReXe2j-.js';
+import { M as MouseEvent } from './mouseParser-CTNGolIA.js';
+import { Writable } from 'node:stream';
+import { a as CellChange, S as ScreenBufferData, C as Cell } from './cell-5Ty_3yMs.js';
+import { D as DoubleBufferData } from './doubleBuffer-d9yVNtj1.js';
+import { a as DirtyTracker } from './dirtyTracking-D0SQrEeo.js';
+
+/**
+ * Animation system for updating sprite animations.
+ * Processes all entities with Animation component.
+ * @module systems/animationSystem
+ */
+
+/**
+ * Query all entities with the Animation component.
+ *
+ * PERF: Returns iterable query result to avoid per-frame allocation.
+ *
+ * @param world - The ECS world
+ * @returns Iterable of entity IDs with Animation component
+ */
+declare function queryAnimation(world: World): Iterable<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;
+
+/**
+ * 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;
+
+/**
+ * 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).
+ *
+ * PERF: Uses iterator directly to avoid intermediate array allocation.
+ *
+ * @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.
+ *
+ * PERF: Reuses module-level scratch array to avoid per-call allocation.
+ * The returned array is only valid until the next call to this function.
+ *
+ * @param world - The ECS world
+ * @returns Array of entity IDs that can receive input (reused buffer)
+ */
+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;
+
+/**
+ * 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;
+    /** Whether mouse tracking is enabled */
+    mouseTracking: boolean;
+    /** Mouse tracking mode */
+    mouseMode: string | null;
+    /** Whether synchronized output is active */
+    syncOutput: boolean;
+    /** Whether bracketed paste mode is enabled */
+    bracketedPaste: boolean;
+    /** Whether focus reporting is enabled */
+    focusReporting: boolean;
+}
+/**
+ * Creates initial output state.
+ */
+declare function createOutputState(): OutputState;
+declare function generateOutput(world: World, state: OutputState, changes: readonly CellChange[], skipSort?: boolean): 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;
+/**
+ * Rings the terminal bell.
+ *
+ * @example
+ * ```typescript
+ * import { bell } from 'blecsd';
+ *
+ * bell(); // Produce audible or visual bell
+ * ```
+ */
+declare function bell(): void;
+/**
+ * Moves cursor to a specific position.
+ *
+ * @param x - Column position (0-indexed)
+ * @param y - Row position (0-indexed)
+ *
+ * @example
+ * ```typescript
+ * import { moveTo } from 'blecsd';
+ *
+ * moveTo(10, 5); // Move to column 10, row 5
+ * ```
+ */
+declare function moveTo(x: number, y: number): void;
+/**
+ * Enables mouse tracking in the terminal.
+ *
+ * @param mode - Mouse tracking mode: 'normal' (clicks only), 'button' (clicks + drag), or 'any' (all motion). Default is 'any'.
+ *
+ * @example
+ * ```typescript
+ * import { enableMouseTracking } from 'blecsd';
+ *
+ * enableMouseTracking('any'); // Track all mouse motion
+ * enableMouseTracking('button'); // Track only when button pressed
+ * enableMouseTracking('normal'); // Track clicks only
+ * ```
+ */
+declare function enableMouseTracking(mode?: 'normal' | 'button' | 'any'): void;
+/**
+ * Disables mouse tracking in the terminal.
+ *
+ * @example
+ * ```typescript
+ * import { disableMouseTracking } from 'blecsd';
+ *
+ * disableMouseTracking();
+ * ```
+ */
+declare function disableMouseTracking(): void;
+/**
+ * Sets the terminal cursor shape.
+ *
+ * @param shape - Cursor shape: 'block', 'underline', or 'bar'
+ *
+ * @example
+ * ```typescript
+ * import { setTerminalCursorShape } from 'blecsd';
+ *
+ * setTerminalCursorShape('block'); // Block cursor
+ * setTerminalCursorShape('underline'); // Underline cursor
+ * setTerminalCursorShape('bar'); // Bar/vertical line cursor
+ * ```
+ */
+declare function setTerminalCursorShape(shape: 'block' | 'underline' | 'bar'): void;
+/**
+ * Sets the terminal window title.
+ *
+ * @param title - Window title string
+ *
+ * @example
+ * ```typescript
+ * import { setWindowTitle } from 'blecsd';
+ *
+ * setWindowTitle('My Terminal App');
+ * ```
+ */
+declare function setWindowTitle(title: string): void;
+/**
+ * Begins synchronized output mode.
+ * Prevents partial screen updates from being displayed.
+ *
+ * @example
+ * ```typescript
+ * import { beginSyncOutput, endSyncOutput } from 'blecsd';
+ *
+ * beginSyncOutput();
+ * // ... render multiple updates ...
+ * endSyncOutput(); // All updates appear atomically
+ * ```
+ */
+declare function beginSyncOutput(): void;
+/**
+ * Ends synchronized output mode.
+ *
+ * @example
+ * ```typescript
+ * import { endSyncOutput } from 'blecsd';
+ *
+ * endSyncOutput();
+ * ```
+ */
+declare function endSyncOutput(): void;
+/**
+ * Saves the current cursor position.
+ *
+ * @example
+ * ```typescript
+ * import { saveCursorPosition, restoreCursorPosition } from 'blecsd';
+ *
+ * saveCursorPosition();
+ * // ... move cursor and draw ...
+ * restoreCursorPosition(); // Return to saved position
+ * ```
+ */
+declare function saveCursorPosition(): void;
+/**
+ * Restores the previously saved cursor position.
+ *
+ * @example
+ * ```typescript
+ * import { restoreCursorPosition } from 'blecsd';
+ *
+ * restoreCursorPosition();
+ * ```
+ */
+declare function restoreCursorPosition(): void;
+/**
+ * Enables bracketed paste mode in the terminal.
+ * When enabled, pasted text is bracketed with special sequences.
+ *
+ * @example
+ * ```typescript
+ * import { enableBracketedPasteMode } from 'blecsd';
+ *
+ * enableBracketedPasteMode();
+ * ```
+ */
+declare function enableBracketedPasteMode(): void;
+/**
+ * Disables bracketed paste mode in the terminal.
+ *
+ * @example
+ * ```typescript
+ * import { disableBracketedPasteMode } from 'blecsd';
+ *
+ * disableBracketedPasteMode();
+ * ```
+ */
+declare function disableBracketedPasteMode(): void;
+/**
+ * Enables focus reporting in the terminal.
+ * When enabled, the terminal sends focus in/out events.
+ *
+ * @example
+ * ```typescript
+ * import { enableFocusReporting } from 'blecsd';
+ *
+ * enableFocusReporting();
+ * ```
+ */
+declare function enableFocusReporting(): void;
+/**
+ * Disables focus reporting in the terminal.
+ *
+ * @example
+ * ```typescript
+ * import { disableFocusReporting } from 'blecsd';
+ *
+ * disableFocusReporting();
+ * ```
+ */
+declare function disableFocusReporting(): 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;
+
+/**
+ * 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 dirty tracker for optimized rendering */
+    readonly dirtyTracker: DirtyTracker;
+}
+/**
+ * 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;
+/**
+ * Recursively renders an entity and its children in tree order.
+ * @internal Currently unused, reserved for future tree-based rendering mode.
+ *
+ * @param ctx - Render context
+ * @param eid - Entity ID
+ */
+/**
+ * Viewport bounds for culling off-screen entities.
+ * Defaults to null (no culling). Set via setViewportBounds().
+ */
+interface ViewportBounds {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Sets the viewport bounds for culling.
+ * Entities outside these bounds will be skipped during rendering.
+ *
+ * Pass null to disable viewport culling (default).
+ * Typically set to screen dimensions for scrollable content optimization.
+ *
+ * @param bounds - Viewport bounds or null to disable culling
+ *
+ * @example
+ * ```typescript
+ * import { setViewportBounds } from 'blecsd';
+ *
+ * // Enable viewport culling for 80x24 screen
+ * setViewportBounds({ x: 0, y: 0, width: 80, height: 24 });
+ *
+ * // Disable viewport culling
+ * setViewportBounds(null);
+ * ```
+ */
+declare function setViewportBounds(bounds: ViewportBounds | null): void;
+/**
+ * Gets the current viewport bounds.
+ *
+ * @returns Current viewport bounds or null if disabled
+ */
+declare function getViewportBounds(): ViewportBounds | null;
+/**
+ * Sets the dirty tracker and screen buffer for the render system.
+ * Must be called before running the render system.
+ *
+ * @param tracker - The dirty tracker for optimized rendering
+ * @param buffer - The screen buffer to render to
+ *
+ * @example
+ * ```typescript
+ * import { setRenderBuffer, createDirtyTracker } from 'blecsd';
+ * import { createScreenBuffer } from 'blecsd';
+ *
+ * const tracker = createDirtyTracker(80, 24);
+ * const buffer = createScreenBuffer(80, 24);
+ * setRenderBuffer(tracker, buffer);
+ * ```
+ */
+declare function setRenderBuffer(tracker: DirtyTracker, buffer: ScreenBufferData): void;
+/**
+ * Gets the current dirty tracker.
+ *
+ * @returns The current dirty tracker or null
+ */
+declare function getRenderBuffer(): DirtyTracker | null;
+/**
+ * Clears the render buffer references.
+ */
+declare function clearRenderBuffer(): void;
+/**
+ * Enables or disables z-order occlusion culling.
+ * When enabled, entities fully hidden behind higher z-index entities are skipped during rendering.
+ *
+ * Disabled by default. Enable for applications with many overlapping widgets (modals, dialogs, overlays)
+ * where the performance benefit outweighs the culling overhead.
+ *
+ * @param enabled - Whether to enable occlusion culling (default: false)
+ *
+ * @example
+ * ```typescript
+ * import { setOcclusionCulling } from 'blecsd';
+ *
+ * // Enable occlusion culling for layered UI
+ * setOcclusionCulling(true);
+ * ```
+ */
+declare function setOcclusionCulling(enabled: boolean): void;
+/**
+ * Gets the current occlusion culling state.
+ *
+ * @returns True if occlusion culling is enabled
+ */
+declare function isOcclusionCullingEnabled(): boolean;
+/**
+ * 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. Applies viewport bounds culling (skips off-screen entities)
+ * 5. Applies z-order occlusion culling (skips fully hidden entities)
+ * 6. Renders each visible entity (background, border, content)
+ * 7. Marks entities as clean
+ *
+ * Viewport culling: entities completely outside the viewport bounds are skipped
+ * to improve performance in scrollable content with many off-screen entities.
+ * Enable via `setViewportBounds({ x, y, width, height })`.
+ *
+ * Occlusion culling: entities fully covered by higher z-index entities are
+ * skipped to improve performance in layered UIs (modals, dialogs, overlays).
+ * Enable via `setOcclusionCulling(true)`.
+ *
+ * @param world - The ECS world
+ * @returns The world (unchanged)
+ *
+ * @example
+ * ```typescript
+ * import { renderSystem, setRenderBuffer, setViewportBounds, createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ * scheduler.registerSystem(LoopPhase.RENDER, renderSystem);
+ *
+ * // Set render buffer and enable viewport culling
+ * setRenderBuffer(dirtyTracker, screenBuffer);
+ * setViewportBounds({ x: 0, y: 0, width: 80, height: 24 });
+ *
+ * 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;
+
+/**
+ * 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;
+
+export { clearEventQueue as $, focusFirst as A, focusLast as B, focusOffset as C, type DirtyRect as D, blurAll as E, getFocused as F, getFocusableEntities as G, getFocusEventBus as H, resetFocusEventBus as I, focusPush as J, focusPop as K, peekFocusStack as L, getFocusStackDepth as M, clearFocusStack as N, saveFocus as O, restoreFocus as P, rewindFocus as Q, createInputSystem as R, registerInputSystem as S, type InputSystemState as T, queryInputReceivers as U, hitTest as V, pointInEntity as W, getInteractiveEntityAt as X, queueKeyEvent as Y, queueMouseEvent as Z, getEventQueue as _, animationSystem as a, isOcclusionCullingEnabled as a$, clearEntityInput as a0, getInputEventBus as a1, resetInputState as a2, captureMouseTo as a3, releaseMouse as a4, isMouseCaptured as a5, getMouseCaptureEntity as a6, createLayoutSystem as a7, computeLayoutNow as a8, getComputedLayout as a9, beginSyncOutput as aA, endSyncOutput as aB, createPanelMoveState as aC, createPanelMoveConfig as aD, createPanelConstraints as aE, beginMove as aF, beginResize as aG, updateMove as aH, updateResize as aI, endMoveOrResize as aJ, cancelMoveOrResize as aK, detectResizeHandle as aL, mergeDirtyRects as aM, keyboardMove as aN, keyboardResize as aO, createRenderSystem as aP, getRenderBuffer as aQ, clearRenderBuffer as aR, markAllDirty as aS, renderContent as aT, renderBackground as aU, renderBorder as aV, renderScrollbar as aW, renderText as aX, renderRect as aY, getViewportBounds as aZ, setViewportBounds as a_, getComputedBounds as aa, hasComputedLayout as ab, invalidateLayout as ac, invalidateAllLayouts as ad, createOutputSystem as ae, createOutputState as af, clearOutputBuffer as ag, clearOutputStream as ah, generateOutput as ai, getOutputBuffer as aj, getOutputStream as ak, getOutputState as al, resetOutputState as am, moveTo as an, saveCursorPosition as ao, restoreCursorPosition as ap, setTerminalCursorShape as aq, setWindowTitle as ar, resetAttributes as as, bell as at, enableMouseTracking as au, disableMouseTracking as av, enableBracketedPasteMode as aw, disableBracketedPasteMode as ax, enableFocusReporting as ay, disableFocusReporting as az, clearScreen as b, setOcclusionCulling as b0, ComputedLayout as b1, type ComputedLayoutData as b2, type FocusEventData as b3, type FocusEventMap as b4, type FocusEventType as b5, type HitTestResult as b6, type InputEventType as b7, type MoveResult as b8, type OutputState as b9, type PanelConstraints as ba, type PanelMoveConfig as bb, type PanelMoveState as bc, type QueuedInputEvent as bd, type QueuedKeyEvent as be, type QueuedMouseEvent as bf, type RenderContext as bg, type ResizeHandle as bh, inputState as bi, cleanup as c, cursorHome as d, enterAlternateScreen as e, focusSystem as f, leaveAlternateScreen as g, hideCursor as h, inputSystem as i, setOutputStream as j, setRenderBuffer as k, layoutSystem as l, showCursor as m, createAnimationSystem as n, outputSystem as o, registerAnimationSystem as p, hasAnimationSystem as q, renderSystem as r, setOutputBuffer as s, queryAnimation as t, updateAnimations as u, createFocusSystem as v, writeRaw as w, focusEntity as x, focusNext as y, focusPrev as z };