@lute-lang/player-web 0.0.0-stage → 0.40.0

package/dist/input/gamepad.d.ts

@@ -0,0 +1,22 @@
+import type { PlayerAction } from "@lute-lang/player";
+/** Logical gamepad buttons used by the visual-novel input layer. */
+export interface GamepadState {
+    readonly a: boolean;
+    readonly b: boolean;
+    readonly y: boolean;
+    readonly rb: boolean;
+    readonly lb: boolean;
+    readonly start: boolean;
+}
+/** Read the standard mapping indices into the portable gamepad state. */
+export declare function readGamepadState(gamepad: Gamepad): GamepadState;
+/** Poll the first connected gamepad and return edge-triggered actions. */
+export declare function pollGamepad(detector: GamepadEdgeDetector, gamepads: readonly (Gamepad | null)[]): ReadonlyArray<PlayerAction>;
+/** Emits actions only on button press edges, while allowing RB hold state. */
+export declare class GamepadEdgeDetector {
+    private previous;
+    /** Poll a state and return newly pressed actions. */
+    poll(current: GamepadState): ReadonlyArray<PlayerAction>;
+    /** Reset edge state after a device disconnect. */
+    reset(): void;
+}

package/dist/input/index.d.ts

@@ -0,0 +1,7 @@
+export { defaultInputMap, resolveKeyboardAction, LongPressRecognizer, SwipeRecognizer, layer, type InputMap, type KeyBinding } from "./map.js";
+export { GamepadEdgeDetector, pollGamepad, readGamepadState, type GamepadState } from "./gamepad.js";
+import { layer } from "./map.js";
+/** Namespaced input layer API. */
+export declare const Input: {
+    layer: typeof layer;
+};

package/dist/input/map.d.ts

@@ -0,0 +1,42 @@
+import { Stream } from "effect";
+import type { PlayerAction } from "@lute-lang/player";
+/** A keyboard binding with optional modifier requirements. */
+export interface KeyBinding {
+    readonly action: PlayerAction;
+    readonly ctrl?: boolean;
+    readonly shift?: boolean;
+    readonly alt?: boolean;
+}
+/** Device mapping table used by Input.layer. */
+export interface InputMap {
+    readonly keyboard: Readonly<Record<string, PlayerAction | KeyBinding>>;
+    readonly pointer: Readonly<Record<string, PlayerAction>>;
+}
+/** Default keyboard, pointer and gesture table for visual-novel controls. */
+export declare const defaultInputMap: InputMap;
+/** Resolve a keyboard event through a mapping table. */
+export declare function resolveKeyboardAction(event: KeyboardEvent, map?: InputMap): PlayerAction | undefined;
+/** Recognizes a pointer hold without allocating per move event. */
+export declare class LongPressRecognizer {
+    private started;
+    private emitted;
+    /** Start a pointer gesture at timestamp milliseconds. */
+    start(at: number): void;
+    /** End the gesture and return true when it was a long press. */
+    end(at: number, threshold?: number): boolean;
+    /** Check a held gesture and emit at most once. */
+    check(at: number, threshold?: number): boolean;
+    /** Cancel an active gesture. */
+    cancel(): void;
+}
+/** Recognizes a vertical swipe from pointer coordinates. */
+export declare class SwipeRecognizer {
+    private startY;
+    private active;
+    /** Begin tracking a pointer. */
+    start(y: number): void;
+    /** End tracking and return swipe direction when threshold is crossed. */
+    end(y: number, threshold?: number): "up" | "down" | undefined;
+}
+/** Attach DOM input listeners and expose their actions as a scoped stream. */
+export declare function layer(element: HTMLElement, map?: InputMap, uiConsumes?: () => boolean, uiPointer?: (event: PointerEvent) => boolean): Stream.Stream<PlayerAction>;

package/dist/mount.d.ts

