ecspresso 0.11.0 → 0.12.0

package/dist/type-utils.d.ts

@@ -2,6 +2,7 @@
  * Utility types for ECSpresso ECS framework
  * This file contains reusable type helpers used across the codebase
  */
+import type { ScreenDefinition } from './screen-types';
 /**
  * Check if two types are exactly the same for overlapping keys
  */
@@ -16,11 +17,89 @@ export type TypesAreCompatible<T extends Record<string, any>, U extends Record<s
     [K in keyof T & keyof U]: ExactlyCompatible<T[K], U[K]>;
 }[keyof T & keyof U] extends false ? false : true;
 /**
- * Bundle compatibility checker.
- * Returns true if bundles can be merged without type conflicts.
- * All overlapping keys across all type categories must have identical types.
+ * Single config object that bundles all 5 world type dimensions.
+ * Replaces the 5 positional type params (ComponentTypes, EventTypes,
+ * ResourceTypes, AssetTypes, ScreenStates) throughout the codebase.
  */
-export type BundlesAreCompatible<C1 extends Record<string, any>, C2 extends Record<string, any>, E1 extends Record<string, any>, E2 extends Record<string, any>, R1 extends Record<string, any>, R2 extends Record<string, any>, A1 extends Record<string, unknown> = {}, A2 extends Record<string, unknown> = {}, S1 extends Record<string, any> = {}, S2 extends Record<string, any> = {}> = TypesAreCompatible<C1, C2> extends true ? TypesAreCompatible<E1, E2> extends true ? TypesAreCompatible<R1, R2> extends true ? TypesAreCompatible<A1, A2> extends true ? TypesAreCompatible<S1, S2> : false : false : false : false;
+export interface WorldConfig {
+    readonly components: Record<string, any>;
+    readonly events: Record<string, any>;
+    readonly resources: Record<string, any>;
+    readonly assets: Record<string, unknown>;
+    readonly screens: Record<string, ScreenDefinition<any, any>>;
+}
+/**
+ * Construct a WorldConfig from individual type dimensions.
+ * All parameters default to empty records.
+ */
+export type WorldConfigFrom<C extends Record<string, any> = {}, E extends Record<string, any> = {}, R extends Record<string, any> = {}, A extends Record<string, unknown> = {}, S extends Record<string, ScreenDefinition<any, any>> = {}> = {
+    readonly components: C;
+    readonly events: E;
+    readonly resources: R;
+    readonly assets: A;
+    readonly screens: S;
+};
+/**
+ * Empty WorldConfig with all slots defaulting to {}.
+ */
+export type EmptyConfig = WorldConfigFrom;
+/**
+ * Merge two WorldConfig types by intersecting each slot.
+ */
+export type MergeConfigs<A extends WorldConfig, B extends WorldConfig> = {
+    readonly components: A['components'] & B['components'];
+    readonly events: A['events'] & B['events'];
+    readonly resources: A['resources'] & B['resources'];
+    readonly assets: A['assets'] & B['assets'];
+    readonly screens: A['screens'] & B['screens'];
+};
+export type WithComponents<Cfg extends WorldConfig, T> = {
+    readonly components: Cfg['components'] & T;
+    readonly events: Cfg['events'];
+    readonly resources: Cfg['resources'];
+    readonly assets: Cfg['assets'];
+    readonly screens: Cfg['screens'];
+};
+export type WithEvents<Cfg extends WorldConfig, T> = {
+    readonly components: Cfg['components'];
+    readonly events: Cfg['events'] & T;
+    readonly resources: Cfg['resources'];
+    readonly assets: Cfg['assets'];
+    readonly screens: Cfg['screens'];
+};
+export type WithResources<Cfg extends WorldConfig, T> = {
+    readonly components: Cfg['components'];
+    readonly events: Cfg['events'];
+    readonly resources: Cfg['resources'] & T;
+    readonly assets: Cfg['assets'];
+    readonly screens: Cfg['screens'];
+};
+export type WithAssets<Cfg extends WorldConfig, T> = {
+    readonly components: Cfg['components'];
+    readonly events: Cfg['events'];
+    readonly resources: Cfg['resources'];
+    readonly assets: Cfg['assets'] & T;
+    readonly screens: Cfg['screens'];
+};
+export type WithScreens<Cfg extends WorldConfig, T> = {
+    readonly components: Cfg['components'];
+    readonly events: Cfg['events'];
+    readonly resources: Cfg['resources'];
+    readonly assets: Cfg['assets'];
+    readonly screens: Cfg['screens'] & T;
+};
+/**
+ * Check if two WorldConfig types are compatible (no conflicting keys
+ * across any slot).
+ */
+export type ConfigsAreCompatible<A extends WorldConfig, B extends WorldConfig> = TypesAreCompatible<A['components'], B['components']> extends true ? TypesAreCompatible<A['events'], B['events']> extends true ? TypesAreCompatible<A['resources'], B['resources']> extends true ? TypesAreCompatible<A['assets'], B['assets']> extends true ? TypesAreCompatible<A['screens'], B['screens']> : false : false : false : false;
+/**
+ * Check if a Requires config is satisfied by an Accumulated config.
+ * Checks all five WorldConfig slots (components, events, resources, assets, screens).
+ * When Required is EmptyConfig, all slots have `keyof {} = never`,
+ * and `never extends X = true`, so empty requirements are always satisfied.
+ */
+export type RequirementsSatisfied<Accumulated extends WorldConfig, Required extends WorldConfig> = keyof Required['components'] extends keyof Accumulated['components'] ? keyof Required['events'] extends keyof Accumulated['events'] ? keyof Required['resources'] extends keyof Accumulated['resources'] ? keyof Required['assets'] extends keyof Accumulated['assets'] ? keyof Required['screens'] extends keyof Accumulated['screens'] ? true : false : false : false : false : false;
 /**
  * Utility type for merging two types
  */
