blecsd 0.3.0 → 0.6.0

package/dist/{inputActions-CRsUtTHM.d.ts → factories-vW7bn_He.d.ts}

@@ -1,7 +1,6 @@
+import { W as World, E as Entity } from './types-B8LmNkzG.js';
 import { z } from 'zod';
-import { h as BorderCharset } from './border-Jb7TrMob.js';
-import { M as MouseEvent, c as MouseButton } from './mouseParser-Cfrbn3AX.js';
-import { b as KeyEvent, K as KeyName } from './keyParser-BnHbg2iD.js';
+import { o as BorderCharset } from './border-Br-Jc027.js';
 
 /**
  * Zod validation schemas and TypeScript types for entity configurations.
@@ -1138,789 +1137,25 @@ declare const RadioButtonConfigSchema: z.ZodObject<{
 type RadioButtonConfig = z.infer<typeof RadioButtonConfigSchema>;
 
 /**
- * Input event buffer for frame-independent input handling.
- *
- * Buffers keyboard and mouse events between frames so no input is lost.
- * Events are collected asynchronously from stdin and drained synchronously
- * each frame by the game loop.
- *
- * HARD REQUIREMENT: No input events should ever be lost or delayed.
- *
- * @module core/inputEventBuffer
- */
-
-/**
- * A timestamped keyboard event.
- */
-interface TimestampedKeyEvent {
-    readonly type: 'key';
-    readonly event: KeyEvent;
-    readonly timestamp: number;
-}
-/**
- * A timestamped mouse event.
- */
-interface TimestampedMouseEvent {
-    readonly type: 'mouse';
-    readonly event: MouseEvent;
-    readonly timestamp: number;
-}
-/**
- * Union of all timestamped input events.
- */
-type TimestampedInputEvent = TimestampedKeyEvent | TimestampedMouseEvent;
-/**
- * Statistics about the input buffer.
- */
-interface InputBufferStats {
-    /** Total key events pushed since creation/reset */
-    readonly totalKeyEvents: number;
-    /** Total mouse events pushed since creation/reset */
-    readonly totalMouseEvents: number;
-    /** Current key events in buffer */
-    readonly pendingKeyEvents: number;
-    /** Current mouse events in buffer */
-    readonly pendingMouseEvents: number;
-    /** Number of events dropped due to overflow */
-    readonly droppedEvents: number;
-    /** Maximum buffer size */
-    readonly maxBufferSize: number;
-}
-/**
- * Latency statistics for input processing.
- * All values in milliseconds.
- */
-interface InputLatencyStats {
-    /** Minimum latency observed */
-    readonly min: number;
-    /** Maximum latency observed */
-    readonly max: number;
-    /** Average latency */
-    readonly avg: number;
-    /** 95th percentile latency */
-    readonly p95: number;
-    /** 99th percentile latency */
-    readonly p99: number;
-    /** Number of samples in the window */
-    readonly sampleCount: number;
-    /** Last frame processing time in ms */
-    readonly lastFrameProcessingTime: number;
-    /** Average frame processing time */
-    readonly avgFrameProcessingTime: number;
-}
-/**
- * Configuration options for the input event buffer.
- */
-interface InputEventBufferOptions {
-    /**
-     * Maximum number of events to buffer before dropping oldest.
-     * Set to 0 for unlimited (not recommended).
-     * @default 1000
-     */
-    readonly maxBufferSize?: number;
-    /**
-     * Whether to emit a warning when buffer overflows.
-     * @default true
-     */
-    readonly warnOnOverflow?: boolean;
-    /**
-     * Custom warning handler for overflow events.
-     * @default console.warn
-     */
-    readonly onOverflow?: (droppedCount: number) => void;
-    /**
-     * Maximum number of latency samples to keep for statistics.
-     * @default 1000
-     */
-    readonly maxLatencySamples?: number;
-    /**
-     * Maximum number of frame processing time samples to keep.
-     * @default 100
-     */
-    readonly maxFrameSamples?: number;
-}
-/**
- * Input event buffer data structure.
- * All state is stored in plain arrays for functional manipulation.
- */
-interface InputEventBufferData {
-    /** Pending key events */
-    keyEvents: TimestampedKeyEvent[];
-    /** Pending mouse events */
-    mouseEvents: TimestampedMouseEvent[];
-    /** Latency samples for statistics */
-    latencySamples: number[];
-    /** Frame processing time samples */
-    frameProcessingTimes: number[];
-    /** Frame start timestamp */
-    frameStartTime: number;
-    /** Total key events pushed since creation/reset */
-    totalKeyEvents: number;
-    /** Total mouse events pushed since creation/reset */
-    totalMouseEvents: number;
-    /** Number of events dropped due to overflow */
-    droppedEvents: number;
-    /** Configuration */
-    readonly config: {
-        readonly maxBufferSize: number;
-        readonly maxLatencySamples: number;
-        readonly maxFrameSamples: number;
-        readonly warnOnOverflow: boolean;
-        readonly onOverflow: (droppedCount: number) => void;
-    };
-}
-/**
- * Creates a new input event buffer.
- *
- * @param options - Buffer configuration options
- * @returns A new InputEventBufferData
- *
- * @example
- * ```typescript
- * import { createInputEventBuffer, pushKeyEvent, drainKeys } from 'blecsd';
- *
- * const buffer = createInputEventBuffer({ maxBufferSize: 500 });
- *
- * // Push events from stdin
- * pushKeyEvent(buffer, keyEvent);
- *
- * // Drain in game loop
- * const keys = drainKeys(buffer);
- * ```
- */
-declare function createInputEventBuffer(options?: InputEventBufferOptions): InputEventBufferData;
-/**
- * Pushes a keyboard event to the buffer.
- *
- * @param buffer - The input event buffer
- * @param event - The keyboard event to buffer
- * @param timestamp - Optional timestamp (default: now)
- *
- * @example
- * ```typescript
- * pushKeyEvent(buffer, { name: 'a', ctrl: false, meta: false, shift: false, sequence: 'a' });
- * ```
- */
-declare function pushKeyEvent(buffer: InputEventBufferData, event: KeyEvent, timestamp?: number): void;
-/**
- * Pushes a mouse event to the buffer.
- *
- * @param buffer - The input event buffer
- * @param event - The mouse event to buffer
- * @param timestamp - Optional timestamp (default: now)
- *
- * @example
- * ```typescript
- * pushMouseEvent(buffer, { x: 10, y: 20, button: 'left', action: 'mousedown', ctrl: false, meta: false, shift: false });
- * ```
- */
-declare function pushMouseEvent(buffer: InputEventBufferData, event: MouseEvent, timestamp?: number): void;
-/**
- * Drains all keyboard events from the buffer.
- * Returns events in order (oldest first) and clears the buffer.
- *
- * @param buffer - The input event buffer
- * @returns Array of timestamped key events
- *
- * @example
- * ```typescript
- * const keys = drainKeys(buffer);
- * for (const { event, timestamp } of keys) {
- *   console.log(`Key: ${event.name} at ${timestamp}`);
- * }
- * ```
- */
-declare function drainKeys(buffer: InputEventBufferData): TimestampedKeyEvent[];
-/**
- * Drains all mouse events from the buffer.
- * Returns events in order (oldest first) and clears the buffer.
- *
- * @param buffer - The input event buffer
- * @returns Array of timestamped mouse events
- *
- * @example
- * ```typescript
- * const mouse = drainMouse(buffer);
- * for (const { event, timestamp } of mouse) {
- *   console.log(`Mouse: ${event.action} at ${event.x},${event.y}`);
- * }
- * ```
- */
-declare function drainMouse(buffer: InputEventBufferData): TimestampedMouseEvent[];
-/**
- * Drains all events (keys and mouse) from the buffer.
- * Returns events in chronological order by timestamp.
- *
- * @param buffer - The input event buffer
- * @returns Array of all timestamped events sorted by timestamp
- *
- * @example
- * ```typescript
- * const events = drainAllEvents(buffer);
- * for (const event of events) {
- *   if (event.type === 'key') {
- *     handleKey(event.event);
- *   } else {
- *     handleMouse(event.event);
- *   }
- * }
- * ```
- */
-declare function drainAllEvents(buffer: InputEventBufferData): TimestampedInputEvent[];
-/**
- * Peeks at all pending events without removing them.
- *
- * @param buffer - The input event buffer
- * @returns Array of all pending events sorted by timestamp
- */
-declare function peekEvents(buffer: InputEventBufferData): TimestampedInputEvent[];
-/**
- * Peeks at pending key events without removing them.
- *
- * @param buffer - The input event buffer
- * @returns Array of pending key events
- */
-declare function peekKeys(buffer: InputEventBufferData): readonly TimestampedKeyEvent[];
-/**
- * Peeks at pending mouse events without removing them.
- *
- * @param buffer - The input event buffer
- * @returns Array of pending mouse events
- */
-declare function peekMouse(buffer: InputEventBufferData): readonly TimestampedMouseEvent[];
-/**
- * Clears all pending events from the buffer.
- *
- * @param buffer - The input event buffer
- */
-declare function clearBuffer(buffer: InputEventBufferData): void;
-/**
- * Gets the number of pending key events.
- *
- * @param buffer - The input event buffer
- */
-declare function getPendingKeyCount(buffer: InputEventBufferData): number;
-/**
- * Gets the number of pending mouse events.
- *
- * @param buffer - The input event buffer
- */
-declare function getPendingMouseCount(buffer: InputEventBufferData): number;
-/**
- * Gets the total number of pending events.
- *
- * @param buffer - The input event buffer
- */
-declare function getPendingCount(buffer: InputEventBufferData): number;
-/**
- * Checks if there are any pending events.
- *
- * @param buffer - The input event buffer
- */
-declare function hasPendingEvents(buffer: InputEventBufferData): boolean;
-/**
- * Gets buffer statistics for debugging.
- *
- * @param buffer - The input event buffer
- * @returns Statistics about the buffer
- *
- * @example
- * ```typescript
- * const stats = getStats(buffer);
- * console.log(`Total events: ${stats.totalKeyEvents + stats.totalMouseEvents}`);
- * console.log(`Dropped: ${stats.droppedEvents}`);
- * ```
- */
-declare function getStats(buffer: InputEventBufferData): InputBufferStats;
-/**
- * Resets buffer statistics.
- *
- * @param buffer - The input event buffer
- */
-declare function resetStats(buffer: InputEventBufferData): void;
-/**
- * Marks the start of frame processing.
- * Call this at the beginning of your input processing phase.
- *
- * @param buffer - The input event buffer
- *
- * @example
- * ```typescript
- * beginFrame(buffer);
- * const keys = drainKeys(buffer);
- * // process keys...
- * endFrame(buffer);
- * ```
- */
-declare function beginFrame(buffer: InputEventBufferData): void;
-/**
- * Marks the end of frame processing and records the processing time.
- * Call this after all input events have been processed.
- *
- * @param buffer - The input event buffer
- * @returns The frame processing time in milliseconds
- */
-declare function endFrame(buffer: InputEventBufferData): number;
-/**
- * Records latency for a processed event.
- * Call this when an event has been fully processed to track input latency.
- *
- * @param buffer - The input event buffer
- * @param latencyMs - The latency in milliseconds
- *
- * @example
- * ```typescript
- * for (const { event, timestamp } of drainKeys(buffer)) {
- *   handleKey(event);
- *   const latency = performance.now() - timestamp;
- *   recordLatency(buffer, latency);
- * }
- * ```
- */
-declare function recordLatency(buffer: InputEventBufferData, latencyMs: number): void;
-/**
- * Records latency for multiple events at once.
- * More efficient than calling recordLatency for each event.
- *
- * @param buffer - The input event buffer
- * @param avgLatencyMs - Average latency for all events
- * @param eventCount - Number of events processed
- */
-declare function recordLatencyBatch(buffer: InputEventBufferData, avgLatencyMs: number, eventCount: number): void;
-/**
- * Gets latency statistics for input processing.
- * Returns min, max, average, and percentile latencies.
- *
- * @param buffer - The input event buffer
- * @returns Latency statistics in milliseconds
- *
- * @example
- * ```typescript
- * const stats = getLatencyStats(buffer);
- * console.log(`Avg latency: ${stats.avg.toFixed(2)}ms`);
- * console.log(`P95 latency: ${stats.p95.toFixed(2)}ms`);
- * if (stats.max > 16) {
- *   console.warn('Input latency exceeds frame budget!');
- * }
- * ```
- */
-declare function getLatencyStats(buffer: InputEventBufferData): InputLatencyStats;
-/**
- * Resets latency statistics.
- *
- * @param buffer - The input event buffer
- */
-declare function resetLatencyStats(buffer: InputEventBufferData): void;
-/**
- * Checks if the current latency is within acceptable bounds.
- * By default, checks if p95 latency is under 16ms (one frame at 60fps).
- *
- * @param buffer - The input event buffer
- * @param maxLatencyMs - Maximum acceptable p95 latency in milliseconds
- * @returns True if latency is acceptable
- */
-declare function isLatencyAcceptable(buffer: InputEventBufferData, maxLatencyMs?: number): boolean;
-/**
- * Checks if frame processing time is within budget.
- * By default, checks if average processing time is under 1ms.
- *
- * @param buffer - The input event buffer
- * @param maxProcessingTimeMs - Maximum acceptable processing time in milliseconds
- * @returns True if processing time is acceptable
- */
-declare function isProcessingTimeAcceptable(buffer: InputEventBufferData, maxProcessingTimeMs?: number): boolean;
-/**
- * Global shared input buffer for simple use cases.
- *
- * For more complex scenarios (multiple input sources, custom overflow handling),
- * create your own buffer with createInputEventBuffer().
- *
- * @example
- * ```typescript
- * import { globalInputBuffer, pushKeyEvent, drainAllEvents } from 'blecsd';
- *
- * // Push from stdin handler
- * pushKeyEvent(globalInputBuffer, event);
- *
- * // Drain in game loop
- * const events = drainAllEvents(globalInputBuffer);
- * ```
+ * Entity factory functions for creating common entity types.
+ * These factories combine components and helpers to create fully-configured entities.
+ * @module core/entities/factories
  */
