excalibur 0.33.0-alpha.99 → 1.1.0-alpha.310

package/build/{dist → esm/src/engine}/actions/action/move-by.d.ts

@@ -1,12 +1,11 @@
 import type { Entity } from '../../entity-component-system/entity';
 import type { Easing } from '../../math';
 import { Vector } from '../../math/vector';
-import type { EasingFunction } from '../../util/easing-functions';
 import type { Action } from '../action';
 export interface MoveByOptions {
     offset: Vector;
     duration: number;
-    easing?: Easing | EasingFunction;
+    easing?: Easing;
 }
 /**
  *
@@ -24,9 +23,7 @@ export declare class MoveByWithOptions implements Action {
     private _stopped;
     private _motion;
     private _offset;
-    private _legacyEasing;
     private _easing;
-    private _useLegacyEasing;
     constructor(entity: Entity, options: MoveByOptions);
     update(elapsed: number): void;
     isComplete(entity: Entity): boolean;

package/build/{dist → esm/src/engine}/actions/action/move-to.d.ts

@@ -1,12 +1,11 @@
 import type { Entity } from '../../entity-component-system/entity';
 import type { Easing } from '../../math';
 import { Vector } from '../../math/vector';
-import type { EasingFunction } from '../../util/easing-functions';
 import type { Action } from '../action';
 export interface MoveToOptions {
     pos: Vector;
     duration: number;
-    easing?: Easing | EasingFunction;
+    easing?: Easing;
 }
 /**
  *
@@ -24,8 +23,6 @@ export declare class MoveToWithOptions implements Action {
     private _stopped;
     private _motion;
     private _easing;
-    private _legacyEasing;
-    private _useLegacyEasing;
     constructor(entity: Entity, options: MoveToOptions);
     update(elapsed: number): void;
     isComplete(entity: Entity): boolean;

package/build/{dist → esm/src/engine}/actions/action/repeat-forever.d.ts

@@ -11,11 +11,19 @@ export declare class RepeatForever implements Action {
     id: number;
     private _actionQueue;
     private _stopped;
+    private _isUpdating;
+    private _resetRequested;
     private _repeatContext;
     private _repeatBuilder;
     constructor(entity: Entity, repeatBuilder: (repeatContext: ActionContext) => any);
     update(elapsed: number): void;
     isComplete(): boolean;
     stop(): void;
+    /**
+     * Restarts the repeat by stopping the current action and rebuilding the sequence.
+     * The builder is called again, including when runAction resets this action.
+     * Actions start from the entity's current state; its position is not restored.
+     * During a child action's update, rebuilding is deferred until that update completes.
+     */
     reset(): void;
 }

package/build/{dist → esm/src/engine}/actions/action/rotate-by.d.ts

@@ -11,7 +11,12 @@ export interface RotateByOptions {
      */
     duration: number;
     /**
-     * Optionally provide type of rotation, default is RotationType.ShortestPath
+     * Optionally provide type of rotation. When omitted the entity rotates by exactly the
+     * signed offset provided, preserving full turns (an offset of 2 PI performs a full revolution).
+     * When provided, the offset determines the target orientation and the rotation type picks
+     * the travel path to it. Non-zero full-turn multiples of 2 PI travel one full revolution in
+     * the requested direction for Clockwise, CounterClockwise, and LongestPath, while
+     * ShortestPath will not move.
      */
     rotationType?: RotationType;
 }