@@ -30,55 +109,167 @@ export type Merge<T1, T2> = T1 & T2;
  */
 export type MergeAll<T extends any[]> = T extends [infer First, ...infer Rest] ? Rest extends [] ? First : Merge<First, MergeAll<Rest>> : {};
 /**
- * Extract the ComponentTypes from a Bundle instance
+ * Wildcard ECSpresso type that any concrete instance is assignable to.
+ * Use as a generic constraint for functions that accept any ECSpresso world.
+ * Matches the phantom _cfg property declared on the ECSpresso class.
  */
-export type ComponentsOf<B> = B extends import('./bundle').default<infer C extends Record<string, any>, any, any, any, any, any, any, any, any> ? C : never;
+export type AnyECSpresso = {
+    readonly _cfg: WorldConfig;
+};
 /**
- * Extract the EventTypes from a Bundle instance
+ * Wildcard Plugin type that any concrete plugin is assignable to.
+ * Matches the phantom _cfg and _requires properties declared on the Plugin interface.
  */
-export type EventsOf<B> = B extends import('./bundle').default<any, infer E extends Record<string, any>, any, any, any, any, any, any, any> ? E : never;
+export type AnyPlugin = {
+    readonly _cfg?: WorldConfig;
+    readonly _requires?: WorldConfig;
+};
 /**
- * Extract the ResourceTypes from a Bundle instance
+ * Extract the full WorldConfig from a Plugin or ECSpresso instance
  */
-export type ResourcesOf<B> = B extends import('./bundle').default<any, any, infer R extends Record<string, any>, any, any, any, any, any, any> ? R : never;
+export type ConfigOf<B> = B extends {
+    readonly _cfg: infer Cfg extends WorldConfig;
+} ? Cfg : never;
 /**
- * Extract the system Labels from a Bundle instance
+ * Extract the ComponentTypes from a Plugin or ECSpresso instance
  */
