narraleaf-react 0.31.4 → 0.33.0

package/dist/game/nlcore/action/actionTypes.d.ts

@@ -21,11 +21,13 @@ export declare const DisplayableActionTypes: {
     readonly action: "displayable:action";
     readonly applyTransform: "displayable:applyTransform";
     readonly applyTransition: "displayable:applyTransition";
+    readonly applyLoop: "displayable:applyLoop";
+    readonly stopLoop: "displayable:stopLoop";
     readonly init: "displayable:init";
     readonly bringToFront: "displayable:bringToFront";
 };
 export type DisplayableActionContentType<TransitionType extends Transition = Transition> = {
-    [K in typeof DisplayableActionTypes[keyof typeof DisplayableActionTypes]]: K extends "displayable:applyTransform" ? [Transform] : K extends "displayable:applyTransition" ? [TransitionType, ((transition: TransitionType) => TransitionType)?] : K extends "displayable:init" ? [scene: Scene | null, layer: Layer | null, isElement?: boolean] : K extends "displayable:bringToFront" ? [] : any;
+    [K in typeof DisplayableActionTypes[keyof typeof DisplayableActionTypes]]: K extends "displayable:applyTransform" ? [Transform] : K extends "displayable:applyTransition" ? [TransitionType, ((transition: TransitionType) => TransitionType)?] : K extends "displayable:applyLoop" ? [Transform, TransformDefinitions.LoopOptions?] : K extends "displayable:stopLoop" ? [TransformDefinitions.LoopStopOptions?] : K extends "displayable:init" ? [scene: Scene | null, layer: Layer | null, isElement?: boolean] : K extends "displayable:bringToFront" ? [] : any;
 };
 export declare const CharacterActionTypes: {
     readonly say: "character:say";
@@ -147,6 +149,7 @@ export type LayerActionContentType = {
 };
 export declare const VideoActionTypes: {
     readonly action: "video:action";
+    readonly preload: "video:preload";
     readonly show: "video:show";
     readonly hide: "video:hide";
     readonly play: "video:play";
@@ -156,10 +159,11 @@ export declare const VideoActionTypes: {
     readonly seek: "video:seek";
 };
 export type VideoActionContentType = {
-    [K in typeof VideoActionTypes[keyof typeof VideoActionTypes]]: K extends "video:action" ? any : K extends "video:show" | "video:hide" | "video:play" | "video:pause" | "video:stop" | "video:resume" ? [] : K extends "video:seek" ? [number] : any;
+    [K in typeof VideoActionTypes[keyof typeof VideoActionTypes]]: K extends "video:action" ? any : K extends "video:preload" | "video:show" | "video:hide" | "video:play" | "video:pause" | "video:stop" | "video:resume" ? [] : K extends "video:seek" ? [number] : any;
 };
 export declare const VfxActionTypes: {
     readonly action: "vfx:action";
+    readonly preload: "vfx:preload";
     readonly show: "vfx:show";
     readonly hide: "vfx:hide";
     readonly pause: "vfx:pause";
@@ -167,7 +171,7 @@ export declare const VfxActionTypes: {
     readonly setRate: "vfx:setRate";
 };
 export type VfxActionContentType = {
-    [K in typeof VfxActionTypes[keyof typeof VfxActionTypes]]: K extends "vfx:action" ? any : K extends "vfx:show" | "vfx:hide" ? [VfxFadeOptions?] : K extends "vfx:pause" | "vfx:resume" ? [] : K extends "vfx:setRate" ? [number] : any;
+    [K in typeof VfxActionTypes[keyof typeof VfxActionTypes]]: K extends "vfx:action" ? any : K extends "vfx:show" | "vfx:hide" ? [VfxFadeOptions?] : K extends "vfx:preload" | "vfx:pause" | "vfx:resume" ? [] : K extends "vfx:setRate" ? [number] : any;
 };
 export declare const PuppetActionTypes: {
     readonly action: "puppet:action";

package/dist/game/nlcore/action/actions/displayableAction.d.ts

@@ -11,16 +11,44 @@ import { Layer } from "../../elements/layer";
 import { LogicAction } from "../../action/logicAction";
 import { ActionExecutionInjection, ExecutedActionResult } from "../../action/action";
 import { Story } from "../../elements/story";
+import type { TransformDefinitions } from "../../elements/transform/type";
 export declare class DisplayableAction<T extends Values<typeof DisplayableActionTypes> = Values<typeof DisplayableActionTypes>, Self extends Displayable<any, any, any> = Displayable<any, any>, TransitionType extends Transition = Transition> extends TypedAction<DisplayableActionContentType<TransitionType>, T, Self> {
     static ActionTypes: {
         readonly action: "displayable:action";
         readonly applyTransform: "displayable:applyTransform";
         readonly applyTransition: "displayable:applyTransition";
+        readonly applyLoop: "displayable:applyLoop";
+        readonly stopLoop: "displayable:stopLoop";
         readonly init: "displayable:init";
         readonly bringToFront: "displayable:bringToFront";
     };
     executeAction(gameState: GameState, injection: ActionExecutionInjection): ExecutedActionResult;
     applyTransform(state: GameState, element: Displayable<any, any>, transform: Transform, injection: ActionExecutionInjection, onFinished?: () => void): Awaitable<CalledActionResult, CalledActionResult>;
+    /**
+     * Start a looping transform on the element, and let the story carry straight on.
+     *
+     * The one action here that resolves without waiting for anything, because there is nothing to
+     * wait for: the motion repeats until something ends it. Nothing is attached to a timeline and
+     * nothing is left unsettled on the stack — a loop is a property the element carries (see
+     * {@link Displayable.loop}), so it is the element's binding, not this action, that a save and a
+     * remount read.
+     */
+    applyLoop(state: GameState, element: Displayable<any, any>, transform: Transform, options: TransformDefinitions.LoopOptions | undefined, injection: ActionExecutionInjection): Awaitable<CalledActionResult>;
+    /**
+     * End the element's looping transform and ease it back to the pose it kept underneath.
+     *
+     * Unlike {@link DisplayableAction.applyLoop} this *is* awaited — the way back has a duration,
+     * even when that duration is zero.
+     */
+    stopLoop(state: GameState, element: Displayable<any, any>, options: TransformDefinitions.LoopStopOptions | undefined, injection: ActionExecutionInjection): Awaitable<CalledActionResult>;
+    /**
+     * Put an element's loop binding back to what it was, and make the running motion agree.
+     *
+     * Both halves are needed and neither is enough: the binding is what a save and a remount read,
+     * the motion is what the player sees. Undoing past a `loop()` has to stop a motion that is
+     * running right now; undoing past a `stopLoop()` has to start one that is not.
+     */
+    private static restoreLoop;
     applyTransition(state: GameState, element: Displayable<any, any>, transition: TransitionType, injection: ActionExecutionInjection, onFinished?: () => void): Awaitable<CalledActionResult, CalledActionResult>;
     initDisplayable(state: GameState, scene: Scene | null, element: Displayable<any, any>, layer: Layer | null, isElement: boolean | undefined, injection: ActionExecutionInjection): Awaitable<CalledActionResult>;
     /**

package/dist/game/nlcore/action/actions/vfxAction.d.ts

@@ -10,6 +10,7 @@ import { Story } from "../../elements/story";
 export declare class VfxAction<T extends Values<typeof VfxActionTypes> = Values<typeof VfxActionTypes>> extends TypedAction<VfxActionContentType, T, Vfx> {
     static ActionTypes: {
         readonly action: "vfx:action";
+        readonly preload: "vfx:preload";
         readonly show: "vfx:show";
         readonly hide: "vfx:hide";
         readonly pause: "vfx:pause";

package/dist/game/nlcore/action/actions/videoAction.d.ts

@@ -10,6 +10,7 @@ import { Story } from "../../elements/story";
 export declare class VideoAction<T extends Values<typeof VideoActionTypes> = Values<typeof VideoActionTypes>> extends TypedAction<VideoActionContentType, T, Video> {
     static ActionTypes: {
         readonly action: "video:action";
+        readonly preload: "video:preload";
         readonly show: "video:show";
         readonly hide: "video:hide";
         readonly play: "video:play";

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

@@ -1,6 +1,6 @@
 import { LogicAction } from "../action/logicAction";
 import { TransformDefinitions } from "../elements/transform/type";
-import { Displayable } from "../elements/displayable/displayable";
+import { Displayable, DisplayableLoopRaw } from "../elements/displayable/displayable";
 import { EventfulDisplayable } from "../../player/elements/displayable/type";
 import { Chained, Proxied } from "../action/chain";
 /**
@@ -14,6 +14,7 @@ import { Chained, Proxied } from "../action/chain";
 export type ICameraUserConfig = TransformDefinitions.CameraTransformProps;
 export type CameraDataRaw = {
     transformState: Record<string, any>;
+    loop?: DisplayableLoopRaw | null;
 };
 /**
  * A stage-wide camera.

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

@@ -5,6 +5,28 @@ import { LogicAction } from "../../action/logicAction";
 import { EventfulDisplayable } from "../../../player/elements/displayable/type";
 import type { TransformDefinitions } from "../../elements/transform/type";
 import type { ImageSrc } from "../../types";
+/**
+ * A looping transform as it goes into a save.
+ *
+ * The transform itself is **not** here, and cannot be: its easing may be a function, and a function
+ * does not survive a round trip through JSON. What is stored instead is the id of the action that
+ * started the loop — the transform is authored data hanging off that action's content node, so the
+ * story itself still holds it, and loading resolves the id back to it through the same action map
+ * the stack model is restored with. A save whose action the story no longer has simply loses the
+ * loop rather than failing to load.
+ *
+ * Public, unlike the rest of the loop plumbing, because every displayable's `*DataRaw` names it and
+ * those are public. An internal-tagged type reached from a public signature is deleted from the
+ * emitted declarations while the signature that uses it stays behind naming something that is no
+ * longer declared, and only the consumer's `skipLibCheck` hides the result.
+ *
+ * (Do not write that tag in prose here: `stripInternal` matches it anywhere in the comment, so
+ * merely describing the hazard is enough to cause it.)
+ */
+export type DisplayableLoopRaw = {
+    actionId: string;
+    options: TransformDefinitions.LoopOptions;
+};
 export declare abstract class Displayable<StateData extends Record<string, any>, Self extends Displayable<any, any, any>, TransformType extends TransformDefinitions.Types = TransformDefinitions.Types> extends Actionable<StateData, Self> implements EventfulDisplayable {
     /**
      * Set Image Position
@@ -179,6 +201,60 @@ export declare abstract class Displayable<StateData extends Record<string, any>,
      * ```
      */
     transform(transform: Transform<TransformType>): Proxied<Self, Chained<LogicAction.Actions, Self>>;
+    /**
+     * Play a transform on this element over and over until something stops it.
+     *
+     * **The line does not wait.** This is the one difference from {@link Displayable.transform}, and
+     * the only one worth remembering: `transform()` is a step of the story and the next line waits
+     * for it to finish, while `loop()` is a property the element carries — it is set, the story
+     * moves on, and the motion keeps running underneath everything that follows.
+     *
+     * An element carries **one** transform at a time, so anything else applied to it takes the
+     * element back: `transform()`, `pos()`, `zoom()`, `show()`, `hide()` and the rest all end the
+     * loop and move on from wherever it had got to. What does *not* end it: the player skipping or
+     * fast-forwarding, a transition changing the picture, changing scene, or saving and loading —
+     * a loaded save puts the loop back.
+     *
+     * The pose the element had when the loop started is what it returns to, and the only thing a
+     * save records; the frames in between are never written down.
+     *
+     * The transform has to be committed, exactly as for {@link Displayable.transform} — a staged
+     * change that was never `commit()`ed is not part of it.
+     *
+     * @param transform - The motion to repeat. For anything that should not snap on each repeat,
+     * either bring it back to where it started or pass `{repeatType: "mirror"}`.
+     * @param options - See {@link TransformDefinitions.LoopOptions}.
+     * @chainable
+     * @example
+     * ```ts
+     * const breathe = Transform.create()
+     *     .scaleY(1.015)
+     *     .commit({ duration: 1900, ease: "easeInOut" });
+     *
+     * scene.action([
+     *     yuko.loop(breathe, { repeatType: "mirror" }),
+     *     yuko.say`...`,                  // plays while she keeps breathing
+     *     yuko.stopLoop({ duration: 300 }),
+     * ]);
+     * ```
+     */
+    loop(transform: Transform<TransformType>, options?: TransformDefinitions.LoopOptions): Proxied<Self, Chained<LogicAction.Actions, Self>>;
+    /**
+     * End the element's looping transform and put it back to the pose it had before the loop
+     * started.
+     *
+     * Unlike {@link Displayable.loop}, this **is** something the line waits for — there is a
+     * definite end to wait for. With no duration the element is back in place on the same frame.
+     *
+     * A no-op on an element that is not looping.
+     *
+     * @chainable
+     * @example
+     * ```ts
+     * yuko.stopLoop({ duration: 300, ease: "easeOut" });
+     * ```
+     */
+    stopLoop(options?: TransformDefinitions.LoopStopOptions): Proxied<Self, Chained<LogicAction.Actions, Self>>;
     /**
      * Bring the Displayable to the front of the layer it is on.
      *

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

@@ -3,7 +3,7 @@ import { Color, ImageSrc } from "../../types";
 import { LogicAction } from "../../game";
 import { FlexibleTuple, SelectElementFromEach } from "../../../../util/data";
 import { Chained, Proxied } from "../../action/chain";
-import { Displayable } from "../../elements/displayable/displayable";
+import { Displayable, DisplayableLoopRaw } from "../../elements/displayable/displayable";
 import { EventfulDisplayable } from "../../../player/elements/displayable/type";
 import { ImageTransition } from "../../elements/transition/transitions/image/imageTransition";
 import { Layer } from "../../elements/layer";
@@ -46,6 +46,7 @@ export interface IImageUserConfig<Tag extends TagGroupDefinition | null = TagGro
 export type ImageDataRaw = {
     state: Record<string, any>;
     transformState: Record<string, any>;
+    loop?: DisplayableLoopRaw | null;
 };
 export type TagGroupDefinition = string[][];
 export type TagSrcResolver<T extends TagGroupDefinition> = (...tags: SelectElementFromEach<T>) => string;

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

@@ -1,5 +1,5 @@
 import type { TransformDefinitions } from "../../elements/transform/type";
-import { Displayable } from "../../elements/displayable/displayable";
+import { Displayable, DisplayableLoopRaw } from "../../elements/displayable/displayable";
 import { EventfulDisplayable } from "../../../player/elements/displayable/type";
 import { Chained, Proxied } from "../../action/chain";
 import { LogicAction } from "../../action/logicAction";
@@ -80,6 +80,7 @@ export type PuppetCommandOptions = {
 export type PuppetDataRaw = {
     state: Record<string, any>;
     transformState: Record<string, any>;
+    loop?: DisplayableLoopRaw | null;
 };
 /**
  * A displayable whose interior is drawn by a backend the host registered.

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

@@ -2,7 +2,7 @@ import { Color } from "../../types";
 import { Chained, Proxied } from "../../action/chain";
 import { LogicAction } from "../../action/logicAction";
 import type { TransformDefinitions } from "../../elements/transform/type";
-import { Displayable } from "../../elements/displayable/displayable";
+import { Displayable, DisplayableLoopRaw } from "../../elements/displayable/displayable";
 import { EventfulDisplayable } from "../../../player/elements/displayable/type";
 import { Layer } from "../../elements/layer";
 export type TextConfig = {
@@ -52,6 +52,7 @@ export interface ITextUserConfig extends TransformDefinitions.TextTransformProps
 export type TextDataRaw = {
     state: Record<string, any>;
     transformState: Record<string, any>;
+    loop?: DisplayableLoopRaw | null;
 };
 export declare class Text extends Displayable<TextDataRaw, Text, TransformDefinitions.TextTransformProps> implements EventfulDisplayable {
     constructor(config: Partial<ITextUserConfig>);

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

@@ -1,6 +1,6 @@
 import { LogicAction } from "../action/logicAction";
 import { TransformDefinitions } from "../elements/transform/type";
-import { Displayable } from "../elements/displayable/displayable";
+import { Displayable, DisplayableLoopRaw } from "../elements/displayable/displayable";
 import { EventfulDisplayable } from "../../player/elements/displayable/type";
 import { Image } from "../elements/displayable/image";
 import { Text } from "../elements/displayable/text";
@@ -16,6 +16,7 @@ export interface ILayerUserConfig extends TransformDefinitions.ImageTransformPro
 export type LayerDataRaw = {
     state: Record<string, any>;
     transformState: Record<string, any>;
+    loop?: DisplayableLoopRaw | null;
 };
 export declare class Layer extends Displayable<LayerDataRaw, Layer, TransformDefinitions.ImageTransformProps> implements EventfulDisplayable {
     /**

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

@@ -24,6 +24,13 @@ export type TransformCompanion = {
     el: Element;
     project: (props: Partial<TransformDefinitions.Types>) => CSSProps;
 };
+/**
+ * A running looping transform. The only thing a caller can do with one is end it — see
+ * {@link Transform.startLoop}.
+ */
+export type TransformLoopHandle = {
+    stop: () => void;
+};
 /**
  * The same thing before the elements are known — what a React host holds, resolved to
  * {@link TransformCompanion} at the moment the animation is built.

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

@@ -13,10 +13,50 @@ export declare namespace TransformDefinitions {
         /**@deprecated */
         sync?: boolean;
     };
+    /**
+     * How a repeat plays each time round.
+     *
+     * - `"loop"` — start over from the first pose. The jump back is instant, so a sequence that
+     *   does not return to where it began shows a snap on every repeat.
+     * - `"reverse"` — play backwards, then forwards again. No snap.
+     * - `"mirror"` — like `"reverse"`, with the easing mirrored too, so an `easeIn` going out is an
+     *   `easeOut` coming back. This is what a breathing or floating motion wants.
+     */
+    type RepeatType = "loop" | "reverse" | "mirror";
     type TransformConfig = {
         sync: boolean;
         repeat?: number;
         repeatDelay?: number;
+        repeatType?: RepeatType;
+    };
+    /**
+     * How a looping transform repeats — see {@link Displayable.loop}.
+     *
+     * There is no "how many times" here on purpose: a loop runs until something stops it. For a
+     * bounded number of repeats use `transform.repeat(n)`, which the line waits for, or
+     * `Control.repeat`.
+     *
+     * This is written into the save as-is, so everything in it has to stay plain JSON.
+     */
+    type LoopOptions = {
+        /**@default "loop" */
+        repeatType?: RepeatType;
+        /**
+         * Milliseconds to hold the last pose before the next repeat starts.
+         * @default 0
+         */
+        repeatDelay?: number;
+    };
+    /**
+     * How an element eases out of its looping transform — see {@link Displayable.stopLoop}.
+     */
+    type LoopStopOptions = {
+        /**
+         * Milliseconds spent returning to the pose the element had before the loop started.
+         * @default 0
+         */
+        duration?: number;
+        ease?: EasingDefinition;
     };
     type VisualEffectTransformProps = {
         maskImage?: React.CSSProperties["maskImage"];

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

@@ -26,6 +26,22 @@ export type VfxConfig = {
 export type VfxFadeOptions = {
     duration?: number;
     easing?: TransformDefinitions.EasingDefinition;
+    /**
+     * Opacity to fade in to, for this showing only. Defaults to `config.opacity`.
+     *
+     * The overlay's own opacity is a property of the material — how strong that rain IS — while this
+     * is a property of the moment: the same rain reading faintly behind a memory and at full strength
+     * in the storm. Read by `show` only; a `hide` always fades to zero.
+     */
+    opacity?: number;
+    /**
+     * Playback speed for this showing only. Defaults to `config.playbackRate`.
+     *
+     * Every `show` restates the speed, so an override lasts exactly as long as the showing that
+     * asked for it and the next `show` is back to the configured rate. Like
+     * {@link Vfx.setPlaybackRate}, it is not persisted: a loaded save plays at `config.playbackRate`.
+     */
+    rate?: number;
 };
 export type VfxState = {
     display: boolean;
@@ -58,15 +74,38 @@ export declare class Vfx extends Actionable<VfxStateRaw> {
         src: string;
     });
     /**
-     * Add the overlay to the stage, fade it in, and start looping playback.
+     * Put the overlay on the stage without showing it: the video element is created and starts
+     * buffering, at zero opacity and paused.
+     *
+     * This is what makes a later {@link show} instant. A video that is not in the document has not
+     * begun to load, let alone decode, so the first frame of an overlay shown from nothing arrives
+     * whenever the decoder gets there — and `show` waits for it rather than fading in an empty
+     * rectangle. Declaring the overlay early moves that wait somewhere the player is not looking.
+     *
+     * Resolves immediately: nothing is waited for, because the point is to stop the story from
+     * waiting later. Calling it on an overlay already on stage does nothing.
+     * @chainable
+     */
+    preload(): Proxied<Vfx, Chained<LogicAction.Actions>>;
+    /**
+     * Fade the overlay in and start looping playback, putting it on the stage first if
+     * {@link preload} has not already.
      *
      * The action waits for the fade-in to finish. Calling it while the overlay is
      * already shown is idempotent (the fade-in is re-applied).
+     *
+     * `options.opacity` and `options.rate` apply to this showing only; both fall back to the
+     * overlay's configured values, so a plain `show()` after an overridden one is back to normal.
      * @chainable
      */
     show(options?: VfxFadeOptions): Proxied<Vfx, Chained<LogicAction.Actions>>;
     /**
-     * Fade the overlay out, then stop playback and remove it from the stage.
+     * Fade the overlay out and stop playback. It stays on the stage, invisible and paused.
+     *
+     * A paused video decodes nothing, so a hidden overlay costs no frame time — and keeping the
+     * element means the next {@link show} has a decoder already holding the clip instead of starting
+     * over. Both halves of the same decision: stop the work, keep the warmth. Only a new game or a
+     * load clears the stage.
      *
      * The action waits for the fade-out to finish. Calling it while the overlay is
      * not shown is a no-op (a weak warning is logged).
@@ -75,6 +114,11 @@ export declare class Vfx extends Actionable<VfxStateRaw> {
     hide(options?: VfxFadeOptions): Proxied<Vfx, Chained<LogicAction.Actions>>;
     /**
      * Freeze the overlay on its current frame.
+     *
+     * A freeze is explicit state, not a side effect of being invisible: it survives a
+     * {@link hide}/{@link show} pair, so an overlay paused and then hidden comes back still frozen
+     * and only {@link resume} starts it moving again. `hide` stops playback of its own accord and
+     * does not touch this.
      * @chainable
      */
     pause(): Proxied<Vfx, Chained<LogicAction.Actions>>;

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

@@ -21,6 +21,17 @@ export declare class Video extends Actionable<VideoStateRaw> {
      * ```
      */
     constructor(config: Partial<VideoConfig>);
+    /**
+     * Put the video element on the stage without showing it, so it can start buffering.
+     *
+     * A video that is not in the document has not begun to load. Declaring it ahead of the line
+     * that shows or plays it is what turns "the movie starts" into something immediate rather
+     * than a wait of unknown length on the player's connection.
+     *
+     * Resolves immediately, and does nothing to an element already on stage.
+     * @chainable
+     */
+    preload(): Proxied<Video, Chained<LogicAction.Actions>>;
     /**
      * Show the video element.
      * @chainable

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

@@ -2,7 +2,7 @@ import React, { ErrorInfo } from "react";
 import { IDialogProps, SayElementProps } from "../elements/say/type";
 import { IUserMenuProps, MenuElementProps } from "../elements/menu/type";
 import { Story } from "../../nlcore/elements/story";
-import clsx from "clsx";
+import type { ClassValue } from "clsx";
 import { Game, type GameLifecycleEventContext } from "../../nlcore/game";
 import { GameState } from "../gameState";
 import { Storable } from "../../nlcore/elements/persistent/storable";
@@ -33,7 +33,7 @@ export interface PlayerProps {
     story?: Story;
     width?: string | number;
     height?: string | number;
-    className?: clsx.ClassValue;
+    className?: ClassValue;
     /**
      * Once the Player is initialized.
      *

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

@@ -3,6 +3,7 @@ import { Image } from "../nlcore/elements/displayable/image";
 import { EventDispatcher } from "../../util/data";
 import { ImageEvents } from "./elements/image/Image";
 import { Transform } from "../nlcore/elements/transform/transform";
+import type { TransformDefinitions } from "../nlcore/elements/transform/type";
 import { Transition } from "../nlcore/elements/transition/transition";
 import { Layer } from "../nlcore/elements/layer";
 import { Camera } from "../nlcore/elements/camera";
@@ -36,12 +37,16 @@ export type ExposedState = {
         events: EventDispatcher<ImageEvents>;
         initDisplayable: (onResolve: () => void) => Timeline;
         applyTransform: (transform: Transform, onResolve: () => void) => Timeline;
+        applyLoop: (transform: Transform, options?: TransformDefinitions.LoopOptions) => void;
+        stopLoop: (options: TransformDefinitions.LoopStopOptions | undefined, onResolve: () => void) => Timeline;
         applyTransition: (transition: Transition<any>, onResolve: () => void) => Timeline;
         updateStyleSync: () => void;
     };
     [ExposedStateType.text]: {
         initDisplayable: (onResolve: () => void) => Timeline;
         applyTransform: (transform: Transform, onResolve: () => void) => Timeline;
+        applyLoop: (transform: Transform, options?: TransformDefinitions.LoopOptions) => void;
+        stopLoop: (options: TransformDefinitions.LoopStopOptions | undefined, onResolve: () => void) => Timeline;
         applyTransition: (transition: Transition<any>, onResolve: () => void) => Timeline;
         updateStyleSync: () => void;
         flush: () => void;
@@ -49,18 +54,24 @@ export type ExposedState = {
     [ExposedStateType.layer]: {
         initDisplayable: (onResolve: () => void) => Timeline;
         applyTransform: (transform: Transform, onResolve: () => void) => Timeline;
+        applyLoop: (transform: Transform, options?: TransformDefinitions.LoopOptions) => void;
+        stopLoop: (options: TransformDefinitions.LoopStopOptions | undefined, onResolve: () => void) => Timeline;
         applyTransition: (transition: Transition<any>, onResolve: () => void) => Timeline;
         updateStyleSync: () => void;
     };
     [ExposedStateType.camera]: {
         initDisplayable: (onResolve: () => void) => Timeline;
         applyTransform: (transform: Transform, onResolve: () => void) => Timeline;
+        applyLoop: (transform: Transform, options?: TransformDefinitions.LoopOptions) => void;
+        stopLoop: (options: TransformDefinitions.LoopStopOptions | undefined, onResolve: () => void) => Timeline;
         applyTransition: (transition: Transition<any>, onResolve: () => void) => Timeline;
         updateStyleSync: () => void;
     };
     [ExposedStateType.puppet]: {
         initDisplayable: (onResolve: () => void) => Timeline;
         applyTransform: (transform: Transform, onResolve: () => void) => Timeline;
+        applyLoop: (transform: Transform, options?: TransformDefinitions.LoopOptions) => void;
+        stopLoop: (options: TransformDefinitions.LoopStopOptions | undefined, onResolve: () => void) => Timeline;
         applyTransition: (transition: Transition<any>, onResolve: () => void) => Timeline;
         updateStyleSync: () => void;
         flush: () => void;