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

package/build/esm/src/engine/collision/solver/realistic-solver.d.ts

@@ -0,0 +1,50 @@
+import type { CollisionContact } from '../detection/collision-contact';
+import { ContactConstraintPoint } from './contact-constraint-point';
+import type { CollisionSolver } from './solver';
+import type { DeepRequired } from '../../util/required';
+import type { PhysicsConfig } from '../physics-config';
+export declare class RealisticSolver implements CollisionSolver {
+    config: DeepRequired<Pick<PhysicsConfig, 'realistic'>['realistic']>;
+    directionMap: Map<string, "horizontal" | "vertical">;
+    distanceMap: Map<string, number>;
+    private _currentContactIds;
+    constructor(config: DeepRequired<Pick<PhysicsConfig, 'realistic'>['realistic']>);
+    lastFrameContacts: Map<string, CollisionContact>;
+    idToContactConstraint: Map<string, ContactConstraintPoint[]>;
+    getContactConstraints(id: string): ContactConstraintPoint[];
+    /**
+     * Solve the contacts for one physics (sub)step
+     * @param contacts
+     * @param _duration length of the step in ms, unused but kept so `substep`/`substepCount` line up positionally with
+     * the {@apilink CollisionSolver} interface
+     * @param substep index of the substep within the frame, collision events are emitted on the first and last substep only
+     * @param substepCount total substeps in the frame
+     */
+    solve(contacts: CollisionContact[], _duration?: number, substep?: number, substepCount?: number): CollisionContact[];
+    /**
+     * Prepares the contact constraints (effective masses, lever arms, restitution targets) and warm starts them
+     * @param contacts
+     * @param substep index of the substep within the frame, `precollision`/`beforecollisionresolve` are only emitted on the first
+     */
+    preSolve(contacts: CollisionContact[], substep?: number): void;
+    /**
+     * @param contacts
+     * @param emitEvents whether `postcollision`/`aftercollisionresolve` fire, only the last substep of a frame does
+     */
+    postSolve(contacts: CollisionContact[], emitEvents?: boolean): void;
+    /**
+     * Warm up body's based on previous frame contact points
+     * @param contacts
+     */
+    warmStart(contacts: CollisionContact[]): void;
+    /**
+     * Iteratively solve the position overlap constraint
+     * @param contacts
+     */
+    solvePosition(contacts: CollisionContact[]): void;
+    /**
+     * Moves and rotates a body by a pseudo impulse applied at a lever arm from its center, honoring the limited degrees of freedom
+     */
+    private _applyPositionCorrection;
+    solveVelocity(contacts: CollisionContact[]): void;
+}

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

@@ -8,7 +8,6 @@ import type { CollisionContact } from '../detection/collision-contact';
  * 2. solveVelocity
  * 3. solvePosition
  * 4. postSolve
- * @inheritdoc
  */
 export interface CollisionSolver {
     /**
@@ -20,6 +19,9 @@ export interface CollisionSolver {
      * 3. solvePosition
      * 4. postSolve
      * @param contacts
+     * @param duration length of the (sub)step in ms
+     * @param substep index of the substep within the current frame, starting at 0
+     * @param substepCount total number of substeps in the current frame
      */
-    solve(contacts: CollisionContact[], duration?: number): CollisionContact[];
+    solve(contacts: CollisionContact[], duration?: number, substep?: number, substepCount?: number): CollisionContact[];
 }

package/build/{dist → esm/src/engine}/debug/debug-config.d.ts

@@ -287,6 +287,22 @@ export declare class DebugConfig {
         gridWidth: number;
         showColliderGeometry: boolean;
     };
