@zylem/game-lib 0.8.9 → 0.9.1

package/dist/{game-DyKbOeck.d.ts → stage-CAPlk_cN.d.ts}

@@ -1,134 +1,17 @@
-import { e as InputPlayerNumber, f as InputProvider, I as Inputs, h as SetupFunction, g as UpdateFunction, j as DestroyFunction, a as SetupContext, U as UpdateContext, D as DestroyContext, L as LoadingEvent, m as IGame, S as StageNavigationOptions } from './base-node-life-cycle-BK9xebT9.js';
-import { G as GameInputConfig, B as BaseGlobals, Z as ZylemGameConfig } from './game-interfaces-vF5sRi1n.js';
 import { B as BaseNode } from './base-node-idopiSw5.js';
+import { h as SetupFunction, g as UpdateFunction, j as DestroyFunction, a as SetupContext, U as UpdateContext, D as DestroyContext, L as LoadingEvent } from './base-node-life-cycle-BK9xebT9.js';
 import { Scene, Color, Object3D, Vector3, BufferGeometry, Material, Group, Texture } from 'three';
-import { al as ZylemWorld, aj as EntityTypeMap } from './entity-type-map-D6BeAdvg.js';
+import { al as ZylemWorld, aj as EntityTypeMap } from './entity-type-map-CrsrKT8c.js';
 import { E as Entity, L as LifecycleFunction, S as StageEntity } from './entity-BIf_a4dl.js';
-import { G as GameEntity, a as GameEntityOptions, y as GameEntityLifeCycle } from './entity-XqvuWgPm.js';
-import { k as ZylemCamera, R as RendererManager, e as CameraPerspective, d as CameraContext, C as CameraPose, P as PerspectiveType, f as CameraBehavior, g as CameraAction, h as CameraPipelineState, V as Viewport, Z as ZylemPostEffect } from './zylem-camera-DZTpPOiD.js';
+import { G as GameEntity, a as GameEntityOptions } from './entity-XqvuWgPm.js';
+import { l as ZylemCamera, R as RendererManager, e as CameraPerspective, d as CameraContext, C as CameraPose, P as PerspectiveType, f as CameraBehavior, g as CameraAction, h as CameraPipelineState, V as Viewport, Z as ZylemPostEffect } from './zylem-camera-CYDtrVgi.js';
 import { d as ZylemShader } from './material-CxxAyJYp.js';
 import { a as SimulationBody } from './simulation-body-zQw-emOr.js';
 import { e as Vec3Input, b as Vec2Input, d as Vec3Components } from './vector-D3eDzvcA.js';
+import { StageEvents } from './events.js';
+import { G as GameInputConfig } from './game-interfaces-vF5sRi1n.js';
 import { SwatchApplyResult, SceneOperationEntry, EntityApplySwatchPayload, SceneOperationPayload } from '@zylem/bridge';
