ecspresso 0.10.2 → 0.11.0

package/dist/ecspresso.d.ts

@@ -1,29 +1,30 @@
 import EntityManager from "./entity-manager";
 import EventBus from "./event-bus";
+import { type ResourceFactoryWithDeps } from "./resource-manager";
 import AssetManager from "./asset-manager";
 import ScreenManager from "./screen-manager";
 import { type ReactiveQueryDefinition } from "./reactive-query-manager";
 import CommandBuffer from "./command-buffer";
 import type { System, SystemPhase, FilteredEntity, Entity, RemoveEntityOptions, HierarchyEntry, HierarchyIteratorOptions } from "./types";
 import type Bundle from "./bundle";
-import type { BundlesAreCompatible } from "./type-utils";
-import type { AssetHandle, AssetConfigurator } from "./asset-types";
-import type { ScreenDefinition, ScreenConfigurator } from "./screen-types";
+import type { AssetHandle } from "./asset-types";
+import type { ScreenDefinition } from "./screen-types";
+import { ECSpressoBuilder } from "./ecspresso-builder";
 /**
     * Interface declaration for ECSpresso constructor to ensure type augmentation works properly.
     * This merges with the class declaration below.
 */
-export default interface ECSpresso<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 interface ECSpresso<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 = string, Groups extends string = string, AssetGroupNames extends string = string, ReactiveQueryNames extends string = string> {
     /**
         * Default constructor
     */
-    new (): ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>;
+    new (): ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;
 }
 /**
     * ECSpresso is the central ECS framework class that connects all features.
     * It handles creation and management of entities, components, and systems, and provides lifecycle hooks.
 */
