@open-slot-ui/pixi 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,933 @@
+import * as pixi_js from 'pixi.js';
+import { Container, Ticker, Texture, Application, TextStyleOptions, Graphics } from 'pixi.js';
+import { ScreenState, ReadoutControl, OpenUI, Control, BlockSpec, Theme, EventLog, SpinControl, ValueDisplay, ButtonControl, ToggleControl, TurboControl, AutoplayControl, SliderControl, PanelControl, SelectControl, StepperControl, Signal, NoticeAction, OpenUIEvents, Dispose, CurrencySpec, JurisdictionConfig, NoticeOptions, RgsErrorOptions, ControlSnapshot, HostHooks, UISpec, Transition } from '@open-slot-ui/core';
+
+type StatusBarSide = 'top' | 'bottom';
+/**
+ * A thin, full-width black-and-white status strip pinned to the top or bottom edge,
+ * holding the compliance readouts (net · RTP · session) as inline items — white
+ * text on a dark bar, no theme accent. Only the jurisdiction-revealed readouts take
+ * a slot, so it adapts from 0→3 items (and hides itself when empty). A full-screen
+ * overlay (OpenUIPixi manages it + insets the HUD by {@link StatusBarView.heightFor}
+ * so controls never sit under it).
+ */
+declare class StatusBarView extends Container {
+    private readonly ui;
+    private readonly side;
+    private readonly bg;
+    private readonly items;
+    private screen;
+    private readonly disposers;
+    /** The strip's pixel height for the current screen (used for the HUD margin too). */
+    static heightFor(screen: ScreenState): number;
+    constructor(controls: ReadoutControl[], ui: OpenUI, ticker: Ticker, side: StatusBarSide);
+    applyLayout(screen: ScreenState): void;
+    private relayout;
+    dispose(): void;
+}
+
+/**
+ * Base view: a Pixi Container bound to a core Control. Owns layout placement and
+ * registers the introspection hook so the core can report bounds/animation state.
+ * Subclasses draw and wire input. Dumb on its own (Charter B3).
+ */
+declare abstract class ControlView extends Container {
+    protected readonly control: Control;
+    protected readonly ui: OpenUI;
+    protected animating: boolean;
+    protected readonly disposers: Array<() => void>;
+    constructor(control: Control, ui: OpenUI);
+    /** Position + fit-scale from the control's layout spec against the screen. */
+    applyLayout(screen: ScreenState): void;
+    private computeRect;
+    dispose(): void;
+}
+
+/** Per-id view override — swap a control's renderer without forking (Charter P7). */
+type ControlViewFactory = (control: Control, ui: OpenUI, ticker: Ticker) => ControlView;
+interface BlockColumnOptions {
+    controlSkins?: Partial<Record<string, ControlViewFactory>>;
+    /** Unclipped layer for select dropdowns (so a scroll mask doesn't clip them). */
+    dropdownLayer?: Container;
+}
+interface BlockColumn {
+    /** Rows laid top→down (first row near y=0); the caller positions/scrolls it. */
+    content: Container;
+    /** Interactive child views, for disposal. */
+    views: ControlView[];
+    /** Total column height. */
+    height: number;
+    /** Inner content width (body width minus padding). */
+    innerW: number;
+}
+/**
+ * Render a declarative `BlockSpec[]` into a column of rows — interactive controls
+ * (slider/toggle/button/select/value/stepper) and static content (heading/text/
+ * callout/stat-grid/steps/paytable/image). All text flows through `ui.t`. This is
+ * the single renderer shared by the small panel body AND the scrollable menu, so
+ * blocks look identical wherever they appear (Charter B3/B9).
+ */
+declare function buildBlockColumn(blocks: BlockSpec[], controls: Control[], ui: OpenUI, ticker: Ticker, bodyW: number, opts?: BlockColumnOptions): BlockColumn;
+
+/**
+ * A skin owns a control's *look* and nothing else. The view drives it with the
+ * current state name; the skin swaps art accordingly. This is the seam where a
+ * game's design (Graphics, SVG, Spine, …) plugs in without touching control logic.
+ */
+interface SpinSkin {
+    /** The display object the view adds into its animated `art` container. */
+    readonly view: Container;
+    /** React to a state change (swap art, recolor, etc.). */
+    update(state: string): void;
+    destroy(): void;
+}
+type SpinSkinFactory = (theme: Theme) => SpinSkin;
+
+interface CellRenderer<C extends Container = Container> {
+    createCell(digit: number): C;
+    setDigit(cell: C, digit: number): void;
+    setFiller(cell: C, digit: number): void;
+    createSeparator?(char: string): Container;
+    destroyCell?(cell: C): void;
+}
+/**
+ * Minimal GSAP-compatible API the Counter uses for `fit` animation.
+ * Passing the default `gsap` import satisfies this shape — no need for type imports.
+ */
+interface GsapLike {
+    to(target: object, vars: Record<string, unknown>): unknown;
+    killTweensOf(target: object): void;
+}
+
+interface OpenUIIcons {
+    settingsIdle?: Texture;
+    settingsActive?: Texture;
+    close?: Texture;
+    rules?: Texture;
+    sliderMusic?: Texture;
+    sliderSound?: Texture;
+    turboOff?: Texture;
+    turboOn?: Texture;
+    /** One texture per turbo mode (index-aligned) — for 3-mode art. Wins over off/on. */
+    turboModes?: Texture[];
+    autoIdle?: Texture;
+    autoActive?: Texture;
+    bonus?: Texture;
+    betPlus?: Texture;
+    betMinus?: Texture;
+}
+interface OpenUIPixiOptions {
+    /** Expose `window.__OPENUI__` for e2e/introspection. Default true. */
+    expose?: boolean;
+    /** Override the spin control's skin (default = the art-free Graphics placeholder). */
+    spinSkin?: SpinSkinFactory;
+    /** Real art for the menu/close/slider controls (else neutral placeholders). */
+    icons?: OpenUIIcons;
+    /**
+     * The composed MENU blocks (Settings → Paytable → Rules) the ☰ button opens in a
+     * scrollable sheet. Usually built by `mountHud` via `composeMenu(spec.menu, …)`;
+     * omitted → a default Settings-only menu (Music/Sound). Pass `false` to skip the
+     * built-in Pixi menu entirely (e.g. when supplying your own HTML/DOM menu).
+     */
+    menu?: BlockSpec[] | false;
+    /** Header title for the menu sheet (localizable). Default 'Menu'. */
+    menuTitle?: string;
+    /** Per-id view override — swap a control's renderer without forking (Charter P7). */
+    controlSkins?: Partial<Record<string, ControlViewFactory>>;
+    /**
+     * Host `gsap` — enables the value counter's auto-downscale so wide currencies
+     * (8-decimal BTC, big SATS counts, long codes) shrink to fit instead of spilling.
+     * Kept out of the lib's deps (Charter B5); the host passes its own gsap.
+     */
+    gsap?: GsapLike;
+    /**
+     * Autoplay count-picker presentation. `'drawer'` (default) is a bottom sheet;
+     * `'radial'` fans the count chips around the spin button.
+     */
+    autoplayPicker?: 'drawer' | 'radial';
+    /**
+     * Put the compliance readouts (net · RTP · session) in a thin status strip at the
+     * `'top'` or `'bottom'` edge instead of at screen corners. Each readout still only
+     * shows when its jurisdiction `display*` flag is set.
+     */
+    statusBar?: StatusBarSide;
+    /**
+     * How the interactive HUD appears on mount: `'shown'` (default), `'hidden'` (off
+     * screen + non-interactive; reveal later with `showControls()`), or `'slide-in'`
+     * (start hidden, then slide in from the edges).
+     */
+    intro?: 'shown' | 'hidden' | 'slide-in';
+}
+/**
+ * The controller: mounts ONE root Container onto the host's existing stage,
+ * shares the host ticker/renderer, drives resize, and exposes introspection.
+ * `unmount()` removes the layer and every listener it created (Charter P2/P12).
+ */
+declare class OpenUIPixi {
+    private readonly ui;
+    private readonly opts;
+    readonly root: Container<pixi_js.ContainerChild>;
+    private readonly views;
+    /** Full-screen overlays (e.g. the autoplay drawer) that own their own layout. */
+    private readonly overlays;
+    private readonly disposers;
+    private _eventLog?;
+    /** Show/hide slide: each interactive view slides toward its anchored edge (bottom
+     *  controls down, top up — behind the status-bar plaque). Views stay direct children
+     *  of `root` (introspection bounds unchanged); only their y moves, and the
+     *  ref-counted input lock makes them non-interactive while moving/hidden. */
+    private slideProg;
+    private slideTarget;
+    private slideHeld;
+    private lastScreenH;
+    private appTicker?;
+    private slideTickFn?;
+    private readonly slideBaseY;
+    private readonly slideSign;
+    constructor(ui: OpenUI, opts?: OpenUIPixiOptions);
+    /** The bus event log backing `window.__OPENUI__.events` (available after mount). */
+    get eventLog(): EventLog | undefined;
+    mount(app: Application): void;
+    /**
+     * Build the unified scrollable MENU bound to the ☰ panel. Composed `menu` blocks
+     * are given by `mountHud`; absent → a default Settings-only menu. Built-in ids
+     * ('music'/'sfx') are reused, not shadowed (P10); button blocks wire `closePanel`.
+     */
+    private buildMenu;
+    /**
+     * Slide the whole interactive HUD in (`true`) or out (`false`): bottom-anchored
+     * controls travel down, top-anchored travel up (behind the status-bar plaque).
+     * Pure translation (no scaling); controls are non-interactive while moving/hidden.
+     */
+    setControlsVisible(visible: boolean): void;
+    /** Apply the current slide progress: translate each interactive view toward its
+     *  anchored edge (pure translation — no scaling). */
+    private applySlide;
+    unmount(): void;
+    private expose;
+}
+
+/**
+ * Pixi view for the spin control. Owns input forwarding + transition playback;
+ * delegates ALL drawing to a swappable skin (Charter B3/P8). The layout scale
+ * lives on `this`; transitions animate the inner `art` container, so squish/turn
+ * never fight the responsive fit-scale — and the skin's art animates with them.
+ */
+interface SpinViewOptions {
+    /** Skin factory for the spin art. */
+    skin?: SpinSkinFactory;
+    /** How long (ms) a press must be held before hold-to-spin engages. Default 260. */
+    holdDelayMs?: number;
+}
+declare class SpinView extends ControlView {
+    private readonly spin;
+    private readonly art;
+    private readonly skin;
+    private readonly tween;
+    private readonly holdDelayMs;
+    private holdTimer;
+    private holding;
+    /** Free-spins face — a ring + remaining count + "FS"; shown when `spin.freeSpins > 0`. */
+    private readonly fsFace;
+    private readonly fsCount;
+    private readonly fsLabel;
+    constructor(spin: SpinControl, ui: OpenUI, ticker: Ticker, skinOrOpts?: SpinSkinFactory | SpinViewOptions);
+    /** Swap the spin face: free-spins counter when `freeSpins > 0`, else the skin. */
+    private updateFreeSpins;
+    private readonly onOver;
+    private readonly onOut;
+    private readonly onDown;
+    private readonly onUp;
+    private readonly onUpOutside;
+    private readonly endHoldGlobal;
+    private clearHoldTimer;
+    private endHold;
+    private updateInteractive;
+    private play;
+    dispose(): void;
+}
+
+/**
+ * View for a value display (balance / bet). Wraps pixi-text-counter's `Counter`
+ * (mechanical-reel digit roll) for the number with the currency symbol/code as a
+ * tight prefix/suffix. The odometer is sized to the VALUE (no hidden leading-zero
+ * reserve), so the symbol hugs the number and large balances never clamp; it grows
+ * when the value grows. Rebuilds on currency / locale change.
+ */
+declare class ValueDisplayView extends ControlView {
+    private readonly vd;
+    private readonly ticker;
+    /** Host `gsap` — when present, the counter auto-downscales wide values to fit
+     *  (Charter B5: no hard gsap dep; the host passes it). */
+    private readonly fitGsap?;
+    private counter;
+    private caption;
+    constructor(vd: ValueDisplay, ui: OpenUI, ticker: Ticker, 
+    /** Host `gsap` — when present, the counter auto-downscales wide values to fit
+     *  (Charter B5: no hard gsap dep; the host passes it). */
+    fitGsap?: GsapLike | undefined);
+    private side;
+    private build;
+    /** (Re)create the rolling counter sized to `total` columns, starting at `fromMinor`. */
+    private buildCounter;
+    private rebuild;
+    dispose(): void;
+}
+
+/** Built-in placeholder glyphs the button can draw without art. */
+type ButtonGlyph = 'menu' | 'close' | 'speaker' | 'speaker-mute' | 'fullscreen' | 'fullscreen-exit' | 'none';
+interface ButtonViewOptions {
+    shape?: 'circle' | 'pill';
+    radius?: number;
+    height?: number;
+    /** Placeholder icon drawn as simple lines (when no texture). */
+    glyph?: ButtonGlyph;
+    /** Skin with real art: a Sprite shown instead of placeholder geometry. */
+    iconTexture?: Texture;
+    /** Target sprite height in reference px. */
+    iconTarget?: number;
+    /** Monochrome look — white circle, black ring, black glyph (matches the turbo
+     *  button's b&w art). Only affects the drawn (no-texture) circle path. */
+    mono?: boolean;
+}
+/**
+ * Generic button view. With `iconTexture` it renders the provided art as a Sprite
+ * (swappable via `setIconTexture`, e.g. ☰ ↔ ✕); otherwise a neutral token placeholder.
+ * Pointer input drives the control's state machine; entry transitions play on `art`.
+ */
+declare class ButtonView extends ControlView {
+    private readonly btn;
+    private readonly art;
+    private readonly bg;
+    private sprite;
+    private labelText;
+    private readonly tween;
+    private readonly shape;
+    private readonly radius;
+    private readonly pillHeight;
+    private glyph;
+    private readonly iconTarget;
+    private readonly mono;
+    constructor(btn: ButtonControl, ui: OpenUI, ticker: Ticker, opts?: ButtonViewOptions);
+    /** Swap the displayed art (e.g. ☰ → ✕). */
+    setIconTexture(tex: Texture): void;
+    /** Swap the placeholder glyph (e.g. speaker ↔ speaker-mute, fullscreen ↔ exit). */
+    setGlyph(glyph: ButtonGlyph): void;
+    private fitSprite;
+    private readonly onOver;
+    private readonly onOut;
+    private readonly onDown;
+    private readonly onUp;
+    private readonly onUpOutside;
+    private updateHit;
+    private updateInteractive;
+    private redraw;
+    private play;
+    dispose(): void;
+}
+
+interface ToggleViewOptions {
+    offTexture?: Texture;
+    onTexture?: Texture;
+    target?: number;
+    radius?: number;
+}
+/**
+ * On/off toggle view (e.g. Turbo). Swaps the off/on art on state change; falls
+ * back to a token-colored circle when no textures are given. Tap → `toggle()`.
+ */
+declare class ToggleView extends ControlView {
+    private readonly toggle;
+    private readonly art;
+    private readonly bg;
+    private sprite;
+    private readonly tween;
+    private readonly offTex;
+    private readonly onTex;
+    private readonly target;
+    private readonly radius;
+    constructor(toggle: ToggleControl, ui: OpenUI, ticker: Ticker, opts?: ToggleViewOptions);
+    private readonly onUp;
+    private texFor;
+    private fit;
+    private redraw;
+    private play;
+    dispose(): void;
+}
+
+interface TurboViewOptions {
+    /** One texture per mode (index-aligned). Wins over off/on when provided. */
+    modeTextures?: Texture[];
+    /** 2-mode art: off frame + engaged frame (used when modeTextures is absent). */
+    offTexture?: Texture;
+    onTexture?: Texture;
+    target?: number;
+    radius?: number;
+}
+/**
+ * Turbo switcher view. One tap cycles to the next mode (`cycle()`), wrapping back
+ * to off. Renders whatever art it has — per-mode textures, a 2-mode off/on pair,
+ * or a token-drawn fallback — and, for 3+ modes, overlays a small level indicator
+ * (lit pips) so "turbo" vs "super" reads at a glance even on 2-frame art.
+ */
+declare class TurboView extends ControlView {
+    private readonly turbo;
+    private readonly art;
+    private readonly bg;
+    private readonly pips;
+    private sprite;
+    private readonly tween;
+    private readonly modeTex;
+    private readonly offTex;
+    private readonly onTex;
+    private readonly target;
+    private readonly radius;
+    constructor(turbo: TurboControl, ui: OpenUI, ticker: Ticker, opts?: TurboViewOptions);
+    private readonly onUp;
+    private texFor;
+    private fit;
+    private redraw;
+    private play;
+    dispose(): void;
+}
+
+interface AutoplayViewOptions {
+    idleTexture?: Texture;
+    activeTexture?: Texture;
+    target?: number;
+    radius?: number;
+    /**
+     * Count-picker presentation. `'drawer'` (default) defers picking to the bottom
+     * AutoplayDrawerView and keeps this button still; `'radial'` fans the count
+     * chips on an arc around the spin button (the classic in-place picker).
+     */
+    picker?: 'drawer' | 'radial';
+    /** Spin-button center in THIS view's local coords — the chips arc around it. */
+    arcCenter?: {
+        x: number;
+        y: number;
+    };
+    /** Fixed angle between chips (degrees). */
+    arcStepDeg?: number;
+    /** Arc radius (default = distance to arcCenter). */
+    arcRadius?: number;
+    /** Sweep direction along the arc (+1 over the top, -1 under). */
+    arcDir?: 1 | -1;
+}
+/**
+ * Autoplay button with a RADIAL count picker.
+ * - tap (idle): button rotates −60°, the count chips pop in one-by-one along an
+ *   arc around the spin button (fixed angle apart);
+ * - pick a chip: the fan collapses and the button becomes a STOP square + count;
+ * - tap (picking): button rotates +60° back and the fan hides;
+ * - tap (active): stops autoplay.
+ * The host runs the loop and feeds the live count.
+ */
+declare class AutoplayView extends ControlView {
+    private readonly auto;
+    private readonly ticker;
+    private readonly art;
+    private readonly bg;
+    private sprite;
+    private readonly countText;
+    private readonly chipLayer;
+    private readonly chips;
+    private readonly idleTex;
+    private readonly activeTex;
+    private readonly target;
+    private readonly radius;
+    private rot;
+    private rotTarget;
+    private phase;
+    private running;
+    private readonly useRadial;
+    private readonly tick;
+    constructor(auto: AutoplayControl, ui: OpenUI, ticker: Ticker, opts?: AutoplayViewOptions);
+    private fit;
+    private fmt;
+    private buildChips;
+    private onState;
+    private update;
+    private drawButton;
+    dispose(): void;
+}
+
+/**
+ * Autoplay picker as a BOTTOM DRAWER, in black & white. On the autoplay control's
+ * `'picking'` state it slides up, dims the HUD, and offers the count choices — plus,
+ * when configured, the responsible-gambling limits: "stop on loss" and "stop on
+ * single win" (multiples of bet; ∞ = no limit). Pick → `autoplay.pick(count,
+ * {lossLimit, singleWinLimit})`; the host enforces them via `hud.reportRound`. Tap
+ * the backdrop → `cancelPicker()`. A full-screen overlay (OpenUIPixi-managed).
+ */
+declare class AutoplayDrawerView extends Container {
+    private readonly auto;
+    private readonly ui;
+    private readonly ticker;
+    private readonly backdrop;
+    private readonly sheet;
+    private readonly sheetBg;
+    private readonly handle;
+    private readonly title;
+    private readonly startBtn;
+    private readonly startBg;
+    private readonly startLabel;
+    private readonly groups;
+    private screen;
+    private prog;
+    private running;
+    private sheetH;
+    private kk;
+    private readonly disposers;
+    private readonly tick;
+    constructor(auto: AutoplayControl, ui: OpenUI, ticker: Ticker);
+    private addGroup;
+    applyLayout(screen: ScreenState): void;
+    /** Base scale from the screen's shorter edge (before fit-to-height). */
+    private baseK;
+    private relayout;
+    /** Lay the sheet out at scale `k`; returns the full slide height (sheetH + 40). */
+    private layoutAt;
+    private drawGroup;
+    private select;
+    private valueOf;
+    private start;
+    private onState;
+    private update;
+    private render2;
+    dispose(): void;
+}
+
+/**
+ * Slider view. With a `trackTexture` (the handle-stripped ScrollBar art) it renders
+ * the real gold/white track + draws the moving handle on top. Without one, it draws
+ * a clean token-styled slider: a thin track, an accent-filled portion, and a white
+ * knob with an accent ring. Origin = track top-left.
+ */
+declare class SliderView extends ControlView {
+    private readonly slider;
+    private readonly handle;
+    private readonly hasTexture;
+    private dragging;
+    constructor(slider: SliderControl, ui: OpenUI, trackTexture?: Texture);
+    private redraw;
+    private valueFromEvent;
+    private readonly onDown;
+    private readonly onMove;
+    private readonly onUp;
+}
+
+interface PopoverParts {
+    music: SliderControl;
+    sfx: SliderControl;
+    rules: ButtonControl;
+}
+interface PopoverArt {
+    rulesTexture?: Texture;
+    musicTrack?: Texture;
+    soundTrack?: Texture;
+}
+/**
+ * The settings flyout as a VERTICAL FAN: on open, the options swoosh up and pop
+ * in one-by-one (bottom→top); on close they retract together. Items are
+ * right-aligned and rise above the (right-side) menu button. No static panel.
+ */
+declare class PopoverView extends ControlView {
+    private readonly panel;
+    private readonly ticker;
+    private readonly music;
+    private readonly sfx;
+    private readonly rules;
+    private readonly items;
+    private phase;
+    private running;
+    private readonly tick;
+    constructor(panel: PanelControl, parts: PopoverParts, ui: OpenUI, ticker: Ticker, art?: PopoverArt);
+    private applyState;
+    private update;
+    dispose(): void;
+}
+
+type InfoContentBuilder = (theme: Theme, width: number) => Container;
+interface PanelViewOptions {
+    closeTexture?: Texture;
+    content?: InfoContentBuilder;
+}
+/**
+ * Full-screen modal: dim backdrop + dark header (title + ✕ close) + a white,
+ * scrollable content card. Content is built dynamically (so it scrolls and is
+ * data-driven). Faithful to the provided Mobile Rules design.
+ */
+declare class PanelView extends ControlView {
+    private readonly panel;
+    private readonly opts;
+    private readonly backdrop;
+    private readonly card;
+    private readonly headerBg;
+    private readonly title;
+    private readonly viewport;
+    private readonly maskG;
+    private readonly catcher;
+    private readonly close;
+    private content;
+    private builtWidth;
+    private scrollY;
+    private contentH;
+    private viewportH;
+    private dragging;
+    private lastY;
+    private wheelHandler;
+    constructor(panel: PanelControl, closeBtn: ButtonControl, ui: OpenUI, ticker: Ticker, opts?: PanelViewOptions);
+    applyLayout(screen: ScreenState): void;
+    private fallback;
+    private readonly onDown;
+    private readonly onMove;
+    private readonly onUp;
+    private clampScroll;
+    private applyOpen;
+    dispose(): void;
+}
+
+interface SelectViewOptions {
+    width?: number;
+    height?: number;
+    /**
+     * An UNCLIPPED layer (above any scroll mask) to render the open dropdown list
+     * into. When given, tapping opens a real list; without it, tapping cycles.
+     */
+    dropdownLayer?: Container;
+}
+/**
+ * Select view: a pill showing the caption + current value + a chevron. With a
+ * `dropdownLayer`, tapping opens a real dropdown LIST (rendered in that unclipped
+ * layer so a scroll mask never clips it); choosing a row selects it. Without one,
+ * it falls back to cycle-on-tap. Token-styled; the headless logic is SelectControl.
+ */
+declare class SelectView extends ControlView {
+    private readonly select;
+    private readonly art;
+    private readonly bg;
+    private readonly chevron;
+    private readonly captionText;
+    private readonly valueText;
+    private readonly tween;
+    private readonly w;
+    private readonly h;
+    private readonly dropdownLayer;
+    private dropdown;
+    constructor(select: SelectControl, ui: OpenUI, ticker: Ticker, opts?: SelectViewOptions);
+    private readonly onUp;
+    private syncDropdown;
+    private showDropdown;
+    private hideDropdown;
+    private redraw;
+    private play;
+    dispose(): void;
+}
+
+/**
+ * Stepper view for a panel body: a `[−] value [+]` row (optionally captioned),
+ * driving the StepperControl. The ± buttons dim + go non-interactive at the ends
+ * (canDec/canInc). Token-styled, locale-reactive.
+ */
+declare class StepperView extends ControlView {
+    private readonly stepper;
+    private readonly minus;
+    private readonly plus;
+    private readonly valueText;
+    private readonly captionText?;
+    constructor(stepper: StepperControl, ui: OpenUI, _ticker: Ticker);
+    private fmt;
+    private redraw;
+}
+
+interface PanelBodyOptions {
+    width?: number;
+    controlSkins?: Partial<Record<string, ControlViewFactory>>;
+}
+/**
+ * A small, CENTERED panel body (the settings popover / declarative panels): walks
+ * a `BlockSpec[]` via the shared {@link buildBlockColumn} renderer, draws a branded
+ * card behind it, and follows the PanelControl's open/closed state. A `modal`
+ * variant also gets a dismissable backdrop. Text re-renders on `ui.locale` change.
+ * (The big scrollable menu uses {@link MenuView}, which shares the same renderer.)
+ */
+declare class PanelBodyView extends ControlView {
+    private readonly panelControl;
+    private readonly controls;
+    private readonly blocks;
+    private readonly ticker;
+    private readonly opts;
+    private readonly backdrop;
+    private readonly card;
+    private readonly content;
+    private childViews;
+    private readonly bodyW;
+    constructor(panelControl: PanelControl, controls: Control[], blocks: BlockSpec[], ui: OpenUI, ticker: Ticker, opts?: PanelBodyOptions);
+    private rebuild;
+    private drawChrome;
+    private applyVisibility;
+    dispose(): void;
+}
+
+interface MenuViewOptions {
+    controlSkins?: Partial<Record<string, ControlViewFactory>>;
+    /** Header title (localizable). Default 'Menu'. */
+    title?: string;
+    /** Max card width in px. Default 560. */
+    maxWidth?: number;
+}
+/**
+ * The unified MENU: one full-screen, scrollable sheet (Settings → Paytable →
+ * Rules) opened by the ☰ button. It renders the composed `BlockSpec[]` through the
+ * shared {@link buildBlockColumn} renderer inside a masked, drag/wheel-scrollable
+ * viewport — and, crucially, the scroll catcher sits BEHIND the content, so the
+ * interactive settings (volume sliders, language select) stay usable while empty
+ * space scrolls. Rebuilds on `ui.locale` change so a language switch re-renders it.
+ */
+declare class MenuView extends ControlView {
+    private readonly panel;
+    private readonly controls;
+    private readonly blocks;
+    private readonly ticker;
+    private readonly opts;
+    private readonly backdrop;
+    private readonly card;
+    private readonly headerBar;
+    private readonly title;
+    private readonly closeBtn;
+    private readonly viewport;
+    private readonly maskG;
+    private readonly catcher;
+    private readonly content;
+    /** Unclipped layer above the scroll mask for open select dropdowns. */
+    private readonly dropdownLayer;
+    private childViews;
+    private readonly titleKey;
+    private readonly maxWidth;
+    private vpW;
+    private vpH;
+    private scrollY;
+    private contentH;
+    private dragging;
+    private lastY;
+    private wheelHandler;
+    constructor(panel: PanelControl, controls: Control[], blocks: BlockSpec[], ui: OpenUI, ticker: Ticker, opts?: MenuViewOptions);
+    private buildClose;
+    private rebuildContent;
+    applyLayout(screen: ScreenState): void;
+    /** Close any open select dropdown (so scrolling/closing doesn't strand it). */
+    private closeSelects;
+    private readonly onDown;
+    private readonly onMove;
+    private readonly onUp;
+    private clampScroll;
+    private applyOpen;
+    dispose(): void;
+}
+
+interface ReadoutViewOptions {
+    /** Compact one-line layout (`CAPTION  value`) for the status bar. Default false (stacked). */
+    inline?: boolean;
+    /** Force black-and-white text (white on a dark bar), ignoring the theme accent/text hue. */
+    mono?: boolean;
+}
+/**
+ * A compact, non-interactive readout for the Stake Engine jurisdiction `display*`
+ * elements — RTP, net position, session timer. Two layouts: `stacked` (a dim
+ * uppercase caption over a bold value — for a screen corner) and `inline`
+ * (`CAPTION  value` on one line, centered on the seam — for the status bar). `mono`
+ * forces white text for the dark b&w status bar. The `'duration'` kind advances
+ * itself off the shared ticker while running. Net position shows an explicit +/-.
+ */
+declare class ReadoutView extends ControlView {
+    private readonly ro;
+    private readonly ticker;
+    private readonly caption?;
+    private readonly valueText;
+    private readonly tick?;
+    constructor(ro: ReadoutControl, ui: OpenUI, ticker: Ticker, opts?: ReadoutViewOptions);
+    private render;
+    dispose(): void;
+}
+
+interface DialogViewOptions {
+    controlSkins?: Partial<Record<string, ControlViewFactory>>;
+    /** Max card width in px. Default 520. */
+    maxWidth?: number;
+}
+/**
+ * A centered, auto-sized modal rendered in the SAME style as the unified menu — the
+ * accent-stroked card on a dimmed backdrop, the same {@link buildBlockColumn}
+ * renderer — so notices/errors are themed for free. Content comes from a
+ * `Signal<BlockSpec[]>` and the footer buttons from a `Signal<NoticeAction[]>`;
+ * every label runs through `ui.t`, so the host's exact text or i18n keys are used.
+ * The Stake Engine error/notice surface (`showError` / `showRgsError`).
+ */
+declare class DialogView extends ControlView {
+    private readonly panel;
+    private readonly blocks;
+    private readonly actions;
+    private readonly ticker;
+    private readonly opts;
+    private readonly backdrop;
+    private readonly card;
+    private readonly closeBtn;
+    private readonly content;
+    private readonly maskG;
+    private readonly buttons;
+    private childViews;
+    private screen;
+    private readonly maxWidth;
+    constructor(panel: PanelControl, blocks: Signal<BlockSpec[]>, actions: Signal<NoticeAction[]>, ui: OpenUI, ticker: Ticker, opts?: DialogViewOptions);
+    private buildClose;
+    applyLayout(screen: ScreenState): void;
+    private relayout;
+    /** Build the footer buttons from `noticeActions` into a centered row (shrunk to
+     *  fit if needed). Returns the row height (0 when there are no actions). */
+    private buildButtons;
+    private makeButton;
+    private drawButton;
+    private applyOpen;
+    dispose(): void;
+}
+
+interface HudOptions extends OpenUIPixiOptions {
+    hooks?: HostHooks;
+}
+/**
+ * The complete-HUD handle returned by `mountHud`. Wraps the headless OpenUI + the
+ * Pixi controller with the day-to-day game verbs, so the host rarely touches the
+ * lower layers. `dispose()` is the single, leak-free teardown (Charter P12).
+ */
+interface BootedHud {
+    readonly ui: OpenUI;
+    readonly pixi: OpenUIPixi;
+    on<K extends keyof OpenUIEvents>(type: K, fn: (p: OpenUIEvents[K]) => void): Dispose;
+    setBalance(major: number): void;
+    setBet(major: number): void;
+    setCurrency(spec: CurrencySpec): void;
+    /** Apply a Stake Engine jurisdiction config (the compliance switchboard) at runtime. */
+    applyJurisdiction(jur: JurisdictionConfig): void;
+    /** Report a settled round (major units): updates net position + enforces autoplay limits. */
+    reportRound(win: number, bet: number): void;
+    /** Set the RTP percentage shown by the RTP readout (when `displayRTP`). */
+    setRtp(percent: number): void;
+    /** Master mute / unmute (music + sfx). */
+    setMuted(muted: boolean): void;
+    /** Show a menu-style notice modal: declarative blocks + optional action buttons. */
+    showNotice(blocks: BlockSpec[], actions?: NoticeAction[]): void;
+    /** Show a menu-style error modal — `message`/`opts.title` are literal text OR i18n
+     *  keys, and `opts.actions` adds custom buttons (e.g. a "Reload"). */
+    showError(message: string, opts?: NoticeOptions): void;
+    /** Show the default (localizable, per-call overridable) message for an RGS status
+     *  code (e.g. `'ERR_IPB'`, `'ERR_IS'`, `'ERR_MAINTENANCE'`). */
+    showRgsError(code: string, opts?: RgsErrorOptions): void;
+    /** Show a FATAL error: a blocking modal that LOCKS the HUD and is dismissable only
+     *  in code (`hideNotice`) — for unrecoverable RGS states. */
+    showFatal(message: string, opts?: NoticeOptions): void;
+    /** Dismiss the notice / error modal. */
+    hideNotice(): void;
+    /** Social / sweepstakes mode: one switch swaps gambling wording (+ a coin → GC/SC). */
+    setSocial(on: boolean, coin?: string): void;
+    /** Switch the spin button to / from its free-spins face: `n > 0` shows "N FS". */
+    setFreeSpins(n: number): void;
+    /** Enter/leave replay mode (Stake `replay=true`) — locks the HUD + shows a REPLAY badge. */
+    setReplay(on: boolean): void;
+    /** Show a buy-feature confirm modal (Cancel / Confirm). Texts are literal-or-key. */
+    confirmBuy(opts: {
+        title?: string;
+        message?: string;
+        onConfirm: () => void;
+        confirmLabel?: string;
+        cancelLabel?: string;
+    }): void;
+    /** Slide the whole interactive HUD in / out — bottom controls go down, top ones up
+     *  (behind the status-bar plaque). Non-interactive while moving. */
+    showControls(): void;
+    hideControls(): void;
+    setControlsVisible(visible: boolean): void;
+    snapshot(): ControlSnapshot[];
+    readonly events: EventLog | undefined;
+    readonly inputLocked: Signal<boolean>;
+    lockInput(): void;
+    unlockInput(): void;
+    unmount(): void;
+    dispose(): void;
+}
+/**
+ * The one-call, out-of-the-box entry: `mountHud(app)` boots the full reference
+ * HUD; `mountHud(app, spec, opts)` configures it from one JSON UISpec + renderer
+ * art/skins. Pure assembly over `createUI` + `OpenUIPixi` (Charter B9).
+ */
+declare function mountHud(app: Application, spec?: UISpec, opts?: HudOptions): BootedHud;
+
+interface TextCellRendererOptions {
+    style: TextStyleOptions;
+    digitWidth: number;
+    digitHeight: number;
+    /** Glyph shown on intermediate (filler) frames during a roll. '' = blank. */
+    fillerChar?: string;
+}
+/**
+ * A zero-asset CellRenderer for pixi-text-counter using plain Pixi `Text`.
+ * Mirrors the shipped BitmapFontCellRenderer's cell convention: each digit is
+ * centered within a digitWidth x digitHeight box.
+ */
+declare class TextCellRenderer implements CellRenderer<Container> {
+    private readonly o;
+    constructor(o: TextCellRendererOptions);
+    createCell(digit: number): Container;
+    setDigit(cell: Container, digit: number): void;
+    setFiller(cell: Container, digit: number): void;
+    createSeparator(char: string): Container;
+    destroyCell(cell: Container): void;
+}
+
+/**
+ * The default skin: art-free, drawn from theme tokens (Charter B2 default skin).
+ * Deliberately generic placeholder geometry — a game swaps this for its own skin.
+ */
+declare function drawSpin(g: Graphics, theme: Theme, state: string): void;
+/** Factory wrapping the placeholder Graphics drawing as a SpinSkin. */
+declare const defaultSpinSkin: SpinSkinFactory;
+
+interface SvgSpinTextures {
+    /** Default look (the spin / rotating-arrows icon). */
+    default: Texture;
+    /** Autoplay look (the STOP-over-count variant). */
+    auto: Texture;
+}
+/**
+ * A skin that renders the provided spin-button SVGs (as textures) faithfully,
+ * swapping between the default and autoplay art by state. The control logic is
+ * untouched — this is purely the look.
+ */
+declare function svgSpinSkin(textures: SvgSpinTextures): SpinSkin;
+
+/**
+ * Minimal ticker-driven tween that interprets core `Transition` descriptors.
+ * Kill-and-replace: every `run()` resets the target and cancels the prior tween,
+ * so re-triggering a state never stacks transforms (Charter B6).
+ */
+declare class Tweener {
+    private readonly ticker;
+    private readonly frames;
+    private loopResolve;
+    constructor(ticker: Ticker);
+    stop(): void;
+    run(target: Container, transition: Transition | undefined, _theme: Theme): Promise<void>;
+    private add;
+    private done;
+    private exec;
+    private scaleYoyo;
+    private fadeTo;
+    /** Continuous rotation; the promise resolves when `stop()` is next called. */
+    private turn;
+    private runSequence;
+}
+
+/** Treat touch devices as non-desktop so we don't fire phantom hover states. */
+declare function isDesktop(): boolean;
+
+export { AutoplayDrawerView, AutoplayView, type AutoplayViewOptions, type BlockColumn, type BlockColumnOptions, type BootedHud, type ButtonGlyph, ButtonView, type ButtonViewOptions, ControlView, type ControlViewFactory, DialogView, type DialogViewOptions, type HudOptions, type InfoContentBuilder, MenuView, type MenuViewOptions, type OpenUIIcons, OpenUIPixi, type OpenUIPixiOptions, type PanelBodyOptions, PanelBodyView, PanelView, type PanelViewOptions, type PopoverArt, type PopoverParts, PopoverView, ReadoutView, type ReadoutViewOptions, SelectView, type SelectViewOptions, SliderView, type SpinSkin, type SpinSkinFactory, SpinView, type SpinViewOptions, type StatusBarSide, StatusBarView, StepperView, type SvgSpinTextures, TextCellRenderer, type TextCellRendererOptions, ToggleView, type ToggleViewOptions, TurboView, type TurboViewOptions, Tweener, ValueDisplayView, buildBlockColumn, defaultSpinSkin, drawSpin, isDesktop, mountHud, svgSpinSkin };