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

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/scroll.d.ts

@@ -59,25 +59,6 @@ export declare const scroll: {
         readonly duration: 0.5;
         readonly bounce: 0;
     };
-    readonly paging: {
-        /**
-         * Deceleration rate a paging release is projected with to pick the next
-         * page.
-         * @source GUESS — UIScrollView paging behaves like a fast scroll view;
-         *   the rate it uses internally is not documented
-         * @measure M-PG1
-         */
-        readonly projectionRate: 0.99;
-        /**
-         * The spring that carries a paging scroll view onto its page.
-         * @source GUESS — SwiftUI `.smooth` default until measured
-         * @measure M-PG1
-         */
-        readonly snap: {
-            readonly duration: 0.5;
-            readonly bounce: 0;
-        };
-    };
     /**
      * `delaysContentTouches`: how long a scroll view holds a touch-down from
      * its content while it decides whether the touch is a scroll (no highlight

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

@@ -1 +1 @@
-{"version":3,"file":"scroll.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/scroll.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,eAAO,MAAM,MAAM;;QAEf;;;;;;;;;;;;;;;;WAgBG;;QAEH;;;;;;;WAOG;;;;QAIH;;;;;;;;;;;WAWG;;;IAGL;;;;;;;;;;OAUG;;;;;;QAGD;;;;;;WAMG;;QAEH;;;;WAIG;;;;;;IAGL;;;;;;;;;;OAUG;;IAEH;;;;;;;;;;;;;;OAcG;;CAEK,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C"}
+{"version":3,"file":"scroll.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/scroll.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,eAAO,MAAM,MAAM;;QAEf;;;;;;;;;;;;;;;;WAgBG;;QAEH;;;;;;;WAOG;;;;QAIH;;;;;;;;;;;WAWG;;;IAGL;;;;;;;;;;OAUG;;;;;IAEH;;;;;;;;;;OAUG;;IAEH;;;;;;;;;;;;;;OAcG;;CAEK,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C"}

package/dist/motion/uikit/scroll.js

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

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.0d1ddcd",
   "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.0d1ddcd",
+    "@astryxdesign/cli": "0.7.7-canary.0d1ddcd",
+    "@astryxdesign/interaction-harness": "0.7.7-canary.0d1ddcd",
     "@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: