narraleaf-react 0.9.0-beta.5 → 0.9.1

package/dist/game/player/elements/nvl/DefaultNvlContainer.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { INvlContainerProps } from "./type";
+export declare function DefaultNvlContainer({ renderDialogItem, dialogs }: INvlContainerProps): React.JSX.Element;
+export default DefaultNvlContainer;

package/dist/game/player/elements/nvl/NvlContainer.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { NvlContainerProps, INvlContainerProps } from "./type";
+export declare function NvlContainer({ children, className, style }: NvlContainerProps): React.JSX.Element;
+export declare function BaseNvlContainer({ renderDialogItem: _renderDialogItem, ...props }: INvlContainerProps & NvlContainerProps): React.JSX.Element;
+export default NvlContainer;

package/dist/game/player/elements/nvl/NvlContext.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { NvlDialogEntry } from "../../gameState";
+import { NvlContextValue } from "./type";
+declare const NvlContext: React.Context<NvlContextValue>;
+export declare function useNvl(): NvlContextValue;
+export declare function useNvlDialogs(): NvlDialogEntry[];
+export declare function useIsNvlMode(): boolean;
+export declare function useIsNvlVisible(): boolean;
+export interface NvlProviderProps {
+    children: React.ReactNode;
+}
+export declare function NvlProvider({ children }: NvlProviderProps): React.JSX.Element;
+export default NvlContext;

package/dist/game/player/elements/nvl/NvlDialogList.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { NvlDialogListProps, NvlDialogItemProps } from "./type";
+export declare function NvlDialogList({ children, className, style, renderDialogItem }: NvlDialogListProps): React.JSX.Element;
+export declare function DefaultNvlDialogItem({ entry, index, className, style, texts }: NvlDialogItemProps & {
+    texts?: React.ReactNode;
+}): React.JSX.Element;
+export default NvlDialogList;

package/dist/game/player/elements/nvl/type.d.ts