@@ -0,0 +1,31 @@
+import { Effect, Scope } from "effect";
+import { type Bindings, type LutePlayerHandle, type PlayerAction, type PlayerHost, type PlayerView } from "@lute-lang/player";
+/** A bindings source accepted by the web facade. */
+export type BindingsSource = Bindings | string | {
+    readonly url: string;
+};
+/** Options for mounting a browser player. */
+export interface MountOptions {
+    readonly bindings: BindingsSource;
+    readonly bundleUrl: string;
+    readonly wasmUrl: string;
+    readonly assetsUrl?: string;
+    readonly storageKey?: string;
+    readonly host?: PlayerHost;
+}
+/** A scoped web player handle. `view` is the live Effect subscription ref. */
+export interface WebPlayerHandle extends LutePlayerHandle {
+}
+/** Mount a web player in the current Effect scope. */
+export declare const mount: (element: HTMLElement, options: MountOptions) => Effect.Effect<WebPlayerHandle, unknown, Scope.Scope>;
+/** Promise facade for non-Effect hosts; this is the only Promise API. */
+export declare const mountPlayer: (element: HTMLElement, options: MountOptions) => Promise<{
+    readonly unmount: () => Promise<void>;
+    readonly view: () => Promise<PlayerView>;
+    readonly act: (action: PlayerAction) => Promise<void>;
+}>;
+/** Namespace-style web facade. */
+export declare const LuteWeb: {
+    mount: typeof mount;
+    mountPlayer: typeof mountPlayer;
+};

package/dist/presenter/index.d.ts

@@ -0,0 +1 @@
+export { PixiPresenter, PixiPresenterTag, presenterLayer, type PresenterOptions } from "./pixiPresenter.js";

package/dist/presenter/pixiPresenter.d.ts

@@ -0,0 +1,66 @@
+import { Context, Layer, Stream } from "effect";
+import type { Bindings, PlayerAction, Presenter } from "@lute-lang/player";
+import type { PixiAppShape } from "../engine/types.js";
+import type { WorldShape } from "../engine/types.js";
+import { PixiApp } from "../engine/app.js";
+import { World } from "../engine/world.js";
+import { type UiShape } from "../ui/ui.js";
+import { type TextureAssets } from "../scene/shared.js";
+import type { Theme } from "../engine/types.js";
+export interface PresenterOptions {
+    readonly pixi: PixiAppShape;
+    readonly world: WorldShape;
+    readonly ui: UiShape;
+    readonly assets: TextureAssets;
+    readonly bindings: Bindings;
+    readonly theme: Theme;
+    readonly titleBackground?: string;
+    readonly logger?: (message: string, error?: unknown) => void;
+}
+/** Pixi implementation of the renderer-free player Presenter port. */
+/** Presenter service key. */
+export declare const PixiPresenterTag: Context.Service<PixiPresenter, PixiPresenter>;
+/** Pixi implementation of the renderer-free player Presenter port. */
+export declare class PixiPresenter implements Presenter {
+    static readonly layer: (bindings: Bindings, theme: Theme, assets: TextureAssets) => Layer.Layer<PixiPresenter, never, PixiApp | UiShape | World>;
+    readonly stage: Presenter["stage"];
+    readonly showLine: Presenter["showLine"];
+    readonly revealLine: Presenter["revealLine"];
+    readonly clearLine: Presenter["clearLine"];
+    readonly restore: Presenter["restore"];
+    readonly showChoice: Presenter["showChoice"];
+    readonly hideChoice: Presenter["hideChoice"];
+    readonly showScreen: Presenter["showScreen"];
+    readonly hideScreen: Presenter["hideScreen"];
+    readonly setUiHidden: Presenter["setUiHidden"];
+    readonly applySettings: Presenter["applySettings"];
+    readonly capture: Presenter["capture"];
+    readonly actions: Stream.Stream<PlayerAction>;
+    private readonly pixi;
+    private readonly world;
+    private readonly ui;
+    private readonly assets;
+    private readonly bindings;
+    private readonly theme;
+    private readonly logger;
+    private readonly actors;
+    private readonly background;
+    private readonly cg;
+    private readonly video;
+    private readonly camera;
+    private readonly vfx;
+    private readonly dialogue;
+    private readonly choice;
+    private readonly choiceActions;
+    private readonly missing;
+    private uiHidden;
+    constructor(options: PresenterOptions);
+    private defaultSettings;
+    private readonly stageCue;
+    private readonly upsertActor;
+    private readonly exitActor;
+    private readonly restoreStage;
+    private readonly showChoiceInternal;
+    private readonly logMissing;
+}
+export declare const presenterLayer: (bindings: Bindings, theme: Theme, assets: TextureAssets) => Layer.Layer<PixiPresenter, never, PixiApp | UiShape | World>;

