ecspresso 0.11.0 → 0.12.0

package/dist/plugins/timers.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Timer Plugin for ECSpresso
+ *
+ * Provides ECS-native timers following the "data, not callbacks" philosophy.
+ * Timers are components processed each frame, automatically cleaned up when entities are removed.
+ */
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { WorldConfigFrom, EmptyConfig } from '../type-utils';
+/**
+ * Data structure passed to onComplete callbacks when a timer completes.
+ *
+ * @example
+ * ```typescript
+ * createTimer(1.5, {
+ *   onComplete: (data) => {
+ *     console.log(`Timer on entity ${data.entityId} finished after ${data.elapsed}s`);
+ *   }
+ * });
+ * ```
+ */
+export interface TimerEventData {
+    /** The entity ID that the timer belongs to */
+    entityId: number;
+    /** The timer's configured duration in seconds */
+    duration: number;
+    /** The actual elapsed time (may exceed duration slightly) */
+    elapsed: number;
+}
+/**
+ * Timer component data structure.
+ * Use `justFinished` to detect timer completion in your systems.
+ */
+export interface Timer {
+    /** Time accumulated so far (seconds) */
+    elapsed: number;
+    /** Target duration (seconds) */
+    duration: number;
+    /** Whether timer repeats after completion */
+    repeat: boolean;
+    /** Whether timer is currently running */
+    active: boolean;
+    /** True for one frame after timer completes */
+    justFinished: boolean;
+    /** Optional callback invoked when timer completes */
+    onComplete?: (data: TimerEventData) => void;
+}
+/**
+ * Component types provided by the timer plugin.
+ * Included automatically via `.withPlugin(createTimerPlugin())`.
+ *
+ * @example
+ * ```typescript
+ * const ecs = ECSpresso.create()
+ *   .withPlugin(createTimerPlugin())
+ *   .withComponentTypes<{ velocity: { x: number; y: number }; player: true }>()
+ *   .build();
+ * ```
+ */
+export interface TimerComponentTypes {
+    timer: Timer;
+}
+/**
+ * Configuration options for the timer plugin.
+ */
+export interface TimerPluginOptions<G extends string = 'timers'> extends BasePluginOptions<G> {
+}
+/**
+ * Options for timer creation
+ */
+export interface TimerOptions {
+    /** Callback invoked when timer completes */
+    onComplete?: (data: TimerEventData) => void;
+}
+/**
+ * Create a one-shot timer that fires once after the specified duration.
+ *
+ * @param duration Duration in seconds until the timer completes
+ * @param options Optional configuration including onComplete callback
+ * @returns Component object suitable for spreading into spawn()
+ *
+ * @example
+ * ```typescript
+ * // Timer without callback
+ * ecs.spawn({
+ *   ...createTimer(2),
+ *   explosion: true,
+ * });
+ *
+ * // Timer with onComplete callback
+ * ecs.spawn({
+ *   ...createTimer(1.5, { onComplete: (data) => console.log('done', data.entityId) }),
+ * });
+ * ```
+ */
+export declare function createTimer(duration: number, options?: TimerOptions): Pick<TimerComponentTypes, 'timer'>;
+/**
+ * Create a repeating timer that fires every `duration` seconds.
+ *
+ * @param duration Duration in seconds between each timer completion
+ * @param options Optional configuration including onComplete callback
+ * @returns Component object suitable for spreading into spawn()
+ *
+ * @example
+ * ```typescript
+ * // Timer without callback
+ * ecs.spawn({
+ *   ...createRepeatingTimer(5),
+ *   spawner: true,
+ * });
+ *
+ * // Repeating timer with onComplete callback
+ * ecs.spawn({
+ *   ...createRepeatingTimer(3, { onComplete: (data) => console.log('cycle', data.elapsed) }),
+ * });
+ * ```
+ */
+export declare function createRepeatingTimer(duration: number, options?: TimerOptions): Pick<TimerComponentTypes, 'timer'>;
+/**
+ * Create a timer plugin for ECSpresso.
+ *
+ * This plugin provides:
+ * - Timer update system that processes all timer components each frame
+ * - `justFinished` flag pattern for one-frame completion detection
+ * - Automatic cleanup when entities are removed
+ *
+ * @example
+ * ```typescript
+ * const ecs = ECSpresso
+ *   .create<Components, Events, Resources>()
+ *   .withPlugin(createTimerPlugin())
+ *   .build();
+ *
+ * // Spawn entity with timer
+ * ecs.spawn({
+ *   ...createRepeatingTimer(5),
+ *   spawner: true,
+ * });
+ *
+ * // React to timer completion in a system
+ * ecs.addSystem('spawn-on-timer')
+ *   .addQuery('spawners', { with: ['timer', 'spawner'] })
+ *   .setProcess((queries, _dt, ecs) => {
+ *     for (const { components } of queries.spawners) {
+ *       if (components.timer.justFinished) {
+ *         ecs.spawn({ enemy: true });
+ *       }
+ *     }
+ *   });
+ * ```
+ */
+export declare function createTimerPlugin<G extends string = 'timers'>(options?: TimerPluginOptions<G>): Plugin<WorldConfigFrom<TimerComponentTypes>, EmptyConfig, 'timer-update', G>;

