narraleaf-react 0.19.2 → 0.20.0

package/dist/game/nlcore/elements/displayable/puppet.d.ts

@@ -0,0 +1,230 @@
+import type { TransformDefinitions } from "../../elements/transform/type";
+import { Displayable } from "../../elements/displayable/displayable";
+import { EventfulDisplayable } from "../../../player/elements/displayable/type";
+import { Chained, Proxied } from "../../action/chain";
+import { LogicAction } from "../../action/logicAction";
+import { Layer } from "../../elements/layer";
+import type { LiveGameEventToken } from "../../types";
+import type { PuppetSize, PuppetStatus } from "../../game/puppet/puppetBackend";
+export type PuppetConfig = {
+    backend: string;
+    src: string;
+    options: Record<string, unknown>;
+    size: PuppetSize | null;
+    className?: string;
+    layer: Layer | undefined;
+};
+export interface IPuppetUserConfig extends TransformDefinitions.ImageTransformProps {
+    /**
+     * Name of the registered backend that draws this puppet.
+     *
+     * See {@link import("../../game").Game.registerPuppetBackend}.
+     */
+    backend: string;
+    /**
+     * The resource descriptor handed to the backend, passed through verbatim.
+     *
+     * **A puppet cannot change its `src`.** The backend's instance lives for as long as the element
+     * is on stage, and swapping the model underneath it would mean tearing that instance down while
+     * the engine's box, transform and saved state stay put. Use a second element instead.
+     */
+    src: string;
+    /** Backend-specific options, passed through verbatim. */
+    options: Record<string, unknown>;
+    /**
+     * The logical size of the box, in pixels. Defaults to the stage size.
+     *
+     * The backend scales its own content inside the box; the element's transform (position, zoom,
+     * scale, rotation) applies on top of it, exactly as it would to an image.
+     */
+    size: PuppetSize | null;
+    /**
+     * Class names for the box, applied to the element the transition wrapper renders — the one
+     * carrying the box's `position: relative` and its width and height.
+     *
+     * That is the **parent** of the container handed to
+     * {@link import("../../game/puppet/puppetBackend").PuppetBackend.mount}, not the container
+     * itself: the backend owns the inside of the box and the engine empties it on dispose, so
+     * anything styled here has to sit outside it. Note also that the wrapper above it — the one the
+     * transform is written to — is not this element, so a class that sets `transform` here will be
+     * overwritten frame by frame.
+     */
+    className?: string;
+    /** Layer of the puppet. */
+    layer?: Layer;
+    /** Initial motion. Part of the saved state, so it survives a save/load round trip. */
+    motion: string | null;
+    /** Initial expression. */
+    expression: string | null;
+    /** Initial skin. */
+    skin: string | null;
+    /** Initial numeric parameters. */
+    params: Record<string, number>;
+    /** Initial string slots. */
+    slots: Record<string, string | null>;
+}
+/** How the story treats a one-shot {@link Puppet.command}. */
+export type PuppetCommandOptions = {
+    /**
+     * Wait for the backend to finish the command before the story moves on.
+     *
+     * Off by default. The engine cannot tell a motion worth a beat from a parameter nudge, and a
+     * backend that never resolves would otherwise park the story forever; opting in makes the wait
+     * the author's decision, and only where they meant it. A waiting command is skippable like any
+     * other timed action.
+     *
+     * @default false
+     */
+    await?: boolean;
+};
+export type PuppetDataRaw = {
+    state: Record<string, any>;
+    transformState: Record<string, any>;
+};
+/**
+ * A displayable whose interior is drawn by a backend the host registered.
+ *
+ * The engine gives a puppet everything a displayable has — a position on a layer, a transform, an
+ * opacity, an entry in the saved game — and nothing else. What appears inside its box is decided
+ * entirely by {@link import("../../game/puppet/puppetBackend").PuppetBackend}, which the engine
+ * neither ships nor understands.
+ *
+ * When no backend answers to `config.backend`, the element degrades quietly: it keeps its place,
+ * its transform and its state, warns once, and draws nothing.
+ *
+ * @example
+ * ```ts
+ * const alice = new Puppet({
+ *     backend: "my-renderer",
+ *     src: "models/alice/alice.model.json",
+ *     size: {width: 900, height: 1200},
+ *     position: {xalign: 0.3},
+ * });
+ *
+ * scene.action([
+ *     alice.show({duration: 400}),
+ *     alice.setMotion("idle"),
+ *     alice.setExpression("smile"),
+ *     alice.command("playMotion", {id: "wave"}, {await: true}),
+ * ]);
+ * ```
+ */
+export declare class Puppet extends Displayable<PuppetDataRaw, Puppet, TransformDefinitions.ImageTransformProps> implements EventfulDisplayable {
+    constructor(config: Partial<IPuppetUserConfig> & {
+        backend: string;
+        src: string;
+    });
+    /**
+     * Request a named motion — usually the loop the model settles into.
+     *
+     * This is persistent state, not a one-shot: it is saved, and re-applied in full the next time
+     * the model mounts. Pass `null` to clear it. A motion meant to play once and end belongs in
+     * {@link Puppet.command}.
+     *
+     * The story does not wait for the backend to take the pose.
+     * @chainable
+     * @example
+     * ```ts
+     * alice.setMotion("idle");
+     * ```
+     */
+    setMotion(motion: string | null): Proxied<Puppet, Chained<LogicAction.Actions>>;
+    /**
+     * Request a named expression, or `null` to clear it. Persistent state, like the motion.
+     * @chainable
+     * @example
+     * ```ts
+     * alice.setExpression("smile");
+     * ```
+     */
+    setExpression(expression: string | null): Proxied<Puppet, Chained<LogicAction.Actions>>;
+    /**
+     * Request a named skin or costume, or `null` to clear it. Persistent state, like the motion.
+     * @chainable
+     * @example
+     * ```ts
+     * alice.setSkin("winter");
+     * ```
+     */
+    setSkin(skin: string | null): Proxied<Puppet, Chained<LogicAction.Actions>>;
+    /**
+     * Set one numeric parameter, leaving every other parameter as it stands.
+     *
+     * What an id means is the backend's business — a rig parameter, a bone override, a blend weight.
+     * The engine only remembers it, saves it, and hands the whole map back on a load.
+     * @chainable
+     * @example
+     * ```ts
+     * alice.setParam("ParamAngleX", 12);
+     * ```
+     */
+    setParam(id: string, value: number): Proxied<Puppet, Chained<LogicAction.Actions>>;
+    /**
+     * Set one free string slot, leaving every other slot as it stands. `null` clears that slot.
+     *
+     * Slots are for the named things `motion` / `expression` / `skin` do not cover — an attachment
+     * point, a swapped-in prop, whatever a particular renderer calls its own.
+     * @chainable
+     * @example
+     * ```ts
+     * alice.setSlot("prop", "umbrella");
+     * ```
+     */
+    setSlot(id: string, value: string | null): Proxied<Puppet, Chained<LogicAction.Actions>>;
+    /**
+     * Send the backend a command the engine neither models nor interprets.
+     *
+     * `name` and `payload` are forwarded verbatim. This is the escape hatch for everything
+     * {@link import("../../game/puppet/puppetBackend").PuppetState} deliberately leaves out — a
+     * motion that plays once and ends, a hit test, lip sync. None of it is saved, so a command is
+     * not restored by a load and not taken back by an undo; anything that has to survive either
+     * belongs in the state, through the `set*` methods above.
+     *
+     * **The story does not wait unless it is asked to.** See {@link PuppetCommandOptions}.
+     * @chainable
+     * @example
+     * ```ts
+     * alice.command("playMotion", {id: "wave"});                  // the story moves straight on
+     * alice.command("playMotion", {id: "bow"}, {await: true});    // ...and here it waits for it
+     * ```
+     */
+    command(name: string, payload?: unknown, options?: PuppetCommandOptions): Proxied<Puppet, Chained<LogicAction.Actions>>;
+    /**
+     * What the backend drawing this puppet is currently doing.
+     *
+     * Two of the five are worth acting on. `"missing-backend"` means nothing answers to
+     * `config.backend`, and `"error"` means the backend threw or the model failed to load; in both
+     * cases the element is still on stage, still transforming and still saving — it is simply not
+     * being drawn. The engine cannot decide what that should mean for a game, so it reports rather
+     * than intervenes.
+     *
+     * The status describes the live instance and is not part of the saved game: a load re-mounts,
+     * and the status starts over from `"unmounted"`.
+     * @example
+     * ```ts
+     * if (alice.getStatus() === "missing-backend") {
+     *     // the renderer this project depends on was never registered
+     * }
+     * ```
+     */
+    getStatus(): PuppetStatus;
+    /**
+     * Listen for this puppet's status changing, receiving the new status.
+     *
+     * A backend fails asynchronously — the element mounts, then the model does or does not load — so
+     * {@link Puppet.getStatus} alone cannot answer "did my renderer come up". Subscribe to be told.
+     * Dispose the returned token to stop listening.
+     * @example
+     * ```ts
+     * const token = alice.onStatusChange((status) => {
+     *     if (status === "error") console.warn("Alice is not being drawn");
+     * });
+     * ```
+     */
+    onStatusChange(listener: (status: PuppetStatus) => void): LiveGameEventToken;
+    /**
+     * Override the layer used to render this puppet.
+     * @param layer - The layer to assign to the puppet.
+     */
+    useLayer(layer: Layer): this;
+}

