@skewedaspect/sage 0.9.5 → 0.10.0-beta.1

package/dist/classes/debugConsole.d.ts

@@ -14,6 +14,7 @@ export declare class DebugConsole implements Disposable {
     $teardown(): Promise<void>;
     private _isDynamicGetter;
     private _getNamespace;
+    private _assertNamespaceFree;
     private _installNamespace;
     private _removeNamespace;
     private _defineGetter;

package/dist/classes/gameEngine.d.ts

@@ -1,28 +1,27 @@
-import { AbstractEngine, HavokPlugin } from '@babylonjs/core';
-import { GameCanvas } from "../interfaces/game.d.ts";
+import { AbstractEngine, HavokPlugin, Scene } from '@babylonjs/core';
+import { EntityMeshLoader, GameCanvas } from "../interfaces/game.d.ts";
 import { Disposable } from "../interfaces/lifecycle.d.ts";
+import { NodeSimulation } from "../entities/nodeSimulation.d.ts";
 import { SceneEngine } from "../engines/scene.d.ts";
 import { AudioEngine } from "../engines/audio.d.ts";
 import { AssetManager } from "../managers/asset.d.ts";
-import { BindingManager } from "../managers/binding.d.ts";
 import { ColliderDebugManager } from "../managers/colliderDebug.d.ts";
 import { DebugConsole } from "./debugConsole.d.ts";
 import { GameManager } from "../managers/game.d.ts";
-import { GameEntityManager } from "../managers/entity.d.ts";
 import { LevelManager } from "../managers/level.d.ts";
-import { SaveManager } from "../managers/save.d.ts";
-import { UserInputManager } from "../managers/input.d.ts";
+import { SimulationSaveManager } from "../managers/simulationSave.d.ts";
 import { AudioManager } from "../managers/audio.d.ts";
-import { GameEvent, GameEventBus, GameEventCallback, Unsubscribe } from "./eventBus.d.ts";
-import { ActionPayload, LibraryEventPayloadMap } from "../events/payloads.d.ts";
+import { GameEventBus, GameEventCallback, Unsubscribe } from "./eventBus.d.ts";
+import { LibraryEventPayloadMap } from "../events/payloads.d.ts";
 import { WildcardPattern } from "../events/types.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
-import { RaycastHelper } from "../utils/raycast.d.ts";
 import { GameTimer } from "../utils/timer.d.ts";
 /**
  * Type definition for game lifecycle hook functions
  */
 export type GameHook = (gameEngine: GameEngine) => Promise<void>;
+/** Builds a NodeSimulation bound to a scene and a mesh source -- a fresh one is built for every level that loads. */
+export type SimulationFactory = (scene: Scene, meshSource?: EntityMeshLoader) => NodeSimulation;
 /**
  * Interface representing the engines used in the game.
  * All engines must implement Disposable for proper cleanup.
@@ -37,12 +36,9 @@ interface Engines extends Record<string, Disposable | undefined> {
  */
 interface Managers extends Record<string, Disposable | undefined> {
     assetManager: AssetManager;
-    bindingManager: BindingManager;
     gameManager: GameManager;
-    entityManager: GameEntityManager;
-    inputManager: UserInputManager;
     levelManager: LevelManager;
-    saveManager: SaveManager;
+    saveManager: SimulationSaveManager;
     audioManager?: AudioManager;
 }
 /**
@@ -65,12 +61,13 @@ export declare class GameEngine {
     engines: Engines;
     eventBus: GameEventBus;
     logger: LoggingUtility;
-    raycast: RaycastHelper;
+    simulation: NodeSimulation | null;
     timer: GameTimer;
     debug: DebugTools;
     largeWorldRendering: boolean;
     started: boolean;
     private _log;
+    private _buildSimulation;
     private _beforeStartHook;
     private _onStartHook;
     private _onTeardownHook;
@@ -81,10 +78,18 @@ export declare class GameEngine {
      * @param physics
      * @param eventBus
      * @param logger
+     * @param timer
+     * @param buildSimulation - Builds a fresh simulation for a scene, once rebuildSimulation is called with one.
      * @param engines
      * @param managers
      */
-    constructor(canvas: GameCanvas, renderEngine: AbstractEngine, physics: HavokPlugin, eventBus: GameEventBus, logger: LoggingUtility, raycast: RaycastHelper, timer: GameTimer, engines: Engines, managers: Managers, largeWorldRendering?: boolean, debug?: DebugTools);
+    constructor(canvas: GameCanvas, renderEngine: AbstractEngine, physics: HavokPlugin, eventBus: GameEventBus, logger: LoggingUtility, timer: GameTimer, buildSimulation: SimulationFactory, engines: Engines, managers: Managers, largeWorldRendering?: boolean, debug?: DebugTools);
+    /**
+     * Builds a fresh NodeSimulation bound to the given scene and mesh source, and swaps it in. A level calls
+     * this once its own scene is ready, so every NodeEntity it spawns gets a node in that scene and loads its
+     * mesh through that source. Left unset, a spawned entity gets a node with no mesh.
+     */
+    rebuildSimulation(scene: Scene, meshSource?: EntityMeshLoader): NodeSimulation;
     /**
      * Register a function to be called before the game engine starts
      * @param hook
@@ -108,7 +113,7 @@ export declare class GameEngine {
      *
      * This is a convenience method that forwards to `eventBus.subscribe()`.
      *
-     * @param eventType - Exact event type string, wildcard pattern (e.g. 'input:*'), or RegExp
+     * @param eventType - Exact event type string, wildcard pattern (e.g. 'level:*'), or RegExp
      * @param callback
      * @returns A function that removes this subscription when called
      *
@@ -118,39 +123,12 @@ export declare class GameEngine {
      *     console.log('Level complete:', event.payload.levelName);
      * });
      *
-     * // Subscribe to all input events
-     * engine.subscribe('input:*', (event) => {
-     *     console.log('Input event:', event.type);
+     * // Subscribe to every level event
+     * engine.subscribe('level:*', (event) => {
+     *     console.log('Level event:', event.type);
      * });
      */
     subscribe<T extends keyof LibraryEventPayloadMap & string>(eventType: T | WildcardPattern | RegExp, callback: GameEventCallback<T, LibraryEventPayloadMap>): Unsubscribe;
-    /**
-     * Subscribe to an action event with full type safety.
-     *
-     * Action events are fired by the binding system when inputs trigger registered actions.
-     * All action events have the same payload structure (`ActionPayload`), containing:
-     * - `value`: The action value (number for analog, boolean for digital)
-     * - `deviceId`: The ID of the input device that triggered the action
-     * - `context`: The binding context that was active (optional)
-     *
-     * @param actionName - The action name (without the 'action:' prefix)
-     * @param callback
-     * @returns A function that removes this subscription when called
-     *
-     * @example
-     * // Subscribe to a specific action
-     * engine.subscribeAction('jump', (event) => {
-     *     console.log('Jump triggered with value:', event.payload.value);
-     *     console.log('From device:', event.payload.deviceId);
-     * });
-     *
-     * // Subscribe to movement action
-     * engine.subscribeAction('moveForward', (event) => {
-     *     const velocity = Number(event.payload.value);
-     *     player.move(velocity);
-     * });
-     */
-    subscribeAction(actionName: string, callback: (event: GameEvent<`action:${string}`, Record<`action:${string}`, ActionPayload>>) => void): Unsubscribe;
     /**
      * Start the engine: runs beforeStart hook, starts the game manager, then runs onStart hook.
      */

package/dist/classes/gameLevel.d.ts

@@ -1,6 +1,6 @@
 import { Quaternion, Scene, StaticSound, TransformNode, Vector3 } from '@babylonjs/core';
 import { LevelConfig, LevelContext } from "../interfaces/level.d.ts";
-import { GameEntity } from "./entity.d.ts";
+import { NodeEntity } from "../entities/nodeEntity.d.ts";
 import { Level } from "./level.d.ts";
 /**
  * Metadata collected from a spawn point node.
@@ -33,7 +33,7 @@ export declare class GameLevel extends Level {
     /** Collected entity nodes from the scene */
     protected _entityNodes: EntityNodeData[];
     /** Entities spawned by this level */
-    protected _spawnedEntities: GameEntity[];
+    protected _spawnedEntities: NodeEntity[];
     /** Level-scoped sounds created from config */
     protected _levelSounds: Map<string, StaticSound>;
     /** Sounds that were playing before deactivation (for resume on activate) */
@@ -46,7 +46,7 @@ export declare class GameLevel extends Level {
      */
     constructor(config: LevelConfig, context: LevelContext);
     get config(): LevelConfig;
-    get spawnedEntities(): readonly GameEntity[];
+    get spawnedEntities(): readonly NodeEntity[];
     /**
      * Build the scene by loading assets, processing node metadata, and spawning entities.
      */
@@ -124,22 +124,25 @@ export declare class GameLevel extends Level {
      */
     private _processSpawnPoint;
     /**
-     * Apply debug collider visualization to an entity if configured.
-     * Level/spawn config takes priority over the entity definition's debugCollider.
-     */
-    private _applyDebugCollider;
-    /**
-     * Create an entity from a spawn definition, inheriting position/rotation/scaling from the spawn point.
+     * Spawn an entity through the simulation, inheriting position and rotation from the spawn point. The node
+     * and its mesh are the simulation's own business, built by NodeEntity's constructor from the class name and
+     * state -- the level does no mesh building of its own.
+     *
+     * A spawn point's scaling has nowhere to go: NodeEntityState declares position and rotation, not scaling,
+     * and inventing a state field for it is not this level's call to make. It is dropped.
      */
     private _spawnEntity;
     /**
-     * Create game entities for all nodes marked with the 'entity' metadata property.
+     * Match collected entity nodes against the level config's entity definitions and spawn entities adopting
+     * their marked node.
      */
     private _processEntityNodes;
     /**
-     * Create a game entity for an entity-tagged node, attaching the existing scene node to it.
+     * Spawn an entity adopting an entity marker's node. `nodeName` is the marked node's own name, written by
+     * the level rather than by configuration, since it is the binding key adoption resolves through
+     * (design/authoring.md#the-binding-key).
      */
-    private _processEntityNode;
+    private _spawnEntityNode;
     /**
      * Create level-scoped sounds from YAML config. Sounds are tracked for lifecycle management
      * (pause on deactivate, resume on activate, dispose on unload).

package/dist/classes/level.d.ts

@@ -1,28 +1,14 @@
-import { Color3, Quaternion, Scene, TransformNode, Vector3 } from '@babylonjs/core';
+import { Color3, Scene, TransformNode } from '@babylonjs/core';
 import { ClusteredLightContainer } from '@babylonjs/core/Lights/Clustered/clusteredLightContainer';
 import { LoggerInterface } from "../interfaces/logger.d.ts";
-import { ColorConfig, LevelConfig, LevelContext, LevelInstance, PropertyHandler } from "../interfaces/level.d.ts";
-import { GameEntity } from "./entity.d.ts";
+import { ColorConfig, LevelConfig, LevelContext, LevelInstance, LevelLoadOptions, PropertyHandler } from "../interfaces/level.d.ts";
 import { GameEngine } from "./gameEngine.d.ts";
 import { OutlineManager } from "../managers/outline.d.ts";
-/**
- * Transform and visibility overrides applied to a mesh built by `Level.createEntityMesh()`.
- */
-export interface CreateEntityMeshOptions {
-    /** World position for the entity's root node. Left at the node default when omitted. */
-    position?: Vector3;
-    /** World rotation for the entity's root node. Left at the node default when omitted. */
-    rotation?: Quaternion;
-    /** Scaling for the entity's root node. Left at the node default when omitted. */
-    scaling?: Vector3;
-    /** When false, the node is disabled immediately on creation so nothing ever renders. Default true. */
-    enabled?: boolean;
-}
 /**
  * Abstract base class for game levels.
  *
  * Levels are responsible for creating and configuring their own scenes via the
- * `buildScene()` method. All runtime dependencies (eventBus, sceneEngine, entityManager)
+ * `buildScene()` method. All runtime dependencies (eventBus, sceneEngine, simulation)
  * are injected via the constructor and are immediately available.
  *
  * Users should not instantiate Level subclasses directly. Instead, use LevelManager
@@ -41,6 +27,7 @@ export declare abstract class Level implements LevelInstance {
     protected readonly _log: LoggerInterface;
     protected readonly _context: LevelContext;
     protected _scene: Scene | null;
+    protected _forRestore: boolean;
     clusteredLights: ClusteredLightContainer | null;
     outlines: OutlineManager | null;
     /**
@@ -77,18 +64,7 @@ export declare abstract class Level implements LevelInstance {
      * Load and create the scene for this level.
      * Progress events will be emitted during loading.
      */
-    load(): Promise<Scene>;
-    /**
-     * Build or import a mesh from the entity definition and attach it to the entity.
-     * Supports primitive shapes (box/sphere/capsule/cylinder) and GLB/GLTF file paths.
-     *
-     * @param entity - The entity whose definition supplies the mesh spec
-     * @param options - Transform overrides and initial enabled state
-     *
-     * @returns The root node the mesh was built under, or null if the level has no scene, the definition has no
-     * mesh spec, or the GLB import produced no meshes.
-     */
-    createEntityMesh(entity: GameEntity, options?: CreateEntityMeshOptions): Promise<TransformNode | null>;
+    load(options?: LevelLoadOptions): Promise<Scene>;
     /**
      * Abstract method for building the scene content.
      * Concrete levels must implement this to create their specific content.

package/dist/debug/builtins.d.ts

@@ -2,5 +2,9 @@ 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/constants.d.ts

@@ -0,0 +1 @@
+export declare const poolSizeLimit = 8;

package/dist/entities/defineEntity.d.ts

@@ -0,0 +1,17 @@
+import { Action, BehaviorClass, StateFor, ValidTuple } from '@skewedaspect/sage-core';
+import { NodeEntity } from "./nodeEntity.d.ts";
+import { MeshConfig } from "./meshConfig.d.ts";
+export interface GameEntityDefinition<Behaviors extends readonly BehaviorClass[]> {
+    type: string;
+    tags?: string[];
+    defaultState?: Partial<StateFor<Behaviors>>;
+    behaviors: Behaviors;
+    mesh?: MeshConfig;
+    actions?: readonly Action[];
+}
+export type GameEntityDefinitionClass<Behaviors extends readonly BehaviorClass[]> = typeof NodeEntity & {
+    readonly behaviors: Behaviors;
+};
+export declare function defineEntity<Behaviors extends readonly BehaviorClass[]>(definition: GameEntityDefinition<Behaviors> & {
+    behaviors: ValidTuple<Behaviors>;
+}): GameEntityDefinitionClass<Behaviors>;

package/dist/entities/entityPicking.d.ts

@@ -0,0 +1,14 @@
+import { Vector3, AbstractMesh, PickingInfo } from '@babylonjs/core';
+import { GameEntity } from '@skewedaspect/sage-core';
+import { NodeEntity } from "./nodeEntity.d.ts";
+export interface EntityPickFilter {
+    tags?: readonly string[];
+}
+export interface EntityPickResult {
+    entity: NodeEntity;
+    mesh: AbstractMesh;
+    point: Vector3;
+    distance: number;
+    normal: Vector3;
+}
+export declare function toEntityPickResult(entities: readonly GameEntity[], info: PickingInfo | null, filter?: EntityPickFilter): EntityPickResult | undefined;

package/dist/entities/meshConfig.d.ts

@@ -0,0 +1,14 @@
+import { ColorConfig } from "../interfaces/level.d.ts";
+export interface MeshMaterialConfig {
+    type?: 'standard' | 'pbr';
+    color?: ColorConfig;
+    emissive?: ColorConfig;
+    metallic?: number;
+    roughness?: number;
+}
+export interface MeshConfig {
+    source: string;
+    params?: Record<string, unknown>;
+    material?: MeshMaterialConfig;
+    visible?: boolean;
+}

package/dist/entities/nodeEntity.d.ts

@@ -0,0 +1,33 @@
+import { TransformNode, AbstractMesh } from '@babylonjs/core';
+import { GameEntity, Action, GameEntityState, GameSimulationContext } from '@skewedaspect/sage-core';
+import { MeshConfig } from "./meshConfig.d.ts";
+export interface Vector3State {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface QuaternionState {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface NodeEntityState extends GameEntityState {
+    parentID?: string;
+    nodeName?: string;
+    position: Vector3State;
+    rotation: QuaternionState;
+}
+export declare abstract class NodeEntity extends GameEntity {
+    #private;
+    static readonly poolable: boolean;
+    static readonly poolSize?: number;
+    static readonly meshConfig?: MeshConfig;
+    static readonly actions?: readonly Action[];
+    get node(): TransformNode;
+    get mesh(): AbstractMesh | undefined;
+    set mesh(mesh: AbstractMesh | undefined);
+    protected constructor(id: string, context: GameSimulationContext, providedState: object, runCreateHooks: boolean, name?: string);
+    update(dt: number): void;
+    destroy(): void;
+}

package/dist/entities/nodePool.d.ts

@@ -0,0 +1,8 @@
+import { NodeSet } from "./nodeSimulationContext.d.ts";
+export declare class NodePool {
+    #private;
+    take(name: string): NodeSet | undefined;
+    give(name: string, set: NodeSet, limit?: number): void;
+    clear(name: string): void;
+    clearAll(): void;
+}

package/dist/entities/nodeSimulation.d.ts

@@ -0,0 +1,22 @@
+import { GameSimulationManager, GameSimulationOptions, StateBag } from '@skewedaspect/sage-core';
+import { Camera, Ray, Scene } from '@babylonjs/core';
+import { EntityPickFilter, EntityPickResult } from "./entityPicking.d.ts";
+import { NodePool } from "./nodePool.d.ts";
+import { MeshLoader, NodeSimulationContext } from "./nodeSimulationContext.d.ts";
+export interface NodeSimulationOptions extends GameSimulationOptions {
+    scene: Scene;
+    loadMesh: MeshLoader;
+    pool: NodePool;
+}
+export declare class NodeSimulation extends GameSimulationManager implements NodeSimulationContext {
+    #private;
+    readonly scene: Scene;
+    readonly pool: NodePool;
+    readonly loadMesh: MeshLoader;
+    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;
+    protected buildReplacementSimulation(options: GameSimulationOptions): NodeSimulation;
+}

package/dist/entities/nodeSimulationContext.d.ts

@@ -0,0 +1,13 @@
+import { AbstractMesh, Scene, TransformNode } from '@babylonjs/core';
+import { GameSimulationContext, StateBag } from '@skewedaspect/sage-core';
+import { NodePool } from "./nodePool.d.ts";
+export interface NodeSet {
+    node: TransformNode;
+    mesh: AbstractMesh | undefined;
+}
+export type MeshLoader = (name: string, state: Readonly<StateBag>) => Promise<AbstractMesh | undefined>;
+export interface NodeSimulationContext extends GameSimulationContext {
+    readonly scene: Scene;
+    readonly pool: NodePool;
+    readonly loadMesh: MeshLoader;
+}

package/dist/entities/standardMeshSource.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMesh, AssetContainer, Mesh } from '@babylonjs/core';
+import { GameEntityType } from '@skewedaspect/sage-core';
+import { EntityMeshLoader } from "../interfaces/game.d.ts";
+export interface MeshAssetSource {
+    load(path: string): Promise<AssetContainer | AbstractMesh>;
+    clone(path: string): Mesh;
+}
+export declare function buildStandardMeshSource(entityClasses: Readonly<Record<string, GameEntityType>>, assets: MeshAssetSource): EntityMeshLoader;

package/dist/events/payloads.d.ts

@@ -1,24 +1,4 @@
 import { AbstractMesh } from '@babylonjs/core';
-import { DeviceType, InputDevice, InputState } from "../interfaces/input.d.ts";
-/** Payload for input:device:connected events */
-export interface DeviceConnectedPayload {
-    device: InputDevice;
-}
-/** Payload for input:device:disconnected events */
-export interface DeviceDisconnectedPayload {
-    device: InputDevice;
-}
-/** Payload for input:changed events */
-export interface InputChangedPayload {
-    deviceId: string;
-    device: InputDevice;
-    state: InputState;
-}
-/** Payload for input:device-type:changed events */
-export interface DeviceTypeChangedPayload {
-    deviceType: DeviceType;
-    previousDeviceType: DeviceType | null;
-}
 /** Payload for level:progress events */
 export interface LevelProgressPayload {
     levelName: string;
@@ -58,12 +38,6 @@ export interface LevelTransitionErrorPayload {
     to: string;
     error: unknown;
 }
-/** Payload for action:* events */
-export interface ActionPayload {
-    value: boolean | number;
-    deviceId: string;
-    context?: string;
-}
 /** Payload for trigger:enter events */
 export interface TriggerEnterPayload {
     trigger: string;
@@ -113,10 +87,6 @@ export interface GameResumedPayload {
  * while still providing type safety for known event types.
  */
 export interface LibraryEventPayloadMap {
-    'input:device:connected': DeviceConnectedPayload;
-    'input:device:disconnected': DeviceDisconnectedPayload;
-    'input:changed': InputChangedPayload;
-    'input:device-type:changed': DeviceTypeChangedPayload;
     'level:progress': LevelProgressPayload;
     'level:complete': LevelCompletePayload;
     'level:error': LevelErrorPayload;

package/dist/events/types.d.ts

@@ -1,12 +1,3 @@
-/**
- * Template literal type for action events.
- * Actions are dynamically named based on user-defined action names.
- *
- * @example
- * type MyActions = ActionEvent<'jump' | 'attack' | 'dodge'>;
- * // Results in: "action:jump" | "action:attack" | "action:dodge"
- */
-export type ActionEvent<Name extends string = string> = `action:${Name}`;
 /**
  * Template literal type for level events.
  *
@@ -15,24 +6,12 @@ export type ActionEvent<Name extends string = string> = `action:${Name}`;
  * // Results in: "level:progress" | "level:complete"
  */
 export type LevelEvent<Name extends string = string> = `level:${Name}`;
-/**
- * Template literal type for input events.
- *
- * @example
- * type MyInputEvents = InputEvent<'changed' | 'device:connected'>;
- * // Results in: "input:changed" | "input:device:connected"
- */
-export type InputEvent<Name extends string = string> = `input:${Name}`;
 /** Library-defined level event types */
 export type LibraryLevelEvent = LevelEvent<'progress' | 'complete' | 'error'>;
-/** Library-defined input event types */
-export type LibraryInputEvent = InputEvent<'changed' | 'device:connected' | 'device:disconnected'>;
-/** Library-defined action event types (dynamic, based on action name) */
-export type LibraryActionEvent = ActionEvent<string>;
 /** All library-defined event types */
-export type LibraryEventType = LibraryLevelEvent | LibraryInputEvent | LibraryActionEvent;
+export type LibraryEventType = LibraryLevelEvent;
 /**
  * Wildcard subscription patterns for subscribing to multiple events.
  * These are valid for subscribe() but NOT for publish().
  */
-export type WildcardPattern = 'action:*' | 'level:*' | 'input:*' | 'input:device:*' | `${string}:*`;
+export type WildcardPattern = 'level:*' | `${string}:*`;

package/dist/input/actionContext.d.ts

@@ -0,0 +1,11 @@
+import { Binding } from "./binding.d.ts";
+export declare class ActionContextRegistry {
+    #private;
+    registerContext(name: string, exclusive?: boolean): void;
+    activateContext(name: string, currentState: (binding: Binding<unknown>) => unknown): void;
+    deactivateContext(name: string): void;
+    isActive(name: string): boolean;
+    isRegistered(name: string): boolean;
+    addBinding(binding: Binding<unknown>): void;
+    isLive(binding: Binding<unknown>): boolean;
+}

package/dist/input/actionRegistry.d.ts

@@ -0,0 +1,7 @@
+import { Action } from '@skewedaspect/sage-core';
+export declare class ActionRegistry {
+    #private;
+    register(action: Action): void;
+    get(name: string): Action | undefined;
+    list(): readonly Action[];
+}

package/dist/input/binding.d.ts

@@ -0,0 +1,31 @@
+import { Action } from '@skewedaspect/sage-core';
+export type BindingKind = 'trigger' | 'toggle' | 'value';
+export type DeviceType = 'keyboard' | 'mouse' | 'gamepad';
+export interface DeviceID {
+    type: DeviceType;
+    index: number;
+}
+export interface BindingInput {
+    device: DeviceID;
+    sourceType: string;
+    sourceKey: string;
+}
+export interface BindingDefinition {
+    kind: BindingKind;
+    action: string;
+    input: BindingInput;
+    context?: string;
+    options?: Record<string, unknown>;
+}
+export interface BindingFire {
+    value: boolean | number;
+}
+export interface Binding<State> {
+    readonly kind: BindingKind;
+    readonly action: Action;
+    readonly device: DeviceID;
+    readonly context?: string;
+    process(state: State): BindingFire | undefined;
+    prime(state: State): void;
+    toDefinition(): BindingDefinition;
+}

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

@@ -0,0 +1,21 @@
+import { Action } from '@skewedaspect/sage-core';
+import { Binding, BindingDefinition, BindingFire, DeviceID } from "../binding.d.ts";
+import { DeviceReader } from "../deviceReader.d.ts";
+export interface ToggleOptions {
+    onValue?: boolean | number;
+    offValue?: boolean | number;
+    initialState?: boolean;
+    threshold?: number;
+    invert?: boolean;
+}
+export declare class ToggleBinding<State> implements Binding<State> {
+    #private;
+    readonly kind: "toggle";
+    readonly action: Action;
+    readonly device: DeviceID;
+    readonly context?: string;
+    constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: ToggleOptions, context?: string);
+    process(state: State): BindingFire | undefined;
+    prime(state: State): void;
+    toDefinition(): BindingDefinition;
+}

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

@@ -0,0 +1,19 @@
+import { Action } from '@skewedaspect/sage-core';
+import { Binding, BindingDefinition, BindingFire, DeviceID } from "../binding.d.ts";
+import { DeviceReader } from "../deviceReader.d.ts";
+export type EdgeMode = 'rising' | 'falling' | 'both';
+export interface TriggerOptions {
+    edge?: EdgeMode;
+    threshold?: number;
+}
+export declare class TriggerBinding<State> implements Binding<State> {
+    #private;
+    readonly kind: "trigger";
+    readonly action: Action;
+    readonly device: DeviceID;
+    readonly context?: string;
+    constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: TriggerOptions, context?: string);
+    process(state: State): BindingFire | undefined;
+    prime(state: State): void;
+    toDefinition(): BindingDefinition;
+}

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

@@ -0,0 +1,23 @@
+import { Action } from '@skewedaspect/sage-core';
+import { Binding, BindingDefinition, BindingFire, DeviceID } from "../binding.d.ts";
+import { DeviceReader } from "../deviceReader.d.ts";
+export interface ValueOptions {
+    scale?: number;
+    offset?: number;
+    invert?: boolean;
+    deadzone?: number;
+    min?: number;
+    max?: number;
+    emitOnChange?: boolean;
+}
+export declare class ValueBinding<State> implements Binding<State> {
+    #private;
+    readonly kind: "value";
+    readonly action: Action;
+    readonly device: DeviceID;
+    readonly context?: string;
+    constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: ValueOptions, context?: string);
+    process(state: State): BindingFire | undefined;
+    prime(state: State): void;
+    toDefinition(): BindingDefinition;
+}

package/dist/input/configuration.d.ts

@@ -0,0 +1,15 @@
+import { Action } from '@skewedaspect/sage-core';
+import { ActionContextRegistry } from "./actionContext.d.ts";
+import { ActionRegistry } from "./actionRegistry.d.ts";
+import { Binding, BindingDefinition } from "./binding.d.ts";
+export interface ContextDefinition {
+    name: string;
+    exclusive: boolean;
+}
+export interface Configuration {
+    actions: readonly Action[];
+    bindings: readonly BindingDefinition[];
+    contexts: readonly ContextDefinition[];
+}
+export declare function exportConfiguration(actions: readonly Action[], bindings: readonly Binding<unknown>[], contexts: readonly ContextDefinition[]): Configuration;
+export declare function importConfiguration(config: Configuration, actions: ActionRegistry, contexts: ActionContextRegistry): readonly BindingDefinition[];