-export default class ECSpresso<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 ECSpresso<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 = string, Groups extends string = string, AssetGroupNames extends string = string, ReactiveQueryNames extends string = string> {
     /** Library version*/
     static readonly VERSION: string;
     /** Access/modify stored components and entities*/
@@ -64,36 +65,57 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
     private _interpolationAlpha;
     /** Maximum fixed update steps per frame (spiral-of-death protection) */
     private _maxFixedSteps;
+    /** Registry of required component relationships: trigger -> [{component, factory}] */
+    private _requiredComponents;
+    /** Pending bundle assets awaiting manager creation at build time */
+    private _pendingBundleAssets;
+    /** Pending bundle screens awaiting manager creation at build time */
+    private _pendingBundleScreens;
+    /** Whether diagnostics timing collection is enabled */
+    private _diagnosticsEnabled;
+    /** Per-system timing in ms, populated when diagnostics enabled */
+    private _systemTimings;
+    /** Per-phase timing in ms, populated when diagnostics enabled */
+    private _phaseTimings;
     /**
         * Creates a new ECSpresso instance.
     */
     constructor();
     /**
-     * Sets up component lifecycle hooks for reactive query tracking
+     * Subscribes to EntityManager lifecycle hooks for change detection,
+     * required component auto-addition, and reactive query tracking.
      * @private
      */
-    private _setupReactiveQueryHooks;
+    private _subscribeLifecycleHooks;
     /**
         * Creates a new ECSpresso builder for type-safe bundle installation.
         * This is the preferred way to create an ECSpresso instance with bundles.
+        * Types are inferred from the builder chain — use `.withBundle()`,
+        * `.withComponentTypes<T>()`, `.withEventTypes<T>()`, and `.withResource()`
+        * to accumulate types without manual aggregate interfaces.
      *
         * @returns A builder instance for fluent method chaining
      *
         * @example
         * ```typescript
-        * const ecs = ECSpresso.create<BaseComponents, BaseEvents, BaseResources>()
-     *	 .withBundle(bundle1)
-     *	 .withBundle(bundle2)
+        * const ecs = ECSpresso.create()
+     *	 .withBundle(createRenderer2DBundle({ ... }))
+     *	 .withBundle(createPhysics2DBundle())
+     *	 .withComponentTypes<{ player: true; enemy: { type: string } }>()
+     *	 .withEventTypes<{ gameStart: true }>()
+     *	 .withResource('score', { value: 0 })
      *	 .build();
+     *
+     * type ECS = typeof ecs;
         * ```
     */
-    static create<C extends Record<string, any> = {}, E extends Record<string, any> = {}, R extends Record<string, any> = {}, A extends Record<string, unknown> = {}, S extends Record<string, ScreenDefinition<any, any>> = {}>(): ECSpressoBuilder<C, E, R, A, S>;
+    static create<C extends Record<string, any> = {}, E extends Record<string, any> = {}, R extends Record<string, any> = {}, A extends Record<string, unknown> = {}, S extends Record<string, ScreenDefinition<any, any>> = {}>(): ECSpressoBuilder<C, E, R, A, S, never, never, never, never>;
     /**
         * Adds a system directly to this ECSpresso instance
         * @param label Unique name to identify the system
         * @returns A SystemBuilder instance for method chaining
     */
-    addSystem(label: string): import("./system-builder").SystemBuilderWithEcspresso<ComponentTypes, EventTypes, ResourceTypes, {}>;
+    addSystem(label: string): import("./system-builder").SystemBuilderWithEcspresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates, {}, string, never>;
     /**
      * Update all systems across execution phases.
      * Phases run in order: preUpdate -> fixedUpdate -> update -> postUpdate -> render.
@@ -106,6 +128,11 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
      * @private
      */
     private _executePhase;
+    /**
+     * Execute a non-fixed phase with optional timing, then play back the command buffer.
+     * @private
+     */
+    private _runPhase;
     /**
      * Initialize all resources and systems
      * This method:
@@ -141,14 +168,14 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
         * @param priority The new priority value (higher values execute first)
         * @returns true if the system was found and updated, false otherwise
     */
-    updateSystemPriority(label: string, priority: number): boolean;
+    updateSystemPriority(label: Labels, priority: number): boolean;
     /**
      * Move a system to a different execution phase at runtime.
      * @param label The unique label of the system to move
      * @param phase The target phase
      * @returns true if the system was found and updated, false otherwise
      */
-    updateSystemPhase(label: string, phase: SystemPhase): boolean;
+    updateSystemPhase(label: Labels, phase: SystemPhase): boolean;
     /**
      * The interpolation alpha between fixed update steps.
      * Ranges from 0 to <1, representing how far into the next
@@ -164,31 +191,31 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
      * Disable a system group. Systems in this group will be skipped during update().
      * @param groupName The name of the group to disable
      */
-    disableSystemGroup(groupName: string): void;
+    disableSystemGroup(groupName: Groups): void;
     /**
      * Enable a system group. Systems in this group will run during update().
      * @param groupName The name of the group to enable
      */
-    enableSystemGroup(groupName: string): void;
+    enableSystemGroup(groupName: Groups): void;
     /**
      * Check if a system group is enabled.
      * @param groupName The name of the group to check
      * @returns true if the group is enabled (or doesn't exist), false if disabled
      */
-    isSystemGroupEnabled(groupName: string): boolean;
+    isSystemGroupEnabled(groupName: Groups): boolean;
     /**
      * Get all system labels that belong to a specific group.
      * @param groupName The name of the group
      * @returns Array of system labels in the group
      */
-    getSystemsInGroup(groupName: string): string[];
+    getSystemsInGroup(groupName: Groups): string[];
     /**
         * Remove a system by its label
         * Calls the system's onDetach method with this ECSpresso instance if defined
         * @param label The unique label of the system to remove
         * @returns true if the system was found and removed, false otherwise
     */
-    removeSystem(label: string): boolean;
+    removeSystem(label: Labels): boolean;
     /**
         * Internal method to register a system with this ECSpresso instance
         * @internal Used by SystemBuilder - replaces direct private property access
@@ -199,17 +226,36 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
     */
     hasResource<K extends keyof ResourceTypes>(key: K): boolean;
     /**
-        * Get a resource if it exists, or undefined if not
-    */
+     * Get a resource by key. Throws if the resource is not found.
+     * @param key The resource key
+     * @returns The resource value
+     * @throws Error if resource not found
+     * @see tryGetResource — the non-throwing alternative that returns undefined
+     */
     getResource<K extends keyof ResourceTypes>(key: K): ResourceTypes[K];
+    /**
+     * Try to get a resource by key. Returns undefined if the resource is not found.
+     * Inspired by Bevy's `World::get_resource::<T>()` which returns `Option<&T>`.
+     *
+     * Two overloads:
+     * 1. Known key — full type safety from `ResourceTypes`
+     * 2. String key with explicit type param — for cross-bundle optional dependencies
+     *
+     * @example
+     * ```typescript
+     * // Known key (type inferred from ResourceTypes)
+     * const score = ecs.tryGetResource('score'); // ScoreResource | undefined
+     *
+     * // Cross-bundle optional dependency (caller specifies expected type)
+     * const si = ecs.tryGetResource<SpatialIndex>('spatialIndex') ?? null;
+     * ```
+     */
+    tryGetResource<K extends keyof ResourceTypes>(key: K): ResourceTypes[K] | undefined;
+    tryGetResource<T>(key: unknown extends T ? never : string): T | undefined;
     /**
         * Add a resource to the ECS instance
     */
-    addResource<K extends keyof ResourceTypes>(key: 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]>;
-        onDispose?: (resource: ResourceTypes[K], ecs?: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>) => void | Promise<void>;
-    }): this;
+    addResource<K extends keyof ResourceTypes>(key: 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;
     /**
         * Remove a resource from the ECS instance (without calling onDispose)
         * @param key The resource key to remove
@@ -258,7 +304,7 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
         */
     spawn<T extends {
         [K in keyof ComponentTypes]?: ComponentTypes[K];
-    }>(components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): FilteredEntity<ComponentTypes, keyof T & keyof ComponentTypes, never>;
+    }>(components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): FilteredEntity<ComponentTypes, keyof T & keyof ComponentTypes>;
     /**
         * Get all entities with specific components
     */
