@redwilly/anima 0.1.24 → 0.1.25

package/dist/index.d.ts

@@ -1,34 +1,4 @@
 import { Glyph as Glyph$1 } from 'fontkit';
-import { Canvas } from '@napi-rs/canvas';
-
-/**
- * A class representing a color with Red, Green, Blue, and Alpha components.
- * RGB values are in the range [0, 255].
- * Alpha value is in the range [0, 1].
- */
-declare class Color {
-    readonly r: number;
-    readonly g: number;
-    readonly b: number;
-    readonly a: number;
-    constructor(r: number, g: number, b: number, a?: number);
-    /**
-     * Creates a Color from a hex string.
-     * Supports formats: #RRGGBB, #RGB, #RRGGBBAA, #RGBA.
-     */
-    static fromHex(hex: string): Color;
-    static fromHSL(h: number, s: number, l: number, a?: number): Color;
-    toHex(): string;
-    toRGBA(): string;
-    lerp(other: Color, t: number): Color;
-    static readonly WHITE: Color;
-    static readonly BLACK: Color;
-    static readonly RED: Color;
-    static readonly GREEN: Color;
-    static readonly BLUE: Color;
-    static readonly YELLOW: Color;
-    static readonly TRANSPARENT: Color;
-}
 
 /**
  * A 2D vector class representing a point or direction in 2D space.
@@ -77,6 +47,80 @@ declare class Matrix3x3 {
     static readonly IDENTITY: Matrix3x3;
 }
 
+/**
+ * A class representing a color with Red, Green, Blue, and Alpha components.
+ * RGB values are in the range [0, 255].
+ * Alpha value is in the range [0, 1].
+ */
+declare class Color {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    /**
+     * Creates a Color from a hex string.
+     * Supports formats: #RRGGBB, #RGB, #RRGGBBAA, #RGBA.
+     */
+    static fromHex(hex: string): Color;
+    static fromHSL(h: number, s: number, l: number, a?: number): Color;
+    toHex(): string;
+    toRGBA(): string;
+    lerp(other: Color, t: number): Color;
+    static readonly WHITE: Color;
+    static readonly BLACK: Color;
+    static readonly RED: Color;
+    static readonly GREEN: Color;
+    static readonly BLUE: Color;
+    static readonly YELLOW: Color;
+    static readonly TRANSPARENT: Color;
+}
+
+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;
+}
+
 /**
  * Type signature for an easing function.
  * Maps a progress value t ∈ [0, 1] to an eased value.
@@ -264,107 +308,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,134 +328,38 @@ 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;
-    /**
-     * 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.
+     * Interpolates all child animations at the given progress.
+     * Each child's progress is scaled based on its duration relative to the container.
      */
-    computeHash(): number;
-}
-
-/**
- * Represents an animation scheduled at a specific time on the Timeline.
- */
-interface ScheduledAnimation {
-    /** The animation to play */
-    readonly animation: Animation;
-    /** Start time in seconds from timeline beginning */
-    readonly startTime: number;
-}
-/**
- * Configuration options for Timeline.
- */
-interface TimelineConfig {
-    /** Whether the timeline loops. Default: false */
-    readonly loop?: boolean;
-}
-
-/**
- * Timeline schedules and controls playback of animations.
- * Animations can be scheduled at specific times and the timeline
- * provides seek/state access for non-linear playback.
- */
-declare class Timeline {
-    private readonly scheduled;
-    private readonly config;
-    private currentTime;
-    constructor(config?: TimelineConfig);
-    /**
-     * Schedule an animation to start at a specific time.
-     * @param animation The animation to schedule
-     * @param startTime Start time in seconds (default: 0)
-     */
-    schedule(animation: Animation, startTime?: number): this;
-    /**
-     * Schedule multiple animations to play in sequence.
-     * First animation starts at the given startTime, subsequent
-     * animations start after the previous one ends.
-     * @param animations Animations to schedule sequentially
-     * @param startTime Start time for the first animation (default: 0)
-     */
-    scheduleSequence(animations: Animation[], startTime?: number): this;
-    /**
-     * Schedule multiple animations to play in parallel.
-     * All animations start at the same time.
-     * @param animations Animations to schedule in parallel
-     * @param startTime Start time for all animations (default: 0)
-     */
-    scheduleParallel(animations: Animation[], startTime?: number): this;
-    /**
-     * Get all scheduled animations with resolved timing information.
-     */
-    private getResolved;
-    /**
-     * Get total duration of the timeline.
-     * Returns the end time of the last animation to finish.
-     */
-    getTotalDuration(): number;
-    /**
-     * Seek to a specific time and update all animations.
-     * @param time Time in seconds to seek to
-     */
-    seek(time: number): void;
-    /**
-     * Get the timeline state at a specific time without modifying the
-     * current playhead position.
-     * @param time Time in seconds
-     */
-    getStateAt(time: number): void;
-    /**
-     * Get the current time of the timeline.
-     */
-    getCurrentTime(): number;
-    /**
-     * Get all scheduled animations.
-     */
-    getScheduled(): readonly ScheduledAnimation[];
-    /**
-     * Check if timeline is configured to loop.
-     */
-    isLooping(): boolean;
-    /**
-     * Clear all scheduled animations.
-     */
-    clear(): void;
+    interpolate(progress: number): void;
+    update(progress: number): void;
 }
 
 /**
@@ -555,686 +402,764 @@ declare class Sequence extends Animation<Mobject> {
 }
 
 /**
- * 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.
+ * Abstract base class for animations that introduce an object to the scene.
  */
-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'.
-     */
+declare abstract class IntroductoryAnimation<T extends Mobject = Mobject> extends Animation<T> {
     readonly lifecycle: AnimationLifecycle;
-    constructor(animations: Animation[]);
-    getDuration(): number;
-    getChildren(): readonly Animation[];
+}
+/**
+ * Abstract base class for animations that transform an existing scene object.
+ */
+declare abstract class TransformativeAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    readonly lifecycle: AnimationLifecycle;
+    protected initialized: boolean;
     /**
-     * Ensures all children are initialized together.
-     * This captures start state for all parallel animations at the same moment.
+     * Captures the start state from the target.
+     * Called once when the animation first becomes active.
      */
+    protected abstract captureStartState(): void;
     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.
-     */
+}
+/**
+ * Abstract base class for animations that exit/remove an object from the scene.
+ */
+declare abstract class ExitAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    readonly lifecycle: AnimationLifecycle;
+}
+
+/**
+ * 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
+ *
+ * This is an introductory animation - it auto-registers the target with 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;
     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;
 }
 
 /**
- * Configuration options for CameraFrame.
+ * Animation that progressively removes a VMobject by erasing the path.
+ * Reverse of Write animation - at progress 0, full object is visible;
+ * at progress 1, nothing is visible.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an exit animation - the target must already be in the scene.
+ *
+ * @example
+ * scene.play(new Write(text));
+ * scene.play(new Unwrite(text));  // Text is erased progressively
  */