+    /**
+     * Screen debug settings
+     *
+     * Visualizes the screen-space coordinate plan, including the safe {@apilink Screen.contentArea}
+     * and the full {@apilink Screen.unsafeArea} (which may be partially offscreen under the
+     * *AndFill display modes).
+     */
+    screen: {
+        showAll: boolean;
+        showContentArea: boolean;
+        contentAreaColor: Color;
+        showUnsafeArea: boolean;
+        unsafeAreaColor: Color;
+        showLegend: boolean;
+        legendColor: Color;
+    };
 }
 /**
  * Implementation of a frame's stats. Meant to have values copied via {@apilink FrameStats.reset}, avoid

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

@@ -12,9 +12,9 @@ export declare class DebugSystem extends System {
     private _engine;
     query: Query<typeof TransformComponent>;
     constructor(world: World);
-    initialize(world: World, scene: Scene): void;
-    update(): void;
-    postupdate(engine: Scene<unknown>, elapsed: number): void;
+    onInitialize(world: World, scene: Scene): void;
+    onUpdate(): void;
+    onPostUpdate(engine: Scene<unknown>, elapsed: number): void;
     /**
      * This applies the current entity transform to the graphics context
      * @param entity

package/build/esm/src/engine/deprecated.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -69,11 +69,11 @@ export interface GoToOptions<TActivationData = any> {
     /**
      * Optionally supply destination scene "in" transition, this will override any previously defined transition
      */
-    destinationIn?: Transition;
+    destinationIn?: Transition | null;
     /**
      * Optionally supply source scene "out" transition, this will override any previously defined transition
      */
-    sourceOut?: Transition;
+    sourceOut?: Transition | null;
     /**
      * Optionally supply a different loader for the destination scene, this will override any previously defined loader
      */