package/dist/game/nlcore/elements/displayable/text.d.ts

@@ -49,6 +49,10 @@ export interface ITextUserConfig extends TransformDefinitions.TextTransformProps
      */
     layer?: Layer;
 }
+export type TextDataRaw = {
+    state: Record<string, any>;
+    transformState: Record<string, any>;
+};
 export declare class Text extends Displayable<TextDataRaw, Text, TransformDefinitions.TextTransformProps> implements EventfulDisplayable {
     constructor(config: Partial<ITextUserConfig>);
     constructor(text: string, config?: Partial<ITextUserConfig>);

package/dist/game/nlcore/elements/layer.d.ts

@@ -13,6 +13,10 @@ export interface ILayerUserConfig extends TransformDefinitions.ImageTransformPro
      */
     zIndex: number;
 }
+export type LayerDataRaw = {
+    state: Record<string, any>;
+    transformState: Record<string, any>;
+};
 export declare class Layer extends Displayable<LayerDataRaw, Layer, TransformDefinitions.ImageTransformProps> implements EventfulDisplayable {
     /**
      * Create a layer that can host displayables.

package/dist/game/nlcore/elements/persistent/serialize.d.ts

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

package/dist/game/nlcore/elements/persistent/storable.d.ts

@@ -26,7 +26,18 @@ export type StorableRestore = {
     /** The namespace keys whose contents were replaced. */
     namespaces: string[];
 };
