@weasel-js/animator 1.10.1 → 1.11.1

package/dist/types-QKD4dhHF.d.ts

@@ -0,0 +1,970 @@
+import { EasingSpec, SpringPresetName } from '@weasel-js/geom';
+
+/**
+ * What an axis of a `T` goes by: a field of a plain object, or a path into a nested one, as a
+ * pose's `knee` and `knee.rotation` are. `never` for a number or an array, whose axes have
+ * indexes only.
+ */
+type AxisName<T> = T extends number | readonly unknown[] ? never : T extends object ? {
+    [K in keyof T & string]: NonNullable<T[K]> extends number ? K : K | `${K}.${string}`;
+}[keyof T & string] : string;
+/** One of a target's axes: its index, or its name where the target's axes have names. */
+type AxisRef<T = unknown> = number | AxisName<T>;
+
+/** How a target's value maps to the flat numbers an animation moves, and back. */
+interface TargetAxes<T> {
+    count: number;
+    to(value: T): number[];
+    from(axes: ArrayLike<number>): T;
+    /** Indexes of axes that are angles in radians. An animation starting from one takes the short
+     *  way round to its destination. */
+    angles?: readonly number[];
+    /** A name for each axis, in the order `to` answers them, for `axes` options to go by. A dot
+     *  makes a path: `knee.rotation` is also reached as `knee`, with the joint's other axes. */
+    names?: readonly string[];
+    /** Optional. `value` with `delta` added axis by axis: what `from` answers for `to(value)`
+     *  plus `delta`, built with no array between. A read of a moving target goes through it. */
+    add?(value: T, delta: ArrayLike<number>): T;
+    /** Optional. Puts `value`'s axes into `out` from `at`: what `to` answers, with no array
+     *  built. `readInto` goes through it. */
+    write?(value: T, out: AxisBuffer, at: number): void;
+}
+/** Somewhere a target's axes are written as numbers. */
+type AxisBuffer = Float64Array | Float32Array | number[];
+/** What {@link createTarget} takes. */
+interface TargetOptions<T> {
+    /** The committed value: what shows when nothing is animating. */
+    get(): T;
+    /** Commits a value: an animation's destination as it starts, and where a canceled one stopped. */
+    set(value: T): void;
+    /** How `T` maps to numbers. Default: a number, an array of numbers, or a plain object whose
+     *  fields are all numbers, read from `get()` when the target is made. */
+    axes?: TargetAxes<T>;
+    /** Called once a frame, after the frame's animations, with the value to show: on every frame
+     *  the target is moving, as an animation starts on it or is redirected, and once more as it
+     *  comes to rest. Omit for a target whose reader
+     *  calls `read()` itself. */
+    show?(value: T): void;
+    /** Called once a frame, after every target that was shown that frame: for a table that
+     *  publishes many targets at once. Targets passing the same function share one call. */
+    publish?(): void;
+}
+/**
+ * One value an animator can move. Pass it as `target` to `tween`, `spring`, `physics` or `decay`.
+ *
+ * An animation on a target commits its destination when it starts and contributes only what is
+ * left to travel, so several on one target add: a second started mid-flight bends the motion
+ * toward its own destination and neither cancels the other.
+ */
+interface Target<T> {
+    /** The value to show: the committed value plus what every running animation has left to travel. */
+    read(): T;
+    /**
+     * As `read`, as numbers: writes the value's `axisCount` axes into `out` from `at` (default 0),
+     * in the order the target's `axes.to` answers them. For a reader of many targets that wants
+     * the numbers and no value built for each.
+     */
+    readInto(out: AxisBuffer, at?: number): void;
+    /** How many axes `readInto` writes. */
+    readonly axisCount: number;
+    /** How its value maps to numbers. */
+    readonly axes: TargetAxes<T>;
+    /**
+     * The indexes of the axes `axes` names, in the order named: what a hold's or a track's `axes`
+     * resolves through. A name is one of `axes.names`, or a path over several of them; an index
+     * passes through. Throws on a name or an index the target has no axis for.
+     */
+    axisIndexes(axes: readonly AxisRef<T>[]): number[];
+    /** The committed value: what shows once nothing is moving it. */
+    committed(): T;
+    /** Writes the committed value. Animations moving the target go on adding to the new one. */
+    commit(value: T): void;
+    /** Whether any animation is moving it. */
+    readonly active: boolean;
+    /**
+     * Stops every animation moving it. Each commits where it was, so the value on screen stays,
+     * unless `commit` is false: then the committed value is left as it stands and the target
+     * shows it. Pass false after something else has written the committed value mid-flight.
+     */
+    stop(opts?: {
+        commit?: boolean;
+    }): void;
+}
+/** Make a {@link Target} over a value the caller owns. */
+declare function createTarget<T>(opts: TargetOptions<T>): Target<T>;
+
+/** Which of a node's two per-anchor color arrays an override applies to. */
+type VertexColorChannel = 'fill' | 'stroke';
+/** Function-form override: receives the consumer-supplied base color
+ *  array and the current animation timestamp (ms, from the animator's
+ *  clock). Returns a flat RGBA float array (values in 0..1, matching
+ *  the renderer's `stroke.vertexColors` / `PathDrawCommand.vertexColors`
+ *  color space) of the same length as `base`. */
+type ColorOverrideFn = (base: readonly number[], tMs: number) => number[];
+/** Either a static per-anchor RGBA float array (0..1) or a function-form
+ *  override (see {@link ColorOverrideFn}). */
+type ColorOverride = readonly number[] | ColorOverrideFn;
+/** Per-node, per-channel store of color overrides. Attached to `useAnimator` as
+ *  `animator.colorOverrides`; painted onto scene nodes by `<SceneCanvas animator>`
+ *  and onto a `createPathLayer`'s nodes by its `colorOverrides` option. */
+declare class ColorOverrideRegistry {
+    private readonly map;
+    private readonly slots;
+    private readonly tables;
+    private _version;
+    set(id: string, channel: VertexColorChannel, override: ColorOverride): void;
+    /** Drops `id`'s override on `channel`, and the colors a finished or canceled animation on its
+     *  {@link target} left painted. An animation still running goes on. */
+    clear(id: string, channel: VertexColorChannel): void;
+    clearAll(): void;
+    /** What `set` stored for `id`'s `channel`; failing that, the colors its {@link target} paints. */
+    get(id: string, channel: VertexColorChannel): ColorOverride | undefined;
+    /** Whether anything overrides `id`, on either channel. */
+    has(id: string): boolean;
+    /**
+     * The {@link Target} for `id`'s colors on `channel`: `length` numbers, flat RGBA per anchor.
+     * Every caller for one node and channel gets the same one, so their animations add. The
+     * registry holds its committed colors and nothing writes the scene.
+     *
+     * What it paints: with no override from `set`, its colors in place of the painter's own; over
+     * one, only what its animations have left to travel, added on top. Ask again for each
+     * animation rather than keeping it: {@link release} and {@link clear} drop a resting one, and
+     * the target it had throws from then on.
+     */
+    target(id: string, channel: VertexColorChannel, length: number): Target<number[]>;
+    private tableOf;
+    private drop;
+    /** Drops the colors `id`'s {@link target} on `channel` left painted, unless an animation is
+     *  still moving it. An override from `set` stays. */
+    release(id: string, channel: VertexColorChannel): void;
+    /**
+     * The colors to paint on `id`'s `channel`, given the colors the painter would
+     * otherwise paint and the frame's timestamp. A function override needs that
+     * `base` and must return an array of its length; failing either, `base`
+     * stands. A {@link target} in motion then adds what it has left to travel.
+     */
+    resolve(id: string, channel: VertexColorChannel, base: readonly number[] | undefined, tMs: number): readonly number[] | undefined;
+    private apply;
+    version(): number;
+}
+
+/** One keyframe. `easing` shapes the approach INTO this key from the previous
+ *  one, so the first key's easing is never consulted. */
+interface Keyframe<T> {
+    /** Time within the track's timeline, in ms. */
+    t: number;
+    value: T;
+    /** A function, the name of a built-in, or cubic-bezier control points. */
+    easing?: EasingSpec;
+}
+/** A track sampled as a pure function of the playhead. Scrubbing one is free
+ *  and order-independent. Give it `onTick`, a `target`, or both. */
+interface SampledTrack<T> {
+    kind: 'sampled';
+    label?: string;
+    /** Sorted ascending by `t`. Of keys sharing a time, the last in the array is
+     *  the value at exactly that time. */
+    keys: Keyframe<T>[];
+    /** Required unless the track has a `target`, or every key's value is a number, a number
+     *  array or a plain object of numbers, all of one shape; those are lerped field by field. */
+    interpolate?: Interpolate<T>;
+    /** Built once per segment and cached. Takes precedence over `interpolate`. */
+    interpolator?: InterpolatorFactory<T>;
+    /** Told each sampled value, at any playhead. Optional beside a `target`. */
+    onTick?: (value: T) => void;
+    /**
+     * A value for the track to move. While the playhead is within the track's keys, the target
+     * shows the sampled value in place of its committed one, as under `animator.hold`, with
+     * what an animation on the target shows apart from its destination added on top. Once the playhead is past the last key, or the
+     * timeline finishes or is canceled, the target keeps the value it was showing; before the
+     * first key the track leaves the target alone.
+     *
+     * With no `interpolate` or `interpolator`, the track is sampled in the target's axes: each
+     * axis lerps on its own, an angle axis the short way round from the key before, and every
+     * sample is a value the axes built, a key's own included.
+     */
+    target?: Target<T>;
+    /** What `target` goes by in a clip, for `toClip` to write and a `ClipBinder` to resolve.
+     *  A target has no name of its own. */
+    targetName?: string;
+    /** What `interpolate` goes by in a clip, as `targetName` is for `target`. */
+    interpolateName?: string;
+    /** The track's share among the target's holds, as `HoldOptions.weight`. Default 1. */
+    weight?: number | (() => number);
+    /** What a function `weight` goes by in a clip, as `targetName` is for `target`. */
+    weightName?: string;
+    /** The axes of the target the track holds, by name or by index, as `HoldOptions.axes`.
+     *  Default: every axis. A clip carries them as they are written here. */
+    axes?: readonly AxisRef<T>[];
+}
+/** A clock that events are booked against, reading in ms. An `AudioEngine`
+ *  from `@weasel-js/audio` is one. */
+interface TimelineClock {
+    now(): number;
+}
+/** What `book` hands back so the booking can be retracted. A `VoiceHandle` from
+ *  `@weasel-js/audio` is one. */
+interface EventBookingHandle {
+    stop(): void;
+}
+/** One entry on an `EventTrack`. Give it `fire`, `book`, or both. */
+interface TimelineEvent {
+    /** Time within the track's timeline, in ms. */
+    t: number;
+    /** What the event goes by in a clip: a `ClipBinder` turns it and `data` into `fire` and
+     *  `book`. */
+    name?: string;
+    /** Carried with `name` into a clip. Anything JSON holds. */
+    data?: unknown;
+    /** Runs on the frame that crosses the edge, told how far behind the frame it
+     *  was crossed, in ms — never negative, and measured against `duration` on
+     *  the loop seam, where the outgoing lap's tail fires after the wrap. */
+    fire?: (lateBy: number) => void;
+    /** Runs up to `booking.lookahead` before the edge on a timeline with a
+     *  `booking`, once per crossing, with the `booking.clock` time the edge lands
+     *  at — never earlier than that clock's `now()`. A returned handle is stopped
+     *  if a pause, seek, rate change, loop change, edit or cancel invalidates the
+     *  booking before the clock reaches `when`; the event is then booked again
+     *  wherever playback next reaches it. A booking with no handle stands. */
+    book?: (when: number) => EventBookingHandle | void;
+}
+/** A track of edge crossings, in forward playback only — a `seek` neither
+ *  fires nor books the span it skips. An event the playhead is sitting on,
+ *  after a seek or at the start, fires when playback next advances from there
+ *  and never while paused. */
+interface EventTrack {
+    kind: 'event';
+    label?: string;
+    /** Sorted ascending by `t`. */
+    events: TimelineEvent[];
+}
+/** How a timeline books its events against an outside clock. */
+interface EventBooking {
+    clock: TimelineClock;
+    /** How far ahead of the playhead to book, in clock ms. Default 100. An event
+     *  first reached later than this — after a frame longer than it — books late. */
+    lookahead?: number;
+    /** An event first reached more than this many clock ms after its edge is
+     *  skipped instead of booked late. Default `Infinity`. */
+    maxLate?: number;
+}
+/** A nested timeline, evaluated at `playhead - at`. Children are NOT registered
+ *  with the animator separately; the parent evaluates them. */
+interface TimelineTrack {
+    kind: 'timeline';
+    label?: string;
+    at: number;
+    timeline: NestedTimeline;
+}
+/** Any track a timeline can hold. */
+type Track = SampledTrack<any> | EventTrack | TimelineTrack;
+/** What a child timeline may declare. The parent owns playback, so `loop`,
+ *  `autoplay`, `onDone` and `cancelKey` have no meaning below the root. */
+interface NestedTimeline {
+    tracks: Track[];
+    /** Defaults to the largest end time across `tracks`. */
+    duration?: number;
+}
+/** What `animator.timeline` takes: a root timeline, which owns playback. */
+interface TimelineOptions extends NestedTimeline {
+    /** `true` loops forever, `n` loops n additional times. Default false. */
+    loop?: boolean | number;
+    /** Default true. When false the timeline registers but holds at t=0 until resumed. */
+    autoplay?: boolean;
+    /** Called when playback reaches the end of its last lap. */
+    onDone?: () => void;
+    /** Any new animation passed the same `cancelKey` cancels this one. */
+    cancelKey?: string;
+    /** Names this timeline in `animator.watch` events and `animator.live()`. */
+    label?: string;
+    /** Books each event's `book` against a clock the timeline does not own, so a
+     *  consumer on that clock lands it at its true sub-frame time. The frame
+     *  clock's mapping onto it is smoothed each frame and resynced on a jump. */
+    booking?: EventBooking;
+}
+/** What `animator.timeline` returns: playback control plus live editing. */
+interface TimelineHandle extends AnimationHandle {
+    /** Move the playhead. Fires no event itself, at any depth; an event exactly
+     *  at `t` fires when playback next advances. Sampled tracks are sampled at
+     *  `t` at once, so a target they hold reads the new value before the next frame. */
+    seek(t: number): void;
+    /** Change the loop policy. `true` loops forever, `n` allows n more laps,
+     *  `false` stops at `duration`. Sets policy only — a timeline already parked
+     *  at `duration` does not restart, because `rearm` declines to revive one.
+     *  Rewind it with `seek(0)` and `resume()` to play it again. */
+    setLoop(loop: boolean | number): void;
+    /** The loop policy as it now stands: `true` endless, `false` stopping at
+     *  `duration`, `n` for n laps still allowed. A finite count falls as laps
+     *  are consumed, matching what `setLoop` takes. */
+    loop(): boolean | number;
+    /** Current playhead in ms. */
+    time(): number;
+    duration(): number;
+    tracks(): readonly Track[];
+    /** Run `fn`, then recompute duration, drop cached interpolators, sample the
+     *  tracks again where the playhead stands, and notify.
+     *  Every mutation must go through this — an edited keyframe otherwise keeps
+     *  interpolating toward its old value with no visible error. */
+    edit(fn: () => void): void;
+    /** Notified after each `edit`. Returns an unsubscribe. */
+    subscribe(cb: () => void): () => void;
+    /** Notified when playback changes other than by time passing: `pause`,
+     *  `resume`, `seek`, `setTimeScale`, `setLoop`, a cancel, and the playhead
+     *  reaching the end. What a view of the playhead listens to, so a change
+     *  made elsewhere reaches it. Returns an unsubscribe. */
+    subscribePlayback(cb: () => void): () => void;
+}
+
+/** The arrays a table can keep its rows' values on screen in. */
+type ShownArray = Float64Array | Float32Array;
+/** What {@link createTargetTable} takes. */
+interface TargetTableOptions<S extends ShownArray = Float64Array> {
+    /** How many numbers a row holds. */
+    axes: number;
+    /** The kind of array to keep `shown` in. Default `Float64Array`. Pass `Float32Array` for a
+     *  painter that uploads it: the table then fills that each frame, and no copy is made. */
+    shown?: new (length: number) => S;
+    /** Rows to make room for at first. The table grows past it. Default 64. */
+    capacity?: number;
+    /** Called after `row` is committed: by `set`, by an animation starting on it, and by one
+     *  canceled on it. */
+    set?(row: number): void;
+    /** Called once a frame, after the animator has filled `shown` for the rows it is moving. */
+    show?(): void;
+}
+/**
+ * Many like values an animator can move, kept as rows of numbers in flat arrays: for thousands
+ * of particles, dots, or vertex colors, where a `Target` apiece costs a read apiece. Each row
+ * is a target (`target(row)`), so it tweens, springs, coasts, and holds like any other, and
+ * every row's value on screen is in `shown` after each frame, with no call per row.
+ */
+interface TargetTable<S extends ShownArray = Float64Array> {
+    readonly axes: number;
+    /** How many rows are in use. */
+    readonly size: number;
+    /** Every row's committed value, row `r` at `r * axes`. A new array once the table grows, so
+     *  read it from the table each time. Write a row through `set`. */
+    readonly committed: Float64Array;
+    /** Every row's value on screen, laid out as `committed`: current after each frame of the
+     *  animator moving the rows, and whenever it is read between frames. A new array once the
+     *  table grows. A `Float32Array` where the table was made with `shown: Float32Array`. */
+    readonly shown: S;
+    /** Adds a row at `value` and answers its index, which a removed row's index is reused for. */
+    add(value: ArrayLike<number>): number;
+    /** Stops whatever is moving `row` and frees it. Its target is dead from here: a row added
+     *  later may take the index, and gets a target of its own. */
+    remove(row: number): void;
+    /** Commits `value` to `row`. A row that is moving keeps what its animations have left on top. */
+    set(row: number, value: ArrayLike<number>): void;
+    /** Row `row` as a target, the same one on every call. */
+    target(row: number): Target<number[]>;
+}
+/** Make a {@link TargetTable} whose rows each hold `axes` numbers. */
+declare function createTargetTable<S extends ShownArray = Float64Array>(opts: TargetTableOptions<S>): TargetTable<S>;
+
+/** What every animation on a {@link Target} takes. */
+interface OnTarget<T> {
+    /** The value to move. */
+    target: Target<T>;
+    /** Told this animation's own value each frame: its destination plus what it has left to travel. */
+    onTick?: (value: T) => void;
+    onDone?: () => void;
+    /** Any new animation passed the same cancelKey cancels the prior one in flight. Leave it off
+     *  to let animations on one target add. */
+    cancelKey?: string;
+    /** False to take `cancelKey` without canceling the animations holding it, so it adds to them
+     *  and `cancelKey`, `pauseKey`, and `isActive` reach them all. Default true. */
+    interrupt?: boolean;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+/** A tween on a {@link Target}. `to` is committed as it starts, and it contributes what is left
+ *  to travel, so it adds to whatever else is moving the target. */
+interface TargetTweenOptions<T> extends OnTarget<T> {
+    to: T;
+    /** Where its own travel starts. Default: the target's committed value, so the value on screen
+     *  does not move as it starts. */
+    from?: T;
+    ms: number;
+    easing?: EasingSpec;
+    /** The path from `from` to `to`, where a straight line per axis is not it. */
+    interpolate?: Interpolate<T>;
+    /** As `interpolate`, built once at the start. Takes precedence. */
+    interpolator?: InterpolatorFactory<T>;
+}
+/** A spring on a {@link Target}. Needs positive stiffness, damping and mass. Interrupting an
+ *  animation on the same target under the same `cancelKey`, it starts at that one's velocity
+ *  unless given its own. */
+interface TargetSpringOptions<T> extends OnTarget<T> {
+    to: T;
+    /** As {@link TargetTweenOptions.from}. */
+    from?: T;
+    /** Initial velocity in T-units per second. */
+    velocity?: T;
+    preset?: SpringPresetName;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    /** Distance from `to` and speed, both in axis units, under which it has come to rest. Default 0.01. */
+    restThreshold?: number;
+}
+/** Spring and coast as one animation on a {@link Target}. With `to: null` it coasts on its
+ *  velocity, committing where it is when it stops. */
+interface TargetPhysicsOptions<T> extends Omit<TargetSpringOptions<T>, 'to'> {
+    to?: T | null;
+}
+/** What `animator.hold` takes. */
+interface HoldOptions<T> {
+    /** The value to hold. */
+    target: Target<T>;
+    /** What to show in place of the committed value: a value, or a function read each frame.
+     *  A value is read as the hold starts and again at `touch()`, and costs a frame nothing. */
+    value: T | (() => T);
+    /** Its share among the target's holds, 0 to 1: a number, or a function read each frame.
+     *  Default 1. Holds on one target show their weighted average, and whatever their weights
+     *  leave short of 1 is the committed value's. */
+    weight?: number | (() => number);
+    /**
+     * The axes of the target it holds, each by name or by index: a plain object's fields
+     * (`['y']`), a rig's joints (`['armL', 'foreL']`) or one of a joint's own
+     * (`['armL.rotation']`), as `target.axisIndexes` resolves them when the hold starts. The
+     * rest are left to the target's other holds and its committed value, and a release commits
+     * only these. Default: every axis.
+     */
+    axes?: readonly AxisRef<T>[];
+    /** Any new animation passed the same cancelKey cancels this one. */
+    cancelKey?: string;
+    /** Names this hold in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+    /** With `false`, it takes its `cancelKey` without canceling whoever holds it. Default true. */
+    interrupt?: boolean;
+}
+/** What `animator.hold` returns. `cancel` commits what the hold was showing, as `release()`
+ *  does; pausing it or scaling its time changes nothing, since it has no clock. */
+interface HoldHandle extends AnimationHandle {
+    /** Says a function-form `value` or `weight` changed outside a frame, so the target shows it
+     *  now rather than at the next frame the animator happens to run. A `value` given as an
+     *  object and then written in place shows only once this is called. */
+    touch(): void;
+    /** Ends the hold. By default it commits the value it was showing, so the target stays where
+     *  it is; with `commit: false` the committed value is left alone and the target falls back
+     *  to it. */
+    release(opts?: {
+        commit?: boolean;
+    }): void;
+}
+/** What `animator.holdRows` takes. */
+interface HoldRowsOptions {
+    /** The table whose rows it holds. */
+    table: TargetTable<ShownArray>;
+    /** The rows to hold. Default: every row the table has as the hold starts. */
+    rows?: ArrayLike<number>;
+    /** The weight each row starts at, 0 to 1. Default 1. */
+    weight?: number;
+    /** The axes of each row it holds, by index. Default: all of them. */
+    axes?: readonly number[];
+    /** Any new animation passed the same cancelKey cancels this one. */
+    cancelKey?: string;
+    /** Names it in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+    /** With `false`, it takes its `cancelKey` without canceling whoever holds it. Default true. */
+    interrupt?: boolean;
+}
+/**
+ * What `animator.holdRows` returns: a hold on each of its rows, which shows that row's value in
+ * `values` at its weight in `weights`, mixed with the row's other holds as `hold`'s are. Write
+ * either in place and call `touch()`. A row stopped through its target, or removed from the
+ * table, is let go of; the rest stay held until the hold is released or canceled, each
+ * committing what it showed, as `release()` does.
+ */
+interface RowsHoldHandle extends HoldHandle {
+    /** Each row's value to hold, laid out as `table.committed`: row `r` at `r * table.axes`.
+     *  A held row starts at its committed value. A new array once the table grows. */
+    readonly values: Float64Array;
+    /** Each held row's weight, 0 to 1, row `r` at `r`. A new array once the table grows. */
+    readonly weights: Float64Array;
+}
+/** A coast on a {@link Target}: it commits where it stops. */
+interface TargetDecayOptions<T> extends OnTarget<T> {
+    /** As {@link TargetTweenOptions.from}. */
+    from?: T;
+    velocity: T;
+    /** Per-second velocity multiplier in (0, 1). Default 0.95. */
+    friction?: number;
+    /** Speed below which it stops. Default 0.5. */
+    threshold?: number;
+}
+
+/** A stagger run's own options: the factory form's fourth argument, and part
+ *  of every fluent builder method's options. */
+interface StaggerOptions {
+    /** Cancel-key for the supervising registration. `animator.cancelKey(key)`
+     *  cancels the whole stagger; `animator.isActive(key)` returns true while
+     *  any timer or child is alive. */
+    cancelKey?: string;
+    /** Names this stagger in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+/** Per-index delay schedule. Number ⇒ `index * delay` ms. Function ⇒ caller
+ *  decides the absolute delay for each index (e.g. `i => i * i * 30`). */
+type StaggerDelay = number | ((index: number) => number);
+/** Produces the animation for one staggered item. */
+type StaggerFactory<TItem> = (item: TItem, index: number) => AnimationHandle;
+/** A `T` value or a function that derives one from the per-item context. Used
+ *  by the fluent builder methods (`.tween`, `.spring`) so each item can
+ *  vary an option (e.g. `to: (_item, i) => (i + 1) * 10`). */
+type StaggerPerItem<T, TItem> = T | ((item: TItem, index: number) => T);
+/** Options for the stagger builder's `.tween` in its `onTick` form: a tween per item, where
+ *  `from`, `to` and `ms` may each vary by item. `cancelKey` and `label` belong
+ *  to the stagger as a whole, as in {@link StaggerOptions}. */
+interface StaggerTweenOptions<T, TItem> extends StaggerOptions {
+    /** Absent: this form hands values to `onTick`. {@link StaggerTargetTweenOptions} moves targets. */
+    target?: undefined;
+    from: StaggerPerItem<T, TItem>;
+    to: StaggerPerItem<T, TItem>;
+    ms: StaggerPerItem<number, TItem>;
+    easing?: EasingSpec;
+    interpolate?: Interpolate<T>;
+    interpolator?: InterpolatorFactory<T>;
+    onTick: (value: T, item: TItem, index: number) => void;
+    onDone?: (item: TItem, index: number) => void;
+}
+/** Options for the stagger builder's `.spring` in its `onTick` form: a spring per item, where
+ *  `from`, `to` and `velocity` may each vary by item. */
+interface StaggerSpringOptions<T, TItem> extends StaggerOptions, Pick<SpringOptions<T>, 'preset' | 'stiffness' | 'damping' | 'mass' | 'interpolate' | 'add' | 'subtract' | 'scale' | 'magnitude' | 'restThreshold'> {
+    /** Absent: this form hands values to `onTick`. {@link StaggerTargetSpringOptions} moves targets. */
+    target?: undefined;
+    from: StaggerPerItem<T, TItem>;
+    to: StaggerPerItem<T, TItem>;
+    velocity?: StaggerPerItem<T, TItem>;
+    onTick: (value: T, item: TItem, index: number) => void;
+    onDone?: (item: TItem, index: number) => void;
+}
+/** What the stagger builder's methods share where each item's animation moves a {@link Target}. */
+interface StaggerOnTarget<T, TItem> extends StaggerOptions {
+    /** The target an item's animation moves: one for them all, or a function of the item.
+     *  Default: the item itself, where the items are targets. */
+    target?: StaggerPerItem<Target<T>, TItem>;
+    /** Told an item's animation's own value each frame, as `TargetTweenOptions.onTick` is. */
+    onTick?: (value: T, item: TItem, index: number) => void;
+    onDone?: (item: TItem, index: number) => void;
+}
+/** Options for the stagger builder's `.tween` moving targets: `animator.tween`'s target form
+ *  per item, where `to`, `from` and `ms` may each vary by item. The tweens share no
+ *  `cancelKey`, so each adds to whatever else is moving its target. */
+interface StaggerTargetTweenOptions<T, TItem> extends StaggerOnTarget<T, TItem>, Pick<TargetTweenOptions<T>, 'easing' | 'interpolate' | 'interpolator'> {
+    to: StaggerPerItem<T, TItem>;
+    from?: StaggerPerItem<T, TItem>;
+    ms: StaggerPerItem<number, TItem>;
+}
+/** Options for the stagger builder's `.spring` moving targets: `animator.spring`'s target
+ *  form per item, where `to`, `from` and `velocity` may each vary by item. */
+interface StaggerTargetSpringOptions<T, TItem> extends StaggerOnTarget<T, TItem>, Pick<TargetSpringOptions<T>, 'preset' | 'stiffness' | 'damping' | 'mass' | 'restThreshold'> {
+    to: StaggerPerItem<T, TItem>;
+    from?: StaggerPerItem<T, TItem>;
+    velocity?: StaggerPerItem<T, TItem>;
+}
+/** `.tween`'s options where the items are targets, each moved by its own tween. No options
+ *  fit where they are not. */
+type StaggerItemTweenOptions<TItem> = TItem extends Target<infer T> ? StaggerTargetTweenOptions<T, TItem> : never;
+/** `.spring`'s options where the items are targets, as {@link StaggerItemTweenOptions}. */
+type StaggerItemSpringOptions<TItem> = TItem extends Target<infer T> ? StaggerTargetSpringOptions<T, TItem> : never;
+/** Narrows a builder method's target options to the call that names its `target`. */
+type Naming = {
+    target: NonNullable<unknown>;
+};
+/**
+ * Fluent form of `Animator.stagger`: pick what to run per item after the
+ * items and the delay schedule are already fixed.
+ *
+ * `.tween` and `.spring` each take three shapes of options. Where the items are targets, each
+ * item's animation moves the item: `animator.stagger(targets, 80).spring({ to: (t) => ... })`.
+ * With a `target`, it moves the target that names for the item. With neither, it hands its
+ * values to `onTick`.
+ */
+interface StaggerBuilder<TItem> {
+    /** Run an arbitrary per-item factory. */
+    each(factory: StaggerFactory<TItem>, opts?: StaggerOptions): AnimationHandle;
+    /** Per-item `animator.tween` with per-item-varying options. */
+    tween(opts: StaggerItemTweenOptions<TItem>): AnimationHandle;
+    tween<T>(opts: StaggerTargetTweenOptions<T, TItem> & Naming): AnimationHandle;
+    tween<T>(opts: StaggerTweenOptions<T, TItem>): AnimationHandle;
+    /** Per-item `animator.spring` with per-item-varying options. */
+    spring(opts: StaggerItemSpringOptions<TItem>): AnimationHandle;
+    spring<T>(opts: StaggerTargetSpringOptions<T, TItem> & Naming): AnimationHandle;
+    spring<T>(opts: StaggerSpringOptions<T, TItem>): AnimationHandle;
+}
+
+/** Blends two `T` values at eased progress `t`. Called once per frame; see
+ *  {@link InterpolatorFactory} when the blend has setup worth hoisting. */
+type Interpolate<T> = (from: T, to: T, t: number) => T;
+/** Built ONCE at tween start with (from, to); the returned function is called with `t ∈ [0, 1]`
+ *  each frame. Use for interpolators with expensive setup (color-space conversion, path-string
+ *  parsing) — d3-interpolate's shape exactly. */
+type InterpolatorFactory<T> = (from: T, to: T) => (t: number) => T;
+/** A running animation. Cancel it, or bend its time — pausing and time-scaling
+ *  act on this animation's own virtual clock, independent of the animator's. */
+interface AnimationHandle {
+    /** Monotonic id assigned by the animator. */
+    id: number;
+    /** Cancel this animation. Idempotent — no-op once already finished/canceled. */
+    cancel(): void;
+    /** Freeze this animation's virtual clock. Idempotent. */
+    pause(): void;
+    /** Resume this animation's virtual clock. Idempotent. */
+    resume(): void;
+    /** Multiply this animation's virtual-clock rate by `scale`. 1 = normal, 0 holds it still, and
+     *  below 0 plays it backward: run back to its start, it ends there holding its start value,
+     *  as it ends holding its destination going forward, and `onDone` runs. */
+    setTimeScale(scale: number): void;
+    /** This animation's own time scale. 1 once it has finished, since the
+     *  animator no longer holds an entry to read. */
+    timeScale(): number;
+    /** True iff this handle is currently paused. */
+    isPaused(): boolean;
+}
+/** A duration-based animation from `from` to `to` over `ms`, shaped by an
+ *  easing curve. Reach for a spring instead when the motion should respond to
+ *  where the value already is rather than restart from a fixed duration. */
+interface TweenOptions<T> {
+    /** Absent: this form hands values to `onTick`. The `Target` form of these options moves a target. */
+    target?: undefined;
+    from: T;
+    to: T;
+    ms: number;
+    easing?: EasingSpec;
+    /** Required when T is not `number`. For T = number, defaults to linear numeric lerp. */
+    interpolate?: Interpolate<T>;
+    /** Factory interpolator built once at tween start. Takes precedence over `interpolate`
+     *  when both are provided. */
+    interpolator?: InterpolatorFactory<T>;
+    onTick: (value: T) => void;
+    onDone?: () => void;
+    /** Any new animation passed the same cancelKey cancels the prior one in flight. */
+    cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+/** A spring animation: runs until the value settles on `to` rather than for a
+ *  set duration, so it absorbs an initial velocity naturally. Non-numeric `T`
+ *  needs the four vector helpers. */
+interface SpringOptions<T> {
+    /** Absent: this form hands values to `onTick`. The `Target` form of these options moves a target. */
+    target?: undefined;
+    from: T;
+    to: T;
+    /** Initial velocity in T-units per second. Default: zero (T-shape-aware). */
+    velocity?: T;
+    preset?: SpringPresetName;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    interpolate?: Interpolate<T>;
+    /** Vector helpers — required for non-numeric T. When `from`, `to` and `velocity` are numbers, number
+     *  arrays or plain objects of numeric fields of one shape, and stiffness, damping and mass are
+     *  positive, the motion is solved in closed form and these only decide when it has come to rest —
+     *  a `subtract` that wraps an angle won't change the path. */
+    add?: (a: T, b: T) => T;
+    subtract?: (a: T, b: T) => T;
+    scale?: (v: T, k: number) => T;
+    magnitude?: (v: T) => number;
+    /** Velocity magnitude below which the spring is considered settled. Default 0.01. */
+    restThreshold?: number;
+    onTick: (value: T) => void;
+    onDone?: () => void;
+    cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+/** Spring and decay as one animation. With a `to`, a spring pulls toward it;
+ *  with `to: null`, the value coasts on its velocity. Either can become the
+ *  other mid-flight through the handle. */
+interface PhysicsOptions<T> {
+    /** Absent: this form hands values to `onTick`. The `Target` form of these options moves a target. */
+    target?: undefined;
+    from: T;
+    /** Target. `null` ⇒ no spring force (decay-mode). */
+    to?: T | null;
+    /** Initial velocity in T-units per second. */
+    velocity?: T;
+    preset?: SpringPresetName;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    restThreshold?: number;
+    /** Vector helpers — required for non-numeric T. When `from`, `to` and `velocity` are numbers, number
+     *  arrays or plain objects of numeric fields of one shape, and stiffness, damping and mass are
+     *  positive, the motion is solved in closed form and these only decide when it has come to rest —
+     *  a `subtract` that wraps an angle won't change the path. */
+    add?: (a: T, b: T) => T;
+    subtract?: (a: T, b: T) => T;
+    scale?: (v: T, k: number) => T;
+    magnitude?: (v: T) => number;
+    onTick: (value: T) => void;
+    onDone?: () => void;
+    cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+/** An `AnimationHandle` that can also be steered while it runs — the point of
+ *  the physics primitive. */
+interface PhysicsHandle<T = unknown> extends AnimationHandle {
+    /** Retarget mid-flight. `null` ⇒ switch to decay-mode (no spring force). */
+    setTarget(to: T | null): void;
+    /** Replace the current velocity in T-units per second. */
+    setVelocity(v: T): void;
+}
+/** Momentum: coast from `from` at `velocity`, slowing by `friction` each
+ *  second until below `threshold`. What a flick-to-pan leaves behind. */
+interface DecayOptions<T> {
+    /** Absent: this form hands values to `onTick`. The `Target` form of these options moves a target. */
+    target?: undefined;
+    from: T;
+    velocity: T;
+    /** Per-second velocity multiplier in (0, 1). Default 0.95. */
+    friction?: number;
+    /** Velocity magnitude below which decay stops. Default 0.5. */
+    threshold?: number;
+    /** When `from` and `velocity` are numbers, number arrays or plain objects of numeric fields of one
+     *  shape and `friction` is below 1, the motion is solved in closed form: `add` and `scale` go
+     *  unused and `magnitude` only decides when it has come to rest. */
+    add: (a: T, b: T) => T;
+    scale: (v: T, k: number) => T;
+    magnitude: (v: T) => number;
+    onTick: (value: T) => void;
+    onDone?: () => void;
+    cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+/** Options for `useAnimator`. Everything here is an injection seam for tests;
+ *  the defaults are the real clock and rAF. */
+interface UseAnimatorOptions {
+    /** Optional clock injection for tests. Returns ms since some epoch. */
+    now?: () => number;
+    /** Optional rAF / cAF injection for tests. Defaults to window.requestAnimationFrame. */
+    requestFrame?: (cb: (t: number) => void) => number;
+    cancelFrame?: (handle: number) => void;
+}
+/**
+ * Owns every running animation on a canvas and drives them from one rAF loop.
+ * Beyond the primitives (`tween`, `spring`, `decay`, `physics`) it offers
+ * composition — `loop`, `stagger` — and bulk control by handle, by cancel-key,
+ * or over everything at once.
+ *
+ * An animator does not know about the scene. An animation either reports values
+ * through `onTick` and the caller decides what to do with them, or moves a
+ * {@link Target}, where several on one target add.
+ */
+interface Animator {
+    tween<T>(opts: TweenOptions<T> | TargetTweenOptions<T>): AnimationHandle;
+    spring<T>(opts: SpringOptions<T> | TargetSpringOptions<T>): AnimationHandle;
+    decay<T>(opts: DecayOptions<T> | TargetDecayOptions<T>): AnimationHandle;
+    /** With `to` set, behaves as a spring; with `to: null`, as a velocity-driven decay.
+     *  Retarget mid-flight via the returned handle's `setTarget`. */
+    physics<T>(opts: PhysicsOptions<T> | TargetPhysicsOptions<T>): PhysicsHandle<T>;
+    /** Shows a value on a {@link Target} in place of its committed one until canceled or released.
+     *  It covers an animation's move to a destination; a coast, push, or `from` offset adds on top. */
+    hold<T>(opts: HoldOptions<T>): HoldHandle;
+    /** Holds rows of a target table at values and weights the caller writes into flat arrays: a
+     *  hold on each row, as `hold` would put there, with no function asked for any of them. */
+    holdRows(opts: HoldRowsOptions): RowsHoldHandle;
+    /** Cancel a specific animation by handle. Pose stays at current value (no jump). */
+    cancel(handle: AnimationHandle): void;
+    /** Cancel every animation currently active under `key`. */
+    cancelKey(key: string): void;
+    /** Cancel everything. Useful from a destructor or "reset scene" path. */
+    cancelAll(): void;
+    /** True iff at least one animation is active. With `key`, scoped to that cancelKey. */
+    isActive(key?: string): boolean;
+    /**
+     * True while the animator is executing an animation tick. Lets an adapter wrapper detect a
+     * `setPose` called from inside another animation's onTick and avoid scheduling a new
+     * animation that would fight the caller.
+     */
+    isTicking(): boolean;
+    /** Freeze every animation managed by this animator. */
+    pause(): void;
+    /** Resume every animation managed by this animator. */
+    resume(): void;
+    /** True iff the animator is currently globally paused. */
+    isPaused(): boolean;
+    /** Multiply every animation's virtual-clock rate by `scale`. Below 0 plays every one backward,
+     *  as each handle's `setTimeScale` does, while the animator's own clock goes on forward: one
+     *  started meanwhile is at its start already, and ends at once. */
+    setTimeScale(scale: number): void;
+    /** The global time scale. Per-animation scales multiply on top of it. */
+    timeScale(): number;
+    /** Freeze every animation whose `cancelKey` matches. */
+    pauseKey(key: string): void;
+    /** Resume every animation whose `cancelKey` matches. */
+    resumeKey(key: string): void;
+    /** Set per-animation timeScale for every animation whose `cancelKey` matches. */
+    setTimeScaleByKey(key: string, scale: number): void;
+    /**
+     * Repeatedly invokes `factory` to produce a child animation. The factory must wire its
+     * returned handle's `onDone` to call `next` so the loop advances. The returned handle's
+     * pause/resume/setTimeScale/cancel delegate to the in-flight child, and
+     * `animator.cancel(handle)`, `animator.cancelKey(opts.cancelKey)`, and
+     * `animator.isActive(opts.cancelKey)` all work for it.
+     */
+    loop(factory: LoopFactory, opts?: LoopOptions): AnimationHandle;
+    /** Sugar over `loop`: a tween between two values, repeated per `direction`. Registered
+     *  with the animator like `loop`. */
+    tweenLoop<T>(opts: TweenLoopOptions<T>): AnimationHandle;
+    /**
+     * Schedules a per-item animation, offset by `delay` ms per index (or a custom function of
+     * the index). Pass `factory` and get a composite `AnimationHandle`; omit it and get a
+     * `StaggerBuilder` for fluent `.each` / `.tween` / `.spring` calls, the last two of which
+     * move the items themselves where they are targets.
+     *
+     * The composite handle's `cancel` cancels the items still waiting AND the in-flight
+     * children. The delays run on the animator's clock, not the wall's: a pause or a time
+     * scale holds or stretches the waiting items along with the children, and a hidden tab
+     * holds both. `animator.cancel(handle)`, `animator.cancelKey(opts.cancelKey)`, and
+     * `animator.isActive(opts.cancelKey)` all work for it.
+     */
+    stagger<TItem>(items: readonly TItem[], delay: StaggerDelay): StaggerBuilder<TItem>;
+    stagger<TItem>(items: readonly TItem[], delay: StaggerDelay, factory: StaggerFactory<TItem>, opts?: StaggerOptions): AnimationHandle;
+    /**
+     * Keyframe timeline. Registered like any other animation, so its playhead
+     * responds to `pause`, `setTimeScale` and `cancelKey`. Sampled tracks are a
+     * pure function of the playhead; event tracks fire only on forward playback.
+     */
+    timeline(opts: TimelineOptions): TimelineHandle;
+    /** Per-node, per-channel color override registry, painted onto scene nodes by
+     *  `<SceneCanvas animator>` and read by `createPathLayer`. Only this animator can move its
+     *  per-node targets. Cleared automatically on animator unmount. */
+    colorOverrides: ColorOverrideRegistry;
+    /**
+     * Subscribe to a callback fired once per RAF frame while any animation is active; returns
+     * an unsubscribe. For consumers that repaint from a non-scene channel such as
+     * `colorOverrides`, whose writes do not trigger a repaint the way scene mutations do.
+     * Fires AFTER the frame's animations have ticked.
+     */
+    onTick(cb: () => void): () => void;
+    /**
+     * Keeps the animator's RAF loop running until the returned cancel function is called. For
+     * effects read on every frame that have no progress state of their own; without it the
+     * loop would idle and `onTick` would stop firing.
+     */
+    keepAlive(): () => void;
+    /**
+     * Subscribe to the lifecycle of every animation this animator runs, the
+     * composites and timelines included. Returns an unsubscribe. Events arrive
+     * synchronously, as each thing happens — see {@link AnimatorEvent} for the
+     * order. With no listener attached nothing is built or delivered, so an
+     * unwatched animator pays nothing for this.
+     */
+    watch(listener: AnimatorListener): () => void;
+    /** What is running right now, in registration order: a fresh snapshot per
+     *  call, for a debug overlay to draw. */
+    live(): LiveAnimation[];
+}
+/** Which animator call started an animation. A loop, tween loop or stagger is
+ *  an entry of its own beside the children it runs; `keepAlive` holds the
+ *  frame loop open and animates nothing. */
+type AnimationKind = 'tween' | 'spring' | 'decay' | 'physics' | 'timeline' | 'loop' | 'tweenLoop' | 'stagger' | 'keepAlive' | 'hold';
+/** Who an {@link AnimatorEvent} is about. One object per registration, so the
+ *  same animation's events share it by identity. */
+interface AnimationInfo {
+    /** The id on the animation's handle. */
+    readonly id: number;
+    readonly kind: AnimationKind;
+    /** The animation's `cancelKey`. Pose helpers key by node, as `pose:<id>`. */
+    readonly key?: string;
+    /** The animation's `label` option. */
+    readonly label?: string;
+}
+/** One row of `animator.live()`. */
+interface LiveAnimation extends AnimationInfo {
+    /** Paused on its own handle. The animator-wide pause is `animator.isPaused()`. */
+    readonly paused: boolean;
+    /** Its own time scale; the animator's multiplies on top. */
+    readonly timeScale: number;
+    /** Virtual ms its clock has advanced since it started. */
+    readonly elapsed: number;
+    /** 0 to 1, for a tween or a timeline (the playhead over its duration).
+     *  Absent where there is no end to measure against: physics, composites. */
+    readonly progress?: number;
+}
+/**
+ * One thing happening to an animation, as `animator.watch` delivers it.
+ *
+ * - `start` — registered. A finished timeline that `seek` or `edit` revives
+ *   starts again, under the same id.
+ * - `end` — finished on its own. Delivered once every animation has ticked
+ *   that frame, in registration order.
+ * - `cancel` — stopped by its handle, `cancel`, `cancelKey` or `cancelAll`.
+ * - `interrupt` — stopped because `by` claimed its `cancelKey`. Delivered
+ *   before `by`'s `start`.
+ * - `error` — its tick threw (an `onTick`, `onDone` or interpolator), so it was
+ *   taken off the table, after the frame's other animations ticked. In place of
+ *   `cancel`, or after `end` when `onDone` threw. The error is also logged.
+ * - `lap` — a looping timeline wrapped; `lap` counts wraps since it started.
+ * - `fire` — an event on a timeline's event track was crossed, at any depth.
+ *   `path` indexes from the root timeline's `tracks()` down through each
+ *   nested timeline to the event track. Delivered after the event's own `fire`.
+ */
+type AnimatorEvent = {
+    readonly type: 'start' | 'end' | 'cancel';
+    readonly animation: AnimationInfo;
+} | {
+    readonly type: 'interrupt';
+    readonly animation: AnimationInfo;
+    readonly by: AnimationInfo;
+} | {
+    readonly type: 'error';
+    readonly animation: AnimationInfo;
+    readonly error: unknown;
+} | {
+    readonly type: 'lap';
+    readonly animation: AnimationInfo;
+    readonly lap: number;
+} | {
+    readonly type: 'fire';
+    readonly animation: AnimationInfo;
+    readonly track: EventTrack;
+    readonly path: readonly number[];
+    readonly event: TimelineEvent;
+    /** As the event's own `fire` is told: ms behind the frame it was crossed. */
+    readonly lateBy: number;
+};
+/** Receives what `animator.watch` delivers. */
+type AnimatorListener = (event: AnimatorEvent) => void;
+/** Options for `Animator.loop`. */
+interface LoopOptions {
+    /** Maximum number of iterations. Default Infinity. */
+    count?: number;
+    /** Invoked when the loop reaches `count` iterations naturally (not on cancel). */
+    onDone?: () => void;
+    /** Any new animation passed the same cancelKey cancels the prior one in flight.
+     *  Also enables `animator.cancelKey` / `animator.isActive(key)` for this loop. */
+    cancelKey?: string;
+    /** Names this loop in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+/** Produces one iteration of a loop. Must arrange for `next` to be called when
+ *  the animation it returns finishes, or the loop stalls after one pass. */
+type LoopFactory = (iteration: number, next: () => void) => AnimationHandle;
+/** Options for `Animator.tweenLoop` — a tween's options plus how each
+ *  iteration relates to the last. */
+interface TweenLoopOptions<T> {
+    from: T;
+    to: T;
+    ms: number;
+    easing?: EasingSpec;
+    /** `restart` (default): from→to every iteration.
+     *  `reverse`: to→from every iteration.
+     *  `alternate`: even iterations from→to, odd iterations to→from. */
+    direction?: 'restart' | 'reverse' | 'alternate';
+    count?: number;
+    interpolate?: Interpolate<T>;
+    onTick: (value: T) => void;
+    onDone?: () => void;
+    cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
+}
+
+export { type TargetTableOptions as $, type Animator as A, type StaggerItemSpringOptions as B, type ColorOverride as C, type DecayOptions as D, type EventBooking as E, type StaggerItemTweenOptions as F, type StaggerOptions as G, type HoldHandle as H, type Interpolate as I, type StaggerPerItem as J, type Keyframe as K, type LiveAnimation as L, type StaggerSpringOptions as M, type NestedTimeline as N, type StaggerTargetSpringOptions as O, type PhysicsHandle as P, type StaggerTargetTweenOptions as Q, type RowsHoldHandle as R, type SampledTrack as S, type Target as T, type StaggerTweenOptions as U, type VertexColorChannel as V, type TargetDecayOptions as W, type TargetOptions as X, type TargetPhysicsOptions as Y, type TargetSpringOptions as Z, type TargetTable as _, type AnimationHandle as a, type TargetTweenOptions as a0, type TimelineClock as a1, type TimelineHandle as a2, type TimelineOptions as a3, type TimelineTrack as a4, type Track as a5, type TweenLoopOptions as a6, type TweenOptions as a7, type UseAnimatorOptions as a8, createTarget as a9, createTargetTable as aa, type TimelineEvent as b, type TargetAxes as c, type AnimationInfo as d, type AnimationKind as e, type AnimatorEvent as f, type AnimatorListener as g, type AxisBuffer as h, type AxisName as i, type AxisRef as j, type ColorOverrideFn as k, ColorOverrideRegistry as l, type EventBookingHandle as m, type EventTrack as n, type HoldOptions as o, type HoldRowsOptions as p, type InterpolatorFactory as q, type LoopFactory as r, type LoopOptions as s, type Naming as t, type PhysicsOptions as u, type ShownArray as v, type SpringOptions as w, type StaggerBuilder as x, type StaggerDelay as y, type StaggerFactory as z };