-export type LabelsOf<B> = B extends import('./bundle').default<any, any, any, any, any, infer L extends string, any, any, any> ? L : never;
+export type ComponentsOf<B> = B extends {
+    readonly _cfg: {
+        components: infer C extends Record<string, any>;
+    };
+} ? C : B extends {
+    readonly _cfg?: {
+        components: infer C extends Record<string, any>;
+    };
+} ? C : never;
 /**
- * Extract the system Groups from a Bundle instance
+ * Extract the EventTypes from a Plugin or ECSpresso instance
  */
-export type GroupsOf<B> = B extends import('./bundle').default<any, any, any, any, any, any, infer G extends string, any, any> ? G : never;
+export type EventsOf<B> = B extends {
+    readonly _cfg: {
+        events: infer E extends Record<string, any>;
+    };
+} ? E : B extends {
+    readonly _cfg?: {
+        events: infer E extends Record<string, any>;
+    };
+} ? E : never;
 /**
- * Extract the AssetGroupNames from a Bundle instance
+ * Extract the ResourceTypes from a Plugin or ECSpresso instance
  */
-export type AssetGroupNamesOf<B> = B extends import('./bundle').default<any, any, any, any, any, any, any, infer AG extends string, any> ? AG : never;
+export type ResourcesOf<B> = B extends {
+    readonly _cfg: {
+        resources: infer R extends Record<string, any>;
+    };
+} ? R : B extends {
+    readonly _cfg?: {
+        resources: infer R extends Record<string, any>;
+    };
+} ? R : never;
 /**
- * Extract the ReactiveQueryNames from a Bundle instance
+ * Extract AssetTypes from a Plugin or ECSpresso instance
  */
-export type ReactiveQueryNamesOf<B> = B extends import('./bundle').default<any, any, any, any, any, any, any, any, infer RQ extends string> ? RQ : never;
+export type AssetTypesOf<B> = B extends {
+    readonly _cfg: {
+        assets: infer A extends Record<string, unknown>;
+    };
+} ? A : B extends {
+    readonly _cfg?: {
+        assets: infer A extends Record<string, unknown>;
+    };
+} ? A : never;
 /**
- * Extract AssetTypes from a Bundle instance
+ * Extract ScreenStates from a Plugin or ECSpresso instance
  */
-export type AssetTypesOf<B> = B extends import('./bundle').default<any, any, any, infer A extends Record<string, unknown>, any, any, any, any, any> ? A : never;
+export type ScreenStatesOf<B> = B extends {
+    readonly _cfg: {
+        screens: infer S extends Record<string, ScreenDefinition<any, any>>;
+    };
+} ? S : B extends {
+    readonly _cfg?: {
+        screens: infer S extends Record<string, ScreenDefinition<any, any>>;
+    };
+} ? S : never;
 /**
- * Extract ScreenStates from a Bundle instance
+ * Extract the system Labels from a Plugin instance
  */
-export type ScreenStatesOf<B> = B extends import('./bundle').default<any, any, any, any, infer S extends Record<string, import('./screen-types').ScreenDefinition<any, any>>, any, any, any, any> ? S : never;
+export type LabelsOf<B> = B extends {
+    readonly _labels?: infer L;
+} ? L extends string ? L : never : never;
 /**
- * Extract ScreenStates from an ECSpresso world instance type
+ * Extract the system Groups from a Plugin instance
  */
-export type ScreenStatesOfWorld<W> = W extends import('./ecspresso').default<any, any, any, any, infer S extends Record<string, import('./screen-types').ScreenDefinition<any, any>>, any, any, any, any> ? S : never;
+export type GroupsOf<B> = B extends {
+    readonly _groups?: infer G;
+} ? G extends string ? G : never : never;
+/**
+ * Extract the AssetGroupNames from a Plugin instance
+ */
+export type AssetGroupNamesOf<B> = B extends {
+    readonly _assetGroupNames?: infer AG;
+} ? AG extends string ? AG : never : never;
+/**
+ * Extract the ReactiveQueryNames from a Plugin instance
+ */
+export type ReactiveQueryNamesOf<B> = B extends {
+    readonly _reactiveQueryNames?: infer RQ;
+} ? RQ extends string ? RQ : never : never;
 /**
  * Extract ComponentTypes from an ECSpresso world instance type.
  */