@@ -289,89 +335,89 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
     removeEntity(entityOrId: number | Entity<ComponentTypes>, options?: RemoveEntityOptions): boolean;
     /**
      * Create an entity as a child of another entity with initial components
-     * @param parentId The parent entity ID
+     * @param parentOrId The parent entity or entity ID
      * @param components Initial components to add
      * @returns The created child entity
      */
     spawnChild<T extends {
         [K in keyof ComponentTypes]?: ComponentTypes[K];
-    }>(parentId: number, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): FilteredEntity<ComponentTypes, keyof T & keyof ComponentTypes, never>;
+    }>(parentOrId: number | Entity<ComponentTypes>, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): FilteredEntity<ComponentTypes, keyof T & keyof ComponentTypes>;
     /**
      * Set the parent of an entity
-     * @param childId The entity to set as a child
-     * @param parentId The entity to set as the parent
+     * @param childOrId The entity or entity ID to set as a child
+     * @param parentOrId The entity or entity ID to set as the parent
      */
-    setParent(childId: number, parentId: number): this;
+    setParent(childOrId: number | Entity<ComponentTypes>, parentOrId: number | Entity<ComponentTypes>): this;
     /**
      * Remove the parent relationship for an entity (orphan it)
-     * @param childId The entity to orphan
+     * @param childOrId The entity or entity ID to orphan
      * @returns true if a parent was removed, false if entity had no parent
      */
-    removeParent(childId: number): boolean;
+    removeParent(childOrId: number | Entity<ComponentTypes>): boolean;
     /**
      * Get the parent of an entity
-     * @param entityId The entity to get the parent of
+     * @param entityOrId The entity or entity ID to get the parent of
      * @returns The parent entity ID, or null if no parent
      */
