blecsd 0.3.0 → 0.6.0

package/dist/core/index.d.ts

@@ -1,23 +1,22 @@
-import { W as World, E as Entity, L as LoopPhase, S as System } from '../types-CPB4CpbH.js';
-export { U as Unsubscribe } from '../types-CPB4CpbH.js';
-import { a as ComponentStore } from '../componentStorage-CJTh-TPO.js';
-export { j as DirtyRect, D as DirtyTracker, c as clearDirtyTracking, a as createDirtyTracker, f as forceFullRedraw, g as getDirtyRegions, b as getDirtyTrackingStats, h as hasDirtyRegions, i as isCellDirty, m as markCellDirty, d as markEntityDirty, e as markRegionDirty, r as removeEntityFromTracking } from '../dirtyTracking-C4v8MmM9.js';
-import * as bitecs from 'bitecs';
-import { ComponentRef, QueryTerm, QueryResult } from 'bitecs';
-export { ComponentRef, QueryResult, QueryTerm } from 'bitecs';
-import { S as StyleData } from '../renderable-CwqGwrEV.js';
-import { B as BoxConfig, b as ButtonConfig, C as CheckboxConfig, F as FormConfig, c as InputConfig, L as ListConfig, P as ProgressBarConfig, R as RadioButtonConfig, f as RadioSetConfig, E as ScreenConfig, S as SelectConfig, g as SliderConfig, T as TextConfig, d as TextareaConfig, e as TextboxConfig } from '../inputActions-CRsUtTHM.js';
-export { A as ActionBinding, h as ActionBindingSchema, i as ActionCallback, j as ActionPresets, k as ActionState, l as BoxConfigSchema, m as ButtonConfigSchema, n as CheckboxConfigSchema, o as FormConfigSchema, p as InputActionManager, q as InputBufferStats, r as InputConfigSchema, I as InputEventBufferData, s as InputEventBufferOptions, t as InputLatencyStats, a as InputState, u as InputStateConfig, v as InputStateStats, K as KeyState, w as ListConfigSchema, M as MouseButtonState, x as MouseState, y as ProgressBarConfigSchema, z as RadioButtonConfigSchema, D as RadioSetConfigSchema, G as ScreenConfigSchema, H as SelectConfigSchema, J as SerializedBindings, N as SerializedBindingsSchema, O as SliderConfigSchema, Q as TextConfigSchema, U as TextareaConfigSchema, V as TextboxConfigSchema, W as TimestampedInputEvent, X as TimestampedKeyEvent, Y as TimestampedMouseEvent, Z as beginFrame, aq as clearBuffer, _ as createInputActionManager, $ as createInputEventBuffer, a0 as createInputState, a1 as drainAllEvents, a2 as drainKeys, a3 as drainMouse, a4 as endFrame, a5 as getLatencyStats, a6 as getMovementDirection, a7 as getPendingCount, a8 as getPendingKeyCount, a9 as getPendingMouseCount, ar as getStats, aa as globalInputBuffer, ab as hasPendingEvents, ac as isAllKeysDown, ad as isAnyKeyDown, ae as isAnyKeyPressed, af as isLatencyAcceptable, ag as isProcessingTimeAcceptable, ah as peekEvents, ai as peekKeys, aj as peekMouse, ak as pushKeyEvent, al as pushMouseEvent, am as recordLatency, an as recordLatencyBatch, ao as resetLatencyStats, ap as resetStats } from '../inputActions-CRsUtTHM.js';
-import { c as EventMap, G as GetEntityEventBus, a as EventBus } from '../events-9ForpTfM.js';
-export { E as EntityEventBusStore, b as EventHandler, S as ScreenEventMap, U as UIEventMap, d as createEntityEventBusStore, e as createEventBus } from '../events-9ForpTfM.js';
+import { W as World, E as Entity, L as LoopPhase, S as System } from '../types-B8LmNkzG.js';
+export { U as Unsubscribe } from '../types-B8LmNkzG.js';
+import { C as ComponentStore } from '../componentStorage-CXJvx4Lt.js';
+export { D as DirtyRect, a as DirtyTracker, c as clearDirtyTracking, b as createDirtyTracker, f as forceFullRedraw, g as getDirtyRegions, d as getDirtyTrackingStats, h as hasDirtyRegions, i as isCellDirty, m as markCellDirty, e as markEntityDirty, j as markRegionDirty, r as removeEntityFromTracking } from '../dirtyTracking-kCS9-NVF.js';
+export { C as CleanupCallback, g as ClickableCache, D as DestroyOptions, i as HitTestOptions, H as HitTestResult, P as PositionValue, a as PositionValueSchema, b as addComponent, c as addEntity, j as centerPosition, k as clampPosition, l as clearCleanupCallbacks, m as clearDestroyQueue, n as createClickableCache, d as createWorld, o as destroyAllChildren, p as destroyEntity, e as destroyWorld, q as entityExists, s as flushDestroyQueue, t as getAllClickablesAt, u as getAllEntities, v as getAllHoverablesAt, w as getClickableAt, x as getClickableCount, y as getClickableEntities, z as getDestroyQueueSize, A as getHoverableAt, B as hasClickableAt, h as hasComponent, E as hasHoverableAt, f as hitTest, F as hitTestAll, G as hitTestDetailed, I as invalidateClickableCache, J as isCacheDirty, K as isKeywordPosition, L as isMarkedForDestruction, M as isPercentagePosition, N as parsePosition, O as parsePositionWithNegative, Q as percentOffsetPosition, R as percentPosition, S as query, T as registerCleanupCallback, U as registerComponent, V as removeComponent, r as removeEntity, W as resetDisposalState, X as resetWorld, Y as resolvePosition, Z as resolvePositionClamped, _ as updateClickableCache, $ as withStore } from '../positioning-DiUivJXa.js';
+import { S as StyleData } from '../renderable-IbSJao5y.js';
+export { B as BoxConfig, a as BoxConfigSchema, k as ButtonConfig, l as ButtonConfigSchema, C as CheckboxConfig, m as CheckboxConfigSchema, F as FormConfig, n as FormConfigSchema, I as InputConfig, o as InputConfigSchema, L as ListConfig, p as ListConfigSchema, P as ProgressBarConfig, q as ProgressBarConfigSchema, R as RadioButtonConfig, r as RadioButtonConfigSchema, s as RadioSetConfig, t as RadioSetConfigSchema, S as ScreenConfig, u as ScreenConfigSchema, v as SelectConfig, w as SelectConfigSchema, x as SliderConfig, y as SliderConfigSchema, T as TextConfig, b as TextConfigSchema, z as TextareaConfig, A as TextareaConfigSchema, D as TextboxConfig, E as TextboxConfigSchema, c as createBoxEntity, d as createButtonEntity, e as createCheckboxEntity, G as createFormEntity, f as createInputEntity, g as createListEntity, H as createProgressBarEntity, J as createRadioButtonEntity, K as createRadioSetEntity, h as createScreenEntity, i as createSelectEntity, M as createSliderEntity, j as createTextEntity, N as createTextareaEntity, O as createTextboxEntity } from '../factories-vW7bn_He.js';
+import { E as EventMap, G as GetEntityEventBus, M as MouseEvent, a as MouseButton, b as EventBus } from '../mouseParser-CCqSEUVN.js';
+export { c as EntityEventBusStore, d as EventHandler, S as ScreenEventMap, U as UIEventMap, e as createEntityEventBusStore, f as createEventBus } from '../mouseParser-CCqSEUVN.js';
 import { z } from 'zod';
-export { F as FixedTimestepConfig, a as FixedUpdateHook, G as GameLoop, b as GameLoopHooks, c as GameLoopOptions, I as InterpolateHook, d as LoopHook, e as LoopState, L as LoopStats, f as createGameLoop, i as isLoopPaused, g as isLoopRunning } from '../gameLoop-C-Ez_i54.js';
-import { K as KeyName, b as KeyEvent } from '../keyParser-BnHbg2iD.js';
+export { F as FixedTimestepConfig, a as FixedUpdateHook, G as GameLoop, b as GameLoopHooks, c as GameLoopOptions, I as InterpolateHook, L as LoopHook, d as LoopState, e as LoopStats, f as createGameLoop, i as isLoopPaused, g as isLoopRunning } from '../gameLoop-C1AyRWyP.js';
+import { K as KeyEvent, a as KeyName } from '../keyParser-DReXe2j-.js';
 import { K as KeyEvent$1 } from '../program-BZaKqDKH.js';
-export { A as AdaptiveFrameBudgetConfig, a as AdaptiveFrameBudgetStatus, F as FrameTelemetry, P as PhaseTimingData, S as Scheduler, T as TelemetryConfig, c as createScheduler, g as getDeltaTime } from '../scheduler-CMcYew9Z.js';
-export { a as PackedHandle, P as PackedStore, b as addToStore, c as clearStore, d as createPackedStore, f as forEachInStore, g as getFromStore, e as getStoreCapacity, h as getStoreData, i as getStoreSize, j as isValidHandle, m as mapStore, r as removeFromStore, s as setInStore } from '../packedStore-BgvnEdE7.js';
-import '../border-Jb7TrMob.js';
-import '../mouseParser-Cfrbn3AX.js';
+import { S as Scheduler } from '../scheduler-NbHT3-D2.js';
+export { A as AdaptiveFrameBudgetConfig, a as AdaptiveFrameBudgetStatus, F as FrameTelemetry, P as PhaseTimingData, T as TelemetryConfig, c as createScheduler, g as getDeltaTime } from '../scheduler-NbHT3-D2.js';
+export { P as PackedHandle, a as PackedStore, b as addToStore, c as clearStore, d as createPackedStore, f as forEachInStore, g as getFromStore, e as getStoreCapacity, h as getStoreData, i as getStoreSize, j as isValidHandle, m as mapStore, r as removeFromStore, s as setInStore } from '../packedStore-480t2X74.js';
+import { ComponentRef, QueryTerm } from 'bitecs';
+export { ComponentRef, QueryResult, QueryTerm } from 'bitecs';
+import '../border-Br-Jc027.js';
 import 'node:stream';
 
 /**
@@ -1242,6 +1241,445 @@ declare function isPointInEntity(world: World, eid: Entity, x: number, y: number
  */
 declare function isPointInInnerBounds(world: World, eid: Entity, x: number, y: number): boolean;
 
+/**
+ * Signal primitives for reactive state management.
+ * Provides automatic dependency tracking and efficient recomputation.
+ * @module core/signals
+ */
+
+/**
+ * Signal getter function.
+ * Returns the current value of the signal.
+ */
+type SignalGetter<T> = () => T;
+/**
+ * Signal setter function.
+ * Updates the signal value and notifies dependents.
+ */
+type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;
+/**
+ * A signal is a tuple of [getter, setter].
+ */
+type Signal<T> = readonly [SignalGetter<T>, SignalSetter<T>];
+/**
+ * Computed signal getter.
+ * Returns the current computed value.
+ */
+type ComputedGetter<T> = SignalGetter<T>;
+/**
+ * Alias for computed signal getter used by reactive sources.
+ */
+type ComputedSignal<T> = SignalGetter<T>;
+/**
+ * Creates a reactive signal with automatic dependency tracking.
+ *
+ * Returns a tuple of [getter, setter]. The getter returns the current value
+ * and tracks dependencies. The setter updates the value and notifies dependents.
+ *
+ * @param initialValue - Initial value of the signal
+ * @returns Tuple of [getter, setter]
+ *
+ * @example
+ * ```typescript
+ * import { createSignal } from 'blecsd';
+ *
+ * const [count, setCount] = createSignal(0);
+ * console.log(count()); // 0
+ * setCount(1);
+ * console.log(count()); // 1
+ *
+ * // Functional update
+ * setCount(prev => prev + 1);
+ * console.log(count()); // 2
+ * ```
+ */
+declare function createSignal<T>(initialValue: T): Signal<T>;
+/**
+ * Creates a computed signal that automatically tracks dependencies.
+ *
+ * The function is executed once immediately, and any signals read during
+ * execution become dependencies. The computed value is cached and only
+ * recomputed when dependencies change.
+ *
+ * Handles diamond dependencies correctly (A depends on B and C, both depend on D -
+ * when D changes, A recomputes only once).
+ *
+ * @param fn - Function that computes the value
+ * @returns Getter function for the computed value
+ *
+ * @example
+ * ```typescript
+ * import { createSignal, createComputed } from 'blecsd';
+ *
+ * const [count, setCount] = createSignal(0);
+ * const doubled = createComputed(() => count() * 2);
+ *
+ * console.log(doubled()); // 0
+ * setCount(5);
+ * console.log(doubled()); // 10
+ * ```
+ */
+declare function createComputed<T>(fn: () => T): ComputedGetter<T>;
+/**
+ * Batches multiple signal updates together.
+ *
+ * All signal updates within the batch function are deferred, and
+ * computed signals only recompute once after all updates complete.
+ *
+ * @param fn - Function containing batched updates
+ *
+ * @example
+ * ```typescript
+ * import { createSignal, createComputed, createBatch } from 'blecsd';
+ *
+ * const [a, setA] = createSignal(0);
+ * const [b, setB] = createSignal(0);
+ * const sum = createComputed(() => a() + b());
+ *
+ * createBatch(() => {
+ *   setA(1);
+ *   setB(2);
+ * });
+ * // sum recomputes only once, not twice
+ * console.log(sum()); // 3
+ * ```
+ */
+declare function createBatch(fn: () => void): void;
+/**
+ * Creates an entity-scoped signal that automatically marks the entity dirty.
+ *
+ * When the signal changes, `markDirty(world, eid)` is called automatically,
+ * integrating with the rendering system's dirty tracking.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param initialValue - Initial value of the signal
+ * @returns Tuple of [getter, setter]
+ *
+ * @example
+ * ```typescript
+ * import { createEntitySignal } from 'blecsd';
+ *
+ * const [health, setHealth] = createEntitySignal(world, playerEntity, 100);
+ * setHealth(80); // Automatically marks playerEntity as dirty
+ * ```
+ */
+declare function createEntitySignal<T>(world: World, eid: Entity, initialValue: T): Signal<T>;
+/**
+ * Disposes a signal or computed, removing all subscriptions.
+ *
+ * For computed signals, this unsubscribes from all dependencies.
+ * Call this when a signal is no longer needed to prevent memory leaks.
+ *
+ * Note: This takes a getter function, not the full signal tuple.
+ *
+ * @param getter - Signal or computed getter function
+ *
+ * @example
+ * ```typescript
+ * import { createSignal, createComputed, disposeSignal } from 'blecsd';
+ *
+ * const [count] = createSignal(0);
+ * const doubled = createComputed(() => count() * 2);
+ *
+ * // When done with the computed
+ * disposeSignal(doubled);
+ * ```
+ */
+declare function disposeSignal<T>(getter: SignalGetter<T>): void;
+/**
+ * Runs a function while tracking signal dependencies.
+ * When any tracked signal changes, the callback is invoked.
+ *
+ * Used internally by the effect system.
+ *
+ * @param fn - Function to run while tracking reads
+ * @param onDependencyChange - Called when any tracked signal changes
+ * @returns Cleanup function that stops tracking
+ * @internal
+ */
+declare function trackDependencies(fn: () => void, onDependencyChange: () => void): () => void;
+
+/**
+ * Declarative widget composition API.
+ *
+ * Instead of imperative entity creation and component attachment,
+ * this module lets users describe UI structure as functional composition.
+ * Reactive signal bindings are set up automatically.
+ *
+ * @module core/declarative
+ *
+ * @example
+ * ```typescript
+ * import { createSignal, el, mount, vbox } from 'blecsd';
+ *
+ * const [title, setTitle] = createSignal('Dashboard');
+ * const [cpu, setCpu] = createSignal(42);
+ *
+ * const tree = mount(world, vbox({}, [
+ *   el('text', { content: title }),
+ *   el('gauge', { value: cpu, label: 'CPU' }),
+ * ]));
+ *
+ * setTitle('Updated!'); // text widget re-renders automatically
+ * setCpu(87);           // gauge widget re-renders automatically
+ *
+ * tree.dispose(); // cleanup all entities and reactive bindings
+ * ```
+ */
+
+/**
+ * Supported widget types for declarative composition.
+ */
+type WidgetType = 'box' | 'text' | 'gauge' | 'list' | 'progressbar';
+/**
+ * A value that may be reactive (a signal getter) or static.
+ */
+type ReactiveProp<T> = T | SignalGetter<T>;
+/**
+ * Configuration for a declarative widget.
+ * Any property can be a static value or a reactive signal getter.
+ */
+interface ReactiveConfig {
+    readonly [key: string]: ReactiveProp<unknown>;
+}
+/**
+ * Describes a widget to be created in the UI tree.
+ */
+interface WidgetDescriptor {
+    readonly type: WidgetType;
+    readonly config: ReactiveConfig;
+    readonly children: readonly WidgetDescriptor[];
+    readonly ref?: (eid: Entity) => void;
+}
+/**
+ * Result of mounting a descriptor tree into actual entities.
+ */
+interface MountedTree {
+    readonly root: Entity;
+    readonly entities: readonly Entity[];
+    readonly dispose: () => void;
+}
+/**
+ * Cleanup handle from a reactive binding.
+ */
+interface BindingCleanup {
+    readonly dispose: () => void;
+}
+/**
+ * Factory function type for creating entities from config.
+ */
+type WidgetFactory = (world: World, config: Record<string, unknown>) => Entity;
+/**
+ * Registry of property setters for widget types.
+ * Maps (widgetType, propName) to a setter function.
+ */
+type PropSetter = (world: World, eid: Entity, value: unknown) => void;
+/**
+ * Registers a widget factory for declarative composition.
+ *
+ * @param type - Widget type name
+ * @param factory - Factory function that creates an entity from config
+ *
+ * @example
+ * ```typescript
+ * import { registerWidgetFactory, createBoxEntity } from 'blecsd';
+ *
+ * registerWidgetFactory('box', (world, config) => createBoxEntity(world, config));
+ * ```
+ */
+declare function registerWidgetFactory(type: WidgetType, factory: WidgetFactory): void;
+/**
+ * Registers a property setter for a widget type.
+ * Used to update a specific property on an entity when a reactive value changes.
+ *
+ * @param type - Widget type name
+ * @param prop - Property name
+ * @param setter - Function that applies the property value to an entity
+ *
+ * @example
+ * ```typescript
+ * import { registerPropSetter, setContent } from 'blecsd';
+ *
+ * registerPropSetter('text', 'content', (world, eid, value) => {
+ *   setContent(world, eid, value as string);
+ * });
+ * ```
+ */
+declare function registerPropSetter(type: WidgetType, prop: string, setter: PropSetter): void;
+/**
+ * Creates a widget descriptor for declarative composition.
+ *
+ * @param type - Widget type ('box', 'text', 'gauge', etc.)
+ * @param config - Configuration object; values can be static or signal getters
+ * @param children - Optional child descriptors
+ * @returns Widget descriptor
+ *
+ * @example
+ * ```typescript
+ * import { el, createSignal } from 'blecsd';
+ *
+ * const [count, setCount] = createSignal(0);
+ *
+ * const desc = el('text', { content: count });
+ * ```
+ */
+declare function el(type: WidgetType, config?: ReactiveConfig, children?: WidgetDescriptor[]): WidgetDescriptor;
+/**
+ * Creates a widget descriptor with a ref callback.
+ *
+ * @param type - Widget type
+ * @param config - Configuration object
+ * @param ref - Callback receiving the created entity ID
+ * @param children - Optional child descriptors
+ * @returns Widget descriptor
+ *
+ * @example
+ * ```typescript
+ * import { elRef } from 'blecsd';
+ *
+ * let myEntity: Entity;
+ * const desc = elRef('box', { width: 20 }, (eid) => { myEntity = eid; });
+ * ```
+ */
+declare function elRef(type: WidgetType, config: ReactiveConfig, ref: (eid: Entity) => void, children?: WidgetDescriptor[]): WidgetDescriptor;
+/**
+ * Creates a vertical box layout descriptor.
+ *
+ * @param config - Box configuration
+ * @param children - Child widget descriptors
+ * @returns Box descriptor with vertical layout
+ *
+ * @example
+ * ```typescript
+ * import { vbox, el } from 'blecsd';
+ *
+ * const layout = vbox({}, [
+ *   el('text', { content: 'Header' }),
+ *   el('text', { content: 'Body' }),
+ * ]);
+ * ```
+ */
+declare function vbox(config?: ReactiveConfig, children?: WidgetDescriptor[]): WidgetDescriptor;
+/**
+ * Creates a horizontal box layout descriptor.
+ *
+ * @param config - Box configuration
+ * @param children - Child widget descriptors
+ * @returns Box descriptor with horizontal layout
+ *
+ * @example
+ * ```typescript
+ * import { hbox, el } from 'blecsd';
+ *
+ * const layout = hbox({}, [
+ *   el('text', { content: 'Left' }),
+ *   el('text', { content: 'Right' }),
+ * ]);
+ * ```
+ */
+declare function hbox(config?: ReactiveConfig, children?: WidgetDescriptor[]): WidgetDescriptor;
+/**
+ * Mounts a widget descriptor tree, creating entities and setting up reactive bindings.
+ *
+ * For each descriptor node:
+ * 1. Creates the entity using the registered factory
+ * 2. Sets static properties immediately
+ * 3. Creates reactive effects for signal-backed properties
+ * 4. Recursively mounts children and establishes parent-child relationships
+ *
+ * @param world - The ECS world
+ * @param descriptor - Root widget descriptor
+ * @param parent - Optional parent entity
+ * @returns Mounted tree with root entity, all entities, and dispose function
+ *
+ * @example
+ * ```typescript
+ * import { mount, el, createSignal } from 'blecsd';
+ *
+ * const [status, setStatus] = createSignal('Ready');
+ *
+ * const tree = mount(world, el('text', { content: status }));
+ * setStatus('Running'); // widget updates automatically
+ *
+ * tree.dispose(); // cleanup
+ * ```
+ */
+declare function mount(world: World, descriptor: WidgetDescriptor, parent?: Entity): MountedTree;
+/**
+ * Convenience function to unmount a tree.
+ * Disposes all reactive bindings. Entity cleanup should be done
+ * separately using the entity disposal system.
+ *
+ * @param tree - The mounted tree to unmount
+ *
+ * @example
+ * ```typescript
+ * import { mount, unmount, el } from 'blecsd';
+ *
+ * const tree = mount(world, el('box', {}));
+ * // ... later ...
+ * unmount(tree); // clean up reactive bindings
+ * ```
+ */
+declare function unmount(tree: MountedTree): void;
+/**
+ * Creates a reactive binding between a signal and an entity property.
+ * The setter is called immediately with the current value, and again
+ * whenever the signal changes.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity to bind to
+ * @param signal - Signal getter providing the value
+ * @param setter - Function that applies the value to the entity
+ * @returns Cleanup handle
+ *
+ * @example
+ * ```typescript
+ * import { bind, createSignal, setContent } from 'blecsd';
+ *
+ * const [text, setText] = createSignal('Hello');
+ *
+ * const cleanup = bind(world, myEntity, text, (world, eid, value) => {
+ *   setContent(world, eid, value);
+ * });
+ *
+ * setText('World'); // entity content updates automatically
+ * cleanup.dispose(); // stop watching
+ * ```
+ */
+declare function bind<T>(world: World, eid: Entity, signal: SignalGetter<T>, setter: (world: World, eid: Entity, value: T) => void): BindingCleanup;
+/**
+ * Registers the default property setters for common widget properties.
+ * Call this once during application setup to enable reactive bindings
+ * for standard properties like content, width, height.
+ *
+ * @param deps - Dependencies injected to avoid circular imports
+ *
+ * @example
+ * ```typescript
+ * import { registerDefaultPropSetters, setContent } from 'blecsd';
+ *
+ * registerDefaultPropSetters({
+ *   setContent: (world, eid, value) => setContent(world, eid, value as string),
+ *   setWidth: (world, eid, value) => setDimensions(world, eid, { width: value as number }),
+ *   setHeight: (world, eid, value) => setDimensions(world, eid, { height: value as number }),
+ * });
+ * ```
+ */
+declare function registerDefaultPropSetters(deps: {
+    readonly setContent: PropSetter;
+    readonly setWidth: PropSetter;
+    readonly setHeight: PropSetter;
+}): void;
+/**
+ * Clears all widget factory and prop setter registrations.
+ * Used for testing.
+ *
+ * @internal
+ */
+declare function resetDeclarativeRegistrations(): void;
+
 /**
  * Dirty Rectangle Tracking System
  *
@@ -1548,447 +1986,34 @@ declare function regionIntersectsDirty(tracker: DirtyTrackerData, x: number, y:
 declare function getDirtyRegionsInViewport(tracker: DirtyTrackerData, viewX: number, viewY: number, viewWidth: number, viewHeight: number): DirtyRect[];
 
 /**
- * Entity disposal and cleanup system.
- *
- * Handles proper cleanup of entities including:
- * - Deferred destruction (mark for destruction, process at frame end)
- * - Hierarchy cleanup (remove from parent, destroy children)
- * - Lifecycle event emission
- * - Store cleanup
- * - Entity recycling
- *
- * @module core/disposal
- *
- * @example
- * ```typescript
- * import { destroyEntity, destroyAllChildren, flushDestroyQueue } from 'blecsd';
- *
- * // Mark entity for destruction (deferred)
- * destroyEntity(world, entity);
- *
- * // At end of frame, process all pending destructions
- * flushDestroyQueue(world);
- *
- * // Or destroy immediately
- * destroyEntity(world, entity, { immediate: true });
- * ```
+ * Focus and hover effects system for dynamic styling.
+ * Manages effect application, removal, and style restoration.
+ * @module core/effects
  */
 
 /**
- * Options for entity destruction.
- */
-interface DestroyOptions {
-    /**
-     * If true, destroy immediately instead of deferring to end of frame.
-     * Use with caution as this may cause issues during iteration.
-     */
-    immediate?: boolean;
-    /**
-     * If true, also destroy all children recursively.
-     * Defaults to true.
-     */
-    destroyChildren?: boolean;
-    /**
-     * If true, emit destroy event before cleanup.
-     * Defaults to true.
-     */
-    emitEvent?: boolean;
-}
-/**
- * Callback for custom cleanup when an entity is destroyed.
+ * A style value that can be static or computed dynamically.
  */
