coily 0.14.0 → 0.15.0

package/README.md

@@ -41,15 +41,17 @@ defineSpring({ tension: 500, dampingRatio: 0.7 }) // damping derived
 defineSpring({ tension: 500, bounce: 0.3 }) // bounce = 1 - dampingRatio
 defineSpring({ duration: 750, dampingRatio: 1 }) // tuned to settle in ~750ms
 defineSpring({ duration: 750, bounce: 0.5 })
+defineSpring({ tension: 500, bounce: 0.9, arrival: 'stop' }) // dead-stop at the target, no overshoot
 ```
 
 - **`tension`**: stiffness (> 0)
 - **`damping`**: friction (>= 0)
 - **`dampingRatio`**: 0 = undamped, < 1 = bouncy, 1 = critically damped, > 1 = overdamped
 - **`bounce`**: a friendlier alias for damping ratio, from -1 (overdamped) to 1 (max bounce)
-- **`duration`**: target settle time in ms. Assumes an initial displacement of 1. Pass `displacement` matching your animation range for accurate timing
+- **`duration`**: settle time in ms — the spring rests at this time, within a frame (a bouncy config can rest up to one oscillation earlier). Assumes an initial displacement of 1. Pass `displacement` matching your animation range for accurate timing
 - **`mass`**: defaults to 1
 - **`precision`**: decimal places of the resting threshold (default 2). A spring is _resting_ once its remaining motion cannot reach half a unit in the last place (0.005 at the default). Coily never rounds values. Set `precision` to match your domain's resolution (see [PRECISION.md](https://github.com/tkofh/coily/blob/main/PRECISION.md))
+- **`arrival`**: what the motion does when the value reaches the target. `'passthrough'` (default) swings through and settles; `'stop'` ends the motion exactly on the target the first time it gets there, however bouncy the config; a number between -1 and 1 scales the velocity at every crossing — negative values rebound. Crossings are solved exactly, never sampled frame by frame (see [PRECISION.md](https://github.com/tkofh/coily/blob/main/PRECISION.md))
 
 Without a config, springs are critically damped with a ~500ms settle time.
 
@@ -60,7 +62,7 @@ Without a config, springs are critically damped with a ~500ms settle time.
 - `spring.velocity`: current velocity, writable to fling
 - `spring.jumpTo(v)`: snap to a value with no animation
 - `spring.config`: assign a new `SpringDefinition`, or `null` to revert to the default
-- `spring.isResting`, `spring.timeRemaining`: settle state and estimated ms until rest
+- `spring.isResting`, `spring.timeRemaining`: settle state and ms until rest — solved from the motion, not estimated (see [PRECISION.md](https://github.com/tkofh/coily/blob/main/PRECISION.md))
 - `spring.settled`: a promise that resolves when the spring next comes to rest (immediately if already resting). Retargeting mid-flight extends the wait; disposing resolves it. `await spring.settled` to sequence animations
 - `spring.onUpdate(cb)` / `onStart(cb)` / `onStop(cb)` / `onDispose(cb)`: subscribe. Each returns an unsubscribe function. `start` fires when the spring leaves rest, `stop` when it settles. The two always alternate, and retargeting mid-flight fires neither
 - `spring.dispose()`: release the spring (calling it twice is a no-op)
@@ -98,7 +100,11 @@ const magnitude = system.createSpring(mapSpring(point, ({ x, y }) => Math.hypot(
 
 A mapped value is a `SpringSource`, the contract `target` accepts and every `Spring` implements. A `CompositeSpring` is a source _of its shape_: `mapSpring` reads it, alone or at the leaves of a shape, but only scalar sources can be followed directly.
 
-Follow graphs may contain cycles: retargets never re-emit, so nothing loops within a frame. Mutual followers converge to a shared value. A cycle whose maps expand (`(v) => v + 10` in both directions) chases forever and never rests, keeping the system awake until you break the cycle.
+Chains advance in dependency order: each frame, a spring moves after the springs it follows — whatever order anything was created or wired in — so a follower always chases its leader's current value rather than last frame's. Update events fire once per spring per frame, after every spring has moved, in that same leader-first order. A callback that reads another spring sees its final value for the frame, and a spring retargeted from inside a callback starts moving on the next frame.
+
+Following is accurate within the frame, too: a follower integrates against the path its leader actually traveled, not a value sampled once at the frame boundary, and when a single frame carries more motion than the system's `couplingTolerance` allows (0.1 value units by default), the system splits that frame into internal sub-steps. Dropped frames and teleporting targets refine themselves; update events still fire once per frame. The result is that a chain keeps the same shape at 30fps as at 120fps — see https://github.com/tkofh/coily/blob/main/PRECISION.md for the model.
+
+Follow graphs may contain cycles: retargets never re-emit, so nothing loops within a frame. Mutual followers converge to a shared value — the same value at any frame rate. A cycle has no order that puts every member after its leaders, so members advance in creation order and the edge that closes the loop chases one frame behind. A cycle whose maps expand (`(v) => v + 10` in both directions) chases forever and never rests, keeping the system awake until you break the cycle.
 
 ### Composites
 

package/dist/config-OOMMRdK8.d.ts

@@ -0,0 +1,312 @@
+//#region src/config.d.ts
+/**
+ * A spring's instantaneous motion, measured relative to its target.
+ * `SpringDefinition.computeTimeRemaining` takes one; build it from a live
+ * spring as `{ position: spring.value - spring.target, velocity: spring.velocity }`.
+ */
+interface SpringState {
+  /** Displacement from the target in value units. 0 means at the target. */
+  readonly position: number;
+  /** Rate of change of the displacement, in value units per second. */
+  readonly velocity: number;
+}
+interface BaseOptions {
+  /**
+   * Decimal places of the resting threshold. A spring rests once its
+   * remaining motion cannot reach half a unit in the last place —
+   * `0.5 * 10^-precision`, or 0.005 at the default.
+   *
+   * Values are never rounded; precision only decides rest. See
+   * https://github.com/tkofh/coily/blob/main/PRECISION.md.
+   *
+   * @default 2
+   */
+  readonly precision?: number | undefined;
+  /**
+   * What the motion does when the value reaches the target, as a
+   * multiplier applied to the velocity at every crossing.
+   *
+   * - `'passthrough'` — multiplier 1. The motion is untouched: the value
+   *   swings through the target and settles as its damping dictates.
+   * - `'stop'` — multiplier 0. Motion ends at the target the first time
+   *   the value gets there, with no overshoot, however bouncy the config.
+   * - A number between -1 and 1 sets the multiplier directly. Negative
+   *   values rebound: `-0.75` reverses the motion with three quarters of
+   *   its speed, at every return. Values between 0 and 1 pass through
+   *   slowed.
+   *
+   * Crossings are solved from the motion's closed form, never sampled
+   * frame by frame, so a `'stop'` lands the value exactly on the target
+   * whatever the frame timing. See
+   * https://github.com/tkofh/coily/blob/main/PRECISION.md.
+   *
+   * @default 'passthrough'
+   */
+  readonly arrival?: 'passthrough' | 'stop' | number | undefined;
+}
+interface WithMass {
+  /**
+   * Mass of the moving value. Heavier springs accelerate more slowly and
+   * carry more momentum through the target. Must be greater than 0.
+   * @default 1
+   */
+  readonly mass?: number | undefined;
+}
+interface WithoutMass {
+  /**
+   * Mass is derived from the other parameters in this input shape
+   * and cannot be provided.
+   */
+  readonly mass?: undefined;
+}
+interface WithTension {
+  /**
+   * Spring stiffness. Higher tension pulls toward the target harder,
+   * making the whole motion faster. Must be greater than 0.
+   */
+  readonly tension: number;
+}
+interface WithDamping {
+  /**
+   * Friction strength. Higher damping bleeds off velocity faster and
+   * reduces bounce; at 0 the spring oscillates forever. Must be greater
+   * than or equal to 0.
+   */
+  readonly damping: number;
+}
+interface WithDampingRatio {
+  /**
+   * Damping as a fraction of critical damping — the character of the
+   * motion, independent of its speed. Below 1 the spring overshoots and
+   * bounces. At 1 it settles as fast as possible without overshooting.
+   * Above 1 it settles slower, still without overshooting. At 0 it never
+   * settles. Must be greater than or equal to 0.
+   */
+  readonly dampingRatio: number;
+}
+interface WithBounce {
+  /**
+   * Bounciness, converted to a damping ratio as `1 - bounce`. 0 settles
+   * as fast as possible without overshooting. Positive values overshoot
+   * and bounce; 1, maximum bounce, is clamped just short of undamped so
+   * the spring still settles. Negative values settle without bounce, more
+   * slowly. Must be between -1 and 1.
+   */
+  readonly bounce: number;
+}
+interface WithDuration {
+  /**
+   * Settle time in milliseconds. The spring is tuned so it rests at this
+   * time, assuming it starts `displacement` away from the target: rest
+   * lands within a frame of the requested duration, and a bouncy config
+   * can rest up to one oscillation earlier. Must be greater than 0.
+   */
+  readonly duration: number;
+}
+interface WithDisplacement {
+  /**
+   * The initial displacement the duration tuning assumes. Set it to your
+   * animation's range — 300 when animating 0 to 300 — so the settle
+   * timing holds; timing skews as the real displacement diverges from
+   * this value. Must not be 0.
+   * @default 1
+   */
+  readonly displacement?: number | undefined;
+}
+interface DirectOptions extends BaseOptions, WithMass, WithTension, WithDamping {}
+interface TensionRatioOptions extends BaseOptions, WithMass, WithTension, WithDampingRatio {}
+interface TensionBounceOptions extends BaseOptions, WithMass, WithTension, WithBounce {}
+interface DampingRatioOptions extends BaseOptions, WithMass, WithDamping, WithDampingRatio {}
+interface DampingBounceOptions extends BaseOptions, WithMass, WithDamping, WithBounce {}
+interface TensionDampingRatioOptions extends BaseOptions, WithoutMass, WithTension, WithDamping, WithDampingRatio {}
+interface TensionDampingBounceOptions extends BaseOptions, WithoutMass, WithTension, WithDamping, WithBounce {}
+interface DurationOptions extends BaseOptions, WithMass, WithDampingRatio, WithDuration, WithDisplacement {}
+interface BounceDurationOptions extends BaseOptions, WithMass, WithBounce, WithDuration, WithDisplacement {}
+interface TensionDurationOptions extends BaseOptions, WithoutMass, WithTension, WithDampingRatio, WithDuration, WithDisplacement {}
+interface TensionBounceDurationOptions extends BaseOptions, WithoutMass, WithTension, WithBounce, WithDuration, WithDisplacement {}
+interface DampingDurationOptions extends BaseOptions, WithoutMass, WithDamping, WithDampingRatio, WithDuration, WithDisplacement {}
+interface DampingBounceDurationOptions extends BaseOptions, WithoutMass, WithDamping, WithBounce, WithDuration, WithDisplacement {}
+/** Every option key accepted by at least one `defineSpring` input shape. */
+type SpringOptionKeys = 'mass' | 'tension' | 'damping' | 'dampingRatio' | 'bounce' | 'duration' | 'displacement' | 'precision' | 'arrival';
+/**
+ * Marks every option key foreign to `T` as "absent or undefined", so mixing
+ * properties from different input shapes fails to type-check instead of
+ * silently resolving to an unintended shape at runtime.
+ */
+type Exact<T> = T & { [K in Exclude<SpringOptionKeys, keyof T>]?: undefined; };
+/**
+ * Every input `defineSpring` accepts: one of the documented parameter
+ * combinations, exactly as written — keys from different combinations
+ * don't mix.
+ */
+type SpringDefinitionOptions = Exact<DirectOptions> | Exact<TensionRatioOptions> | Exact<TensionBounceOptions> | Exact<DampingRatioOptions> | Exact<DampingBounceOptions> | Exact<TensionDampingRatioOptions> | Exact<TensionDampingBounceOptions> | Exact<DurationOptions> | Exact<BounceDurationOptions> | Exact<TensionDurationOptions> | Exact<TensionBounceDurationOptions> | Exact<DampingDurationOptions> | Exact<DampingBounceDurationOptions>;
+/**
+ * Immutable, resolved spring parameters. Whatever `defineSpring` input
+ * shape produced it, a config carries concrete `mass`, `tension`,
+ * `damping`, and `precision`, plus the quantities derived from them.
+ * Instances are frozen and safe to share between springs; to change a
+ * spring's behavior, assign a new config via `spring.config`.
+ */
+declare class SpringDefinition {
+  /** The config for springs created without one: critically damped, settling in about 500ms. */
+  static readonly default: SpringDefinition;
+  /** Mass of the moving value, as provided or derived. */
+  readonly mass: number;
+  /** Spring stiffness, as provided or derived. */
+  readonly tension: number;
+  /** Friction strength, as provided or derived. */
+  readonly damping: number;
+  /** Decimal places of the resting threshold — see `restingMagnitude`. */
+  readonly precision: number;
+  /**
+   * Velocity multiplier applied when the value crosses the target, as
+   * provided or resolved from its named form. 1 (`'passthrough'`) leaves
+   * the motion untouched, 0 (`'stop'`) ends it at the target, negative
+   * values rebound.
+   */
+  readonly arrival: number;
+  /** Oscillation rate with no damping: `sqrt(tension / mass)`, in radians per second. */
+  readonly naturalFrequency: number;
+  /** The damping at which bounce disappears: `2 * mass * naturalFrequency`. */
+  readonly criticalDamping: number;
+  /**
+   * `damping / criticalDamping`. Below 1 the spring overshoots and
+   * bounces, at 1 it settles fastest without overshooting, above 1 it
+   * settles slower.
+   */
+  readonly dampingRatio: number;
+  /** Resting threshold in value units: half a unit in the last `precision` place. */
+  readonly restingMagnitude: number;
+  constructor(input: SpringDefinitionOptions);
+  /**
+   * Computes when a spring with this config comes to rest from `state`,
+   * in ms.
+   *
+   * The time is solved from the motion's decay bound rather than
+   * estimated: the spring is resting at the first tick at or after it.
+   * An underdamped spring can also rest earlier — its rest amplitude
+   * pulses, and a frame that samples a dip inside the resting threshold
+   * rests there — so read the value as "no later than", tight in
+   * practice. See
+   * https://github.com/tkofh/coily/blob/main/PRECISION.md.
+   *
+   * Returns 0 when `state` is already inside the resting threshold.
+   * Returns Infinity when the motion never settles: a `dampingRatio` of
+   * 0 whose `arrival` neither stops nor slows it. When `arrival` is 0
+   * the result is capped at the first target crossing, where such a
+   * spring rests exactly; other multipliers fold their per-crossing
+   * velocity loss into the time.
+   */
+  computeTimeRemaining(state: SpringState): number;
+}
+/**
+ * Creates a config from direct physical parameters: you set stiffness
+ * and friction exactly.
+ */
+declare function defineSpring(input: Exact<DirectOptions>): SpringDefinition;
+/**
+ * Creates a config from stiffness and motion character. Damping is
+ * derived as `2 * dampingRatio * sqrt(mass * tension)`.
+ */
+declare function defineSpring(input: Exact<TensionRatioOptions>): SpringDefinition;
+/**
+ * Creates a config from stiffness and bounciness. Damping is derived to
+ * match the requested bounce, from -1 (no bounce, slow settle) to 1
+ * (maximum bounce).
+ */
+declare function defineSpring(input: Exact<TensionBounceOptions>): SpringDefinition;
+/**
+ * Creates a config from friction and motion character. Tension is
+ * derived as `damping^2 / (4 * dampingRatio^2 * mass)`; `dampingRatio`
+ * must be greater than 0.
+ */
+declare function defineSpring(input: Exact<DampingRatioOptions>): SpringDefinition;
+/**
+ * Creates a config from friction and bounciness. Tension is derived to
+ * match the requested bounce; `bounce` must be less than 1.
+ */
+declare function defineSpring(input: Exact<DampingBounceOptions>): SpringDefinition;
+/**
+ * Creates a config from all three physical knobs. Mass is derived as
+ * `damping^2 / (4 * dampingRatio^2 * tension)` and cannot be provided;
+ * `dampingRatio` must be greater than 0.
+ */
+declare function defineSpring(input: Exact<TensionDampingRatioOptions>): SpringDefinition;
+/**
+ * Creates a config from all three physical knobs. Mass is derived from
+ * tension, damping, and the requested bounce, and cannot be provided;
+ * `bounce` must be less than 1.
+ */
+declare function defineSpring(input: Exact<TensionDampingBounceOptions>): SpringDefinition;
+/**
+ * Tunes the spring to rest at `duration` milliseconds, with
+ * `dampingRatio` setting the motion's character. Tension and damping are
+ * both derived.
+ *
+ * The timing assumes the motion starts `displacement` (default 1) away
+ * from the target — pass a `displacement` matching your animation range
+ * for accurate timing.
+ *
+ * @example
+ * ```ts
+ * // Tuned for a 300px move; rests within 750ms
+ * defineSpring({ duration: 750, dampingRatio: 1, displacement: 300 })
+ * ```
+ */
+declare function defineSpring(input: Exact<DurationOptions>): SpringDefinition;
+/**
+ * Tunes the spring to rest at `duration` milliseconds, with
+ * `bounce` setting how oscillatory the settling motion is. Tension and
+ * damping are both derived.
+ *
+ * The timing assumes the motion starts `displacement` (default 1) away
+ * from the target — pass a `displacement` matching your animation range
+ * for accurate timing.
+ */
+declare function defineSpring(input: Exact<BounceDurationOptions>): SpringDefinition;
+/**
+ * Tunes a spring of the given stiffness to rest at `duration`
+ * milliseconds. Mass is derived from tension and the computed natural
+ * frequency, then damping from mass and `dampingRatio`; mass cannot be
+ * provided.
+ *
+ * The timing assumes the motion starts `displacement` (default 1) away
+ * from the target — pass a `displacement` matching your animation range
+ * for accurate timing.
+ */
+declare function defineSpring(input: Exact<TensionDurationOptions>): SpringDefinition;
+/**
+ * Tunes a spring of the given stiffness to rest at `duration`
+ * milliseconds, with `bounce` setting how oscillatory the settling motion
+ * is. Mass is derived from tension and the computed natural frequency,
+ * and cannot be provided.
+ *
+ * The timing assumes the motion starts `displacement` (default 1) away
+ * from the target — pass a `displacement` matching your animation range
+ * for accurate timing.
+ */
+declare function defineSpring(input: Exact<TensionBounceDurationOptions>): SpringDefinition;
+/**
+ * Tunes a spring of the given friction to rest at `duration`
+ * milliseconds. Mass is derived from damping, `dampingRatio`, and the
+ * computed natural frequency, then tension from mass; mass cannot be
+ * provided.
+ *
+ * The timing assumes the motion starts `displacement` (default 1) away
+ * from the target — pass a `displacement` matching your animation range
+ * for accurate timing.
+ */
+declare function defineSpring(input: Exact<DampingDurationOptions>): SpringDefinition;
+/**
+ * Tunes a spring of the given friction to rest at `duration`
+ * milliseconds, with `bounce` setting how oscillatory the settling motion
+ * is. Mass is derived from damping and the computed natural frequency,
+ * and cannot be provided.
+ *
+ * The timing assumes the motion starts `displacement` (default 1) away
+ * from the target — pass a `displacement` matching your animation range
+ * for accurate timing.
+ */
+declare function defineSpring(input: Exact<DampingBounceDurationOptions>): SpringDefinition;
+//#endregion
+export { defineSpring as i, SpringDefinitionOptions as n, SpringState as r, SpringDefinition as t };

package/dist/css.d.ts

@@ -0,0 +1,175 @@
+import { r as SpringState, t as SpringDefinition } from "./config-OOMMRdK8.js";
+//#region src/css.d.ts
+interface LinearEasingOptions {
+  /**
+   * Animation range the duration is tuned for, in value units. The easing
+   * shape is identical regardless; only the settle time scales with it.
+   * The keyframe helpers (`springToWaapi`, `springToCss`,
+   * `springToTransition`) default it to the largest move among their
+   * specs instead.
+   * @default 1
+   */
+  readonly displacement?: number;
+  /**
+   * Max output error of the piecewise-linear approximation, in progress
+   * units (0..1). Smaller keeps more stops.
+   * @default 0.0025
+   */
+  readonly maxError?: number;
+  /**
+   * Hard cap on generated duration, in ms, for near-undamped configs.
+   * @default 10000
+   */
+  readonly maxDuration?: number;
+}
+interface EasingBase {
+  /** A CSS `linear()` easing string. */
+  readonly easing: string;
+  /** Duration to pair the easing with, in ms. */
+  readonly duration: number;
+  /** Number of stops in the easing (diagnostic). */
+  readonly stops: number;
+  /** Worst reconstruction error vs the dense trajectory (diagnostic). */
+  readonly maxError: number;
+}
+/** The easing of a spring that comes to rest: play it once over `duration`. */
+interface SettlingEasing extends EasingBase {
+  readonly mode: 'settle';
+}
+/**
+ * The easing of a spring that never rests — an undamped oscillation,
+ * expressed as a seamless loop. Animate the property between its two
+ * swing extremes (`from` and `2 * target - from`, target at the 50%
+ * midpoint) with `animation-iteration-count: infinite` and
+ * `animation-direction: alternate`. `duration` is one half period.
+ */
+interface LoopingEasing extends EasingBase {
+  readonly mode: 'loop';
+  readonly direction: 'alternate';
+  readonly iterations: 'infinite';
+}
+type LinearEasing = SettlingEasing | LoopingEasing;
+/**
+ * Turns a resolved spring config into a CSS `linear()` easing and the
+ * duration in ms to pair it with. A spring that settles returns a
+ * `'settle'` easing. A pure undamped config (`dampingRatio: 0` with
+ * passthrough `arrival`) has no friction and never settles, so it
+ * returns a `'loop'` easing for an infinite alternating animation.
+ */
+declare function springToLinear(config: SpringDefinition, options?: LinearEasingOptions): LinearEasing;
+/**
+ * Like `springToLinear`, but from a spring caught mid-flight rather than at
+ * rest: `state` carries both the displacement from the target (`position`)
+ * and the current `velocity`, so the easing continues the motion smoothly
+ * instead of restarting. Use it to regenerate an animation when its target
+ * changes — the interruption carries momentum instead of stalling. The
+ * from-rest shape trick doesn't apply here (the curve now depends on the
+ * velocity), so this is computed per interruption, not cached per config.
+ *
+ * Always a settling easing; `position` must be nonzero.
+ */
+declare function springFromState(config: SpringDefinition, state: SpringState, options?: LinearEasingOptions): LinearEasing;
+/**
+ * Evolves a spring `state` forward by `elapsedMs`, returning the new
+ * displacement and velocity. Pair it with a running `element.animate` — read
+ * the animation's `currentTime`, evolve the state it started from, and you
+ * have the exact live velocity the Web Animations API never exposes, ready
+ * to hand to `springFromState` on interruption.
+ */
+declare function springStateAt(config: SpringDefinition, state: SpringState, elapsedMs: number): SpringState;
+/** What to animate: a CSS property from one numeric value to another. */
+interface PropertySpec {
+  /** The CSS property, e.g. `'opacity'`, `'transform'`, `'translate'`. */
+  readonly property: string;
+  /** Start value. */
+  readonly from: number;
+  /** Target value the spring is tuned toward. */
+  readonly to: number;
+  /**
+   * Unit appended to numbers, e.g. `'px'`, `'%'`, `'deg'`.
+   * @default ''
+   */
+  readonly unit?: string;
+  /**
+   * Formats an interpolated number into a property value, overriding
+   * `unit` — needed for wrapped values like `(v) => `translateX(${v}px)``.
+   */
+  readonly format?: (value: number) => string;
+  /**
+   * The property's current velocity, in its units per second. Set it to
+   * regenerate an interrupted animation from its live motion so it carries
+   * momentum instead of restarting from rest. Single-property only — a
+   * from-state easing depends on that property's velocity and can't be
+   * shared across properties.
+   */
+  readonly velocity?: number;
+}
+interface CssOptions extends LinearEasingOptions {
+  /**
+   * Name for the generated `@keyframes` rule.
+   * @default 'coily'
+   */
+  readonly name?: string;
+}
+/**
+ * Builds arguments for `element.animate(keyframes, options)`: two keyframes
+ * carrying the endpoint values, and options carrying the spring's `linear()`
+ * easing and duration. Pass an array of specs to drive several properties
+ * from one spring. A settling spring fills forwards; an undamped one repeats
+ * infinitely in alternating directions.
+ *
+ * @example
+ * ```ts
+ * const { keyframes, options } = springToWaapi(config, {
+ *   property: 'translate',
+ *   from: 0,
+ *   to: 300,
+ *   unit: 'px',
+ * })
+ * element.animate(keyframes, options)
+ * ```
+ */
+declare function springToWaapi(config: SpringDefinition, spec: PropertySpec | PropertySpec[], options?: LinearEasingOptions): {
+  keyframes: Keyframe[];
+  options: KeyframeAnimationOptions;
+};
+/**
+ * Builds CSS text for the animation: a `@keyframes` rule and an `animation`
+ * shorthand value, driving one property or several from one spring. The
+ * `name` option (default `'coily'`) names the `@keyframes` rule and is
+ * referenced by the `animation` value.
+ *
+ * @example
+ * ```ts
+ * const { keyframes, animation } = springToCss(config, {
+ *   property: 'translate',
+ *   from: 0,
+ *   to: 300,
+ *   unit: 'px',
+ * })
+ * const style = document.createElement('style')
+ * style.textContent = keyframes
+ * document.head.append(style)
+ * element.style.animation = animation
+ * ```
+ */
+declare function springToCss(config: SpringDefinition, spec: PropertySpec | PropertySpec[], options?: CssOptions): {
+  keyframes: string;
+  animation: string;
+};
+/**
+ * Builds a CSS `transition` value that springs a property change: set it on
+ * the element, then change the property (on `:hover`, a toggled class, a
+ * state attribute) to animate. Pass several specs for one `transition`
+ * across properties.
+ *
+ * Only settling springs — a transition can't loop. It also can't carry
+ * momentum: a change interrupted mid-flight restarts the spring from rest
+ * instead of reversing through its current velocity, so it stalls at the
+ * turn. For motion that's reversed often, drive a live `Spring` instead. The
+ * specs' `from`/`to` only tune the duration; the actual values live in your
+ * CSS rules.
+ */
+declare function springToTransition(config: SpringDefinition, spec: PropertySpec | PropertySpec[], options?: LinearEasingOptions): string;
+//#endregion
+export { CssOptions, LinearEasing, LinearEasingOptions, LoopingEasing, PropertySpec, SettlingEasing, springFromState, springStateAt, springToCss, springToLinear, springToTransition, springToWaapi };