-    getParent(entityId: number): number | null;
+    getParent(entityOrId: number | Entity<ComponentTypes>): number | null;
     /**
      * Get all children of an entity in insertion order
-     * @param parentId The parent entity
+     * @param parentOrId The parent entity or entity ID
      * @returns Readonly array of child entity IDs
      */
-    getChildren(parentId: number): readonly number[];
+    getChildren(parentOrId: number | Entity<ComponentTypes>): readonly number[];
     /**
      * Get a child at a specific index
-     * @param parentId The parent entity
+     * @param parentOrId The parent entity or entity ID
      * @param index The index of the child
      * @returns The child entity ID, or null if index is out of bounds
      */
-    getChildAt(parentId: number, index: number): number | null;
+    getChildAt(parentOrId: number | Entity<ComponentTypes>, index: number): number | null;
     /**
      * Get the index of a child within its parent's children list
-     * @param parentId The parent entity
-     * @param childId The child entity to find
+     * @param parentOrId The parent entity or entity ID
+     * @param childOrId The child entity or entity ID to find
      * @returns The index of the child, or -1 if not found
      */
-    getChildIndex(parentId: number, childId: number): number;
+    getChildIndex(parentOrId: number | Entity<ComponentTypes>, childOrId: number | Entity<ComponentTypes>): number;
     /**
      * Get all ancestors of an entity in order [parent, grandparent, ...]
-     * @param entityId The entity to get ancestors of
+     * @param entityOrId The entity or entity ID to get ancestors of
      * @returns Readonly array of ancestor entity IDs
      */
-    getAncestors(entityId: number): readonly number[];
+    getAncestors(entityOrId: number | Entity<ComponentTypes>): readonly number[];
     /**
      * Get all descendants of an entity in depth-first order
-     * @param entityId The entity to get descendants of
+     * @param entityOrId The entity or entity ID to get descendants of
      * @returns Readonly array of descendant entity IDs
      */
-    getDescendants(entityId: number): readonly number[];
+    getDescendants(entityOrId: number | Entity<ComponentTypes>): readonly number[];
     /**
      * Get the root ancestor of an entity (topmost parent), or self if no parent
-     * @param entityId The entity to get the root of
+     * @param entityOrId The entity or entity ID to get the root of
      * @returns The root entity ID
      */
-    getRoot(entityId: number): number;
+    getRoot(entityOrId: number | Entity<ComponentTypes>): number;
     /**
      * Get siblings of an entity (other children of the same parent)
-     * @param entityId The entity to get siblings of
+     * @param entityOrId The entity or entity ID to get siblings of
      * @returns Readonly array of sibling entity IDs
      */
-    getSiblings(entityId: number): readonly number[];
+    getSiblings(entityOrId: number | Entity<ComponentTypes>): readonly number[];
     /**
      * Check if an entity is a descendant of another entity
-     * @param entityId The potential descendant
-     * @param ancestorId The potential ancestor
-     * @returns true if entityId is a descendant of ancestorId
+     * @param entityOrId The potential descendant (entity or ID)
+     * @param ancestorOrId The potential ancestor (entity or ID)
+     * @returns true if entityOrId is a descendant of ancestorOrId
      */
-    isDescendantOf(entityId: number, ancestorId: number): boolean;
+    isDescendantOf(entityOrId: number | Entity<ComponentTypes>, ancestorOrId: number | Entity<ComponentTypes>): boolean;
     /**
      * Check if an entity is an ancestor of another entity
-     * @param entityId The potential ancestor
-     * @param descendantId The potential descendant
-     * @returns true if entityId is an ancestor of descendantId
+     * @param entityOrId The potential ancestor (entity or ID)
+     * @param descendantOrId The potential descendant (entity or ID)
+     * @returns true if entityOrId is an ancestor of descendantOrId
      */