-type CleanupCallback = (world: World, entity: Entity) => void;
+type DynamicValue<T> = T | ((world: World, entity: Entity) => T);
 /**
- * Registers a cleanup callback that runs when any entity is destroyed.
- *
- * Use this to register store cleanup functions.
- *
- * @param callback - Function to call during entity cleanup
- * @returns Function to unregister the callback
+ * Effect configuration with support for dynamic values.
+ * Values can be static or functions that compute the value at render time.
  *
  * @example
  * ```typescript
- * import { registerCleanupCallback } from 'blecsd';
+ * import { EffectConfig } from 'blecsd';
  *
- * // Register cleanup for a custom store
- * const unregister = registerCleanupCallback((world, entity) => {
- *   myCustomStore.delete(entity);
- * });
+ * // Static effect
+ * const staticEffect: EffectConfig = {
+ *   fg: 0xff0000ff,
+ *   bold: true,
+ * };
  *
- * // Later, unregister if needed
- * unregister();
- * ```
- */
-declare function registerCleanupCallback(callback: CleanupCallback): () => void;
-/**
- * Clears all registered cleanup callbacks.
- * Primarily for testing.
- */
-declare function clearCleanupCallbacks(): void;
-/**
- * Marks an entity for destruction.
- *
- * By default, destruction is deferred to the end of the frame via
- * `flushDestroyQueue()`. This prevents issues when destroying entities
- * during iteration.
- *
- * @param world - The ECS world
- * @param entity - The entity to destroy
- * @param options - Destruction options
- *
- * @example
- * ```typescript
- * import { destroyEntity } from 'blecsd';
- *
- * // Deferred destruction (recommended)
- * destroyEntity(world, entity);
- *
- * // Immediate destruction
- * destroyEntity(world, entity, { immediate: true });
- *
- * // Don't destroy children
- * destroyEntity(world, entity, { destroyChildren: false });
- * ```
- */
-declare function destroyEntity(world: World, entity: Entity, options?: DestroyOptions): void;
-/**
- * Destroys all children of an entity without destroying the parent.
- *
- * @param world - The ECS world
- * @param parent - The parent entity
- * @param options - Destruction options (immediate applies to all children)
- *
- * @example
- * ```typescript
- * import { destroyAllChildren } from 'blecsd';
- *
- * // Clear all children from a container
- * destroyAllChildren(world, container);
- * ```
- */
-declare function destroyAllChildren(world: World, parent: Entity, options?: DestroyOptions): void;
-/**
- * Checks if an entity is marked for destruction.
- *
- * @param entity - The entity to check
- * @returns true if entity is queued for destruction
- */
-declare function isMarkedForDestruction(entity: Entity): boolean;
-/**
- * Processes all entities marked for destruction.
- *
- * Should be called at the end of each frame, typically in POST_RENDER phase.
- *
- * @param world - The ECS world
- * @returns Number of entities destroyed
- *
- * @example
- * ```typescript
- * import { flushDestroyQueue } from 'blecsd';
- *
- * // In your game loop's post-render phase:
- * const destroyed = flushDestroyQueue(world);
- * ```
- */
-declare function flushDestroyQueue(world: World): number;
-/**
- * Destroys all entities in a world.
- *
- * This performs immediate destruction of all entities.
- *
- * @param world - The ECS world to clear
- *
- * @example
- * ```typescript
- * import { destroyWorld } from 'blecsd';
- *
- * // Clean up everything before resetting
- * destroyWorld(world);
- * ```
- */
-declare function destroyWorld(world: World): void;
-/**
- * Gets the number of entities currently queued for destruction.
- *
- * @param world - Optional world to check (if not provided, returns global count)
- * @returns Number of entities in destroy queue
- */
-declare function getDestroyQueueSize(world?: World): number;
-/**
- * Clears the destruction queue without destroying entities.
- *
- * Use with caution - entities will remain but won't be destroyed.
- *
- * @param world - The ECS world
- */
-declare function clearDestroyQueue(world: World): void;
-/**
- * Resets all disposal state.
- * Primarily for testing.
- */
-declare function resetDisposalState(): void;
-
-/**
- * ECS World creation and management
- * @module core/world
- */
-
-/**
- * Creates a new ECS world for the game.
- *
- * @returns A new World instance
- *
- * @example
- * ```typescript
- * import { createWorld } from 'blecsd';
- *
- * const world = createWorld();
- * ```
- */
-declare function createWorld(): World;
-/**
- * Resets an existing world, removing all entities and resetting component data.
- * Useful for level reloading or game restart.
- *
- * @param world - The world to reset
- *
- * @example
- * ```typescript
- * import { createWorld, resetWorld } from 'blecsd';
- *
- * const world = createWorld();
- * // ... game runs ...
- * resetWorld(world); // Clear everything for new game
- * ```
- */
-declare function resetWorld(world: World): void;
-
-/**
- * Creates a new entity in the world.
- *
- * @param world - The ECS world to add the entity to
- * @returns The newly created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity } from 'blecsd';
- *
- * const world = createWorld();
- * const player = addEntity(world);
- * const enemy = addEntity(world);
- * ```
- */
-declare function addEntity(world: World): Entity;
-/**
- * Removes an entity and all its components from the world.
- *
- * @param world - The ECS world containing the entity
- * @param eid - The entity ID to remove
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, removeEntity } from 'blecsd';
- *
- * const world = createWorld();
- * const entity = addEntity(world);
- * // ... use entity ...
- * removeEntity(world, entity); // Clean up when done
- * ```
- */
-declare function removeEntity(world: World, eid: Entity): void;
-/**
- * Checks if an entity exists in the world.
- *
- * @param world - The ECS world to check
- * @param eid - The entity ID to check
- * @returns True if the entity exists, false otherwise
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, removeEntity, entityExists } from 'blecsd';
- *
- * const world = createWorld();
- * const entity = addEntity(world);
- *
- * console.log(entityExists(world, entity)); // true
- * removeEntity(world, entity);
- * console.log(entityExists(world, entity)); // false
- * ```
- */
-declare function entityExists(world: World, eid: Entity): boolean;
-/**
- * Gets all entity IDs currently in the world.
- *
- * @param world - The ECS world to query
- * @returns Array of all entity IDs in the world
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, getAllEntities } from 'blecsd';
- *
- * const world = createWorld();
- * addEntity(world);
- * addEntity(world);
- * addEntity(world);
- *
- * const entities = getAllEntities(world);
- * console.log(entities.length); // 3
- * ```
- */
-declare function getAllEntities(world: World): readonly Entity[];
-/**
- * Adds a component to an entity.
- *
- * @param world - The ECS world
- * @param eid - The entity to add the component to
- * @param component - The component to add
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, addComponent, Position } from 'blecsd';
- *
- * const world = createWorld();
- * const entity = addEntity(world);
- * addComponent(world, entity, Position);
- * Position.x[entity] = 100;
- * Position.y[entity] = 50;
- * ```
- */
-declare function addComponent(world: World, eid: Entity, component: ComponentRef): void;
-/**
- * Checks if an entity has a specific component.
- *
- * @param world - The ECS world
- * @param eid - The entity to check
- * @param component - The component to check for
- * @returns True if the entity has the component, false otherwise
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, addComponent, hasComponent, Position } from 'blecsd';
- *
- * const world = createWorld();
- * const entity = addEntity(world);
- *
- * console.log(hasComponent(world, entity, Position)); // false
- * addComponent(world, entity, Position);
- * console.log(hasComponent(world, entity, Position)); // true
- * ```
- */
-declare function hasComponent(world: World, eid: Entity, component: ComponentRef): boolean;
-/**
- * Removes a component from an entity.
- *
- * @param world - The ECS world
- * @param eid - The entity to remove the component from
- * @param component - The component to remove
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, addComponent, removeComponent, hasComponent, Position } from 'blecsd';
- *
- * const world = createWorld();
- * const entity = addEntity(world);
- * addComponent(world, entity, Position);
- *
- * console.log(hasComponent(world, entity, Position)); // true
- * removeComponent(world, entity, Position);
- * console.log(hasComponent(world, entity, Position)); // false
- * ```
- */
-declare function removeComponent(world: World, eid: Entity, component: ComponentRef): void;
-/**
- * Queries the world for entities that have all specified components.
- *
- * @param world - The ECS world to query
- * @param components - Array of components that entities must have
- * @returns Array of entity IDs that match the query
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, addComponent, query, Position, Velocity } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create entities with different component combinations
- * const staticEntity = addEntity(world);
- * addComponent(world, staticEntity, Position);
- *
- * const movingEntity = addEntity(world);
- * addComponent(world, movingEntity, Position);
- * addComponent(world, movingEntity, Velocity);
- *
- * // Query for entities with both Position and Velocity
- * const movingEntities = query(world, [Position, Velocity]);
- * console.log(movingEntities.length); // 1 (only movingEntity)
- * ```
- */
-declare function query(world: World, components: QueryTerm[]): QueryResult;
-/**
- * Registers a component with the world. This is typically called automatically
- * when components are first used, but can be useful for advanced scenarios.
- *
- * @param world - The ECS world
- * @param component - The component to register
- *
- * @example
- * ```typescript
- * import { createWorld, registerComponent, Position } from 'blecsd';
- *
- * const world = createWorld();
- * registerComponent(world, Position);
- * ```
- */
-declare const registerComponent: (world: bitecs.World, component: ComponentRef) => bitecs.ComponentData;
-/**
- * Creates a component with a custom backing store. Useful for components that
- * need special memory layouts or interop with external systems.
- *
- * @param store - Custom store object with typed arrays
- * @returns A component that uses the provided store
- *
- * @example
- * ```typescript
- * import { withStore } from 'blecsd';
- *
- * // Create a component backed by custom Float32Arrays
- * const CustomPosition = withStore({
- *   x: new Float32Array(10000),
- *   y: new Float32Array(10000),
- * });
- * ```
- */
-declare const withStore: <T>(createStore: (eid: bitecs.EntityId) => T) => (relation: bitecs.Relation<T>) => bitecs.Relation<T>;
-
-/**
- * Focus and hover effects system for dynamic styling.
- * Manages effect application, removal, and style restoration.
- * @module core/effects
- */
-
-/**
- * A style value that can be static or computed dynamically.
- */
-type DynamicValue<T> = T | ((world: World, entity: Entity) => T);
-/**
- * Effect configuration with support for dynamic values.
- * Values can be static or functions that compute the value at render time.
- *
- * @example
- * ```typescript
- * import { EffectConfig } from 'blecsd';
- *
- * // Static effect
- * const staticEffect: EffectConfig = {
- *   fg: 0xff0000ff,
- *   bold: true,
- * };
- *
- * // Dynamic effect based on entity state
- * const dynamicEffect: EffectConfig = {
- *   fg: (world, eid) => isActive(world, eid) ? 0x00ff00ff : 0xff0000ff,
- *   bold: (world, eid) => hasHighPriority(world, eid),
- * };
+ * // Dynamic effect based on entity state
+ * const dynamicEffect: EffectConfig = {
+ *   fg: (world, eid) => isActive(world, eid) ? 0x00ff00ff : 0xff0000ff,
+ *   bold: (world, eid) => hasHighPriority(world, eid),
+ * };
  * ```
  */
 interface EffectConfig {
@@ -2053,21 +2078,21 @@ declare function resolveEffectConfig(world: World, eid: Entity, config: EffectCo
  * @param eid - The entity ID
  * @returns Stored style data or undefined
  */
-declare function getStoredStyle(eid: Entity): StoredStyle | undefined;
+declare function getStoredStyle(_world: World, eid: Entity): StoredStyle | undefined;
 /**
  * Checks if an entity has stored style data.
  *
  * @param eid - The entity ID
  * @returns true if entity has stored style
  */
-declare function hasStoredStyle(eid: Entity): boolean;
+declare function hasStoredStyle(_world: World, eid: Entity): boolean;
 /**
  * Clears stored style for an entity.
  * Call this when an entity is destroyed.
  *
  * @param eid - The entity ID
  */
-declare function clearStoredStyle(eid: Entity): void;
+declare function clearStoredStyle(_world: World, eid: Entity): void;
 /**
  * Clears all stored styles.
  * Primarily for testing.
@@ -2121,7 +2146,7 @@ declare function removeFocusEffect(world: World, eid: Entity): void;
  * @param eid - The entity ID
  * @returns true if focus effect is applied
  */
-declare function hasFocusEffectApplied(eid: Entity): boolean;
+declare function hasFocusEffectApplied(_world: World, eid: Entity): boolean;
 /**
  * Applies hover effect to an entity.
  * Uses the entity's hoverEffectFg and hoverEffectBg from the Interactive component.
@@ -2170,7 +2195,7 @@ declare function removeHoverEffect(world: World, eid: Entity): void;
  * @param eid - The entity ID
  * @returns true if hover effect is applied
  */
-declare function hasHoverEffectApplied(eid: Entity): boolean;
+declare function hasHoverEffectApplied(_world: World, eid: Entity): boolean;
 /**
  * Applies a custom effect configuration to an entity.
  * Stores the original style for later restoration.
@@ -2311,7 +2336,7 @@ declare function setEffects(world: World, eid: Entity, config: EffectsConfig): v
  * @param eid - The entity ID
  * @returns The effects configuration or undefined
  */
-declare function getEffects(eid: Entity): EffectsConfig | undefined;
+declare function getEffects(_world: World, eid: Entity): EffectsConfig | undefined;
 /**
  * Clears the effects configuration for an entity.
  *
@@ -2379,28 +2404,28 @@ declare function removeDisabledEffect(world: World, eid: Entity): void;
  * @param eid - The entity ID
  * @returns true if press effect is applied
  */
-declare function hasPressEffectApplied(eid: Entity): boolean;
+declare function hasPressEffectApplied(_world: World, eid: Entity): boolean;
 /**
  * Checks if disabled effect is currently applied.
  *
  * @param eid - The entity ID
  * @returns true if disabled effect is applied
  */
-declare function hasDisabledEffectApplied(eid: Entity): boolean;
+declare function hasDisabledEffectApplied(_world: World, eid: Entity): boolean;
 /**
  * Checks if any effect is currently applied to an entity.
  *
  * @param eid - The entity ID
  * @returns true if any effect is active
  */
-declare function hasAnyEffectApplied(eid: Entity): boolean;
+declare function hasAnyEffectApplied(_world: World, eid: Entity): boolean;
 /**
  * Gets the current effect state for an entity.
  *
  * @param eid - The entity ID
  * @returns Object describing which effects are applied
  */
-declare function getEffectState(eid: Entity): {
+declare function getEffectState(_world: World, eid: Entity): {
     focus: boolean;
     hover: boolean;
     press: boolean;
@@ -2412,35 +2437,13 @@ declare function getEffectState(eid: Entity): {
  *
  * @param eid - The entity ID
  */
-declare function clearEffectState(eid: Entity): void;
+declare function clearEffectState(_world: World, eid: Entity): void;
 /**
  * Clears all effect configs.
  * Primarily for testing.
  */
 declare function clearAllEffectConfigs(): void;
 
-/**
- * Entity factory functions for creating common entity types.
- * These factories combine components and helpers to create fully-configured entities.
- * @module core/entities/factories
- */
-
-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;
-
 /**
  * Entity data storage for arbitrary key-value pairs.
  *
@@ -2482,7 +2485,7 @@ type EntityDataMap = Map<string, DataValue>;
  * console.log(health); // 100 (default, since not set)
  * ```
  */
-declare function getEntityData<T = DataValue>(eid: Entity, key: string, defaultValue?: T): T;
+declare function getEntityData<T = DataValue>(_world: World, eid: Entity, key: string, defaultValue?: T): T;
 /**
  * Sets a value on an entity.
  *
@@ -2506,7 +2509,7 @@ declare function getEntityData<T = DataValue>(eid: Entity, key: string, defaultV
  * setEntityData(entity, 'onDeath', () => console.log('Game over'));
  * ```
  */
-declare function setEntityData(eid: Entity, key: string, value: DataValue): void;
+declare function setEntityData(_world: World, eid: Entity, key: string, value: DataValue): void;
 /**
  * Checks if an entity has data stored for a specific key.
  *
@@ -2524,7 +2527,7 @@ declare function setEntityData(eid: Entity, key: string, value: DataValue): void
  * }
  * ```
  */
-declare function hasEntityData(eid: Entity, key: string): boolean;
+declare function hasEntityData(_world: World, eid: Entity, key: string): boolean;
 /**
  * Deletes a specific key from an entity's data.
  *
@@ -2541,7 +2544,7 @@ declare function hasEntityData(eid: Entity, key: string): boolean;
  * deleteEntityData(entity, 'temporaryBuff');
  * ```
  */
-declare function deleteEntityData(eid: Entity, key: string): boolean;
+declare function deleteEntityData(_world: World, eid: Entity, key: string): boolean;
 /**
  * Gets all keys stored on an entity.
  *
@@ -2559,7 +2562,7 @@ declare function deleteEntityData(eid: Entity, key: string): boolean;
  * console.log(keys); // ['name', 'score']
  * ```
  */
-declare function getEntityDataKeys(eid: Entity): string[];
+declare function getEntityDataKeys(_world: World, eid: Entity): string[];
 /**
  * Gets all data stored on an entity as a plain object.
  *
@@ -2577,7 +2580,7 @@ declare function getEntityDataKeys(eid: Entity): string[];
  * console.log(allData); // { name: 'Player', score: 100 }
  * ```
  */
-declare function getAllEntityData(eid: Entity): Record<string, DataValue>;
+declare function getAllEntityData(_world: World, eid: Entity): Record<string, DataValue>;
 /**
  * Sets multiple values on an entity at once.
  *
@@ -2596,7 +2599,7 @@ declare function getAllEntityData(eid: Entity): Record<string, DataValue>;
  * });
  * ```
  */
-declare function setEntityDataBulk(eid: Entity, data: Record<string, DataValue>): void;
+declare function setEntityDataBulk(_world: World, eid: Entity, data: Record<string, DataValue>): void;
 /**
  * Clears all data stored on an entity.
  *
@@ -2610,7 +2613,7 @@ declare function setEntityDataBulk(eid: Entity, data: Record<string, DataValue>)
  * clearEntityData(entity);
  * ```
  */
-declare function clearEntityData(eid: Entity): void;
+declare function clearEntityData(_world: World, eid: Entity): void;
 /**
  * Clears all entity data from the store.
  * Useful for testing or resetting game state.
@@ -2652,7 +2655,7 @@ declare function getEntityDataCount(): number;
  * }
  * ```
  */
-declare function hasAnyEntityData(eid: Entity): boolean;
+declare function hasAnyEntityData(_world: World, eid: Entity): boolean;
 /**
  * Updates a value on an entity using a transform function.
  * If the key doesn't exist, the transform receives undefined.
@@ -2677,7 +2680,7 @@ declare function hasAnyEntityData(eid: Entity): boolean;
  * updateEntityData(entity, 'items', (current) => [...(current ?? []), newItem]);
  * ```
  */
-declare function updateEntityData<T = DataValue>(eid: Entity, key: string, transform: (current: T | undefined) => T): void;
+declare function updateEntityData<T = DataValue>(_world: World, eid: Entity, key: string, transform: (current: T | undefined) => T): void;
 
 /**
  * Event bubbling system for hierarchical event propagation.
@@ -2916,263 +2919,790 @@ declare const EmitDescendantsOptionsSchema: z.ZodObject<{
 declare function emitDescendants<T extends EventMap, K extends keyof T>(world: World, eid: Entity, eventName: K, eventData: T[K], getEventBus: GetEntityEventBus<T>, options?: EmitDescendantsOptions): EmitDescendantsResult;
 
 /**
- * Hit Test System with Z-Order Aware Clickable Sorting
- *
- * Provides efficient hit testing for mouse interactions, sorting clickable
- * elements by z-index so the topmost element receives events first.
- *
- * @module core/hitTest
- *
- * @example
- * ```typescript
- * import {
- *   createClickableCache,
- *   hitTest,
- *   hitTestAll,
- *   invalidateClickableCache,
- * } from 'blecsd';
+ * Input event buffer for frame-independent input handling.
  *
- * // Create cache for efficient hit testing
- * const cache = createClickableCache();
+ * 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.
  *
- * // Hit test at mouse position - returns topmost entity
- * const topEntity = hitTest(world, mouseX, mouseY, cache);
+ * HARD REQUIREMENT: No input events should ever be lost or delayed.
  *
- * // Get all entities under point, sorted by z-index (highest first)
- * const allEntities = hitTestAll(world, mouseX, mouseY, cache);
- *
- * // Invalidate cache when hierarchy changes
- * invalidateClickableCache(cache);
- * ```
+ * @module core/inputEventBuffer
  */
 
 /**
- * Cache for clickable element sorting.
- *
- * Maintains a sorted list of clickable/hoverable entities for efficient
- * hit testing. The cache is invalidated when the hierarchy changes.
+ * A timestamped keyboard event.
  */
-interface ClickableCache {
-    /** Sorted entities (highest z-index first) */
-    entities: Entity[];
-    /** Whether cache needs rebuilding */
-    dirty: boolean;
-    /** Last known count for quick dirty check */
-    lastCount: number;
+interface TimestampedKeyEvent {
+    readonly type: 'key';
+    readonly event: KeyEvent;
+    readonly timestamp: number;
 }
 /**
- * Result of a hit test operation.
+ * A timestamped mouse event.
  */
-interface HitTestResult {
-    /** The entity under the point (topmost if multiple) */
-    readonly entity: Entity;
-    /** Z-index of the entity */
-    readonly zIndex: number;
+interface TimestampedMouseEvent {
+    readonly type: 'mouse';
+    readonly event: MouseEvent;
+    readonly timestamp: number;
 }
 /**
- * Options for hit testing.
- */
-interface HitTestOptions {
-    /** Use cached positions for faster testing (default: true) */
-    useCachedPositions?: boolean;
-    /** Only test clickable entities (default: true) */
-    clickableOnly?: boolean;
-    /** Only test hoverable entities (default: false) */
-    hoverableOnly?: boolean;
-    /** Test both clickable and hoverable (default: false) */
-    interactiveOnly?: boolean;
+ * 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;
 }
 /**
- * Creates a new clickable cache.
- *
- * The cache stores a z-index sorted list of interactive entities
- * for efficient hit testing.
+ * 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.
  *
- * @returns A new ClickableCache
+ * @param options - Buffer configuration options
+ * @returns A new InputEventBufferData
  *
  * @example
  * ```typescript
- * import { createClickableCache } from 'blecsd';
+ * import { createInputEventBuffer, pushKeyEvent, drainKeys } from 'blecsd';
  *
- * const cache = createClickableCache();
+ * const buffer = createInputEventBuffer({ maxBufferSize: 500 });
+ *
+ * // Push events from stdin
+ * pushKeyEvent(buffer, keyEvent);
+ *
+ * // Drain in game loop
+ * const keys = drainKeys(buffer);
  * ```
  */
-declare function createClickableCache(): ClickableCache;
+declare function createInputEventBuffer(options?: InputEventBufferOptions): InputEventBufferData;
 /**
- * Marks the clickable cache as needing rebuild.
+ * Pushes a keyboard event to the buffer.
  *
- * Call this when:
- * - Entities are added or removed
- * - Z-index values change
- * - Interactive state changes (clickable/hoverable toggled)
- *
- * @param cache - The clickable cache
+ * @param buffer - The input event buffer
+ * @param event - The keyboard event to buffer
+ * @param timestamp - Optional timestamp (default: now)
  *
  * @example
  * ```typescript
- * import { invalidateClickableCache } from 'blecsd';
- *
- * // After adding a new clickable entity
- * invalidateClickableCache(cache);
+ * pushKeyEvent(buffer, { name: 'a', ctrl: false, meta: false, shift: false, sequence: 'a' });
  * ```
  */
-declare function invalidateClickableCache(cache: ClickableCache): void;
+declare function pushKeyEvent(buffer: InputEventBufferData, event: KeyEvent, timestamp?: number): void;
 /**
- * Checks if the cache needs rebuilding.
+ * Pushes a mouse event to the buffer.
  *
- * @param cache - The clickable cache
- * @returns true if cache is dirty
+ * @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 isCacheDirty(cache: ClickableCache): boolean;
+declare function pushMouseEvent(buffer: InputEventBufferData, event: MouseEvent, timestamp?: number): void;
 /**
- * Rebuilds the clickable cache if needed.
+ * Drains all keyboard events from the buffer.
+ * Returns events in order (oldest first) and clears the buffer.
  *
- * Queries for all interactive entities and sorts them by z-index
- * in descending order (highest z-index first for hit testing).
+ * @param buffer - The input event buffer
+ * @returns Array of timestamped key events
  *
- * @param world - The ECS world
- * @param cache - The clickable cache
+ * @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
- * import { updateClickableCache } from 'blecsd';
+ * 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.
  *
- * // Rebuild cache before hit testing
- * updateClickableCache(world, cache);
+ * @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 updateClickableCache(world: World, cache: ClickableCache): void;
+declare function drainAllEvents(buffer: InputEventBufferData): TimestampedInputEvent[];
 /**
- * Gets the current sorted clickable entities from cache.
+ * Peeks at all pending events without removing them.
  *
- * @param world - The ECS world
- * @param cache - The clickable cache
- * @returns Array of entities sorted by z-index (highest first)
+ * @param buffer - The input event buffer
+ * @returns Array of all pending events sorted by timestamp
  */
-declare function getClickableEntities(world: World, cache: ClickableCache): readonly Entity[];
+declare function peekEvents(buffer: InputEventBufferData): TimestampedInputEvent[];
 /**
- * Gets the count of clickable entities.
+ * Peeks at pending key events without removing them.
  *
- * @param world - The ECS world
- * @param cache - The clickable cache
- * @returns Number of clickable/hoverable entities
+ * @param buffer - The input event buffer
+ * @returns Array of pending key events
  */
-declare function getClickableCount(world: World, cache: ClickableCache): number;
-declare function hitTest(world: World, x: number, y: number, cache?: ClickableCache, options?: HitTestOptions): Entity | null;
+declare function peekKeys(buffer: InputEventBufferData): readonly TimestampedKeyEvent[];
 /**
- * Performs a hit test and returns all entities at the point.
+ * Peeks at pending mouse events without removing them.
  *
- * Returns entities sorted by z-index (highest first).
+ * @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 world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache for efficiency
- * @param options - Hit test options
- * @returns Array of entities at the point, sorted by z-index (highest first)
+ * @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
- * import { hitTestAll, createClickableCache } from 'blecsd';
+ * 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.
  *
- * const cache = createClickableCache();
+ * @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.
  *
- * // Get all entities under mouse position
- * const entities = hitTestAll(world, mouseX, mouseY, cache);
+ * @param buffer - The input event buffer
  *
- * for (const eid of entities) {
- *   console.log(`Entity ${eid} at z=${getZIndex(world, eid)}`);
- * }
+ * @example
+ * ```typescript
+ * beginFrame(buffer);
+ * const keys = drainKeys(buffer);
+ * // process keys...
+ * endFrame(buffer);
  * ```
  */
-declare function hitTestAll(world: World, x: number, y: number, cache?: ClickableCache, options?: HitTestOptions): Entity[];
+declare function beginFrame(buffer: InputEventBufferData): void;
 /**
- * Performs a hit test with detailed results.
+ * Marks the end of frame processing and records the processing time.
+ * Call this after all input events have been processed.
  *
- * @param world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache for efficiency
- * @param options - Hit test options
- * @returns Array of HitTestResults with entity and z-index
+ * @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
- * import { hitTestDetailed, createClickableCache } from 'blecsd';
+ * 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.
  *
- * const cache = createClickableCache();
+ * @param buffer - The input event buffer
+ * @returns Latency statistics in milliseconds
  *
- * const results = hitTestDetailed(world, mouseX, mouseY, cache);
- * for (const { entity, zIndex } of results) {
- *   console.log(`Entity ${entity} at z=${zIndex}`);
+ * @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 hitTestDetailed(world: World, x: number, y: number, cache?: ClickableCache, options?: HitTestOptions): HitTestResult[];
+declare function getLatencyStats(buffer: InputEventBufferData): InputLatencyStats;
 /**
- * Checks if any clickable entity is under the point.
+ * Resets latency statistics.
  *
- * @param world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache
- * @returns true if any clickable entity is under the point
+ * @param buffer - The input event buffer
  */
-declare function hasClickableAt(world: World, x: number, y: number, cache?: ClickableCache): boolean;
+declare function resetLatencyStats(buffer: InputEventBufferData): void;
 /**
- * Checks if any hoverable entity is under the point.
+ * Checks if the current latency is within acceptable bounds.
+ * By default, checks if p95 latency is under 16ms (one frame at 60fps).
  *
- * @param world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache
- * @returns true if any hoverable entity is under the point
+ * @param buffer - The input event buffer
+ * @param maxLatencyMs - Maximum acceptable p95 latency in milliseconds
+ * @returns True if latency is acceptable
  */
-declare function hasHoverableAt(world: World, x: number, y: number, cache?: ClickableCache): boolean;
+declare function isLatencyAcceptable(buffer: InputEventBufferData, maxLatencyMs?: number): boolean;
 /**
- * Gets the topmost clickable entity at a point.
+ * Checks if frame processing time is within budget.
+ * By default, checks if average processing time is under 1ms.
  *
- * Convenience wrapper for hitTest with clickableOnly=true.
+ * @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.
  *
- * @param world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache
- * @returns Topmost clickable entity or null
+ * 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);
+ * ```
  */
-declare function getClickableAt(world: World, x: number, y: number, cache?: ClickableCache): Entity | null;
+declare const globalInputBuffer: InputEventBufferData;
+
 /**
- * Gets the topmost hoverable entity at a point.
+ * Input state tracking for keyboard and mouse.
  *
- * Convenience wrapper for hitTest with hoverableOnly=true.
+ * Provides frame-aware input queries like isKeyPressed (just this frame),
+ * isKeyReleased, key hold time, and repeat handling.
  *
- * @param world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache
- * @returns Topmost hoverable entity or null
+ * @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.
  */
-declare function getHoverableAt(world: World, x: number, y: number, cache?: ClickableCache): Entity | null;
+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;
+}
 /**
- * Gets all clickable entities at a point.
+ * Creates a new InputState tracker.
  *
- * @param world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache
- * @returns Array of clickable entities (highest z-index first)
+ * @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 getAllClickablesAt(world: World, x: number, y: number, cache?: ClickableCache): Entity[];
+declare function createInputState(config?: InputStateConfig): InputState;
 /**
- * Gets all hoverable entities at a point.
+ * Checks if any of the specified keys are pressed.
  *
- * @param world - The ECS world
- * @param x - Screen X coordinate
- * @param y - Screen Y coordinate
- * @param cache - Optional clickable cache
- * @returns Array of hoverable entities (highest z-index first)
+ * @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 getAllHoverablesAt(world: World, x: number, y: number, cache?: ClickableCache): Entity[];
+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[];
+};
 
 /**
  * Configurable key binding system.
@@ -4262,506 +4792,783 @@ declare function createPhaseManager(): PhaseManager;
 declare const defaultPhaseManager: PhaseManager;
 
 /**
- * Position caching for render optimization.
- * Caches computed positions to avoid expensive recalculations.
- * @module core/positionCache
- */
-
-/**
- * Last computed position data.
- * Used to cache resolved positions and skip recalculation when unchanged.
+ * Plugin/Module System
  *
- * - `xi`: Inner X start (left edge after border/padding)
- * - `xl`: Inner X end (right edge before border/padding)
- * - `yi`: Inner Y start (top edge after border/padding)
- * - `yl`: Inner Y end (bottom edge before border/padding)
- * - `base`: Scroll base offset
- * - `valid`: Cache validity flag (1 = valid, 0 = invalid)
+ * Provides a plugin interface for extending blECSd with reusable modules
+ * that bundle components, systems, and lifecycle hooks. Plugins declare
+ * which scheduler phase their systems belong to, enabling modular
+ * composition of functionality.
+ *
+ * @module core/plugins
  *
  * @example
  * ```typescript
- * import { setPositionCache, getPositionCache, invalidatePositionCache } from 'blecsd';
- *
- * // Set cached position after computing
- * setPositionCache(world, entity, { xi: 5, xl: 85, yi: 3, yl: 23, base: 0 });
+ * import { createPluginRegistry, registerPlugin, LoopPhase } from 'blecsd';
  *
- * // Get cached position (returns undefined if invalid)
- * const cached = getPositionCache(world, entity);
- * if (cached) {
- *   // Use cached values instead of recalculating
- *   console.log(`Inner bounds: ${cached.xi},${cached.yi} to ${cached.xl},${cached.yl}`);
- * }
+ * const registry = createPluginRegistry();
+ * const plugin = {
+ *   name: 'physics',
+ *   version: '1.0.0',
+ *   systems: [
+ *     { system: gravitySystem, phase: LoopPhase.ANIMATION, priority: 0 },
+ *   ],
+ * };
  *
- * // Invalidate when position changes
- * invalidatePositionCache(world, entity);
+ * registerPlugin(registry, scheduler, world, plugin);
  * ```
  */
-declare const PositionCache: {
-    /** Inner X start (left edge after border/padding) */
-    xi: Float32Array<ArrayBuffer>;
-    /** Inner X end (right edge before border/padding) */
-    xl: Float32Array<ArrayBuffer>;
-    /** Inner Y start (top edge after border/padding) */
-    yi: Float32Array<ArrayBuffer>;
-    /** Inner Y end (bottom edge before border/padding) */
-    yl: Float32Array<ArrayBuffer>;
-    /** Scroll base offset */
-    base: Float32Array<ArrayBuffer>;
-    /** Cache validity flag (1 = valid, 0 = invalid) */
-    valid: Uint8Array<ArrayBuffer>;
-};
+
 /**
- * Cached position data returned by getPositionCache.
+ * A component definition that a plugin provides.
+ * Stores metadata about the component for registration tracking.
  */
-interface CachedPosition {
-    /** Inner X start (left edge after border/padding) */
-    readonly xi: number;
-    /** Inner X end (right edge before border/padding) */
-    readonly xl: number;
-    /** Inner Y start (top edge after border/padding) */
-    readonly yi: number;
-    /** Inner Y end (bottom edge before border/padding) */
-    readonly yl: number;
-    /** Scroll base offset */
-    readonly base: number;
+interface PluginComponent {
+    /** Unique name identifying this component */
+    readonly name: string;
+    /** The actual component store (SoA typed arrays or marker) */
+    readonly store: unknown;
 }
 /**
- * Options for setting position cache.
+ * A system definition that a plugin provides,
+ * including which scheduler phase it should run in.
  */
-interface SetPositionCacheOptions {
-    /** Inner X start (left edge after border/padding) */
-    readonly xi: number;
-    /** Inner X end (right edge before border/padding) */
-    readonly xl: number;
-    /** Inner Y start (top edge after border/padding) */
-    readonly yi: number;
-    /** Inner Y end (bottom edge before border/padding) */
-    readonly yl: number;
-    /** Scroll base offset */
-    readonly base: number;
+interface PluginSystem {
+    /** The system function */
+    readonly system: System;
+    /** The scheduler phase this system should be registered in */
+    readonly phase: LoopPhase;
+    /** Priority within the phase (lower = earlier, default: 0) */
+    readonly priority?: number;
 }
 /**
- * Sets the cached position for an entity.
- * Marks the cache as valid.
+ * A widget declaration that a plugin provides.
+ * Used to register widgets when the plugin is installed.
+ */
+interface PluginWidgetDeclaration {
+    /** Widget type name (e.g., 'bar-chart', 'pie-chart') */
+    readonly name: string;
+    /** Human-readable description */
+    readonly description?: string;
+    /** Factory function for creating the widget entity */
+    readonly factory: (world: World, config: Record<string, unknown>) => number;
+    /** Tags for categorization */
+    readonly tags?: readonly string[];
+}
+/**
+ * A theme declaration that a plugin provides.
+ * Used to register themes when the plugin is installed.
+ */
+interface PluginThemeDeclaration {
+    /** Theme name */
+    readonly name: string;
+    /** Theme data object */
+    readonly theme: Record<string, unknown>;
+}
+/**
+ * Plugin interface for extending blECSd with reusable functionality.
  *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
- * @param options - Position values to cache
+ * Plugins bundle components, systems, and lifecycle hooks into a
+ * single installable unit. They declare dependencies and can
+ * initialize/cleanup world state.
  *
  * @example
  * ```typescript
- * import { setPositionCache } from 'blecsd';
+ * import type { Plugin } from 'blecsd';
+ * import { LoopPhase } from 'blecsd';
  *
- * // After computing positions during render
- * setPositionCache(world, entity, {
- *   xi: 5,   // Inner left
- *   xl: 85,  // Inner right
- *   yi: 3,   // Inner top
- *   yl: 23,  // Inner bottom
- *   base: 0, // Scroll offset
- * });
+ * const myPlugin: Plugin = {
+ *   name: 'my-plugin',
+ *   version: '1.0.0',
+ *   dependencies: ['core-renderer'],
+ *   components: [
+ *     { name: 'MyComponent', store: MyComponentStore },
+ *   ],
+ *   systems: [
+ *     { system: myUpdateSystem, phase: LoopPhase.UPDATE },
+ *     { system: myRenderSystem, phase: LoopPhase.RENDER, priority: 10 },
+ *   ],
+ *   init: (world) => {
+ *     // Set up initial world state
+ *     return world;
+ *   },
+ *   cleanup: (world) => {
+ *     // Tear down plugin state
+ *     return world;
+ *   },
+ * };
  * ```
  */
-declare function setPositionCache(_world: World, eid: Entity, options: SetPositionCacheOptions): void;
+interface Plugin {
+    /** Unique plugin name */
+    readonly name: string;
+    /** Semantic version string */
+    readonly version: string;
+    /** Names of plugins this one depends on (must be registered first) */
+    readonly dependencies?: readonly string[];
+    /** Components provided by this plugin */
+    readonly components?: readonly PluginComponent[];
+    /** Systems provided by this plugin, with phase assignments */
+    readonly systems?: readonly PluginSystem[];
+    /** Widget declarations provided by this plugin */
+    readonly widgets?: readonly PluginWidgetDeclaration[];
+    /** Theme declarations provided by this plugin */
+    readonly themes?: readonly PluginThemeDeclaration[];
+    /** Zod schema for plugin configuration validation */
+    readonly configSchema?: z.ZodType;
+    /** Called when the plugin is registered. Can set up initial world state. */
+    readonly init?: (world: World) => World;
+    /** Called when the plugin is activated (starts processing). */
+    readonly onActivate?: (world: World) => void;
+    /** Called when the plugin is deactivated (stops processing). */
+    readonly onDeactivate?: (world: World) => void;
+    /** Called when the plugin is unregistered. Can clean up world state. */
+    readonly cleanup?: (world: World) => World;
+}
 /**
- * Gets the cached position for an entity.
- * Returns undefined if the cache is invalid.
- *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
- * @returns Cached position data or undefined if invalid
+ * Info about a registered plugin, returned by getPlugins().
+ */
+interface PluginInfo {
+    /** Plugin name */
+    readonly name: string;
+    /** Plugin version */
+    readonly version: string;
+    /** Names of dependencies */
+    readonly dependencies: readonly string[];
+    /** Number of components provided */
+    readonly componentCount: number;
+    /** Number of systems provided */
+    readonly systemCount: number;
+    /** Number of widgets provided */
+    readonly widgetCount: number;
+    /** Number of themes provided */
+    readonly themeCount: number;
+    /** Whether the plugin is currently active */
+    readonly active: boolean;
+}
+/**
+ * Result of a plugin registration operation.
+ */
+interface PluginRegistrationResult {
+    /** Whether registration succeeded */
+    readonly success: boolean;
+    /** Error message if registration failed */
+    readonly error?: string;
+    /** Number of systems registered with the scheduler */
+    readonly systemsRegistered: number;
+    /** Number of components registered */
+    readonly componentsRegistered: number;
+}
+/**
+ * Registry that tracks all registered plugins and their state.
+ */
+interface PluginRegistry {
+    /** Internal storage, not for direct access */
+    readonly _plugins: ReadonlyMap<string, PluginRegistryEntry>;
+}
+/**
+ * Internal entry for a registered plugin.
+ * @internal
+ */
+interface PluginRegistryEntry {
+    readonly plugin: Plugin;
+    readonly registeredSystems: readonly PluginSystem[];
+    active: boolean;
+}
+/**
+ * Zod schema for PluginComponent validation.
  *
  * @example
  * ```typescript
- * import { getPositionCache } from 'blecsd';
+ * import { PluginComponentSchema } from 'blecsd';
  *
- * const cached = getPositionCache(world, entity);
- * if (cached) {
- *   // Use cached values
- *   const innerWidth = cached.xl - cached.xi;
- *   const innerHeight = cached.yl - cached.yi;
- * }
+ * const validated = PluginComponentSchema.parse({
+ *   name: 'MyComponent',
+ *   store: myStore,
+ * });
  * ```
  */
-declare function getPositionCache(_world: World, eid: Entity): CachedPosition | undefined;
+declare const PluginComponentSchema: z.ZodObject<{
+    name: z.ZodString;
+    store: z.ZodUnknown;
+}, z.core.$strip>;
 /**
- * Checks if the position cache is valid for an entity.
+ * Zod schema for PluginSystem validation.
  *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
- * @returns true if cache is valid
+ * @example
+ * ```typescript
+ * import { PluginSystemSchema } from 'blecsd';
+ *
+ * const validated = PluginSystemSchema.parse({
+ *   system: mySystem,
+ *   phase: 2, // LoopPhase.UPDATE
+ *   priority: 0,
+ * });
+ * ```
+ */
+declare const PluginSystemSchema: z.ZodObject<{
+    system: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    phase: z.ZodEnum<typeof LoopPhase>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Zod schema for Plugin manifest validation.
+ * Validates the structure of a plugin before registration.
  *
  * @example
  * ```typescript
- * import { hasValidPositionCache } from 'blecsd';
+ * import { PluginSchema } from 'blecsd';
  *
- * if (hasValidPositionCache(world, entity)) {
- *   // Skip expensive position calculation
+ * const result = PluginSchema.safeParse(pluginCandidate);
+ * if (result.success) {
+ *   registerPlugin(registry, scheduler, world, result.data);
  * }
  * ```
  */
-declare function hasValidPositionCache(_world: World, eid: Entity): boolean;
 /**
- * Invalidates the position cache for an entity.
- * Call this when position, size, or parent changes.
+ * Zod schema for PluginWidgetDeclaration validation.
+ */
+declare const PluginWidgetDeclarationSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    factory: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    tags: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for PluginThemeDeclaration validation.
+ */
+declare const PluginThemeDeclarationSchema: z.ZodObject<{
+    name: z.ZodString;
+    theme: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const PluginSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    dependencies: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    components: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        store: z.ZodUnknown;
+    }, z.core.$strip>>>>;
+    systems: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        system: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        phase: z.ZodEnum<typeof LoopPhase>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>>;
+    widgets: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        factory: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        tags: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>>;
+    themes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        theme: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>>>;
+    configSchema: z.ZodOptional<z.ZodUnknown>;
+    init: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    onActivate: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    onDeactivate: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    cleanup: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+}, z.core.$strip>;
+/**
+ * Creates a new, empty plugin registry.
  *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
+ * @returns A new PluginRegistry
  *
  * @example
  * ```typescript
- * import { invalidatePositionCache } from 'blecsd';
+ * import { createPluginRegistry } from 'blecsd';
  *
- * // Invalidate when entity moves
- * setPosition(world, entity, 10, 20);
- * invalidatePositionCache(world, entity);
+ * const registry = createPluginRegistry();
  * ```
  */
-declare function invalidatePositionCache(_world: World, eid: Entity): void;
+declare function createPluginRegistry(): PluginRegistry;
 /**
- * Invalidates the position cache for an entity and all its descendants.
- * Call this when a parent changes position, as all children need recalculation.
+ * Registers a plugin with the given registry and scheduler.
  *
- * @param world - The ECS world
- * @param eid - The entity ID
- * @param getDescendants - Function to get descendant entities
+ * Validates the plugin manifest, checks dependencies, registers systems
+ * with the scheduler, and calls the plugin's init hook if present.
+ *
+ * @param registry - The plugin registry to register with
+ * @param scheduler - The scheduler to register systems with
+ * @param world - The ECS world (passed to init hook)
+ * @param plugin - The plugin to register
+ * @returns Registration result with success status and details
  *
  * @example
  * ```typescript
- * import { invalidatePositionCacheTree, getChildren } from 'blecsd';
+ * import { createPluginRegistry, createScheduler, registerPlugin, LoopPhase } from 'blecsd';
  *
- * // Invalidate entire subtree when parent moves
- * invalidatePositionCacheTree(world, parentEntity, (w, e) => {
- *   // Return all descendants recursively
- *   return getAllDescendants(w, e);
+ * const registry = createPluginRegistry();
+ * const scheduler = createScheduler();
+ * const world = createWorld();
+ *
+ * const result = registerPlugin(registry, scheduler, world, {
+ *   name: 'physics',
+ *   version: '1.0.0',
+ *   systems: [
+ *     { system: gravitySystem, phase: LoopPhase.ANIMATION },
+ *   ],
  * });
+ *
+ * if (!result.success) {
+ *   console.error('Plugin registration failed:', result.error);
+ * }
  * ```
  */
-declare function invalidatePositionCacheTree(world: World, eid: Entity, getDescendants: (world: World, eid: Entity) => Entity[]): void;
+declare function registerPlugin(registry: PluginRegistry, scheduler: Scheduler, world: World, plugin: Plugin): PluginRegistrationResult;
 /**
- * Clears all position caches.
- * Useful for forcing a complete recalculation after major changes.
+ * Unregisters a plugin, removing its systems from the scheduler
+ * and calling the cleanup hook.
  *
- * @param _world - The ECS world (unused, for API consistency)
+ * @param registry - The plugin registry
+ * @param scheduler - The scheduler to unregister systems from
+ * @param world - The ECS world (passed to cleanup hook)
+ * @param pluginName - The name of the plugin to unregister
+ * @returns true if the plugin was found and unregistered
  *
  * @example
  * ```typescript
- * import { clearAllPositionCaches } from 'blecsd';
+ * import { unregisterPlugin } from 'blecsd';
  *
- * // After screen resize
- * clearAllPositionCaches(world);
+ * const removed = unregisterPlugin(registry, scheduler, world, 'physics');
+ * if (!removed) {
+ *   console.warn('Plugin not found');
+ * }
  * ```
  */
-declare function clearAllPositionCaches(_world: World): void;
+declare function unregisterPlugin(registry: PluginRegistry, scheduler: Scheduler, world: World, pluginName: string): boolean;
 /**
- * Gets inner width from cached position.
- * Returns 0 if cache is invalid.
+ * Gets information about all registered plugins.
  *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
- * @returns Inner width or 0 if invalid
+ * @param registry - The plugin registry
+ * @returns Array of plugin info objects
  *
  * @example
  * ```typescript
- * import { getCachedInnerWidth } from 'blecsd';
+ * import { getPlugins } from 'blecsd';
  *
- * const innerWidth = getCachedInnerWidth(world, entity);
+ * const plugins = getPlugins(registry);
+ * for (const info of plugins) {
+ *   console.log(`${info.name} v${info.version} (${info.systemCount} systems)`);
+ * }
  * ```
  */
-declare function getCachedInnerWidth(_world: World, eid: Entity): number;
+declare function getPlugins(registry: PluginRegistry): readonly PluginInfo[];
 /**
- * Gets inner height from cached position.
- * Returns 0 if cache is invalid.
+ * Checks if a plugin is registered.
  *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
- * @returns Inner height or 0 if invalid
+ * @param registry - The plugin registry
+ * @param pluginName - The plugin name to check
+ * @returns true if the plugin is registered
  *
  * @example
  * ```typescript
- * import { getCachedInnerHeight } from 'blecsd';
+ * import { hasPlugin } from 'blecsd';
  *
- * const innerHeight = getCachedInnerHeight(world, entity);
+ * if (hasPlugin(registry, 'physics')) {
+ *   console.log('Physics plugin is loaded');
+ * }
  * ```
  */
-declare function getCachedInnerHeight(_world: World, eid: Entity): number;
+declare function hasPlugin(registry: PluginRegistry, pluginName: string): boolean;
 /**
- * Updates just the scroll base in the cache.
- * Useful when only scroll position changes but layout is the same.
+ * Gets the count of registered plugins.
  *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
- * @param base - New scroll base value
+ * @param registry - The plugin registry
+ * @returns Number of registered plugins
  *
  * @example
  * ```typescript
- * import { updateCachedScrollBase } from 'blecsd';
+ * import { getPluginCount } from 'blecsd';
  *
- * // After scrolling (layout unchanged, just scroll offset)
- * updateCachedScrollBase(world, entity, newScrollY);
+ * console.log(`${getPluginCount(registry)} plugins loaded`);
  * ```
  */
-declare function updateCachedScrollBase(_world: World, eid: Entity, base: number): void;
+declare function getPluginCount(registry: PluginRegistry): number;
 /**
- * Checks if a point is within the cached inner bounds.
- * Returns false if cache is invalid.
+ * Unregisters all plugins in reverse registration order,
+ * calling cleanup hooks and removing systems.
  *
- * @param _world - The ECS world (unused, for API consistency)
- * @param eid - The entity ID
- * @param x - X coordinate to test
- * @param y - Y coordinate to test
- * @returns true if point is within inner bounds
+ * @param registry - The plugin registry
+ * @param scheduler - The scheduler to unregister systems from
+ * @param world - The ECS world (passed to cleanup hooks)
  *
  * @example
  * ```typescript
- * import { isPointInCachedBounds } from 'blecsd';
+ * import { clearPlugins } from 'blecsd';
  *
- * // Efficient hit testing using cached positions
- * if (isPointInCachedBounds(world, entity, mouseX, mouseY)) {
- *   // Point is inside the element's inner area
- * }
+ * clearPlugins(registry, scheduler, world);
  * ```
  */
-declare function isPointInCachedBounds(_world: World, eid: Entity, x: number, y: number): boolean;
-
+declare function clearPlugins(registry: PluginRegistry, scheduler: Scheduler, world: World): void;
 /**
- * Advanced positioning system with percentage and expression support.
- * Resolves position values to absolute coordinates.
- * @module core/positioning
+ * Creates a plugin definition with sensible defaults.
+ * A convenience function that makes plugin creation more concise.
+ *
+ * @param config - Plugin configuration
+ * @returns A fully-formed Plugin object
+ *
+ * @example
+ * ```typescript
+ * import { definePlugin, LoopPhase } from 'blecsd';
+ *
+ * const myPlugin = definePlugin({
+ *   name: 'my-charts',
+ *   version: '1.0.0',
+ *   widgets: [
+ *     { name: 'bar-chart', factory: createBarChart, tags: ['chart', 'data'] },
+ *     { name: 'pie-chart', factory: createPieChart, tags: ['chart', 'data'] },
+ *   ],
+ *   systems: [
+ *     { system: chartAnimationSystem, phase: LoopPhase.ANIMATION },
+ *   ],
+ * });
+ * ```
  */
-
+declare function definePlugin(config: Plugin): Plugin;
 /**
- * Position value types supported by the positioning system.
- * - number: absolute position in cells
- * - string: percentage ('50%'), expression ('50%-5'), or keyword ('center', 'half')
+ * Activates a previously deactivated plugin.
+ * Re-registers its systems with the scheduler and calls onActivate.
+ *
+ * @param registry - The plugin registry
+ * @param scheduler - The scheduler to register systems with
+ * @param world - The ECS world
+ * @param pluginName - The name of the plugin to activate
+ * @returns true if the plugin was found and activated
+ *
+ * @example
+ * ```typescript
+ * import { activatePlugin } from 'blecsd';
+ *
+ * activatePlugin(registry, scheduler, world, 'physics');
+ * ```
  */
-type PositionValue = number | string;
+declare function activatePlugin(registry: PluginRegistry, scheduler: Scheduler, world: World, pluginName: string): boolean;
 /**
- * Schema for validating position values.
- * Accepts numbers, percentage strings, expressions, and keywords.
+ * Deactivates a plugin without fully unregistering it.
+ * Removes its systems from the scheduler and calls onDeactivate,
+ * but keeps the plugin in the registry for later reactivation.
+ *
+ * @param registry - The plugin registry
+ * @param scheduler - The scheduler to unregister systems from
+ * @param world - The ECS world
+ * @param pluginName - The name of the plugin to deactivate
+ * @returns true if the plugin was found and deactivated
  *
  * @example
  * ```typescript
- * import { PositionValueSchema } from 'blecsd';
+ * import { deactivatePlugin } from 'blecsd';
  *
- * PositionValueSchema.parse(10);        // Valid: absolute
- * PositionValueSchema.parse('50%');     // Valid: percentage
- * PositionValueSchema.parse('50%-5');   // Valid: expression
- * PositionValueSchema.parse('center');  // Valid: keyword
+ * deactivatePlugin(registry, scheduler, world, 'physics');
+ * // Plugin is still registered but not running
+ * // Re-activate later with activatePlugin()
  * ```
  */
-declare const PositionValueSchema: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+declare function deactivatePlugin(registry: PluginRegistry, scheduler: Scheduler, world: World, pluginName: string): boolean;
 /**
- * Resolves a position value to an absolute coordinate.
- *
- * Supports:
- * - Numbers: returned as-is
- * - Percentages: '50%' → parentSize * 0.5
- * - Expressions: '50%-5' → (parentSize * 0.5) - 5
- * - Keywords:
- *   - 'center': (parentSize - elementSize) / 2
- *   - 'half': parentSize / 2
- *   - 'left'/'top': 0
- *   - 'right'/'bottom': parentSize - elementSize
+ * Checks if a plugin is currently active.
  *
- * @param value - Position value to resolve
- * @param parentSize - Size of the parent container
- * @param elementSize - Size of the element (for centering)
- * @returns Resolved absolute position
+ * @param registry - The plugin registry
+ * @param pluginName - The name of the plugin to check
+ * @returns true if the plugin is registered and active
  *
  * @example
  * ```typescript
- * import { parsePosition } from 'blecsd';
+ * import { isPluginActive } from 'blecsd';
  *
- * // Absolute position
- * parsePosition(10, 100, 20); // 10
+ * if (isPluginActive(registry, 'physics')) {
+ *   console.log('Physics is running');
+ * }
+ * ```
+ */
+declare function isPluginActive(registry: PluginRegistry, pluginName: string): boolean;
+/**
+ * Validates plugin configuration against its declared config schema.
+ * Returns the validated config or throws if invalid.
+ *
+ * @param plugin - The plugin with a configSchema
+ * @param config - The configuration to validate
+ * @returns The validated configuration
+ * @throws If the config is invalid according to the plugin's schema
  *
- * // Percentage
- * parsePosition('50%', 100, 20); // 50
+ * @example
+ * ```typescript
+ * import { validatePluginConfig, definePlugin } from 'blecsd';
+ * import { z } from 'zod';
  *
- * // Expression
- * parsePosition('50%-5', 100, 20); // 45
- * parsePosition('100%-10', 100, 20); // 90
+ * const plugin = definePlugin({
+ *   name: 'my-plugin',
+ *   version: '1.0.0',
+ *   configSchema: z.object({ maxItems: z.number().positive() }),
+ * });
  *
- * // Keywords
- * parsePosition('center', 100, 20); // 40 ((100-20)/2)
- * parsePosition('half', 100, 20); // 50 (100/2)
- * parsePosition('right', 100, 20); // 80 (100-20)
+ * const config = validatePluginConfig(plugin, { maxItems: 10 });
  * ```
  */
-declare function parsePosition(value: PositionValue, parentSize: number, elementSize?: number): number;
+declare function validatePluginConfig(plugin: Plugin, config: unknown): unknown;
+
+/**
+ * Position caching for render optimization.
+ * Caches computed positions to avoid expensive recalculations.
+ * @module core/positionCache
+ */
+
 /**
- * Resolves a position value that may be negative (from right/bottom edge).
- * Negative values are converted to offsets from the opposite edge.
+ * Last computed position data.
+ * Used to cache resolved positions and skip recalculation when unchanged.
  *
- * @param value - Position value to resolve
- * @param parentSize - Size of the parent container
- * @param elementSize - Size of the element
- * @returns Resolved absolute position
+ * - `xi`: Inner X start (left edge after border/padding)
+ * - `xl`: Inner X end (right edge before border/padding)
+ * - `yi`: Inner Y start (top edge after border/padding)
+ * - `yl`: Inner Y end (bottom edge before border/padding)
+ * - `base`: Scroll base offset
+ * - `valid`: Cache validity flag (1 = valid, 0 = invalid)
  *
  * @example
  * ```typescript
- * import { parsePositionWithNegative } from 'blecsd';
+ * import { setPositionCache, getPositionCache, invalidatePositionCache } from 'blecsd';
  *
- * // Positive values work normally
- * parsePositionWithNegative(10, 100, 20); // 10
+ * // Set cached position after computing
+ * setPositionCache(world, entity, { xi: 5, xl: 85, yi: 3, yl: 23, base: 0 });
  *
- * // Negative values are from the right/bottom
- * parsePositionWithNegative(-10, 100, 20); // 70 (100 - 10 - 20)
- * parsePositionWithNegative(-5, 100, 10); // 85 (100 - 5 - 10)
+ * // Get cached position (returns undefined if invalid)
+ * const cached = getPositionCache(world, entity);
+ * if (cached) {
+ *   // Use cached values instead of recalculating
+ *   console.log(`Inner bounds: ${cached.xi},${cached.yi} to ${cached.xl},${cached.yl}`);
+ * }
+ *
+ * // Invalidate when position changes
+ * invalidatePositionCache(world, entity);
  * ```
  */
-declare function parsePositionWithNegative(value: PositionValue, parentSize: number, elementSize?: number): number;
+declare const PositionCache: {
+    /** Inner X start (left edge after border/padding) */
+    xi: Float32Array<ArrayBuffer>;
+    /** Inner X end (right edge before border/padding) */
+    xl: Float32Array<ArrayBuffer>;
+    /** Inner Y start (top edge after border/padding) */
+    yi: Float32Array<ArrayBuffer>;
+    /** Inner Y end (bottom edge before border/padding) */
+    yl: Float32Array<ArrayBuffer>;
+    /** Scroll base offset */
+    base: Float32Array<ArrayBuffer>;
+    /** Cache validity flag (1 = valid, 0 = invalid) */
+    valid: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Cached position data returned by getPositionCache.
+ */
+interface CachedPosition {
+    /** Inner X start (left edge after border/padding) */
+    readonly xi: number;
+    /** Inner X end (right edge before border/padding) */
+    readonly xl: number;
+    /** Inner Y start (top edge after border/padding) */
+    readonly yi: number;
+    /** Inner Y end (bottom edge before border/padding) */
+    readonly yl: number;
+    /** Scroll base offset */
+    readonly base: number;
+}
 /**
- * Validates that a position value is within valid bounds.
+ * Options for setting position cache.
+ */
+interface SetPositionCacheOptions {
+    /** Inner X start (left edge after border/padding) */
+    readonly xi: number;
+    /** Inner X end (right edge before border/padding) */
+    readonly xl: number;
+    /** Inner Y start (top edge after border/padding) */
+    readonly yi: number;
+    /** Inner Y end (bottom edge before border/padding) */
+    readonly yl: number;
+    /** Scroll base offset */
+    readonly base: number;
+}
+/**
+ * Sets the cached position for an entity.
+ * Marks the cache as valid.
  *
- * @param value - Resolved position value
- * @param parentSize - Size of the parent container
- * @param elementSize - Size of the element
- * @returns Clamped position value within bounds
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
+ * @param options - Position values to cache
  *
  * @example
  * ```typescript
- * import { clampPosition } from 'blecsd';
+ * import { setPositionCache } from 'blecsd';
  *
- * clampPosition(-10, 100, 20); // 0 (can't be negative)
- * clampPosition(90, 100, 20); // 80 (element must fit)
- * clampPosition(50, 100, 20); // 50 (within bounds)
+ * // After computing positions during render
+ * setPositionCache(world, entity, {
+ *   xi: 5,   // Inner left
+ *   xl: 85,  // Inner right
+ *   yi: 3,   // Inner top
+ *   yl: 23,  // Inner bottom
+ *   base: 0, // Scroll offset
+ * });
  * ```
  */
-declare function clampPosition(value: number, parentSize: number, elementSize?: number): number;
+declare function setPositionCache(_world: World, eid: Entity, options: SetPositionCacheOptions): void;
 /**
- * Checks if a position value is a percentage or expression containing a percentage.
+ * Gets the cached position for an entity.
+ * Returns undefined if the cache is invalid.
  *
- * @param value - Position value to check
- * @returns true if the value contains a percentage
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
+ * @returns Cached position data or undefined if invalid
  *
  * @example
  * ```typescript
- * import { isPercentagePosition } from 'blecsd';
+ * import { getPositionCache } from 'blecsd';
  *
- * isPercentagePosition('50%'); // true
- * isPercentagePosition('50%-5'); // true
- * isPercentagePosition(50); // false
- * isPercentagePosition('center'); // false
+ * const cached = getPositionCache(world, entity);
+ * if (cached) {
+ *   // Use cached values
+ *   const innerWidth = cached.xl - cached.xi;
+ *   const innerHeight = cached.yl - cached.yi;
+ * }
  * ```
  */
-declare function isPercentagePosition(value: PositionValue): boolean;
+declare function getPositionCache(_world: World, eid: Entity): CachedPosition | undefined;
 /**
- * Checks if a position value is a keyword.
+ * Checks if the position cache is valid for an entity.
  *
- * @param value - Position value to check
- * @returns true if the value is a position keyword
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
+ * @returns true if cache is valid
  *
  * @example
  * ```typescript
- * import { isKeywordPosition } from 'blecsd';
+ * import { hasValidPositionCache } from 'blecsd';
  *
- * isKeywordPosition('center'); // true
- * isKeywordPosition('half'); // true
- * isKeywordPosition('50%'); // false
- * isKeywordPosition(50); // false
+ * if (hasValidPositionCache(world, entity)) {
+ *   // Skip expensive position calculation
+ * }
  * ```
  */
-declare function isKeywordPosition(value: PositionValue): boolean;
+declare function hasValidPositionCache(_world: World, eid: Entity): boolean;
 /**
- * Creates a position value that centers an element.
+ * Invalidates the position cache for an entity.
+ * Call this when position, size, or parent changes.
  *
- * @returns 'center' keyword
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
  *
  * @example
  * ```typescript
- * import { centerPosition, parsePosition } from 'blecsd';
+ * import { invalidatePositionCache } from 'blecsd';
  *
- * const pos = centerPosition();
- * const resolved = parsePosition(pos, 100, 20); // 40
+ * // Invalidate when entity moves
+ * setPosition(world, entity, 10, 20);
+ * invalidatePositionCache(world, entity);
  * ```
  */
-declare function centerPosition(): 'center';
+declare function invalidatePositionCache(_world: World, eid: Entity): void;
 /**
- * Creates a percentage position value.
+ * Invalidates the position cache for an entity and all its descendants.
+ * Call this when a parent changes position, as all children need recalculation.
  *
- * @param percent - Percentage value (0-100)
- * @returns Percentage string
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param getDescendants - Function to get descendant entities
  *
  * @example
  * ```typescript
- * import { percentPosition, parsePosition } from 'blecsd';
+ * import { invalidatePositionCacheTree, getChildren } from 'blecsd';
  *
- * const pos = percentPosition(50);
- * const resolved = parsePosition(pos, 100, 0); // 50
+ * // Invalidate entire subtree when parent moves
+ * invalidatePositionCacheTree(world, parentEntity, (w, e) => {
+ *   // Return all descendants recursively
+ *   return getAllDescendants(w, e);
+ * });
  * ```
  */
-declare function percentPosition(percent: number): string;
+declare function invalidatePositionCacheTree(world: World, eid: Entity, getDescendants: (world: World, eid: Entity) => Entity[]): void;
 /**
- * Creates a percentage position with an offset.
+ * Clears all position caches.
+ * Useful for forcing a complete recalculation after major changes.
  *
- * @param percent - Percentage value (0-100)
- * @param offset - Offset to add (negative to subtract)
- * @returns Expression string
+ * @param _world - The ECS world (unused, for API consistency)
  *
  * @example
  * ```typescript
- * import { percentOffsetPosition, parsePosition } from 'blecsd';
+ * import { clearAllPositionCaches } from 'blecsd';
  *
- * const pos = percentOffsetPosition(50, -5);
- * const resolved = parsePosition(pos, 100, 0); // 45
+ * // After screen resize
+ * clearAllPositionCaches(world);
+ * ```
+ */
+declare function clearAllPositionCaches(_world: World): void;
+/**
+ * Gets inner width from cached position.
+ * Returns 0 if cache is invalid.
+ *
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
+ * @returns Inner width or 0 if invalid
+ *
+ * @example
+ * ```typescript
+ * import { getCachedInnerWidth } from 'blecsd';
  *
- * const pos2 = percentOffsetPosition(100, -10);
- * const resolved2 = parsePosition(pos2, 100, 0); // 90
+ * const innerWidth = getCachedInnerWidth(world, entity);
  * ```
  */
-declare function percentOffsetPosition(percent: number, offset: number): string;
+declare function getCachedInnerWidth(_world: World, eid: Entity): number;
 /**
- * Resolves both X and Y position values at once.
+ * Gets inner height from cached position.
+ * Returns 0 if cache is invalid.
  *
- * @param x - X position value
- * @param y - Y position value
- * @param parentWidth - Parent container width
- * @param parentHeight - Parent container height
- * @param elementWidth - Element width (for centering)
- * @param elementHeight - Element height (for centering)
- * @returns Resolved { x, y } coordinates
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
+ * @returns Inner height or 0 if invalid
  *
  * @example
  * ```typescript
- * import { resolvePosition } from 'blecsd';
+ * import { getCachedInnerHeight } from 'blecsd';
  *
- * const pos = resolvePosition('center', 'center', 100, 80, 20, 10);
- * // pos = { x: 40, y: 35 }
+ * const innerHeight = getCachedInnerHeight(world, entity);
+ * ```
+ */
+declare function getCachedInnerHeight(_world: World, eid: Entity): number;
+/**
+ * Updates just the scroll base in the cache.
+ * Useful when only scroll position changes but layout is the same.
+ *
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
+ * @param base - New scroll base value
+ *
+ * @example
+ * ```typescript
+ * import { updateCachedScrollBase } from 'blecsd';
  *
- * const pos2 = resolvePosition('50%-5', '100%-10', 100, 80, 0, 0);
- * // pos2 = { x: 45, y: 70 }
+ * // After scrolling (layout unchanged, just scroll offset)
+ * updateCachedScrollBase(world, entity, newScrollY);
  * ```
  */
-declare function resolvePosition(x: PositionValue, y: PositionValue, parentWidth: number, parentHeight: number, elementWidth?: number, elementHeight?: number): {
-    x: number;
-    y: number;
-};
+declare function updateCachedScrollBase(_world: World, eid: Entity, base: number): void;
 /**
- * Resolves position values and clamps them to valid bounds.
+ * Checks if a point is within the cached inner bounds.
+ * Returns false if cache is invalid.
  *
- * @param x - X position value
- * @param y - Y position value
- * @param parentWidth - Parent container width
- * @param parentHeight - Parent container height
- * @param elementWidth - Element width
- * @param elementHeight - Element height
- * @returns Resolved and clamped { x, y } coordinates
+ * @param _world - The ECS world (unused, for API consistency)
+ * @param eid - The entity ID
+ * @param x - X coordinate to test
+ * @param y - Y coordinate to test
+ * @returns true if point is within inner bounds
  *
  * @example
  * ```typescript
- * import { resolvePositionClamped } from 'blecsd';
+ * import { isPointInCachedBounds } from 'blecsd';
  *
- * // Position that would go off-screen is clamped
- * const pos = resolvePositionClamped('100%', '100%', 100, 80, 20, 10);
- * // pos = { x: 80, y: 70 } (clamped so element fits)
+ * // Efficient hit testing using cached positions
+ * if (isPointInCachedBounds(world, entity, mouseX, mouseY)) {
+ *   // Point is inside the element's inner area
+ * }
  * ```
  */
-declare function resolvePositionClamped(x: PositionValue, y: PositionValue, parentWidth: number, parentHeight: number, elementWidth?: number, elementHeight?: number): {
-    x: number;
-    y: number;
-};
+declare function isPointInCachedBounds(_world: World, eid: Entity, x: number, y: number): boolean;
 
 /**
  * Common ECS queries for filtering and selecting entities.
@@ -5079,140 +5886,548 @@ declare function getChildEntities(_world: World, parent: Entity): Entity[];
  *
  * @example
  * ```typescript
- * import { createWorld, createBoxEntity, getDescendantEntities } from 'blecsd';
+ * import { createWorld, createBoxEntity, getDescendantEntities } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const root = createBoxEntity(world, { x: 0, y: 0 });
+ * const child = createBoxEntity(world, { parent: root, x: 1, y: 1 });
+ * const grandchild = createBoxEntity(world, { parent: child, x: 2, y: 2 });
+ *
+ * const descendants = getDescendantEntities(world, root);
+ * // descendants = [child, grandchild]
+ * ```
+ */
+declare function getDescendantEntities(world: World, parent: Entity): Entity[];
+/**
+ * Gets all root entities (entities with no parent).
+ *
+ * Filters queryHierarchy to entities where parent === 0 (NULL_ENTITY).
+ *
+ * @param world - The ECS world
+ * @returns Array of root entity IDs
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, createBoxEntity, getRootEntities } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const root1 = createBoxEntity(world, { x: 0, y: 0 });
+ * const root2 = createBoxEntity(world, { x: 10, y: 0 });
+ * const child = createBoxEntity(world, { parent: root1, x: 1, y: 1 });
+ *
+ * const roots = getRootEntities(world);
+ * // roots = [root1, root2]
+ * ```
+ */
+declare function getRootEntities(world: World): Entity[];
+/**
+ * Filters entities to only those that are focusable and enabled.
+ *
+ * Returns entities where Focusable.focusable === 1.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entity IDs to filter
+ * @returns Filtered array of focusable entity IDs
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, queryFocusable, filterFocusable } from 'blecsd';
+ *
+ * const world = createWorld();
+ * // ... create focusable entities, some disabled ...
+ *
+ * const allFocusables = queryFocusable(world);
+ * const enabledFocusables = filterFocusable(world, allFocusables);
+ *
+ * for (const eid of enabledFocusables) {
+ *   // Process only enabled focusable entities
+ * }
+ * ```
+ */
+declare function filterFocusable(_world: World, entities: readonly Entity[]): Entity[];
+/**
+ * Filters entities to only those that are clickable.
+ *
+ * Returns entities where Interactive.clickable === 1.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entity IDs to filter
+ * @returns Filtered array of clickable entity IDs
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, queryInteractive, filterClickable } from 'blecsd';
+ *
+ * const world = createWorld();
+ * // ... create interactive entities ...
+ *
+ * const allInteractives = queryInteractive(world);
+ * const clickables = filterClickable(world, allInteractives);
+ *
+ * for (const eid of clickables) {
+ *   // Process only clickable entities
+ * }
+ * ```
+ */
+declare function filterClickable(_world: World, entities: readonly Entity[]): Entity[];
+/**
+ * Sorts entities by tab index for focus navigation.
+ *
+ * Entities with lower tabIndex are focused first. Entities with tabIndex 0
+ * follow DOM-like ordering.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entity IDs to sort
+ * @returns New array of entity IDs sorted by tab index
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, queryFocusable, sortByTabIndex, filterFocusable } from 'blecsd';
+ *
+ * const world = createWorld();
+ * // ... create focusable entities with different tab indices ...
+ *
+ * const focusables = queryFocusable(world);
+ * const enabled = filterFocusable(world, focusables);
+ * const tabOrder = sortByTabIndex(world, enabled);
+ *
+ * // tabOrder is now in correct focus navigation order
+ * ```
+ */
+declare function sortByTabIndex(_world: World, entities: readonly Entity[]): Entity[];
+/**
+ * Sorts entities by depth in the hierarchy (ancestors first).
+ *
+ * Useful for processing entities in parent-to-child order.
+ *
+ * @param world - The ECS world
+ * @param entities - Array of entity IDs to sort
+ * @returns New array of entity IDs sorted by depth (ascending)
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, queryHierarchy, sortByDepth } from 'blecsd';
+ *
+ * const world = createWorld();
+ * // ... create hierarchical entities ...
+ *
+ * const hierarchical = queryHierarchy(world);
+ * const topDown = sortByDepth(world, hierarchical);
+ *
+ * for (const eid of topDown) {
+ *   // Process parent before children
+ * }
+ * ```
+ */
+declare function sortByDepth(_world: World, entities: readonly Entity[]): Entity[];
+
+/**
+ * Reactive effect system for blECSd.
+ * Effects automatically re-run when their dependencies change.
+ *
+ * @module core/reactiveEffects
+ */
+
+/**
+ * Effect handle for disposal.
+ */
+interface EffectHandle {
+    readonly dispose: () => void;
+}
+/**
+ * Effect function that may optionally return a cleanup function.
+ * The function can return nothing (void/undefined) or a cleanup function.
+ */
+type EffectFunction = () => unknown;
+/**
+ * Creates an immediate effect that runs when dependencies change.
+ * The effect runs immediately on creation and re-runs whenever any signal
+ * read inside the effect changes.
+ *
+ * @param fn - Effect function to run
+ * @returns Effect handle for disposal
+ *
+ * @example
+ * ```typescript
+ * import { createSignal, createEffect } from 'blecsd';
+ *
+ * const [count, setCount] = createSignal(0);
+ *
+ * const effect = createEffect(() => {
+ *   console.log(`Count is now: ${count()}`);
+ *   return () => console.log('Cleaning up effect');
+ * });
+ *
+ * setCount(5); // Logs: "Cleaning up effect", then "Count is now: 5"
+ *
+ * effect.dispose(); // Stop the effect
+ * ```
+ */
+declare function createEffect(fn: EffectFunction): EffectHandle;
+/**
+ * Creates a scheduled effect that defers execution to a specific ECS loop phase.
+ * Unlike immediate effects, scheduled effects batch their updates and run during
+ * the specified phase of the game loop.
+ *
+ * @param fn - Effect function to run
+ * @param phase - Loop phase to run in (default: LATE_UPDATE)
+ * @returns Effect handle for disposal
+ *
+ * @example
+ * ```typescript
+ * import { createSignal, createScheduledEffect, LoopPhase } from 'blecsd';
+ *
+ * const [position, setPosition] = createSignal({ x: 0, y: 0 });
+ *
+ * // Effect runs during LAYOUT phase
+ * const effect = createScheduledEffect(() => {
+ *   const pos = position();
+ *   console.log(`Position updated: ${pos.x}, ${pos.y}`);
+ * }, LoopPhase.LAYOUT);
+ *
+ * setPosition({ x: 10, y: 20 }); // Marked dirty, waits for LAYOUT phase
+ *
+ * effect.dispose(); // Stop the effect
+ * ```
+ */
+declare function createScheduledEffect(fn: EffectFunction, phase?: LoopPhase): EffectHandle;
+/**
+ * Disposes an effect, stopping it from running and cleaning up.
+ * This is a convenience function equivalent to calling effect.dispose().
+ *
+ * @param handle - Effect handle to dispose
+ *
+ * @example
+ * ```typescript
+ * import { createEffect, disposeEffect } from 'blecsd';
+ *
+ * const effect = createEffect(() => {
+ *   console.log('Effect running');
+ * });
+ *
+ * disposeEffect(effect); // Same as effect.dispose()
+ * ```
+ */
+declare function disposeEffect(handle: EffectHandle): void;
+/**
+ * Flushes all scheduled effects for a specific phase.
+ * This is called by the reactive system during each loop phase.
+ *
+ * @param phase - Loop phase to flush effects for
+ * @internal
+ */
+declare function flushScheduledEffects(phase: LoopPhase): void;
+/**
+ * Gets the count of scheduled effects for a specific phase.
+ * Useful for debugging and testing.
+ *
+ * @param phase - Loop phase to count effects for
+ * @returns Number of scheduled effects in the phase
+ *
+ * @example
+ * ```typescript
+ * import { createScheduledEffect, getScheduledEffectCount, LoopPhase } from 'blecsd';
+ *
+ * createScheduledEffect(() => {}, LoopPhase.UPDATE);
+ * createScheduledEffect(() => {}, LoopPhase.UPDATE);
+ *
+ * console.log(getScheduledEffectCount(LoopPhase.UPDATE)); // 2
+ * ```
+ */
+declare function getScheduledEffectCount(phase: LoopPhase): number;
+/**
+ * Gets the total count of all scheduled effects across all phases.
+ *
+ * @returns Total number of scheduled effects
+ *
+ * @example
+ * ```typescript
+ * import { createScheduledEffect, getTotalScheduledEffectCount, LoopPhase } from 'blecsd';
+ *
+ * createScheduledEffect(() => {}, LoopPhase.UPDATE);
+ * createScheduledEffect(() => {}, LoopPhase.RENDER);
+ *
+ * console.log(getTotalScheduledEffectCount()); // 2
+ * ```
+ */
+declare function getTotalScheduledEffectCount(): number;
+
+/**
+ * Reactive data source adapters for blECSd.
+ * Provides signal-based wrappers for common data sources like intervals, timers, and reducers.
+ *
+ * @module core/reactiveSource
+ */
+
+/**
+ * Dispose function for reactive sources.
+ */
+type Dispose = () => void;
+/**
+ * Creates a signal that updates at a regular interval.
+ * The signal value is computed by calling the provided function.
+ *
+ * @param fn - Function to call on each interval
+ * @param intervalMs - Interval in milliseconds
+ * @returns Tuple of [getter, dispose]
+ *
+ * @example
+ * ```typescript
+ * import { createIntervalSignal } from 'blecsd';
+ *
+ * const [time, dispose] = createIntervalSignal(() => Date.now(), 1000);
+ *
+ * console.log(time()); // Current timestamp
+ * // ... wait 1 second ...
+ * console.log(time()); // Updated timestamp
+ *
+ * dispose(); // Stop the interval
+ * ```
+ */
+declare function createIntervalSignal<T>(fn: () => T, intervalMs: number): [SignalGetter<T>, Dispose];
+/**
+ * Creates a signal that tracks elapsed time as a progress value from 0 to 1.
+ * Useful for animations, countdowns, and timed transitions.
+ *
+ * @param durationMs - Duration in milliseconds
+ * @returns Tuple of [progress getter (0-1), dispose]
+ *
+ * @example
+ * ```typescript
+ * import { createTimerSignal } from 'blecsd';
+ *
+ * const [progress, dispose] = createTimerSignal(5000); // 5 second timer
+ *
+ * console.log(progress()); // 0.0
+ * // ... wait 2.5 seconds ...
+ * console.log(progress()); // ~0.5
+ * // ... wait 2.5 more seconds ...
+ * console.log(progress()); // 1.0
+ *
+ * dispose(); // Stop the timer
+ * ```
+ */
+declare function createTimerSignal(durationMs: number): [SignalGetter<number>, Dispose];
+/**
+ * Dispatch function for reducer signal.
+ */
+type Dispatch<A> = (action: A) => void;
+/**
+ * Reducer function type.
+ */
+type Reducer<T, A> = (state: T, action: A) => T;
+/**
+ * Creates a signal with a reducer-style update pattern.
+ * Similar to React's useReducer, but as a reactive signal.
+ *
+ * @param reducer - Reducer function (state, action) => newState
+ * @param initial - Initial state value
+ * @returns Tuple of [getter, dispatch]
+ *
+ * @example
+ * ```typescript
+ * import { createReducerSignal } from 'blecsd';
  *
- * const world = createWorld();
- * const root = createBoxEntity(world, { x: 0, y: 0 });
- * const child = createBoxEntity(world, { parent: root, x: 1, y: 1 });
- * const grandchild = createBoxEntity(world, { parent: child, x: 2, y: 2 });
+ * type CounterAction = { type: 'increment' } | { type: 'decrement' } | { type: 'reset' };
  *
- * const descendants = getDescendantEntities(world, root);
- * // descendants = [child, grandchild]
+ * const [count, dispatch] = createReducerSignal<number, CounterAction>(
+ *   (state, action) => {
+ *     switch (action.type) {
+ *       case 'increment': return state + 1;
+ *       case 'decrement': return state - 1;
+ *       case 'reset': return 0;
+ *     }
+ *   },
+ *   0
+ * );
+ *
+ * console.log(count()); // 0
+ * dispatch({ type: 'increment' });
+ * console.log(count()); // 1
+ * dispatch({ type: 'increment' });
+ * console.log(count()); // 2
+ * dispatch({ type: 'reset' });
+ * console.log(count()); // 0
  * ```
  */
-declare function getDescendantEntities(world: World, parent: Entity): Entity[];
+declare function createReducerSignal<T, A>(reducer: Reducer<T, A>, initial: T): [SignalGetter<T>, Dispatch<A>];
 /**
- * Gets all root entities (entities with no parent).
- *
- * Filters queryHierarchy to entities where parent === 0 (NULL_ENTITY).
+ * Combiner function type for derived signals.
+ */
+type Combiner<T, R> = (...values: T[]) => R;
+/**
+ * Creates a derived signal that combines multiple signal values.
+ * The combiner function is called whenever any input signal changes.
  *
- * @param world - The ECS world
- * @returns Array of root entity IDs
+ * @param signals - Array of signal getters to combine
+ * @param combiner - Function to combine signal values
+ * @returns Computed signal with combined value
  *
  * @example
  * ```typescript
- * import { createWorld, createBoxEntity, getRootEntities } from 'blecsd';
+ * import { createSignal, createDerivedSignal } from 'blecsd';
  *
- * const world = createWorld();
- * const root1 = createBoxEntity(world, { x: 0, y: 0 });
- * const root2 = createBoxEntity(world, { x: 10, y: 0 });
- * const child = createBoxEntity(world, { parent: root1, x: 1, y: 1 });
+ * const [firstName, setFirstName] = createSignal('John');
+ * const [lastName, setLastName] = createSignal('Doe');
  *
- * const roots = getRootEntities(world);
- * // roots = [root1, root2]
+ * const fullName = createDerivedSignal(
+ *   [firstName, lastName],
+ *   (first, last) => `${first} ${last}`
+ * );
+ *
+ * console.log(fullName()); // "John Doe"
+ * setFirstName('Jane');
+ * console.log(fullName()); // "Jane Doe"
  * ```
  */
-declare function getRootEntities(world: World): Entity[];
+declare function createDerivedSignal<T, R>(signals: ReadonlyArray<SignalGetter<T>>, combiner: Combiner<T, R>): ComputedSignal<R>;
 /**
- * Filters entities to only those that are focusable and enabled.
- *
- * Returns entities where Focusable.focusable === 1.
+ * Minimal interface for a readable stream.
+ */
+interface ReadableStream {
+    on(event: string, listener: (...args: unknown[]) => void): void;
+    removeListener(event: string, listener: (...args: unknown[]) => void): void;
+    destroy?(): void;
+}
+/**
+ * Options for stream signal creation.
+ */
+interface StreamSignalOptions<T> {
+    /**
+     * Transform function to convert Buffer chunks to signal values.
+     * Defaults to converting Buffer to string.
+     */
+    transform?: (chunk: Buffer) => T;
+    /**
+     * Initial value for the signal.
+     */
+    initialValue: T;
+    /**
+     * Whether to destroy the stream on dispose. Defaults to false.
+     */
+    destroyOnDispose?: boolean;
+}
+/**
+ * Creates a signal from a Node.js Readable stream.
+ * Updates on each 'data' event with the transformed chunk value.
  *
- * @param world - The ECS world
- * @param entities - Array of entity IDs to filter
- * @returns Filtered array of focusable entity IDs
+ * @param readable - A readable stream (Node.js Readable or compatible)
+ * @param options - Stream signal options
+ * @returns Tuple of [getter, dispose]
  *
  * @example
  * ```typescript
- * import { createWorld, queryFocusable, filterFocusable } from 'blecsd';
+ * import { createStreamSignal } from 'blecsd';
+ * import { createReadStream } from 'fs';
  *
- * const world = createWorld();
- * // ... create focusable entities, some disabled ...
+ * const stream = createReadStream('./data.txt', { encoding: 'utf8' });
+ * const [data, dispose] = createStreamSignal(stream, {
+ *   initialValue: '',
+ *   transform: (chunk) => chunk.toString('utf8')
+ * });
  *
- * const allFocusables = queryFocusable(world);
- * const enabledFocusables = filterFocusable(world, allFocusables);
+ * console.log(data()); // Latest chunk from stream
  *
- * for (const eid of enabledFocusables) {
- *   // Process only enabled focusable entities
- * }
+ * dispose(); // Clean up listeners
  * ```
  */
-declare function filterFocusable(_world: World, entities: readonly Entity[]): Entity[];
+declare function createStreamSignal<T>(readable: ReadableStream, options: StreamSignalOptions<T>): [SignalGetter<T>, Dispose];
 /**
- * Filters entities to only those that are clickable.
- *
- * Returns entities where Interactive.clickable === 1.
+ * Subscribe function type for callback signal.
+ * Takes a callback and returns an unsubscribe function.
+ */
+type Subscribe<T> = (callback: (value: T) => void) => () => void;
+/**
+ * Creates a signal from a generic subscribe/unsubscribe pattern.
+ * This is a universal adapter for WebSocket, EventEmitter, and other callback-based sources.
  *
- * @param world - The ECS world
- * @param entities - Array of entity IDs to filter
- * @returns Filtered array of clickable entity IDs
+ * @param subscribe - Function that takes a callback and returns an unsubscribe function
+ * @param initialValue - Initial value for the signal
+ * @returns Tuple of [getter, dispose]
  *
  * @example
  * ```typescript
- * import { createWorld, queryInteractive, filterClickable } from 'blecsd';
+ * import { createCallbackSignal } from 'blecsd';
  *
- * const world = createWorld();
- * // ... create interactive entities ...
+ * // WebSocket example
+ * const ws = new WebSocket('ws://localhost:8080');
+ * const [message, dispose] = createCallbackSignal<string>(
+ *   (callback) => {
+ *     const handler = (event: MessageEvent) => callback(event.data);
+ *     ws.addEventListener('message', handler);
+ *     return () => ws.removeEventListener('message', handler);
+ *   },
+ *   ''
+ * );
  *
- * const allInteractives = queryInteractive(world);
- * const clickables = filterClickable(world, allInteractives);
+ * console.log(message()); // Latest WebSocket message
  *
- * for (const eid of clickables) {
- *   // Process only clickable entities
- * }
+ * dispose(); // Unsubscribe
  * ```
  */
-declare function filterClickable(_world: World, entities: readonly Entity[]): Entity[];
+declare function createCallbackSignal<T>(subscribe: Subscribe<T>, initialValue: T): [SignalGetter<T>, Dispose];
 /**
- * Sorts entities by tab index for focus navigation.
- *
- * Entities with lower tabIndex are focused first. Entities with tabIndex 0
- * follow DOM-like ordering.
+ * Creates a signal that polls an async function at regular intervals.
+ * Handles promises and errors gracefully.
  *
- * @param world - The ECS world
- * @param entities - Array of entity IDs to sort
- * @returns New array of entity IDs sorted by tab index
+ * @param fn - Async function to poll
+ * @param intervalMs - Polling interval in milliseconds
+ * @param initialValue - Initial value for the signal
+ * @returns Tuple of [getter, dispose]
  *
  * @example
  * ```typescript
- * import { createWorld, queryFocusable, sortByTabIndex, filterFocusable } from 'blecsd';
+ * import { createPollingSignal } from 'blecsd';
  *
- * const world = createWorld();
- * // ... create focusable entities with different tab indices ...
+ * const [apiData, dispose] = createPollingSignal(
+ *   async () => {
+ *     const response = await fetch('https://api.example.com/status');
+ *     return response.json();
+ *   },
+ *   5000, // Poll every 5 seconds
+ *   { status: 'unknown' }
+ * );
  *
- * const focusables = queryFocusable(world);
- * const enabled = filterFocusable(world, focusables);
- * const tabOrder = sortByTabIndex(world, enabled);
+ * console.log(apiData()); // Latest API response
  *
- * // tabOrder is now in correct focus navigation order
+ * dispose(); // Stop polling
  * ```
  */
-declare function sortByTabIndex(_world: World, entities: readonly Entity[]): Entity[];
+declare function createPollingSignal<T>(fn: () => Promise<T>, intervalMs: number, initialValue: T): [SignalGetter<T>, Dispose];
 /**
- * Sorts entities by depth in the hierarchy (ancestors first).
- *
- * Useful for processing entities in parent-to-child order.
+ * Minimal interface for an event emitter.
+ */
+interface EventEmitter {
+    on(eventName: string, listener: (...args: unknown[]) => void): void;
+    removeListener(eventName: string, listener: (...args: unknown[]) => void): void;
+}
+/**
+ * Creates a signal from a Node.js EventEmitter event.
+ * Updates whenever the specified event is emitted.
  *
- * @param world - The ECS world
- * @param entities - Array of entity IDs to sort
- * @returns New array of entity IDs sorted by depth (ascending)
+ * @param emitter - Event emitter instance
+ * @param eventName - Name of the event to listen to
+ * @param initialValue - Initial value for the signal (optional)
+ * @returns Tuple of [getter, dispose]
  *
  * @example
  * ```typescript
- * import { createWorld, queryHierarchy, sortByDepth } from 'blecsd';
+ * import { createEventSignal } from 'blecsd';
+ * import { EventEmitter } from 'events';
  *
- * const world = createWorld();
- * // ... create hierarchical entities ...
+ * const emitter = new EventEmitter();
+ * const [message, dispose] = createEventSignal<string>(emitter, 'message', '');
  *
- * const hierarchical = queryHierarchy(world);
- * const topDown = sortByDepth(world, hierarchical);
+ * emitter.emit('message', 'Hello');
+ * console.log(message()); // "Hello"
  *
- * for (const eid of topDown) {
- *   // Process parent before children
- * }
+ * emitter.emit('message', 'World');
+ * console.log(message()); // "World"
+ *
+ * dispose(); // Remove listener
  * ```
  */
-declare function sortByDepth(_world: World, entities: readonly Entity[]): Entity[];
+declare function createEventSignal<T>(emitter: EventEmitter, eventName: string, initialValue?: T): [SignalGetter<T | undefined>, Dispose];
 
 /**
  * Scene management for game screens.
@@ -5426,283 +6641,156 @@ declare function createSlideTransition(duration: number, direction: 'left' | 'ri
 declare function createSceneSystem(sceneManager: SceneManager, getDelta: () => number): System;
 
 /**
- * ECS world state serialization and deserialization.
- *
- * Provides functions to serialize ECS world state to JSON and restore it,
- * supporting component data, entity relationships, and custom serializers
- * for complex (non-typed-array) data.
- *
+ * ECS world state serialization with delta compression
  * @module core/serialization
  */
 
 /**
- * A registered component descriptor for serialization.
- */
-interface ComponentDescriptor {
-    /** Unique name for the component (used as key in serialized data) */
-    readonly name: string;
-    /** The component store object (SoA typed arrays) */
-    readonly store: Record<string, any>;
-    /** Optional custom serializer for non-typed-array data */
-    readonly serialize?: (eid: Entity) => unknown;
-    /** Optional custom deserializer for non-typed-array data */
-    readonly deserialize?: (eid: Entity, data: unknown) => void;
-}
-/**
- * Serialized entity data.
+ * Component field data - maps field names to their value arrays
  */
-interface SerializedEntity {
-    /** Original entity ID (for relationship mapping) */
-    readonly id: number;
-    /** Map of component name to serialized component data */
-    readonly components: Record<string, SerializedComponentData>;
+interface ComponentFieldData {
+    readonly [fieldName: string]: readonly number[];
 }
 /**
- * Serialized component data for a single entity.
+ * Serialized component data
  */
-interface SerializedComponentData {
-    /** Typed array field values (field name -> value) */
-    readonly fields: Record<string, number>;
-    /** Optional custom data from serialize callback */
-    readonly custom?: unknown;
+interface ComponentData {
+    readonly name: string;
+    readonly entities: readonly number[];
+    readonly values: ComponentFieldData;
 }
 /**
- * Complete serialized world snapshot.
+ * Complete world snapshot
  */
-interface SerializedWorld {
-    /** Version for forward compatibility */
+interface WorldSnapshot {
     readonly version: number;
-    /** Timestamp of serialization */
     readonly timestamp: number;
-    /** Array of serialized entities */
-    readonly entities: readonly SerializedEntity[];
-    /** Optional metadata attached by user */
-    readonly metadata?: Record<string, unknown> | undefined;
-}
-/**
- * Options for serialization.
- */
-interface SerializeOptions {
-    /** Only serialize entities with these IDs (default: all entities) */
-    readonly entityFilter?: readonly Entity[] | undefined;
-    /** Only serialize these components by name (default: all registered) */
-    readonly componentFilter?: readonly string[] | undefined;
-    /** Metadata to include in the snapshot */
-    readonly metadata?: Record<string, unknown> | undefined;
+    readonly entityCount: number;
+    readonly components: readonly ComponentData[];
 }
 /**
- * Options for deserialization.
+ * Delta between two world snapshots
  */
-interface DeserializeOptions {
-    /** If true, clear the world before loading (default: false) */
-    readonly clearWorld?: boolean | undefined;
-    /** If true, create a new world instead of modifying the given one (default: false) */
-    readonly createNew?: boolean | undefined;
+interface WorldDelta {
+    readonly baseTimestamp: number;
+    readonly timestamp: number;
+    readonly addedEntities: readonly number[];
+    readonly removedEntities: readonly number[];
+    readonly changedComponents: readonly ComponentData[];
 }
 /**
- * Result of deserialization.
+ * Component registration for serialization
  */
-interface DeserializeResult {
-    /** The world that was deserialized into */
-    readonly world: World;
-    /** Map from old entity IDs to new entity IDs */
-    readonly entityMap: ReadonlyMap<number, Entity>;
-    /** Count of entities restored */
-    readonly entityCount: number;
-    /** Count of components restored */
-    readonly componentCount: number;
+interface ComponentRegistration {
+    readonly name: string;
+    readonly component: any;
+    readonly fields: readonly string[];
 }
 /**
- * Registers a component for serialization.
- *
- * Components must be registered before they can be serialized or deserialized.
- * The descriptor tells the serializer how to read/write the component's data.
- *
- * @param descriptor - Component descriptor with name, store, and optional custom serializers
- *
- * @example
- * ```typescript
- * import { registerSerializable, Position } from 'blecsd';
- *
- * registerSerializable({
- *   name: 'Position',
- *   store: Position,
- * });
- * ```
- */
-declare function registerSerializable(descriptor: ComponentDescriptor): void;
-/**
- * Unregisters a component from serialization.
- *
- * @param name - The component name to unregister
- * @returns True if the component was found and removed
- *
- * @example
- * ```typescript
- * import { unregisterSerializable } from 'blecsd';
- *
- * unregisterSerializable('Position');
- * ```
- */
-declare function unregisterSerializable(name: string): boolean;
-/**
- * Gets a registered component descriptor by name.
+ * Registers components for serialization.
+ * Must be called before serializing/deserializing world state.
  *
- * @param name - The component name
- * @returns The descriptor, or undefined if not registered
+ * @param registrations - Array of component registrations
  *
  * @example
  * ```typescript
- * import { getSerializable } from 'blecsd';
+ * import { registerComponents, Position, Velocity } from 'blecsd';
  *
- * const desc = getSerializable('Position');
- * if (desc) {
- *   console.log(Object.keys(desc.store)); // ['x', 'y', 'z', 'absolute']
- * }
+ * registerComponents([
+ *   { name: 'Position', component: Position, fields: ['x', 'y', 'z', 'absolute'] },
+ *   { name: 'Velocity', component: Velocity, fields: ['x', 'y', 'maxSpeed', 'friction'] },
+ * ]);
  * ```
  */
-declare function getSerializable(name: string): ComponentDescriptor | undefined;
+declare function registerComponents(registrations: readonly ComponentRegistration[]): void;
 /**
- * Gets all registered component names.
+ * Gets the currently registered components.
  *
- * @returns Array of registered component names
+ * @returns Array of component registrations
  *
  * @example
  * ```typescript
  * import { getRegisteredComponents } from 'blecsd';
  *
- * const names = getRegisteredComponents();
- * console.log(names); // ['Position', 'Velocity', 'Renderable']
- * ```
- */
-declare function getRegisteredComponents(): readonly string[];
-/**
- * Clears all registered serializable components.
- * Useful for testing.
- *
- * @example
- * ```typescript
- * import { clearSerializableRegistry } from 'blecsd';
- *
- * clearSerializableRegistry();
- * ```
- */
-declare function clearSerializableRegistry(): void;
-/**
- * Serializes ECS world state to a snapshot object.
- *
- * Only components registered via `registerSerializable` are included.
- * The snapshot can be converted to JSON with `JSON.stringify`.
- *
- * @param world - The world to serialize
- * @param options - Optional serialization options
- * @returns A serialized world snapshot
- *
- * @example
- * ```typescript
- * import { createWorld, addEntity, setPosition, serializeWorld, registerSerializable, Position } from 'blecsd';
- *
- * registerSerializable({ name: 'Position', store: Position });
- *
- * const world = createWorld();
- * const eid = addEntity(world);
- * setPosition(world, eid, 10, 20);
- *
- * const snapshot = serializeWorld(world);
- * const json = JSON.stringify(snapshot);
+ * const components = getRegisteredComponents();
+ * console.log(components.map(c => c.name));
  * ```
  */
-declare function serializeWorld(world: World, options?: SerializeOptions): SerializedWorld;
+declare function getRegisteredComponents(): readonly ComponentRegistration[];
 /**
- * Serializes ECS world state to a JSON string.
+ * Serializes a world to a snapshot.
  *
- * Convenience wrapper around `serializeWorld` + `JSON.stringify`.
- *
- * @param world - The world to serialize
- * @param options - Optional serialization options
- * @returns JSON string of the world state
+ * @param world - The ECS world to serialize
+ * @param components - Array of component registrations to serialize
+ * @returns World snapshot
  *
  * @example
  * ```typescript
- * import { createWorld, addEntity, setPosition, serializeWorldToJSON, registerSerializable, Position } from 'blecsd';
- *
- * registerSerializable({ name: 'Position', store: Position });
+ * import { createWorld, addEntity, setPosition, serializeWorld } from 'blecsd';
  *
  * const world = createWorld();
- * const eid = addEntity(world);
- * setPosition(world, eid, 10, 20);
+ * const entity = addEntity(world);
+ * setPosition(world, entity, 10, 5);
  *
- * const json = serializeWorldToJSON(world);
- * // Save to file, send over network, etc.
+ * const snapshot = serializeWorld(world, [
+ *   { name: 'Position', component: Position, fields: ['x', 'y', 'z', 'absolute'] },
+ * ]);
  * ```
  */
-declare function serializeWorldToJSON(world: World, options?: SerializeOptions): string;
+declare function serializeWorld(world: World, components: readonly ComponentRegistration[]): WorldSnapshot;
 /**
- * Deserializes a world snapshot back into an ECS world.
- *
- * Creates new entities and restores their component data from the snapshot.
- * Returns a mapping from old entity IDs to new ones for relationship fixup.
+ * Deserializes a snapshot into a new world.
  *
- * @param snapshot - The serialized world snapshot
- * @param world - The world to deserialize into
- * @param options - Optional deserialization options
- * @returns Result with the world, entity map, and statistics
+ * @param snapshot - World snapshot to deserialize
+ * @returns A new world with the snapshot data
  *
  * @example
  * ```typescript
- * import { createWorld, deserializeWorld, registerSerializable, Position } from 'blecsd';
- *
- * registerSerializable({ name: 'Position', store: Position });
- *
- * const world = createWorld();
- * const result = deserializeWorld(snapshot, world);
+ * import { deserializeWorld, getAllEntities } from 'blecsd';
  *
- * console.log(result.entityCount); // number of entities restored
- * console.log(result.entityMap); // Map<oldId, newId>
+ * const world = deserializeWorld(snapshot);
+ * const entities = getAllEntities(world);
+ * console.log(`Restored ${entities.length} entities`);
  * ```
  */
-declare function deserializeWorld(snapshot: SerializedWorld, world: World, options?: DeserializeOptions): DeserializeResult;
+declare function deserializeWorld(snapshot: WorldSnapshot): World;
 /**
- * Deserializes a JSON string back into an ECS world.
+ * Creates a delta between two snapshots.
  *
- * Convenience wrapper around JSON.parse + `deserializeWorld`.
- *
- * @param json - The JSON string to parse
- * @param world - The world to deserialize into
- * @param options - Optional deserialization options
- * @returns Result with the world, entity map, and statistics
+ * @param prev - Previous snapshot
+ * @param current - Current snapshot
+ * @returns Delta containing changes between snapshots
  *
  * @example
  * ```typescript
- * import { createWorld, deserializeWorldFromJSON, registerSerializable, Position } from 'blecsd';
- *
- * registerSerializable({ name: 'Position', store: Position });
+ * import { serializeWorld, createWorldDelta } from 'blecsd';
  *
- * const world = createWorld();
- * const result = deserializeWorldFromJSON(jsonString, world);
+ * const snapshot1 = serializeWorld(world, components);
+ * // ... modify world ...
+ * const snapshot2 = serializeWorld(world, components);
  *
- * console.log(result.entityCount);
+ * const delta = createWorldDelta(snapshot1, snapshot2);
+ * console.log(`Added: ${delta.addedEntities.length}, Removed: ${delta.removedEntities.length}`);
  * ```
  */
-declare function deserializeWorldFromJSON(json: string, world: World, options?: DeserializeOptions): DeserializeResult;
+declare function createWorldDelta(prev: WorldSnapshot, current: WorldSnapshot): WorldDelta;
 /**
- * Creates a deep clone of a serialized world snapshot.
- * Useful for creating save slots or undo history.
+ * Applies a delta to a world.
  *
- * @param snapshot - The snapshot to clone
- * @returns A new snapshot with identical data
+ * @param world - The world to apply the delta to
+ * @param delta - The delta to apply
+ * @param components - Component registrations
+ * @returns The modified world
  *
  * @example
  * ```typescript
- * import { serializeWorld, cloneSnapshot } from 'blecsd';
+ * import { applyWorldDelta } from 'blecsd';
  *
- * const snapshot = serializeWorld(world);
- * const backup = cloneSnapshot(snapshot);
+ * const world = deserializeWorld(baseSnapshot);
+ * applyWorldDelta(world, delta, components);
  * ```
  */
-declare function cloneSnapshot(snapshot: SerializedWorld): SerializedWorld;
-/** Current serialization format version */
-declare const SERIALIZATION_VERSION = 1;
+declare function applyWorldDelta(world: World, delta: WorldDelta, components: readonly ComponentRegistration[]): World;
 
 /**
  * Shrink-to-content calculation utilities.
@@ -6367,11 +7455,41 @@ declare function getComputedStyles(world: World, entities: readonly Entity[]): M
  */
 
 /**
- * Error thrown when entity validation fails.
+ * Creates an entity validation error with the given message.
+ *
+ * @param message - The error message
+ * @returns An Error with name set to 'EntityValidationError'
+ *
+ * @example
+ * ```typescript
+ * import { createEntityValidationError, isEntityValidationError } from 'blecsd';
+ *
+ * const error = createEntityValidationError('Entity 5 is missing Position');
+ * console.log(error.name); // 'EntityValidationError'
+ * console.log(isEntityValidationError(error)); // true
+ * ```
  */
-declare class EntityValidationError extends Error {
-    constructor(message: string);
-}
+declare function createEntityValidationError(message: string): Error;
+/**
+ * Type guard to check if an error is an entity validation error.
+ *
+ * @param error - The value to check
+ * @returns True if the error is an EntityValidationError
+ *
+ * @example
+ * ```typescript
+ * import { isEntityValidationError } from 'blecsd';
+ *
+ * try {
+ *   validateEntity(world, eid, [Position], 'test');
+ * } catch (error) {
+ *   if (isEntityValidationError(error)) {
+ *     console.log('Validation failed:', error.message);
+ *   }
+ * }
+ * ```
+ */
+declare function isEntityValidationError(error: unknown): error is Error;
 /**
  * Registers a component name for better error messages.
  * This is optional but recommended for clearer validation errors.
@@ -6396,7 +7514,7 @@ declare function registerComponentName(component: ComponentRef, name: string): v
  * @param eid - The entity ID to validate
  * @param requiredComponents - Array of components the entity must have
  * @param context - Context string describing where this validation is happening (e.g., "layoutSystem", "createBox")
- * @throws {EntityValidationError} If entity doesn't exist or is missing required components
+ * @throws {Error} An EntityValidationError if entity doesn't exist or is missing required components
  *
  * @example
  * ```typescript
@@ -6816,6 +7934,8 @@ interface PackedQueryAdapterConfig {
     readonly queries: readonly PackedQueryRegistration[];
     /** Initial capacity for each PackedStore (default: 64) */
     readonly initialCapacity?: number;
+    /** Synchronization strategy for scheduler integration (default: 'all') */
+    readonly syncMode?: 'all' | 'render_only';
 }
 /**
  * Extended adapter backed by PackedStores for cache-friendly iteration.
@@ -6876,6 +7996,8 @@ interface PackedQueryAdapter extends WorldAdapter {
      * @returns Frozen array of query names
      */
     readonly getRegisteredQueries: () => readonly string[];
+    /** Scheduler sync mode hint. */
+    readonly syncMode: 'all' | 'render_only';
 }
 /**
  * Zod schema for PackedQueryRegistration.
@@ -6917,6 +8039,10 @@ declare const PackedQueryAdapterConfigSchema: z.ZodObject<{
         components: z.ZodArray<z.ZodUnknown>;
     }, z.core.$strip>>;
     initialCapacity: z.ZodOptional<z.ZodNumber>;
+    syncMode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        render_only: "render_only";
+    }>>;
 }, z.core.$strip>;
 /**
  * Default adapter used when no custom adapter is registered.
@@ -6980,6 +8106,23 @@ declare function setWorldAdapter(world: World, adapter: WorldAdapter): void;
  * ```
  */
 declare function getWorldAdapter(world: World): WorldAdapter;
+/**
+ * Synchronizes the registered world adapter if it is PackedStore-backed.
+ *
+ * Safe to call unconditionally each frame/system tick. For non-packed
+ * adapters this is a no-op.
+ *
+ * @param world - The ECS world
+ *
+ * @example
+ * ```typescript
+ * import { syncWorldAdapter } from 'blecsd';
+ *
+ * // Call before systems that read adapter-backed query data
+ * syncWorldAdapter(world);
+ * ```
+ */
+declare function syncWorldAdapter(world: World): void;
 /**
  * Clears any custom adapter for a world.
  *
@@ -7036,6 +8179,13 @@ declare function clearWorldAdapter(world: World): void;
  * ```
  */
 declare function createPackedQueryAdapter(config: PackedQueryAdapterConfig): PackedQueryAdapter;
+/**
+ * Creates the default PackedQueryAdapter used for TUI acceleration.
+ *
+ * @param _initialCapacity - Deprecated, kept for API compatibility. No longer used.
+ * @returns Packed query adapter with common TUI query registrations
+ */
+declare function createDefaultPackedQueryAdapter(_initialCapacity?: number): PackedQueryAdapter;
 /**
  * Type guard to check if an adapter is a PackedQueryAdapter.
  *
@@ -7055,6 +8205,95 @@ declare function createPackedQueryAdapter(config: PackedQueryAdapterConfig): Pac
  */
 declare function isPackedQueryAdapter(adapter: WorldAdapter): adapter is PackedQueryAdapter;
 
+/**
+ * WorldStore - Utilities for world-scoped storage
+ *
+ * Provides a pattern for storing entity-associated data on the world object
+ * rather than in module-level Map singletons. This ensures:
+ * - World isolation: Each world has its own data
+ * - Memory safety: Data is cleaned up when world is destroyed
+ * - Library-first: Users can create multiple worlds without conflicts
+ * - Testability: No global state between tests
+ *
+ * @module core/worldStore
+ */
+
+/**
+ * Gets or creates a world-scoped store.
+ * Stores are Maps that live on the world object, not as module singletons.
+ *
+ * @param world - The ECS world
+ * @param key - Unique string key for this store (e.g., 'select:options')
+ * @returns A Map scoped to this world
+ *
+ * @example
+ * ```typescript
+ * // Instead of module-level singleton:
+ * // const optionsStore = new Map<Entity, SelectOption[]>();
+ *
+ * // Use world-scoped store:
+ * function getOptionsStore(world: World): Map<Entity, SelectOption[]> {
+ *   return getWorldStore(world, 'select:options');
+ * }
+ *
+ * // Usage
+ * const store = getOptionsStore(world);
+ * store.set(entity, options);
+ * ```
+ */
+declare function getWorldStore<K, V>(world: World, key: string): Map<K, V>;
+/**
+ * Gets or creates a world-scoped Set.
+ *
+ * @param world - The ECS world
+ * @param key - Unique string key for this set
+ * @returns A Set scoped to this world
+ *
+ * @example
+ * ```typescript
+ * function getActiveSpinners(world: World): Set<Entity> {
+ *   return getWorldSet(world, 'spinner:active');
+ * }
+ * ```
+ */
+declare function getWorldSet<T>(world: World, key: string): Set<T>;
+/**
+ * Cleans up all data for an entity across all world stores.
+ * Call this when an entity is removed to prevent memory leaks.
+ *
+ * @param world - The ECS world
+ * @param entity - The entity being removed
+ *
+ * @example
+ * ```typescript
+ * export function removeEntity(world: World, entity: Entity): void {
+ *   // ... remove from components ...
+ *   cleanupEntityStores(world, entity);
+ * }
+ * ```
+ */
+declare function cleanupEntityStores(world: World, entity: Entity): void;
+/**
+ * Destroys all stores for a world.
+ * Call this when destroying a world to free memory.
+ *
+ * @param world - The ECS world
+ *
+ * @example
+ * ```typescript
+ * export function destroyWorld(world: World): void {
+ *   clearWorldStores(world);
+ *   // ... other cleanup ...
+ * }
+ * ```
+ */
+declare function clearWorldStores(world: World): void;
+/**
+ * Gets all store keys for debugging/inspection.
+ * @internal
+ */
+declare function getStoreKeys(world: World): string[];
+
 /**
  * Z-order management for entity layering.
  *
@@ -7295,4 +8534,4 @@ declare function normalizeZIndices(world: World, parent: Entity): void;
  */
 declare function resetZOrder(entity: Entity): void;
 
-export { type AbsolutePosition, type AdoptEvent, type ArchetypeDefinition, type ArchetypePoolConfig, type ArchetypePoolStats, type AttachEvent, type AutoPaddingData, BUILTIN_PHASE_NAMES, type BindingMatch, type BorderDockingContext, type BorderDockingOptions, type BorderEdge, type BorderStyleType, BoxConfig, type BubbleResult, type BubbleableEvent, type BubbleableEventOptions, ButtonConfig, type CachedPosition, CheckboxConfig, type CleanupCallback, type ClickableCache, type ClipRect, type ClipStack, Clipping, type ClippingData, type ClippingOptions, type ComponentDescriptor, type ComponentResetFn, type ComputedPositionData, type ConditionContext, type ConnectionFlags, DEFAULT_NAV_BINDINGS, DEFAULT_TEXT_BINDINGS, DEFAULT_WORLD_ADAPTER, DEFAULT_Z_INDEX, type DataValue, type DeprecatedAPIMetadata, DeprecatedAPIMetadataSchema, type DeserializeOptions, type DeserializeResult, type DestroyEvent, type DestroyOptions, type DetachEvent, type DirtyStats, type DirtyTrackerData, type DockingBuffer, type DockingCell, type DynamicValue, type EffectConfig, type EffectivePaddingData, type EffectsConfig, type EmitDescendantsOptions, EmitDescendantsOptionsSchema, type EmitDescendantsResult, EmitDescendantsResultSchema, Entity, type EntityDataMap, type EntityHandle, type EntityPool, EntityValidationError, EventBus, EventMap, FormConfig, GetEntityEventBus, type HitTestOptions, type HitTestResult, INHERITING_PROPERTIES, InitPriority, type InitPriorityLevel, type InnerDimensions, type InnerPosition, InputConfig, JUNCTION_ASCII, JUNCTION_BOLD, JUNCTION_DOUBLE, JUNCTION_SINGLE, type Junction, type JunctionCharset, type KeyBinding, type KeyBindingRegistry, KeyBindingSchema, KeyBindingsArraySchema, type KeyLockFilter, type KeyLockOptions, type KeyLockState, type LazyInitFn, type LazyValue, type DirtyRect as LegacyDirtyRect, type LifecycleEvent, type LifecycleEventMap, type LifecycleEventName, ListConfig, LoopPhase, MAX_Z_INDEX, MIN_Z_INDEX, NON_INHERITING_PROPERTIES, Overflow, type OverflowValue, type PackedQueryAdapter, type PackedQueryAdapterConfig, PackedQueryAdapterConfigSchema, type PackedQueryRegistration, PackedQueryRegistrationSchema, type ParsedKey, type PerformanceIssueMetadata, PerformanceIssueMetadataSchema, type PhaseId, type PhaseManager, PositionCache, type PositionValue, PositionValueSchema, ProgressBarConfig, RadioButtonConfig, RadioSetConfig, type RecyclingSystemStats, type RelativePosition, type RemoveEvent, type ReparentEvent, type ResolvedEffect, SERIALIZATION_VERSION, type Scene, type SceneManager, type SceneTransition, ScreenConfig, SelectConfig, type SerializeOptions, type SerializedComponentData, type SerializedEntity, type SerializedWorld, type SetPositionCacheOptions, type ShrinkBox, SliderConfig, type StartupReport, type SubsystemEntry, System, type TerminalCapabilities, type TerminalTooSmallMetadata, TerminalTooSmallMetadataSchema, TextConfig, TextareaConfig, TextboxConfig, type TotalPadding, type TransitionState, type UnsupportedCapabilityMetadata, UnsupportedCapabilityMetadataSchema, type WarningEmitter, type WarningEvent, type WarningEventMap, WarningEventSchema, type WarningMetadata, WarningType, type WarningTypeValue, World, type WorldAdapter, type WorldAdapterType, ZOrder, acquireEntity, addComponent, addEntity, addIgnoredKeys, allocateEntity, applyCustomEffect, applyDisabledEffect, applyFocusEffect, applyHoverEffect, applyJunctions, applyKeyLockOptions, applyPressEffect, applyShrink, areAllKeysLocked, assertEntityAlive, bubbleEvent, calculateShrinkSize, centerPosition, clampPosition, clampToClipRect, clearAllArchetypePools, clearAllEffectConfigs, clearAllEntityData, clearAllPositionCaches, clearAllStoredStyles, clearArchetypePool, clearCapabilityCache, clearCleanupCallbacks, clearDestroyQueue, clearDockingContext, clearEffectState, clearEffects, clearEntityData, clearIgnoredKeys, clearLifecycleEventBuses, clearSerializableRegistry, clearStoredStyle, clearStyleCache, clearWorldAdapter, cloneSnapshot, computeInheritedStyle, createBorderDockingContext, createBoxEntity, createBubbleableEvent, createButtonEntity, createCheckboxEntity, createClickableCache, createClipRect, createClipStack, createEntityPool, createFadeTransition, createFormEntity, createInfiniteClipRect, createInputEntity, createKeyBindingRegistry, createKeyLockScope, createKeyLockState, createListEntity, createPackedQueryAdapter, createPhaseManager, createProgressBarEntity, createRadioButtonEntity, createRadioSetEntity, createSceneManager, createSceneSystem, createScreenEntity, createSelectEntity, createSlideTransition, createSliderEntity, createTextEntity, createTextareaEntity, createTextboxEntity, createWarningEmitter, createWorld, createWorldAdapter, deallocateEntity, defaultPhaseManager, deleteEntityData, deserializeWorld, deserializeWorldFromJSON, destroyAllChildren, destroyEntity, destroyWorld, detectAllJunctions, detectBorderStyle, detectCapabilities, detectJunctions, doesPropertyInherit, emitAdopt, emitAttach, emitDeprecatedAPIWarning, emitDescendants, emitDestroy, emitDetach, emitPerformanceWarning, emitRemove, emitReparent, emitTerminalTooSmallWarning, emitUnsupportedCapabilityWarning, entityExists, evaluateCondition, filterClickable, filterDirty, filterFocusable, filterVisible, filterVisibleDirty, findPropertySource, flushDestroyQueue, forceFullRedrawFlag, formatKey, formatKeyEvent, formatStartupReport, getAbsoluteEdges, getAbsolutePosition, getAllClickablesAt, getAllEntities, getAllEntityData, getAllHoverablesAt, getArchetypePoolStats, getAutoPadding, getBindingForAction, getBindingsForKey, getCacheGeneration, getCachedInnerHeight, getCachedInnerWidth, getChildEntities, getChildrenByZIndex, getClickableAt, getClickableCount, getClickableEntities, getClipRect, getClipRectHeight, getClipRectToAncestor, getClipRectWidth, getClipping, getComputedEffectStyle, getComputedPosition, getComputedStyles, getConnectionFlags, getCurrentClip, getDefaultStyle, getDescendantEntities, getDestroyQueueSize, getDirtyEntities, getDirtyRegionsInViewport, getDirtyStats, getEdgeCount, getEdgesAt, getEffectState, getEffectivePadding, getEffects, getEntityCount, getEntityData, getEntityDataCount, getEntityDataKeys, getEntityPoolCapacity, getGrabbedKeys, getHoverableAt, getIgnoredKeys, getInheritedProperty, getInnerDimensions, getInnerPosition, getJunctionChar, getJunctionCharset, getJunctionRenderData, getKeyLockFilter, getKeyLockState, getLifecycleEventBus, getLocalStyle, getLocalZ, getOriginalStyle, getOverflow, getPositionCache, getRecyclingStats, getRegisteredComponents, getRelativePosition, getRootEntities, getSerializable, getShrinkBox, getShrinkHeight, getShrinkWidth, getStartupReport, getStoredStyle, getTotalEffectivePadding, getTotalPadding, getWorldAdapter, getZIndex, grabKeys, hasAnyEffectApplied, hasAnyEntityData, hasAutoPadding, hasClickableAt, hasClipping, hasComponent, hasDirtyEntities, hasDisabledEffectApplied, hasEntityAutoPadding, hasEntityData, hasFocusEffectApplied, hasHoverEffectApplied, hasHoverableAt, hasPressEffectApplied, hasStoredStyle, hasValidPositionCache, hasValidStyleCache, hasZOrder, hitTest, hitTestAll, hitTestDetailed, initSubsystem, initSubsystemsUpTo, intersectClipRects, invalidateAllStyleCaches, invalidateClickableCache, invalidatePositionCache, invalidatePositionCacheTree, invalidateStyleCache, isBorderChar, isBuiltinPhase, isCacheDirty, isClipRectEmpty, isDefaultColor, isEntityAlive, isEntityDirty, isEntityValid, isJunctionChar, isKeyGrabbed, isKeyIgnored, isKeyLocked, isKeywordPosition, isMarkedForDestruction, isPackedQueryAdapter, isPercentagePosition, isPointInCachedBounds, isPointInEntity, isPointInInnerBounds, isPointVisible, isRectVisible, lazy, clearDirtyTracking as legacyClearDirtyTracking, createDirtyTracker as legacyCreateDirtyTracker, getDirtyRegions as legacyGetDirtyRegions, isCellDirty as legacyIsCellDirty, markCellDirty as legacyMarkCellDirty, markEntityDirty as legacyMarkEntityDirty, markRegionDirty as legacyMarkRegionDirty, removeEntityFromTracking as legacyRemoveEntityFromTracking, listBindings, lockAllKeys, markAllEntitiesDirty, matchEvent, matchesKey, mergeStyles, moveDown, moveUp, needsFullRedraw, normalizeZIndices, onAdopt, onAttach, onDestroy, onDetach, onRemove, onReparent, parseKeyString, parsePosition, parsePositionWithNegative, percentOffsetPosition, percentPosition, popClipRect, preallocateEntities, precomputeStyles, pushClipRect, query, queryBorder, queryContent, queryFocusable, queryHierarchy, queryInteractive, queryPadding, queryRenderable, queryScrollable, regionIntersectsDirty, registerArchetype, registerBinding, registerBindings, registerCleanupCallback, registerComponent, registerComponentName, registerEdge, registerRectBorder, registerSerializable, registerSubsystem, releaseAllGrabbedKeys, releaseEntity, releaseKeys, removeAllEffects, removeComponent, removeDisabledEffect, removeEntity, removeFocusEffect, removeHoverEffect, removeIgnoredKeys, removeLifecycleEventBus, removePressEffect, resetDisposalState, resetEntityPool, resetKeyLockState, resetSubsystems, resetWorld, resetZOrder, resizeDirtyTracker, resizeDockingContext, resolveEffectConfig, resolvePosition, resolvePositionClamped, resolveStyle, serializeWorld, serializeWorldToJSON, setAbsoluteBottom, setAbsoluteEdges, setAbsoluteLeft, setAbsolutePosition, setAbsoluteRight, setAbsoluteTop, setBack, setEffects, setEntityData, setEntityDataBulk, setFront, setIgnoredKeys, setKeyLockFilter, setLocalZ, setOverflow, setPositionCache, setRelativePosition, setWorldAdapter, setZIndex, shouldBlockKeyEvent, shouldClipContent, sortByDepth, sortByTabIndex, sortByZIndex, syncEffects, unlockAllKeys, unregisterArchetype, unregisterBinding, unregisterSerializable, updateCachedScrollBase, updateClickableCache, updateEntityBounds, updateEntityData, validateEntity, withStore };
+export { type AbsolutePosition, type ActionBinding, ActionBindingSchema, type ActionCallback, ActionPresets, type ActionState, type AdoptEvent, type ArchetypeDefinition, type ArchetypePoolConfig, type ArchetypePoolStats, type AttachEvent, type AutoPaddingData, BUILTIN_PHASE_NAMES, type BindingMatch, type BorderDockingContext, type BorderDockingOptions, type BorderEdge, type BorderStyleType, type BubbleResult, type BubbleableEvent, type BubbleableEventOptions, type CachedPosition, type ClipRect, type ClipStack, Clipping, type ClippingData, type ClippingOptions, type ComponentData, type ComponentFieldData, type ComponentRegistration, type ComponentResetFn, type ComputedGetter, type ComputedPositionData, type ComputedSignal, type ConditionContext, type ConnectionFlags, DEFAULT_NAV_BINDINGS, DEFAULT_TEXT_BINDINGS, DEFAULT_WORLD_ADAPTER, DEFAULT_Z_INDEX, type DataValue, type DeprecatedAPIMetadata, DeprecatedAPIMetadataSchema, type DestroyEvent, type DetachEvent, type DirtyStats, type DirtyTrackerData, type DockingBuffer, type DockingCell, type DynamicValue, type EffectConfig, type EffectHandle, type EffectivePaddingData, type EffectsConfig, type EmitDescendantsOptions, EmitDescendantsOptionsSchema, type EmitDescendantsResult, EmitDescendantsResultSchema, Entity, type EntityDataMap, type EntityHandle, type EntityPool, EventBus, EventMap, GetEntityEventBus, INHERITING_PROPERTIES, InitPriority, type InitPriorityLevel, type InnerDimensions, type InnerPosition, type InputActionManager, type InputBufferStats, type InputEventBufferData, type InputEventBufferOptions, type InputLatencyStats, type InputState, type InputStateConfig, type InputStateStats, JUNCTION_ASCII, JUNCTION_BOLD, JUNCTION_DOUBLE, JUNCTION_SINGLE, type Junction, type JunctionCharset, type KeyBinding, type KeyBindingRegistry, KeyBindingSchema, KeyBindingsArraySchema, type KeyLockFilter, type KeyLockOptions, type KeyLockState, type KeyState, type LazyInitFn, type LazyValue, type DirtyRect as LegacyDirtyRect, type LifecycleEvent, type LifecycleEventMap, type LifecycleEventName, LoopPhase, MAX_Z_INDEX, MIN_Z_INDEX, type MountedTree, type MouseButtonState, type MouseState, NON_INHERITING_PROPERTIES, Overflow, type OverflowValue, type PackedQueryAdapter, type PackedQueryAdapterConfig, PackedQueryAdapterConfigSchema, type PackedQueryRegistration, PackedQueryRegistrationSchema, type ParsedKey, type PerformanceIssueMetadata, PerformanceIssueMetadataSchema, type PhaseId, type PhaseManager, type Plugin, type PluginComponent, PluginComponentSchema, type PluginInfo, type PluginRegistrationResult, type PluginRegistry, PluginSchema, type PluginSystem, PluginSystemSchema, type PluginThemeDeclaration, PluginThemeDeclarationSchema, type PluginWidgetDeclaration, PluginWidgetDeclarationSchema, PositionCache, type ReactiveConfig, type ReactiveProp, type RecyclingSystemStats, type RelativePosition, type RemoveEvent, type ReparentEvent, type ResolvedEffect, type Scene, type SceneManager, type SceneTransition, Scheduler, type SerializedBindings, SerializedBindingsSchema, type SetPositionCacheOptions, type ShrinkBox, type Signal, type SignalGetter, type SignalSetter, type StartupReport, type SubsystemEntry, System, type TerminalCapabilities, type TerminalTooSmallMetadata, TerminalTooSmallMetadataSchema, type TimestampedInputEvent, type TimestampedKeyEvent, type TimestampedMouseEvent, type TotalPadding, type TransitionState, type UnsupportedCapabilityMetadata, UnsupportedCapabilityMetadataSchema, type WarningEmitter, type WarningEvent, type WarningEventMap, WarningEventSchema, type WarningMetadata, WarningType, type WarningTypeValue, type WidgetDescriptor, type WidgetType, World, type WorldAdapter, type WorldAdapterType, type WorldDelta, type WorldSnapshot, ZOrder, acquireEntity, activatePlugin, addIgnoredKeys, allocateEntity, applyCustomEffect, applyDisabledEffect, applyFocusEffect, applyHoverEffect, applyJunctions, applyKeyLockOptions, applyPressEffect, applyShrink, applyWorldDelta, areAllKeysLocked, assertEntityAlive, beginFrame, bind, bubbleEvent, calculateShrinkSize, clampToClipRect, cleanupEntityStores, clearAllArchetypePools, clearAllEffectConfigs, clearAllEntityData, clearAllPositionCaches, clearAllStoredStyles, clearArchetypePool, clearBuffer, clearCapabilityCache, clearDockingContext, clearEffectState, clearEffects, clearEntityData, clearIgnoredKeys, clearLifecycleEventBuses, clearPlugins, clearStoredStyle, clearStyleCache, clearWorldAdapter, clearWorldStores, computeInheritedStyle, createBatch, createBorderDockingContext, createBubbleableEvent, createCallbackSignal, createClipRect, createClipStack, createComputed, createDefaultPackedQueryAdapter, createDerivedSignal, createEffect, createEntityPool, createEntitySignal, createEntityValidationError, createEventSignal, createFadeTransition, createInfiniteClipRect, createInputActionManager, createInputEventBuffer, createInputState, createIntervalSignal, createKeyBindingRegistry, createKeyLockScope, createKeyLockState, createPackedQueryAdapter, createPhaseManager, createPluginRegistry, createPollingSignal, createReducerSignal, createSceneManager, createSceneSystem, createScheduledEffect, createSignal, createSlideTransition, createStreamSignal, createTimerSignal, createWarningEmitter, createWorldAdapter, createWorldDelta, deactivatePlugin, deallocateEntity, defaultPhaseManager, definePlugin, deleteEntityData, deserializeWorld, detectAllJunctions, detectBorderStyle, detectCapabilities, detectJunctions, disposeEffect, disposeSignal, doesPropertyInherit, drainAllEvents, drainKeys, drainMouse, el, elRef, emitAdopt, emitAttach, emitDeprecatedAPIWarning, emitDescendants, emitDestroy, emitDetach, emitPerformanceWarning, emitRemove, emitReparent, emitTerminalTooSmallWarning, emitUnsupportedCapabilityWarning, endFrame, evaluateCondition, filterClickable, filterDirty, filterFocusable, filterVisible, filterVisibleDirty, findPropertySource, flushScheduledEffects, forceFullRedrawFlag, formatKey, formatKeyEvent, formatStartupReport, getAbsoluteEdges, getAbsolutePosition, getAllEntityData, getArchetypePoolStats, getAutoPadding, getBindingForAction, getBindingsForKey, getCacheGeneration, getCachedInnerHeight, getCachedInnerWidth, getChildEntities, getChildrenByZIndex, getClipRect, getClipRectHeight, getClipRectToAncestor, getClipRectWidth, getClipping, getComputedEffectStyle, getComputedPosition, getComputedStyles, getConnectionFlags, getCurrentClip, getDefaultStyle, getDescendantEntities, getDirtyEntities, getDirtyRegionsInViewport, getDirtyStats, getEdgeCount, getEdgesAt, getEffectState, getEffectivePadding, getEffects, getEntityCount, getEntityData, getEntityDataCount, getEntityDataKeys, getEntityPoolCapacity, getGrabbedKeys, getIgnoredKeys, getInheritedProperty, getInnerDimensions, getInnerPosition, getJunctionChar, getJunctionCharset, getJunctionRenderData, getKeyLockFilter, getKeyLockState, getLatencyStats, getLifecycleEventBus, getLocalStyle, getLocalZ, getMovementDirection, getOriginalStyle, getOverflow, getPendingCount, getPendingKeyCount, getPendingMouseCount, getPluginCount, getPlugins, getPositionCache, getRecyclingStats, getRegisteredComponents, getRelativePosition, getRootEntities, getScheduledEffectCount, getShrinkBox, getShrinkHeight, getShrinkWidth, getStartupReport, getStats, getStoreKeys, getStoredStyle, getTotalEffectivePadding, getTotalPadding, getTotalScheduledEffectCount, getWorldAdapter, getWorldSet, getWorldStore, getZIndex, globalInputBuffer, grabKeys, hasAnyEffectApplied, hasAnyEntityData, hasAutoPadding, hasClipping, hasDirtyEntities, hasDisabledEffectApplied, hasEntityAutoPadding, hasEntityData, hasFocusEffectApplied, hasHoverEffectApplied, hasPendingEvents, hasPlugin, hasPressEffectApplied, hasStoredStyle, hasValidPositionCache, hasValidStyleCache, hasZOrder, hbox, initSubsystem, initSubsystemsUpTo, intersectClipRects, invalidateAllStyleCaches, invalidatePositionCache, invalidatePositionCacheTree, invalidateStyleCache, isAllKeysDown, isAnyKeyDown, isAnyKeyPressed, isBorderChar, isBuiltinPhase, isClipRectEmpty, isDefaultColor, isEntityAlive, isEntityDirty, isEntityValid, isEntityValidationError, isJunctionChar, isKeyGrabbed, isKeyIgnored, isKeyLocked, isLatencyAcceptable, isPackedQueryAdapter, isPluginActive, isPointInCachedBounds, isPointInEntity, isPointInInnerBounds, isPointVisible, isProcessingTimeAcceptable, isRectVisible, lazy, clearDirtyTracking as legacyClearDirtyTracking, createDirtyTracker as legacyCreateDirtyTracker, getDirtyRegions as legacyGetDirtyRegions, isCellDirty as legacyIsCellDirty, markCellDirty as legacyMarkCellDirty, markEntityDirty as legacyMarkEntityDirty, markRegionDirty as legacyMarkRegionDirty, removeEntityFromTracking as legacyRemoveEntityFromTracking, listBindings, lockAllKeys, markAllEntitiesDirty, matchEvent, matchesKey, mergeStyles, mount, moveDown, moveUp, needsFullRedraw, normalizeZIndices, onAdopt, onAttach, onDestroy, onDetach, onRemove, onReparent, parseKeyString, peekEvents, peekKeys, peekMouse, popClipRect, preallocateEntities, precomputeStyles, pushClipRect, pushKeyEvent, pushMouseEvent, queryBorder, queryContent, queryFocusable, queryHierarchy, queryInteractive, queryPadding, queryRenderable, queryScrollable, recordLatency, recordLatencyBatch, regionIntersectsDirty, registerArchetype, registerBinding, registerBindings, registerComponentName, registerComponents, registerDefaultPropSetters, registerEdge, registerPlugin, registerPropSetter, registerRectBorder, registerSubsystem, registerWidgetFactory, releaseAllGrabbedKeys, releaseEntity, releaseKeys, removeAllEffects, removeDisabledEffect, removeFocusEffect, removeHoverEffect, removeIgnoredKeys, removeLifecycleEventBus, removePressEffect, resetDeclarativeRegistrations, resetEntityPool, resetKeyLockState, resetLatencyStats, resetStats, resetSubsystems, resetZOrder, resizeDirtyTracker, resizeDockingContext, resolveEffectConfig, resolveStyle, serializeWorld, setAbsoluteBottom, setAbsoluteEdges, setAbsoluteLeft, setAbsolutePosition, setAbsoluteRight, setAbsoluteTop, setBack, setEffects, setEntityData, setEntityDataBulk, setFront, setIgnoredKeys, setKeyLockFilter, setLocalZ, setOverflow, setPositionCache, setRelativePosition, setWorldAdapter, setZIndex, shouldBlockKeyEvent, shouldClipContent, sortByDepth, sortByTabIndex, sortByZIndex, syncEffects, syncWorldAdapter, trackDependencies, unlockAllKeys, unmount, unregisterArchetype, unregisterBinding, unregisterPlugin, updateCachedScrollBase, updateEntityBounds, updateEntityData, validateEntity, validatePluginConfig, vbox };