blecsd 0.1.1 → 0.3.0

package/dist/core/index.d.ts

@@ -1,21 +1,166 @@
-import { W as World, E as Entity, L as LoopPhase, S as System } from '../types-BcsvoKzf.js';
-export { U as Unsubscribe } from '../types-BcsvoKzf.js';
+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-jTMOA-GK.js';
-export { A as ActionBinding, h as ActionBindingSchema, i as ActionCallback, j as ActionPresets, k as ActionState, B as BoxConfig, l as BoxConfigSchema, b as ButtonConfig, m as ButtonConfigSchema, C as CheckboxConfig, n as CheckboxConfigSchema, F as FormConfig, o as FormConfigSchema, p as InputActionManager, q as InputBufferStats, c as InputConfig, r as InputConfigSchema, I as InputEventBufferData, s as InputEventBufferOptions, t as InputLatencyStats, a as InputState, u as InputStateConfig, v as InputStateStats, K as KeyState, L as ListConfig, w as ListConfigSchema, M as MouseButtonState, x as MouseState, P as ProgressBarConfig, y as ProgressBarConfigSchema, R as RadioButtonConfig, z as RadioButtonConfigSchema, f as RadioSetConfig, D as RadioSetConfigSchema, E as ScreenConfig, G as ScreenConfigSchema, S as SelectConfig, H as SelectConfigSchema, J as SerializedBindings, N as SerializedBindingsSchema, g as SliderConfig, O as SliderConfigSchema, T as TextConfig, Q as TextConfigSchema, d as TextareaConfig, U as TextareaConfigSchema, e as TextboxConfig, V as TextboxConfigSchema, W as TimestampedInputEvent, X as TimestampedKeyEvent, Y as TimestampedMouseEvent, aD as beginFrame, aE as clearBuffer, Z as createBoxEntity, _ as createButtonEntity, $ as createCheckboxEntity, a0 as createFormEntity, a1 as createInputActionManager, a2 as createInputEntity, a3 as createInputEventBuffer, a4 as createInputState, a5 as createListEntity, a6 as createProgressBarEntity, a7 as createRadioButtonEntity, a8 as createRadioSetEntity, a9 as createScreenEntity, aa as createSelectEntity, ab as createSliderEntity, ac as createTextEntity, ad as createTextareaEntity, ae as createTextboxEntity, af as drainAllEvents, ag as drainKeys, ah as drainMouse, aF as endFrame, ai as getLatencyStats, aj as getMovementDirection, ak as getPendingCount, al as getPendingKeyCount, am as getPendingMouseCount, aG as getStats, an as globalInputBuffer, ao as hasPendingEvents, ap as isAllKeysDown, aq as isAnyKeyDown, ar as isAnyKeyPressed, as as isLatencyAcceptable, at as isProcessingTimeAcceptable, au as peekEvents, av as peekKeys, aw as peekMouse, ax as pushKeyEvent, ay as pushMouseEvent, az as recordLatency, aA as recordLatencyBatch, aB as resetLatencyStats, aC as resetStats } from '../inputActions-CefRUBuT.js';
-import { b as EventMap, E as EventBus } from '../events-BbbxkgvX.js';
-export { a as EventHandler, S as ScreenEventMap, U as UIEventMap, c as createEventBus } from '../events-BbbxkgvX.js';
-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-BIPW7-OY.js';
+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 { z } from 'zod';
-import { K as KeyName, b as KeyEvent } from '../keyParser-Bwm8-l7v.js';
+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';
 import { K as KeyEvent$1 } from '../program-BZaKqDKH.js';
-export { S as Scheduler, c as createScheduler, g as getDeltaTime } from '../scheduler-DcfoFuum.js';
-import '../border-D_Jb4ZJV.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 'node:stream';
 
+/**
+ * Absolute positioning helpers for screen-edge anchoring.
+ * Provides blessed-compatible aleft, aright, atop, abottom positioning.
+ * @module core/absolutePositioning
+ */
+
+/**
+ * Sets the absolute left position (distance from left edge of screen).
+ *
+ * This anchors the element to the left edge of the screen, ignoring parent positioning.
+ * Equivalent to blessed's `aleft` property.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param left - Distance from left edge of screen
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setAbsoluteLeft } from 'blecsd';
+ *
+ * // Position element 10 cells from left edge of screen
+ * setAbsoluteLeft(world, entity, 10);
+ * ```
+ */
+declare function setAbsoluteLeft(world: World, eid: Entity, left: number): Entity;
+/**
+ * Sets the absolute right position (distance from right edge of screen).
+ *
+ * This anchors the element to the right edge of the screen, ignoring parent positioning.
+ * Equivalent to blessed's `aright` property.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param right - Distance from right edge of screen
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setAbsoluteRight } from 'blecsd';
+ *
+ * // Position element 10 cells from right edge of screen
+ * setAbsoluteRight(world, entity, 10);
+ * ```
+ */
+declare function setAbsoluteRight(world: World, eid: Entity, right: number): Entity;
+/**
+ * Sets the absolute top position (distance from top edge of screen).
+ *
+ * This anchors the element to the top edge of the screen, ignoring parent positioning.
+ * Equivalent to blessed's `atop` property.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param top - Distance from top edge of screen
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setAbsoluteTop } from 'blecsd';
+ *
+ * // Position element 5 cells from top edge of screen
+ * setAbsoluteTop(world, entity, 5);
+ * ```
+ */
+declare function setAbsoluteTop(world: World, eid: Entity, top: number): Entity;
+/**
+ * Sets the absolute bottom position (distance from bottom edge of screen).
+ *
+ * This anchors the element to the bottom edge of the screen, ignoring parent positioning.
+ * Equivalent to blessed's `abottom` property.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param bottom - Distance from bottom edge of screen
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setAbsoluteBottom } from 'blecsd';
+ *
+ * // Position element 5 cells from bottom edge of screen
+ * setAbsoluteBottom(world, entity, 5);
+ * ```
+ */
+declare function setAbsoluteBottom(world: World, eid: Entity, bottom: number): Entity;
+/**
+ * Sets absolute position from all four edges.
+ *
+ * This is a convenience function that sets the position based on multiple edge distances.
+ * Uses left/top if both left/right or top/bottom are specified.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param options - Edge distances (any combination)
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setAbsoluteEdges } from 'blecsd';
+ *
+ * // Position element 10 from left, 5 from top
+ * setAbsoluteEdges(world, entity, { left: 10, top: 5 });
+ *
+ * // Position element 10 from right, 5 from bottom
+ * setAbsoluteEdges(world, entity, { right: 10, bottom: 5 });
+ * ```
+ */
+declare function setAbsoluteEdges(world: World, eid: Entity, options: {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}): Entity;
+/**
+ * Gets the current absolute edge distances for an entity.
+ *
+ * Returns distances from each edge of the screen. Useful for reading back
+ * the current positioning of an absolutely-positioned element.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Edge distances or undefined if entity has no position
+ *
+ * @example
+ * ```typescript
+ * import { getAbsoluteEdges } from 'blecsd';
+ *
+ * const edges = getAbsoluteEdges(world, entity);
+ * if (edges) {
+ *   console.log(`Left: ${edges.left}, Top: ${edges.top}`);
+ * }
+ * ```
+ */
+declare function getAbsoluteEdges(world: World, eid: Entity): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+} | undefined;
+
 /**
  * Auto-padding system for automatically adding padding inside borders.
  *
@@ -1171,8 +1316,8 @@ interface DirtyTrackerData {
     readonly dirtyCells: Uint8Array;
     /** Set of dirty entity IDs */
     readonly dirtyEntities: Set<Entity>;
