@astryxdesign/core 0.7.6 → 0.7.7-canary.240e8c5

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/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/slider.ts

@@ -0,0 +1,105 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file slider.ts
+ * @input Nothing: data only
+ * @output Exports `slider`: UISlider's hit target, tracking rule, release
+ *   coast, lift, drop and end haptic, measured on the iOS 26.2 simulator
+ * @position The slider domain of the UIKit constants table (motion/uikit).
+ *   Lengths are in pt (CSS px). Tests check each leaf's `@source`.
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/Slider/sliderTouchController.ts
+ * - /packages/core/src/Slider/Slider.tsx
+ * - /packages/core/src/motion/uikit/slider.test.ts
+ */
+
+import {SLIDER_RELEASE_SPRING} from './springs';
+
+/**
+ * UISlider's touch values: hit target, tracking, release coast, lift, drop
+ * and the end-of-track haptic.
+ */
+export const slider = {
+  /**
+   * The thumb's touch target, a square in pt centered on the thumb. It is
+   * the 37 × 24 pt thumb grown by its hit edge insets: 12 pt above and
+   * below, 5.5 pt left and right. UIKit hit-tests inside the control's frame
+   * first, so the lab's 40 pt frame clipped it to 48 × 40.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro.
+   *   `_thumbHitEdgeInsets` reads {−12, −5.5, −12, −5.5}. Touch-downs on a
+   *   4 pt grid take the thumb from −24 to +20 pt in x. A track tap away
+   *   from the thumb moves nothing. Oct 23 2026
+   */
+  thumbHitTarget: 48,
+  /**
+   * Value range per track length of finger travel. The value moves by
+   * (max − min) × translation ÷ the track's full length. The translation
+   * counts from the pan's threshold: the touch-down point plus 10 pt along
+   * the track. 1 means one full range per track length.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. In
+   *   drags at 120 to 2000 pt/s, each event's value is v0 plus the
+   *   translation past 10 pt ÷ 300. Past the max end, the value leaves 1
+   *   only once the finger comes back past where it reached 1. Oct 23 2026
+   */
+  trackingGain: 1,
+  /**
+   * The coast after the lift. The thumb and the value spring from where the
+   * finger left them to the projected target, with the release velocity.
+   * Critically damped, it never overshoots a target ahead of it.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+   *   `UIViewSpringAnimationBehavior` at the lift reads response 0.4 and
+   *   damping ratio 1. Four releases fit it per frame, at rms 0.11 pt or
+   *   less. Oct 23 2026
+   */
+  releaseSpring: SLIDER_RELEASE_SPRING,
+  /**
+   * The deceleration rate of the coast's momentum projection, per ms
+   * (WWDC18's `project`). It is not UIScrollView's normal rate (0.998), so
+   * pass it to the projection explicitly.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+   *   release behavior's projection deceleration reads 0.996. Oct 23 2026
+   */
+  releaseProjectionRate: 0.996,
+  /**
+   * How much of the projection the coast travels. The target is the lift
+   * value plus this share of the projected distance. A finger lifted outside
+   * the control's tracking bounds coasts back to the lift value instead.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+   *   release behavior's target smoothing reads 0.4. A 126.9 pt/s release
+   *   travels 12.56 pt, against 12.64 predicted. Oct 23 2026
+   */
+  releaseProjectionShare: 0.4,
+  /**
+   * The thumb's growth under a finger, uniform about its center (37 × 24 to
+   * 57.35 × 37.2 pt).
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The lens
+   *   frame settled during an 800 ms hold. Oct 23 2026
+   */
+  liftScale: 1.55,
+  /**
+   * The lift: the thumb grows to `liftScale` when the finger lands.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The lens
+   *   width per frame in an 800 ms hold fits one spring at rms 0.31 pt.
+   *   Oct 23 2026
+   */
+  liftSpring: {response: 0.215, dampingRatio: 0.6},
+  /**
+   * The drop: the thumb shrinks back to its rest size when the finger lifts,
+   * while the coast runs.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+   *   lens's spring at the lift of an 800 ms hold reads response 0.5 s and
+   *   damping ratio 0.7. The width per frame fits it at rms 0.10 pt.
+   *   Oct 23 2026
+   */
+  dropSpring: {response: 0.5, dampingRatio: 0.7},
+  /**
+   * The feedback each time the value reaches an end, once per entry. It
+   * re-arms when the value leaves the end, in the drag and the coast. UIKit
+   * plays "Micro Tap Medium", and the web stand-in is the closest kind.
+   * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+   *   haptics log of drags into both ends shows the fluid slider generator's
+   *   "Micro Tap Medium" once per entry. Oct 23 2026
+   */
+  endHaptic: 'impactMedium',
+} as const;

