@redwilly/anima 0.1.24 → 0.1.26

package/dist/index.d.ts

@@ -1,6 +1,53 @@
 import { Glyph as Glyph$1 } from 'fontkit';
 import { Canvas } from '@napi-rs/canvas';
 
+/**
+ * Unified vector type for both 2D and 3D usage.
+ * - 2D vectors use z = 0
+ * - 3D vectors use non-zero z when needed
+ */
+declare class Vector {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    constructor(x: number, y: number, z?: number);
+    add(other: Vector): Vector;
+    subtract(other: Vector): Vector;
+    multiply(scalar: number): Vector;
+    dot(other: Vector): number;
+    length(): number;
+    normalize(): Vector;
+    lerp(other: Vector, t: number): Vector;
+    equals(other: Vector, tolerance?: number): boolean;
+    toPlanar(): Vector;
+    static fromPlanar(v: Vector, z?: number): Vector;
+    static readonly ZERO: Vector;
+    static readonly UP: Vector;
+    static readonly DOWN: Vector;
+    static readonly LEFT: Vector;
+    static readonly RIGHT: Vector;
+}
+
+/**
+ * A 4x4 matrix class for 3D affine transforms and projection.
+ * Stored in row-major order.
+ */
+declare class Matrix4x4 {
+    readonly values: Float32Array;
+    constructor(values: number[] | Float32Array);
+    multiply(other: Matrix4x4): Matrix4x4;
+    transformPoint(point: Vector): Vector;
+    transformPoint2D(point: Vector): Vector;
+    inverse(): Matrix4x4;
+    static identity(): Matrix4x4;
+    static translation(tx: number, ty: number, tz?: number): Matrix4x4;
+    static rotationX(angle: number): Matrix4x4;
+    static rotationY(angle: number): Matrix4x4;
+    static rotationZ(angle: number): Matrix4x4;
+    static scale(sx: number, sy: number, sz?: number): Matrix4x4;
+    static readonly IDENTITY: Matrix4x4;
+}
+
 /**
  * A class representing a color with Red, Green, Blue, and Alpha components.
  * RGB values are in the range [0, 255].
@@ -30,51 +77,103 @@ declare class Color {
     static readonly TRANSPARENT: Color;
 }
 
+type PathCommandType = 'Move' | 'Line' | 'Quadratic' | 'Cubic' | 'Close';
+interface PathCommand {
+    type: PathCommandType;
+    end: Vector;
+    control1?: Vector;
+    control2?: Vector;
+}
+
 /**
- * A 2D vector class representing a point or direction in 2D space.
+ * A class representing a Bezier path, capable of storing standard path commands
+ * (move, line, quadratic curve, cubic curve, close).
  */
-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;
+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: Vector): void;
+    lineTo(point: Vector): void;
+    quadraticTo(control: Vector, end: Vector): void;
+    cubicTo(control1: Vector, control2: Vector, end: Vector): void;
+    closePath(): void;
+    getCommands(): PathCommand[];
+    getLength(): number;
+    /** Returns the point on the path at the normalized position t (0-1). */
+    getPointAt(t: number): Vector;
+    getTangentAt(t: number): Vector;
+    getPoints(count: number): Vector[];
+    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 3x3 matrix class for 2D affine transformations.
- * Stored in row-major order:
- * [ 0  1  2 ]
- * [ 3  4  5 ]
- * [ 6  7  8 ]
+ * Context provided to updater functions on each frame evaluation.
  */
-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;
+interface UpdaterContext {
+    /** Absolute scene time in seconds. */
+    readonly time: number;
+    /** Time delta from previous evaluated frame (seconds). */
+    readonly dt: number;
+    /** Monotonic frame index produced by the updater engine. */
+    readonly frame: number;
+    /** The scene currently being evaluated. */
+    readonly scene: Scene;
+    /**
+     * True when evaluation is discontinuous (first frame or backward seek).
+     * Updaters using integrators can use this to reset internal accumulators.
+     */
+    readonly discontinuous: boolean;
+}
+/**
+ * A function that mutates a mobject every evaluated frame.
+ */
+type UpdaterFunction<T extends Mobject = Mobject> = (mobject: T, context: UpdaterContext) => void;
+/**
+ * Public options accepted by Mobject.addUpdater.
+ */
+interface UpdaterOptions {
+    /**
+     * Higher priority runs first. Default: 0.
+     * Ties are resolved by insertion order.
+     */
+    priority?: number;
+    /** Whether this updater starts enabled. Default: true. */
+    enabled?: boolean;
+    /** Optional descriptive label for debugging/introspection. */
+    name?: string;
+}
+/**
+ * Opaque handle returned from addUpdater for later removal/toggling.
+ */
+interface UpdaterHandle {
+    readonly id: number;
+}
+/**
+ * Internal normalized representation stored by each mobject.
+ */
+interface MobjectUpdaterRecord {
+    readonly id: number;
+    readonly order: number;
+    readonly name?: string;
+    readonly fn: UpdaterFunction<Mobject>;
+    priority: number;
+    enabled: boolean;
 }
 
 /**
@@ -264,107 +363,6 @@ 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;
-    setLastDelay(seconds: number): 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;
-    delay(seconds: number): 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;
-    /**
-     * Computes a CRC32 hash of this mobject's full state.
-     * Used by the segment cache to detect changes.
-     */
-    computeHash(): number;
-}
-
 /**
  * Configuration options for animations.
  */