-    /** Previous bounds for each entity */
-    readonly entityBounds: Map<Entity, EntityBoundsEntry>;
+    /** Previous bounds for each entity, backed by ComponentStore for cache-friendly iteration */
+    readonly entityBounds: ComponentStore<EntityBoundsEntry>;
     /** Coalesced dirty regions */
     readonly dirtyRegions: DirtyRect[];
     /** Whether regions need recalculation */
@@ -2274,6 +2419,28 @@ declare function clearEffectState(eid: Entity): void;
  */
 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.
  *
@@ -2601,11 +2768,6 @@ interface BubbleableEventOptions<T> {
  * ```
  */
 declare function createBubbleableEvent<T>(options: BubbleableEventOptions<T>): BubbleableEvent<T>;
-/**
- * Function type for getting an EventBus for a specific entity.
- * Returns undefined if the entity has no event bus.
- */
-type GetEntityEventBus<T extends EventMap> = (world: World, eid: Entity) => EventBus<T> | undefined;
 /**
  * Result of bubbling an event through the hierarchy.
  */
@@ -2656,51 +2818,102 @@ interface BubbleResult {
  * ```
  */
 declare function bubbleEvent<T, E extends EventMap>(world: World, event: BubbleableEvent<T>, getEventBus: GetEntityEventBus<E>): BubbleResult;
+
 /**
- * Creates a simple entity event bus store.
- * Useful for quickly setting up event bubbling without custom storage.
- *
- * @returns An object with methods to manage entity event buses
- *
- * @example
- * ```typescript
- * import { createEntityEventBusStore, createBubbleableEvent, bubbleEvent } from 'blecsd';
- *
- * interface MyEvents {
- *   click: BubbleableEvent<{ x: number; y: number }>;
- *   focus: BubbleableEvent<void>;
- * }
- *
- * const store = createEntityEventBusStore<MyEvents>();
- *
- * // Attach a bus to an entity
- * const bus = store.getOrCreate(buttonEntity);
- * bus.on('click', (e) => console.log('clicked!', e.payload));
- *
- * // Bubble an event
- * const event = createBubbleableEvent({
- *   type: 'click',
- *   target: buttonEntity,
- *   payload: { x: 10, y: 20 },
- * });
+ * Event propagation to descendants (downward through hierarchy).
+ * Emits events to an entity and all its children recursively.
+ * @module core/eventDescendants
+ */
+
+/**
+ * Result of emitting an event to descendants.
+ */
+interface EmitDescendantsResult {
+    /** Number of entities the event was dispatched to */
+    dispatchCount: number;
+    /** Maximum depth reached during traversal */
+    maxDepth: number;
+    /** Whether a circular reference was detected */
+    circularReferenceDetected: boolean;
+}
+/**
+ * Zod schema for EmitDescendantsResult.
+ */
+declare const EmitDescendantsResultSchema: z.ZodObject<{
+    dispatchCount: z.ZodNumber;
+    maxDepth: z.ZodNumber;
+    circularReferenceDetected: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Options for emitting events to descendants.
+ */
+interface EmitDescendantsOptions {
+    /** Maximum depth to traverse (default: Infinity) */
+    maxDepth?: number;
+    /** Whether to include the root entity (default: true) */
+    includeRoot?: boolean;
+}
+/**
+ * Zod schema for EmitDescendantsOptions.
+ */
+declare const EmitDescendantsOptionsSchema: z.ZodObject<{
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    includeRoot: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Emits an event to an entity and all its descendants in the hierarchy.
+ * Traverses the entity tree depth-first, visiting each descendant entity.
+ * Safely handles circular references by tracking visited entities.
  *
- * bubbleEvent(world, event, store.get);
- * ```
- */
-declare function createEntityEventBusStore<E extends EventMap>(): {
-    /** Get an entity's event bus (undefined if none exists) */
-    get: GetEntityEventBus<E>;
-    /** Get or create an event bus for an entity */
-    getOrCreate: (eid: Entity, createBus: () => EventBus<E>) => EventBus<E>;
-    /** Set an entity's event bus */
-    set: (eid: Entity, bus: EventBus<E>) => void;
-    /** Remove an entity's event bus */
-    delete: (eid: Entity) => boolean;
-    /** Check if an entity has an event bus */
-    has: (eid: Entity) => boolean;
-    /** Clear all stored event buses */
-    clear: () => void;
-};
+ * @typeParam T - Event map type
+ * @typeParam K - Event name type
+ * @param world - The ECS world
+ * @param eid - The root entity to start emitting from
+ * @param eventName - The name of the event to emit
+ * @param eventData - The event data to pass to handlers
+ * @param getEventBus - Function to get the event bus for an entity
+ * @param options - Optional emission configuration
+ * @returns Result with dispatch count, max depth, and circular reference detection
+ *
+ * @example
+ * ```typescript
+ * import { emitDescendants, createEventBus } from 'blecsd';
+ *
+ * // Set up entity hierarchy
+ * const parent = addEntity(world);
+ * const child1 = addEntity(world);
+ * const child2 = addEntity(world);
+ * appendChild(world, parent, child1);
+ * appendChild(world, parent, child2);
+ *
+ * // Create event buses for entities
+ * const eventBuses = new Map();
+ * eventBuses.set(parent, createEventBus());
+ * eventBuses.set(child1, createEventBus());
+ * eventBuses.set(child2, createEventBus());
+ *
+ * const getEventBus = (world, eid) => eventBuses.get(eid);
+ *
+ * // Listen for events
+ * eventBuses.get(parent).on('action', (data) => console.log('Parent:', data));
+ * eventBuses.get(child1).on('action', (data) => console.log('Child1:', data));
+ * eventBuses.get(child2).on('action', (data) => console.log('Child2:', data));
+ *
+ * // Emit to all descendants
+ * const result = emitDescendants(
+ *   world,
+ *   parent,
+ *   'action',
+ *   { type: 'activate' },
+ *   getEventBus
+ * );
+ * // Logs: "Parent: { type: 'activate' }"
+ * //       "Child1: { type: 'activate' }"
+ *       "Child2: { type: 'activate' }"
+ * // result.dispatchCount === 3
+ * ```
+ */
+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
@@ -4033,7 +4246,7 @@ interface PhaseManager {
  *
  * // Add custom phases
  * const preRender = manager.registerPhase('PRE_RENDER', LoopPhase.LAYOUT);
- * const postPhysics = manager.registerPhase('POST_PHYSICS', LoopPhase.PHYSICS);
+ * const postPhysics = manager.registerPhase('POST_PHYSICS', LoopPhase.ANIMATION);
  *
  * // Get execution order
  * console.log(manager.getPhaseOrder());
@@ -5065,7 +5278,7 @@ interface SceneTransition {
     /** Called when the transition starts */
     onStart?(world: World): void;
     /** Called each frame during the transition with progress (0-1) */
-    onUpdate?(world: World, progress: number): void;
+    onUpdate?: ((world: World, progress: number) => void) | undefined;
     /** Called when the transition completes */
     onComplete?(world: World): void;
 }
@@ -5264,27 +5477,27 @@ interface SerializedWorld {
     /** Array of serialized entities */
     readonly entities: readonly SerializedEntity[];
     /** Optional metadata attached by user */
-    readonly metadata?: Record<string, unknown>;
+    readonly metadata?: Record<string, unknown> | undefined;
 }
 /**
  * Options for serialization.
  */
 interface SerializeOptions {
     /** Only serialize entities with these IDs (default: all entities) */
-    readonly entityFilter?: readonly Entity[];
+    readonly entityFilter?: readonly Entity[] | undefined;
     /** Only serialize these components by name (default: all registered) */
-    readonly componentFilter?: readonly string[];
+    readonly componentFilter?: readonly string[] | undefined;
     /** Metadata to include in the snapshot */
-    readonly metadata?: Record<string, unknown>;
+    readonly metadata?: Record<string, unknown> | undefined;
 }
 /**
  * Options for deserialization.
  */
 interface DeserializeOptions {
     /** If true, clear the world before loading (default: false) */
-    readonly clearWorld?: boolean;
+    readonly clearWorld?: boolean | undefined;
     /** If true, create a new world instead of modifying the given one (default: false) */
-    readonly createNew?: boolean;
+    readonly createNew?: boolean | undefined;
 }
 /**
  * Result of deserialization.
@@ -5722,196 +5935,6 @@ declare function getEntityPoolCapacity(pool: EntityPool): number;
  */
 declare function assertEntityAlive(pool: EntityPool, handle: EntityHandle): void;
 
-/**
- * Packed Store: Cache-friendly storage with stable handles
- *
- * Implements the three-vector pattern for O(1) add/remove operations
- * with stable identifiers and cache-friendly iteration:
- *
- * - data[]: Dense contiguous storage for actual values
- * - dataIndex[]: Maps handle index → position in data array
- * - id[]: Maps position in data → handle index (inverse mapping)
- * - generations[]: Tracks generation at each slot for stale handle detection
- *
- * @module core/storage/packedStore
- */
-/**
- * Handle to an element in a packed store.
- * The combination of index and generation ensures handles
- * become invalid after the element is removed.
- */
-interface PackedHandle {
-    readonly index: number;
-    readonly gen: number;
-}
-/**
- * Packed store state. All arrays are parallel structures
- * that work together to provide stable handles with O(1) operations.
- */
-interface PackedStore<T> {
-    /** Dense contiguous data array for cache-friendly iteration */
-    readonly data: T[];
-    /** Maps handle index → position in data array */
-    readonly dataIndex: Int32Array;
-    /** Maps data position → handle index (inverse of dataIndex) */
-    readonly id: Int32Array;
-    /** Generation counter for each slot (bumped on removal) */
-    readonly generations: Uint32Array;
-    /** Number of live elements */
-    size: number;
-    /** Total allocated capacity */
-    capacity: number;
-}
-/**
- * Creates a new packed store with optional initial capacity.
- *
- * @param initialCapacity - Initial capacity hint (default 64)
- * @returns Empty packed store
- *
- * @example
- * ```typescript
- * import { createPackedStore, addToStore } from 'blecsd';
- *
- * interface Particle { x: number; y: number; vx: number; vy: number; }
- * const particles = createPackedStore<Particle>();
- * const handle = addToStore(particles, { x: 0, y: 0, vx: 1, vy: 0 });
- * ```
- */
-declare function createPackedStore<T>(initialCapacity?: number): PackedStore<T>;
-/**
- * Adds a value to the packed store and returns a stable handle.
- *
- * If there are freed slots from prior deletions, one is reused.
- * Otherwise, capacity is expanded as needed.
- *
- * @param store - The packed store
- * @param value - Value to add
- * @returns Handle to the stored value
- *
- * @example
- * ```typescript
- * const handle = addToStore(store, { name: 'entity1' });
- * // handle.index is stable even after other elements are removed
- * ```
- */
-declare function addToStore<T>(store: PackedStore<T>, value: T): PackedHandle;
-/**
- * Checks if a handle is valid (points to a live element).
- *
- * @param store - The packed store
- * @param handle - Handle to validate
- * @returns True if the handle points to a live element
- *
- * @example
- * ```typescript
- * if (isValidHandle(store, handle)) {
- *   const value = getFromStore(store, handle);
- * }
- * ```
- */
-declare function isValidHandle<T>(store: PackedStore<T>, handle: PackedHandle): boolean;
-/**
- * Gets the value associated with a handle.
- *
- * @param store - The packed store
- * @param handle - Handle to the element
- * @returns The value, or undefined if handle is invalid
- *
- * @example
- * ```typescript
- * const particle = getFromStore(particles, handle);
- * if (particle) {
- *   console.log(particle.x, particle.y);
- * }
- * ```
- */
-declare function getFromStore<T>(store: PackedStore<T>, handle: PackedHandle): T | undefined;
-/**
- * Sets (replaces) the value at a handle.
- *
- * @param store - The packed store
- * @param handle - Handle to the element
- * @param value - New value
- * @returns True if successful, false if handle is invalid
- */
-declare function setInStore<T>(store: PackedStore<T>, handle: PackedHandle, value: T): boolean;
-/**
- * Removes an element from the packed store using swap-and-pop.
- *
- * The handle becomes invalid after removal. Any other handles
- * remain valid (this is the key benefit of the three-vector pattern).
- *
- * @param store - The packed store
- * @param handle - Handle to remove
- * @returns True if removed, false if handle was invalid
- *
- * @example
- * ```typescript
- * removeFromStore(particles, handle);
- * // handle is now invalid, but other handles remain valid
- * ```
- */
-declare function removeFromStore<T>(store: PackedStore<T>, handle: PackedHandle): boolean;
-/**
- * Clears all elements from the store but retains capacity.
- *
- * @param store - The packed store to clear
- */
-declare function clearStore<T>(store: PackedStore<T>): void;
-/**
- * Iterates over all live elements in the store.
- * Iteration is cache-friendly as it traverses the dense data array.
- *
- * @param store - The packed store
- * @param fn - Callback for each element (receives value and handle)
- *
- * @example
- * ```typescript
- * forEachInStore(particles, (particle, handle) => {
- *   particle.x += particle.vx;
- *   particle.y += particle.vy;
- * });
- * ```
- */
-declare function forEachInStore<T>(store: PackedStore<T>, fn: (value: T, handle: PackedHandle) => void): void;
-/**
- * Maps over all live elements, producing a new array.
- *
- * @param store - The packed store
- * @param fn - Transform function
- * @returns Array of transformed values
- */
-declare function mapStore<T, U>(store: PackedStore<T>, fn: (value: T, handle: PackedHandle) => U): U[];
-/**
- * Returns the dense data array for direct iteration.
- * This is the fastest way to iterate when you don't need handles.
- *
- * WARNING: Do not modify the array structure (push/pop/splice).
- * The returned array is a view into internal storage.
- *
- * @param store - The packed store
- * @returns Readonly view of the dense data array (length = store.size)
- *
- * @example
- * ```typescript
- * // Fastest iteration when handles aren't needed
- * const data = getStoreData(particles);
- * for (let i = 0; i < particles.size; i++) {
- *   const p = data[i];
- *   p.x += p.vx;
- * }
- * ```
- */
-declare function getStoreData<T>(store: PackedStore<T>): readonly T[];
-/**
- * Gets the current number of live elements.
- */
-declare function getStoreSize<T>(store: PackedStore<T>): number;
-/**
- * Gets the current capacity (including freed slots).
- */
-declare function getStoreCapacity<T>(store: PackedStore<T>): number;
-
 /**
  * Archetype-based Entity Pool: Pre-allocated entity recycling per component archetype
  *
@@ -6335,6 +6358,360 @@ declare function precomputeStyles(world: World, entities: readonly Entity[]): vo
  */
 declare function getComputedStyles(world: World, entities: readonly Entity[]): Map<Entity, StyleData>;
 
+/**
+ * Entity and component validation utilities
+ *
+ * Provides helpful error messages when components are missing or entities are invalid.
+ *
+ * @module core/validation
+ */
+
+/**
+ * Error thrown when entity validation fails.
+ */
+declare class EntityValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Registers a component name for better error messages.
+ * This is optional but recommended for clearer validation errors.
+ *
+ * @param component - The component to register
+ * @param name - The human-readable name for the component
+ *
+ * @example
+ * ```typescript
+ * import { registerComponentName, Position, Velocity } from 'blecsd';
+ *
+ * registerComponentName(Position, 'Position');
+ * registerComponentName(Velocity, 'Velocity');
+ * ```
+ */
+declare function registerComponentName(component: ComponentRef, name: string): void;
+/**
+ * Validates that an entity exists and has all required components.
+ * Throws a descriptive error if validation fails.
+ *
+ * @param world - The ECS world
+ * @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
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity, validateEntity, Position, Velocity } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * // This will throw because entity is missing Position and Velocity
+ * try {
+ *   validateEntity(world, entity, [Position, Velocity], 'movementSystem');
+ * } catch (error) {
+ *   console.error(error.message);
+ *   // "Entity 0 is missing required components for movementSystem: Position, Velocity.
+ *   //  Did you forget to call addComponent(world, eid, Position)?"
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity, addComponent, validateEntity, Position } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ * addComponent(world, entity, Position);
+ *
+ * // This passes - no error thrown
+ * validateEntity(world, entity, [Position], 'renderSystem');
+ * ```
+ */
+declare function validateEntity(world: World, eid: Entity, requiredComponents: ComponentRef[], context: string): void;
+/**
+ * Validates that an entity exists and has all required components.
+ * Returns true if valid, false if invalid (does not throw).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID to validate
+ * @param requiredComponents - Array of components the entity must have
+ * @returns True if entity exists and has all required components, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity, addComponent, isEntityValid, Position, Velocity } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ * addComponent(world, entity, Position);
+ *
+ * console.log(isEntityValid(world, entity, [Position])); // true
+ * console.log(isEntityValid(world, entity, [Position, Velocity])); // false
+ * ```
+ */
+declare function isEntityValid(world: World, eid: Entity, requiredComponents: ComponentRef[]): boolean;
+
+/**
+ * Warning system for non-fatal screen issues.
+ *
+ * Provides typed warnings for terminal/screen issues like small sizes,
+ * unsupported capabilities, deprecated APIs, and performance problems.
+ *
+ * @module core/warnings
+ *
+ * @example
+ * ```typescript
+ * import { createWarningEmitter, WarningType } from 'blecsd';
+ *
+ * const warnings = createWarningEmitter();
+ *
+ * warnings.on('warning', (event) => {
+ *   console.warn(`[${event.type}] ${event.message}`);
+ * });
+ *
+ * // Emit a warning
+ * warnings.emit('warning', {
+ *   type: WarningType.TERMINAL_TOO_SMALL,
+ *   message: 'Terminal size is very small',
+ *   metadata: { width: 20, height: 10, minWidth: 80, minHeight: 24 },
+ *   timestamp: Date.now(),
+ * });
+ * ```
+ */
+
+/**
+ * Warning type enumeration.
+ */
+declare const WarningType: {
+    /** Terminal resized to very small dimensions */
+    readonly TERMINAL_TOO_SMALL: "terminal-too-small";
+    /** Requested terminal capability is not supported */
+    readonly UNSUPPORTED_CAPABILITY: "unsupported-capability";
+    /** Using deprecated API */
+    readonly DEPRECATED_API: "deprecated-api";
+    /** Performance issue detected (frame drops) */
+    readonly PERFORMANCE_ISSUE: "performance-issue";
+};
+type WarningTypeValue = (typeof WarningType)[keyof typeof WarningType];
+/**
+ * Metadata for terminal too small warnings.
+ */
+interface TerminalTooSmallMetadata {
+    readonly width: number;
+    readonly height: number;
+    readonly minWidth: number;
+    readonly minHeight: number;
+}
+/**
+ * Metadata for unsupported capability warnings.
+ */
+interface UnsupportedCapabilityMetadata {
+    readonly capability: string;
+    readonly fallback?: string | undefined;
+}
+/**
+ * Metadata for deprecated API warnings.
+ */
+interface DeprecatedAPIMetadata {
+    readonly api: string;
+    readonly replacement: string;
+    readonly since: string;
+}
+/**
+ * Metadata for performance warnings.
+ */
+interface PerformanceIssueMetadata {
+    readonly metric: string;
+    readonly value: number;
+    readonly threshold: number;
+    readonly frameTime?: number | undefined;
+}
+/**
+ * Union type for warning metadata.
+ */
+type WarningMetadata = TerminalTooSmallMetadata | UnsupportedCapabilityMetadata | DeprecatedAPIMetadata | PerformanceIssueMetadata;
+/**
+ * Warning event payload.
+ */
+interface WarningEvent {
+    readonly type: WarningTypeValue;
+    readonly message: string;
+    readonly metadata: WarningMetadata;
+    readonly timestamp: number;
+}
+/**
+ * Zod schema for terminal too small metadata.
+ */
+declare const TerminalTooSmallMetadataSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    minWidth: z.ZodNumber;
+    minHeight: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Zod schema for unsupported capability metadata.
+ */
+declare const UnsupportedCapabilityMetadataSchema: z.ZodObject<{
+    capability: z.ZodString;
+    fallback: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod schema for deprecated API metadata.
+ */
+declare const DeprecatedAPIMetadataSchema: z.ZodObject<{
+    api: z.ZodString;
+    replacement: z.ZodString;
+    since: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Zod schema for performance issue metadata.
+ */
+declare const PerformanceIssueMetadataSchema: z.ZodObject<{
+    metric: z.ZodString;
+    value: z.ZodNumber;
+    threshold: z.ZodNumber;
+    frameTime: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Zod schema for warning events.
+ */
+declare const WarningEventSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        "terminal-too-small": "terminal-too-small";
+        "unsupported-capability": "unsupported-capability";
+        "deprecated-api": "deprecated-api";
+        "performance-issue": "performance-issue";
+    }>;
+    message: z.ZodString;
+    metadata: z.ZodUnion<readonly [z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        minWidth: z.ZodNumber;
+        minHeight: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        capability: z.ZodString;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        api: z.ZodString;
+        replacement: z.ZodString;
+        since: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        metric: z.ZodString;
+        value: z.ZodNumber;
+        threshold: z.ZodNumber;
+        frameTime: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Warning event map for typed event bus.
+ */
+interface WarningEventMap {
+    warning: WarningEvent;
+}
+/**
+ * Warning emitter type.
+ */
+type WarningEmitter = EventBus<WarningEventMap>;
+/**
+ * Creates a new warning event emitter.
+ *
+ * @returns A new warning emitter
+ *
+ * @example
+ * ```typescript
+ * import { createWarningEmitter } from 'blecsd';
+ *
+ * const warnings = createWarningEmitter();
+ *
+ * // Listen for all warnings
+ * warnings.on('warning', (event) => {
+ *   console.warn(`Warning: ${event.message}`);
+ * });
+ * ```
+ */
+declare function createWarningEmitter(): WarningEmitter;
+/**
+ * Creates and emits a terminal too small warning.
+ *
+ * @param emitter - The warning emitter
+ * @param width - Current terminal width
+ * @param height - Current terminal height
+ * @param minWidth - Minimum recommended width
+ * @param minHeight - Minimum recommended height
+ *
+ * @example
+ * ```typescript
+ * import { emitTerminalTooSmallWarning } from 'blecsd';
+ *
+ * emitTerminalTooSmallWarning(warnings, 40, 15, 80, 24);
+ * ```
+ */
+declare function emitTerminalTooSmallWarning(emitter: WarningEmitter, width: number, height: number, minWidth: number, minHeight: number): void;
+/**
+ * Creates and emits an unsupported capability warning.
+ *
+ * @param emitter - The warning emitter
+ * @param capability - The unsupported capability name
+ * @param fallback - Optional fallback description
+ *
+ * @example
+ * ```typescript
+ * import { emitUnsupportedCapabilityWarning } from 'blecsd';
+ *
+ * emitUnsupportedCapabilityWarning(
+ *   warnings,
+ *   'truecolor',
+ *   'Falling back to 256-color mode'
+ * );
+ * ```
+ */
+declare function emitUnsupportedCapabilityWarning(emitter: WarningEmitter, capability: string, fallback?: string): void;
+/**
+ * Creates and emits a deprecated API warning.
+ *
+ * @param emitter - The warning emitter
+ * @param api - The deprecated API name
+ * @param replacement - The replacement API
+ * @param since - Version since deprecated
+ *
+ * @example
+ * ```typescript
+ * import { emitDeprecatedAPIWarning } from 'blecsd';
+ *
+ * emitDeprecatedAPIWarning(
+ *   warnings,
+ *   'oldFunction()',
+ *   'newFunction()',
+ *   'v2.0.0'
+ * );
+ * ```
+ */
+declare function emitDeprecatedAPIWarning(emitter: WarningEmitter, api: string, replacement: string, since: string): void;
+/**
+ * Creates and emits a performance issue warning.
+ *
+ * @param emitter - The warning emitter
+ * @param metric - The performance metric name
+ * @param value - The measured value
+ * @param threshold - The threshold value
+ * @param frameTime - Optional frame time in milliseconds
+ *
+ * @example
+ * ```typescript
+ * import { emitPerformanceWarning } from 'blecsd';
+ *
+ * emitPerformanceWarning(
+ *   warnings,
+ *   'frame-time',
+ *   35,
+ *   16.67,
+ *   35
+ * );
+ * ```
+ */
+declare function emitPerformanceWarning(emitter: WarningEmitter, metric: string, value: number, threshold: number, frameTime?: number): void;
+
 /**
  * World adapter API for custom storage and query strategies.
  *
@@ -6360,6 +6737,9 @@ type WorldAdapterType = 'bitecs' | 'custom';
 /**
  * World adapter interface.
  *
+ * The base interface provides `queryRenderables` for backwards compatibility.
+ * Adapters may optionally support named queries via `queryByName`.
+ *
  * @example
  * ```typescript
  * import type { WorldAdapter } from 'blecsd';
@@ -6380,7 +6760,164 @@ interface WorldAdapter {
      * @returns Array of renderable entities
      */
     readonly queryRenderables: (world: World) => readonly Entity[];
+    /**
+     * Returns entities matching a named query, or undefined if
+     * the query name is not registered.
+     *
+     * Only available on adapters that support named queries
+     * (e.g. PackedQueryAdapter).
+     *
+     * @param name - The query name
+     * @param world - The ECS world
+     * @returns Array of entities, or undefined if query not registered
+     */
+    readonly queryByName?: (name: string, world: World) => readonly Entity[] | undefined;
+}
+/**
+ * Registration entry for a named PackedStore-backed query.
+ *
+ * @example
+ * ```typescript
+ * import type { PackedQueryRegistration } from 'blecsd';
+ * import { Position, Renderable } from 'blecsd';
+ *
+ * const reg: PackedQueryRegistration = {
+ *   name: 'renderables',
+ *   components: [Position, Renderable],
+ * };
+ * ```
+ */
+interface PackedQueryRegistration {
+    /** Unique name for the query */
+    readonly name: string;
+    /** Component set that defines the query */
+    readonly components: readonly QueryTerm[];
 }
+/**
+ * Configuration for creating a PackedQueryAdapter.
+ *
+ * @example
+ * ```typescript
+ * import type { PackedQueryAdapterConfig } from 'blecsd';
+ * import { Focusable, Interactive, Position, Renderable } from 'blecsd';
+ *
+ * const config: PackedQueryAdapterConfig = {
+ *   queries: [
+ *     { name: 'renderables', components: [Position, Renderable] },
+ *     { name: 'focusable', components: [Focusable] },
+ *     { name: 'interactive', components: [Interactive] },
+ *   ],
+ *   initialCapacity: 128,
+ * };
+ * ```
+ */
+interface PackedQueryAdapterConfig {
+    /** Named queries to register */
+    readonly queries: readonly PackedQueryRegistration[];
+    /** Initial capacity for each PackedStore (default: 64) */
+    readonly initialCapacity?: number;
+}
+/**
+ * Extended adapter backed by PackedStores for cache-friendly iteration.
+ *
+ * Maintains a PackedStore<number> per registered query, updated via sync().
+ * Use getQueryData/getQuerySize for zero-allocation hot-path iteration.
+ *
+ * @example
+ * ```typescript
+ * import { createPackedQueryAdapter, Position, Renderable, Focusable } from 'blecsd';
+ *
+ * const adapter = createPackedQueryAdapter({
+ *   queries: [
+ *     { name: 'renderables', components: [Position, Renderable] },
+ *     { name: 'focusable', components: [Focusable] },
+ *   ],
+ * });
+ *
+ * // Each frame: sync, then query
+ * adapter.sync(world);
+ * const data = adapter.getQueryData('focusable');
+ * for (let i = 0; i < adapter.getQuerySize('focusable'); i++) {
+ *   const eid = data[i];
+ *   // Process entity...
+ * }
+ * ```
+ */
+interface PackedQueryAdapter extends WorldAdapter {
+    /** Looks up entities by registered query name. Returns undefined for unknown names. */
+    readonly queryByName: (name: string, world: World) => readonly Entity[] | undefined;
+    /**
+     * Synchronizes all PackedStores with current bitecs query results.
+     * Call once per frame before querying.
+     *
+     * @param world - The ECS world
+     */
+    readonly sync: (world: World) => void;
+    /**
+     * Returns the dense data array for a named query (zero-allocation hot path).
+     * Only elements at indices 0 through getQuerySize(name) - 1 are live.
+     * Returns a frozen empty array for unknown query names.
+     *
+     * @param name - The query name
+     * @returns Dense array of entity IDs
+     */
+    readonly getQueryData: (name: string) => readonly number[];
+    /**
+     * Returns the number of entities in a named query's PackedStore.
+     * Returns 0 for unknown query names.
+     *
+     * @param name - The query name
+     * @returns Entity count
+     */
+    readonly getQuerySize: (name: string) => number;
+    /**
+     * Returns all registered query names.
+     *
+     * @returns Frozen array of query names
+     */
+    readonly getRegisteredQueries: () => readonly string[];
+}
+/**
+ * Zod schema for PackedQueryRegistration.
+ *
+ * Validates the structural shape of a query registration.
+ * Component references (QueryTerm) are opaque to Zod and validated
+ * as unknown[].
+ *
+ * @example
+ * ```typescript
+ * import { PackedQueryRegistrationSchema } from 'blecsd';
+ *
+ * const result = PackedQueryRegistrationSchema.safeParse({
+ *   name: 'renderables',
+ *   components: [Position, Renderable],
+ * });
+ * ```
+ */
+declare const PackedQueryRegistrationSchema: z.ZodObject<{
+    name: z.ZodString;
+    components: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Zod schema for PackedQueryAdapterConfig.
+ *
+ * @example
+ * ```typescript
+ * import { PackedQueryAdapterConfigSchema } from 'blecsd';
+ *
+ * const result = PackedQueryAdapterConfigSchema.safeParse({
+ *   queries: [{ name: 'renderables', components: [Position, Renderable] }],
+ *   initialCapacity: 128,
+ * });
+ * ```
+ */
+declare const PackedQueryAdapterConfigSchema: z.ZodObject<{
+    queries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        components: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    initialCapacity: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 /**
  * Default adapter used when no custom adapter is registered.
  *
@@ -6456,6 +6993,67 @@ declare function getWorldAdapter(world: World): WorldAdapter;
  * ```
  */
 declare function clearWorldAdapter(world: World): void;
+/**
+ * Creates a PackedQueryAdapter backed by PackedStores for cache-friendly iteration.
+ *
+ * Each registered query gets its own PackedStore<number> holding entity IDs.
+ * Call sync(world) once per frame to reconcile stores with bitecs query results,
+ * then use queryByName, getQueryData, or getQuerySize to read results.
+ *
+ * If no 'renderables' query is registered, one is auto-registered with
+ * [Position, Renderable] to maintain backwards compatibility with queryRenderables.
+ *
+ * @param config - Adapter configuration with named queries
+ * @returns A PackedQueryAdapter
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createPackedQueryAdapter,
+ *   setWorldAdapter,
+ *   Position,
+ *   Renderable,
+ *   Focusable,
+ * } from 'blecsd';
+ *
+ * const adapter = createPackedQueryAdapter({
+ *   queries: [
+ *     { name: 'renderables', components: [Position, Renderable] },
+ *     { name: 'focusable', components: [Focusable] },
+ *   ],
+ *   initialCapacity: 256,
+ * });
+ *
+ * setWorldAdapter(world, adapter);
+ *
+ * // Each frame:
+ * adapter.sync(world);
+ * const data = adapter.getQueryData('focusable');
+ * for (let i = 0; i < adapter.getQuerySize('focusable'); i++) {
+ *   const eid = data[i];
+ *   // Process entity in dense cache-friendly order
+ * }
+ * ```
+ */
+declare function createPackedQueryAdapter(config: PackedQueryAdapterConfig): PackedQueryAdapter;
+/**
+ * Type guard to check if an adapter is a PackedQueryAdapter.
+ *
+ * @param adapter - The adapter to check
+ * @returns True if the adapter is a PackedQueryAdapter
+ *
+ * @example
+ * ```typescript
+ * import { getWorldAdapter, isPackedQueryAdapter } from 'blecsd';
+ *
+ * const adapter = getWorldAdapter(world);
+ * if (isPackedQueryAdapter(adapter)) {
+ *   adapter.sync(world);
+ *   const data = adapter.getQueryData('renderables');
+ * }
+ * ```
+ */
+declare function isPackedQueryAdapter(adapter: WorldAdapter): adapter is PackedQueryAdapter;
 
 /**
  * Z-order management for entity layering.
@@ -6697,4 +7295,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, type BubbleResult, type BubbleableEvent, type BubbleableEventOptions, type CachedPosition, 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 DeserializeOptions, type DeserializeResult, type DestroyEvent, type DestroyOptions, type DetachEvent, type DirtyRect, type DirtyStats, type DirtyTrackerData, type DockingBuffer, type DockingCell, type DynamicValue, type EffectConfig, type EffectivePaddingData, type EffectsConfig, Entity, type EntityDataMap, type EntityHandle, type EntityPool, EventBus, EventMap, type GetEntityEventBus, type HitTestOptions, type HitTestResult, INHERITING_PROPERTIES, InitPriority, type InitPriorityLevel, type InnerDimensions, type InnerPosition, 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 LifecycleEvent, type LifecycleEventMap, type LifecycleEventName, LoopPhase, MAX_Z_INDEX, MIN_Z_INDEX, NON_INHERITING_PROPERTIES, Overflow, type OverflowValue, type PackedHandle, type PackedStore, type ParsedKey, type PhaseId, type PhaseManager, PositionCache, type PositionValue, PositionValueSchema, type RecyclingSystemStats, type RelativePosition, type RemoveEvent, type ReparentEvent, type ResolvedEffect, SERIALIZATION_VERSION, type Scene, type SceneManager, type SceneTransition, type SerializeOptions, type SerializedComponentData, type SerializedEntity, type SerializedWorld, type SetPositionCacheOptions, type ShrinkBox, type StartupReport, type SubsystemEntry, System, type TerminalCapabilities, type TotalPadding, type TransitionState, World, type WorldAdapter, type WorldAdapterType, ZOrder, acquireEntity, addComponent, addEntity, addIgnoredKeys, addToStore, 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, clearDirtyTracking, clearDockingContext, clearEffectState, clearEffects, clearEntityData, clearIgnoredKeys, clearLifecycleEventBuses, clearSerializableRegistry, clearStore, clearStoredStyle, clearStyleCache, clearWorldAdapter, cloneSnapshot, computeInheritedStyle, createBorderDockingContext, createBubbleableEvent, createClickableCache, createClipRect, createClipStack, createDirtyTracker, createEntityEventBusStore, createEntityPool, createFadeTransition, createInfiniteClipRect, createKeyBindingRegistry, createKeyLockScope, createKeyLockState, createPackedStore, createPhaseManager, createSceneManager, createSceneSystem, createSlideTransition, createWorld, createWorldAdapter, deallocateEntity, defaultPhaseManager, deleteEntityData, deserializeWorld, deserializeWorldFromJSON, destroyAllChildren, destroyEntity, destroyWorld, detectAllJunctions, detectBorderStyle, detectCapabilities, detectJunctions, doesPropertyInherit, emitAdopt, emitAttach, emitDestroy, emitDetach, emitRemove, emitReparent, entityExists, evaluateCondition, filterClickable, filterDirty, filterFocusable, filterVisible, filterVisibleDirty, findPropertySource, flushDestroyQueue, forEachInStore, forceFullRedrawFlag, formatKey, formatKeyEvent, formatStartupReport, 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, getDirtyRegions, getDirtyRegionsInViewport, getDirtyStats, getEdgeCount, getEdgesAt, getEffectState, getEffectivePadding, getEffects, getEntityCount, getEntityData, getEntityDataCount, getEntityDataKeys, getEntityPoolCapacity, getFromStore, 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, getStoreCapacity, getStoreData, getStoreSize, 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, isCellDirty, isClipRectEmpty, isDefaultColor, isEntityAlive, isEntityDirty, isJunctionChar, isKeyGrabbed, isKeyIgnored, isKeyLocked, isKeywordPosition, isMarkedForDestruction, isPercentagePosition, isPointInCachedBounds, isPointInEntity, isPointInInnerBounds, isPointVisible, isRectVisible, isValidHandle, lazy, listBindings, lockAllKeys, mapStore, markAllEntitiesDirty, markCellDirty, markEntityDirty, markRegionDirty, 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, registerEdge, registerRectBorder, registerSerializable, registerSubsystem, releaseAllGrabbedKeys, releaseEntity, releaseKeys, removeAllEffects, removeComponent, removeDisabledEffect, removeEntity, removeEntityFromTracking, removeFocusEffect, removeFromStore, removeHoverEffect, removeIgnoredKeys, removeLifecycleEventBus, removePressEffect, resetDisposalState, resetEntityPool, resetKeyLockState, resetSubsystems, resetWorld, resetZOrder, resizeDirtyTracker, resizeDockingContext, resolveEffectConfig, resolvePosition, resolvePositionClamped, resolveStyle, serializeWorld, serializeWorldToJSON, setAbsolutePosition, setBack, setEffects, setEntityData, setEntityDataBulk, setFront, setIgnoredKeys, setInStore, setKeyLockFilter, setLocalZ, setOverflow, setPositionCache, setRelativePosition, setWorldAdapter, setZIndex, shouldBlockKeyEvent, shouldClipContent, sortByDepth, sortByTabIndex, sortByZIndex, syncEffects, unlockAllKeys, unregisterArchetype, unregisterBinding, unregisterSerializable, updateCachedScrollBase, updateClickableCache, updateEntityBounds, updateEntityData, withStore };
+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 };