@astryxdesign/core 0.7.7-canary.36f8ea1 → 0.7.7-canary.550ff21

package/dist/motion/paging.js

@@ -0,0 +1,128 @@
+// 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 { paging } from "./uikit/paging.js";
+
+/**
+ * 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) {
+  return Math.abs(velocity) < paging.release.velocityFloor ? 0 : velocity;
+}
+
+/** A paging settle: the curve and where it ends. */
+
+/**
+ * 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
+}) {
+  const {
+    springPull,
+    friction,
+    stepsPerSecond,
+    restDistance,
+    restSpeed
+  } = paging.integrator;
+  const xs = [from];
+  const vs = [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, t) => {
+    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
+}) {
+  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/dist/motion/uikit/index.d.ts

@@ -2,9 +2,9 @@
  * @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`, the `slider` domain and the
- *   gesture thresholds (one `UIKIT_*` group per recognizer, their union
- *   `UIKIT_GESTURES`, and the haptic tables)
+ *   …), `scroll`, `timing`, `navigation`, `progressBar`, 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
  *   core: not exported from the package entry point
  *
@@ -18,6 +18,7 @@
  */
 export { HAPTIC_FEEDBACK_KINDS, HAPTIC_VIBRATION_PATTERNS, UIKIT_CLICK, UIKIT_CONTROL, UIKIT_GESTURES, UIKIT_LONG_PRESS, UIKIT_PAN, UIKIT_PINCH, UIKIT_PRESS, UIKIT_ROTATION, UIKIT_SCREEN_EDGE_PAN, UIKIT_SWIPE, UIKIT_TAP, UIKIT_VELOCITY, type GestureConstant, type GestureConstantUnit, type HapticFeedbackKind, } from './gestures.js';
 export { navigation, registerNavigationTable } from './navigation.js';
+export { progressBar, registerProgressBarTable } from './progressBar.js';
 export { registerScrollTable, scroll } from './scroll.js';
 export { slider } from './slider.js';
 export { ACTION_SHEET_DISMISS_SPRING, ACTION_SHEET_PRESENT_SPRING, ALERT_DISMISS_SPRING, ALERT_PRESENT_SPRING, BANNER_SPRING, CONTEXT_MENU_DISMISS_SPRING, CONTEXT_MENU_LIFT_SPRING, CONTEXT_MENU_MORPH_SPRING, DIRECT_CHANGE_SPRING, EMPHASIS_SPRING, FINGER_TRACKING_SPRING, KEYBOARD_SPRING, MENU_CLOSE_SPRING, MENU_OPEN_SPRING, MENU_REDUCED_MOTION_SPRING, NAVIGATION_BAR_ELEMENTS_SPRING, NAVIGATION_INTERACTIVE_POP_FINISH_SPRING, NAVIGATION_POP_SPRING, NAVIGATION_PUSH_SPRING, QUICK_CHANGE_SPRING, SEGMENTED_THUMB_SPRING, SETTLE_SPRING, SHEET_DETENT_SPRING, SHEET_DISMISS_SPRING, SHEET_DISMISS_SWIPE_SPRING, SHEET_PRESENT_SPRING, SHEET_RELEASE_FAST_SPRING, STATE_CHANGE_SPRING, SUB_MENU_BACK_SPRING, SUB_MENU_OPEN_SPRING, SWITCH_THUMB_MOVE_SPRING, SWITCH_THUMB_STRETCH_SPRING, TIMED_CHANGE_SPRING, VIEW_CHANGE_SPRING, registerSpringsTable, springs, } from './springs.js';

package/dist/motion/uikit/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,WAAW,EACX,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,WAAW,EACX,WAAW,EACX,cAAc,EACd,qBAAqB,EACrB,WAAW,EACX,SAAS,EACT,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,UAAU,EAAE,uBAAuB,EAAC,MAAM,cAAc,CAAC;AACjE,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC;AACrD,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,0BAA0B,EAC1B,8BAA8B,EAC9B,wCAAwC,EACxC,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,WAAW,EACX,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,WAAW,EACX,WAAW,EACX,cAAc,EACd,qBAAqB,EACrB,WAAW,EACX,SAAS,EACT,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,UAAU,EAAE,uBAAuB,EAAC,MAAM,cAAc,CAAC;AACjE,OAAO,EAAC,WAAW,EAAE,wBAAwB,EAAC,MAAM,eAAe,CAAC;AACpE,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC;AACrD,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,0BAA0B,EAC1B,8BAA8B,EAC9B,wCAAwC,EACxC,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC"}

package/dist/motion/uikit/index.js