+export type StorableEvents = {
+    "event:storable.change": [StorableChange];
+    "event:storable.restore": [StorableRestore];
+};
 export declare class Namespace<T extends NameSpaceContent<keyof T>> {
+    /**
+     * Whether a value can be written to a save.
+     *
+     * Plain objects and arrays may nest freely; the leaves have to be a primitive, `null`,
+     * `undefined` or a `Date`. A value that refers back to itself, or one that nests past 64
+     * levels, is not serializable — both report `false` rather than recursing forever.
+     */
     static isSerializable(value: any): boolean;
     name: string;
     constructor(name: string, initContent: T, key?: string);

package/dist/game/nlcore/elements/persistent/type.d.ts

@@ -1,10 +1,52 @@
 export type StorableData<K extends string = string> = {
     [key in K]: number | boolean | string | StorableData | StorableData[] | undefined | null | Date;
 };
-export type StorableType = BaseStorableType | Record<string, BaseStorableType> | Array<BaseStorableType>;
+/**
+ * A value that stands on its own, with nothing inside it: a JSON primitive, or a `Date`.
+ */
+export type BaseStorableType = number | boolean | string | undefined | null | Date;
+export type BaseStorableTypeName = "any" | "date";
+/**
+ * Anything a namespace can hold.
+ *
+ * Plain objects and arrays nest freely — `{party: [{name: "yuko", metAt: new Date()}]}` is a
+ * single stored value, and a `Date` buried anywhere inside it comes back as a `Date`. Only the
+ * leaves are constrained, to {@link BaseStorableType}: a save file is JSON, and a class
+ * instance, a `Map`, a function or a symbol has no representation in it.
+ *
+ * Two limits are enforced when the value is written to a save rather than when it is assigned,
+ * because that is when they start to matter:
+ *
+ * - nesting is capped at 64 levels;
+ * - a value that refers back to itself is rejected outright. A save is a tree; a cycle has no
+ *   place in one, and cutting the back-edge would silently save a different object graph than
+ *   the one the author built.
+ *
+ * Reference identity is not part of the value. Storing the same object at two positions saves
+ * two copies, and loading produces two independent objects — the same bargain `JSON.stringify`
+ * makes.
+ */
+export type StorableType = BaseStorableType | {
+    [key: string]: StorableType;
+} | StorableType[];
+/**
+ * A position inside a stored value: the property keys walked from its root. `[]` is the value
+ * itself, `["party", 0, "metAt"]` is the `metAt` of the first element of `party`.
+ *
+ * Array indices are written as numbers and object keys as strings, but both are read back with
+ * plain property access, so the distinction is presentational.
+ */
+export type StorablePath = (string | number)[];
 /**
  * A single stored value as it appears in a saved game. Values are tagged on the way out so
- * that types JSON cannot express (currently `Date`) survive the round-trip.
+ * that types JSON cannot express (currently `Date`, and a nested `undefined`) survive the
+ * round-trip.
+ *
+ * `data` is plain JSON. The two types JSON loses are not encoded in-band — no sentinel object
+ * is inserted that a stored value could collide with — but named by position in `dates` and
+ * `undefineds`, which the loader walks to put the real values back. Both are absent when there
+ * is nothing to name, so a value holding neither serializes exactly as it did before this
+ * scheme existed, and a save written before it loads unchanged.
  *
  * This is part of the on-disk save format rather than an implementation detail: it is what
  * {@link SavedGame}'s `store` actually contains. Read it through `Namespace`, never by hand.
@@ -12,6 +54,10 @@ export type StorableType = BaseStorableType | Record<string, BaseStorableType> |
 export type WrappedStorableData<T extends StorableType = any> = {
     type: BaseStorableTypeName;
     data: T;
+    /** Positions in `data` that held a `Date`, stored as an ISO 8601 string. */
+    dates?: StorablePath[];
+    /** Positions in `data` that held `undefined`, stored as `null`. */
+    undefineds?: StorablePath[];
 };
 /**
  * One namespace's contents in a saved game: every value wrapped by {@link WrappedStorableData}.
@@ -19,3 +65,6 @@ export type WrappedStorableData<T extends StorableType = any> = {
 export type SerializedNamespaceData = {
     [key: string]: WrappedStorableData;
 };
+export type NameSpaceContent<T extends string | number | symbol> = {
+    [K in T]?: StorableType;
+};

package/dist/game/nlcore/elements/persistent.d.ts

@@ -1,9 +1,18 @@
 import { Actionable } from "../action/actionable";
+import { StorableType } from "../elements/persistent/type";
+import { Chained, Proxied } from "../action/chain";
+import { LogicAction } from "../game";
 import { BooleanValueKeyOf, StringKeyOf } from "../../../util/data";
 import { Lambda } from "../elements/condition";
 import { Word } from "../elements/character/word";
 import { DynamicWord, DynamicWordResult } from "../elements/character/sentence";
 import { LambdaHandler } from "../elements/type";
+export type PersistentContent = {
+    [K in string]: StorableType;
+};
+export type DynamicPersistentData = {
+    [K in string]: StorableType;
+};
 export declare class Persistent<T extends PersistentContent> extends Actionable<null> {
     constructor(namespace: string, defaultContent: T);
     /**
@@ -13,15 +22,15 @@ export declare class Persistent<T extends PersistentContent> extends Actionable<
      * @param value - The value to set
      * @returns A chainable persistent action
      */