-import { BehaviorSystem, BehaviorEntityLink, BehaviorRuntime, BehaviorSystemFactory, BehaviorRef, Simulation } from '@zylem/behaviors/core';
-import { StageEvents, GameEvents } from './events.js';
-import { D as DefaultTouchControlsOptions } from './default-controls-CAKJ5zlo.js';
-import { S as StageTransitionConfig } from './stage-transition-CmGpV4tc.js';
-
-declare class InputManager {
-    private inputMap;
-    private currentInputs;
-    private previousInputs;
-    private readonly targetElement?;
-    private readonly mouseTargetElement?;
-    constructor(config?: GameInputConfig, options?: {
-        targetElement?: HTMLElement;
-        mouseTargetElement?: HTMLElement;
-    });
-    /**
-     * Reconfigure keyboard and mouse providers at runtime without affecting gamepad providers.
-     * Disposes existing keyboard/mouse providers and creates new ones from the given config.
-     */
-    configure(config: GameInputConfig): void;
-    addInputProvider(playerNumber: InputPlayerNumber, provider: InputProvider): void;
-    dispose(): void;
-    getInputs(delta: number): Inputs;
-    private buildPlayerEntries;
-    private addConfigurableProviders;
-    private createConfigurableProviders;
-    private mergeInputs;
-}
-
-/**
- * This class is an alternative to {@link Clock} with a different API design and behavior.
- * The goal is to avoid the conceptual flaws that became apparent in `Clock` over time.
- *
- * - `Timer` has an `update()` method that updates its internal state. That makes it possible to
- * call `getDelta()` and `getElapsed()` multiple times per simulation step without getting different values.
- * - The class can make use of the Page Visibility API to avoid large time delta values when the app
- * is inactive (e.g. tab switched or browser hidden).
- *
- * ```js
- * const timer = new Timer();
- * timer.connect( document ); // use Page Visibility API
- * ```
- *
- * @three_import import { Timer } from 'three/addons/misc/Timer.js';
- */
-declare class Timer {
-    protected _previousTime: number;
-    protected _currentTime: number;
-    protected _startTime: number;
-    protected _delta: number;
-    protected _elapsed: number;
-    protected _timescale: number;
-    protected _document: Document | null;
-    protected _pageVisibilityHandler: (() => void) | null;
-    /**
-     * Constructs a new timer.
-     */
-    constructor();
-    /**
-     * Connect the timer to the given document.Calling this method is not mandatory to
-     * use the timer but enables the usage of the Page Visibility API to avoid large time
-     * delta values.
-     *
-     * @param {Document} document - The document.
-     */
-    connect(document: Document): void;
-    /**
-     * Disconnects the timer from the DOM and also disables the usage of the Page Visibility API.
-     */
-    disconnect(): void;
-    /**
-     * Returns the time delta in seconds.
-     *
-     * @return {number} The time delta in second.
-     */
-    getDelta(): number;
-    /**
-     * Returns the elapsed time in seconds.
-     *
-     * @return {number} The elapsed time in second.
-     */
-    getElapsed(): number;
-    /**
-     * Returns the timescale.
-     *
-     * @return {number} The timescale.
-     */
-    getTimescale(): number;
-    /**
-     * Sets the given timescale which scale the time delta computation
-     * in `update()`.
-     *
-     * @param {number} timescale - The timescale to set.
-     * @return {Timer} A reference to this timer.
-     */
-    setTimescale(timescale: number): Timer;
-    /**
-     * Resets the time computation for the current simulation step.
-     *
-     * @return {Timer} A reference to this timer.
-     */
-    reset(): Timer;
-    /**
-     * Can be used to free all internal resources. Usually called when
-     * the timer instance isn't required anymore.
-     */
-    dispose(): void;
-    /**
-     * Updates the internal state of the timer. This method should be called
-     * once per simulation step and before you perform queries against the timer
-     * (e.g. via `getDelta()`).
-     *
-     * @param {number} timestamp - The current time in milliseconds. Can be obtained
-     * from the `requestAnimationFrame` callback argument. If not provided, the current
-     * time will be determined with `performance.now`.
-     * @return {Timer} A reference to this timer.
-     */
-    update(timestamp?: number): Timer;
-}
+import { BehaviorSystem, BehaviorEntityLink, BehaviorRuntime, BehaviorSystemFactory, BehaviorRef } from '@zylem/behaviors/core';
 
 /**
  * CameraManager orchestrates multiple cameras per stage.
@@ -524,6 +407,7 @@ interface ThirdPersonOptions {
  */
 declare class ThirdPersonPerspective implements CameraPerspective {
     readonly id = "third-person";
+    readonly projection: "perspective";
     /**
      * Slightly looser than the previous 0.15 to compose better with the
      * trailing-delay follow: the trail absorbs short, fast moves and the
@@ -589,6 +473,7 @@ interface Fixed2DOptions {
  */
 declare class Fixed2DPerspective implements CameraPerspective {
     readonly id = "fixed-2d";
+    readonly projection: "orthographic";
     readonly defaults: {
         damping: number;
     };
@@ -636,6 +521,7 @@ interface FirstPersonOptions {
  */
 declare class FirstPersonPerspective implements CameraPerspective {
     readonly id = "first-person";
+    readonly projection: "perspective";
     readonly defaults: {
         damping: number;
     };
@@ -690,11 +576,128 @@ declare class FirstPersonPerspective implements CameraPerspective {
     private deriveYawPitchFromQuaternion;
 }
 
+/**
+ * Configuration for the isometric perspective.
+ * The offset is world-locked along (1, 1, 1): yaw 45°, elevation atan(√2).
+ */
+interface IsometricOptions {
+    /** Distance from the target along the isometric axis. Default 10. */
+    distance?: number;
+    /** Orthographic frustum size. Default 10. */
+    zoom?: number;
+    /** Key in CameraContext.targets to frame. Default 'primary'. */
+    targetKey?: string;
+    /** Fallback camera position when no target exists. */
+    initialPosition?: Vec3Input;
+    /** Fallback lookAt point when no target exists. */
+    initialLookAt?: Vec3Input;
+}
+/**
+ * Orthographic isometric perspective.
+ *
+ * The view direction stays locked in world space, so the target can move
+ * without the camera orbiting around it. Player look input is not accepted.
+ */
+declare class IsometricPerspective implements CameraPerspective {
+    readonly id = "isometric";
+    readonly projection: "orthographic";
+    readonly defaults: {
+        damping: number;
+    };
+    private opts;
+    private initialPosition?;
+    private initialLookAt?;
+    constructor(options?: IsometricOptions);
+    getBasePose(ctx: CameraContext): CameraPose;
+    private staticPose;
+    private pose;
+}
+
+/**
+ * Configuration for the top-down perspective.
+ * The camera sits above the target and looks straight down at the XZ plane.
+ */
+interface TopDownOptions {
+    /** Height above the target, in world units. Default 10. */
+    height?: number;
+    /** Orthographic frustum size. Default 10. */
+    zoom?: number;
+    /** Key in CameraContext.targets to frame. Default 'primary'. */
+    targetKey?: string;
+    /** Fallback camera position when no target exists. */
+    initialPosition?: Vec3Input;
+    /** Fallback lookAt point when no target exists. */
+    initialLookAt?: Vec3Input;
+}
+/**
+ * Orthographic top-down perspective.
+ *
+ * Rotation is locked to world -Y. The camera follows the target's XZ and
+ * stays `height` above it. Player look input is not accepted.
+ */
+declare class TopDownPerspective implements CameraPerspective {
+    readonly id = "top-down";
+    readonly projection: "orthographic";
+    readonly defaults: {
+        damping: number;
+    };
+    private opts;
+    private initialPosition?;
+    private initialLookAt?;
+    constructor(options?: TopDownOptions);
+    getBasePose(ctx: CameraContext): CameraPose;
+    private staticPose;
+    private pose;
+}
+
+/**
+ * Configuration for the second-person perspective.
+ *
+ * The camera sits on another entity (`anchorKey`) and looks at the subject.
+ * Nothing here reads player look input.
+ */
+interface SecondPersonOptions {
+    /** Key of the entity whose eyes the camera uses. Default 'anchor'. */
+    anchorKey?: string;
+    /** Key of the entity to look at. Default 'primary'. */
+    subjectKey?: string;
+    /** Height above the anchor's position. Default 1.7. */
+    eyeHeight?: number;
+    /** Perspective field of view. Default 75. */
+    fov?: number;
+    /** Fallback camera position when the anchor is missing. */
+    initialPosition?: Vec3Input;
+    /** Fallback lookAt point when the anchor is missing. */
+    initialLookAt?: Vec3Input;
+}
+/**
+ * Second-person perspective.
+ *
+ * Position comes from an anchor entity. The subject, when present, is the
+ * look-at; otherwise the camera looks along the anchor's forward (−Z).
+ * The player's facing does not move this camera.
+ */
+declare class SecondPersonPerspective implements CameraPerspective {
+    readonly id = "second-person";
+    readonly projection: "perspective";
+    readonly defaults: {
+        damping: number;
+    };
+    private opts;
+    private initialPosition?;
+    private initialLookAt?;
+    constructor(options?: SecondPersonOptions);
+    getBasePose(ctx: CameraContext): CameraPose;
+    private staticPose;
+    /** Anchor forward in world space. Three.js objects look down −Z. */
+    private anchorForward;
+}
+
 /**
  * Perspective-specific options union.
  * Extend as new perspective types are added.
  */
-type PerspectiveOptions = ThirdPersonOptions | Fixed2DOptions | FirstPersonOptions;
+type PerspectiveOptions = ThirdPersonOptions | Fixed2DOptions | FirstPersonOptions | IsometricOptions | TopDownOptions | SecondPersonOptions;
 /**
  * Factory: create a CameraPerspective from a PerspectiveType string.
  * Unrecognized types default to ThirdPersonPerspective.
@@ -916,6 +919,10 @@ declare class StageDebugDelegate {
     private warnedMissingAddFactory;
     private transformTool;
     private swatchApplier;
+    private marquee;
+    private selectionHighlight;
+    private selectionBoundsPool;
+    private hoverBounds;
     private grid;
     private lastTool;
     /** Element the current gizmo drag captured, so pointerup is never missed. */
@@ -929,6 +936,13 @@ declare class StageDebugDelegate {
     /** Camera used for debug orbit / raycasts (active primary, usually `__debug__`). */
     private getDebugViewCamera;
     private resolveEntity;
+    /**
+     * Every entity a marquee may catch. `childrenMap` is the live stage;
+     * `debugMap` is consulted too so anything only registered there (the same
+     * set the single pick resolves through) is not skipped. Whether an entity
+     * has a selectable volume is the marquee's call, via its selection bounds.
+     */
+    private forEachSelectableEntity;
     /** Copy all stage children into debugMap so raycast/select tools work after enabling debug mid-session. */
     private populateDebugMap;
     private ensureCameraDebugDelegate;
@@ -961,6 +975,12 @@ declare class StageDebugDelegate {
      * available when a tool is armed with debug off.
      */
     private ensureToolVisuals;
+    /**
+     * Outline every selected entity. Re-fitted each frame so the boxes follow
+     * entities that move, and so a uuid whose entity has gone (deleted, or
+     * undone) simply drops out instead of leaving a stale box behind.
+     */
+    private updateSelectionHighlight;
     /**
      * Hide the overlays whose tool has just gone away.
      *
@@ -1664,525 +1684,4 @@ declare class Stage {
  */
 declare function createStage(...options: StageOptions): Stage;
 
-/**
- * Stage state interface - minimal to prevent circular dependencies
- */
-interface StageStateInterface {
-    backgroundColor: Color;
-    backgroundImage: string | null;
-    inputs: {
-        p1: string[];
-        p2: string[];
-    };
-    variables: Record<string, any>;
-    gravity: Vector3 | Vec3Components;
-    entities: Partial<BaseEntityInterface>[];
-    stageRef?: any;
-}
-/**
- * Minimal stage interface to break circular dependencies
- */
-interface StageInterface {
-    uuid: string;
-    children: any[];
-    state: StageStateInterface;
-}
-
-declare const AspectRatio: {
-    readonly FourByThree: number;
-    readonly SixteenByNine: number;
-    readonly NineBySixteen: number;
-    readonly TwentyOneByNine: number;
-    readonly OneByOne: number;
-};
-type AspectRatioValue = (typeof AspectRatio)[keyof typeof AspectRatio] | number;
-/**
- * AspectRatioDelegate manages sizing a canvas to fit within a container
- * while preserving a target aspect ratio. It notifies a consumer via
- * onResize when the final width/height are applied so renderers/cameras
- * can update their viewports.
- */
-declare class AspectRatioDelegate {
-    container: HTMLElement;
-    canvas: HTMLCanvasElement;
-    aspectRatio: number;
-    onResize?: (width: number, height: number) => void;
-    private handleResizeBound;
-    private resizeObserver;
-    constructor(params: {
-        container: HTMLElement;
-        canvas: HTMLCanvasElement;
-        aspectRatio: AspectRatioValue;
-        onResize?: (width: number, height: number) => void;
-    });
-    /** Attach window resize listener and apply once. */
-    attach(): void;
-    /** Detach window resize listener. */
-    detach(): void;
-    /** Compute the largest size that fits container while preserving aspect. */
-    measure(): {
-        width: number;
-        height: number;
-    };
-    /** Apply measured size to canvas and notify. */
-    apply(): void;
-}
-
-interface ViewportSize {
-    width: number;
-    height: number;
-}
-
-type RetroResolution = {
-    key: string;
-    width: number;
-    height: number;
-    notes?: string;
-};
-type RetroPreset = {
-    displayAspect: number;
-    resolutions: RetroResolution[];
-};
-/**
- * Retro, console, and device display presets.
- * displayAspect represents the intended display aspect (letterboxing target),
- * not necessarily the raw pixel aspect of internal buffers.
- */
-declare const RetroPresets: Record<string, RetroPreset>;
-type RetroPresetKey = keyof typeof RetroPresets;
-declare function getDisplayAspect(preset: RetroPresetKey): number;
-declare function getPresetResolution(preset: RetroPresetKey, key?: string): RetroResolution | undefined;
-declare function parseResolution(text: string): {
-    width: number;
-    height: number;
-} | null;
-
-/**
- * Resolution descriptor for the game's internal render buffer.
- *  - `string` : a "WxH" literal or a known retro preset (e.g. `'NES'`).
- *  - `{ width, height }` : explicit pixel dimensions.
- *  - `'native'` : skip internal-resolution scaling — render at the
- *    canvas' CSS size × DPR (i.e. 1:1 with the device viewport).
- */
-type ResolutionInput = string | {
-    width: number;
-    height: number;
-} | 'native';
-type DeviceProfile = 'auto' | 'desktop' | 'mobile';
-interface ResolveGameConfigRuntime {
-    deviceProfile?: DeviceProfile;
-    viewportSize?: ViewportSize;
-}
-type GameDeviceConfig = Partial<{
-    /** numeric value or key in AspectRatio */
-    aspectRatio: AspectRatioValue | keyof typeof AspectRatio;
-    /** console/display preset to derive aspect ratio */
-    preset: RetroPresetKey;
-    /** lock internal render buffer for this device profile */
-    resolution: ResolutionInput;
-    /**
-     * Auto-merge built-in virtual touch controls into the resolved input
-     * config. The provider auto-enables on mobile devices via
-     * `enabled: 'auto'`, so on desktop runtimes the UI stays dormant.
-     *  - `true`         : default joystick + A/B layout, default theme.
-     *  - options object : forwarded to `defaultTouchControls('p1', ...)`.
-     *  - `false` / unset: no auto-injection (caller wires controls manually).
-     */
-    controls: boolean | DefaultTouchControlsOptions;
-}>;
-type GameConfigLike = Partial<{
-    id: string;
-    globals: Record<string, any>;
-    stages: StageInterface[];
-    debug: boolean;
-    time: number;
-    input: GameInputConfig;
-    /** numeric value or key in AspectRatio */
-    aspectRatio: AspectRatioValue | keyof typeof AspectRatio;
-    /** console/display preset to derive aspect ratio */
-    preset: RetroPresetKey;
-    /** lock internal render buffer to this desktop/default resolution */
-    resolution: ResolutionInput;
-    /** mobile-specific aspect/preset/resolution overrides */
-    mobile: GameDeviceConfig;
-    fullscreen: boolean;
-    /** CSS background value for document body */
-    bodyBackground: string;
-    /** existing container by reference */
-    container: HTMLElement;
-    /** create/find container by id */
-    containerId: string;
-    /** optional canvas if caller wants to manage it */
-    canvas: HTMLCanvasElement;
-}>;
-declare class GameConfig {
-    id: string;
-    globals: Record<string, any>;
-    stages: StageInterface[];
-    debug: boolean;
-    time: number;
-    input: GameInputConfig | undefined;
-    aspectRatio: number;
-    internalResolution: {
-        width: number;
-        height: number;
-    } | undefined;
-    fullscreen: boolean;
-    bodyBackground: string | undefined;
-    container: HTMLElement;
-    containerId?: string | undefined;
-    canvas?: HTMLCanvasElement | undefined;
-    constructor(id: string, globals: Record<string, any>, stages: StageInterface[], debug: boolean, time: number, input: GameInputConfig | undefined, aspectRatio: number, internalResolution: {
-        width: number;
-        height: number;
-    } | undefined, fullscreen: boolean, bodyBackground: string | undefined, container: HTMLElement, containerId?: string | undefined, canvas?: HTMLCanvasElement | undefined);
-}
-/**
- * Factory for authoring configuration objects in user code.
- * Returns a plain object that can be passed to `game(...)`.
- */
-declare function gameConfig(config: GameConfigLike): GameConfigLike;
-
-interface GameCanvasOptions {
-    id: string;
-    container?: HTMLElement;
-    containerId?: string;
-    canvas?: HTMLCanvasElement;
-    bodyBackground?: string;
-    fullscreen?: boolean;
-    aspectRatio: AspectRatioValue | number;
-}
-/**
- * GameCanvas is a DOM delegate that owns:
- * - container lookup/creation and styling (including fullscreen centering)
- * - body background application
- * - canvas mounting into container
- * - aspect ratio sizing via AspectRatioDelegate
- */
-declare class GameCanvas {
-    id: string;
-    container: HTMLElement;
-    canvas: HTMLCanvasElement;
-    bodyBackground?: string;
-    fullscreen: boolean;
-    aspectRatio: number;
-    private ratioDelegate;
-    private overlayContainer;
-    constructor(options: GameCanvasOptions);
-    applyBodyBackground(): void;
-    mountCanvas(): void;
-    mountRenderer(rendererDom: HTMLCanvasElement, onResize: (width: number, height: number) => void): void;
-    getOverlayContainer(): HTMLElement;
-    centerIfFullscreen(): void;
-    attachAspectRatio(onResize: (width: number, height: number) => void): void;
-    setAspectRatio(aspectRatio: number): void;
-    reapplyLayout(): void;
-    destroy(): void;
-    private mountChildren;
-    private ensureOverlayContainer;
-    private ensureContainer;
-}
-
-/**
- * Game-level loading event that includes stage context.
- */
-interface GameLoadingEvent {
-    type: 'start' | 'progress' | 'complete';
-    stageName?: string;
-    stageIndex?: number;
-    message: string;
-    progress: number;
-    current?: number;
-    total?: number;
-}
-
-type ZylemGameOptions<TGlobals extends BaseGlobals> = ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals> & Partial<GameConfig>;
-declare class ZylemGame<TGlobals extends BaseGlobals> {
-    id: string;
-    initialGlobals: TGlobals;
-    customSetup: ((params: SetupContext<ZylemGame<TGlobals>, TGlobals>) => void) | null;
-    customUpdate: ((params: UpdateContext<ZylemGame<TGlobals>, TGlobals>) => void) | null;
-    customDestroy: ((params: DestroyContext<ZylemGame<TGlobals>, TGlobals>) => void) | null;
-    stages: Stage[];
-    stageMap: Map<string, Stage>;
-    currentStageId: string;
-    previousTimeStamp: number;
-    totalTime: number;
-    timer: Timer;
-    inputManager: InputManager;
-    wrapperRef: Game<TGlobals>;
-    globalInputConfig: GameInputConfig | undefined;
-    defaultCamera: ZylemCamera | null;
-    /** Shared renderer manager for all stages */
-    rendererManager: RendererManager | null;
-    container: HTMLElement | null;
-    canvas: HTMLCanvasElement | null;
-    aspectRatioDelegate: AspectRatioDelegate | null;
-    resolvedConfig: GameConfig | null;
-    gameCanvas: GameCanvas | null;
-    private animationFrameId;
-    private isDisposed;
-    /**
-     * True while a `loadStage` is in progress. Used to reject re-entrant stage
-     * navigation (e.g. a button press during a transition), which would race
-     * two loads on `stageMap`/the render loop and, because `currentStageId` is
-     * transiently `''`, misresolve the target stage.
-     */
-    private loadInFlight;
-    /**
-     * True once `start()` has been invoked for this game's initial stage.
-     * Used by `loadStage` to decide whether to drive the stage's `_setup`
-     * lifecycle directly (for subsequent stages loaded via `nextStage`
-     * / `loadStage`) or defer to `start()` (for the very first stage).
-     */
-    private hasStarted;
-    private debugDelegate;
-    private loadingDelegate;
-    private rendererObserver;
-    private eventBusUnsubscribes;
-    private thumbnailUnsubscribes;
-    /** Serialized last-published game config, for dirty-checking resize churn. */
-    private lastPublishedGameConfig;
-    /** Editor ↔ game bridge adapter (RAF-coalesced publishes, command intake). */
-    private gameBridge;
-    /** Stops republishing the entity catalog on registry changes. */
-    private catalogUnsubscribe;
-    private readonly gameUpdateParams;
-    private readonly stageSetupParams;
-    private readonly stageUpdateParams;
-    private readonly frameCallback;
-    private readonly sourceOptions;
-    private displayRuntime;
-    static FRAME_LIMIT: number;
-    static FRAME_DURATION: number;
-    static MAX_DELTA_SECONDS: number;
-    constructor(options: ZylemGameOptions<TGlobals>, wrapperRef: Game<TGlobals>, displayRuntime?: ResolveGameConfigRuntime);
-    /**
-     * Raycast at normalized device coordinates (editor `entity:pick`) and
-     * describe the hit the same way the entity list does, so a consumer can
-     * show name, type, and pose for whatever is under the pointer.
-     */
-    private pickEntityAtNdc;
-    /** Publish the placeable entity types the editor's Add palette lists. */
-    private publishEntityCatalog;
-    /** Spawn a catalog type programmatically (editor `entity:create`). */
-    private createCatalogEntity;
-    setDisplayRuntime(runtime: ResolveGameConfigRuntime): void;
-    loadGameCanvas(config: GameConfig): void;
-    loadDebugOptions(options: ZylemGameOptions<TGlobals>): void;
-    /** Whether a stage load is currently in progress. */
-    isLoading(): boolean;
-    loadStage(stage: Stage, stageIndex?: number, transition?: StageTransitionConfig): Promise<void>;
-    private performLoadStage;
-    /**
-     * Merges game-level global input config with the stage's per-stage overrides
-     * and reconfigures the InputManager.
-     */
-    applyInputConfig(stage: Stage): void;
-    /**
-     * Update the game-level global input config and re-apply to the current stage.
-     */
-    setGlobalInputConfig(config: GameInputConfig): void;
-    unloadCurrentStage(): void;
-    setGlobals(options: ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals>): void;
-    params(): UpdateContext<ZylemGame<TGlobals>, TGlobals>;
-    start(): void;
-    /**
-     * Execute a single frame update.
-     * This method can be called directly for testing or from the game loop.
-     * @param deltaTime Optional delta time in seconds. If not provided, uses timer delta.
-     */
-    step(deltaTime?: number): void;
-    loop(timestamp: number): void;
-    dispose(): void;
-    outOfLoop(): void;
-    getStage(id: string): Stage | undefined;
-    currentStage(): Stage | undefined;
-    /**
-     * Subscribe to loading events from the game.
-     * Events include stage context (stageName, stageIndex).
-     * @param callback Invoked for each loading event
-     * @returns Unsubscribe function
-     */
-    onLoading(callback: (event: GameLoadingEvent) => void): () => void;
-    /**
-     * Build the stage config payload for the current stage.
-     */
-    private buildStageConfigPayload;
-    /**
-     * Build a bridge entity summary for one entity, or null for entities on
-     * the managed render path (instanced packs/bundles), which can number in
-     * the thousands and are not useful in the editor panel.
-     */
-    private buildEntitySummary;
-    /**
-     * Build the full entities payload for the current stage.
-     */
-    private buildEntitiesPayload;
-    /**
-     * Generate entity thumbnails as entities become available, streaming
-     * upserts/thumbnails/removals to the editor through the bridge
-     * (RAF-coalesced, merged by uuid).
-     *
-     * All of this work exists only to feed the editor, and thumbnails in
-     * particular cost an offscreen render plus a pixel readback on the shared
-     * renderer. Each publisher therefore checks the bridge for a live listener
-     * first, and a late-connecting editor is backfilled from
-     * {@link wireEditorBackfill}.
-     */
-    private wireEntityThumbnails;
-    /**
-     * Republish the current stage when an editor subscribes after the game
-     * started. Without this, entities added while nothing was listening would
-     * never appear, since the per-entity publishers were skipped.
-     */
-    private wireEditorBackfill;
-    private clearEntityThumbnailWiring;
-    private buildGameConfigPayload;
-    /** Publish the resolved display config over the bridge. */
-    /**
-     * Publish the display config, skipping unchanged payloads. The
-     * `ResizeObserver` on `<zylem-game>` funnels into `setDisplayRuntime`, which
-     * fires on every layout tick even when nothing about the config moved.
-     */
-    private publishGameConfig;
-    /** Publish a full stage snapshot (config + entity list) over the bridge. */
-    private publishStageSnapshot;
-    /**
-     * Subscribe to the game event bus for stage loading and state events,
-     * mirroring global-variable updates to the editor over the bridge.
-     */
-    private subscribeToEventBus;
-}
-
-type GameOptions<TGlobals extends BaseGlobals> = Array<ZylemGameConfig<Stage, any, TGlobals> | GameConfigLike | Stage | GameEntityLifeCycle | BaseNode>;
-
-declare class Game<TGlobals extends BaseGlobals> implements IGame<TGlobals> {
-    private wrappedGame;
-    options: GameOptions<TGlobals>;
-    private setupCallbacks;
-    private updateCallbacks;
-    private destroyCallbacks;
-    private pendingLoadingCallbacks;
-    private globalChangeCallbacks;
-    private globalChangesCallbacks;
-    private activeGlobalSubscriptions;
-    private eventDelegate;
-    /** Pending global input config set before the game starts. */
-    private pendingInputConfig;
-    private displayRuntime;
-    refErrorMessage: string;
-    constructor(options: GameOptions<TGlobals>);
-    onSetup(...callbacks: Array<SetupFunction<ZylemGame<TGlobals>, TGlobals>>): this;
-    onUpdate(...callbacks: Array<UpdateFunction<ZylemGame<TGlobals>, TGlobals>>): this;
-    onDestroy(...callbacks: Array<DestroyFunction<ZylemGame<TGlobals>, TGlobals>>): this;
-    /**
-     * Set composable input configuration as global defaults for the entire game.
-     * Multiple configs are deep-merged (later configs win on key conflicts).
-     * Per-stage overrides (via stage.setInputConfiguration) are merged on top.
-     * Can be called before or after start().
-     * @example game.setInputConfiguration(useArrowsForAxes('p1'), useWASDForDirections('p2'));
-     */
-    setInputConfiguration(...configs: GameInputConfig[]): this;
-    start(): Promise<this>;
-    setDisplayRuntime(runtime: Partial<ResolveGameConfigRuntime>): this;
-    setDeviceProfile(profile: DeviceProfile): this;
-    setViewportSize(width: number, height: number): this;
-    private load;
-    private setOverrides;
-    /**
-     * Subscribe to changes on a global value. Subscriptions are registered
-     * when the game starts and cleaned up when disposed.
-     * The callback receives the value and the current stage.
-     * @example game.onGlobalChange('score', (val, stage) => console.log(val));
-     */
-    onGlobalChange<T = unknown>(path: string, callback: (value: T, stage: Stage | null) => void): this;
-    /**
-     * Subscribe to changes on multiple global paths. Subscriptions are registered
-     * when the game starts and cleaned up when disposed.
-     * The callback receives the values and the current stage.
-     * @example game.onGlobalChanges(['score', 'lives'], ([score, lives], stage) => console.log(score, lives));
-     */
-    onGlobalChanges<T extends unknown[] = unknown[]>(paths: string[], callback: (values: T, stage: Stage | null) => void): this;
-    /**
-     * Register all stored global change callbacks.
-     * Called internally during start().
-     */
-    private registerGlobalSubscriptions;
-    /**
-     * Get the current stage wrapper.
-     */
-    getCurrentStage(): Stage | null;
-    /**
-     * Experimental escape hatches. APIs here are unstable and may change or be
-     * removed without a major version bump.
-     */
-    readonly experimental: {
-        /**
-         * The `@zylem/behaviors` {@link Simulation} backing the current stage's
-         * physics world, or `null` before a stage is loaded. Intended for debug
-         * tooling and the editor; games should not need it.
-         */
-        getRuntime: () => Simulation | null;
-    };
-    pause(): Promise<void>;
-    resume(): Promise<void>;
-    /**
-     * Execute a single frame update.
-     * Useful for testing or manual frame stepping.
-     * @param deltaTime Optional delta time in seconds (defaults to 1/60)
-     */
-    step(deltaTime?: number): void;
-    /**
-     * Reload the first stage. Pass `{ transition }` to blend from the current
-     * stage instead of cutting.
-     * @example game.reset({ transition: { duration: 1 } });
-     */
-    reset(options?: StageNavigationOptions): Promise<void>;
-    /**
-     * Go to the previous stage in the stage array. Pass `{ transition }` to
-     * blend from the current stage instead of cutting.
-     */
-    previousStage(options?: StageNavigationOptions): void;
-    loadStageFromId(stageId: string): Promise<void>;
-    /**
-     * Go to the next stage. Pass `{ transition }` to blend from the current
-     * stage instead of cutting.
-     * @example
-     * game.nextStage({
-     *   transition: { duration: 1.2, shader: createStageTransition({ pattern: 'noise' }) },
-     * });
-     */
-    nextStage(options?: StageNavigationOptions): void;
-    goToStage(): Promise<void>;
-    end(): Promise<void>;
-    dispose(): void;
-    /**
-     * Dispatch an event from the game.
-     * Events are emitted both locally and to the global event bus.
-     */
-    dispatch<K extends keyof GameEvents>(event: K, payload: GameEvents[K]): void;
-    /**
-     * Listen for events on this game instance.
-     * @returns Unsubscribe function
-     */
-    listen<K extends keyof GameEvents>(event: K, handler: (payload: GameEvents[K]) => void): () => void;
-    /**
-     * Subscribe to loading events from the game.
-     * Events include stage context (stageName, stageIndex).
-     * @param callback Invoked for each loading event
-     * @returns Unsubscribe function
-     */
-    onLoading(callback: (event: GameLoadingEvent) => void): () => void;
-}
-/**
- * create a new game
- * @param options GameOptions - Array of IGameOptions, Stage, GameEntity, or BaseNode objects
- * @param options.id Game name string (when using IGameOptions)
- * @param options.globals Game globals object (when using IGameOptions)
- * @param options.stages Array of stage objects (when using IGameOptions)
- * @returns Game
- */
-declare function createGame<TGlobals extends BaseGlobals>(...options: GameOptions<TGlobals>): Game<TGlobals>;
-
-export { AspectRatio as A, Stage as B, CameraWrapper as C, type DeviceProfile as D, type StageStateInterface as E, Fixed2DPerspective as F, Game as G, type PerspectiveOptions as P, type ResolutionInput as R, type StageConfigLike as S, ThirdPersonPerspective as T, type GameLoadingEvent as a, type GameConfigLike as b, createGame as c, type GameDeviceConfig as d, type ResolveGameConfigRuntime as e, createStage as f, gameConfig as g, type StageOptions as h, createCamera as i, type CameraOptions as j, CameraManager as k, FirstPersonPerspective as l, createPerspective as m, type ThirdPersonOptions as n, type Fixed2DOptions as o, type FirstPersonOptions as p, type AspectRatioValue as q, getDisplayAspect as r, stageConfig as s, getPresetResolution as t, parseResolution as u, type RetroPreset as v, type RetroPresetKey as w, type RetroResolution as x, RenderBundleManager as y, RenderStrategyManager as z };
+export { type BaseEntityInterface as B, CameraWrapper as C, Fixed2DPerspective as F, IsometricPerspective as I, type PerspectiveOptions as P, RenderBundleManager as R, type StageConfigLike as S, ThirdPersonPerspective as T, ZylemStage as Z, type StageOptions as a, createCamera as b, createStage as c, type CameraOptions as d, CameraManager as e, FirstPersonPerspective as f, SecondPersonPerspective as g, TopDownPerspective as h, createPerspective as i, type ThirdPersonOptions as j, type Fixed2DOptions as k, type FirstPersonOptions as l, type SecondPersonOptions as m, type IsometricOptions as n, type TopDownOptions as o, RenderStrategyManager as p, Stage as q, stageConfig as s };