ecspresso 0.11.0 → 0.12.0

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

@@ -1,13 +1,13 @@
 /**
- * Collision Bundle for ECSpresso
+ * Collision Plugin for ECSpresso
  *
  * Provides layer-based collision detection with events.
  * Uses worldTransform for position (world-space collision).
  * Supports AABB and circle colliders.
  */
-import { Bundle } from 'ecspresso';
-import type { SystemPhase } from 'ecspresso';
-import type { TransformComponentTypes } from './transform';
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { WorldConfigFrom } from '../type-utils';
+import type { TransformWorldConfig } from './transform';
 /**
  * Axis-Aligned Bounding Box collider.
  */
@@ -42,13 +42,13 @@ export interface CollisionLayer<L extends string = never> {
     collidesWith: readonly L[];
 }
 /**
- * Component types provided by the collision bundle.
- * Included automatically via `.withBundle(createCollisionBundle())`.
+ * Component types provided by the collision plugin.
+ * Included automatically via `.withPlugin(createCollisionPlugin())`.
  *
  * @example
  * ```typescript
  * const ecs = ECSpresso.create()
- *   .withBundle(createCollisionBundle())
+ *   .withPlugin(createCollisionPlugin())
  *   .withComponentTypes<{ sprite: Sprite; enemy: boolean }>()
  *   .build();
  * ```
@@ -79,23 +79,17 @@ export interface CollisionEvent<L extends string = never> {
     depth: number;
 }
 /**
- * Event types provided by the collision bundle.
+ * Event types provided by the collision plugin.
  */
 export interface CollisionEventTypes<L extends string = never> {
     collision: CollisionEvent<L>;
 }
 /**
- * Configuration options for the collision bundle.
+ * Configuration options for the collision plugin.
  */
-export interface CollisionBundleOptions<G extends string = 'physics'> {
-    /** System group name (default: 'physics') */
-    systemGroup?: G;
-    /** Priority for collision system (default: 0) */
-    priority?: number;
+export interface CollisionPluginOptions<G extends string = 'physics'> extends BasePluginOptions<G> {
     /** Name of the collision event (default: 'collision') */
     collisionEventName?: string;
-    /** Execution phase (default: 'postUpdate') */
-    phase?: SystemPhase;
 }
 /**
  * Create an AABB collider component.
@@ -245,17 +239,19 @@ export type CollisionPairCallback<W = unknown> = (firstEntityId: number, secondE
  *   'player:enemy': (playerId, enemyId, ecs) => { ... },
  * });
  *
- * ecs.eventBus.subscribe('collision', (data) => handler(data, ecs));
+ * ecs.eventBus.subscribe('collision', (data) => handler({ data, ecs }));
  * ```
  */
 export declare function createCollisionPairHandler<W = unknown, L extends string = string>(pairs: {
     [K in `${L}:${L}`]?: CollisionPairCallback<W>;
-}): (event: CollisionEvent<L>, ecs: W) => void;
-type CombinedComponentTypes<L extends string> = CollisionComponentTypes<L> & TransformComponentTypes;
+}): (ctx: {
+    data: CollisionEvent<L>;
+    ecs: W;
+}) => void;
 /**
- * Create a collision bundle for ECSpresso.
+ * Create a collision plugin for ECSpresso.
  *
- * This bundle provides:
+ * This plugin provides:
  * - Collision detection between entities with colliders
  * - AABB-AABB, circle-circle, and AABB-circle collision
  * - Layer-based filtering for collision pairs
@@ -264,15 +260,15 @@ type CombinedComponentTypes<L extends string> = CollisionComponentTypes<L> & Tra
  *
  * Uses worldTransform for position (world-space collision detection).
  * The `layers` parameter is required for type inference — at runtime the
- * bundle does not consume it.
+ * plugin does not consume it.
  *
  * @example
  * ```typescript
  * const layers = defineCollisionLayers({ player: ['enemy'], enemy: ['player'] });
  * const ecs = ECSpresso
  *   .create()
- *   .withBundle(createTransformBundle())
- *   .withBundle(createCollisionBundle({ layers }))
+ *   .withPlugin(createTransformPlugin())
+ *   .withPlugin(createCollisionPlugin({ layers }))
  *   .build();
  *
  * // Entity with collision
@@ -283,7 +279,7 @@ type CombinedComponentTypes<L extends string> = CollisionComponentTypes<L> & Tra
  * });
  * ```
  */