package/src/motion/uikit/springs.ts

@@ -454,6 +454,33 @@ export const KEYBOARD_SPRING = {
  */
 export const BANNER_SPRING = {mass: 3, stiffness: 1000, damping: 500} as const;
 
+/**
+ * UISlider's release: after a finger lifts, the thumb settles on this spring
+ * toward 0.4 of the release's momentum projection. It is critically damped,
+ * so it never overshoots a target ahead of it.
+ * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+ *   `UIViewSpringAnimationBehavior` at the lift reads response 0.4 and
+ *   damping ratio 1. Four releases fit it per frame (the UIKit slider
+ *   table). Oct 23 2026
+ */
+export const SLIDER_RELEASE_SPRING = {response: 0.4, dampingRatio: 1} as const;
+
+/**
+ * UISlider's lift: a finger's touch-down scales the thumb up on this spring.
+ * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+ *   thumb's scale per frame after touch-down (the UIKit slider table).
+ *   Oct 23 2026
+ */
+export const SLIDER_LIFT_SPRING = {response: 0.215, dampingRatio: 0.6} as const;
+
+/**
+ * UISlider's drop: the lift's end scales the thumb back down on this spring.
+ * @source measured: UIKit lab, iOS 26.2 simulator, iPhone 17 Pro. The
+ *   thumb's scale per frame after the lift (the UIKit slider table).
+ *   Oct 23 2026
+ */
+export const SLIDER_DROP_SPRING = {response: 0.5, dampingRatio: 0.7} as const;
+
 /**
  * Every spring above, by row name: the table the existing readers use. A
  * component imports only the rows it plays (`architecture:component-style-authoring`
@@ -494,10 +521,15 @@ export const springs = {
   segmentedThumb: SEGMENTED_THUMB_SPRING,
   keyboard: KEYBOARD_SPRING,
   banner: BANNER_SPRING,
+  sliderRelease: SLIDER_RELEASE_SPRING,
+  sliderLift: SLIDER_LIFT_SPRING,
+  sliderDrop: SLIDER_DROP_SPRING,
 } as const;
 
 /**
- * The springs spec:AST-094 FR4 names: the only ones that are motion roles.
+ * The only springs that are motion roles. The touch presentations' record
+ * names some, and a component's own record names others, such as Slider's
+ * three. The generated motion role table lists each with its record.
  * The registry takes these rows alone, so registering ships no other spring.
  */
 const SPRING_ROLES = {
@@ -516,10 +548,13 @@ const SPRING_ROLES = {
   contextMenuLift: CONTEXT_MENU_LIFT_SPRING,
   contextMenuDismiss: CONTEXT_MENU_DISMISS_SPRING,
   contextMenuMorph: CONTEXT_MENU_MORPH_SPRING,
+  sliderRelease: SLIDER_RELEASE_SPRING,
+  sliderLift: SLIDER_LIFT_SPRING,
+  sliderDrop: SLIDER_DROP_SPRING,
 };
 
 /**
- * Registers the springs spec:AST-094 FR4 names as internal motion roles
+ * Registers the role springs (`SPRING_ROLES`) as internal motion roles
  * (motion/roles.ts), by their row names (`springs.settle`). Every other
  * spring, UIKit's menu spring under Reduce Motion and the keyboard's
  * included, is not a role. Nothing registers on import: the touch code that