-    isAncestorOf(entityId: number, descendantId: number): boolean;
+    isAncestorOf(entityOrId: number | Entity<ComponentTypes>, descendantOrId: number | Entity<ComponentTypes>): boolean;
     /**
      * Get all root entities (entities that have children but no parent)
      * @returns Readonly array of root entity IDs
@@ -413,7 +459,7 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
      * ecs.commands.spawn({ position: { x: 0, y: 0 } });
      * ```
      */
-    get commands(): CommandBuffer<ComponentTypes, EventTypes, ResourceTypes>;
+    get commands(): CommandBuffer<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>;
     /**
      * The current tick number, incremented at the end of each update()
      */
@@ -425,14 +471,47 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
      * Manual change detection should compare: getChangeSeq(...) > changeThreshold
      */
     get changeThreshold(): number;
+    /**
+     * Toggle diagnostics timing collection. When enabled, system and phase
+     * timings are recorded each frame. When disabled, timing maps are cleared
+     * and no overhead is incurred.
+     */
+    enableDiagnostics(enabled: boolean): void;
+    get diagnosticsEnabled(): boolean;
+    get systemTimings(): ReadonlyMap<string, number>;
+    get phaseTimings(): Readonly<Record<SystemPhase, number>>;
+    get entityCount(): number;
     /**
      * Mark a component as changed on an entity.
      * Each call increments a global monotonic sequence; systems with changed
      * queries will see the mark exactly once (on their next execution).
-     * @param entityId The entity ID
+     * @param entityOrId The entity or entity ID
      * @param componentName The component that was changed
      */
-    markChanged<K extends keyof ComponentTypes>(entityId: number, componentName: K): void;
+    markChanged<K extends keyof ComponentTypes>(entityOrId: number | Entity<ComponentTypes>, componentName: K): void;
+    /**
+     * Register a dispose callback for a component type.
+     * Called when a component is removed (explicit removal, entity destruction, or replacement).
+     * Later registrations replace earlier ones for the same component type.
+     * @param componentName The component type to register disposal for
+     * @param callback Function receiving the component value being disposed
+     */
+    registerDispose<K extends keyof ComponentTypes>(componentName: K, callback: (value: ComponentTypes[K]) => void): 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.
+     * Enforced at insertion time (spawn/addComponent) only — removal is unrestricted.
+     * @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
+     */
+    registerRequired<Trigger extends keyof ComponentTypes, Required extends keyof ComponentTypes>(trigger: Trigger, required: Required, factory: (triggerValue: ComponentTypes[Trigger]) => ComponentTypes[Required]): void;
+    /**
+     * Check for circular dependencies in the required components graph.
+     * @throws Error if adding trigger→newRequired would create a cycle
+     */
+    private _checkRequiredCycle;
     /**
      * Register a callback when a specific component is added to any entity
      * @param componentName The component key
@@ -452,13 +531,13 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
      * @param name Unique name for the query
      * @param definition Query definition with with/without arrays and onEnter/onExit callbacks
      */
-    addReactiveQuery<WithComponents extends keyof ComponentTypes, WithoutComponents extends keyof ComponentTypes = never, OptionalComponents extends keyof ComponentTypes = never>(name: string, definition: ReactiveQueryDefinition<ComponentTypes, WithComponents, WithoutComponents, OptionalComponents>): void;
+    addReactiveQuery<WithComponents extends keyof ComponentTypes, WithoutComponents extends keyof ComponentTypes = never, OptionalComponents extends keyof ComponentTypes = never>(name: ReactiveQueryNames, definition: ReactiveQueryDefinition<ComponentTypes, WithComponents, WithoutComponents, OptionalComponents>): void;
     /**
      * Remove a reactive query by name.
      * @param name Name of the query to remove
      * @returns true if the query existed and was removed, false otherwise
      */
-    removeReactiveQuery(name: string): boolean;
+    removeReactiveQuery(name: ReactiveQueryNames): boolean;
     /**
      * Subscribe to an event (convenience wrapper for eventBus.subscribe)
      * @param eventType The event type to subscribe to
@@ -478,7 +557,8 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
      * @param callback The hook to call after all systems have processed
      * @returns An unsubscribe function to remove the hook
      */
