@astryxdesign/core 0.7.6 → 0.7.7-canary.36f8ea1

package/dist/motion/animator.js

@@ -668,26 +668,49 @@ export function createAnimator(element, options = {}) {
   };
 
   /**
-   * 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, latest) => latest == null || segment.group == null ? null : {
+    latest,
+    start: segment.start + latest - segment.group.provisional
+  };
+
+  /**
+   * 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, time) => {
     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);
   };
   const velocityAt = (property, time) => {
     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) {
@@ -860,6 +883,30 @@ export function createAnimator(element, options = {}) {
       }
     }
     const moving = properties.filter(p => segments.has(p));
+    // 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).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();
+    if (rebuiltAfterFirstFrame) {
+      restarted.add(waiting);
+    }
+    if (callGroup != null) {
+      for (const property of moving) {
+        const group = segments.get(property).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.
@@ -887,10 +934,6 @@ export function createAnimator(element, options = {}) {
       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).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.
@@ -996,6 +1039,15 @@ export function createAnimator(element, options = {}) {
       waiting.channels.add(channel);
       // A cancel before the first frame rejects its ready promise.
       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;
@@ -1614,6 +1666,17 @@ export function createAnimator(element, options = {}) {
       if (!group.resolved && group.madeInFrame !== true && now() - (group.task?.first ?? group.provisional) <= LATE_START_MS && group.animations.some(animation => animation.startTime == null && animation.playState === 'running')) {
         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), () => settleCancelled(group));
   };

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

@@ -2,7 +2,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
@@ -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 { 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';
 export { registerTimingTable, timing } from './timing.js';
 //# sourceMappingURL=index.d.ts.map

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,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,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,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
@@ -22,5 +22,6 @@
 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 { 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";
 export { registerTimingTable, timing } from "./timing.js";

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

@@ -0,0 +1,97 @@
+/**
+ * UISlider's touch values: hit target, tracking, release coast, lift, drop
+ * and the end-of-track haptic.
+ */
+export declare 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
+     */
+    readonly 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
+     */
+    readonly 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
+     */
+    readonly releaseSpring: {
+        readonly response: 0.4;
+        readonly dampingRatio: 1;
+    };
+    /**
+     * 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
+     */
+    readonly 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
+     */
+    readonly 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
+     */
+    readonly 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
+     */
+    readonly liftSpring: {
+        readonly response: 0.215;
+        readonly 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
+     */
+    readonly dropSpring: {
+        readonly response: 0.5;
+        readonly 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
+     */
+    readonly endHaptic: "impactMedium";
+};
+//# sourceMappingURL=slider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slider.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/slider.ts"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;;;;OASG;;IAEH;;;;;;;;;OASG;;IAEH;;;;;;;;OAQG;;;;;IAEH;;;;;;OAMG;;IAEH;;;;;;;OAOG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;;OAOG;;;;;IAEH;;;;;;;OAOG;;CAEK,CAAC"}

package/dist/motion/uikit/slider.js

@@ -0,0 +1,111 @@
+// 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.js";
+
+/**
+ * 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'
+};

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

@@ -399,6 +399,39 @@ export declare const BANNER_SPRING: {
     readonly stiffness: 1000;
     readonly damping: 500;
 };
+/**
+ * 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 declare const SLIDER_RELEASE_SPRING: {
+    readonly response: 0.4;
+    readonly dampingRatio: 1;
+};
+/**
+ * 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 declare const SLIDER_LIFT_SPRING: {
+    readonly response: 0.215;
+    readonly dampingRatio: 0.6;
+};
+/**
+ * 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 declare const SLIDER_DROP_SPRING: {
+    readonly response: 0.5;
+    readonly dampingRatio: 0.7;
+};
 /**
  * Every spring above, by row name: the table the existing readers use. A
  * component imports only the rows it plays (`architecture:component-style-authoring`
@@ -550,9 +583,21 @@ export declare const springs: {
         readonly stiffness: 1000;
         readonly damping: 500;
     };
+    readonly sliderRelease: {
+        readonly response: 0.4;
+        readonly dampingRatio: 1;
+    };
+    readonly sliderLift: {
+        readonly response: 0.215;
+        readonly dampingRatio: 0.6;
+    };
+    readonly sliderDrop: {
+        readonly response: 0.5;
+        readonly dampingRatio: 0.7;
+    };
 };
 /**
- * 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

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

@@ -1 +1 @@
-{"version":3,"file":"springs.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/springs.ts"],"names":[],"mappings":"AAmCA;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;CAAsC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;CAAyC,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,eAAe;;;CAAwC,CAAC;AAErE;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;CAGzB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;CAA6C,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;CAAsC,CAAC;AAEvE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB;;;;CAIrB,CAAC;AAMX;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;CAA4C,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;CAA4C,CAAC;AAE/E;;;;;;GAMG;AACH,eAAO,MAAM,wCAAwC;;;CAG3C,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B;;;CAGjC,CAAC;AAMX;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB;;;CAG5B,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;CAG7B,CAAC;AAMX;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;CAI9B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;CAI9B,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;CAA+C,CAAC;AAE7E;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;CAAgD,CAAC;AAE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB;;;CAA4C,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;CAG9B,CAAC;AAEX;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;CAG5B,CAAC;AAEX;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B;;;CAG7B,CAAC;AAMX;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B;;;CAG9B,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;CAGzB,CAAC;AAMX;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;CAAoD,CAAC;AAE/E;;;;GAIG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCV,CAAC;AAwBX;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAI3C"}
+{"version":3,"file":"springs.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/springs.ts"],"names":[],"mappings":"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"}

package/dist/motion/uikit/springs.js

@@ -488,6 +488,42 @@ export const BANNER_SPRING = {
   damping: 500
 };
 
+/**
+ * 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
+};
+
+/**
+ * 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
+};
+
+/**
+ * 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
+};
+
 /**
  * Every spring above, by row name: the table the existing readers use. A
  * component imports only the rows it plays (`architecture:component-style-authoring`
@@ -527,11 +563,16 @@ export const springs = {
   switchThumbStretch: SWITCH_THUMB_STRETCH_SPRING,
   segmentedThumb: SEGMENTED_THUMB_SPRING,
   keyboard: KEYBOARD_SPRING,
-  banner: BANNER_SPRING
+  banner: BANNER_SPRING,
+  sliderRelease: SLIDER_RELEASE_SPRING,
+  sliderLift: SLIDER_LIFT_SPRING,
+  sliderDrop: SLIDER_DROP_SPRING
 };
 
 /**
- * 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 = {
@@ -549,11 +590,14 @@ const SPRING_ROLES = {
   subMenuBack: SUB_MENU_BACK_SPRING,
   contextMenuLift: CONTEXT_MENU_LIFT_SPRING,
   contextMenuDismiss: CONTEXT_MENU_DISMISS_SPRING,
-  contextMenuMorph: CONTEXT_MENU_MORPH_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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astryxdesign/core",
-  "version": "0.7.6",
+  "version": "0.7.7-canary.36f8ea1",
   "displayName": "Astryx Core",
   "description": "The component library. Accessible, themeable React components with built-in spacing, dark mode, and StyleX styling.",
   "author": "Meta Open Source",
@@ -860,6 +860,9 @@
     "react-dom": ">=19.0.0"
   },
   "devDependencies": {
+    "@astryxdesign/a11y-spec": "0.7.7-canary.36f8ea1",
+    "@astryxdesign/cli": "0.7.7-canary.36f8ea1",
+    "@astryxdesign/interaction-harness": "0.7.7-canary.36f8ea1",
     "@babel/cli": "^7.29.7",
     "@babel/core": "^7.29.7",
     "@babel/preset-react": "^7.29.7",
@@ -870,10 +873,7 @@
     "@testing-library/jest-dom": "^6.6.0",
     "@testing-library/react": "^16.3.2",
     "@types/babel__core": "^7.20.5",
-    "tailwindcss": "^4.3.2",
-    "@astryxdesign/cli": "0.7.6",
-    "@astryxdesign/a11y-spec": "0.0.0",
-    "@astryxdesign/interaction-harness": "0.0.0"
+    "tailwindcss": "^4.3.2"
   },
   "dependencies": {
     "intl-messageformat": "^11.2.9"

package/src/AppShell/AppShell.doc.mjs

@@ -45,6 +45,11 @@ export const docs = {
         description:
           'Start the page heading inside `children`. AppShell owns the skip link, the banner landmark and the main landmark, but it renders no heading, so the first heading in the content area is the page h1.',
       },
+      {
+        guidance: true,
+        description:
+          'On phones, opt the page into the full screen with `viewport-fit=cover` in the viewport meta tag (`width=device-width, initial-scale=1, viewport-fit=cover`). AppShell then extends its header under the status bar and out to the screen sides, and keeps the header\'s items and the end of the content inside the device\'s safe area. An installed web app can also draw under the status bar with `<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">`. In landscape only the header is inset: an inline SideNav and the content\'s sides still reach under a notch, so keep content padding there. A shell with no header region or phone top bar keeps no top inset; keep top padding there.',
+      },
       {
         guidance: false,
         description:
@@ -343,6 +348,11 @@ export const docsDense = {
         description:
           'Give every nav slot an accessible name: TopNav and SideNav are separate navigation landmarks, so pass `label` to each.',
       },
+      {
+        guidance: true,
+        description:
+          'Phones: add `viewport-fit=cover` to the viewport meta; the header then reaches under the status bar while its items and the content end stay in the safe area. Landscape: only the header is inset (not an inline SideNav or the content sides). No header region or phone top bar: no top inset, so keep top padding. Installed web apps: `apple-mobile-web-app-status-bar-style` `black-translucent`.',
+      },
       {
         guidance: true,
         description: