@streamsai/ui 0.0.0-stage → 0.1.0

package/dist/motion/config.d.ts

@@ -0,0 +1,849 @@
+import type { Transition } from 'motion/react';
+/**
+ * The one place motion is tuned. Every animation in the product is a `motion` (motion.dev)
+ * animation that reads its timing from here: popups, dialogs, sheets, collapses, route and pane
+ * changes, lists, progress, loops. CSS does not animate, with two exceptions that cannot be
+ * `motion` without real cost: hover/focus/press feedback on colour, border, shadow and opacity
+ * (driven by pseudo-classes), and the mobile View Transitions. Those read the `--motion-*`
+ * custom properties in `styles/tokens.css`, which mirror `duration` and `ease` below;
+ * `config.test.ts` fails when the two drift, so a change here is a change in tokens.css too.
+ *
+ * The house style is quick and quiet: things arrive with a short fade and a few pixels of travel,
+ * leave faster than they came, and nothing bounces more than a hair. Reduced motion is honoured
+ * globally (`MotionProvider` and the reset in `globals.css`), so no call site checks it.
+ */
+type CubicBezier = [number, number, number, number];
+/** Seconds (what `motion` takes). tokens.css carries the same numbers in ms. */
+export declare const duration: {
+    /** Sense `short-100`: a small element leaving (`presets.scaleIn`'s exit). */
+    readonly short: 0.1;
+    /** Hover washes, icon swaps, press feedback: anything the pointer is already on. */
+    readonly fast: 0.12;
+    /** The default: popups, panels, rows entering, route content, collapses. */
+    readonly base: 0.2;
+    /** Large surfaces travelling a long way: sheets, the details pane, the viewer. */
+    readonly slow: 0.32;
+    /** One orchestrated page-load moment (brand and auth pages, `presets.reveal`). */
+    readonly reveal: 0.48;
+};
+export declare const ease: {
+    /** Symmetric, for things that change in place (colour, width, rotation). */
+    readonly standard: CubicBezier;
+    /** Entrances: fast start, long soft landing. */
+    readonly out: CubicBezier;
+    /** Exits: leave quickly, no lingering. */
+    readonly in: CubicBezier;
+    /** Sense `ease-enter`: decelerates into place, for scale entrances. */
+    readonly enter: CubicBezier;
+    /** Sense `ease-exit`: accelerates away, for scale exits. */
+    readonly exit: CubicBezier;
+};
+/** Springs for things that move because the layout moved (reorders, pills, indicators). */
+export declare const spring: {
+    /** Layout shifts, reorders, a tab indicator sliding: settles in about `base`. */
+    readonly snappy: {
+        readonly type: "spring";
+        readonly visualDuration: 0.22;
+        readonly bounce: 0.12;
+    };
+    /** Small things popping into place (reactions, badges): a touch of overshoot. */
+    readonly pop: {
+        readonly type: "spring";
+        readonly visualDuration: 0.24;
+        readonly bounce: 0.28;
+    };
+};
+/** Pixels of travel. Motion here suggests direction, it never carries content across the screen. */
+export declare const distance: {
+    /** Rows, route content, toasts: the default rise. */
+    readonly nudge: 4;
+    /** Cards and empty states arriving on their own. */
+    readonly rise: 8;
+    /** Panels and drawers sliding in from an edge. */
+    readonly slide: 16;
+};
+/** Scale a popping element starts from. */
+export declare const scale: {
+    readonly pop: 0.94;
+    /** Popups and dialogs growing out of their trigger. */
+    readonly popup: 0.96;
+    readonly subtle: 0.98;
+    /** Sense `scale-enter` / `scale-exit`: never from 0, always from 95%. */
+    readonly enter: 0.95;
+};
+/** Seconds between siblings in a staggered group, and the ceiling on the whole cascade. */
+export declare const stagger: {
+    readonly step: 0.03;
+    /** Sense `short-20`: the offset between peers entering together, and an exit's fade delay. */
+    readonly offset: 0.02;
+    /** Items beyond this delay arrive together, so a long list never takes long to appear. */
+    readonly max: 0.18;
+};
+/** Ready-made transitions for the common cases. */
+export declare const transitions: {
+    readonly fast: {
+        readonly duration: 0.12;
+        readonly ease: CubicBezier;
+    };
+    readonly base: {
+        readonly duration: 0.2;
+        readonly ease: CubicBezier;
+    };
+    readonly enter: {
+        readonly duration: 0.2;
+        readonly ease: CubicBezier;
+    };
+    /** Popups, menus and tooltips: they answer a click, so they arrive at `fast`. */
+    readonly enterFast: {
+        readonly duration: 0.12;
+        readonly ease: CubicBezier;
+    };
+    readonly exit: {
+        readonly duration: 0.12;
+        readonly ease: CubicBezier;
+    };
+    readonly slow: {
+        readonly duration: 0.32;
+        readonly ease: CubicBezier;
+    };
+    /** A meter that follows a clock ticking every `base`: each step is linear so the sum drains evenly. */
+    readonly meter: {
+        readonly duration: 0.2;
+        readonly ease: "linear";
+    };
+    readonly layout: {
+        readonly type: "spring";
+        readonly visualDuration: 0.22;
+        readonly bounce: 0.12;
+    };
+    readonly pop: {
+        readonly type: "spring";
+        readonly visualDuration: 0.24;
+        readonly bounce: 0.28;
+    };
+};
+/**
+ * Pointer / tap press feedback. Use on a `motion.*` element as
+ * `whileTap={press.whileTap}` (and `transition={press.transition}`), never CSS
+ * `active:scale-*`. Reduced motion is honoured by `MotionProvider`.
+ *
+ * `commit.scale` stays a mutable `number[]` so it is assignable to motion's
+ * `animate` keyframes (a `readonly` tuple from `as const` is not).
+ */
+export declare const press: {
+    /** Scale while the pointer is down — quiet shrink, not a bounce. */
+    scale: 0.94;
+    whileTap: {
+        scale: 0.94;
+    };
+    transition: {
+        readonly duration: 0.12;
+        readonly ease: CubicBezier;
+    };
+    /**
+     * One-shot shrink→grow for keyboard / programmatic commit (e.g. Enter-to-send)
+     * where `whileTap` never fires. Drive `animate` from a short-lived flag.
+     */
+    commit: {
+        scale: number[];
+        transition: {
+            readonly type: "spring";
+            readonly visualDuration: 0.24;
+            readonly bounce: 0.28;
+        };
+    };
+};
+/**
+ * Prop bags for `motion.*` elements: `<motion.div {...presets.rise} />`. Each carries its own
+ * enter and exit, so it behaves the same inside `AnimatePresence` or on its own. Reach for these
+ * before writing an inline `initial` / `animate`; add a preset here rather than tuning one call site.
+ */
+export declare const presets: {
+    /** Opacity only. Overlays, content swapping in place, anything that should not move. */
+    readonly fade: {
+        readonly initial: {
+            readonly opacity: 0;
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly transition: {
+                readonly duration: 0.2;
+                readonly ease: CubicBezier;
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** The default entrance: fade plus a small rise. Rows, route content, messages. */
+    readonly rise: {
+        readonly initial: {
+            readonly opacity: 0;
+            readonly y: 4;
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly y: 0;
+            readonly transition: {
+                readonly duration: 0.2;
+                readonly ease: CubicBezier;
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly y: number;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** A card or empty state arriving on its own, a little more travel than `rise`. */
+    readonly lift: {
+        readonly initial: {
+            readonly opacity: 0;
+            readonly y: 8;
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly y: 0;
+            readonly transition: {
+                readonly duration: 0.32;
+                readonly ease: CubicBezier;
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly y: 4;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** Small elements appearing (reaction pills, badges, counters, indicators). */
+    readonly pop: {
+        readonly initial: {
+            readonly opacity: 0;
+            readonly scale: 0.94;
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly scale: 1;
+            readonly transition: {
+                readonly type: "spring";
+                readonly visualDuration: 0.24;
+                readonly bounce: 0.28;
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly scale: 0.94;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** One piece of content replacing another in the same spot (Copy → Copied, icon swaps). */
+    readonly swap: {
+        readonly initial: {
+            readonly opacity: 0;
+            readonly scale: 0.98;
+            readonly filter: "blur(2px)";
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly scale: 1;
+            readonly filter: "blur(0px)";
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+            readonly transitionEnd: {
+                readonly filter: "none";
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly scale: 0.98;
+            readonly filter: "blur(2px)";
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /**
+     * Odometer roll for a rising count: new value enters from the top, old exits downward.
+     * Clip the parent (`overflow-hidden`) so the travel stays inside the glyph box.
+     */
+    readonly wheelUp: {
+        readonly initial: {
+            readonly y: "-100%";
+            readonly opacity: 0;
+        };
+        readonly animate: {
+            readonly y: 0;
+            readonly opacity: 1;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+        readonly exit: {
+            readonly y: "100%";
+            readonly opacity: 0;
+            readonly transition: {
+                readonly duration: 0.1;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** Reverse of `wheelUp` — a falling count rolls the other way. */
+    readonly wheelDown: {
+        readonly initial: {
+            readonly y: "100%";
+            readonly opacity: 0;
+        };
+        readonly animate: {
+            readonly y: 0;
+            readonly opacity: 1;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+        readonly exit: {
+            readonly y: "-100%";
+            readonly opacity: 0;
+            readonly transition: {
+                readonly duration: 0.1;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** A dialog arriving over its backdrop: a fade, a slight grow and a short rise. */
+    readonly dialog: {
+        readonly initial: {
+            readonly opacity: 0;
+            readonly scale: 0.96;
+            readonly y: 4;
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly scale: 1;
+            readonly y: 0;
+            readonly transition: {
+                readonly duration: 0.2;
+                readonly ease: CubicBezier;
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly scale: 0.98;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** One-off page-load moment for brand surfaces (sign-in, the landing hero). */
+    readonly reveal: {
+        readonly initial: {
+            readonly opacity: 0;
+            readonly y: 8;
+            readonly filter: "blur(4px)";
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly y: 0;
+            readonly filter: "blur(0px)";
+            readonly transition: {
+                readonly duration: 0.48;
+                readonly ease: CubicBezier;
+            };
+            readonly transitionEnd: {
+                readonly filter: "none";
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly transition: {
+                readonly duration: 0.12;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /** Height 0 ↔ auto, for disclosure content and rows that expand in place. */
+    readonly collapse: {
+        readonly initial: {
+            readonly height: 0;
+            readonly opacity: 0;
+        };
+        readonly animate: {
+            readonly height: "auto";
+            readonly opacity: 1;
+            readonly transition: {
+                readonly height: {
+                    readonly duration: 0.2;
+                    readonly ease: CubicBezier;
+                };
+                readonly opacity: {
+                    readonly delay: 0.04;
+                    readonly duration: 0.2;
+                    readonly ease: CubicBezier;
+                };
+            };
+        };
+        readonly exit: {
+            readonly height: 0;
+            readonly opacity: 0;
+            readonly transition: {
+                readonly height: {
+                    readonly duration: 0.2;
+                    readonly ease: CubicBezier;
+                };
+                readonly opacity: {
+                    readonly duration: 0.12;
+                    readonly ease: CubicBezier;
+                };
+            };
+        };
+    };
+    /**
+     * Width 0 ↔ auto, for side panels that take space from their neighbour (the details pane): the
+     * neighbour narrows with the panel instead of snapping to its final width in one frame. The
+     * panel is an opaque surface, so it slides in solid with its edge. A fade on its own clock made
+     * the neighbour move while the panel was still invisible (and after it had gone), which read as
+     * two animations instead of one.
+     */
+    readonly collapseX: {
+        readonly initial: {
+            readonly width: 0;
+        };
+        readonly animate: {
+            readonly width: "auto";
+            readonly transition: {
+                readonly duration: 0.2;
+                readonly ease: CubicBezier;
+            };
+        };
+        readonly exit: {
+            readonly width: 0;
+            readonly transition: {
+                readonly duration: 0.2;
+                readonly ease: CubicBezier;
+            };
+        };
+    };
+    /**
+     * Sense `scale-enter` / `scale-exit`: grows from 95% on `ease.enter` with a linear fade over
+     * `base`, and leaves faster (`short`) on `ease.exit` with its fade a beat behind. Chips, thumbnails
+     * and cards that appear in place without travelling.
+     */
+    readonly scaleIn: {
+        readonly initial: {
+            readonly opacity: 0;
+            readonly scale: 0.95;
+        };
+        readonly animate: {
+            readonly opacity: 1;
+            readonly scale: 1;
+            readonly transition: {
+                readonly scale: {
+                    readonly duration: 0.2;
+                    readonly ease: CubicBezier;
+                };
+                readonly opacity: {
+                    readonly duration: 0.2;
+                    readonly ease: "linear";
+                };
+            };
+        };
+        readonly exit: {
+            readonly opacity: 0;
+            readonly scale: 0.95;
+            readonly transition: {
+                readonly scale: {
+                    readonly duration: 0.1;
+                    readonly ease: CubicBezier;
+                };
+                readonly opacity: {
+                    readonly duration: 0.1;
+                    readonly ease: "linear";
+                    readonly delay: 0.02;
+                };
+            };
+        };
+    };
+};
+/** Where Base UI placed the popup; `'none'` is a select laid over its trigger. */
+type PopupSide = 'top' | 'bottom' | 'left' | 'right' | 'inline-start' | 'inline-end' | 'none';
+/**
+ * Menus, popovers, selects, tooltips and hover cards: a quick scale-and-fade that drifts a few
+ * pixels out from the trigger. `side` is where the popup sits relative to its trigger.
+ */
+export declare const popup: (side?: PopupSide, dir?: "ltr" | "rtl") => {
+    initial: {
+        y: 4;
+        x: number;
+        opacity: number;
+        scale: 0.96;
+    } | {
+        y: number;
+        x: number;
+        opacity: number;
+        scale: 0.96;
+    } | {
+        x: 4;
+        y: number;
+        opacity: number;
+        scale: 0.96;
+    } | {
+        x: number;
+        y: number;
+        opacity: number;
+        scale: 0.96;
+    } | {
+        y: number;
+        x: number;
+        opacity: number;
+        scale: 0.96;
+    };
+    animate: {
+        opacity: number;
+        scale: number;
+        x: number;
+        y: number;
+        transition: {
+            readonly duration: 0.12;
+            readonly ease: CubicBezier;
+        };
+    };
+    exit: {
+        opacity: number;
+        scale: 0.96;
+        transition: {
+            readonly duration: 0.12;
+            readonly ease: CubicBezier;
+        };
+    };
+};
+/**
+ * A popup that fades and drifts a few pixels from the side it opens on, without the scale of
+ * `popup`. For a surface that reads as part of the form it belongs to: the dropdown lists and
+ * pickers of a dense editor. `tip` arrives faster than a list; `fade` does not move at all (a
+ * list that opens on hover).
+ */
+export declare const drift: (side?: PopupSide, kind?: "list" | "tip" | "fade") => {
+    initial: {
+        opacity: number;
+        y: number;
+    };
+    animate: {
+        opacity: number;
+        y: number;
+        transition: {
+            readonly duration: 0.1 | 0.12 | 0.18;
+            readonly ease: CubicBezier;
+        };
+    };
+    exit: {
+        opacity: number;
+        y: number;
+        transition: {
+            readonly duration: 0.1 | 0.12 | 0.18;
+            readonly ease: CubicBezier;
+        };
+    };
+};
+/** Sheets and drawers: the whole panel travels in from its edge and back out. */
+export declare const sheet: (side: "top" | "bottom" | "left" | "right") => {
+    initial: {
+        y: string;
+        x?: undefined;
+    } | {
+        y: string;
+        x?: undefined;
+    } | {
+        x: string;
+        y?: undefined;
+    } | {
+        x: string;
+        y?: undefined;
+    };
+    animate: {
+        transition: {
+            readonly duration: 0.32;
+            readonly ease: CubicBezier;
+        };
+        x: number;
+        y?: undefined;
+    } | {
+        transition: {
+            readonly duration: 0.32;
+            readonly ease: CubicBezier;
+        };
+        y: number;
+        x?: undefined;
+    };
+    exit: {
+        transition: {
+            duration: 0.2;
+            ease: CubicBezier;
+        };
+        y: string;
+        x?: undefined;
+    } | {
+        transition: {
+            duration: 0.2;
+            ease: CubicBezier;
+        };
+        y: string;
+        x?: undefined;
+    } | {
+        transition: {
+            duration: 0.2;
+            ease: CubicBezier;
+        };
+        x: string;
+        y?: undefined;
+    } | {
+        transition: {
+            duration: 0.2;
+            ease: CubicBezier;
+        };
+        x: string;
+        y?: undefined;
+    };
+};
+/** Inline-start / end slides for panels, drawers and pane swaps. `dir` flips them in RTL. */
+export declare const slide: (from: "start" | "end", dir?: "ltr" | "rtl") => {
+    initial: {
+        opacity: number;
+        x: number;
+    };
+    animate: {
+        opacity: number;
+        x: number;
+        transition: {
+            readonly duration: 0.2;
+            readonly ease: CubicBezier;
+        };
+    };
+    exit: {
+        opacity: number;
+        x: number;
+        transition: {
+            readonly duration: 0.12;
+            readonly ease: CubicBezier;
+        };
+    };
+};
+/**
+ * Height changes of content that stays in place, driven by `AutoHeight`. Symmetric, because a card
+ * that grows and shrinks should not snap on either leg (`ease.out` front-loads nearly all of the
+ * movement into the first frames). `reveal` is for small things appearing in a card (an error, an
+ * input, a list expanding); `step` is for a whole question changing, so it matches `stepSwap`.
+ */
+export declare const resize: {
+    readonly reveal: {
+        readonly duration: 0.25;
+        readonly ease: CubicBezier;
+    };
+    readonly step: {
+        readonly duration: 0.35;
+        readonly ease: CubicBezier;
+    };
+};
+/**
+ * A diagram re-flowing around a change (a branch added or removed in the cycle builder): nodes,
+ * connectors, chips and the line joining them all travel on this one clock, so they arrive together
+ * and nothing is seen jumping. Slightly slower than a card moving alone, because the whole picture moves.
+ */
+export declare const reflow: {
+    readonly duration: 0.3;
+    readonly ease: CubicBezier;
+};
+/**
+ * A row gliding into a list that follows its end (a cycle divider): the rows above rise as it grows,
+ * so it is deliberately slower than `reflow`, and symmetric so the lift starts and lands softly.
+ */
+export declare const glide: {
+    readonly duration: 0.65;
+    readonly ease: CubicBezier;
+};
+/**
+ * The edit button of a connector sliding out from behind its "+" (cycle builder). `shift` is the
+ * button's width plus the 6px gap. The slide is quick and decelerates hard; the fade is `fast`.
+ * Reduced motion drops the transform and keeps the fade (`MotionProvider`).
+ */
+export declare const edgeReveal: {
+    readonly shift: 42;
+    readonly transition: {
+        readonly x: {
+            readonly duration: 0.18;
+            readonly ease: CubicBezier;
+        };
+        readonly opacity: {
+            readonly duration: 0.12;
+            readonly ease: CubicBezier;
+        };
+    };
+};
+/**
+ * One step of a multi-step flow replacing another, cross-fading (use with `AnimatePresence
+ * mode="popLayout" custom={dir}`). `dir` is 1 for forward and -1 for back: the old step leaves
+ * toward the side it came from and the new one arrives a beat later from the other, so the two
+ * overlap and nothing pops. Travel is `distance.slide`.
+ */
+export declare const stepSwap: {
+    initial: (dir: 1 | -1) => {
+        opacity: number;
+        x: number;
+    };
+    animate: {
+        opacity: number;
+        x: number;
+        transition: {
+            duration: number;
+            delay: number;
+            ease: CubicBezier;
+        };
+    };
+    exit: (dir: 1 | -1) => {
+        opacity: number;
+        x: number;
+        transition: {
+            duration: number;
+            ease: CubicBezier;
+        };
+    };
+};
+/**
+ * A clipped one-line label (sidebar stream and session titles) sliding the rest of itself into
+ * view while hovered, then holding at the end. `to(px)` runs at a steady reading pace, so a long
+ * title takes longer than a short one, after a rest that keeps a pointer sweeping past rows from
+ * setting them all moving. `back` snaps home at once when the pointer leaves: no rewind.
+ */
+export declare const scrollReveal: {
+    /** Seconds the pointer rests on the row before the title starts moving. */
+    delay: number;
+    /** Pixels per second. */
+    speed: number;
+    to: (px: number) => Transition;
+    back: {
+        duration: number;
+    };
+};
+/** Delay for the `index`-th item of a staggered group, `step` apart and capped at `stagger.max`. */
+export declare const staggerDelay: (index: number, step?: number) => number;
+/**
+ * Infinite-loop transitions for loading indicators. These run forever at a steady cadence so the
+ * loading state is always perceptible. Under reduced motion anything that moves stops (the spinner
+ * stops turning) and the opacity pulses carry on, so loading still shows.
+ */
+export declare const loops: {
+    /** Spinner: one full clockwise turn per second, linear. Animate `transform`, not `rotate`, so
+     *  the browser runs it (motion drives `rotate` in JS, every frame). */
+    readonly spin: {
+        readonly repeat: number;
+        readonly repeatType: "loop";
+        readonly ease: "linear";
+        readonly duration: 1;
+    };
+    /**
+     * Skeleton and status-dot: smooth opacity float, slow enough to read as "still loading". Give it
+     * keyframes that come back to where they start (`[1, 0.4, 1]`): it loops rather than mirrors, so
+     * the browser runs it off the main thread (motion drives a mirrored loop in JS, every frame).
+     */
+    readonly pulse: {
+        readonly repeat: number;
+        readonly repeatType: "loop";
+        readonly ease: CubicBezier;
+        readonly duration: 1.4;
+    };
+    /** Text caret while an agent streams its reply: a soft on/off at a typing cadence. */
+    readonly blink: {
+        readonly repeat: number;
+        readonly repeatType: "mirror";
+        readonly ease: CubicBezier;
+        readonly duration: 0.53;
+    };
+    /**
+     * AI shimmer text (shadcn AI Shimmer / AI Elements): animate `backgroundPosition` from
+     * `100% center` → `0% center` forever so a clipped gradient sweeps across the glyphs.
+     * Duration matches the AI Elements default (2s).
+     */
+    readonly shimmer: {
+        readonly repeat: number;
+        readonly repeatType: "loop";
+        readonly ease: "linear";
+        readonly duration: 2;
+    };
+    /** Vibe skeleton wave: a highlight band crosses the placeholder, then rests before the next. */
+    readonly sweep: {
+        readonly repeat: number;
+        readonly repeatType: "loop";
+        readonly ease: CubicBezier;
+        readonly duration: 1.6;
+        readonly repeatDelay: 0.4;
+    };
+};
+export declare const runningIndicator: {
+    readonly core: {
+        readonly transform: ["scale(1)", "scale(0.88)", "scale(1)"];
+    };
+    readonly halo: {
+        readonly opacity: [1, 0, 1];
+    };
+    readonly transition: {
+        readonly repeat: number;
+        readonly repeatType: "loop";
+        readonly ease: CubicBezier;
+        readonly duration: 2;
+    };
+};
+export declare const loopAnimate: {
+    /** Spinner / Trace running icon: opacity pulse + WAAPI spin. */
+    spinner: {
+        opacity: number[];
+        transform: string[];
+    };
+    /** Same pulse without the turn (reduced motion / `prefers-reduced-motion`). */
+    spinnerReduced: {
+        opacity: number[];
+    };
+    /** ShimmerText / Trace running title: gradient sweep across glyphs. */
+    shimmer: {
+        backgroundPosition: string[];
+    };
+};
+export declare const loopTransition: {
+    spinner: {
+        transform: {
+            readonly repeat: number;
+            readonly repeatType: "loop";
+            readonly ease: "linear";
+            readonly duration: 1;
+        };
+        opacity: {
+            readonly repeat: number;
+            readonly repeatType: "loop";
+            readonly ease: CubicBezier;
+            readonly duration: 1.4;
+        };
+    };
+    shimmer: {
+        readonly repeat: number;
+        readonly repeatType: "loop";
+        readonly ease: "linear";
+        readonly duration: 2;
+    };
+};
+export {};