@@ -0,0 +1,49 @@
+import type { GameState, NvlDialogEntry, NvlState } from "../../gameState";
+import type { TransformDefinitions } from "../../../nlcore/elements/transform/type";
+import type { Word } from "../../../nlcore/elements/character/word";
+import type { Pausing } from "../../../nlcore/elements/character/pause";
+import React from "react";
+export type NvlDialogProxy = {
+    entry: NvlDialogEntry;
+    index: number;
+    isActive: boolean;
+    gameState: GameState;
+    words: Word<Pausing | string>[];
+    useTypeEffect: boolean;
+};
+export interface INvlContainerProps {
+    dialogs?: NvlDialogProxy[];
+    renderDialogItem?: NvlDialogItemRenderer;
+}
+export interface NvlContainerProps {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface NvlDialogListProps {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    renderDialogItem?: NvlDialogItemRenderer;
+}
+export interface NvlDialogItemProps {
+    entry: NvlDialogEntry;
+    index: number;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface NvlDialogItemRenderProps {
+    entry: NvlDialogEntry;
+    index: number;
+    isActive: boolean;
+    nametag: React.ReactNode;
+    texts: React.ReactNode;
+}
+export type NvlDialogItemRenderer = (props: NvlDialogItemRenderProps) => React.ReactNode;
+export interface NvlContextValue {
+    state: NvlState;
+    dialogs: NvlDialogEntry[];
+    isActive: boolean;
+    isVisible: boolean;
+    transitionOptions: Partial<TransformDefinitions.CommonTransformProps> | null;
+}

package/dist/game/player/elements/nvl/useNvlDialogState.d.ts

@@ -0,0 +1,14 @@
+import { DialogState } from "../say/UIDialog";
+import { GameState } from "../../gameState";
+import type { NvlDialogEntry } from "../../gameState";
+import type { Word } from "../../../nlcore/elements/character/word";
+import type { Pausing } from "../../../nlcore/elements/character/pause";
+type UseNvlDialogStateParams = {
+    entry: NvlDialogEntry;
+    gameState: GameState;
+    words: Word<Pausing | string>[];
+    isActive: boolean;
+    useTypeEffect: boolean;
+};
+export declare function useNvlDialogState({ entry, gameState, words, isActive, useTypeEffect, }: UseNvlDialogStateParams): DialogState;
+export {};

package/dist/game/player/elements/player/StageClickAnnouncer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/game/player/elements/say/Avatar.d.ts

@@ -0,0 +1,13 @@
+import type { Character } from "../../../nlcore/elements/character";
+import type { Image } from "../../../nlcore/elements/displayable/image";
+import React from "react";
+export type DialogAvatarContext = {
+    visible: boolean;
+    src: string | null;
+    character: Character | null;
+    portrait: Image | null;
+    alt: string;
+};
+export declare function useAvatar(): DialogAvatarContext;
+export declare function Avatar({ className, style, alt, ...props }: React.ImgHTMLAttributes<HTMLImageElement>): React.JSX.Element | null;
+export default Avatar;

package/dist/game/player/elements/say/Nametag.d.ts

@@ -1,2 +1,9 @@
 import React from "react";
-export default function Nametag({ ...props }: Readonly<React.HTMLAttributes<HTMLDivElement>>): React.JSX.Element;
+import type { Character } from "../../../nlcore/elements/character";
+import type { NvlDialogEntry } from "../../gameState";
+type NametagProps = React.HTMLAttributes<HTMLDivElement> & {
+    entry?: NvlDialogEntry;
+    character?: Character | null;
+};
+export default function Nametag({ entry, character, ...props }: Readonly<NametagProps>): React.JSX.Element;
+export {};

package/dist/game/player/elements/say/Sentence.d.ts

@@ -1,11 +1,12 @@
 import { Pausing } from "../../../nlcore/elements/character/pause";
-import { Sentence } from "../../../nlcore/elements/character/sentence";
+import { Sentence, type StaticWord } from "../../../nlcore/elements/character/sentence";
 import { Word } from "../../../nlcore/elements/character/word";
 import { GameState } from "../../../../game/nlcore/common/game";
 import { Color } from "../../../../game/nlcore/types";
 import React from "react";
 import { DialogElementProps } from "./type";
 import { DialogState } from "./UIDialog";
+import type { NvlDialogEntry } from "../../gameState";
 type BaseTextsProps = {
     /**
      * The default color of the text
@@ -15,6 +16,74 @@ type BaseTextsProps = {
     style?: React.CSSProperties;
     dialog?: DialogState;
 } & React.HTMLAttributes<HTMLDivElement>;
+export type TextsPreviewInput = StaticWord<string | Pausing> | StaticWord<string | Pausing>[];
+export type TextsPreviewLoop = boolean | {
+    /**
+     * Whether the preview restarts after the current type effect completes.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Delay before the next preview cycle starts, in milliseconds.
+     * @default 1000
+     */
+    delay?: number;
+};
+export interface TextsPreviewProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    /**
+     * Static text or words to preview.
+     */
+    text?: TextsPreviewInput;
+    /**
+     * Sentence to preview. Dynamic words are not evaluated; pass `words` when
+     * previewing already-evaluated runtime content.
+     */
+    sentence?: Sentence;
+    /**
+     * Already-evaluated words, useful when previewing dynamic sentence content.
+     */
+    words?: Word<Pausing | string>[];
+    /**
+     * Whether the preview should use the rolling type effect.
+     * @default true
+     */
+    useTypeEffect?: boolean;
+    /**
+     * Loop behavior for settings screens and other static previews.
+     * @default true
+     */
+    loop?: TextsPreviewLoop;
+    /**
+     * Delay before replay when `loop` is `true`, in milliseconds.
+     * Ignored when `loop` is an object with `delay`.
+     * @default 1000
+     */
+    restartDelay?: number;
+    /**
+     * Characters per second used by the preview.
+     * @default current game's `cps` preference, or Game.DefaultPreference.cps outside GameProvider
+     */
+    cps?: number;
+    /**
+     * Speed multiplier used by the preview.
+     * @default current game's `gameSpeed` preference, or Game.DefaultPreference.gameSpeed outside GameProvider
+     */
+    gameSpeed?: number;
+    /**
+     * Duration for a pause without an explicit duration, in milliseconds.
+     * @default current game's `autoForwardDefaultPause` config, or Game.DefaultConfig.autoForwardDefaultPause outside GameProvider
+     */
+    pauseDuration?: number;
+    /**
+     * Fallback color when neither the word nor the sentence defines one.
+     */
+    defaultColor?: Color;
+    fontSize?: React.CSSProperties["fontSize"];
+    fontWeight?: React.CSSProperties["fontWeight"];
+    fontWeightBold?: React.CSSProperties["fontWeight"];
+    fontFamily?: React.CSSProperties["fontFamily"];
+    onCompleted?: () => void;
+}
 /**
  * Props-based wrapper component
  * Provides a clean interface for direct prop usage
@@ -28,10 +97,18 @@ export interface TextsProps extends DialogElementProps {
     count?: number;
     words?: Word<Pausing | string>[];
 }
+export type EntryTextsProps = BaseTextsProps & {
+    entry: NvlDialogEntry;
+    gameState: GameState;
+    words: Word<Pausing | string>[];
+    useTypeEffect: boolean;
+    isActive: boolean;
+};
+export declare function TextsPreview({ text, sentence, words, useTypeEffect, loop, restartDelay, cps, gameSpeed, pauseDuration, defaultColor, className, style, fontSize, fontWeight, fontWeightBold, fontFamily, onCompleted, ...props }: TextsPreviewProps): React.JSX.Element;
 export declare function RawTexts(props: BaseTextsProps): React.JSX.Element;
 /**
  * Context-based wrapper component
  * Provides integration with the sentence context
  */
-export declare function Texts(props: BaseTextsProps): React.JSX.Element;
+export declare function Texts(props: BaseTextsProps | EntryTextsProps): React.JSX.Element;
 export default Texts;

package/dist/game/player/elements/say/UIDialog.d.ts

@@ -6,7 +6,7 @@ import React from "react";
 import { DialogAction, DialogStateType, SayElementProps } from "./type";
 type DialogEvents = {
     "event:dialog.requestComplete": [];
-    "event:dialog.complete": [force: boolean];
+    "event:dialog.complete": [force?: boolean];
     "event:dialog.forceSkip": [];
     "event:dialog.onFlush": [];
     "event:dialog.simulateClick": [];
@@ -16,6 +16,7 @@ type DialogStateConfig = {
     action: DialogAction;
     evaluatedWords: Word<Pausing | string>[];
     gameState: GameState;
+    suppressInitialAnimation?: boolean;
 };
 export declare class DialogState {
     static Events: {
@@ -31,12 +32,15 @@ export declare class DialogState {
     private _count;
     private _forceSkipped;
     private _idle;
+    private _active;
     private autoForwardScheduler;
     constructor(config: DialogStateConfig);
     get state(): DialogStateType;
     get deps(): React.DependencyList;
     isIdle(): boolean;
     setIdle(idle: boolean): void;
+    isActive(): boolean;
+    setActive(active: boolean): this;
     /**
      * Only for dialog component to call
      *
@@ -68,5 +72,5 @@ export declare class DialogState {
     safeEmit(event: keyof DialogEvents, ...args: DialogEvents[keyof DialogEvents]): this;
     private scheduleAutoForward;
 }
-export default function PlayerDialog({ action, onFinished, useTypeEffect, gameState, }: Readonly<SayElementProps>): React.JSX.Element;
+export default function PlayerDialog({ action, onFinished, useTypeEffect, gameState, active, }: Readonly<SayElementProps>): React.JSX.Element;
 export {};

package/dist/game/player/elements/say/type.d.ts

@@ -4,6 +4,7 @@ import { Sentence } from "../../../nlcore/elements/character/sentence";
 import { Word } from "../../../nlcore/elements/character/word";
 import { Pausing } from "../../../nlcore/elements/character/pause";
 import React from "react";
+import type { HTMLMotionProps } from "motion/react";
 export interface SayElementProps {
     action: {
         sentence: Sentence | null;
@@ -19,12 +20,13 @@ export interface SayElementProps {
     onFinished?: (skiped?: boolean) => void;
     useTypeEffect?: boolean;
     gameState: GameState;
+    active?: boolean;
 }
 export interface IDialogProps {
 }
 export type DialogProps = {
-    children: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
+    children?: React.ReactNode;
+} & HTMLMotionProps<"div">;
 export type DialogElementProps = {
     children?: never;
 } & React.HTMLAttributes<HTMLDivElement>;

package/dist/game/player/elements/say/useDialog.d.ts

@@ -1,3 +1,4 @@
+import type { SentenceMetadata } from "../../../nlcore/elements/character/sentence";
 /**
  * Represents the context of a dialog, containing information about its completion status
  * and the text content.
@@ -9,6 +10,8 @@ export type DialogContext = {
     text: string;
     /** Whether the dialog is the narrator */
     isNarrator: boolean;
+    /** User-provided runtime metadata from the current sentence, if any */
+    metadata?: SentenceMetadata;
 };
 /**
  * A custom hook that provides access to the current dialog's state and content.

package/dist/game/player/elements/type.d.ts

@@ -8,16 +8,20 @@ import { GameState } from "../gameState";
 import { Storable } from "../../nlcore/elements/persistent/storable";
 import { LiveGame } from "../../nlcore/game/liveGame";
 import { INotificationsProps, NotificationsProps } from "./notification/type";
+import { INvlContainerProps } from "./nvl/type";
 export type Components<T extends Record<string, any>> = (props: Readonly<T>) => React.JSX.Element;
 export type SayComponent = Components<IDialogProps>;
 export type MenuComponent = Components<IUserMenuProps>;
 export type NotificationComponent = Components<INotificationsProps>;
+export type NvlDialogComponent = Components<INvlContainerProps>;
 export type ComponentsTypes = {
     say: SayComponent;
     menu: MenuComponent;
     notification: NotificationComponent;
+    nvlDialog: NvlDialogComponent;
 };
 export type { SayElementProps, MenuElementProps, NotificationsProps as INotificationProps, };
+export type { INvlContainerProps, NvlDialogItemRenderProps } from "./nvl/type";
 export type PlayerEventContext = {
     game: Game;
     gameState: GameState;
@@ -35,6 +39,12 @@ export interface PlayerProps {
      * only called each lifecycle once
      */
     onReady?: (ctx: PlayerEventContext) => void;
+    /**
+     * Once the internal preload pass is ready and the Player has committed that state.
+     *
+     * only called each lifecycle once
+     */
+    onPreloadedReady?: (ctx: PlayerEventContext) => void;
     /**
      * Once the game is ended
      *

package/dist/game/player/gameState.d.ts

@@ -10,6 +10,7 @@ import { Storable } from "../nlcore/elements/persistent/storable";
 import { Game } from "../nlcore/game";
 import { Clickable, MenuElement, TextElement } from "./gameState.type";
 import { Sentence } from "../nlcore/elements/character/sentence";
+import { type SceneSnapshot } from "../nlcore/action/actions/sceneAction";
 import { Logger } from "../../util/logger";
 import { Story } from "../nlcore/elements/story";
 import { LiveGame } from "../nlcore/game/liveGame";
@@ -24,6 +25,29 @@ import { Timelines } from "./Tasks";
 import { Notification, NotificationManager } from "./lib/notification";
 import { ActionHistoryManager } from "../../game/nlcore/action/actionHistory";
 import { GameHistoryManager } from "../../game/nlcore/action/gameHistory";
+import type { Character } from "../nlcore/elements/character";
+import type { TransformDefinitions } from "../nlcore/elements/transform/type";
+import type { NvlBlockOptions } from "../nlcore/action/actionTypes";
+import { type NormalizedCharacterPortraitConfig } from "../nlcore/elements/character/avatar";
+export type NvlDialogEntry = {
+    id: string;
+    actionId: string;
+    character: Character | null;
+    sentence: Sentence;
+    text: string;
+};
+export type NvlDialogPhase = "idle" | "typing" | "awaitAdvance";
+export type NvlState = {
+    active: boolean;
+    visible: boolean;
+    sessionId: string | null;
+    dialogs: NvlDialogEntry[];
+    options: NvlBlockOptions | null;
+    activeDialogId: string | null;
+    phase: NvlDialogPhase;
+    pendingAdvance: boolean;
+    isTyping: boolean;
+};
 type Legacy_PlayerStateElement = {
     texts: Clickable<TextElement>[];
     menus: Clickable<MenuElement, Chosen>[];
@@ -47,6 +71,23 @@ export type PlayerStateElement = {
     texts: Clickable<TextElement>[];
     menus: Clickable<MenuElement, Chosen>[];
 };
+export type NvlStateData = {
+    active: boolean;
+    visible: boolean;
+    sessionId: string | null;
+    options?: NvlBlockOptions | null;
+    activeDialogId?: string | null;
+    phase?: NvlDialogPhase;
+    pendingAdvance?: boolean;
+    dialogIds?: string[];
+    dialogs?: NvlDialogEntryData[];
+};
+export type NvlDialogEntryData = {
+    id: string;
+    actionId?: string;
+    text: string;
+    characterId: string | null;
+};
 export type PlayerStateData = {
     scenes: {
         sceneId: string;
@@ -61,6 +102,11 @@ export type PlayerStateData = {
     }[];
     audio: AudioManagerDataRaw;
     videos: [videoId: string, videoState: VideoStateRaw][];
+    nvlState?: NvlStateData;
+};
+export type PresentationSnapshot = {
+    scenes: SceneSnapshot[];
+    nvlState: NvlState;
 };
 interface StageUtils {
     update: () => void;
@@ -73,9 +119,16 @@ type GameStateEvents = {
     "event:state.player.skip": [force?: boolean];
     "event:state.player.lineEnd": [];
     "event:state.player.requestFlush": [];
+    "event:state.player.stageClick": [];
     "event.state.onExpose": [unknown, ExposedState[ExposedStateType]];
     "event:state.onRender": [];
     "event:state:flushPreloadedScenes": [];
+    "event:state.nvl.enter": [sessionId: string, options: NvlBlockOptions | null];
+    "event:state.nvl.exit": [];
+    "event:state.nvl.dialogComplete": [dialogId: string];
+    "event:state.nvl.dialogAppend": [entry: NvlDialogEntry];
+    "event:state.nvl.visibilityChange": [visible: boolean, options?: Partial<TransformDefinitions.CommonTransformProps>];
+    "event:state.nvl.change": [state: NvlState];
 };
 /**
  * Core game state management class
@@ -86,6 +139,8 @@ export declare class GameState {
         [K in keyof GameStateEvents]: K;
     };
     private state;
+    private nvlState;
+    private _suppressNextNvlTyping;
     currentHandling: CalledActionResult | null;
     stage: StageUtils;
     game: Game;
@@ -106,6 +161,8 @@ export declare class GameState {
     readonly actionHistory: ActionHistoryManager;
     readonly gameHistory: GameHistoryManager;
     pageRouter: null;
+    private stageClickBuffer;
+    private readonly nvlAdvanceWaiters;
     constructor(game: Game, stage: StageUtils);
     get deps(): number;
     addVideo(video: Video): this;
@@ -126,6 +183,7 @@ export declare class GameState {
     getSceneElements(): PlayerStateElement[];
     getLastScene(): Scene | null;
     getCurrentScene(): Scene | null;
+    findCurrentPortraitForCharacter(character: Character): NormalizedCharacterPortraitConfig | null;
     sceneExists(scene?: Scene): boolean;
     isSceneActive(scene: Scene): boolean;
     wait(ms: number): Promise<void>;
@@ -138,6 +196,78 @@ export declare class GameState {
     createMenu(menu: MenuData, afterChoose?: (choice: Chosen) => void, scene?: Scene): LiveGameEventToken & {
         prompt: null | string;
     };
+    /**
+     * Enter NVL mode
+     * @param options - Optional block options for transitions
+     */
+    enterNvlMode(options?: NvlBlockOptions | null): this;
+    /**
+     * Exit NVL mode
+     * @param options - Optional block options for transitions
+     */
+    exitNvlMode(options?: NvlBlockOptions | null): this;
+    /**
+     * Set NVL layer visibility without exiting NVL mode
+     * @param visible - Whether to show or hide the NVL layer
+     * @param options - Optional transition properties
+     */
+    setNvlVisibility(visible: boolean, options?: Partial<TransformDefinitions.CommonTransformProps>): this;
+    /**
+     * Append a dialog to the NVL dialog list
+     * @param entry - The dialog entry to append
+     */
+    appendNvlDialog(entry: NvlDialogEntry): this;
+    /**
+     * Remove a dialog from the NVL dialog list
+     * @param id - The dialog id to remove
+     */
+    removeNvlDialog(id: string): this;
+    /**
+     * Get current NVL dialogs
+     */
+    getNvlDialogs(): NvlDialogEntry[];
+    /**
+     * Check if currently in NVL mode
+     */
+    isNvlMode(): boolean;
+    /**
+     * Get NVL state
+     */
+    getNvlState(): NvlState;
+    /**
+     * Create a snapshot of the current NVL state.
+     */
+    createNvlSnapshot(): NvlState;
+    createPresentationSnapshot(): PresentationSnapshot;
+    /**
+     * Restore NVL state and refresh UI.
+     */
+    restoreNvlSnapshot(snapshot: NvlState): this;
+    restorePresentationSnapshot(snapshot: PresentationSnapshot): this;
+    /**
+     * Clear NVL dialogs
+     */
+    clearNvlDialogs(): this;
+    setNvlActiveDialog(dialogId: string | null, isTyping: boolean): this;
+    setNvlTyping(isTyping: boolean): this;
+    getNvlDialog(dialogId: string): NvlDialogEntry | null;
+    getActiveNvlDialogForAction(actionId: string): NvlDialogEntry | null;
+    getLatestNvlDialogForAction(actionId: string): NvlDialogEntry | null;
+    allocateNvlDialogId(actionId: string): string;
+    ensureNvlDialog(entry: NvlDialogEntry): {
+        created: boolean;
+        entry: NvlDialogEntry;
+    };
+    activateNvlDialog(dialogId: string, phase?: Exclude<NvlDialogPhase, "idle">, preserveProgress?: boolean): this;
+    waitForNvlAdvance(dialogId: string, resolve: () => void): LiveGameEventToken;
+    requestNvlAdvance(dialogId: string): "ignore" | "typing" | "advance";
+    requestNvlSkip(dialogId: string): "ignore" | "typing" | "advance";
+    completeNvlTyping(dialogId: string): boolean;
+    settleNvlDialog(dialogId: string): this;
+    suppressNextNvlTyping(): this;
+    consumeNvlTypingSuppression(): boolean;
+    recordStageClick(): this;
+    consumeStageClick(maxAgeMs?: number): boolean;
     createDisplayable(displayable: LogicAction.DisplayableElements, scene?: Scene | null, layer?: Layer | null): this;
     disposeDisplayable(displayable: LogicAction.DisplayableElements, scene?: Scene | null, layer?: Layer | null): this;
     forceReset(): void;
@@ -186,6 +316,10 @@ export declare class GameState {
     fromElementSnapshot(snapshot: PlayerStateElementSnapshot): PlayerStateElement;
     private removeElements;
     private resetLayers;
+    private syncNvlDerivedState;
+    private emitNvlStateChange;
+    private resolveNvlAdvance;
+    private isDisplayableVisible;
     private createWaitableAction;
     private sceneNotFound;
     private layerNotFound;

package/dist/game/player/lib/AudioManager.d.ts

@@ -21,6 +21,7 @@ export declare class AudioManager {
     private sound;
     private ready;
     private isReady;
+    private isInitializing;
     constructor(gameState: GameState);
     /**
      * Must be called ONCE on the client side to prepare audio subsystem.

package/dist/game/player/lib/ErrorFallback.d.ts

@@ -1,5 +1,9 @@
 import React, { ErrorInfo } from "react";
+type ErrorFallbackInfo = ErrorInfo & {
+    digest?: string;
+};
 export default function ErrorFallback({ error, errorInfo }: {
     error: Error;
-    errorInfo: ErrorInfo;
+    errorInfo: ErrorFallbackInfo;
 }): React.JSX.Element;
+export {};

package/dist/game/player/libElements.d.ts

@@ -4,9 +4,10 @@ import { Stage } from "./lib/PageRouter/Stage";
 import GameMenu from "./elements/menu/UIMenu/Menu";
 import Item from "./elements/menu/UIMenu/Item";
 import Notifications from "./elements/notification/Notifications";
-import Texts from "./elements/say/Sentence";
+import Texts, { TextsPreview } from "./elements/say/Sentence";
 import Nametag from "./elements/say/Nametag";
 import Dialog from "./elements/say/Dialog";
+import Avatar, { useAvatar } from "./elements/say/Avatar";
 import { useDialog } from "./elements/say/useDialog";
 import { useVoiceState } from "./elements/say/useVoiceState";
 import { Page, PageInjectContext } from "./lib/PageRouter/Page";
@@ -15,4 +16,10 @@ import { RootPath } from "./lib/PageRouter/router";
 import { FixedAspectRatioContainer } from "./lib/FixedAspectRatioContainer";
 import { useKeyBinding } from "./lib/keyMap";
 import { useLiveGame } from "./lib/useLiveGame";
-export { Isolated, usePreference, Stage, GameMenu, Item, Notifications, Texts, Nametag, Dialog, useDialog, useVoiceState, Page, Layout, LayoutRouterProvider, PageInjectContext, RootPath, FixedAspectRatioContainer, useKeyBinding, useLiveGame, };
+import { NvlContainer } from "./elements/nvl/NvlContainer";
+import { DefaultNvlContainer } from "./elements/nvl/DefaultNvlContainer";
+import { NvlDialogList, DefaultNvlDialogItem } from "./elements/nvl/NvlDialogList";
+import { NvlProvider, useNvl, useNvlDialogs, useIsNvlMode, useIsNvlVisible } from "./elements/nvl/NvlContext";
+export type { DialogAvatarContext } from "./elements/say/Avatar";
+export type { TextsPreviewInput, TextsPreviewLoop, TextsPreviewProps } from "./elements/say/Sentence";
+export { Isolated, usePreference, Stage, GameMenu, Item, Notifications, Texts, TextsPreview, Nametag, Dialog, Avatar, useAvatar, useDialog, useVoiceState, Page, Layout, LayoutRouterProvider, PageInjectContext, RootPath, FixedAspectRatioContainer, useKeyBinding, useLiveGame, NvlContainer, DefaultNvlContainer, NvlDialogList, DefaultNvlDialogItem, NvlProvider, useNvl, useNvlDialogs, useIsNvlMode, useIsNvlVisible, };

package/dist/game/player/provider/game-state.d.ts

@@ -21,4 +21,5 @@ export declare function GameProvider({ children, game }: {
  * @throws Error if used outside of GameProvider
  */
 export declare function useGame(): GameContextType;
+export declare function useOptionalGame(): GameContextType | null;
 export {};