-    set<K extends StringKeyOf<T>>(key: K, value: T[K]): ChainedPersistent<T>;
-    set<K extends StringKeyOf<T>>(key: K, handler: (value: T[K]) => T[K]): ChainedPersistent<T>;
+    set<K extends StringKeyOf<T>>(key: K, value: T[K]): Proxied<Persistent<T>, Chained<LogicAction.Actions>>;
+    set<K extends StringKeyOf<T>>(key: K, handler: (value: T[K]) => T[K]): Proxied<Persistent<T>, Chained<LogicAction.Actions>>;
     /**
      * Create an action to assign a value to the persistent storage
      * @chainable
      * @param value - The value to assign
      * @returns A chainable persistent action
      */
-    assign(value: Partial<T> | ((value: T) => Partial<T>)): ChainedPersistent<T>;
+    assign(value: Partial<T> | ((value: T) => Partial<T>)): Proxied<Persistent<T>, Chained<LogicAction.Actions>>;
     /**
      * Determine whether the values are equal, can be used in {@link Condition}
      * @example

package/dist/game/nlcore/elements/scene.d.ts

@@ -37,6 +37,9 @@ export type JumpConfig = {
 };
 type ChainableAction = Proxied<LogicAction.GameElement, Chained<LogicAction.Actions>> | LogicAction.Actions;
 type ChainedScene = Proxied<Scene, Chained<LogicAction.Actions>>;
+export type SceneDataRaw = {
+    state: Record<string, any>;
+};
 export declare class Scene extends Constructable<LogicAction.Actions, Scene> {
     get local(): Persistent<any>;
     get background(): Image;

package/dist/game/nlcore/elements/script.d.ts

@@ -15,6 +15,7 @@ export interface ScriptCtx {
     $: NamespaceGetter;
 }
 type ScriptRun = (ctx: ScriptCtx) => ScriptCleaner | void;
+export type ScriptCleaner = () => void;
 export declare class Script extends Actionable<object> {
     /**
      * Create a script action from a handler.

package/dist/game/nlcore/elements/sound.d.ts

@@ -7,6 +7,9 @@ export declare enum SoundType {
     Bgm = "bgm",
     Sound = "sound"
 }
+export type SoundDataRaw = {
+    state: Record<string, any>;
+};
 export type VoiceIdMap = Record<string | number, string | Sound>;
 export type VoiceSrcGenerator = (id: string | number) => string | Sound;
 export interface ISoundUserConfig {

package/dist/game/nlcore/elements/story.d.ts

@@ -18,6 +18,7 @@ export interface IStoryConfig {
      */
     camera?: Camera;
 }