package/dist/scene/actor.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+import { Container } from "pixi.js";
+import type { Bindings, EffectSpec, Stage } from "@lute-lang/player";
+import type { WorldShape, Theme } from "../engine/types.js";
+import { spriteTexture, type TextureAssets } from "./shared.js";
+/** Resolve the character sprite using costume then emotion fallbacks. */
+export declare const resolveActorTexture: typeof spriteTexture;
+export declare class ActorSprite {
+    readonly target: Container;
+    readonly actor: Stage["actors"][number];
+    private readonly world;
+    private readonly bindings;
+    private readonly assets;
+    private readonly design;
+    private readonly theme;
+    private readonly logger;
+    private readonly logged;
+    constructor(parent: Container, actor: Stage["actors"][number], world: WorldShape, bindings: Bindings, assets: TextureAssets, design: {
+        readonly width: number;
+        readonly height: number;
+    }, theme: Theme, logger?: (message: string) => void);
+    updateTexture(actor: Stage["actors"][number]): void;
+    readonly play: (action: EffectSpec | undefined, instant?: boolean, durationOverride?: number) => Effect.Effect<void>;
+    destroy(): void;
+}
+export declare const removeActor: (actor: ActorSprite, action: EffectSpec | undefined, instant?: boolean) => Effect.Effect<void>;

package/dist/scene/background.d.ts

@@ -0,0 +1,24 @@
+import { Effect } from "effect";
+import { Container } from "pixi.js";
+import type { EffectSpec, Stage } from "@lute-lang/player";
+import type { Bindings } from "@lute-lang/player";
+import type { WorldShape, Theme } from "../engine/types.js";
+import { type TextureAssets } from "./shared.js";
+export declare const backgroundFile: (bindings: Bindings, bg: Stage["bg"]) => string | undefined;
+/** Full-design-resolution background with optional texture crossfade. */
+export declare class Background {
+    readonly target: Container;
+    private readonly world;
+    private readonly bindings;
+    private readonly assets;
+    private readonly theme;
+    private readonly design;
+    private readonly logger;
+    private readonly logged;
+    private current;
+    constructor(parent: Container, world: WorldShape, bindings: Bindings, assets: TextureAssets, design: {
+        readonly width: number;
+        readonly height: number;
+    }, theme: Theme, logger?: (message: string) => void);
+    readonly set: (bg: Stage["bg"], transition: EffectSpec | undefined, instant?: boolean, durationOverride?: number) => Effect.Effect<void>;
+}

package/dist/scene/camera.d.ts

@@ -0,0 +1,37 @@
+import { Effect } from "effect";
+import type { Bindings, EffectSpec } from "@lute-lang/player";
+import type { Container } from "pixi.js";
+import type { WorldShape } from "../engine/types.js";
+export interface CameraPlacement {
+    readonly scale: number;
+    readonly x: number;
+    readonly y: number;
+}
+/** Compute camera transform around the design-space centre. */
+export declare const framingPlacement: (framing: {
+    readonly zoom: number;
+    readonly x?: number | null;
+    readonly y?: number | null;
+} | undefined, design: {
+    readonly width: number;
+    readonly height: number;
+}, focus: {
+    readonly x: number;
+    readonly y: number;
+} | undefined) => CameraPlacement;
+export declare class Camera {
+    readonly target: Container;
+    private readonly world;
+    private readonly bindings;
+    private readonly design;
+    private readonly actors;
+    private readonly logger;
+    constructor(target: Container, actors: Container, world: WorldShape, bindings: Bindings, design: {
+        readonly width: number;
+        readonly height: number;
+    }, logger?: (message: string) => void);
+    readonly clear: () => void;
+    readonly apply: (framingName: string | undefined, focusName: string | undefined) => void;
+    readonly move: (move: EffectSpec | undefined, duration: number | undefined, instant?: boolean) => Effect.Effect<void>;
+    private findActor;
+}

