ecspresso 0.10.2 → 0.12.0

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.
      */
@@ -38,7 +38,7 @@ export default class AssetManager<AssetTypes extends Record<string, unknown> = R
     /**
      * Get a loaded asset or undefined
      */
-    getOrUndefined<K extends keyof AssetTypes>(key: K): AssetTypes[K] | undefined;
+    tryGet<K extends keyof AssetTypes>(key: K): AssetTypes[K] | undefined;
     /**
      * Get a handle to an asset with status information
      */
@@ -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

@@ -26,13 +26,13 @@ export interface AssetHandle<T> {
     /**
      * Get the asset value if loaded, undefined otherwise.
      */
-    getOrUndefined(): T | undefined;
+    tryGet(): T | undefined;
 }
 /**
  * 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.
      */
@@ -56,28 +56,30 @@ export interface AssetsResource<A extends Record<string, unknown>> {
     /**
      * Get a loaded asset or undefined if not loaded
      */
-    getOrUndefined<K extends keyof A>(key: K): A[K] | undefined;
+    tryGet<K extends keyof A>(key: K): A[K] | undefined;
     /**
      * Get a handle to an asset with status information
      */
     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/command-buffer.d.ts

@@ -1,5 +1,6 @@
 import type ECSpresso from './ecspresso';
 import type { RemoveEntityOptions } from './types';
+import type { WorldConfig, EmptyConfig } from './type-utils';
 /**
  * CommandBuffer queues structural changes to be executed later.
  * This prevents ordering issues when modifying entities during system execution.
@@ -16,66 +17,75 @@ import type { RemoveEntityOptions } from './types';
  * ecs.commands.playback(ecs);
  * ```
  */
-export default class CommandBuffer<ComponentTypes extends Record<string, any> = {}, EventTypes extends Record<string, any> = {}, ResourceTypes extends Record<string, any> = {}> {
+export default class CommandBuffer<Cfg extends WorldConfig = EmptyConfig> {
     private commands;
     /**
      * Queue an entity removal command
-     * @param entityId The ID of the entity to remove
+     * @param entityId The entity ID to remove
      * @param options Optional removal options (cascade, etc.)
      */
     removeEntity(entityId: number, options?: RemoveEntityOptions): void;
     /**
      * Queue a component addition command
-     * @param entityId The ID of the entity
+     * @param entityId The entity ID
      * @param componentName The name of the component to add
      * @param componentValue The component data
      */
-    addComponent<K extends keyof ComponentTypes>(entityId: number, componentName: K, componentValue: ComponentTypes[K]): void;
+    addComponent<K extends keyof Cfg['components']>(entityId: number, componentName: K, componentValue: Cfg['components'][K]): void;
     /**
      * Queue a component removal command
-     * @param entityId The ID of the entity
+     * @param entityId The entity ID
      * @param componentName The name of the component to remove
      */
-    removeComponent<K extends keyof ComponentTypes>(entityId: number, componentName: K): void;
+    removeComponent<K extends keyof Cfg['components']>(entityId: number, componentName: K): void;
     /**
      * Queue an entity spawn command
      * @param components The initial components for the new entity
      * @returns void (entity ID not available until playback)
      */
     spawn<T extends {
-        [K in keyof ComponentTypes]?: ComponentTypes[K];
-    }>(components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): void;
+        [K in keyof Cfg['components']]?: Cfg['components'][K];
+    }>(components: T & Record<Exclude<keyof T, keyof Cfg['components']>, never>): void;
     /**
      * Queue a child entity spawn command
-     * @param parentId The ID of the parent entity
+     * @param parentId The parent entity ID
      * @param components The initial components for the new child entity
      */
     spawnChild<T extends {
-        [K in keyof ComponentTypes]?: ComponentTypes[K];
-    }>(parentId: number, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): void;
+        [K in keyof Cfg['components']]?: Cfg['components'][K];
+    }>(parentId: number, components: T & Record<Exclude<keyof T, keyof Cfg['components']>, never>): void;
     /**
      * Queue multiple component additions
-     * @param entityId The ID of the entity
+     * @param entityId The entity ID
      * @param components Object with component names as keys and component data as values
      */
     addComponents<T extends {
-        [K in keyof ComponentTypes]?: ComponentTypes[K];
-    }>(entityId: number, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): void;
+        [K in keyof Cfg['components']]?: Cfg['components'][K];
+    }>(entityId: number, components: T & Record<Exclude<keyof T, keyof Cfg['components']>, never>): void;
     /**
      * Queue a parent assignment command
-     * @param childId The ID of the child entity
-     * @param parentId The ID of the parent entity
+     * @param childId The child entity ID
+     * @param parentId The parent entity ID
      */
     setParent(childId: number, parentId: number): void;