-declare const globalInputBuffer: InputEventBufferData;
 
-/**
- * Input state tracking for keyboard and mouse.
- *
- * Provides frame-aware input queries like isKeyPressed (just this frame),
- * isKeyReleased, key hold time, and repeat handling.
- *
- * @module core/inputState
- */
-
-/**
- * State of a single key.
- */
-interface KeyState {
-    /** Key is currently pressed down */
-    readonly pressed: boolean;
-    /** Key was pressed this frame (transitioned from up to down) */
-    readonly justPressed: boolean;
-    /** Key was released this frame (transitioned from down to up) */
-    readonly justReleased: boolean;
-    /** Time the key has been held in milliseconds */
-    readonly heldTime: number;
-    /** Number of auto-repeat events received while held */
-    readonly repeatCount: number;
-    /** Last event timestamp */
-    readonly lastEventTime: number;
-}
-/**
- * State of a mouse button.
- */
-interface MouseButtonState {
-    /** Button is currently pressed */
-    readonly pressed: boolean;
-    /** Button was pressed this frame */
-    readonly justPressed: boolean;
-    /** Button was released this frame */
-    readonly justReleased: boolean;
-    /** Time the button has been held in milliseconds */
-    readonly heldTime: number;
-    /** Last event timestamp */
-    readonly lastEventTime: number;
-}
-/**
- * Current mouse position and state.
- */
-interface MouseState {
-    /** Current X position */
-    readonly x: number;
-    /** Current Y position */
-    readonly y: number;
-    /** X movement since last frame */
-    readonly deltaX: number;
-    /** Y movement since last frame */
-    readonly deltaY: number;
-    /** Scroll wheel delta since last frame (positive = up) */
-    readonly wheelDelta: number;
-    /** State of each button */
-    readonly buttons: Readonly<Record<MouseButton, MouseButtonState>>;
-}
-/**
- * Input state statistics.
- */
-interface InputStateStats {
-    /** Number of keys currently held down */
-    readonly keysDown: number;
-    /** Number of keys pressed this frame */
-    readonly keysPressed: number;
-    /** Number of keys released this frame */
-    readonly keysReleased: number;
-    /** Total key events processed this frame */
-    readonly keyEventsThisFrame: number;
-    /** Total mouse events processed this frame */
-    readonly mouseEventsThisFrame: number;
-    /** Current frame number */
-    readonly frameCount: number;
-}
-/**
- * Configuration for input state tracking.
- */
-interface InputStateConfig {
-    /**
-     * Whether to track OS key repeats separately.
-     * When true, repeatCount increments for each repeat event.
-     * When false, repeats are ignored after initial press.
-     * @default true
-     */
-    readonly trackRepeats?: boolean;
-    /**
-     * Minimum time (ms) between key events to consider them separate presses.
-     * Helps filter out very fast unintentional double-presses.
-     * @default 0 (no debouncing)
-     */
-    readonly debounceTime?: number;
-    /**
-     * Custom repeat rate in ms. When set, overrides OS key repeat.
-     * InputState will generate synthetic repeat events at this rate.
-     * @default undefined (use OS repeat)
-     */
-    readonly customRepeatRate?: number;
-    /**
-     * Initial delay before custom repeat starts (ms).
-     * @default 500
-     */
-    readonly customRepeatDelay?: number;
-}
-/**
- * InputState interface for type-safe access.
- *
- * Tracks input state across frames.
- * Call `update()` at the start of each frame with input events from the buffer.
- * Then use query methods like `isKeyDown()`, `isKeyPressed()`, etc.
- */
-interface InputState {
-    update(keyEvents: readonly TimestampedKeyEvent[], mouseEvents: readonly TimestampedMouseEvent[], deltaTime: number): void;
-    isKeyDown(key: KeyName | string): boolean;
-    isKeyPressed(key: KeyName | string): boolean;
-    isKeyReleased(key: KeyName | string): boolean;
-    getKeyHeldTime(key: KeyName | string): number;
-    getKeyState(key: KeyName | string): KeyState;
-    getKeyRepeatCount(key: KeyName | string): number;
-    getPressedKeys(): string[];
-    getJustPressedKeys(): string[];
-    getJustReleasedKeys(): string[];
-    isCtrlDown(): boolean;
-    isAltDown(): boolean;
-    isShiftDown(): boolean;
-    hasModifier(): boolean;
-    isMouseButtonDown(button: MouseButton): boolean;
-    isMouseButtonPressed(button: MouseButton): boolean;
-    isMouseButtonReleased(button: MouseButton): boolean;
-    getMouseX(): number;
-    getMouseY(): number;
-    getMousePosition(): {
-        x: number;
-        y: number;
-    };
-    getMouseDelta(): {
-        deltaX: number;
-        deltaY: number;
-    };
-    getWheelDelta(): number;
-    getMouseState(): MouseState;
-    releaseKey(key: KeyName | string): void;
-    releaseAllKeys(): void;
-    releaseAllMouseButtons(): void;
-    releaseAll(): void;
-    getStats(): InputStateStats;
-    getFrameCount(): number;
-    reset(): void;
-}
-/**
- * Creates a new InputState tracker.
- *
- * @param config - Configuration options
- * @returns A new InputState instance
- *
- * @example
- * ```typescript
- * import { createInputState } from 'blecsd';
- *
- * const inputState = createInputState({
- *   trackRepeats: true,
- *   debounceTime: 50, // Ignore inputs within 50ms
- * });
- * ```
- */
-declare function createInputState(config?: InputStateConfig): InputState;
-/**
- * Checks if any of the specified keys are pressed.
- *
- * @param inputState - The input state to check
- * @param keys - Keys to check
- * @returns true if any key is currently pressed
- *
- * @example
- * ```typescript
- * if (isAnyKeyDown(inputState, ['w', 'up'])) {
- *   moveForward();
- * }
- * ```
- */
-declare function isAnyKeyDown(inputState: InputState, keys: readonly (KeyName | string)[]): boolean;
-/**
- * Checks if all specified keys are pressed.
- *
- * @param inputState - The input state to check
- * @param keys - Keys to check
- * @returns true if all keys are currently pressed
- *
- * @example
- * ```typescript
- * if (isAllKeysDown(inputState, ['ctrl', 's'])) {
- *   save();
- * }
- * ```
- */
-declare function isAllKeysDown(inputState: InputState, keys: readonly (KeyName | string)[]): boolean;
-/**
- * Checks if any of the specified keys were just pressed this frame.
- *
- * @param inputState - The input state to check
- * @param keys - Keys to check
- * @returns true if any key was just pressed
- */
-declare function isAnyKeyPressed(inputState: InputState, keys: readonly (KeyName | string)[]): boolean;
-/**
- * Gets the direction vector from WASD or arrow keys.
- *
- * @param inputState - The input state to check
- * @returns Object with x (-1, 0, or 1) and y (-1, 0, or 1)
- *
- * @example
- * ```typescript
- * const dir = getMovementDirection(inputState);
- * player.x += dir.x * speed;
- * player.y += dir.y * speed;
- * ```
- */
-declare function getMovementDirection(inputState: InputState): {
-    x: number;
-    y: number;
-};
-
-/**
- * Input action mapping system for game controls.
- *
- * Maps physical inputs (keys, mouse buttons) to logical game actions.
- * Supports multiple bindings per action, runtime rebinding, and save/load.
- *
- * @module core/inputActions
- */
-
-/**
- * Configuration for a single action binding.
- */
-interface ActionBinding {
-    /** Unique action identifier (e.g., 'jump', 'attack', 'move_left') */
-    readonly action: string;
-    /** Keys that activate this action */
-    readonly keys: readonly string[];
-    /** Mouse buttons that activate this action */
-    readonly mouseButtons?: readonly MouseButton[] | undefined;
-    /** Whether action fires continuously while held (default: false) */
-    readonly continuous?: boolean | undefined;
-    /** Deadzone for analog inputs (0-1, default: 0.1) */
-    readonly deadzone?: number | undefined;
-}
-/**
- * Runtime state of an action.
- */
-interface ActionState {
-    /** Action is currently active (input is held) */
-    readonly active: boolean;
-    /** Action was just activated this frame */
-    readonly justActivated: boolean;
-    /** Action was just deactivated this frame */
-    readonly justDeactivated: boolean;
-    /** How long the action has been active (ms) */
-    readonly activeTime: number;
-    /** Analog value (0-1), 1 when digital input is pressed */
-    readonly value: number;
-}
-/**
- * Serialized action bindings for save/load.
- */
-interface SerializedBindings {
-    readonly version: number;
-    readonly bindings: readonly {
-        readonly action: string;
-        readonly keys: readonly string[];
-        readonly mouseButtons?: readonly string[] | undefined;
-        readonly continuous?: boolean | undefined;
-    }[];
-}
-/**
- * Callback for action state changes.
- */
-type ActionCallback = (action: string, state: ActionState, inputState: InputState) => void;
-/**
- * Zod schema for action binding validation.
- */
-declare const ActionBindingSchema: z.ZodObject<{
-    action: z.ZodString;
-    keys: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    mouseButtons: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        unknown: "unknown";
-        left: "left";
-        right: "right";
-        middle: "middle";
-        wheelUp: "wheelUp";
-        wheelDown: "wheelDown";
-    }>>>;
-    continuous: z.ZodDefault<z.ZodBoolean>;
-    deadzone: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-/**
- * Zod schema for serialized bindings.
- */
-declare const SerializedBindingsSchema: z.ZodObject<{
-    version: z.ZodNumber;
-    bindings: z.ZodArray<z.ZodObject<{
-        action: z.ZodString;
-        keys: z.ZodArray<z.ZodString>;
-        mouseButtons: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        continuous: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/**
- * InputActionManager interface for type-safe access.
- */
-interface InputActionManager {
-    register(binding: ActionBinding): InputActionManager;
-    registerAll(bindings: readonly ActionBinding[]): InputActionManager;
-    unregister(action: string): boolean;
-    hasAction(action: string): boolean;
-    getActions(): string[];
-    getBinding(action: string): ActionBinding | undefined;
-    update(inputState: InputState, deltaTime: number): void;
-    isActive(action: string): boolean;
-    isJustActivated(action: string): boolean;
-    isJustDeactivated(action: string): boolean;
-    getValue(action: string): number;
-    getActiveTime(action: string): number;
-    getState(action: string): ActionState;
-    getActiveActions(): string[];
-    rebindKeys(action: string, keys: readonly string[]): boolean;
-    rebindMouseButtons(action: string, buttons: readonly MouseButton[]): boolean;
-    addKey(action: string, key: string): boolean;
-    removeKey(action: string, key: string): boolean;
-    getKeysForAction(action: string): string[];
-    getMouseButtonsForAction(action: string): MouseButton[];
-    getActionsForKey(key: string): string[];
-    onAction(action: string, callback: ActionCallback): () => void;
-    onAnyAction(callback: ActionCallback): () => void;
-    saveBindings(): SerializedBindings;
-    loadBindings(data: unknown): void;
-    toJSON(pretty?: boolean): string;
-    fromJSON(json: string): void;
-    resetStates(): void;
-    clear(): void;
-}
-/**
- * Creates a new InputActionManager.
- *
- * @param initialBindings - Optional initial bindings to register
- * @returns A new InputActionManager instance
- *
- * @example
- * ```typescript
- * import { createInputActionManager } from 'blecsd';
- *
- * const actions = createInputActionManager([
- *   { action: 'jump', keys: ['space'] },
- *   { action: 'attack', keys: ['j'], mouseButtons: ['left'] },
- * ]);
- * ```
- */
-declare function createInputActionManager(initialBindings?: readonly ActionBinding[]): InputActionManager;
-/**
- * Common action presets for quick setup.
- */
-declare const ActionPresets: {
-    /**
-     * Standard platformer controls.
-     */
-    readonly platformer: readonly ActionBinding[];
-    /**
-     * Standard top-down controls.
-     */
-    readonly topDown: readonly ActionBinding[];
-    /**
-     * Menu navigation controls.
-     */
-    readonly menu: readonly ActionBinding[];
-};
+declare function createBoxEntity(world: World, config?: BoxConfig): Entity;
+declare function createTextEntity(world: World, config?: TextConfig): Entity;
+declare function createButtonEntity(world: World, config?: ButtonConfig): Entity;
+declare function createScreenEntity(world: World, config: ScreenConfig): Entity;
+declare function createInputEntity(world: World, config?: InputConfig): Entity;
+declare function createListEntity(world: World, config?: ListConfig): Entity;
+declare function createCheckboxEntity(world: World, config?: CheckboxConfig): Entity;
+declare function createTextboxEntity(world: World, config?: TextboxConfig): Entity;
+declare function createTextareaEntity(world: World, config?: TextareaConfig): Entity;
+declare function createSelectEntity(world: World, config?: SelectConfig): Entity;
+declare function createSliderEntity(world: World, config?: SliderConfig): Entity;
+declare function createFormEntity(world: World, config?: FormConfig): Entity;
+declare function createProgressBarEntity(world: World, config?: ProgressBarConfig): Entity;
+declare function createRadioSetEntity(world: World, config?: RadioSetConfig): Entity;
+declare function createRadioButtonEntity(world: World, config?: RadioButtonConfig): Entity;
 
-export { createInputEventBuffer as $, type ActionBinding as A, type BoxConfig as B, type CheckboxConfig as C, RadioSetConfigSchema as D, type ScreenConfig as E, type FormConfig as F, ScreenConfigSchema as G, SelectConfigSchema as H, type InputEventBufferData as I, type SerializedBindings as J, type KeyState as K, type ListConfig as L, type MouseButtonState as M, SerializedBindingsSchema as N, SliderConfigSchema as O, type ProgressBarConfig as P, TextConfigSchema as Q, type RadioButtonConfig as R, type SelectConfig as S, type TextConfig as T, TextareaConfigSchema as U, TextboxConfigSchema as V, type TimestampedInputEvent as W, type TimestampedKeyEvent as X, type TimestampedMouseEvent as Y, beginFrame as Z, createInputActionManager as _, type InputState as a, createInputState as a0, drainAllEvents as a1, drainKeys as a2, drainMouse as a3, endFrame as a4, getLatencyStats as a5, getMovementDirection as a6, getPendingCount as a7, getPendingKeyCount as a8, getPendingMouseCount as a9, globalInputBuffer as aa, hasPendingEvents as ab, isAllKeysDown as ac, isAnyKeyDown as ad, isAnyKeyPressed as ae, isLatencyAcceptable as af, isProcessingTimeAcceptable as ag, peekEvents as ah, peekKeys as ai, peekMouse as aj, pushKeyEvent as ak, pushMouseEvent as al, recordLatency as am, recordLatencyBatch as an, resetLatencyStats as ao, resetStats as ap, clearBuffer as aq, getStats as ar, type ButtonConfig as b, type InputConfig as c, type TextareaConfig as d, type TextboxConfig as e, type RadioSetConfig as f, type SliderConfig as g, ActionBindingSchema as h, type ActionCallback as i, ActionPresets as j, type ActionState as k, BoxConfigSchema as l, ButtonConfigSchema as m, CheckboxConfigSchema as n, FormConfigSchema as o, type InputActionManager as p, type InputBufferStats as q, InputConfigSchema as r, type InputEventBufferOptions as s, type InputLatencyStats as t, type InputStateConfig as u, type InputStateStats as v, ListConfigSchema as w, type MouseState as x, ProgressBarConfigSchema as y, RadioButtonConfigSchema as z };
+export { TextareaConfigSchema as A, type BoxConfig as B, type CheckboxConfig as C, type TextboxConfig as D, TextboxConfigSchema as E, type FormConfig as F, createFormEntity as G, createProgressBarEntity as H, type InputConfig as I, createRadioButtonEntity as J, createRadioSetEntity as K, type ListConfig as L, createSliderEntity as M, createTextareaEntity as N, createTextboxEntity as O, type ProgressBarConfig as P, type RadioButtonConfig as R, type ScreenConfig as S, type TextConfig as T, BoxConfigSchema as a, TextConfigSchema as b, createBoxEntity as c, createButtonEntity as d, createCheckboxEntity as e, createInputEntity as f, createListEntity as g, createScreenEntity as h, createSelectEntity as i, createTextEntity as j, type ButtonConfig as k, ButtonConfigSchema as l, CheckboxConfigSchema as m, FormConfigSchema as n, InputConfigSchema as o, ListConfigSchema as p, ProgressBarConfigSchema as q, RadioButtonConfigSchema as r, type RadioSetConfig as s, RadioSetConfigSchema as t, ScreenConfigSchema as u, type SelectConfig as v, SelectConfigSchema as w, type SliderConfig as x, SliderConfigSchema as y, type TextareaConfig as z };