@skewedaspect/sage 0.9.6 → 0.10.0-beta.2

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;
@@ -74,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;
@@ -113,10 +76,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;
@@ -128,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/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,13 @@
+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;
+    removeBinding(binding: Binding<unknown>): void;
+    list(): readonly Binding<unknown>[];
+    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,33 @@
+import { Action } from '@skewedaspect/sage-core';
+export type BindingKind = 'trigger' | 'toggle' | 'value' | 'delta';
+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;
+    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

@@ -0,0 +1,25 @@
+import { Action } from '@skewedaspect/sage-core';
+import { Binding, BindingDefinition, BindingFire, BindingInput, 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;
+    /** 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;
+    readonly kind: "toggle";
+    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

@@ -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 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;
+    readonly kind: "trigger";
+    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

@@ -0,0 +1,26 @@
+import { Action } from '@skewedaspect/sage-core';
+import { Binding, BindingDefinition, BindingFire, BindingInput, 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;
+    /** 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;
+    readonly kind: "value";
+    readonly action: Action;
+    readonly device: DeviceID;
+    readonly context?: string;
+    readonly preventDefault: boolean;
+    constructor(action: Action, device: DeviceID, reader: DeviceReader<State>, options?: ValueOptions, context?: string);
+    get input(): BindingInput;
+    process(state: State): BindingFire;
+    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[];

package/dist/input/deliverAction.d.ts

@@ -0,0 +1,4 @@
+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): void;
+export declare function deliverValueAction(action: Action, value: number, context: GameSimulationContext, senderID: string): void;

package/dist/input/deviceReader.d.ts

@@ -0,0 +1,5 @@
+export interface DeviceReader<State> {
+    readonly sourceType: string;
+    readonly sourceKey: string;
+    getValue(state: State): boolean | number | undefined;
+}

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

@@ -0,0 +1,9 @@
+import { GamepadState } from "../deviceState.d.ts";
+import { DeviceReader } from "../deviceReader.d.ts";
+export type GamepadSourceType = 'button' | 'axis';
+export declare class GamepadReader implements DeviceReader<GamepadState> {
+    readonly sourceType: GamepadSourceType;
+    readonly sourceKey: string;
+    constructor(sourceType: GamepadSourceType, sourceKey: string);
+    getValue(state: GamepadState): boolean | number | undefined;
+}

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

@@ -0,0 +1,8 @@
+import { KeyboardState } from "../deviceState.d.ts";
+import { DeviceReader } from "../deviceReader.d.ts";
+export declare class KeyboardReader implements DeviceReader<KeyboardState> {
+    readonly sourceType = "key";
+    readonly sourceKey: string;
+    constructor(sourceKey: string);
+    getValue(state: KeyboardState): boolean | undefined;
+}

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

@@ -0,0 +1,9 @@
+import { MouseState } from "../deviceState.d.ts";
+import { DeviceReader } from "../deviceReader.d.ts";
+export type MouseSourceType = 'button' | 'position' | 'wheel' | 'movement';
+export declare class MouseReader implements DeviceReader<MouseState> {
+    readonly sourceType: MouseSourceType;
+    readonly sourceKey: string;
+    constructor(sourceType: MouseSourceType, sourceKey: string);
+    getValue(state: MouseState): boolean | number | undefined;
+}

package/dist/input/deviceState.d.ts

@@ -0,0 +1,24 @@
+export interface KeyboardState {
+    readonly keys: Readonly<Record<string, boolean>>;
+}
+export interface MouseState {
+    readonly buttons: Readonly<Record<string, boolean>>;
+    readonly position: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly wheel: Readonly<{
+        deltaX: number;
+        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>>;
+    readonly axes: Readonly<Record<string, number>>;
+}

package/dist/input/inputCapture.d.ts

@@ -0,0 +1,21 @@
+import { BindingInput, DeviceType } from "./binding.d.ts";
+export interface CaptureOptions {
+    deviceTypes?: readonly DeviceType[];
+    sourceTypes?: readonly string[];
+    signal?: AbortSignal;
+}
+export interface CandidateInput {
+    device: {
+        type: DeviceType;
+        index: number;
+    };
+    sourceType: string;
+    sourceKey: string;
+    value: boolean | number;
+}
+export declare class InputCapture {
+    #private;
+    constructor(options?: CaptureOptions);
+    feed(candidate: CandidateInput): void;
+    wait(): Promise<BindingInput>;
+}

package/dist/input/resolveBinding.d.ts

@@ -0,0 +1,4 @@
+import { Action } from '@skewedaspect/sage-core';
+import { Binding, BindingDefinition } from "./binding.d.ts";
+import { DeviceReader } from "./deviceReader.d.ts";
+export declare function resolveBinding<State>(definition: BindingDefinition, action: Action, reader: DeviceReader<State>): Binding<State>;

package/dist/interfaces/game.d.ts

@@ -1,6 +1,14 @@
-import { EngineOptions, NullEngineOptions, WebGPUEngineOptions } from '@babylonjs/core';
+import { AbstractMesh, EngineOptions, NullEngineOptions, Scene, WebGPUEngineOptions } from '@babylonjs/core';
+import { StateBag } from '@skewedaspect/sage-core';
 import { LogLevel } from "./logger.d.ts";
-import { BindingDefinition } from "./binding.d.ts";
+/**
+ * Builds a NodeEntity class's mesh from its name and state, into the given scene.
+ *
+ * NodeSimulationContext's own MeshLoader carries no scene, because the same context that calls it also holds
+ * the scene -- but a game's own loader is authored once, before any scene exists, and reused across every
+ * level's simulation, so it needs the scene handed in.
+ */
+export type EntityMeshLoader = (scene: Scene, name: string, state: Readonly<StateBag>) => Promise<AbstractMesh | undefined>;
 export type GameCanvas = HTMLCanvasElement | OffscreenCanvas | null;
 /** Specifies which rendering engine to force using */
 export type EngineType = 'webgl' | 'webgpu' | 'auto';
@@ -19,8 +27,6 @@ export type RenderEngineOptions = (BabylonEngineOptions | NullEngineOptions | We
 export interface SageOptions {
     /** Render engine options for BabylonJS */
     renderOptions?: RenderEngineOptions;
-    /** Input bindings to be registered at startup */
-    bindings?: BindingDefinition[];
     /** Logging level for the engine */
     logLevel?: LogLevel;
     /** Audio channel names. If provided, SAGE initializes AudioV2 with one bus per channel. */
@@ -37,7 +43,17 @@ export interface SageOptions {
      * - `{ namespace: 'myGame' }`: enabled with custom namespace
      * - `false`: disabled (production builds)
      */
-    debug?: false | {
+    debug?: boolean | {
         namespace?: string;
     };
+    /**
+     * Pre-loaded Havok WASM binary, for booting outside a browser.
+     *
+     * Havok normally fetches its own WASM over HTTP; in node there is nothing to fetch from, so the
+     * bytes have to be handed in. Browsers should leave this unset -- it is not a performance knob,
+     * and setting it does not change how physics behaves.
+     */
+    havokBinary?: BufferSource;
+    /** The simulation's fixed step duration, in seconds. Default 1/60. */
+    fixedStepDuration?: number;
 }

package/dist/interfaces/level.d.ts

@@ -1,7 +1,18 @@
 import { Scene, TransformNode } from '@babylonjs/core';
 import { GameEngine } from "../classes/gameEngine.d.ts";
+import { EntityMeshLoader } from "./game.d.ts";
 import { ColliderDebugConfig } from "../managers/colliderDebug.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
+/**
+ * Options controlling how a level loads.
+ */
+export interface LevelLoadOptions {
+    /**
+     * If true, this load is restoring a save: the level runs no marker-driven spawning of its own, since the
+     * restored snapshot is the sole source of entities (design/simulation.md#saved-games).
+     */
+    forRestore?: boolean;
+}
 /**
  * Minimal interface for Level that property handlers receive.
  * This avoids circular dependencies while still providing access to level functionality.
@@ -43,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;
 }
 /**
@@ -51,13 +62,15 @@ export interface SpawnDefinition {
  * Used to configure entities that are marked with the 'entity' property in scene files.
  */
 export interface EntityDefinition {
-    /** Optional name override for the entity (overrides the scene node name). */
+    /** The entity type name to spawn, adopting the marked node. */
+    entity: string;
+    /** Optional human-readable name for the entity instance. */
     name?: string;
     /** Tags to apply to the entity (merged with definition tags). */
     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;
 }
 /**
@@ -81,6 +94,11 @@ export interface SceneConfig {
 export interface LevelConfig {
     /** The name of the level */
     name: string;
+    /**
+     * Builds a NodeEntity class's mesh from its name and state, into the level's scene. Left unset, every
+     * entity this level spawns gets a node with no mesh.
+     */
+    meshSource?: EntityMeshLoader;
     /** Scene file path, or configuration object with path and options */
     scene?: string | SceneConfig;
     /** Name of a registered custom Level class to use instead of GameLevel */

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

@@ -1,19 +1,23 @@
 import { AbstractEngine, Scene } from '@babylonjs/core';
 import { Disposable } from "../interfaces/lifecycle.d.ts";
 import { GameEventBus } from "../classes/eventBus.d.ts";
-import { GameEntityManager } from "./entity.d.ts";
+import { GameEngine } from "../classes/gameEngine.d.ts";
+import { InputManager } from "./input.d.ts";
 import { LevelManager } from "./level.d.ts";
-import { UserInputManager } from "./input.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
 /**
  * Callback function for frame updates.
  * 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 _entityManager;
+    private _gameEngine;
     private _inputManager;
     private _levelManager;
     private _log;
@@ -26,8 +30,14 @@ export declare class GameManager implements Disposable {
     /** Whether the game is currently paused */
     private _paused;
     started: boolean;
-    constructor(engine: AbstractEngine, eventBus: GameEventBus, entityManager: GameEntityManager, inputManager: UserInputManager, levelManager: LevelManager, logger?: LoggingUtility);
+    constructor(engine: AbstractEngine, eventBus: GameEventBus, levelManager: LevelManager, logger?: LoggingUtility);
     get currentScene(): Scene | null;
+    /**
+     * Late-bind the GameEngine after construction.
+     * 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.
@@ -57,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>;