@skewedaspect/sage 0.10.0-beta.1 → 0.10.0-beta.2

package/dist/behaviors/sound.d.ts

@@ -0,0 +1,22 @@
+import { Behavior } from '@skewedaspect/sage-core';
+import { NodeBehaviorHooks } from "../entities/nodeEntity.d.ts";
+export interface SoundConfig {
+    url: string;
+    volume?: number;
+    loop?: boolean;
+    spatial?: boolean;
+    maxDistance?: number;
+    channel?: string;
+}
+export interface SoundState {
+    sounds: Record<string, SoundConfig>;
+}
+export declare class SoundBehavior extends Behavior<SoundState> implements NodeBehaviorHooks {
+    #private;
+    static readonly ops: readonly ["play", "stop"];
+    readonly defaults: SoundState;
+    onMeshLoaded(): void;
+    onDestroy(): void;
+    play(name: string): void;
+    stop(name: string): void;
+}

package/dist/classes/gameEngine.d.ts

@@ -8,6 +8,7 @@ import { AssetManager } from "../managers/asset.d.ts";
 import { ColliderDebugManager } from "../managers/colliderDebug.d.ts";
 import { DebugConsole } from "./debugConsole.d.ts";
 import { GameManager } from "../managers/game.d.ts";
+import { InputManager } from "../managers/input.d.ts";
 import { LevelManager } from "../managers/level.d.ts";
 import { SimulationSaveManager } from "../managers/simulationSave.d.ts";
 import { AudioManager } from "../managers/audio.d.ts";