-export declare function createCollisionBundle<L extends string, G extends string = 'physics'>(options: CollisionBundleOptions<G> & {
+export declare function createCollisionPlugin<L extends string, G extends string = 'physics'>(options: CollisionPluginOptions<G> & {
     layers: LayerFactories<Record<L, readonly string[]>>;
-}): Bundle<CombinedComponentTypes<L>, CollisionEventTypes<L>, {}, {}, {}, 'collision-detection', G>;
+}): Plugin<WorldConfigFrom<CollisionComponentTypes<L>, CollisionEventTypes<L>>, TransformWorldConfig, 'collision-detection', G>;
 export {};

package/dist/plugins/coroutine.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Coroutine Plugin for ECSpresso
+ *
+ * ES6 generator-based coroutines for multi-step, frame-spanning scripted sequences.
+ * A `coroutine` component holds a live generator. A system ticks all generators each
+ * frame via `.next(dt)`. Helper generators (`waitSeconds`, `waitFrames`, `waitUntil`,
+ * `waitForEvent`, `parallel`, `race`) compose via `yield*`.
+ */
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { EventsOfWorld, AnyECSpresso } from 'ecspresso';
+import type { WorldConfigFrom, EmptyConfig } from '../type-utils';
+/**
+ * Yields void, returns void, receives deltaTime (number) via `.next(dt)`.
+ * First `.next(dt)` initializes the generator (runs to first yield, dt discarded per JS spec).
+ * Subsequent `.next(dt)` resume from yield with dt as the yield expression value.
+ */
+export type CoroutineGenerator = Generator<void, void, number>;
+export interface CoroutineEventData {
+    entityId: number;
+}
+export interface CoroutineState {
+    generator: CoroutineGenerator;
+    onComplete?: (data: CoroutineEventData) => void;
+}
+export interface CoroutineComponentTypes {
+    coroutine: CoroutineState;
+}
+export interface CoroutinePluginOptions<G extends string = 'coroutines'> extends BasePluginOptions<G> {
+}
+export interface CoroutineOptions {
+    onComplete?: (data: CoroutineEventData) => void;
+}
+/**
+ * Create a coroutine component for spawning or adding to an entity.
+ *
+ * @param generator - The generator function to drive
+ * @param options - Optional configuration (onComplete event)
+ * @returns Component object suitable for spreading into spawn()
+ */
+export declare function createCoroutine(generator: CoroutineGenerator, options?: CoroutineOptions): Pick<CoroutineComponentTypes, 'coroutine'>;
+/**
+ * Wait for a specified number of seconds. Accumulates dt until elapsed >= seconds.
+ * If seconds <= 0, returns immediately.
+ */
+export declare function waitSeconds(seconds: number): CoroutineGenerator;
+/**
+ * Wait for a specified number of frames. Yields `frames` times.
+ * If frames <= 0, returns immediately.
+ */
+export declare function waitFrames(frames: number): CoroutineGenerator;
+/**
+ * Wait until a predicate returns true. Yields each frame until predicate is satisfied.
+ * User closes over ecs if needed for state checks.
+ */
+export declare function waitUntil(predicate: () => boolean): CoroutineGenerator;
+/**
+ * Run multiple coroutines in parallel. Completes when all finish.
+ * Initializes all sub-generators, ticks all each frame.
+ * Empty array = immediate return.
+ */
+export declare function parallel(...coroutines: CoroutineGenerator[]): CoroutineGenerator;
+/**
+ * Run multiple coroutines, completing when the first one finishes.
+ * Calls `.return()` on remaining generators (triggers finally blocks).
+ * Empty array = immediate return.
+ */
+export declare function race(...coroutines: CoroutineGenerator[]): CoroutineGenerator;
+/**
+ * Wait until a matching event fires on the event bus.
+ * Subscribes via eventBus.subscribe, yields until event received, unsubscribes in finally block.
+ *
+ * @param eventBus - Object with subscribe method (typically ecs.eventBus)
+ * @param eventType - Event type name to listen for
+ * @param filter - Optional predicate to filter events
+ */
+export declare function waitForEvent<ET extends Record<string, any>, E extends keyof ET & string>(eventBus: {
+    subscribe(type: E, cb: (data: ET[E]) => void): () => void;
+}, eventType: E, filter?: (data: ET[E]) => boolean): CoroutineGenerator;
+/**
+ * Structural interface for ECS methods used by cancelCoroutine.
+ */
+export interface CoroutineWorld {
+    getComponent(entityId: number, componentName: string): unknown | undefined;
+    commands: {
+        removeComponent(entityId: number, componentName: string): void;
+    };
+}
+/**
+ * Cancel a running coroutine on an entity. Calls generator.return() (triggers finally blocks)
+ * and queues component removal.
+ *
+ * @returns true if the entity had a coroutine that was cancelled, false otherwise
+ */
+export declare function cancelCoroutine(ecs: CoroutineWorld, entityId: number): boolean;
+/**
+ * Type-safe coroutine helpers that validate event names against a world's event types.
+ * Use `createCoroutineHelpers<typeof ecs>()` to get compile-time validation.
+ */
+export interface CoroutineHelpers<W extends AnyECSpresso> {
+    createCoroutine: (generator: CoroutineGenerator, options?: {
+        onComplete?: (data: CoroutineEventData) => void;
+    }) => Pick<CoroutineComponentTypes, 'coroutine'>;
+    waitForEvent: <E extends keyof EventsOfWorld<W> & string>(eventBus: {
+        subscribe(type: E, cb: (data: EventsOfWorld<W>[E]) => void): () => void;
+    }, eventType: E, filter?: (data: EventsOfWorld<W>[E]) => boolean) => CoroutineGenerator;
+}
+/**
+ * Create typed coroutine helpers that validate event names at compile time.
+ *
+ * @example
+ * ```typescript
+ * const { createCoroutine, waitForEvent } = createCoroutineHelpers<typeof ecs>();
+ * ecs.spawn({ ...createCoroutine(myGen(), { onComplete: (data) => console.log(data.entityId) }) });
+ * ```
+ */
+export declare function createCoroutineHelpers<W extends AnyECSpresso>(_world?: W): CoroutineHelpers<W>;
+/**
+ * Create a coroutine plugin for ECSpresso.
+ *
+ * This plugin provides:
+ * - Coroutine system that ticks all generator-based coroutines each frame
+ * - Automatic cleanup via dispose callback (triggers generator finally blocks)
+ * - `onComplete` callback invocation
+ * - Component removal on completion
+ */
+export declare function createCoroutinePlugin<G extends string = 'coroutines'>(options?: CoroutinePluginOptions<G>): Plugin<WorldConfigFrom<CoroutineComponentTypes>, EmptyConfig, 'coroutine-update', G>;

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

