@astryxdesign/core 0.7.6-canary.fdabeba → 0.7.6

package/dist/utils/coarsePointer.js

@@ -0,0 +1,45 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file coarsePointer.ts
+ * @input A window
+ * @output Exports isCoarsePointer and watchCoarsePointer: whether the
+ *   primary pointer is coarse (TOUCH_QUERY), and when it changes
+ * @position The coarse-pointer gate of packages/core/src/gestures and of
+ *   the press controller (pressFeedback.ts): touch-only work registers only
+ *   while it holds
+ *
+ * Under a coarse primary pointer, a phone's touch work stays registered: the
+ * gesture host's page listeners, the page hold and the finger scroll. Under a
+ * fine one, recognizers still attach, and the host listens on the page only
+ * during a press (AST-094). The answer can change while the page is open (a
+ * tablet docking a mouse), so a holder watches it.
+ *
+ * SYNC: When modified, update coarsePointer.test.ts.
+ */
+
+import { TOUCH_QUERY } from "./touchQueries.js";
+
+/** Whether the primary pointer of `view` is coarse now. */
+export function isCoarsePointer(view) {
+  return typeof view?.matchMedia === 'function' && view.matchMedia(TOUCH_QUERY).matches;
+}
+
+/**
+ * Call `listener` with the new answer each time the primary pointer of
+ * `view` turns coarse or fine, until the returned function is called.
+ */
+export function watchCoarsePointer(view, listener) {
+  if (typeof view?.matchMedia !== 'function') {
+    return () => {};
+  }
+  const query = view.matchMedia(TOUCH_QUERY);
+  const onChange = () => listener(query.matches);
+  if (typeof query.addEventListener === 'function') {
+    query.addEventListener('change', onChange);
+    return () => query.removeEventListener('change', onChange);
+  }
+  // Safari before 14 only has the older pair.
+  query.addListener(onChange);
+  return () => query.removeListener(onChange);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"devWarning.d.ts","sourceRoot":"","sources":["../../src/utils/devWarning.ts"],"names":[],"mappings":"AAyBA,gDAAgD;AAChD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,IAAI,CAKN;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,IAAI,CAEN;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,IAAI,CAMN;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}
+{"version":3,"file":"devWarning.d.ts","sourceRoot":"","sources":["../../src/utils/devWarning.ts"],"names":[],"mappings":"AAoBA,gDAAgD;AAChD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,IAAI,CAKN;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,IAAI,CAEN;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,IAAI,CAMN;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/utils/devWarning.js

@@ -6,15 +6,10 @@
  * @output Standardized `Component: message` console warnings and errors
  * @position Shared dev-logging utility used across components and hooks
  *
- * Standardizes how the design system surfaces information to the builder:
- * every message reads `Component: message` (e.g. `Field: isOptional and
- * isRequired are mutually exclusive.`), so the source is always obvious in
- * the console.
- *
- * Prefer the `useDevWarning` hook inside components — it guards against
- * repeating a warning on every render. These imperative helpers exist for
- * the non-render contexts a hook can't cover: plain functions, module
- * initialization, and inside effects.
+ * Every message reads `Component: message`, so the source is clear in the
+ * console. Prefer `useDevWarning` in components, because it does not repeat
+ * a warning on each render. These helpers are for plain functions, module
+ * initialization and effects.
  *
  * SYNC: When modified, update:
  * - /packages/core/src/utils/index.ts

package/dist/utils/flatTree.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file flatTree.ts
+ * @input A DOM node
+ * @output Exports parentAcrossShadow, and containsAlongFlatTree, which walks it
+ * @position The flat-tree parent the browser scrolls and dispatches
+ *   through, shared by the gesture host's native-scroll probe and the
+ *   selection lock (which the press feedback controller uses without the
+ *   gesture system)
+ */
+/** The node's parent, crossing out of shadow roots. */
+export declare function parentAcrossShadow(node: Node): Node | null;
+/**
+ * Whether `node` is `ancestor` or below it along the flat tree: across an open
+ * shadow root to its host, which `Node.contains` does not follow.
+ */
+export declare function containsAlongFlatTree(ancestor: Node, node: Node): boolean;
+//# sourceMappingURL=flatTree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flatTree.d.ts","sourceRoot":"","sources":["../../src/utils/flatTree.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAa1D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAOzE"}

package/dist/utils/flatTree.js

@@ -0,0 +1,38 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file flatTree.ts
+ * @input A DOM node
+ * @output Exports parentAcrossShadow, and containsAlongFlatTree, which walks it
+ * @position The flat-tree parent the browser scrolls and dispatches
+ *   through, shared by the gesture host's native-scroll probe and the
+ *   selection lock (which the press feedback controller uses without the
+ *   gesture system)
+ */
+
+/** The node's parent, crossing out of shadow roots. */
+export function parentAcrossShadow(node) {
+  // The flat tree the browser scrolls and dispatches through: a slotted node
+  // goes to its slot, a shadow root to its host.
+  const slot = node.assignedSlot;
+  if (slot != null) {
+    return slot;
+  }
+  if (node.parentNode != null) {
+    return node.parentNode instanceof ShadowRoot ? node.parentNode.host : node.parentNode;
+  }
+  return null;
+}
+
+/**
+ * Whether `node` is `ancestor` or below it along the flat tree: across an open
+ * shadow root to its host, which `Node.contains` does not follow.
+ */
+export function containsAlongFlatTree(ancestor, node) {
+  for (let at = node; at != null; at = parentAcrossShadow(at)) {
+    if (at === ancestor) {
+      return true;
+    }
+  }
+  return false;
+}

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

@@ -3,22 +3,6 @@
  * @input Uses StyleX and theme color tokens
  * @output Exports shared focus-outline prop builders
  * @position Internal utility for consistent keyboard focus outlines across core components
- *
- * Centralizes the standard Astryx focus outline, shown only for keyboard focus.
- * Every focusable surface drew the same 2px accent ring already; writing it per
- * component meant dozens of identical definitions to keep in step, and they did
- * not stay in step — offsets drifted and one ring was a border-width thick.
- *
- * Every ring in core and lab is drawn from here, with one exception recorded in
- * Switch: its condition is a component-scoped ancestor marker, which cannot be
- * shared without leaking focus state between components. A component may still
- * override the OFFSET (a ring that must sit inset, or clear of a field border);
- * width, style and color are not restated anywhere.
- *
- * Every value comes from the `--focus-outline-*` tokens, which is how a theme
- * restyles the ring: one override reaches every component at once. The
- * `:focus-visible` condition is not themeable and stays here, so a theme can
- * change what the ring looks like but cannot show it to pointer users.
  */
 import * as stylex from '@stylexjs/stylex';
 /**

package/dist/utils/focusOutline.stylex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"focusOutline.stylex.d.ts","sourceRoot":"","sources":["../../src/utils/focusOutline.stylex.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAS3C;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,QAAyE,CAAC;AAgBpG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAC;AAEX,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB;;;;;CAK3B,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6H7B,CAAC;AAIH,KAAK,cAAc,GAAG,OAAO,CAAC;AAiB9B,eAAO,MAAM,iBAAiB;uCAdT,cAAc,EAAE;;;;;;;sCAAhB,cAAc,EAAE;;;;;;;gDAAhB,cAAc,EAAE;;;;;;;qCAAhB,cAAc,EAAE;;;;;;;kDAAhB,cAAc,EAAE;;;;;;;iDAAhB,cAAc,EAAE;;;;;;;CA2B3B,CAAC"}
+{"version":3,"file":"focusOutline.stylex.d.ts","sourceRoot":"","sources":["../../src/utils/focusOutline.stylex.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AASH,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAS3C;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,QAAyE,CAAC;AAgBpG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAC;AAEX,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB;;;;;CAK3B,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4H7B,CAAC;AAIH,KAAK,cAAc,GAAG,OAAO,CAAC;AAiB9B,eAAO,MAAM,iBAAiB;uCAdT,cAAc,EAAE;;;;;;;sCAAhB,cAAc,EAAE;;;;;;;gDAAhB,cAAc,EAAE;;;;;;;qCAAhB,cAAc,EAAE;;;;;;;kDAAhB,cAAc,EAAE;;;;;;;iDAAhB,cAAc,EAAE;;;;;;;CA2B3B,CAAC"}

package/dist/utils/focusOutline.stylex.js

@@ -5,24 +5,15 @@
  * @input Uses StyleX and theme color tokens
  * @output Exports shared focus-outline prop builders
  * @position Internal utility for consistent keyboard focus outlines across core components
- *
- * Centralizes the standard Astryx focus outline, shown only for keyboard focus.
- * Every focusable surface drew the same 2px accent ring already; writing it per
- * component meant dozens of identical definitions to keep in step, and they did
- * not stay in step — offsets drifted and one ring was a border-width thick.
- *
- * Every ring in core and lab is drawn from here, with one exception recorded in
- * Switch: its condition is a component-scoped ancestor marker, which cannot be
- * shared without leaking focus state between components. A component may still
- * override the OFFSET (a ring that must sit inset, or clear of a field border);
- * width, style and color are not restated anywhere.
- *
- * Every value comes from the `--focus-outline-*` tokens, which is how a theme
- * restyles the ring: one override reaches every component at once. The
- * `:focus-visible` condition is not themeable and stays here, so a theme can
- * change what the ring looks like but cannot show it to pointer users.
  */
 
+// Every ring in core and lab comes from here, except Switch's: its condition
+// is a component-scoped ancestor marker, which cannot be shared without
+// leaking focus state. A component may override only the offset. The values
+// come from the `--focus-outline-*` tokens, so a theme restyles every ring at
+// once. The `:focus-visible` condition is not themeable, so a theme cannot
+// show the ring to pointer users.
+
 import * as stylex from '@stylexjs/stylex';
 import "../theme/tokens.stylex.js";
 import { focusVars } from "../theme/tokens.stylex.js";

package/dist/utils/focusReturn.d.ts

@@ -3,11 +3,15 @@
  * @input The document's current active element and the shared interaction
  *   modality.
  * @output Whether focus is currently "detached" — on nothing in particular —
- *   and a focus move whose ring follows the last input.
+ *   or 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`).
  * @position Utility; used by overlay triggers (e.g. DateInput, DateTimeInput)
  *   that return focus to their control when the overlay closes, but only when
  *   the dismiss did not already move focus somewhere the user chose, and by
- *   overlays (Dialog, DropdownMenu) that move focus programmatically.
+ *   overlays (Dialog, DropdownMenu) that move focus programmatically, and by
+ *   disclosures that hide focused content. Only
+ *   `isFocusDetached` is exported from the utils entry; the rest is internal.
  */
 import { type InteractionModality } from './interactionModality.js';
 /**
@@ -26,16 +30,46 @@ import { type InteractionModality } from './interactionModality.js';
  */
 export declare function isFocusDetached(doc?: Document): boolean;
 /**
- * Move focus programmatically so its ring follows the last input
- * (`architecture:interaction-modality` INV1). After pointer input the browser's
+ * True when focus would be lost if `surface` hid now: nothing is focused (see
+ * isFocusDetached) or focus sits inside `surface`. Reads `surface`'s own
+ * document, so a surface in an iframe or Picture-in-Picture window is
+ * answered there. Internal: not exported from the utils barrel.
+ */
+export declare function isFocusLost(surface: Element | null, doc?: Document): boolean;
+/** Where focus was, inside a container, before a change removed or hid content. */
+export interface FocusWithin {
+    readonly element: Element;
+    readonly container: HTMLElement;
+}
+/**
+ * The focused element, if it is inside `container`. A disclosure calls this
+ * in the commit before the DOM changes (`LayoutChangeSnapshot`'s
+ * `onBeforeChange`), and passes the result to `moveFocusLeftBehind` from a
+ * layout effect of the same commit. Internal.
+ */
+export declare function noteFocusWithin(container: HTMLElement | null | undefined): FocusWithin | null;
+/**
+ * Moves focus noted by `noteFocusWithin` to `target` when the change lost it
+ * (`isFocusLost`): it fell to the page because its element was removed, or
+ * it is still inside `hidden`, content the change hid but kept, which the
+ * browser is about to blur. Focus that survived the change, or that was never
+ * inside, is not moved. The ring follows the last input, so the calling
+ * component keeps modality tracking active
+ * (`useInteractionModalityTracking()`). Returns whether focus moved. Internal.
+ */
+export declare function moveFocusLeftBehind(note: FocusWithin | null, target: HTMLElement | null | undefined, hidden?: Element | null): boolean;
+/**
+ * Move focus programmatically so its ring follows the last input. After pointer input the browser's
  * focus option keeps the element from matching `:focus-visible`, which is the
  * one way to reach an element the overlay does not render: the consumer's
  * autofocus target, the control that opened a Dialog, or a menu trigger the
  * caller renders. Pass `options` (for example `preventScroll`) as to `focus()`.
  *
- * `modality` defaults to the page's last input. A caller moving focus inside a
- * second document (a same-origin iframe, a Document Picture-in-Picture window)
- * passes that document's, which it tracks with `trackInteractionModalityIn`.
+ * `modality` defaults to the last input in the element's own document: the
+ * page's for an element on the page, and a second document's (a same-origin
+ * iframe, a Document Picture-in-Picture window) for an element there, which
+ * the component tracks by passing its element's ref to
+ * `useInteractionModalityTracking`.
  *
  * Make sure modality tracking is active (`useInteractionModalityTracking()`)
  * in the component that calls this.

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

@@ -1 +1 @@
-{"version":3,"file":"focusReturn.d.ts","sourceRoot":"","sources":["../../src/utils/focusReturn.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,QAAmB,GAAG,OAAO,CAKjE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,GAAE,mBAA8C,GACvD,IAAI,CA2BN"}
+{"version":3,"file":"focusReturn.d.ts","sourceRoot":"","sources":["../../src/utils/focusReturn.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,QAAmB,GAAG,OAAO,CAKjE;AAED;;;;;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"}

package/dist/utils/focusReturn.js

@@ -5,11 +5,15 @@
  * @input The document's current active element and the shared interaction
  *   modality.
  * @output Whether focus is currently "detached" — on nothing in particular —
- *   and a focus move whose ring follows the last input.
+ *   or 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`).
  * @position Utility; used by overlay triggers (e.g. DateInput, DateTimeInput)
  *   that return focus to their control when the overlay closes, but only when
  *   the dismiss did not already move focus somewhere the user chose, and by
- *   overlays (Dialog, DropdownMenu) that move focus programmatically.
+ *   overlays (Dialog, DropdownMenu) that move focus programmatically, and by
+ *   disclosures that hide focused content. Only
+ *   `isFocusDetached` is exported from the utils entry; the rest is internal.
  */
 
 import { getInteractionModality } from "./interactionModality.js";
@@ -34,21 +38,69 @@ export function isFocusDetached(doc = document) {
 }
 
 /**
- * Move focus programmatically so its ring follows the last input
- * (`architecture:interaction-modality` INV1). After pointer input the browser's
+ * True when focus would be lost if `surface` hid now: nothing is focused (see
+ * isFocusDetached) or focus sits inside `surface`. Reads `surface`'s own
+ * document, so a surface in an iframe or Picture-in-Picture window is
+ * answered there. Internal: not exported from the utils barrel.
+ */
+export function isFocusLost(surface, doc) {
+  const ownerDocument = doc ?? surface?.ownerDocument ?? document;
+  return isFocusDetached(ownerDocument) || surface != null && surface.contains(ownerDocument.activeElement);
+}
+
+/** Where focus was, inside a container, before a change removed or hid content. */
+
+/**
+ * The focused element, if it is inside `container`. A disclosure calls this
+ * in the commit before the DOM changes (`LayoutChangeSnapshot`'s
+ * `onBeforeChange`), and passes the result to `moveFocusLeftBehind` from a
+ * layout effect of the same commit. Internal.
+ */
+export function noteFocusWithin(container) {
+  const active = container?.ownerDocument.activeElement;
+  if (container == null || active == null || !container.contains(active)) {
+    return null;
+  }
+  return {
+    element: active,
+    container
+  };
+}
+
+/**
+ * Moves focus noted by `noteFocusWithin` to `target` when the change lost it
+ * (`isFocusLost`): it fell to the page because its element was removed, or
+ * it is still inside `hidden`, content the change hid but kept, which the
+ * browser is about to blur. Focus that survived the change, or that was never
+ * inside, is not moved. The ring follows the last input, so the calling
+ * component keeps modality tracking active
+ * (`useInteractionModalityTracking()`). Returns whether focus moved. Internal.
+ */
+export function moveFocusLeftBehind(note, target, hidden = null) {
+  if (note == null || target == null || !isFocusLost(hidden, note.container.ownerDocument)) {
+    return false;
+  }
+  focusForLastInput(target);
+  return true;
+}
+
+/**
+ * Move focus programmatically so its ring follows the last input. After pointer input the browser's
  * focus option keeps the element from matching `:focus-visible`, which is the
  * one way to reach an element the overlay does not render: the consumer's
  * autofocus target, the control that opened a Dialog, or a menu trigger the
  * caller renders. Pass `options` (for example `preventScroll`) as to `focus()`.
  *
- * `modality` defaults to the page's last input. A caller moving focus inside a
- * second document (a same-origin iframe, a Document Picture-in-Picture window)
- * passes that document's, which it tracks with `trackInteractionModalityIn`.
+ * `modality` defaults to the last input in the element's own document: the
+ * page's for an element on the page, and a second document's (a same-origin
+ * iframe, a Document Picture-in-Picture window) for an element there, which
+ * the component tracks by passing its element's ref to
+ * `useInteractionModalityTracking`.
  *
  * Make sure modality tracking is active (`useInteractionModalityTracking()`)
  * in the component that calls this.
  */
-export function focusForLastInput(element, options, modality = getInteractionModality()) {
+export function focusForLastInput(element, options, modality = getInteractionModality(element)) {
   // A text-entry field paints its own focus treatment to show where typing
   // goes, and an extra blur there can run validation or mark it touched. The
   // field's own window: one in an iframe or a Picture-in-Picture window is

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

@@ -1 +1 @@
-{"version":3,"file":"getNodeText.d.ts","sourceRoot":"","sources":["../../src/utils/getNodeText.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,OAAO,CAAC;AAErC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAkBnD"}
+{"version":3,"file":"getNodeText.d.ts","sourceRoot":"","sources":["../../src/utils/getNodeText.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,OAAO,CAAC;AAErC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAkBnD"}

package/dist/utils/getNodeText.js

@@ -9,13 +9,14 @@
  */
 
 import { isValidElement } from 'react';
+import { isRenderable } from "./isRenderable.js";
 /**
  * The plain text a node renders through strings, numbers and element
  * children, joined with spaces. Text a component renders internally, from
  * props other than `children`, is not reachable and yields `''`.
  */
 export function getNodeText(node) {
-  if (node == null || typeof node === 'boolean') {
+  if (!isRenderable(node)) {
     return '';
   }
   if (typeof node === 'string') {

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

@@ -1 +1 @@
-{"version":3,"file":"hitArea.d.ts","sourceRoot":"","sources":["../../src/utils/hitArea.ts"],"names":[],"mappings":"AA+BA,+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;AAodD,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":"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"}

package/dist/utils/hitArea.js

@@ -15,17 +15,15 @@
  *   a standalone control writes `watchHitArea`'s insets to an invisible
  *   coarse-only hit layer
  *
- * A finger needs a 44 × 44 px target, but a control may not grow on a phone,
- * and its hit area must never take a neighbour's taps. Each side grows toward
- * the minimum size and stops at half the gap to the nearest neighbour on that
- * side (0 when they touch), so two neighbours' areas meet in the middle and a
- * tap always goes to the nearer target. CSS cannot see where the neighbours
- * are, so a live control measures: only where the primary pointer is coarse,
- * only while on screen, and every control pending a measurement in one read
- * pass per frame (all reads, then all writes), up to a 4 ms budget, the rest
- * carried to the next frame. Until the first pass the
- * insets are 0, so first paint and server rendering never overlap anything.
  */
+
+// A finger needs a 44 × 44 px target, but a control may not grow on a phone,
+// and its hit area must never take a neighbor's taps. Each side grows toward
+// the minimum and stops at half the gap to the nearest neighbor on that side,
+// so a tap always goes to the nearer target. CSS cannot see the neighbors, so a
+// 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.
 import { observeContent } from "./sharedMutationObserver.js";
 
 /** A rect in client pixels. */
@@ -383,10 +381,9 @@ function scheduleAll() {
  * neighbour, and the next tap uses the fresh insets.
  */
 function onPress(event) {
-  // One listener for every watched control, on the document: a control, a
-  // row or a handle carries none of its own (a list's listeners stay the
-  // list's, spec:AST-103 FR5). The innermost watched element the press
-  // lands in is the one it is for.
+  // One listener on the document for every watched control, so a control, row
+  // or handle has none of its own (AST-103 FR5). The innermost watched element
+  // that the press lands in is the one it is for.
   for (let node = event.target instanceof Element ? event.target : null; node != null; node = node.parentElement) {
     if (watched.has(node)) {
       checkPress(node, event);
@@ -494,9 +491,9 @@ function observe(element, entry) {
 }
 
 /**
- * Everything that watches the page for hit areas: on only while the primary
- * pointer is coarse, so a mouse page runs no observer, timer or listener for
- * them (`spec:AST-094` FR24).
+ * Everything that watches the page for hit areas is on only while the
+ * primary pointer is coarse, so a mouse page runs no observer, timer or
+ * listener for them.
  */
 function startObserving() {
   if (view == null) {

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

@@ -1 +1 @@
-{"version":3,"file":"ime.d.ts","sourceRoot":"","sources":["../../src/utils/ime.ts"],"names":[],"mappings":"AA6DA,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAIV"}
+{"version":3,"file":"ime.d.ts","sourceRoot":"","sources":["../../src/utils/ime.ts"],"names":[],"mappings":"AAiCA,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAIV"}

package/dist/utils/ime.js

@@ -2,60 +2,32 @@
 
 /**
  * @file ime.ts
- * @input Receives a keyboard event (React SyntheticEvent's `nativeEvent`, or a
- *   native DOM KeyboardEvent) with optional `isComposing` / `keyCode`.
- * @output Exports `isImeKeyEvent`, the canonical predicate for "this keydown is
- *   part of an in-progress IME composition and must not be treated as a command".
- * @position Shared low-level utility; consumed by every editable/overlay surface
- *   that handles Enter/Escape/arrows in `onKeyDown` (Typeahead, PowerSearch,
- *   Dialog, ContextMenu, Tooltip, Chat composer, focus-trap Escape, ...).
- *
- * ── Why this exists (read once, here — do not re-explain at call sites) ──
- *
- * When a CJK user (Korean / Japanese / Chinese) is composing text via an IME,
- * the browser fires a `keydown` event to COMMIT or CANCEL the pending
- * composition (Enter commits the highlighted candidate; Escape cancels it;
- * ArrowUp/Down/Home/End navigate the candidate window). Crucially this
- * `keydown` fires BEFORE the `compositionend` event that actually writes the
- * committed text into the field. So a naive `onKeyDown` handler sees a bare
- * "Enter" or "Escape" and misreads the composition-commit/cancel as an
- * application command — accepting a typeahead suggestion, submitting a chat
- * message, closing a dialog/menu/tooltip, or saving a filter — mid-composition.
- * The fix is to detect the composing keydown and early-return before running
- * any command logic.
- *
- * Two signals, both needed:
- *
- *  1. `event.isComposing === true` — the modern, spec'd signal
- *     (https://www.w3.org/TR/uievents/#dom-keyboardevent-iscomposing). This is
- *     the primary check and is reliable in current evergreen browsers.
- *
- *  2. `event.keyCode === 229` — the legacy fallback. `229` is the sentinel
- *     keyCode browsers report for "the key event is being processed by an IME".
- *     It is still load-bearing: some IMEs and older Safari fire the composing
- *     `keydown` with `isComposing` NOT yet set to `true`, but DO report
- *     keyCode 229. Keeping both makes the guard robust across the browser
- *     matrix we support. Do not drop the 229 fallback without a browser-matrix
- *     audit.
- *
- * ── Which event object to pass ──
- *
- * React's SyntheticEvent for KeyboardEvent *does* surface `isComposing`, but to
- * avoid any cross-browser normalization gap prefer passing the *native* event
- * (`e.nativeEvent`) from React handlers — that is what BaseTypeahead,
- * PowerSearch, and the Chat composer do. Native DOM listeners (Dialog,
- * ContextMenu, Tooltip, focus-trap) pass the DOM `KeyboardEvent` directly.
- * The parameter is intentionally structurally typed so both shapes are accepted.
- *
- * Note: `keyCode` is deprecated on the DOM `KeyboardEvent` type but is still
- * present at runtime; we read it defensively via the optional structural field.
+ * @input A keyboard event (a React event's `nativeEvent`, or a native DOM
+ *   KeyboardEvent) with optional `isComposing` and `keyCode`
+ * @output `isImeKeyEvent`: whether a keydown is part of an IME composition and
+ *   must not act as a command
+ * @position Shared low-level utility for every surface that handles Enter,
+ *   Escape or arrows in `onKeyDown`
  */
 
+// During IME composition (Korean, Japanese, Chinese), the browser fires a
+// keydown to commit or cancel the composition before `compositionend`. A
+// plain handler sees Enter or Escape and runs a command mid-composition. So
+// return early on a composing keydown. Do not explain this again at call
+// sites.
+//
+// Both signals are needed. `isComposing` is the standard signal. keyCode 229
+// is the legacy fallback: some IMEs and older Safari send the composing
+// keydown with `isComposing` not yet true, but with keyCode 229. Do not drop
+// it without a browser-matrix audit.
+//
+// Prefer the native event (`e.nativeEvent`) from React handlers. The
+// parameter is structurally typed, so both event shapes work. `keyCode` is
+// deprecated in the DOM types but is still present at runtime.
+
 /**
- * The sentinel `keyCode` browsers report while a key event is being processed
- * by an IME (the composing keydown that fires before `compositionend`). See the
- * file header for why this legacy signal is still load-bearing alongside
- * `isComposing`.
+ * The sentinel `keyCode` that browsers report while an IME processes a key
+ * event. See the note above for why this legacy signal stays.
  */
 const IME_PROCESSING_KEY_CODE = 229;
 export function isImeKeyEvent(event) {

package/dist/utils/inputPresentation.d.ts

@@ -2,23 +2,23 @@
  * @file inputPresentation.ts
  * @input A presentation policy, the deprecated nativePicker value, and pointer type
  * @output The resolved picker surface for DateInput, DateTimeInput, and TimeInput
- * @position Shared presentation vocabulary owned by spec:AST-043
+ * @position Shared presentation vocabulary (AST-043)
  *
  * SYNC: When modified, update these files to stay in sync:
- * - /docs/specs/AST-043-input-presentation/spec.md (FR1–FR3 tables)
+ * - /docs/specs/AST-043-input-presentation/spec.md
  * - /packages/core/src/DateInput/DateInput.tsx
  * - /packages/core/src/DateTimeInput/DateTimeInput.tsx
  * - /packages/core/src/TimeInput/TimeInput.tsx
  */
-/** Picker-surface policy for date/time inputs (`spec:AST-043` FR1). */
+/** Picker-surface policy for date/time inputs. */
 export type InputPresentation = 'text-input' | 'popover' | 'bottom-sheet' | 'native' | 'adaptive-bottom-sheet' | 'adaptive-native';
-/** `presentation` for components without a text-only surface: all except `TimeInput` exclude `text-input` (AST-043). */
+/** `presentation` for components without a text-only surface: all except `TimeInput` exclude `text-input`. */
 export type PickerPresentation = Exclude<InputPresentation, 'text-input'>;
 /** The surface a resolved `InputPresentation` actually renders. */
 export type InputPresentationSurface = 'text-input' | 'desktop' | 'sheet' | 'native';
 /** The surface a resolved `PickerPresentation` renders: one where a picker opens. */
 export type PickerPresentationSurface = Exclude<InputPresentationSurface, 'text-input'>;
-/** Deprecated picker policy (`spec:AST-043` FR3). */
+/** Deprecated picker policy. */
 export type LegacyNativePicker = 'touch' | 'always' | 'never';
 /**
  * Typed as the narrower policy because the default opens a picker for every

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,uEAAuE;AACvE,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,SAAS,GACT,cAAc,GACd,QAAQ,GACR,uBAAuB,GACvB,iBAAiB,CAAC;AAEtB,wHAAwH;AACxH,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,qDAAqD;AACrD,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;;;;;;;;;;;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"}

package/dist/utils/inputPresentation.js

@@ -4,24 +4,24 @@
  * @file inputPresentation.ts
  * @input A presentation policy, the deprecated nativePicker value, and pointer type
  * @output The resolved picker surface for DateInput, DateTimeInput, and TimeInput
- * @position Shared presentation vocabulary owned by spec:AST-043
+ * @position Shared presentation vocabulary (AST-043)
  *
  * SYNC: When modified, update these files to stay in sync:
- * - /docs/specs/AST-043-input-presentation/spec.md (FR1–FR3 tables)
+ * - /docs/specs/AST-043-input-presentation/spec.md
  * - /packages/core/src/DateInput/DateInput.tsx
  * - /packages/core/src/DateTimeInput/DateTimeInput.tsx
  * - /packages/core/src/TimeInput/TimeInput.tsx
  */
 
-/** Picker-surface policy for date/time inputs (`spec:AST-043` FR1). */
+/** Picker-surface policy for date/time inputs. */
 
-/** `presentation` for components without a text-only surface: all except `TimeInput` exclude `text-input` (AST-043). */
+/** `presentation` for components without a text-only surface: all except `TimeInput` exclude `text-input`. */
 
 /** The surface a resolved `InputPresentation` actually renders. */
 
 /** The surface a resolved `PickerPresentation` renders: one where a picker opens. */
 
-/** Deprecated picker policy (`spec:AST-043` FR3). */
+/** Deprecated picker policy. */
 
 /**
  * Typed as the narrower policy because the default opens a picker for every

package/dist/utils/inputStream.d.ts

@@ -0,0 +1,17 @@
+/** Options for {@link subscribeInput}. */
+export interface InputSubscriptionOptions {
+    /**
+     * The subscriber calls `preventDefault()` on this event type, so the
+     * native listener must not be passive while it is subscribed.
+     * @default false
+     */
+    readonly cancels?: boolean;
+}
+/** The events a window's capture phase sees: its own, and the document's. */
+export type InputEventMap = WindowEventMap & DocumentEventMap;
+/**
+ * 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;
+//# sourceMappingURL=inputStream.d.ts.map