-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 Unwrite<T extends VMobject = VMobject> extends ExitAnimation<T> {
+    private readonly isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    private readonly originalPaths;
+    private readonly originalOpacity;
+    private readonly originalFillOpacity;
+    /** For VGroup targets: original state of each child. */
+    private readonly childStates;
+    constructor(target: T);
+    interpolate(progress: number): void;
+    /** Interpolates a single VMobject (non-VGroup). */
+    private interpolateVMobject;
+    /** Interpolates a VGroup by animating each child's paths. */
+    private interpolateVGroup;
 }
+
 /**
- * Camera bounds that limit how far the camera can pan.
+ * 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 Bounds {
-    minX: number;
-    maxX: number;
-    minY: number;
-    maxY: 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;
 }
+
 /**
- * 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)
+ * Animation that fades a Mobject in by increasing its opacity from 0 to 1.
  *
- * The CameraFrame is the primary way to control camera animations in Anima.
- * Access it via `scene.frame` or `scene.camera.frame`.
+ * 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
- * // Zoom in over 1 second
- * this.play(this.frame.zoomIn(2).duration(1));
+ * 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.
  *
- * @example
- * // Pan to center on an object
- * this.play(this.frame.centerOn(circle).duration(0.5));
+ * 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
- * // 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;
+declare class FadeOut<T extends Mobject = Mobject> extends ExitAnimation<T> {
+    private startOpacity;
+    interpolate(progress: number): void;
+}
+
+/**
+ * Animation that moves a Mobject from its current position to a destination.
+ * Uses linear interpolation between start and end positions.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ * Start position is captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(circle);  // or use FadeIn first
+ * scene.play(new MoveTo(circle, 2, 0));  // Move to (2, 0)
+ */
+declare class MoveTo<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
+    private startPosition;
+    private readonly endPosition;
+    constructor(target: T, destination: Vector2);
+    constructor(target: T, x: number, y: number);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    /** Returns the target position of the move animation. */
+    getDestination(): Vector2;
+}
+
+/**
+ * Animation that rotates a Mobject by a specified angle.
+ * Uses linear interpolation between start and end rotation.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ * Start rotation is captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(square);
+ * scene.play(new Rotate(square, Math.PI / 4));  // Rotate 45 degrees
+ */
+declare class Rotate<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
+    private startRotation;
+    private endRotation;
+    private readonly angle;
+    constructor(target: T, angle: number);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    /** Returns the total rotation angle in radians. */
+    getAngle(): number;
+}
+
+/**
+ * Animation that scales a Mobject to a target scale factor.
+ * Uses linear interpolation between start and end scale.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ * Start scale is captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(circle);
+ * scene.play(new Scale(circle, 2));  // Scale to 2x
+ */
+declare class Scale<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
+    private startScale;
+    private readonly endScale;
+    constructor(target: T, factor: number);
+    constructor(target: T, factorX: number, factorY: number);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    /** Returns the scale factor. */
+    getFactor(): number;
+}
+
+/**
+ * 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;
     /**
-     * The current height of the frame in world units, accounting for scale.
-     * @returns The frame height multiplied by the current scale.y
+     * Animates back to the last saved state.
+     * Pops the saved state from the stack.
+     * @throws Error if no state was previously saved
      */
-    get height(): number;
+    restore(durationSeconds?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    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;
     /**
-     * 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
-     *
+     * Queues multiple animations to run in parallel (simultaneously).
+     * Automatically handles both Animation objects and mobject method calls.
      * @example
-     * frame.setScale(2, 2); // Zoom out 2x
-     * frame.setScale(0.5, 0.5); // Zoom in 2x
+     * circle.fadeIn(1).parallel(
+     *     circle.moveTo(100, 50),
+     *     circle.rotate(Math.PI)
+     * ).fadeOut(1);
      */
-    setScale(sx: number, sy: number): this;
+    parallel(...items: (Animation<Mobject> | Mobject)[]): 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);
+     * Computes a CRC32 hash of this mobject's full state.
+     * Used by the segment cache to detect changes.
      */
-    setBounds(minX: number, minY: number, maxX: number, maxY: number): this;
+    computeHash(): number;
+}
+
+/**
+ * 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[]);
     /**
-     * Removes any bounds restrictions on camera movement.
-     *
-     * @returns This CameraFrame for method chaining
-     *
-     * @example
-     * frame.clearBounds(); // Camera can now pan freely
+     * Gets the stroke color.
      */
-    clearBounds(): this;
+    getStrokeColor(): Color;
     /**
-     * Checks if the camera has bounds set.
-     *
-     * @returns True if bounds are set, false otherwise
+     * Gets the stroke width.
      */
-    hasBounds(): boolean;
+    getStrokeWidth(): number;
     /**
-     * Gets the current bounds configuration.
-     *
-     * @returns The bounds object or undefined if no bounds are set
+     * Gets the fill color.
      */
-    getBounds(): Bounds | undefined;
+    getFillColor(): 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)
+     * Gets the fill opacity.
      */
-    pos(x: number, y: number): this;
+    getFillOpacity(): number;
     /**
-     * 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));
+     * Adds a new path to the VMobject.
+     * @param path - The BezierPath to add.
+     * @returns this for chaining.
      */
-    zoomIn(factor?: number): this & {
-        toAnimation(): Animation<Mobject>;
-    };
+    addPath(path: BezierPath): this;
     /**
-     * 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));
+     * Sets the stroke color and width.
+     * @param color - The stroke color.
+     * @param width - The stroke width. Default is 2.
+     * @returns this for chaining.
      */
-    zoomOut(factor?: number): this & {
-        toAnimation(): Animation<Mobject>;
-    };
+    stroke(color: Color, width?: number): this;
     /**
-     * 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));
+     * 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.
      */
-    centerOn(target: Mobject): this & {
-        toAnimation(): Animation<Mobject>;
+    fill(color: Color, opacity?: number): this;
+    getPoints(): PathCommand[];
+    setPoints(commands: PathCommand[]): this;
+    private getPointsAsVectors;
+    getBoundingBox(): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
     };
     /**
-     * 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));
+     * 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.
      */
-    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));
+    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.
      */