-    onPostUpdate(callback: (ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes>, deltaTime: number) => void): () => void;
+    onPostUpdate(callback: (ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>, deltaTime: number) => void): () => void;
+    private requireAssetManager;
     /**
      * Get a loaded asset by key. Throws if not loaded.
      */
@@ -502,15 +582,16 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
     /**
      * Load all assets in a group
      */
-    loadAssetGroup(groupName: string): Promise<void>;
+    loadAssetGroup(groupName: AssetGroupNames): Promise<void>;
     /**
      * Check if all assets in a group are loaded
      */
-    isAssetGroupLoaded(groupName: string): boolean;
+    isAssetGroupLoaded(groupName: AssetGroupNames): boolean;
     /**
      * Get the loading progress of a group (0-1)
      */
-    getAssetGroupProgress(groupName: string): number;
+    getAssetGroupProgress(groupName: AssetGroupNames): number;
+    private requireScreenManager;
     /**
      * Transition to a new screen, clearing the stack
      */
@@ -560,15 +641,19 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
      */
     getScreenStackDepth(): number;
     /**
-     * Internal method to set the asset manager
+     * Internal method to set the asset manager and drain pending bundle assets
      * @internal Used by ECSpressoBuilder
      */
     _setAssetManager(manager: AssetManager<AssetTypes>): void;
     /**
-     * Internal method to set the screen manager
+     * Internal method to set the screen manager and drain pending bundle screens
      * @internal Used by ECSpressoBuilder
      */
     _setScreenManager(manager: ScreenManager<ScreenStates>): void;
+    /** @internal */
+    _hasPendingBundleAssets(): boolean;
+    /** @internal */
+    _hasPendingBundleScreens(): boolean;
     /**
      * Internal method to set the fixed timestep interval
      * @internal Used by ECSpressoBuilder
@@ -579,111 +664,5 @@ export default class ECSpresso<ComponentTypes extends Record<string, any> = {},
         * Called by the ECSpressoBuilder during the build process.
         * The type safety is guaranteed by the builder's type system.
     */
