@panelwave/player 1.1.0 → 1.3.0

package/index.d.ts

@@ -1,7 +1,7 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
-import { OnDestroy, EventEmitter, OnInit, OnChanges, SimpleChanges, AfterViewInit, ElementRef } from '@angular/core';
+import { OnDestroy, EventEmitter, OnInit, OnChanges, AfterViewChecked, SimpleChanges, AfterViewInit, ElementRef } from '@angular/core';
 import { SafeHtml } from '@angular/platform-browser';
 import * as _panelwave_player from '@panelwave/player';
 
@@ -36,6 +36,11 @@ interface Panel {
     audio?: PanelAudioTrack[];
     /** Array of panel variants based on conditions (optional) */
     variants?: PanelVariant[];
+    /**
+     * Animation of the panel while it is shown (schema `PanelAnimations`):
+     * layer keyframes (schema 1.6+) and/or a camera move.
+     */
+    animations?: PanelAnimations;
     /** Whether this panel can be shared socially (optional) */
     shareable?: boolean;
     /** Override for age rating (optional) */
@@ -48,6 +53,14 @@ interface Panel {
     memoryBudgetHint?: number;
     /** Plugin instances for this panel (optional) */
     plugins?: PluginInstance$1[];
+    /**
+     * Server-side paywall stub: public manifests strip the content of paid
+     * panels and set this flag. The player renders a lock placeholder instead
+     * of layers, bubbles and hotspots (see `isLockedPanel`).
+     */
+    'x-locked'?: boolean;
+    /** Custom extension properties starting with x- (format 1.7+) */
+    [key: `x-${string}`]: unknown;
 }
 /**
  * Manifest audio role (schema `AudioTrack.role`). `ui` plays on the SFX bus,
@@ -71,6 +84,60 @@ interface PanelAudioTrack {
     /** JSON Logic condition; the track only plays when it evaluates true (optional) */
     visibleIf?: JsonLogic;
 }
+/**
+ * Layer property a keyframe animates (schema 1.6+).
+ *
+ * - `opacity`: 0-1, replaces the layer's opacity
+ * - `transform.x` / `transform.y`: offset from the layer's resting position as a
+ *   fraction of the panel's width / height (0.1 = 10 % right / down)
+ * - `transform.scale`: scale factor around the layer's center (1 = unchanged)
+ * - `transform.rotation`: degrees clockwise around the layer's center
+ * - `blur`: blur radius in px at a panel width of 1024 px (scaled with the rendered panel)
+ * - `brightness` / `contrast` / `saturate`: multiplier (1 = unchanged)
+ */
+type AnimatableProperty = 'opacity' | 'transform.x' | 'transform.y' | 'transform.scale' | 'transform.rotation' | 'blur' | 'brightness' | 'contrast' | 'saturate';
+/** Easing names the schema allows on animations and keyframes. */
+type AnimationEasing = 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out';
+/**
+ * One keyframe of a layer animation (schema `AnimationKeyframe`, 1.6+).
+ */
+interface AnimationKeyframe {
+    /** Keyframe identifier (optional) */
+    id?: string;
+    /** Id of the animated layer (`Panel.layers[].id`) */
+    layerId: string;
+    /** Animated property */
+    property: AnimatableProperty;
+    /** Position on the animation's timeline in milliseconds */
+    timeMs: number;
+    /** Property value at this keyframe (units: see {@link AnimatableProperty}) */
+    value: number;
+    /** Easing from this keyframe to the next one of the same track (default `linear`) */
+    easing?: AnimationEasing;
+}
+/**
+ * Panel animation (schema `PanelAnimations`).
+ */
+interface PanelAnimations {
+    /** Human-friendly name (authoring aid) */
+    name?: string;
+    /** Camera move start (normalized rect of the panel) */
+    startViewportRect?: NormalizedRect;
+    /** Camera move end (normalized rect of the panel) */
+    endViewportRect?: NormalizedRect;
+    /** Total running time; when omitted, keyframes run until their last keyframe */
+    durationMs?: number;
+    /** Easing of the camera move */
+    easing?: AnimationEasing;
+    /** Restart from 0 when durationMs is reached (default false) */
+    loop?: boolean;
+    /**
+     * Layer keyframes. Keyframes with the same layerId + property form a track;
+     * values hold before the first / after the last keyframe and are interpolated
+     * in between with the earlier keyframe's easing.
+     */
+    keyframes?: AnimationKeyframe[];
+}
 /**
  * Format-specific view configuration
  */
@@ -348,6 +415,8 @@ interface BalloonConfig {
     strokeColor: string;
     /** Hex color */
     fillColor: string;
+    /** Hex color of the lettering (default #000000; schema 1.7.0) */
+    textColor?: string;
     tail: TailConfig;
     hideBorder: HideBorderConfig;
 }
