ecspresso 0.11.0 → 0.12.0

package/dist/entity-manager.d.ts

@@ -47,38 +47,42 @@ export default class EntityManager<ComponentTypes> {
      * 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
+     * @param callback Function receiving the component value being disposed and the entity ID
      */
-    registerDispose<ComponentName extends keyof ComponentTypes>(componentName: ComponentName, callback: (value: ComponentTypes[ComponentName]) => void): void;
+    registerDispose<ComponentName extends keyof ComponentTypes>(componentName: ComponentName, callback: (ctx: {
+        value: ComponentTypes[ComponentName];
+        entityId: number;
+    }) => void): void;
     /**
      * Get all registered dispose callbacks.
-     * @internal Used by ECSpresso for bundle installation
+     * @internal Used by ECSpresso for plugin installation
      */
-    getDisposeCallbacks(): Map<keyof ComponentTypes, (value: any) => void>;
+    getDisposeCallbacks(): Map<keyof ComponentTypes, (ctx: {
+        value: unknown;
+        entityId: number;
+    }) => void>;
     /**
      * Invoke the dispose callback for a component, if registered.
      * Errors are caught and logged to prevent blocking removal.
      */
     private invokeDispose;
-    private resolveEntity;
-    private resolveEntityId;
-    addComponent<ComponentName extends keyof ComponentTypes>(entityOrId: number | Entity<ComponentTypes>, componentName: ComponentName, data: ComponentTypes[ComponentName]): this;
+    addComponent<ComponentName extends keyof ComponentTypes>(entityId: number, componentName: ComponentName, data: ComponentTypes[ComponentName]): this;
     /**
      * Add multiple components to an entity at once
-     * @param entityOrId Entity or entity ID to add components to
+     * @param entityId Entity ID to add components to
      * @param components Object with component names as keys and component data as values
      */
     addComponents<T extends {
         [K in keyof ComponentTypes]?: ComponentTypes[K];
-    }>(entityOrId: number | Entity<ComponentTypes>, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): this;
-    removeComponent<ComponentName extends keyof ComponentTypes>(entityOrId: number | Entity<ComponentTypes>, componentName: ComponentName): this;
+    }>(entityId: number, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): this;
+    removeComponent<ComponentName extends keyof ComponentTypes>(entityId: number, componentName: ComponentName): this;
     getComponent<ComponentName extends keyof ComponentTypes>(entityId: number, componentName: ComponentName): ComponentTypes[ComponentName] | undefined;
     getEntitiesWithQuery<WithComponents extends keyof ComponentTypes = never, WithoutComponents extends keyof ComponentTypes = never>(required?: ReadonlyArray<WithComponents>, excluded?: ReadonlyArray<WithoutComponents>, changed?: ReadonlyArray<keyof ComponentTypes>, changeThreshold?: number, parentHas?: ReadonlyArray<keyof ComponentTypes>): Array<FilteredEntity<ComponentTypes, WithComponents extends never ? never : WithComponents, WithoutComponents extends never ? never : WithoutComponents>>;
     /**
      * Check if an entity's direct parent has all specified components
      */
     private parentHasComponents;
-    removeEntity(entityOrId: number | Entity<ComponentTypes>, options?: RemoveEntityOptions): boolean;
+    removeEntity(entityId: number, options?: RemoveEntityOptions): boolean;
     /**
      * Internal method to remove a single entity without cascade logic
      */
