@zylem/game-lib 0.8.8 → 0.9.0

package/dist/{game-BPOr7zTB.d.ts → stage-BuGkjZnr.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-CkkFMSrL.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-XZNGBeca.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 { 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-Baf5vH8Z.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 { SceneOperationPayload } from '@zylem/bridge';
-import { BehaviorSystem, BehaviorEntityLink, BehaviorRuntime, BehaviorSystemFactory, 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 { 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 } from '@zylem/behaviors/core';
 
 /**
  * CameraManager orchestrates multiple cameras per stage.
@@ -846,6 +729,28 @@ declare class CameraWrapper {
  */
 declare function createCamera(options: CameraOptions): CameraWrapper;
 
+/**
+ * Applies swatches (configured shaders / behaviors) to live entities and
+ * inverts those applications for undo.
+ *
+ * One `entity:apply-swatch` message is a batch: every swatch is applied to
+ * every uuid, in order, under a single operation id. Each pair reports its own
+ * result so a multi-select apply can partially succeed (a light in the
+ * selection has no material) while the rest still land.
+ *
+ * Undo follows the stage's "editor holds the history, game holds the
+ * instances" rule. The original material and any displaced behavior refs are
+ * kept here per operation, so undo puts back the exact objects rather than a
+ * reconstruction — the pre-swatch material (texture, tint, standard shader) is
+ * usually not describable as a swatch at all.
+ */
+
+interface SwatchApplyOutcome {
+    results: SwatchApplyResult[];
+    /** One entry per successful pair, ready for a `scene:operation`. */
+    entries: SceneOperationEntry[];
+}
+
 /**
  * Owns the stage's in-world debug/editor interaction layer.
  *
@@ -893,6 +798,11 @@ declare class StageDebugDelegate {
     private lastDebugEnabled;
     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. */
@@ -906,6 +816,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;
@@ -938,6 +855,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.
      *
@@ -951,13 +874,27 @@ declare class StageDebugDelegate {
     update(): void;
     /**
      * Raycast at NDC coordinates (from a host that cannot send DOM pointer
-     * events, e.g. an overlay sitting on a preview iframe). Updates hover so
-     * the next `update()` paints the highlight.
+     * events, e.g. an overlay sitting on a preview iframe, or the bridge's
+     * `entity:pick`).
+     *
+     * Hover follows the pick only while pick mode is armed (a drag in flight),
+     * so a one-shot pick from an inspector does not disturb the user's hover.
+     * While armed, the next `update()` paints the highlight.
      */
-    pickAtNdc(ndcX: number, ndcY: number): {
+    pickAtNdc(ndcX: number, ndcY: number, options?: {
+        updateHover?: boolean;
+    }): {
         uuid: string;
         name: string;
     } | null;
+    /**
+     * Apply swatches to live entities (`entity:apply-swatch`). Every uuid ×
+     * swatch pair is attempted and reported; successful pairs are recorded so
+     * the operation can be undone exactly via {@link applySceneOperation}.
+     */
+    applySwatches(payload: EntityApplySwatchPayload & {
+        opId: string;
+    }): SwatchApplyOutcome;
     /** Collider wireframes, straight from the wasm simulation. */
     private updateColliderWireframes;
     /**
@@ -1355,11 +1292,35 @@ declare class StageEntityDelegate {
      */
     destroyAll(): void;
     private registerBehaviorLinks;
+    /**
+     * Index one ref, lazily create its system, and attach. Shared by spawn-time
+     * registration and late per-ref attaches.
+     */
+    private linkBehaviorRef;
+    private unlinkBehaviorLink;
     /**
      * Re-index an entity's behavior refs after a late `entity.use(...)`.
      * Spawn-time registration only sees refs that existed at attach.
+     *
+     * Detaches and re-attaches every behavior on the entity, which resets their
+     * per-link state. Prefer {@link attachBehaviorLink} /
+     * {@link detachBehaviorLink} when only one ref changed.
      */
     syncBehaviorLinks(entity: any): void;
+    /**
+     * Attach a single ref that was added to a live entity (`entity.use(...)`
+     * after spawn) without disturbing the entity's other behaviors.
+     *
+     * @returns `false` when the stage is not loaded or the ref is already linked.
+     */
+    attachBehaviorLink(entity: any, ref: BehaviorRef): boolean;
+    /**
+     * Detach a single ref's system link from a live entity, leaving its other
+     * behaviors attached.
+     *
+     * @returns `false` when no link for that ref exists.
+     */
+    detachBehaviorLink(entity: any, ref: BehaviorRef): boolean;
     private unregisterBehaviorLinks;
 }
 
@@ -1603,519 +1564,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);
-    /** 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, 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, createPerspective as g, type ThirdPersonOptions as h, type Fixed2DOptions as i, type FirstPersonOptions as j, RenderStrategyManager as k, Stage as l, stageConfig as s };