@redwilly/anima 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,18 +1,2086 @@
-export { Scene } from './core/scene';
-export type { SceneConfig } from './core/scene';
-export { Mobject, VMobject, VGroup } from './mobjects';
-export { Camera, CameraFrame } from './core/camera';
-export type { CameraConfig, ResolvedCameraConfig } from './core/camera';
-export { Circle, Rectangle, Line, Arrow, Arc, Polygon, Point } from './mobjects/geometry';
-export { Text, Glyph } from './mobjects/text';
-export type { TextStyle } from './mobjects/text';
-export { Graph, GraphNode, GraphEdge } from './mobjects/graph';
-export type { GraphNodeId, NodeConfig, EdgeConfig, LayoutType, LayoutConfig } from './mobjects/graph';
-export { Animation, FadeIn, FadeOut, MoveTo, Rotate, Scale, MorphTo, Draw, Write, Unwrite, Sequence, Parallel, KeyframeTrack, KeyframeAnimation, Follow, Shake } from './core/animations';
-export type { AnimationConfig, Keyframe } from './core/animations';
-export { Color, Vector2 } from './core/math';
-export { serialize, deserialize } from './core/serialization';
-export { Timeline } from './core/timeline';
-export type { ScheduledAnimation, TimelineConfig } from './core/timeline';
-export { Renderer, FrameRenderer, ProgressReporter, Resolution } from './core/renderer';
-export * from './core/animations/easing';
+import { Glyph as Glyph$1 } from 'fontkit';
+import { Canvas } from '@napi-rs/canvas';
+
+/**
+ * A class representing a color with Red, Green, Blue, and Alpha components.
+ * RGB values are in the range [0, 255].
+ * Alpha value is in the range [0, 1].
+ */
+declare class Color {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    /**
+     * Creates a Color from a hex string.
+     * Supports formats: #RRGGBB, #RGB, #RRGGBBAA, #RGBA.
+     */
+    static fromHex(hex: string): Color;
+    static fromHSL(h: number, s: number, l: number, a?: number): Color;
+    toHex(): string;
+    toRGBA(): string;
+    lerp(other: Color, t: number): Color;
+    static readonly WHITE: Color;
+    static readonly BLACK: Color;
+    static readonly RED: Color;
+    static readonly GREEN: Color;
+    static readonly BLUE: Color;
+    static readonly YELLOW: Color;
+    static readonly TRANSPARENT: Color;
+}
+
+/**
+ * A 2D vector class representing a point or direction in 2D space.
+ */
+declare class Vector2 {
+    readonly x: number;
+    readonly y: number;
+    constructor(x: number, y: number);
+    add(other: Vector2): Vector2;
+    subtract(other: Vector2): Vector2;
+    multiply(scalar: number): Vector2;
+    dot(other: Vector2): number;
+    /** Magnitude (length) of the vector. */
+    length(): number;
+    /** Returns a normalized unit vector. Returns ZERO for zero-length vectors. */
+    normalize(): Vector2;
+    lerp(other: Vector2, t: number): Vector2;
+    equals(other: Vector2, tolerance?: number): boolean;
+    static readonly ZERO: Vector2;
+    static readonly UP: Vector2;
+    static readonly DOWN: Vector2;
+    static readonly LEFT: Vector2;
+    static readonly RIGHT: Vector2;
+}
+
+/**
+ * A 3x3 matrix class for 2D affine transformations.
+ * Stored in row-major order:
+ * [ 0  1  2 ]
+ * [ 3  4  5 ]
+ * [ 6  7  8 ]
+ */
+declare class Matrix3x3 {
+    readonly values: Float32Array;
+    constructor(values: number[] | Float32Array);
+    multiply(other: Matrix3x3): Matrix3x3;
+    /** Transforms a Vector2 point (assumes z=1). */
+    transformPoint(point: Vector2): Vector2;
+    /** @throws Error if the matrix is not invertible. */
+    inverse(): Matrix3x3;
+    static identity(): Matrix3x3;
+    static translation(tx: number, ty: number): Matrix3x3;
+    static rotation(angle: number): Matrix3x3;
+    static scale(sx: number, sy: number): Matrix3x3;
+    static shear(shx: number, shy: number): Matrix3x3;
+    static readonly IDENTITY: Matrix3x3;
+}
+
+/**
+ * Type signature for an easing function.
+ * Maps a progress value t ∈ [0, 1] to an eased value.
+ * Must satisfy: f(0) = 0 and f(1) = 1
+ */
+type EasingFunction = (t: number) => number;
+
+/**
+ * Linear easing (no easing, constant speed).
+ */
+declare const linear: EasingFunction;
+/**
+ * Quadratic ease-in: slow start, accelerating.
+ */
+declare const easeInQuad: EasingFunction;
+/**
+ * Quadratic ease-out: fast start, decelerating.
+ */
+declare const easeOutQuad: EasingFunction;
+/**
+ * Quadratic ease-in-out: slow start and end.
+ */
+declare const easeInOutQuad: EasingFunction;
+/**
+ * Cubic ease-in: slow start, accelerating.
+ */
+declare const easeInCubic: EasingFunction;
+/**
+ * Cubic ease-out: fast start, decelerating.
+ */
+declare const easeOutCubic: EasingFunction;
+/**
+ * Cubic ease-in-out: slow start and end.
+ */
+declare const easeInOutCubic: EasingFunction;
+/**
+ * Quartic ease-in: slow start, accelerating.
+ */
+declare const easeInQuart: EasingFunction;
+/**
+ * Quartic ease-out: fast start, decelerating.
+ */
+declare const easeOutQuart: EasingFunction;
+/**
+ * Quartic ease-in-out: slow start and end.
+ */
+declare const easeInOutQuart: EasingFunction;
+/**
+ * Quintic ease-in: slow start, accelerating.
+ */
+declare const easeInQuint: EasingFunction;
+/**
+ * Quintic ease-out: fast start, decelerating.
+ */
+declare const easeOutQuint: EasingFunction;
+/**
+ * Quintic ease-in-out: slow start and end.
+ */
+declare const easeInOutQuint: EasingFunction;
+/**
+ * Sinusoidal ease-in: uses sine curve for smooth acceleration.
+ */
+declare const easeInSine: EasingFunction;
+/**
+ * Sinusoidal ease-out: uses sine curve for smooth deceleration.
+ */
+declare const easeOutSine: EasingFunction;
+/**
+ * Sinusoidal ease-in-out: smooth S-curve using sine.
+ */
+declare const easeInOutSine: EasingFunction;
+/**
+ * Exponential ease-in: dramatic acceleration.
+ */
+declare const easeInExpo: EasingFunction;
+/**
+ * Exponential ease-out: dramatic deceleration.
+ */
+declare const easeOutExpo: EasingFunction;
+/**
+ * Exponential ease-in-out: dramatic S-curve.
+ */
+declare const easeInOutExpo: EasingFunction;
+/**
+ * Circular ease-in: quarter circle acceleration.
+ */
+declare const easeInCirc: EasingFunction;
+/**
+ * Circular ease-out: quarter circle deceleration.
+ */
+declare const easeOutCirc: EasingFunction;
+/**
+ * Circular ease-in-out: half circle S-curve.
+ */
+declare const easeInOutCirc: EasingFunction;
+/**
+ * Back ease-in: pulls back before accelerating forward.
+ */
+declare const easeInBack: EasingFunction;
+/**
+ * Back ease-out: overshoots then settles.
+ */
+declare const easeOutBack: EasingFunction;
+/**
+ * Back ease-in-out: pulls back, overshoots, then settles.
+ */
+declare const easeInOutBack: EasingFunction;
+/**
+ * Elastic ease-in: builds up elastic energy.
+ */
+declare const easeInElastic: EasingFunction;
+/**
+ * Elastic ease-out: releases elastic energy with overshoot oscillation.
+ */
+declare const easeOutElastic: EasingFunction;
+/**
+ * Elastic ease-in-out: elastic effect on both ends.
+ */
+declare const easeInOutElastic: EasingFunction;
+
+/**
+ * Bounce ease-in: bounces before settling.
+ */
+declare const easeInBounce: EasingFunction;
+/**
+ * Bounce ease-out: bounces at the end.
+ */
+declare const easeOutBounce: EasingFunction;
+/**
+ * Bounce ease-in-out: bounces at both ends.
+ */
+declare const easeInOutBounce: EasingFunction;
+
+/**
+ * Smooth S-curve using cubic smoothstep.
+ * This is the DEFAULT easing for all Manim animations.
+ * Formula: 3t² - 2t³
+ */
+declare const smooth: EasingFunction;
+/**
+ * Applies smooth twice for extra smoothness.
+ * Creates an even more gradual transition at the endpoints.
+ */
+declare const doubleSmooth: EasingFunction;
+/**
+ * Starts fast, decelerates at end (rush into the destination).
+ * Uses sqrt for fast start that slows down.
+ */
+declare const rushInto: EasingFunction;
+/**
+ * Slow start, accelerates from beginning (rush from the start).
+ * Uses quadratic for slow start that speeds up.
+ */
+declare const rushFrom: EasingFunction;
+/**
+ * Starts normal, slows into the end.
+ */
+declare const slowInto: EasingFunction;
+/**
+ * Goes from 0 to 1 and back to 0.
+ * Useful for temporary effects.
+ */
+declare const thereAndBack: EasingFunction;
+/** Goes from 0 to 1 and back to 0 with a pause at the peak. */
+declare function thereAndBackWithPause(pauseRatio?: number): EasingFunction;
+/** Overshoots slightly then settles (like a running start). */
+declare function runningStart(pullFactor?: number): EasingFunction;
+/**
+ * Oscillates back and forth (wiggle/shake effect).
+ * Creates a wobbling motion that ends at 1.
+ */
+declare const wiggle: EasingFunction;
+/** Approaches but doesn't quite reach 1 (asymptotic approach). */
+declare function notQuiteThere(proportion?: number): EasingFunction;
+/** Reaches the destination early and stays there. */
+declare function lingering(proportion?: number): EasingFunction;
+/** Asymptotically approaches 1 via exponential decay. */
+declare function exponentialDecay(halfLife?: number): EasingFunction;
+
+/** @throws Error if an easing with the given name already exists. */
+declare function registerEasing(name: string, fn: EasingFunction): void;
+declare function getEasing(name: string): EasingFunction | undefined;
+declare function hasEasing(name: string): boolean;
+declare function unregisterEasing(name: string): boolean;
+/** Clears all registered custom easings (useful for testing). */
+declare function clearRegistry(): void;
+
+/**
+ * Manages a queue of animations for fluent chaining.
+ * This is an internal implementation detail of Mobject's fluent API.
+ */
+declare class AnimationQueue {
+    private readonly target;
+    private readonly queue;
+    constructor(target: Mobject);
+    enqueueAnimation(animation: Animation<Mobject>): void;
+    setLastDuration(seconds: number): void;
+    setLastEasing(easing: EasingFunction): void;
+    isEmpty(): boolean;
+    popLastAnimation(): Animation<Mobject> | null;
+    toAnimation(): Animation<Mobject>;
+    getTotalDuration(): number;
+}
+interface MobjectState {
+    position: Vector2;
+    scale: Vector2;
+    rotation: number;
+}
+/**
+ * Base class for all mathematical objects.
+ * Manages position, rotation, scale, and opacity via a local transformation matrix.
+ * Includes fluent animation API for chainable animations.
+ */
+declare class Mobject {
+    protected localMatrix: Matrix3x3;
+    protected opacityValue: number;
+    protected animQueue: AnimationQueue | null;
+    private savedStates;
+    parent: Mobject | null;
+    constructor();
+    protected getQueue(): AnimationQueue;
+    get matrix(): Matrix3x3;
+    getWorldMatrix(): Matrix3x3;
+    get position(): Vector2;
+    get rotation(): number;
+    get scale(): Vector2;
+    get opacity(): number;
+    pos(x: number, y: number): this;
+    show(): this;
+    hide(): this;
+    setOpacity(value: number): this;
+    setRotation(angle: number): this;
+    setScale(sx: number, sy: number): this;
+    applyMatrix(m: Matrix3x3): this;
+    saveState(): this;
+    getSavedState(): MobjectState | undefined;
+    clearSavedStates(): this;
+    /**
+     * Animates back to the last saved state.
+     * Pops the saved state from the stack.
+     * @throws Error if no state was previously saved
+     */
+    restore(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    private createAnimation;
+    fadeIn(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    fadeOut(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    moveTo(x: number, y: number, durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    rotate(angle: number, durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    scaleTo(factor: number, durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    scaleToXY(factorX: number, factorY: number, durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    duration(seconds: number): this;
+    ease(easing: EasingFunction): this;
+    toAnimation(): Animation<Mobject>;
+    getQueuedDuration(): number;
+    hasQueuedAnimations(): boolean;
+    /**
+     * Queues multiple animations to run in parallel (simultaneously).
+     * Automatically handles both Animation objects and mobject method calls.
+     * @example
+     * circle.fadeIn(1).parallel(
+     *     circle.moveTo(100, 50),
+     *     circle.rotate(Math.PI)
+     * ).fadeOut(1);
+     */
+    parallel(...items: (Animation<Mobject> | Mobject)[]): this;
+}
+
+/**
+ * Configuration options for animations.
+ */
+interface AnimationConfig {
+    /** Duration of the animation in seconds. Default: 1 */
+    readonly durationSeconds: number;
+    /** Easing function to apply. Default: smooth */
+    readonly easing: EasingFunction;
+    /** Delay before animation starts in seconds. Default: 0 */
+    readonly delaySeconds: number;
+}
+/**
+ * Animation lifecycle category determines how Scene.play() handles the target.
+ * - 'introductory': Auto-registers target with scene (FadeIn, Create, Draw, Write)
+ * - 'transformative': Requires target to already be in scene (MoveTo, Rotate, Scale)
+ * - 'exit': Requires target in scene, may auto-remove after (FadeOut)
+ */
+type AnimationLifecycle = 'introductory' | 'transformative' | 'exit';
+
+/**
+ * Abstract base class for all animations.
+ * Provides configuration for duration, easing, and delay.
+ * Subclasses must specify their lifecycle category.
+ */
+declare abstract class Animation<T extends Mobject = Mobject> {
+    protected readonly target: T;
+    protected durationSeconds: number;
+    protected easingFn: EasingFunction;
+    protected delaySeconds: number;
+    /**
+     * The lifecycle category of this animation.
+     * Determines how Scene.play() handles scene registration and validation.
+     */
+    abstract readonly lifecycle: AnimationLifecycle;
+    constructor(target: T);
+    duration(seconds: number): this;
+    ease(easing: EasingFunction): this;
+    delay(seconds: number): this;
+    getDuration(): number;
+    getDelay(): number;
+    getEasing(): EasingFunction;
+    getTarget(): T;
+    getConfig(): AnimationConfig;
+    abstract interpolate(progress: number): void;
+    /**
+     * Ensures the animation is initialized before interpolation.
+     * Called before first update to capture start state.
+     * Default: no-op. Override in subclasses that need lazy initialization.
+     */
+    ensureInitialized(): void;
+    /**
+     * Resets the animation to its uninitialized state.
+     * Allows animations to be replayed or looped.
+     */
+    reset(): void;
+    update(progress: number): void;
+}
+
+/**
+ * Represents an animation scheduled at a specific time on the Timeline.
+ */
+interface ScheduledAnimation {
+    /** The animation to play */
+    readonly animation: Animation;
+    /** Start time in seconds from timeline beginning */
+    readonly startTime: number;
+}
+/**
+ * Configuration options for Timeline.
+ */
+interface TimelineConfig {
+    /** Whether the timeline loops. Default: false */
+    readonly loop?: boolean;
+}
+
+/**
+ * Timeline schedules and controls playback of animations.
+ * Animations can be scheduled at specific times and the timeline
+ * provides seek/state access for non-linear playback.
+ */
+declare class Timeline {
+    private readonly scheduled;
+    private readonly config;
+    private currentTime;
+    constructor(config?: TimelineConfig);
+    /**
+     * Schedule an animation to start at a specific time.
+     * @param animation The animation to schedule
+     * @param startTime Start time in seconds (default: 0)
+     */
+    schedule(animation: Animation, startTime?: number): this;
+    /**
+     * Schedule multiple animations to play in sequence.
+     * First animation starts at the given startTime, subsequent
+     * animations start after the previous one ends.
+     * @param animations Animations to schedule sequentially
+     * @param startTime Start time for the first animation (default: 0)
+     */
+    scheduleSequence(animations: Animation[], startTime?: number): this;
+    /**
+     * Schedule multiple animations to play in parallel.
+     * All animations start at the same time.
+     * @param animations Animations to schedule in parallel
+     * @param startTime Start time for all animations (default: 0)
+     */
+    scheduleParallel(animations: Animation[], startTime?: number): this;
+    /**
+     * Get all scheduled animations with resolved timing information.
+     */
+    private getResolved;
+    /**
+     * Get total duration of the timeline.
+     * Returns the end time of the last animation to finish.
+     */
+    getTotalDuration(): number;
+    /**
+     * Seek to a specific time and update all animations.
+     * @param time Time in seconds to seek to
+     */
+    seek(time: number): void;
+    /**
+     * Get the timeline state at a specific time without modifying the
+     * current playhead position.
+     * @param time Time in seconds
+     */
+    getStateAt(time: number): void;
+    /**
+     * Get the current time of the timeline.
+     */
+    getCurrentTime(): number;
+    /**
+     * Get all scheduled animations.
+     */
+    getScheduled(): readonly ScheduledAnimation[];
+    /**
+     * Check if timeline is configured to loop.
+     */
+    isLooping(): boolean;
+    /**
+     * Clear all scheduled animations.
+     */
+    clear(): void;
+}
+
+/**
+ * Executes animations in sequence, one after another.
+ * Total duration equals the sum of all child animation durations.
+ *
+ * This is a composition animation - its lifecycle is determined by its children.
+ * Only the first child is initialized when the sequence starts; subsequent
+ * children are initialized when they become active.
+ */
+declare class Sequence extends Animation<Mobject> {
+    private readonly children;
+    private readonly childDurations;
+    private readonly totalChildDuration;
+    /**
+     * The lifecycle of Sequence is determined by its FIRST child animation.
+     * If the first animation is introductory, it will register the target,
+     * allowing subsequent transformative animations to work.
+     */
+    readonly lifecycle: AnimationLifecycle;
+    constructor(animations: Animation[]);
+    getDuration(): number;
+    getChildren(): readonly Animation[];
+    /**
+     * Initializes only the first child.
+     * Later children are initialized when they become active in interpolate().
+     */
+    ensureInitialized(): void;
+    reset(): void;
+    /**
+     * Interpolates the sequence at the given progress.
+     * Maps global progress to the correct child animation.
+     *
+     * IMPORTANT: We only update children that have started or completed.
+     * Children that haven't started yet are NOT updated to avoid
+     * premature initialization with incorrect state.
+     */
+    interpolate(progress: number): void;
+    update(progress: number): void;
+}
+
+/**
+ * Executes animations in parallel, all starting at the same time.
+ * Total duration equals the maximum of all child animation durations.
+ *
+ * This is a composition animation - its lifecycle is determined by its children.
+ * By default, uses 'transformative' lifecycle if children are mixed.
+ *
+ * All children are initialized together before any interpolation begins,
+ * ensuring they all capture state at the same moment.
+ */
+declare class Parallel extends Animation<Mobject> {
+    private readonly children;
+    private readonly maxChildDuration;
+    /**
+     * The lifecycle of Parallel is 'introductory' only if ALL children are introductory.
+     * Otherwise, it defaults to 'transformative'.
+     */
+    readonly lifecycle: AnimationLifecycle;
+    constructor(animations: Animation[]);
+    getDuration(): number;
+    getChildren(): readonly Animation[];
+    /**
+     * Ensures all children are initialized together.
+     * This captures start state for all parallel animations at the same moment.
+     */
+    ensureInitialized(): void;
+    reset(): void;
+    /**
+     * Interpolates all child animations at the given progress.
+     * Each child's progress is scaled based on its duration relative to the container.
+     */
+    interpolate(progress: number): void;
+    update(progress: number): void;
+}
+
+/**
+ * Configuration options for CameraFrame.
+ */
+interface CameraFrameConfig {
+    /** Width of the viewport in pixels. Defaults to 1920. */
+    pixelWidth?: number;
+    /** Height of the viewport in pixels. Defaults to 1080. */
+    pixelHeight?: number;
+}
+/**
+ * Camera bounds that limit how far the camera can pan.
+ */
+interface Bounds {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}
+/**
+ * CameraFrame represents the viewport window in world space.
+ * Extends Mobject (not VMobject - no visual representation).
+ * Its transform properties define what the camera shows:
+ * - scale(2) = zoom OUT (larger frame = see more)
+ * - scale(0.5) = zoom IN (smaller frame = see less)
+ *
+ * The CameraFrame is the primary way to control camera animations in Anima.
+ * Access it via `scene.frame` or `scene.camera.frame`.
+ *
+ * @example
+ * // Zoom in over 1 second
+ * this.play(this.frame.zoomIn(2).duration(1));
+ *
+ * @example
+ * // Pan to center on an object
+ * this.play(this.frame.centerOn(circle).duration(0.5));
+ *
+ * @example
+ * // Fit multiple objects in view
+ * this.play(this.frame.fitTo([obj1, obj2, obj3]).duration(1));
+ */
+declare class CameraFrame extends Mobject {
+    private readonly baseWidth;
+    private readonly baseHeight;
+    private bounds?;
+    /**
+     * Creates a new CameraFrame with the specified viewport dimensions.
+     *
+     * @param config - Configuration options
+     * @param config.pixelWidth - Width of the viewport in pixels (default: 1920)
+     * @param config.pixelHeight - Height of the viewport in pixels (default: 1080)
+     *
+     * @example
+     * const frame = new CameraFrame({ pixelWidth: 1920, pixelHeight: 1080 });
+     */
+    constructor(config?: CameraFrameConfig);
+    /**
+     * The current width of the frame in world units, accounting for scale.
+     * @returns The frame width multiplied by the current scale.x
+     */
+    get width(): number;
+    /**
+     * The current height of the frame in world units, accounting for scale.
+     * @returns The frame height multiplied by the current scale.y
+     */
+    get height(): number;
+    /**
+     * Sets the scale of the camera frame.
+     * Overrides Mobject.setScale to prevent zero or negative scales.
+     *
+     * @param sx - Scale factor for the x-axis (must be positive)
+     * @param sy - Scale factor for the y-axis (must be positive)
+     * @returns This CameraFrame for method chaining
+     * @throws Error if sx or sy is zero or negative
+     *
+     * @example
+     * frame.setScale(2, 2); // Zoom out 2x
+     * frame.setScale(0.5, 0.5); // Zoom in 2x
+     */
+    setScale(sx: number, sy: number): this;
+    /**
+     * Sets bounds that limit how far the camera can pan.
+     * When bounds are set, the camera position is clamped to stay within them,
+     * accounting for the frame size so edges don't go outside bounds.
+     *
+     * @param minX - Minimum x coordinate
+     * @param minY - Minimum y coordinate
+     * @param maxX - Maximum x coordinate
+     * @param maxY - Maximum y coordinate
+     * @returns This CameraFrame for method chaining
+     *
+     * @example
+     * // Limit camera to a 100x100 world area
+     * frame.setBounds(0, 0, 100, 100);
+     */
+    setBounds(minX: number, minY: number, maxX: number, maxY: number): this;
+    /**
+     * Removes any bounds restrictions on camera movement.
+     *
+     * @returns This CameraFrame for method chaining
+     *
+     * @example
+     * frame.clearBounds(); // Camera can now pan freely
+     */
+    clearBounds(): this;
+    /**
+     * Checks if the camera has bounds set.
+     *
+     * @returns True if bounds are set, false otherwise
+     */
+    hasBounds(): boolean;
+    /**
+     * Gets the current bounds configuration.
+     *
+     * @returns The bounds object or undefined if no bounds are set
+     */
+    getBounds(): Bounds | undefined;
+    /**
+     * Sets the position of the camera frame.
+     * Overrides Mobject.pos to clamp position within bounds if set.
+     *
+     * @param x - The x coordinate in world space
+     * @param y - The y coordinate in world space
+     * @returns This CameraFrame for method chaining
+     *
+     * @example
+     * frame.pos(5, 3); // Move camera center to (5, 3)
+     */
+    pos(x: number, y: number): this;
+    /**
+     * Smoothly zoom the camera in by the given factor.
+     * Internally scales the frame down, which makes objects appear larger.
+     *
+     * @param factor - Zoom multiplier. 2 = objects appear 2x larger (default: 2)
+     * @returns FluentAnimation that can be chained with .duration() and .ease()
+     * @throws Error if factor is zero or negative
+     *
+     * @example
+     * // Zoom in 2x over 1 second
+     * this.play(this.frame.zoomIn(2).duration(1));
+     *
+     * @example
+     * // Zoom in 3x with easing
+     * this.play(this.frame.zoomIn(3).duration(1.5).ease(easeInOutQuad));
+     */
+    zoomIn(factor?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    /**
+     * Smoothly zoom the camera out by the given factor.
+     * Internally scales the frame up, which makes objects appear smaller.
+     *
+     * @param factor - Zoom multiplier. 2 = objects appear 2x smaller (default: 2)
+     * @returns FluentAnimation that can be chained with .duration() and .ease()
+     * @throws Error if factor is zero or negative
+     *
+     * @example
+     * // Zoom out 2x over 1 second
+     * this.play(this.frame.zoomOut(2).duration(1));
+     *
+     * @example
+     * // Zoom out to show more of the scene
+     * this.play(this.frame.zoomOut(4).duration(2).ease(easeOutCubic));
+     */
+    zoomOut(factor?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    /**
+     * Move the camera to center on a target Mobject.
+     * The camera will smoothly pan so the target is at the center of the frame.
+     *
+     * @param target - The Mobject to center on
+     * @returns FluentAnimation that can be chained with .duration() and .ease()
+     * @throws Error if target is null or undefined
+     *
+     * @example
+     * // Center on a circle over 0.5 seconds
+     * this.play(this.frame.centerOn(circle).duration(0.5));
+     *
+     * @example
+     * // Pan to focus on different objects in sequence
+     * await this.play(this.frame.centerOn(obj1).duration(1));
+     * await this.play(this.frame.centerOn(obj2).duration(1));
+     */
+    centerOn(target: Mobject): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    /**
+     * Zoom in/out while keeping a specific world point fixed on screen.
+     * Like pinch-to-zoom behavior where the pinch point stays stationary.
+     *
+     * Uses the formula: C' = P * (1 - factor) + C * factor
+     * Where P = point, C = current center, factor = zoom factor.
+     *
+     * @param factor - Scale multiplier. Less than 1 for zoom in, greater than 1 for zoom out
+     * @param point - World coordinates to keep fixed on screen
+     * @returns Parallel animation combining move and scale
+     * @throws Error if factor is zero or negative
+     *
+     * @example
+     * // Zoom in 2x on a specific point
+     * this.play(frame.zoomToPoint(0.5, { x: 5, y: 5 }).duration(1));
+     *
+     * @example
+     * // Zoom out while keeping an object's position fixed
+     * this.play(frame.zoomToPoint(2, circle.position).duration(1));
+     */
+    zoomToPoint(factor: number, point: {
+        x: number;
+        y: number;
+    }): Parallel;
+    /**
+     * Automatically frame one or more objects with optional margin.
+     * Calculates the bounding box of all targets and animates the camera
+     * to show them all with the specified margin around them.
+     *
+     * @param targets - Single Mobject or array of Mobjects to frame
+     * @param margin - Padding around the objects in world units (default: 0.5)
+     * @returns FluentAnimation that can be chained with .duration() and .ease()
+     * @throws Error if targets array is empty
+     *
+     * @example
+     * // Fit a single object with default margin
+     * this.play(this.frame.fitTo(circle).duration(1));
+     *
+     * @example
+     * // Fit multiple objects with custom margin
+     * this.play(this.frame.fitTo([obj1, obj2, obj3], 1.0).duration(1.5));
+     *
+     * @example
+     * // Show all objects in the scene
+     * this.play(this.frame.fitTo(allObjects, 0).duration(2));
+     */
+    fitTo(targets: Mobject | Mobject[], margin?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    private calculateBounds;
+    private hasGetBoundingBox;
+}
+
+/**
+ * Configuration options for Camera.
+ */
+interface CameraConfig {
+    /** Pixel width for aspect ratio calculation. Default: 1920 */
+    readonly pixelWidth?: number;
+    /** Pixel height for aspect ratio calculation. Default: 1080 */
+    readonly pixelHeight?: number;
+}
+/**
+ * Resolved camera configuration with all defaults applied.
+ */
+interface ResolvedCameraConfig {
+    readonly pixelWidth: number;
+    readonly pixelHeight: number;
+}
+
+/**
+ * Camera manages the view into the scene.
+ * Uses CameraFrame (a Mobject) to store transform state, enabling camera animations.
+ *
+ * The Camera provides both instant manipulation methods (panTo, zoomTo) and
+ * access to the CameraFrame for fluent animation APIs.
+ *
+ * @example
+ * // Instant camera manipulation
+ * camera.zoomTo(2);
+ * camera.panTo(new Vector2(5, 3));
+ *
+ * @example
+ * // Animated camera movement via frame
+ * this.play(this.frame.zoomIn(2).duration(1));
+ * this.play(this.frame.centerOn(circle).duration(0.5));
+ */
+declare class Camera {
+    private readonly config;
+    /** The CameraFrame that stores the camera's transform state. Use this for animations. */
+    readonly frame: CameraFrame;
+    /**
+     * Creates a new Camera with the specified viewport dimensions.
+     *
+     * @param config - Configuration options
+     * @param config.pixelWidth - Width of the viewport in pixels (default: 1920)
+     * @param config.pixelHeight - Height of the viewport in pixels (default: 1080)
+     */
+    constructor(config?: CameraConfig);
+    get frameHeight(): number;
+    get frameWidth(): number;
+    get frameYRadius(): number;
+    get frameXRadius(): number;
+    get pixelWidth(): number;
+    get pixelHeight(): number;
+    get position(): Vector2;
+    get zoom(): number;
+    get rotation(): number;
+    pan(delta: Vector2): this;
+    panTo(position: Vector2): this;
+    zoomTo(level: number): this;
+    rotateTo(angle: number): this;
+    getViewMatrix(): Matrix3x3;
+    /**
+     * Transforms a world-space position to screen-space (pixel) coordinates.
+     *
+     * Screen coordinates have origin at top-left, with x increasing right
+     * and y increasing downward.
+     *
+     * @param pos - Position in world coordinates
+     * @returns Position in screen coordinates (pixels)
+     *
+     * @example
+     * const screenPos = camera.worldToScreen(circle.position);
+     * console.log(`Circle is at pixel (${screenPos.x}, ${screenPos.y})`);
+     */
+    worldToScreen(pos: Vector2): Vector2;
+    /**
+     * Transforms a screen-space (pixel) position to world coordinates.
+     * This is the inverse of worldToScreen.
+     *
+     * @param pos - Position in screen coordinates (pixels, origin at top-left)
+     * @returns Position in world coordinates
+     *
+     * @example
+     * // Convert a mouse click position to world coordinates
+     * const worldPos = camera.screenToWorld(new Vector2(mouseX, mouseY));
+     */
+    screenToWorld(pos: Vector2): Vector2;
+    /**
+     * Checks if a world-space position is currently visible within the camera frame.
+     *
+     * @param pos - Position in world coordinates to check
+     * @returns True if the position is within the visible frame bounds
+     *
+     * @example
+     * if (camera.isInView(object.position)) {
+     *   console.log('Object is visible');
+     * }
+     */
+    isInView(pos: Vector2): boolean;
+    reset(): this;
+}
+
+/**
+ * Configuration options for Scene.
+ */
+interface SceneConfig {
+    /** Pixel width of the scene. Default: 1920 */
+    readonly width?: number;
+    /** Pixel height of the scene. Default: 1080 */
+    readonly height?: number;
+    /** Background color. Default: BLACK */
+    readonly backgroundColor?: Color;
+    /** Frames per second. Default: 60 */
+    readonly frameRate?: number;
+}
+
+/**
+ * Scene is the core container that manages Mobjects and coordinates animations.
+ * It provides both a simple API for playing animations and access to the
+ * underlying Timeline and Camera for advanced control.
+ */
+declare class Scene {
+    private readonly config;
+    private readonly mobjects;
+    private readonly timeline;
+    private readonly _camera;
+    private playheadTime;
+    constructor(config?: SceneConfig);
+    get camera(): Camera;
+    get frame(): CameraFrame;
+    /** Get scene width in pixels. */
+    getWidth(): number;
+    /** Get scene height in pixels. */
+    getHeight(): number;
+    /** Get scene background color. */
+    getBackgroundColor(): Color;
+    /** Get scene frame rate. */
+    getFrameRate(): number;
+    /**
+     * Add mobjects to the scene and make them immediately visible.
+     * Use this for static elements or backgrounds that should be visible
+     * before any animations begin.
+     */
+    add(...mobjects: Mobject[]): this;
+    /**
+     * Remove mobjects from the scene.
+     */
+    remove(...mobjects: Mobject[]): this;
+    /**
+     * Check if a mobject is registered with this scene.
+     */
+    has(mobject: Mobject): boolean;
+    /**
+     * Get all mobjects in the scene.
+     */
+    getMobjects(): readonly Mobject[];
+    /**
+     * Schedule animations to play at the current playhead position.
+     *
+     * Accepts either Animation objects or Mobjects with queued fluent animations.
+     * When a Mobject is passed, its queued animation chain is automatically extracted.
+     *
+     * - Introductory animations (FadeIn, Create, Draw, Write) auto-register
+     *   their targets with the scene if not already present.
+     * - Transformative animations (MoveTo, Rotate, Scale) require the target
+     *   to already be in the scene, otherwise an error is thrown.
+     *
+     * @example
+     * // ProAPI style
+     * this.play(new FadeIn(circle), new MoveTo(rect, 2, 0));
+     *
+     * // FluentAPI style
+     * circle.fadeIn(1).moveTo(2, 0, 1);
+     * this.play(circle);
+     *
+     * // Mixed
+     * circle.fadeIn(1);
+     * this.play(circle, new FadeIn(rect));
+     */
+    play(...items: Array<Animation | Mobject>): this;
+    /**
+     * Add a delay before the next play() call.
+     * @param seconds Number of seconds to wait
+     */
+    wait(seconds: number): this;
+    /**
+     * Get the current playhead time.
+     */
+    getCurrentTime(): number;
+    /**
+     * Get the total duration of all scheduled animations.
+     */
+    getTotalDuration(): number;
+    /**
+     * Get the underlying Timeline for advanced control.
+     * Use this for direct manipulation of animation timing.
+     */
+    getTimeline(): Timeline;
+    /**
+     * Get the Camera for view control and frame dimensions.
+     * Camera calculates Manim-compatible frame dimensions from pixel resolution.
+     */
+    getCamera(): Camera;
+    /**
+     * Validates and registers animation targets based on lifecycle.
+     * Handles composition animations (Sequence, Parallel) by processing children.
+     */
+    private validateAndRegisterAnimation;
+    /**
+     * Gets children of composition animations (Sequence, Parallel).
+     * Returns empty array for non-composition animations.
+     */
+    private getAnimationChildren;
+}
+
+type PathCommandType = 'Move' | 'Line' | 'Quadratic' | 'Cubic' | 'Close';
+interface PathCommand {
+    type: PathCommandType;
+    end: Vector2;
+    control1?: Vector2;
+    control2?: Vector2;
+}
+
+/**
+ * A class representing a Bezier path, capable of storing standard path commands
+ * (move, line, quadratic curve, cubic curve, close).
+ */
+declare class BezierPath {
+    private commands;
+    private currentPoint;
+    private startPoint;
+    private cachedLength;
+    private segmentLengths;
+    private segmentCDF;
+    /** Invalidates the cached length data. Called after any path modification. */
+    private invalidateCache;
+    /** Builds the cache if not already valid. */
+    private ensureCache;
+    /** Starts a new subpath at the specified point. */
+    moveTo(point: Vector2): void;
+    lineTo(point: Vector2): void;
+    quadraticTo(control: Vector2, end: Vector2): void;
+    cubicTo(control1: Vector2, control2: Vector2, end: Vector2): void;
+    closePath(): void;
+    getCommands(): PathCommand[];
+    getLength(): number;
+    /** Returns the point on the path at the normalized position t (0-1). */
+    getPointAt(t: number): Vector2;
+    getTangentAt(t: number): Vector2;
+    getPoints(count: number): Vector2[];
+    getPointCount(): number;
+    clone(): BezierPath;
+    /** Returns a new BezierPath where all segments are converted to Cubic curves. */
+    toCubic(): BezierPath;
+    static interpolate(path1: BezierPath, path2: BezierPath, t: number): BezierPath;
+    /** Matches the number of points/commands in two paths for morphing. */
+    static matchPoints(path1: BezierPath, path2: BezierPath): [BezierPath, BezierPath];
+    private static fromCommands;
+}
+
+/**
+ * A Mobject that is defined by one or more BezierPaths.
+ * Supports stroke and fill styling, plus VMobject-specific fluent animations.
+ *
+ * Default behavior: visible with white stroke, no fill.
+ * - Stroke: white, width 2 (visible by default)
+ * - Fill: not rendered by default (fillOpacity = 0)
+ *
+ * When .fill(color) is called, the default stroke is disabled unless
+ * .stroke(color, width) was called explicitly.
+ *
+ * Use .stroke(color, width) to add a stroke.
+ * Use .fill(color) to add a fill (opacity defaults to 1).
+ */
+declare class VMobject extends Mobject {
+    protected pathList: BezierPath[];
+    /** Stroke color. Only rendered if strokeWidth > 0. */
+    protected strokeColor: Color;
+    /** Stroke width. Default 2 for visibility. */
+    protected strokeWidth: number;
+    /** Fill color. Only rendered if fillOpacity > 0. */
+    protected fillColor: Color;
+    /** Fill opacity. Default 0 means no fill is rendered. */
+    protected fillOpacity: number;
+    /** Tracks whether stroke() was explicitly called. */
+    protected strokeExplicitlySet: boolean;
+    constructor();
+    get paths(): BezierPath[];
+    set paths(value: BezierPath[]);
+    /**
+     * Gets the stroke color.
+     */
+    getStrokeColor(): Color;
+    /**
+     * Gets the stroke width.
+     */
+    getStrokeWidth(): number;
+    /**
+     * Gets the fill color.
+     */
+    getFillColor(): Color;
+    /**
+     * Gets the fill opacity.
+     */
+    getFillOpacity(): number;
+    /**
+     * Adds a new path to the VMobject.
+     * @param path - The BezierPath to add.
+     * @returns this for chaining.
+     */
+    addPath(path: BezierPath): this;
+    /**
+     * Sets the stroke color and width.
+     * @param color - The stroke color.
+     * @param width - The stroke width. Default is 2.
+     * @returns this for chaining.
+     */
+    stroke(color: Color, width?: number): this;
+    /**
+     * Sets the fill color and opacity.
+     * If stroke was not explicitly set, the default stroke is disabled.
+     * @param color - The fill color.
+     * @param opacity - The fill opacity. Defaults to the color's alpha value.
+     * @returns this for chaining.
+     */
+    fill(color: Color, opacity?: number): this;
+    getPoints(): PathCommand[];
+    setPoints(commands: PathCommand[]): this;
+    private getPointsAsVectors;
+    getBoundingBox(): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    /**
+     * Progressively draws the VMobject's paths from start to end.
+     * Preserves fill throughout the animation.
+     * @param durationSeconds - Animation duration in seconds.
+     * @returns this for chaining.
+     */
+    write(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    /**
+     * Progressively removes the VMobject's paths (reverse of write).
+     * @param durationSeconds - Animation duration in seconds.
+     * @returns this for chaining.
+     */
+    unwrite(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    /**
+     * First draws the stroke progressively (0-50%), then fades in the fill (50-100%).
+     * @param durationSeconds - Animation duration in seconds.
+     * @returns this for chaining.
+     */
+    draw(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+}
+
+type CornerPosition = 'TOP_LEFT' | 'TOP_RIGHT' | 'BOTTOM_LEFT' | 'BOTTOM_RIGHT';
+type Direction = 'RIGHT' | 'LEFT' | 'UP' | 'DOWN';
+type Edge = 'TOP' | 'BOTTOM' | 'LEFT' | 'RIGHT';
+
+/**
+ * A collection of VMobjects that can be manipulated as a single unit.
+ * Uses Scene Graph hierarchy: transforms on parent are inherited by children
+ * via getWorldMatrix() calculation, not by mutating child matrices.
+ */
+declare class VGroup extends VMobject {
+    protected children: VMobject[];
+    constructor(...mobjects: VMobject[]);
+    get length(): number;
+    add(...mobjects: VMobject[]): this;
+    remove(mobject: VMobject): this;
+    clear(): this;
+    getChildren(): VMobject[];
+    get(index: number): VMobject | undefined;
+    pos(x: number, y: number): this;
+    show(): this;
+    hide(): this;
+    /**
+     * Sets the opacity for this VGroup and all children.
+     * @param value - The opacity value (0-1).
+     * @returns this for chaining.
+     */
+    setOpacity(value: number): this;
+    /**
+     * Sets the stroke color and width for this VGroup and all children.
+     * @param color - The stroke color.
+     * @param width - The stroke width. Default is 2.
+     * @returns this for chaining.
+     */
+    stroke(color: Color, width?: number): this;
+    /**
+     * Sets the fill color and opacity for this VGroup and all children.
+     * @param color - The fill color.
+     * @param opacity - The fill opacity. Default is 1 (fully opaque).
+     * @returns this for chaining.
+     */
+    fill(color: Color, opacity?: number): this;
+    getBoundingBox(): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    center(): this;
+    toCorner(corner: CornerPosition, buff?: number): this;
+    arrange(direction?: Direction, buff?: number, shouldCenter?: boolean): this;
+    alignTo(target: VMobject, edge: Edge): this;
+}
+
+declare class Arc extends VMobject {
+    readonly radius: number;
+    readonly startAngle: number;
+    readonly endAngle: number;
+    constructor(radius?: number, startAngle?: number, endAngle?: number);
+    private generatePath;
+}
+
+declare class Circle extends Arc {
+    constructor(radius?: number);
+}
+
+declare class Line extends VMobject {
+    readonly start: Vector2;
+    readonly end: Vector2;
+    constructor(x1?: number, y1?: number, x2?: number, y2?: number);
+    private generatePath;
+}
+
+declare class Point extends Circle {
+    constructor(location?: Vector2);
+}
+
+declare class Polygon extends VMobject {
+    readonly vertices: Vector2[];
+    constructor(vertices: Vector2[]);
+    private generatePath;
+}
+
+declare class Rectangle extends Polygon {
+    readonly width: number;
+    readonly height: number;
+    constructor(width?: number, height?: number);
+}
+
+declare class Arrow extends Line {
+    readonly tipLength: number;
+    readonly tipAngle: number;
+    constructor(x1?: number, y1?: number, x2?: number, y2?: number, tipLength?: number, tipAngle?: number);
+    private addTip;
+}
+
+/**
+ * A VMobject representing a single glyph character.
+ * Converts fontkit glyph path to BezierPath for rendering.
+ */
+declare class Glyph extends VMobject {
+    readonly character: string;
+    readonly glyphId: number;
+    constructor(fontkitGlyph: Glyph$1, character: string, scale: number, offsetX: number, offsetY: number);
+}
+
+/**
+ * Options for configuring Text appearance.
+ */
+interface TextStyle {
+    fontSize: number;
+    color: Color;
+}
+
+/**
+ * A VGroup of vectorized glyphs created from a text string using fontkit.
+ * Each character becomes a Glyph VMobject that can be individually animated.
+ */
+declare class Text extends VGroup {
+    readonly text: string;
+    private style;
+    private fontPath;
+    constructor(text: string, fontPath: string, options?: Partial<TextStyle>);
+    private buildGlyphs;
+    private getCharacterForGlyph;
+    private applyStyle;
+    setStyle(options: Partial<TextStyle>): this;
+    getStyle(): TextStyle;
+    getGlyph(index: number): Glyph | undefined;
+}
+
+/** Unique identifier for graph nodes. */
+type GraphNodeId = string;
+/** Configuration for creating a graph node. */
+interface NodeConfig {
+    position?: {
+        x: number;
+        y: number;
+    };
+    radius?: number;
+    strokeColor?: Color;
+    strokeWidth?: number;
+    fillColor?: Color;
+    fillOpacity?: number;
+}
+/** Configuration for creating a graph edge. */
+interface EdgeConfig {
+    strokeColor?: Color;
+    strokeWidth?: number;
+    curved?: boolean;
+}
+/** Supported layout algorithms. */
+type LayoutType = 'force-directed' | 'tree' | 'circular';
+/** Configuration for graph layout algorithms. */
+interface LayoutConfig {
+    radius?: number;
+    levelHeight?: number;
+    siblingSpacing?: number;
+    iterations?: number;
+    springLength?: number;
+    repulsion?: number;
+    attraction?: number;
+    damping?: number;
+    minDistance?: number;
+}
+
+/**
+ * A graph node represented as a circular VMobject.
+ * Supports customizable radius, stroke, and fill styling.
+ */
+declare class GraphNode extends VMobject {
+    readonly id: GraphNodeId;
+    private nodeRadius;
+    constructor(id: GraphNodeId, config?: NodeConfig);
+    get radius(): number;
+    /**
+     * Generates a circular BezierPath approximation using cubic Bezier curves.
+     * Uses the standard 4-point circle approximation with control point factor ~0.5523.
+     */
+    private generateCirclePath;
+    getCenter(): Vector2;
+}
+
+/**
+ * A graph edge represented as a BezierPath connecting two nodes.
+ * Supports straight or curved edges with customizable styling.
+ */
+declare class GraphEdge extends VMobject {
+    readonly source: GraphNodeId;
+    readonly target: GraphNodeId;
+    private sourceNode;
+    private targetNode;
+    private curved;
+    constructor(sourceNode: GraphNode, targetNode: GraphNode, config?: EdgeConfig);
+    /**
+     * Recalculates the edge path based on current node positions.
+     * Call this when nodes move to update the edge connection.
+     */
+    updatePath(): void;
+    getPath(): BezierPath | undefined;
+    /**
+     * Updates node references (used when nodes are replaced).
+     */
+    setNodes(sourceNode: GraphNode, targetNode: GraphNode): void;
+}
+
+/**
+ * A graph structure containing nodes and edges.
+ * Manages nodes as VMobjects and edges as BezierPath curves.
+ * Supports multiple layout algorithms for automatic positioning.
+ */
+declare class Graph extends VGroup {
+    private nodes;
+    private edges;
+    constructor();
+    /** Adds a node to the graph. */
+    addNode(id: GraphNodeId, config?: NodeConfig): GraphNode;
+    /** Removes a node and all connected edges from the graph. */
+    removeNode(id: GraphNodeId): this;
+    getNode(id: GraphNodeId): GraphNode | undefined;
+    getNodes(): GraphNode[];
+    addEdge(sourceId: GraphNodeId, targetId: GraphNodeId, config?: EdgeConfig): GraphEdge | undefined;
+    removeEdge(sourceId: GraphNodeId, targetId: GraphNodeId): this;
+    private removeEdgeInternal;
+    getEdgePath(sourceId: GraphNodeId, targetId: GraphNodeId): ReturnType<GraphEdge['getPath']>;
+    getEdges(): GraphEdge[];
+    /** Applies a layout algorithm to reposition all nodes. */
+    layout(type: LayoutType, config?: LayoutConfig): this;
+    updateEdges(): this;
+}
+
+/**
+ * Abstract base class for animations that introduce an object to the scene.
+ *
+ * Introductory animations:
+ * - Automatically register the target with the scene if not already present
+ * - Do not require the target to be in the scene beforehand
+ * - Typically animate opacity or drawing from 0 to visible
+ *
+ * Examples: FadeIn, Write, Draw, GrowFromCenter, SpinIn
+ */
+declare abstract class IntroductoryAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    readonly lifecycle: AnimationLifecycle;
+}
+
+/**
+ * Abstract base class for animations that transform an existing scene object.
+ *
+ * Transformative animations:
+ * - Require the target to already be registered with the scene
+ * - Throw an error if the target is not in the scene
+ * - Operate on objects that are already visible or have been introduced
+ * - Use lazy initialization to capture start state when animation becomes active
+ *
+ * Examples: MoveTo, Rotate, Scale, MorphTo, Transform
+ */
+declare abstract class TransformativeAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    readonly lifecycle: AnimationLifecycle;
+    protected initialized: boolean;
+    /**
+     * Captures the start state from the target.
+     * Called once when the animation first becomes active.
+     */
+    protected abstract captureStartState(): void;
+    ensureInitialized(): void;
+    reset(): void;
+}
+
+/**
+ * Abstract base class for animations that exit/remove an object from the scene.
+ *
+ * Exit animations:
+ * - Require the target to already be registered with the scene
+ * - Throw an error if the target is not in the scene
+ * - Typically animate opacity or scale to 0
+ * - May optionally auto-remove the target from the scene after completion
+ *
+ * Examples: FadeOut, ShrinkToCenter, Uncreate
+ */
+declare abstract class ExitAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    readonly lifecycle: AnimationLifecycle;
+}
+
+/**
+ * Animation that fades a Mobject in by increasing its opacity from 0 to 1.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ * You do not need to call scene.add() before using FadeIn.
+ *
+ * @example
+ * const circle = new Circle(1);
+ * scene.play(new FadeIn(circle));  // Circle is auto-registered and faded in
+ */
+declare class FadeIn<T extends Mobject = Mobject> extends IntroductoryAnimation<T> {
+    private readonly startOpacity;
+    constructor(target: T);
+    interpolate(progress: number): void;
+}
+
+/**
+ * Animation that fades a Mobject out by decreasing its opacity to 0.
+ *
+ * This is an exit animation - the target must already be in the scene.
+ * The starting opacity is captured when the animation first runs,
+ * not when it's constructed, so it correctly fades from the current opacity.
+ *
+ * @example
+ * scene.add(circle);
+ * scene.play(new FadeOut(circle));  // Circle fades out
+ */
+declare class FadeOut<T extends Mobject = Mobject> extends ExitAnimation<T> {
+    private startOpacity;
+    interpolate(progress: number): void;
+}
+
+/**
+ * Animation that moves a Mobject from its current position to a destination.
+ * Uses linear interpolation between start and end positions.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ * Start position is captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(circle);  // or use FadeIn first
+ * scene.play(new MoveTo(circle, 2, 0));  // Move to (2, 0)
+ */
+declare class MoveTo<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
+    private startPosition;
+    private readonly endPosition;
+    constructor(target: T, destination: Vector2);
+    constructor(target: T, x: number, y: number);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    /** Returns the target position of the move animation. */
+    getDestination(): Vector2;
+}
+
+/**
+ * Animation that rotates a Mobject by a specified angle.
+ * Uses linear interpolation between start and end rotation.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ * Start rotation is captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(square);
+ * scene.play(new Rotate(square, Math.PI / 4));  // Rotate 45 degrees
+ */
+declare class Rotate<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
+    private startRotation;
+    private endRotation;
+    private readonly angle;
+    constructor(target: T, angle: number);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    /** Returns the total rotation angle in radians. */
+    getAngle(): number;
+}
+
+/**
+ * Animation that scales a Mobject to a target scale factor.
+ * Uses linear interpolation between start and end scale.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ * Start scale is captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(circle);
+ * scene.play(new Scale(circle, 2));  // Scale to 2x
+ */
+declare class Scale<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
+    private startScale;
+    private readonly endScale;
+    constructor(target: T, factor: number);
+    constructor(target: T, factorX: number, factorY: number);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    /** Returns the scale factor. */
+    getFactor(): number;
+}
+
+/**
+ * Animation that morphs a VMobject from its current shape to a target shape.
+ * Uses BezierPath interpolation for smooth path transitions.
+ *
+ * This is a transformative animation - the source must already be in the scene.
+ * The target VMobject is used only as a shape template and is NOT added to the scene.
+ * Source paths are captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(circle);
+ * scene.play(new MorphTo(circle, square));  // circle morphs into square's shape
+ */
+declare class MorphTo<T extends VMobject = VMobject> extends TransformativeAnimation<T> {
+    private sourcePaths;
+    private readonly targetPaths;
+    constructor(source: T, target: VMobject);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    private getEmptyPath;
+}
+
+/**
+ * Animation that first draws the border progressively, then fills the shape.
+ * The first 50% of the animation draws the stroke, the second 50% fades in the fill.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ *
+ * @example
+ * const rect = new Rectangle(2, 1);
+ * scene.play(new Draw(rect));  // Border draws, then fill fades in
+ */
+declare class Draw<T extends VMobject = VMobject> extends IntroductoryAnimation<T> {
+    private readonly isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    private readonly originalPaths;
+    private readonly originalFillOpacity;
+    private readonly originalOpacity;
+    /** For VGroup targets: original state of each child. */
+    private readonly childStates;
+    constructor(target: T);
+    /** Interpolates stroke drawing (0-0.5) and then fill fade (0.5-1). */
+    interpolate(progress: number): void;
+    /** Interpolates a single VMobject (non-VGroup). */
+    private interpolateVMobject;
+    /** Interpolates a VGroup by animating each child's paths. */
+    private interpolateVGroup;
+}
+
+/**
+ * Animation that progressively draws a VMobject's paths from start to end.
+ * Preserves both stroke and fill properties - the complete object is visible at the end.
+ *
+ * This is the canonical animation for progressive path drawing.
+ * At progress 0, nothing is shown. At progress 1, the complete path is shown.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ *
+ * @example
+ * const circle = new Circle(1);
+ * scene.play(new Write(circle));  // Circle is drawn progressively
+ *
+ * const text = new Text('Hello');
+ * scene.play(new Write(text));  // Text is written progressively
+ */
+declare class Write<T extends VMobject = VMobject> extends IntroductoryAnimation<T> {
+    private readonly isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    private readonly originalPaths;
+    private readonly originalOpacity;
+    private readonly originalFillOpacity;
+    /** For VGroup targets: original state of each child. */
+    private readonly childStates;
+    constructor(target: T);
+    interpolate(progress: number): void;
+    /** Interpolates a single VMobject (non-VGroup). */
+    private interpolateVMobject;
+    /** Interpolates a VGroup by animating each child's paths. */
+    private interpolateVGroup;
+}
+
+/**
+ * Animation that progressively removes a VMobject by erasing the path.
+ * Reverse of Write animation - at progress 0, full object is visible;
+ * at progress 1, nothing is visible.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an exit animation - the target must already be in the scene.
+ *
+ * @example
+ * scene.play(new Write(text));
+ * scene.play(new Unwrite(text));  // Text is erased progressively
+ */
+declare class Unwrite<T extends VMobject = VMobject> extends ExitAnimation<T> {
+    private readonly isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    private readonly originalPaths;
+    private readonly originalOpacity;
+    private readonly originalFillOpacity;
+    /** For VGroup targets: original state of each child. */
+    private readonly childStates;
+    constructor(target: T);
+    interpolate(progress: number): void;
+    /** Interpolates a single VMobject (non-VGroup). */
+    private interpolateVMobject;
+    /** Interpolates a VGroup by animating each child's paths. */
+    private interpolateVGroup;
+}
+
+/**
+ * Supported value types for keyframe interpolation.
+ */
+type KeyframeValue = number;
+/**
+ * A single keyframe with a normalized time position [0,1] and value.
+ */
+interface Keyframe<T extends KeyframeValue = KeyframeValue> {
+    /** Normalized time position in [0, 1]. */
+    readonly time: number;
+    /** The value at this keyframe. */
+    readonly value: T;
+    /** Optional easing function for interpolation TO this keyframe. */
+    readonly easing?: EasingFunction;
+}
+/**
+ * Interpolation function for a specific value type.
+ * Takes start value, end value, and progress [0,1], returns interpolated value.
+ */
+type InterpolatorFn<T> = (start: T, end: T, progress: number) => T;
+
+/**
+ * Manages a sequence of keyframes for animating a single property.
+ * Keyframes are stored sorted by time and interpolated on demand.
+ */
+declare class KeyframeTrack<T extends KeyframeValue = number> {
+    private keyframes;
+    private readonly interpolator;
+    /**
+     * Creates a new KeyframeTrack with the specified interpolator.
+     * Defaults to linear number interpolation.
+     */
+    constructor(interpolator?: InterpolatorFn<T>);
+    /**
+     * Adds a keyframe at the specified normalized time.
+     * Time must be in [0, 1]. Replaces existing keyframe at same time.
+     */
+    addKeyframe(time: number, value: T, easing?: EasingFunction): this;
+    removeKeyframe(time: number): boolean;
+    /**
+     * Gets the keyframe at the specified time.
+     * Returns undefined if no keyframe exists at that time.
+     */
+    getKeyframe(time: number): Keyframe<T> | undefined;
+    /** All keyframes sorted by time. */
+    getKeyframes(): ReadonlyArray<Keyframe<T>>;
+    /** Interpolated value at normalized time (uses target keyframe easing). */
+    getValueAt(time: number): T;
+    getKeyframeCount(): number;
+}
+
+/**
+ * Property setter function type for applying values to a Mobject.
+ */
+type PropertySetter<T extends Mobject, V> = (target: T, value: V) => void;
+/**
+ * Animation that interpolates multiple property tracks via keyframes.
+ * Each track controls a single property and is interpolated independently.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ */
+declare class KeyframeAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    private readonly tracks;
+    readonly lifecycle: AnimationLifecycle;
+    /**
+     * Adds a named keyframe track with its property setter.
+     * The setter is called during interpolation to apply values to the target.
+     */
+    addTrack<V extends KeyframeValue>(name: string, track: KeyframeTrack<V>, setter: PropertySetter<T, V>): this;
+    /** Gets a track by name. */
+    getTrack<V extends KeyframeValue>(name: string): KeyframeTrack<V> | undefined;
+    /** All track names. */
+    getTrackNames(): string[];
+    /**
+     * Interpolates all tracks at the given progress and applies values to target.
+     */
+    interpolate(progress: number): void;
+}
+
+/**
+ * Configuration options for the Follow animation.
+ */
+interface FollowConfig {
+    /**
+     * Offset from the target's position. The camera will track
+     * (target.position + offset) instead of the exact target position.
+     * @default Vector2.ZERO
+     */
+    offset?: Vector2;
+    /**
+     * Damping factor for smooth following (0 to 1).
+     * - 0 = instant snap to target (no smoothing)
+     * - 0.9 = very smooth, slow following
+     * Higher values create a more "laggy" camera that takes longer to catch up.
+     * @default 0
+     */
+    damping?: number;
+}
+/**
+ * Animation that makes a CameraFrame track a target Mobject's position over time.
+ * Unlike MoveTo which captures position once, Follow reads the target position
+ * every frame, allowing the camera to track moving objects.
+ *
+ * @example
+ * // Basic follow - camera snaps to target position
+ * this.play(new Follow(this.frame, movingCircle).duration(5));
+ *
+ * @example
+ * // Smooth follow with damping
+ * this.play(new Follow(this.frame, player, { damping: 0.8 }).duration(10));
+ *
+ * @example
+ * // Follow with offset (camera leads the target)
+ * this.play(new Follow(this.frame, car, {
+ *   offset: new Vector2(2, 0),  // Camera 2 units ahead
+ *   damping: 0.5
+ * }).duration(10));
+ */
+declare class Follow extends Animation<CameraFrame> {
+    readonly lifecycle: AnimationLifecycle;
+    private readonly followTarget;
+    private readonly offset;
+    private readonly damping;
+    /**
+     * Creates a new Follow animation.
+     *
+     * @param frame - The CameraFrame to animate
+     * @param target - The Mobject to follow
+     * @param config - Configuration options
+     * @throws Error if frame is null or undefined
+     * @throws Error if target is null or undefined
+     *
+     * @example
+     * const follow = new Follow(scene.frame, player, { damping: 0.7 });
+     * this.play(follow.duration(10));
+     */
+    constructor(frame: CameraFrame, target: Mobject, config?: FollowConfig);
+    /**
+     * Updates the camera position each frame to track the target.
+     * @param progress - Animation progress (0 to 1)
+     */
+    interpolate(progress: number): void;
+}
+
+/**
+ * Configuration options for the Shake animation.
+ */
+interface ShakeConfig {
+    /**
+     * Maximum displacement distance in world units.
+     * Higher values create more violent shaking.
+     * @default 0.2
+     */
+    intensity?: number;
+    /**
+     * Number of oscillations per second.
+     * Higher values create faster, more frantic shaking.
+     * @default 10
+     */
+    frequency?: number;
+    /**
+     * Controls how quickly the shake diminishes over time.
+     * - 0 = no decay (constant intensity throughout)
+     * - 1 = linear decay
+     * - Higher values = faster decay (shake fades quickly)
+     * @default 1
+     */
+    decay?: number;
+}
+/**
+ * Camera shake effect animation.
+ * Creates procedural displacement using layered sine waves to simulate
+ * impacts, explosions, or earthquakes.
+ *
+ * The shake automatically returns to the original position when complete.
+ *
+ * @example
+ * // Basic shake effect
+ * this.play(new Shake(this.frame).duration(0.5));
+ *
+ * @example
+ * // Intense explosion shake with quick decay
+ * this.play(new Shake(this.frame, {
+ *   intensity: 0.5,
+ *   frequency: 20,
+ *   decay: 2
+ * }).duration(0.3));
+ *
+ * @example
+ * // Subtle earthquake with slow decay
+ * this.play(new Shake(this.frame, {
+ *   intensity: 0.1,
+ *   frequency: 5,
+ *   decay: 0.5
+ * }).duration(3));
+ */
+declare class Shake extends TransformativeAnimation<CameraFrame> {
+    private originalPosition;
+    private readonly intensity;
+    private readonly frequency;
+    private readonly decay;
+    private readonly seedX;
+    private readonly seedY;
+    /**
+     * Creates a new Shake animation.
+     *
+     * @param frame - The CameraFrame to shake
+     * @param config - Configuration options for intensity, frequency, and decay
+     *
+     * @example
+     * const shake = new Shake(scene.frame, { intensity: 0.3 });
+     * this.play(shake.duration(0.5));
+     */
+    constructor(frame: CameraFrame, config?: ShakeConfig);
+    /**
+     * Captures the original position before shake begins.
+     */
+    protected captureStartState(): void;
+    /**
+     * Applies procedural shake displacement each frame.
+     * @param progress - Animation progress (0 to 1)
+     */
+    interpolate(progress: number): void;
+    /**
+     * Generates pseudo-random noise using layered sine waves.
+     * @param t - Time value
+     * @param seed - Random seed for variation
+     * @returns Noise value between -1 and 1
+     */
+    private noise;
+}
+
+/**
+ * Scene serialization - the main entry point for serializing/deserializing Scenes.
+ */
+
+/**
+ * Serializes a Scene into a JSON-formatted string.
+ *
+ * Useful for saving scene state to a file or transmitting it over a network.
+ */
+declare function serialize(scene: Scene): string;
+/**
+ * Restores a complete Scene from a JSON-formatted string.
+ */
+declare function deserialize(json: string): Scene;
+
+/**
+ * Supported render output formats.
+ * - sprite: PNG sequence (frame_0000.png, frame_0001.png, ...)
+ * - png: Single PNG frame
+ * - mp4: H.264 video (requires FFmpeg - future)
+ * - webp: Animated WebP (requires FFmpeg - future)
+ * - gif: Animated GIF (requires FFmpeg - future)
+ */
+type RenderFormat = 'sprite' | 'png' | 'mp4' | 'webp' | 'gif';
+/**
+ * Quality presets for rendering.
+ * - production: Full resolution, best quality
+ * - preview: Half resolution for faster preview
+ */
+type RenderQuality = 'production' | 'preview';
+/**
+ * Standard resolution presets.
+ */
+declare const Resolution: {
+    /** 854x480 (16:9) */
+    readonly p480: {
+        readonly width: 854;
+        readonly height: 480;
+    };
+    /** 1280x720 (16:9) */
+    readonly p720: {
+        readonly width: 1280;
+        readonly height: 720;
+    };
+    /** 1920x1080 (16:9) */
+    readonly p1080: {
+        readonly width: 1920;
+        readonly height: 1080;
+    };
+    /** 3840x2160 (16:9) */
+    readonly p4K: {
+        readonly width: 3840;
+        readonly height: 2160;
+    };
+};
+/**
+ * Configuration for rendering.
+ */
+interface RenderConfig {
+    /** Output width in pixels. Defaults to scene width. */
+    width?: number;
+    /** Output height in pixels. Defaults to scene height. */
+    height?: number;
+    /** Frames per second. Defaults to scene frame rate. */
+    frameRate?: number;
+    /** Output format. Defaults to 'sprite'. */
+    format?: RenderFormat;
+    /** Quality preset. Defaults to 'production'. */
+    quality?: RenderQuality;
+    /** Progress callback for render updates. */
+    onProgress?: ProgressCallback;
+}
+/**
+ * Progress information during rendering.
+ */
+interface RenderProgress {
+    /** Current frame being rendered (0-indexed). */
+    currentFrame: number;
+    /** Total number of frames to render. */
+    totalFrames: number;
+    /** Percentage complete (0-100). */
+    percentage: number;
+    /** Elapsed time in milliseconds. */
+    elapsedMs: number;
+    /** Estimated remaining time in milliseconds. */
+    estimatedRemainingMs: number;
+}
+/**
+ * Callback for progress updates during rendering.
+ */
+type ProgressCallback = (progress: RenderProgress) => void;
+
+/**
+ * Main renderer for producing output from Scenes.
+ * Supports multiple output formats and provides progress callbacks.
+ */
+declare class Renderer {
+    /**
+     * Renders a scene to the specified output.
+     *
+     * @param scene The scene to render
+     * @param outputPath Output file or directory path (depends on format)
+     * @param config Optional render configuration
+     */
+    render(scene: Scene, outputPath: string, config?: RenderConfig): Promise<void>;
+    /**
+     * Renders only the last frame of a scene as a PNG.
+     *
+     * @param scene The scene to render
+     * @param outputPath Output PNG file path
+     * @param config Optional render configuration
+     */
+    renderLastFrame(scene: Scene, outputPath: string, config?: RenderConfig): Promise<void>;
+    /**
+     * Resolves partial config with scene defaults.
+     */
+    private resolveConfig;
+    /**
+     * Ensures the directory exists.
+     */
+    private ensureDirectory;
+    /**
+     * Renders a single frame (the last frame of the animation).
+     */
+    private renderSingleFrame;
+}
+
+/**
+ * Renders individual frames from a Scene.
+ * Responsible for drawing mobjects to a canvas at a specific point in time.
+ */
+declare class FrameRenderer {
+    private readonly scene;
+    private readonly width;
+    private readonly height;
+    constructor(scene: Scene, width: number, height: number);
+    /**
+     * Calculates the matrix that transforms Manim world coordinates to screen pixels.
+     *
+     * Manim coordinate system:
+     * - Origin at center of screen
+     * - Y-axis points up
+     * - frameHeight = 8.0 units
+     *
+     * Screen coordinate system:
+     * - Origin at top-left
+     * - Y-axis points down
+     * - Width x Height pixels
+     */
+    private calculateWorldToScreenMatrix;
+    /**
+     * Renders a single frame at the specified time.
+     */
+    renderFrame(time: number): Canvas;
+    /**
+     * Gets the canvas dimensions.
+     */
+    getDimensions(): {
+        width: number;
+        height: number;
+    };
+}
+
+/**
+ * Tracks rendering progress and reports updates via callback.
+ */
+declare class ProgressReporter {
+    private readonly totalFrames;
+    private readonly onProgress?;
+    private readonly startTime;
+    private currentFrame;
+    constructor(totalFrames: number, onProgress?: ProgressCallback);
+    /**
+     * Report progress for the current frame.
+     */
+    reportFrame(frameIndex: number): void;
+    /**
+     * Report rendering complete.
+     */
+    complete(): void;
+}
+
+export { Animation, type AnimationConfig, Arc, Arrow, Camera, type CameraConfig, CameraFrame, Circle, Color, Draw, type EasingFunction, type EdgeConfig, FadeIn, FadeOut, Follow, FrameRenderer, Glyph, Graph, GraphEdge, GraphNode, type GraphNodeId, type Keyframe, KeyframeAnimation, KeyframeTrack, type LayoutConfig, type LayoutType, Line, Mobject, MorphTo, MoveTo, type NodeConfig, Parallel, Point, Polygon, type ProgressCallback, ProgressReporter, Rectangle, type RenderConfig, type RenderFormat, type RenderProgress, type RenderQuality, Renderer, Resolution, type ResolvedCameraConfig, Rotate, Scale, Scene, type SceneConfig, type ScheduledAnimation, Sequence, Shake, Text, type TextStyle, Timeline, type TimelineConfig, Unwrite, VGroup, VMobject, Vector2, Write, clearRegistry, smooth as defaultEasing, deserialize, doubleSmooth, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, exponentialDecay, getEasing, hasEasing, linear, lingering, notQuiteThere, registerEasing, runningStart, rushFrom, rushInto, serialize, slowInto, smooth, thereAndBack, thereAndBackWithPause, unregisterEasing, wiggle };