coily 0.15.0 → 0.16.0

package/dist/css.js

@@ -1,4 +1,4 @@
-import { i as State, n as OverdampedSolver, o as invariant, r as UnderdampedSolver, t as CriticallyDampedSolver } from "./solver-CVXOTDkZ.js";
+import { i as State, n as OverdampedSolver, o as invariant, r as UnderdampedSolver, t as CriticallyDampedSolver } from "./solver-CAXuxdKj.js";
 //#region src/css.ts
 function pickSolver(config, state) {
 	const solver = config.dampingRatio < 1 ? new UnderdampedSolver(state) : config.dampingRatio === 1 ? new CriticallyDampedSolver(state) : new OverdampedSolver(state);
@@ -119,11 +119,13 @@ function reconstructionError(dense, simplified) {
 	return worst;
 }
 /**
-* 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.
+* Turns a spring config into a CSS `linear()` easing and the duration in
+* ms to pair it with. A settling config returns a `'settle'` easing. A
+* pure undamped config (`dampingRatio: 0` with passthrough `arrival`)
+* never settles and returns a `'loop'` easing for an infinite alternating
+* animation. Any other config that never settles, such as
+* `dampingRatio: 0` with `arrival: -1`, returns a `'settle'` easing cut
+* off at `maxDuration`.
 */
 function springToLinear(config, options = {}) {
 	const displacement = options.displacement ?? 1;
@@ -137,15 +139,17 @@ function springToLinear(config, options = {}) {
 	return buildSettle(config, displacement, Math.min(settleTime, maxDuration), maxError);
 }
 /**
-* 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.
+* Like `springToLinear`, but for a spring caught mid-flight. `state`
+* carries the displacement from the target (`position`) and the current
+* `velocity`, so the easing continues the motion instead of restarting it.
+* Use it to regenerate an animation when its target changes. The curve
+* depends on the velocity, so compute it per interruption instead of
+* caching it per config.
 *
-* Always a settling easing; `position` must be nonzero.
+* The result is always a `'settle'` easing, timed from `position`, so
+* `options.displacement` is ignored. A config that never settles is cut
+* off at `maxDuration`. Throws when `position` is 0 (within 1e-9), even if
+* `velocity` is not.
 */
 function springFromState(config, state, options = {}) {
 	const maxError = options.maxError ?? .0025;
@@ -155,11 +159,12 @@ function springFromState(config, state, options = {}) {
 	return buildSettle(config, state.position, Math.min(settleTime, maxDuration), maxError, state.velocity);
 }
 /**
-* 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.
+* Advances a spring `state` by `elapsedMs` ms and returns the new
+* displacement and velocity. `elapsedMs <= 0` returns a copy of `state`.
+*
+* The Web Animations API doesn't expose velocity, so to interrupt a running
+* `element.animate`, advance the state it started from by its `currentTime`
+* and hand the result to `springFromState`.
 */
 function springStateAt(config, state, elapsedMs) {
 	if (elapsedMs <= 0) return {
@@ -207,7 +212,7 @@ function asArray(spec) {
 * 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
+* from one spring. A settling spring fills forwards. An undamped one repeats
 * infinitely in alternating directions.
 *
 * @example
@@ -241,10 +246,11 @@ function springToWaapi(config, spec, options = {}) {
 	};
 }
 /**
-* 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.
+* Builds CSS text for the animation: a `@keyframes` rule named by `name`
+* (default `'coily'`) and an `animation` shorthand value that references
+* it, driving one property or several from one spring. A settling spring
+* fills forwards. An undamped one repeats infinitely in alternating
+* directions.
 *
 * @example
 * ```ts
@@ -271,17 +277,35 @@ function springToCss(config, spec, options = {}) {
 	};
 }
 /**
-* 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.
+* Builds a CSS `transition` value that animates a property change with the
+* spring. Set it on the element, then change the property, for example on
+* `:hover`, with a toggled class, or with a state attribute. Pass several
+* specs to build one `transition` for several properties.
+*
+* The values come from your CSS rules. Each spec's `from` and `to` only
+* size the move, which tunes the duration. An undamped (looping) config
+* throws, because a transition cannot loop.
+*
+* A transition starts from rest unless its spec carries a `velocity`, in
+* the property's units per second, such as a drag's speed at release. The
+* velocity reshapes the curve and the duration, so build the transition at
+* the handoff. A spec with a velocity must be the only spec in the call.
+*
+* ```ts
+* // Release a dragged card back to 0 at the drag's speed.
+* card.style.transition = springToTransition(config, {
+*   property: 'translate',
+*   from: dragX,
+*   to: 0,
+*   velocity: releaseVelocity,
+* })
+* card.style.translate = '0px'
+* ```
 *
-* 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.
+* The browser carries no momentum between transitions, so a change that
+* interrupts one mid-flight stalls at the turn. To keep the momentum, read
+* the velocity with `springStateAt` and rebuild the transition with it.
+* For motion that reverses often, drive a live `Spring` instead.
 */
 function springToTransition(config, spec, options = {}) {
 	const specs = asArray(spec);

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { i as defineSpring, n as SpringDefinitionOptions, r as SpringState, t as SpringDefinition } from "./config-OOMMRdK8.js";
-import { _ as accelerationOf, a as createSpringSystem, b as SpringSourceSymbol, c as ConfigShape, g as KinematicSource, h as SpringTarget, i as SpringSystemOptions, m as Spring, n as SpringOptions, o as CompositeSpring, p as Purpose, r as SpringSystem, s as CompositeSpringTarget, t as CompositeSpringOptions, u as PurposeShape, v as velocityOf, x as mapSpring, y as SpringSource } from "./system-Du_fXXmO.js";
-export { type CompositeSpring, type CompositeSpringOptions, type CompositeSpringTarget, type ConfigShape, type KinematicSource, type Purpose, type PurposeShape, type Spring, type SpringDefinition, type SpringDefinitionOptions, type SpringOptions, type SpringSource, SpringSourceSymbol, type SpringState, type SpringSystem, type SpringSystemOptions, type SpringTarget, accelerationOf, createSpringSystem, defineSpring, mapSpring, velocityOf };
+import { i as defineSpring, n as SpringDefinitionOptions, r as SpringState, t as SpringDefinition } from "./config-B8M2xp26.js";
+import { A as SpringSourceSymbol, C as accelerationOf, D as SourceValues, E as SourceShape, O as SpringSource, S as TargetedSourceApi, T as velocityOf, _ as Spring, a as createSpringSystem, b as KinematicSourceApi, c as CompositeSpring, d as PartialShape, f as PurposeShape, g as Purpose, h as TargetShape, i as SpringSystemOptions, j as mapSpring, k as SpringSourceApi, l as CompositeSpringTarget, m as Shape, n as SpringOptions, o as Ramp, p as ReadonlyShape, r as SpringSystem, s as RampOptions, t as CompositeSpringOptions, u as ConfigShape, v as SpringTarget, w as targetOf, x as TargetedSource, y as KinematicSource } from "./system-C7PbI4L0.js";
+export { type CompositeSpring, type CompositeSpringOptions, type CompositeSpringTarget, type ConfigShape, type KinematicSource, type KinematicSourceApi, type PartialShape, type Purpose, type PurposeShape, type Ramp, type RampOptions, type ReadonlyShape, type Shape, type SourceShape, type SourceValues, type Spring, SpringDefinition, type SpringDefinitionOptions, type SpringOptions, type SpringSource, type SpringSourceApi, SpringSourceSymbol, type SpringState, type SpringSystem, type SpringSystemOptions, type SpringTarget, type TargetShape, type TargetedSource, type TargetedSourceApi, accelerationOf, createSpringSystem, defineSpring, mapSpring, targetOf, velocityOf };

package/dist/index.js

@@ -1,91 +1,124 @@
-import { a as registerRecipe, i as mapSpring, n as SpringSourceSymbol, r as isSpringSource, s as defineSpring, t as createSpringSystem } from "./system-Br_cPnaN.js";
-import { o as invariant } from "./solver-CVXOTDkZ.js";
+import { a as SpringSourceSymbol, c as registerRecipe, i as defineSpring, o as isSpringSource, r as SpringDefinition, s as mapSpring, t as createSpringSystem } from "./system-WejqGkfv.js";
+import { o as invariant } from "./solver-CAXuxdKj.js";
 //#region src/kinematic-source.ts
 function isKinematicSource(value) {
 	if (!isSpringSource(value)) return false;
 	const api = value[SpringSourceSymbol];
 	return "velocity" in api && "acceleration" in api;
 }
-const NOT_KINEMATIC = "expected a source in motion (a Spring or CompositeSpring); a value derived with mapSpring has neither velocity nor acceleration";
-/**
-* Derives a source from another's velocity — the rate its value changes,
-* in value units per second. `velocityOf(motion)` is a source that reads
-* `motion`'s current velocity, so speed-driven effects fall out of the
-* same follow and `mapSpring` machinery as everything else: a spring can
-* follow it (`blur.target = velocityOf(motion)`) and a map can shape it
-* (`mapSpring(velocityOf(motion), (v) => 1 + Math.abs(v) * 0.001)` for
-* squash and stretch). A scalar source yields a scalar velocity a spring
-* can follow; a `CompositeSpring` or shape yields a velocity of the same
-* shape, mapped to a scalar the way the composite itself is.
-*
-* The result is a stateless view, not a spring: it holds no
-* subscriptions and needs no disposal, and reads report the source's
-* current velocity on the fly. It updates when the source does and is
-* released with it — followers detach then, keeping their current
-* target, as they would from a disposed spring.
-*
-* Only a source in motion qualifies — a `Spring` or a `CompositeSpring`.
-* A value derived with `mapSpring` has no velocity (its rate of change
-* would need the derivative of the map), so it is rejected at the type
-* level and at runtime; take `velocityOf` of the spring the map reads
-* instead.
-*/
-function velocityOf(source) {
-	invariant(isKinematicSource(source), NOT_KINEMATIC);
+function deriveView(source, read) {
 	const api = source[SpringSourceSymbol];
-	const velocity = Object.freeze({ [SpringSourceSymbol]: Object.freeze({
+	const view = Object.freeze({ [SpringSourceSymbol]: Object.freeze({
 		get value() {
-			return api.velocity;
+			return read();
 		},
 		onUpdate: (callback) => api.onUpdate(callback),
 		onDispose: (callback) => api.onDispose(callback)
 	}) });
-	registerRecipe(velocity, {
+	registerRecipe(view, {
 		sources: [source],
-		read: () => api.velocity,
+		read,
 		fns: []
 	});
-	return velocity;
+	return view;
+}
+const NOT_KINEMATIC = "expected a source in motion (a Spring, CompositeSpring, or Ramp); a derived source, such as a mapSpring result, has neither velocity nor acceleration";
+/**
+* Derives a source that reads another source's velocity: the rate its
+* value changes, in value units per second. Speed-driven effects then
+* use the same tools as everything else. A spring can follow it
+* (`blur.target = velocityOf(motion)`), and a map can shape it
+* (`mapSpring(velocityOf(motion), (v) => 1 + Math.abs(v) * 0.001)` for
+* squash and stretch). A scalar source yields a scalar velocity. A
+* `CompositeSpring` yields a velocity of its own shape, which you map to
+* a scalar as you would its value.
+*
+* The result is a stateless view that holds no subscriptions and needs
+* no disposal. Each read reports the source's current velocity. It
+* updates when the source does and is released with it, and followers
+* then detach and keep their current target.
+*
+* Only a `Spring`, a `CompositeSpring`, a `Ramp`, or a Vue ref that wraps
+* one qualifies. A `mapSpring` result has no velocity, and `velocityOf`
+* rejects it at the type level and at runtime. Take `velocityOf` of the
+* spring the map reads instead.
+*/
+function velocityOf(source) {
+	invariant(isKinematicSource(source), NOT_KINEMATIC);
+	const api = source[SpringSourceSymbol];
+	return deriveView(source, () => api.velocity);
 }
 /**
-* Derives a source from another's acceleration — the rate its velocity
-* changes, in value units per second squared. `accelerationOf(motion)`
-* spikes when `motion` is pushed hardest and passes through zero at the
-* peak of a swing, so force-driven effects fall out of the same follow
-* and `mapSpring` machinery: a spring can follow it, and a map can turn
-* it into an impact flash or a jelly wobble
+* Derives a source that reads another source's acceleration: the rate
+* its velocity changes, in value units per second squared. On a spring it
+* is largest just after a retarget and near the far end of each swing,
+* and passes through zero where a swing moves fastest. A spring can
+* follow it, and a map can turn it into an impact flash or a jelly wobble
 * (`mapSpring(accelerationOf(motion), (a) => Math.min(1, Math.abs(a) * 1e-4))`).
-* A scalar source yields a scalar acceleration; a `CompositeSpring` or
-* shape yields an acceleration of the same shape, mapped to a scalar the
-* way the composite itself is.
+* A scalar source yields a scalar acceleration. A `CompositeSpring`
+* yields an acceleration of its own shape, which you map to a scalar as
+* you would its value. A `Ramp`'s acceleration is always 0.
 *
-* The result is a stateless view, not a spring: it holds no
-* subscriptions and needs no disposal, and reads report the source's
-* current acceleration on the fly. It updates when the source does and
-* is released with it, followers detaching then as from a disposed
-* spring.
+* The result is a stateless view that holds no subscriptions and needs
+* no disposal. Each read reports the source's current acceleration. It
+* updates when the source does and is released with it, and followers
+* then detach and keep their current target.
 *
-* Only a source in motion qualifies — a `Spring` or a `CompositeSpring`.
-* A value derived with `mapSpring` has no acceleration, so it is rejected
-* at the type level and at runtime; take `accelerationOf` of the spring
-* the map reads instead.
+* Only a `Spring`, a `CompositeSpring`, a `Ramp`, or a Vue ref that wraps
+* one qualifies. A `mapSpring` result has no acceleration, and
+* `accelerationOf` rejects it at the type level and at runtime. Take
+* `accelerationOf` of the spring the map reads instead.
 */
 function accelerationOf(source) {
 	invariant(isKinematicSource(source), NOT_KINEMATIC);
 	const api = source[SpringSourceSymbol];
-	const acceleration = Object.freeze({ [SpringSourceSymbol]: Object.freeze({
-		get value() {
-			return api.acceleration;
-		},
-		onUpdate: (callback) => api.onUpdate(callback),
-		onDispose: (callback) => api.onDispose(callback)
-	}) });
-	registerRecipe(acceleration, {
-		sources: [source],
-		read: () => api.acceleration,
-		fns: []
-	});
-	return acceleration;
+	return deriveView(source, () => api.acceleration);
+}
+function isTargetedSource(value) {
+	return isKinematicSource(value) && "target" in value[SpringSourceSymbol];
+}
+const NO_TARGET = "expected a source with a target (a Spring, CompositeSpring, or Ramp); a derived source, such as a mapSpring result, has no target";
+/**
+* Derives a source that reads a spring's or ramp's target: where it is
+* heading, not where it is. Pair it with the source in a `mapSpring`
+* shape to measure against the destination, such as remaining travel,
+* progress, or a lead that anticipates the move. A `Spring` or a bounded
+* `Ramp` yields a scalar target that a spring can follow. An endless
+* `Ramp` yields `Infinity` or `-Infinity`, and a spring that follows it
+* throws. A `CompositeSpring` yields a target of its own shape, which you
+* map to a scalar as you would its value.
+*
+* ```ts
+* const system = createSpringSystem()
+* const body = system.createSpring(0)
+* // The eyes look ahead by the body's remaining travel, capped at 20.
+* const lead = mapSpring({ value: body, target: targetOf(body) }, ({ value, target }) =>
+*   Math.max(-20, Math.min(20, target - value)),
+* )
+* const eyes = system.createSpring(lead)
+*
+* body.target = 100
+* system.advance(100)
+* eyes.target // 20: the body still has more than 20 to go
+* ```
+*
+* The result is a stateless view that holds no subscriptions and needs
+* no disposal. Each read reports the spring's current target. It updates
+* when the spring does, but assigning `target` emits nothing by itself,
+* so followers pick up a new target on the next frame, when the spring
+* starts toward it. Under reduced motion, a `'motion'` spring jumps to
+* its new target and notifies followers at once. The view is released
+* with the spring, and followers then detach and keep their current
+* target.
+*
+* Only a `Spring`, a `CompositeSpring`, a `Ramp`, or a Vue ref that wraps
+* one has a target. `targetOf` rejects a `mapSpring` result at the type
+* level and at runtime.
+*/
+function targetOf(spring) {
+	invariant(isTargetedSource(spring), NO_TARGET);
+	const api = spring[SpringSourceSymbol];
+	return deriveView(spring, () => api.target);
 }
 //#endregion
-export { SpringSourceSymbol, accelerationOf, createSpringSystem, defineSpring, mapSpring, velocityOf };
+export { SpringDefinition, SpringSourceSymbol, accelerationOf, createSpringSystem, defineSpring, mapSpring, targetOf, velocityOf };

package/dist/nuxt.d.ts

@@ -11,47 +11,48 @@ interface CoilyModuleOptions {
    */
   debug?: boolean;
   /**
-   * Frame-rate cap. 0 means uncapped: one tick per displayed frame.
-   * Capped ticks land on whole display frames and receive the true
-   * elapsed time.
+   * Frame-rate cap. 0 means uncapped: one tick per displayed frame. A
+   * capped tick lands on a whole display frame and receives the true
+   * elapsed time in ms.
    * @default 0
    */
   fps?: number;
   /**
-   * Frame gap in milliseconds above which the gap is treated as lag and
-   * replaced with `adjustedLag`, so springs don't teleport when frames
-   * resume. 0 disables lag clamping.
+   * The frame gap in ms above which the system treats the gap as lag and
+   * replaces it with `adjustedLag`, so springs do not jump when frames
+   * resume. 0 turns off lag clamping.
    * @default 500
    */
   lagThreshold?: number;
   /**
-   * The elapsed milliseconds a lagging frame is replaced with. Clamped
-   * to at most `lagThreshold`.
+   * The elapsed time in ms that replaces a lagging frame. A frame uses
+   * at most `lagThreshold` ms of it.
    * @default 33
    */
   adjustedLag?: number;
   /**
-   * How far a spring may trail a source it follows within one frame, in
-   * the value's own units. Frames whose motion would exceed it split
-   * into internal sub-steps; smaller is tighter and costs more solver
-   * work.
+   * How far a spring can trail a source it follows within one frame, in
+   * the value's own units. Frames whose motion would exceed it run as
+   * sub-steps, so a smaller value follows more closely at more cost.
    * @default 0.1
    */
   couplingTolerance?: number;
   /**
-   * When springs snap to their targets instead of animating: `'user'`
+   * When springs snap to their targets instead of animating. `'user'`
    * follows the OS prefers-reduced-motion setting, including live
-   * changes; `'always'` and `'never'` force one behavior.
+   * changes. `'always'` and `'never'` force one behavior.
    * @default 'user'
    */
   reducedMotion?: 'user' | 'always' | 'never';
 }
 /**
- * The Nuxt module: creates an app-wide spring system (started on the
- * client), auto-imports the composables and helpers `useSpring`,
- * `useSpringSystem`, `useSpringPool`, `defineSpring`, `mapSpring`,
- * `velocityOf`, and `accelerationOf`, and registers the `SpringValue`
- * component. Types are left out — they would be noise in most apps.
+ * The Nuxt module. It creates one spring system for the app and starts
+ * it on the client only, so server rendering shows springs at their
+ * initial values. The module auto-imports
+ * `useSpring`, `useRamp`, `useSpringSystem`, `useSpringPool`,
+ * `defineSpring`, `mapSpring`, `velocityOf`, `accelerationOf`, and
+ * `targetOf`, and registers the `SpringValue` component. It does not
+ * auto-import types.
  */
 declare const coilyModule: NuxtModule;
 //#endregion

package/dist/nuxt.js

@@ -23,11 +23,13 @@ export default defineNuxtPlugin((nuxtApp) => {
 })`;
 }
 /**
-* The Nuxt module: creates an app-wide spring system (started on the
-* client), auto-imports the composables and helpers `useSpring`,
-* `useSpringSystem`, `useSpringPool`, `defineSpring`, `mapSpring`,
-* `velocityOf`, and `accelerationOf`, and registers the `SpringValue`
-* component. Types are left out — they would be noise in most apps.
+* The Nuxt module. It creates one spring system for the app and starts
+* it on the client only, so server rendering shows springs at their
+* initial values. The module auto-imports
+* `useSpring`, `useRamp`, `useSpringSystem`, `useSpringPool`,
+* `defineSpring`, `mapSpring`, `velocityOf`, `accelerationOf`, and
+* `targetOf`, and registers the `SpringValue` component. It does not
+* auto-import types.
 */
 const coilyModule = defineNuxtModule({
 	meta: {
@@ -47,6 +49,10 @@ const coilyModule = defineNuxtModule({
 				from: "coily/vue",
 				name: "useSpring"
 			},
+			{
+				from: "coily/vue",
+				name: "useRamp"
+			},
 			{
 				from: "coily/vue",
 				name: "useSpringSystem"
@@ -70,6 +76,10 @@ const coilyModule = defineNuxtModule({
 			{
 				from: "coily",
 				name: "accelerationOf"
+			},
+			{
+				from: "coily",
+				name: "targetOf"
 			}
 		]);
 		addComponent({

package/dist/{solver-CVXOTDkZ.js → solver-CAXuxdKj.js}

@@ -5,9 +5,8 @@ function invariant(condition, message) {
 	throw new Error(resolved ?? "Invariant Failed");
 }
 /**
-* True for plain objects only. Class instances are excluded so shape
-* walks reject values like a `Spring` instead of descending into their
-* fields as if they were nested shapes.
+* True for plain objects only. Excluding class instances makes shape walks
+* reject a `Spring` instead of descending into it as a nested shape.
 */
 function isRecord(value) {
 	if (typeof value !== "object" || value === null) return false;
@@ -27,8 +26,8 @@ const RESOLVED = Promise.resolve();
 //#endregion
 //#region src/state.ts
 /**
-* The mutable position/velocity pair a motion and its solvers share, in
-* displacement space: position 0 means at the target.
+* The mutable position and velocity that a motion and its solvers share,
+* in displacement space. Position 0 means at the target.
 */
 var State = class {
 	#config;
@@ -55,9 +54,8 @@ var State = class {
 		this.#velocity = value;
 	}
 	/**
-	* The rest test: displacement, plus the displacement the current
-	* velocity could still convert into (|x| + |v| / wn), is inside the
-	* config's resting threshold.
+	* True when |x| + |v| / wn, the displacement plus what the velocity could
+	* still add, is within the config's resting threshold.
 	*/
 	get isResting() {
 		return Math.abs(this.#position) + Math.abs(this.#velocity) / this.#config.naturalFrequency <= this.#config.restingMagnitude;
@@ -174,6 +172,8 @@ var CriticallyDampedSolver = class {
 		this.#state.velocity = scaleVelocity * decay + decayVelocity * scale;
 	}
 };
+/** The `wd * t` past which `OverdampedSolver` evaluates only its slow mode. */
+const TAIL = 20;
 /** dampingRatio > 1: slow non-oscillating decay, x(t) = exp(-sigma*t) * (c1*sinh(wd*t) + c2*cosh(wd*t)) / wd. */
 var OverdampedSolver = class {
 	#state;
@@ -220,15 +220,23 @@ var OverdampedSolver = class {
 		this.configure();
 	}
 	#evaluate() {
+		const wd = this.#dampedFrequency;
+		const wdt = wd * this.#t;
+		if (wdt > TAIL) {
+			const slowRate = wd - this.#decayRate;
+			const position = (this.#c1 + this.#c2) / (2 * wd) * Math.exp(slowRate * this.#t);
+			this.#state.position = position;
+			this.#state.velocity = slowRate * position;
+			return;
+		}
 		const decay = Math.exp(-this.#decayRate * this.#t);
 		const decayVelocity = -this.#decayRate * decay;
-		const clamped = Math.min(this.#dampedFrequency * this.#t, 300);
-		const sinh = Math.sinh(clamped);
-		const cosh = Math.cosh(clamped);
+		const sinh = Math.sinh(wdt);
+		const cosh = Math.cosh(wdt);
 		const scale = this.#c1 * sinh + this.#c2 * cosh;
-		const scaleVelocity = this.#c1 * this.#dampedFrequency * cosh + this.#c2 * this.#dampedFrequency * sinh;
-		this.#state.position = scale * decay / this.#dampedFrequency;
-		this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / this.#dampedFrequency;
+		const scaleVelocity = this.#c1 * wd * cosh + this.#c2 * wd * sinh;
+		this.#state.position = scale * decay / wd;
+		this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / wd;
 	}
 };
 //#endregion