@astryxdesign/core 0.7.8 → 0.7.9-canary.0200dfe

package/dist/utils/flatTree.js

@@ -3,11 +3,12 @@
 /**
  * @file flatTree.ts
  * @input A DOM node
- * @output Exports parentAcrossShadow, and containsAlongFlatTree, which walks it
+ * @output Exports parentAcrossShadow, containsAlongFlatTree, which walks it,
+ *   and deepActiveElement
  * @position The flat-tree parent the browser scrolls and dispatches
- *   through, shared by the gesture host's native-scroll probe and the
+ *   through, shared by the gesture host's native-scroll probe, the
  *   selection lock (which the press feedback controller uses without the
- *   gesture system)
+ *   gesture system) and the Layer module's input hold
  */
 
 /** The node's parent, crossing out of shadow roots. */
@@ -35,4 +36,13 @@ export function containsAlongFlatTree(ancestor, node) {
     }
   }
   return false;
+}
+
+/** The focused element of `doc`, inside open shadow roots too. */
+export function deepActiveElement(doc) {
+  let active = doc?.activeElement ?? null;
+  while (active?.shadowRoot?.activeElement != null) {
+    active = active.shadowRoot.activeElement;
+  }
+  return active;
 }

package/dist/utils/focusReturn.d.ts

@@ -3,8 +3,9 @@
  * @input The document's current active element and the shared interaction
  *   modality.
  * @output Whether focus would be lost if a surface hid now; a focus move whose
- *   ring follows the last input; and the one path that moves focus out of
- *   content a change removed or hid (`noteFocusWithin`, `moveFocusLeftBehind`).
+ *   ring follows the last input; the focus return of a closed overlay, which
+ *   never scrolls the page; and the one path that moves focus out of content a
+ *   change removed or hid (`noteFocusWithin`, `moveFocusLeftBehind`).
  * @position Utility; used by overlays (BottomSheet, Dialog, DropdownMenu) that
  *   move focus programmatically, and by disclosures that hide focused
  *   content. isFocusDetached lives in isFocusDetached.ts, so the utils entry,