@@ -385,856 +383,887 @@ interface AnimationConfig {
 type AnimationLifecycle = 'introductory' | 'transformative' | 'exit';
 
 /**
- * Abstract base class for all animations.
- * Provides configuration for duration, easing, and delay.
- * Subclasses must specify their lifecycle category.
+ * 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 abstract class Animation<T extends Mobject = Mobject> {
-    protected readonly target: T;
-    protected durationSeconds: number;
-    protected easingFn: EasingFunction;
-    protected delaySeconds: number;
+declare class Parallel extends Animation<Mobject> {
+    private readonly children;
+    private readonly maxChildDuration;
     /**
-     * The lifecycle category of this animation.
-     * Determines how Scene.play() handles scene registration and validation.
+     * The lifecycle of Parallel is 'introductory' only if ALL children are introductory.
+     * Otherwise, it defaults to 'transformative'.
      */
-    abstract readonly lifecycle: AnimationLifecycle;
-    constructor(target: T);
-    duration(seconds: number): this;
-    ease(easing: EasingFunction): this;
-    delay(seconds: number): this;
+    readonly lifecycle: AnimationLifecycle;
+    constructor(animations: Animation[]);
     getDuration(): number;
-    getDelay(): number;
-    getEasing(): EasingFunction;
-    getTarget(): T;
-    getConfig(): AnimationConfig;
-    abstract interpolate(progress: number): void;
+    getChildren(): readonly Animation[];
     /**
-     * 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.
+     * Ensures all children are initialized together.
+     * This captures start state for all parallel animations at the same moment.
      */
     ensureInitialized(): void;
+    reset(): void;
     /**
-     * Resets the animation to its uninitialized state.
-     * Allows animations to be replayed or looped.
+     * Interpolates all child animations at the given progress.
+     * Each child's progress is scaled based on its duration relative to the container.
      */
-    reset(): void;
+    interpolate(progress: number): void;
     update(progress: number): 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;
     /**
-     * Hashes the animation type, config, and target state.
-     * Subclass-specific behavior is captured through the target's hash,
-     * since animations mutate the target.
+     * 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.
      */
-    computeHash(): number;
+    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;
 }
 
 /**
- * Represents an animation scheduled at a specific time on the Timeline.
+ * Abstract base class for animations that introduce an object to the scene.
  */
-interface ScheduledAnimation {
-    /** The animation to play */
-    readonly animation: Animation;
-    /** Start time in seconds from timeline beginning */
-    readonly startTime: number;
+declare abstract class IntroductoryAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    readonly lifecycle: AnimationLifecycle;
 }
 /**
- * Configuration options for Timeline.
+ * Abstract base class for animations that transform an existing scene object.
  */
-interface TimelineConfig {
-    /** Whether the timeline loops. Default: false */
-    readonly loop?: boolean;
+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;
 }
-
 /**
- * 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.
+ * Abstract base class for animations that exit/remove an object from the scene.
  */
-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;
+declare abstract class ExitAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    readonly lifecycle: AnimationLifecycle;
 }
 
 /**
- * Executes animations in sequence, one after another.
- * Total duration equals the sum of all child animation durations.
+ * Animation that first draws the stroke progressively, then fades in the fill.
+ * - First 50%: stroke draws progressively
+ * - Second 50%: fill fades in
  *
- * 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.
+ * - Single VMobject: stroke then fill
+ * - VGroup: all children animate together
+ * - Text (VGroup of Glyphs): Glyphs animate sequentially for handwriting effect
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
  */
-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.
-     */
+declare class Draw<T extends VMobject = VMobject> extends IntroductoryAnimation<T> {
+    private readonly originalPaths;
+    private readonly originalOpacity;
+    private readonly originalStrokeColor;
+    private readonly originalStrokeWidth;
+    private readonly originalFillColor;
+    private readonly originalFillOpacity;
+    private readonly childStates;
+    /** Glyph states for Text children, keyed by the Text VMobject reference. */
+    private readonly glyphStates;
+    constructor(target: T);
+    private createState;
     interpolate(progress: number): void;
-    update(progress: number): void;
+    private interpolateVGroup;
+    private interpolateGlyphs;
+    /** Interpolates a single VMobject: stroke (0-0.5), then fill (0.5-1). */
+    private interpolateVMobject;
 }
 
 /**
- * Executes animations in parallel, all starting at the same time.
- * Total duration equals the maximum of all child animation durations.
+ * 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.
  *
- * This is a composition animation - its lifecycle is determined by its children.
- * By default, uses 'transformative' lifecycle if children are mixed.
+ * Supports VGroup (including Text): animates each child's paths progressively.
  *
- * All children are initialized together before any interpolation begins,
- * ensuring they all capture state at the same moment.
+ * 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 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.
-     */
+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;
-    update(progress: number): void;
+    /** Interpolates a single VMobject (non-VGroup). */
+    private interpolateVMobject;
+    /** Interpolates a VGroup by animating each child's paths. */
+    private interpolateVGroup;
 }
 
 /**
- * Configuration options for CameraFrame.
+ * Animation that progressively draws VMobject paths from start to end.
+ *
+ * - Single VMobject: paths draw progressively
+ * - VGroup: all children animate together with same progress
+ * - Text (VGroup of Glyphs): Glyphs animate sequentially for handwriting effect
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
  */