package/dist/scene/cgLayer.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { Container } from "pixi.js";
+import type { Bindings, EffectSpec, Stage } from "@lute-lang/player";
+import type { WorldShape, Theme } from "../engine/types.js";
+import { cgPlacement, type TextureAssets } from "./shared.js";
+export { cgPlacement };
+export declare class CgLayer {
+    readonly target: Container;
+    private readonly world;
+    private readonly bindings;
+    private readonly assets;
+    private readonly design;
+    private readonly theme;
+    private readonly logger;
+    private current;
+    constructor(parent: Container, world: WorldShape, bindings: Bindings, assets: TextureAssets, design: {
+        readonly width: number;
+        readonly height: number;
+    }, theme: Theme, logger?: (message: string) => void);
+    readonly show: (cg: Stage["cg"], transition: EffectSpec | undefined, instant?: boolean, durationOverride?: number) => Effect.Effect<void>;
+}

package/dist/scene/index.d.ts

@@ -0,0 +1,7 @@
+export { ActorSprite, resolveActorTexture } from "./actor.js";
+export { Background, backgroundFile } from "./background.js";
+export { Camera, framingPlacement } from "./camera.js";
+export { CgLayer, cgPlacement } from "./cgLayer.js";
+export { VideoLayer, Sequence } from "./videoLayer.js";
+export { Vfx } from "./vfx.js";
+export * from "./shared.js";

package/dist/scene/shared.d.ts

@@ -0,0 +1,36 @@
+import { Container, Texture } from "pixi.js";
+import type { Bindings, Stage } from "@lute-lang/player";
+import type { Theme } from "../engine/types.js";
+export interface TextureAssets {
+    readonly texture: (file: string) => Texture | undefined;
+    readonly video: (file: string) => Texture | undefined;
+}
+export declare const assetFile: (bindings: Bindings, assetId: string | undefined) => string | undefined;
+export declare const finite: (value: number | null | undefined, fallback: number) => number;
+export declare const textureFor: (assets: TextureAssets, file: string | undefined) => Texture | undefined;
+export declare const placeholder: (parent: Container, name: string, theme: Theme, width: number, height: number) => Container;
+export declare const spriteTexture: (bindings: Bindings, actor: Stage["actors"][number]) => string | undefined;
+export interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+export interface Placement {
+    readonly x: number;
+    readonly y: number;
+    readonly scale: number;
+}
+export declare const anchorPlacement: (anchor: {
+    readonly x: number;
+    readonly y?: number | null;
+    readonly scale?: number | null;
+} | undefined, design: Size, texture: Size) => Placement;
+export interface CgPlacement {
+    readonly x: number;
+    readonly y: number;
+    readonly scale: number;
+    readonly width: number;
+    readonly height: number;
+}
+export declare const cgPlacement: (fit: "cover" | "contain", design: Size, texture: Size, scale: number | undefined, x: number | null | undefined, y: number | null | undefined) => CgPlacement;
+export declare const clearContainer: (container: Container) => void;
+export declare const transitionDuration: (duration: number | undefined, fallback?: number) => number;

package/dist/scene/vfx.d.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+import { Container } from "pixi.js";
+import type { EffectSpec } from "@lute-lang/player";
+import type { WorldShape } from "../engine/types.js";
+export declare class Vfx {
+    readonly target: Container;
+    private readonly world;
+    private readonly design;
+    constructor(parent: Container, world: WorldShape, design: {
+        readonly width: number;
+        readonly height: number;
+    });
+    readonly play: (effect: EffectSpec, duration: number | undefined, instant?: boolean) => Effect.Effect<void>;
+}

package/dist/scene/videoLayer.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { Container } from "pixi.js";
+import type { Bindings, Stage } from "@lute-lang/player";
+import type { WorldShape, Theme } from "../engine/types.js";
+import { type TextureAssets } from "./shared.js";
+export declare class VideoLayer {
+    readonly target: Container;
+    private readonly assets;
+    private readonly bindings;
+    private readonly design;
+    private readonly theme;
+    private readonly logger;
+    private active;
+    constructor(parent: Container, _world: WorldShape, bindings: Bindings, assets: TextureAssets, design: {
+        readonly width: number;
+        readonly height: number;
+    }, theme: Theme, logger?: (message: string) => void);
+    readonly show: (video: Stage["video"], blocking: boolean, skip?: boolean) => Effect.Effect<void>;
+    readonly hide: () => Effect.Effect<void>;
+}
+export { VideoLayer as Sequence };