@@ -370,6 +439,12 @@ interface Hotspot {
     label: LocalizedString;
     /** Localized accessibility label (optional, overrides label for screen readers) */
     ariaLabel?: LocalizedString;
+    /**
+     * How readers see it (schema 1.7.0): `area` = invisible click area, `button` = the
+     * label shown as a button, `auto` (default) = button when the panel's goTo hotspots
+     * lead to two or more panels (a choice), else area.
+     */
+    display?: 'auto' | 'button' | 'area';
     /** Action to perform when activated */
     action: HotspotAction;
     /** Condition for hotspot visibility (optional) */
@@ -422,7 +497,7 @@ type HotspotAction = HotspotGoToAction | HotspotSetVariablesAction | HotspotOpen
  */
 interface HotspotGoToAction {
     type: 'goTo';
-    /** Target panel ID */
+    /** Target panel ID: any panel of the work, including one in another chapter */
     to: string;
     /** Variable mutations applied before navigating (optional) */
     mutations?: Mutation[];
@@ -686,9 +761,9 @@ interface Graph {
  * Edge connecting two panels with optional conditions
  */
 interface Edge {
-    /** Source panel ID */
+    /** Source panel ID (a panel of the chapter that holds this graph) */
     from: string;
-    /** Target panel ID */
+    /** Target panel ID: any panel of the work; one in another chapter switches the reader to that chapter */
     to: string;
     /** Condition that must be true for this edge to be traversable (optional) */
     condition?: JsonLogic;
@@ -706,6 +781,11 @@ interface Edge {
     priority?: number;
     /** Localized label for this edge (optional, for UI) */
     label?: Record<string, string>;
+    /**
+     * Editor edge metadata (schema `Edge.mutations`): the CMS keeps the choice
+     * label in an `{ op: 'meta', edgeType: { label } }` descriptor here.
+     */
+    mutations?: Record<string, unknown>[];
 }
 /**
  * Optional metadata for graph nodes
@@ -1396,6 +1476,29 @@ interface Page {
         /** Transition effect when leaving this page */
         out?: Transition;
     };
+    /** Visual properties of the page (optional) */
+    visual?: PageVisual;
+}
+/**
+ * Visual properties of a page (schema Page.visual)
+ */
+interface PageVisual {
+    /**
+     * Page background color (CSS hex) — the space between and around the
+     * panels. Falls back to settings.typography.default_page_bg_color.
+     */
+    background_color?: string;
+    /** Background image asset ID or URI */
+    background_image?: string;
+    /** Background texture asset ID or URI */
+    background_texture?: string;
+    /** Page margins in pixels */
+    margins?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
 }
 /**
  * Page layout configuration
@@ -1554,8 +1657,8 @@ interface OutputPreset {
 interface Extras {
     /** Cover image(s) (optional) */
     cover?: ExtraItem;
-    /** Alternative covers (optional) */
-    alt_cover?: ExtraItem;
+    /** Alternative cover(s): one block, or several (array form, schema 1.6+) */
+    alt_cover?: ExtraItem | ExtraItem[];
     /** Character sheets (optional) */
     character_sheets?: ExtraItem[];
     /** Author information (optional) */
@@ -1587,6 +1690,12 @@ interface ExtraItem {
     shareable?: boolean;
     /** Whether this extra is behind a paywall (optional) */
     gated?: boolean;
+    /** Character sheets: the character shown (first of characterIds for ensemble sheets) */
+    characterId?: string;
+    /** Character sheets: all characters shown on an ensemble sheet (schema 1.6+) */
+    characterIds?: string[];
+    /** Custom extension properties starting with x- (format 1.7+) */
+    [key: `x-${string}`]: unknown;
 }
 /**
  * Image in an extra item
@@ -2010,6 +2119,26 @@ interface PanelChangeEvent {
     /** Transition used */
     transition?: string;
 }
+/**
+ * Payload of `<pw-player-shell>`'s `(panelChange)` output.
+ *
+ * Panels are keyed by id in `chapter.panels`; the optional `Panel.id` of the
+ * format is not required and is usually absent, so read the id from
+ * `panelId`, not from `panel`.
+ */
+interface PlayerPanelChangeEvent {
+    /** The panel that is now current (the manifest object, variants unresolved). */
+    panel: Panel;
+    /** The chapter the panel belongs to. */
+    chapter: Chapter;
+    /** Id of the current panel: its key in `chapter.panels`. */
+    panelId: string;
+    /**
+     * Id of the panel that was current before this change (it may belong to
+     * the previous chapter). Undefined for the first panel after a (re)load.
+     */
+    previousPanelId?: string;
+}
 /**
  * Decision event payload
  */
@@ -2384,6 +2513,8 @@ declare class PlayerStateService {
 declare class ManifestService {
     private manifest;
     private indexes;
+    /** Absolute URL the current manifest was fetched from (null for object manifests). */
+    private manifestUrl;
     private readonly http;
     /**
      * Load manifest from a URL
@@ -2405,6 +2536,12 @@ declare class ManifestService {
      * Get the current manifest
      */
     getManifest(): PanelWaveManifest | null;
+    /**
+     * The URL the current manifest was loaded from, absolute — the last
+     * fallback for relative asset references (AssetUrlService); null when the
+     * manifest was supplied as an object.
+     */
+    getManifestUrl(): string | null;
     /**
      * Check if a manifest is loaded
      */
@@ -2509,6 +2646,20 @@ declare class ManifestService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ManifestService>;
 }
 
+/**
+ * Turns manifest asset references (`src`, poster, portrait, thumbnail…) into
+ * loadable URLs: absolute ones pass through, relative ones resolve against
+ * the loaded manifest's `assets.base` (per category, then `mediaBase`) and,
+ * failing that, the URL the manifest itself came from. One place for the
+ * rule every layer/overlay used to re-implement with `baseUrl + src`.
+ */
+declare class AssetUrlService {
+    private readonly manifestService;
+    resolve(src: string | undefined | null, category?: AssetCategory): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetUrlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssetUrlService>;
+}
+
 /**
  * Variable Store Service
  * Provides scoped variable storage with mutations and persistence
@@ -2769,6 +2920,19 @@ declare class FlowEngineService {
      * @returns Navigation result with next panel and transition
      */
     getNextPanel(graph: Graph, currentPanelId: string, context: Record<string, unknown>, defaultTransition?: Transition, defaultCameraMove?: CameraMove): NavigationResult;
+    /**
+     * Next panel within a chapter. A chapter WITH edges uses the graph
+     * ({@link getNextPanel}, conditions and priorities included). A chapter
+     * without any edges follows its reading order (entry, then
+     * `chapter.panels` key order) with the format defaults; null after the
+     * last panel.
+     */
+    getNextInChapter(chapter: Chapter, currentPanelId: string, context: Record<string, unknown>, defaultTransition?: Transition, defaultCameraMove?: CameraMove): NavigationResult;
+    /**
+     * Previous panel(s) within a chapter: the sources of edges into the panel,
+     * or — in a chapter without edges — the panel before it in reading order.
+     */
+    getPreviousInChapter(chapter: Chapter, currentPanelId: string): string[];
     /**
      * Camera move to play when navigating BACK from `currentPanelId` to
      * `previousPanelId`: the move of the edge originally traversed
@@ -2973,6 +3137,10 @@ declare class ImageCacheService {
      * Support for createImageBitmap
      */
     private readonly supportsImageBitmap;
+    /** Images warmed for `<img>` rendering (see preload), least recent first. */
+    private warmed;
+    /** How many warmed images stay referenced (a few panels/pages ahead). */
+    private readonly WARM_LIMIT;
     /**
      * Load an image from cache or network
      */
@@ -2998,9 +3166,16 @@ declare class ImageCacheService {
      */
     private evictLRU;
     /**
-     * Preload an image
+     * Preload an image for an upcoming `<img>`: loads it the way an `<img>`
+     * does (same URL, no CORS request) and decodes it, then keeps the element
+     * alive so the browser's memory cache serves the next `<img src>` with the
+     * decoded pixels — the panel appears in the frame it mounts, without the
+     * blank gap a cold load (or a fetch()/ImageBitmap copy the `<img>` never
+     * uses) leaves between autoplay panels.
      */
     preload(url: string): Promise<void>;
+    /** Load and decode an image through an `Image` element. */
+    private warmImage;
     /**
      * Preload multiple images
      */
@@ -3696,6 +3871,12 @@ declare class VisibilityService implements OnDestroy {
  * Auto-advance coupling (§4.3.6): when the last queue slot completes its pass
  * the sequencer emits {@link queueComplete}; the host advances the page/panel
  * only when autoplay is on.
+ *
+ * Image holds: with a page timeline (see {@link start}) the panels without a
+ * sequenced video hold the sequence for their dwell time, in reading order —
+ * video A, image B (2 s), image C (4 s), video D plays A, waits 6 s, plays D,
+ * so the reader has time for the art between the videos. Images before the
+ * first video delay it; images after the last one delay `queueComplete`.
  */
 
 /**
@@ -3744,6 +3925,15 @@ interface SequencedVideo extends SequencedVideoInfo {
     /** Optional hook invoked right before a stalled slot is skipped. */
     onStallSkip?(): void;
 }
+/**
+ * One panel of the page in reading order, with the time a panel without a
+ * sequenced video holds the sequence (its autoplay dwell time).
+ */
+interface PageTimelineEntry {
+    panelId: string;
+    /** Dwell time in ms; ignored for panels whose videos play in the sequence. */
+    holdMs: number;
+}
 /** Default stall-skip timeout: 10 s (§7). */
 declare const DEFAULT_STALL_TIMEOUT_MS = 10000;
 declare class VideoSequencerService implements OnDestroy {
@@ -3765,6 +3955,12 @@ declare class VideoSequencerService implements OnDestroy {
     private running;
     /** Stall-skip timer for the active slot. */
     private stallTimer?;
+    /** The page in reading order, with each panel's hold time. */
+    private timeline;
+    /** Timeline index of the last slot that played (-1: none yet). */
+    private timelinePosition;
+    /** Pending image hold before the next slot (or before `queueComplete`). */
+    private holdTimer?;
     /**
      * Stall-skip timeout (ms). If the active slot makes no progress for this
      * long the sequencer skips it (§7). Injectable via {@link setStallTimeout}
@@ -3789,8 +3985,12 @@ declare class VideoSequencerService implements OnDestroy {
      * visibility changes so newly-visible videos append and leaving ones drop.
      * Already-registered sequenced videos (components reused across a page
      * change) are re-observed and re-queued.
+     *
+     * @param timeline The page's panels in reading order with their hold times.
+     *   Panels without a sequenced video hold the sequence for that long
+     *   between the videos. Omitted: the videos play back to back.
      */
-    start(): void;
+    start(timeline?: readonly PageTimelineEntry[]): void;
     /** Stop the sequence and release all observers/timers. */
     reset(): void;
     ngOnDestroy(): void;
@@ -3842,9 +4042,18 @@ declare class VideoSequencerService implements OnDestroy {
     private completeActiveSlot;
     /**
      * Advance to the next queue slot, or emit `queueComplete` when the queue is
-     * exhausted.
+     * exhausted — each after holding for the image panels in between.
      */
     private advance;
+    /**
+     * Total hold of the image panels between the last played slot and the
+     * timeline index `target` (exclusive). Panels whose videos are sequenced
+     * never hold: they play, or were skipped as not visible.
+     */
+    private holdBefore;
+    /** Index of a panel in the page timeline, or -1. */
+    private timelineIndex;
+    private clearHoldTimer;
     /** Activate the head slot of the queue (all its sequenced videos). */
     private playNext;
     private armStallTimer;
@@ -3931,9 +4140,16 @@ declare class PreloadService {
     /** Low-priority items handed to requestIdleCallback but not started yet. */
     private idlePending;
     private readonly imageCache;
+    private readonly paywall;
     constructor();
     /**
-     * Add item to preload queue
+     * Add item to preload queue.
+     *
+     * Items of a panel the paywall locks for the reader (the renderers show
+     * its placeholder) are skipped: gated artwork is not fetched ahead of the
+     * gate. A later call after the lock lifts preloads them. Only panel ids
+     * the paywall knows are judged; items without one (or with a legacy index
+     * id from preloadNext) load as before.
      */
     add(item: PreloadItem): void;
     /**
@@ -3952,6 +4168,8 @@ declare class PreloadService {
      * Predict next indices based on direction
      */
     private predict;
+    /** Does the paywall lock this (known) panel for the reader? */
+    private isLockedPanel;
     /**
      * Clear queue
      */
@@ -4201,6 +4419,10 @@ declare class TrackingService {
  *   by `refId` (see `isExtraLocked`).
  * - A gated panel unlocks when the gating rule's requirement is satisfied by
  *   the reader's entitlement snapshot.
+ * - Age requirements are NOT subject to that precedence: every rule that
+ *   applies to a panel (its panel rules, its chapter's rules, every work
+ *   rule; each outside its own preview) and carries an age must be met first.
+ *   A chapter preview or a free panel rule never bypasses a work age gate.
  */
 
 type EvaluatorEntitlementType = 'free' | 'subscription' | 'purchase' | 'age_gate';
@@ -4347,16 +4569,41 @@ declare class PaywallService {
     private chapterOrder;
     private manifest;
     private products;
+    /** Panels the server stripped for this reader (`"x-locked": true`). */
+    private lockedPanels;
+    /** Decisions per panel for the current rules + snapshot (cleared on change). */
+    private decisions;
+    /** False while a host entitlement adapter decides access (see setEnforced). */
+    private enforced;
     private snapshotSubject;
     readonly snapshot$: Observable<EntitlementSnapshot>;
+    private changesSubject;
+    /**
+     * Fires whenever a lock can flip: new manifest, new snapshot, enforcement
+     * change or clear(). Renderers re-check `isPanelLocked` on it.
+     */
+    readonly changes$: Observable<void>;
     /** Load the rules and reading order from a manifest. Safe to call repeatedly. */
     setManifest(manifest: PanelWaveManifest | null): void;
     /** `paywall.products` by id (format 1.6); the first entry wins on duplicate ids. */
     static productsFromManifest(manifest: PanelWaveManifest | null): Map<string, PaywallProduct>;
     /** Replace what the reader owns (after sign-in, or a completed purchase). */
     setSnapshot(snapshot: EntitlementSnapshot | null | undefined): void;
+    /**
+     * Whether the rules are this service's to enforce. The shell turns it off
+     * while a host `entitlementAdapter` decides access (the adapter wins over
+     * manifest rules): the rules then still describe gates, but renderers no
+     * longer lock panels by them (`x-locked` stubs stay locked regardless).
+     */
+    setEnforced(enforced: boolean): void;
+    /**
+     * Should renderers show the locked placeholder for this panel? True when
+     * the rules are enforced here and the reader's snapshot does not open it.
+     * Memoized per rules + snapshot, so it is cheap to call from templates.
+     */
+    isPanelLocked(panelId: string): boolean;
     getSnapshot(): EntitlementSnapshot;
-    /** True when the work carries no paywall rules at all. */
+    /** True when the work carries no paywall rules and no locked panels. */
     get isFreeWork(): boolean;
     /** Reading-order index used for preview counting, or -1 when unknown. */
     indexOf(panelId: string): number;
@@ -4366,8 +4613,16 @@ declare class PaywallService {
      * An unknown panel id gets `MAX_SAFE_INTEGER` as its index so it falls
      * OUTSIDE any free preview: a panel the reading order does not know about
      * must not be handed out as a free sample.
+     *
+     * Defence in depth: a panel the server stripped (`"x-locked": true`) is
+     * locked whatever the rules say — its content is not in the manifest, so
+     * neither a free preview nor an entitlement can show it. The applying
+     * rule's own lock reason is kept while it locks; otherwise the reason is
+     * the rule's purchase/subscription requirement, else `purchase_required`
+     * (never the age, which would re-open the age gate forever on a stub).
      */
     evaluate(panelId: string): AccessDecision;
+    private decide;
     /** Is this extras block locked by an extras-scoped rule the reader does not satisfy? */
     isExtraLocked(extraId: string): boolean;
     /** Convenience: may the reader open this panel? */
@@ -4398,6 +4653,8 @@ declare class PaywallService {
     private get defaultLocale();
     /** Reset to a manifest-less, entitlement-less state. */
     clear(): void;
+    /** Drop memoized decisions and tell renderers. */
+    private changed;
     /**
      * Reader-facing wording for a lock reason. Kept here rather than in the
      * overlay so the same sentence is used wherever a gate is explained.
@@ -4998,6 +5255,13 @@ declare class PlayerService {
     static ɵprov: i0.ɵɵInjectableDeclaration<PlayerService>;
 }
 
+/**
+ * True when a panel is a server-side paywall stub: public manifests strip
+ * the content of paid panels and flag them `"x-locked": true`. Only the
+ * boolean `true` counts (a `"true"` string is not a lock).
+ */
+declare function isLockedPanel(panel: Panel | null | undefined): boolean;
+
 /**
  * Video Config Utilities
  * Resolves the effective VideoLayer playback config from layer fields,
@@ -5089,6 +5353,8 @@ interface BalloonOptions {
     strokeWidth: number;
     strokeColor: string;
     fillColor: string;
+    /** Lettering colour (CSS colour; BalloonConfig.textColor, schema 1.7.0). */
+    textColor: string;
     tailWidth: number;
     cornerRadius: number;
     fontFamily: string;
@@ -5127,6 +5393,8 @@ interface BalloonRenderResult {
     width: number;
     height: number;
     svg: SVGSVGElement;
+    /** True when the text needs more height than a fixed maxHeight allows (it is cut off). */
+    textOverflows: boolean;
     balloon: ComicBalloon;
     update: (newText?: string, newTailOptions?: TailOptions | null) => BalloonRenderResult;
     updateTail: (newTailOptions: TailOptions | null) => BalloonRenderResult;
@@ -5226,6 +5494,177 @@ declare function resolvePanelVariant(panel: Panel, context: VariantContext, forc
  */
 declare function resolvePanels(panels: Record<string, Panel>, context: VariantContext): Record<string, Panel>;
 
+/**
+ * Page view format selection. A chapter carries one page sequence per output
+ * format (`Page.layout.format`): mobile, tablet, desktop, big screen, print…
+ * The player shows the sequence that suits the screen best and keeps the
+ * others out of page navigation, the TOC and the page lookup.
+ */
+
+/** Screen classes the format preference lists are keyed by. */
+type ScreenClass = 'phone' | 'tablet' | 'desktop' | 'bigscreen';
+/**
+ * Classify the player's viewport. `width`/`height` are CSS px, `dpr` the
+ * device pixel ratio: a 4K screen at 150 % or 200 % scaling still counts as
+ * a big screen, a laptop at 125 % does not.
+ */
+declare function screenClassFor(width: number, height: number, dpr?: number): ScreenClass;
+/** The output format a page is laid out for; null for legacy pages without one. */
+declare function pageFormatOf(page: Page | null | undefined): string | null;
+/** Distinct formats of the given pages, in first-seen order. */
+declare function pageFormatsOf(pages: readonly Page[] | null | undefined): string[];
+/**
+ * Formats ranked for a screen class: its preference list, then any formats
+ * it does not name (closest aspect ratio to `aspect` first). Only formats in
+ * `available` are returned.
+ */
+declare function rankPageFormats(available: readonly string[], screen: ScreenClass, aspect?: number): string[];
+/**
+ * The page format to show on this screen, or null when the pages carry no
+ * format at all. `preferred` (a host override) wins when pages exist for it.
+ */
+declare function pickPageFormat(available: readonly string[], width: number, height: number, dpr?: number, preferred?: string | null): string | null;
+/**
+ * The page sequence of one format. Pages without a format (legacy) belong to
+ * every sequence; a null format means "all pages".
+ */
+declare function pagesForFormat(pages: readonly Page[] | null | undefined, format: string | null): Page[];
+/** Width / height of a page's frame: its canvas size, else its format's aspect, else 16:9. */
+declare function pageAspectRatio(page: Page | null | undefined): number;
+
+/**
+ * Reading position as a URL: page view and panel view get their own
+ * addresses, so a reader can bookmark or share exactly what they see.
+ *
+ *   ?page=pg-D3        page view, page `pg-D3`
+ *   ?panel=ch1-p022    panel view (and canvas view), panel `ch1-p022`
+ *   (neither)          the cover / the start of the work
+ *
+ * Ids are the manifest's page and panel ids. A page id belongs to one output
+ * format; the player falls back to the page showing the same panels when the
+ * reader's screen uses another format.
+ */
+/** What the player shows: the cover, a page, a single panel or the canvas. */
+type PlayerView = 'cover' | 'page' | 'panel' | 'canvas';
+/** The reader's position, emitted by the shell's `locationChange` output. */
+interface PlayerLocation {
+    view: PlayerView;
+    /** Chapter of the current panel (absent on the cover of an empty work). */
+    chapterId?: string;
+    /** Current panel (page view: the panel the reader is on). */
+    panelId?: string;
+    /** Open page (page view only). */
+    pageId?: string;
+}
+/** URL query parameters the position uses. */
+declare const LOCATION_PARAMS: {
+    readonly page: "page";
+    readonly panel: "panel";
+};
+/** The position a URL's query string asks for (page wins over panel). */
+declare function parseLocationSearch(search: string): {
+    pageId?: string;
+    panelId?: string;
+};
+/**
+ * The URL for a position: `href` with the position's query parameter set and
+ * every other parameter kept (e.g. `embed`). `drop` removes further
+ * parameters (a share link leaves out `embed`).
+ */
+declare function locationUrl(href: string, location: PlayerLocation, drop?: readonly string[]): string;
+
+/**
+ * Page background color. The page color fills the space between and around
+ * the panels in page view and the frame around the panel in panel view, so a
+ * reader moving from a white page to a black one sees the switch at the
+ * first panel of the new page.
+ */
+
+/** Used when neither the page nor the work sets a color. */
+declare const DEFAULT_PAGE_BACKGROUND = "#1a1a1a";
+/**
+ * The page's background color: `page.visual.background_color`, else the
+ * work's `settings.typography.default_page_bg_color`, else
+ * {@link DEFAULT_PAGE_BACKGROUND}. Values that are not CSS hex colors are
+ * skipped.
+ */
+declare function resolvePageBackground(page: Page | null | undefined, settings: Settings | null | undefined): string;
+
+/**
+ * Extras Viewer Component
+ * Displays bonus content gallery
+ */
+
+/**
+ * Extra item type
+ */
+type ExtraType = 'cover' | 'art' | 'bts' | 'interview' | 'other';
+/**
+ * Extra item definition
+ */
+interface Extra {
+    id: string;
+    type: ExtraType;
+    title: LocalizedString;
+    description?: LocalizedString;
+    thumbnail?: string;
+    asset?: string;
+    mediaType?: 'image' | 'video' | 'audio' | 'document';
+    gated?: boolean;
+    tags?: string[];
+    /** Character sheets: names of the characters shown (one, or several on an ensemble sheet). */
+    characters?: LocalizedString[];
+}
+
+/**
+ * Map the manifest's keyed `extras` blocks (schema $defs/ExtraBlock) to the
+ * flat list the extras viewer renders — including the media each block
+ * carries, resolved through the asset catalog.
+ *
+ * ExtraBlock media, in schema terms:
+ *   - `images[] { assetId, caption }`, `video[] (VideoLayer)`, `audio[] (AudioTrack)`
+ *     reference catalog assets by id;
+ *   - `url` / `thumbnail` are direct links (thumbnail may also be an asset id);
+ *   - `contentType` (image | video | audio | pdf | text) states the kind explicitly.
+ * Previously only id/title/text were passed on, so every extra rendered as an
+ * empty image.
+ */
+
+/** Just the catalog shape this module reads (image / video / audio items). */
+interface CatalogLike {
+    category?: string;
+    variants?: {
+        src: string;
+        w?: number;
+        direction?: string;
+    }[];
+    poster?: {
+        src: string;
+    };
+}
+type AssetLookup = (assetId: string) => CatalogLike | null | undefined;
+
+/**
+ * Thumbnails for navigation surfaces (thumbnail strip, TOC) and the work's
+ * cover. Panels carry no thumbnail field of their own: the thumbnail is a
+ * small rendition of the panel's artwork, resolved through the asset catalog.
+ */
+
+/** Width (physical px) a thumbnail tile is rendered at. */
+declare const THUMBNAIL_WIDTH = 320;
+/**
+ * The thumbnail source of a panel: an explicit `thumbnail`, else its
+ * bottom-most visible image layer (the artwork the panel is drawn on), else
+ * the poster of its first video layer. Empty when the panel has no artwork.
+ */
+declare function panelThumbnailSrc(panel: Panel | null | undefined, lookup: AssetLookup, width?: number): string;
+/**
+ * The work's cover image: `meta.cover` (asset id or URL), else the
+ * `extras.cover` block (its image, link or thumbnail). A gated cover block
+ * is not shown. Empty when the work has no cover.
+ */
+declare function coverImageSrc(manifest: PanelWaveManifest | null | undefined, lookup: AssetLookup, width?: number): string;
+
 /**
  * Renders an inlined Lucide icon by name (e.g. `lucideX`).
  *
@@ -5262,6 +5701,19 @@ interface Character {
     role?: string;
 }
 
+/**
+ * Viewport Component
+ * Main rendering container for panels with pan/zoom support
+ */
+
+/** A panel the viewport should warm ahead of time (see `preloadTargets`). */
+interface ViewportPreloadTarget {
+    panelId: string;
+    panel: Panel;
+    /** Share of the panel container (panel view) or page canvas (page view) width it renders at; default 1. */
+    widthFraction?: number;
+}
+
 /**
  * Camera state: world coordinates of the viewport center plus zoom factor
  * (world-to-screen scale).
@@ -5507,30 +5959,6 @@ interface Preferences {
     highContrast: boolean;
 }
 
-/**
- * Extras Viewer Component
- * Displays bonus content gallery
- */
-
-/**
- * Extra item type
- */
-type ExtraType = 'cover' | 'art' | 'bts' | 'interview' | 'other';
-/**
- * Extra item definition
- */
-interface Extra {
-    id: string;
-    type: ExtraType;
-    title: LocalizedString;
-    description?: LocalizedString;
-    thumbnail?: string;
-    asset?: string;
-    mediaType?: 'image' | 'video' | 'audio' | 'document';
-    gated?: boolean;
-    tags?: string[];
-}
-
 /**
  * Age Gate Component
  * Displays age verification UI for restricted content
@@ -5679,6 +6107,15 @@ declare class BranchChooserComponent {
 /**
  * Entitlement adapter interface
  * Provides entitlement and paywall functionality
+ *
+ * An adapter decides NAVIGATION only. It wins over the manifest's paywall
+ * rules, so with an adapter the rules no longer lock rendering: a panel the
+ * adapter refuses is still rendered. A move to it is stopped at the gate,
+ * but a refused entry panel (initial load, bookmark resume) gets the paywall
+ * raised OVER its rendered content, and page / canvas view show it in full.
+ * Hosts must not rely on an adapter to hide content: strip it on the server
+ * (`"x-locked": true` stubs stay locked regardless) or pass an
+ * `entitlementSnapshot`, which locks rendering as well.
  */
 interface EntitlementAdapter {
     /**
@@ -5698,7 +6135,7 @@ interface EntitlementAdapter {
  * Player Shell Component
  * Main orchestrator for the PanelWave player
  */
-declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
+declare class PlayerShellComponent implements OnInit, OnChanges, AfterViewChecked, OnDestroy {
     /**
      * Manifest to load
      */
@@ -5708,7 +6145,9 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      */
     manifestUrl?: string;
     /**
-     * Entitlement adapter for paywall integration
+     * Entitlement adapter for paywall integration. Gates navigation only: a
+     * refused entry panel gets the paywall over its rendered content (see
+     * {@link EntitlementAdapter}); don't rely on it to hide content.
      */
     entitlementAdapter?: EntitlementAdapter;
     /**
@@ -5787,17 +6226,55 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      */
     initialChapterId?: string;
     /**
-     * Initial panel ID
+     * Initial panel ID. Without `initialChapterId` the chapter holding the
+     * panel is looked up. A panel link opens in panel view.
      */
     initialPanelId?: string;
+    /**
+     * Initial page (manifest page id, e.g. from a `?page=` link): opens that
+     * page in page view. On a screen whose page format differs, the page
+     * showing the same panels opens. Wins over `initialPanelId`.
+     */
+    initialPageId?: string;
+    /**
+     * View to open in. Default: page view when the work has pages (after the
+     * cover), panel view for a panel link.
+     */
+    initialViewMode?: 'page' | 'panel';
+    /**
+     * Link the share dialog offers. Default: the current address with the
+     * reading position (`?page=` / `?panel=`, see `locationUrl`).
+     */
+    shareUrl?: string;
+    /**
+     * The reading position changed: cover, page, panel or canvas — for hosts
+     * that keep it in the address bar (`locationUrl`) so pages and panels
+     * can be bookmarked and shared.
+     */
+    locationChange: EventEmitter<PlayerLocation>;
     /**
      * Enable autoplay
      */
     autoplay: boolean;
     /**
-     * Seconds per panel in autoplay mode
+     * Seconds per panel in autoplay mode. With the default author timing this
+     * only applies to panels without an authored `durationMs` (and the cover);
+     * once the reader picks a speed in the toolbar it applies to every panel.
      */
     secondsPerPanel: number;
+    /**
+     * Page view format: 'auto' (default) shows the page sequence of the
+     * authored output format that suits the screen (phone → mobile-portrait,
+     * 4K → bigscreen-landscape, …); a format id forces that sequence when the
+     * work has pages for it.
+     */
+    pageFormat: string;
+    /**
+     * Show the work's cover (`meta.cover` / `extras.cover`) before the first
+     * panel when reading starts at the beginning. It also heads the thumbnail
+     * strip and the table of contents.
+     */
+    showCover: boolean;
     /**
      * Force reduced motion (host override). Reduced motion is also on when the
      * reader enabled it in Settings or the OS asks for it — see `motionReduced`.
@@ -5831,12 +6308,10 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      */
     ready: EventEmitter<void>;
     /**
-     * Panel changed
+     * The current panel changed. Carries the panel's id (`panelId`, its key in
+     * `chapter.panels`) and the id of the panel before it (`previousPanelId`).
      */
-    panelChange: EventEmitter<{
-        panel: Panel;
-        chapter: Chapter;
-    }>;
+    panelChange: EventEmitter<PlayerPanelChangeEvent>;
     /**
      * Chapter changed
      */
@@ -5897,6 +6372,8 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * Current page (for page view)
      */
     currentPage?: Page;
+    /** Cache for {@link pageBackground}: the page lookup runs once per panel. */
+    private pageBackgroundCache;
     /**
      * Current chapter
      */
@@ -6008,6 +6485,21 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * reveal modes and revisit-jumps).
      */
     visitedPanelIds: string[];
+    /**
+     * Page view and choices: the reader's choices so far (choice panel →
+     * the panel the chosen hotspot jumped to). Panels off the chosen path —
+     * and the branches of choices still ahead — show as placeholders in page
+     * view; pages made up of off-path panels only are skipped.
+     */
+    private madeChoices;
+    private branchGraph;
+    /** Placeholders in page view (off the path, or behind a choice not made yet). */
+    hiddenPanelIds: ReadonlySet<string>;
+    /** Off the chosen path for good (pages of these only are skipped). */
+    private unchosenPanelIds;
+    private refreshBranchVisibility;
+    /** A page whose panels are all off the chosen path: page navigation skips it. */
+    private isPageOffPath;
     /**
      * Autoplay timer
      */
@@ -6016,6 +6508,25 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * Autoplay enabled state
      */
     autoplayEnabled: boolean;
+    /**
+     * Autoplay dwell time source: 'author' plays each panel for its authored
+     * `durationMs` (the CMS timeline), 'manual' for the reader's chosen
+     * `secondsPerPanel`.
+     */
+    autoplayTiming: 'author' | 'manual';
+    /** Page format of the page sequence page view shows (null: pages carry none). */
+    activePageFormat: string | null;
+    /** Cover image (screen-sized and thumbnail), empty when the work has none. */
+    coverUrl: string;
+    coverThumbUrl: string;
+    /** The cover is shown in place of the story (before the first panel). */
+    coverVisible: boolean;
+    /** Upcoming panels the viewport warms (reading-order look-ahead). */
+    preloadTargets: ViewportPreloadTarget[];
+    /** PanelWave icon on the button that opens the toolbar. */
+    readonly panelwaveIcon = "data:image/webp;base64,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";
+    /** Panels on the current page (page view): all of them are "current" in the thumbnail strip. */
+    get currentPagePanelIds(): string[];
     /**
      * Speech-bubble toggle state. Every bubble is implicitly subject to this
      * (schema 1.3) — per-bubble visibleIf is reserved for story logic.
@@ -6091,6 +6602,8 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
     private analyticsSessionEnded;
     private workCompleteTracked;
     private lastTrackedPanelId?;
+    /** Id of the panel of the last `panelChange` emission (its `previousPanelId` source). */
+    private lastPanelChangeId?;
     /** Bound pagehide handler so add/removeEventListener match. */
     private readonly onPageHide;
     private readonly playerState;
@@ -6100,6 +6613,13 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
     private readonly translationService;
     private readonly canvasCamera;
     private readonly paywallService;
+    private readonly assetUrl;
+    private readonly preloadService;
+    private readonly host;
+    /** The player is shown in fullscreen (kept in sync with the browser, Esc included). */
+    isFullscreen: boolean;
+    /** The browser can show the player in fullscreen (not e.g. on iPhone Safari). */
+    readonly fullscreenAvailable: boolean;
     /** ngOnInit ran: later input changes are live updates, not initial values. */
     private initialized;
     /** The state subscriptions are set up once per instance, not per (re)load. */
@@ -6164,13 +6684,6 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * navigation, so session_start precedes the first panel_view.
      */
     private startAnalyticsSession;
-    /**
-     * Deterministic reading order for a chapter: breadth-first over the graph
-     * from the entry panel(s), then any unreachable panels in declaration
-     * order (branching narratives have no single true order — BFS approximates
-     * "distance from start", which is what the funnel needs).
-     */
-    private readingOrderForChapter;
     /**
      * Coarse device class for analytics breakdowns (matches the dashboard's
      * device segments): touch + narrow = phone, touch + wide = tablet,
@@ -6183,7 +6696,16 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * one-time `work_complete` signal.
      */
     private trackPanelView;
-    /** An end panel (no outgoing edges) of the manifest's last chapter. */
+    /**
+     * A panel's id: its key in `chapter.panels`. Panels don't reliably carry
+     * their own id (`Panel.id` is optional in the format), so resolve it by
+     * identity, as getCurrentPanelId() does.
+     */
+    private panelIdOf;
+    /**
+     * An end panel of the manifest's last chapter: no outgoing edges, or —
+     * in a chapter without edges — the last panel in reading order.
+     */
     private isEndOfWork;
     /**
      * Close the analytics session exactly once: emit `session_end` and flush
@@ -6216,6 +6738,13 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      *   blocked attempt never changes story state.
      */
     navigateToPanel(chapterId: string, panelId: string, transition?: Transition, cameraMove?: CameraMove, mutations?: Mutation[]): Promise<void>;
+    /**
+     * Raise the gate in front of a panel the reader may not open: the age gate
+     * for an unanswered age requirement (answered in-player), the paywall
+     * otherwise. A host-supplied adapter still wins — it is the documented
+     * override. Returns true when a gate was raised.
+     */
+    private raiseGateIfBlocked;
     /**
      * Rebuild the flat variable context handed to the viewport/canvas for
      * hotspot visibleIf evaluation. New object identity per call so OnPush
@@ -6233,6 +6762,11 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * Keep the audio engine's playing set in step with the effective panel
      * (variant-resolved, so a variant's `audio` override wins) and the
      * variable context its tracks' `visibleIf` conditions read.
+     *
+     * A panel the renderers lock (age gate, paywall, `x-locked` stub) stays
+     * silent: it syncs with no panel, which stops its tracks. The shell
+     * re-syncs on `PaywallService.changes$`, so the audio starts once the age
+     * is confirmed or the purchase lands.
      */
     private syncPanelAudio;
     /**
@@ -6321,6 +6855,21 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * Toolbar event handlers
      */
     onToggleView(): void;
+    /** Toolbar fullscreen button: show the player in fullscreen, or go back to the browser view. */
+    toggleFullscreen(): void;
+    /** Follow fullscreen changes from any source (button, Esc, F11-less browser UI). */
+    onFullscreenChange(): void;
+    /**
+     * Double-click on the viewport: a panel in page view opens large in panel
+     * view; in panel view the reader goes back to the page.
+     */
+    onPanelDoubleClick(panelId: string | null): void;
+    /** Viewport previous arrow: the previous page in page view, else the previous panel. */
+    onViewportPrevious(): void;
+    /** Viewport next arrow: the next page in page view, else the next panel. */
+    onViewportNext(): void;
+    /** Switch to a view mode, setting up the page / video sequence / camera it needs. */
+    private setViewMode;
     /** Land the canvas camera on the current panel (entering canvas view). */
     private jumpCameraToCurrentPanel;
     /**
@@ -6380,6 +6929,13 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
     onPreferencesChange(prefs: Preferences): void;
     onToggleAutoplay(): void;
     onSecondsPerPanelChange(seconds: number): void;
+    /** Toolbar: back to the author's timing ('author') or the reader's speed ('manual'). */
+    onAutoplayTimingChange(timing: 'author' | 'manual'): void;
+    /**
+     * Seconds shown next to the autoplay controls: the reader's speed, or with
+     * the author's timing the current panel's (page's) authored dwell time.
+     */
+    get autoplaySecondsDisplay(): number;
     onToggleThumbnails(): void;
     onOpenToc(): void;
     onOpenSettings(): void;
@@ -6408,8 +6964,8 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * override; navigation keeps it per panel.
      */
     onCycleAlternative(): void;
-    /** Open the branch chooser with the paths currently open from this panel. */
-    onShowBranches(): void;
+    /** Open the branch chooser with the paths currently open from this panel (or `panelId`). */
+    onShowBranches(panelId?: string): void;
     onOpenExtras(): void;
     /** Toggle the reader's like for this work (persisted on the device). */
     onLike(): void;
@@ -6420,6 +6976,25 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      */
     onBookmark(): void;
     onShare(): void;
+    /** Link in the open share dialog. */
+    shareLink: string;
+    /**
+     * What to share: the host's `shareUrl`, else the current address with the
+     * reading position — the page in page view, the panel in panel view, the
+     * work itself on the cover. `embed` is dropped: the link opens the full
+     * reader.
+     */
+    private buildShareLink;
+    /** The reading position: cover, page (with its id), panel or canvas. */
+    get currentLocation(): PlayerLocation;
+    /** Last position reported through `locationChange`. */
+    private lastLocationKey;
+    /**
+     * Report a changed reading position. Checked after every render: the
+     * position changes in many places (navigation, view toggle, cover, page
+     * format). Page view reports the page, not each panel the reader focuses.
+     */
+    ngAfterViewChecked(): void;
     onOpenComments(): void;
     /**
      * Modal close handlers
@@ -6437,6 +7012,7 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
     onTocNavigate(target: {
         chapterId: string;
         panelId?: string;
+        cover?: boolean;
     }): void;
     /**
      * Handle thumbnail navigation
@@ -6444,6 +7020,7 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
     onThumbnailNavigate(target: {
         chapterId: string;
         panelId: string;
+        cover?: boolean;
     }): void;
     /**
      * Keyboard shortcut handler
@@ -6480,6 +7057,24 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * timer.
      */
     private startAutoplay;
+    /** Run the wall-clock autoplay step: show progress, advance after `durationMs`. */
+    private armAutoplayTimer;
+    /** One autoplay step: leave the cover, turn the page (page view) or go to the next panel. */
+    private autoplayAdvance;
+    /** The reader is on the work's last panel (page view: its last page). */
+    private atEndOfWork;
+    /** Dwell time of one panel: authored `durationMs`, or the reader's seconds per panel. */
+    private panelDwellMs;
+    /** The current page's panel ids in reading order (placement order without one). */
+    private pageReadingOrderIds;
+    /**
+     * Start the page-view video sequence. Image panels between the videos hold
+     * it for their dwell time (authored `durationMs`, else the reader's seconds
+     * per panel), so the art gets read before the next video starts.
+     */
+    private startPageSequence;
+    /** Dwell time of what is on screen: the current panel, or every panel of the current page. */
+    private currentDwellMs;
     /**
      * Stop autoplay
      */
@@ -6530,26 +7125,124 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      */
     private stopAutoplayProgress;
     /**
-     * Find the page that contains the current panel
+     * The page (of the active format's page sequence) that shows a panel —
+     * by default the current one. A panel the sequence leaves out lands on the
+     * page closest before it in reading order.
      */
     private findPageContainingPanel;
     /**
-     * Navigate to next page (in page view mode)
-     */
-    navigateToNextPage(): void;
+     * Background color of the page the reader is on — the open page in page
+     * view, the page holding the current panel in panel view — so the frame
+     * switches color exactly when the first panel of the next page appears.
+     */
+    get pageBackground(): string;
+    /**
+     * Open the initial view: page view (default; `initialViewMode` overrides)
+     * on `page` — or, when that page is not in the screen's page format, the
+     * page showing the current panel. Canvas chapters and hosts that force a
+     * view mode keep theirs. Behind the cover the page sequence waits until
+     * the cover is left.
+     */
+    private enterInitialView;
+    /** A page by its manifest id, in any chapter and format. */
+    private findPageById;
+    /** The chapter that holds a panel. */
+    private findChapterOfPanel;
+    /** First panel of a page in reading order (placement order without one). */
+    private firstPanelOf;
+    /** The chapter's pages in the active page format (legacy pages without a format included). */
+    chapterPages(chapter: Chapter | undefined): Page[];
+    /**
+     * Pick the page sequence for the current screen (or the host's
+     * `pageFormat`). In page view a change of format re-opens the page that
+     * shows the current panel in the new sequence.
+     */
+    private updatePageFormat;
+    onWindowResize(): void;
+    /**
+     * After a jump to a panel (TOC, thumbnails, chapter change, next/previous):
+     * the cover gives way, page view opens the page showing the panel, and the
+     * look-ahead follows.
+     */
+    private afterJump;
+    /** The chapter before (-1) or after (+1) the current one. */
+    private adjacentChapter;
+    private isFirstChapter;
+    /** The panel a page starts with: first in its reading order, else its first placement. */
+    private firstPanelIdOf;
+    /** Show a page of the current chapter, its first panel becoming the current one. */
+    private showPage;
+    /**
+     * Page view across a chapter boundary: the first (+1) or last (-1) page of
+     * the adjacent chapter. The move goes through the panel gates like any
+     * other; a blocked move stays put.
+     */
+    private turnToAdjacentChapter;
+    /**
+     * Navigate to next page (in page view mode); past the chapter's last page
+     * to the next chapter. From the cover, the story starts.
+     */
+    navigateToNextPage(): Promise<void>;
+    /** Make the cover visible (thumbnail strip, TOC, back from the first panel/page). */
+    showCoverPage(): void;
+    /** Leave the cover: the story starts at the current (first) panel or page. */
+    hideCover(): void;
+    /**
+     * While the cover is up the viewport is not mounted, so its look-ahead
+     * cannot warm what comes first. Warm it here: the first panel (page view:
+     * the current page's panels) at the rendition a freshly mounted panel
+     * starts with (the catalog's primary variant, before layout knows its
+     * width) — the story then appears without a load gap.
+     */
+    private warmBehindCover;
+    /** Resolve the cover image from `meta.cover` / `extras.cover` through the asset catalog. */
+    private resolveCover;
+    /** The work's title in the current locale (cover alt text). */
+    get workTitle(): string;
+    /**
+     * Reading-order look-ahead for the viewport's preloader: the next panels
+     * (panel view) or the next pages' panels (page view), crossing into the
+     * next chapter, so autoplay and paging never wait for artwork.
+     */
+    private updatePreloadTargets;
     /**
      * Restart the page-view video sequence (and autoplay arming) after the
      * current page changed.
      */
     private onPageChanged;
     /**
-     * Navigate to previous page (in page view mode)
+     * Page view shows a whole page at once, so the per-panel navigation gate
+     * never runs: panels the paywall locks render as placeholders. When some of
+     * them only wait for the reader's age, ask once for the page (the highest
+     * minimum age among them); confirming unlocks them in place.
+     */
+    private promptAgeGateForPage;
+    /**
+     * Page view: the reader activated a locked panel's placeholder. Raise the
+     * gate that unlocks it in place, without moving: the age gate when only
+     * the age is missing, otherwise the paywall for that panel (the same gate
+     * a panel move would raise). A panel that is not locked raises nothing.
+     */
+    onLockedPanelActivate(panelId: string): void;
+    /**
+     * Ask once for the age the given panels wait for (the highest minimum
+     * age among those locked only by their age), with no pending move:
+     * confirming unlocks them in place.
      */
-    navigateToPreviousPage(): void;
+    private promptAgeGate;
     /**
-     * Get available locales from manifest
+     * Navigate to previous page (in page view mode); before the chapter's
+     * first page to the previous chapter's last page, before the work's first
+     * page to the cover.
+     */
+    navigateToPreviousPage(): Promise<void>;
+    /**
+     * Languages the work can be read in (the toolbar shows the language switch
+     * when there are several): `meta.locales` plus the languages the content
+     * is translated into. Computed once per manifest.
      */
     get availableLocales(): LocaleCode[];
+    private localeCache?;
     /**
      * Get characters from manifest mapped to roster format
      */
@@ -6611,8 +7304,19 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
      * "Choices". A closed conditional edge does not count.
      */
     get hasBranchesAhead(): boolean;
-    /** Outgoing edges of the current panel whose conditions pass right now. */
+    /** Outgoing edges of the current panel (or `fromPanelId`) whose conditions pass right now. */
     private openEdges;
+    /**
+     * The current panel is a decision: two or more open paths carry an authored
+     * choice label. "Next" then asks the reader instead of following one of them.
+     */
+    private isDecisionAhead;
+    /**
+     * Page view: a decision on the current page the reader has not taken yet
+     * (the last one in reading order). Turning the page would only show the
+     * placeholders of its branches, so "next" asks instead.
+     */
+    private pendingDecisionOnPage;
     /** Open outgoing edges with reader-facing labels. */
     private computeBranchChoices;
     private branchLabel;
@@ -6620,7 +7324,7 @@ declare class PlayerShellComponent implements OnInit, OnChanges, OnDestroy {
     /** Traverse the chosen edge (its transition / camera move / mutations apply). */
     onBranchChosen(choice: BranchChoice): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<PlayerShellComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PlayerShellComponent, "pw-player-shell", never, { "manifest": { "alias": "manifest"; "required": false; }; "manifestUrl": { "alias": "manifestUrl"; "required": false; }; "entitlementAdapter": { "alias": "entitlementAdapter"; "required": false; }; "entitlementSnapshot": { "alias": "entitlementSnapshot"; "required": false; }; "entitlementEndpoint": { "alias": "entitlementEndpoint"; "required": false; }; "readerToken": { "alias": "readerToken"; "required": false; }; "initialVariables": { "alias": "initialVariables"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "initialChapterId": { "alias": "initialChapterId"; "required": false; }; "initialPanelId": { "alias": "initialPanelId"; "required": false; }; "autoplay": { "alias": "autoplay"; "required": false; }; "secondsPerPanel": { "alias": "secondsPerPanel"; "required": false; }; "reducedMotion": { "alias": "reducedMotion"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "viewModeOverride": { "alias": "viewModeOverride"; "required": false; }; }, { "paywallAction": "paywallAction"; "ageVerified": "ageVerified"; "likeChange": "likeChange"; "bookmarkChange": "bookmarkChange"; "ready": "ready"; "panelChange": "panelChange"; "chapterChange": "chapterChange"; "error": "error"; "localeChange": "localeChange"; "variableChange": "variableChange"; "navigationAttempt": "navigationAttempt"; "cameraChange": "cameraChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PlayerShellComponent, "pw-player-shell", never, { "manifest": { "alias": "manifest"; "required": false; }; "manifestUrl": { "alias": "manifestUrl"; "required": false; }; "entitlementAdapter": { "alias": "entitlementAdapter"; "required": false; }; "entitlementSnapshot": { "alias": "entitlementSnapshot"; "required": false; }; "entitlementEndpoint": { "alias": "entitlementEndpoint"; "required": false; }; "readerToken": { "alias": "readerToken"; "required": false; }; "initialVariables": { "alias": "initialVariables"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "initialChapterId": { "alias": "initialChapterId"; "required": false; }; "initialPanelId": { "alias": "initialPanelId"; "required": false; }; "initialPageId": { "alias": "initialPageId"; "required": false; }; "initialViewMode": { "alias": "initialViewMode"; "required": false; }; "shareUrl": { "alias": "shareUrl"; "required": false; }; "autoplay": { "alias": "autoplay"; "required": false; }; "secondsPerPanel": { "alias": "secondsPerPanel"; "required": false; }; "pageFormat": { "alias": "pageFormat"; "required": false; }; "showCover": { "alias": "showCover"; "required": false; }; "reducedMotion": { "alias": "reducedMotion"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "viewModeOverride": { "alias": "viewModeOverride"; "required": false; }; }, { "paywallAction": "paywallAction"; "ageVerified": "ageVerified"; "likeChange": "likeChange"; "bookmarkChange": "bookmarkChange"; "locationChange": "locationChange"; "ready": "ready"; "panelChange": "panelChange"; "chapterChange": "chapterChange"; "error": "error"; "localeChange": "localeChange"; "variableChange": "variableChange"; "navigationAttempt": "navigationAttempt"; "cameraChange": "cameraChange"; }, never, never, true, never>;
 }
 
 /**
@@ -6685,9 +7389,11 @@ declare class CanvasStageComponent implements OnInit, OnChanges, OnDestroy {
     cameraChange: EventEmitter<CameraState>;
     readonly camera: CanvasCameraService;
     private readonly manifestService;
+    private readonly assetUrlService;
     private readonly preloadService;
     private readonly elementRef;
     private readonly cdr;
+    private readonly paywall;
     private readonly destroy$;
     /** Current world transform CSS for `.canvas-world`. */
     worldTransform: string;
@@ -6756,6 +7462,12 @@ declare class CanvasStageComponent implements OnInit, OnChanges, OnDestroy {
     /** Balloon lettering scale (same DIN-A4 reference as the panel viewport). */
     getReadingScale(): number;
     isCurrent(panelId: string): boolean;
+    /**
+     * Show the locked placeholder instead of the panel's content: a server
+     * stub (`"x-locked": true`), or a panel the paywall rules lock for the
+     * reader's current snapshot (age gate not yet answered, not purchased).
+     */
+    isLocked(panel: Panel | null | undefined, panelId?: string | null): boolean;
     trackPlacement(_index: number, entry: StagePlacement): string;
     private freeRoamAllowed;
     onPointerDown(event: PointerEvent): void;
@@ -6924,7 +7636,25 @@ declare class HotspotsOverlayComponent implements OnChanges {
      * Hotspots passing their visibleIf condition
      */
     visibleHotspots: Hotspot[];
+    /**
+     * Hotspots shown as labelled buttons: `display: "button"`, and with `auto`
+     * (the default) the goTo hotspots of a panel whose hotspots lead to two or
+     * more panels (a decision). `area` — and any other auto hotspot — stays an
+     * invisible area over the artwork (a door, a phone, a painted button).
+     */
+    choiceIds: ReadonlySet<string>;
     ngOnChanges(): void;
+    /** The visible button text of a choice hotspot (its label), or '' for plain areas. */
+    choiceText(h: Hotspot): string;
+    /** Bounding box (container units) of a hotspot shape — where its button label sits. */
+    boundsOf(s: HotspotShape): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Label font size: fits the button height, readable but never huge. */
+    choiceFontSize(h: Hotspot): number;
     /**
      * Accessible label: ariaLabel wins over label, falls back to the id
      */
@@ -7072,6 +7802,7 @@ declare class VideoLayerComponent implements OnInit, OnChanges, OnDestroy {
     private readonly sequencer;
     private readonly audioEngine;
     private readonly cdr;
+    private readonly assetUrl;
     /** Follows the player-wide Audio toggle (engine master mute). */
     private masterMuteSub?;
     private readonly host;
@@ -7079,8 +7810,6 @@ declare class VideoLayerComponent implements OnInit, OnChanges, OnDestroy {
     src: string;
     /** Reverse-variant URL used for the pingpong backward pass (empty if none). */
     reverseSrc: string;
-    /** Base URL for resolving relative paths. */
-    baseUrl: string;
     /** Poster image URL. */
     poster: string;
     /** Show native controls. */
@@ -7176,6 +7905,8 @@ declare class VideoLayerComponent implements OnInit, OnChanges, OnDestroy {
     private registeredWithSequencer;
     /** Whether this video is currently the sequencer's active slot member. */
     private activatedBySequencer;
+    /** An `on-view` video started by hovering it (page view), not by the sequence. */
+    private hoverPlaying;
     /**
      * What triggered the most recent playback, for tracking payloads. Set when
      * playback starts (sequencer / view / hover / click).
@@ -7189,6 +7920,7 @@ declare class VideoLayerComponent implements OnInit, OnChanges, OnDestroy {
     private readonly onTimeUpdateBound;
     getVideoUrl(): string;
     getPosterUrl(): string;
+    /** Absolute URLs as-is; relative ones via the manifest's assets.base / manifest URL. */
     private resolveUrl;
     private get video();
     private get startTimeSec();
@@ -7224,14 +7956,27 @@ declare class VideoLayerComponent implements OnInit, OnChanges, OnDestroy {
     /** Called from the template once the <video> element is available. */
     onLoadedMetadata(): void;
     private handleViewActiveChange;
-    /** Click / tap handler (on-click toggle). */
+    /**
+     * Click / tap handler: on-click layers toggle; any other video that is
+     * not playing (waiting for its turn in the page sequence, finished, or
+     * paused) starts on a click.
+     */
     onClick(): void;
     /** Keyboard handler (Enter / Space) for on-click layers. */
     onKeydown(event: KeyboardEvent): void;
-    /** Mouse enter — on-hover start (page view only). */
+    /**
+     * Mouse enter — on-hover start (page view only). An `on-view` video in page
+     * view that is not playing (still waiting for its turn in the sequence, or
+     * finished) plays while the pointer rests on it too.
+     */
     onMouseEnter(): void;
-    /** Mouse leave — on-hover pause keeping position. */
+    /**
+     * Mouse leave — on-hover pause keeping position; an `on-view` video the
+     * hover started pauses too, unless the sequence took it over meanwhile.
+     */
     onMouseLeave(): void;
+    /** The video is not playing: never started, paused or finished. */
+    private isIdle;
     private togglePlayback;
     /** Whether this layer participates in keyboard interaction. */
     isKeyboardInteractive(): boolean;
@@ -7336,7 +8081,7 @@ declare class VideoLayerComponent implements OnInit, OnChanges, OnDestroy {
     private scheduleFrameStep;
     private stopFrameStepping;
     static ɵfac: i0.ɵɵFactoryDeclaration<VideoLayerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<VideoLayerComponent, "pw-video-layer", never, { "src": { "alias": "src"; "required": false; }; "reverseSrc": { "alias": "reverseSrc"; "required": false; }; "baseUrl": { "alias": "baseUrl"; "required": false; }; "poster": { "alias": "poster"; "required": false; }; "controls": { "alias": "controls"; "required": false; }; "playMode": { "alias": "playMode"; "required": false; }; "startMode": { "alias": "startMode"; "required": false; }; "muted": { "alias": "muted"; "required": false; }; "startAtMs": { "alias": "startAtMs"; "required": false; }; "loopFromMs": { "alias": "loopFromMs"; "required": false; }; "streaming": { "alias": "streaming"; "required": false; }; "viewMode": { "alias": "viewMode"; "required": false; }; "viewActive": { "alias": "viewActive"; "required": false; }; "reducedMotion": { "alias": "reducedMotion"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "videoId": { "alias": "videoId"; "required": false; }; "panelId": { "alias": "panelId"; "required": false; }; "assetId": { "alias": "assetId"; "required": false; }; "placementId": { "alias": "placementId"; "required": false; }; "readingOrderIndex": { "alias": "readingOrderIndex"; "required": false; }; "placementZ": { "alias": "placementZ"; "required": false; }; "placementY": { "alias": "placementY"; "required": false; }; "placementX": { "alias": "placementX"; "required": false; }; }, { "videoPlay": "videoPlay"; "videoPause": "videoPause"; "videoEnd": "videoEnd"; "videoLoop": "videoLoop"; "passComplete": "passComplete"; "videoError": "videoError"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VideoLayerComponent, "pw-video-layer", never, { "src": { "alias": "src"; "required": false; }; "reverseSrc": { "alias": "reverseSrc"; "required": false; }; "poster": { "alias": "poster"; "required": false; }; "controls": { "alias": "controls"; "required": false; }; "playMode": { "alias": "playMode"; "required": false; }; "startMode": { "alias": "startMode"; "required": false; }; "muted": { "alias": "muted"; "required": false; }; "startAtMs": { "alias": "startAtMs"; "required": false; }; "loopFromMs": { "alias": "loopFromMs"; "required": false; }; "streaming": { "alias": "streaming"; "required": false; }; "viewMode": { "alias": "viewMode"; "required": false; }; "viewActive": { "alias": "viewActive"; "required": false; }; "reducedMotion": { "alias": "reducedMotion"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "videoId": { "alias": "videoId"; "required": false; }; "panelId": { "alias": "panelId"; "required": false; }; "assetId": { "alias": "assetId"; "required": false; }; "placementId": { "alias": "placementId"; "required": false; }; "readingOrderIndex": { "alias": "readingOrderIndex"; "required": false; }; "placementZ": { "alias": "placementZ"; "required": false; }; "placementY": { "alias": "placementY"; "required": false; }; "placementX": { "alias": "placementX"; "required": false; }; }, { "videoPlay": "videoPlay"; "videoPause": "videoPause"; "videoEnd": "videoEnd"; "videoLoop": "videoLoop"; "passComplete": "passComplete"; "videoError": "videoError"; }, never, never, true, never>;
 }
 
 declare class PlayerComponent {
@@ -7344,5 +8089,5 @@ declare class PlayerComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<PlayerComponent, "pw-player", never, {}, {}, never, never, true, never>;
 }
 
-export { ANONYMOUS_READER, ActionModalComponent, AgeGateComponent, AudioEngineService, BranchChooserComponent, CANVAS_PANEL_BUDGET, CanvasCameraService, CanvasStageComponent, ComicBalloon, DEFAULT_BALLOON_CONFIG, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_VIDEO_MUTED, DEFAULT_VIDEO_PLAY_MODE, DEFAULT_VIDEO_START_MODE, EntitlementError, EntitlementService, ExportService, FlowEngineService, HotspotActionService, HotspotsOverlayComponent, HttpEntitlementAdapter, ImageCacheService, ManifestService, MockEntitlementAdapter, NullEntitlementAdapter, PANEL_AUDIO_LEAVE_FADE_MS, PanelAudioService, PaywallOverlayComponent, PaywallService, PlayerComponent, PlayerEvent, PlayerService, PlayerShellComponent, PlayerStateService, PluginHostService, PluginSandboxComponent, PreloadService, PwIconComponent, RESERVED_NAMESPACES, SpeechBubblesComponent, TrackingService, TranslationService, UserGestureService, VISIBILITY_THRESHOLD, VariableStoreService, VideoControllerService, VideoLayerComponent, VideoSequencerService, VisibilityService, applyVariantOverrides, balloonConfigToRenderOptions, balloonConfigToTailOptions, busForRole, chapterOrderFromManifest, createBalloon, evaluatePanelAccess, evaluateWorkAccess, findWorkGateRule, fromManifestRule, isExtraLocked, mergeBalloonConfig, readingOrderFromManifest, resolveMuted, resolvePanelVariant, resolvePanels, resolvePlayMode, resolveStartMode, resolveVideoConfig, rulesFromManifest, satisfiesRule, selectVariant, toEntitlementStatus };
-export type { AccessDecision, AgeVerificationResult, AssetBase, AssetCatalogItem, AssetCatalogItemAudio, AssetCatalogItemImage, AssetCatalogItemJson, AssetCatalogItemPluginPayload, AssetCatalogItemSubtitle, AssetCatalogItemVector, AssetCatalogItemVideo, AssetCategory, AssetCommon, AssetRef, AssetReference, AssetVariant, Assets, AudioLayer, AudioRole, AudioTrack, AudioVariant, BalloonConfig, BalloonConfigOverride, BalloonOptions, BalloonRenderResult, BalloonType, Bookmark, BoundingBox, BranchChoice, BubbleStyle, BubbleTail, CameraMove, CameraMovePath, CameraState, CameraZoomProfile, CanvasBackground, CanvasCameraPolicy, CanvasDecoration, CanvasFitMode, CanvasFreeRoam, CanvasLayout, CanvasOverviewPolicy, CanvasPlacement, CanvasRevealMode, Chapter, Character$1 as Character, ContentWarning, Creator, DecisionEvent, DeepLinkTarget, DeviceVariables, Edge, EffectiveVideoConfig, EntitlementAdapter$1 as EntitlementAdapter, EntitlementContext, EntitlementErrorCode, EntitlementSnapshot, EntitlementSnapshotResponse, EntitlementStatus, EntitlementVariables, ErrorEvent$1 as ErrorEvent, EvaluatorEntitlementType, EvaluatorRule, EvaluatorScope, ExtraImage, ExtraItem, Extras, FormatView, Graph, HideBorderConfig, Hotspot, HotspotAction, HotspotCircle, HotspotGoToAction, HotspotOpenExtrasAction, HotspotOpenModalAction, HotspotPluginEventAction, HotspotPolygon, HotspotRect, HotspotSetVariablesAction, HotspotShape, HotspotUiEffect, HttpEntitlementAdapterConfig, ImageLayer, ImageVariant, JsonLogic, JsonLogicExpression, JsonValue, JsonVariant, Layer, LayerKind, LayerViewMode, LocaleCode, LocalizedString, LockReason, Meta, Mutation, MutationOperation, NavigationPath, NodeMetadata, NormalizedPoint, NormalizedRect, OutputFormat, OutputPreset, OverlayState, Page, PageLayout, Panel, PanelAudioRole, PanelAudioTrack, PanelChangeEvent, PanelPartial, PanelPlacement, PanelRef, PanelVariant, PanelWaveManifest, PanelwaveHeader, Paywall, PaywallAction, PaywallEvent, PaywallGate$1 as PaywallGate, PaywallProduct, PaywallRule, PlaybackState, PlayerError, PlayerErrorCode, PlayerEventData, PlayerOptions, PlayerPreferences, PlayerState, PlayerStatistics, PluginInstance$1 as PluginInstance, PluginLayer, PreferenceVariables, PreloadItem, PreloadPriority, PreloadSettings, PreloadStatus$1 as PreloadStatus, PreviewInfo, PurchaseInfo, ReadingProgress, ResolvedPanel, ResolvedPanelAudio, SequenceAudioTrack, SequencedVideo, SequencedVideoInfo, Settings, SpeechBubble, StagePlacement, SubtitleVariant, TailConfig, TailCurve, TailOptions, TextLayer, TextStyle, Tracking, TrackingConfig$1 as TrackingConfig, TrackingEvent, Transform, Transition, TraversalOptions, TraversalResult, UIDefaults, UISettings, UserInfo, UserVariables, VariableChangeEvent, VariableContext, VariableDefinition, VariableMutation, VariableScope, VariableStore, VariableType, VariableValidationResult, Variables, VariantContext, VectorVariant, VideoEvent, VideoLayer, VideoPlayMode, VideoPoster, VideoStartMode, VideoState, VideoStatus, VideoTrackingPayload, VideoTrigger, VideoVariant, ViewMode, ViewportState, VisibilityChange, WorldPoint, WorldRect };
+export { ANONYMOUS_READER, ActionModalComponent, AgeGateComponent, AssetUrlService, AudioEngineService, BranchChooserComponent, CANVAS_PANEL_BUDGET, CanvasCameraService, CanvasStageComponent, ComicBalloon, DEFAULT_BALLOON_CONFIG, DEFAULT_PAGE_BACKGROUND, DEFAULT_STALL_TIMEOUT_MS, DEFAULT_VIDEO_MUTED, DEFAULT_VIDEO_PLAY_MODE, DEFAULT_VIDEO_START_MODE, EntitlementError, EntitlementService, ExportService, FlowEngineService, HotspotActionService, HotspotsOverlayComponent, HttpEntitlementAdapter, ImageCacheService, LOCATION_PARAMS, ManifestService, MockEntitlementAdapter, NullEntitlementAdapter, PANEL_AUDIO_LEAVE_FADE_MS, PanelAudioService, PaywallOverlayComponent, PaywallService, PlayerComponent, PlayerEvent, PlayerService, PlayerShellComponent, PlayerStateService, PluginHostService, PluginSandboxComponent, PreloadService, PwIconComponent, RESERVED_NAMESPACES, SpeechBubblesComponent, THUMBNAIL_WIDTH, TrackingService, TranslationService, UserGestureService, VISIBILITY_THRESHOLD, VariableStoreService, VideoControllerService, VideoLayerComponent, VideoSequencerService, VisibilityService, applyVariantOverrides, balloonConfigToRenderOptions, balloonConfigToTailOptions, busForRole, chapterOrderFromManifest, coverImageSrc, createBalloon, evaluatePanelAccess, evaluateWorkAccess, findWorkGateRule, fromManifestRule, isExtraLocked, isLockedPanel, locationUrl, mergeBalloonConfig, pageAspectRatio, pageFormatOf, pageFormatsOf, pagesForFormat, panelThumbnailSrc, parseLocationSearch, pickPageFormat, rankPageFormats, readingOrderFromManifest, resolveMuted, resolvePageBackground, resolvePanelVariant, resolvePanels, resolvePlayMode, resolveStartMode, resolveVideoConfig, rulesFromManifest, satisfiesRule, screenClassFor, selectVariant, toEntitlementStatus };
+export type { AccessDecision, AgeVerificationResult, AnimatableProperty, AnimationEasing, AnimationKeyframe, AssetBase, AssetCatalogItem, AssetCatalogItemAudio, AssetCatalogItemImage, AssetCatalogItemJson, AssetCatalogItemPluginPayload, AssetCatalogItemSubtitle, AssetCatalogItemVector, AssetCatalogItemVideo, AssetCategory, AssetCommon, AssetRef, AssetReference, AssetVariant, Assets, AudioLayer, AudioRole, AudioTrack, AudioVariant, BalloonConfig, BalloonConfigOverride, BalloonOptions, BalloonRenderResult, BalloonType, Bookmark, BoundingBox, BranchChoice, BubbleStyle, BubbleTail, CameraMove, CameraMovePath, CameraState, CameraZoomProfile, CanvasBackground, CanvasCameraPolicy, CanvasDecoration, CanvasFitMode, CanvasFreeRoam, CanvasLayout, CanvasOverviewPolicy, CanvasPlacement, CanvasRevealMode, Chapter, Character$1 as Character, ContentWarning, Creator, DecisionEvent, DeepLinkTarget, DeviceVariables, Edge, EffectiveVideoConfig, EntitlementAdapter$1 as EntitlementAdapter, EntitlementContext, EntitlementErrorCode, EntitlementSnapshot, EntitlementSnapshotResponse, EntitlementStatus, EntitlementVariables, ErrorEvent$1 as ErrorEvent, EvaluatorEntitlementType, EvaluatorRule, EvaluatorScope, ExtraImage, ExtraItem, Extras, FormatView, Graph, HideBorderConfig, Hotspot, HotspotAction, HotspotCircle, HotspotGoToAction, HotspotOpenExtrasAction, HotspotOpenModalAction, HotspotPluginEventAction, HotspotPolygon, HotspotRect, HotspotSetVariablesAction, HotspotShape, HotspotUiEffect, HttpEntitlementAdapterConfig, ImageLayer, ImageVariant, JsonLogic, JsonLogicExpression, JsonValue, JsonVariant, Layer, LayerKind, LayerViewMode, LocaleCode, LocalizedString, LockReason, Meta, Mutation, MutationOperation, NavigationPath, NodeMetadata, NormalizedPoint, NormalizedRect, OutputFormat, OutputPreset, OverlayState, Page, PageLayout, PageVisual, Panel, PanelAnimations, PanelAudioRole, PanelAudioTrack, PanelChangeEvent, PanelPartial, PanelPlacement, PanelRef, PanelVariant, PanelWaveManifest, PanelwaveHeader, Paywall, PaywallAction, PaywallEvent, PaywallGate$1 as PaywallGate, PaywallProduct, PaywallRule, PlaybackState, PlayerError, PlayerErrorCode, PlayerEventData, PlayerLocation, PlayerOptions, PlayerPanelChangeEvent, PlayerPreferences, PlayerState, PlayerStatistics, PlayerView, PluginInstance$1 as PluginInstance, PluginLayer, PreferenceVariables, PreloadItem, PreloadPriority, PreloadSettings, PreloadStatus$1 as PreloadStatus, PreviewInfo, PurchaseInfo, ReadingProgress, ResolvedPanel, ResolvedPanelAudio, ScreenClass, SequenceAudioTrack, SequencedVideo, SequencedVideoInfo, Settings, SpeechBubble, StagePlacement, SubtitleVariant, TailConfig, TailCurve, TailOptions, TextLayer, TextStyle, Tracking, TrackingConfig$1 as TrackingConfig, TrackingEvent, Transform, Transition, TraversalOptions, TraversalResult, UIDefaults, UISettings, UserInfo, UserVariables, VariableChangeEvent, VariableContext, VariableDefinition, VariableMutation, VariableScope, VariableStore, VariableType, VariableValidationResult, Variables, VariantContext, VectorVariant, VideoEvent, VideoLayer, VideoPlayMode, VideoPoster, VideoStartMode, VideoState, VideoStatus, VideoTrackingPayload, VideoTrigger, VideoVariant, ViewMode, ViewportState, VisibilityChange, WorldPoint, WorldRect };