@@ -90,14 +94,20 @@ export default class EntityManager<ComponentTypes> {
      * @param handler Function receiving the new component value and the entity
      * @returns Unsubscribe function to remove the callback
      */
-    onComponentAdded<ComponentName extends keyof ComponentTypes>(componentName: ComponentName, handler: (value: ComponentTypes[ComponentName], entity: Entity<ComponentTypes>) => void): () => void;
+    onComponentAdded<ComponentName extends keyof ComponentTypes>(componentName: ComponentName, handler: (ctx: {
+        value: ComponentTypes[ComponentName];
+        entity: Entity<ComponentTypes>;
+    }) => void): () => void;
     /**
      * Register a callback when a specific component is removed from any entity
      * @param componentName The component key
      * @param handler Function receiving the old component value and the entity
      * @returns Unsubscribe function to remove the callback
      */
-    onComponentRemoved<ComponentName extends keyof ComponentTypes>(componentName: ComponentName, handler: (oldValue: ComponentTypes[ComponentName], entity: Entity<ComponentTypes>) => void): () => void;
+    onComponentRemoved<ComponentName extends keyof ComponentTypes>(componentName: ComponentName, handler: (ctx: {
+        value: ComponentTypes[ComponentName];
+        entity: Entity<ComponentTypes>;
+    }) => void): () => void;
     onAfterComponentAdded(hook: (entityId: number, componentName: keyof ComponentTypes) => void): () => void;
     onAfterEntityMutated(hook: (entityId: number) => void): () => void;
     onAfterComponentRemoved(hook: (entityId: number, componentName: keyof ComponentTypes) => void): () => void;
@@ -110,10 +120,10 @@ export default class EntityManager<ComponentTypes> {
     get changeSeq(): number;
     /**
      * Mark a component as changed on an entity, stamping the next sequence number.
-     * @param entityOrId The entity or entity ID
+     * @param entityId The entity ID
      * @param componentName The component that changed
      */
-    markChanged<K extends keyof ComponentTypes>(entityOrId: number | Entity<ComponentTypes>, componentName: K): void;
+    markChanged<K extends keyof ComponentTypes>(entityId: number, componentName: K): void;
     /**
      * Get the sequence number at which a component was last changed on an entity
      * @param entityId The entity ID
@@ -123,89 +133,89 @@ export default class EntityManager<ComponentTypes> {
     getChangeSeq<K extends keyof ComponentTypes>(entityId: number, componentName: K): number;
     /**
      * Create an entity as a child of another entity with initial components
-     * @param parentOrId The parent entity or entity ID
+     * @param parentId The parent entity ID
      * @param components Initial components to add
      * @returns The created child entity
      */
     spawnChild<T extends {
         [K in keyof ComponentTypes]?: ComponentTypes[K];
-    }>(parentOrId: number | Entity<ComponentTypes>, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): FilteredEntity<ComponentTypes, keyof T & keyof ComponentTypes>;
+    }>(parentId: number, components: T & Record<Exclude<keyof T, keyof ComponentTypes>, never>): FilteredEntity<ComponentTypes, keyof T & keyof ComponentTypes>;
     /**
      * Set the parent of an entity
-     * @param childOrId The entity or entity ID to set as a child
-     * @param parentOrId The entity or entity ID to set as the parent
+     * @param childId The entity ID to set as a child
+     * @param parentId The entity ID to set as the parent
      */
-    setParent(childOrId: number | Entity<ComponentTypes>, parentOrId: number | Entity<ComponentTypes>): this;
+    setParent(childId: number, parentId: number): this;
     /**
      * Remove the parent relationship for an entity (orphan it)
-     * @param childOrId The entity or entity ID to orphan
+     * @param childId The entity ID to orphan
      * @returns true if a parent was removed, false if entity had no parent
      */
-    removeParent(childOrId: number | Entity<ComponentTypes>): boolean;
+    removeParent(childId: number): boolean;
     /**
      * Get the parent of an entity
-     * @param entityOrId The entity or entity ID to get the parent of
+     * @param entityId The entity ID to get the parent of
      * @returns The parent entity ID, or null if no parent
      */
-    getParent(entityOrId: number | Entity<ComponentTypes>): number | null;
+    getParent(entityId: number): number | null;
     /**
      * Get all children of an entity in insertion order
-     * @param parentOrId The parent entity or entity ID
+     * @param parentId The parent entity ID
      * @returns Readonly array of child entity IDs
      */
-    getChildren(parentOrId: number | Entity<ComponentTypes>): readonly number[];
+    getChildren(parentId: number): readonly number[];
     /**
      * Get a child at a specific index
-     * @param parentOrId The parent entity or entity ID
+     * @param parentId The parent entity ID
      * @param index The index of the child
      * @returns The child entity ID, or null if index is out of bounds
      */
-    getChildAt(parentOrId: number | Entity<ComponentTypes>, index: number): number | null;
+    getChildAt(parentId: number, index: number): number | null;
     /**
      * Get the index of a child within its parent's children list
-     * @param parentOrId The parent entity or entity ID
-     * @param childOrId The child entity or entity ID to find
+     * @param parentId The parent entity ID
+     * @param childId The child entity ID to find
      * @returns The index of the child, or -1 if not found
      */
-    getChildIndex(parentOrId: number | Entity<ComponentTypes>, childOrId: number | Entity<ComponentTypes>): number;
+    getChildIndex(parentId: number, childId: number): number;
     /**
      * Get all ancestors of an entity in order [parent, grandparent, ...]
-     * @param entityOrId The entity or entity ID to get ancestors of
+     * @param entityId The entity ID to get ancestors of
      * @returns Readonly array of ancestor entity IDs
      */
-    getAncestors(entityOrId: number | Entity<ComponentTypes>): readonly number[];
+    getAncestors(entityId: number): readonly number[];
     /**
      * Get all descendants of an entity in depth-first order
-     * @param entityOrId The entity or entity ID to get descendants of
+     * @param entityId The entity ID to get descendants of
      * @returns Readonly array of descendant entity IDs
      */
-    getDescendants(entityOrId: number | Entity<ComponentTypes>): readonly number[];
+    getDescendants(entityId: number): readonly number[];
     /**
      * Get the root ancestor of an entity (topmost parent), or self if no parent
-     * @param entityOrId The entity or entity ID to get the root of
+     * @param entityId The entity ID to get the root of
      * @returns The root entity ID
      */
-    getRoot(entityOrId: number | Entity<ComponentTypes>): number;
+    getRoot(entityId: number): number;
     /**
      * Get siblings of an entity (other children of the same parent)
-     * @param entityOrId The entity or entity ID to get siblings of
+     * @param entityId The entity ID to get siblings of
      * @returns Readonly array of sibling entity IDs
      */
-    getSiblings(entityOrId: number | Entity<ComponentTypes>): readonly number[];
+    getSiblings(entityId: number): readonly number[];
     /**
      * Check if an entity is a descendant of another entity
-     * @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
+     * @param entityId The potential descendant ID
+     * @param ancestorId The potential ancestor ID
+     * @returns true if entityId is a descendant of ancestorId
      */
-    isDescendantOf(entityOrId: number | Entity<ComponentTypes>, ancestorOrId: number | Entity<ComponentTypes>): boolean;
+    isDescendantOf(entityId: number, ancestorId: number): boolean;
     /**
      * Check if an entity is an ancestor of another entity
-     * @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
+     * @param entityId The potential ancestor ID
+     * @param descendantId The potential descendant ID
+     * @returns true if entityId is an ancestor of descendantId
      */
-    isAncestorOf(entityOrId: number | Entity<ComponentTypes>, descendantOrId: number | Entity<ComponentTypes>): boolean;
+    isAncestorOf(entityId: number, descendantId: number): boolean;
     /**
      * Get all root entities (entities that have children but no parent)
      * @returns Readonly array of root entity IDs

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import ECSpresso from './ecspresso';
-import { SystemBuilder } from './system-builder';
-import Bundle, { mergeBundles } from './bundle';
+import { SystemBuilder, type ProcessContext } from './system-builder';
+import { type Plugin, type BasePluginOptions, definePlugin } from './plugin';
 export * from './types';
 export * from './asset-types';
 export * from './screen-types';
@@ -8,6 +8,7 @@ export * from './utils/math';
 export type { ReactiveQueryDefinition } from './reactive-query-manager';
 export { default as AssetManager, createAssetConfigurator } from './asset-manager';
 export { default as ScreenManager, createScreenConfigurator } from './screen-manager';
-export { SystemBuilder };
-export { Bundle, mergeBundles };
+export { SystemBuilder, type ProcessContext };
+export { type Plugin, type BasePluginOptions, definePlugin };
+export { directValue, type ResourceDirectValue } from './resource-manager';
 export default ECSpresso;

package/dist/plugin.d.ts

@@ -0,0 +1,61 @@
+import type ECSpresso from './ecspresso';
+import type { SystemPhase } from './types';
+import type { WorldConfig, EmptyConfig, MergeConfigs, AnyECSpresso, ConfigOf } from './type-utils';
+/**
+ * Plugin interface for ECSpresso. A plugin is a plain object with an `install`
+ * function that configures a world directly, plus phantom properties for
+ * compile-time type extraction.
+ *
+ * @typeParam Cfg - The WorldConfig this plugin provides (components, events, resources, etc.)
+ * @typeParam Requires - The WorldConfig this plugin requires from other plugins
+ */
+export interface Plugin<Cfg extends WorldConfig = EmptyConfig, Requires extends WorldConfig = EmptyConfig, Labels extends string = never, Groups extends string = never, AssetGroupNames extends string = never, ReactiveQueryNames extends string = never> {
+    readonly id: string;
+    readonly install: (world: ECSpresso<MergeConfigs<Cfg, Requires>>) => void;
+    readonly _cfg?: Cfg;
+    readonly _requires?: Requires;
+    readonly _labels?: Labels;
+    readonly _groups?: Groups;
+    readonly _assetGroupNames?: AssetGroupNames;
+    readonly _reactiveQueryNames?: ReactiveQueryNames;
+}
+/**
+ * Common configuration options shared by most plugins.
+ * Plugin-specific options interfaces extend this with additional fields.
+ */
+export interface BasePluginOptions<G extends string = string> {
+    /** System group name for all systems registered by this plugin */
+    systemGroup?: G;
+    /** Priority for the plugin's primary system (default varies per plugin) */
+    priority?: number;
+    /** Execution phase for the plugin's primary system */
+    phase?: SystemPhase;
+}
+/**
+ * Factory function to create a type-safe Plugin with phantom type parameters.
+ * The type assertion adds phantom types without runtime cost.
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Explicit config type param
+ * const myPlugin = definePlugin<WorldConfigFrom<MyComponents, MyEvents, MyResources>>({
+ *   id: 'my-plugin',
+ *   install(world) { ... },
+ * });
+ *
+ * // Option 2: Single world type param (extracts config automatically)
+ * type MyWorld = typeof ecs;
+ * const myPlugin = definePlugin<MyWorld>({
+ *   id: 'my-plugin',
+ *   install(world) { ... },
+ * });
+ * ```
+ */
+export declare function definePlugin<W extends AnyECSpresso, Requires extends WorldConfig = EmptyConfig, Labels extends string = never, Groups extends string = never, AssetGroupNames extends string = never, ReactiveQueryNames extends string = never>(config: {
+    id: string;
+    install: (world: W) => void;
+}): Plugin<ConfigOf<W>, Requires, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;
+export declare function definePlugin<Cfg extends WorldConfig = EmptyConfig, Requires extends WorldConfig = EmptyConfig, Labels extends string = never, Groups extends string = never, AssetGroupNames extends string = never, ReactiveQueryNames extends string = never>(config: {
+    id: string;
+    install: (world: ECSpresso<MergeConfigs<Cfg, Requires>>) => void;
+}): Plugin<Cfg, Requires, Labels, Groups, AssetGroupNames, ReactiveQueryNames>;

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

@@ -1,12 +1,13 @@
 /**
- * Audio Bundle for ECSpresso
+ * Audio Plugin for ECSpresso
  *
  * Web Audio API integration via Howler.js for sound effects and music playback.
  * User-defined channels with type-safe volume control, hybrid resource + component API,
  * and asset manager integration.
  */
-import { Bundle } from 'ecspresso';
-import type { SystemPhase, AssetsOfWorld } from 'ecspresso';
+import { type Plugin, type BasePluginOptions } from 'ecspresso';
+import type { AssetsOfWorld, AnyECSpresso, ChannelOfWorld } from 'ecspresso';
+import type { WorldConfigFrom, EmptyConfig } from '../type-utils';
 import type { Howl } from 'howler';
 /**
  * Configuration for a single audio channel.
@@ -56,7 +57,7 @@ export interface AudioSource<Ch extends string = string> {
     _soundId: number;
 }
 /**
- * Component types provided by the audio bundle.
+ * Component types provided by the audio plugin.
  */
 export interface AudioComponentTypes<Ch extends string = string> {
     audioSource: AudioSource<Ch>;
@@ -93,7 +94,7 @@ export interface SoundEndedEvent {
     sound: string;
 }
 /**
- * Event types provided by the audio bundle.
+ * Event types provided by the audio plugin.
  */
 export interface AudioEventTypes<Ch extends string = string> {
     playSound: PlaySoundEvent<Ch>;
@@ -157,23 +158,17 @@ export interface AudioState<Ch extends string = string> {
     isMuted(): boolean;
 }
 /**
- * Resource types provided by the audio bundle.
+ * Resource types provided by the audio plugin.
  */
 export interface AudioResourceTypes<Ch extends string = string> {
     audioState: AudioState<Ch>;
 }
 /**
- * Configuration options for the audio bundle.
+ * Configuration options for the audio plugin.
  */
-export interface AudioBundleOptions<Ch extends string, G extends string = 'audio'> {
+export interface AudioPluginOptions<Ch extends string, G extends string = 'audio'> extends BasePluginOptions<G> {
     /** Channel definitions from defineAudioChannels */
     channels: Readonly<Record<Ch, AudioChannelConfig>>;
-    /** System group name (default: 'audio') */
-    systemGroup?: G;
-    /** Priority for audio sync system (default: 0) */
-    priority?: number;
-    /** Execution phase (default: 'update') */
-    phase?: SystemPhase;
 }
 /**
  * Create an audioSource component for entity-attached audio.
@@ -219,7 +214,7 @@ export declare function loadSound(src: string | string[], options?: {
     preload?: boolean;
 }): () => Promise<Howl>;
 /**
- * Create an audio bundle for ECSpresso.
+ * Create an audio plugin for ECSpresso.
  *
  * Provides:
  * - `audioState` resource for fire-and-forget SFX and music
@@ -240,7 +235,7 @@ export declare function loadSound(src: string | string[], options?: {
  *
  * const ecs = ECSpresso.create()
  *   .withAssets(a => a.add('explosion', loadSound('/sfx/boom.mp3')))
- *   .withBundle(createAudioBundle({ channels }))
+ *   .withPlugin(createAudioPlugin({ channels }))
  *   .build();
  *
  * await ecs.initialize();
@@ -248,46 +243,31 @@ export declare function loadSound(src: string | string[], options?: {
  * audio.play('explosion', { channel: 'sfx' });
  * ```
  */
-export declare function createAudioBundle<Ch extends string, G extends string = 'audio'>(options: AudioBundleOptions<Ch, G>): Bundle<AudioComponentTypes<Ch>, AudioEventTypes<Ch>, AudioResourceTypes<Ch>, {}, {}, 'audio-sync', G, never, 'audio-sources'>;
-type AnyECSpresso = import('ecspresso').default<any, any, any, any, any, any, any>;
+export declare function createAudioPlugin<Ch extends string, G extends string = 'audio'>(options: AudioPluginOptions<Ch, G>): Plugin<WorldConfigFrom<AudioComponentTypes<Ch>, AudioEventTypes<Ch>, AudioResourceTypes<Ch>>, EmptyConfig, 'audio-sync', G, never, 'audio-sources'>;
 /**
- * Kit result from createAudioKit.
- */
-export interface AudioKit<W extends AnyECSpresso, Ch extends string, G extends string = 'audio'> {
-    bundle: Bundle<AudioComponentTypes<Ch>, AudioEventTypes<Ch>, AudioResourceTypes<Ch>, {}, {}, 'audio-sync', G, never, 'audio-sources'>;
-    createAudioSource: (sound: keyof AssetsOfWorld<W> & string, channel: Ch, options?: {
-        volume?: number;
-        loop?: boolean;
-        autoRemove?: boolean;
-    }) => Pick<AudioComponentTypes<Ch>, 'audioSource'>;
-    loadSound: typeof loadSound;
-}
-/**
- * Create a typed audio kit that captures the world type W and channel type Ch.
- *
- * The returned `createAudioSource` validates sound keys against the world's
- * asset types at compile time.
+ * Typed helpers for the audio plugin.
+ * Creates helpers that validate sound keys and channel names against the world type W.
+ * Call after .build() using typeof ecs.
  *
  * @template W - Concrete ECS world type (e.g. `typeof ecs`)
- * @template Ch - Channel name union from defineAudioChannels
- * @template G - System group name (default: 'audio')
- * @param options - Bundle configuration including channel definitions
- * @returns A kit object with bundle, createAudioSource, loadSound
  *
  * @example
  * ```typescript
- * const channels = defineAudioChannels({ sfx: { volume: 1 }, music: { volume: 0.7 } });
- * type Ch = ChannelsOf<typeof channels>;
- * const kit = createAudioKit<typeof ecs, Ch>({ channels });
- *
  * const ecs = ECSpresso.create()
- *   .withBundle(kit.bundle)
+ *   .withPlugin(createAudioPlugin({ channels }))
  *   .withAssets(a => a.add('boom', loadSound('/sfx/boom.mp3')))
  *   .build();
  *
- * // Type-safe: 'boom' must be a registered asset
- * kit.createAudioSource('boom', 'sfx');
+ * const { createAudioSource } = createAudioHelpers<typeof ecs>();
+ * // Type-safe: 'boom' must be a registered asset, 'sfx' a valid channel
+ * createAudioSource('boom', 'sfx');
  * ```
  */
-export declare function createAudioKit<W extends AnyECSpresso, Ch extends string, G extends string = 'audio'>(options: AudioBundleOptions<Ch, G>): AudioKit<W, Ch, G>;
-export {};
+export interface AudioHelpers<W extends AnyECSpresso> {
+    createAudioSource: (sound: keyof AssetsOfWorld<W> & string, channel: ChannelOfWorld<W>, options?: {
+        volume?: number;
+        loop?: boolean;
+        autoRemove?: boolean;
+    }) => Pick<AudioComponentTypes<ChannelOfWorld<W>>, 'audioSource'>;
+}
+export declare function createAudioHelpers<W extends AnyECSpresso>(_world?: W): AudioHelpers<W>;

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

@@ -1,13 +1,13 @@
 /**
- * Bounds Bundle for ECSpresso
+ * Bounds Plugin for ECSpresso
  *
  * Provides screen bounds enforcement for entities with transforms.
  * Reads worldTransform for position checking; modifies localTransform for corrections.
  * Supports destroy, clamp, and wrap behaviors.
  */
-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';
 /**
  * Component that marks an entity for destruction when outside bounds.
  */
@@ -30,14 +30,14 @@ export interface WrapAtBounds {
     padding?: number;
 }
 /**
- * Component types provided by the bounds bundle.
- * Included automatically via `.withBundle(createBoundsBundle())`.
+ * Component types provided by the bounds plugin.
+ * Included automatically via `.withPlugin(createBoundsPlugin())`.
  *
  * @example
  * ```typescript
  * const ecs = ECSpresso.create()
- *   .withBundle(createTransformBundle())
- *   .withBundle(createBoundsBundle({ width: 800, height: 600 }))
+ *   .withPlugin(createTransformPlugin())
+ *   .withPlugin(createBoundsPlugin({ width: 800, height: 600 }))
  *   .withComponentTypes<{ sprite: Sprite }>()
  *   .build();
  * ```
@@ -61,7 +61,7 @@ export interface BoundsRect {
     height: number;
 }
 /**
- * Resource types provided by the bounds bundle.
+ * Resource types provided by the bounds plugin.
  */
 export interface BoundsResourceTypes {
     bounds: BoundsRect;
@@ -76,25 +76,19 @@ export interface EntityOutOfBoundsEvent {
     exitEdge: 'top' | 'bottom' | 'left' | 'right';
 }
 /**
- * Event types provided by the bounds bundle.
+ * Event types provided by the bounds plugin.
  */
 export interface BoundsEventTypes {
     entityOutOfBounds: EntityOutOfBoundsEvent;
 }
 /**
- * Configuration options for the bounds bundle.
+ * Configuration options for the bounds plugin.
  */
-export interface BoundsBundleOptions<G extends string = 'physics'> {
-    /** System group name (default: 'physics') */
-    systemGroup?: G;
-    /** Priority for bounds systems (default: 50) */
-    priority?: number;
+export interface BoundsPluginOptions<G extends string = 'physics'> extends BasePluginOptions<G> {
     /** Resource key for bounds rectangle (default: 'bounds') */
     boundsResourceKey?: string;
     /** Whether to auto-remove entities when out of bounds (default: true) */
     autoRemove?: boolean;
-    /** Execution phase (default: 'postUpdate') */
-    phase?: SystemPhase;
 }
 /**
  * Create a bounds rectangle resource.
@@ -158,11 +152,10 @@ export declare function createClampToBounds(margin?: number): Pick<BoundsCompone
  * ```
  */
 export declare function createWrapAtBounds(padding?: number): Pick<BoundsComponentTypes, 'wrapAtBounds'>;
-type CombinedComponentTypes = BoundsComponentTypes & TransformComponentTypes;
 /**
- * Create a bounds bundle for ECSpresso.
+ * Create a bounds plugin for ECSpresso.
  *
- * This bundle provides:
+ * This plugin provides:
  * - Destroy out of bounds system - removes entities that exit bounds
  * - Clamp to bounds system - constrains entities within bounds
  * - Wrap at bounds system - wraps entities to opposite edge
@@ -176,8 +169,8 @@ type CombinedComponentTypes = BoundsComponentTypes & TransformComponentTypes;
  * const ecs = ECSpresso
  *   .create<Components, Events, Resources>()
  *   .withResource('bounds', createBounds(800, 600))
- *   .withBundle(createTransformBundle())
- *   .withBundle(createBoundsBundle())
+ *   .withPlugin(createTransformPlugin())
+ *   .withPlugin(createBoundsPlugin())
  *   .build();
  *
  * // Entity that gets destroyed when leaving screen
@@ -187,5 +180,4 @@ type CombinedComponentTypes = BoundsComponentTypes & TransformComponentTypes;
  * });
  * ```
  */
-export declare function createBoundsBundle<ResourceTypes extends BoundsResourceTypes = BoundsResourceTypes, G extends string = 'physics'>(options?: BoundsBundleOptions<G>): Bundle<CombinedComponentTypes, BoundsEventTypes, ResourceTypes, {}, {}, 'bounds-destroy' | 'bounds-clamp' | 'bounds-wrap', G>;
-export {};
+export declare function createBoundsPlugin<ResourceTypes extends BoundsResourceTypes = BoundsResourceTypes, G extends string = 'physics'>(options?: BoundsPluginOptions<G>): Plugin<WorldConfigFrom<BoundsComponentTypes, BoundsEventTypes, ResourceTypes>, TransformWorldConfig, 'bounds-destroy' | 'bounds-clamp' | 'bounds-wrap', G>;

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

@@ -1,20 +1,21 @@
 /**
- * Camera / Viewport Bundle for ECSpresso
+ * Camera / Viewport Plugin for ECSpresso
  *
  * Provides a camera entity with world/screen coordinate conversion, smooth follow,
  * trauma-based shake, bounds clamping, and logical viewport dimensions.
  *
- * This bundle is renderer-agnostic. PixiJS or other renderer integration (applying
+ * This plugin is renderer-agnostic. PixiJS or other renderer integration (applying
  * cameraState to a container/stage transform) is the consumer's responsibility.
  *
  * Camera uses its own x/y/zoom/rotation rather than localTransform/worldTransform.
  * It reads the target entity's worldTransform for follow, but doesn't participate
  * in the transform hierarchy itself.
  */
-import { Bundle } from 'ecspresso';
+import { type Plugin } from 'ecspresso';
 import type { SystemPhase } from 'ecspresso';
 import type ECSpresso from 'ecspresso';
-import type { TransformComponentTypes } from './transform';
+import type { WorldConfigFrom } from '../type-utils';
+import type { TransformWorldConfig } from './transform';
 export interface Camera {
     x: number;
     y: number;
@@ -48,7 +49,6 @@ export interface CameraComponentTypes {
     cameraShake: CameraShake;
     cameraBounds: CameraBounds;
 }
-type CombinedComponentTypes = CameraComponentTypes & TransformComponentTypes;
 export interface CameraState {
     x: number;
     y: number;
@@ -63,7 +63,7 @@ export interface CameraState {
 export interface CameraResourceTypes {
     cameraState: CameraState;
 }
-export interface CameraBundleOptions<G extends string = 'camera'> {
+export interface CameraPluginOptions<G extends string = 'camera'> {
     viewportWidth?: number;
     viewportHeight?: number;
     systemGroup?: G;
@@ -76,7 +76,7 @@ export declare function createCamera(x?: number, y?: number, zoom?: number, rota
 export declare function createCameraFollow(target: number, options?: Partial<Omit<CameraFollow, 'target'>>): Pick<CameraComponentTypes, 'cameraFollow'>;
 export declare function createCameraShake(options?: Partial<CameraShake>): Pick<CameraComponentTypes, 'cameraShake'>;
 export declare function createCameraBounds(minX: number, minY: number, maxX: number, maxY: number): Pick<CameraComponentTypes, 'cameraBounds'>;
-export declare function addTrauma<C extends CombinedComponentTypes, R extends CameraResourceTypes>(ecs: ECSpresso<C, any, R>, entityId: number, amount: number): void;
+export declare function addTrauma<Cfg extends WorldConfigFrom<CameraComponentTypes, {}, CameraResourceTypes>>(ecs: ECSpresso<Cfg>, entityId: number, amount: number): void;
 export declare function worldToScreen(worldX: number, worldY: number, state: CameraState): {
     x: number;
     y: number;
@@ -85,5 +85,4 @@ export declare function screenToWorld(screenX: number, screenY: number, state: C
     x: number;
     y: number;
 };
-export declare function createCameraBundle<G extends string = 'camera'>(options?: CameraBundleOptions<G>): Bundle<CombinedComponentTypes, {}, CameraResourceTypes, {}, {}, 'camera-follow' | 'camera-shake-update' | 'camera-bounds' | 'camera-state-sync', G>;
-export {};
+export declare function createCameraPlugin<G extends string = 'camera'>(options?: CameraPluginOptions<G>): Plugin<WorldConfigFrom<CameraComponentTypes, {}, CameraResourceTypes>, TransformWorldConfig, 'camera-follow' | 'camera-shake-update' | 'camera-bounds' | 'camera-state-sync', G>;