+    /**
+     * Queue a component mutation command.
+     * The mutator runs during playback, receiving the component for in-place mutation.
+     * Automatically marks the component as changed.
+     * @param entityId The entity ID
+     * @param componentName The component to mutate
+     * @param mutator A function that receives the component value for in-place mutation
+     */
+    mutateComponent<K extends keyof Cfg['components']>(entityId: number, componentName: K, mutator: (value: Cfg['components'][K]) => void): void;
     /**
      * Queue a markChanged command
-     * @param entityId The ID of the entity
+     * @param entityId The entity ID
      * @param componentName The component to mark as changed
      */
-    markChanged<K extends keyof ComponentTypes>(entityId: number, componentName: K): void;
+    markChanged<K extends keyof Cfg['components']>(entityId: number, componentName: K): void;
     /**
      * Queue a parent removal command
-     * @param childId The ID of the child entity
+     * @param childId The child entity ID
      */
     removeParent(childId: number): void;
     /**
@@ -83,7 +93,7 @@ export default class CommandBuffer<ComponentTypes extends Record<string, any> =
      * Errors from individual commands are caught and logged, but do not stop playback.
      * @param ecs The ECSpresso instance to execute commands on
      */
-    playback<AssetTypes extends Record<string, any> = {}, ScreenStates extends Record<string, any> = {}>(ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>): void;
+    playback(ecs: ECSpresso<Cfg>): void;
     /**
      * Clear all queued commands without executing them
      */

package/dist/ecspresso-builder.d.ts