@@ -91,8 +91,8 @@ export declare class Director<TKnownScenes extends string = any> {
     private _engine;
     events: EventEmitter<DirectorEvents>;
     private _logger;
-    private _deferredGoto?;
-    private _deferredTransition?;
+    private _deferredGoto;
+    private _deferredTransition;
     private _initialized;
     /**
      * Current scene's name
@@ -105,7 +105,7 @@ export declare class Director<TKnownScenes extends string = any> {
     /**
      * Current transition if any
      */
-    currentTransition?: Transition;
+    currentTransition: Transition | null;
     /**
      * All registered scenes in Excalibur
      */
@@ -150,12 +150,12 @@ export declare class Director<TKnownScenes extends string = any> {
     private _getLoader;
     private _getInTransition;
     private _getOutTransition;
-    getDeferredScene(): Scene<unknown> | SceneConstructor;
+    getDeferredScene(): Scene<unknown> | SceneConstructor | null;
     /**
      * Returns a scene by name if it exists, might be the constructor and not the instance of a scene
      * @param name
      */
-    getSceneDefinition(name?: string): Scene | SceneConstructor | undefined;
+    getSceneDefinition(name?: string): Scene | SceneConstructor | null;
     /**
      * Returns the name of the registered scene, null if none can be found
      * @param scene
@@ -192,7 +192,7 @@ export declare class Director<TKnownScenes extends string = any> {
      * This will call any constructors that were given as a definition
      * @param scene
      */
-    getSceneInstance(scene: string): Scene | undefined;
+    getSceneInstance(scene: string): Scene | null;
     /**
      * Triggers scene loading if has not already been loaded
      * @param scene
@@ -213,4 +213,9 @@ export declare class Director<TKnownScenes extends string = any> {
      */
     swapScene<TData = undefined>(destinationScene: string, data?: TData): Promise<void>;
     private _emitEvent;
+    /**
+     * Tears down any initialized scene's {@apilink InputHost}, removing native pointer listeners
+     * the scene attached to the canvas/window and disabling input. Called by {@apilink Engine.dispose}.
+     */
+    dispose(): void;
 }

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

@@ -2,7 +2,7 @@ import type { Engine } from '../engine';
 import type { Scene } from '../scene';
 import type { TransitionOptions } from './transition';
 import { Transition } from './transition';
-import { type EasingFunction } from '../util/easing-functions';
+import type { Easing } from '../math/easings';
 export interface SlideOptions {
     /**
      * Duration of the transition in milliseconds
@@ -15,7 +15,7 @@ export interface SlideOptions {
     /**
      * Optionally select an easing function, by default linear (aka lerp)
      */
-    easingFunction?: EasingFunction;
+    easingFunction?: Easing;
 }
 /**
  * Slide`s between the previous scene and the destination scene

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

@@ -2,7 +2,6 @@ import type { Engine } from '../engine';
 import type { Scene } from '../scene';
 import { Entity, TransformComponent } from '../entity-component-system';
 import { GraphicsComponent } from '../graphics';
-import type { EasingFunction } from '../util/easing-functions';
 import type { CoroutineInstance } from '../util/coroutine';
 import type { Easing } from '../math/easings';
 export interface TransitionOptions {
@@ -27,7 +26,7 @@ export interface TransitionOptions {
     /**
      * Optionally specify a easing function, by default linear
      */
-    easing?: Easing | EasingFunction;
+    easing?: Easing;
     /**
      * Optionally specify a transition direction, by default 'out'
      *
@@ -47,7 +46,6 @@ export declare class Transition extends Entity {
     readonly blockInput: boolean;
     readonly duration: number;
     readonly easing: Easing;
-    readonly legacyEasing: EasingFunction;
     readonly direction: 'out' | 'in';
     private _completeFuture;
     protected _engine?: Engine;
@@ -56,7 +54,6 @@ export declare class Transition extends Entity {
     private _currentDistance;
     private _currentProgress;
     done: Promise<void>;
-    private _useLegacyEasing;
     /**
      * Returns a number between [0, 1] indicating what state the transition is in.
      *

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

@@ -26,9 +26,11 @@ import type { GoToOptions, SceneMap, StartOptions, SceneWithOptions, WithRoot }
 import { Director, DirectorEvents } from './director/director';
 import { InputHost } from './input/input-host';
 import type { PhysicsConfig } from './collision/physics-config';
+import type { LightingConfig } from './lighting/lighting-config';
 import type { DeepRequired } from './util/required';
 import type { Context } from './context';
 import type { GarbageCollectionOptions } from './garbage-collector';
+import type { Plugin } from './plugin';
 export interface EngineEvents extends DirectorEvents {
     fallbackgraphicscontext: ExcaliburGraphicsContext2DCanvas;
     initialize: InitializeEvent<Engine>;
@@ -81,6 +83,10 @@ export declare enum ScrollPreventionMode {
  * Defines the available options to configure the Excalibur engine at constructor time.
  */
 export interface EngineOptions<TKnownScenes extends string = any> {
+    /**
+     * Optionally configure Excalibur plugins
+     */
+    plugins?: Plugin[];
     /**
      * Optionally configure the width of the viewport in css pixels
      */
@@ -325,6 +331,18 @@ export interface EngineOptions<TKnownScenes extends string = any> {
      * Default is configured to use {@apilink SolverStrategy.Arcade} physics simulation
      */
     physics?: boolean | PhysicsConfig;
+    /**
+     * Optionally enable the 2D lighting simulation in excalibur, adding the {@apilink LightingSystem} and
+     * {@apilink FlickerSystem} to every scene.
+     *
+     * **Potential performance impact** — the lighting overlay is rasterized with the 2D Canvas API and
+     * re-uploaded to the GPU every frame, which carries a performance penalty.
+     *
+     * Pass a {@apilink LightingConfig} to tune the lighting simulation's defaults instead of just enabling it.
+     *
+     * Default is false
+     */
+    lighting?: boolean | LightingConfig;
     /**
      * Optionally specify scenes with their transitions and loaders to excalibur's scene {@apilink Director}
      *
@@ -349,6 +367,37 @@ export declare class Engine<TKnownScenes extends string = any> implements CanIni
      */
     scope: <TReturn>(cb: () => TReturn) => TReturn;
     global: GlobalEventHandlers;
+    private _plugins;
+    get plugins(): readonly Plugin[];
+    /**
+     * Check whether a plugin with the given name is currently installed.
+     *
+     * @param name The unique plugin name to check
+     * @returns `true` if a plugin with that name is installed
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Add a plugin to the engine after construction.
+     *
+     * If the engine has already passed certain lifecycle stages, the plugin's hooks
+     * for those stages will be called immediately so the plugin can "catch up".
+     *
+     * If a plugin with the same {@apilink Plugin.name} is already installed, a warning
+     * is logged and the plugin is not added.
+     *
+     * @param plugin The plugin to add
+     * @returns `true` if the plugin was added, `false` if it was skipped (duplicate name)
+     */
+    addPlugin(plugin: Plugin): boolean;
+    /**
+     * Remove a plugin from the engine by name.
+     *
+     * The plugin's {@apilink Plugin.dispose} method will be called if present.
+     *
+     * @param name The unique plugin name to remove
+     * @returns `true` if the plugin was found and removed
+     */
+    removePlugin(name: string): boolean;
     private _garbageCollector;
     readonly garbageCollectorConfig: GarbageCollectionOptions | null;
     /**
@@ -384,11 +433,15 @@ export declare class Engine<TKnownScenes extends string = any> implements CanIni
     /**
      * Direct access to the canvas element ID, if an ID exists
      */
-    canvasElementId: string;
+    canvasElementId?: string;
     /**
      * Direct access to the physics configuration for excalibur
      */
     physics: DeepRequired<PhysicsConfig>;
+    /**
+     * Direct access to the lighting configuration for excalibur
+     */
+    lighting: DeepRequired<LightingConfig>;
     /**
      * Optionally set the maximum fps if not set Excalibur will go as fast as the device allows.
      *
@@ -599,6 +652,7 @@ export declare class Engine<TKnownScenes extends string = any> implements CanIni
      */
     constructor(options?: EngineOptions<TKnownScenes>);
     private _handleWebGLContextLost;
+    private _handleWebGLContextRestored;
     private _performanceThresholdTriggered;
     private _fpsSamples;
     private _monitorPerformanceThresholdAndTriggerFallback;
@@ -619,7 +673,7 @@ export declare class Engine<TKnownScenes extends string = any> implements CanIni
      * Returns a BoundingBox of the top left corner of the screen
      * and the bottom right corner of the screen.
      */
-    getWorldBounds(): import("./").BoundingBox;
+    getWorldBounds(): import("./collision").BoundingBox;
     /**
      * Gets the current engine timescale factor (default is 1.0 which is 1:1 time)
      */
@@ -852,16 +906,12 @@ export declare class Engine<TKnownScenes extends string = any> implements CanIni
     start(loader?: DefaultLoader): Promise<void>;
     /**
      * Starts the internal game loop for Excalibur after configuring any routes, loaders, or transitions
-     * @param startOptions Optional {@apilink StartOptions} to configure the routes for scenes in Excalibur
+     * @param sceneName
+     * @param options {Optional} {@apilink StartOptions} to configure the routes for scenes in Excalibur
      *
      * Note: start() only resolves AFTER the user has clicked the play button
      */
     start(sceneName: WithRoot<TKnownScenes>, options?: StartOptions): Promise<void>;
-    /**
-     * Starts the internal game loop after any loader is finished
-     * @param loader
-     */
-    start(loader?: DefaultLoader): Promise<void>;
     /**
      * Returns the current frames elapsed milliseconds
      */

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

@@ -30,7 +30,7 @@ export declare abstract class Component {
     /**
      * Current owning {@apilink Entity}, if any, of this component. Null if not added to any {@apilink Entity}
      */
-    owner?: Entity;
+    owner: Entity | null;
     /**
      * Clones any properties on this component, if that property value has a `clone()` method it will be called
      */

package/build/{dist → esm/src/engine}/entity-component-system/components/motion-component.d.ts

@@ -31,6 +31,7 @@ export interface Motion {
     inertia: number;
 }
 export declare class MotionComponent extends Component {
+    private static _NAME;
     /**
      * The velocity of an entity in pixels per second
      */

package/build/{dist → esm/src/engine}/entity-component-system/components/pause-component.d.ts

@@ -2,7 +2,9 @@ import { Component } from '../component';
 export interface PauseComponentInterface {
     canPause: boolean;
 }
+export declare const PauseComponentTag: "ex.paused";
 export declare class PauseComponent extends Component {
+    private static _NAME;
     paused: boolean;
     canPause: boolean;
     constructor(config?: Partial<PauseComponentInterface>);

package/build/{dist → esm/src/engine}/entity-component-system/components/tags-component.d.ts

@@ -1,4 +1,5 @@
 import { Component } from '../component';
 export declare class TagsComponent extends Component {
+    private static _NAME;
     tags: Set<string>;
 }

package/build/{dist → esm/src/engine}/entity-component-system/components/transform-component.d.ts

@@ -19,6 +19,7 @@ export interface TransformComponentData {
     coordPlane?: CoordPlane;
 }
 export declare class TransformComponent extends Component {
+    private static _NAME;
     private _logger;
     private _parentComponent;
     private _transform;

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

@@ -107,16 +107,6 @@ export declare class Entity<TKnownComponents extends Component = any> implements
      * The current scene that the entity is in, if any
      */
     scene: Scene | null;
-    /**
-     * Whether this entity is active, if set to false it will be reclaimed
-     * @deprecated use isActive
-     */
-    get active(): boolean;
-    /**
-     * Whether this entity is active, if set to false it will be reclaimed
-     * @deprecated use isActive
-     */
-    set active(val: boolean);
     /**
      * Whether this entity is active, if set to false it will be reclaimed
      */

package/build/{dist → esm/src/engine}/entity-component-system/index.d.ts

@@ -2,7 +2,6 @@ export * from './component';
 export * from './entity';
 export * from './entity-manager';
 export * from './query';
-export * from './tag-query';
 export * from './query-manager';
 export * from './system';
 export * from './system-manager';

package/build/{dist → esm/src/engine}/entity-component-system/query.d.ts

@@ -62,7 +62,7 @@ export declare class Query<TAllComponentCtors extends ComponentCtor<Component> =
     /**
      * Potentially adds or removes an entity from a query index, returns true if added, false if not added or was removed.
      * @param entity
-     * @param [optional] removedComponent that should be treated as removed from the entity
+     * @param {optional} removedComponent that should be treated as removed from the entity
      */
     checkAndModify(entity: Entity, removedComponent?: ComponentCtor<Component>): boolean;
     removeEntity(entity: Entity): void;

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

@@ -48,22 +48,29 @@ export declare abstract class System {
      * Optionally specify an initialize handler
      * @param scene
      */
-    initialize?(world: World, scene: Scene): void;
+    onInitialize?(world: World, scene: Scene): void;
+    /**
+     * Optionally specify a dispose handler, called when the system is removed from the
+     * {@apilink SystemManager} after having been initialized. Use it to release any resources the
+     * system provisioned in `initialize` (entities it added, observable subscriptions, etc.)
+     * @param scene
+     */
+    dispose?(world: World, scene: Scene): void;
     /**
      * Update all entities that match this system's types
      * @param elapsed Time in milliseconds
      */
-    abstract update(elapsed: number): void;
+    abstract onUpdate(elapsed: number): void;
     /**
      * Optionally run a preupdate before the system processes matching entities
      * @param scene
      * @param elapsed Time in milliseconds since the last frame
      */
-    preupdate?(scene: Scene, elapsed: number): void;
+    onPreUpdate?(scene: Scene, elapsed: number): void;
     /**
      * Optionally run a postupdate after the system processes matching entities
      * @param scene
      * @param elapsed Time in milliseconds since the last frame
      */
-    postupdate?(scene: Scene, elapsed: number): void;
+    onPostUpdate?(scene: Scene, elapsed: number): void;
 }

package/build/{dist → esm/src/engine}/entity-component-system/world.d.ts

@@ -25,10 +25,6 @@ export declare class World {
      * Query the ECS world for entities that match your components
      */
     query<TKnownComponentCtors extends ComponentCtor<Component> = never, TAnyComponentCtors extends ComponentCtor<Component> = never>(params: TKnownComponentCtors[] | QueryParams<TKnownComponentCtors, TAnyComponentCtors>): Query<TKnownComponentCtors, TAnyComponentCtors>;
-    /**
-     * @deprecated
-     */
-    queryTags<TKnownTags extends string>(requiredTags: TKnownTags[]): Query<any, any>;
     /**
      * Update systems by type and time elapsed in milliseconds
      */
@@ -47,7 +43,7 @@ export declare class World {
     /**
      * Get a system out of the ECS world
      */
-    get(system: SystemCtor<System>): System;
+    get(system: SystemCtor<System>): System | null;
     /**
      * Remove an entity from the ECS world
      * @param entity

package/build/{dist → esm/src/engine}/events/media-events.d.ts

@@ -1,6 +1,6 @@
 import type { Sound } from '../resources/sound/sound';
+import type { SoundTrack } from '../resources/sound/sound-track';
 import type { Actor } from '../actor';
-import type { WebAudioInstance } from '../resources/sound/web-audio-instance';
 import { GameEvent } from '../';
 export declare class MediaEvent extends GameEvent<Sound> {
     target: Sound;
@@ -37,8 +37,8 @@ export declare class MediaEvent extends GameEvent<Sound> {
     layPath(_actor: Actor): void;
 }
 export declare class NativeSoundEvent extends MediaEvent {
-    track?: WebAudioInstance;
-    constructor(target: Sound, track?: WebAudioInstance);
+    track?: SoundTrack | undefined;
+    constructor(target: Sound, track?: SoundTrack | undefined);
 }
 export declare class NativeSoundProcessedEvent extends MediaEvent {
     private _processedData;

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

@@ -522,14 +522,14 @@ export declare class DeactivateEvent extends GameEvent<Scene> {
 /**
  * Event thrown on an {@apilink Actor} when the graphics bounds completely leaves the screen.
  */
-export declare class ExitViewPortEvent extends GameEvent<Entity> {
+export declare class ExitViewportEvent extends GameEvent<Entity> {
     self: Entity;
     constructor(self: Entity);
 }
 /**
  * Event thrown on an {@apilink Actor} when any part of the graphics bounds are on screen.
  */
-export declare class EnterViewPortEvent extends GameEvent<Entity> {
+export declare class EnterViewportEvent extends GameEvent<Entity> {
     self: Entity;
     constructor(self: Entity);
 }
@@ -581,7 +581,7 @@ export declare class RemoveEvent<T extends OnRemove> extends GameEvent<T> {
 export declare class PauseEvent extends GameEvent<Scene> {
     self: Scene;
     /**
-     * @param context  The context for the scene deactivation
+     * @param self The context for the scene deactivation
      */
     constructor(self: Scene);
 }
@@ -591,7 +591,7 @@ export declare class PauseEvent extends GameEvent<Scene> {
 export declare class ResumeEvent extends GameEvent<Scene> {
     self: Scene;
     /**
-     * @param context  The context for the scene deactivation
+     * @param self  The context for the scene deactivation
      */
     constructor(self: Scene);
 }

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

@@ -10,6 +10,11 @@ export interface HasTick {
      * @param idempotencyToken Optional idempotencyToken prevents a ticking animation from updating twice per frame
      */
     tick(elapsed: number, idempotencyToken?: number): void;
+    /**
+     * Optional property to tick any graphics EVEN when offscreen, this is useful when you want to keep animations synchronized
+     * across your game scene.
+     */
+    shouldAlwaysTick?: boolean;
 }
 export declare enum AnimationDirection {
     /**
@@ -89,6 +94,11 @@ export interface AnimationOptions {
      * Optionally set arbitrary meta data for the animation
      */
     data?: Record<string, any>;
+    /**
+     * Optionally tick this animation even when offscreen, default false. Useful for keeping animations synchronized
+     * across your game scene.
+     */
+    shouldAlwaysTick?: boolean;
 }
 export interface AnimationEvents {
     frame: FrameEvent;
@@ -118,11 +128,6 @@ export interface FromSpriteSheetOptions {
         duration?: number;
         options?: GetSpriteOptions;
     }[];
-    /**
-     * Optionally specify a default duration for frames in milliseconds
-     * @deprecated use `durationPerFrame`
-     */
-    durationPerFrameMs?: number;
     /**
      * Optionally specify a default duration for frames in milliseconds
      */
@@ -145,6 +150,10 @@ export interface FromSpriteSheetOptions {
      * Optionally set arbitrary meta data for the animation
      */
     data?: Record<string, any>;
+    /**
+     * Optionally tick this animation even when offscreen, default false.
+     */
+    shouldAlwaysTick?: boolean;
 }
 /**
  * Create an Animation given a list of {@apilink Frame | `frames`} in {@apilink AnimationOptions}
@@ -158,6 +167,7 @@ export declare class Animation extends Graphic implements HasTick {
     strategy: AnimationStrategy;
     frameDuration: number;
     data: Map<string, any>;
+    shouldAlwaysTick: boolean;
     private _idempotencyToken;
     private _firstTick;
     private _currentFrame;

package/build/{dist → esm/src/engine}/graphics/context/circle-renderer/circle-renderer.d.ts

@@ -17,6 +17,11 @@ export declare class CircleRenderer implements RendererPlugin {
     initialize(gl: WebGL2RenderingContext, context: ExcaliburGraphicsContextWebGL): void;
     dispose(): void;
     private _isFull;
+    _scratchTopLeft: Vector;
+    _scratchTopRight: Vector;
+    _scratchBottomRight: Vector;
+    _scratchBottomLeft: Vector;
+    _scratchRadius: Vector;
     draw(pos: Vector, radius: number, color: Color, stroke?: Color, strokeThickness?: number): void;
     hasPendingDraws(): boolean;
     flush(): void;

package/build/{dist → esm/src/engine}/graphics/context/debug-text.d.ts

@@ -1,5 +1,6 @@
 import type { ExcaliburGraphicsContext } from '../context/excalibur-graphics-context';
 import type { Vector } from '../../math/vector';
+import { BoundingBox } from '../../collision/bounding-box';
 import { Color } from '../../color';
 /**
  * Internal debug text helper
@@ -18,11 +19,22 @@ export declare class DebugText {
     private _spriteSheet;
     private _spriteFont;
     load(): Promise<void>;
+    /**
+     * Measures the pixel dimensions of `text` as it would be drawn by {@apilink DebugText.write},
+     * accounting for the optional scale factor.
+     * @param text   Text to measure
+     * @param scale  Glyph scale factor, defaults to 1
+     * @returns BoundingBox whose width/height are the rendered size in pixels (origin Zero)
+     */
+    measureText(text: string, scale?: number): BoundingBox;
     /**
      * Writes debug text using the built in sprint font
      * @param ctx
      * @param text
      * @param pos
+     * @param foreground Optional foreground color override
+     * @param background Optional background color override
+     * @param scale Optional glyph scale factor, defaults to 1
      */
-    write(ctx: ExcaliburGraphicsContext, text: string, pos: Vector, foreground?: Color, background?: Color): void;
+    write(ctx: ExcaliburGraphicsContext, text: string, pos: Vector, foreground?: Color, background?: Color, scale?: number): void;
 }