package/dist/text/dialogueWindow.d.ts

@@ -0,0 +1,52 @@
+import { Effect } from "effect";
+import { Container } from "pixi.js";
+import type { LineView, PlayMode, Settings } from "@lute-lang/player";
+import type { Theme, WorldShape } from "../engine/types.js";
+import { type TextStyleBindings } from "./richText.js";
+/** Design-space dimensions used to place the dialogue window. */
+export interface DialogueDesign {
+    readonly width: number;
+    readonly height: number;
+}
+/** Optional visual configuration for the dialogue entity. */
+export interface DialogueWindowOptions {
+    readonly nameColors?: Readonly<Record<string, number>>;
+    readonly textStyles?: TextStyleBindings;
+    readonly boxWidth?: number;
+    readonly boxHeight?: number;
+    readonly fontSize?: number;
+}
+/** A Pixi dialogue panel with a world-owned typewriter behaviour. */
+export declare class DialogueWindow {
+    readonly target: Container;
+    private readonly panel;
+    private readonly namePlate;
+    private readonly nameText;
+    private readonly textArea;
+    private readonly indicator;
+    private readonly world;
+    private readonly theme;
+    private readonly options;
+    private readonly graphemeTexts;
+    private timeline;
+    private currentLine;
+    private revealed;
+    private panelOpacity;
+    constructor(parent: Container, world: WorldShape, theme: Theme, options?: DialogueWindowOptions);
+    /** Shows a line and completes when its reveal behaviour ends. */
+    show: (line: LineView, settings: Settings, mode: PlayMode) => Effect.Effect<void>;
+    /** Finishes the current typewriter and makes the complete line visible. */
+    get reveal(): Effect.Effect<void>;
+    /** Removes line content and cancels behaviours attached to the window. */
+    get clear(): Effect.Effect<void>;
+    /** Changes panel opacity without changing the user's configured setting. */
+    setOpacity: (alpha: number) => void;
+    /** Hides or shows the complete dialogue entity. */
+    setHidden: (hidden: boolean) => void;
+    /** Repositions and resizes the panel for a new design resolution. */
+    relayout: (design: DialogueDesign) => void;
+    private clearTextChildren;
+    private buildTextChildren;
+    private tintText;
+    private typewriterBehaviour;
+}

package/dist/text/richText.d.ts

@@ -0,0 +1,37 @@
+import { Container, Text, type TextStyleOptions } from "pixi.js";
+import type { Segment } from "@lute-lang/player";
+/** Binding values accepted by a named text style. */
+export interface TextStyleBinding {
+    readonly fontWeight?: TextStyleOptions["fontWeight"];
+    readonly fontStyle?: TextStyleOptions["fontStyle"];
+    readonly color?: number | string;
+    readonly alpha?: number;
+    readonly scale?: number;
+    readonly letterSpacing?: number;
+    readonly fontFamily?: string;
+    readonly fontSize?: number;
+}
+/** The plain map supplied by the bindings decoder. */
+export type TextStyleBindings = Readonly<Record<string, TextStyleBinding>>;
+/** A style-bearing piece of text after line breaking. */
+export interface StyledRun {
+    readonly text: string;
+    readonly styles: ReadonlyArray<string>;
+    readonly line: number;
+}
+/** True when a grapheme is forbidden at the beginning of a line. */
+export declare const isForbiddenLineStart: (value: string) => boolean;
+/** True when a grapheme is forbidden at the end of a line. */
+export declare const isForbiddenLineEnd: (value: string) => boolean;
+/** Maps one named binding to Pixi's TextStyle options. */
+export declare const mapTextStyle: (names: ReadonlyArray<string>, bindings: TextStyleBindings, base?: TextStyleBinding) => TextStyleBinding;
+/**
+ * Breaks styled segments into runs constrained to `width`. Latin text wraps at
+ * whitespace; CJK text wraps at grapheme boundaries. Basic kinsoku rules keep
+ * punctuation out of line starts and opening punctuation out of line ends.
+ */
+export declare const layoutStyledRuns: (segments: ReadonlyArray<Segment>, width: number, bindings: TextStyleBindings, fallback?: TextStyleBinding, locale?: string) => ReadonlyArray<StyledRun>;
+/** Creates Pixi Text children for laid-out runs and positions them in the box. */
+export declare const renderStyledRuns: (target: Container, runs: ReadonlyArray<StyledRun>, bindings: TextStyleBindings, fallback?: TextStyleBinding, lineHeight?: number) => ReadonlyArray<Text>;
+/** Returns true when a grapheme is CJK-like and should use character wrapping. */
+export declare const isCjkGrapheme: (value: string) => boolean;