package/dist/{bundles → plugins}/transform.d.ts

@@ -1,13 +1,13 @@
 /**
- * Transform Bundle for ECSpresso
+ * Transform Plugin for ECSpresso
  *
  * Provides hierarchical transform propagation following Bevy's Transform/GlobalTransform pattern.
  * LocalTransform is modified by user code; WorldTransform is computed automatically.
  *
  * @see https://docs.rs/bevy/latest/bevy/transform/components/struct.GlobalTransform.html
  */
-import { Bundle } from 'ecspresso';
-import type { SystemPhase } from 'ecspresso';
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { WorldConfigFrom, EmptyConfig } from '../type-utils';
 /**
  * Local transform relative to parent (or world if no parent).
  * This is the transform you modify directly.
@@ -31,13 +31,13 @@ export interface WorldTransform {
     scaleY: number;
 }
 /**
- * Component types provided by the transform bundle.
- * Included automatically via `.withBundle(createTransformBundle())`.
+ * Component types provided by the transform plugin.
+ * Included automatically via `.withPlugin(createTransformPlugin())`.
  *
  * @example
  * ```typescript
  * const ecs = ECSpresso.create()
- *   .withBundle(createTransformBundle())
+ *   .withPlugin(createTransformPlugin())
  *   .withComponentTypes<{ sprite: Sprite; velocity: { x: number; y: number } }>()
  *   .build();
  * ```
@@ -47,15 +47,14 @@ export interface TransformComponentTypes {
     worldTransform: WorldTransform;
 }
 /**
- * Configuration options for the transform bundle.
+ * WorldConfig representing the transform plugin's provided components.
+ * Used as the `Requires` type parameter by plugins that depend on transform.
  */
-export interface TransformBundleOptions<G extends string = 'transform'> {
-    /** System group name (default: 'transform') */
-    systemGroup?: G;
-    /** Priority for transform propagation (default: 500, runs after physics) */
-    priority?: number;
-    /** Execution phase (default: 'postUpdate') */
-    phase?: SystemPhase;
+export type TransformWorldConfig = WorldConfigFrom<TransformComponentTypes>;
+/**
+ * Configuration options for the transform plugin.
+ */
+export interface TransformPluginOptions<G extends string = 'transform'> extends BasePluginOptions<G> {
 }
 /**
  * Default local transform values.
@@ -126,9 +125,9 @@ export interface TransformOptions {
  */
 export declare function createTransform(x: number, y: number, options?: TransformOptions): TransformComponentTypes;
 /**
- * Create a transform bundle for ECSpresso.
+ * Create a transform plugin for ECSpresso.
  *
- * This bundle provides:
+ * This plugin provides:
  * - Transform propagation system that computes world transforms from local transforms
  * - Parent-first traversal ensures parents are processed before children
  * - Supports full transform hierarchy (position, rotation, scale)
@@ -137,8 +136,8 @@ export declare function createTransform(x: number, y: number, options?: Transfor
  * ```typescript
  * const ecs = ECSpresso
  *   .create<Components, Events, Resources>()
- *   .withBundle(createTransformBundle())
- *   .withBundle(createPhysics2DBundle())
+ *   .withPlugin(createTransformPlugin())
+ *   .withPlugin(createPhysics2DPlugin())
  *   .build();
  *
  * // Spawn entity with transform
@@ -148,4 +147,4 @@ export declare function createTransform(x: number, y: number, options?: Transfor
  * });
  * ```
  */
-export declare function createTransformBundle<G extends string = 'transform'>(options?: TransformBundleOptions<G>): Bundle<TransformComponentTypes, {}, {}, {}, {}, 'transform-propagation', G>;
+export declare function createTransformPlugin<G extends string = 'transform'>(options?: TransformPluginOptions<G>): Plugin<WorldConfigFrom<TransformComponentTypes>, EmptyConfig, 'transform-propagation', G>;

package/dist/{bundles → plugins}/tween.d.ts

@@ -1,11 +1,12 @@
 /**
- * Tween Bundle for ECSpresso
+ * Tween Plugin for ECSpresso
  *
  * Declarative property animation within the ECS. Tween any numeric component
  * field over time with standard easing functions, sequences, and completion events.
  */
-import { Bundle } from 'ecspresso';
-import type { SystemPhase, ComponentsOfWorld, EventsOfWorld } from 'ecspresso';
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { ComponentsOfWorld, AnyECSpresso } from 'ecspresso';
+import type { WorldConfigFrom, EmptyConfig } from '../type-utils';
 import { type EasingFn } from '../utils/easing';
 /**
  * Data structure published when a tween completes.
@@ -17,15 +18,6 @@ export interface TweenEventData {
     /** Number of steps in the tween */
     stepCount: number;
 }