-export type ComponentsOfWorld<W> = W extends import('./ecspresso').default<infer C extends Record<string, any>, any, any, any, any, any, any, any, any> ? C : never;
+export type ComponentsOfWorld<W> = W extends {
+    readonly _cfg: {
+        components: infer C extends Record<string, any>;
+    };
+} ? C : never;
 /**
  * Extract EventTypes from an ECSpresso world instance type.
  */
-export type EventsOfWorld<W> = W extends import('./ecspresso').default<any, infer E extends Record<string, any>, any, any, any, any, any, any, any> ? E : never;
+export type EventsOfWorld<W> = W extends {
+    readonly _cfg: {
+        events: infer E extends Record<string, any>;
+    };
+} ? E : never;
 /**
  * Extract AssetTypes from an ECSpresso world instance type.
  */
-export type AssetsOfWorld<W> = W extends import('./ecspresso').default<any, any, any, infer A extends Record<string, unknown>, any, any, any, any, any> ? A : never;
+export type AssetsOfWorld<W> = W extends {
+    readonly _cfg: {
+        assets: infer A extends Record<string, unknown>;
+    };
+} ? A : never;
+/**
+ * Extract ScreenStates from an ECSpresso world instance type
+ */
+export type ScreenStatesOfWorld<W> = W extends {
+    readonly _cfg: {
+        screens: infer S extends Record<string, ScreenDefinition<any, any>>;
+    };
+} ? S : never;
+/**
+ * Extract event names from an EventTypes record whose payload extends the given shape.
+ * Eliminates the need for each plugin to define its own mapped filter type.
+ *
+ * @example
+ * ```typescript
+ * interface MyEventData { entityId: number }
+ * type MyEventName<ET> = EventNameMatching<ET, MyEventData>;
+ * ```
+ */
+export type EventNameMatching<ET extends Record<string, any>, Payload> = {
+    [K in keyof ET & string]: ET[K] extends Payload ? K : never;
+}[keyof ET & string];
+/**
+ * Extract the channel type from a world's AudioSource component.
+ * Falls back to `string` if the world has no audioSource component.
+ */
+export type ChannelOfWorld<W> = W extends {
+    readonly _cfg: {
+        components: {
+            audioSource: {
+                channel: infer Ch extends string;
+            };
+        };
+    };
+} ? Ch : string;
 export {};

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import ECSpresso from "./ecspresso";
+import type { WorldConfig, EmptyConfig, WorldConfigFrom } from "./type-utils";
 /**
  * Execution phase for systems. Systems are grouped by phase and executed
  * in this fixed order: preUpdate -> fixedUpdate -> update -> postUpdate -> render.
@@ -109,7 +110,7 @@ export type QueryDefinition<ComponentTypes extends Record<string, any>, WithComp
  *
  * world.addSystem('movement')
  *   .addQuery('entities', movingEntitiesQuery)
- *   .setProcess((queries) => {
+ *   .setProcess(({ queries }) => {
  *     for (const entity of queries.entities) {
  *       updatePosition(entity);
  *     }
@@ -123,7 +124,7 @@ export declare function createQueryDefinition<ComponentTypes extends Record<stri
     optional?: ReadonlyArray<keyof ComponentTypes>;
     parentHas?: ReadonlyArray<keyof ComponentTypes>;
 }>(queryDef: QueryDef): QueryDef;
-export interface System<ComponentTypes extends Record<string, any> = {}, WithComponents extends keyof ComponentTypes = never, WithoutComponents extends keyof ComponentTypes = never, EventTypes extends Record<string, any> = {}, ResourceTypes extends Record<string, any> = {}, AssetTypes extends Record<string, unknown> = {}, ScreenStates extends Record<string, any> = {}> {
+export interface System<Cfg extends WorldConfig = EmptyConfig, WithComponents extends keyof Cfg['components'] = never, WithoutComponents extends keyof Cfg['components'] = never> {
     label: string;
     /**
      * System priority - higher values execute first (default: 0)
@@ -144,17 +145,17 @@ export interface System<ComponentTypes extends Record<string, any> = {}, WithCom
      * Screens where this system should run. If specified, system only runs
      * when current screen is in this list.
      */