package/dist/text/segments.d.ts

@@ -0,0 +1,31 @@
+import type { Segment } from "@lute-lang/player";
+/** A grapheme in the reveal order of a line. Times are seconds from the line start. */
+export interface RevealGrapheme {
+    readonly grapheme: string;
+    readonly styles: ReadonlyArray<string>;
+    readonly segment: number;
+    readonly start: number;
+    readonly end: number;
+}
+/** A pause in the reveal timeline. */
+export interface RevealPause {
+    readonly segment: number;
+    readonly start: number;
+    readonly end: number;
+}
+/** The immutable, grapheme-aware typewriter timeline. */
+export interface RevealTimeline {
+    readonly graphemes: ReadonlyArray<RevealGrapheme>;
+    readonly pauses: ReadonlyArray<RevealPause>;
+    readonly duration: number;
+    readonly locale: string;
+}
+/**
+ * Builds the reveal schedule for a line. `rate` is a multiplier on the line's
+ * characters-per-second setting; a zero speed makes every grapheme immediate.
+ */
+export declare const buildRevealTimeline: (segments: ReadonlyArray<Segment>, charactersPerSecond: number, locale?: string) => RevealTimeline;
+/** Alias kept descriptive for callers that treat the result as a reveal plan. */
+export declare const segmentRevealTimeline: typeof buildRevealTimeline;
+/** Returns all graphemes in a string using the same locale-aware segmentation as the timeline. */
+export declare const graphemes: (text: string, locale?: string) => ReadonlyArray<string>;

package/dist/theme.d.ts

@@ -0,0 +1,7 @@
+import type { Bindings } from "@lute-lang/player";
+import type { Theme } from "./engine/types.js";
+/** Parse a CSS-style six digit colour, returning a supplied fallback on invalid input. */
+export declare const parseColour: (value: unknown, fallback: number) => number;
+/** Build the renderer theme from optional binding UI values. */
+export declare const themeFromBindings: (bindings: Pick<Bindings, "ui"> | undefined) => Theme;
+export declare const defaultTheme: Theme;

package/dist/ui/index.d.ts

@@ -0,0 +1,3 @@
+export { Ui, UiTag, uiLayer, type UiShape } from "./ui.js";
+export * from "./widgets/index.js";
+export * from "./screens/index.js";

package/dist/ui/screens/backlog-screen.d.ts

@@ -0,0 +1 @@
+export { BacklogScreen } from "./backlog.js";

package/dist/ui/screens/backlog.d.ts

@@ -0,0 +1,25 @@
+import { Container } from "pixi.js";
+import type { ScreenModel } from "@lute-lang/player";
+import type { Theme } from "../../engine/types.js";
+import { ScreenView, type EmitAction } from "./common.js";
+/** Backlog screen with virtualized entries and voice replay actions. */
+export declare class BacklogScreen extends ScreenView {
+    private readonly list;
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Backlog";
+    }>, theme: Theme, emit: EmitAction);
+    handleKey(key: string): boolean;
+    private row;
+}
+/** In-game quick action bar. */
+export declare class HudScreen extends Container {
+    /** Scaled button width and gap in design coordinates. */
+    static readonly buttonWidth = 101;
+    static readonly gap = 4;
+    static readonly totalWidth: number;
+    constructor(theme: Theme, emit: EmitAction, state: {
+        readonly auto: boolean;
+        readonly skip: boolean;
+        readonly hidden?: boolean;
+    });
+}

package/dist/ui/screens/common.d.ts