-    _installBundle<C extends Record<string, any>, E extends Record<string, any>, R extends Record<string, any>, A extends Record<string, unknown> = {}, S extends Record<string, ScreenDefinition<any, any>> = {}>(bundle: Bundle<C, E, R, A, S>): this;
-}
-/**
- * Resource factory with optional dependencies and disposal callback
- */
-type ResourceFactoryWithDeps<T> = {
-    dependsOn?: readonly string[];
-    factory: (context?: any) => T | Promise<T>;
-    onDispose?: (resource: T, context?: any) => void | Promise<void>;
-};
-/**
-    * Builder class for ECSpresso that provides fluent type-safe bundle installation.
-    * Handles type checking during build process to ensure type safety.
-*/
-export declare class ECSpressoBuilder<C extends Record<string, any> = {}, E extends Record<string, any> = {}, R extends Record<string, any> = {}, A extends Record<string, unknown> = {}, S extends Record<string, ScreenDefinition<any, any>> = {}> {
-    /** The ECSpresso instance being built*/
-    private ecspresso;
-    /** Asset configurator for collecting asset definitions */
-    private assetConfigurator;
-    /** Screen configurator for collecting screen definitions */
-    private screenConfigurator;
-    /** Pending resources to add during build */
-    private pendingResources;
-    /** Fixed timestep interval (null means use default 1/60) */
-    private _fixedDt;
-    constructor();
-    /**
-        * Add the first bundle when starting with empty types.
-        * This overload allows any bundle to be added to an empty ECSpresso instance.
-    */
-    withBundle<BC extends Record<string, any>, BE extends Record<string, any>, BR extends Record<string, any>>(this: ECSpressoBuilder<{}, {}, {}, A, S>, bundle: Bundle<BC, BE, BR>): ECSpressoBuilder<BC, BE, BR, A, S>;
-    /**
-        * Add a subsequent bundle with type checking.
-        * This overload enforces bundle type compatibility.
-    */
-    withBundle<BC extends Record<string, any>, BE extends Record<string, any>, BR extends Record<string, any>>(bundle: BundlesAreCompatible<C, BC, E, BE, R, BR> extends true ? Bundle<BC, BE, BR> : never): ECSpressoBuilder<C & BC, E & BE, R & BR, A, S>;
-    /**
-     * Add a resource during ECSpresso construction
-     * @param key The resource key
-     * @param resource The resource value, factory function, or factory with dependencies/disposal
-     * @returns This builder with updated resource types
-     *
-     * @example
-     * ```typescript
-     * ECSpresso.create<Components, Events, Resources>()
-     *   .withResource('config', { debug: true })
-     *   .withResource('counter', () => 42)
-     *   .withResource('derived', {
-     *     dependsOn: ['base'],
-     *     factory: (ecs) => ecs.getResource('base') * 2,
-     *     onDispose: (value) => console.log('Disposed:', value)
-     *   })
-     *   .build();
-     * ```
-     */
-    withResource<K extends string, V>(key: K, resource: V | ((context?: any) => V | Promise<V>) | ResourceFactoryWithDeps<V>): ECSpressoBuilder<C, E, R & Record<K, V>, A, S>;
-    /**
-     * Configure assets for this ECSpresso instance
-     * @param configurator Function that receives an AssetConfigurator and returns it after adding assets
-     * @returns This builder with updated asset types
-     *
-     * @example
-     * ```typescript
-     * ECSpresso.create<Components, Events, Resources>()
-     *   .withAssets(assets => assets
-     *     .add('playerSprite', () => loadTexture('player.png'))
-     *     .addGroup('level1', {
-     *       background: () => loadTexture('level1-bg.png'),
-     *       music: () => loadAudio('level1.mp3'),
-     *     })
-     *   )
-     *   .build();
-     * ```
-     */
-    withAssets<NewA extends Record<string, unknown>>(configurator: (assets: AssetConfigurator<{}>) => AssetConfigurator<NewA>): ECSpressoBuilder<C, E, R, A & NewA, S>;
-    /**
-     * Configure screens for this ECSpresso instance
-     * @param configurator Function that receives a ScreenConfigurator and returns it after adding screens
-     * @returns This builder with updated screen types
-     *
-     * @example
-     * ```typescript
-     * ECSpresso.create<Components, Events, Resources>()
-     *   .withScreens(screens => screens
-     *     .add('loading', {
-     *       initialState: () => ({ progress: 0 }),
-     *     })
-     *     .add('gameplay', {
-     *       initialState: ({ level }) => ({ score: 0, level }),
-     *       requiredAssetGroups: ['level1'],
-     *     })
-     *   )
-     *   .build();
-     * ```
-     */
-    withScreens<NewS extends Record<string, ScreenDefinition<any, any>>>(configurator: (screens: ScreenConfigurator<{}>) => ScreenConfigurator<NewS>): ECSpressoBuilder<C, E, R, A, S & NewS>;
-    /**
-     * Configure the fixed timestep interval for the fixedUpdate phase.
-     * @param dt The fixed timestep in seconds (e.g., 1/60 for 60Hz physics)
-     * @returns This builder for method chaining
-     */
-    withFixedTimestep(dt: number): this;
-    /**
-        * Complete the build process and return the built ECSpresso instance
-    */
-    build(): ECSpresso<C, E, R, A, S>;
+    _installBundle<C extends Record<string, any>, E extends Record<string, any>, R extends Record<string, any>, A extends Record<string, unknown> = {}, S extends Record<string, ScreenDefinition<any, any>> = {}>(bundle: Bundle<C, E, R, A, S, any, any, any, any>): this;
 }
-export {};