@@ -58,18 +59,38 @@ export declare function moveFocusLeftBehind(note: FocusWithin | null, target: HT
  */
 export declare function focusForLastInput(element: HTMLElement, options?: FocusOptions, modality?: InteractionModality): void;
 /**
- * Prepares the focus return for an open surface that may be removed while
- * open (rendered only while open, or removed with its view). Removing a
- * `<dialog>` runs no close and no browser focus return. Call this while the
- * surface is mounted: it reads the frame that hosts the surface now, because a
- * removed frame's document has no window. Call the returned function from the
- * effect cleanup with the opener.
+ * Returns focus to `opener` after an overlay closes, without a scroll and with
+ * the ring the last input calls for. WebKit records the nearest focusable
+ * ancestor of a tapped button as the opener, such as a `tabindex="-1"` main
+ * region. A reveal of that region scrolls the page to its top edge.
+ */
+export declare function returnFocusForLastInput(opener: HTMLElement, modality?: InteractionModality): void;
+/**
+ * Prepares a focus repair for an open surface that may be removed while open
+ * (rendered only while open, or removed with its view). Removing a `<dialog>`
+ * runs no close and no browser focus return. Call this while the surface is
+ * mounted: it reads the frame that hosts the surface now, because a removed
+ * frame's document has no window. Call the returned function from the effect
+ * cleanup with the repair to run.
  *
- * Once the commit has finished, focus moves to the opener only when the
- * surface really left the document (StrictMode's simulated unmount keeps it),
- * the opener is still on the page, and the removal lost focus, both in the
- * surface's document and in the document that hosts its frame. A control the
- * user pressed outside the surface, or outside its frame, keeps its focus.
+ * Once the commit has finished, the repair runs only when the surface really
+ * left the document (StrictMode's simulated unmount keeps it) and the removal
+ * lost focus, both in the surface's document and in the document that hosts
+ * its frame. A control the user pressed outside the surface, or outside its
+ * frame, keeps its focus, and so does a surface that took focus in the same
+ * commit.
+ */
+export declare function prepareFocusRepairOnRemoval(surface: Element, options?: {
+    /**
+     * Skip the repair when focus already rested on the page body before the
+     * commit's first removal: the removal did not lose that focus.
+     */
+    keepRestingFocus?: boolean;
+}): (repair: () => void) => void;
+/**
+ * The focus repair above that returns focus to `opener` while the opener is
+ * still on the page. Call the returned function from the effect cleanup with
+ * the opener.
  */
 export declare function prepareFocusReturnOnRemoval(surface: Element): (opener: Element | null) => void;
 //# sourceMappingURL=focusReturn.d.ts.map

package/dist/utils/focusReturn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"focusReturn.d.ts","sourceRoot":"","sources":["../../src/utils/focusReturn.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAG/B;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM5E;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACxC,WAAW,GAAG,IAAI,CAMpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,GAAG,IAAI,EACxB,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACtC,MAAM,GAAE,OAAO,GAAG,IAAW,GAC5B,OAAO,CAUT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,GAAE,mBAAqD,GAC9D,IAAI,CA2BN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,GACf,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,KAAK,IAAI,CAYlC"}
+{"version":3,"file":"focusReturn.d.ts","sourceRoot":"","sources":["../../src/utils/focusReturn.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAG/B;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM5E;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACxC,WAAW,GAAG,IAAI,CAMpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,GAAG,IAAI,EACxB,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACtC,MAAM,GAAE,OAAO,GAAG,IAAW,GAC5B,OAAO,CAUT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,GAAE,mBAAqD,GAC9D,IAAI,CA2BN;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,WAAW,EACnB,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,IAAI,CAEN;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE;IACR;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GACA,CAAC,MAAM,EAAE,MAAM,IAAI,KAAK,IAAI,CAkB9B;AAgBD;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,GACf,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,KAAK,IAAI,CASlC"}

package/dist/utils/focusReturn.js

@@ -5,8 +5,9 @@
  * @input The document's current active element and the shared interaction
  *   modality.
  * @output Whether focus would be lost if a surface hid now; a focus move whose
- *   ring follows the last input; and the one path that moves focus out of
- *   content a change removed or hid (`noteFocusWithin`, `moveFocusLeftBehind`).
+ *   ring follows the last input; the focus return of a closed overlay, which
+ *   never scrolls the page; and the one path that moves focus out of content a
+ *   change removed or hid (`noteFocusWithin`, `moveFocusLeftBehind`).
  * @position Utility; used by overlays (BottomSheet, Dialog, DropdownMenu) that
  *   move focus programmatically, and by disclosures that hide focused
  *   content. isFocusDetached lives in isFocusDetached.ts, so the utils entry,
@@ -108,28 +109,74 @@ export function focusForLastInput(element, options, modality = getInteractionMod
 }
 
 /**
- * Prepares the focus return for an open surface that may be removed while
- * open (rendered only while open, or removed with its view). Removing a
- * `<dialog>` runs no close and no browser focus return. Call this while the
- * surface is mounted: it reads the frame that hosts the surface now, because a
- * removed frame's document has no window. Call the returned function from the
- * effect cleanup with the opener.
+ * Returns focus to `opener` after an overlay closes, without a scroll and with
+ * the ring the last input calls for. WebKit records the nearest focusable
+ * ancestor of a tapped button as the opener, such as a `tabindex="-1"` main
+ * region. A reveal of that region scrolls the page to its top edge.
+ */
+export function returnFocusForLastInput(opener, modality) {
+  focusForLastInput(opener, {
+    preventScroll: true
+  }, modality);
+}
+
+/**
+ * Prepares a focus repair for an open surface that may be removed while open
+ * (rendered only while open, or removed with its view). Removing a `<dialog>`
+ * runs no close and no browser focus return. Call this while the surface is
+ * mounted: it reads the frame that hosts the surface now, because a removed
+ * frame's document has no window. Call the returned function from the effect
+ * cleanup with the repair to run.
  *
- * Once the commit has finished, focus moves to the opener only when the
- * surface really left the document (StrictMode's simulated unmount keeps it),
- * the opener is still on the page, and the removal lost focus, both in the
- * surface's document and in the document that hosts its frame. A control the
- * user pressed outside the surface, or outside its frame, keeps its focus.
+ * Once the commit has finished, the repair runs only when the surface really
+ * left the document (StrictMode's simulated unmount keeps it) and the removal
+ * lost focus, both in the surface's document and in the document that hosts
+ * its frame. A control the user pressed outside the surface, or outside its
+ * frame, keeps its focus, and so does a surface that took focus in the same
+ * commit.
  */
-export function prepareFocusReturnOnRemoval(surface) {
+export function prepareFocusRepairOnRemoval(surface, options) {
   const host = surface.ownerDocument.defaultView?.frameElement ?? null;
-  return opener => {
+  return repair => {
+    if (options?.keepRestingFocus === true && wasFocusDetachedBeforeRemoval(surface.ownerDocument)) {
+      return;
+    }
     queueMicrotask(() => {
-      if (surface.isConnected || opener == null || !opener.isConnected) {
+      if (surface.isConnected) {
         return;
       }
       if (isFocusLost(surface) && (host == null || isFocusLost(host))) {
-        focusForLastInput(opener);
+        repair();
+      }
+    });
+  };
+}
+
+// Whether focus rested on the page body when the current commit began
+// removing surfaces, per document. One removal can drop focus before a later
+// surface's cleanup runs, so every cleanup of the commit reads the first value.
+const focusDetachedAtRemovalStart = new WeakMap();
+function wasFocusDetachedBeforeRemoval(doc) {
+  let wasDetached = focusDetachedAtRemovalStart.get(doc);
+  if (wasDetached === undefined) {
+    wasDetached = isFocusDetached(doc);
+    focusDetachedAtRemovalStart.set(doc, wasDetached);
+    queueMicrotask(() => focusDetachedAtRemovalStart.delete(doc));
+  }
+  return wasDetached;
+}
+
+/**
+ * The focus repair above that returns focus to `opener` while the opener is
+ * still on the page. Call the returned function from the effect cleanup with
+ * the opener.
+ */
+export function prepareFocusReturnOnRemoval(surface) {
+  const repairOnRemoval = prepareFocusRepairOnRemoval(surface);
+  return opener => {
+    repairOnRemoval(() => {
+      if (opener != null && opener.isConnected) {
+        returnFocusForLastInput(opener);
       }
     });
   };

package/dist/utils/hitArea.d.ts

@@ -53,6 +53,13 @@ export declare function writeHitInsets(element: HTMLElement, insets: HitInsets):
 export interface WatchHitAreaOptions {
     /** The size to grow toward, px. @default 44 */
     readonly minSize?: number;
+    /**
+     * A touch that the browser hit-tests onto a descendant is the element's,
+     * however near a neighbour is. Set it for a host whose content can paint
+     * past its box, such as a list row with a swipe panel. A control whose
+     * grown input is its descendant leaves it off. @default false
+     */
+    readonly ownsDescendantTouches?: boolean;
 }
 /**
  * Stops every watch and forgets them, for tests: no observer, listener or
@@ -68,5 +75,5 @@ export declare function resetHitAreaForTests(): void;
  * its parent's text and children settle after a change, all in the shared
  * per-frame pass, and re-measured at once when a touch starts on it.
  */
-export declare function watchHitArea(element: Element, onInsets: (insets: HitInsets) => void, { minSize }?: WatchHitAreaOptions): () => void;
+export declare function watchHitArea(element: Element, onInsets: (insets: HitInsets) => void, { minSize, ownsDescendantTouches, }?: WatchHitAreaOptions): () => void;
 //# sourceMappingURL=hitArea.d.ts.map

package/dist/utils/hitArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hitArea.d.ts","sourceRoot":"","sources":["../../src/utils/hitArea.ts"],"names":[],"mappings":"AA6BA,+BAA+B;AAC/B,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,mEAAmE;AACnE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,qDAAqD;AACrD,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC,6CAA6C;AAC7C,eAAO,MAAM,aAAa,EAAE,SAAkD,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;CAKvB,CAAC;AAmCX;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,EAClC,OAAO,GAAE,MAAyB,GACjC,SAAS,CA4CX;AAYD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,OAAO,GAAE,MAAyB,GACjC,MAAM,CAoBR;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAI5E;AAmdD,iCAAiC;AACjC,MAAM,WAAW,mBAAmB;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAW3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,EACrC,EAAC,OAA0B,EAAC,GAAE,mBAAwB,GACrD,MAAM,IAAI,CAyDZ"}
+{"version":3,"file":"hitArea.d.ts","sourceRoot":"","sources":["../../src/utils/hitArea.ts"],"names":[],"mappings":"AAgCA,+BAA+B;AAC/B,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,mEAAmE;AACnE,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,qDAAqD;AACrD,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC,6CAA6C;AAC7C,eAAO,MAAM,aAAa,EAAE,SAAkD,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;CAKvB,CAAC;AAmCX;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,EAClC,OAAO,GAAE,MAAyB,GACjC,SAAS,CA4CX;AAYD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAC7B,OAAO,GAAE,MAAyB,GACjC,MAAM,CAoBR;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAI5E;AAskBD,iCAAiC;AACjC,MAAM,WAAW,mBAAmB;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CAC1C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAW3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,EACrC,EACE,OAA0B,EAC1B,qBAA6B,GAC9B,GAAE,mBAAwB,GAC1B,MAAM,IAAI,CA0DZ"}

package/dist/utils/hitArea.js

@@ -24,6 +24,9 @@
 // live control measures: only under a coarse primary pointer (AST-094), only on
 // screen, and in one read pass per frame within a 4 ms budget. Until the first
 // pass the insets are 0, so first paint never overlaps anything.
+// The insets are lengths in the control's own box, so a pass measures in its
+// layout px. A layer that opens from a smaller scale then keeps the insets of
+// the size it settles at.
 import { observeContent } from "./sharedMutationObserver.js";
 
 /** A rect in client pixels. */
@@ -217,6 +220,8 @@ const observedSizes = new WeakMap();
 const scopeTimers = new Map();
 let frame = null;
 let view = null;
+/** The document the shared press listener is on, while it is on one. */
+let pressDocument = null;
 let pointer = null;
 let visibility = null;
 let resize = null;
@@ -263,6 +268,74 @@ function plainRect(element) {
     bottom
   };
 }
+
+/** A box that the transforms around it leave at its layout size. */
+const UNSCALED = {
+  x: 1,
+  y: 1
+};
+
+/** One axis of a box's scale on screen: its client size over its layout size. */
+function axisScale(onScreen, layout) {
+  if (!(layout > 0) || !(onScreen > 0)) {
+    return 1;
+  }
+  const scale = onScreen / layout;
+  // Within rounding of 1 the box is at its layout size: no change to the rects.
+  return Math.abs(scale - 1) < 1e-3 ? 1 : scale;
+}
+
+/**
+ * How far the transforms around `element` scale its box on screen, per axis.
+ * A layer that opens from a smaller scale scales every rect inside it, while
+ * the layout box keeps the size the layer settles at. Only a scale is
+ * expected: a rotated or skewed box would read as a larger scale.
+ */
+function screenScale(element, onScreen) {
+  // The offset size is the layout size in whole pixels, unaffected by
+  // transforms, and costs no style resolution. A box with none, such as an SVG
+  // element or a jsdom box, reads as unscaled.
+  const box = element;
+  const offsetWidth = box.offsetWidth ?? 0;
+  const offsetHeight = box.offsetHeight ?? 0;
+  if (offsetWidth === 0 || offsetHeight === 0) {
+    return UNSCALED;
+  }
+  // Within a pixel of its layout size the box reads as unscaled, which bounds
+  // the inset error at about a pixel. Only a box that a transform shrinks or
+  // grows reads its exact size from the computed style.
+  if (Math.abs(onScreen.right - onScreen.left - offsetWidth) <= 1 && Math.abs(onScreen.bottom - onScreen.top - offsetHeight) <= 1) {
+    return UNSCALED;
+  }
+  const style = element.ownerDocument.defaultView?.getComputedStyle(element);
+  if (style == null || !style.width.endsWith('px')) {
+    return UNSCALED;
+  }
+  const px = value => Number.parseFloat(value) || 0;
+  const isContentBox = style.boxSizing !== 'border-box';
+  const width = px(style.width) + (isContentBox ? px(style.paddingLeft) + px(style.paddingRight) + px(style.borderLeftWidth) + px(style.borderRightWidth) : 0);
+  const height = px(style.height) + (isContentBox ? px(style.paddingTop) + px(style.paddingBottom) + px(style.borderTopWidth) + px(style.borderBottomWidth) : 0);
+  return {
+    x: axisScale(onScreen.right - onScreen.left, width),
+    y: axisScale(onScreen.bottom - onScreen.top, height)
+  };
+}
+
+/**
+ * `rect` in the layout px of the box at `origin`: its offset from `origin`,
+ * divided by that box's scale on screen.
+ */
+function inLayout(rect, origin, scale) {
+  if (scale.x === 1 && scale.y === 1) {
+    return rect;
+  }
+  return {
+    left: origin.left + (rect.left - origin.left) / scale.x,
+    top: origin.top + (rect.top - origin.top) / scale.y,
+    right: origin.left + (rect.right - origin.left) / scale.x,
+    bottom: origin.top + (rect.bottom - origin.top) / scale.y
+  };
+}
 /** The watched element `element` belongs to, if any (itself included). */
 function watchedOwner(element) {
   for (let node = element; node != null; node = node.parentElement) {
@@ -297,14 +370,15 @@ function readCandidates(doc) {
 /** A control's rect and clamped insets, from candidates already read. */
 function measureOne(watch, candidates) {
   const target = plainRect(watch.element);
+  const scale = screenScale(watch.element, target);
   // Two targets each growing up to half the minimum reach each other from a
   // minimum apart.
   const reach = Math.max(0, watch.minSize);
   const band = grown(target, {
-    top: reach,
-    right: reach,
-    bottom: reach,
-    left: reach
+    top: reach * scale.y,
+    right: reach * scale.x,
+    bottom: reach * scale.y,
+    left: reach * scale.x
   });
   const neighbours = candidates.filter(({
     element,
@@ -314,7 +388,12 @@ function measureOne(watch, candidates) {
   }) => rect);
   return {
     target,
-    insets: clampedHitInsets(target, neighbours, watch.minSize),
+    // The insets are in the control's layout px. The returned rects stay in
+    // screen px for a touch's distance checks. A neighbour maps by the
+    // control's scale, as if it is in the same layer. A neighbour outside that
+    // layer then reads farther away. A touch compares screen distances, so it
+    // still counts that neighbour.
+    insets: clampedHitInsets(inLayout(target, target, scale), neighbours.map(rect => inLayout(rect, target, scale)), watch.minSize),
     neighbours
   };
 }
@@ -419,7 +498,12 @@ function checkPress(element, event) {
     const own = distanceTo(target, x, y);
     isNearerNeighbour ||= neighbours.some(rect => distanceTo(rect, x, y) < own);
   }
-  if (isNearerNeighbour) {
+  // A watch can own its descendants' touches. Then a press that the browser
+  // hit-tests onto a descendant lands on content the element paints, even
+  // past its own box. A swipe panel's entry beside a moved row is such
+  // content. That touch is the element's.
+  const isOnOwnContent = [...entry.watches].some(watch => watch.ownsDescendantTouches) && press.target instanceof Node && press.target !== element && element.contains(press.target);
+  if (isNearerNeighbour && !isOnOwnContent) {
     const swallow = click => {
       disarm();
       // A keyboard or assistive-technology activation (detail 0) is never
@@ -500,7 +584,8 @@ function startObserving() {
     return;
   }
   view.addEventListener('resize', scheduleAll);
-  view.document.addEventListener('pointerdown', onPress, PASSIVE_CAPTURE);
+  pressDocument = view.document;
+  pressDocument.addEventListener('pointerdown', onPress, PASSIVE_CAPTURE);
   if (typeof IntersectionObserver === 'function') {
     visibility = new IntersectionObserver(entries => {
       for (const entry of entries) {
@@ -555,7 +640,10 @@ function stopObserving() {
     entry.release = null;
   }
   view?.removeEventListener('resize', scheduleAll);
-  view?.document.removeEventListener('pointerdown', onPress, PASSIVE_CAPTURE);
+  // The listener leaves the document it went on. A window can close first, as
+  // a removed iframe's, and then it has no document to read.
+  pressDocument?.removeEventListener('pointerdown', onPress, PASSIVE_CAPTURE);
+  pressDocument = null;
   visibility?.disconnect();
   resize?.disconnect();
   visibility = null;
@@ -613,7 +701,8 @@ export function resetHitAreaForTests() {
  * per-frame pass, and re-measured at once when a touch starts on it.
  */
 export function watchHitArea(element, onInsets, {
-  minSize = MIN_TOUCH_TARGET
+  minSize = MIN_TOUCH_TARGET,
+  ownsDescendantTouches = false
 } = {}) {
   const owner = element.ownerDocument.defaultView;
   if (owner == null) {
@@ -633,6 +722,7 @@ export function watchHitArea(element, onInsets, {
   const watch = {
     element,
     minSize,
+    ownsDescendantTouches,
     onInsets,
     isVisible: isCoarse && visibility == null,
     last: NO_HIT_INSETS

package/dist/utils/inputPresentation.d.ts

@@ -1,6 +1,7 @@
 /**
  * @file inputPresentation.ts
- * @input A presentation policy, the deprecated nativePicker value, and pointer type
+ * @input A presentation policy, the deprecated nativePicker value, whether the
+ *   native date control can show the calendar, and pointer type
  * @output The resolved picker surface for DateInput, DateTimeInput, and TimeInput
  * @position Shared presentation vocabulary (AST-043)
  *
@@ -48,6 +49,13 @@ export declare function presentationFromNativePicker(nativePicker: LegacyNativeP
 export declare function effectivePickerPresentation(presentation: PickerPresentation | undefined, nativePicker: LegacyNativePicker | undefined): PickerPresentation;
 /** The effective policy: explicit `presentation` wins over the deprecated prop. */
 export declare function effectiveInputPresentation(presentation: InputPresentation | undefined, nativePicker: LegacyNativePicker | undefined, component: 'date' | 'time'): InputPresentation;
+/**
+ * The policy a date picker follows in its calendar. `<input type="date">` is
+ * Gregorian, so in a calendar it cannot show, the policies that use it
+ * (`native` and `adaptive-native`) use the Astryx popover on a fine pointer and
+ * the bottom sheet on a coarse one instead.
+ */
+export declare function calendarPickerPresentation(presentation: PickerPresentation, isNativeCalendar: boolean): PickerPresentation;
 /** Resolve a picker-only policy to the surface rendered for the current pointer. */
 export declare function resolvePickerPresentation(presentation: PickerPresentation, isCoarsePointer: boolean): PickerPresentationSurface;
 /** Resolve a policy to the surface rendered for the current pointer. */

package/dist/utils/inputPresentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inputPresentation.d.ts","sourceRoot":"","sources":["../../src/utils/inputPresentation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,kDAAkD;AAClD,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,SAAS,GACT,cAAc,GACd,QAAQ,GACR,uBAAuB,GACvB,iBAAiB,CAAC;AAEtB,8GAA8G;AAC9G,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;AAE1E,mEAAmE;AACnE,MAAM,MAAM,wBAAwB,GAClC,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEhD,qFAAqF;AACrF,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAC7C,wBAAwB,EACxB,YAAY,CACb,CAAC;AAEF,gCAAgC;AAChC,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,kBAAsC,CAAC;AAEhF;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,YAAY,EAAE,kBAAkB,GAC/B,kBAAkB,CASpB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,kBAAkB,EAChC,SAAS,EAAE,MAAM,GAAG,MAAM,GACzB,iBAAiB,CAKnB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,kBAAkB,GAAG,SAAS,EAC5C,YAAY,EAAE,kBAAkB,GAAG,SAAS,GAC3C,kBAAkB,CAQpB;AAED,mFAAmF;AACnF,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,iBAAiB,GAAG,SAAS,EAC3C,YAAY,EAAE,kBAAkB,GAAG,SAAS,EAC5C,SAAS,EAAE,MAAM,GAAG,MAAM,GACzB,iBAAiB,CAQnB;AAED,oFAAoF;AACpF,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,OAAO,GACvB,yBAAyB,CAa3B;AAED,wEAAwE;AACxE,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,iBAAiB,EAC/B,eAAe,EAAE,OAAO,GACvB,wBAAwB,CAI1B"}
+{"version":3,"file":"inputPresentation.d.ts","sourceRoot":"","sources":["../../src/utils/inputPresentation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,kDAAkD;AAClD,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,SAAS,GACT,cAAc,GACd,QAAQ,GACR,uBAAuB,GACvB,iBAAiB,CAAC;AAEtB,8GAA8G;AAC9G,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;AAE1E,mEAAmE;AACnE,MAAM,MAAM,wBAAwB,GAClC,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEhD,qFAAqF;AACrF,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAC7C,wBAAwB,EACxB,YAAY,CACb,CAAC;AAEF,gCAAgC;AAChC,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,kBAAsC,CAAC;AAEhF;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,YAAY,EAAE,kBAAkB,GAC/B,kBAAkB,CASpB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,kBAAkB,EAChC,SAAS,EAAE,MAAM,GAAG,MAAM,GACzB,iBAAiB,CAKnB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,kBAAkB,GAAG,SAAS,EAC5C,YAAY,EAAE,kBAAkB,GAAG,SAAS,GAC3C,kBAAkB,CAQpB;AAED,mFAAmF;AACnF,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,iBAAiB,GAAG,SAAS,EAC3C,YAAY,EAAE,kBAAkB,GAAG,SAAS,EAC5C,SAAS,EAAE,MAAM,GAAG,MAAM,GACzB,iBAAiB,CAQnB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,kBAAkB,EAChC,gBAAgB,EAAE,OAAO,GACxB,kBAAkB,CAQpB;AAED,oFAAoF;AACpF,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,OAAO,GACvB,yBAAyB,CAa3B;AAED,wEAAwE;AACxE,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,iBAAiB,EAC/B,eAAe,EAAE,OAAO,GACvB,wBAAwB,CAI1B"}

package/dist/utils/inputPresentation.js

@@ -2,7 +2,8 @@
 
 /**
  * @file inputPresentation.ts
- * @input A presentation policy, the deprecated nativePicker value, and pointer type
+ * @input A presentation policy, the deprecated nativePicker value, whether the
+ *   native date control can show the calendar, and pointer type
  * @output The resolved picker surface for DateInput, DateTimeInput, and TimeInput
  * @position Shared presentation vocabulary (AST-043)
  *
@@ -86,6 +87,19 @@ export function effectiveInputPresentation(presentation, nativePicker, component
   return DEFAULT_INPUT_PRESENTATION;
 }
 
+/**
+ * The policy a date picker follows in its calendar. `<input type="date">` is
+ * Gregorian, so in a calendar it cannot show, the policies that use it
+ * (`native` and `adaptive-native`) use the Astryx popover on a fine pointer and
+ * the bottom sheet on a coarse one instead.
+ */
+export function calendarPickerPresentation(presentation, isNativeCalendar) {
+  if (!isNativeCalendar && (presentation === 'native' || presentation === 'adaptive-native')) {
+    return 'adaptive-bottom-sheet';
+  }
+  return presentation;
+}
+
 /** Resolve a picker-only policy to the surface rendered for the current pointer. */
 export function resolvePickerPresentation(presentation, isCoarsePointer) {
   switch (presentation) {

package/dist/utils/inputStream.d.ts

@@ -6,12 +6,25 @@ export interface InputSubscriptionOptions {
      * @default false
      */
     readonly cancels?: boolean;
+    /**
+     * The subscriber runs before every subscriber that is not first. When it
+     * returns `true`, no later subscriber hears the event.
+     * @default false
+     */
+    readonly first?: boolean;
 }
 /** The events a window's capture phase sees: its own, and the document's. */
 export type InputEventMap = WindowEventMap & DocumentEventMap;
+/**
+ * The type of the latest pointer event `view`'s stream delivered: `mouse`,
+ * `pen` or `touch`, or `null` before any. The stream hears a pointer event
+ * type only while a subscriber listens to it, as press feedback does on any
+ * page with a pressable. Reading it adds no listener.
+ */
+export declare function getLastPointerType(view: Window): string | null;
 /**
  * Listen to `type` on `view`'s capture phase through its shared native
  * listener. Returns the unsubscribe; calling it again does nothing.
  */
-export declare function subscribeInput<K extends keyof InputEventMap>(view: Window, type: K, listener: (event: InputEventMap[K]) => void, { cancels }?: InputSubscriptionOptions): () => void;
+export declare function subscribeInput<K extends keyof InputEventMap>(view: Window, type: K, listener: (event: InputEventMap[K]) => unknown, { cancels, first }?: InputSubscriptionOptions): () => void;
 //# sourceMappingURL=inputStream.d.ts.map

package/dist/utils/inputStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inputStream.d.ts","sourceRoot":"","sources":["../../src/utils/inputStream.ts"],"names":[],"mappings":"AA4CA,0CAA0C;AAC1C,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,6EAA6E;AAC7E,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAI9D;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,aAAa,EAC1D,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,EAC3C,EAAC,OAAe,EAAC,GAAE,wBAA6B,GAC/C,MAAM,IAAI,CAoCZ"}
+{"version":3,"file":"inputStream.d.ts","sourceRoot":"","sources":["../../src/utils/inputStream.ts"],"names":[],"mappings":"AAgDA,0CAA0C;AAC1C,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,6EAA6E;AAC7E,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAM9D;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE9D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,aAAa,EAC1D,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,OAAO,EAC9C,EAAC,OAAe,EAAE,KAAa,EAAC,GAAE,wBAA6B,GAC9D,MAAM,IAAI,CA4CZ"}

package/dist/utils/inputStream.js

@@ -4,7 +4,8 @@
  * @file inputStream.ts
  * @input A window, and subscribers to its input events (the press feedback
  *   controller, the gesture host)
- * @output subscribeInput
+ * @output subscribeInput, and getLastPointerType: the type of the latest
+ *   pointer event the stream delivered
  * @position The one entry for document-wide input listeners in core: one
  *   native listener per event type on the window's capture phase, shared by
  *   every subscriber
@@ -22,8 +23,10 @@
 // `blur` or `focus`. A subscriber for the window's own event checks
 // `event.target`.
 //
-// Subscribers run in subscription order. One that throws is reported, and
-// the rest still run.
+// Subscribers run in subscription order, after the ones subscribed `first`.
+// A first subscriber that returns `true` ends the dispatch: no later
+// subscriber hears the event. One that throws is reported, and the rest still
+// run.
 //
 // A type's native listener is passive, so it blocks no scroll. It is
 // non-passive only while a subscriber that cancels the event
@@ -34,13 +37,26 @@
 /** The events a window's capture phase sees: its own, and the document's. */
 
 const streams = new WeakMap();
+/** The type of the latest pointer event each window's stream delivered. */
+const lastPointerTypes = new WeakMap();
+
+/**
+ * The type of the latest pointer event `view`'s stream delivered: `mouse`,
+ * `pen` or `touch`, or `null` before any. The stream hears a pointer event
+ * type only while a subscriber listens to it, as press feedback does on any
+ * page with a pressable. Reading it adds no listener.
+ */
+export function getLastPointerType(view) {
+  return lastPointerTypes.get(view) ?? null;
+}
 
 /**
  * Listen to `type` on `view`'s capture phase through its shared native
  * listener. Returns the unsubscribe; calling it again does nothing.
  */
 export function subscribeInput(view, type, listener, {
-  cancels = false
+  cancels = false,
+  first = false
 } = {}) {
   let channels = streams.get(view);
   if (channels == null) {
@@ -57,9 +73,15 @@ export function subscribeInput(view, type, listener, {
   }
   const subscriber = {
     listener: listener,
-    cancels
+    cancels,
+    isFirst: first
   };
-  channel.subscribers.push(subscriber);
+  const firstLater = first ? channel.subscribers.findIndex(other => !other.isFirst) : -1;
+  if (firstLater === -1) {
+    channel.subscribers.push(subscriber);
+  } else {
+    channel.subscribers.splice(firstLater, 0, subscriber);
+  }
   register(view, type, channel);
   let isSubscribed = true;
   return () => {
@@ -101,7 +123,7 @@ function register(view, type, channel) {
   if (wanted == null) {
     return;
   }
-  const listener = event => dispatch(channel, event);
+  const listener = event => dispatch(view, channel, event);
   view.addEventListener(type, listener, {
     capture: true,
     passive: !wanted
@@ -111,7 +133,14 @@ function register(view, type, channel) {
     cancels: wanted
   };
 }
-function dispatch(channel, event) {
+function dispatch(view, channel, event) {
+  // Recorded before any subscriber runs, so each reads the pointer at hand.
+  const {
+    pointerType
+  } = event;
+  if (typeof pointerType === 'string' && pointerType !== '') {
+    lastPointerTypes.set(view, pointerType);
+  }
   // A subscriber may subscribe or unsubscribe while the event runs; the
   // event goes to those subscribed when it arrived.
   for (const subscriber of [...channel.subscribers]) {
@@ -119,7 +148,9 @@ function dispatch(channel, event) {
       continue;
     }
     try {
-      subscriber.listener(event);
+      if (subscriber.listener(event) === true && subscriber.isFirst) {
+        return;
+      }
     } catch (error) {
       report(error);
     }

package/dist/utils/interactionOverlay.stylex.d.ts

@@ -3,7 +3,8 @@
  * @input StyleX and the semantic interaction-overlay color tokens
  * @output Reusable background-color and background-image state styles, the
  *   touch press's registered strength variable (`pressVars`) and its clocks
- *   (`pressConsts`)
+ *   (`pressConsts`). The list row's compositor press layer and its clocks
+ *   are internal (privateAttributes/press.stylex.ts, utils/rowPressLayer.stylex.ts)
  * @position Internal styling utility for interactive core surfaces
  *
  * SYNC: When modified, update pressFeedback.ts, pressGesture.ts (the fade
@@ -29,16 +30,11 @@ export declare const pressVars: stylex.VarGroup<Readonly<{
     '--astryx-press-alpha': stylex.Types.Num<0>;
 }>, symbol>;
 /**
- * The touch press's clocks that both the stylesheet and the controller read.
- *
- * `defineConsts`, so the one number is inlined here at build time and is the
- * controller's constant at run time (`PRESS_FADE_MS` in pressGesture.ts):
- * the release animation and the controller's clock cannot drift apart. When
- * that clock runs out, the controller waits for a release animation that a
- * busy main thread started late, then removes the attribute.
+ * The touch press's measured release clock, kept as a reference value. Press
+ * releases now play the theme's `--duration-exit`.
  */
 export declare const pressConsts: {
-    /** How long the release takes, in ms. UIKit's deselect clock. */
+    /** UIKit's deselect clock, in ms: the measured reference value. */
     releaseMs: number;
 };
 export declare const interactionOverlayStyles: Readonly<{