+export type ElementStateRaw = Record<string, any>;
 export declare class Story extends Constructable<SceneAction<"scene:action">, Story> {
     constructor(name: string, config?: Partial<IStoryConfig>);
     /**

package/dist/game/nlcore/elements/transform/position.d.ts

@@ -1,3 +1,4 @@
+import { CSSProps } from "../../elements/transition/type";
 export declare enum CommonPositionType {
     Left = "left",
     Center = "center",
@@ -19,6 +20,12 @@ export type OffsetPosition = {
     xoffset: number;
     yoffset: number;
 };
+export type D2Position<X = any, Y = any> = {
+    x: UnknownAble<X>;
+    y: UnknownAble<Y>;
+    xoffset: UnknownAble<number>;
+    yoffset: UnknownAble<number>;
+};
 export type RawPosition = CommonPositionType | (Partial<Coord2DPosition> & {
     xalign?: never;
     yalign?: never;
@@ -28,6 +35,45 @@ export type RawPosition = CommonPositionType | (Partial<Coord2DPosition> & {
 });
 type Unknown = typeof PositionUtils.Unknown;
 type UnknownAble<T> = T | Unknown;
+export declare class PositionUtils {
+    static readonly Unknown: unique symbol;
+    static isUnknown(arg: any): arg is typeof PositionUtils.Unknown;
+    static D2PositionToCSS(pos: D2Position, invertX?: boolean, invertY?: boolean, dimensions?: {
+        width: number;
+        height: number;
+    }): CSSProps;
+    /**
+     * Resolve a position component (base position + pixel offset) to a CSS length.
+     *
+     * When the design {@link dimension} (the game's base width or height for this axis) is
+     * known, the base position and its offset are folded into a single percentage of that
+     * dimension. This keeps offsets resolution-independent — they scale with the stage just
+     * like sizes do — and lets `motion` interpolate the result: a mixed `calc(% + px)` value
+     * cannot be animated on its percentage part, so the offset would otherwise be the only
+     * animatable piece and any align change would be silently dropped.
+     *
+     * Without a dimension it falls back to the legacy `calc(<pos> + <offset>px)` form.
+     */
+    static calc(pos: number | string, offset?: UnknownAble<number>, dimension?: number): string;
+    /**
+     * Express a position component as a percentage of the given design dimension.
+     * Accepts an existing percentage string (e.g. `"50%"`) or a pixel number, and returns
+     * `null` for any other form so the caller can fall back to the legacy representation.
+     */
+    static toPercent(pos: number | string, dimension: number): number | null;
+    static toCoord2D(pos: IPosition | D2Position): Coord2D;
+    static orUnknown<T>(arg: T | UnknownAble<T> | undefined): T | Unknown;
+    static mergePosition(a: IPosition, b: IPosition): Coord2D;
+    static serializePosition(pos: IPosition): D2Position;
+    static isRawCommonPositionType(arg: any): arg is CommonPositionType;
+    static isRawCoord2DPosition(arg: any): arg is Partial<Coord2DPosition>;
+    static isRawAlignPosition(arg: any): arg is Partial<AlignPosition>;
+    static isRawPosition(arg: any): arg is RawPosition;
+    static isPosition(arg: any): arg is IPosition;
+    static rawPositionToCoord2D(arg: any): Coord2D;
+    static tryParsePosition(arg: any): IPosition;
+    static wrap(def: CSSProps): CSSProps;
+}
 export declare class CommonPosition implements IPosition {
     static Positions: typeof CommonPositionType;
     static isCommonPositionType(arg: any): arg is CommonPosition;

package/dist/game/nlcore/elements/vfx.d.ts

@@ -1,4 +1,6 @@
 import { Actionable } from "../action/actionable";
+import { Chained, Proxied } from "../action/chain";
+import { LogicAction } from "../game";
 import type { TransformDefinitions } from "../elements/transform/type";
 /**
  * How the overlay video is composited onto the stage.
@@ -25,6 +27,13 @@ export type VfxFadeOptions = {
     duration?: number;
     easing?: TransformDefinitions.EasingDefinition;
 };
+export type VfxState = {
+    display: boolean;
+    paused: boolean;
+};
+export type VfxStateRaw = {
+    state: VfxState;
+};
 /**
  * A full-screen looping video overlay for particle and ambience effects
  * (falling petals, light dust, rain, snow, fog, light flares).
@@ -55,7 +64,7 @@ export declare class Vfx extends Actionable<VfxStateRaw> {
      * already shown is idempotent (the fade-in is re-applied).
      * @chainable
      */
-    show(options?: VfxFadeOptions): ChainedVfx;
+    show(options?: VfxFadeOptions): Proxied<Vfx, Chained<LogicAction.Actions>>;
     /**
      * Fade the overlay out, then stop playback and remove it from the stage.
      *
@@ -63,17 +72,17 @@ export declare class Vfx extends Actionable<VfxStateRaw> {
      * not shown is a no-op (a weak warning is logged).
      * @chainable
      */
-    hide(options?: VfxFadeOptions): ChainedVfx;
+    hide(options?: VfxFadeOptions): Proxied<Vfx, Chained<LogicAction.Actions>>;
     /**
      * Freeze the overlay on its current frame.
      * @chainable
      */
-    pause(): ChainedVfx;
+    pause(): Proxied<Vfx, Chained<LogicAction.Actions>>;
     /**
      * Continue playback from the current frame.
      * @chainable
      */
-    resume(): ChainedVfx;
+    resume(): Proxied<Vfx, Chained<LogicAction.Actions>>;
     /**
      * Adjust the playback speed (e.g. `0.5` for slow drifting).
      *
@@ -81,5 +90,5 @@ export declare class Vfx extends Actionable<VfxStateRaw> {
      * returns to `config.playbackRate`.
      * @chainable
      */
-    setPlaybackRate(rate: number): ChainedVfx;
+    setPlaybackRate(rate: number): Proxied<Vfx, Chained<LogicAction.Actions>>;
 }

