@astryxdesign/core 0.7.7 → 0.7.8-canary.0d54fd3

package/dist/motion/animator.js

@@ -4,11 +4,12 @@
  * @file animator.ts
  * @input An element, target values, and a spring, momentum curves (coast.ts)
  *   or any closed-form curve
- * @output Exports `createAnimator`: a compositor animator for translate,
- *   rotate, scale and opacity, with presentation values and velocities read
- *   from the analytic curves, velocity-preserving retargeting, freeze-in-place
- *   `stop`, completion promises, a shared clock, and UIKit's Reduced Motion
- *   substitution; plus its option, handle and transition types
+ * @output Exports `createMotionAnimator`, a compositor animator for
+ *   translate, rotate, scale and opacity, and its option, handle and
+ *   transition types. It reads presentation values and velocities from the
+ *   analytic curves. It retargets with the velocity kept, freezes in place on
+ *   `stop`, and gives completion promises, a shared clock, and UIKit's
+ *   Reduced Motion substitution.
  * @position Motion foundation (DOM). Internal to core: components use it for
  *   every touch-presentation animation; not exported from the package entry
  *
@@ -180,11 +181,13 @@
  */
 
 import { cubicBezier } from "./bezier.js";
+import { LATE_START_MS } from "./frameBlock.js";
 import { solveSpring, toSpring } from "./spring.js";
 import { registerPresentedOffset } from "./presentation.js";
 import { resolveMotion } from "./resolveMotion.js";
 import { reducedMotionCrossFade, registerReducedMotionCrossFade } from "./uikit/timing.js";
 import { planReducedMotion } from "./reducedMotionPlan.js";
+import { themeReducesMotion } from "../privateAttributes/reducedMotion.stylex.js";
 
 /**
  * A value the animator can drive.
@@ -212,7 +215,7 @@ import { planReducedMotion } from "./reducedMotionPlan.js";
  */
 
 /**
- * Options of `createAnimator`.
+ * Options of `createMotionAnimator`.
  */
 /** How `set` puts values in place. */
 