@@ -37,6 +38,7 @@ interface Engines extends Record<string, Disposable | undefined> {
 interface Managers extends Record<string, Disposable | undefined> {
     assetManager: AssetManager;
     gameManager: GameManager;
+    inputManager: InputManager;
     levelManager: LevelManager;
     saveManager: SimulationSaveManager;
     audioManager?: AudioManager;
@@ -66,6 +68,7 @@ export declare class GameEngine {
     debug: DebugTools;
     largeWorldRendering: boolean;
     started: boolean;
+    private _stopped;
     private _log;
     private _buildSimulation;
     private _beforeStartHook;
@@ -135,6 +138,10 @@ export declare class GameEngine {
     start(): Promise<void>;
     /**
      * Stop the engine: runs the teardown hook, then tears down all managers and engines in order.
+     *
+     * Managers claim what they need when they are built, not when the engine starts -- the input manager's
+     * window listeners, the debug console's namespace -- so an engine that never started still has
+     * everything to release. Tearing down twice is the no-op.
      */
     stop(): Promise<void>;
 }

package/dist/classes/gameLevel.d.ts

@@ -1,6 +1,7 @@
 import { Quaternion, Scene, StaticSound, TransformNode, Vector3 } from '@babylonjs/core';
 import { LevelConfig, LevelContext } from "../interfaces/level.d.ts";
 import { NodeEntity } from "../entities/nodeEntity.d.ts";
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { Level } from "./level.d.ts";
 /**
  * Metadata collected from a spawn point node.
@@ -47,6 +48,11 @@ export declare class GameLevel extends Level {
     constructor(config: LevelConfig, context: LevelContext);
     get config(): LevelConfig;
     get spawnedEntities(): readonly NodeEntity[];
+    /**
+     * The simulation this level built its scene against: the one its own spawns and despawns go through,
+     * whichever simulation the engine holds at the time. Throws before `buildScene` has bound one.
+     */
+    protected get simulation(): NodeSimulation;
     /**
      * Build the scene by loading assets, processing node metadata, and spawning entities.
      */

package/dist/classes/level.d.ts

@@ -1,5 +1,6 @@
 import { Color3, Scene, TransformNode } from '@babylonjs/core';
 import { ClusteredLightContainer } from '@babylonjs/core/Lights/Clustered/clusteredLightContainer';
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { LoggerInterface } from "../interfaces/logger.d.ts";
 import { ColorConfig, LevelConfig, LevelContext, LevelInstance, LevelLoadOptions, PropertyHandler } from "../interfaces/level.d.ts";
 import { GameEngine } from "./gameEngine.d.ts";
@@ -28,6 +29,12 @@ export declare abstract class Level implements LevelInstance {
     protected readonly _context: LevelContext;
     protected _scene: Scene | null;
     protected _forRestore: boolean;
+    /**
+     * The simulation this level's scene was built against. A transition loads the next level before
+     * disposing this one, so by the time this level despawns what it spawned, the engine already holds the
+     * next level's simulation, minting the same IDs.
+     */
+    protected _simulation: NodeSimulation | null;
     clusteredLights: ClusteredLightContainer | null;
     outlines: OutlineManager | null;
     /**
@@ -47,6 +54,18 @@ export declare abstract class Level implements LevelInstance {
      * @param progress - Percentage (0-100)
      * @param message
      */
+    /**
+     * The simulation this level owns, or nothing for a level that never built one. The level manager binds
+     * the engine to the current level's simulation (design/simulation.md#which-simulation-the-engine-holds).
+     */
+    get $simulation(): NodeSimulation | null;
+    /**
+     * Take over a simulation built to replace this level's own, as a save load does once it has restored
+     * into a fresh one.
+     *
+     * @param simulation
+     */
+    $adoptSimulation(simulation: NodeSimulation): void;
     protected $emitProgress(progress: number, message: string): void;
     protected _toColor3(color: ColorConfig): Color3;
     /**

package/dist/debug/builtins.d.ts

@@ -2,9 +2,5 @@ import { DebugConsole } from "../classes/debugConsole.d.ts";
 import { GameEngine } from "../classes/gameEngine.d.ts";
 /**
  * Registers all default references and commands onto the debug console namespace.
- *
- * The entity system's class table carries no behavior list on the entity itself (entities.md#the-entity-
- * class-table), and a NodeEntity has no collider-debug method of its own -- so, unlike the 0.9 console, this
- * has no `list(type)`, no `entities` proxy, and no `showColliders`/`hideColliders`.
  */
 export declare function registerBuiltins(dc: DebugConsole, ge: GameEngine): void;

package/dist/entities/entityPicking.d.ts

@@ -11,4 +11,5 @@ export interface EntityPickResult {
     distance: number;
     normal: Vector3;
 }
+export declare function findEntityForMesh(entities: readonly GameEntity[], mesh: AbstractMesh): NodeEntity | undefined;
 export declare function toEntityPickResult(entities: readonly GameEntity[], info: PickingInfo | null, filter?: EntityPickFilter): EntityPickResult | undefined;

package/dist/entities/nodeEntity.d.ts

@@ -1,5 +1,7 @@
 import { TransformNode, AbstractMesh } from '@babylonjs/core';
 import { GameEntity, Action, GameEntityState, GameSimulationContext } from '@skewedaspect/sage-core';
+import { AudioManager } from "../managers/audio.d.ts";
+import { ColliderDebugConfig } from "../managers/colliderDebug.d.ts";
 import { MeshConfig } from "./meshConfig.d.ts";
 export interface Vector3State {
     x: number;
@@ -17,6 +19,11 @@ export interface NodeEntityState extends GameEntityState {
     nodeName?: string;
     position: Vector3State;
     rotation: QuaternionState;
+    debugCollider?: ColliderDebugConfig;
+}
+export interface NodeBehaviorHooks {
+    onMeshLoaded?(): void;
+    onDestroy?(): void;
 }
 export declare abstract class NodeEntity extends GameEntity {
     #private;
@@ -27,6 +34,9 @@ export declare abstract class NodeEntity extends GameEntity {
     get node(): TransformNode;
     get mesh(): AbstractMesh | undefined;
     set mesh(mesh: AbstractMesh | undefined);
+    get audio(): AudioManager | undefined;
+    showCollider(config?: ColliderDebugConfig, color?: string): void;
+    hideCollider(name?: string): void;
     protected constructor(id: string, context: GameSimulationContext, providedState: object, runCreateHooks: boolean, name?: string);
     update(dt: number): void;
     destroy(): void;

package/dist/entities/nodeSimulation.d.ts

@@ -1,22 +1,30 @@
 import { GameSimulationManager, GameSimulationOptions, StateBag } from '@skewedaspect/sage-core';
-import { Camera, Ray, Scene } from '@babylonjs/core';
+import { AbstractMesh, Camera, Ray, Scene } from '@babylonjs/core';
 import { EntityPickFilter, EntityPickResult } from "./entityPicking.d.ts";
+import { NodeEntity } from "./nodeEntity.d.ts";
 import { NodePool } from "./nodePool.d.ts";
 import { MeshLoader, NodeSimulationContext } from "./nodeSimulationContext.d.ts";
+import { AudioManager } from "../managers/audio.d.ts";
+import { ColliderDebugManager } from "../managers/colliderDebug.d.ts";
 export interface NodeSimulationOptions extends GameSimulationOptions {
     scene: Scene;
     loadMesh: MeshLoader;
     pool: NodePool;
+    audio?: AudioManager;
+    colliders: ColliderDebugManager;
 }
 export declare class NodeSimulation extends GameSimulationManager implements NodeSimulationContext {
     #private;
     readonly scene: Scene;
     readonly pool: NodePool;
     readonly loadMesh: MeshLoader;
+    readonly audio: AudioManager | undefined;
+    readonly colliders: ColliderDebugManager;
     constructor(options: NodeSimulationOptions);
     prewarm(name: string, count: number, state?: StateBag): Promise<void>;
     pickEntityWithRay(ray: Ray, filter?: EntityPickFilter): EntityPickResult | undefined;
     pickEntity(x: number, y: number, filter?: EntityPickFilter): EntityPickResult | undefined;
     pickEntityForward(camera: Camera, range: number, filter?: EntityPickFilter): EntityPickResult | undefined;
+    getEntityForMesh(mesh: AbstractMesh): NodeEntity | undefined;
     protected buildReplacementSimulation(options: GameSimulationOptions): NodeSimulation;
 }

package/dist/entities/nodeSimulationContext.d.ts

@@ -1,5 +1,7 @@
 import { AbstractMesh, Scene, TransformNode } from '@babylonjs/core';
 import { GameSimulationContext, StateBag } from '@skewedaspect/sage-core';
+import { AudioManager } from "../managers/audio.d.ts";
+import { ColliderDebugManager } from "../managers/colliderDebug.d.ts";
 import { NodePool } from "./nodePool.d.ts";
 export interface NodeSet {
     node: TransformNode;
@@ -10,4 +12,6 @@ export interface NodeSimulationContext extends GameSimulationContext {
     readonly scene: Scene;
     readonly pool: NodePool;
     readonly loadMesh: MeshLoader;
+    readonly audio?: AudioManager;
+    readonly colliders: ColliderDebugManager;
 }

package/dist/events/payloads.d.ts

@@ -48,17 +48,6 @@ export interface TriggerExitPayload {
     trigger: string;
     other: AbstractMesh;
 }
-/** Payload for entity:state-changed events */
-export interface EntityStateChangedPayload {
-    /** The ID of the entity whose state changed */
-    entityId: string;
-    /** The type of the entity */
-    entityType: string;
-    /** The current state (optional - may include full state or just changed parts) */
-    state?: object;
-    /** Specific changes made (optional - alternative to full state) */
-    changes?: Record<string, unknown>;
-}
 /** Payload for asset:progress events */
 export interface AssetProgressPayload {
     path: string;
@@ -98,7 +87,6 @@ export interface LibraryEventPayloadMap {
     'asset:complete': AssetCompletePayload;
     'trigger:enter': TriggerEnterPayload;
     'trigger:exit': TriggerExitPayload;
-    'entity:state-changed': EntityStateChangedPayload;
     'game:paused': GamePausedPayload;
     'game:resumed': GameResumedPayload;
     [key: string]: unknown;

package/dist/input/actionContext.d.ts

@@ -7,5 +7,7 @@ export declare class ActionContextRegistry {
     isActive(name: string): boolean;
     isRegistered(name: string): boolean;
     addBinding(binding: Binding<unknown>): void;
+    removeBinding(binding: Binding<unknown>): void;
+    list(): readonly Binding<unknown>[];
     isLive(binding: Binding<unknown>): boolean;
 }

package/dist/input/binding.d.ts

@@ -1,5 +1,5 @@
 import { Action } from '@skewedaspect/sage-core';
-export type BindingKind = 'trigger' | 'toggle' | 'value';
+export type BindingKind = 'trigger' | 'toggle' | 'value' | 'delta';
 export type DeviceType = 'keyboard' | 'mouse' | 'gamepad';
 export interface DeviceID {
     type: DeviceType;
@@ -25,6 +25,8 @@ export interface Binding<State> {
     readonly action: Action;
     readonly device: DeviceID;
     readonly context?: string;
+    readonly preventDefault: boolean;
+    readonly input: BindingInput;
     process(state: State): BindingFire | undefined;
     prime(state: State): void;
     toDefinition(): BindingDefinition;

package/dist/input/bindings/delta.d.ts

@@ -0,0 +1,23 @@
+import { Action } from '@skewedaspect/sage-core';
+import { Binding, BindingDefinition, BindingFire, BindingInput, DeviceID } from "../binding.d.ts";
+import { DeviceReader } from "../deviceReader.d.ts";
+export interface DeltaOptions {
+    scale?: number;
+    invert?: boolean;
+    deadzone?: number;
+    /** Takes this input from the browser while the binding is live (input.md#claiming-an-input-from-the-browser). */
+    preventDefault?: boolean;
+}
+export declare class DeltaBinding<State> implements Binding<State> {
+    #private;
+    readonly kind: "delta";
+    readonly action: Action;
+    readonly device: DeviceID;
+    readonly context?: string;
+    readonly preventDefault: boolean;
+    constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: DeltaOptions, context?: string);
+    get input(): BindingInput;
+    process(state: State): BindingFire | undefined;
+    prime(_state: State): void;
+    toDefinition(): BindingDefinition;
+}

package/dist/input/bindings/toggle.d.ts

@@ -1,5 +1,5 @@
 import { Action } from '@skewedaspect/sage-core';
-import { Binding, BindingDefinition, BindingFire, DeviceID } from "../binding.d.ts";
+import { Binding, BindingDefinition, BindingFire, BindingInput, DeviceID } from "../binding.d.ts";
 import { DeviceReader } from "../deviceReader.d.ts";
 export interface ToggleOptions {
     onValue?: boolean | number;
@@ -7,6 +7,8 @@ export interface ToggleOptions {
     initialState?: boolean;
     threshold?: number;
     invert?: boolean;
+    /** Takes this input from the browser while the binding is live (input.md#claiming-an-input-from-the-browser). */
+    preventDefault?: boolean;
 }
 export declare class ToggleBinding<State> implements Binding<State> {
     #private;
@@ -14,7 +16,9 @@ export declare class ToggleBinding<State> implements Binding<State> {
     readonly action: Action;
     readonly device: DeviceID;
     readonly context?: string;
+    readonly preventDefault: boolean;
     constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: ToggleOptions, context?: string);
+    get input(): BindingInput;
     process(state: State): BindingFire | undefined;
     prime(state: State): void;
     toDefinition(): BindingDefinition;

package/dist/input/bindings/trigger.d.ts

@@ -1,10 +1,12 @@
 import { Action } from '@skewedaspect/sage-core';
-import { Binding, BindingDefinition, BindingFire, DeviceID } from "../binding.d.ts";
+import { Binding, BindingDefinition, BindingFire, BindingInput, DeviceID } from "../binding.d.ts";
 import { DeviceReader } from "../deviceReader.d.ts";
 export type EdgeMode = 'rising' | 'falling' | 'both';
 export interface TriggerOptions {
     edge?: EdgeMode;
     threshold?: number;
+    /** Takes this input from the browser while the binding is live (input.md#claiming-an-input-from-the-browser). */
+    preventDefault?: boolean;
 }
 export declare class TriggerBinding<State> implements Binding<State> {
     #private;
@@ -12,7 +14,9 @@ export declare class TriggerBinding<State> implements Binding<State> {
     readonly action: Action;
     readonly device: DeviceID;
     readonly context?: string;
+    readonly preventDefault: boolean;
     constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: TriggerOptions, context?: string);
+    get input(): BindingInput;
     process(state: State): BindingFire | undefined;
     prime(state: State): void;
     toDefinition(): BindingDefinition;

package/dist/input/bindings/value.d.ts

@@ -1,5 +1,5 @@
 import { Action } from '@skewedaspect/sage-core';
-import { Binding, BindingDefinition, BindingFire, DeviceID } from "../binding.d.ts";
+import { Binding, BindingDefinition, BindingFire, BindingInput, DeviceID } from "../binding.d.ts";
 import { DeviceReader } from "../deviceReader.d.ts";
 export interface ValueOptions {
     scale?: number;
@@ -8,7 +8,8 @@ export interface ValueOptions {
     deadzone?: number;
     min?: number;
     max?: number;
-    emitOnChange?: boolean;
+    /** Takes this input from the browser while the binding is live (input.md#claiming-an-input-from-the-browser). */
+    preventDefault?: boolean;
 }
 export declare class ValueBinding<State> implements Binding<State> {
     #private;
@@ -16,8 +17,10 @@ export declare class ValueBinding<State> implements Binding<State> {
     readonly action: Action;
     readonly device: DeviceID;
     readonly context?: string;
+    readonly preventDefault: boolean;
     constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: ValueOptions, context?: string);
-    process(state: State): BindingFire | undefined;
-    prime(state: State): void;
+    get input(): BindingInput;
+    process(state: State): BindingFire;
+    prime(_state: State): void;
     toDefinition(): BindingDefinition;
 }

package/dist/input/deliverAction.d.ts

@@ -1,3 +1,4 @@
-import { GameSimulationContext } from '@skewedaspect/sage-core';
+import { Action, GameSimulationContext } from '@skewedaspect/sage-core';
 import { Binding } from "./binding.d.ts";
-export declare function deliverAction<State>(binding: Binding<State>, state: State, context: GameSimulationContext, senderID: string, targetID: string): void;
+export declare function deliverAction<State>(binding: Binding<State>, state: State, context: GameSimulationContext, senderID: string): void;
+export declare function deliverValueAction(action: Action, value: number, context: GameSimulationContext, senderID: string): void;

package/dist/input/deviceReaders/mouse.d.ts

@@ -1,6 +1,6 @@
 import { MouseState } from "../deviceState.d.ts";
 import { DeviceReader } from "../deviceReader.d.ts";
-export type MouseSourceType = 'button' | 'position' | 'wheel';
+export type MouseSourceType = 'button' | 'position' | 'wheel' | 'movement';
 export declare class MouseReader implements DeviceReader<MouseState> {
     readonly sourceType: MouseSourceType;
     readonly sourceKey: string;

package/dist/input/deviceState.d.ts

@@ -12,6 +12,11 @@ export interface MouseState {
         deltaY: number;
         deltaZ: number;
     }>;
+    /** How far the pointer travelled since the last routing pass, which is what a delta binding reads. */
+    readonly movement: Readonly<{
+        x: number;
+        y: number;
+    }>;
 }
 export interface GamepadState {
     readonly buttons: Readonly<Record<string, number>>;

package/dist/interfaces/game.d.ts

@@ -43,7 +43,7 @@ export interface SageOptions {
      * - `{ namespace: 'myGame' }`: enabled with custom namespace
      * - `false`: disabled (production builds)
      */
-    debug?: false | {
+    debug?: boolean | {
         namespace?: string;
     };
     /**

package/dist/interfaces/level.d.ts

@@ -54,7 +54,7 @@ export interface SpawnDefinition {
     tags?: string[];
     /** Additional configuration passed to the entity's initial state */
     config?: Record<string, unknown>;
-    /** Debug collider visualization config. Overrides the entity definition's debugCollider. */
+    /** Debug collider visualization config, written into the spawned entity's own debugCollider state field. */
     debugCollider?: ColliderDebugConfig;
 }
 /**
@@ -70,7 +70,7 @@ export interface EntityDefinition {
     tags?: string[];
     /** Additional configuration passed to the entity's initial state */
     config?: Record<string, unknown>;
-    /** Debug collider visualization config. Overrides the entity definition's debugCollider. */
+    /** Debug collider visualization config, written into the spawned entity's own debugCollider state field. */
     debugCollider?: ColliderDebugConfig;
 }
 /**

package/dist/managers/asset.d.ts

@@ -17,16 +17,23 @@ export declare class AssetManager implements Disposable {
     private _containers;
     /** Extracted fragment meshes (source meshes for instancing), keyed by full fragment path */
     private _sourceMeshes;
+    /** Container loads still in flight, keyed by base path, so concurrent callers share one load */
+    private _pendingContainers;
     constructor(eventBus: GameEventBus, sceneEngine: SceneEngine, logger?: LoggingUtility);
     /**
      * Split a path on `#` into base path and optional fragment name.
      */
     private _parsePath;
     /**
-     * Load (or retrieve from cache) the AssetContainer for a base path.
-     * Increments refCount.
+     * Load (or retrieve from cache) the AssetContainer for a base path, counting one reference for this
+     * caller. A caller arriving while the same base path is already loading shares that load instead of
+     * starting a second one, which would leave the first container cached over and uncounted.
      */
     private _loadContainer;
+    /**
+     * Read one container off disk and cache it, counting no references; `_loadContainer` does the counting.
+     */
+    private _fetchContainer;
     /**
      * Find a mesh by name inside a container. Throws if not found.
      */
@@ -49,7 +56,14 @@ export declare class AssetManager implements Disposable {
      */
     clone(path: string): Mesh;
     /**
-     * Preload a batch of asset paths. Emits `asset:progress` after each and `asset:complete` when finished.
+     * Preload a batch of asset paths, up to `MAX_CONCURRENT_LOADS` at a time, so a batch costs about as
+     * long as its slowest asset rather than the sum of them all.
+     *
+     * Emits `asset:progress` as each asset finishes loading, naming the asset that finished and counting
+     * one to one up to the total. Loads finish out of request order, so the paths do too.
+     *
+     * Every asset is attempted, and every load has finished before this returns. If any failed, it throws
+     * an `AggregateError` naming all of them and emits no `asset:complete`.
      */
     preload(paths: string[]): Promise<void>;
     /**

package/dist/managers/game.d.ts

@@ -2,6 +2,7 @@ import { AbstractEngine, Scene } from '@babylonjs/core';
 import { Disposable } from "../interfaces/lifecycle.d.ts";
 import { GameEventBus } from "../classes/eventBus.d.ts";
 import { GameEngine } from "../classes/gameEngine.d.ts";
+import { InputManager } from "./input.d.ts";
 import { LevelManager } from "./level.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
 /**
@@ -9,10 +10,15 @@ import { LoggingUtility } from "../utils/logger.d.ts";
  * Called once per frame with the delta time in seconds.
  */
 export type FrameCallback = (deltaTime: number) => void;
+/** How a frame callback answers to pause (design/ui.md#when-a-view-observes). */
+export interface FrameCallbackOptions {
+    suspendedByPause?: boolean;
+}
 export declare class GameManager implements Disposable {
     private _engine;
     private _eventBus;
     private _gameEngine;
+    private _inputManager;
     private _levelManager;
     private _log;
     private _boundRenderLoop;
@@ -31,6 +37,7 @@ export declare class GameManager implements Disposable {
      * Called by createGameEngine() after the GameEngine instance is created.
      */
     $setGameEngine(gameEngine: GameEngine): void;
+    setInputManager(inputManager: InputManager): void;
     /**
      * Whether the game is currently paused.
      * When paused, entity updates and frame callbacks are skipped, but rendering continues.
@@ -60,7 +67,7 @@ export declare class GameManager implements Disposable {
      * unsubscribe();
      * ```
      */
-    registerFrameCallback(callback: FrameCallback): () => void;
+    registerFrameCallback(callback: FrameCallback, options?: FrameCallbackOptions): () => void;
     private _renderLoop;
     private _resizeHandler;
     start(): Promise<void>;

package/dist/managers/input.d.ts

@@ -0,0 +1,34 @@
+import { GameSimulationContext, Unsubscribe } from '@skewedaspect/sage-core';
+import { Disposable } from "../interfaces/lifecycle.d.ts";
+import { Binding, DeviceType } from "../input/binding.d.ts";
+import { InputCapture } from "../input/inputCapture.d.ts";
+import { GamepadState, KeyboardState, MouseState } from "../input/deviceState.d.ts";
+import { ActionContextRegistry } from "../input/actionContext.d.ts";
+import { ActionRegistry } from "../input/actionRegistry.d.ts";
+declare module '@skewedaspect/sage-core' {
+    interface EventMap {
+        'input:deviceChanged': DeviceChangedPayload;
+    }
+}
+export interface DeviceChangedPayload {
+    deviceType: DeviceType;
+    /** Undefined for the first deliberate input of a session, which replaces no device type. */
+    previousDeviceType: DeviceType | undefined;
+}
+export declare const ROUTING_LOOP_SENDER_ID = "sage-input";
+export declare const DELIBERATE_THRESHOLD = 0.2;
+export declare const MOVEMENT_THRESHOLD = 2;
+export declare class InputManager implements Disposable {
+    #private;
+    readonly actions: ActionRegistry;
+    readonly contexts: ActionContextRegistry;
+    constructor();
+    get lastActiveDeviceType(): DeviceType | undefined;
+    deviceState(type: 'keyboard', index: number): KeyboardState;
+    deviceState(type: 'mouse', index: number): MouseState;
+    deviceState(type: 'gamepad', index: number): GamepadState;
+    registerCapture(capture: InputCapture): Unsubscribe;
+    getBindingsForAction(action: string, deviceType?: DeviceType, context?: string): readonly Binding<unknown>[];
+    routeCapturedInput(context: GameSimulationContext): void;
+    $teardown(): Promise<void>;
+}

package/dist/managers/level.d.ts

@@ -3,6 +3,7 @@ import { Disposable } from "../interfaces/lifecycle.d.ts";
 import { Level } from "../classes/level.d.ts";
 import { GameEventBus } from "../classes/eventBus.d.ts";
 import { GameEngine } from "../classes/gameEngine.d.ts";
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
 /**
  * Options for level transitions.
@@ -147,6 +148,19 @@ export declare class LevelManager implements Disposable {
      * @param options
      */
     loadLevel(config: LevelConfig, options?: LevelLoadOptions): Promise<Level>;
+    /**
+     * Bind the engine to a level's own simulation. A level that built none leaves the engine as it is.
+     *
+     * @param level
+     */
+    private _bindSimulation;
+    /**
+     * Hand the current level a simulation built to replace its own, and bind the engine to it. A save load
+     * restores into a fresh simulation, and the level that owns the scene has to follow it.
+     *
+     * @param simulation
+     */
+    $bindSimulation(simulation: NodeSimulation): void;
     /**
      * Activates a level by name, loading it if necessary.
      *

package/dist/managers/simulationSave.d.ts

@@ -1,4 +1,6 @@
 import { GameSimulationManager, GameSimulationSnapshot } from '@skewedaspect/sage-core';
+import { GameEngine } from "../classes/gameEngine.d.ts";
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { Disposable } from "../interfaces/lifecycle.d.ts";
 import { LevelLoadOptions } from "../interfaces/level.d.ts";
 export interface LevelLoader {
@@ -6,6 +8,7 @@ export interface LevelLoader {
         name: string;
     } | null;
     transition(levelName: string, options?: LevelLoadOptions): Promise<void>;
+    $bindSimulation(simulation: NodeSimulation): void;
 }
 export interface SaveEnvelope {
     saveFormatVersion: number;
@@ -17,14 +20,19 @@ export interface SaveEnvelope {
 }
 export type BeforeSaveHook = () => Record<string, unknown>;
 export interface LoadResult {
-    simulation: GameSimulationManager;
+    simulation: NodeSimulation;
     envelope: SaveEnvelope;
 }
 export declare class SimulationSaveManager implements Disposable {
     #private;
     constructor(levelLoader: LevelLoader, engineVersion: string, now?: () => number);
+    /**
+     * Late-bind the GameEngine after construction. Called by createGameEngine() after the GameEngine
+     * instance is created; load() needs it to reach the simulation a transition just rebuilt.
+     */
+    $setGameEngine(gameEngine: GameEngine): void;
     onBeforeSave(hook: BeforeSaveHook): void;
     save(simulation: GameSimulationManager): SaveEnvelope;
-    load(envelope: SaveEnvelope, simulation: GameSimulationManager): Promise<LoadResult>;
+    load(envelope: SaveEnvelope): Promise<LoadResult>;
     $teardown(): Promise<void>;
 }