package/dist/game/nlcore/elements/video.d.ts

@@ -1,8 +1,16 @@
 import { Actionable } from "../action/actionable";
+import { Chained, Proxied } from "../action/chain";
+import { LogicAction } from "../game";
 export type VideoConfig = {
     src: string;
     muted: boolean;
 };
+export type VideoState = {
+    display: boolean;
+};
+export type VideoStateRaw = {
+    state: VideoState;
+};
 export declare class Video extends Actionable<VideoStateRaw> {
     /**
      * Create a video element with source and optional mute flag.
@@ -17,12 +25,12 @@ export declare class Video extends Actionable<VideoStateRaw> {
      * Show the video element.
      * @chainable
      */
-    show(): ChainedVideo;
+    show(): Proxied<Video, Chained<LogicAction.Actions>>;
     /**
      * Hide the video element.
      * @chainable
      */
-    hide(): ChainedVideo;
+    hide(): Proxied<Video, Chained<LogicAction.Actions>>;
     /**
      * Play the video and wait until it finishes.
      * @chainable
@@ -31,24 +39,24 @@ export declare class Video extends Actionable<VideoStateRaw> {
      * video.play();
      * ```
      */
-    play(): ChainedVideo;
+    play(): Proxied<Video, Chained<LogicAction.Actions>>;
     /**
      * Pause the video, keeping its current position.
      * @chainable
      */
-    pause(): ChainedVideo;
+    pause(): Proxied<Video, Chained<LogicAction.Actions>>;
     /**
      * Resume playback from the current position.
      *
      * Unlike {@link play}, this does not wait for the video to finish.
      * @chainable
      */
-    resume(): ChainedVideo;
+    resume(): Proxied<Video, Chained<LogicAction.Actions>>;
     /**
      * Stop the video: pause it and end any pending {@link play} so the story continues.
      * @chainable
      */
-    stop(): ChainedVideo;
+    stop(): Proxied<Video, Chained<LogicAction.Actions>>;
     /**
      * Seek to a specific time (in seconds).
      * @chainable
@@ -57,5 +65,5 @@ export declare class Video extends Actionable<VideoStateRaw> {
      * video.seek(3);
      * ```
      */
-    seek(time: number): ChainedVideo;
+    seek(time: number): Proxied<Video, Chained<LogicAction.Actions>>;
 }