@@ -30,8 +35,9 @@ export declare class RotateByWithOptions implements Action {
     private _motion;
     private _offset;
     private _startAngle;
-    private _rotationType;
-    private _endAngle;
+    private _rotationType?;
+    private _travel;
+    private _currentAngle;
     constructor(entity: Entity, options: RotateByOptions);
     update(elapsed: number): void;
     isComplete(): boolean;

package/build/{dist → esm/src/engine}/actions/action-context.d.ts

@@ -1,4 +1,3 @@
-import type { EasingFunction } from '../util/easing-functions';
 import { ActionQueue } from './action-queue';
 import type { MoveByOptions } from './action/move-by';
 import type { MoveToOptions } from './action/move-to';
@@ -42,48 +41,9 @@ export declare class ActionContext {
      * @param options
      */
     curveTo(options: CurveToOptions): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param pos       The x,y vector location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(pos: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param x         The x location to move the actor to
-     * @param y         The y location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(x: number, y: number, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor by a specified vector offset relative to the current position given
-     * a duration and a {@apilink EasingFunction}. This method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param offset Vector offset relative to the current position
-     * @param duration The duration in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveBy({offset: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offset: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor by a specified x and y offset relative to the current position given
-     * a duration and a {@apilink EasingFunction}. This method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param offset Vector offset relative to the current position
-     * @param duration The duration in milliseconds
-     * @param easingFcn Use {@apilink EasingFunction} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveBy({offset: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offsetX: number, offsetY: number, duration: number, easingFcn?: EasingFunction): ActionContext;
     /**
      * Moves an actor to a specified {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveTo(options: MoveToOptions): ActionContext;
@@ -106,10 +66,17 @@ export declare class ActionContext {
     moveTo(x: number, y: number, speed: number): ActionContext;
     /**
      * Moves an actor by a specified offset {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveBy(options: MoveByOptions): ActionContext;
+    /**
+     * This method will move an actor by the specified x offset and y offset from its current position, at a certain speed.
+     * This method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param offset  The Vector offset to apply to this actor
+     * @param speed  The speed in pixels per second the actor should move
+     */
+    moveBy(offset: Vector, speed: number): ActionContext;
     /**
      * This method will move an actor by the specified x offset and y offset from its current position, at a certain speed.
      * This method is part of the actor 'Action' fluent API allowing action chaining.
@@ -117,7 +84,6 @@ export declare class ActionContext {
      * @param yOffset     The y location to move the actor to
      * @param speed  The speed in pixels per second the actor should move
      */
-    moveBy(offset: Vector, speed: number): ActionContext;
     moveBy(xOffset: number, yOffset: number, speed: number): ActionContext;
     /**
      * Rotates an actor to a specified angle over a duration in milliseconds,

package/build/{dist → esm/src/engine}/actions/actions-component.d.ts

@@ -5,7 +5,6 @@ import type { Actor } from '../actor';
 import { MotionComponent } from '../entity-component-system/components/motion-component';
 import { TransformComponent } from '../entity-component-system/components/transform-component';
 import type { Vector, RotationType } from '../math';
-import type { EasingFunction } from '../util/easing-functions';
 import type { ActionQueue } from './action-queue';
 import type { Action } from './action';
 import type { Color } from '../color';
@@ -16,6 +15,7 @@ import type { MoveByOptions, RotateByOptions, RotateToOptions, ScaleByOptions, S
 export interface ActionContextMethods extends Pick<ActionContext, keyof ActionContext> {
 }
 export declare class ActionsComponent extends Component implements ActionContextMethods {
+    private static _NAME;
     dependencies: (typeof TransformComponent | typeof MotionComponent)[];
     private _ctx;
     onAdd(entity: Entity): void;
@@ -52,47 +52,9 @@ export declare class ActionsComponent extends Component implements ActionContext
      * @param options
      */
     curveTo(options: CurveToOptions): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param pos       The x,y vector location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunctions} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(pos: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     * This method will move an actor to the specified `x` and `y` position over the
-     * specified duration using a given {@apilink EasingFunctions} and return back the actor. This
-     * method is part of the actor 'Action' fluent API allowing action chaining.
-     * @param x         The x location to move the actor to
-     * @param y         The y location to move the actor to
-     * @param duration  The time it should take the actor to move to the new location in milliseconds
-     * @param easingFcn Use {@apilink EasingFunctions} or a custom function to use to calculate position, Default is {@apilink EasingFunctions.Linear}
-     * @deprecated use new moveTo({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeTo(x: number, y: number, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     *
-     * @param offset
-     * @param duration
-     * @param easingFcn
-     * @deprecated use new moveBy({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offset: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
-    /**
-     *
-     * @param offsetX
-     * @param offsetY
-     * @param duration
-     * @param easingFcn
-     * @deprecated use new moveBy({pos: Vector, duration: number, easing: EasingFunction})
-     */
-    easeBy(offsetX: number, offsetY: number, duration: number, easingFcn?: EasingFunction): ActionContext;
     /**
      * Moves an actor to a specified {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveTo(options: MoveToOptions): ActionContext;
@@ -115,7 +77,7 @@ export declare class ActionsComponent extends Component implements ActionContext
     moveTo(x: number, y: number, speed: number): ActionContext;
     /**
      * Moves an actor by a specified offset {@link Vector} in a given duration in milliseconds.
-     * You may optionally specify an {@link EasingFunction}
+     * You may optionally specify an {@link Easing}
      * @param options
      */
     moveBy(options: MoveByOptions): ActionContext;

package/build/{dist → esm/src/engine}/actions/actions-system.d.ts

@@ -1,13 +1,12 @@
 import type { Query, World } from '../entity-component-system';
 import { System, SystemType } from '../entity-component-system//system';
-import { PauseComponent } from '../entity-component-system/components/pause-component';
 import { ActionsComponent } from './actions-component';
 export declare class ActionsSystem extends System {
     world: World;
     static priority: -5;
     systemType: SystemType;
     private _actions;
-    query: Query<typeof ActionsComponent | typeof PauseComponent>;
+    query: Query<typeof ActionsComponent>;
     constructor(world: World);
-    update(elapsed: number): void;
+    onUpdate(elapsed: number): void;
 }

package/build/{dist → esm/src/engine}/actions/index.d.ts

@@ -8,8 +8,6 @@ export * from './action/repeat';
 export * from './action/repeat-forever';
 export * from './action/blink';
 export * from './action/die';
-export * from './action/ease-to';
-export * from './action/ease-by';
 export * from './action/fade';
 export * from './action/follow';
 export * from './action/meet';

package/build/{dist → esm/src/engine}/actor.d.ts

@@ -1,4 +1,4 @@
-import type { PostCollisionEvent, PreCollisionEvent, CollisionStartEvent, CollisionEndEvent, EnterViewPortEvent, ExitViewPortEvent, PreDrawEvent, PostDrawEvent, PreDebugDrawEvent, PostDebugDrawEvent, ActionStartEvent, ActionCompleteEvent } from './events';
+import type { PostCollisionEvent, PreCollisionEvent, CollisionStartEvent, CollisionEndEvent, EnterViewportEvent, ExitViewportEvent, PreDrawEvent, PostDrawEvent, PreDebugDrawEvent, PostDebugDrawEvent, ActionStartEvent, ActionCompleteEvent, PostTransformDrawEvent, PreTransformDrawEvent } from './events';
 import { type KillEvent, PostKillEvent, PreKillEvent } from './events';
 import type { Engine } from './engine';
 import type { Color } from './color';
@@ -34,7 +34,7 @@ export declare function isActor(x: any): x is Actor;
 /**
  * Actor constructor options
  */
-export type ActorArgs = ColliderArgs & {
+export type ActorOptions = ColliderArgs & {
     /**
      * Optionally set the name of the actor, default is 'anonymous'
      */
@@ -93,8 +93,7 @@ export type ActorArgs = ColliderArgs & {
      */
     material?: Material;
     /**
-     * Optionally set the color of an actor, only used if no graphics are present
-     * If a width/height or a radius was set a default graphic will be added
+     * Optionally set the opacity of an actor, only used if no graphics are present
      */
     opacity?: number;
     /**
@@ -106,7 +105,7 @@ export type ActorArgs = ColliderArgs & {
      */
     anchor?: Vector;
     /**
-     * Optionally set the anchor for graphics in the actor
+     * Optionally set the pixel offset for graphics in the actor
      */
     offset?: Vector;
     /**
@@ -119,6 +118,8 @@ export type ActorArgs = ColliderArgs & {
     collisionGroup?: CollisionGroup;
     /**
      * Optionally set if the actor can be paused
+     *
+     * (default is true)
      */
     canPause?: boolean;
 };
@@ -162,6 +163,11 @@ type ColliderArgs = // custom collider
     width?: undefined;
     height?: undefined;
 };
+/**
+ * Actor constructor options
+ * @deprecated use ActorOptions
+ */
+export type ActorArgs = ActorOptions;
 export interface ActorEvents extends EntityEvents {
     collisionstart: CollisionStartEvent;
     collisionend: CollisionEndEvent;
@@ -172,8 +178,8 @@ export interface ActorEvents extends EntityEvents {
     postkill: PostKillEvent;
     predraw: PreDrawEvent;
     postdraw: PostDrawEvent;
-    pretransformdraw: PreDrawEvent;
-    posttransformdraw: PostDrawEvent;
+    pretransformdraw: PreTransformDrawEvent;
+    posttransformdraw: PostTransformDrawEvent;
     predebugdraw: PreDebugDrawEvent;
     postdebugdraw: PostDebugDrawEvent;
     pointerup: PointerEvent;
@@ -188,8 +194,8 @@ export interface ActorEvents extends EntityEvents {
     pointerdragenter: PointerEvent;
     pointerdragleave: PointerEvent;
     pointerdragmove: PointerEvent;
-    enterviewport: EnterViewPortEvent;
-    exitviewport: ExitViewPortEvent;
+    enterviewport: EnterViewportEvent;
+    exitviewport: ExitViewportEvent;
     actionstart: ActionStartEvent;
     actioncomplete: ActionCompleteEvent;
 }
@@ -219,8 +225,8 @@ export declare const ActorEvents: {
     readonly PointerDragEnter: "pointerdragenter";
     readonly PointerDragLeave: "pointerdragleave";
     readonly PointerDragMove: "pointerdragmove";
-    readonly EnterViewPort: "enterviewport";
-    readonly ExitViewPort: "exitviewport";
+    readonly EnterViewport: "enterviewport";
+    readonly ExitViewport: "exitviewport";
     readonly ActionStart: "actionstart";
     readonly ActionComplete: "actioncomplete";
 };
@@ -401,7 +407,7 @@ export declare class Actor extends Entity implements Eventable, PointerEvents, C
      *
      * @param config
      */
-    constructor(config?: ActorArgs);
+    constructor(config?: ActorOptions);
     clone(): Actor;
     /**
      * `onInitialize` is called before the first update of the actor. This method is meant to be
@@ -462,7 +468,7 @@ export declare class Actor extends Entity implements Eventable, PointerEvents, C
      */
     unkill(): void;
     /**
-     * Indicates wether the actor has been killed.
+     * Indicates whether the actor has been killed.
      */
     isKilled(): boolean;
     /**
@@ -487,31 +493,14 @@ export declare class Actor extends Entity implements Eventable, PointerEvents, C
     get localCenter(): Vector;
     get width(): number;
     get height(): number;
-    /**
-     * Gets this actor's rotation taking into account any parent relationships
-     * @returns Rotation angle in radians
-     * @deprecated Use {@apilink globalRotation} instead
-     */
-    getGlobalRotation(): number;
     /**
      * The actor's rotation (in radians) taking into account any parent relationships
      */
     get globalRotation(): number;
-    /**
-     * Gets an actor's world position taking into account parent relationships, scaling, rotation, and translation
-     * @returns Position in world coordinates
-     * @deprecated Use {@apilink globalPos} instead
-     */
-    getGlobalPos(): Vector;
     /**
      * The actor's world position taking into account parent relationships, scaling, rotation, and translation
      */
     get globalPos(): Vector;
-    /**
-     * Gets the global scale of the Actor
-     * @deprecated Use {@apilink globalScale} instead
-     */
-    getGlobalScale(): Vector;
     /**
      * The global scale of the Actor
      */

package/build/{dist → esm/src/engine}/camera.d.ts

@@ -1,5 +1,4 @@
 import type { Engine } from './engine';
-import type { EasingFunction } from './util/easing-functions';
 import { Vector } from './math/vector';
 import type { Actor } from './actor';
 import type { CanUpdate, CanInitialize } from './interfaces/lifecycle-events';
@@ -221,7 +220,7 @@ export declare class Camera implements CanUpdate, CanInitialize {
     private _lerpStart;
     private _lerpEnd;
     private _lerpResolve;
-    private _lerpPromise;
+    private _lerpPromise?;
     protected _isShaking: boolean;
     private _shakeMagnitudeX;
     private _shakeMagnitudeY;
@@ -236,11 +235,7 @@ export declare class Camera implements CanUpdate, CanInitialize {
     private _zoomDuration;
     private _zoomResolve;
     private _zoomPromise;
-    private _legacyZoomEasing;
-    private _useLegacyZoom;
     private _zoomEasing;
-    private _legacyEasing;
-    private _useLegacyEasing;
     private _easing;
     private _halfWidth;
     private _halfHeight;
@@ -292,7 +287,7 @@ export declare class Camera implements CanUpdate, CanInitialize {
      * @returns A {@apilink Promise} that resolves when movement is finished, including if it's interrupted.
      *          The {@apilink Promise} value is the {@apilink Vector} of the target position. It will be rejected if a move cannot be made.
      */
-    move(pos: Vector, duration: number, easingFn?: Easing | EasingFunction): Promise<Vector>;
+    move(pos: Vector, duration: number, easingFn?: Easing): Promise<Vector>;
     /**
      * Sets the camera to shake at the specified magnitudes for the specified duration
      * @param magnitudeX  The x magnitude of the shake
@@ -306,15 +301,15 @@ export declare class Camera implements CanUpdate, CanInitialize {
      * @param scale    The scale of the zoom
      * @param duration The duration of the zoom in milliseconds
      */
-    zoomOverTime(scale: number, duration?: number, easingFn?: Easing | EasingFunction): Promise<boolean>;
-    private _viewport;
+    zoomOverTime(scale: number, duration?: number, easingFn?: Easing): Promise<boolean>;
+    private _viewport?;
     /**
      * Gets the bounding box of the viewport of this camera in world coordinates
      */
     get viewport(): BoundingBox;
     /**
      * Adds one or more new camera strategies to this camera
-     * @param cameraStrategy Instance of an {@apilink CameraStrategy}
+     * @param cameraStrategies Instance of an {@apilink CameraStrategy}
      */
     addStrategy<T extends CameraStrategy<any>[]>(...cameraStrategies: T): void;
     /**
@@ -393,6 +388,14 @@ export declare class Camera implements CanUpdate, CanInitialize {
      * Applies the relevant transformations to the game canvas to "move" or apply effects to the Camera
      * @param ctx Canvas context to apply transformations
      */
+    /**
+     * Finalizes this frame's draw transform (fixed-update interpolation and pixel-snap), without
+     * mutating `ctx`. Split out from {@apilink draw} so systems that need the finalized transform
+     * before their own draw pass (e.g. LightingSystem, which runs before GraphicsSystem) can call
+     * this directly instead of the full `draw()`, which also applies the transform to the context.
+     * @internal
+     */
+    _finalizeDrawTransform(ctx: ExcaliburGraphicsContext): void;
     draw(ctx: ExcaliburGraphicsContext): void;
     updateTransform(pos: Vector): void;
     private _isDoneShaking;

package/build/{dist → esm/src/engine}/collision/body-component.d.ts

@@ -40,6 +40,7 @@ export declare enum DegreeOfFreedom {
  * of physics simulation.
  */
 export declare class BodyComponent extends Component implements Clonable<BodyComponent> {
+    private static _NAME;
     dependencies: (typeof TransformComponent | typeof MotionComponent)[];
     static _ID: number;
     readonly id: Id<'body'>;
@@ -100,21 +101,10 @@ export declare class BodyComponent extends Component implements Clonable<BodyCom
      */
     canSleep: boolean;
     private _sleeping;
-    /**
-     * Whether this body is sleeping or not
-     * @deprecated use isSleeping
-     */
-    get sleeping(): boolean;
     /**
      * Whether this body is sleeping or not
      */
     get isSleeping(): boolean;
-    /**
-     * Set the sleep state of the body
-     * @param sleeping
-     * @deprecated use isSleeping
-     */
-    setSleeping(sleeping: boolean): void;
     wake(): void;
     sleep(): void;
     set isSleeping(sleeping: boolean);
@@ -154,19 +144,10 @@ export declare class BodyComponent extends Component implements Clonable<BodyCom
      * Note: this only limits responses in the realistic solver, if velocity/angularVelocity is set the actor will still respond
      */
     limitDegreeOfFreedom: DegreeOfFreedom[];
-    /**
-     * Returns if the owner is active
-     * @deprecated use isActive
-     */
-    get active(): boolean;
     /**
      * Returns if the owner is active
      */
     get isActive(): boolean;
-    /**
-     * @deprecated Use globalPos
-     */
-    get center(): Vector;
     transform: TransformComponent;
     motion: MotionComponent;
     onAdd(owner: Entity<any>): void;
@@ -251,6 +232,16 @@ export declare class BodyComponent extends Component implements Clonable<BodyCom
      * @param impulse
      */
     applyImpulse(point: Vector, impulse: Vector): void;
+    /**
+     * Apply an impulse (impulseX, impulseY) at a lever arm (offsetX, offsetY) from the body's center.
+     *
+     * Scalar variant of {@apilink BodyComponent.applyImpulse} used by the collision solver hot loops, it allocates nothing
+     * @param offsetX
+     * @param offsetY
+     * @param impulseX
+     * @param impulseY
+     */
+    applyImpulseAtOffset(offsetX: number, offsetY: number, impulseX: number, impulseY: number): void;
     /**
      * Apply only linear impulse to the body
      * @param impulse

package/build/{dist → esm/src/engine}/collision/bounding-box.d.ts

@@ -85,7 +85,7 @@ export declare class BoundingBox {
      * Transform the axis aligned bounding box by a {@apilink Matrix}, producing a new axis aligned bounding box
      * @param matrix
      */
-    transform(matrix: AffineMatrix): BoundingBox;
+    transform(matrix: AffineMatrix, dest?: BoundingBox): BoundingBox;
     /**
      * Returns the perimeter of the bounding box
      */
@@ -138,7 +138,7 @@ export declare class BoundingBox {
      * @param other  Other {@apilink BoundingBox} to test intersection with
      * @returns A Vector in the direction of the current BoundingBox, this <- other
      */
-    intersect(other: BoundingBox): Vector;
+    intersect(other: BoundingBox): Vector | null;
     /**
      * Test whether the bounding box has intersected with another bounding box, returns the side of the current bb that intersected.
      * @param bb The other actor to test
@@ -147,14 +147,7 @@ export declare class BoundingBox {
     /**
      * Draw a debug bounding box
      * @param ex
-     * @param color
-     * @deprecated
-     */
-    draw(ex: ExcaliburGraphicsContext, options?: RectGraphicsOptions): void;
-    /**
-     * Draw a debug bounding box
-     * @param ex
-     * @param color
+     * @param [options={ color: Color.Yellow }]
      */
     debug(ex: ExcaliburGraphicsContext, options?: RectGraphicsOptions): void;
 }

package/build/{dist → esm/src/engine}/collision/collider-component.d.ts

@@ -8,7 +8,7 @@ import { CircleCollider } from './colliders/circle-collider';
 import type { Collider } from './colliders/collider';
 import { CompositeCollider } from './colliders/composite-collider';
 import { PolygonCollider } from './colliders/polygon-collider';
-import type { EdgeCollider } from './colliders/edge-collider';
+import { EdgeCollider } from './colliders/edge-collider';
 import { EventEmitter } from '../event-emitter';
 export interface ColliderComponentData {
     type: string;
@@ -69,6 +69,8 @@ export interface CompositeColliderData {
 }
 export type ColliderCreationData = BoxColliderData | CircleColliderData | PolygonColliderData | EdgeColliderData | CompositeColliderData | CapsuleColliderData;
 export declare class ColliderComponent extends Component {
+    private _logger;
+    private static _NAME;
     events: EventEmitter<any>;
     /**
      * Observable that notifies when a collider is added to the body
@@ -83,11 +85,18 @@ export declare class ColliderComponent extends Component {
     /**
      * Get the current collider geometry
      */
-    get(): Collider | undefined;
+    get(): Collider | null;
+    /**
+     * Use specific collider geometry
+     * @param collider
+     * @returns the collider you set
+     */
+    use<T extends Collider>(collider?: T): T;
     /**
      * Set the collider geometry
      * @param collider
      * @returns the collider you set
+     * @deprecated Use .use(collider) instead
      */
     set<T extends Collider>(collider: T): T;
     private _collidersToRemove;
@@ -95,6 +104,12 @@ export declare class ColliderComponent extends Component {
      * Remove collider geometry from collider component
      */
     clear(): void;
+    private _collidersToFinalize;
+    /**
+     * Removal happens in two phases: colliders removed this frame are untracked from collision detection right away, but
+     * stay wired to this component for one more frame so the `collisionend` of any contact they were in still reaches the
+     * owner. The next call finalizes them.
+     */
     processColliderRemoval(): void;
     clone(): ColliderComponent;
     /**

package/build/{dist → esm/src/engine}/collision/colliders/circle-collider.d.ts

@@ -28,6 +28,14 @@ export declare class CircleCollider extends Collider {
      */
     offset: Vector;
     private _globalMatrix;
+    private _syncedVersion;
+    private _syncedOffsetX;
+    private _syncedOffsetY;
+    /**
+     * Rebuilds the world matrix from the owner transform if it (or the offset) changed since the last sync
+     */
+    private _ensureWorld;
+    get worldVersion(): number;
     get worldPos(): Vector;
     private _naturalRadius;
     private _radius;

package/build/{dist → esm/src/engine}/collision/colliders/closest-line-jump-table.d.ts

@@ -3,7 +3,7 @@ import type { PolygonCollider } from './polygon-collider';
 import type { EdgeCollider } from './edge-collider';
 import type { CircleCollider } from './circle-collider';
 export declare const ClosestLineJumpTable: {
-    PolygonPolygonClosestLine(polygonA: PolygonCollider, polygonB: PolygonCollider): LineSegment;
+    PolygonPolygonClosestLine(polygonA: PolygonCollider, polygonB: PolygonCollider): LineSegment | null;
     PolygonEdgeClosestLine(polygon: PolygonCollider, edge: EdgeCollider): LineSegment;
     PolygonCircleClosestLine(polygon: PolygonCollider, circle: CircleCollider): LineSegment;
     CircleCircleClosestLine(circleA: CircleCollider, circleB: CircleCollider): LineSegment;