-    inScreens?: ReadonlyArray<keyof ScreenStates & string>;
+    inScreens?: ReadonlyArray<keyof Cfg['screens'] & string>;
     /**
      * Screens where this system should NOT run. If specified, system skips
      * when current screen is in this list.
      */
-    excludeScreens?: ReadonlyArray<keyof ScreenStates & string>;
+    excludeScreens?: ReadonlyArray<keyof Cfg['screens'] & string>;
     /**
      * Assets that must be loaded for this system to run.
      * System will be skipped if any required asset is not loaded.
      */
-    requiredAssets?: ReadonlyArray<keyof AssetTypes & string>;
+    requiredAssets?: ReadonlyArray<keyof Cfg['assets'] & string>;
     /**
      * When true, the system's process function runs even when all queries
      * return zero entities. Default is false (system is skipped when all
@@ -162,41 +163,68 @@ export interface System<ComponentTypes extends Record<string, any> = {}, WithCom
      */
     runWhenEmpty?: boolean;
     entityQueries?: {
-        [queryName: string]: QueryConfig<ComponentTypes, WithComponents, WithoutComponents>;
+        [queryName: string]: QueryConfig<Cfg['components'], WithComponents, WithoutComponents>;
     };
     /**
-     * Process method that runs during each update cycle
-     * @param queries The entity queries results based on system's entityQueries definition
-     * @param deltaTime Time elapsed since the last update in seconds
-     * @param ecs The ECSpresso instance providing access to all ECS functionality
+     * Process method that runs during each update cycle.
+     * Receives a single context object with queries, dt, and ecs.
      */
-    process?(queries: {
-        [queryName: string]: Array<FilteredEntity<ComponentTypes, WithComponents, WithoutComponents>>;
-    } | Array<FilteredEntity<ComponentTypes, WithComponents, WithoutComponents>>, deltaTime: number, ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>): void;
+    process?(ctx: {
+        queries: {
+            [queryName: string]: Array<FilteredEntity<Cfg['components'], WithComponents, WithoutComponents>>;
+        };
+        dt: number;
+        ecs: ECSpresso<Cfg>;
+    }): void;
     /**
      * Lifecycle hook called when the system is initialized
      * This is called when ECSpresso.initialize() is invoked, after resources are initialized
      * Use this for one-time initialization that depends on resources
      * @param ecs The ECSpresso instance providing access to all ECS functionality
      */
-    onInitialize?(ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>): void | Promise<void>;
+    onInitialize?(ecs: ECSpresso<Cfg>): void | Promise<void>;
     /**
      * Lifecycle hook called when the system is detached from the ECS
      * @param ecs The ECSpresso instance providing access to all ECS functionality
      */
-    onDetach?(ecs: import("./ecspresso").default<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>): void;
+    onDetach?(ecs: import("./ecspresso").default<Cfg>): void;
+    /**
+     * Per-query callbacks that fire once per entity the first time it appears
+     * in a query's results. Fires before process. Automatic cleanup when
+     * entity leaves query (component removed, entity destroyed) so re-entry
+     * fires the callback again.
+     */
+    onEntityEnter?: Record<string, (ctx: {
+        entity: FilteredEntity<Cfg['components'], WithComponents, WithoutComponents>;
+        ecs: ECSpresso<Cfg>;
+    }) => void>;
     /**
      * Event handlers for specific event types
      */
     eventHandlers?: {
-        [EventName in keyof EventTypes]?: {
-            /**
-             * Event handler function
-             * @param data The event data specific to this event type
-             * @param ecs The ECSpresso instance providing access to all ECS functionality
-             */
-            handler(data: EventTypes[EventName], ecs: ECSpresso<ComponentTypes, EventTypes, ResourceTypes, AssetTypes, ScreenStates>): void;
-        };
+        [EventName in keyof Cfg['events']]?: (ctx: {
+            data: Cfg['events'][EventName];
+            ecs: ECSpresso<Cfg>;
+        }) => void;
     };
 }
