@scntix/animate 0.0.1

package/_runtime/types/node.d.ts

@@ -0,0 +1,1426 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Opaque handle returned to JS after `createDrawable`.
+ *
+ * Wraps the underlying `Element` (already initialised with `pathLength=1000`
+ * and an initial `stroke-dasharray`).
+ */
+export class DrawableHandle {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Apply a normalized draw amount from the start of the path.
+     */
+    draw(progress: number): void;
+    /**
+     * Apply a partial normalized draw range `[start, end]`.
+     */
+    setRange(start: number, end: number): void;
+    /**
+     * Apply a partial visible draw range from a spec string like `"20% 80%"`.
+     */
+    setRangeSpec(spec: string): void;
+    /**
+     * The underlying DOM element (for passing to `animate()`).
+     */
+    readonly element: Element;
+}
+
+export class Easing {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static clearRegistry(): void;
+    static customBounce(bounces: number, strength: number): Function;
+    static customEase(path: string): Function;
+    static easeInBack(t: number): number;
+    static easeInBounce(t: number): number;
+    static easeInCirc(t: number): number;
+    static easeInCubic(t: number): number;
+    static easeInElastic(t: number): number;
+    static easeInExpo(t: number): number;
+    static easeInOutBack(t: number): number;
+    static easeInOutBounce(t: number): number;
+    static easeInOutCirc(t: number): number;
+    static easeInOutCubic(t: number): number;
+    static easeInOutElastic(t: number): number;
+    static easeInOutExpo(t: number): number;
+    static easeInOutQuad(t: number): number;
+    static easeInOutQuart(t: number): number;
+    static easeInOutQuint(t: number): number;
+    static easeInOutSine(t: number): number;
+    static easeInQuad(t: number): number;
+    static easeInQuart(t: number): number;
+    static easeInQuint(t: number): number;
+    static easeInSine(t: number): number;
+    static easeOutBack(t: number): number;
+    static easeOutBounce(t: number): number;
+    static easeOutCirc(t: number): number;
+    static easeOutCubic(t: number): number;
+    static easeOutElastic(t: number): number;
+    static easeOutExpo(t: number): number;
+    static easeOutInBack(t: number): number;
+    static easeOutInBounce(t: number): number;
+    static easeOutInCirc(t: number): number;
+    static easeOutInCubic(t: number): number;
+    static easeOutInElastic(t: number): number;
+    static easeOutInExpo(t: number): number;
+    static easeOutInQuad(t: number): number;
+    static easeOutInQuart(t: number): number;
+    static easeOutInQuint(t: number): number;
+    static easeOutInSine(t: number): number;
+    static easeOutQuad(t: number): number;
+    static easeOutQuart(t: number): number;
+    static easeOutQuint(t: number): number;
+    static easeOutSine(t: number): number;
+    static expoScale(start: number, end: number): Function;
+    static irregular(steps: number, randomness: number, seed: bigint): Function;
+    static linear(t: number): number;
+    static register(name: string, easing: any): void;
+    static roughEase(steps: number, randomness: number, seed: bigint): Function;
+    static slowMo(config: any): Function;
+    static unregister(name: string): boolean;
+    static wiggle(wiggles: number): Function;
+}
+
+/**
+ * Returned to JS as `{ translateX, translateY, rotate }`.
+ *
+ * Each field is a JS object `{ from: 0, to: totalLength, modifier: fn }`.
+ * Fields are exposed via getters because `JsValue` is not `Copy`.
+ */
+export class MotionPathValues {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly rotate: any;
+    readonly translateX: any;
+    readonly translateY: any;
+}
+
+/**
+ * SVG path morphing utilities.
+ */
+export class PathMorph {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Equalize two paths to compatible cubic segment counts.
+     *
+     * Returns `[normalizedFrom, normalizedTo]`.
+     */
+    static equalize(from: string, to: string): Array<any>;
+    /**
+     * Interpolate between two SVG path data strings.
+     * Paths must have compatible structure (same commands, same number of values).
+     */
+    static interpolate(from: string, to: string, progress: number): string;
+    /**
+     * Normalize a path into absolute cubic segments.
+     */
+    static normalize(path: string): string;
+    /**
+     * Sample a position and tangent angle along a path at progress `[0, 1]`.
+     */
+    static sample(path: string, progress: number): any;
+    /**
+     * Parse an SVG path and return the number of segments.
+     * Useful for checking compatibility before interpolating.
+     */
+    static segmentCount(path: string): number;
+}
+
+export class ReducedMotion {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static getPolicy(): string;
+    static prefers(): boolean;
+    static resetPolicy(): void;
+    static setPolicy(policy: string): boolean;
+    static shouldReduce(): boolean;
+}
+
+/**
+ * Math, easing, and conversion utilities.
+ *
+ * ```js
+ * import { Utils } from 'scntix-animate';
+ *
+ * const x = Utils.clamp(150, 0, 100);     // 100
+ * const y = Utils.mapRange(0.5, 0, 1, -100, 100); // 0
+ * const r = Utils.random(0, 10);          // e.g. 7.3
+ * const s = Utils.lerp(0, 100, 0.25);    // 25
+ * const w = Utils.wrap(380, 0, 360);     // 20
+ * const d = Utils.degToRad(90);          // π/2
+ * ```
+ */
+export class Utils {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Absolute value.
+     */
+    static abs(value: number): number;
+    /**
+     * Angle from (x1,y1) to (x2,y2) in radians.
+     */
+    static angle(x1: number, y1: number, x2: number, y2: number): number;
+    /**
+     * Ceiling to integer.
+     */
+    static ceil(value: number): number;
+    /**
+     * Clamp a value between min and max.
+     */
+    static clamp(value: number, min: number, max: number): number;
+    /**
+     * Compose functions right-to-left (mathematical composition order).
+     *
+     * ```js
+     * const transform = Utils.compose(Math.round, v => v * 2);
+     * transform(1.7); // Math.round(1.7 * 2) = Math.round(3.4) = 3
+     * ```
+     */
+    static compose(fns: Array<any>): Function;
+    /**
+     * Frame-rate independent exponential decay (damped lerp).
+     *
+     * Useful for smooth mouse following without fixed durations.
+     *
+     * ```js
+     * // In a rAF loop:
+     * x = Utils.damp(x, targetX, deltaTime, 0.05); // 5% pull toward target each ms
+     * ```
+     */
+    static damp(start: number, end: number, delta_time: number, factor: number): number;
+    /**
+     * Convert degrees to radians.
+     */
+    static degToRad(degrees: number): number;
+    /**
+     * Distance between two 2D points.
+     */
+    static distance(x1: number, y1: number, x2: number, y2: number): number;
+    /**
+     * Floor to integer.
+     */
+    static floor(value: number): number;
+    /**
+     * Convert frames to milliseconds at a given FPS.
+     */
+    static framesToMs(frames: number, fps: number): number | undefined;
+    /**
+     * Get a computed CSS property value from an element as a number.
+     *
+     * ```js
+     * const opacity = Utils.getProperty(el, 'opacity');        // 1.0
+     * const x = Utils.getProperty(el, 'translateX');           // 0
+     * ```
+     */
+    static getProperty(element: Element, prop: string): number;
+    /**
+     * Hex color to [r, g, b, a] array (each 0-255, alpha 0-1).
+     */
+    static hexToRgba(hex: string): Float64Array;
+    /**
+     * HSL to RGB conversion.
+     * Input: h in [0, 360), s and l in [0, 1].
+     * Returns Float64Array [r, g, b] where each is 0-255.
+     */
+    static hslToRgb(h: number, s: number, l: number): Float64Array;
+    /**
+     * Interpolate between two CSS color strings at `progress` ∈ [0, 1].
+     *
+     * Supports any format recognized by scntix-animate (hex, rgb, rgba, hsl, hsla).
+     *
+     * ```js
+     * Utils.interpolateColor('#ff0000', 'blue', 0.5); // 'rgb(128, 0, 128)'
+     * ```
+     */
+    static interpolateColor(from: string, to: string, progress: number): string;
+    /**
+     * Inverse lerp — where does value fall between start and end? Returns [0, 1].
+     */
+    static invLerp(start: number, end: number, value: number): number;
+    /**
+     * Linear interpolation between start and end.
+     */
+    static lerp(start: number, end: number, factor: number): number;
+    /**
+     * Map a value from one range to another.
+     * Equivalent to anime.js `mapRange`.
+     *
+     * ```js
+     * Utils.mapRange(0.5, 0, 1, -100, 100); // 0
+     * Utils.mapRange(75, 0, 100, 0, 1);     // 0.75
+     * ```
+     */
+    static mapRange(value: number, in_low: number, in_high: number, out_low: number, out_high: number): number;
+    /**
+     * Euclidean modulo (always positive).
+     *
+     * ```js
+     * Utils.modulo(-1, 5); // 4 (not -1 like JS %)
+     * ```
+     */
+    static modulo(a: number, b: number): number;
+    /**
+     * Convert milliseconds to frames at a given FPS.
+     */
+    static msToFrames(ms: number, fps: number): number | undefined;
+    /**
+     * Convert milliseconds to seconds.
+     */
+    static msToS(ms: number): number;
+    /**
+     * Get the current performance timestamp in ms.
+     */
+    static now(): number;
+    /**
+     * Pad start of a number string.
+     *
+     * ```js
+     * Utils.padStart(5, 3, '0'); // '005'
+     * ```
+     */
+    static padStart(value: number, total_length: number, pad: string): string;
+    /**
+     * Parse a time string ("1s", "500ms", "30f@60fps") to milliseconds.
+     */
+    static parseTime(s: string): number | undefined;
+    /**
+     * Apply a series of transform functions to a starting value (left-to-right pipe).
+     *
+     * ```js
+     * const transform = Utils.pipe(
+     *   v => v * 2,
+     *   v => v + 10,
+     *   v => Math.round(v),
+     * );
+     * transform(5); // 20  (5*2=10, 10+10=20, round(20)=20)
+     * ```
+     */
+    static pipe(fns: Array<any>): Function;
+    /**
+     * Convert radians to degrees.
+     */
+    static radToDeg(radians: number): number;
+    /**
+     * Random float between min (inclusive) and max (exclusive).
+     *
+     * ```js
+     * Utils.random(0, 100);      // e.g. 42.7
+     * Utils.random(0, 100, 0);   // e.g. 73 (integer)
+     * ```
+     */
+    static random(min: number, max: number): number;
+    /**
+     * Random integer between min and max (inclusive).
+     */
+    static randomInt(min: number, max: number): number;
+    /**
+     * Random item from an array.
+     */
+    static randomItem(arr: Array<any>): any;
+    /**
+     * Alias for `mapRange`. Kept for backwards compatibility.
+     */
+    static remap(value: number, in_start: number, in_end: number, out_start: number, out_end: number): number;
+    /**
+     * Round and format a number with fixed decimal places.
+     *
+     * ```js
+     * Utils.roundPad(3.14159, 2); // '3.14'
+     * ```
+     */
+    static roundPad(value: number, decimal_length: number): string;
+    /**
+     * Round to specified decimal places.
+     */
+    static roundTo(value: number, decimals: number): number;
+    /**
+     * Convert seconds to milliseconds.
+     */
+    static sToMs(s: number): number;
+    /**
+     * Set a CSS property on an element immediately (no animation).
+     *
+     * ```js
+     * Utils.setProperty(el, 'opacity', 0.5);
+     * Utils.setProperty(el, 'translateX', 100);  // applies as transform
+     * ```
+     */
+    static setProperty(element: Element, prop: string, value: number): void;
+    /**
+     * Shuffle an array (Fisher-Yates). Returns a new array.
+     */
+    static shuffle(arr: Array<any>): Array<any>;
+    /**
+     * Get the sign of a number (-1, 0, or 1).
+     */
+    static sign(value: number): number;
+    /**
+     * Snap value to nearest multiple of step.
+     *
+     * ```js
+     * Utils.snap(47, 50); // 50
+     * Utils.snap(24, 50); // 0
+     * ```
+     */
+    static snap(value: number, step: number): number;
+    /**
+     * Snap to the nearest value in a list of snap points.
+     *
+     * ```js
+     * Utils.snapToPoints(42, [0, 50, 100, 200]); // 50
+     * ```
+     */
+    static snapToPoints(value: number, points: Array<any>): number;
+    /**
+     * Truncate to integer (towards zero).
+     */
+    static trunc(value: number): number;
+    /**
+     * Wrap a value within a range [min, max).
+     *
+     * ```js
+     * Utils.wrap(380, 0, 360); // 20
+     * Utils.wrap(-10, 0, 360); // 350
+     * ```
+     */
+    static wrap(value: number, min: number, max: number): number;
+}
+
+/**
+ * Persistent per-property animation binder.
+ */
+export class WasmAnimatable {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get the currently cached target value for a property.
+     * To get the live DOM value, use `getLive(prop)`.
+     */
+    get(prop: string): number;
+    /**
+     * Get the live computed CSS value (reads from DOM each call).
+     */
+    getLive(prop: string): number;
+    /**
+     * Cancel all running animations and restore initial values.
+     */
+    revert(): void;
+    /**
+     * Animate a property to a new value.
+     *
+     * Parameters:
+     * - `prop`     — CSS property or transform (e.g. `"translateX"`, `"opacity"`)
+     * - `to`       — Target value as a number
+     * - `duration` — Override duration in ms (`null` = use per-property default)
+     * - `easing`   — Override easing string (`null` = use per-property default)
+     */
+    set(prop: string, to: number, duration?: number | null, easing?: string | null): void;
+    /**
+     * Immediately set a property value without animation.
+     */
+    setImmediate(prop: string, value: number): void;
+    /**
+     * Stop all running animations without restoring values.
+     */
+    stop(): void;
+    /**
+     * Whether any property animation is currently running.
+     */
+    readonly isAnimating: boolean;
+    /**
+     * The underlying target element.
+     */
+    readonly target: Element;
+}
+
+/**
+ * Animation handle exposed to JavaScript.
+ */
+export class WasmAnimation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Remove this animation and clean up resources.
+     */
+    destroy(): void;
+    /**
+     * Set onBegin callback.
+     */
+    onBegin(cb: Function): void;
+    /**
+     * Set onComplete callback.
+     */
+    onComplete(cb: Function): void;
+    /**
+     * Set onLoop callback (receives iteration number).
+     */
+    onLoop(cb: Function): void;
+    /**
+     * Set onUpdate callback (receives progress 0.0–1.0).
+     */
+    onUpdate(cb: Function): void;
+    /**
+     * Pause the animation. Returns true if the animation was paused.
+     */
+    pause(): boolean;
+    /**
+     * Play the animation (or resume if paused). Returns true if an action was taken.
+     */
+    play(): boolean;
+    /**
+     * Restart the animation from the beginning. Returns true if restarted.
+     */
+    restart(): boolean;
+    /**
+     * Reverse the playback direction. Returns true if reversed.
+     */
+    reverse(): boolean;
+    /**
+     * Seek to a specific time in milliseconds.
+     */
+    seek(time: number): void;
+    /**
+     * Set playback speed (1.0 = normal, 2.0 = double, 0.5 = half).
+     */
+    setSpeed(speed: number): void;
+    /**
+     * Whether the animation has completed.
+     */
+    readonly completed: boolean;
+    /**
+     * Get the total duration in milliseconds.
+     */
+    readonly duration: number;
+    /**
+     * Get a Promise that resolves when the animation completes.
+     */
+    readonly finished: Promise<any>;
+}
+
+/**
+ * Physics-based draggable element.
+ */
+export class WasmDraggable {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Destroy the draggable, release all event listeners and observers.
+     */
+    destroy(): void;
+    /**
+     * Disable dragging (cannot be grabbed).
+     */
+    disable(): void;
+    /**
+     * Enable dragging.
+     */
+    enable(): void;
+    /**
+     * Refresh container bounds (re-read from DOM). Called automatically on resize.
+     */
+    refresh(): void;
+    /**
+     * Reset position to (0, 0) and clear all state.
+     */
+    reset(): void;
+    /**
+     * Revert the draggable: reset position and destroy.
+     */
+    revert(): void;
+    /**
+     * Set X position immediately.
+     */
+    setX(x: number): void;
+    /**
+     * Set Y position immediately.
+     */
+    setY(y: number): void;
+    /**
+     * Apply current snap config to position.
+     */
+    snap(): void;
+    /**
+     * Current drag angle in radians.
+     */
+    readonly angle: number;
+    /**
+     * Delta X since last frame.
+     */
+    readonly deltaX: number;
+    /**
+     * Delta Y since last frame.
+     */
+    readonly deltaY: number;
+    /**
+     * Destination X (after snap/release calculation).
+     */
+    readonly destX: number;
+    /**
+     * Destination Y (after snap/release calculation).
+     */
+    readonly destY: number;
+    /**
+     * Whether currently being dragged.
+     */
+    readonly isDragging: boolean;
+    /**
+     * Whether the draggable is enabled.
+     */
+    readonly isEnabled: boolean;
+    /**
+     * Whether currently in release/settle phase.
+     */
+    readonly isReleasing: boolean;
+    /**
+     * X progress within container bounds [0, 1].
+     */
+    progressX: number;
+    /**
+     * Y progress within container bounds [0, 1].
+     */
+    progressY: number;
+    /**
+     * Current velocity magnitude (px/ms).
+     */
+    readonly velocity: number;
+    /**
+     * Current X velocity component.
+     */
+    readonly velocityX: number;
+    /**
+     * Current Y velocity component.
+     */
+    readonly velocityY: number;
+    /**
+     * Current X position (px).
+     */
+    readonly x: number;
+    /**
+     * Current Y position (px).
+     */
+    readonly y: number;
+}
+
+/**
+ * Global engine control exposed to JavaScript.
+ */
+export class WasmEngine {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of currently active animations.
+     */
+    static activeCount(): number;
+    /**
+     * Resume after a manual `suspend()`.
+     */
+    static resume(): void;
+    /**
+     * Set target FPS (0 = no limit, use native rAF rate).
+     */
+    static setFPS(fps: number): void;
+    /**
+     * Stop all animations and clear the engine.
+     */
+    static stopAll(): void;
+    /**
+     * Manually suspend ALL animations (independent of page visibility).
+     *
+     * ```js
+     * WasmEngine.suspend();   // freeze everything
+     * WasmEngine.resume();    // unfreeze
+     * ```
+     */
+    static suspend(): void;
+    /**
+     * Add a per-frame tick subscriber. Returns a subscriber ID for removal.
+     *
+     * ```js
+     * const id = WasmEngine.tickerAdd((time, deltaTime) => {
+     *   console.log(`frame at ${time}ms, delta=${deltaTime}ms`);
+     * });
+     * WasmEngine.tickerRemove(id);
+     * ```
+     */
+    static tickerAdd(cb: Function): bigint;
+    /**
+     * Remove all tick subscribers.
+     */
+    static tickerClear(): void;
+    /**
+     * Remove a tick subscriber by its ID.
+     */
+    static tickerRemove(id: bigint): void;
+    /**
+     * Number of DOM write errors encountered.
+     */
+    static writeErrorCount(): number;
+    /**
+     * Current measured frames-per-second (rolling 16-frame average).
+     */
+    static readonly fps: number;
+    /**
+     * Whether the engine is currently manually suspended.
+     */
+    static readonly suspended: boolean;
+}
+
+export class WasmFlipAnimation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    destroy(): void;
+    finish(): void;
+    pause(): void;
+    resume(): void;
+    revert(): void;
+    readonly isActive: boolean;
+    readonly progress: number;
+}
+
+export class WasmFlipState {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly length: number;
+}
+
+export class WasmHoverGesture {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    destroy(): void;
+    disable(): void;
+    enable(): void;
+    revert(): void;
+    readonly isActive: boolean;
+}
+
+/**
+ * Standalone inertia simulation handle.
+ */
+export class WasmInertia {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(config: any);
+    /**
+     * Advance the inertia simulation and return `[position, settled_flag]`.
+     *
+     * `settled_flag` is `1.0` when the simulation is settled and `0.0` otherwise.
+     * A `Float64Array` is used here to keep the JS bridge allocation-light.
+     */
+    tick(delta_ms: number): Float64Array;
+    readonly isSettled: boolean;
+    readonly position: number;
+    readonly velocity: number;
+}
+
+/**
+ * Keyframe sequence for multi-stop animations.
+ *
+ * ```js
+ * const seq = new WasmKeyframeSequence('target', 'opacity', 1000);
+ * seq.addKeyframe(0.0, 0);
+ * seq.addKeyframe(0.5, 1, 'easeInQuad');
+ * seq.addKeyframe(1.0, 0.5);
+ * console.log(seq.valueAt(500)); // 1.0
+ * ```
+ */
+export class WasmKeyframeSequence {
+    free(): void;
+    [Symbol.dispose](): void;
+    addKeyframe(offset: number, value: any, easing?: string | null): void;
+    formattedValueAt(time: number): string | undefined;
+    keyframeCount(): number;
+    constructor(target: string, property: string, duration: number);
+    valueAt(time: number): number | undefined;
+    readonly duration: number;
+}
+
+export class WasmLayoutTransition {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    destroy(): void;
+    finish(): void;
+    pause(): void;
+    resume(): void;
+    revert(): void;
+    readonly isActive: boolean;
+    readonly progress: number;
+    readonly targetCount: number;
+}
+
+/**
+ * A reactive numeric motion value handle.
+ */
+export class WasmMotionValue {
+    free(): void;
+    [Symbol.dispose](): void;
+    connectDOM(element: Element, property: string): void;
+    destroy(): void;
+    get(): number;
+    getVelocity(): number;
+    jump(value: number): void;
+    constructor(init: number);
+    on(callback: Function): Function;
+    set(value: number): void;
+    setWithVelocity(previous: number, current: number, delta_ms: number): void;
+}
+
+export class WasmObserver {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    destroy(): void;
+    disable(): void;
+    enable(): void;
+    refresh(): void;
+    revert(): void;
+    readonly enabled: boolean;
+}
+
+export class WasmPanGesture {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    destroy(): void;
+    disable(): void;
+    enable(): void;
+    revert(): void;
+    readonly isActive: boolean;
+}
+
+/**
+ * Standalone 2D physics simulation handle.
+ */
+export class WasmPhysics2D {
+    free(): void;
+    [Symbol.dispose](): void;
+    clearAttractor(): void;
+    impulse(vx: number, vy: number): void;
+    constructor(config: any);
+    setAttractor(x: number, y: number, strength: number, max_force: number): void;
+    tick(delta_ms: number): Float64Array;
+    readonly isResting: boolean;
+    readonly velocityX: number;
+    readonly velocityY: number;
+    readonly x: number;
+    readonly y: number;
+}
+
+/**
+ * Standalone multi-property physics simulation handle.
+ */
+export class WasmPhysicsProps {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(config: any);
+    tick(delta_ms: number): any;
+    readonly isSettled: boolean;
+}
+
+export class WasmPressGesture {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    destroy(): void;
+    disable(): void;
+    enable(): void;
+    revert(): void;
+    readonly isActive: boolean;
+}
+
+/**
+ * Scoped animation manager.
+ *
+ * ```js
+ * const scope = createScope({ mediaQueries: { sm: '(max-width: 768px)' } });
+ * scope.add(() => {
+ *   animate('.box', { translateX: [0, 100], duration: 500 });
+ * });
+ * // Later:
+ * scope.revert(); // stops everything
+ * ```
+ */
+export class WasmScope {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a constructor callback. Executed immediately; any animations created
+     * during execution are tracked for cleanup.
+     */
+    add(callback: Function): void;
+    /**
+     * Revert all current instances, then re-run all constructors.
+     */
+    refresh(): void;
+    /**
+     * Revert all tracked animations, observers, and splitters.
+     */
+    revert(): void;
+    /**
+     * Current media query match state.
+     */
+    readonly matches: object;
+}
+
+export class WasmScrambleText {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    destroy(): void;
+    finish(): void;
+    pause(): void;
+    resume(): void;
+    revert(): void;
+    readonly currentText: string;
+    readonly isActive: boolean;
+    readonly progress: number;
+}
+
+export class WasmScrollObserver {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Destroy the observer and remove all listeners. This is an alias for `revert()`.
+     */
+    destroy(): void;
+    /**
+     * Link an animation to this scroll observer.
+     */
+    link(animation: WasmAnimation): void;
+    /**
+     * Recompute scroll offsets (call after layout changes).
+     */
+    refresh(): void;
+    /**
+     * Clean up the observer and remove scroll listeners if no longer needed.
+     */
+    revert(): void;
+    /**
+     * Whether the observed element is currently in the scroll view.
+     */
+    readonly isInView: boolean;
+    /**
+     * The scroll position (in px) where the leave threshold fires.
+     */
+    readonly offsetEnd: number;
+    /**
+     * The scroll position (in px) where the enter threshold fires.
+     */
+    readonly offsetStart: number;
+    /**
+     * Current scroll progress [0.0, 1.0].
+     */
+    readonly progress: number;
+}
+
+export class WasmScrollSmoother {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    destroy(): void;
+    pause(): void;
+    refresh(): void;
+    resume(): void;
+    revert(): void;
+    readonly currentY: number;
+    readonly paused: boolean;
+    readonly progress: number;
+    readonly targetY: number;
+}
+
+export class WasmScrollTo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    destroy(): void;
+    revert(): void;
+    readonly isActive: boolean;
+    readonly progress: number;
+}
+
+/**
+ * Spring physics configuration and evaluation.
+ */
+export class WasmSpring {
+    free(): void;
+    [Symbol.dispose](): void;
+    static fromBounce(bounce: number, duration: number): WasmSpring;
+    constructor(mass: number, stiffness: number, damping: number, velocity?: number | null);
+    /**
+     * Sample the spring at evenly spaced points from t=0 to t=1.
+     *
+     * For `count > 0`, returns `count + 1` samples (including endpoints).
+     * For `count == 0`, returns a single sample at t=0.
+     */
+    sample(count: number): Float64Array;
+    solve(t: number): number;
+    readonly dampingRatio: number;
+    readonly duration: number;
+    readonly isBouncy: boolean;
+}
+
+export class WasmTextReplace {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    destroy(): void;
+    finish(): void;
+    pause(): void;
+    resume(): void;
+    revert(): void;
+    readonly currentText: string;
+    readonly isActive: boolean;
+    readonly progress: number;
+}
+
+export class WasmTextSplitter {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    destroy(): void;
+    refresh(): void;
+    revert(): void;
+    readonly chars: Array<any>;
+    readonly isAutoResplit: boolean;
+    readonly lines: Array<any>;
+    readonly words: Array<any>;
+}
+
+/**
+ * Timeline for sequencing multiple animations.
+ */
+export class WasmTimeline {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add an animation at a position in the timeline.
+     */
+    add(config: any, position?: string | null): void;
+    /**
+     * Add a label at the current end.
+     */
+    addLabel(label: string): void;
+    /**
+     * Insert a callback at a position in the timeline.
+     */
+    call(cb: Function, position?: string | null): void;
+    constructor();
+    /**
+     * Set onBegin callback.
+     */
+    onBegin(cb: Function): void;
+    /**
+     * Set onComplete callback.
+     */
+    onComplete(cb: Function): void;
+    /**
+     * Set onLoop callback (receives iteration number).
+     */
+    onLoop(cb: Function): void;
+    /**
+     * Set onPause callback.
+     */
+    onPause(cb: Function): void;
+    /**
+     * Set onResume callback.
+     */
+    onResume(cb: Function): void;
+    /**
+     * Set onUpdate callback (receives progress 0.0–1.0).
+     */
+    onUpdate(cb: Function): void;
+    /**
+     * Pause the timeline. Returns true if an active instance was paused.
+     */
+    pause(): boolean;
+    /**
+     * Play the timeline.
+     */
+    play(): void;
+    /**
+     * Restart the timeline. Returns true if an active instance was restarted.
+     */
+    restart(): boolean;
+    /**
+     * Reverse the timeline playback. Returns true if an action was taken.
+     */
+    reverse(): boolean;
+    /**
+     * Seek the timeline to a specific time and apply values.
+     */
+    seek(time: number): void;
+    /**
+     * Set repeat count (0 = infinite).
+     */
+    setRepeat(count: number): void;
+    /**
+     * Set playback speed (1.0 = normal, 2.0 = double, 0.5 = half).
+     */
+    setSpeed(speed: number): void;
+    /**
+     * Enable yoyo.
+     */
+    setYoyo(yoyo: boolean): void;
+    /**
+     * Duration of a single play-through.
+     */
+    readonly duration: number;
+    /**
+     * Get a Promise that resolves when the timeline completes.
+     */
+    readonly finished: Promise<any>;
+    /**
+     * Total duration including repeats.
+     */
+    readonly totalDuration: number;
+}
+
+/**
+ * A frame-accurate, fully-controllable timer.
+ */
+export class WasmTimer {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Cancel the timer (does not fire onComplete).
+     */
+    cancel(): void;
+    /**
+     * Pause the timer at the current position.
+     */
+    pause(): boolean;
+    /**
+     * Play the timer from its current position (or restart if completed).
+     */
+    play(): boolean;
+    /**
+     * Restart from the beginning.
+     */
+    restart(): boolean;
+    /**
+     * Reverse playback direction.
+     */
+    reverse(): void;
+    /**
+     * Seek to a specific time in ms.
+     */
+    seek(time: number): void;
+    /**
+     * Set playback speed multiplier.
+     */
+    setSpeed(speed: number): void;
+    /**
+     * Whether the timer has completed.
+     */
+    readonly completed: boolean;
+    /**
+     * Get the current elapsed time in ms.
+     */
+    readonly currentTime: number;
+    /**
+     * Total duration in ms.
+     */
+    readonly duration: number;
+    /**
+     * A Promise that resolves when the timer completes.
+     */
+    readonly finished: Promise<any>;
+    /**
+     * Whether the timer is currently paused.
+     */
+    readonly paused: boolean;
+    /**
+     * Get current progress [0.0, 1.0].
+     */
+    readonly progress: number;
+}
+
+export class WasmViewTransition {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    skipTransition(): void;
+    readonly finished: any;
+    readonly isNative: boolean;
+    readonly ready: any;
+    readonly updateCallbackDone: any;
+}
+
+export class WasmWaapiAnimation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    commitStyles(): void;
+    destroy(): void;
+    finish(): void;
+    pause(): void;
+    play(): void;
+    reverse(): void;
+    revert(): void;
+    readonly animations: Array<any>;
+    readonly currentTime: number;
+    readonly duration: number;
+    readonly persist: boolean;
+    readonly progress: number;
+}
+
+/**
+ * Create and start an animation.
+ *
+ * ```js
+ * const anim = animate({
+ *   targets: '.box',
+ *   translateX: [0, 250],
+ *   opacity: [0, 1],
+ *   scale: [0.5, 1],
+ *   duration: 1000,
+ *   delay: 0,
+ *   easing: 'easeOutCubic',
+ *   loop: 1,
+ *   direction: 'normal',
+ *   autoplay: true,
+ *   stagger: 100,
+ *   composition: 'replace',  // or 'add', 'accumulate'
+ *   begin: (anim) => {},
+ *   update: (progress) => {},
+ *   complete: (anim) => {},
+ * });
+ *
+ * // Control
+ * anim.pause();
+ * anim.play();
+ * anim.seek(500);
+ * anim.reverse();
+ * anim.restart();
+ *
+ * // Promise
+ * await anim.finished;
+ * ```
+ */
+export function animate(config: any): WasmAnimation;
+
+/**
+ * Animate properties of a plain JavaScript object.
+ *
+ * All numeric properties are interpolated each frame and written back to the
+ * object via `Reflect.set`. Use the `update` callback to react to changes.
+ *
+ * ```js
+ * const state = { progress: 0 };
+ * const anim = animateObject(state, {
+ *   progress: [0, 1],
+ *   duration: 2000,
+ *   update: () => draw(state.progress),
+ * });
+ * ```
+ */
+export function animateObject(obj: any, config: any): WasmAnimation;
+
+export function commitStyles(value: any): void;
+
+/**
+ * Create a persistent property animator for a DOM element.
+ *
+ * Property configs are specified per-property in the `config` object:
+ * - A number means duration in ms (uses default easing)
+ * - An object `{ duration, easing }` sets both defaults
+ *
+ * ```js
+ * const box = createAnimatable('.box', {
+ *   translateX: { duration: 600, easing: 'spring(1,80,12,0)' },
+ *   translateY: { duration: 600, easing: 'spring(1,80,12,0)' },
+ *   opacity:    { duration: 200, easing: 'easeOutQuad' },
+ *   scale:      400,  // 400ms, default easing
+ * });
+ * ```
+ */
+export function createAnimatable(target: any, config: any): WasmAnimatable;
+
+/**
+ * Create a fully-featured draggable element.
+ */
+export function createDraggable(target: any, config: any): WasmDraggable;
+
+/**
+ * Set up an SVG geometry element for stroke-drawing animation.
+ *
+ * - Resolves `selector` in the document.
+ * - Casts the element to `SVGGeometryElement` (returns `Err` if not geometry).
+ * - Sets `pathLength="1000"` so that dash values are normalised.
+ * - Applies the initial draw state using `start`.
+ * - Returns a `DrawableHandle` wrapping the element.
+ */
+export function createDrawable(selector: string, start: number, end: number): DrawableHandle;
+
+export function createHover(target: any, config: any): WasmHoverGesture;
+
+/**
+ * Resolve an SVG geometry element, read its total length once, and return
+ * three tween-object values for `translateX`, `translateY`, and `rotate`.
+ *
+ * `offset` (clamped to `[0.0, 1.0]`) shifts the starting position along
+ * the path.
+ */
+export function createMotionPath(path_selector: string, offset: number): MotionPathValues;
+
+export function createObserver(config: any): WasmObserver;
+
+export function createPan(target: any, config: any): WasmPanGesture;
+
+export function createPress(target: any, config: any): WasmPressGesture;
+
+/**
+ * Create a new scope.
+ *
+ * ```js
+ * const scope = createScope({
+ *   mediaQueries: { sm: '(max-width: 768px)', lg: '(min-width: 1024px)' }
+ * });
+ * ```
+ */
+export function createScope(config: any): WasmScope;
+
+/**
+ * Create a scroll observer from a JS config object.
+ *
+ * ```js
+ * const obs = createScrollObserver({
+ *   target: '.hero',
+ *   enter: 'end start',
+ *   leave: 'start end',
+ *   sync: 'linear',
+ *   axis: 'y',
+ * });
+ * obs.link(animation);
+ * ```
+ */
+export function createScrollObserver(config: any): WasmScrollObserver;
+
+export function createScrollSmoother(config: any): WasmScrollSmoother;
+
+/**
+ * Create a new timer.
+ *
+ * ```js
+ * const timer = createTimer({
+ *   duration: 2000,
+ *   loop: 3,
+ *   easing: 'linear',
+ *   onBegin:    (t) => console.log('start'),
+ *   onUpdate:   (t) => draw(t.progress),
+ *   onLoop:     (t) => console.log('loop', t.currentIteration),
+ *   onComplete: (t) => console.log('done'),
+ * });
+ *
+ * // Infinite: use `duration: Infinity` or `loop: Infinity`
+ * const ticker = createTimer({
+ *   duration: Infinity,
+ *   onUpdate: (t) => physics.step(t.deltaTime),
+ * });
+ * ```
+ */
+export function createTimer(config: any): WasmTimer;
+
+export function easingToLinear(easing: any, samples: number): string;
+
+export function flipCapture(targets: any): WasmFlipState;
+
+export function flipFrom(state: WasmFlipState, config: any): WasmFlipAnimation;
+
+export function followValue(source: WasmMotionValue, spring_config: any): WasmMotionValue;
+
+export function init(): void;
+
+export function layoutTransition(targets: any, update: Function, config: any): WasmLayoutTransition;
+
+export function mapValue(source: WasmMotionValue, input_range: Array<any>, output_range: Array<any>): WasmMotionValue;
+
+export function motionValue(init: number): WasmMotionValue;
+
+export function registerTransformProperties(): boolean;
+
+/**
+ * Register a JS object (scroll observer, text splitter, draggable, etc.) with the currently
+ * active scope. The object must have a `.revert()` or `.destroy()` method.
+ *
+ * This is called automatically for `animate()` and `animateObject()` calls.
+ * For other objects (draggable, scroll observer, text splitter), call this manually
+ * inside a scope constructor, or call `scope.add(() => { ... })` which auto-tracks them.
+ *
+ * ```js
+ * scope.add(() => {
+ *   const drag = createDraggable('.el', {...});
+ *   scopeRegisterJs(drag); // register for auto-destroy on scope.revert()
+ * });
+ * ```
+ */
+export function scopeRegisterJs(val: any): void;
+
+export function scrambleText(target: any, config: any): WasmScrambleText;
+
+export function scrollTo(config: any): WasmScrollTo;
+
+export function splitText(target: any, config: any): WasmTextSplitter;
+
+/**
+ * Calculate stagger delays.
+ *
+ * ```js
+ * // Simple: 100ms between each
+ * const delays = stagger(100, 5);         // [0, 100, 200, 300, 400]
+ *
+ * // From center
+ * const delays = stagger(100, 5, { from: 'center' });  // [200, 100, 0, 100, 200]
+ *
+ * // Value range [min, max] mapped across elements
+ * const delays = stagger([100, 500], 5);  // [100, 200, 300, 400, 500]
+ *
+ * // Grid stagger (2D)
+ * const delays = stagger(50, 20, { grid: [5, 4], from: 'center', axis: 'x' });
+ * ```
+ */
+export function stagger(value: any, count: number, options: any): Float64Array;
+
+/**
+ * Simple stagger with count + optional from string (backwards-compatible API).
+ *
+ * ```js
+ * const delays = staggerSimple(100, 5, 'center');
+ * ```
+ */
+export function staggerSimple(delay: number, count: number, from?: string | null): Float64Array;
+
+export function startViewTransition(update: Function, config: any): WasmViewTransition;
+
+export function textReplace(target: any, config: any): WasmTextReplace;
+
+export function version(): string;
+
+export function waapi(targets: any, config: any): WasmWaapiAnimation;