@@ -4,9 +4,9 @@
  * @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`, the `slider` domain and the
- *   gesture thresholds (one `UIKIT_*` group per recognizer, their union
- *   `UIKIT_GESTURES`, and the haptic tables)
+ *   …), `scroll`, `timing`, `navigation`, `progressBar`, 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
  *   core: not exported from the package entry point
  *
@@ -21,6 +21,7 @@
 
 export { HAPTIC_FEEDBACK_KINDS, HAPTIC_VIBRATION_PATTERNS, UIKIT_CLICK, UIKIT_CONTROL, UIKIT_GESTURES, UIKIT_LONG_PRESS, UIKIT_PAN, UIKIT_PINCH, UIKIT_PRESS, UIKIT_ROTATION, UIKIT_SCREEN_EDGE_PAN, UIKIT_SWIPE, UIKIT_TAP, UIKIT_VELOCITY } from "./gestures.js";
 export { navigation, registerNavigationTable } from "./navigation.js";
+export { progressBar, registerProgressBarTable } from "./progressBar.js";
 export { registerScrollTable, scroll } from "./scroll.js";
 export { slider } from "./slider.js";
 export { ACTION_SHEET_DISMISS_SPRING, ACTION_SHEET_PRESENT_SPRING, ALERT_DISMISS_SPRING, ALERT_PRESENT_SPRING, BANNER_SPRING, CONTEXT_MENU_DISMISS_SPRING, CONTEXT_MENU_LIFT_SPRING, CONTEXT_MENU_MORPH_SPRING, DIRECT_CHANGE_SPRING, EMPHASIS_SPRING, FINGER_TRACKING_SPRING, KEYBOARD_SPRING, MENU_CLOSE_SPRING, MENU_OPEN_SPRING, MENU_REDUCED_MOTION_SPRING, NAVIGATION_BAR_ELEMENTS_SPRING, NAVIGATION_INTERACTIVE_POP_FINISH_SPRING, NAVIGATION_POP_SPRING, NAVIGATION_PUSH_SPRING, QUICK_CHANGE_SPRING, SEGMENTED_THUMB_SPRING, SETTLE_SPRING, SHEET_DETENT_SPRING, SHEET_DISMISS_SPRING, SHEET_DISMISS_SWIPE_SPRING, SHEET_PRESENT_SPRING, SHEET_RELEASE_FAST_SPRING, STATE_CHANGE_SPRING, SUB_MENU_BACK_SPRING, SUB_MENU_OPEN_SPRING, SWITCH_THUMB_MOVE_SPRING, SWITCH_THUMB_STRETCH_SPRING, TIMED_CHANGE_SPRING, VIEW_CHANGE_SPRING, registerSpringsTable, springs } from "./springs.js";

package/dist/motion/uikit/paging.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @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 declare 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.
+     */
+    readonly 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.
+         */
+        readonly 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.
+         */
+        readonly 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.
+         */
+        readonly 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.
+         */
+        readonly 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
+         */
+        readonly restSpeed: 0.05;
+    };
+    readonly 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.
+         */
+        readonly 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.
+         */
+        readonly 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
+         */
+        readonly 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.
+         */
+        readonly 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.
+     */
+    readonly 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.
+     */
+    readonly panAxisRatio: 2;
+    readonly 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.
+         */
+        readonly 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.
+         */
+        readonly 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.
+     */
+    readonly rubberBandDimension: "pageWidth";
+};
+//# sourceMappingURL=paging.d.ts.map

package/dist/motion/uikit/paging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/paging.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,MAAM;IACjB;;;;;;;;;;;OAWG;;QAED;;;;;;;WAOG;;QAEH;;;;;;WAMG;;QAEH;;;;;;WAMG;;QAEH;;;;;;WAMG;;QAEH;;;;;WAKG;;;;QAIH;;;;;;;WAOG;;QAEH;;;;;;;;;;;WAWG;;QAEH;;;;;;;;;WASG;;QAEH;;;;;;WAMG;;;IAGL;;;;;;;;OAQG;;IAEH;;;;;;;;;OASG;;;QAGD;;;;;;WAMG;;QAEH;;;;;;WAMG;;;IAGL;;;;;;;;OAQG;;CAEK,CAAC"}

package/dist/motion/uikit/paging.js

@@ -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'
+};

package/dist/motion/uikit/progressBar.d.ts

@@ -0,0 +1,59 @@
+/**
+ * UIProgressView's values, for ProgressBar. Two values are motion roles in the
+ * generated motion role table: the whole-track duration,
+ * `progress.fillTrackMs`, and its curve, `progress.curves.fill`. Every other
+ * value is an internal constant.
+ */
+export declare const progressBar: {
+    /**
+     * setProgress(_:animated: true) runs this long for a change of the whole
+     * track (0 → 1). A smaller change runs in proportion, measured on the model
+     * values: 0.2 → 0.8 takes 0.6 s. A retargeted fill starts from wherever it
+     * is drawn.
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, UIView animation on the fill's frame (duration,
+     *   beginFromCurrentState) for jumps of 0.6, 0.4 and 0.6, Oct 23 2026
+     */
+    readonly fillTrackMs: 1000;
+    readonly curves: {
+        /**
+         * That animation's curve: linear, and Reduce Motion leaves it unchanged.
+         * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+         *   iPhone 17 Pro, the fill's position animation (timing function
+         *   linear), with Reduce Motion off and on, Oct 23 2026
+         */
+        readonly fill: readonly [0, 0, 1, 1];
+    };
+    readonly progressView: {
+        /**
+         * The track's height in the `.default` style; the fill is as tall.
+         * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+         *   iPhone 17 Pro, intrinsic size of UIProgressView(progressViewStyle:
+         *   .default), Oct 23 2026
+         */
+        readonly heightPt: 4;
+        /**
+         * Above zero progress, the fill is never narrower than this many track
+         * heights: 8 pt on the 4 pt track. At 0.005 of a 300 pt track it is 8 pt
+         * wide; at 0.05 it is 15 pt.
+         * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+         *   iPhone 17 Pro, the fill image view's frame at progress 0, 0.005,
+         *   0.01, 0.05, 0.5 and 1, Oct 23 2026
+         */
+        readonly minimumFillHeights: 2;
+        /**
+         * At progress 0 the fill is transparent (alpha 0, still at its minimum
+         * width).
+         * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+         *   iPhone 17 Pro, the fill image view's alpha at progress 0, Oct 23 2026
+         */
+        readonly emptyFillAlpha: 0;
+    };
+};
+/**
+ * Registers the table's two roles, for the generated motion role table and its
+ * test, which call it. Nothing at runtime reads the registry: `resolveMotion`
+ * returns the table value. Idempotent, and nothing runs on import.
+ */
+export declare function registerProgressBarTable(): void;
+//# sourceMappingURL=progressBar.d.ts.map

package/dist/motion/uikit/progressBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressBar.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/progressBar.ts"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;;;OAQG;;;QAGD;;;;;WAKG;;;;QAIH;;;;;WAKG;;QAEH;;;;;;;WAOG;;QAEH;;;;;WAKG;;;CAGG,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C"}

package/dist/motion/uikit/progressBar.js

@@ -0,0 +1,82 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file progressBar.ts
+ * @input Nothing: data only
+ * @output Exports `progressBar` (UIProgressView's fill: the whole-track
+ *   duration and curve, its minimum length and its empty alpha) and
+ *   `registerProgressBarTable`
+ * @position ProgressBar's rows of the UIKit constants table (motion/uikit).
+ *   Lengths are in pt (CSS px), durations in ms, alphas in 0..1. Tests check
+ *   each leaf's `@source`.
+ *
+ * SYNC: When modified, update
+ * /packages/core/src/ProgressBar/ProgressBarTouch.ts and
+ * /packages/core/src/ProgressBar/ProgressBar.test.tsx.
+ */
+
+import { registerMotionTable } from "../roles.js";
+
+/**
+ * UIProgressView's values, for ProgressBar. Two values are motion roles in the
+ * generated motion role table: the whole-track duration,
+ * `progress.fillTrackMs`, and its curve, `progress.curves.fill`. Every other
+ * value is an internal constant.
+ */
+export const progressBar = {
+  /**
+   * setProgress(_:animated: true) runs this long for a change of the whole
+   * track (0 → 1). A smaller change runs in proportion, measured on the model
+   * values: 0.2 → 0.8 takes 0.6 s. A retargeted fill starts from wherever it
+   * is drawn.
+   * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+   *   iPhone 17 Pro, UIView animation on the fill's frame (duration,
+   *   beginFromCurrentState) for jumps of 0.6, 0.4 and 0.6, Oct 23 2026
+   */
+  fillTrackMs: 1000,
+  curves: {
+    /**
+     * That animation's curve: linear, and Reduce Motion leaves it unchanged.
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, the fill's position animation (timing function
+     *   linear), with Reduce Motion off and on, Oct 23 2026
+     */
+    fill: [0, 0, 1, 1]
+  },
+  progressView: {
+    /**
+     * The track's height in the `.default` style; the fill is as tall.
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, intrinsic size of UIProgressView(progressViewStyle:
+     *   .default), Oct 23 2026
+     */
+    heightPt: 4,
+    /**
+     * Above zero progress, the fill is never narrower than this many track
+     * heights: 8 pt on the 4 pt track. At 0.005 of a 300 pt track it is 8 pt
+     * wide; at 0.05 it is 15 pt.
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, the fill image view's frame at progress 0, 0.005,
+     *   0.01, 0.05, 0.5 and 1, Oct 23 2026
+     */
+    minimumFillHeights: 2,
+    /**
+     * At progress 0 the fill is transparent (alpha 0, still at its minimum
+     * width).
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, the fill image view's alpha at progress 0, Oct 23 2026
+     */
+    emptyFillAlpha: 0
+  }
+};
+
+/**
+ * Registers the table's two roles, for the generated motion role table and its
+ * test, which call it. Nothing at runtime reads the registry: `resolveMotion`
+ * returns the table value. Idempotent, and nothing runs on import.
+ */
+export function registerProgressBarTable() {
+  registerMotionTable('progress', progressBar, {
+    roles: ['fillTrackMs', 'curves.fill']
+  });
+}