@astryxdesign/core 0.7.6 → 0.7.7-canary.0d1ddcd

package/src/motion/animator.ts

@@ -517,6 +517,14 @@ interface StartGroup {
   madeInFrame?: boolean;
   /** The task it was made in, with every call made in that task. */
   task?: TaskMark;
+  /**
+   * Per channel, when its animation's first frame ran without a known start.
+   * That frame came too late to stand for the start, and the browser had not
+   * told it yet. The compositor starts the animation within about a frame of
+   * this time. Until the browser tells its start, a read of the channel takes
+   * the curve from here.
+   */
+  latest?: Map<Channel, number>;
   /** A later call in the same task that took over its curves. */
   adoptedBy?: StartGroup;
   readonly resolve: (start: number) => void;
@@ -1044,7 +1052,7 @@ export function createAnimator(
     if (segment == null) {
       return null;
     }
-    if (time >= segment.start + segment.duration) {
+    if (time >= endOf(property, segment)) {
       return null;
     }
     return segment;
@@ -1070,16 +1078,89 @@ export function createAnimator(
   };
 
   /**
-   * The value on screen at `time`. A curve the browser has not started is at
-   * its start up to now; a later time reads the curve from its provisional
-   * start, the model's best guess until the browser's start moves it (a
-   * companion that samples a curve ahead follows its shape).
+   * A held curve's start once a frame dated its call, as the browser's start
+   * moves it: by that frame's lead over the call's own time.
+   */
+  const datedFromLatest = (
+    segment: Segment,
+    latest: number | undefined,
+  ): {latest: number; start: number} | null =>
+    latest == null || segment.group == null
+      ? null
+      : {latest, start: segment.start + latest - segment.group.provisional};
+
+  /**
+   * When a waiting curve's call had its first frame, which put the curve on
+   * screen. Undefined for a curve that does not wait, or whose call has had
+   * no first frame.
+   */
+  const shownSince = (
+    property: MotionProperty,
+    segment: Segment,
+  ): number | undefined =>
+    segment.group?.resolved === false
+      ? segment.group.latest?.get(CHANNEL_OF[property])
+      : undefined;
+
+  /** A curve's end, dated from its call's first frame while it waits. */
+  const endOf = (property: MotionProperty, segment: Segment): number =>
+    (datedFromLatest(segment, shownSince(property, segment))?.start ??
+      segment.start) + segment.duration;
+
+  /**
+   * Takes a curve on screen out of the call that still waits for the
+   * browser's start. The curve keeps its course, dated from the call's first
+   * frame. A call that has no channel left starts at that frame.
+   */
+  const leaveWaitingCall = (
+    segment: Segment,
+    channel: Channel,
+    latest: number,
+  ) => {
+    const group = segment.group;
+    if (group == null) {
+      return;
+    }
+    const index = group.segments.indexOf(segment);
+    if (index >= 0) {
+      group.segments.splice(index, 1);
+    }
+    segment.start += latest - group.provisional;
+    segment.group = undefined;
+    if (!CHANNELS[channel].some(p => segments.get(p)?.group === group)) {
+      group.latest?.delete(channel);
+      group.channels.delete(channel);
+    }
+    if (group.channels.size === 0 && group.segments.length === 0) {
+      resolveGroup(group, latest);
+    }
+  };
+
+  /**
+   * The value on screen at `time`. Until the browser reports its start, a
+   * held curve shows its first value. A frame that ran without that start
+   * dates the curve. Without that frame, a later time reads from the
+   * provisional start, so a companion that samples ahead follows the curve's
+   * shape.
    */
   const valueAt = (property: MotionProperty, time: number): number => {
     const segment = segments.get(property);
-    if (segment != null && isHeld(segment) && time <= now()) {
+    if (segment != null && isHeld(segment)) {
+      // The compositor starts the call near its first frame. The curve is
+      // dated as the browser's start would date it. A curve that joined by an
+      // older clock keeps its lead over the call's own time.
+      const latest = segment.group?.latest?.get(CHANNEL_OF[property]);
+      const dated = datedFromLatest(segment, latest);
+      if (dated != null) {
+        const elapsed = Math.max(time, dated.latest) - dated.start;
+        return elapsed >= segment.duration
+          ? segment.target
+          : segment.at(elapsed);
+      }
       // Nothing has moved on screen until the browser starts the call.
-      return segment.at(0);
+      if (time <= now()) {
+        return segment.at(0);
+      }
     }
     return curveAt(property, time);
   };
@@ -1087,10 +1168,22 @@ export function createAnimator(
   const velocityAt = (property: MotionProperty, time: number): number => {
     const held = segments.get(property);
     if (held != null && isHeld(held)) {
-      // Still at its start on screen, but moving in the model: a retarget
-      // carries the velocity the curve has reached by now, so a flick whose
-      // moves all land before the browser starts any keeps its speed.
-      return held.speed(Math.max(0, time - held.start));
+      // Still at its start on screen, but moving in the model. A retarget
+      // carries the velocity the curve has reached by now. So a flick whose
+      // moves all land before the browser starts any keeps its speed. Past
+      // its first frame, it reads from that frame, as its value does.
+      const dated = datedFromLatest(
+        held,
+        held.group?.latest?.get(CHANNEL_OF[property]),
+      );
+      return held.speed(
+        Math.max(
+          0,
+          dated != null && time > dated.latest
+            ? time - dated.start
+            : time - held.start,
+        ),
+      );
     }
     const segment = segmentAt(property, time);
     if (segment == null || time < segment.start) {
@@ -1270,12 +1363,54 @@ export function createAnimator(
     // Settled curves become resting values.
     for (const property of properties) {
       const segment = segments.get(property);
-      if (segment != null && time >= segment.start + segment.duration) {
+      if (segment != null && time >= endOf(property, segment)) {
         resting[property] = segment.target;
         segments.delete(property);
       }
     }
     const moving = properties.filter(p => segments.has(p));
+    if (callGroup == null) {
+      // A call that starts now rebuilds a channel the compositor has moving
+      // since a first frame without a known start. The channel carries on
+      // from that frame, with a start of its own, instead of starting its
+      // curve again.
+      for (const property of moving) {
+        const segment = segments.get(property) as Segment;
+        const latest = shownSince(property, segment);
+        if (latest != null) {
+          leaveWaitingCall(segment, channel, latest);
+        }
+      }
+    }
+    // An explicit call can rebuild a channel while one of its curves still
+    // waits for the browser's start. The animation then joins the current
+    // call, or else that waiting call, with no start of its own.
+    const waiting =
+      callGroup ??
+      moving
+        .map(p => (segments.get(p) as Segment).group)
+        .find(group => group != null && !group.resolved) ??
+      null;
+    const rebuiltAfterFirstFrame = waiting?.framed === true;
+    // The new animation starts at the frame that commits it, from its first
+    // keyframe. That holds for a waiting call it joins after that call's
+    // first frame, and for every waiting call it takes a curve from. So this
+    // channel's reads below, and until that frame, take that first value.
+    const restarted = new Set<StartGroup>();
+    if (rebuiltAfterFirstFrame) {
+      restarted.add(waiting);
+    }
+    if (callGroup != null) {
+      for (const property of moving) {
+        const group = (segments.get(property) as Segment).group;
+        if (group != null && group !== callGroup && !group.resolved) {
+          restarted.add(group);
+        }
+      }
+    }
+    for (const group of restarted) {
+      group.latest?.delete(channel);
+    }
     if (channel === 'translate') {
       // The animation built below starts from the value at `time` (its first
       // keyframe); a rebase or a retarget builds a new one, so a new start.
@@ -1308,15 +1443,6 @@ export function createAnimator(
       previous?.cancel();
       return;
     }
-    // A channel rebuilt by an explicit call (set, rebase, a retarget of
-    // another axis) while one of its curves still waits for the browser's
-    // start keeps that start: no explicit start for this animation.
-    const waiting =
-      callGroup ??
-      moving
-        .map(p => (segments.get(p) as Segment).group)
-        .find(group => group != null && !group.resolved) ??
-      null;
     // The keyframes start where the animation will: at the waiting call's
     // own time, which its start moves to the browser's (resolveGroup), so a
     // write later in the task keeps the screen on the model's clock.
@@ -1431,6 +1557,20 @@ export function createAnimator(
       waiting.channels.add(channel);
       // A cancel before the first frame rejects its ready promise.
       (animation as Partial<Animation>).ready?.catch(() => {});
+      if (rebuiltAfterFirstFrame) {
+        // The frame that commits it dates this channel's start again. The
+        // call's other channels keep their own.
+        requestFrame?.(() => {
+          if (
+            !waiting.resolved &&
+            running.get(channel) === animation &&
+            animation.startTime == null &&
+            animation.playState === 'running'
+          ) {
+            (waiting.latest ??= new Map()).set(channel, now());
+          }
+        });
+      }
     } else {
       // One clock: the keyframes were sampled from `time`.
       animation.startTime = time;
@@ -1937,10 +2077,14 @@ export function createAnimator(
     for (const channel of start === 'commit' ? [] : channels) {
       for (const property of CHANNELS[channel]) {
         const segment = segments.get(property);
+        // A call's first frame puts its channels on screen, even before the
+        // browser reports the start. So such a channel is not at rest either.
         if (
           segment != null &&
-          time < segment.start + segment.duration &&
-          (segment.group == null || segment.group.resolved)
+          time < endOf(property, segment) &&
+          (segment.group == null ||
+            segment.group.resolved ||
+            shownSince(property, segment) != null)
         ) {
           return null;
         }
@@ -2135,6 +2279,22 @@ export function createAnimator(
       ) {
         resolveGroup(group, now());
       }
+      // The browser's start is still unread. The compositor starts the call
+      // near this frame, so each moving channel's reads take the curve from
+      // now until the browser tells its start.
+      if (!group.resolved) {
+        for (const channel of group.channels) {
+          const animation = running.get(channel);
+          if (
+            animation != null &&
+            group.animations.includes(animation) &&
+            animation.startTime == null &&
+            animation.playState === 'running'
+          ) {
+            (group.latest ??= new Map()).set(channel, now());
+          }
+        }
+      }
     });
     ready.then(
       () => syncGroup(group),
@@ -3643,9 +3803,11 @@ export function createAnimator(
         }
         owners.add(segment.owner);
         // A curve still waiting for the browser's start stays in its call:
-        // it starts with that call's commit.
+        // it starts with that call's commit. A curve whose call had its first
+        // frame is on screen already, so it leaves the call (leaveWaitingCall).
+        const latest = shownSince(property, segment);
         const group =
-          segment.group != null && !segment.group.resolved
+          latest == null && segment.group != null && !segment.group.resolved
             ? segment.group
             : undefined;
         const replace = (next: Segment) => {
@@ -3662,6 +3824,9 @@ export function createAnimator(
         if (segment.spring != null) {
           const from = valueAt(property, time) + delta;
           const velocity = velocityAt(property, time);
+          if (latest != null) {
+            leaveWaitingCall(segment, CHANNEL_OF[property], latest);
+          }
           const curve = solveSpring(toSpring(segment.spring), {
             from,
             to: segment.target,
@@ -3682,6 +3847,9 @@ export function createAnimator(
             spring: segment.spring,
           });
         } else {
+          if (latest != null) {
+            leaveWaitingCall(segment, CHANNEL_OF[property], latest);
+          }
           replace({
             ...segment,
             target: segment.target + delta,

package/src/motion/paging.ts

@@ -0,0 +1,138 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file paging.ts
+ * @input A release velocity, a settle's start, end and velocity, and the UIKit
+ *   paging constants
+ * @output Exports `pagingSettleVelocity`, `solvePaging` (UIKit's paging settle
+ *   as a curve the animator plays) and `solveAnimatedPageScroll`
+ * @position Pure math, with no DOM and no React
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/motion/paging.test.ts
+ * - /packages/core/src/motion/README.md
+ */
+
+import type {MotionCurve} from './animator';
+import {paging} from './uikit/paging';
+
+/**
+ * The velocity a paging settle starts at. It is the release velocity that every
+ * gesture reads, zeroed below `velocityFloor`. The page choice reads the
+ * release velocity itself.
+ */
+export function pagingSettleVelocity(velocity: number): number {
+  return Math.abs(velocity) < paging.release.velocityFloor ? 0 : velocity;
+}
+
+/** A paging settle: the curve and where it ends. */
+export interface PagingCurve extends MotionCurve {
+  readonly from: number;
+  readonly to: number;
+  /** Integration steps the settle took. */
+  readonly steps: number;
+}
+
+/**
+ * UIKit's paging settle from `from` (px), moving at `velocity` (px/s), onto
+ * `to`. It steps `paging.integrator` `stepsPerSecond` times a second and ends
+ * exactly on `to`. The same motion returns an overscrolled pager to its first
+ * or last page.
+ *
+ * Positions are content offsets along the paging axis, 0 at page 0 and growing
+ * toward later pages. Velocities are px/s of that offset.
+ *
+ * No closed form reproduces the per-frame stepping, so the settle integrates
+ * once into a table, and the curve reads the table. A release needs at most
+ * about 400 steps, well under a millisecond of work.
+ *
+ * The release velocity enters in px per millisecond per step, as UIKit hands it
+ * to the integrator. At 960 steps a second, the content starts at 96 % of the
+ * finger's speed, as in UIKit.
+ */
+export function solvePaging({
+  from,
+  velocity,
+  to,
+}: {
+  from: number;
+  velocity: number;
+  to: number;
+}): PagingCurve {
+  const {springPull, friction, stepsPerSecond, restDistance, restSpeed} =
+    paging.integrator;
+  const xs: number[] = [from];
+  const vs: number[] = [velocity / 1000];
+  let x = from;
+  let v = velocity / 1000;
+  // ~10 s of steps: far beyond any settle (≈ 0.35 s from rest).
+  const maxSteps = stepsPerSecond * 10;
+  let steps = 0;
+  while (steps < maxSteps) {
+    if (Math.abs(to - x) < restDistance && Math.abs(v) < restSpeed) {
+      break;
+    }
+    v = (v + (to - x) * springPull) * friction;
+    x += v;
+    steps += 1;
+    xs.push(x);
+    vs.push(v);
+  }
+  xs[xs.length - 1] = to;
+  vs[vs.length - 1] = 0;
+  const duration = steps / stepsPerSecond;
+  const last = xs.length - 1;
+  const read = (table: number[], t: number): number => {
+    if (!(t > 0)) {
+      return table[0];
+    }
+    const s = t * stepsPerSecond;
+    if (s >= last) {
+      return table[last];
+    }
+    const i = Math.floor(s);
+    const f = s - i;
+    return table[i] + (table[i + 1] - table[i]) * f;
+  };
+  return {
+    from,
+    to,
+    steps,
+    duration,
+    at: t => read(xs, t),
+    // px per step × steps per second
+    velocity: t => read(vs, t) * stepsPerSecond,
+  };
+}
+
+/**
+ * `setContentOffset(_:animated:)`: `paging.animatedScroll.duration` on a
+ * sinusoidal ease-in-out, whatever the distance. UIKit starts it from the
+ * current offset and drops any velocity, as here.
+ */
+export function solveAnimatedPageScroll({
+  from,
+  to,
+}: {
+  from: number;
+  to: number;
+}): MotionCurve {
+  const {duration} = paging.animatedScroll;
+  const distance = to - from;
+  return {
+    duration,
+    at: t => {
+      const u = Math.min(1, Math.max(0, t / duration));
+      return from + (distance * (1 - Math.cos(Math.PI * u))) / 2;
+    },
+    velocity: t => {
+      if (t <= 0 || t >= duration) {
+        return 0;
+      }
+      return (
+        ((distance * Math.PI) / (2 * duration)) *
+        Math.sin((Math.PI * t) / duration)
+      );
+    },
+  };
+}

package/src/motion/uikit/index.ts

@@ -4,7 +4,7 @@
  * @file index.ts
  * @input The domain files of the UIKit constants table
  * @output Re-exports `springs` and one constant per spring (`SHEET_PRESENT_SPRING`,
- *   …), `scroll`, `timing`, `navigation` and the
+ *   …), `scroll`, `timing`, `navigation`, the `slider` domain and the
  *   gesture thresholds (one `UIKIT_*` group per recognizer, their union
  *   `UIKIT_GESTURES`, and the haptic tables)
  * @position Entry of the UIKit constants table (motion/uikit). Internal to
@@ -40,6 +40,7 @@ export {
 } from './gestures';
 export {navigation, registerNavigationTable} from './navigation';
 export {registerScrollTable, scroll} from './scroll';
+export {slider} from './slider';
 export {
   ACTION_SHEET_DISMISS_SPRING,
   ACTION_SHEET_PRESENT_SPRING,

package/src/motion/uikit/paging.ts

@@ -0,0 +1,162 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file paging.ts
+ * @input Nothing; data only
+ * @output Exports `paging`, the measured constants of a paging UIScrollView
+ * @position The paging domain of the UIKit constants table (motion/uikit). Only
+ *   core reads it, so the `uikit` namespace does not re-export it
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/motion/MEASUREMENTS.md (measurement tasks)
+ * - /packages/core/src/motion/paging.ts and paging.test.ts
+ */
+
+export const paging = {
+  /**
+   * After the lift, one model moves the content: the settle onto the chosen
+   * page and the return from an overscroll. Each display frame runs floor(frame
+   * interval in ms) steps of 1 ms:
+   *
+   *   v = (v + (target − x) · springPull) · friction;  x += v  (v: pt per step)
+   *
+   * A 60 Hz frame runs 16 steps, not 16.67. With these values, the model
+   * replays eight captured releases to 0.20 pt RMS. It replays five overscroll
+   * returns to 0.16–0.33 pt RMS (402 pt pages, iOS 26.2, 3× screen). Without
+   * the floor, the error is 1.0 pt RMS, with a systematic shape.
+   */
+  integrator: {
+    /**
+     * Velocity added per 1 ms step, per point of distance to the target page
+     * (pt per step²).
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026.
+     *   `_pagingSpringPull` reads the same on a 402 pt paging UIScrollView and
+     *   on UIPageViewController's scroll view. It replays 8 captured settles to
+     *   0.20 pt RMS.
+     */
+    springPull: 0.000284858,
+    /**
+     * Velocity kept per step after the pull (`_pagingFriction`, equal to
+     * `_defaultPagingFriction`).
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. Both read
+     *   the same on the two scroll views of `springPull`, and they replay with
+     *   it.
+     */
+    friction: 0.970815,
+    /**
+     * Integration steps per second: floor(16.67 ms) = 16 steps per 60 Hz frame,
+     * and floor(8.33 ms) = 8 per 120 Hz frame, so 960.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. In a 60 fps
+     *   log of 8 releases at rest, floored stepping fits to 0.20 pt RMS.
+     *   Unfloored stepping fits to 1.0 pt RMS.
+     */
+    stepsPerSecond: 960,
+    /**
+     * A settle ends exactly on the page once the remaining distance is below
+     * this many points and the step velocity is below `restSpeed`.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. The
+     *   captured settles jump the last 0.33 pt onto the page about 0.35 s after
+     *   a release at rest.
+     */
+    restDistance: 0.5,
+    /**
+     * Step velocity (pt per step) below which a settle may end.
+     * @source GUESS — the captured settles end at about 0.04 pt per step;
+     *   the threshold is not observable more finely at 60 fps
+     * @measure M-PG12
+     */
+    restSpeed: 0.05,
+  },
+  release: {
+    /**
+     * Released slower than `advanceSpeed`, the scroll view settles on the page
+     * nearest the content position: past half a page, the next one.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. In releases
+     *   at rest from page 1, content at 48.5 % of the page stays, and 57.5 %
+     *   goes to the next page. On a second 402 pt pager, 45 % stays and 55 %
+     *   advances.
+     */
+    commitFraction: 0.5,
+    /**
+     * Released at least this fast (pt/s), the scroll view pages in the
+     * direction of the velocity, from any content position. A flick from 6 % of
+     * the page advances. The speed is UIPanGestureRecognizer's velocity at the
+     * last movement, and it never decays. The scroll view's
+     * `_horizontalVelocity` equals it at every sample. A drag held still for
+     * 397 ms before the lift still pages at the speed it had.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. Steady
+     *   releases at 10, 25 and 40 % of a 402 pt page: 292.7, 295.3 and 298.6
+     *   pt/s stay; 310.7, 316.4 and 329.9 advance. The result is the same at
+     *   every position: a threshold, not a projection.
+     */
+    advanceSpeed: 300,
+    /**
+     * A settle velocity slower than this (pt/s) is zeroed, so the settle starts
+     * at rest. It is paging's own tuning on the one release velocity that every
+     * gesture reads.
+     * @source GUESS — the middle of the measured (200, 249] bracket. In the
+     *   UIKit lab (iOS 26.2 simulator, Oct 23 2026),
+     *   `scrollViewWillEndDragging` reads 0 for steady releases at 175 and 200
+     *   pt/s. It reads 0.249 pt/ms for a release at 249 pt/s.
+     * @measure M-PG13
+     */
+    velocityFloor: 225,
+    /**
+     * Pages a release may travel from the page the drag started on, at any
+     * speed and drag distance.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. A drag of
+     *   1.5 pages from page 1 lands on page 2 at release speeds of 0, 600 and
+     *   3000 pt/s.
+     */
+    maxPagesFromStart: 1,
+  },
+  /**
+   * A finger that lands on a settling pager does not stop it at once. The
+   * settle runs on for about this long, then the content holds under the
+   * finger. Lifted without a move, the content settles again on the nearest
+   * page.
+   * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. After
+   *   touch-downs 60 and 160 ms into a settle, the content moved on for 82.6
+   *   and 87.5 ms (5 frames), then held.
+   */
+  catchStopMs: 85,
+  /**
+   * A horizontal pager's pan begins only for a drag within atan(1 ÷ this) of
+   * horizontal (26.6° for 2). A steeper drag goes to the vertical scroll around
+   * it. Between 26.6° and 45°, neither moves.
+   * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. A scroll
+   *   view's directional lock holds the major axis up to 25° and frees it from
+   *   30°. An inline calendar pager in a sheet pages at 20° from horizontal. At
+   *   35° and 45°, it moves neither itself nor the sheet, and it leaves 55° to
+   *   the sheet.
+   */
+  panAxisRatio: 2,
+  animatedScroll: {
+    /**
+     * `setContentOffset(_:animated:)` duration. It is the same for one page and
+     * for five, as for a page control's tap.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026.
+     *   `_contentOffsetAnimationDuration` reads 0.3, and five animated moves of
+     *   1 to 5 pages each last 0.30 s.
+     */
+    duration: 0.3,
+    /**
+     * Its curve is a sinusoidal ease-in-out: x = from + (to − from) · (1 − cos
+     * πu) ÷ 2, for u = t ÷ duration.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. The five
+     *   moves fit the sinusoid to 0.14–0.51 pt RMS, and a 2010 pt move fits to
+     *   0.20 pt. The curve easeInEaseOut (0.42, 0, 0.58, 1) misses by 7.7 pt.
+     */
+    curve: 'sineInOut',
+  },
+  /**
+   * Past the first or last page, the content follows the finger through the
+   * scroll view's rubber band (scroll.rubberBand.coefficient), with d = the
+   * page width. It returns on the integrator above.
+   * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. A pan of 90
+   *   pt past page 0 shows 42.7–45 pt, and 290 pt shows 114.3 pt. The formula
+   *   gives 44.1 and 114.2, with c 0.55 and d 402. The return replays on the
+   *   integrator to 0.16–0.33 pt RMS.
+   */
+  rubberBandDimension: 'pageWidth',
+} as const;

package/src/motion/uikit/scroll.ts

@@ -4,8 +4,8 @@
  * @file scroll.ts
  * @input Nothing; data only
  * @output Exports `scroll`, the UIScrollView constants: deceleration rates,
- *   the rubber-band coefficient, the bounce-back spring, paging and the
- *   content-touch delay
+ *   the rubber-band coefficient, the bounce-back spring and the content-touch
+ *   delay
  * @position The scroll domain of the UIKit constants table (motion/uikit);
  *   read by the motion math and components
  *
@@ -82,22 +82,6 @@ export const scroll = {
    * @measure M-S3
    */
   bounce: {duration: 0.5, bounce: 0},
-  paging: {
-    /**
-     * Deceleration rate a paging release is projected with to pick the next
-     * page.
-     * @source GUESS — UIScrollView paging behaves like a fast scroll view;
-     *   the rate it uses internally is not documented
-     * @measure M-PG1
-     */
-    projectionRate: 0.99,
-    /**
-     * The spring that carries a paging scroll view onto its page.
-     * @source GUESS — SwiftUI `.smooth` default until measured
-     * @measure M-PG1
-     */
-    snap: {duration: 0.5, bounce: 0},
-  },
   /**
    * `delaysContentTouches`: how long a scroll view holds a touch-down from
    * its content while it decides whether the touch is a scroll (no highlight