-export type { Merge, MergeAll, TypesAreCompatible, ComponentsOf, EventsOf, ResourcesOf, LabelsOf, GroupsOf, AssetGroupNamesOf, ReactiveQueryNamesOf, AssetTypesOf, ScreenStatesOf, ComponentsOfWorld, EventsOfWorld, AssetsOfWorld, ScreenStatesOfWorld } from './type-utils';
+/**
+ * Typed world interface for plugin helpers and structural typing.
+ *
+ * Generic over component types `C`:
+ * - `BaseWorld` (no param): defaults to `{}`, meaning component-accessing methods
+ *   cannot be called (keys resolve to `never`). Use for functions that only need
+ *   `removeEntity`, `getResource`, etc.
+ * - `BaseWorld<MyComponents>`: narrows `getComponent`, `hasComponent`, `markChanged`,
+ *   `spawn`, and command buffer methods to the declared component map.
+ *
+ * Structural typing ensures any `ECSpresso<Cfg>` where `Cfg['components']` is a
+ * superset of `C` satisfies `BaseWorld<C>`.
+ */
+type _BaseWorldCfg<C extends Record<string, any>> = WorldConfigFrom<C, Record<string, any>, Record<string, any>, Record<string, unknown>, Record<string, any>>;
+type _EventBus = import("./event-bus").default<Record<string, any>>;
+export type BaseWorld<C extends Record<string, any> = {}> = Pick<ECSpresso<_BaseWorldCfg<C>>, 'getComponent' | 'hasComponent' | 'removeEntity' | 'spawn' | 'markChanged' | 'getResource' | 'hasResource'> & {
+    eventBus: Pick<_EventBus, 'publish'>;
+    commands: Pick<import("./command-buffer").default<_BaseWorldCfg<C>>, 'spawn' | 'removeEntity' | 'addComponent' | 'removeComponent'>;
+};
+export type { Merge, MergeAll, TypesAreCompatible, ComponentsOf, EventsOf, ResourcesOf, LabelsOf, GroupsOf, AssetGroupNamesOf, ReactiveQueryNamesOf, AssetTypesOf, ScreenStatesOf, ComponentsOfWorld, EventsOfWorld, AssetsOfWorld, ScreenStatesOfWorld, AnyECSpresso, AnyPlugin, EventNameMatching, ChannelOfWorld, WorldConfig, EmptyConfig, WorldConfigFrom, MergeConfigs, ConfigsAreCompatible, ConfigOf, WithComponents, WithEvents, WithResources, WithAssets, WithScreens } from './type-utils';

package/dist/utils/check-required-cycle.d.ts

@@ -1,6 +1,6 @@
 /**
  * BFS cycle detection for required component graphs.
- * Shared by ECSpresso and Bundle.
+ * Shared by ECSpresso and Plugin.
  *
  * @param trigger     The component that triggers the requirement
  * @param newRequired The component about to be added as required

package/dist/utils/narrowphase.d.ts

@@ -2,8 +2,8 @@
  * Shared Narrowphase Module
  *
  * Provides contact-computing narrowphase tests and a generic collision
- * iteration pipeline used by both the collision bundle (event-only) and
- * the physics2D bundle (impulse response).
+ * iteration pipeline used by both the collision plugin (event-only) and
+ * the physics2D plugin (impulse response).
  */
 import type { SpatialIndex } from './spatial-hash';
 /** Contact result from a narrowphase test. Normal points from A toward B. */