@@ -1,11 +1,12 @@
 /**
- * Diagnostics Bundle for ECSpresso
+ * Diagnostics Plugin for ECSpresso
  *
  * Runtime diagnostics: FPS, entity count, per-system timing, per-phase timing,
  * and an optional DOM overlay for visual debugging.
  */
-import { Bundle } from 'ecspresso';
+import { type Plugin } from 'ecspresso';
 import type { SystemPhase } from 'ecspresso';
+import type { WorldConfigFrom, EmptyConfig } from '../type-utils';
 export interface DiagnosticsData {
     fps: number;
     entityCount: number;
@@ -16,7 +17,7 @@ export interface DiagnosticsData {
 export interface DiagnosticsResourceTypes {
     diagnostics: DiagnosticsData;
 }
-export interface DiagnosticsBundleOptions<G extends string = 'diagnostics'> {
+export interface DiagnosticsPluginOptions<G extends string = 'diagnostics'> {
     /** System group name (default: 'diagnostics') */
     systemGroup?: G;
     /** Enable timing collection on initialize (default: true) */
@@ -34,7 +35,7 @@ export interface DiagnosticsOverlayOptions {
     /** Maximum systems to show in overlay (default: 10) */
     maxSystemsShown?: number;
 }
-export declare function createDiagnosticsBundle<G extends string = 'diagnostics'>(options?: DiagnosticsBundleOptions<G>): Bundle<{}, {}, DiagnosticsResourceTypes, {}, {}, 'diagnostics-collect', G>;
+export declare function createDiagnosticsPlugin<G extends string = 'diagnostics'>(options?: DiagnosticsPluginOptions<G>): Plugin<WorldConfigFrom<{}, {}, DiagnosticsResourceTypes>, EmptyConfig, 'diagnostics-collect', G>;
 /**
  * Create a DOM overlay that displays diagnostics data.
  * Returns a cleanup function that removes the element and clears the interval.

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

@@ -1,15 +1,15 @@
 /**
- * Input Bundle for ECSpresso
+ * Input Plugin for ECSpresso
  *
  * Provides frame-accurate keyboard, pointer (mouse + touch via PointerEvent),
- * and action mapping input. Resource-only bundle — input is polled via the
+ * and action mapping input. Resource-only plugin — input is polled via the
  * `inputState` resource. No ECS components or events.
  *
  * DOM events are accumulated between frames and snapshotted once per frame
  * in the system's process step, so all systems see consistent state.
  */
-import { Bundle } from 'ecspresso';
-import type { SystemPhase } from 'ecspresso';
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { WorldConfigFrom, EmptyConfig } from '../type-utils';
 export interface Vec2 {
     x: number;
     y: number;
@@ -68,13 +68,7 @@ export type ActionMap<A extends string = string> = Record<A, ActionBinding>;
 export interface InputResourceTypes<A extends string = string> {
     inputState: InputState<A>;
 }
-export interface InputBundleOptions<A extends string = string, G extends string = 'input'> {
-    /** System group name (default: 'input') */
-    systemGroup?: G;
-    /** Priority for input system (default: 100) */
-    priority?: number;
-    /** Execution phase (default: 'preUpdate') */
-    phase?: SystemPhase;
+export interface InputPluginOptions<A extends string = string, G extends string = 'input'> extends BasePluginOptions<G> {
     /** Initial action mappings */
     actions?: ActionMap<A>;
     /** EventTarget to attach listeners to (default: globalThis). Pass a custom target for testability. */
@@ -88,9 +82,9 @@ export interface InputBundleOptions<A extends string = string, G extends string
  */
 export declare function createActionBinding(binding: ActionBinding): ActionBinding;
 /**
- * Create an input bundle for ECSpresso.
+ * Create an input plugin for ECSpresso.
  *
- * This bundle provides:
+ * This plugin provides:
  * - Frame-accurate keyboard state (isDown, justPressed, justReleased)
  * - Pointer position/delta and button state (mouse + touch via PointerEvent)
  * - Named action mapping with runtime remapping
@@ -99,7 +93,7 @@ export declare function createActionBinding(binding: ActionBinding): ActionBindi
  * @example
  * ```typescript
  * const ecs = ECSpresso.create()
- *   .withBundle(createInputBundle({
+ *   .withPlugin(createInputPlugin({
  *     actions: {
  *       jump: { keys: [' ', 'ArrowUp'] },
  *       shoot: { keys: ['z'], buttons: [0] },
@@ -113,5 +107,5 @@ export declare function createActionBinding(binding: ActionBinding): ActionBindi
  * if (input.keyboard.isDown('ArrowRight')) { ... }
  * ```
  */
-export declare function createInputBundle<A extends string = string, G extends string = 'input'>(options?: InputBundleOptions<A, G>): Bundle<{}, {}, InputResourceTypes<A>, {}, {}, 'input-state', G>;
+export declare function createInputPlugin<A extends string = string, G extends string = 'input'>(options?: InputPluginOptions<A, G>): Plugin<WorldConfigFrom<{}, {}, InputResourceTypes<A>>, EmptyConfig, 'input-state', G>;
 export {};

package/dist/plugins/particles.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Particle System Plugin for ECSpresso
+ *
+ * High-performance particle system where particles live outside the ECS in
+ * pre-allocated pools. Renders via PixiJS v8's ParticleContainer + Particle API.
+ * Renderer2D is a required dependency.
+ *
+ * Follows the established plugin pattern: immutable shared config
+ * (ParticleEffectConfig) + mutable per-entity state (ParticleEmitter) component,
+ * side-storage Map for PixiJS objects, kit pattern for typed helpers.
+ */
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { BaseWorld } from 'ecspresso';
+import type { WorldConfigFrom } from '../type-utils';
+import type { TransformComponentTypes } from 'ecspresso/plugins/transform';
+/** BaseWorld narrowed to particle components for typed access in helpers. */
+type ParticleWorld = BaseWorld<ParticleComponentTypes>;
+/** Fixed value or random range [min, max] */
+export type ParticleValue = number | readonly [number, number];
+/** Emission geometry */
+export type EmissionShape = 'point' | 'circle';
+/** Blend modes for particle rendering */
+export type ParticleBlendMode = 'normal' | 'add' | 'multiply' | 'screen';
+/**
+ * User-facing config input for defining a particle effect.
+ * All properties optional except maxParticles and texture.
+ */
+export interface ParticleEffectInput {
+    /** Pool size — maximum simultaneous particles */
+    maxParticles: number;
+    /** PixiJS Texture for particles */
+    texture: unknown;
+    /** Particles per second (0 = burst-only, default: 10) */
+    spawnRate?: number;
+    /** Particles per burst (default: 0) */
+    burstCount?: number;
+    /** Emitter lifetime in seconds (-1 = infinite, default: -1) */
+    duration?: number;
+    /** Per-particle lifetime in seconds (default: 1) */
+    lifetime?: ParticleValue;
+    /** Initial speed in pixels/second (default: 100) */
+    speed?: ParticleValue;
+    /** Emission direction in radians (default: [0, 2*PI]) */
+    angle?: ParticleValue;
+    /** Spawn geometry (default: 'point') */
+    emissionShape?: EmissionShape;
+    /** Radius for 'circle' shape (default: 0) */
+    emissionRadius?: number;
+    /** Acceleration in pixels/second^2 (default: {x: 0, y: 0}) */
+    gravity?: {
+        readonly x: number;
+        readonly y: number;
+    };
+    /** Initial scale (default: 1) */
+    startSize?: ParticleValue;
+    /** Final scale (default: same as startSize) */
+    endSize?: ParticleValue;
+    /** Initial opacity (default: 1) */
+    startAlpha?: ParticleValue;
+    /** Final opacity (default: 0) */
+    endAlpha?: ParticleValue;
+    /** Initial hex color (default: 0xffffff) */
+    startTint?: number;
+    /** Final hex color (default: same as startTint) */
+    endTint?: number;
+    /** Initial rotation in radians (default: 0) */
+    startRotation?: ParticleValue;
+    /** Rotation velocity in rad/s (default: 0) */
+    rotationSpeed?: ParticleValue;
+    /** Blend mode (default: 'normal') */
+    blendMode?: ParticleBlendMode;
+    /** Particles in world coordinates (default: true) */
+    worldSpace?: boolean;
+}
+/**
+ * Frozen, fully-resolved particle effect config.
+ * Output of defineParticleEffect.
+ */
+export interface ParticleEffectConfig {
+    readonly maxParticles: number;
+    readonly texture: unknown;
+    readonly spawnRate: number;
+    readonly burstCount: number;
+    readonly duration: number;
+    readonly lifetime: ParticleValue;
+    readonly speed: ParticleValue;
+    readonly angle: ParticleValue;
+    readonly emissionShape: EmissionShape;
+    readonly emissionRadius: number;
+    readonly gravity: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly startSize: ParticleValue;
+    readonly endSize: ParticleValue;
+    readonly startAlpha: ParticleValue;
+    readonly endAlpha: ParticleValue;
+    readonly startTint: number;
+    readonly endTint: number;
+    readonly startRotation: ParticleValue;
+    readonly rotationSpeed: ParticleValue;
+    readonly blendMode: ParticleBlendMode;
+    readonly worldSpace: boolean;
+}
+/**
+ * Mutable per-particle state. Pre-allocated, never GC'd.
+ */
+export interface ParticleState {
+    active: boolean;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    life: number;
+    maxLife: number;
+    size: number;
+    startSize: number;
+    endSize: number;
+    alpha: number;
+    startAlpha: number;
+    endAlpha: number;
+    tint: number;
+    rotation: number;
+    rotationSpeed: number;
+}
+/**
+ * Per-entity emitter state stored as an ECS component.
+ */
+export interface ParticleEmitter {
+    readonly config: ParticleEffectConfig;
+    activeCount: number;
+    spawnAccumulator: number;
+    elapsed: number;
+    playing: boolean;
+    pendingBurst: number;
+    finished: boolean;
+    onComplete?: (data: ParticleEmitterEventData) => void;
+}
+/**
+ * Component types provided by the particle plugin.
+ */
+export interface ParticleComponentTypes {
+    particleEmitter: ParticleEmitter;
+}
+/**
+ * Data published when an emitter completes.
+ */
+export interface ParticleEmitterEventData {
+    entityId: number;
+}
+export interface ParticlePluginOptions<G extends string = 'particles'> extends BasePluginOptions<G> {
+}
+/**
+ * Sample a ParticleValue: returns fixed value or random within [min, max].
+ */
+export declare function sampleRange(value: ParticleValue): number;
+/**
+ * Linear interpolation between two hex colors (RGB channels).
+ */
+export declare function lerpTint(start: number, end: number, t: number): number;
+/**
+ * Define a particle effect config with defaults applied and frozen.
+ */
+export declare function defineParticleEffect(input: ParticleEffectInput): ParticleEffectConfig;
+/**
+ * Create a particleEmitter component suitable for spreading into spawn().
+ */
+export declare function createParticleEmitter(config: ParticleEffectConfig, options?: {
+    playing?: boolean;
+    onComplete?: (data: ParticleEmitterEventData) => void;
+}): Pick<ParticleComponentTypes, 'particleEmitter'>;
+/**
+ * Queue a burst of particles on an emitter.
+ * Returns false if entity has no particleEmitter component.
+ */
+export declare function burstParticles(ecs: ParticleWorld, entityId: number, count?: number): boolean;
+/**
+ * Stop an emitter from spawning new particles.
+ * Existing particles continue their lifecycle.
+ */
+export declare function stopEmitter(ecs: ParticleWorld, entityId: number): boolean;
+/**
+ * Resume a stopped emitter.
+ */
+export declare function resumeEmitter(ecs: ParticleWorld, entityId: number): boolean;
+/**
+ * Runtime data stored outside the ECS, keyed by entity ID.
+ */
+export interface EmitterRuntimeData {
+    particles: ParticleState[];
+    pixiContainer: unknown;
+    pixiParticles: unknown[];
+}
+export declare const particlePresets: {
+    readonly explosion: (texture: unknown, overrides?: Partial<ParticleEffectInput>) => ParticleEffectConfig;
+    readonly smoke: (texture: unknown, overrides?: Partial<ParticleEffectInput>) => ParticleEffectConfig;
+    readonly fire: (texture: unknown, overrides?: Partial<ParticleEffectInput>) => ParticleEffectConfig;
+    readonly sparkle: (texture: unknown, overrides?: Partial<ParticleEffectInput>) => ParticleEffectConfig;
+    readonly trail: (texture: unknown, overrides?: Partial<ParticleEffectInput>) => ParticleEffectConfig;
+};
+type ParticleLabels = 'particle-update' | 'particle-render-sync';
+type ParticleRequires = WorldConfigFrom<TransformComponentTypes & {
+    renderLayer: string;
+}>;
+/**
+ * Create a particle system plugin for ECSpresso.
+ *
+ * Provides:
+ * - Pre-allocated particle pools outside the entity system
+ * - Continuous and burst emission modes
+ * - Velocity, gravity, lifetime, interpolation (size, alpha, tint, rotation)
+ * - World-space and local-space particle emission
+ * - PixiJS ParticleContainer rendering (via renderer2D dependency)
+ * - Presets for common effects (explosion, smoke, fire, sparkle, trail)
+ *
+ * Renderer2D is a required dependency.
+ */
+export declare function createParticlePlugin<G extends string = 'particles'>(options?: ParticlePluginOptions<G>): Plugin<WorldConfigFrom<ParticleComponentTypes>, ParticleRequires, ParticleLabels, G, never, 'particle-emitters'>;
+/**
+ * Get the runtime data for an emitter entity.
+ * Useful for tests and advanced usage.
+ * @internal Exported for testing only.
+ */
+export declare function getEmitterData(emitterDataMap: Map<number, EmitterRuntimeData>, entityId: number): EmitterRuntimeData | undefined;
+export {};

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

@@ -1,16 +1,17 @@
 /**
- * Physics 2D Bundle for ECSpresso
+ * Physics 2D Plugin for ECSpresso
  *
  * Provides ECS-native arcade physics: gravity, forces, drag, semi-implicit Euler
  * integration, and impulse-based collision response with friction.
  *
- * Reuses collider types from the collision bundle for shape definitions.
+ * Reuses collider types from the collision plugin for shape definitions.
  * Has its own collision detection in fixedUpdate for physics response;
- * the existing collision bundle can still run in postUpdate for game logic events.
+ * the existing collision plugin can still run in postUpdate for game logic events.
  */
-import { Bundle } from 'ecspresso';
+import { type Plugin } from 'ecspresso';
 import type { SystemPhase } from 'ecspresso';
-import type { TransformComponentTypes } from './transform';
+import type { WorldConfigFrom } from '../type-utils';
+import type { TransformComponentTypes, TransformWorldConfig } from './transform';
 import type { CollisionComponentTypes, LayerFactories } from './collision';
 import type { Vector2D } from 'ecspresso';
 /**
@@ -37,13 +38,20 @@ export interface RigidBody {
     gravityScale: number;
 }
 /**
- * Component types provided by the physics bundle.
+ * Component types directly provided by the physics plugin.
  */
-export interface Physics2DComponentTypes<L extends string = never> extends TransformComponentTypes, CollisionComponentTypes<L> {
+export interface Physics2DOwnComponentTypes {
     rigidBody: RigidBody;
     velocity: Vector2D;
     force: Vector2D;
 }
+/**
+ * Full component types available when using the physics plugin
+ * (own components + transform + collision dependencies).
+ * Convenience alias for consumer code.
+ */
+export interface Physics2DComponentTypes<L extends string = never> extends TransformComponentTypes, CollisionComponentTypes<L>, Physics2DOwnComponentTypes {
+}
 /**
  * Physics configuration resource.
  */
@@ -67,7 +75,7 @@ export interface Physics2DCollisionEvent {
 export interface Physics2DEventTypes {
     physicsCollision: Physics2DCollisionEvent;
 }
-export interface Physics2DBundleOptions<G extends string = 'physics2D', CG extends string = never> {
+export interface Physics2DPluginOptions<G extends string = 'physics2D', CG extends string = never> {
     /** World gravity vector (default: {x: 0, y: 0}) */
     gravity?: Vector2D;
     /** System group name (default: 'physics2D') */
@@ -108,29 +116,23 @@ export declare function createForce(x: number, y: number): {
  * Accumulate a force onto an entity's force component.
  */
 export declare function applyForce(ecs: {
-    entityManager: {
-        getComponent(id: number, name: 'force'): Vector2D | undefined;
-    };
+    getComponent(id: number, name: 'force'): Vector2D | undefined;
 }, entityId: number, fx: number, fy: number): void;
 /**
  * Apply an instantaneous impulse: velocity += impulse / mass.
  */
 export declare function applyImpulse(ecs: {
-    entityManager: {
-        getComponent(id: number, name: 'velocity'): Vector2D | undefined;
-        getComponent(id: number, name: 'rigidBody'): RigidBody | undefined;
-    };
+    getComponent(id: number, name: 'velocity'): Vector2D | undefined;
+    getComponent(id: number, name: 'rigidBody'): RigidBody | undefined;
 }, entityId: number, ix: number, iy: number): void;
 /**
  * Directly set an entity's velocity.
  */
 export declare function setVelocity(ecs: {
-    entityManager: {
-        getComponent(id: number, name: 'velocity'): Vector2D | undefined;
-    };
+    getComponent(id: number, name: 'velocity'): Vector2D | undefined;
 }, entityId: number, vx: number, vy: number): void;
 /**
- * Create a 2D physics bundle for ECSpresso.
+ * Create a 2D physics plugin for ECSpresso.
  *
  * Provides:
  * - Semi-implicit Euler integration (gravity, forces, drag → velocity → position)
@@ -140,8 +142,8 @@ export declare function setVelocity(ecs: {
  * @example
  * ```typescript
  * const ecs = ECSpresso.create()
- *   .withBundle(createTransformBundle())
- *   .withBundle(createPhysics2DBundle({ gravity: { x: 0, y: 980 } }))
+ *   .withPlugin(createTransformPlugin())
+ *   .withPlugin(createPhysics2DPlugin({ gravity: { x: 0, y: 980 } }))
  *   .withFixedTimestep(1/60)
  *   .build();
  *
@@ -154,6 +156,8 @@ export declare function setVelocity(ecs: {
  * });
  * ```
  */
-export declare function createPhysics2DBundle<L extends string = never, G extends string = 'physics2D', CG extends string = never>(options?: Physics2DBundleOptions<G, CG> & {
+type Physics2DProvides<L extends string = never> = Physics2DOwnComponentTypes & CollisionComponentTypes<L>;
+export declare function createPhysics2DPlugin<L extends string = never, G extends string = 'physics2D', CG extends string = never>(options?: Physics2DPluginOptions<G, CG> & {
     layers?: LayerFactories<Record<L, readonly string[]>>;
-}): Bundle<Physics2DComponentTypes<L>, Physics2DEventTypes, Physics2DResourceTypes, {}, {}, 'physics2D-integration' | 'physics2D-collision', G | CG>;
+}): Plugin<WorldConfigFrom<Physics2DProvides<L>, Physics2DEventTypes, Physics2DResourceTypes>, TransformWorldConfig, 'physics2D-integration' | 'physics2D-collision', G | CG>;
+export {};