@@ -292,15 +295,20 @@ const SAMPLE_TOLERANCE = {
 /** Keyframes start on this grid (ms) and are split where the curve needs it. */
 const SAMPLE_GRID_MS = 1000 / 30;
 
-/** A curve that has not settled by then (an undamped spring) snaps. */
-const MAX_DURATION_MS = 30_000;
+/**
+ * A curve within this many sample tolerances of its target can show as at
+ * rest. A call on it then starts as one from rest does, at the browser's start.
+ */
+const REST_DISTANCE_TOLERANCES = 2;
 
 /**
- * How long a task must run on past its first call from rest before that
- * counts as a block (WebKit; startAfterBlock): two frames at 60 Hz.
+ * A curve shows as at rest only while it moves at most one `SAMPLE_TOLERANCE`
+ * a frame at this rate.
  */
-// Browser start times are frame times and a task's end a live clock, so only a block longer than a frame plus the task's own length can be told apart from that quantization.
-const LATE_START_MS = 34;
+const REST_FRAMES_PER_SECOND = 60;
+
+/** A curve that has not settled by then (an undamped spring) snaps. */
+const MAX_DURATION_MS = 30_000;
 
 /**
  * The task calls from rest are made in, shared by every call made in it
@@ -420,7 +428,7 @@ export function animatorFor(element, options = {}) {
   const key = options.pseudoElement ?? '';
   let animator = byPseudo.get(key);
   if (animator == null) {
-    animator = createAnimator(element, options);
+    animator = createMotionAnimator(element, options);
     byPseudo.set(key, animator);
   }
   return animator;
@@ -524,7 +532,7 @@ const REDUCED_TRANSITION = {
  *
  * @example
  * ```
- * const animator = createAnimator(sheet);
+ * const animator = createMotionAnimator(sheet);
  * // finger lifts at 1200 px/s heading for the detent at 0 (a component
  * // passes the spring of its motion role):
  * animator.animate({y: 0}, {spring: {response: 0.45, dampingRatio: 0.9}, velocity: {y: 1200}});
@@ -533,7 +541,7 @@ const REDUCED_TRANSITION = {
  * animator.stop(['y']);
  * ```
  */
-export function createAnimator(element, options = {}) {
+export function createMotionAnimator(element, options = {}) {
   const now = options.now ?? defaultNow;
   const frameSource = options.requestFrame ?? (typeof requestAnimationFrame === 'function' ? callback => {
     requestAnimationFrame(() => callback());
@@ -552,8 +560,9 @@ export function createAnimator(element, options = {}) {
   };
   const pseudoElement = options.pseudoElement;
   // Reduced Motion reads the person's settings and nothing else: no option
-  // overrides them (design:reduced-motion DR4).
-  const prefersReducedMotion = defaultPrefersReducedMotion;
+  // overrides them (design:reduced-motion DR4). A theme that reduces motion
+  // for everyone counts as the setting.
+  const prefersReducedMotion = () => defaultPrefersReducedMotion() || themeReducesMotion(target);
   const isCoarsePointer = defaultIsCoarsePointer;
   const resting = {
     ...IDENTITY,
@@ -737,6 +746,14 @@ export function createAnimator(element, options = {}) {
     }
     return curveAt(property, time);
   };
+
+  /**
+   * Whether a curve's tail already shows as at rest at `time`. Under a
+   * starved main thread the browser commits a call late. A call that starts
+   * at its own time then skips that far into its curve. One that starts at
+   * the commit holds an element that hardly moves.
+   */
+  const showsAtRest = (property, segment, time) => Math.abs(valueAt(property, time) - segment.target) <= REST_DISTANCE_TOLERANCES * SAMPLE_TOLERANCE[property] && Math.abs(velocityAt(property, time)) <= SAMPLE_TOLERANCE[property] * REST_FRAMES_PER_SECOND;
   const velocityAt = (property, time) => {
     const held = segments.get(property);
     if (held != null && isHeld(held)) {
@@ -1506,10 +1523,10 @@ export function createAnimator(element, options = {}) {
   // -- starting from rest ---------------------------------------------------
 
   /**
-   * A call starts from rest when nothing on the channels it drives is moving
-   * (a curve still waiting for its first frame counts as rest) and nothing
-   * pins its clock (`at`). Returns its start group, or null for an explicit
-   * start.
+   * A call starts from rest when nothing on the channels it drives moves on
+   * screen and nothing pins its clock (`at`). A curve still waiting for its
+   * first frame counts as rest, as does one whose tail already shows as at
+   * rest. Returns its start group, or null for an explicit start.
    */
   const beginGroup = (time, properties, at, start) => {
     if (target == null || typeof target.animate !== 'function') {
@@ -1538,16 +1555,18 @@ export function createAnimator(element, options = {}) {
       }
       return null;
     }
-    // A call that continues motion starts now unless it asks for the
-    // browser's start (`commit`). `presented` asks only for a call from rest:
-    // an element still moving is not at rest, so a retarget starts now, from
-    // the value and velocity on screen (spec:AST-094 FR6).
+    // A call that continues motion starts now, unless it asks for the
+    // browser's start (`commit`). `presented` asks only for a call from rest.
+    // A curve that still moves is not at rest, so a call on it starts now,
+    // from the value and velocity on screen. A tail that shows as at rest
+    // counts as rest, so a call on it waits, under `presented` for its two
+    // frames.
     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 < endOf(property, segment) && (segment.group == null || segment.group.resolved || shownSince(property, segment) != null)) {
+        if (segment != null && time < endOf(property, segment) && (segment.group == null || segment.group.resolved || shownSince(property, segment) != null) && !showsAtRest(property, segment, time)) {
           return null;
         }
       }

package/dist/motion/frameBlock.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file frameBlock.ts
+ * @input none
+ * @output LATE_START_MS
+ * @position The motion modules' shared measure of a main-thread block.
+ */
+/**
+ * How long a task must run on past a frame, or past its first call from rest,
+ * to count as a block. It is two frames at 60 Hz. Browser start times are
+ * frame times, while a task's end is on a live clock. So only a block longer
+ * than a frame plus the task's own length stands out from that quantization.
+ */
+export declare const LATE_START_MS = 34;
+//# sourceMappingURL=frameBlock.d.ts.map

package/dist/motion/frameBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameBlock.d.ts","sourceRoot":"","sources":["../../src/motion/frameBlock.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,KAAK,CAAC"}

package/dist/motion/frameBlock.js

@@ -0,0 +1,16 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file frameBlock.ts
+ * @input none
+ * @output LATE_START_MS
+ * @position The motion modules' shared measure of a main-thread block.
+ */
+
+/**
+ * How long a task must run on past a frame, or past its first call from rest,
+ * to count as a block. It is two frames at 60 Hz. Browser start times are
+ * frame times, while a task's end is on a live clock. So only a block longer
+ * than a frame plus the task's own length stands out from that quantization.
+ */
+export const LATE_START_MS = 34;

package/dist/motion/progress.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @file progress.ts
+ * @input A spring, a normalized progress, an animator's presented velocities
+ * @output Exports `progressCurve` (a spring's progress from 0 to 1 as a
+ *   MotionCurve), `mapProgress` (one curve as a function of another),
+ *   `mapRange` (the clamped linear map most companions use) and
+ *   `presentedProgressVelocity` (the progress velocity that continues what
+ *   an animator shows)
+ * @position Shared by the motion building blocks that move several channels
+ *   along one path and by companion motion (a
+ *   scrim's dim following a sheet): one velocity unit, one curve mapping and
+ *   one way to continue an interrupted motion
+ *
+ * A path is described by a normalized progress: 0 where it starts, 1 where
+ * it rests, beyond either end on a spring's overshoot. Its velocity is in
+ * progress per second; each channel's own velocity stays in the channel's
+ * units per second.
+ *
+ * An interrupted motion continues from what is on screen: the
+ * block reads the presented values and velocities from the animator at one
+ * `now` (`get`, `getVelocity`), restarts a path from those values, and starts
+ * its progress with the presented velocity projected on the path's tangent
+ * at its start, v·t / (t·t), where t = d(values)/dp. Channels are weighted
+ * into one unit first (px per unit of scale, say), so a scale and a
+ * translation count alike.
+ *
+ * A companion follows a driving curve through `mapProgress`, most often
+ * with `mapRange`: `mapProgress(sheetY, mapRange([closedY, openY], [0, dim]))`
+ * dims a scrim as a sheet rises. Played on another animator, it stays in
+ * lockstep only when it starts with its driver: pass the driver's start,
+ * `scrim.play({opacity}, {at: start})` with `start = await handle.started`
+ * (or one shared `at` for both calls); two calls from rest otherwise each
+ * start at their own commit.
+ *
+ * SYNC: When modified, update /packages/core/src/motion/progress.test.ts and
+ * /packages/core/src/motion/README.md.
+ */
+import type { Animator, MotionCurve, MotionProperty } from './animator.js';
+import { type SpringDescription } from './spring.js';
+/**
+ * The progress of `spring` from 0 to 1, starting with `velocity` (progress
+ * per second): exactly 1 once it settles within `epsilon`.
+ */
+export declare function progressCurve(spring: SpringDescription, { velocity, epsilon, }?: {
+    velocity?: number;
+    epsilon?: number;
+}): MotionCurve;
+/**
+ * The curve of `f(driver(t))`, its velocity by the chain rule: a channel
+ * following a path as its progress moves, or a companion following any
+ * driving curve (a sheet's `y` mapped onto its scrim's opacity). The driver
+ * is any MotionCurve, not only a progress from 0 to 1. A companion played on
+ * another animator starts with its driver (`{at: start}`; see the file
+ * header).
+ */
+export declare function mapProgress(driver: MotionCurve, f: (value: number) => number): MotionCurve;
+/**
+ * The linear map from `input` to `output`, held at `output`'s ends outside
+ * `input` unless `clamp` is false: what most companions are (a scrim's dim
+ * along a sheet's travel, a parallax, a dismissal's fade). Either range may
+ * run backward (`[openY, closedY]`).
+ */
+export declare function mapRange(input: readonly [number, number], output: readonly [number, number], { clamp }?: {
+    clamp?: boolean;
+}): (x: number) => number;
+/**
+ * One channel of a path: an animator property and its value at each
+ * progress.
+ */
+export interface ProgressChannel {
+    readonly property: MotionProperty;
+    /** The property's value at progress `p`. */
+    at(p: number): number;
+    /**
+     * What one unit of the property weighs in the projection, in a unit the
+     * channels share (px per unit of scale for a box `weight` px wide). 1 by
+     * default.
+     */
+    readonly weight?: number;
+}
+/**
+ * The progress velocity, per second, that continues what `animator`
+ * presents at `now` along a path that starts there: the presented velocity
+ * projected on the path's tangent at progress 0, v·t / (t·t). 0 when the
+ * path does not move any of its channels.
+ */
+export declare function presentedProgressVelocity(animator: Pick<Animator, 'getVelocity'>, channels: ReadonlyArray<ProgressChannel>, now?: number): number;
+//# sourceMappingURL=progress.d.ts.map

package/dist/motion/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/motion/progress.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAC,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAC,MAAM,YAAY,CAAC;AACtE,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,UAAU,CAAC;AAKlB;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,iBAAiB,EACzB,EACE,QAAY,EACZ,OAA0B,GAC3B,GAAE;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAM,GAC5C,WAAW,CAQb;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,WAAW,EACnB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAC3B,WAAW,CAWb;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,EAAC,KAAY,EAAC,GAAE;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAM,GACrC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAWvB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,4CAA4C;IAC5C,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,EACvC,QAAQ,EAAE,aAAa,CAAC,eAAe,CAAC,EACxC,GAAG,CAAC,EAAE,MAAM,GACX,MAAM,CAUR"}

package/dist/motion/progress.js

@@ -0,0 +1,128 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file progress.ts
+ * @input A spring, a normalized progress, an animator's presented velocities
+ * @output Exports `progressCurve` (a spring's progress from 0 to 1 as a
+ *   MotionCurve), `mapProgress` (one curve as a function of another),
+ *   `mapRange` (the clamped linear map most companions use) and
+ *   `presentedProgressVelocity` (the progress velocity that continues what
+ *   an animator shows)
+ * @position Shared by the motion building blocks that move several channels
+ *   along one path and by companion motion (a
+ *   scrim's dim following a sheet): one velocity unit, one curve mapping and
+ *   one way to continue an interrupted motion
+ *
+ * A path is described by a normalized progress: 0 where it starts, 1 where
+ * it rests, beyond either end on a spring's overshoot. Its velocity is in
+ * progress per second; each channel's own velocity stays in the channel's
+ * units per second.
+ *
+ * An interrupted motion continues from what is on screen: the
+ * block reads the presented values and velocities from the animator at one
+ * `now` (`get`, `getVelocity`), restarts a path from those values, and starts
+ * its progress with the presented velocity projected on the path's tangent
+ * at its start, v·t / (t·t), where t = d(values)/dp. Channels are weighted
+ * into one unit first (px per unit of scale, say), so a scale and a
+ * translation count alike.
+ *
+ * A companion follows a driving curve through `mapProgress`, most often
+ * with `mapRange`: `mapProgress(sheetY, mapRange([closedY, openY], [0, dim]))`
+ * dims a scrim as a sheet rises. Played on another animator, it stays in
+ * lockstep only when it starts with its driver: pass the driver's start,
+ * `scrim.play({opacity}, {at: start})` with `start = await handle.started`
+ * (or one shared `at` for both calls); two calls from rest otherwise each
+ * start at their own commit.
+ *
+ * SYNC: When modified, update /packages/core/src/motion/progress.test.ts and
+ * /packages/core/src/motion/README.md.
+ */
+
+import { SETTLING_EPSILON, solveSpring, toSpring } from "./spring.js";
+
+/** The step of the finite differences taken on a progress. */
+const STEP = 1e-4;
+
+/**
+ * The progress of `spring` from 0 to 1, starting with `velocity` (progress
+ * per second): exactly 1 once it settles within `epsilon`.
+ */
+export function progressCurve(spring, {
+  velocity = 0,
+  epsilon = SETTLING_EPSILON
+} = {}) {
+  const curve = solveSpring(toSpring(spring), {
+    from: 0,
+    to: 1,
+    velocity
+  });
+  const duration = curve.settleTime(epsilon);
+  return {
+    duration,
+    at: t => t >= duration ? 1 : curve.value(t),
+    velocity: t => t >= duration ? 0 : curve.velocity(t)
+  };
+}
+
+/**
+ * The curve of `f(driver(t))`, its velocity by the chain rule: a channel
+ * following a path as its progress moves, or a companion following any
+ * driving curve (a sheet's `y` mapped onto its scrim's opacity). The driver
+ * is any MotionCurve, not only a progress from 0 to 1. A companion played on
+ * another animator starts with its driver (`{at: start}`; see the file
+ * header).
+ */
+export function mapProgress(driver, f) {
+  return {
+    duration: driver.duration,
+    at: t => f(driver.at(t)),
+    velocity: t => {
+      const value = driver.at(t);
+      return (f(value + STEP) - f(value - STEP)) / (2 * STEP) * driver.velocity(t);
+    }
+  };
+}
+
+/**
+ * The linear map from `input` to `output`, held at `output`'s ends outside
+ * `input` unless `clamp` is false: what most companions are (a scrim's dim
+ * along a sheet's travel, a parallax, a dismissal's fade). Either range may
+ * run backward (`[openY, closedY]`).
+ */
+export function mapRange(input, output, {
+  clamp = true
+} = {}) {
+  const [a, b] = input;
+  const [c, d] = output;
+  return x => {
+    let t = a === b ? x < a ? 0 : 1 : (x - a) / (b - a);
+    if (clamp) {
+      t = Math.min(1, Math.max(0, t));
+    }
+    // Exact at both ends.
+    return t === 0 ? c : t === 1 ? d : c + (d - c) * t;
+  };
+}
+
+/**
+ * One channel of a path: an animator property and its value at each
+ * progress.
+ */
+
+/**
+ * The progress velocity, per second, that continues what `animator`
+ * presents at `now` along a path that starts there: the presented velocity
+ * projected on the path's tangent at progress 0, v·t / (t·t). 0 when the
+ * path does not move any of its channels.
+ */
+export function presentedProgressVelocity(animator, channels, now) {
+  let along = 0;
+  let squared = 0;
+  for (const channel of channels) {
+    const weight = channel.weight ?? 1;
+    const tangent = (channel.at(STEP) - channel.at(0)) / STEP * weight;
+    along += animator.getVelocity(channel.property, now) * weight * tangent;
+    squared += tangent * tangent;
+  }
+  return squared > 1e-12 ? along / squared : 0;
+}

package/dist/motion/reducedMotion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reducedMotion.d.ts","sourceRoot":"","sources":["../../src/motion/reducedMotion.ts"],"names":[],"mappings":"AAqDA,6EAA6E;AAC7E,eAAO,MAAM,yBAAyB,2DACoB,CAAC;AAE3D,gFAAgF;AAChF,eAAO,MAAM,4BAA4B,iEACuB,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,EACxB,OAAO,GAAE;IACP,gEAAgE;IAChE,YAAY,CAAC,EAAE,OAAO,CAAC;CACnB,GACL,iBAAiB,GAAG,IAAI,CAmB1B;AAED,oCAAoC;AACpC,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,MAAM,IAAI,EAChB,IAAI,SAAI,GACP,gBAAgB,CAyClB"}
+{"version":3,"file":"reducedMotion.d.ts","sourceRoot":"","sources":["../../src/motion/reducedMotion.ts"],"names":[],"mappings":"AAsDA,6EAA6E;AAC7E,eAAO,MAAM,yBAAyB,2DACoB,CAAC;AAE3D,gFAAgF;AAChF,eAAO,MAAM,4BAA4B,iEACuB,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,EACxB,OAAO,GAAE;IACP,gEAAgE;IAChE,YAAY,CAAC,EAAE,OAAO,CAAC;CACnB,GACL,iBAAiB,GAAG,IAAI,CAoB1B;AAED,oCAAoC;AACpC,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,MAAM,IAAI,EAChB,IAAI,SAAI,GACP,gBAAgB,CAyClB"}

package/dist/motion/reducedMotion.js

@@ -46,6 +46,7 @@
 
 import { defaultIsCoarsePointer, defaultPrefersReducedMotion } from "./animator.js";
 import { resolveMotion } from "./resolveMotion.js";
+import { themeReducesMotion } from "../privateAttributes/reducedMotion.stylex.js";
 import { reducedMotionCrossFade, registerReducedMotionCrossFade } from "./uikit/timing.js";
 
 /** Reduce Motion on a coarse primary pointer: an opacity-only cross-fade. */
@@ -68,7 +69,8 @@ export const REDUCED_MOTION_INSTANT_QUERY = '(prefers-reduced-motion: reduce) an
  * the length is fixed.
  */
 export function reducedMotionFade(element, options = {}) {
-  if (!defaultPrefersReducedMotion()) {
+  // A theme that reduces motion for everyone counts as the setting.
+  if (!defaultPrefersReducedMotion() && !themeReducesMotion(element)) {
     return null;
   }
   const fades = options.touchRelease === true || defaultIsCoarsePointer();

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

@@ -0,0 +1,41 @@
+/**
+ * @file alert.ts
+ * @input Nothing; data only
+ * @output Exports `alertController`: how UIAlertController (`.alert`) tracks
+ *   a finger across its actions
+ * @position The alert domain of the UIKit constants table (motion/uikit);
+ *   its springs are `springs.alertPresent` and `springs.alertDismiss`
+ *
+ * Every value was read from UIKit on the iOS 26.2 simulator. A host app
+ * presented `UIAlertController(.alert)` with two and with three actions.
+ * Real HID touches drove it, and the action views' highlight was sampled
+ * every frame. Lengths are in pt (CSS px), durations in ms.
+ *
+ * Every leaf carries one or more `@source`; GUESS values also carry the
+ * `@measure` task that will confirm or replace them. uikit.test.ts enforces
+ * both.
+ *
+ * SYNC: When modified, update /packages/core/src/motion/MEASUREMENTS.md
+ */
+export declare const alertController: {
+    readonly actions: {
+        /**
+         * How long after touch-down the touched action highlights: none, it is
+         * highlighted in the touch-down frame (a tap and a 300 ms hold alike).
+         * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+         *   iPhone 17 Pro, per-frame highlight of the action views under real HID
+         *   touches, Oct 23 2026
+         */
+        readonly highlightOnsetMs: 0;
+        /**
+         * How far outside an action the finger may go and keep it highlighted:
+         * none. The highlight cleared 1 pt below the action, and a lift there ran
+         * nothing. UIButton keeps 70 pt; an alert action does not.
+         * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+         *   iPhone 17 Pro, per-frame highlight of the action views under real HID
+         *   touches, Oct 23 2026
+         */
+        readonly highlightExpansion: 0;
+    };
+};
+//# sourceMappingURL=alert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alert.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/alert.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,eAAe;;QAExB;;;;;;WAMG;;QAEH;;;;;;;WAOG;;;CAGG,CAAC"}

package/dist/motion/uikit/alert.js

@@ -0,0 +1,43 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file alert.ts
+ * @input Nothing; data only
+ * @output Exports `alertController`: how UIAlertController (`.alert`) tracks
+ *   a finger across its actions
+ * @position The alert domain of the UIKit constants table (motion/uikit);
+ *   its springs are `springs.alertPresent` and `springs.alertDismiss`
+ *
+ * Every value was read from UIKit on the iOS 26.2 simulator. A host app
+ * presented `UIAlertController(.alert)` with two and with three actions.
+ * Real HID touches drove it, and the action views' highlight was sampled
+ * every frame. Lengths are in pt (CSS px), durations in ms.
+ *
+ * Every leaf carries one or more `@source`; GUESS values also carry the
+ * `@measure` task that will confirm or replace them. uikit.test.ts enforces
+ * both.
+ *
+ * SYNC: When modified, update /packages/core/src/motion/MEASUREMENTS.md
+ */
+
+export const alertController = {
+  actions: {
+    /**
+     * How long after touch-down the touched action highlights: none, it is
+     * highlighted in the touch-down frame (a tap and a 300 ms hold alike).
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, per-frame highlight of the action views under real HID
+     *   touches, Oct 23 2026
+     */
+    highlightOnsetMs: 0,
+    /**
+     * How far outside an action the finger may go and keep it highlighted:
+     * none. The highlight cleared 1 pt below the action, and a lift there ran
+     * nothing. UIButton keeps 70 pt; an alert action does not.
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, per-frame highlight of the action views under real HID
+     *   touches, Oct 23 2026
+     */
+    highlightExpansion: 0
+  }
+};

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`, `progressBar`, `segmentedControl`,
- *   the `slider` and switch (`switchControl`) domains, and the gesture
- *   thresholds (one `UIKIT_*` group per recognizer, their union
+ *   …), `scroll`, `timing`, `navigation`, `picker`, `progressBar`,
+ *   `segmentedControl`, the `slider` and switch (`switchControl`) domains, 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
@@ -19,6 +19,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 { picker } from './picker.js';
 export { progressBar, registerProgressBarTable } from './progressBar.js';
 export { registerScrollTable, scroll } from './scroll.js';
 export { segmentedControl } from './segmented.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;;;;;;;;;;;;;;;;;;GAkBG;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,gBAAgB,EAAC,MAAM,aAAa,CAAC;AAC7C,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,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AACvC,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;;;;;;;;;;;;;;;;;;GAkBG;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,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EAAC,WAAW,EAAE,wBAAwB,EAAC,MAAM,eAAe,CAAC;AACpE,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC;AACrD,OAAO,EAAC,gBAAgB,EAAC,MAAM,aAAa,CAAC;AAC7C,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,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AACvC,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`, `progressBar`, `segmentedControl`,
- *   the `slider` and switch (`switchControl`) domains, and the gesture
- *   thresholds (one `UIKIT_*` group per recognizer, their union
+ *   …), `scroll`, `timing`, `navigation`, `picker`, `progressBar`,
+ *   `segmentedControl`, the `slider` and switch (`switchControl`) domains, 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
@@ -22,6 +22,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 { picker } from "./picker.js";
 export { progressBar, registerProgressBarTable } from "./progressBar.js";
 export { registerScrollTable, scroll } from "./scroll.js";
 export { segmentedControl } from "./segmented.js";