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

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

@@ -15,6 +15,7 @@ export interface PointerComponentOptions {
  * are intersecting the pointer.
  */
 export declare class PointerComponent extends Component {
+    private static _NAME;
     /**
      * Use any existing Collider component geometry for pointer events. This is useful if you want
      * user pointer events only to trigger on the same collision geometry used in the collider component

package/build/{dist → esm/src/engine}/input/pointer-event-receiver.d.ts

@@ -34,6 +34,8 @@ export declare class PointerEventReceiver {
     events: EventEmitter<PointerEvents>;
     primary: PointerAbstraction;
     private _activeNativePointerIdsToNormalized;
+    private _freedNormalizedIds;
+    private _nextNormalizedId;
     lastFramePointerCoords: Map<number, GlobalCoordinates>;
     currentFramePointerCoords: Map<number, GlobalCoordinates>;
     currentFramePointerDown: Map<number, boolean>;
@@ -44,6 +46,16 @@ export declare class PointerEventReceiver {
     currentFrameCancel: PointerEvent[];
     currentFrameWheel: WheelEvent[];
     private _enabled;
+    /**
+     * Tracks whether the {@apilink PointerSystem} has already processed (updated and cleared) this
+     * receiver during the current frame.
+     *
+     * This is used by the {@apilink InputHost} to guarantee the receiver's per-frame events are always
+     * flushed, even when no {@apilink PointerSystem} is active in the current scene. Without this, removing
+     * the PointerSystem would cause the `currentFrame*` arrays to grow unbounded on every native pointer event.
+     * @internal
+     */
+    _processedThisFrame: boolean;
     constructor(target: GlobalEventHandlers & EventTarget, engine: Engine);
     toggleEnabled(enabled: boolean): void;
     /**
@@ -103,6 +115,7 @@ export declare class PointerEventReceiver {
      * @internal
      */
     update(): void;
+    private _releaseEndedPointer;
     /**
      * Clears the current frame event and pointer data
      */

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

@@ -31,11 +31,11 @@ export declare class PointerSystem extends System {
      */
     overrideUseGraphicsBounds: boolean;
     private _scene;
-    initialize(world: World, scene: Scene): void;
+    onInitialize(world: World, scene: Scene): void;
     private _sortedTransforms;
     private _sortedEntities;
     private _zHasChanged;
     private _zIndexUpdate;
-    preupdate(): void;
-    update(): void;
+    onPreUpdate(): void;
+    onUpdate(): void;
 }

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

@@ -1,6 +1,4 @@
 export type * from './clonable';
-export type * from './audio';
-export * from './audio-implementation';
 export type * from './evented';
 export type * from './loadable';
 export * from './lifecycle-events';

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

@@ -4,7 +4,7 @@ import { Vector } from './math/vector';
 import type { SpriteFont } from './graphics';
 import { Font } from './graphics/font';
 import { Actor } from './actor';
-import type { ActorArgs } from './actor';
+import type { ActorOptions } from './actor';
 /**
  * Option for creating a label
  */
@@ -65,7 +65,7 @@ export declare class Label extends Actor {
      * Build a new label
      * @param options
      */
-    constructor(options?: LabelOptions & ActorArgs);
+    constructor(options?: LabelOptions & ActorOptions);
     _initialize(engine: Engine): void;
     /**
      * Returns the width of the text in the label (in pixels);

package/build/esm/src/engine/lighting/cone-light-component.d.ts

@@ -0,0 +1,47 @@
+import { Component } from '../entity-component-system/component';
+import { Color } from '../color';
+import type { FlickerOptions } from './flicker-options';
+import type { PointLightComponentOptions } from './point-light-component';
+export interface ConeLightComponentOptions extends PointLightComponentOptions {
+    /**
+     * Radius of the light in world pixels. Default 200
+     */
+    radius?: number;
+    /**
+     * Total angle arc of the wedge in radians. Default Math.PI / 3
+     */
+    angle?: number;
+    /**
+     * Heading angle in radians relative to the owning entity's world rotation
+     * (0 = Right when the entity is unrotated). Default 0
+     */
+    direction?: number;
+    /**
+     * Edge smoothing ratio. 0.0 represents hard cuts, 1.0 represents full dissipation. Default 0.25
+     */
+    softness?: number;
+}
+/**
+ * Emits light restricted to a directional angular wedge,
+ * cutting through any {@apilink DarknessComponent} veil.
+ */
+export declare class ConeLightComponent extends Component {
+    private static _NAME;
+    color: Color;
+    intensity: number;
+    radius: number;
+    angle: number;
+    direction: number;
+    softness: number;
+    flicker?: FlickerOptions;
+    enabled: boolean;
+    private _currentIntensity;
+    /**
+     * Runtime intensity after flicker calculations are applied, written by the {@apilink FlickerSystem}.
+     * Until a {@apilink FlickerSystem} writes a value (e.g. a {@apilink LightingSystem} added manually
+     * without one), reads track the live {@apilink ConeLightComponent.intensity} value.
+     */
+    get currentIntensity(): number;
+    set currentIntensity(value: number);
+    constructor(options?: ConeLightComponentOptions);
+}

package/build/esm/src/engine/lighting/darkness-component.d.ts

@@ -0,0 +1,34 @@
+import { Component } from '../entity-component-system/component';
+import { Color } from '../color';
+export interface DarknessComponentOptions {
+    /**
+     * Color of the darkness veil. Default rgb(0, 0, 10)
+     */
+    color?: Color;
+    /**
+     * Opacity of the darkness veil (0.0 to 1.0). Default 0.85
+     */
+    intensity?: number;
+    /**
+     * Width of the darkness boundary in world pixels. Set to Infinity for global coverage. Default Infinity
+     */
+    width?: number;
+    /**
+     * Height of the darkness boundary in world pixels. Set to Infinity for global coverage. Default Infinity
+     */
+    height?: number;
+}
+/**
+ * Controls the darkness veil drawn over a scene or room by the {@apilink LightingSystem}.
+ *
+ * With `width`/`height` of `Infinity` (the default) the veil covers the whole screen. With finite
+ * dimensions the veil is a "room" rectangle in world pixels centered on the owning entity's position.
+ */
+export declare class DarknessComponent extends Component {
+    private static _NAME;
+    color: Color;
+    intensity: number;
+    width: number;
+    height: number;
+    constructor(options?: DarknessComponentOptions);
+}

package/build/esm/src/engine/lighting/flicker-options.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Options for light flicker driven by the {@apilink FlickerSystem} using deterministic layered sine waves.
+ */
+export interface FlickerOptions {
+    /**
+     * Frequency of the flicker oscillation in Hz.
+     */
+    frequency: number;
+    /**
+     * Maximum deviation from base intensity (0.0 to 1.0).
+     */
+    amplitude: number;
+    /**
+     * Optional secondary wave frequency for asymmetrical, organic modulation.
+     */
+    secondaryFrequency?: number;
+}

package/build/esm/src/engine/lighting/flicker-system.d.ts

@@ -0,0 +1,19 @@
+import { System, SystemType } from '../entity-component-system/system';
+import type { World } from '../entity-component-system/world';
+/**
+ * Modulates active light intensities ahead of the lighting render pass
+ * utilizing deterministic layered sine waves.
+ *
+ * Writes {@apilink PointLightComponent.currentIntensity} and {@apilink ConeLightComponent.currentIntensity},
+ * so it must run before the {@apilink LightingSystem} rasterizes the frame.
+ */
+export declare class FlickerSystem extends System {
+    static priority: 0;
+    readonly systemType = SystemType.Update;
+    private _pointQuery;
+    private _coneQuery;
+    private _elapsed;
+    onInitialize(world: World): void;
+    onUpdate(elapsed: number): void;
+    private _applyFlicker;
+}

package/build/esm/src/engine/lighting/index.d.ts

@@ -0,0 +1,8 @@
+export * from './lighting-config';
+export type * from './flicker-options';
+export * from './darkness-component';
+export * from './point-light-component';
+export * from './cone-light-component';
+export * from './light-occluder-component';
+export * from './flicker-system';
+export * from './lighting-system';

package/build/esm/src/engine/lighting/light-occluder-component.d.ts

@@ -0,0 +1,66 @@
+import { Component } from '../entity-component-system/component';
+import { Vector } from '../math/vector';
+export type OccluderShape = {
+    kind: 'box';
+    width: number;
+    height: number;
+    anchor?: Vector;
+} | {
+    kind: 'polygon';
+    vertices: Vector[];
+} | {
+    kind: 'circle';
+    radius: number;
+};
+/** A shadow volume silhouette approximated by a closed polygon in screen space */
+export type PolyOccluder = {
+    kind: 'poly';
+    verts: Vector[];
+};
+/** A shadow volume silhouette approximated by a circle in screen space */
+export type CircleOccluder = {
+    kind: 'circle';
+    center: Vector;
+    radius: number;
+};
+/** World/screen-space occluder geometry consumed by {@apilink LightingSystem} to cast shadows */
+export type Occluder = PolyOccluder | CircleOccluder;
+export interface LightOccluderComponentOptions {
+    /**
+     * Shape of the occluder, independent of any collider geometry on the entity
+     */
+    shape: OccluderShape;
+    /**
+     * When false, skips shadow volume geometry generation for this occluder. Default true
+     */
+    castShadows?: boolean;
+    /**
+     * Local space coordinate offset shifting the occluder geometry away from the transform origin. Default Vector.Zero
+     */
+    offset?: Vector;
+}
+/**
+ * Marks an entity as a light-blocking obstacle that projects dynamic shadows in the {@apilink LightingSystem}.
+ *
+ * Box shapes are centered on the transform origin by default (`anchor: Vector.Half`, matching {@apilink Shape.Box}).
+ * Polygon and circle shapes are positioned by their own vertex/center coordinates, same as {@apilink Shape.Polygon}
+ * and {@apilink Shape.Circle} — `offset` shifts any shape further from the transform origin in local space.
+ */
+export declare class LightOccluderComponent extends Component {
+    private static _NAME;
+    castShadows: boolean;
+    private _shape;
+    private _offset;
+    private _localVertices;
+    constructor(options: LightOccluderComponentOptions);
+    get shape(): OccluderShape;
+    set shape(shape: OccluderShape);
+    get offset(): Vector;
+    set offset(offset: Vector);
+    clone(): LightOccluderComponent;
+    /**
+     * Evaluates the bounding shape vertices in local space, factoring in local offsets.
+     * Returns an empty array for circular primitives. Cached until `shape` or `offset` are reassigned.
+     */
+    localVertices(): Vector[];
+}

package/build/esm/src/engine/lighting/lighting-config.d.ts

@@ -0,0 +1,47 @@
+import type { DeepRequired } from '../util/required';
+import type { Color } from '../color';
+/**
+ * Lighting simulation configuration, normalized from {@apilink EngineOptions.lighting}
+ */
+export interface LightingConfig {
+    /**
+     * Enables the scene {@apilink LightingSystem} and {@apilink FlickerSystem}. Default false.
+     *
+     * The lighting overlay is rendered with the 2D Canvas API and re-uploaded to the GPU every frame,
+     * which carries a performance penalty — this is why lighting is opt-in.
+     */
+    enabled: boolean;
+    /**
+     * The z-index of the provisioned lighting overlay. Default 100.
+     *
+     * Overridden per-instance by {@apilink LightingSystemOptions.zIndex}.
+     */
+    zIndex?: number;
+    /**
+     * World-pixel padding added around the camera frustum when culling lights/occluders. Default 64.
+     */
+    cullPadding?: number;
+    /**
+     * Ambient brightness floor (0.0 to 1.0) subtracted from darkness intensity. Default 0.05.
+     */
+    ambientIntensity?: number;
+    /**
+     * Ambient light color, blended into any {@apilink DarknessComponent} veil proportional to
+     * `ambientIntensity` (e.g. a blue ambient at low intensity produces a moonlit veil). Default `null`,
+     * meaning no color tint is applied.
+     */
+    ambientColor?: Color | null;
+    /**
+     * Fraction of a light's intensity used when painting its colored tint (0.0 to 1.0). Default 0.35.
+     */
+    tintAlphaFactor?: number;
+    /**
+     * Occluder shadow radial gradient opacity at the occluder (near) edge (0.0 to 1.0). Default 0.92.
+     */
+    shadowNearOpacity?: number;
+    /**
+     * Occluder shadow radial gradient opacity at 40% of the shadow's reach (0.0 to 1.0). Default 0.6.
+     */
+    shadowMidOpacity?: number;
+}
+export declare const getDefaultLightingConfig: () => DeepRequired<LightingConfig>;

package/build/esm/src/engine/lighting/lighting-system.d.ts

@@ -0,0 +1,153 @@
+import { System, SystemType } from '../entity-component-system/system';
+import type { World } from '../entity-component-system/world';
+import type { Scene } from '../scene';
+import { Vector } from '../math/vector';
+import { Color } from '../color';
+import { ScreenElement } from '../screen-element';
+export interface LightingSystemOptions {
+    /**
+     * The z-index of the provisioned lighting overlay. Defaults to 100.
+     */
+    zIndex?: number;
+    /**
+     * Fixed anchor screen positioning coordinate. When omitted the overlay is anchored to the
+     * top left of the full visible canvas ({@apilink Screen.unsafeArea}) every frame.
+     */
+    pos?: Vector;
+    /**
+     * Fixed resolution dimensions. Defaults to tracking the screen {@apilink Screen.resolution} when omitted.
+     */
+    size?: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Hook an external ScreenElement host rather than provisioning an independent one.
+     * The caller becomes responsible for its position and size.
+     */
+    screenElement?: ScreenElement;
+    /**
+     * Overrides {@apilink EngineOptions.lighting}'s `ambientIntensity` for this scene's instance.
+     */
+    ambientIntensity?: number;
+    /**
+     * Overrides {@apilink EngineOptions.lighting}'s `ambientColor` for this scene's instance.
+     */
+    ambientColor?: Color | null;
+}
+/**
+ * Composite canvas-driven visibility system tracking ambient, darkness,
+ * light masks, and ray projected shadow volumes.
+ *
+ * Renders via a {@apilink Canvas} graphic on a screen-space {@apilink ScreenElement} named 'lighting'.
+ * The raster pipeline per frame: ambient-blended darkness veil → room rect fills/clips → camera frustum
+ * cull → per-light destination-out punch (with occluder shadows subtracted) → colored tint passes.
+ *
+ * Enabled scene-wide via {@apilink EngineOptions.lighting}, or add an instance manually to a scene's world.
+ *
+ * **Potentially performance impacting** — the overlay is rasterized with the 2D Canvas API and re-uploaded
+ * to the GPU every frame.
+ *
+ * Known limitations: circle occluder radii scale uniformly with `Math.min(scale.x, scale.y)` so a
+ * non-uniformly scaled occluder won't cast an elliptical shadow, darkness room rects have no independent
+ * rotation of their own (though they do rotate along with the camera), and polygon shadow volumes can
+ * split at corners when the silhouette edge is not face on to the light.
+ */
+export declare class LightingSystem extends System {
+    static priority: number;
+    readonly systemType = SystemType.Draw;
+    private _options;
+    private _engine;
+    private _scene;
+    private _lightingEntity;
+    private _lightingCanvas;
+    private _offscreen;
+    private _offscreenCtx;
+    private _darknessEntries;
+    private _pointLights;
+    private _coneLights;
+    private _occluderEntries;
+    private _ambientScratch;
+    private _subscriptions;
+    constructor(options?: LightingSystemOptions);
+    onInitialize(world: World, scene: Scene): void;
+    /**
+     * Releases everything `initialize` provisioned: unsubscribes the component tracking queries,
+     * removes the lighting overlay ScreenElement (when this system created it), and drops the
+     * offscreen scratch canvas. Called by the {@apilink SystemManager} when the system is removed,
+     * e.g. when `engine.lighting.enabled` is turned off at runtime.
+     */
+    dispose(_world: World, scene: Scene): void;
+    /**
+     * Queries `world` for entities with `ctor` + a TransformComponent, seeds `entries` from the
+     * initial matches, and wires the query's entityAdded$/entityRemoved$ to keep `entries` in sync
+     * as matching entities are added/removed. Shared by all four light-like component trackers below.
+     */
+    private _wireQuery;
+    private _initDarkness;
+    private _initPointLights;
+    private _initConeLights;
+    private _initOccluders;
+    private _initCanvas;
+    onUpdate(elapsed: number): void;
+    /**
+     * Writes the scene's effective ambient intensity/color into `dest` (avoids allocating a fresh
+     * object every frame).
+     */
+    private _computeAmbient;
+    private _darknessFill;
+    private _drawDarknessVeil;
+    /**
+     * Computes (and caches) a room darkness rect's world bounds and camera-rotated screen quad. Only
+     * rebuilds when the room's world position/dimensions or the camera's finalized transform changed
+     * since last frame - the screen quad depends on the camera's full transform (which also moves with
+     * camera shake and fixed-update interpolation, not just pos/zoom/rotation), so the transform's
+     * matrix components are the cache key.
+     */
+    private _computeRoomClip;
+    private _inCameraView;
+    /**
+     * Computes (once per frame, shared by the erase and tint passes) whether each light in `entries` is
+     * enabled and within `cullBounds`, and its screen-space position/radius. Writes into each entry's
+     * persistent `screenPos` in place rather than allocating a new Vector.
+     */
+    private _updateLightVisibility;
+    /**
+     * Computes (and caches) an occluder's world-space shadow geometry. Only re-projects through the
+     * entity's transform when its position/rotation/scale or the component's shape/offset changed
+     * since last frame — avoids rebuilding shadow geometry for static occluders every frame.
+     */
+    private _computeOccluderGeometry;
+    /**
+     * True when the occluder's world geometry overlaps `bounds` expanded by `expand` on every side.
+     * Shadows only matter for occluders within a light's radius, and visible light centers lie within
+     * the cull bounds expanded by their own radius - so `expand` of twice the largest visible light
+     * radius is conservative.
+     */
+    private _occluderInRange;
+    private _collectOccluders;
+    /**
+     * Transforms every occluder's (cached, world-space) geometry to screen space once for this frame,
+     * so `_drawOccluderShadows` can reuse the same screen-space geometry for every light instead of
+     * re-transforming it once per (light, occluder) pair. Also computes a screen-space bounding circle
+     * per occluder so the shadow pass can cheaply skip (light, occluder) pairs that are out of range.
+     */
+    private _collectScreenOccluders;
+    private _drawOccluderShadows;
+    private _paintPointGradient;
+    private _paintConeGradient;
+    /**
+     * Draws a single light's shape into the offscreen scratch canvas, punches its occluder shadows
+     * out of it (destination-out), then punches the scratch out of the darkness veil (lights erase
+     * darkness).
+     */
+    private _drawLight;
+    /**
+     * Paints the additive colored tint for a non-white light, clipped to its containing room rect
+     */
+    private _drawColorTint;
+    private _drawPointLights;
+    private _drawConeLights;
+    private _drawColorTints;
+    private _renderLightingCanvas;
+}

package/build/esm/src/engine/lighting/point-light-component.d.ts

@@ -0,0 +1,46 @@
+import { Component } from '../entity-component-system/component';
+import { Color } from '../color';
+import type { FlickerOptions } from './flicker-options';
+export interface PointLightComponentOptions {
+    /**
+     * Color of the light. Non-white colors are painted as an additive tint. Default Color.White
+     */
+    color?: Color;
+    /**
+     * Base intensity of the light (0.0 to 1.0). Default 1.0
+     */
+    intensity?: number;
+    /**
+     * Radius of the light in world pixels. Default 150
+     */
+    radius?: number;
+    /**
+     * Optional flicker animation applied by the {@apilink FlickerSystem}
+     */
+    flicker?: FlickerOptions;
+    /**
+     * Default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Emits light uniformly in all directions from the owning entity's position,
+ * cutting through any {@apilink DarknessComponent} veil.
+ */
+export declare class PointLightComponent extends Component {
+    private static _NAME;
+    color: Color;
+    intensity: number;
+    radius: number;
+    flicker?: FlickerOptions;
+    enabled: boolean;
+    private _currentIntensity;
+    /**
+     * Runtime intensity after flicker calculations are applied, written by the {@apilink FlickerSystem}.
+     * Until a {@apilink FlickerSystem} writes a value (e.g. a {@apilink LightingSystem} added manually
+     * without one), reads track the live {@apilink PointLightComponent.intensity} value.
+     */
+    get currentIntensity(): number;
+    set currentIntensity(value: number);
+    constructor(options?: PointLightComponentOptions);
+}

package/build/{dist → esm/src/engine}/math/affine-matrix.d.ts

@@ -1,5 +1,6 @@
 import { Matrix } from './matrix';
 import { Vector } from './vector';
+import { Vector3 } from './vector3';
 export declare class AffineMatrix {
     /**
      * |         |         |          |
@@ -8,7 +9,7 @@ export declare class AffineMatrix {
      * | data[1] | data[3] | data[5]  |
      * |   0     |    0    |    1     |
      */
-    data: Float64Array;
+    data: Float64Array<ArrayBuffer>;
     /**
      * Converts the current matrix into a DOMMatrix
      *
@@ -61,6 +62,12 @@ export declare class AffineMatrix {
      * @param target
      */
     inverse(target?: AffineMatrix): AffineMatrix;
+    /**
+     * Multiply the current matrix by a vector producing a new vector
+     * @param vector
+     * @param dest
+     */
+    multiply(vector: Vector3, dest?: Vector3): Vector3;
     /**
      * Multiply the current matrix by a vector producing a new vector
      * @param vector

package/build/esm/src/engine/math/coord-plane.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Enum representing the coordinate plane for the position 2D vector in the {@apilink TransformComponent}
+ */
+export declare enum CoordPlane {
+    /**
+     * The world coordinate plane (default) represents world space, any entities drawn with world
+     * space move when the camera moves.
+     */
+    World = "world",
+    /**
+     * The screen coordinate plane represents screen space, entities drawn in screen space are pinned
+     * to screen coordinates ignoring the camera.
+     *
+     * Screen space is rooted at the top-left of the safe {@apilink Screen.contentArea} (the
+     * "C-frame"): a `CoordPlane.Screen` entity with `pos = (0, 0)` is drawn at
+     * `contentArea.topLeft`, not at the raw canvas corner (the "R-frame"). The engine applies this
+     * shift automatically before drawing — see {@apilink Screen.contentAreaOffset}.
+     *
+     * Under display modes that don't clip ({@apilink DisplayMode.Fixed}, {@apilink DisplayMode.FitScreen},
+     * {@apilink DisplayMode.FillScreen}, {@apilink DisplayMode.FitContainer}, {@apilink DisplayMode.FillContainer})
+     * `contentAreaOffset = (0, 0)` so the C and R frames coincide. Under
+     * {@apilink DisplayMode.FitScreenAndFill} / {@apilink DisplayMode.FitContainerAndFill} /
+     * {@apilink DisplayMode.FitScreenAndZoom} / {@apilink DisplayMode.FitContainerAndZoom}, the
+     * C-frame is shifted into the safe area.
+     *
+     * ```
+     *   World (infinite, camera)         Screen (CoordPlane.Screen, C)       Canvas / resolution (R)
+     *
+     *     +                                    +                                 +
+     *     | camera moves this                  | (0,0) = contentArea.topLeft     | (0,0) = canvas top-left
+     *     |                                    |   shifts into the safe area     |   raw canvas corner
+     *     |                                    |   on *AndFill / *AndZoom        |
+     *     v                                    v                                 v
+     *                                   +----------- contentW -----------+     +----------- resolutionW -------------------+
+     *   worldToScreen():                |                                |     |         |                        |        |
+     *   camera.transform                |        contentArea             |     | unsafe  |     contentArea        | unsafe |
+     *   - contentAreaOffset  ========>  |     (CoordPlane.Screen)        | <== | (clip)  |       (R span)         | (clip) |
+     *                                   |                                |     |         |                        |        |
+     *   screenToWorld():                +-------------------------------_+     +-------------------------------------------+
+     *   camera.inverse
+     *   + contentAreaOffset
+     *
+     *   contentAreaOffset = (clip|0, clip|0)   on the *AndFill / *AndZoom horizontal-clip axis;
+     *                         (0, 0)    under Fixed/FitScreen/FillScreen/FitContainer/FillContainer.
+     * ```
+     *
+     * Use {@apilink Screen.worldToScreenCoordinates}, {@apilink Screen.screenToWorldCoordinates},
+     * {@apilink Screen.pageToScreenCoordinates} and {@apilink Screen.screenToPageCoordinates}
+     * to convert between frames — they perform the offset and camera math for you.
+     */
+    Screen = "screen"
+}

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

@@ -178,8 +178,7 @@ export declare class Graph<T> {
      * This method calculates the shortest path from the specified start node to the
      * specified end node in the graph. It returns an object containing the path and
      * the total distance of the path.
-     * @param startNode - The node from which the search for the shortest path begins.
-     * @param endNode - The node where the search for the shortest path ends.
+     * @param sourcenode - The node from which the search for the shortest path begins.
      * @returns An object containing:
      *   - `path`: An array of nodes representing the shortest path from startNode to endNode.
      *     If no path is found, this will be `null`.
@@ -249,7 +248,7 @@ export declare class Edge<T> {
     get source(): Node<T>;
     get target(): Node<T>;
     get weight(): number;
-    get partnerEdge(): Edge<T>;
+    get partnerEdge(): Edge<T> | null;
 }
 /**
  * Represents a node in a graph, with a unique identifier and optional data.

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

@@ -15,3 +15,5 @@ export * from './util';
 export * from './rotation-type';
 export * from './graph';
 export * from './easings';
+export * from './vector3';
+export * from './vector4';

package/build/{dist → esm/src/engine}/math/line-segment.d.ts

@@ -60,7 +60,7 @@ export declare class LineSegment {
      * @param sideVector Vector that traces the line
      * @param length Length to clip along side
      */
-    clip(sideVector: Vector, length: number, normalize?: boolean): LineSegment;
+    clip(sideVector: Vector, length: number, normalize?: boolean): LineSegment | null;
     /**
      * Find the perpendicular distance from the line to a point
      * https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line