-    fitTo(targets: Mobject | Mobject[], margin?: number): this & {
+    unwrite(durationSeconds?: number): this & {
         toAnimation(): Animation<Mobject>;
     };
-    private calculateBounds;
-    private hasGetBoundingBox;
+    /**
+     * 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;
 }
 
 /**
- * Configuration options for Camera.
+ * Configuration options for CameraFrame.
  */
-interface CameraConfig {
-    /** Pixel width for aspect ratio calculation. Default: 1920 */
-    readonly pixelWidth?: number;
-    /** Pixel height for aspect ratio calculation. Default: 1080 */
-    readonly pixelHeight?: number;
+interface CameraFrameConfig {
+    /** Width of the viewport in pixels. Defaults to 1920. */
+    pixelWidth?: number;
+    /** Height of the viewport in pixels. Defaults to 1080. */
+    pixelHeight?: number;
 }
 /**
- * Resolved camera configuration with all defaults applied.
+ * Camera bounds that limit how far the camera can pan.
  */
-interface ResolvedCameraConfig {
-    readonly pixelWidth: number;
-    readonly pixelHeight: number;
+interface Bounds {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
 }
-
 /**
- * Camera manages the view into the scene.
- * Uses CameraFrame (a Mobject) to store transform state, enabling camera animations.
+ * 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 Camera provides both instant manipulation methods (panTo, zoomTo) and
- * access to the CameraFrame for fluent animation APIs.
+ * The CameraFrame is the primary way to control camera animations in Anima.
+ * Access it via `scene.frame` or `scene.camera.frame`.
  *
  * @example
- * // Instant camera manipulation
- * camera.zoomTo(2);
- * camera.panTo(new Vector2(5, 3));
+ * // Zoom in over 1 second
+ * this.play(this.frame.zoomIn(2).duration(1));
  *
  * @example
- * // Animated camera movement via frame
- * this.play(this.frame.zoomIn(2).duration(1));
+ * // 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 Camera {
-    private readonly config;
-    /** The CameraFrame that stores the camera's transform state. Use this for animations. */
-    readonly frame: CameraFrame;
+declare class CameraFrame extends Mobject {
+    private readonly baseWidth;
+    private readonly baseHeight;
+    private bounds?;
     /**
-     * Creates a new Camera with the specified viewport dimensions.
+     * 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)
-     */
-    constructor(config?: CameraConfig);
-    get frameHeight(): number;
-    get frameWidth(): number;
-    get frameYRadius(): number;
-    get frameXRadius(): number;
-    get pixelWidth(): number;
-    get pixelHeight(): number;
-    get position(): Vector2;
-    get zoom(): number;
-    get rotation(): number;
-    pan(delta: Vector2): this;
-    panTo(position: Vector2): this;
-    zoomTo(level: number): this;
-    rotateTo(angle: number): this;
-    getViewMatrix(): Matrix3x3;
-    /**
-     * Transforms a world-space position to screen-space (pixel) coordinates.
-     *
-     * Screen coordinates have origin at top-left, with x increasing right
-     * and y increasing downward.
-     *
-     * @param pos - Position in world coordinates
-     * @returns Position in screen coordinates (pixels)
-     *
-     * @example
-     * const screenPos = camera.worldToScreen(circle.position);
-     * console.log(`Circle is at pixel (${screenPos.x}, ${screenPos.y})`);
-     */
-    worldToScreen(pos: Vector2): Vector2;
-    /**
-     * Transforms a screen-space (pixel) position to world coordinates.
-     * This is the inverse of worldToScreen.
-     *
-     * @param pos - Position in screen coordinates (pixels, origin at top-left)
-     * @returns Position in world coordinates
-     *
-     * @example
-     * // Convert a mouse click position to world coordinates
-     * const worldPos = camera.screenToWorld(new Vector2(mouseX, mouseY));
-     */
-    screenToWorld(pos: Vector2): Vector2;
-    /**
-     * Checks if a world-space position is currently visible within the camera frame.
-     *
-     * @param pos - Position in world coordinates to check
-     * @returns True if the position is within the visible frame bounds
      *
      * @example
-     * if (camera.isInView(object.position)) {
-     *   console.log('Object is visible');
-     * }
-     */
-    isInView(pos: Vector2): boolean;
-    reset(): this;
-    /**
-     * Hashes camera config and the CameraFrame's full transform state.
-     */
-    computeHash(): number;
-}
-
-/**
- * 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.
- *
- * 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.
- */
-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;
-    /**
-     * Add mobjects to the scene and make them immediately visible.
-     * Use this for static elements or backgrounds that should be visible
-     * before any animations begin.
-     */
-    add(...mobjects: Mobject[]): this;
-    /**
-     * Remove mobjects from the scene.
+     * const frame = new CameraFrame({ pixelWidth: 1920, pixelHeight: 1080 });
      */
-    remove(...mobjects: Mobject[]): this;
+    constructor(config?: CameraFrameConfig);
     /**
-     * Check if a mobject is registered with this scene.
+     * The current width of the frame in world units, accounting for scale.
+     * @returns The frame width multiplied by the current scale.x
      */
-    has(mobject: Mobject): boolean;
+    get width(): number;
     /**
-     * Get all mobjects in the scene.
+     * The current height of the frame in world units, accounting for scale.
+     * @returns The frame height multiplied by the current scale.y
      */
-    getMobjects(): readonly Mobject[];
+    get height(): 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.
+     * Sets the scale of the camera frame.
+     * Overrides Mobject.setScale to prevent zero or negative scales.
      *
-     * - 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.
+     * @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
-     * // 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));
+     * frame.setScale(2, 2); // Zoom out 2x
+     * frame.setScale(0.5, 0.5); // Zoom in 2x
      */
-    play(...items: Array<Animation | Mobject>): this;
+    setScale(sx: number, sy: number): this;
     /**
-     * Add a delay before the next play() call.
-     * @param seconds Number of seconds to wait
+     * 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);
      */
-    wait(seconds: number): this;
+    setBounds(minX: number, minY: number, maxX: number, maxY: number): this;
     /**
-     * Get the current playhead time.
+     * Removes any bounds restrictions on camera movement.
+     *
+     * @returns This CameraFrame for method chaining
+     *
+     * @example
+     * frame.clearBounds(); // Camera can now pan freely
      */
-    getCurrentTime(): number;
+    clearBounds(): this;
     /**
-     * Get the total duration of all scheduled animations.
+     * Checks if the camera has bounds set.
+     *
+     * @returns True if bounds are set, false otherwise
      */
-    getTotalDuration(): number;
+    hasBounds(): boolean;
     /**
-     * Get the underlying Timeline for advanced control.
-     * Use this for direct manipulation of animation timing.
+     * Gets the current bounds configuration.
+     *
+     * @returns The bounds object or undefined if no bounds are set
      */
-    getTimeline(): Timeline;
+    getBounds(): Bounds | undefined;
     /**
-     * Get the Camera for view control and frame dimensions.
-     * Camera calculates Manim-compatible frame dimensions from pixel resolution.
+     * 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)
      */
-    getCamera(): Camera;
+    pos(x: number, y: number): this;
     /**
-     * Get the list of segments emitted by play() and wait() calls.
-     * Used by the Renderer for cache-aware segmented rendering.
+     * 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));
      */
-    getSegments(): readonly Segment[];
+    zoomIn(factor?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
     /**
-     * Validates and registers animation targets based on lifecycle.
-     * Handles composition animations (Sequence, Parallel) by processing children.
+     * 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));
      */
-    private validateAndRegisterAnimation;
+    zoomOut(factor?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
     /**
-     * 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
+     * Move the camera to center on a target Mobject.
+     * The camera will smoothly pan so the target is at the center of the frame.
      *
-     * This respects the scene graph hierarchy - children of registered
-     * VGroups are implicitly in scene via their parent.
+     * @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));
      */
-    isInScene(mobject: Mobject): boolean;
+    centerOn(target: Mobject): this & {
+        toAnimation(): Animation<Mobject>;
+    };
     /**
-     * Gets children of composition animations (Sequence, Parallel).
-     * Returns empty array for non-composition animations.
+     * 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));
      */
-    private getAnimationChildren;
+    zoomToPoint(factor: number, point: {
+        x: number;
+        y: number;
+    }): Animation;
     /**
-     * Computes a holistic CRC32 hash for a segment.
-     * Includes camera state, all current mobjects, animations, and timing.
+     * 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));
      */
-    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;
+    fitTo(targets: Mobject | Mobject[], margin?: number): this & {
+        toAnimation(): Animation<Mobject>;
+    };
+    private calculateBounds;
+    private hasGetBoundingBox;
 }
 
 /**
- * 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).
+ * Configuration options for Camera.
  */
-declare class VMobject extends Mobject {
-    protected pathList: BezierPath[];
-    /** Stroke color. Only rendered if strokeWidth > 0. */
-    protected strokeColor: Color;
-    /** Stroke width. Default 2 for visibility. */
-    protected strokeWidth: number;
-    /** Fill color. Only rendered if fillOpacity > 0. */
-    protected fillColor: Color;
-    /** Fill opacity. Default 0 means no fill is rendered. */
-    protected fillOpacity: number;
-    /** Tracks whether stroke() was explicitly called. */
-    protected strokeExplicitlySet: boolean;
-    constructor();
-    get paths(): BezierPath[];
-    set paths(value: BezierPath[]);
-    /**
-     * Gets the stroke color.
-     */
-    getStrokeColor(): Color;
-    /**
-     * Gets the stroke width.
-     */
-    getStrokeWidth(): number;
-    /**
-     * Gets the fill color.
-     */
-    getFillColor(): Color;
-    /**
-     * Gets the fill opacity.
-     */
-    getFillOpacity(): number;
-    /**
-     * Adds a new path to the VMobject.
-     * @param path - The BezierPath to add.
-     * @returns this for chaining.
-     */
-    addPath(path: BezierPath): this;
-    /**
-     * Sets the stroke color and width.
-     * @param color - The stroke color.
-     * @param width - The stroke width. Default is 2.
-     * @returns this for chaining.
-     */
-    stroke(color: Color, width?: number): this;
+interface CameraConfig {
+    /** Pixel width for aspect ratio calculation. Default: 1920 */
+    readonly pixelWidth?: number;
+    /** Pixel height for aspect ratio calculation. Default: 1080 */
+    readonly pixelHeight?: number;
+}
+/**
+ * Resolved camera configuration with all defaults applied.
+ */
+interface ResolvedCameraConfig {
+    readonly pixelWidth: number;
+    readonly pixelHeight: number;
+}
+
+/**
+ * Camera manages the view into the scene.
+ * Uses CameraFrame (a Mobject) to store transform state, enabling camera animations.
+ *
+ * The Camera provides both instant manipulation methods (panTo, zoomTo) and
+ * access to the CameraFrame for fluent animation APIs.
+ *
+ * @example
+ * // Instant camera manipulation
+ * camera.zoomTo(2);
+ * camera.panTo(new Vector2(5, 3));
+ *
+ * @example
+ * // Animated camera movement via frame
+ * this.play(this.frame.zoomIn(2).duration(1));
+ * this.play(this.frame.centerOn(circle).duration(0.5));
+ */
+declare class Camera {
+    private readonly config;
+    /** The CameraFrame that stores the camera's transform state. Use this for animations. */
+    readonly frame: CameraFrame;
     /**
-     * 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(): Vector2;
+    get zoom(): number;
+    get rotation(): number;
+    pan(delta: Vector2): this;
+    panTo(position: Vector2): this;
+    zoomTo(level: number): this;
+    rotateTo(angle: number): this;
+    getViewMatrix(): Matrix3x3;
     /**
-     * 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: Vector2): Vector2;
     /**
-     * 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 Vector2(mouseX, mouseY));
      */
-    unwrite(durationSeconds?: number): this & {
-        toAnimation(): Animation<Mobject>;
-    };
+    screenToWorld(pos: Vector2): Vector2;
     /**
-     * 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: Vector2): 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;
 }
@@ -1297,665 +1222,708 @@ declare class VGroup extends VMobject {
     computeHash(): number;
 }
 
-declare class Arc extends VMobject {
-    readonly radius: number;
-    readonly startAngle: number;
-    readonly endAngle: number;
-    constructor(radius?: number, startAngle?: number, endAngle?: number);
-    private generatePath;
-}
-
-declare class Circle extends Arc {
-    constructor(radius?: number);
-}
-
-declare class Line extends VMobject {
-    readonly start: Vector2;
-    readonly end: Vector2;
-    constructor(x1?: number, y1?: number, x2?: number, y2?: number);
-    private generatePath;
-}
-
-declare class Polygon extends VMobject {
-    readonly vertices: Vector2[];
-    constructor(...points: Array<[number, number]>);
-    private generatePath;
-}
-
-declare class Rectangle extends Polygon {
-    readonly width: number;
-    readonly height: number;
-    constructor(width?: number, height?: number);
-}
-
-declare class Arrow extends Line {
-    readonly tipLength: number;
-    readonly tipAngle: number;
-    constructor(x1?: number, y1?: number, x2?: number, y2?: number, tipLength?: number, tipAngle?: number);
-    private addTip;
-}
-
-/**
- * A VMobject representing a single glyph character.
- * Converts fontkit glyph path to BezierPath for rendering.
- */
-declare class Glyph extends VMobject {
-    readonly character: string;
-    readonly glyphId: number;
-    constructor(fontkitGlyph: Glyph$1, character: string, scale: number, offsetX: number, offsetY: number);
-}
-
-/**
- * A VGroup of vectorized glyphs created from a text string using fontkit.
- * Each character becomes a Glyph VMobject that can be individually animated.
- *
- * Uses VMobject's fill/stroke as the source of truth (same as geometry).
- * Default: white fill, white stroke width 2.
- */
-declare class Text extends VGroup {
-    readonly text: string;
-    private fontSize;
-    private fontPath;
-    constructor(text: string, fontPath?: string, options?: {
-        fontSize?: number;
-    });
-    private buildGlyphs;
-    /** Propagates this Text's fill/stroke to all Glyph children. */
-    private propagate;
-    stroke(color: Color, width?: number): this;
-    fill(color: Color, opacity?: number): this;
-    getFontSize(): number;
-    getGlyph(index: number): Glyph | undefined;
-}
-
-/** Unique identifier for graph nodes. */
-type GraphNodeId = string;
-/** Configuration for creating a graph node. */
-interface NodeConfig {
-    position?: {
-        x: number;
-        y: number;
-    };
-    radius?: number;
-    strokeColor?: Color;
-    strokeWidth?: number;
-    fillColor?: Color;
-    fillOpacity?: number;
-}
-/** Configuration for creating a graph edge. */
-interface EdgeConfig {
-    strokeColor?: Color;
-    strokeWidth?: number;
-    curved?: boolean;
-}
-/** Supported layout algorithms. */
-type LayoutType = 'force-directed' | 'tree' | 'circular';
-/** Configuration for graph layout algorithms. */
-interface LayoutConfig {
-    radius?: number;
-    levelHeight?: number;
-    siblingSpacing?: number;
-    iterations?: number;
-    springLength?: number;
-    repulsion?: number;
-    attraction?: number;
-    damping?: number;
-    minDistance?: number;
-}
-
 /**
- * A graph node represented as a circular VMobject.
- * Supports customizable radius, stroke, and fill styling.
+ * Abstract base class for all animations.
+ * Provides configuration for duration, easing, and delay.
+ * Subclasses must specify their lifecycle category.
  */
-declare class GraphNode extends VMobject {
-    readonly id: GraphNodeId;
-    private nodeRadius;
-    constructor(id: GraphNodeId, config?: NodeConfig);
-    get radius(): 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;
     /**
-     * Generates a circular BezierPath approximation using cubic Bezier curves.
-     * Uses the standard 4-point circle approximation with control point factor ~0.5523.
+     * 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.
      */
-    private generateCirclePath;
-    getCenter(): Vector2;
-}
-
-/**
- * A graph edge represented as a BezierPath connecting two nodes.
- * Supports straight or curved edges with customizable styling.
- */
-declare class GraphEdge extends VMobject {
-    readonly source: GraphNodeId;
-    readonly target: GraphNodeId;
-    private sourceNode;
-    private targetNode;
-    private curved;
-    constructor(sourceNode: GraphNode, targetNode: GraphNode, config?: EdgeConfig);
+    ensureInitialized(): void;
     /**
-     * Recalculates the edge path based on current node positions.
-     * Call this when nodes move to update the edge connection.
+     * Resets the animation to its uninitialized state.
+     * Allows animations to be replayed or looped.
      */
-    updatePath(): void;
-    getPath(): BezierPath | undefined;
+    reset(): void;
+    update(progress: number): void;
     /**
-     * Updates node references (used when nodes are replaced).
+     * Hashes the animation type, config, and target state.
+     * Subclass-specific behavior is captured through the target's hash,
+     * since animations mutate the target.
      */
-    setNodes(sourceNode: GraphNode, targetNode: GraphNode): void;
+    computeHash(): number;
 }
 
 /**
- * A graph structure containing nodes and edges.
- * Manages nodes as VMobjects and edges as BezierPath curves.
- * Supports multiple layout algorithms for automatic positioning.
+ * Animation that morphs a VMobject from its current shape to a target shape.
+ * Uses BezierPath interpolation for smooth path transitions.
+ *
+ * This is a transformative animation - the source must already be in the scene.
+ * The target VMobject is used only as a shape template and is NOT added to the scene.
+ * Source paths are captured lazily when animation becomes active.
+ *
+ * @example
+ * scene.add(circle);
+ * scene.play(new MorphTo(circle, square));  // circle morphs into square's shape
  */
-declare class Graph extends VGroup {
-    private nodes;
-    private edges;
-    constructor();
-    /** Adds a node to the graph. */
-    addNode(id: GraphNodeId, config?: NodeConfig): GraphNode;
-    /** Removes a node and all connected edges from the graph. */
-    removeNode(id: GraphNodeId): this;
-    getNode(id: GraphNodeId): GraphNode | undefined;
-    getNodes(): GraphNode[];
-    addEdge(sourceId: GraphNodeId, targetId: GraphNodeId, config?: EdgeConfig): GraphEdge | undefined;
-    removeEdge(sourceId: GraphNodeId, targetId: GraphNodeId): this;
-    private removeEdgeInternal;
-    getEdgePath(sourceId: GraphNodeId, targetId: GraphNodeId): ReturnType<GraphEdge['getPath']>;
-    getEdges(): GraphEdge[];
-    /** Applies a layout algorithm to reposition all nodes. */
-    layout(type: LayoutType, config?: LayoutConfig): this;
-    updateEdges(): this;
+declare class MorphTo<T extends VMobject = VMobject> extends TransformativeAnimation<T> {
+    private sourcePaths;
+    private readonly targetPaths;
+    constructor(source: T, target: VMobject);
+    protected captureStartState(): void;
+    interpolate(progress: number): void;
+    private getEmptyPath;
 }
 
 /**
- * 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
+ * Supported value types for keyframe interpolation.
  */
-declare abstract class IntroductoryAnimation<T extends Mobject = Mobject> extends Animation<T> {
-    readonly lifecycle: AnimationLifecycle;
+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;
 
 /**
- * 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
+ * Manages a sequence of keyframes for animating a single property.
+ * Keyframes are stored sorted by time and interpolated on demand.
  */
-declare abstract class TransformativeAnimation<T extends Mobject = Mobject> extends Animation<T> {
-    readonly lifecycle: AnimationLifecycle;
-    protected initialized: boolean;
+declare class KeyframeTrack<T extends KeyframeValue = number> {
+    private keyframes;
+    private readonly interpolator;
     /**
-     * Captures the start state from the target.
-     * Called once when the animation first becomes active.
+     * Creates a new KeyframeTrack with the specified interpolator.
+     * Defaults to linear number interpolation.
      */
-    protected abstract captureStartState(): void;
-    ensureInitialized(): void;
-    reset(): void;
+    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;
 }
 
 /**
- * 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
+ * Property setter function type for applying values to a Mobject.
  */
-declare abstract class ExitAnimation<T extends Mobject = Mobject> extends Animation<T> {
-    readonly lifecycle: AnimationLifecycle;
-}
-
+type PropertySetter<T extends Mobject, V> = (target: T, value: V) => void;
 /**
- * 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.
+ * Animation that interpolates multiple property tracks via keyframes.
+ * Each track controls a single property and is interpolated independently.
  *
- * @example
- * const circle = new Circle(1);
- * scene.play(new FadeIn(circle));  // Circle is auto-registered and faded in
+ * This is a transformative animation - the target must already be in the scene.
  */
-declare class FadeIn<T extends Mobject = Mobject> extends IntroductoryAnimation<T> {
-    private readonly startOpacity;
-    constructor(target: T);
+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;
 }
 
 /**
- * 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
+ * Configuration options for the Follow animation.
  */
-declare class FadeOut<T extends Mobject = Mobject> extends ExitAnimation<T> {
-    private startOpacity;
-    interpolate(progress: number): void;
+interface FollowConfig {
+    /**
+     * Offset from the target's position. The camera will track
+     * (target.position + offset) instead of the exact target position.
+     * @default Vector2.ZERO
+     */
+    offset?: Vector2;
+    /**
+     * Damping factor for smooth following (0 to 1).
+     * - 0 = instant snap to target (no smoothing)
+     * - 0.9 = very smooth, slow following
+     * Higher values create a more "laggy" camera that takes longer to catch up.
+     * @default 0
+     */
+    damping?: number;
 }
-
 /**
- * Animation that 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.
+ * 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
- * 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.
+ * // Basic follow - camera snaps to target position
+ * this.play(new Follow(this.frame, movingCircle).duration(5));
  *
- * This is a transformative animation - the target must already be in the scene.
- * Start rotation is captured lazily when animation becomes active.
+ * @example
+ * // Smooth follow with damping
+ * this.play(new Follow(this.frame, player, { damping: 0.8 }).duration(10));
  *
  * @example
- * scene.add(square);
- * scene.play(new Rotate(square, Math.PI / 4));  // Rotate 45 degrees
+ * // 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 Rotate<T extends Mobject = Mobject> extends TransformativeAnimation<T> {
-    private startRotation;
-    private endRotation;
-    private readonly angle;
-    constructor(target: T, angle: number);
-    protected captureStartState(): void;
+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;
-    /** Returns the total rotation angle in radians. */
-    getAngle(): number;
 }
 
 /**
- * Animation that scales a Mobject to a target scale factor.
- * Uses linear interpolation between start and end scale.
- *
- * This is a transformative animation - the target must already be in the scene.
- * Start scale is captured lazily when animation becomes active.
- *
- * @example
- * scene.add(circle);
- * scene.play(new Scale(circle, 2));  // Scale to 2x
+ * Configuration options for the Shake animation.
  */
-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;
+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 morphs a VMobject from its current shape to a target shape.
- * Uses BezierPath interpolation for smooth path transitions.
+ * Camera shake effect animation.
+ * Creates procedural displacement using layered sine waves to simulate
+ * impacts, explosions, or earthquakes.
  *
- * This is a transformative animation - the source must already be in the scene.
- * The target VMobject is used only as a shape template and is NOT added to the scene.
- * Source paths are captured lazily when animation becomes active.
+ * The shake automatically returns to the original position when complete.
  *
  * @example
- * scene.add(circle);
- * scene.play(new MorphTo(circle, square));  // circle morphs into square's shape
+ * // 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 MorphTo<T extends VMobject = VMobject> extends TransformativeAnimation<T> {
-    private sourcePaths;
-    private readonly targetPaths;
-    constructor(source: T, target: VMobject);
+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;
-    private getEmptyPath;
+    /**
+     * 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;
 }
 
 /**
- * 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
- *
- * This is an introductory animation - it auto-registers the target with the scene.
+ * Represents an animation scheduled at a specific time on the Timeline.
  */
-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;
-    private interpolateVGroup;
-    private interpolateGlyphs;
-    /** Interpolates a single VMobject: stroke (0-0.5), then fill (0.5-1). */
-    private interpolateVMobject;
+interface ScheduledAnimation {
+    /** The animation to play */
+    readonly animation: Animation;
+    /** Start time in seconds from timeline beginning */
+    readonly startTime: number;
 }
-
 /**
- * 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.
+ * Configuration options for Timeline.
  */
-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;
+interface TimelineConfig {
+    /** Whether the timeline loops. Default: false */
+    readonly loop?: boolean;
 }
 
 /**
- * Animation that progressively removes a VMobject by erasing the path.
- * Reverse of Write animation - at progress 0, full object is visible;
- * at progress 1, nothing is visible.
- *
- * Supports VGroup (including Text): animates each child's paths progressively.
- *
- * This is an exit animation - the target must already be in the scene.
- *
- * @example
- * scene.play(new Write(text));
- * scene.play(new Unwrite(text));  // Text is erased progressively
+ * 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 Unwrite<T extends VMobject = VMobject> extends ExitAnimation<T> {
-    private readonly isVGroup;
-    /** For non-VGroup targets: original paths on the target itself. */
-    private readonly originalPaths;
-    private readonly originalOpacity;
-    private readonly originalFillOpacity;
-    /** For VGroup targets: original state of each child. */
-    private readonly childStates;
-    constructor(target: T);
-    interpolate(progress: number): void;
-    /** Interpolates a single VMobject (non-VGroup). */
-    private interpolateVMobject;
-    /** Interpolates a VGroup by animating each child's paths. */
-    private interpolateVGroup;
+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;
 }
 
 /**
- * Supported value types for keyframe interpolation.
- */
-type KeyframeValue = number;
-/**
- * A single keyframe with a normalized time position [0,1] and value.
+ * Configuration options for Scene.
  */
-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 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;
 }
+
 /**
- * Interpolation function for a specific value type.
- * Takes start value, end value, and progress [0,1], returns interpolated value.
+ * A Segment represents one independent rendering unit,
+ * corresponding to a single play() or wait() call.
+ *
+ * Its hash is a holistic CRC32 composition of the camera state,
+ * all current mobjects, and the animations for this segment.
  */
-type InterpolatorFn<T> = (start: T, end: T, progress: number) => T;
+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 sequence of keyframes for animating a single property.
- * Keyframes are stored sorted by time and interpolated on demand.
+ * Scene is the core container that manages Mobjects and coordinates animations.
+ * It provides both a simple API for playing animations and access to the
+ * underlying Timeline and Camera for advanced control.
  */
-declare class KeyframeTrack<T extends KeyframeValue = number> {
-    private keyframes;
-    private readonly interpolator;
+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;
     /**
-     * Creates a new KeyframeTrack with the specified interpolator.
-     * Defaults to linear number interpolation.
+     * 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.
      */
-    constructor(interpolator?: InterpolatorFn<T>);
+    add(...mobjects: Mobject[]): this;
     /**
-     * Adds a keyframe at the specified normalized time.
-     * Time must be in [0, 1]. Replaces existing keyframe at same time.
+     * Remove mobjects from the scene.
      */
-    addKeyframe(time: number, value: T, easing?: EasingFunction): this;
-    removeKeyframe(time: number): boolean;
+    remove(...mobjects: Mobject[]): this;
     /**
-     * Gets the keyframe at the specified time.
-     * Returns undefined if no keyframe exists at that time.
+     * Check if a mobject is registered with this scene.
      */
-    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;
+    has(mobject: Mobject): boolean;
+    /**
+     * Get all mobjects in the scene.
+     */
+    getMobjects(): readonly Mobject[];
+    /**
+     * Schedule animations to play at the current playhead position.
+     *
+     * Accepts either Animation objects or Mobjects with queued fluent animations.
+     * When a Mobject is passed, its queued animation chain is automatically extracted.
+     *
+     * - Introductory animations (FadeIn, Create, Draw, Write) auto-register
+     *   their targets with the scene if not already present.
+     * - Transformative animations (MoveTo, Rotate, Scale) require the target
+     *   to already be in the scene, otherwise an error is thrown.
+     *
+     * @example
+     * // ProAPI style
+     * this.play(new FadeIn(circle), new MoveTo(rect, 2, 0));
+     *
+     * // FluentAPI style
+     * circle.fadeIn(1).moveTo(2, 0, 1);
+     * this.play(circle);
+     *
+     * // Mixed
+     * circle.fadeIn(1);
+     * this.play(circle, new FadeIn(rect));
+     */
+    play(...items: Array<Animation | Mobject>): this;
+    /**
+     * Add a delay before the next play() call.
+     * @param seconds Number of seconds to wait
+     */
+    wait(seconds: number): this;
+    /**
+     * Get the current playhead time.
+     */
+    getCurrentTime(): number;
+    /**
+     * Get the total duration of all scheduled animations.
+     */
+    getTotalDuration(): number;
+    /**
+     * Get the underlying Timeline for advanced control.
+     * Use this for direct manipulation of animation timing.
+     */
+    getTimeline(): Timeline;
+    /**
+     * Get the Camera for view control and frame dimensions.
+     * Camera calculates Manim-compatible frame dimensions from pixel resolution.
+     */
+    getCamera(): Camera;
+    /**
+     * Get the list of segments emitted by play() and wait() calls.
+     * Used by the Renderer for cache-aware segmented rendering.
+     */
+    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;
+}
+
+declare class Arc extends VMobject {
+    readonly radius: number;
+    readonly startAngle: number;
+    readonly endAngle: number;
+    constructor(radius?: number, startAngle?: number, endAngle?: number);
+    private generatePath;
+}
+
+declare class Line extends VMobject {
+    readonly start: Vector2;
+    readonly end: Vector2;
+    constructor(x1?: number, y1?: number, x2?: number, y2?: number);
+    private generatePath;
+}
+
+declare class Arrow extends Line {
+    readonly tipLength: number;
+    readonly tipAngle: number;
+    constructor(x1?: number, y1?: number, x2?: number, y2?: number, tipLength?: number, tipAngle?: number);
+    private addTip;
+}
+
+declare class Circle extends Arc {
+    constructor(radius?: number);
+}
+
+declare class Polygon extends VMobject {
+    readonly vertices: Vector2[];
+    constructor(...points: Array<[number, number]>);
+    private generatePath;
+}
+
+declare class Rectangle extends Polygon {
+    readonly width: number;
+    readonly height: number;
+    constructor(width?: number, height?: number);
 }
 
 /**
- * Property setter function type for applying values to a Mobject.
+ * A VMobject representing a single glyph character.
+ * Converts fontkit glyph path to BezierPath for rendering.
  */
-type PropertySetter<T extends Mobject, V> = (target: T, value: V) => void;
+declare class Glyph extends VMobject {
+    readonly character: string;
+    readonly glyphId: number;
+    constructor(fontkitGlyph: Glyph$1, character: string, scale: number, offsetX: number, offsetY: number);
+}
+
 /**
- * Animation that interpolates multiple property tracks via keyframes.
- * Each track controls a single property and is interpolated independently.
+ * A VGroup of vectorized glyphs created from a text string using fontkit.
+ * Each character becomes a Glyph VMobject that can be individually animated.
  *
- * This is a transformative animation - the target must already be in the scene.
+ * Uses VMobject's fill/stroke as the source of truth (same as geometry).
+ * Default: white fill, white stroke width 2.
  */
-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;
+declare class Text extends VGroup {
+    readonly text: string;
+    private fontSize;
+    private fontPath;
+    constructor(text: string, fontPath?: string, options?: {
+        fontSize?: number;
+    });
+    private buildGlyphs;
+    /** Propagates this Text's fill/stroke to all Glyph children. */
+    private propagate;
+    stroke(color: Color, width?: number): this;
+    fill(color: Color, opacity?: number): this;
+    getFontSize(): number;
+    getGlyph(index: number): Glyph | undefined;
 }
 
-/**
- * Configuration options for the Follow animation.
- */
-interface FollowConfig {
-    /**
-     * Offset from the target's position. The camera will track
-     * (target.position + offset) instead of the exact target position.
-     * @default Vector2.ZERO
-     */
-    offset?: Vector2;
-    /**
-     * Damping factor for smooth following (0 to 1).
-     * - 0 = instant snap to target (no smoothing)
-     * - 0.9 = very smooth, slow following
-     * Higher values create a more "laggy" camera that takes longer to catch up.
-     * @default 0
-     */
+/** Unique identifier for graph nodes. */
+type GraphNodeId = string;
+/** Configuration for creating a graph node. */
+interface NodeConfig {
+    position?: {
+        x: number;
+        y: number;
+    };
+    radius?: number;
+    strokeColor?: Color;
+    strokeWidth?: number;
+    fillColor?: Color;
+    fillOpacity?: number;
+}
+/** Configuration for creating a graph edge. */
+interface EdgeConfig {
+    strokeColor?: Color;
+    strokeWidth?: number;
+    curved?: boolean;
+}
+/** Supported layout algorithms. */
+type LayoutType = 'force-directed' | 'tree' | 'circular';
+/** Configuration for graph layout algorithms. */
+interface LayoutConfig {
+    radius?: number;
+    levelHeight?: number;
+    siblingSpacing?: number;
+    iterations?: number;
+    springLength?: number;
+    repulsion?: number;
+    attraction?: number;
     damping?: number;
+    minDistance?: number;
 }
+
 /**
- * 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));
+ * A graph node represented as a circular VMobject.
+ * Supports customizable radius, stroke, and fill styling.
  */
-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);
+declare class GraphNode extends VMobject {
+    readonly id: GraphNodeId;
+    private nodeRadius;
+    constructor(id: GraphNodeId, config?: NodeConfig);
+    get radius(): number;
     /**
-     * Updates the camera position each frame to track the target.
-     * @param progress - Animation progress (0 to 1)
+     * Generates a circular BezierPath approximation using cubic Bezier curves.
+     * Uses the standard 4-point circle approximation with control point factor ~0.5523.
      */
-    interpolate(progress: number): void;
+    private generateCirclePath;
+    getCenter(): Vector2;
 }
 
 /**
- * Configuration options for the Shake animation.
+ * A graph edge represented as a BezierPath connecting two nodes.
+ * Supports straight or curved edges with customizable styling.
  */
-interface ShakeConfig {
-    /**
-     * Maximum displacement distance in world units.
-     * Higher values create more violent shaking.
-     * @default 0.2
-     */
-    intensity?: number;
+declare class GraphEdge extends VMobject {
+    readonly source: GraphNodeId;
+    readonly target: GraphNodeId;
+    private sourceNode;
+    private targetNode;
+    private curved;
+    constructor(sourceNode: GraphNode, targetNode: GraphNode, config?: EdgeConfig);
     /**
-     * Number of oscillations per second.
-     * Higher values create faster, more frantic shaking.
-     * @default 10
+     * Recalculates the edge path based on current node positions.
+     * Call this when nodes move to update the edge connection.
      */
-    frequency?: number;
+    updatePath(): void;
+    getPath(): BezierPath | undefined;
     /**
-     * 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
+     * Updates node references (used when nodes are replaced).
      */
-    decay?: number;
+    setNodes(sourceNode: GraphNode, targetNode: GraphNode): void;
 }
+
 /**
- * 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));
+ * A graph structure containing nodes and edges.
+ * Manages nodes as VMobjects and edges as BezierPath curves.
+ * Supports multiple layout algorithms for automatic positioning.
  */
-declare class Shake extends TransformativeAnimation<CameraFrame> {
-    private originalPosition;
-    private readonly intensity;
-    private readonly frequency;
-    private readonly decay;
-    private readonly seedX;
-    private readonly seedY;
-    /**
-     * Creates a new Shake animation.
-     *
-     * @param frame - The CameraFrame to shake
-     * @param config - Configuration options for intensity, frequency, and decay
-     *
-     * @example
-     * const shake = new Shake(scene.frame, { intensity: 0.3 });
-     * this.play(shake.duration(0.5));
-     */
-    constructor(frame: CameraFrame, config?: ShakeConfig);
-    /**
-     * Captures the original position before shake begins.
-     */
-    protected captureStartState(): void;
-    /**
-     * Applies procedural shake displacement each frame.
-     * @param progress - Animation progress (0 to 1)
-     */
-    interpolate(progress: number): void;
-    /**
-     * Generates pseudo-random noise using layered sine waves.
-     * @param t - Time value
-     * @param seed - Random seed for variation
-     * @returns Noise value between -1 and 1
-     */
-    private noise;
+declare class Graph extends VGroup {
+    private nodes;
+    private edges;
+    constructor();
+    /** Adds a node to the graph. */
+    addNode(id: GraphNodeId, config?: NodeConfig): GraphNode;
+    /** Removes a node and all connected edges from the graph. */
+    removeNode(id: GraphNodeId): this;
+    getNode(id: GraphNodeId): GraphNode | undefined;
+    getNodes(): GraphNode[];
+    addEdge(sourceId: GraphNodeId, targetId: GraphNodeId, config?: EdgeConfig): GraphEdge | undefined;
+    removeEdge(sourceId: GraphNodeId, targetId: GraphNodeId): this;
+    private removeEdgeInternal;
+    getEdgePath(sourceId: GraphNodeId, targetId: GraphNodeId): ReturnType<GraphEdge['getPath']>;
+    getEdges(): GraphEdge[];
+    /** Applies a layout algorithm to reposition all nodes. */
+    layout(type: LayoutType, config?: LayoutConfig): this;
+    updateEdges(): this;
 }
 
 /**
@@ -2093,88 +2061,4 @@ declare class Renderer {
     private renderSegmentToFile;
 }
 
-/**
- * Renders individual frames from a Scene.
- * Responsible for drawing mobjects to a canvas at a specific point in time.
- */
-declare class FrameRenderer {
-    private readonly scene;
-    private readonly width;
-    private readonly height;
-    constructor(scene: Scene, width: number, height: number);
-    /**
-     * Calculates the matrix that transforms Manim world coordinates to screen pixels.
-     *
-     * Manim coordinate system:
-     * - Origin at center of screen
-     * - Y-axis points up
-     * - frameHeight = 8.0 units
-     *
-     * Screen coordinate system:
-     * - Origin at top-left
-     * - Y-axis points down
-     * - Width x Height pixels
-     */
-    private calculateWorldToScreenMatrix;
-    /**
-     * Renders a single frame at the specified time.
-     */
-    renderFrame(time: number): Canvas;
-    /**
-     * Gets the canvas dimensions.
-     */
-    getDimensions(): {
-        width: number;
-        height: number;
-    };
-}
-
-/**
- * Tracks rendering progress and reports updates via callback.
- */
-declare class ProgressReporter {
-    private readonly totalFrames;
-    private readonly onProgress?;
-    private readonly startTime;
-    private currentFrame;
-    constructor(totalFrames: number, onProgress?: ProgressCallback);
-    /**
-     * Report progress for the current frame.
-     */
-    reportFrame(frameIndex: number): void;
-    /**
-     * Report rendering complete.
-     */
-    complete(): void;
-}
-
-/** 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, Glyph, Graph, GraphEdge, GraphNode, type GraphNodeId, type Keyframe, KeyframeAnimation, KeyframeTrack, type LayoutConfig, type LayoutType, Line, Mobject, MorphTo, MoveTo, type NodeConfig, Parallel, Polygon, type ProgressCallback, Rectangle, type RenderConfig, type RenderFormat, type RenderProgress, type RenderQuality, Renderer, Resolution, type ResolvedCameraConfig, Rotate, Scale, Scene, type SceneConfig, type ScheduledAnimation, 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 };