@astryxdesign/core 0.7.5 → 0.7.6-canary.0bd3b37

package/src/motion/spring.test.ts

@@ -1,650 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file spring.test.ts
- * @input vitest, the spring model
- * @output Checks the closed-form spring against an independent RK4
- *   integration of the ODE across damping regimes, every conversion against
- *   Apple's published equations, and the settling duration against every
- *   published reference value
- * @position Testing; validates spring.ts without a browser
- */
-
-import {describe, expect, it} from 'vitest';
-import {
-  absoluteVelocity,
-  dampingRatioOf,
-  durationBounceOf,
-  relativeVelocity,
-  responseDampingOf,
-  responseOf,
-  settlingDuration,
-  solveSpring,
-  solveSpringTowardRamp,
-  springFromDurationBounce,
-  springFromPhysics,
-  springFromResponse,
-  springFromUIKitDampingDuration,
-  type Spring,
-} from './spring';
-
-/**
- * Independent reference: classic fourth-order Runge-Kutta on
- * m·x″ + c·x′ + k·(x − to) = 0. Shares nothing with the closed form.
- */
-function rk4(
-  spring: Spring,
-  from: number,
-  to: number,
-  velocity: number,
-  until: number,
-  dt = 1e-4,
-): {t: number; value: number; velocity: number}[] {
-  const {mass: m, stiffness: k, damping: c} = spring;
-  const accel = (x: number, v: number) => (-k * (x - to) - c * v) / m;
-  let x = from;
-  let v = velocity;
-  const out = [{t: 0, value: x, velocity: v}];
-  const steps = Math.round(until / dt);
-  for (let i = 1; i <= steps; i++) {
-    const k1x = v;
-    const k1v = accel(x, v);
-    const k2x = v + (dt / 2) * k1v;
-    const k2v = accel(x + (dt / 2) * k1x, v + (dt / 2) * k1v);
-    const k3x = v + (dt / 2) * k2v;
-    const k3v = accel(x + (dt / 2) * k2x, v + (dt / 2) * k2v);
-    const k4x = v + dt * k3v;
-    const k4v = accel(x + dt * k3x, v + dt * k3v);
-    x += (dt / 6) * (k1x + 2 * k2x + 2 * k3x + k4x);
-    v += (dt / 6) * (k1v + 2 * k2v + 2 * k3v + k4v);
-    if (i % 100 === 0) {
-      out.push({t: i * dt, value: x, velocity: v});
-    }
-  }
-  return out;
-}
-
-const RATIOS = [
-  0, 0.05, 0.3, 0.5, 0.75, 0.9, 0.99, 0.999999, 1, 1.000001, 1.2, 2, 5,
-];
-const RESPONSES = [0.15, 0.35, 0.5, 1];
-const RELEASES = [
-  {from: 0, to: 1, velocity: 0},
-  {from: 0, to: 300, velocity: 0},
-  {from: 300, to: 0, velocity: -2500},
-  {from: -120, to: 80, velocity: 4000},
-  // Zero displacement, all velocity: the case UIKit's relative velocity
-  // cannot express.
-  {from: 50, to: 50, velocity: 1800},
-];
-
-describe('solveSpring matches an RK4 integration of the ODE', () => {
-  for (const dampingRatio of RATIOS) {
-    for (const response of RESPONSES) {
-      it(`ζ=${dampingRatio}, response=${response}s`, () => {
-        // springFromResponse keeps overdamping, so every regime is covered.
-        const spring = springFromResponse({response, dampingRatio});
-        for (const release of RELEASES) {
-          const curve = solveSpring(spring, release);
-          const scale = Math.max(
-            1,
-            Math.abs(release.from - release.to),
-            Math.abs(release.velocity) * response,
-          );
-          for (const sample of rk4(
-            spring,
-            release.from,
-            release.to,
-            release.velocity,
-            1.5,
-          )) {
-            expect(Math.abs(curve.value(sample.t) - sample.value)).toBeLessThan(
-              1e-6 * scale,
-            );
-            expect(
-              Math.abs(curve.velocity(sample.t) - sample.velocity),
-            ).toBeLessThan((1e-6 * scale * 2 * Math.PI) / response);
-          }
-        }
-      });
-    }
-  }
-});
-
-describe('solveSpring', () => {
-  it('agrees with WebKit\u2019s SpringSolver (an independent port of its code)', () => {
-    // Source/WebCore/platform/graphics/SpringSolver.h, verbatim in
-    // structure: unit move, initial velocity positive toward the target.
-    const webkitSolve = (
-      m: number,
-      k: number,
-      c: number,
-      v0: number,
-      t: number,
-    ) => {
-      const w0 = Math.sqrt(k / m);
-      const zeta = c / (2 * Math.sqrt(k * m));
-      let x: number;
-      if (zeta < 1) {
-        const wd = w0 * Math.sqrt(1 - zeta * zeta);
-        const b = (zeta * w0 + -v0) / wd;
-        x =
-          Math.exp(-t * zeta * w0) * (Math.cos(wd * t) + b * Math.sin(wd * t));
-      } else {
-        x = (1 + (-v0 + w0) * t) * Math.exp(-t * w0);
-      }
-      return 1 - x;
-    };
-    const cases = [
-      [1, 438.64908449286042, 31.415926535897931, 0],
-      [1, 322.27279677026473, 31.2364069556928, 0],
-      [1, 100, 5, 0],
-      [1, 100, 20, 0],
-      [2, 300, 12, 4],
-      [1, 250, 31.6227766016838, -3],
-    ];
-    for (const [m, k, c, v0] of cases) {
-      const curve = solveSpring(
-        springFromPhysics({mass: m, stiffness: k, damping: c}),
-        {
-          from: 0,
-          to: 1,
-          velocity: v0,
-        },
-      );
-      for (let t = 0; t <= 1.5; t += 0.01) {
-        expect(curve.value(t)).toBeCloseTo(webkitSolve(m, k, c, v0, t), 6);
-      }
-    }
-  });
-
-  it('starts at the release value and velocity in every regime', () => {
-    for (const dampingRatio of RATIOS) {
-      const curve = solveSpring(
-        springFromResponse({response: 0.4, dampingRatio}),
-        {
-          from: 10,
-          to: 250,
-          velocity: -700,
-        },
-      );
-      expect(curve.value(0)).toBeCloseTo(10, 9);
-      expect(curve.velocity(0)).toBeCloseTo(-700, 6);
-    }
-  });
-
-  it('is continuous across critical damping', () => {
-    const release = {from: 0, to: 300, velocity: 1200};
-    const critical = solveSpring(
-      springFromResponse({response: 0.5, dampingRatio: 1}),
-      release,
-    );
-    for (const dampingRatio of [1 - 1e-5, 1 - 1e-7, 1 + 1e-7, 1 + 1e-5]) {
-      const near = solveSpring(
-        springFromResponse({response: 0.5, dampingRatio}),
-        release,
-      );
-      for (let t = 0; t <= 1.5; t += 0.01) {
-        expect(Math.abs(near.value(t) - critical.value(t))).toBeLessThan(0.01);
-      }
-    }
-  });
-
-  it('comes to rest at the target', () => {
-    for (const dampingRatio of RATIOS.filter(r => r > 0)) {
-      const curve = solveSpring(
-        springFromResponse({response: 0.3, dampingRatio}),
-        {from: 0, to: 100},
-      );
-      const settle = curve.settleTime(0.01);
-      expect(Math.abs(curve.value(settle + 5) - 100)).toBeLessThan(0.01);
-    }
-  });
-
-  it('settleTime bounds every later displacement (property sweep)', () => {
-    for (const dampingRatio of RATIOS.filter(r => r > 0)) {
-      for (const response of RESPONSES) {
-        for (const release of RELEASES) {
-          const curve = solveSpring(
-            springFromResponse({response, dampingRatio}),
-            release,
-          );
-          for (const threshold of [1, 0.1, 0.001]) {
-            const settle = curve.settleTime(threshold);
-            expect(Number.isFinite(settle)).toBe(true);
-            for (let i = 0; i <= 400; i++) {
-              const t = settle + (i / 400) * 3 * response;
-              expect(Math.abs(curve.value(t) - release.to)).toBeLessThanOrEqual(
-                threshold * (1 + 1e-9),
-              );
-            }
-          }
-        }
-      }
-    }
-  });
-
-  it('settleTime is 0 when already settled, Infinity when undamped and displaced', () => {
-    const spring = springFromResponse({response: 0.4, dampingRatio: 0.8});
-    expect(solveSpring(spring, {from: 5, to: 5}).settleTime(0.5)).toBe(0);
-    expect(solveSpring(spring, {from: 5.1, to: 5}).settleTime(0.5)).toBe(0);
-    const undamped = springFromResponse({response: 0.4, dampingRatio: 0});
-    expect(solveSpring(undamped, {from: 0, to: 1}).settleTime(0.001)).toBe(
-      Infinity,
-    );
-  });
-
-  it('an undamped spring oscillates with the response as its period (WWDC23: bounce 1 is a cosine)', () => {
-    const curve = solveSpring(
-      springFromDurationBounce({duration: 0.5, bounce: 1}),
-      {from: 0, to: 1},
-    );
-    for (let t = 0; t <= 2; t += 0.05) {
-      expect(curve.value(t)).toBeCloseTo(
-        1 - Math.cos((2 * Math.PI * t) / 0.5),
-        9,
-      );
-    }
-  });
-});
-
-describe('solveSpringTowardRamp (a target moving at constant speed)', () => {
-  /** RK4 on m·x″ + c·x′ + k·(x − (target + slope·t)) = 0. */
-  function rk4Ramp(
-    spring: Spring,
-    {
-      from,
-      velocity,
-      target,
-      slope,
-    }: {from: number; velocity: number; target: number; slope: number},
-    until: number,
-    dt = 1e-4,
-  ): {t: number; value: number; velocity: number}[] {
-    const {mass: m, stiffness: k, damping: c} = spring;
-    const accel = (time: number, x: number, v: number) =>
-      (-k * (x - (target + slope * time)) - c * v) / m;
-    let x = from;
-    let v = velocity;
-    const out = [{t: 0, value: x, velocity: v}];
-    const steps = Math.round(until / dt);
-    for (let i = 1; i <= steps; i++) {
-      const time = (i - 1) * dt;
-      const k1x = v;
-      const k1v = accel(time, x, v);
-      const k2x = v + (dt / 2) * k1v;
-      const k2v = accel(time + dt / 2, x + (dt / 2) * k1x, v + (dt / 2) * k1v);
-      const k3x = v + (dt / 2) * k2v;
-      const k3v = accel(time + dt / 2, x + (dt / 2) * k2x, v + (dt / 2) * k2v);
-      const k4x = v + dt * k3v;
-      const k4v = accel(time + dt, x + dt * k3x, v + dt * k3v);
-      x += (dt / 6) * (k1x + 2 * k2x + 2 * k3x + k4x);
-      v += (dt / 6) * (k1v + 2 * k2v + 2 * k3v + k4v);
-      if (i % 100 === 0) {
-        out.push({t: i * dt, value: x, velocity: v});
-      }
-    }
-    return out;
-  }
-
-  it.each([
-    {
-      name: 'underdamped',
-      spring: springFromResponse({response: 0.32, dampingRatio: 0.8}),
-      slope: 0.16,
-    },
-    {
-      name: 'critically damped',
-      spring: springFromResponse({response: 0.3, dampingRatio: 1}),
-      slope: -40,
-    },
-    {
-      name: 'overdamped',
-      spring: springFromPhysics({
-        stiffness: 100,
-        damping: 40,
-        allowOverdamping: true,
-      }),
-      slope: 250,
-    },
-  ])('matches an RK4 integration ($name)', ({spring, slope}) => {
-    const start = {from: 1, velocity: 0.5, target: 1.02, slope};
-    const curve = solveSpringTowardRamp(spring, start);
-    const scale = Math.max(1, Math.abs(slope));
-    for (const sample of rk4Ramp(spring, start, 1.5)) {
-      expect(Math.abs(curve.value(sample.t) - sample.value)).toBeLessThan(
-        1e-7 * scale,
-      );
-      expect(Math.abs(curve.velocity(sample.t) - sample.velocity)).toBeLessThan(
-        1e-6 * scale,
-      );
-    }
-  });
-
-  it('starts where it is told and settles lag behind, at the target\u2019s speed', () => {
-    const spring = springFromResponse({response: 0.3, dampingRatio: 1});
-    const curve = solveSpringTowardRamp(spring, {
-      from: 0,
-      velocity: 2,
-      target: 0,
-      slope: 10,
-    });
-    expect(curve.value(0)).toBeCloseTo(0, 12);
-    expect(curve.velocity(0)).toBeCloseTo(2, 12);
-    expect(curve.lag).toBeCloseTo((spring.damping * 10) / spring.stiffness, 12);
-    expect(curve.value(5) - (10 * 5 - curve.lag)).toBeCloseTo(0, 6);
-    expect(curve.velocity(5)).toBeCloseTo(10, 6);
-  });
-
-  it('with no slope it is the ordinary spring', () => {
-    const spring = springFromResponse({response: 0.35, dampingRatio: 0.85});
-    const ramp = solveSpringTowardRamp(spring, {
-      from: 0,
-      velocity: 3,
-      target: 1,
-      slope: 0,
-    });
-    const plain = solveSpring(spring, {from: 0, to: 1, velocity: 3});
-    for (let t = 0; t <= 1; t += 0.05) {
-      expect(ramp.value(t)).toBeCloseTo(plain.value(t), 12);
-      expect(ramp.velocity(t)).toBeCloseTo(plain.velocity(t), 12);
-    }
-  });
-});
-
-describe('conversions', () => {
-  it('(duration, bounce) follows the WWDC23 equations', () => {
-    // stiffness = (2π ÷ duration)², damping = (1 − bounce) × 4π ÷ duration.
-    const bouncy = springFromDurationBounce({duration: 0.5, bounce: 0.3});
-    expect(bouncy.mass).toBe(1);
-    expect(bouncy.stiffness).toBeCloseTo(((2 * Math.PI) / 0.5) ** 2, 9);
-    expect(bouncy.damping).toBeCloseTo((0.7 * 4 * Math.PI) / 0.5, 9);
-    // damping = 4π ÷ (duration × (1 + bounce)) for negative bounce.
-    const flattened = springFromDurationBounce({duration: 0.4, bounce: -0.5});
-    expect(flattened.damping).toBeCloseTo((4 * Math.PI) / (0.4 * 0.5), 9);
-    expect(dampingRatioOf(flattened)).toBeCloseTo(2, 9);
-  });
-
-  it('round-trips (duration, bounce) over the whole range', () => {
-    for (const duration of [0.15, 0.3, 0.5, 0.75, 1.2]) {
-      for (const bounce of [-0.9, -0.5, -0.1, 0, 0.15, 0.3, 0.6, 0.95, 1]) {
-        const back = durationBounceOf(
-          springFromDurationBounce({duration, bounce}),
-        );
-        expect(back.duration).toBeCloseTo(duration, 9);
-        expect(back.bounce).toBeCloseTo(bounce, 9);
-      }
-    }
-  });
-
-  it('SwiftUI presets map to their damping ratios (smooth 0, snappy 0.15, bouncy 0.3)', () => {
-    expect(
-      dampingRatioOf(springFromDurationBounce({duration: 0.5, bounce: 0})),
-    ).toBeCloseTo(1, 12);
-    expect(
-      dampingRatioOf(springFromDurationBounce({duration: 0.5, bounce: 0.15})),
-    ).toBeCloseTo(0.85, 12);
-    expect(
-      dampingRatioOf(springFromDurationBounce({duration: 0.5, bounce: 0.3})),
-    ).toBeCloseTo(0.7, 12);
-  });
-
-  it('(response, dampingRatio) reproduces WebKit\u2019s UIKit-matched switch springs exactly', () => {
-    // Source/WebCore/rendering/cocoa/RenderThemeCocoa.mm:
-    // SpringSolver(1.0, 438.64908449286042, 31.415926535897931, 0.0) and
-    // SpringSolver(1.0, 322.27279677026473, 31.2364069556928, 0.0).
-    const move = springFromResponse({response: 0.3, dampingRatio: 0.75});
-    expect(move.stiffness).toBeCloseTo(438.64908449286042, 9);
-    expect(move.damping).toBeCloseTo(31.415926535897931, 9);
-    const press = springFromResponse({response: 0.35, dampingRatio: 0.87});
-    expect(press.stiffness).toBeCloseTo(322.27279677026473, 9);
-    expect(press.damping).toBeCloseTo(31.2364069556928, 9);
-  });
-
-  it('round-trips (response, dampingRatio) and physics', () => {
-    const spring = springFromPhysics({mass: 2, stiffness: 300, damping: 20});
-    const {response, dampingRatio} = responseDampingOf(spring);
-    expect(response).toBeCloseTo((2 * Math.PI) / Math.sqrt(150), 12);
-    expect(dampingRatio).toBeCloseTo(20 / (2 * Math.sqrt(600)), 12);
-    // A different mass with the same ω₀ and ζ is the same motion.
-    const unit = springFromResponse({response, dampingRatio});
-    const a = solveSpring(spring, {from: 0, to: 1, velocity: 3});
-    const b = solveSpring(unit, {from: 0, to: 1, velocity: 3});
-    for (let t = 0; t < 1; t += 0.05) {
-      expect(a.value(t)).toBeCloseTo(b.value(t), 9);
-    }
-    expect(responseOf(unit)).toBeCloseTo(response, 12);
-  });
-
-  it('treats an overdamped physics spring as critical unless allowed (SwiftUI, UIKit)', () => {
-    const clamped = springFromPhysics({stiffness: 100, damping: 50});
-    expect(dampingRatioOf(clamped)).toBeCloseTo(1, 12);
-    const kept = springFromPhysics({
-      stiffness: 100,
-      damping: 50,
-      allowOverdamping: true,
-    });
-    expect(dampingRatioOf(kept)).toBeCloseTo(2.5, 12);
-  });
-
-  it('rejects impossible parameters', () => {
-    expect(() => springFromDurationBounce({duration: 0, bounce: 0})).toThrow(
-      RangeError,
-    );
-    expect(() => springFromResponse({response: -1, dampingRatio: 1})).toThrow(
-      RangeError,
-    );
-    expect(() => springFromPhysics({stiffness: 100, damping: -1})).toThrow(
-      RangeError,
-    );
-    expect(() =>
-      springFromPhysics({mass: 0, stiffness: 100, damping: 1}),
-    ).toThrow(RangeError);
-  });
-
-  it('relative velocity follows UIKit\u2019s documented example', () => {
-    // "if the total animation distance is 200 points and you want the start
-    // of the animation to match a view velocity of 100 pt/s, use 0.5"
-    expect(relativeVelocity(100, 0, 200)).toBe(0.5);
-    expect(absoluteVelocity(0.5, 0, 200)).toBe(100);
-    expect(relativeVelocity(-100, 300, 100)).toBe(0.5);
-  });
-});
-
-describe('settlingDuration (CASpringAnimation semantics)', () => {
-  it('matches Apple\u2019s CASpringAnimation documentation example', () => {
-    // mass 1, stiffness 100: damping 5 → "approximately 2.85 seconds";
-    // damping 15 → "just over 1 second".
-    const loose = settlingDuration(
-      springFromPhysics({stiffness: 100, damping: 5}),
-    );
-    expect(loose).toBeGreaterThan(2.845);
-    expect(loose).toBeLessThan(2.865);
-    const tight = settlingDuration(
-      springFromPhysics({stiffness: 100, damping: 15}),
-    );
-    expect(tight).toBeGreaterThan(1);
-    expect(tight).toBeLessThan(1.05);
-  });
-
-  it('matches WebKit\u2019s iOS switch durations, the settling durations of its springs', () => {
-    // Source/WebCore/rendering/ios/RenderThemeIOS.h:
-    // switchAnimationVisuallyOnDuration 0.4880138408543766_s,
-    // switchAnimationHeldDuration 0.5073965509413827_s.
-    expect(
-      settlingDuration(springFromResponse({response: 0.3, dampingRatio: 0.75})),
-    ).toBeCloseTo(0.4880138408543766, 9);
-    expect(
-      settlingDuration(
-        springFromResponse({response: 0.35, dampingRatio: 0.87}),
-      ),
-    ).toBeCloseTo(0.5073965509413827, 9);
-  });
-
-  it('is shorter for a stiffer or a better-damped spring, as documented', () => {
-    const base = settlingDuration(
-      springFromPhysics({stiffness: 100, damping: 10}),
-    );
-    expect(
-      settlingDuration(springFromPhysics({stiffness: 200, damping: 10})),
-    ).toBeLessThan(base);
-    expect(
-      settlingDuration(springFromPhysics({stiffness: 100, damping: 15})),
-    ).toBeLessThan(base);
-    expect(
-      settlingDuration(
-        springFromPhysics({mass: 2, stiffness: 100, damping: 10}),
-      ),
-    ).toBeGreaterThan(base);
-  });
-
-  it('a critically damped unit move settles at (1 + u)·e^(−u) = ε', () => {
-    const spring = springFromResponse({response: 0.5, dampingRatio: 1});
-    const omega = (2 * Math.PI) / 0.5;
-    const u = settlingDuration(spring) * omega;
-    expect((1 + u) * Math.exp(-u)).toBeCloseTo(0.001, 9);
-  });
-
-  it('accounts for the initial velocity', () => {
-    const spring = springFromResponse({response: 0.5, dampingRatio: 0.8});
-    const still = settlingDuration(spring);
-    // Moving away from the target, or toward it hard enough to overshoot
-    // further, settles later; a velocity close to the spring's own natural
-    // start (here ζ·ω₀ ≈ 10 distances/s) shrinks the oscillation instead.
-    expect(settlingDuration(spring, {initialVelocity: -8})).toBeGreaterThan(
-      still,
-    );
-    expect(settlingDuration(spring, {initialVelocity: 40})).toBeGreaterThan(
-      still,
-    );
-    expect(settlingDuration(spring, {initialVelocity: 8})).toBeLessThan(still);
-  });
-});
-
-// Read from UIKit on the iOS 26.2 simulator (UIKit lab, injected host app,
-// iPhone 17 Pro, Oct 23 2026): CASpringAnimation.settlingDuration for mass 1,
-// stiffness 100, and the duration UIKit gives UIView.animate(springDuration:
-// bounce:initialSpringVelocity:).
-const CA_SETTLING = [
-  {damping: 5, velocity: 0, settling: 2.854974609888761},
-  {damping: 5, velocity: 5, settling: 2.854974609888761},
-  {damping: 5, velocity: -5, settling: 2.992531378997136},
-  {damping: 10, velocity: 0, settling: 1.4727003346780927},
-  {damping: 10, velocity: 5, settling: 1.3815510557964277},
-  {damping: 10, velocity: -5, settling: 1.5350814063145797},
-  {damping: 15, velocity: 0, settling: 1.0220937981854987},
-  {damping: 15, velocity: 5, settling: 0.9637816892907282},
-  {damping: 15, velocity: -5, settling: 1.0625267085113923},
-];
-const UIKIT_SPRING_DURATION = [
-  {duration: 0.3, bounce: 0, velocity: 0, uikit: 0.4409405178437803},
-  {duration: 0.3, bounce: 0, velocity: 2, uikit: 0.43617534275714415},
-  {duration: 0.3, bounce: 0.15, velocity: 0, uikit: 0.4419904194536484},
-  {duration: 0.3, bounce: 0.15, velocity: 2, uikit: 0.4379526271453696},
-  {duration: 0.3, bounce: 0.3, velocity: 0, uikit: 0.5177731699046524},
-  {duration: 0.5, bounce: 0, velocity: 0, uikit: 0.734900863},
-  {duration: 0.5, bounce: 0.15, velocity: 0, uikit: 0.736650699089414},
-  {duration: 0.5, bounce: 0.3, velocity: 2, uikit: 0.8493819071116907},
-  {duration: 1, bounce: 0, velocity: 0, uikit: 1.469801726},
-  {duration: 1, bounce: 0, velocity: 2, uikit: 1.410252226},
-  {duration: 1, bounce: 0.15, velocity: 2, uikit: 1.4240715395795775},
-  {duration: 1, bounce: 0.3, velocity: 0, uikit: 1.725910566348841},
-];
-
-describe('settlingDuration against values read from UIKit', () => {
-  it.each(CA_SETTLING)(
-    'CASpringAnimation(stiffness 100, damping $damping, v $velocity).settlingDuration',
-    ({damping, velocity, settling}) => {
-      const spring = springFromPhysics({stiffness: 100, damping});
-      expect(settlingDuration(spring, {initialVelocity: velocity})).toBeCloseTo(
-        settling,
-        12,
-      );
-    },
-  );
-
-  it.each(UIKIT_SPRING_DURATION)(
-    'UIView.animate(springDuration: $duration, bounce: $bounce, v $velocity) runs $uikit s',
-    ({duration, bounce, velocity, uikit}) => {
-      const spring = springFromDurationBounce({duration, bounce});
-      const mine = settlingDuration(spring, {initialVelocity: velocity});
-      if (bounce > 0) {
-        expect(mine).toBeCloseTo(uikit, 12);
-      } else {
-        // Critically damped: UIKit stops 0.0016 later in ω₀·t.
-        expect(Math.abs(mine - uikit) / uikit).toBeLessThan(3e-4);
-      }
-    },
-  );
-
-  it('UIKit’s default spring runs 0.505824 s: overdamping clamped to critical', () => {
-    const spring = springFromPhysics({mass: 3, stiffness: 1000, damping: 500});
-    expect(dampingRatioOf(spring)).toBeCloseTo(1, 12);
-    expect(
-      Math.abs(settlingDuration(spring) - 0.505824) / 0.505824,
-    ).toBeLessThan(3e-4);
-  });
-});
-
-describe('springFromUIKitDampingDuration (legacy damping/duration API)', () => {
-  // Read from UIKit (same capture): UIView.animate(withDuration: D,
-  // usingSpringWithDamping: ζ, initialSpringVelocity: 0) → mass 1 and these.
-  it.each([
-    {duration: 0.3, dampingRatio: 0.5, stiffness: 1796.883, damping: 42.3897},
-    {duration: 0.3, dampingRatio: 0.8, stiffness: 898.86, damping: 47.9696},
-    {duration: 0.3, dampingRatio: 1, stiffness: 947.288, damping: 61.5561},
-    {duration: 0.5, dampingRatio: 0.5, stiffness: 646.878, damping: 25.4338},
-    {duration: 0.5, dampingRatio: 0.8, stiffness: 323.589, damping: 28.7817},
-    {duration: 0.5, dampingRatio: 1, stiffness: 341.024, damping: 36.9337},
-    {duration: 1, dampingRatio: 0.5, stiffness: 161.72, damping: 12.7169},
-    {duration: 1, dampingRatio: 0.8, stiffness: 80.897, damping: 14.3909},
-    {duration: 1, dampingRatio: 1, stiffness: 85.256, damping: 18.4668},
-  ])(
-    'D $duration, ζ $dampingRatio → stiffness $stiffness',
-    ({duration, dampingRatio, stiffness, damping}) => {
-      const spring = springFromUIKitDampingDuration({duration, dampingRatio});
-      expect(spring.mass).toBe(1);
-      expect(Math.abs(spring.stiffness - stiffness) / stiffness).toBeLessThan(
-        1e-4,
-      );
-      expect(Math.abs(spring.damping - damping) / damping).toBeLessThan(1e-4);
-    },
-  );
-
-  it('at ζ 1 the derived spring settles exactly at the duration', () => {
-    const spring = springFromUIKitDampingDuration({
-      duration: 0.4,
-      dampingRatio: 1,
-    });
-    expect(settlingDuration(spring)).toBeCloseTo(0.4, 3);
-  });
-
-  it.each([
-    {dampingRatio: 0.1, omega: 46.1019536228216},
-    {dampingRatio: 0.3, omega: 19.1698},
-    {dampingRatio: 0.65, omega: 10.3869},
-    {dampingRatio: 0.95, omega: 8.4425},
-  ])(
-    'reproduces the wide read at D 1, ζ $dampingRatio',
-    ({dampingRatio, omega}) => {
-      const spring = springFromUIKitDampingDuration({
-        duration: 1,
-        dampingRatio,
-      });
-      expect(Math.sqrt(spring.stiffness)).toBeCloseTo(omega, 3);
-    },
-  );
-
-  it('interpolates between the measured ratios', () => {
-    const a = springFromUIKitDampingDuration({duration: 1, dampingRatio: 0.6});
-    const b = springFromUIKitDampingDuration({
-      duration: 1,
-      dampingRatio: 0.625,
-    });
-    const c = springFromUIKitDampingDuration({duration: 1, dampingRatio: 0.65});
-    expect(Math.sqrt(b.stiffness)).toBeCloseTo(
-      (Math.sqrt(a.stiffness) + Math.sqrt(c.stiffness)) / 2,
-      9,
-    );
-  });
-});