ecspresso 0.10.2 → 0.11.0

package/README.md

@@ -20,6 +20,7 @@ A type-safe, modular, and extensible Entity Component System (ECS) framework for
 - **Reactive Queries**: Enter/exit callbacks when entities match or unmatch queries
 - **System Groups**: Enable/disable groups of systems at runtime
 - **Component Lifecycle**: Callbacks for component add/remove with unsubscribe support
+- **Required Components**: Auto-add dependent components on spawn/addComponent (e.g. `localTransform` implies `worldTransform`)
 - **Command Buffer**: Deferred structural changes for safe entity/component operations during systems
 - **Timer Bundle**: ECS-native timers with event-based completion notifications
 
@@ -47,7 +48,7 @@ npm install ecspresso
 - [Entity Hierarchy](#entity-hierarchy) -- [Traversal](#traversal), [Parent-First Traversal](#parent-first-traversal), [Cascade Deletion](#cascade-deletion)
 - [Change Detection](#change-detection) -- [Marking Changes](#marking-changes), [Changed Query Filter](#changed-query-filter), [Sequence Timing](#sequence-timing)
 - [Command Buffer](#command-buffer) -- [Available Commands](#available-commands)
-- [Bundles](#bundles) -- [Built-in Bundles](#built-in-bundles), [Timer Bundle](#timer-bundle)
+- [Bundles](#bundles) -- [Required Components](#required-components), [Built-in Bundles](#built-in-bundles), [Timer Bundle](#timer-bundle)
 - [Asset Management](#asset-management)
 - [Screen Management](#screen-management) -- [Screen-Scoped Systems](#screen-scoped-systems), [Screen Resource](#screen-resource)
 - [Type Safety](#type-safety)
@@ -107,7 +108,7 @@ const entity = world.spawn({
 // Add components later
 world.entityManager.addComponent(entity.id, 'velocity', { x: 5, y: 0 });
 
-// Get component data (returns null if not found)
+// Get component data (returns undefined if not found)
 const position = world.entityManager.getComponent(entity.id, 'position');
 
 // Remove components or entities
@@ -687,16 +688,66 @@ const game = ECSpresso.create<GameComponents, {}, GameResources>()
   .build();
 ```
 
+### Required Components
+
+Bundles can declare that certain components depend on others. When an entity gains a trigger component, any required components that aren't already present are auto-added with default values:
+
+```typescript
+const transformBundle = new Bundle<TransformComponents>('transform')
+  .registerRequired('localTransform', 'worldTransform', () => ({
+    x: 0, y: 0, rotation: 0, scaleX: 1, scaleY: 1,
+  }));
+
+const world = ECSpresso.create()
+  .withBundle(transformBundle)
+  .build();
+
+// worldTransform is auto-added with defaults
+const entity = world.spawn({
+  localTransform: { x: 100, y: 200, rotation: 0, scaleX: 1, scaleY: 1 },
+});
+
+// Explicit values always win — no auto-add if already provided
+const entity2 = world.spawn({
+  localTransform: { x: 100, y: 200, rotation: 0, scaleX: 1, scaleY: 1 },
+  worldTransform: { x: 50, y: 50, rotation: 0, scaleX: 2, scaleY: 2 }, // used as-is
+});
+```
+
+Requirements can also be registered via the builder or at runtime:
+
+```typescript
+// Builder
+const world = ECSpresso.create()
+  .withComponentTypes<Components>()
+  .withRequired('rigidBody', 'velocity', () => ({ x: 0, y: 0 }))
+  .withRequired('rigidBody', 'force', () => ({ x: 0, y: 0 }))
+  .build();
+
+// Runtime
+world.registerRequired('position', 'velocity', () => ({ x: 0, y: 0 }));
+```
+
+**Behavior:**
+- Enforced at insertion time (`spawn`, `addComponent`, `addComponents`, `spawnChild`, command buffer)
+- Removal is unrestricted — removing a required component does not cascade
+- Transitive requirements resolve automatically (A requires B, B requires C → all three added)
+- Circular dependencies are detected and rejected at registration time
+- Auto-added components are marked as changed and trigger reactive queries
+- Component names and factory return types are fully type-checked
+
+**Built-in requirements:** The Transform bundle registers `localTransform` → `worldTransform`. The Physics 2D bundle registers `rigidBody` → `velocity` and `rigidBody` → `force`.
+
 ### Built-in Bundles
 
 | Bundle | Import | Default Phase | Description |
 |--------|--------|---------------|-------------|
-| **Input** | `ecspresso/bundles/utils/input` | `preUpdate` | Frame-accurate keyboard/pointer input with action mapping |
-| **Timers** | `ecspresso/bundles/utils/timers` | `preUpdate` | ECS-native timers with event-based completion |
-| **Movement** | `ecspresso/bundles/utils/movement` | `fixedUpdate` | Velocity-based movement integration |
-| **Transform** | `ecspresso/bundles/utils/transform` | `postUpdate` | Hierarchical transform propagation (local/world transforms) |
-| **Bounds** | `ecspresso/bundles/utils/bounds` | `postUpdate` | Screen bounds enforcement (destroy, clamp, wrap) |
-| **Collision** | `ecspresso/bundles/utils/collision` | `postUpdate` | Layer-based AABB/circle collision detection with events |
+| **Input** | `ecspresso/bundles/input` | `preUpdate` | Frame-accurate keyboard/pointer input with action mapping |
+| **Timers** | `ecspresso/bundles/timers` | `preUpdate` | ECS-native timers with event-based completion |
+| **Movement** | `ecspresso/bundles/movement` | `fixedUpdate` | Velocity-based movement integration |
+| **Transform** | `ecspresso/bundles/transform` | `postUpdate` | Hierarchical transform propagation (local/world transforms) |
+| **Bounds** | `ecspresso/bundles/bounds` | `postUpdate` | Screen bounds enforcement (destroy, clamp, wrap) |
+| **Collision** | `ecspresso/bundles/collision` | `postUpdate` | Layer-based AABB/circle collision detection with events |
 | **2D Renderer** | `ecspresso/bundles/renderers/renderer2D` | `render` | Automated PixiJS scene graph wiring |
 
 Each bundle accepts a `phase` option to override its default.
@@ -709,11 +760,9 @@ The input bundle provides frame-accurate keyboard, pointer (mouse + touch via Po
 import {
   createInputBundle,
   type InputResourceTypes, type KeyCode
-} from 'ecspresso/bundles/utils/input';
-
-interface Resources extends InputResourceTypes {}
+} from 'ecspresso/bundles/input';
 
-const world = ECSpresso.create<Components, Events, Resources>()
+const world = ECSpresso.create()
   .withBundle(createInputBundle({
     actions: {
       jump: { keys: [' ', 'ArrowUp'] },
@@ -730,10 +779,17 @@ if (input.actions.justActivated('jump')) { /* ... */ }
 if (input.keyboard.isDown('ArrowRight')) { /* ... */ }
 if (input.pointer.justPressed(0)) { /* ... */ }
 
-// Runtime remapping
-input.setActionMap({ jump: { keys: ['w'] } });
+// Runtime remapping — must include all configured actions
+input.setActionMap({
+  jump: { keys: ['w'] },
+  shoot: { keys: ['z'], buttons: [0] },
+  moveLeft: { keys: ['a'] },
+  moveRight: { keys: ['d'] },
+});
 ```
 
+Action names are type-safe — `isActive`, `justActivated`, `justDeactivated`, `setActionMap`, and `getActionMap` only accept action names from the config. The type parameter `A` is inferred from the `actions` object keys passed to `createInputBundle`. Defaults to `string` when no actions are configured.
+
 Key values use the `KeyCode` type — a union of all standard `KeyboardEvent.key` values — providing autocomplete and compile-time validation. Note that the space bar key is `' '` (a space character), not `'Space'`.
 
 ### Timer Bundle
@@ -744,7 +800,7 @@ The timer bundle provides ECS-native timers that follow the "data, not callbacks
 import {
   createTimerBundle, createTimer, createRepeatingTimer,
   type TimerComponentTypes, type TimerEventData
-} from 'ecspresso/bundles/utils/timers';
+} from 'ecspresso/bundles/timers';
 
 // Events used with onComplete must have TimerEventData payload
 interface Events {
@@ -949,8 +1005,8 @@ world.getResource('nonexistent');
 world.entityManager.addComponent(999, 'position', { x: 0, y: 0 });
 // → "Cannot add component 'position': Entity with ID 999 does not exist"
 
-// Component not found returns null (no throw)
-world.entityManager.getComponent(123, 'position'); // null
+// Component not found returns undefined (no throw)
+world.entityManager.getComponent(123, 'position'); // undefined
 ```
 
 ## Performance Tips

package/dist/asset-manager.d.ts

@@ -6,7 +6,7 @@ import type { AssetStatus, AssetDefinition, AssetHandle, AssetsResource, AssetEv
 /**
  * Manages asset loading and access for ECSpresso
  */
-export default class AssetManager<AssetTypes extends Record<string, unknown> = Record<string, never>> {
+export default class AssetManager<AssetTypes extends Record<string, unknown> = Record<string, never>, AssetGroupNames extends string = string> {
     private readonly assets;
     private readonly groups;
     private eventBus;
@@ -14,7 +14,7 @@ export default class AssetManager<AssetTypes extends Record<string, unknown> = R
      * Set the event bus for asset events
      * @internal
      */
-    setEventBus(eventBus: EventBus<AssetEvents>): void;
+    setEventBus(eventBus: EventBus<AssetEvents<keyof AssetTypes & string, AssetGroupNames>>): void;
     /**
      * Register an asset definition
      */
@@ -30,7 +30,7 @@ export default class AssetManager<AssetTypes extends Record<string, unknown> = R
     /**
      * Load all assets in a group
      */
-    loadAssetGroup(groupName: string): Promise<void>;
+    loadAssetGroup(groupName: AssetGroupNames): Promise<void>;
     /**
      * Get a loaded asset. Throws if not loaded.
      */
@@ -54,15 +54,15 @@ export default class AssetManager<AssetTypes extends Record<string, unknown> = R
     /**
      * Check if all assets in a group are loaded
      */
-    isGroupLoaded(groupName: string): boolean;
+    isGroupLoaded(groupName: AssetGroupNames): boolean;
     /**
      * Get the loading progress of a group (0-1)
      */
-    getGroupProgress(groupName: string): number;
+    getGroupProgress(groupName: AssetGroupNames): number;
     /**
      * Get detailed group progress
      */
-    getGroupProgressDetails(groupName: string): {
+    getGroupProgressDetails(groupName: AssetGroupNames): {
         loaded: number;
         total: number;
         progress: number;
@@ -74,7 +74,7 @@ export default class AssetManager<AssetTypes extends Record<string, unknown> = R
     /**
      * Create the $assets resource object
      */
-    createResource(): AssetsResource<AssetTypes>;
+    createResource(): AssetsResource<AssetTypes, AssetGroupNames>;
     /**
      * Get all registered asset keys
      */
@@ -91,21 +91,21 @@ export default class AssetManager<AssetTypes extends Record<string, unknown> = R
 /**
  * Implementation of AssetConfigurator for builder pattern
  */
-export declare class AssetConfiguratorImpl<A extends Record<string, unknown>> implements AssetConfigurator<A> {
+export declare class AssetConfiguratorImpl<A extends Record<string, unknown>, G extends string = never> implements AssetConfigurator<A, G> {
     private readonly manager;
-    constructor(manager: AssetManager<A>);
-    add<K extends string, T>(key: K, loader: () => Promise<T>): AssetConfigurator<A & Record<K, T>>;
-    addWithConfig<K extends string, T>(key: K, definition: AssetDefinition<T>): AssetConfigurator<A & Record<K, T>>;
-    addGroup<G extends string, T extends Record<string, () => Promise<unknown>>>(groupName: G, assets: T): AssetConfigurator<A & {
+    constructor(manager: AssetManager<A, G>);
+    add<K extends string, T>(key: K, loader: () => Promise<T>): AssetConfigurator<A & Record<K, T>, G>;
+    addWithConfig<K extends string, T>(key: K, definition: AssetDefinition<T>): AssetConfigurator<A & Record<K, T>, G>;
+    addGroup<GN extends string, T extends Record<string, () => Promise<unknown>>>(groupName: GN, assets: T): AssetConfigurator<A & {
         [K in keyof T]: Awaited<ReturnType<T[K]>>;
-    }>;
+    }, G | GN>;
     /**
      * Get the underlying manager
      * @internal
      */
-    getManager(): AssetManager<A>;
+    getManager(): AssetManager<A, G>;
 }
 /**
  * Create a new AssetConfigurator for builder pattern usage
  */
-export declare function createAssetConfigurator<A extends Record<string, unknown> = Record<string, never>>(manager?: AssetManager<A>): AssetConfiguratorImpl<A>;
+export declare function createAssetConfigurator<A extends Record<string, unknown> = Record<string, never>, G extends string = never>(manager?: AssetManager<A, G>): AssetConfiguratorImpl<A, G>;

package/dist/asset-types.d.ts

@@ -32,7 +32,7 @@ export interface AssetHandle<T> {
  * Resource interface for accessing assets in systems
  * Exposed as $assets resource
  */
-export interface AssetsResource<A extends Record<string, unknown>> {
+export interface AssetsResource<A extends Record<string, unknown>, G extends string = string> {
     /**
      * Get the loading status of an asset
      */
@@ -44,11 +44,11 @@ export interface AssetsResource<A extends Record<string, unknown>> {
     /**
      * Check if all assets in a group are loaded
      */
-    isGroupLoaded(groupName: string): boolean;
+    isGroupLoaded(groupName: G): boolean;
     /**
      * Get the loading progress of a group (0-1)
      */
-    getGroupProgress(groupName: string): number;
+    getGroupProgress(groupName: G): number;
     /**
      * Get a loaded asset. Throws if not loaded.
      */
@@ -63,21 +63,23 @@ export interface AssetsResource<A extends Record<string, unknown>> {
     getHandle<K extends keyof A>(key: K): AssetHandle<A[K]>;
 }
 /**
- * Events emitted by the asset system
+ * Events emitted by the asset system.
+ * @typeParam K - Asset key type (defaults to `string` for backward compatibility)
+ * @typeParam G - Asset group name type (defaults to `string` for backward compatibility)
  */
-export interface AssetEvents {
+export interface AssetEvents<K extends string = string, G extends string = string> {
     assetLoaded: {
-        key: string;
+        key: K;
     };
     assetFailed: {
-        key: string;
+        key: K;
         error: Error;
     };
     assetGroupLoaded: {
-        group: string;
+        group: G;
     };
     assetGroupProgress: {
-        group: string;
+        group: G;
         progress: number;
         loaded: number;
         total: number;
@@ -86,19 +88,19 @@ export interface AssetEvents {
 /**
  * Configuration for asset definitions during builder setup
  */
-export interface AssetConfigurator<A extends Record<string, unknown>> {
+export interface AssetConfigurator<A extends Record<string, unknown>, G extends string = never> {
     /**
      * Add a single eager asset
      */
-    add<K extends string, T>(key: K, loader: () => Promise<T>): AssetConfigurator<A & Record<K, T>>;
+    add<K extends string, T>(key: K, loader: () => Promise<T>): AssetConfigurator<A & Record<K, T>, G>;
     /**
      * Add a single asset with full configuration
      */
-    addWithConfig<K extends string, T>(key: K, definition: AssetDefinition<T>): AssetConfigurator<A & Record<K, T>>;
+    addWithConfig<K extends string, T>(key: K, definition: AssetDefinition<T>): AssetConfigurator<A & Record<K, T>, G>;
     /**
      * Add a group of assets that can be loaded together
      */
-    addGroup<G extends string, T extends Record<string, () => Promise<unknown>>>(groupName: G, assets: T): AssetConfigurator<A & {
+    addGroup<GN extends string, T extends Record<string, () => Promise<unknown>>>(groupName: GN, assets: T): AssetConfigurator<A & {
         [K in keyof T]: Awaited<ReturnType<T[K]>>;
-    }>;
+    }, G | GN>;
 }

package/dist/bundle.d.ts

@@ -1,18 +1,22 @@
 import { SystemBuilderWithBundle } from './system-builder';
 import type ECSpresso from './ecspresso';
+import type { ResourceFactoryWithDeps } from './resource-manager';
 import type { AssetDefinition } from './asset-types';
 import type { ScreenDefinition } from './screen-types';
 import type { BundlesAreCompatible } from './type-utils';
+import type { QueryDefinition } from './types';
 /**
  * Bundle class that encapsulates a set of components, resources, events, and systems
  * that can be merged into a ECSpresso instance
  */
-export default class Bundle<ComponentTypes extends Record<string, any> = {}, EventTypes extends Record<string, any> = {}, ResourceTypes extends Record<string, any> = {}, AssetTypes extends Record<string, unknown> = {}, ScreenStates extends Record<string, ScreenDefinition<any, any>> = {}> {
+export default class Bundle<ComponentTypes extends Record<string, any> = {}, EventTypes extends Record<string, any> = {}, ResourceTypes extends Record<string, any> = {}, AssetTypes extends Record<string, unknown> = {}, ScreenStates extends Record<string, ScreenDefinition<any, any>> = {}, Labels extends string = never, Groups extends string = never, AssetGroupNames extends string = never, ReactiveQueryNames extends string = never> {
     private _systems;
     private _resources;
     private _assets;
     private _assetGroups;
     private _screens;
+    private _disposeCallbacks;
+    private _requiredComponents;
     private _id;
     constructor(id?: string);
     /**
@@ -27,17 +31,14 @@ export default class Bundle<ComponentTypes extends Record<string, any> = {}, Eve
     /**
      * Add a system to this bundle, by label (creating a new builder) or by reusing an existing one
      */
-    addSystem<Q extends Record<string, any>>(builder: SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, Q>): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, Q>;
-    addSystem(label: string): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, {}>;
+    addSystem<Q extends Record<string, QueryDefinition<ComponentTypes>>, BL extends string, BG extends string, L extends string, SG extends string>(builder: SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, Q, BL, BG, L, SG, any, any>): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, Q, Labels, Groups, L, SG, AssetGroupNames, ReactiveQueryNames>;
+    addSystem<L extends string>(label: L): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, {}, Labels, Groups, L, never, AssetGroupNames, ReactiveQueryNames>;
     /**
      * Add a resource to this bundle
      * @param label The resource key
      * @param resource The resource value, a factory function, or a factory with dependencies
      */
-    addResource<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>) => ResourceTypes[K] | Promise<ResourceTypes[K]>) | {
-        dependsOn: readonly string[];
-        factory: (ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>) => ResourceTypes[K] | Promise<ResourceTypes[K]>;
-    }): this;
+    addResource<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>) => ResourceTypes[K] | Promise<ResourceTypes[K]>) | ResourceFactoryWithDeps<ResourceTypes[K], ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>, keyof ResourceTypes & string>): this;
     /**
      * Add an asset to this bundle
      * @param key The asset key
@@ -47,21 +48,21 @@ export default class Bundle<ComponentTypes extends Record<string, any> = {}, Eve
     addAsset<K extends string, T>(key: K, loader: () => Promise<T>, options?: {
         eager?: boolean;
         group?: string;
-    }): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes & Record<K, T>, ScreenStates>;
+    }): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes & Record<K, T>, ScreenStates, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;
     /**
      * Add a group of assets to this bundle
      * @param groupName The group name
      * @param assets Object mapping asset keys to loader functions
      */
-    addAssetGroup<G extends string, T extends Record<string, () => Promise<unknown>>>(groupName: G, assets: T): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes & {
+    addAssetGroup<GN extends string, T extends Record<string, () => Promise<unknown>>>(groupName: GN, assets: T): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes & {
         [K in keyof T]: Awaited<ReturnType<T[K]>>;
-    }, ScreenStates>;
+    }, ScreenStates, Labels, Groups, AssetGroupNames | GN, ReactiveQueryNames>;
     /**
      * Add a screen to this bundle
      * @param name The screen name
      * @param definition The screen definition
      */
-    addScreen<K extends string, Config extends Record<string, unknown>, State extends Record<string, unknown>>(name: K, definition: ScreenDefinition<Config, State>): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates & Record<K, ScreenDefinition<Config, State>>>;
+    addScreen<K extends string, Config extends Record<string, unknown>, State extends Record<string, unknown>>(name: K, definition: ScreenDefinition<Config, State, ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, Record<string, ScreenDefinition>>>): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates & Record<K, ScreenDefinition<Config, State>>, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;
     /**
      * Get all asset definitions in this bundle
      */
@@ -70,6 +71,50 @@ export default class Bundle<ComponentTypes extends Record<string, any> = {}, Eve
      * Get all screen definitions in this bundle
      */
     getScreens(): Map<string, ScreenDefinition<any, any>>;
+    /**
+     * Register a dispose callback for a component type in this bundle.
+     * Called when a component is removed (explicit removal, entity destruction, or replacement).
+     * @param componentName The component type to register disposal for
+     * @param callback Function receiving the component value being disposed
+     * @returns This bundle for method chaining
+     */
+    registerDispose<K extends keyof ComponentTypes>(componentName: K, callback: (value: ComponentTypes[K]) => void): this;
+    /**
+     * Get all registered dispose callbacks in this bundle
+     */
+    getDisposeCallbacks(): Map<string, (value: unknown) => void>;
+    /**
+     * Register a required component relationship.
+     * When an entity gains `trigger`, the `required` component is auto-added
+     * (using `factory` for the default value) if not already present.
+     * @param trigger The component whose presence triggers auto-addition
+     * @param required The component to auto-add
+     * @param factory Function that creates the default value for the required component
+     * @returns This bundle for method chaining
+     */
+    registerRequired<Trigger extends keyof ComponentTypes, Required extends keyof ComponentTypes>(trigger: Trigger, required: Required, factory: (triggerValue: ComponentTypes[Trigger]) => ComponentTypes[Required]): this;
+    /**
+     * Declare reactive query names that this bundle will register at runtime.
+     * This is a pure type-level operation with no runtime cost.
+     */
+    withReactiveQueryNames<N extends string>(): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, Labels, Groups, AssetGroupNames, ReactiveQueryNames | N>;
+    /**
+     * Get all registered required component mappings in this bundle
+     */
+    getRequiredComponents(): Map<string, Array<{
+        component: string;
+        factory: (triggerValue: any) => unknown;
+    }>>;
+    /**
+     * Check for circular dependencies in the required components graph
+     * @throws Error if adding the new edge would create a cycle
+     */
+    private _checkRequiredCycle;
+    /**
+     * Internal method to set a dispose callback
+     * @internal Used by mergeBundles
+     */
+    _setDisposeCallback(name: string, callback: (value: unknown) => void): void;
     /**
      * Internal method to set a resource
      * @internal Used by mergeBundles
@@ -85,16 +130,21 @@ export default class Bundle<ComponentTypes extends Record<string, any> = {}, Eve
      * @internal Used by mergeBundles
      */
     _setScreen(name: string, definition: ScreenDefinition<any, any>): void;
+    /**
+     * Internal method to add a required component entry
+     * @internal Used by mergeBundles
+     */
+    _addRequired(trigger: string, component: string, factory: (triggerValue: any) => unknown): void;
     /**
      * Get all systems defined in this bundle
      * Returns built System objects instead of SystemBuilders
      */
-    getSystems(): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, any>[];
+    getSystems(): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, any, any, any, any, any, any, any>[];
     /**
      * Register all systems in this bundle with an ECSpresso instance
      * @internal Used by ECSpresso when adding a bundle
      */
-    registerSystemsWithEcspresso(ecspresso: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>): void;
+    registerSystemsWithEcspresso(ecspresso: ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>): void;
     /**
      * Get all resources defined in this bundle
      */
@@ -108,7 +158,7 @@ export default class Bundle<ComponentTypes extends Record<string, any> = {}, Eve
     /**
      * Get all system builders in this bundle
      */
-    getSystemBuilders(): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, any>[];
+    getSystemBuilders(): SystemBuilderWithBundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, any, any, any, any, any, any, any>[];
     /**
      * Check if this bundle has a specific resource
      * @param key The resource key to check
@@ -119,5 +169,5 @@ export default class Bundle<ComponentTypes extends Record<string, any> = {}, Eve
 /**
  * Function that merges multiple bundles into a single bundle
  */
-export declare function mergeBundles<C1 extends Record<string, any>, E1 extends Record<string, any>, R1 extends Record<string, any>, A1 extends Record<string, unknown>, S1 extends Record<string, ScreenDefinition<any, any>>, C2 extends Record<string, any>, E2 extends Record<string, any>, R2 extends Record<string, any>, A2 extends Record<string, unknown>, S2 extends Record<string, ScreenDefinition<any, any>>>(id: string, bundle1: Bundle<C1, E1, R1, A1, S1>, bundle2: BundlesAreCompatible<C1, C2, E1, E2, R1, R2, A1, A2, S1, S2> extends true ? Bundle<C2, E2, R2, A2, S2> : never): Bundle<C1 & C2, E1 & E2, R1 & R2, A1 & A2, S1 & S2>;
-export declare function mergeBundles<ComponentTypes extends Record<string, any>, EventTypes extends Record<string, any>, ResourceTypes extends Record<string, any>, AssetTypes extends Record<string, unknown>, ScreenStates extends Record<string, ScreenDefinition<any, any>>>(id: string, ...bundles: Array<Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>>): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>;
+export declare function mergeBundles<C1 extends Record<string, any>, E1 extends Record<string, any>, R1 extends Record<string, any>, A1 extends Record<string, unknown>, S1 extends Record<string, ScreenDefinition<any, any>>, L1 extends string, G1 extends string, AG1 extends string, RQ1 extends string, C2 extends Record<string, any>, E2 extends Record<string, any>, R2 extends Record<string, any>, A2 extends Record<string, unknown>, S2 extends Record<string, ScreenDefinition<any, any>>, L2 extends string, G2 extends string, AG2 extends string, RQ2 extends string>(id: string, bundle1: Bundle<C1, E1, R1, A1, S1, L1, G1, AG1, RQ1>, bundle2: BundlesAreCompatible<C1, C2, E1, E2, R1, R2, A1, A2, S1, S2> extends true ? Bundle<C2, E2, R2, A2, S2, L2, G2, AG2, RQ2> : never): Bundle<C1 & C2, E1 & E2, R1 & R2, A1 & A2, S1 & S2, L1 | L2, G1 | G2, AG1 | AG2, RQ1 | RQ2>;
+export declare function mergeBundles<ComponentTypes extends Record<string, any>, EventTypes extends Record<string, any>, ResourceTypes extends Record<string, any>, AssetTypes extends Record<string, unknown>, ScreenStates extends Record<string, ScreenDefinition<any, any>>, Labels extends string, Groups extends string, AssetGroupNamesParam extends string, ReactiveQueryNamesParam extends string>(id: string, ...bundles: Array<Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, Labels, Groups, AssetGroupNamesParam, ReactiveQueryNamesParam>>): Bundle<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, Labels, Groups, AssetGroupNamesParam, ReactiveQueryNamesParam>;