@@ -0,0 +1,193 @@
+import type ECSpresso from "./ecspresso";
+import type { ResourceFactoryWithDeps, ResourceDirectValue } from "./resource-manager";
+import { type Plugin } from "./plugin";
+import type { WorldConfig, EmptyConfig, ConfigsAreCompatible, MergeConfigs, TypesAreCompatible, RequirementsSatisfied, WithComponents, WithEvents, WithResources } from "./type-utils";
+import type { AssetConfigurator, AssetsResource } from "./asset-types";
+import type { ScreenDefinition, ScreenConfigurator, ScreenResource } from "./screen-types";
+/**
+ * Helper type: finalize built-in resources ($assets, $screen) in the resource map.
+ * Auto-injects $assets/$screen when plugins contribute asset/screen types even without
+ * explicit withAssets()/withScreens(). Also narrows the AssetGroupNames on $assets.
+ */
+type FinalizeBuiltinResources<Cfg extends WorldConfig, AG extends string> = {
+    readonly components: Cfg['components'];
+    readonly events: Cfg['events'];
+    readonly resources: Omit<Cfg['resources'], '$assets' | '$screen'> & ([keyof Cfg['assets']] extends [never] ? {} : {
+        $assets: AssetsResource<Cfg['assets'], AG>;
+    }) & ([keyof Cfg['screens']] extends [never] ? {} : {
+        $screen: ScreenResource<Cfg['screens']>;
+    });
+    readonly assets: Cfg['assets'];
+    readonly screens: Cfg['screens'];
+};
+/**
+    * Builder class for ECSpresso that provides fluent type-safe plugin installation.
+    * Handles type checking during build process to ensure type safety.
+*/
+export declare class ECSpressoBuilder<Cfg extends WorldConfig = EmptyConfig, Labels extends string = never, Groups extends string = never, AssetGroupNames extends string = never, ReactiveQueryNames extends string = never> {
+    /** 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;
+    /** Pending dispose callbacks to register during build */
+    private pendingDisposeCallbacks;
+    /** Pending required component registrations to apply during build */
+    private pendingRequiredComponents;
+    /** Pending plugins to install during build */
+    private pendingPlugins;
+    /** Fixed timestep interval (null means use default 1/60) */
+    private _fixedDt;
+    constructor();
+    /**
+        * Add the first plugin when starting with empty types.
+        * This overload allows any plugin to be added to an empty ECSpresso instance.
+        * Only merges the plugin's Provides (PCfg) into accumulated config, not its Requires (PReq).
+    */
+    withPlugin<PCfg extends WorldConfig, PReq extends WorldConfig = EmptyConfig, BL extends string = never, BG extends string = never, BAG extends string = never, BRQ extends string = never>(this: ECSpressoBuilder<{
+        readonly components: {};
+        readonly events: {};
+        readonly resources: {};
+        readonly assets: Cfg['assets'];
+        readonly screens: Cfg['screens'];
+    }, Labels, Groups, AssetGroupNames, ReactiveQueryNames>, plugin: Plugin<PCfg, PReq, BL, BG, BAG, BRQ>): ECSpressoBuilder<{
+        readonly components: PCfg['components'];
+        readonly events: PCfg['events'];
+        readonly resources: PCfg['resources'];
+        readonly assets: Cfg['assets'] & PCfg['assets'];
+        readonly screens: Cfg['screens'] & PCfg['screens'];
+    }, Labels | BL, Groups | BG, AssetGroupNames | BAG, ReactiveQueryNames | BRQ>;
+    /**
+        * Add a subsequent plugin with type checking.
+        * This overload enforces plugin type compatibility and requirement satisfaction.
+        * Only merges the plugin's Provides (PCfg) into accumulated config, not its Requires (PReq).
+    */
+    withPlugin<PCfg extends WorldConfig, PReq extends WorldConfig = EmptyConfig, BL extends string = never, BG extends string = never, BAG extends string = never, BRQ extends string = never>(plugin: ConfigsAreCompatible<Cfg, PCfg> extends true ? RequirementsSatisfied<Cfg, PReq> extends true ? Plugin<PCfg, PReq, BL, BG, BAG, BRQ> : never : never): ECSpressoBuilder<MergeConfigs<Cfg, PCfg>, Labels | BL, Groups | BG, AssetGroupNames | BAG, ReactiveQueryNames | BRQ>;
+    /**
+     * Add application-specific component types to the builder chain.
+     * This is a pure type-level operation with no runtime cost.
+     * Conflicts with existing component types (same key, different type) produce a `never` return.
+     */
+    withComponentTypes<T extends Record<string, any>>(): TypesAreCompatible<Cfg['components'], T> extends true ? ECSpressoBuilder<WithComponents<Cfg, T>, Labels, Groups, AssetGroupNames, ReactiveQueryNames> : never;
+    /**
+     * Add application-specific event types to the builder chain.
+     * This is a pure type-level operation with no runtime cost.
+     * Conflicts with existing event types (same key, different type) produce a `never` return.
+     */
+    withEventTypes<T extends Record<string, any>>(): TypesAreCompatible<Cfg['events'], T> extends true ? ECSpressoBuilder<WithEvents<Cfg, T>, Labels, Groups, AssetGroupNames, ReactiveQueryNames> : never;
+    /**
+     * Add application-specific resource types to the builder chain.
+     * This is a pure type-level operation with no runtime cost.
+     * Conflicts with existing resource types (same key, different type) produce a `never` return.
+     */
+    withResourceTypes<T extends Record<string, any>>(): TypesAreCompatible<Cfg['resources'], T> extends true ? ECSpressoBuilder<WithResources<Cfg, T>, Labels, Groups, AssetGroupNames, ReactiveQueryNames> : never;
+    /**
+     * Add a resource during ECSpresso construction.
+     *
+     * When the key matches a pre-declared resource type (via `withResourceTypes`, `create<C,E,R>()`,
+     * or plugin resources), the value is validated against that type.
+     * For new keys, the value type is inferred as before.
+     *
+     * @param key The resource key
+     * @param resource The resource value, factory function, or factory with dependencies/disposal
+     * @returns This builder with updated resource types
+     */
+    withResource<K extends keyof Cfg['resources'] & string>(key: K, resource: Cfg['resources'][K] | ((context: ECSpresso<Cfg>) => Cfg['resources'][K] | Promise<Cfg['resources'][K]>) | ResourceFactoryWithDeps<Cfg['resources'][K], ECSpresso<Cfg>, keyof Cfg['resources'] & string> | ResourceDirectValue<Cfg['resources'][K]>): ECSpressoBuilder<Cfg, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;
+    withResource<K extends string, V>(key: K & ([K] extends [keyof Cfg['resources']] ? [V] extends [Cfg['resources'][K & keyof Cfg['resources']]] ? string : never : string), resource: V | ((context: ECSpresso<WithResources<Cfg, Record<K, V>>>) => V | Promise<V>) | ResourceFactoryWithDeps<V, ECSpresso<WithResources<Cfg, Record<K, V>>>, keyof (Cfg['resources'] & Record<K, V>) & string> | ResourceDirectValue<V>): ECSpressoBuilder<WithResources<Cfg, Record<K, V>>, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;
+    /**
+     * Register a dispose callback for a component type during build.
+     * 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 builder for method chaining
+     */
+    withDispose<K extends keyof Cfg['components'] & string>(componentName: K, callback: (ctx: {
+        value: Cfg['components'][K];
+        entityId: number;
+    }) => void): this;
+    /**
+     * Register a required component relationship during build.
+     * 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 builder for method chaining
+     */
+    withRequired<Trigger extends keyof Cfg['components'] & string, Required extends keyof Cfg['components'] & string>(trigger: Trigger, required: Required, factory: (triggerValue: Cfg['components'][Trigger]) => Cfg['components'][Required]): this;
+    /**
+     * 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
+     */
+    withAssets<NewA extends Record<string, unknown>, NewG extends string = never>(configurator: (assets: AssetConfigurator<{}, never>) => AssetConfigurator<NewA, NewG>): ECSpressoBuilder<{
+        readonly components: Cfg['components'];
+        readonly events: Cfg['events'];
+        readonly resources: Cfg['resources'] & {
+            $assets: AssetsResource<Cfg['assets'] & NewA, string>;
+        };
+        readonly assets: Cfg['assets'] & NewA;
+        readonly screens: Cfg['screens'];
+    }, Labels, Groups, AssetGroupNames | NewG, ReactiveQueryNames>;
+    /**
+     * 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
+     */
+    withScreens<NewS extends Record<string, ScreenDefinition<any, any>>>(configurator: (screens: ScreenConfigurator<{}, ECSpresso<{
+        readonly components: Cfg['components'];
+        readonly events: Cfg['events'];
+        readonly resources: Cfg['resources'];
+        readonly assets: Cfg['assets'];
+        readonly screens: Record<string, ScreenDefinition>;
+    }>>) => ScreenConfigurator<NewS, ECSpresso<{
+        readonly components: Cfg['components'];
+        readonly events: Cfg['events'];
+        readonly resources: Cfg['resources'];
+        readonly assets: Cfg['assets'];
+        readonly screens: Record<string, ScreenDefinition>;
+    }>>): ECSpressoBuilder<{
+        readonly components: Cfg['components'];
+        readonly events: Cfg['events'];
+        readonly resources: Cfg['resources'] & {
+            $screen: ScreenResource<Cfg['screens'] & NewS>;
+        };
+        readonly assets: Cfg['assets'];
+        readonly screens: Cfg['screens'] & NewS;
+    }, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;
+    /**
+     * 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;
+    /**
+     * Declare reactive query names that will be registered at runtime.
+     * This is a pure type-level operation with no runtime cost.
+     */
+    withReactiveQueryNames<N extends string>(): ECSpressoBuilder<Cfg, Labels, Groups, AssetGroupNames, ReactiveQueryNames | N>;
+    /**
+     * Create a plugin factory from the builder's accumulated types.
+     * Returns a definePlugin equivalent with no manual type parameters.
+     */
+    pluginFactory(): <PL extends string = never, PG extends string = never, PAG extends string = never, PRQ extends string = never>(config: {
+        id: string;
+        install: (world: ECSpresso<Cfg>) => void;
+    }) => Plugin<Cfg, EmptyConfig, PL, PG, PAG, PRQ>;
+    /**
+        * Complete the build process and return the built ECSpresso instance
+    */
+    build(): ECSpresso<FinalizeBuiltinResources<Cfg, [AssetGroupNames] extends [never] ? string : AssetGroupNames>, [
+        Labels
+    ] extends [never] ? string : Labels, [
+        Groups
+    ] extends [never] ? string : Groups, [
+        AssetGroupNames
+    ] extends [never] ? string : AssetGroupNames, [
+        ReactiveQueryNames
+    ] extends [never] ? string : ReactiveQueryNames>;
+}
+export {};