@@ -31,7 +31,7 @@ export interface BaseColliderInfo<L extends string = string> {
 /**
  * Build a BaseColliderInfo from raw entity/collider component data.
  * Returns null if the entity has neither an AABB nor circle collider.
- * Shared by collision bundle (event-only) and physics2D bundle (impulse response).
+ * Shared by collision plugin (event-only) and physics2D plugin (impulse response).
  */
 export declare function buildBaseColliderInfo<L extends string>(entityId: number, x: number, y: number, layer: L, collidesWith: readonly L[], aabb: {
     width: number;
@@ -44,11 +44,11 @@ export declare function buildBaseColliderInfo<L extends string>(entityId: number
     offsetY?: number;
 } | undefined): BaseColliderInfo<L> | null;
 /**
- * Retrieve the optional spatialIndex resource, returning null when absent.
- * Centralizes the cross-bundle typed lookup so individual bundles don't each
+ * Retrieve the optional spatialIndex resource, returning undefined when absent.
+ * Centralizes the cross-plugin typed lookup so individual plugins don't each
  * need to import SpatialIndex or repeat the tryGetResource pattern.
  */
-export declare function tryGetSpatialIndex(tryGetResource: <T>(key: string) => T | undefined): SpatialIndex | null;
+export declare function tryGetSpatialIndex(tryGetResource: <T>(key: string) => T | undefined): SpatialIndex | undefined;
 export declare function computeAABBvsAABB(ax: number, ay: number, ahw: number, ahh: number, bx: number, by: number, bhw: number, bhh: number): Contact | null;
 export declare function computeCircleVsCircle(ax: number, ay: number, ar: number, bx: number, by: number, br: number): Contact | null;
 export declare function computeAABBvsCircle(aabbX: number, aabbY: number, ahw: number, ahh: number, circleX: number, circleY: number, radius: number): Contact | null;
@@ -60,4 +60,4 @@ export declare function computeContact(a: BaseColliderInfo, b: BaseColliderInfo)
  * Uses a context parameter forwarded to the callback to avoid
  * per-frame closure allocation.
  */
-export declare function detectCollisions<I extends BaseColliderInfo, C>(colliders: I[], spatialIndex: SpatialIndex | null, onContact: (a: I, b: I, contact: Contact, context: C) => void, context: C): void;
+export declare function detectCollisions<I extends BaseColliderInfo, C>(colliders: I[], spatialIndex: SpatialIndex | undefined, onContact: (a: I, b: I, contact: Contact, context: C) => void, context: C): void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ecspresso",
-	"version": "0.11.0",
+	"version": "0.12.0",
 	"main": "dist/index.js",
 	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -11,57 +11,65 @@
 			"import": "./dist/index.js",
 			"types": "./dist/index.d.ts"
 		},
-		"./bundles/renderers/renderer2D": {
-			"import": "./dist/bundles/renderers/renderer2D.js",
-			"types": "./dist/bundles/renderers/renderer2D.d.ts"
+		"./plugins/renderers/renderer2D": {
+			"import": "./dist/plugins/renderers/renderer2D.js",
+			"types": "./dist/plugins/renderers/renderer2D.d.ts"
 		},
-		"./bundles/bounds": {
-			"import": "./dist/bundles/bounds.js",
-			"types": "./dist/bundles/bounds.d.ts"
+		"./plugins/bounds": {
+			"import": "./dist/plugins/bounds.js",
+			"types": "./dist/plugins/bounds.d.ts"
 		},
-		"./bundles/camera": {
-			"import": "./dist/bundles/camera.js",
-			"types": "./dist/bundles/camera.d.ts"
+		"./plugins/camera": {
+			"import": "./dist/plugins/camera.js",
+			"types": "./dist/plugins/camera.d.ts"
 		},
-		"./bundles/collision": {
-			"import": "./dist/bundles/collision.js",
-			"types": "./dist/bundles/collision.d.ts"
+		"./plugins/collision": {
+			"import": "./dist/plugins/collision.js",
+			"types": "./dist/plugins/collision.d.ts"
 		},
-		"./bundles/diagnostics": {
-			"import": "./dist/bundles/diagnostics.js",
-			"types": "./dist/bundles/diagnostics.d.ts"
+		"./plugins/diagnostics": {
+			"import": "./dist/plugins/diagnostics.js",
+			"types": "./dist/plugins/diagnostics.d.ts"
 		},
-		"./bundles/input": {
-			"import": "./dist/bundles/input.js",
-			"types": "./dist/bundles/input.d.ts"
+		"./plugins/input": {
+			"import": "./dist/plugins/input.js",
+			"types": "./dist/plugins/input.d.ts"
 		},
-		"./bundles/physics2D": {
-			"import": "./dist/bundles/physics2D.js",
-			"types": "./dist/bundles/physics2D.d.ts"
+		"./plugins/physics2D": {
+			"import": "./dist/plugins/physics2D.js",
+			"types": "./dist/plugins/physics2D.d.ts"
 		},
-		"./bundles/spatial-index": {
-			"import": "./dist/bundles/spatial-index.js",
-			"types": "./dist/bundles/spatial-index.d.ts"
+		"./plugins/spatial-index": {
+			"import": "./dist/plugins/spatial-index.js",
+			"types": "./dist/plugins/spatial-index.d.ts"
 		},
-		"./bundles/state-machine": {
-			"import": "./dist/bundles/state-machine.js",
-			"types": "./dist/bundles/state-machine.d.ts"
+		"./plugins/state-machine": {
+			"import": "./dist/plugins/state-machine.js",
+			"types": "./dist/plugins/state-machine.d.ts"
 		},
-		"./bundles/timers": {
-			"import": "./dist/bundles/timers.js",
-			"types": "./dist/bundles/timers.d.ts"
+		"./plugins/timers": {
+			"import": "./dist/plugins/timers.js",
+			"types": "./dist/plugins/timers.d.ts"
 		},
-		"./bundles/transform": {
-			"import": "./dist/bundles/transform.js",
-			"types": "./dist/bundles/transform.d.ts"
+		"./plugins/transform": {
+			"import": "./dist/plugins/transform.js",
+			"types": "./dist/plugins/transform.d.ts"
 		},
-		"./bundles/tween": {
-			"import": "./dist/bundles/tween.js",
-			"types": "./dist/bundles/tween.d.ts"
+		"./plugins/tween": {
+			"import": "./dist/plugins/tween.js",
+			"types": "./dist/plugins/tween.d.ts"
 		},
-		"./bundles/audio": {
-			"import": "./dist/bundles/audio.js",
-			"types": "./dist/bundles/audio.d.ts"
+		"./plugins/audio": {
+			"import": "./dist/plugins/audio.js",
+			"types": "./dist/plugins/audio.d.ts"
+		},
+		"./plugins/sprite-animation": {
+			"import": "./dist/plugins/sprite-animation.js",
+			"types": "./dist/plugins/sprite-animation.d.ts"
+		},
+		"./plugins/particles": {
+			"import": "./dist/plugins/particles.js",
+			"types": "./dist/plugins/particles.d.ts"
 		}
 	},
 	"publishConfig": {
@@ -84,13 +92,13 @@
 	"devDependencies": {
 		"@types/bun": "latest",
 		"@types/howler": "^2.2.12",
-		"@types/three": "^0.180.0",
-		"howler": "^2.2.0",
-		"pixi.js": "^8.15.0",
-		"three": "^0.180.0"
+		"@types/three": "^0.183.1",
+		"howler": "^2.2.4",
+		"pixi.js": "^8.16.0",
+		"three": "^0.183.2"
 	},
 	"peerDependencies": {
-		"typescript": "^5.9.2",
+		"typescript": "^5.9.3",
 		"pixi.js": "^8.0.0",
 		"howler": "^2.2.0"
 	},