package/dist/game/nlcore/game/liveGame.d.ts

@@ -1,3 +1,5 @@
+import { Character } from "../elements/character";
+import { Sentence } from "../elements/character/sentence";
 import { Storable } from "../elements/persistent/storable";
 import { Story } from "../elements/story";
 import { Game } from "../game";
@@ -9,6 +11,51 @@ import { EventDispatcher } from "../../../util/data";
 import { GameState } from "../../player/gameState";
 import { GameHistory } from "../action/gameHistory";
 import { StackModel, StackSnapshot } from "../action/stackModel";
+export type LiveGameEvent = {
+    "event:character.prompt": [
+        {
+            /**
+             * The character who says the sentence
+             */
+            character: Character | null;
+            /**
+             * The sentence said by the character
+             */
+            sentence: Sentence;
+            /**
+             * The text of the sentence
+             */
+            text: string;
+        }
+    ];
+    "event:menu.choose": [
+        {
+            /**
+             * The sentence selected by the player
+             */
+            sentence: Sentence;
+            /**
+             * The text of the sentence
+             */
+            text: string;
+        }
+    ];
+    "event:action.current": [
+        {
+            /**
+             * The id of the action that just began executing (as assigned by the story compiler),
+             * or null for an action with no id. Fires for every executed action, including those
+             * inside parallel/async branches — subscribers that only care about top-level lines
+             * should filter by their own id set.
+             */
+            actionId: string | null;
+            /**
+             * The action's type (e.g. `"character:say"`).
+             */
+            actionType: string | null;
+        }
+    ];
+};
 export declare class LiveGame {
     static DefaultNamespaces: {
         game: {};