-interface CameraFrameConfig {
-    /** Width of the viewport in pixels. Defaults to 1920. */
-    pixelWidth?: number;
-    /** Height of the viewport in pixels. Defaults to 1080. */
-    pixelHeight?: number;
+declare class Write<T extends VMobject = VMobject> extends IntroductoryAnimation<T> {
+    private readonly originalPaths;
+    private readonly originalOpacity;
+    private readonly originalStrokeColor;
+    private readonly originalStrokeWidth;
+    private readonly originalFillColor;
+    private readonly originalFillOpacity;
+    private readonly childStates;
+    /** Glyph states for Text children, keyed by the Text VMobject reference. */
+    private readonly glyphStates;
+    constructor(target: T);
+    private createState;
+    interpolate(progress: number): void;
+    private interpolateVGroup;
+    private interpolateGlyphs;
+    /** Applies progress to a single VMobject, updating its paths and style. */
+    private applyProgress;
 }
+
 /**
- * Camera bounds that limit how far the camera can pan.
+ * 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
  */
-interface Bounds {
-    minX: number;
-    maxX: number;
-    minY: number;
-    maxY: number;
+declare class FadeIn<T extends Mobject = Mobject> extends IntroductoryAnimation<T> {
+    private readonly startOpacity;
+    constructor(target: T);
+    interpolate(progress: number): void;
 }
+
 /**
- * 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`.
+ * Animation that fades a Mobject out by decreasing its opacity to 0.
  *
- * @example
- * // Zoom in over 1 second
- * this.play(this.frame.zoomIn(2).duration(1));
+ * 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
- * // 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));
+ * scene.add(circle);
+ * scene.play(new FadeOut(circle));  // Circle fades out
  */
-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;
+declare class FadeOut<T extends Mobject = Mobject> extends ExitAnimation<T> {
+    private startOpacity;
+    interpolate(progress: number): void;
 }
 
 /**
- * Configuration options for Camera.
+ * 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)
  */
-interface CameraConfig {
-    /** Pixel width for aspect ratio calculation. Default: 1920 */
-    readonly pixelWidth?: number;
-    /** Pixel height for aspect ratio calculation. Default: 1080 */
-    readonly pixelHeight?: number;
+declare class MoveTo<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
+    private startPosition;
+    private readonly endPosition;
+    constructor(target: T, destination: Vector);
+    constructor(target: T, x: number, y: number, z?: number);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    /** Returns the target position of the move animation. */
+    getDestination(): Vector;
 }
+
 /**
- * Resolved camera configuration with all defaults applied.
+ * 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
  */
-interface ResolvedCameraConfig {
-    readonly pixelWidth: number;
-    readonly pixelHeight: number;
+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;
 }
 
 /**
- * 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.
+ * Animation that scales a Mobject to a target scale factor.
+ * Uses linear interpolation between start and end scale.
  *
- * @example
- * // Instant camera manipulation
- * camera.zoomTo(2);
- * camera.panTo(new Vector2(5, 3));
+ * This is a transformative animation - the target must already be in the scene.
+ * Start scale is captured lazily when animation becomes active.
  *
  * @example
- * // Animated camera movement via frame
- * this.play(this.frame.zoomIn(2).duration(1));
- * this.play(this.frame.centerOn(circle).duration(0.5));
+ * scene.add(circle);
+ * scene.play(new Scale(circle, 2));  // Scale to 2x
  */
-declare class Camera {
-    private readonly config;
-    /** The CameraFrame that stores the camera's transform state. Use this for animations. */
-    readonly frame: CameraFrame;
+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;
+}
+
+/**
+ * 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;
+    setLastDelay(seconds: number): void;
+    isEmpty(): boolean;
+    popLastAnimation(): Animation<Mobject> | null;
+    toAnimation(): Animation<Mobject>;
+    getTotalDuration(): number;
+}
+interface MobjectState {
+    position: Vector;
+    scale: Vector;
+    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: Matrix4x4;
+    protected opacityValue: number;
+    protected animQueue: AnimationQueue | null;
+    protected pointCloud: Vector[];
+    protected submobjects: Mobject[];
+    private savedStates;
+    private logicalRotation;
+    private logicalScale;
+    private updaters;
+    private nextUpdaterId;
+    private nextUpdaterOrder;
+    private updatersEnabled;
+    parent: Mobject | null;
+    constructor();
+    protected getQueue(): AnimationQueue;
+    get matrix(): Matrix4x4;
+    getWorldMatrix(): Matrix4x4;
     /**
-     * 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)
+     * Matrix used by renderer.
+     * Geometry-driven mobjects bake their own transform into points,
+     * so only ancestor matrix transforms should be applied at draw time.
      */
-    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;
+    getRenderMatrix(): Matrix4x4;
+    get position(): Vector;
     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;
+    get scale(): Vector;
+    get opacity(): number;
+    pos(x: number, y: number, z?: number): this;
+    show(): this;
+    hide(): this;
+    setOpacity(value: number): this;
+    setRotation(angle: number): this;
+    setScale(sx: number, sy: number): this;
+    applyMatrix(m: Matrix4x4): this;
+    addSubmobjects(...mobjects: Mobject[]): this;
+    removeSubmobject(mobject: Mobject): this;
+    clearSubmobjects(): this;
+    getSubmobjects(): Mobject[];
+    addUpdater(fn: UpdaterFunction<this>, options?: UpdaterOptions): UpdaterHandle;
+    removeUpdater(handleOrFn: UpdaterHandle | UpdaterFunction<this>): this;
+    clearUpdaters(): this;
+    suspendUpdaters(): this;
+    resumeUpdaters(): this;
+    enableUpdater(handleOrFn: UpdaterHandle | UpdaterFunction<this>): this;
+    disableUpdater(handleOrFn: UpdaterHandle | UpdaterFunction<this>): this;
+    hasActiveUpdaters(recursive?: boolean): boolean;
+    /**
+     * Internal API used by UpdaterEngine.
+     * Returns a deterministic snapshot for current-frame execution.
+     */
+    getUpdaterRecordsSnapshot(): MobjectUpdaterRecord[];
+    private setUpdaterEnabled;
+    protected setPointCloud(points: Array<Vector>): void;
+    protected getPointCloud(): Vector[];
+    saveState(): this;
+    getSavedState(): MobjectState | undefined;
+    clearSavedStates(): this;
     /**
-     * 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));
+     * Animates back to the last saved state.
+     * Pops the saved state from the stack.
+     * @throws Error if no state was previously saved
      */
-    screenToWorld(pos: Vector2): Vector2;
+    restore(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    fadeIn(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    fadeOut(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    moveTo(destination: Vector, durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    moveTo(x: number, y: number, durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    moveTo(x: number, y: number, z: 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;
+    delay(seconds: number): this;
+    toAnimation(): Animation<Mobject>;
+    getQueuedDuration(): number;
+    hasQueuedAnimations(): boolean;
     /**
-     * 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
-     *
+     * Queues multiple animations to run in parallel (simultaneously).
+     * Automatically handles both Animation objects and mobject method calls.
      * @example
-     * if (camera.isInView(object.position)) {
-     *   console.log('Object is visible');
-     * }
+     * circle.fadeIn(1).parallel(
+     *     circle.moveTo(100, 50),
+     *     circle.rotate(Math.PI)
+     * ).fadeOut(1);
      */
-    isInView(pos: Vector2): boolean;
-    reset(): this;
+    parallel(...items: (Animation<Mobject> | Mobject)[]): this;
     /**
-     * Hashes camera config and the CameraFrame's full transform state.
+     * Computes a CRC32 hash of this mobject's full state.
+     * Used by the segment cache to detect changes.
      */
     computeHash(): number;
+    protected applyMatrixToOwnGeometry(m: Matrix4x4): void;
+    protected usesGeometryTransforms(): boolean;
+    private collectGeometryPoints;
+    private getGeometryCenter;
+    private syncLocalMatrixFromGeometry;
+    private updateLogicalStateFromMatrix;
+    private setLocalMatrix;
 }
 
 /**
- * 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;
-}
-
-/**
- * A Segment represents one independent rendering unit,
- * corresponding to a single play() or wait() call.
+ * A Mobject that is defined by one or more BezierPaths.
+ * Supports stroke and fill styling, plus VMobject-specific fluent animations.
  *
- * Its hash is a holistic CRC32 composition of the camera state,
- * all current mobjects, and the animations for this segment.
- */
-interface Segment {
-    /** Zero-based index in the scene's segment list. */
-    readonly index: number;
-    /** Start time in seconds. */
-    readonly startTime: number;
-    /** End time in seconds. */
-    readonly endTime: number;
-    /** Animations scheduled in this segment (empty for wait segments). */
-    readonly animations: readonly Animation[];
-    /** CRC32 hash of camera + mobjects + animations at this point. */
-    readonly hash: 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.
+ * 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 Scene {
-    private readonly config;
-    private readonly mobjects;
-    private readonly timeline;
-    private readonly _camera;
-    private readonly segmentList;
-    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;
+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[]);
     /**
-     * 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.
+     * Gets the stroke color.
      */
-    add(...mobjects: Mobject[]): this;
+    getStrokeColor(): Color;
     /**
-     * Remove mobjects from the scene.
+     * Gets the stroke width.
      */
-    remove(...mobjects: Mobject[]): this;
+    getStrokeWidth(): number;
     /**
-     * Check if a mobject is registered with this scene.
+     * Gets the fill color.
      */
-    has(mobject: Mobject): boolean;
+    getFillColor(): Color;
     /**
-     * Get all mobjects in the scene.
+     * Gets the fill opacity.
      */
-    getMobjects(): readonly Mobject[];
+    getFillOpacity(): number;
     /**
-     * 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));
+     * Adds a new path to the VMobject.
+     * @param path - The BezierPath to add.
+     * @returns this for chaining.
      */
-    play(...items: Array<Animation | Mobject>): this;
+    addPath(path: BezierPath): this;
     /**
-     * Add a delay before the next play() call.
-     * @param seconds Number of seconds to wait
+     * Sets the stroke color and width.
+     * @param color - The stroke color.
+     * @param width - The stroke width. Default is 2.
+     * @returns this for chaining.
      */
-    wait(seconds: number): this;
+    stroke(color: Color, width?: number): this;
     /**
-     * Get the current playhead time.
+     * 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.
      */
-    getCurrentTime(): number;
+    fill(color: Color, opacity?: number): this;
+    getPoints(): PathCommand[];
+    setPoints(commands: PathCommand[]): this;
+    private getPointsAsVectors;
+    getBoundingBox(): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    protected applyMatrixToOwnGeometry(m: Matrix4x4): void;
     /**
-     * Get the total duration of all scheduled animations.
+     * 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>;
+    };
+    /**
+     * Extends parent hash with VMobject-specific state:
+     * stroke/fill colors, widths, opacity, and path geometry.
+     */
+    computeHash(): number;
+    private syncPointCloudFromPaths;
+}
+
+/**
+ * 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 });
      */
-    getTotalDuration(): number;
+    constructor(config?: CameraFrameConfig);
     /**
-     * Get the underlying Timeline for advanced control.
-     * Use this for direct manipulation of animation timing.
+     * The current width of the frame in world units, accounting for scale.
+     * @returns The frame width multiplied by the current scale.x
      */
-    getTimeline(): Timeline;
+    get width(): number;
     /**
-     * Get the Camera for view control and frame dimensions.
-     * Camera calculates Manim-compatible frame dimensions from pixel resolution.
+     * The current height of the frame in world units, accounting for scale.
+     * @returns The frame height multiplied by the current scale.y
      */
-    getCamera(): Camera;
+    get height(): number;
     /**
-     * Get the list of segments emitted by play() and wait() calls.
-     * Used by the Renderer for cache-aware segmented rendering.
+     * 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
      */
-    getSegments(): readonly Segment[];
+    setScale(sx: number, sy: number): this;
     /**
-     * Validates and registers animation targets based on lifecycle.
-     * Handles composition animations (Sequence, Parallel) by processing children.
+     * 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);
      */
-    private validateAndRegisterAnimation;
+    setBounds(minX: number, minY: number, maxX: number, maxY: number): this;
     /**
-     * Checks if a Mobject is in the scene.
-     * An object is "in scene" if:
-     * - It's directly registered in this.mobjects, OR
-     * - Any ancestor in its parent chain is registered
+     * Removes any bounds restrictions on camera movement.
      *
-     * This respects the scene graph hierarchy - children of registered
-     * VGroups are implicitly in scene via their parent.
+     * @returns This CameraFrame for method chaining
+     *
+     * @example
+     * frame.clearBounds(); // Camera can now pan freely
      */
-    isInScene(mobject: Mobject): boolean;
+    clearBounds(): this;
     /**
-     * Gets children of composition animations (Sequence, Parallel).
-     * Returns empty array for non-composition animations.
+     * Checks if the camera has bounds set.
+     *
+     * @returns True if bounds are set, false otherwise
      */
-    private getAnimationChildren;
+    hasBounds(): boolean;
     /**
-     * Computes a holistic CRC32 hash for a segment.
-     * Includes camera state, all current mobjects, animations, and timing.
+     * Gets the current bounds configuration.
+     *
+     * @returns The bounds object or undefined if no bounds are set
      */
-    private computeSegmentHash;
-}
-
-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[]);
+    getBounds(): Bounds | undefined;
     /**
-     * Gets the stroke color.
+     * 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)
      */
-    getStrokeColor(): Color;
+    pos(x: number, y: number): this;
     /**
-     * Gets the stroke width.
+     * 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));
      */
-    getStrokeWidth(): number;
+    zoomIn(factor?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
     /**
-     * Gets the fill color.
+     * 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));
      */
-    getFillColor(): Color;
+    zoomOut(factor?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
     /**
-     * Gets the fill opacity.
+     * 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));
      */
-    getFillOpacity(): number;
+    centerOn(target: Mobject): this & {
+        toAnimation(): Animation<Mobject>;
+    };
     /**
-     * Adds a new path to the VMobject.
-     * @param path - The BezierPath to add.
-     * @returns this for chaining.
+     * 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));
      */
-    addPath(path: BezierPath): this;
+    zoomToPoint(factor: number, point: {
+        x: number;
+        y: number;
+    }): Animation;
     /**
-     * Sets the stroke color and width.
-     * @param color - The stroke color.
-     * @param width - The stroke width. Default is 2.
-     * @returns this for chaining.
+     * 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));
      */
-    stroke(color: Color, width?: number): this;
+    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 Vector(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;
     /**
-     * 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.
+     * 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)
      */
-    fill(color: Color, opacity?: number): this;
-    getPoints(): PathCommand[];
-    setPoints(commands: PathCommand[]): this;
-    private getPointsAsVectors;
-    getBoundingBox(): {
-        minX: number;
-        maxX: number;
-        minY: number;
-        maxY: number;
-    };
+    constructor(config?: CameraConfig);
+    get frameHeight(): number;
+    get frameWidth(): number;
+    get frameYRadius(): number;
+    get frameXRadius(): number;
+    get pixelWidth(): number;
+    get pixelHeight(): number;
+    get position(): Vector;
+    get zoom(): number;
+    get rotation(): number;
+    pan(delta: Vector): this;
+    panTo(position: Vector): this;
+    zoomTo(level: number): this;
+    rotateTo(angle: number): this;
+    getViewMatrix(): Matrix4x4;
     /**
-     * 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.
+     * 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})`);
      */
-    write(durationSeconds?: number): this & {
-        toAnimation(): Animation<Mobject>;
-    };
+    worldToScreen(pos: Vector): Vector;
     /**
-     * Progressively removes the VMobject's paths (reverse of write).
-     * @param durationSeconds - Animation duration in seconds.
-     * @returns this for chaining.
+     * 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 Vector(mouseX, mouseY));
      */
-    unwrite(durationSeconds?: number): this & {
-        toAnimation(): Animation<Mobject>;
-    };
+    screenToWorld(pos: Vector): Vector;
     /**
-     * First draws the stroke progressively (0-50%), then fades in the fill (50-100%).
-     * @param durationSeconds - Animation duration in seconds.
-     * @returns this for chaining.
+     * 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');
+     * }
      */
-    draw(durationSeconds?: number): this & {
-        toAnimation(): Animation<Mobject>;
-    };
+    isInView(pos: Vector): boolean;
+    reset(): this;
     /**
-     * Extends parent hash with VMobject-specific state:
-     * stroke/fill colors, widths, opacity, and path geometry.
+     * Hashes camera config and the CameraFrame's full transform state.
      */
     computeHash(): number;
 }
@@ -1245,11 +1274,9 @@ 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.
+ * Uses Mobject's submobject hierarchy and recursive geometry transforms.
  */
 declare class VGroup extends VMobject {
-    protected children: VMobject[];
     constructor(...mobjects: VMobject[]);
     get length(): number;
     add(...mobjects: VMobject[]): this;
@@ -1257,7 +1284,6 @@ declare class VGroup extends VMobject {
     clear(): this;
     getChildren(): VMobject[];
     get(index: number): VMobject | undefined;
-    pos(x: number, y: number): this;
     show(): this;
     hide(): this;
     /**
@@ -1290,10 +1316,6 @@ declare class VGroup extends VMobject {
     toCorner(corner: CornerPosition, buff?: number): this;
     arrange(direction?: Direction, buff?: number, shouldCenter?: boolean): this;
     alignTo(target: VMobject, edge: Edge): this;
-    /**
-     * Recursively hashes this VGroup and all children.
-     * Any child state change invalidates segments containing this group.
-     */
     computeHash(): number;
 }
 
@@ -1310,14 +1332,14 @@ declare class Circle extends Arc {
 }
 
 declare class Line extends VMobject {
-    readonly start: Vector2;
-    readonly end: Vector2;
+    readonly start: Vector;
+    readonly end: Vector;
     constructor(x1?: number, y1?: number, x2?: number, y2?: number);
     private generatePath;
 }
 
 declare class Polygon extends VMobject {
-    readonly vertices: Vector2[];
+    readonly vertices: Vector[];
     constructor(...points: Array<[number, number]>);
     private generatePath;
 }
@@ -1417,7 +1439,7 @@ declare class GraphNode extends VMobject {
      * Uses the standard 4-point circle approximation with control point factor ~0.5523.
      */
     private generateCirclePath;
-    getCenter(): Vector2;
+    getCenter(): Vector;
 }
 
 /**
@@ -1455,167 +1477,62 @@ declare class Graph extends VGroup {
     /** 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;
+    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;
 }
 
 /**
- * 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
+ * Abstract base class for all animations.
+ * Provides configuration for duration, easing, and delay.
+ * Subclasses must specify their lifecycle category.
  */
-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;
+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;
+    /**
+     * Hashes the animation type, config, and target state.
+     * Subclass-specific behavior is captured through the target's hash,
+     * since animations mutate the target.
+     */
+    computeHash(): number;
 }
 
 /**
@@ -1640,322 +1557,528 @@ declare class MorphTo<T extends VMobject = VMobject> extends TransformativeAnima
 }
 
 /**
- * Animation that first draws the stroke progressively, then fades in the fill.
- * - First 50%: stroke draws progressively
- * - Second 50%: fill fades in
- *
- * - Single VMobject: stroke then fill
- * - VGroup: all children animate together
- * - Text (VGroup of Glyphs): Glyphs animate sequentially for handwriting effect
+ * 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 an introductory animation - it auto-registers the target with the scene.
+ * This is a transformative animation - the target must already be in the scene.
  */
-declare class Draw<T extends VMobject = VMobject> extends IntroductoryAnimation<T> {
-    private readonly originalPaths;
-    private readonly originalOpacity;
-    private readonly originalStrokeColor;
-    private readonly originalStrokeWidth;
-    private readonly originalFillColor;
-    private readonly originalFillOpacity;
-    private readonly childStates;
-    /** Glyph states for Text children, keyed by the Text VMobject reference. */
-    private readonly glyphStates;
-    constructor(target: T);
-    private createState;
+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;
-    private interpolateVGroup;
-    private interpolateGlyphs;
-    /** Interpolates a single VMobject: stroke (0-0.5), then fill (0.5-1). */
-    private interpolateVMobject;
 }
 
+type FollowOffsetInput = Vector | readonly [number, number] | readonly [number, number, number];
 /**
- * Animation that progressively draws VMobject paths from start to end.
+ * 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.
+     * Accepts:
+     * - `Vector`
+     * - `[x, y]`
+     * - `[x, y, z]`
+     *
+     * Note: camera follow movement is planar, so only x/y affect the CameraFrame position.
+     * If provided, z is accepted for API consistency but ignored by this animation.
+     * @default Vector.ZERO
+     */
+    offset?: FollowOffsetInput;
+    /**
+     * 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.
  *
- * - Single VMobject: paths draw progressively
- * - VGroup: all children animate together with same progress
- * - Text (VGroup of Glyphs): Glyphs animate sequentially for handwriting effect
+ * @example
+ * // Basic follow - camera snaps to target position
+ * this.play(new Follow(this.frame, movingCircle).duration(5));
  *
- * This is an introductory animation - it auto-registers the target with the scene.
+ * @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: [2, 0],  // Camera 2 units ahead
+ *   damping: 0.5
+ * }).duration(10));
+ *
+ * @example
+ * // 3D tuple offset is accepted for consistency, but z is ignored by camera follow
+ * this.play(new Follow(this.frame, car, {
+ *   offset: [2, 0, 1],
+ *   damping: 0.5
+ * }).duration(10));
  */
-declare class Write<T extends VMobject = VMobject> extends IntroductoryAnimation<T> {
-    private readonly originalPaths;
-    private readonly originalOpacity;
-    private readonly originalStrokeColor;
-    private readonly originalStrokeWidth;
-    private readonly originalFillColor;
-    private readonly originalFillOpacity;
-    private readonly childStates;
-    /** Glyph states for Text children, keyed by the Text VMobject reference. */
-    private readonly glyphStates;
-    constructor(target: T);
-    private createState;
+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;
-    private interpolateVGroup;
-    private interpolateGlyphs;
-    /** Applies progress to a single VMobject, updating its paths and style. */
-    private applyProgress;
+    private static normalizeOffset;
+}
+
+/**
+ * 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;
 }
-
 /**
- * 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.
+ * Camera shake effect animation.
+ * Creates procedural displacement using layered sine waves to simulate
+ * impacts, explosions, or earthquakes.
  *
- * Supports VGroup (including Text): animates each child's paths progressively.
+ * The shake automatically returns to the original position when complete.
  *
- * This is an exit animation - the target must already be in the scene.
+ * @example
+ * // Basic shake effect
+ * this.play(new Shake(this.frame).duration(0.5));
  *
  * @example
- * scene.play(new Write(text));
- * scene.play(new Unwrite(text));  // Text is erased progressively
+ * // 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 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);
+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;
-    /** Interpolates a single VMobject (non-VGroup). */
-    private interpolateVMobject;
-    /** Interpolates a VGroup by animating each child's paths. */
-    private interpolateVGroup;
+    /**
+     * 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;
 }
 
 /**
- * Supported value types for keyframe interpolation.
- */
-type KeyframeValue = number;
-/**
- * A single keyframe with a normalized time position [0,1] and value.
+ * Represents an animation scheduled at a specific time on the Timeline.
  */
-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;
+interface ScheduledAnimation {
+    /** The animation to play */
+    readonly animation: Animation;
+    /** Start time in seconds from timeline beginning */
+    readonly startTime: number;
 }
 /**
- * Interpolation function for a specific value type.
- * Takes start value, end value, and progress [0,1], returns interpolated value.
+ * Configuration options for Timeline.
  */
-type InterpolatorFn<T> = (start: T, end: T, progress: number) => T;
+interface TimelineConfig {
+    /** Whether the timeline loops. Default: false */
+    readonly loop?: boolean;
+}
 
 /**
- * Manages a sequence of keyframes for animating a single property.
- * Keyframes are stored sorted by time and interpolated on demand.
+ * 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 KeyframeTrack<T extends KeyframeValue = number> {
-    private keyframes;
-    private readonly interpolator;
+declare class Timeline {
+    private readonly scheduled;
+    private readonly config;
+    private currentTime;
+    constructor(config?: TimelineConfig);
     /**
-     * Creates a new KeyframeTrack with the specified interpolator.
-     * Defaults to linear number interpolation.
+     * Schedule an animation to start at a specific time.
+     * @param animation The animation to schedule
+     * @param startTime Start time in seconds (default: 0)
      */
-    constructor(interpolator?: InterpolatorFn<T>);
+    schedule(animation: Animation, startTime?: number): this;
     /**
-     * Adds a keyframe at the specified normalized time.
-     * Time must be in [0, 1]. Replaces existing keyframe at same time.
+     * 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)
      */
-    addKeyframe(time: number, value: T, easing?: EasingFunction): this;
-    removeKeyframe(time: number): boolean;
+    scheduleSequence(animations: Animation[], startTime?: number): this;
     /**
-     * Gets the keyframe at the specified time.
-     * Returns undefined if no keyframe exists at that time.
+     * 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)
      */
-    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;
+    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;
 }
 
 /**
- * Property setter function type for applying values to a Mobject.
+ * Configuration options for Scene.
  */
-type PropertySetter<T extends Mobject, V> = (target: T, value: V) => void;
+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;
+}
+
+/** Protocol for objects that contribute to segment hashing. */
+interface Hashable {
+    computeHash(): number;
+}
+
 /**
- * Animation that interpolates multiple property tracks via keyframes.
- * Each track controls a single property and is interpolated independently.
+ * A Segment represents one independent rendering unit,
+ * corresponding to a single play() or wait() call.
  *
- * This is a transformative animation - the target must already be in the scene.
+ * Its hash is a holistic CRC32 composition of the camera state,
+ * all current mobjects, and the animations for this segment.
  */
-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[];
+interface Segment {
+    /** Zero-based index in the scene's segment list. */
+    readonly index: number;
+    /** Start time in seconds. */
+    readonly startTime: number;
+    /** End time in seconds. */
+    readonly endTime: number;
+    /** Animations scheduled in this segment (empty for wait segments). */
+    readonly animations: readonly Animation[];
+    /** CRC32 hash of camera + mobjects + animations at this point. */
+    readonly hash: number;
+}
+
+/**
+ * Manages a disk-based cache of rendered segment partial files.
+ *
+ * Each segment is stored as a video file keyed by its CRC32 hash.
+ * On re-render, segments whose hashes match an existing file are skipped.
+ */
+declare class SegmentCache {
+    private readonly cacheDir;
+    constructor(cacheDir: string);
+    /** Ensure the cache directory exists. */
+    init(): Promise<void>;
+    /** Check if a rendered segment file exists for the given hash. */
+    has(hash: number): boolean;
+    /** Get the absolute file path for a segment hash. */
+    getPath(hash: number): string;
+    /** Get the cache directory path. */
+    getDir(): string;
     /**
-     * Interpolates all tracks at the given progress and applies values to target.
+     * Remove cached files that are not in the active set.
+     * Call after a full render to clean up stale segments.
      */
-    interpolate(progress: number): void;
+    prune(activeHashes: Set<number>): Promise<void>;
 }
 
 /**
- * Configuration options for the Follow animation.
+ * 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.
  */
-interface FollowConfig {
+declare class Scene {
+    private readonly config;
+    private readonly mobjects;
+    private readonly timeline;
+    private readonly _camera;
+    private readonly updaterEngine;
+    private readonly segmentList;
+    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;
     /**
-     * Offset from the target's position. The camera will track
-     * (target.position + offset) instead of the exact target position.
-     * @default Vector2.ZERO
+     * 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.
      */
-    offset?: Vector2;
+    add(...mobjects: Mobject[]): this;
     /**
-     * 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
+     * Remove mobjects from the scene.
      */
-    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;
+    remove(...mobjects: Mobject[]): this;
     /**
-     * Creates a new Follow animation.
+     * 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.
      *
-     * @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
+     * 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
-     * const follow = new Follow(scene.frame, player, { damping: 0.7 });
-     * this.play(follow.duration(10));
+     * // 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));
      */
-    constructor(frame: CameraFrame, target: Mobject, config?: FollowConfig);
+    play(...items: Array<Animation | Mobject>): this;
     /**
-     * Updates the camera position each frame to track the target.
-     * @param progress - Animation progress (0 to 1)
+     * Add a delay before the next play() call.
+     * @param seconds Number of seconds to wait
      */
-    interpolate(progress: number): void;
-}
-
-/**
- * Configuration options for the Shake animation.
- */
-interface ShakeConfig {
+    wait(seconds: number): this;
     /**
-     * Maximum displacement distance in world units.
-     * Higher values create more violent shaking.
-     * @default 0.2
+     * Get the current playhead time.
      */
-    intensity?: number;
+    getCurrentTime(): number;
     /**
-     * Number of oscillations per second.
-     * Higher values create faster, more frantic shaking.
-     * @default 10
+     * Get the total duration of all scheduled animations.
      */
-    frequency?: number;
+    getTotalDuration(): 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
+     * Evaluates scene state at an absolute time.
+     * Execution order is deterministic:
+     * 1) timeline animations
+     * 2) mobject updaters
      */
-    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;
+    evaluateFrame(time: number): void;
     /**
-     * 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));
+     * Returns true if any scene mobject (or camera frame) has active updaters.
+     * Used by renderer to disable unsafe segment caching.
      */
-    constructor(frame: CameraFrame, config?: ShakeConfig);
+    hasActiveUpdaters(): boolean;
     /**
-     * Captures the original position before shake begins.
+     * Get the underlying Timeline for advanced control.
+     * Use this for direct manipulation of animation timing.
      */
-    protected captureStartState(): void;
+    getTimeline(): Timeline;
     /**
-     * Applies procedural shake displacement each frame.
-     * @param progress - Animation progress (0 to 1)
+     * Get the Camera for view control and frame dimensions.
+     * Camera calculates Manim-compatible frame dimensions from pixel resolution.
      */
-    interpolate(progress: number): void;
+    getCamera(): Camera;
     /**
-     * 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
+     * Get the list of segments emitted by play() and wait() calls.
+     * Used by the Renderer for cache-aware segmented rendering.
      */
-    private noise;
+    getSegments(): readonly Segment[];
+    /**
+     * Validates and registers animation targets based on lifecycle.
+     * Handles composition animations (Sequence, Parallel) by processing children.
+     */
+    private validateAndRegisterAnimation;
+    /**
+     * Checks if a Mobject is in the scene.
+     * An object is "in scene" if:
+     * - It's directly registered in this.mobjects, OR
+     * - Any ancestor in its parent chain is registered
+     *
+     * This respects the scene graph hierarchy - children of registered
+     * VGroups are implicitly in scene via their parent.
+     */
+    isInScene(mobject: Mobject): boolean;
+    /**
+     * Computes a holistic CRC32 hash for a segment.
+     * Includes camera state, all current mobjects, animations, and timing.
+     */
+    private computeSegmentHash;
 }
 
 /**
@@ -2148,33 +2271,4 @@ declare class ProgressReporter {
     complete(): void;
 }
 
-/** Protocol for objects that contribute to segment hashing. */
-interface Hashable {
-    computeHash(): number;
-}
-
-/**
- * Manages a disk-based cache of rendered segment partial files.
- *
- * Each segment is stored as a video file keyed by its CRC32 hash.
- * On re-render, segments whose hashes match an existing file are skipped.
- */
-declare class SegmentCache {
-    private readonly cacheDir;
-    constructor(cacheDir: string);
-    /** Ensure the cache directory exists. */
-    init(): Promise<void>;
-    /** Check if a rendered segment file exists for the given hash. */
-    has(hash: number): boolean;
-    /** Get the absolute file path for a segment hash. */
-    getPath(hash: number): string;
-    /** Get the cache directory path. */
-    getDir(): string;
-    /**
-     * Remove cached files that are not in the active set.
-     * Call after a full render to clean up stale segments.
-     */
-    prune(activeHashes: Set<number>): Promise<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 Hashable, type Keyframe, KeyframeAnimation, KeyframeTrack, type LayoutConfig, type LayoutType, Line, Mobject, MorphTo, MoveTo, type NodeConfig, Parallel, Polygon, type ProgressCallback, ProgressReporter, Rectangle, type RenderConfig, type RenderFormat, type RenderProgress, type RenderQuality, Renderer, Resolution, type ResolvedCameraConfig, Rotate, Scale, Scene, type SceneConfig, type ScheduledAnimation, type Segment, SegmentCache, Sequence, Shake, Text, Timeline, type TimelineConfig, Unwrite, VGroup, VMobject, Vector2, Write, clearRegistry, smooth as defaultEasing, 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, slowInto, smooth, thereAndBack, thereAndBackWithPause, unregisterEasing, wiggle };
+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 Hashable, type Keyframe, KeyframeAnimation, KeyframeTrack, type LayoutConfig, type LayoutType, Line, Mobject, MorphTo, MoveTo, type NodeConfig, Parallel, Polygon, type ProgressCallback, ProgressReporter, Rectangle, type RenderConfig, type RenderFormat, type RenderProgress, type RenderQuality, Renderer, Resolution, type ResolvedCameraConfig, Rotate, Scale, Scene, type SceneConfig, type ScheduledAnimation, type Segment, SegmentCache, Sequence, Shake, Text, Timeline, type TimelineConfig, Unwrite, type UpdaterContext, type UpdaterFunction, type UpdaterHandle, type UpdaterOptions, VGroup, VMobject, Vector, Write, clearRegistry, smooth as defaultEasing, 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, slowInto, smooth, thereAndBack, thereAndBackWithPause, unregisterEasing, wiggle };