-/**
- * Extracts event names from EventTypes that have TweenEventData as their payload.
- * This ensures only compatible events can be used with tween.onComplete.
- * Uses `keyof EventTypes & string` to exclude number/symbol keys, ensuring the
- * result is always a string subtype and Tween<E> is assignable to Tween<Record<string, any>>.
- */
-export type TweenEventName<EventTypes extends Record<string, any>> = {
-    [K in keyof EventTypes & string]: EventTypes[K] extends TweenEventData ? K : never;
-}[keyof EventTypes & string];
 export interface TweenTarget {
     /** Component name on the entity */
     component: string;
@@ -41,7 +33,7 @@ export interface TweenStep {
     duration: number;
     easing: EasingFn;
 }
-export interface Tween<EventTypes extends Record<string, any> = Record<string, any>> {
+export interface Tween {
     steps: TweenStep[];
     currentStep: number;
     elapsed: number;
@@ -50,25 +42,19 @@ export interface Tween<EventTypes extends Record<string, any> = Record<string, a
     completedLoops: number;
     direction: 1 | -1;
     state: 'pending' | 'active' | 'complete';
-    onComplete?: TweenEventName<EventTypes>;
+    onComplete?: (data: TweenEventData) => void;
     justFinished: boolean;
 }
 export type LoopMode = 'once' | 'loop' | 'yoyo';
 /**
- * Component types provided by the tween bundle.
+ * Component types provided by the tween plugin.
  */
-export interface TweenComponentTypes<EventTypes extends Record<string, any> = Record<string, any>> {
-    tween: Tween<EventTypes>;
+export interface TweenComponentTypes {
+    tween: Tween;
 }
-export interface TweenBundleOptions<G extends string = 'tweens'> {
-    /** System group name (default: 'tweens') */
-    systemGroup?: G;
-    /** Priority for tween update system (default: 0) */
-    priority?: number;
-    /** Execution phase (default: 'update') */
-    phase?: SystemPhase;
+export interface TweenPluginOptions<G extends string = 'tweens'> extends BasePluginOptions<G> {
 }
-export interface TweenOptions<EventTypes extends Record<string, any> = Record<string, any>> {
+export interface TweenOptions {
     /** Explicit starting value (default: captures current value on first tick) */
     from?: number;
     /** Easing function (default: linear) */
@@ -77,8 +63,8 @@ export interface TweenOptions<EventTypes extends Record<string, any> = Record<st
     loop?: LoopMode;
     /** Number of loops. -1 = infinite (default: 1) */
     loops?: number;
-    /** Event name to publish when tween completes */
-    onComplete?: TweenEventName<EventTypes>;
+    /** Callback invoked when tween completes */
+    onComplete?: (data: TweenEventData) => void;
 }
 /**
  * Create a single-target tween component.
@@ -90,7 +76,7 @@ export interface TweenOptions<EventTypes extends Record<string, any> = Record<st
  * @param options Optional configuration
  * @returns Component object suitable for spreading into spawn()
  */
-export declare function createTween<EventTypes extends Record<string, any> = Record<string, any>>(component: string, field: string, to: number, duration: number, options?: TweenOptions<EventTypes>): Pick<TweenComponentTypes<EventTypes>, 'tween'>;
+export declare function createTween(component: string, field: string, to: number, duration: number, options?: TweenOptions): Pick<TweenComponentTypes, 'tween'>;
 export interface TweenSequenceStepInput {
     targets: ReadonlyArray<{
         component: string;
@@ -101,13 +87,13 @@ export interface TweenSequenceStepInput {
     duration: number;
     easing?: EasingFn;
 }
-export interface TweenSequenceOptions<EventTypes extends Record<string, any> = Record<string, any>> {
+export interface TweenSequenceOptions {
     /** Loop mode (default: 'once') */
     loop?: LoopMode;
     /** Number of loops. -1 = infinite (default: 1) */
     loops?: number;
-    /** Event name to publish when tween completes */
-    onComplete?: TweenEventName<EventTypes>;
+    /** Callback invoked when tween completes */
+    onComplete?: (data: TweenEventData) => void;
 }
 /**
  * Create a multi-step tween sequence. Each step can have parallel targets.
@@ -116,8 +102,7 @@ export interface TweenSequenceOptions<EventTypes extends Record<string, any> = R
  * @param options Optional configuration
  * @returns Component object suitable for spreading into spawn()
  */
-export declare function createTweenSequence<EventTypes extends Record<string, any> = Record<string, any>>(steps: ReadonlyArray<TweenSequenceStepInput>, options?: TweenSequenceOptions<EventTypes>): Pick<TweenComponentTypes<EventTypes>, 'tween'>;
-type AnyECSpresso = import('ecspresso').default<any, any, any, any, any, any, any>;
+export declare function createTweenSequence(steps: ReadonlyArray<TweenSequenceStepInput>, options?: TweenSequenceOptions): Pick<TweenComponentTypes, 'tween'>;
 /**
  * Recursively produce a union of dot-separated paths that resolve to `number`
  * within type T. Depth-limited to 4 levels to prevent TS recursion errors.
@@ -147,51 +132,31 @@ export interface TypedTweenSequenceStepInput<C extends Record<string, any>> {
     duration: number;
     easing?: EasingFn;
 }
-export interface TweenKit<W extends AnyECSpresso, G extends string = 'tweens'> {
-    bundle: Bundle<TweenComponentTypes<EventsOfWorld<W>>, EventsOfWorld<W>, {}, {}, {}, 'tween-update', G>;
-    createTween: <K extends keyof ComponentsOfWorld<W> & string>(component: K, field: NumericPaths<ComponentsOfWorld<W>[K]>, to: number, duration: number, options?: TweenOptions<EventsOfWorld<W>>) => Pick<TweenComponentTypes<EventsOfWorld<W>>, 'tween'>;
-    createTweenSequence: (steps: ReadonlyArray<TypedTweenSequenceStepInput<ComponentsOfWorld<W>>>, options?: TweenSequenceOptions<EventsOfWorld<W>>) => Pick<TweenComponentTypes<EventsOfWorld<W>>, 'tween'>;
+export interface TweenHelpers<W extends AnyECSpresso> {
+    createTween: <K extends keyof ComponentsOfWorld<W> & string>(component: K, field: NumericPaths<ComponentsOfWorld<W>[K]>, to: number, duration: number, options?: {
+        from?: number;
+        easing?: EasingFn;
+        loop?: LoopMode;
+        loops?: number;
+        onComplete?: (data: TweenEventData) => void;
+    }) => Pick<TweenComponentTypes, 'tween'>;
+    createTweenSequence: (steps: ReadonlyArray<TypedTweenSequenceStepInput<ComponentsOfWorld<W>>>, options?: {
+        loop?: LoopMode;
+        loops?: number;
+        onComplete?: (data: TweenEventData) => void;
+    }) => Pick<TweenComponentTypes, 'tween'>;
 }
+export declare function createTweenHelpers<W extends AnyECSpresso>(_world?: W): TweenHelpers<W>;
 /**
- * Create a typed tween kit that captures the world type W.
- *
- * The returned `createTween` and `createTweenSequence` validate component names
- * and field paths at compile time. Runtime behavior is identical to the standalone
- * functions — all validation is type-level only.
- *
- * @template W - Concrete ECS world type (e.g. `typeof ecs`)
- * @template G - System group name (default: 'tweens')
- * @param options - Optional bundle configuration (same as createTweenBundle)
- * @returns A kit object with bundle, createTween, createTweenSequence
- *
- * @example
- * ```typescript
- * const kit = createTweenKit<typeof ecs>();
- * // or: const kit = createTweenKit<ECS>();
- *
- * const ecs = ECSpresso.create()
- *   .withBundle(kit.bundle)
- *   .build();
- *
- * // Type-safe: 'position' must be a component, 'x' must be a numeric field
- * kit.createTween('position', 'x', 100, 1);
- *
- * // Type error: 'z' is not a field of position
- * kit.createTween('position', 'z', 100, 1);
- * ```
- */
-export declare function createTweenKit<W extends AnyECSpresso, G extends string = 'tweens'>(options?: TweenBundleOptions<G>): TweenKit<W, G>;
-/**
- * Create a tween bundle for ECSpresso.
+ * Create a tween plugin for ECSpresso.
  *
- * This bundle provides:
+ * This plugin provides:
  * - Tween system that processes all tween components each frame
  * - Support for single-field, multi-target, and multi-step sequences
  * - 31 standard easing functions
  * - Loop modes: once, loop, yoyo
  * - `justFinished` flag for one-frame completion detection
- * - `onComplete` event publishing
+ * - `onComplete` callback on completion
  * - Change detection via markChanged
  */
-export declare function createTweenBundle<EventTypes extends Record<string, any> = Record<string, any>, G extends string = 'tweens'>(options?: TweenBundleOptions<G>): Bundle<TweenComponentTypes<EventTypes>, EventTypes, {}, {}, {}, 'tween-update', G>;
-export {};
+export declare function createTweenPlugin<G extends string = 'tweens'>(options?: TweenPluginOptions<G>): Plugin<WorldConfigFrom<TweenComponentTypes>, EmptyConfig, 'tween-update', G>;

package/dist/resource-manager.d.ts

@@ -6,6 +6,29 @@ export interface ResourceFactoryWithDeps<T, Context = unknown, D extends string
     factory: (context: Context) => T | Promise<T>;
     onDispose?: (resource: T, context: Context) => void | Promise<void>;
 }
+/** @internal */
+export declare const RESOURCE_DIRECT: unique symbol;
+/**
+ * Branded wrapper for storing a value as-is, bypassing factory detection.
+ * The value is carried on the symbol key to avoid structural conflicts
+ * with user resource types that have a `value` property.
+ * Create via the `directValue()` helper.
+ */
+export interface ResourceDirectValue<T> {
+    [RESOURCE_DIRECT]: T;
+}
+/**
+ * Wrap a value to store it as-is, bypassing factory detection.
+ * Use when the resource itself is a function or class that should not be invoked.
+ *
+ * @example
+ * ```ts
+ * import { directValue } from 'ecspresso';
+ * world.addResource('handler', directValue(myFunction));
+ * world.addResource('MyClass', directValue(MyClass));
+ * ```
+ */
+export declare function directValue<T>(value: T): ResourceDirectValue<T>;
 /**
  * When Context is unknown (default), context args are optional.
  * When Context is a specific type (e.g. ECSpresso<...>), context is required.
@@ -18,17 +41,19 @@ export default class ResourceManager<ResourceTypes extends Record<string, any> =
     private resourceDisposers;
     private initializedResourceKeys;
     /**
-     * Add a resource to the manager
+     * Add a resource to the manager.
+     *
+     * Resolution order:
+     * 1. `{ factory, dependsOn?, onDispose? }` → factory with optional deps/disposal
+     * 2. `{ value }` → direct value wrapper (use to store functions/classes as-is)
+     * 3. `typeof === 'function'` → bare factory (no deps)
+     * 4. Anything else → direct value
+     *
      * @param label The resource key
      * @param resource The resource value, a factory function, or a factory with dependencies
      * @returns The resource manager instance for chaining
      */
-    add<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((context: Context) => ResourceTypes[K] | Promise<ResourceTypes[K]>) | ResourceFactoryWithDeps<ResourceTypes[K], Context, keyof ResourceTypes & string>): this;
-    /**
-     * Improved detection of factory functions vs direct values/classes
-     * @private
-     */
-    private _isFactoryFunction;
+    add<K extends keyof ResourceTypes>(label: K, resource: ResourceTypes[K] | ((context: Context) => ResourceTypes[K] | Promise<ResourceTypes[K]>) | ResourceFactoryWithDeps<ResourceTypes[K], Context, keyof ResourceTypes & string> | ResourceDirectValue<ResourceTypes[K]>): this;
     /**
      * Try to get a resource from the manager.
      * Returns the resource value if it exists, or undefined if not found.

package/dist/screen-manager.d.ts

@@ -4,7 +4,7 @@
 import type EventBus from './event-bus';
 import type AssetManager from './asset-manager';
 import type ECSpresso from './ecspresso';
-import type { ScreenDefinition, ScreenResource, ScreenEvents, ScreenConfigurator } from './screen-types';
+import type { ScreenDefinition, ScreenResource, ScreenEvents, ScreenConfigurator, ScreenConfig, ScreenState } from './screen-types';
 /**
  * Manages screen/state transitions for ECSpresso
  */
@@ -20,6 +20,7 @@ export default class ScreenManager<Screens extends Record<string, ScreenDefiniti
      * @internal
      */
     setDependencies(eventBus: EventBus<ScreenEvents<keyof Screens & string>>, assetManager: AssetManager<any> | null, ecs: ECSpresso<any, any, any, any, any>): void;
+    private requireEcs;
     /**
      * Register a screen definition
      */
@@ -49,25 +50,30 @@ export default class ScreenManager<Screens extends Record<string, ScreenDefiniti
      */
     getCurrentScreen(): keyof Screens | null;
     /**
-     * Get the current screen config (immutable)
+     * Get the current screen config (immutable).
+     * If `screen` is provided, asserts that the current screen matches.
      */
-    getConfig<K extends keyof Screens>(): Screens[K] extends ScreenDefinition<infer C, any> ? Readonly<C> : never;
+    getConfig(screen?: keyof Screens): Readonly<ScreenConfig<Screens[keyof Screens]>>;
     /**
-     * Get the current screen config or null
+     * Get the current screen config or undefined.
+     * If `screen` is provided, returns undefined when the current screen doesn't match.
      */
-    getConfigOrNull<K extends keyof Screens>(): (Screens[K] extends ScreenDefinition<infer C, any> ? Readonly<C> : never) | null;
+    tryGetConfig(screen?: keyof Screens): Readonly<ScreenConfig<Screens[keyof Screens]>> | undefined;
     /**
-     * Get the current screen state (mutable)
+     * Get the current screen state (mutable).
+     * If `screen` is provided, asserts that the current screen matches.
      */
-    getState<K extends keyof Screens>(): Screens[K] extends ScreenDefinition<any, infer S> ? S : never;
+    getState(screen?: keyof Screens): ScreenState<Screens[keyof Screens]>;
     /**
-     * Get the current screen state or null
+     * Get the current screen state or undefined.
+     * If `screen` is provided, returns undefined when the current screen doesn't match.
      */
-    getStateOrNull<K extends keyof Screens>(): (Screens[K] extends ScreenDefinition<any, infer S> ? S : never) | null;
+    tryGetState(screen?: keyof Screens): ScreenState<Screens[keyof Screens]> | undefined;
     /**
-     * Update the current screen state
+     * Update the current screen state.
+     * If `screen` is provided, asserts that the current screen matches.
      */
-    updateState<K extends keyof Screens>(update: Partial<Screens[K] extends ScreenDefinition<any, infer S> ? S : never> | ((current: Screens[K] extends ScreenDefinition<any, infer S> ? S : never) => Partial<Screens[K] extends ScreenDefinition<any, infer S> ? S : never>)): void;
+    updateState(update: unknown, screen?: keyof Screens): void;
     /**
      * Get the screen stack depth
      */

package/dist/screen-types.d.ts

@@ -5,7 +5,7 @@ import type ECSpresso from './ecspresso';
 /**
  * Definition for a screen including its state, lifecycle hooks, and requirements
  */
-export interface ScreenDefinition<Config extends Record<string, unknown> = Record<string, never>, State extends Record<string, unknown> = Record<string, never>, W = ECSpresso<any, any, any, any, any>> {
+export interface ScreenDefinition<Config extends Record<string, unknown> = Record<string, never>, State extends Record<string, unknown> = Record<string, never>, W = ECSpresso<any>> {
     /**
      * Function to create initial state from config
      */
@@ -13,7 +13,10 @@ export interface ScreenDefinition<Config extends Record<string, unknown> = Recor
     /**
      * Lifecycle hook called when entering this screen
      */
-    readonly onEnter?: (config: Config, ecs: W) => void | Promise<void>;
+    readonly onEnter?: (ctx: {
+        config: Config;
+        ecs: W;
+    }) => void | Promise<void>;
     /**
      * Lifecycle hook called when exiting this screen
      */