@@ -0,0 +1,68 @@
+import { Container, Text, Texture } from "pixi.js";
+import type { PlayerAction, ScreenModel } from "@lute-lang/player";
+import type { Theme } from "../../engine/types.js";
+import { Button, FocusManager, Panel } from "../widgets/index.js";
+/** Screen output callback. */
+export type EmitAction = (action: PlayerAction) => void;
+/** Common themed screen container with focus traversal. */
+export declare abstract class ScreenView extends Container {
+    readonly focus: FocusManager;
+    protected readonly theme: Theme;
+    protected readonly emitAction: EmitAction;
+    protected readonly panel: Panel;
+    protected readonly title: Text;
+    protected readonly panelWidth: number;
+    protected readonly panelHeight: number;
+    constructor(heading: string, theme: Theme, emit: EmitAction, width?: number, height?: number);
+    /** Centre this screen inside the configured design coordinates. */
+    layout(design: {
+        readonly width: number;
+        readonly height: number;
+    }, full?: boolean): void;
+    /** Add a button and register it in keyboard focus order. */
+    protected button(text: string, action: PlayerAction, x: number, y: number, disabled?: boolean): Button;
+    /** Route key events to focusable controls. */
+    handleKey(key: string): boolean;
+    /** Clear scene children and focus before rebuilding dynamic content. */
+    protected clearContent(): void;
+}
+/** Title screen with continue gating and optional preloaded background texture. */
+export declare class TitleScreen extends ScreenView {
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Title";
+    }>, theme: Theme, emit: EmitAction, gameTitle?: string, textureFor?: (file: string) => Texture | undefined);
+}
+/** Pause menu screen. */
+export declare class MenuScreen extends ScreenView {
+    constructor(theme: Theme, emit: EmitAction);
+}
+/** Confirmation modal. */
+export declare class ConfirmScreen extends ScreenView {
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Confirm";
+    }>, theme: Theme, emit: EmitAction);
+}
+/** End-of-story screen. */
+export declare class EndedScreen extends ScreenView {
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Ended";
+    }>, theme: Theme, emit: EmitAction);
+}
+/** Halted/error screen. */
+export declare class HaltedScreen extends ScreenView {
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Halted";
+    }>, theme: Theme, emit: EmitAction);
+}
+/** Loading progress screen. */
+export declare class LoadingScreen extends ScreenView {
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Loading";
+    }>, theme: Theme, emit: EmitAction);
+}
+/** Idle flow menu. */
+export declare class IdleScreen extends ScreenView {
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Idle";
+    }>, theme: Theme, emit: EmitAction);
+}

package/dist/ui/screens/confirm.d.ts

@@ -0,0 +1 @@
+export { ConfirmScreen } from "./common.js";

package/dist/ui/screens/ended.d.ts

@@ -0,0 +1 @@
+export { EndedScreen } from "./common.js";

package/dist/ui/screens/halted.d.ts

@@ -0,0 +1 @@
+export { HaltedScreen } from "./common.js";

package/dist/ui/screens/hud.d.ts

@@ -0,0 +1 @@
+export { HudScreen } from "./backlog.js";

package/dist/ui/screens/idle.d.ts

@@ -0,0 +1 @@
+export { IdleScreen } from "./common.js";

package/dist/ui/screens/index.d.ts

@@ -0,0 +1,4 @@
+export { ScreenView, type EmitAction, TitleScreen, TitleScreen as Title, MenuScreen, MenuScreen as Menu, ConfirmScreen, ConfirmScreen as Confirm, EndedScreen, EndedScreen as Ended, HaltedScreen, HaltedScreen as Halted, LoadingScreen, LoadingScreen as Loading, IdleScreen, IdleScreen as Idle } from "./common.js";
+export { BacklogScreen, BacklogScreen as Backlog, HudScreen, HudScreen as Hud } from "./backlog.js";
+export { SaveLoadScreen, SaveLoadScreen as SaveLoad, SLOTS_PER_PAGE, pageSlots } from "./save-load.js";
+export { SettingsScreen, SettingsScreen as Settings } from "./settings.js";

package/dist/ui/screens/loading.d.ts

@@ -0,0 +1 @@
+export { LoadingScreen } from "./common.js";

package/dist/ui/screens/menu.d.ts

@@ -0,0 +1 @@
+export { MenuScreen } from "./common.js";

package/dist/ui/screens/save-load-screen.d.ts

@@ -0,0 +1 @@
+export { SaveLoadScreen, SLOTS_PER_PAGE, pageSlots } from "./save-load.js";