@jsenv/navi 0.29.402 → 0.29.404

package/dist/jsenv_navi.js

@@ -2,9 +2,9 @@
  * AI reading this file: read ../docs/AI_INSTRUCTIONS.md for context on
  * using @jsenv/navi as intended.
  */
-import { installImportMetaCssBuild, windowHeightSignal, windowWidthSignal, visualViewportHeightSignal, visualViewportWidthSignal, getAppHeight, getAppWidth, coarsePointerSignal, smallTouchScreenSignal } from "./jsenv_navi_side_effects.js";
-export { disableVirtualKeyboardOverlay } from "./jsenv_navi_side_effects.js";
-import { createPubSub, elementIsFocusable, createIterableWeakSet, dispatchInternalCustomEvent, dispatchCustomEvent, getVisuallyVisibleInfo, getFirstVisuallyVisibleAncestor, getElementSignature, findEvent, createValueEffect, findFocusDelegateTarget, findFocusable, scrollIntoViewThroughScrollables, allowWheelThrough, dispatchPublicCustomEvent, resolveCSSColor, getScrollContainerSet, ELEMENT_SIZE_CHANGE, findSelfOrAncestorFixedPosition, visibleRectEffect, pickPositionRelativeTo, getBorderSizes, getPaddingSizes, applyNewPosition, measureLongestVisualLineWidth, chainEvent, keepTouchRefusable, isPressDrivenClick, waitForTap, waitForPressHeld, suppressClickAfterGesture, startDragToTravel, dragSourceThatStoodDown, markDragSource, refuseDragTo, startDragTo, installPanZoom, createInternalCustomEvent, getKeyboardEventDefaultAction, activeElementSignal, normalizeStyle, mergeOneStyle, getPositionedParent, normalizeStyles, createGroupTransitionController, getBorderRadius, preventIntermediateScrollbar, createOpacityTransition, getScrollContainer, watchWheelTravel, scrollRoomTowards, isTouchDrivenEvent, scrollIntoViewScoped, closestOpenableAncestor, isAncestorOpen, isDisplayedDespiteClosedAncestor, observeAncestorOpenState, getAncestorOpenType, findBefore, findAfter, resolveCSSSize, hasCSSSizeUnit, releaseWheelGesture, getScrollIntoViewScopedOffsets, wheelGestureIsTakenFrom, claimWheelGesture, initFocusGroup, stringifyStyle as stringifyStyle$1, isScrollable, resolveOklchLightness, contrastColor, trapScrollInside, parsePositionArea, snapToPixel, trapFocusInside, onAncestorReopen, isPressDisputedByDrag, canScroll, measureWidestChildRow, performTabNavigation, dragAfterIntent, stickyAsRelativeCoords, createDragToMoveGestureController, getDropTargetInfo, setStyles, useActiveElement } from "@jsenv/dom";
+import { installImportMetaCssBuild, isSignal, getSignalType, findControlProxy, findControlRoot, isControl, findControlHost, isNumberInput, findControlProxyTargetController, findNearestControlHost, dispatchRequestSetUIState, getUIStateFromElement, getUIStateControllerById, windowHeightSignal, windowWidthSignal, visualViewportHeightSignal, visualViewportWidthSignal, getAppHeight, getAppWidth, PSEUDO_STATE_DEFAULT, PSEUDO_NAMED_STYLES_DEFAULT, initPseudoStyles, applyStyle, getParentControl, isControlRoot, readControlValue, dispatchRequestClearUIState, dispatchRequestResetUIState, findClosestControlWithAction, isEditableTarget, coarsePointerSignal, isKeyboardModality, onUIStateControllerDestroyed, getRadioSiblings, findProxyControllers, addInputEffect, findControlProxyTarget, isMatchingFocusVisible, onUIStateControllerCreated, toDomValue, PSEUDO_CLASSES, subscribeToPseudoState, resolveInputProps, smallTouchScreenSignal, timeStringToSeconds, parseTimeParts, formatTimeParts, seedDefaultValueFromSignal, minutesFromTime as minutesFromTime$1, timeFromMinutes } from "./jsenv_navi_side_effects.js";
+export { disableVirtualKeyboardOverlay, getNowHours, getNowHoursRoundedToStep, isToday } from "./jsenv_navi_side_effects.js";
+import { createPubSub, elementIsFocusable, createIterableWeakSet, getVisuallyVisibleInfo, getFirstVisuallyVisibleAncestor, getElementSignature, findEvent, createValueEffect, findFocusDelegateTarget, findFocusable, scrollIntoViewThroughScrollables, allowWheelThrough, dispatchPublicCustomEvent, resolveCSSColor, getScrollContainerSet, ELEMENT_SIZE_CHANGE, dispatchCustomEvent, findSelfOrAncestorFixedPosition, visibleRectEffect, pickPositionRelativeTo, getBorderSizes, getPaddingSizes, applyNewPosition, measureLongestVisualLineWidth, dispatchInternalCustomEvent, chainEvent, keepTouchRefusable, isPressDrivenClick, waitForTap, waitForPressHeld, suppressClickAfterGesture, startDragToTravel, dragSourceThatStoodDown, markDragSource, refuseDragTo, startDragTo, installPanZoom, createInternalCustomEvent, getKeyboardEventDefaultAction, activeElementSignal, normalizeStyle, mergeOneStyle, getPositionedParent, normalizeStyles, createGroupTransitionController, getBorderRadius, preventIntermediateScrollbar, createOpacityTransition, getScrollContainer, watchWheelTravel, scrollRoomTowards, isTouchDrivenEvent, scrollIntoViewScoped, closestOpenableAncestor, isAncestorOpen, isDisplayedDespiteClosedAncestor, observeAncestorOpenState, getAncestorOpenType, findBefore, findAfter, resolveCSSSize, hasCSSSizeUnit, releaseWheelGesture, getScrollIntoViewScopedOffsets, wheelGestureIsTakenFrom, claimWheelGesture, initFocusGroup, stringifyStyle as stringifyStyle$1, isScrollable, resolveOklchLightness, contrastColor, trapScrollInside, parsePositionArea, snapToPixel, trapFocusInside, onAncestorReopen, isPressDisputedByDrag, canScroll, measureWidestChildRow, performTabNavigation, dragAfterIntent, stickyAsRelativeCoords, createDragToMoveGestureController, getDropTargetInfo, setStyles, useActiveElement } from "@jsenv/dom";
 export { chainEvent, clickIsSuppressed, contrastColor, createDragGestureController, dragAfterIntent, findEvent, markDragSource, startDragTo } from "@jsenv/dom";
 import { signal, computed, effect, untracked, batch, useComputed, useSignal } from "@preact/signals";
 import { options, isValidElement, createContext, render, h, toChildArray, cloneElement, createElement, Fragment as Fragment$1 } from "preact";
@@ -12,7 +12,7 @@ import { useErrorBoundary, useLayoutEffect, useContext, useCallback, useRef, use
 import { humanizeI18n, setRuntimeLangSource, formatDuration, formatMonth, formatDay, resolveTimeRangePrecision, formatDatePlaceholder, toDate, getRelativeDay, formatDayRelative, formatMonthPlaceholder, formatWeekPlaceholder, formatDatetimePlaceholder, formatDatetime, toTimeOfDay, formatTimeOfDay, formatTime, formatMinuteDuration, formatSecondDuration, formatHourDuration, formatTimeRelative, formatNumber, interpolateText, installInterpolateJsx } from "@jsenv/humanize";
 export { createI18n, formatDatetime, formatDay, formatDayRelative, formatDuration, formatHourDuration, formatMinuteDuration, formatMonth, formatNumber, formatSecondDuration, formatTime, formatTimeOfDay, formatTimeRange, formatTimeRelative, interpolateText } from "@jsenv/humanize";
 import { jsxs, jsx, Fragment } from "preact/jsx-runtime";
-import { CHAR_CLASS_PRESETS, TYPE_RULE, durationContainsNaN, compareTwoDurations, durationToSeconds, DISPLAYABLE_RULE, MAX_LINE_BREAKS_RULE, NO_EMOJI_RULE, SINGLE_SPACE_RULE, createValidity, resolveCharClass, getCharClassMessageKey, compileCharClassAnchored, compileCharClass, parseDuration, durationToISOString } from "@jsenv/validity";
+import { TYPE_RULE, durationContainsNaN, compareTwoDurations, durationToSeconds, DISPLAYABLE_RULE, MAX_LINE_BREAKS_RULE, NO_EMOJI_RULE, SINGLE_SPACE_RULE, createValidity, resolveCharClass, getCharClassMessageKey, compileCharClassAnchored, compileCharClass, parseDuration, durationToISOString } from "@jsenv/validity";
 export { compareTwoDurations, durationContainsNaN, durationToHours, durationToISOString, durationToMinutes, durationToNumber, durationToSeconds, durationToString, parseDuration } from "@jsenv/validity";
 import { Suspense, createPortal, forwardRef } from "preact/compat";
 
@@ -1577,27 +1577,6 @@ naviI18n.addAll({
   },
 });
 
-const isSignal = (value) => {
-  return getSignalType(value) !== null;
-};
-
-const BRAND_SYMBOL = Symbol.for("preact-signals");
-const getSignalType = (value) => {
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-
-  if (value.brand !== BRAND_SYMBOL) {
-    return null;
-  }
-
-  if (typeof value._fn === "function") {
-    return "computed";
-  }
-
-  return "signal";
-};
-
 /*
  * The network policy: one declaration saying whether a request may go out,
  * read by the action layer rather than by every callback.
@@ -4757,1118 +4736,6 @@ const actionRunEffect = (
   return actionRunnedByThisEffect;
 };
 
-/**
- * DOM utilities for navigating the control element hierarchy.
- *
- * A control is a self-contained interactive widget. Its DOM structure can be
- * either flat (host only) or layered (wrapper + host):
- *
- * Flat — the element is both the root and the host:
- * ```html
- * <button navi-control navi-control-host>Click me</button>
- * ```
- *
- * Layered — a visual wrapper surrounds a native input that is the real host:
- * ```html
- * <span navi-control>           ← wrapper: root of the control's DOM subtree
- *   <input navi-control-host /> ← host: holds controlProps, value, UI state, constraints
- * </span>
- * ```
- *
- * Attribute roles:
- *  - `navi-control`           boolean, on the wrapper/root; marks the control boundary
- *  - `navi-control-host`      boolean, on the host; set automatically by `useInteractiveProps`
- *
- * See control_proxy.js for the `navi-control-proxy-for` pattern.
- */
-
-/**
- * Returns the host element inside `el` — the element that holds the control's
- * value, UI state, and constraints (i.e. the element onto which
- * `useInteractiveProps` spreads `controlProps` and its event handlers).
- *
- * Returns `null` when `el` is itself the host (no separate wrapper).
- */
-const findControlHost = (el) => {
-  if (el.hasAttribute("navi-control-host")) {
-    return el;
-  }
-  return el.querySelector("[navi-control-host]");
-};
-/**
- * The control this element belongs to, wherever it sits relative to it.
- *
- * `findControlHost` above answers for a control's own DOM (itself, or the native
- * element it wraps). This one is for something that is not part of a control but
- * has to reach one — an interaction declared on a box (see
- * interaction/interactions.js), which may be the control, may sit inside it, or
- * may be a wrapper around exactly one. Nearest wins in that order, and the answer
- * is null when there is no control the box belongs to: not every box lives in
- * one, and a box laying out several controls (a row of badges, a toolbar) is
- * held by none of them — its interactions are its own, and a press on its empty
- * part is not a press on the first control it happens to contain.
- */
-const findNearestControlHost = (el) => {
-  // Itself, then upwards — the box is inside a button, or is one.
-  const selfOrAncestor = el.closest("[navi-control-host]");
-  if (selfOrAncestor) {
-    return selfOrAncestor;
-  }
-  // …then downwards, only when the box wraps a single control. Counted by
-  // control, not by host: a picker holds the hosts of its popup content, and a
-  // box around that one picker is still around one control.
-  let single = null;
-  for (const host of el.querySelectorAll("[navi-control-host]")) {
-    const controlRoot = host.closest("[navi-control]") || host;
-    const controlAbove = controlRoot.parentElement.closest("[navi-control]");
-    if (controlAbove && el.contains(controlAbove)) {
-      continue;
-    }
-    if (single && single !== controlRoot) {
-      return null;
-    }
-    single = controlRoot;
-  }
-  return single ? findControlHost(single) : null;
-};
-const isControlRoot = (el) => {
-  return el.hasAttribute("navi-control");
-};
-const isControlHost = (el) => {
-  return el.hasAttribute("navi-control-host");
-};
-const isControl = (el) => {
-  return isControlRoot(el) || isControlHost(el);
-};
-
-/**
- * Returns the nearest ancestor of `el` (exclusive of `el`'s own control) that
- * has a `[data-action]` attribute.
- *
- * The search walks up `parentElement` manually (rather than using `.closest()`)
- * so it can stop at hard boundaries.
- *
- * **`[navi-control="picker"]` boundary**: a picker is a hard stop for what is
- * inside its popup. Elements in there can reach the picker itself, but nothing
- * above it — an input inside a picker must not submit the form around it. The
- * picker's own trigger is not inside it: a picker pressed as a whole (a confirm
- * picker sending the form around it, see picker_confirm.jsx) stands in that
- * form like any control there, and reaches it.
- *
- * ```html
- * <form data-action="outer">              ← found from the picker's own input,
- *   <button navi-control="picker" data-action="p">  NOT from inside its popup
- *     <input navi-control-host />         ← el (the picker's own input)
- *     <div popover data-picker-content>
- *       <input navi-control-host />       ← el (in picker popover): stops at the picker
- *     </div>
- *   </button>
- * </form>
- * ```
- */
-const findClosestControlWithAction = (el) => {
-  let current = el;
-  while (current) {
-    if (current.hasAttribute("data-action")) {
-      return current;
-    }
-    if (isPickerBoundaryFor(current, el)) {
-      return undefined;
-    }
-    current = current.parentElement;
-  }
-  return undefined;
-};
-const isPickerBoundaryFor = (candidate, el) => {
-  if (candidate.getAttribute("navi-control") !== "picker") {
-    return false;
-  }
-  const content = el.closest("[data-picker-content]");
-  return Boolean(content) && candidate.contains(content);
-};
-
-/**
- * Returns the closest ancestor control element of `el` — i.e. the nearest
- * `[navi-control]` element that is not the control `el` belongs to.
- *
- * `navi-control` is only on wrapper elements, never on hosts. So
- * `el.closest("[navi-control]")` from a host returns that host's own wrapper,
- * and one more `.parentNode.closest("[navi-control]")` reaches a true ancestor:
- *
- * ```html
- * <button navi-control>              ← outer control  (returned)
- *   <span navi-control>              ← inner wrapper  (skipped via parentNode)
- *     <input navi-control-host />    ← el
- *   </span>
- * </button>
- * ```
- */
-const getParentControl = (el) => {
-  const ownControlRoot = el.closest("[navi-control]");
-  const parentControlRoot = ownControlRoot.parentNode.closest("[navi-control]");
-  return parentControlRoot;
-};
-
-/**
- * Returns the root element of the control that `el` belongs to, or `null` if
- * `el` is not part of a control.
- *
- * Use this when you have an element that may be a host (inner input) and need
- * the visual boundary of its control — e.g. to anchor a callout, track
- * mousedown interactions, or measure the control's bounding box.
- */
-const findControlRoot = (el) => {
-  if (el.hasAttribute("navi-control")) {
-    return el;
-  }
-  if (el.hasAttribute("navi-control-host")) {
-    return el.closest("[navi-control]");
-  }
-  return null;
-};
-
-/**
- * Parses a time string into seconds.
- * Accepts:
- *   - number: returned as-is (already in seconds)
- *   - "HH:MM" string: converted to seconds (e.g. "00:30" → 1800, "01:00" → 3600)
- *   - undefined/null: returned as-is
- */
-const timeStringToSeconds = (timeString) => {
-  if (typeof timeString !== "string") {
-    return timeString;
-  }
-  const colonIndex = timeString.indexOf(":");
-  if (colonIndex === -1) {
-    return Number(timeString);
-  }
-  const hours = parseInt(timeString.slice(0, colonIndex), 10);
-  const minutes = parseInt(timeString.slice(colonIndex + 1), 10);
-  return (hours * 60 + minutes) * 60;
-};
-
-const isToday = (value) => {
-  if (!value) {
-    return false;
-  }
-  const now = new Date();
-  const todayStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
-  if (typeof value === "string") {
-    return value === todayStr;
-  }
-  if (typeof value === "number") {
-    const d = new Date(value);
-    const s = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-    return s === todayStr;
-  }
-  if (value instanceof Date) {
-    const s = `${value.getFullYear()}-${String(value.getMonth() + 1).padStart(2, "0")}-${String(value.getDate()).padStart(2, "0")}`;
-    return s === todayStr;
-  }
-  return false;
-};
-
-/**
- * Returns the current time as "HH:MM", with an optional minute offset.
- *
- * @param {number} [offsetMinutes=0] - Minutes to add (negative = subtract).
- *   E.g. getNowHours(-5) returns "now minus 5 minutes".
- *
- * @example
- * getNowHours()       // "14:30"
- * getNowHours(-5)     // "14:25"
- */
-const getNowHours = (offsetMinutes = 0) => {
-  const now = new Date();
-  const totalMinutes = now.getHours() * 60 + now.getMinutes() + offsetMinutes;
-  const clamped =
-    totalMinutes < 0
-      ? 0
-      : totalMinutes > 23 * 60 + 59
-        ? 23 * 60 + 59
-        : totalMinutes;
-  const h = Math.floor(clamped / 60);
-  const m = clamped % 60;
-  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
-};
-
-/**
- * Returns the current time rounded up to the nearest step boundary,
- * with an optional minute offset applied first.
- *
- * This is useful to compute a step-aligned `min` for a time picker:
- * passing it ensures the first available slot is always on a step boundary.
- *
- * @param {number} stepMinutes - Step size in minutes (e.g. 30).
- * @param {number} [offsetMinutes=0] - Minutes to add before rounding (negative = subtract).
- *
- * @example
- * // At 9:32, step 30, offset -5 → raw = 9:27 → ceil to 30 → "09:30"
- * // At 9:38, step 30, offset -5 → raw = 9:33 → ceil to 30 → "10:00"
- * getNowHoursRoundedToStep(30, -5)
- */
-const getNowHoursRoundedToStep = (stepMinutes, offsetMinutes = 0) => {
-  const now = new Date();
-  const totalMinutes = now.getHours() * 60 + now.getMinutes() + offsetMinutes;
-  const aligned = Math.ceil(totalMinutes / stepMinutes) * stepMinutes;
-  const clamped =
-    aligned < 0 ? 0 : aligned > 23 * 60 + 59 ? 23 * 60 + 59 : aligned;
-  const h = Math.floor(clamped / 60);
-  const m = clamped % 60;
-  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
-};
-
-/**
- * "HH:MM" and its two numbers, in both directions — what any control made of an
- * hour beside a minute (fields, wheels) aggregates to and is placed from. Held
- * as numbers, written on two digits: how they are shown is each control's own
- * business.
- */
-const parseTimeParts = (time) => {
-  if (typeof time !== "string") {
-    return null;
-  }
-  const match = /^(\d{1,2}):(\d{1,2})/.exec(time);
-  if (!match) {
-    return null;
-  }
-  return { hour: Number(match[1]), minute: Number(match[2]) };
-};
-
-// Half a time is not a time: a control holding one of the two and nothing in
-// the other has no value at all, and a form has nothing to send about it.
-const formatTimeParts = (hour, minute) => {
-  if (
-    hour === "" ||
-    hour === undefined ||
-    minute === "" ||
-    minute === undefined
-  ) {
-    return undefined;
-  }
-  return `${padTwo$1(hour)}:${padTwo$1(minute)}`;
-};
-
-const minutesFromTime$1 = (time) => {
-  const parts = parseTimeParts(time);
-  if (!parts) {
-    return null;
-  }
-  return parts.hour * 60 + parts.minute;
-};
-
-// Not folded back into the day: 1440 is "24:00", the end of the day a span can
-// run into.
-const timeFromMinutes = (minutes) => {
-  return `${padTwo$1(Math.floor(minutes / 60))}:${padTwo$1(minutes % 60)}`;
-};
-
-const padTwo$1 = (value) => String(value).padStart(2, "0");
-
-// What a bound signal's type says is what its VALUE is (a validity type);
-// what a control's `type` says is what the control IS. This table is the whole
-// bridge between the two vocabularies: a value type with a row here asks for
-// that control, one without a row asks for nothing and the control keeps its
-// own default. "string" has no row on purpose — it is the value every typeless
-// control already holds — and a name only one side knows must never cross as
-// is: a control type nobody implements is a plain text field that writes an
-// object as "[object Object]" (see warnOnUnknownPickerType in picker.jsx).
-// Numeric value types map to navi_number rather than the native type="number"
-// (spinner buttons, poor UX).
-const CONTROL_TYPE_BY_SIGNAL_TYPE = {
-  boolean: "checkbox",
-  number: "navi_number",
-  integer: "navi_number",
-  float: "navi_number",
-  ratio: "navi_number",
-  longitude: "navi_number",
-  latitude: "navi_number",
-  second: "navi_number",
-  minute: "navi_number",
-  hour: "navi_number",
-  year: "navi_number",
-  percentage: "navi_percentage",
-  date: "date",
-  month: "month",
-  week: "week",
-  time: "time",
-  datetime: "datetime",
-  duration: "duration",
-  color: "color",
-  email: "email",
-  url: "url",
-  array: "array",
-  object: "object",
-};
-
-// Conceptual navi types: defaults, plus the host type they resolve to.
-// `navi-input-type` keeps the type the caller asked for once the host has
-// become something plainer — it is what says the value is a number (see
-// isNumberInput), and what lets constraint messages use domain-specific
-// wording instead of the generic "Ce nombre doit être...".
-// A type a picker preset draws (navi_time, navi_minute: see picker_preset.jsx)
-// has no row: resolveInputProps runs before the preset resolver, and a row
-// would turn the type into its host before the preset resolver reads it. The
-// preset hands the host type on itself.
-const NAVI_TYPE_DEFAULTS = {
-  navi_percentage: {
-    "type": "navi_number",
-    "navi-input-type": "percentage",
-    "min": 0,
-    "max": 100,
-    "step": 1,
-  },
-  navi_number: {
-    "type": "text",
-    "navi-input-type": "number",
-    "autoCorrect": "off",
-    "spellcheck": false,
-    "autoComplete": "off",
-  },
-};
-
-// The navi input types whose value IS a number.
-const NUMBER_NAVI_INPUT_TYPE_SET = new Set([
-  "number",
-  "percentage",
-  "hour",
-  "minute",
-  "second",
-]);
-
-/**
- * Whether the control holds a number — asked of what the control IS, never of
- * `inputMode`. In HTML `inputmode` picks the on-screen keyboard and says
- * nothing about the value: a licence number, a postal code or a card number
- * with a check letter all want the digit keypad while staying strings. What a
- * number field is spelled `type="number"`, or a navi type that resolves to a
- * text host and leaves `navi-input-type` behind to say what it was.
- */
-const isNumberInput = (type, naviInputType) => {
-  if (type === "number") {
-    return true;
-  }
-  return NUMBER_NAVI_INPUT_TYPE_SET.has(naviInputType);
-};
-
-/**
- * resolveInputProps — normalizes input-related props that are shared across
- * `<Picker>`, `<Input>` (textual) and `<Range>`. Mutates the props object in place.
- *
- * Normalization is applied recursively: a navi type may resolve to another navi
- * type (e.g. `navi_percentage` → `navi_number` → `text`), and each step applies its
- * own formatters and defaults before moving to the next.
- *
- * Steps applied for each type:
- * 1. Record the original navi type in `props["navi-input-type"]` (first call only).
- * 2. Apply defaults for the current type (min, max, step, and any other props),
- *    only when the prop is not already set.
- * 3. Apply min/max formatters (e.g. HH:MM string → number for duration types,
- *    Date → formatted string for date/time types).
- * 4. Apply step formatter (same conversion rules).
- * 5. Remap `props.type` to the target type defined by the current type's defaults,
- *    then recurse.
- *
- * Supported navi types and their targets:
- * - `navi_percentage` → `navi_number`  (0–100, step 1)
- * - `navi_number`     → `text`         (inputMode="numeric", no spin buttons implied)
- *
- * Standard HTML input types with formatters:
- * - `date`, `month`, `week`, `time`, `datetime-local`, `datetime`:
- *   min/max accept `Date` instances or timestamps and are converted to the
- *   string format expected by the native input.
- * - `time`, `datetime-local`, `datetime`:
- *   step accepts `"HH:MM"` and is converted to seconds.
- */
-/**
- * A bound signal that carries a default of its own says the same thing on every
- * control: the control starts there, uncontrolled, and a reset goes back to it.
- * Uncontrolled here is about where the control starts, not about whether it
- * follows the signal — the binding stays two-way either way (see
- * stateFromSignal in control_hooks.jsx) — nor about what a form counts as
- * held: that is the signal's content (isUIStateHeld in held_ui_state.js), and a
- * stateSignal holds its default. Written once and used by everything
- * that takes a `signal`, so one signal cannot mean two different things
- * depending on which control it was handed to.
- */
-const seedDefaultValueFromSignal = (props) => {
-  const signalOptions = props.signal?.options;
-  if (!signalOptions) {
-    return;
-  }
-  if (Object.hasOwn(props, "defaultValue")) {
-    // explicit defaultValue prop prevails
-    return;
-  }
-  // Snapshot the signal's current default so that resetUIState restores to the
-  // original default — not the value the signal had at the time of the last
-  // re-render.
-  const defaultValue = signalOptions.getDefaultValue(false);
-  if (defaultValue !== undefined) {
-    props.defaultValue = defaultValue;
-  }
-};
-
-const resolveInputProps = (props, { controlType = "input" } = {}) => {
-  // `signal` carries a bound state signal. It is left on `props` on purpose:
-  // `createControlInfo` (control_hooks.jsx) reads it to seed the state and to
-  // follow it, and `onUIAction` (ui_state_controller.js) writes user
-  // interactions back into it. Here we only derive input defaults (type/min/max,
-  // defaultValue/defaultChecked) from the signal's `options`, so the control
-  // ends up uncontrolled-with-default while still bound to the signal.
-  const signal = props.signal;
-  if (signal) {
-    const signalOptions = signal.options;
-    if (signalOptions) {
-      for (const key of ["min", "max", "step"]) {
-        if (props[key] === undefined && signalOptions[key] !== undefined) {
-          props[key] = signalOptions[key];
-        }
-      }
-      if (props.type === undefined && signalOptions.type !== undefined) {
-        const typeFromSignal = CONTROL_TYPE_BY_SIGNAL_TYPE[signalOptions.type];
-        // A value type and the control for it usually agree — a date-typed
-        // signal wants a date field — but a boolean one maps to a checkbox, and
-        // a picker made into a checkbox is not a picker with a different look:
-        // it is another control, with no popup to open. A picker asked to hold
-        // a yes/no keeps its two rows and stays itself.
-        const wouldChangeWhatTheControlIs =
-          controlType === "picker" &&
-          (typeFromSignal === "checkbox" || typeFromSignal === "radio");
-        if (typeFromSignal !== undefined && !wouldChangeWhatTheControlIs) {
-          props.type = typeFromSignal;
-        }
-      }
-    }
-
-    const isCheckable = props.type === "checkbox" || props.type === "radio";
-    if (isCheckable) {
-      if (Object.hasOwn(props, "defaultChecked")) ; else {
-        // If no explicit defaultChecked, derive it from the signal's default
-        // value so that resetUIState restores to the original default.
-        // Only a stateSignal carries a default of its own; a plain signal has
-        // no `options` at all, hence the optional read.
-        const defaultVal = signalOptions?.getDefaultValue(false);
-        if (defaultVal === undefined) ; else if (props.type === "radio") {
-          if (defaultVal === true) {
-            props.defaultChecked = true;
-          } else if (
-            Object.hasOwn(props, "value") &&
-            defaultVal === props.value
-          ) {
-            props.defaultChecked = true;
-          }
-        } else if (typeof defaultVal === "boolean") {
-          // Standalone checkbox bound to a boolean signal.
-          props.defaultChecked = defaultVal;
-        } else {
-          // Checkbox is a group member: defaultVal is the array of
-          // selected item values.
-          const checkboxValue = props.value;
-          props.defaultChecked =
-            Array.isArray(defaultVal) && defaultVal.includes(checkboxValue);
-        }
-      }
-      return;
-    }
-
-    seedDefaultValueFromSignal(props);
-  }
-
-  const currentType = props.type;
-  // Apply min/max/step formatters before anything else — this must run even for
-  // standard HTML types (date, time, etc.) that have no NAVI_TYPE_DEFAULTS entry.
-  const currentTypeMinMaxFormatter = MIN_MAX_FORMATTER_BY_TYPE[currentType];
-  const currentTypeStepFormatter = STEP_FORMATTER_BY_TYPE[currentType];
-  if (currentTypeMinMaxFormatter) {
-    props.min = currentTypeMinMaxFormatter(props.min);
-    props.max = currentTypeMinMaxFormatter(props.max);
-  }
-  if (currentTypeStepFormatter) {
-    props.step = currentTypeStepFormatter(props.step);
-  }
-
-  // For navi_number: choose inputMode based on whether step/min/max suggest decimals.
-  // inputMode="numeric" (integer keyboard) vs "decimal" (keyboard with decimal separator).
-  if (currentType === "navi_number") {
-    if (props.inputMode === undefined) {
-      props.inputMode =
-        hasDecimalPlaces(props.step) ||
-        hasDecimalPlaces(props.min) ||
-        hasDecimalPlaces(props.max)
-          ? "decimal"
-          : "numeric";
-    }
-  }
-
-  const { charGuard } = props;
-  if (charGuard) {
-    if (charGuard === true || charGuard === "auto") {
-      // Auto-resolve charGuard from context.
-      let charGuardResolved;
-      const inputMode = props.inputMode;
-      if (inputMode === "numeric") {
-        charGuardResolved = "numeric";
-      } else if (inputMode === "decimal") {
-        charGuardResolved = "decimal";
-      } else if (currentType === "tel") {
-        charGuardResolved = "tel";
-      } else if (currentType === "email") {
-        charGuardResolved = "email";
-      }
-      if (charGuardResolved !== undefined) {
-        props.charGuard = charGuardResolved;
-      }
-    }
-    // charGuard is now resolved: derive inputMode from it if not already set.
-    if (props.inputMode === undefined && props.charGuard) {
-      const autoMode = INPUT_MODE_FROM_CHAR_GUARD[props.charGuard];
-      if (autoMode) {
-        props.inputMode = autoMode;
-      }
-    }
-    // Build pattern from the resolved charGuard (preset name → class, or raw class passthrough).
-    if (props.pattern === undefined && props.charGuard) {
-      const charClass = CHAR_CLASS_PRESETS[props.charGuard] ?? props.charGuard;
-      props.pattern = `${charClass}*`;
-    }
-  }
-
-  // Compute maxLength from max when inputMode is numeric/decimal.
-  // Done here (after inputMode is set) so controller.props has the resolved value.
-  if (props.maxLength === undefined) {
-    if (props.inputMode === "numeric") {
-      const { min, max } = props;
-      if (max === undefined) ; else {
-        const canBeNegative = min === undefined ? max < 0 : min < 0;
-        const signCharCount = canBeNegative ? 1 : 0;
-        const integerDigitCount = String(Math.floor(Math.abs(max))).length;
-        props.maxLength = signCharCount + integerDigitCount;
-      }
-    } else if (props.inputMode === "decimal") {
-      const { min, max, step } = props;
-      if (max === undefined) ; else if (step === undefined) ; else {
-        const canBeNegative = min === undefined ? max < 0 : min < 0;
-        const signCharCount = canBeNegative ? 1 : 0;
-        const integerDigitCount = String(Math.floor(Math.abs(max))).length;
-        const stepStr = String(step);
-        const dotIndex = stepStr.indexOf(".");
-        // integer step + decimal inputMode is an unusual combo, but we stay consistent:
-        // no decimal part in maxLength since valid values are whole numbers anyway
-        const isIntegerStep = dotIndex === -1;
-        const decimalSignCharCount = isIntegerStep ? 0 : 1;
-        const decimalDigitCount = isIntegerStep
-          ? 0
-          : stepStr.length - dotIndex - 1;
-        props.maxLength =
-          signCharCount +
-          integerDigitCount +
-          decimalSignCharCount +
-          decimalDigitCount;
-      }
-    }
-  }
-
-  // Resolve maxLengthGuard boolean/auto → the computed maxLength number.
-  if (props.maxLengthGuard === true || props.maxLengthGuard === "auto") {
-    props.maxLengthGuard =
-      typeof props.maxLength === "number" ? props.maxLength : undefined;
-  }
-
-  const currentTypeDefaults = NAVI_TYPE_DEFAULTS[currentType];
-  if (!currentTypeDefaults) {
-    return;
-  }
-
-  for (const key of Object.keys(currentTypeDefaults)) {
-    if (props[key] === undefined) {
-      props[key] = currentTypeDefaults[key];
-    }
-  }
-  const targetType = currentTypeDefaults.type;
-  props.type = targetType;
-  resolveInputProps(props);
-};
-
-// Presets that imply a specific mobile keyboard inputMode.
-const INPUT_MODE_FROM_CHAR_GUARD = {
-  numeric: "numeric",
-  pin: "numeric",
-  card: "numeric",
-  tel: "tel",
-  decimal: "decimal",
-};
-
-const normalizeToDate = (value) => {
-  if (value === undefined || value === null) {
-    return null;
-  }
-  if (typeof value === "number") {
-    return new Date(value);
-  }
-  if (value instanceof Date) {
-    return value;
-  }
-  return null;
-};
-
-const toInputDate = (value) => {
-  const date = normalizeToDate(value);
-  if (!date) {
-    return value;
-  }
-  const yyyy = date.getFullYear();
-  const mm = String(date.getMonth() + 1).padStart(2, "0");
-  const dd = String(date.getDate()).padStart(2, "0");
-  return `${yyyy}-${mm}-${dd}`;
-};
-const toInputMonth = (value) => {
-  const date = normalizeToDate(value);
-  if (!date) {
-    return value;
-  }
-  const yyyy = date.getFullYear();
-  const mm = String(date.getMonth() + 1).padStart(2, "0");
-  return `${yyyy}-${mm}`;
-};
-const toInputWeek = (value) => {
-  const date = normalizeToDate(value);
-  if (!date) {
-    return value;
-  }
-  // ISO week number
-  const d = new Date(date);
-  d.setHours(0, 0, 0, 0);
-  d.setDate(d.getDate() + 3 - ((d.getDay() + 6) % 7));
-  const yearStart = new Date(d.getFullYear(), 0, 4);
-  const week =
-    Math.round(
-      ((d - yearStart) / 86400000 - 3 + ((yearStart.getDay() + 6) % 7)) / 7,
-    ) + 1;
-  return `${d.getFullYear()}-W${String(week).padStart(2, "0")}`;
-};
-const toInputTime = (value) => {
-  const date = normalizeToDate(value);
-  if (!date) {
-    return value;
-  }
-  const hh = String(date.getHours()).padStart(2, "0");
-  const mm = String(date.getMinutes()).padStart(2, "0");
-  return `${hh}:${mm}`;
-};
-const toInputDatetime = (value) => {
-  const date = normalizeToDate(value);
-  if (!date) {
-    return value;
-  }
-  const yyyy = date.getFullYear();
-  const mm = String(date.getMonth() + 1).padStart(2, "0");
-  const dd = String(date.getDate()).padStart(2, "0");
-  const hh = String(date.getHours()).padStart(2, "0");
-  const min = String(date.getMinutes()).padStart(2, "0");
-  return `${yyyy}-${mm}-${dd}T${hh}:${min}`;
-};
-
-const MIN_MAX_FORMATTER_BY_TYPE = {
-  "date": toInputDate,
-  "month": toInputMonth,
-  "week": toInputWeek,
-  "time": toInputTime,
-  "datetime-local": toInputDatetime,
-  "datetime": toInputDatetime,
-};
-const STEP_FORMATTER_BY_TYPE = {
-  "time": timeStringToSeconds,
-  "datetime-local": timeStringToSeconds,
-  "datetime": timeStringToSeconds,
-};
-
-const hasDecimalPlaces = (value) => {
-  if (value === undefined || value === null) {
-    return false;
-  }
-  const num = Number(value);
-  return !isNaN(num) && !Number.isInteger(num);
-};
-
-const dispatchRequestSetUIState = (element, value, detail) => {
-  const controlHost = findControlHost(element) || element;
-  return dispatchInternalCustomEvent(controlHost, "navi_set_ui_state", {
-    ...detail,
-    value,
-  });
-};
-const dispatchRequestClearUIState = (element, e) => {
-  const controlHost = findControlHost(element) || element;
-  return dispatchInternalCustomEvent(controlHost, "navi_clear_ui_state", {
-    event: e,
-  });
-};
-const dispatchRequestResetUIState = (element, e) => {
-  const controlHost = findControlHost(element) || element;
-  return dispatchInternalCustomEvent(controlHost, "navi_reset_ui_state", {
-    event: e,
-  });
-};
-/**
- * @param {Element} el
- * @param {{ own?: boolean }} [options] `own`: what the element holds BY ITSELF.
- *   Only a button ever answers differently — one with no value of its own
- *   inherits the value of the control around it, which is what makes
- *   `--navi-send` on a form's button be about that form. Something asking what
- *   THIS element says (a travel command reading what the travel is about) wants
- *   the own value and would otherwise be handed the surrounding control's.
- */
-const getUIStateFromElement = (el, { own } = {}) => {
-  let uiState;
-  dispatchInternalCustomEvent(el, "navi_get_ui_state", {
-    own,
-    respondWith: (v) => {
-      uiState = v;
-    },
-  });
-  return uiState;
-};
-
-/**
- * Converts a JS value into the form expected by the browser DOM property for a
- * given control type/input type combination.
- *
- * For example:
- * - `datetime-local` inputs expect a local datetime string without timezone
- * - `number`/`range` inputs expect a numeric string or number
- * - `color` inputs require a non-empty hex string (falls back to `#000000`)
- * - All other inputs receive the value as-is (undefined → "")
- *
- * Returns either the converted value directly, or a converter function when the
- * conversion depends on the runtime value (e.g. plain inputs return `asInputValue`).
- *
- * @param {any} value - The JS value to convert.
- * @param {{ controlType: string, type: string }} options
- * @returns {any} The DOM-compatible value or a converter function.
- */
-const asControlHostValue = (
-  jsValue,
-  { controlType, type, naviInputType, pad },
-) => {
-  if (controlType === "select") {
-    // A select holds one of its options, always a string; holding nothing is
-    // the empty option, which the element spells "".
-    return asInputValue(jsValue);
-  }
-  if (controlType === "input" || controlType === "picker") {
-    if (type === "datetime-local") {
-      return asDatetimeLocalString(jsValue);
-    }
-    if (type === "range" || isNumberInput(type, naviInputType)) {
-      return asNumberString(jsValue, pad);
-    }
-    if (type === "color") {
-      return asColorString(jsValue);
-    }
-    return asInputValue(jsValue);
-  }
-  return jsValue;
-};
-// As explained in https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input/datetime-local#setting_timezones
-// datetime-local does not support timezones
-const asDatetimeLocalString = (dateTimeString) => {
-  const date = new Date(dateTimeString);
-  if (isNaN(date.getTime())) {
-    return dateTimeString;
-  }
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}`;
-};
-// `pad` is how many digits the number is WRITTEN on — an hour is held as 7 and
-// shown as "07". Held and shown are two things here, the way they are for a
-// datetime-local above: what the field says is derived from what the control
-// holds, and reading it back (readNumberFromInput) gives the number again.
-const asNumberString = (jsValue, pad) => {
-  if (jsValue === undefined) {
-    return "";
-  }
-  if (!pad || jsValue === "" || jsValue === null) {
-    return jsValue;
-  }
-  const number = Number(jsValue);
-  if (Number.isNaN(number)) {
-    return jsValue;
-  }
-  const negative = number < 0;
-  const digits = String(negative ? -number : number).padStart(Number(pad), "0");
-  return negative ? `-${digits}` : digits;
-};
-// Browser requires a non-empty value for <input type="color">.
-// When our logical value is empty we give it #000000 so it doesn't choke.
-// The UI uses the original (possibly empty) value to show the checkerboard.
-const asColorString = (jsValue) => {
-  return jsValue || "#000000";
-};
-const asInputValue = (jsValue) => {
-  if (jsValue === undefined) {
-    return "";
-  }
-  return jsValue;
-};
-
-/**
- * Reads the current logical JS value from a control host DOM element.
- *
- * Handles all navi control host element types:
- * - `<button>` — reads via `navi_get_value` custom event, falls back to `button.value`
- * - `<input type="number|range">` — parses as a number, returns `undefined` when empty
- * - `<input type="checkbox|radio">` — returns `undefined` when unchecked, otherwise reads
- *   via `navi_get_value` custom event (to preserve the original JS type of the value prop)
- * - `<input type="datetime-local">` — converts the local datetime string to an ISO 8601 string
- * - `<input type="navi_picker">` — delegates to the controller via `navi_get_ui_state`
- * - All other inputs — returns `input.value` as a string
- *
- * @param {HTMLElement} controlHost - The control host DOM element to read from.
- * @returns {any} The current logical value of the control.
- */
-const readControlValue = (controlHost) => {
-  if (
-    controlHost.tagName === "BUTTON" ||
-    controlHost.getAttribute("role") === "button"
-  ) {
-    return readValueFromButton(controlHost);
-  }
-  if (controlHost.tagName === "INPUT") {
-    // important: input.type = "navi_js"; followed by input.type; returns "text"
-    // so use getAttribute
-    const type = controlHost.getAttribute("type");
-
-    if (
-      type === "range" ||
-      isNumberInput(type, controlHost.getAttribute("navi-input-type"))
-    ) {
-      return readNumberFromInput(controlHost);
-    }
-    if (type === "color") {
-      return readValueFromControlHost(controlHost);
-    }
-    if (type === "checkbox" || type === "radio") {
-      return readValueFromCheckableInput(controlHost);
-    }
-    if (type === "datetime-local") {
-      return readDatetimeLocalFromInput(controlHost);
-    }
-    if (type === "navi_js") {
-      return getUIStateFromElement(controlHost);
-    }
-    return readValueFromInput(controlHost);
-  }
-  if (controlHost.hasAttribute("navi-control-host")) {
-    // Non-button, non-input navi controls (e.g. Badge.Button rendered as span)
-    return readValueFromControlHost(controlHost);
-  }
-  return readValueFromElement(controlHost);
-};
-const readValueFromControlHost = (controlHost) => {
-  return readValueFromNaviCustomEvent(controlHost, controlHost.value);
-};
-const readValueFromButton = (button) => {
-  return readValueFromControlHost(button);
-};
-const readDatetimeLocalFromInput = (input) => {
-  const localDateTimeString = input.value;
-  if (localDateTimeString === "") {
-    return "";
-  }
-  const localDate = new Date(localDateTimeString);
-  if (isNaN(localDate.getTime())) {
-    return localDateTimeString;
-  }
-  return localDate.toISOString();
-};
-const readNumberFromInput = (input) => {
-  const numberString = input.value;
-  if (numberString === "") {
-    return "";
-  }
-  const asNumber = Number(numberString);
-  if (isNaN(asNumber)) {
-    return numberString;
-  }
-  return asNumber;
-};
-const readValueFromCheckableInput = (input) => {
-  const checked = input.checked;
-  if (!checked) {
-    return undefined;
-  }
-  return readValueFromControlHost(input);
-};
-const readValueFromInput = (input) => {
-  const value = input.value;
-  return value;
-};
-const readValueFromElement = (element) => {
-  const value = element.value;
-  return value;
-};
-const readValueFromNaviCustomEvent = (field, fallback) => {
-  // prefer the value given as prop (respect original type, browser would convert to string)
-  let responded;
-  let value;
-  dispatchCustomEvent(field, "navi_get_value", {
-    respondWith: (jsValue) => {
-      responded = true;
-      value = jsValue;
-    },
-  });
-  if (responded) {
-    return value;
-  }
-  return fallback;
-};
-
-// In-memory registry of all mounted ui state controllers keyed by their id.
-// Allows direct controller access without dispatching DOM events — used by external
-// callers (e.g. selectable_list) to call setUIState by id instead of via the DOM.
-const controllersById = new Map();
-
-// In-memory registry for radio controllers, keyed by input name.
-// Allows radio sibling unchecking without querying the DOM — necessary when
-// items are virtualized and their DOM element may not exist at the time.
-// Form scoping is reproduced by comparing parentUIStateController references.
-const radioControllersByName = new Map();
-
-// Registry for non-serializable JS values that cannot be written to DOM attributes as-is.
-// When a value is an object/array, we store it here and write a reference string to the DOM
-// instead of "[object Object]". Console-inspectable via window.__navi_js('id').
-// The controller id is used as key — if the controller has no id, the value is not registered.
-const naviJsRegistry = new Map();
-
-const getUIStateControllerById = (id) => controllersById.get(id);
-const getRadioSiblings = (radioUIStateController) => {
-  const siblings = radioControllersByName.get(radioUIStateController.name);
-  return siblings;
-};
-
-const toDomValue = (
-  jsValue,
-  { controlType, id, type, naviInputType, pad },
-) => {
-  const domValue = asControlHostValue(jsValue, {
-    controlType,
-    type,
-    naviInputType,
-    pad,
-  });
-  if (isSerializableAsDomValue(domValue)) {
-    return domValue;
-  }
-  naviJsRegistry.set(id, domValue);
-  return `window.__navi_js('${id}')`;
-};
-
-window.__navi_js = (id) => naviJsRegistry.get(id);
-const isSerializableAsDomValue = (value) => {
-  if (value === null || value === undefined) {
-    return true;
-  }
-  const type = typeof value;
-  return type === "string" || type === "number" || type === "boolean";
-};
-
-const onUIStateControllerCreated = (uiStateController) => {
-  const { id, name, controlType } = uiStateController;
-  if (id) {
-    controllersById.set(id, uiStateController);
-  }
-  const proxyFor = uiStateController.props["navi-control-proxy-for"];
-  if (proxyFor) {
-    let proxySet = proxyControllersByRealInputId.get(proxyFor);
-    if (!proxySet) {
-      proxySet = new Set();
-      proxyControllersByRealInputId.set(proxyFor, proxySet);
-    }
-    proxySet.add(uiStateController);
-  }
-  if (
-    controlType === "input" &&
-    uiStateController.props.type === "radio" &&
-    name
-  ) {
-    let set = radioControllersByName.get(name);
-    if (!set) {
-      set = new Set();
-      radioControllersByName.set(name, set);
-    }
-    set.add(uiStateController);
-  }
-};
-const onUIStateControllerDestroyed = (uiStateController) => {
-  const { id, name, controlType } = uiStateController;
-  if (id) {
-    // Only the controller the id currently points at may take the entry away:
-    // when two controls share an id, the one leaving would otherwise unregister
-    // the one staying (see the warning in onUIStateControllerCreated), and the
-    // same holds while a control is being replaced by its successor, which
-    // registers during its render, before this cleanup runs.
-    if (controllersById.get(id) === uiStateController) {
-      controllersById.delete(id);
-      naviJsRegistry.delete(id);
-    }
-  }
-  const proxyFor = uiStateController.props["navi-control-proxy-for"];
-  if (proxyFor) {
-    const proxySet = proxyControllersByRealInputId.get(proxyFor);
-    if (proxySet) {
-      proxySet.delete(uiStateController);
-      if (proxySet.size === 0) {
-        proxyControllersByRealInputId.delete(proxyFor);
-      }
-    }
-  }
-  if (
-    controlType === "input" &&
-    uiStateController.controlHostProps.type === "radio" &&
-    name
-  ) {
-    const set = radioControllersByName.get(name);
-    if (set) {
-      set.delete(uiStateController);
-      if (set.size === 0) {
-        radioControllersByName.delete(name);
-      }
-    }
-  }
-};
-
-/**
- * Controller-based equivalent of findControlProxyTarget.
- * Given a proxy controller, returns the real control's controller.
- * Finds the target by walking the parent controller's children — no DOM queries.
- * Returns `null` when the controller is not a proxy or the target is not found.
- */
-const findControlProxyTargetController = (controller) => {
-  const proxyFor = controller.controlHostProps["navi-control-proxy-for"];
-  if (!proxyFor) {
-    return null;
-  }
-  return getUIStateControllerById(proxyFor) ?? null;
-};
-
-// Reverse-lookup map: real-input id → the proxy controllers that reference it
-// via `navi-control-proxy-for`. A single control can be represented by several
-// proxies (an "enable"/"disable" button pair for one radio, for instance), so
-// each id holds a set. Maintained on create/destroy so lookup is O(1).
-const proxyControllersByRealInputId = new Map();
-const findProxyControllers = (realInputId) => {
-  if (!realInputId) {
-    return null;
-  }
-  return proxyControllersByRealInputId.get(realInputId) ?? null;
-};
-
 /**
  * The attributes constraints read, filled by each constraint module as it
  * evaluates. A constraint declares the attribute it wants (`"data-no-emoji"`)
@@ -6497,113 +5364,6 @@ const isInertOnClick = (element) => {
   return true;
 };
 
-/**
- * DOM utilities for the proxy control pattern.
- *
- * Some components need a native `<input>` internally — for form submission,
- * constraint validation, or browser autofill — but the user may not want to
- * display that input at all. In those cases the input is hidden and a separate
- * visible element (the proxy) takes over the visual and interactive role.
- *
- * The typical use case is `SelectableList`: each list item acts as a styled
- * radio button, but an actual `<input type="radio">` lives hidden in the DOM
- * so form submission and validation work natively.  When users DO want to
- * display the input they want full control over its appearance, so they render
- * their own element and link it to the real input via `navi-control-proxy-for`:
- *
- * ```html
- *  <div>
- *   <input id="color_red" type="radio" name="color" value="red"  /> ← real control (hidden, drives form/validation)
- *   <input type="radio" name="proxy" value="red" />                 ← proxy (visible, delegates interactions to real input)
- * </div>
- * ```
- *
- * A press on a checkable proxy is dealt to the real control, and so is the
- * focus: state management, validation and form submission then all happen
- * where the value lives. A proxy that says what its press does — a button
- * carrying `command="--navi-check"` — answers the press itself instead.
- *
- * Note: an alternative design would be to require users to always instantiate
- * the input explicitly — e.g. `<Selectable.Input headless />` when they don't
- * want to display it. That would remove the need for the proxy mechanism
- * entirely. For now we keep the proxy pattern.
- */
-
-
-/**
- * Given a proxy element, returns the real control it represents.
- * Returns `null` when `el` is not a proxy.
- */
-const findControlProxyTarget = (el) => {
-  const proxyFor = el.getAttribute("navi-control-proxy-for");
-  if (!proxyFor) {
-    return null;
-  }
-  return document.getElementById(proxyFor);
-};
-
-// Shared: asked on every pseudo state change of every box, and almost always
-// empty.
-const NO_PROXIES = Object.freeze([]);
-/**
- * Given a real control element, returns every proxy that visually represents
- * it — a control can have more than one (an "enable"/"disable" button pair for
- * one radio, for instance).
- *
- * Answered from the controller registry rather than the document: every proxy
- * declares itself through the `navi-control-proxy-for` prop, so the registry
- * knows them all, while asking the document means walking it in full for each
- * of the (overwhelmingly many) controls that have no proxy at all.
- *
- * Returns an empty array when no proxy exists for `el`.
- */
-const findControlProxies = (el) => {
-  if (!el.id) {
-    return NO_PROXIES;
-  }
-  const proxyControllerSet = findProxyControllers(el.id);
-  if (!proxyControllerSet) {
-    return NO_PROXIES;
-  }
-  const proxyElements = [];
-  for (const proxyController of proxyControllerSet) {
-    const proxyElement = proxyController.ref.current;
-    if (proxyElement) {
-      proxyElements.push(proxyElement);
-    }
-  }
-  return proxyElements;
-};
-
-/**
- * Given a real control element, returns the proxy a gesture on the control
- * lands on — the one thing said about the control is drawn on.
- *
- * Use when you need a single visible stand-in for the real control — anchoring
- * a callout, for instance. Anything notifying proxies of a state change wants
- * `findControlProxies` instead, so a control represented by several of them
- * updates all of them.
- *
- * A proxy the pointer cannot reach is drawn for the control without standing
- * for it: the surface around it takes the presses for everything it holds, so
- * that surface is where a refusal about the control belongs — not a box inside
- * it the finger never has to find. A selectable list row whose whole area is
- * the click target is exactly that arrangement (see `selectableArea`), and it
- * is read from the arrangement itself rather than from a flag repeating it:
- * where a gesture can land IS pointer-events.
- *
- * Returns `null` when no proxy stands for `el`.
- */
-const findControlProxy = (el) => {
-  for (const proxyElement of findControlProxies(el)) {
-    if (getComputedStyle(proxyElement).pointerEvents === "none") {
-      continue;
-    }
-    return proxyElement;
-  }
-  return null;
-};
-
 /**
  * Typography reset shared by the surfaces a control opens: callout, popover,
  * dialog.
@@ -20651,1453 +19411,6 @@ const getDefaultDisplay = (tagName) => {
   return TAG_NAME_TO_DEFAULT_DISPLAY.get(normalizedTagName) || "inline";
 };
 
-const addInputEffect = (
-  input,
-  callback,
-  { waitForChange = false, debounce = 0, debugInteraction = () => {} } = {},
-) => {
-  const getState =
-    input.type === "checkbox" || input.type === "radio"
-      ? () => input.checked
-      : () => input.value;
-
-  if (waitForChange) {
-    return listenInputStateChange(input, callback, { getState });
-  }
-
-  const [teardown, addTeardown] = createPubSub();
-  let currentState = getState();
-  let timeout;
-  let debounceTimeout;
-  let onEvent;
-  if (debounce) {
-    onEvent = (e, { skipDebounce } = {}) => {
-      clearTimeout(timeout);
-      clearTimeout(debounceTimeout);
-      const state = getState();
-      if (state === currentState) {
-        debugInteraction(
-          e,
-          `interaction ignored (state unchanged: "${state}")`,
-        );
-        return;
-      }
-
-      if (skipDebounce) {
-        debugInteraction(e, `skip debounce, callback called with "${state}"`);
-        if (callback(e) !== false) {
-          currentState = state;
-        }
-      } else {
-        debugInteraction(
-          e,
-          `debounced ${debounce}ms, pending callback with "${state}"`,
-        );
-        debounceTimeout = setTimeout(() => {
-          debugInteraction(
-            e,
-            `debounce elapsed, callback called with "${state}"`,
-          );
-          if (callback(e) !== false) {
-            currentState = state;
-          }
-        }, debounce);
-      }
-    };
-    // no need to wait for change events (blur, enter key)
-    // we consider this as strong interactions requesting an immediate response
-    const stop = listenInputStateChange(
-      input,
-      (e) => {
-        onEvent(e, { skipDebounce: true });
-      },
-      { getState, changeOnEnter: true },
-    );
-    addTeardown(() => {
-      stop();
-    });
-  } else {
-    onEvent = (e) => {
-      clearTimeout(timeout);
-      const state = getState();
-      if (state === currentState) {
-        debugInteraction(
-          e,
-          `interaction ignored (state unchanged: "${state}")`,
-        );
-        return;
-      }
-      debugInteraction(e, `callback called with "${state}"`);
-      if (callback(e) !== false) {
-        currentState = state;
-      }
-    };
-    // Autocomplete, programmatic changes, form restoration
-    input.addEventListener("change", onEvent);
-    addTeardown(() => {
-      input.removeEventListener("change", onEvent);
-    });
-  }
-
-  const onAsyncEvent = (e, options) => {
-    debugInteraction(e, `async event, scheduling callback`);
-    timeout = setTimeout(() => {
-      onEvent(e, options);
-    }, 0);
-  };
-
-  // Standard user input (typing)
-  const onInput = (e) => {
-    onEvent(e);
-  };
-  input.addEventListener("input", onInput);
-  addTeardown(() => {
-    input.removeEventListener("input", onInput);
-  });
-
-  // Form reset - need to check the form
-  const form = input.form;
-  if (form) {
-    // Form reset happens asynchronously, check value after reset completes
-    form.addEventListener("reset", onAsyncEvent);
-    addTeardown(() => {
-      form.removeEventListener("reset", onAsyncEvent);
-    });
-  }
-
-  // Paste events (some browsers need special handling)
-  input.addEventListener("paste", onEvent);
-  addTeardown(() => {
-    input.removeEventListener("paste", onEvent);
-  });
-
-  input.addEventListener("navi_ui_state_change", (e) => {
-    // radios are unchecked by an internal setUIState call when another radio is checked.
-    // navi_ui_state_change is dispatched whenever setUIState changes state, so we
-    // listen here to keep currentState in sync — otherwise input_effect thinks the
-    // radio is still checked and ignores the next user click as "state unchanged".
-    if (input.type === "radio") {
-      currentState = e.detail.value;
-    }
-    const clearEvent = findEvent(
-      e,
-      (eInChain) =>
-        eInChain.type === "navi_set_ui_state" && eInChain.detail.isClear,
-    );
-    const isClear = Boolean(clearEvent);
-    if (isClear) {
-      // "navi_clear" behaves like an async event
-      // a bit like form reset because
-      // our action will be updated async after the component re-renders
-      // and we need to wait that to happen to properly call action with the right value
-      debugInteraction(e, `navi_clear received, scheduling callback`);
-      onAsyncEvent(e, { skipDebounce: true });
-    }
-  });
-
-  return teardown;
-};
-
-const listenInputStateChange = (
-  input,
-  callback,
-  { getState, changeOnEnter },
-) => {
-  const [teardown, addTeardown] = createPubSub();
-
-  let stateAtInteraction;
-  const oninput = () => {
-    stateAtInteraction = undefined;
-  };
-  const onkeydown = (e) => {
-    if (e.key === "Enter") {
-      /**
-       * Browser trigger a "change" event right after the enter is pressed
-       * if the input value has changed.
-       * We need to prevent the next change event otherwise we would request action twice
-       */
-      stateAtInteraction = getState();
-      if (changeOnEnter) {
-        onchange(e);
-      }
-    }
-    if (e.key === "Escape") {
-      /**
-       * Browser trigger a "change" event right after the escape is pressed
-       * if the input value has changed.
-       * We need to prevent the next change event otherwise we would request action when
-       * we actually want to cancel
-       */
-      stateAtInteraction = getState();
-    }
-  };
-  const onchange = (e) => {
-    if (stateAtInteraction !== undefined && getState() === stateAtInteraction) {
-      stateAtInteraction = undefined;
-      return;
-    }
-    callback(e);
-  };
-  input.addEventListener("input", oninput);
-  input.addEventListener("keydown", onkeydown);
-  input.addEventListener("change", onchange);
-  addTeardown(() => {
-    input.removeEventListener("input", oninput);
-    input.removeEventListener("keydown", onkeydown);
-    input.removeEventListener("change", onchange);
-  });
-
-  {
-    // Handle programmatic value changes that don't trigger browser change events
-    //
-    // Problem: When input values are set programmatically (not by user typing),
-    // browsers don't fire the 'change' event. However, our application logic
-    // still needs to detect these changes.
-    //
-    // Example scenario:
-    // 1. User starts editing (letter key pressed, value set programmatically)
-    // 2. User doesn't type anything additional (this is the key part)
-    // 3. User clicks outside to finish editing
-    // 4. Without this code, no change event would fire despite the fact that the input value did change from its original state
-    //
-    // This distinction is crucial because:
-    //
-    // - If the user typed additional text after the initial programmatic value,
-    //   the browser would fire change events normally
-    // - But when they don't type anything else, the browser considers it as "no user interaction"
-    //   even though the programmatic initial value represents a meaningful change
-    //
-    // We achieve this by checking if the input value has changed between focus and blur without any user interaction
-    // if yes we fire the callback because input value did change
-    let stateAtStart = getState();
-    let interacted = false;
-
-    const onfocus = () => {
-      interacted = false;
-      stateAtStart = getState();
-    };
-    const oninput = (e) => {
-      if (!e.isTrusted) {
-        // non trusted "input" events will be ignored by the browser when deciding to fire "change" event
-        // we ignore them too
-        return;
-      }
-      interacted = true;
-    };
-    const onblur = (e) => {
-      if (interacted) {
-        return;
-      }
-      if (stateAtStart === getState()) {
-        return;
-      }
-      callback(e);
-    };
-
-    input.addEventListener("focus", onfocus);
-    input.addEventListener("input", oninput);
-    input.addEventListener("blur", onblur);
-    addTeardown(() => {
-      input.removeEventListener("focus", onfocus);
-      input.removeEventListener("input", oninput);
-      input.removeEventListener("blur", onblur);
-    });
-  }
-
-  return teardown;
-};
-
-const requestPseudoStateCheck = (element, detail) => {
-  dispatchInternalCustomEvent(
-    element,
-    "navi_pseudo_state_request_check",
-    detail,
-  );
-  // When a control has visible proxies mirroring its state (e.g. selectable
-  // radio with `navi-control-proxy-for`), re-check them too so they stay in
-  // sync with the real control.
-  for (const proxy of findControlProxies(element)) {
-    dispatchInternalCustomEvent(
-      proxy,
-      "navi_pseudo_state_request_check",
-      detail,
-    );
-  }
-};
-/**
- * Called back whenever `element`'s pseudo state changes.
- *
- * Kept beside the element rather than announced to the DOM: an element that
- * changes state has at most one or two interested parties, each known by name
- * (the box drawing it, the accent color reading its computed style), and a
- * CustomEvent costs its allocation and its capture/bubble walk whether anyone
- * listens or not — paid on every element, on every state change. A lookup that
- * finds nothing costs nothing.
- *
- * @param {Element} element
- * @param {(pseudoState: object, oldPseudoState: object) => void} callback
- * @returns {() => void} teardown
- */
-const subscribeToPseudoState = (element, callback) => {
-  let subscriberSet = pseudoStateSubscriberSetWeakMap.get(element);
-  if (!subscriberSet) {
-    subscriberSet = new Set();
-    pseudoStateSubscriberSetWeakMap.set(element, subscriberSet);
-  }
-  subscriberSet.add(callback);
-  return () => {
-    subscriberSet.delete(callback);
-  };
-};
-const pseudoStateSubscriberSetWeakMap = new WeakMap();
-const notifyPseudoStateSubscribers = (element, value, oldValue) => {
-  const subscriberSet = pseudoStateSubscriberSetWeakMap.get(element);
-  if (!subscriberSet) {
-    return;
-  }
-  for (const subscriber of subscriberSet) {
-    subscriber(value, oldValue);
-  }
-};
-
-const PSEUDO_CLASSES = {};
-Object.assign(PSEUDO_CLASSES, {
-  ":valid": {
-    attribute: "data-valid",
-    test: (el) => el.matches(":valid"),
-  },
-  ":invalid": {
-    attribute: "data-invalid",
-    test: (el) => el.matches(":invalid"),
-  },
-  ":visited": {
-    attribute: "data-visited",
-  },
-  // Written by whoever knows the current url — a Link from its href, a Button
-  // from its route — so it lives here rather than with one of them.
-  ":-navi-href-current": {
-    attribute: "data-href-current",
-  },
-});
-const definePseudoClass = (pseudoClass, definition) => {
-  PSEUDO_CLASSES[pseudoClass] = definition;
-};
-
-// On touch devices (hover: none), browsers synthesize mouseenter/mouseleave
-// from touch events but never fire mouseleave when the finger lifts, leaving
-// el.matches(":hover") stuck at true. This causes hover styles (e.g. input
-// background highlight) to remain visible long after the user has stopped
-// touching the element. Checking (hover: hover) lets us skip hover tracking
-// entirely on touch-only devices where persistent hover makes no sense.
-const hoverSupported = window.matchMedia("(hover: hover)").matches;
-definePseudoClass(":hover", {
-  attribute: "data-hover",
-  setup: (el, callback) => {
-    if (!hoverSupported) {
-      return () => {};
-    }
-    const recheckProxy = (e) => {
-      for (const proxy of findControlProxies(el)) {
-        requestPseudoStateCheck(proxy, { event: e });
-      }
-    };
-    const recheckProxyTarget = (e) => {
-      const proxyTarget = findControlProxyTarget(el);
-      if (proxyTarget) {
-        requestPseudoStateCheck(proxyTarget, { event: e });
-      }
-    };
-    let onmouseenter = (e) => {
-      callback();
-      recheckProxy(e);
-      recheckProxyTarget(e);
-    };
-    let onmouseleave = (e) => {
-      callback();
-      recheckProxy(e);
-      recheckProxyTarget(e);
-    };
-
-    if (el.tagName === "LABEL") {
-      // input.matches(":hover") is true when hovering the label
-      // so when label is hovered/not hovered we need to recheck the input too
-      const recheckInput = (e) => {
-        if (el.htmlFor) {
-          const input = document.getElementById(el.htmlFor);
-          if (!input) {
-            // cannot find the input for this label in the DOM
-            return;
-          }
-          requestPseudoStateCheck(input, { event: e });
-          return;
-        }
-        const input = el.querySelector("input, textarea, select");
-        if (!input) {
-          // label does not contain an input
-          return;
-        }
-        requestPseudoStateCheck(input, { event: e });
-      };
-      const _onmouseenter = onmouseenter;
-      onmouseenter = (e) => {
-        recheckInput(e);
-        _onmouseenter(e);
-      };
-      const _onmouseleave = onmouseleave;
-      onmouseleave = (e) => {
-        recheckInput(e);
-        _onmouseleave(e);
-      };
-    }
-
-    el.addEventListener("mouseenter", onmouseenter);
-    el.addEventListener("mouseleave", onmouseleave);
-    return () => {
-      el.removeEventListener("mouseenter", onmouseenter);
-      el.removeEventListener("mouseleave", onmouseleave);
-    };
-  },
-  test: (el) => {
-    if (!hoverSupported) {
-      return false;
-    }
-    if (el.matches(":hover")) {
-      return true;
-    }
-    for (const proxy of findControlProxies(el)) {
-      if (proxy.matches(":hover")) {
-        return true;
-      }
-    }
-    return false;
-  },
-});
-definePseudoClass(":disabled", {
-  attribute: "data-disabled",
-  add: (el) => {
-    if (
-      el.tagName === "BUTTON" ||
-      el.tagName === "INPUT" ||
-      el.tagName === "SELECT" ||
-      el.tagName === "TEXTAREA"
-    ) {
-      el.disabled = true;
-    }
-  },
-  remove: (el) => {
-    if (
-      el.tagName === "BUTTON" ||
-      el.tagName === "INPUT" ||
-      el.tagName === "SELECT" ||
-      el.tagName === "TEXTAREA"
-    ) {
-      el.disabled = false;
-    }
-  },
-});
-definePseudoClass(":read-only", {
-  attribute: "data-readonly",
-  add: (el) => {
-    if (
-      el.tagName === "INPUT" ||
-      el.tagName === "SELECT" ||
-      el.tagName === "TEXTAREA"
-    ) {
-      if (el.type === "checkbox" || el.type === "radio") {
-        // there is no readOnly for checkboxes/radios
-        return;
-      }
-      // el.readOnly = true;
-    }
-  },
-  remove: (el) => {
-    if (
-      el.tagName === "INPUT" ||
-      el.tagName === "SELECT" ||
-      el.tagName === "TEXTAREA"
-    ) {
-      if (el.type === "checkbox" || el.type === "radio") {
-        // there is no readOnly for checkboxes/radios
-        return;
-      }
-      // el.readOnly = false;
-    }
-  },
-});
-definePseudoClass(":checked", {
-  attribute: "data-checked",
-  setup: (el, callback) => {
-    if (el.type === "checkbox") {
-      // Listen to user interactions
-      el.addEventListener("input", callback);
-      // Intercept programmatic changes to .checked property
-      const originalDescriptor = Object.getOwnPropertyDescriptor(
-        HTMLInputElement.prototype,
-        "checked",
-      );
-      Object.defineProperty(el, "checked", {
-        get: originalDescriptor.get,
-        set(value) {
-          originalDescriptor.set.call(this, value);
-          callback();
-        },
-        configurable: true,
-      });
-      return () => {
-        // Restore original property descriptor
-        Object.defineProperty(el, "checked", originalDescriptor);
-        el.removeEventListener("input", callback);
-      };
-    }
-    if (el.type === "radio") {
-      // Listen to changes on the radio
-      el.addEventListener("input", callback);
-      // Intercept programmatic changes to .checked property
-      const originalDescriptor = Object.getOwnPropertyDescriptor(
-        HTMLInputElement.prototype,
-        "checked",
-      );
-      Object.defineProperty(el, "checked", {
-        get: originalDescriptor.get,
-        set(value) {
-          originalDescriptor.set.call(this, value);
-          callback();
-        },
-        configurable: true,
-      });
-      return () => {
-        el.removeEventListener("input", callback);
-        // Restore original property descriptor
-        Object.defineProperty(el, "checked", originalDescriptor);
-      };
-    }
-    if (el.tagName === "INPUT") {
-      el.addEventListener("input", callback);
-      return () => {
-        el.removeEventListener("input", callback);
-      };
-    }
-    return () => {};
-  },
-  test: (el) => el.matches(":checked"),
-});
-definePseudoClass(":active", {
-  attribute: "data-active",
-  setup: (el, callback) => {
-    // I'ts recommended to use :-navi-pressed over :active for interactive elements.
-    const onPointerDown = () => {
-      const onRelease = () => {
-        document.removeEventListener("pointercancel", onRelease, true);
-        document.removeEventListener("pointerup", onRelease, true);
-        callback();
-      };
-      document.addEventListener("pointercancel", onRelease, true);
-      document.addEventListener("pointerup", onRelease, true);
-      callback();
-    };
-    el.addEventListener("pointerdown", onPointerDown);
-    return () => {
-      el.removeEventListener("pointerdown", onPointerDown);
-    };
-  },
-  test: (el) => el.matches(":active"),
-});
-
-// The current input modality: true after a keyboard navigation key (arrow keys,
-// Escape, Enter, Ctrl, Alt, Shift, Space — Space ignored on editable fields),
-// false after a pointer interaction. Updated by the listeners in the
-// focus_classes block below. At module scope so isMatchingFocusVisible (used
-// here and in control_hooks.jsx) can read it.
-let keyboardNavigationUsed = false;
-
-// HOW FOCUS-VISIBLE IS DECIDED (the details behind isMatchingFocusVisible)
-//
-// Two rules, depending on what `el` is:
-//
-// 1. An EDITABLE target (text-ish input, textarea, contenteditable — anything
-//    whose whole point is keyboard input, see isEditableTarget) shows its ring
-//    whenever it holds the focus, however the focus arrived — mouse,
-//    programmatic, even a focus({ focusVisible: false }). Being focused, for
-//    such a field, means being about to type, and that is what the ring
-//    announces. Its check is on :focus rather than :focus-visible on purpose:
-//    the native :focus-visible obeys the focusVisible option, which callers
-//    set from the modality without knowing what they are focusing.
-//
-// 2. Anything else needs BOTH the native :focus-visible match AND the current
-//    modality being keyboard (`keyboardNavigationUsed`).
-//
-//    The native match alone cannot be trusted, because we routinely take the
-//    pointer out of the browser's hands: a picker opens on mousedown and calls
-//    preventDefault() so the browser does not move focus itself (see
-//    picker_custom.jsx). The browser therefore never registers that a pointer
-//    was what moved focus, and whatever focus-visible state the previous
-//    keyboard interaction left behind stays true — even across the
-//    programmatic focus({ focusVisible: false }) that follows. Close a picker
-//    with Escape (ring on the trigger, rightly) and click it open again: the
-//    popup's own focusable would come up ringed, from a mouse press.
-//
-//    `keyboardNavigationUsed` has no such blind spot — it is set by navigation
-//    keydowns and cleared by pointerdown, whatever anyone prevents afterwards
-//    — so it is the authority for everything rule 1 does not cover.
-//
-// Ring INHERITANCE (a controlled element ringing because its aria-controls
-// controller is focused) stays gated on the keyboard modality even for an
-// editable controller — see hasIndirectFocus: propagating a ring promises
-// keyboard shortcuts will drive the controlled element, a promise that only
-// holds once a physical keyboard has actually been used.
-/**
- * Whether `el` should currently show a focus ring — the enriched
- * :focus-visible behind every [data-focus-visible] navi renders.
- * Use this instead of a bare el.matches(":focus-visible") wherever
- * focus-visible is evaluated; the comment above details the rules.
- * @param {Element} el
- * @returns {boolean}
- */
-const isMatchingFocusVisible = (el) => {
-  if (isEditableTarget(el)) {
-    return el.matches(":focus");
-  }
-  if (!el.matches(":focus-visible")) {
-    return false;
-  }
-  if (!keyboardNavigationUsed) {
-    return false;
-  }
-  return true;
-};
-
-// Elements that invite keyboard input: focusing one — even with the mouse —
-// means the user is about to type, so they always warrant a visible focus.
-// Also used to ignore the Space key as a navigation key while typing, and by
-// programmatic focus (focus_transfer.js) to pass focusVisible: true so the
-// native :focus-visible agrees with the ring rule 1 above draws.
-const EDITABLE_INPUT_TYPE_SET = new Set([
-  "text",
-  "search",
-  "url",
-  "email",
-  "password",
-  "tel",
-  "number",
-  "date",
-  "time",
-  "datetime-local",
-  "month",
-  "week",
-]);
-const isEditableTarget = (target) => {
-  if (!target) {
-    return false;
-  }
-  const tag = target.tagName;
-  if (tag === "TEXTAREA") {
-    return !target.readOnly;
-  }
-  if (tag === "INPUT") {
-    if (!target.type || EDITABLE_INPUT_TYPE_SET.has(target.type)) {
-      return !target.readOnly;
-    }
-  }
-  if (target.isContentEditable) {
-    return true;
-  }
-  return false;
-};
-
-// The current modality, for code deciding whether something it is about to
-// focus should show a ring — a slide arriving, a popup opening. The question is
-// "was the user on the keyboard when this was asked for", which is what this
-// flag says; the element that happens to hold the focus right now says nothing
-// about it (it may have been focused programmatically, ring or no ring, by the
-// travel before this one).
-const isKeyboardModality = () => keyboardNavigationUsed;
-
-{
-  // We implement :focus and :focus-visible with enriched semantics:
-  // an element is considered focused not only when it natively has focus, but also
-  // when a "focus proxy" element has focus (e.g. a read-only range input delegates
-  // focus to a sibling span) or when a controlling element has focus (e.g. a combobox
-  // input with aria-controls pointing to a listbox — the listbox should appear focused
-  // while the input is focused).
-  //
-  // We intentionally reuse the native :focus / :focus-visible names rather than
-  // introducing new navi-specific pseudo-classes (e.g. :-navi-focus). This is a
-  // deliberate exception: all existing CSS and code written as [data-focus] or
-  // [data-focus-visible] automatically benefits from the enriched behavior without
-  // any changes. A separate navi-specific class would require updating every
-  // component.
-  //
-  // When a controller element (e.g. combobox input) gains or loses focus,
-  // notify the elements it controls via aria-controls so they re-check their
-  // focus state. `requestPseudoStateCheck` also re-checks the controlled
-  // element's proxy (if any), so the visible proxy mirrors the hidden real
-  // input's inherited focus.
-  const notifyAriaControlled = (el, e) => {
-    const controlledIds = el.getAttribute("aria-controls");
-    if (!controlledIds) {
-      return;
-    }
-    for (const id of controlledIds.split(" ")) {
-      const controlled = document.getElementById(id);
-      if (controlled) {
-        requestPseudoStateCheck(controlled, { event: e });
-      }
-    }
-  };
-  // Tracks whether the user has pressed a keyboard navigation key (arrow keys,
-  // Escape, Enter, Ctrl, Alt, Shift, Space) since the last pointer interaction.
-  // Space is ignored when the target is an editable field.
-  // This flag is used to gate focus-visible inheritance via aria-controls:
-  // on mobile (or when the user hasn't used keyboard nav yet) an input that
-  // controls a radio should not cause the radio to show a focus ring.
-  // (Declared at module scope — see keyboardNavigationUsed above.)
-  const NAVIGATION_KEY_SET = new Set([
-    "ArrowUp",
-    "ArrowDown",
-    "ArrowLeft",
-    "ArrowRight",
-    "Escape",
-    "Enter",
-    "Control",
-    "Alt",
-    "Shift",
-    " ",
-    "Tab",
-  ]);
-  document.addEventListener(
-    "keydown",
-    (e) => {
-      if (!NAVIGATION_KEY_SET.has(e.key)) {
-        return;
-      }
-      if (e.key === " " && isEditableTarget(e.target)) {
-        return;
-      }
-      keyboardNavigationUsed = true;
-    },
-    { capture: true },
-  );
-  document.addEventListener(
-    "pointerdown",
-    () => {
-      keyboardNavigationUsed = false;
-    },
-    { capture: true },
-  );
-
-  // A keystroke flips keyboardNavigationUsed, which can turn :focus-visible on —
-  // but only for the element that holds focus, directly or through aria-controls
-  // / a proxy. Pressing a key cannot reveal a focus ring on an unfocused element.
-  // So a single shared handler re-checks just that focus chain (the active
-  // element, what it controls, and its proxy — the last two via
-  // requestPseudoStateCheck / notifyAriaControlled). This runs in the bubble
-  // phase, after the capture-phase listener above has updated the flag.
-  //
-  // The alternative — each registered :focus-visible element adding its own
-  // document keydown listener that re-tests itself — makes one keypress cost
-  // O(number-of-boxes) full-document [aria-controls] / proxy queries, since every
-  // unfocused element falls through matches(":focus-visible") into hasIndirectFocus.
-  const recheckFocusChainOnKey = (e) => {
-    const active = document.activeElement;
-    if (!active || active === document.body) {
-      return;
-    }
-    requestPseudoStateCheck(active, { event: e });
-    notifyAriaControlled(active, e);
-  };
-  document.addEventListener("keydown", recheckFocusChainOnKey);
-  document.addEventListener("keyup", recheckFocusChainOnKey);
-
-  // Returns true when el holds focus indirectly — either because a controlling
-  // element (aria-controls) has focus, or because el is a proxy whose target
-  // is itself controlled by a focused element.
-  const hasIndirectFocus = (el, { requireFocusVisible = false } = {}) => {
-    // No ring inheritance without a keyboard: an editable target draws its own
-    // ring on any focus (see isMatchingFocusVisible), but propagating that ring
-    // to a controlled element (aria-controls) is a promise that keyboard
-    // shortcuts will drive it — a promise that holds only once a physical
-    // keyboard has actually been used. On touch devices the flag stays false
-    // and a focused search input keeps its ring to itself.
-    if (requireFocusVisible && !keyboardNavigationUsed) {
-      return false;
-    }
-    // A controller/proxy counts as focused for inheritance via the same rule
-    // used everywhere: :focus for plain inheritance, isMatchingFocusVisible for
-    // the focus-visible variant (so a mouse-focused controller doesn't propagate
-    // a ring).
-    const isFocusedTarget = (target) =>
-      requireFocusVisible
-        ? isMatchingFocusVisible(target)
-        : target.matches(":focus");
-    // Both branches of isFocusedTarget rest on :focus / :focus-visible, and only
-    // one element in the document can match those: document.activeElement. So
-    // the single controller worth testing is known upfront — asking the document
-    // for every [aria-controls] would collect candidates that cannot qualify,
-    // once per element and again on every re-check, on a document each new
-    // element makes bigger.
-    const isControlledBy = (target) => {
-      const id = target.id;
-      if (!id) {
-        return false;
-      }
-      const activeElement = document.activeElement;
-      if (!activeElement || activeElement === document.body) {
-        return false;
-      }
-      if (!activeElement.matches(`[aria-controls~="${id}"]`)) {
-        return false;
-      }
-      // A controller inside the element it controls means focus is already
-      // native (:focus-within) — nothing to inherit.
-      if (target.contains(activeElement)) {
-        return false;
-      }
-      return isFocusedTarget(activeElement);
-    };
-    if (isControlledBy(el)) {
-      return true;
-    }
-    const proxyTarget = findControlProxyTarget(el);
-    if (proxyTarget) {
-      if (isFocusedTarget(proxyTarget)) {
-        return true;
-      }
-      if (isControlledBy(proxyTarget)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
-  // One registration per element for everything focus-related, shared by
-  // :focus, :focus-visible and :focus-within: they all react to the same
-  // focusin/focusout, and they all re-check through the same callback (see
-  // initPseudoStyles), which the Set turns into one call.
-  const focusTrackingWeakMap = new WeakMap();
-  const trackFocus = (el, callback) => {
-    let tracking = focusTrackingWeakMap.get(el);
-    if (!tracking) {
-      const callbackSet = new Set();
-      const onFocusChange = (e) => {
-        for (const trackedCallback of callbackSet) {
-          trackedCallback();
-        }
-        notifyAriaControlled(el, e);
-      };
-      el.addEventListener("focusin", onFocusChange);
-      el.addEventListener("focusout", onFocusChange);
-      tracking = {
-        callbackSet,
-        teardown: () => {
-          el.removeEventListener("focusin", onFocusChange);
-          el.removeEventListener("focusout", onFocusChange);
-          focusTrackingWeakMap.delete(el);
-        },
-      };
-      focusTrackingWeakMap.set(el, tracking);
-      observeAriaControls();
-    }
-    tracking.callbackSet.add(callback);
-    return () => {
-      tracking.callbackSet.delete(callback);
-      if (tracking.callbackSet.size === 0) {
-        tracking.teardown();
-      }
-    };
-  };
-  // When aria-controls changes on a focused element, what it used to control
-  // and what it controls now both re-check their inherited focus. One observer
-  // on the document rather than one per tracked element: the attribute changes
-  // rarely, on few elements, while thousands are tracked — and it can be set
-  // after the element was, so "has it at setup" would miss it.
-  let ariaControlsObserver = null;
-  const observeAriaControls = () => {
-    if (ariaControlsObserver) {
-      return;
-    }
-    ariaControlsObserver = new MutationObserver((mutations) => {
-      for (const mutation of mutations) {
-        const el = mutation.target;
-        if (!focusTrackingWeakMap.has(el)) {
-          continue;
-        }
-        if (!el.matches(":focus-within")) {
-          continue;
-        }
-        const oldIds = (mutation.oldValue || "").split(" ").filter(Boolean);
-        for (const id of oldIds) {
-          const controlled = document.getElementById(id);
-          if (controlled) {
-            requestPseudoStateCheck(controlled, {});
-          }
-        }
-        notifyAriaControlled(el, {});
-      }
-    });
-    ariaControlsObserver.observe(document.documentElement, {
-      subtree: true,
-      attributes: true,
-      attributeFilter: ["aria-controls"],
-      attributeOldValue: true,
-    });
-  };
-
-  definePseudoClass(":focus", {
-    attribute: "data-focus",
-    setup: trackFocus,
-    test: (el) => {
-      if (el.matches(":focus")) {
-        return true;
-      }
-      if (hasIndirectFocus(el)) {
-        return true;
-      }
-      return false;
-    },
-  });
-  definePseudoClass(":focus-visible", {
-    attribute: "data-focus-visible",
-    // No per-element keydown/keyup listener: the shared recheckFocusChainOnKey
-    // handler re-checks the focused element (the only one a keystroke can turn
-    // focus-visible) so a keypress stays O(1), not O(number-of-boxes).
-    setup: trackFocus,
-    test: (el) => {
-      if (isMatchingFocusVisible(el)) {
-        return true;
-      }
-      if (hasIndirectFocus(el, { requireFocusVisible: true })) {
-        return true;
-      }
-      return false;
-    },
-  });
-  definePseudoClass(":focus-within", {
-    attribute: "data-focus-within",
-    setup: trackFocus,
-    test: (el) => {
-      if (el.matches(":focus-within")) {
-        return true;
-      }
-      if (hasIndirectFocus(el)) {
-        return true;
-      }
-      if (el.contains(document.activeElement)) {
-        // for some reason :focus-within sometimes is false while focus is within...
-        // (popover with chrome for some reason)
-        return true;
-      }
-      return false;
-    },
-  });
-}
-
-Object.assign(PSEUDO_CLASSES, {
-  ":-navi-pointed": {
-    attribute: "data-pointed",
-  },
-  ":-navi-pointed-by-mouse": {
-    attribute: "data-pointed-by-mouse",
-  },
-  ":-navi-pointed-by-keyboard": {
-    attribute: "data-pointed-by-keyboard",
-  },
-  ":-navi-pointed-by-proxy": {
-    attribute: "data-pointed-by-proxy",
-  },
-  ":-navi-selected": {
-    attribute: "data-selected",
-  },
-  ":-navi-loading": {
-    attribute: "data-loading",
-  },
-  ":-navi-status-info": {
-    attribute: "data-status-info",
-  },
-  ":-navi-status-success": {
-    attribute: "data-status-success",
-  },
-  ":-navi-status-warning": {
-    attribute: "data-status-warning",
-  },
-  ":-navi-status-error": {
-    attribute: "data-status-error",
-  },
-  ":-navi-expanded": {
-    attribute: "data-expanded",
-  },
-  ":-navi-void": {
-    attribute: "data-void",
-  },
-  "::highlight": {},
-});
-definePseudoClass(":-navi-has-value", {
-  attribute: "data-has-value",
-  setup: (el, callback) => {
-    const controlHost = findControlHost(el) || el;
-    return addInputEffect(controlHost, callback);
-  },
-  test: (el) => {
-    if (isControlHost(el)) {
-      const uiState = getUIStateFromElement(el);
-      if (uiState === undefined || uiState === "") {
-        return false;
-      }
-      return true;
-    }
-    if (el.value === "") {
-      return false;
-    }
-    return true;
-  },
-});
-{
-  const pressedElements = new WeakSet();
-  definePseudoClass(":-navi-pressed", {
-    attribute: "data-pressed",
-    setup: (el, callback) => {
-      // Prefer :-navi-pressed over :active for interactive elements because:
-      // - :active only tracks the primary (left) button; right-click and touch
-      //   long-press do not trigger :active reliably across browsers.
-      // - :-navi-pressed explicitly ignores non-primary buttons (e.g. right-click)
-      //   and correctly clears pressed state when a context menu opens on long-press,
-      //   which would otherwise leave the element stuck in a pressed appearance.
-
-      // Note: it might be tempting to use el.setPointerCapture() here so that pointerup
-      // always fires on el regardless of where the pointer is released. However,
-      // pointer capture routes all subsequent pointer events to the capturing element,
-      // which means any other element in the tree that expects to receive pointerup,
-      // mouseup, click, etc. after a pointerdown will silently not get them.
-      // For example a <label> that reacts to mousedown + click, or a third-party
-      // library that attaches its own listeners, would break because an ancestor
-      // grabbed the pointer out from under them.
-      // To avoid forcing every such element to declare an opt-out attribute
-      // (e.g. navi-own-pointer-capture) we simply listen on document instead,
-      // which is safe and does not interfere with anyone else's event flow.
-      const onPointerDown = (e) => {
-        if (e.button !== 0) {
-          // only left pointer (mouse left click, touch, pen)
-          return;
-        }
-        pressedElements.add(el);
-        const onRelease = () => {
-          pressedElements.delete(el);
-          document.removeEventListener("pointercancel", onRelease, true);
-          document.removeEventListener("pointerup", onRelease, true);
-          document.removeEventListener("contextmenu", onContextMenu, true);
-          callback();
-        };
-        const onContextMenu = (e) => {
-          // On touch devices, a long-press triggers the context menu.
-          // If the context menu is not prevented, it means it will open and the
-          // pointer events (pointerup, lostpointercapture) won't fire normally,
-          // leaving the element stuck in pressed state. We clear it manually.
-          // e.button === -1 means the event was synthesized from a long-press (not a real mouse click).
-          if (e.button === -1 && !e.defaultPrevented) {
-            pressedElements.delete(el);
-            document.removeEventListener("pointercancel", onRelease, true);
-            document.removeEventListener("pointerup", onRelease, true);
-            document.removeEventListener("contextmenu", onContextMenu, true);
-            callback();
-          }
-        };
-        document.addEventListener("pointercancel", onRelease, true);
-        document.addEventListener("pointerup", onRelease, true);
-        document.addEventListener("contextmenu", onContextMenu, true);
-        callback();
-      };
-      el.addEventListener("pointerdown", onPointerDown);
-      return () => {
-        el.removeEventListener("pointerdown", onPointerDown);
-        pressedElements.delete(el);
-      };
-    },
-    test: (el) => pressedElements.has(el),
-  });
-}
-
-{
-  definePseudoClass(":-navi-drag-grabbed", {
-    attribute: "navi-drag-grabbed",
-    setup: (el, callback) => {
-      const onGrab = () => {
-        callback();
-        const onRelease = () => {
-          el.removeEventListener("navi_drag_release", onRelease);
-          callback();
-        };
-        el.addEventListener("navi_drag_release", onRelease);
-      };
-      el.addEventListener("navi_drag_grab", onGrab);
-      return () => {
-        el.removeEventListener("navi_drag_grab", onGrab);
-      };
-    },
-    test: (el) => el.hasAttribute("data-drag-grabbed"),
-  });
-  definePseudoClass(":-navi-dragging", {
-    attribute: "navi-dragging",
-    setup: (el, callback) => {
-      const onStart = () => {
-        callback();
-        const onRelease = () => {
-          el.removeEventListener("navi_drag_release", onRelease);
-          callback();
-        };
-        el.addEventListener("navi_drag_release", onRelease);
-      };
-      el.addEventListener("navi_drag_start", onStart);
-      return () => {
-        el.removeEventListener("navi_drag_start", onStart);
-      };
-    },
-    test: (el) => el.hasAttribute("data-dragging"),
-  });
-}
-
-const EMPTY_STATE = {};
-const elementToImpactWeakMap = new WeakMap();
-const initPseudoStyles = (
-  element,
-  {
-    pseudoClasses,
-    pseudoState, // ":disabled", ":read-only", ":-navi-loading", etc...
-    effect,
-    elementToImpact = element,
-    elementListeningPseudoState,
-  },
-) => {
-  elementToImpactWeakMap.set(element, elementToImpact);
-  if (elementListeningPseudoState === element) {
-    console.warn(
-      `elementListeningPseudoState should not be the same as element to avoid infinite loop`,
-    );
-    elementListeningPseudoState = null;
-  }
-
-  const proxyTarget = findControlProxyTarget(element);
-
-  const onStateChange = (value, oldValue) => {
-    effect?.(value, oldValue);
-    if (elementListeningPseudoState) {
-      notifyPseudoStateSubscribers(
-        elementListeningPseudoState,
-        value,
-        oldValue,
-      );
-    }
-    // When this element's state changes, notify any proxy element that mirrors it
-    // so it can re-check and visually reflect the new state.
-    for (const proxy of findControlProxies(element)) {
-      requestPseudoStateCheck(proxy, {});
-    }
-  };
-
-  if (!pseudoClasses || pseudoClasses.length === 0) {
-    onStateChange(EMPTY_STATE);
-    return () => {};
-  }
-
-  const [teardown, addTeardown] = createPubSub();
-
-  let state;
-  const checkPseudoClasses = () => {
-    let someChange = false;
-    const currentState = {};
-    for (const pseudoClass of pseudoClasses) {
-      const pseudoClassDefinition = PSEUDO_CLASSES[pseudoClass];
-      if (!pseudoClassDefinition) {
-        console.warn(`Unknown pseudo class: ${pseudoClass}`);
-        continue;
-      }
-      let currentValue;
-      if (
-        pseudoState &&
-        Object.hasOwn(pseudoState, pseudoClass) &&
-        pseudoState[pseudoClass] !== undefined
-      ) {
-        currentValue = pseudoState[pseudoClass];
-      } else {
-        const { test } = pseudoClassDefinition;
-        if (test) {
-          currentValue = test(element, pseudoState);
-        }
-      }
-      // If this element is a proxy for another (navi-control-proxy-for="targetId"),
-      // inherit the target's active pseudo-state when the element itself isn't in that state.
-      // We check the target's elementToImpact (not the target itself) because the
-      // data-* attribute may be set on a different element (e.g. pseudoStateSelector).
-      if (!currentValue && proxyTarget) {
-        const { attribute } = pseudoClassDefinition;
-        if (attribute) {
-          const targetElementToImpact =
-            elementToImpactWeakMap.get(proxyTarget) || proxyTarget;
-          if (targetElementToImpact.hasAttribute(attribute)) {
-            currentValue = true;
-          }
-        }
-      }
-      currentState[pseudoClass] = currentValue;
-      const oldValue = state ? state[pseudoClass] : undefined;
-      if (oldValue !== currentValue || !state) {
-        someChange = true;
-        const { attribute, add, remove } = pseudoClassDefinition;
-        if (currentValue) {
-          if (attribute) {
-            elementToImpact.setAttribute(attribute, "");
-          }
-          add?.(element);
-        } else {
-          if (attribute) {
-            elementToImpact.removeAttribute(attribute);
-          }
-          remove?.(element);
-        }
-      }
-    }
-    if (!someChange) {
-      return;
-    }
-    const oldState = state;
-    state = currentState;
-    onStateChange(state, oldState);
-  };
-
-  addTeardown(
-    subscribeToPseudoState(element, (pseudoState, oldPseudoState) => {
-      state = pseudoState;
-      onStateChange(state, oldPseudoState);
-    }),
-  );
-  // One function for every way a re-check can be asked, so that setups
-  // registering it side by side (the focus tracking, for one) hold the same
-  // callback and call it once.
-  const requestCheck = () => {
-    checkPseudoClasses();
-  };
-  element.addEventListener("navi_pseudo_state_request_check", requestCheck);
-  addTeardown(() => {
-    element.removeEventListener(
-      "navi_pseudo_state_request_check",
-      requestCheck,
-    );
-  });
-
-  for (const pseudoClass of pseudoClasses) {
-    const pseudoClassDefinition = PSEUDO_CLASSES[pseudoClass];
-    if (!pseudoClassDefinition) {
-      console.warn(`Unknown pseudo class: ${pseudoClass}`);
-      continue;
-    }
-    const { setup } = pseudoClassDefinition;
-    if (setup) {
-      const cleanup = setup(element, requestCheck);
-      addTeardown(cleanup);
-    }
-  }
-  checkPseudoClasses();
-
-  return teardown;
-};
-
-const applyStyle = (
-  element,
-  style,
-  pseudoState,
-  pseudoNamedStyles,
-  preventInitialTransition,
-) => {
-  if (!element) {
-    return;
-  }
-  const styleToApply = getStyleToApply(style, pseudoState, pseudoNamedStyles);
-  // The same object comes back for every state change of a box whose inline
-  // style has no pseudo entry: nothing to write.
-  if (appliedStyleWeakMap.get(element) === styleToApply) {
-    return;
-  }
-  updateStyle(element, styleToApply, preventInitialTransition);
-};
-
-const PSEUDO_STATE_DEFAULT = {};
-const PSEUDO_NAMED_STYLES_DEFAULT = {};
-const getStyleToApply = (styles, pseudoState, pseudoNamedStyles) => {
-  if (
-    !pseudoState ||
-    pseudoState === PSEUDO_STATE_DEFAULT ||
-    !pseudoNamedStyles ||
-    pseudoNamedStyles === PSEUDO_NAMED_STYLES_DEFAULT
-  ) {
-    return styles;
-  }
-  let style = styles;
-  for (const pseudoKey of Object.keys(pseudoNamedStyles)) {
-    if (!hasEveryState(pseudoState, getPseudoKeyRequiredStates(pseudoKey))) {
-      continue;
-    }
-    if (style === styles) {
-      style = { ...styles };
-    }
-    // Both sides are already normalized for CSS by the box; only the
-    // properties that compose (a press scale on top of a translate) go through
-    // a merge, the rest is a plain override.
-    const styleToAdd = pseudoNamedStyles[pseudoKey];
-    for (const key of Object.keys(styleToAdd)) {
-      const value = styleToAdd[key];
-      if (value === undefined) {
-        continue;
-      }
-      if (key === "transform" || key === "willChange") {
-        style[key] = mergeOneStyle(style[key], value, key, "css");
-      } else {
-        style[key] = value;
-      }
-    }
-  }
-  return style;
-};
-
-// The state names a pseudo key asks for, parsed once: the same few keys come
-// back on every state change of every box that has them. "::x" alone always
-// matches; "::x:a:b" and ":a:b" ask for ":a" and ":b" — the state keys as
-// checkPseudoClasses writes them, colon included.
-const pseudoKeyRequiredStatesMap = new Map();
-const getPseudoKeyRequiredStates = (pseudoKey) => {
-  const cached = pseudoKeyRequiredStatesMap.get(pseudoKey);
-  if (cached) {
-    return cached;
-  }
-  let requiredStates;
-  if (pseudoKey.startsWith("::")) {
-    const nextColonIndex = pseudoKey.indexOf(":", 2);
-    requiredStates =
-      nextColonIndex === -1
-        ? []
-        : getPseudoKeyRequiredStates(pseudoKey.slice(nextColonIndex));
-  } else {
-    const nextColonIndex = pseudoKey.indexOf(":", 1);
-    requiredStates =
-      nextColonIndex === -1
-        ? [pseudoKey]
-        : pseudoKey
-            .slice(1)
-            .split(":")
-            .map((state) => `:${state}`);
-  }
-  pseudoKeyRequiredStatesMap.set(pseudoKey, requiredStates);
-  return requiredStates;
-};
-const hasEveryState = (pseudoState, states) => {
-  for (const state of states) {
-    if (!pseudoState[state]) {
-      return false;
-    }
-  }
-  return true;
-};
-
-// element → the style object last written to it, so the next one is written
-// as a difference: the values that changed, the keys it no longer has.
-const appliedStyleWeakMap = new WeakMap();
-const elementTransitionWeakMap = new WeakMap();
-const elementRenderedWeakSet = new WeakSet();
-const NO_STYLE = {};
-const updateStyle = (element, style, preventInitialTransition) => {
-  const styleToApply = style || NO_STYLE;
-  const styleApplied = appliedStyleWeakMap.get(element) || NO_STYLE;
-  // TRANSITION ANTI-FLICKER STRATEGY:
-  // Problem: When setting both transition and styled properties simultaneously
-  // (e.g., el.style.transition = "border-radius 0.3s ease"; el.style.borderRadius = "20px"),
-  // the browser will immediately perform a transition even if no transition existed before.
-  //
-  // Solution: Temporarily disable transitions during initial style application by setting
-  // transition to "none", then restore the intended transition after the frame completes.
-  // We handle multiple updateStyle calls in the same frame gracefully - only one
-  // requestAnimationFrame is scheduled per element, and the final transition value wins.
-  let skipTransition = false;
-  if (!elementRenderedWeakSet.has(element)) {
-    const hasTransition = Object.hasOwn(styleToApply, "transition");
-    if (hasTransition || preventInitialTransition) {
-      if (!elementTransitionWeakMap.has(element)) {
-        element.style.transition = "none";
-      }
-      elementTransitionWeakMap.set(element, styleToApply.transition);
-      // Stays "none" until the first frame puts the intended value back
-      skipTransition = true;
-    }
-    afterFirstFrame(element);
-  }
-
-  for (const key of Object.keys(styleToApply)) {
-    const value = styleToApply[key];
-    if (value === undefined || value === null) {
-      // a removal: handled below with the keys this style no longer has
-      continue;
-    }
-    if (skipTransition && key === "transition") {
-      continue;
-    }
-    if (styleApplied[key] === value) {
-      continue;
-    }
-    if (key.startsWith("--")) {
-      element.style.setProperty(key, value);
-    } else {
-      element.style[key] = value;
-    }
-  }
-
-  for (const key of Object.keys(styleApplied)) {
-    const previousValue = styleApplied[key];
-    if (previousValue === undefined || previousValue === null) {
-      continue;
-    }
-    const value = styleToApply[key];
-    if (value !== undefined && value !== null) {
-      continue;
-    }
-    if (key.startsWith("--")) {
-      element.style.removeProperty(key);
-    } else {
-      element.style[key] = "";
-    }
-  }
-
-  appliedStyleWeakMap.set(element, styleToApply);
-};
-
-// One frame for every element waiting for its first one, not one frame each.
-// What this owes each element — put back the transition suppressed above, and
-// remember it has now been painted once — is a few microseconds, while asking
-// the browser for a frame costs more than that, and a page mounting thousands of
-// boxes asks thousands of times in the same tick. A Set, so an element styled
-// twice before the frame arrives is still one entry.
-let elementSetWaitingFirstFrame = new Set();
-let firstFrameScheduled = false;
-const afterFirstFrame = (element) => {
-  elementSetWaitingFirstFrame.add(element);
-  if (firstFrameScheduled) {
-    return;
-  }
-  firstFrameScheduled = true;
-  requestAnimationFrame(() => {
-    firstFrameScheduled = false;
-    const elements = elementSetWaitingFirstFrame;
-    elementSetWaitingFirstFrame = new Set();
-    for (const element of elements) {
-      if (elementTransitionWeakMap.has(element)) {
-        const transitionToRestore = elementTransitionWeakMap.get(element);
-        if (transitionToRestore === undefined) {
-          element.style.transition = "";
-        } else {
-          element.style.transition = transitionToRestore;
-        }
-        elementTransitionWeakMap.delete(element);
-      }
-      elementRenderedWeakSet.add(element);
-    }
-  });
-};
-
 /**
  * Keeps a DOM element in sync with `syncElement(el)` whenever syncElement changes.
  * - If element is already mounted: runs syncElement immediately during render.
@@ -33011,8 +30324,6 @@ const RouteTravel = ({
   // and read back as "the page changed" it would start a second travel nobody
   // asked for, over pictures that are already showing something else.
   const pageAskedForRef = useRef(null);
-  // What a press stopped in flight, until the gesture says what it is about.
-  const caughtAtPressRef = useRef(null);
   // The latest way to answer a gesture, for a watcher that outlives every
   // render (see the wheel effect below).
   const travelHandlersRef = useRef(null);
@@ -33448,6 +30759,23 @@ const RouteTravel = ({
     }
     redirectTravel(travel, page, toIndex > fromIndex ? "forward" : "back");
   };
+
+  // One page further than the travel in flight is going, the same way: what
+  // a second swipe asks for over a page still arriving. Reached the way a tab
+  // pressed while it plays reaches it — the same pictures, the router pointed
+  // one page further (see redirectTravel) — so nothing restarts and nothing
+  // stops. Past the last page there is nothing to aim at, and the travel
+  // simply arrives where it was going.
+  const aimOnePageFurther = (travel, sign) => {
+    const fromIndex = pageIndexOf(pages, travel.page);
+    const page = sign > 0 ? pages[fromIndex - 1] : pages[fromIndex + 1];
+    if (fromIndex === -1 || !page) {
+      return;
+    }
+    redirectTravel(travel, page, travel.direction);
+    pageAskedForRef.current = page;
+    travelTo(page, "drag");
+  };
   const endTravel = travel => {
     if (travel.ended) {
       return;
@@ -33518,7 +30846,8 @@ const RouteTravel = ({
             travelOn: false
           };
         }
-        caughtAtPressRef.current = null;
+        // Stopped here, where it stands now: left playing under the press
+        // until the hand said it holds it (see inFlight in onPointerDown).
         holdTravel(travelInFlight);
         // Where the pictures stand right now, said as a pull: what the finger
         // continues from, so nothing jumps when it takes them over.
@@ -33586,11 +30915,18 @@ const RouteTravel = ({
       thrown
     }) => {
       const travel = travelRef.current;
-      if (
-      // Thrown on before its end: handing over from there would mean jumping
-      // the pictures the rest of the way first (see scrubTravel below), a
-      // page seen leaping. The travel caught simply arrives.
-      thrown || !travel || travel.noPicture || travel.ended || travel.reverting || !CAN_KEEP_PICTURE) {
+      if (thrown) {
+        // Caught, then thrown on before its end: the page after is reached by
+        // aiming the travel in hand further, and let go of it arrives there.
+        // There is no box to hand over — a new one would mean jumping these
+        // pictures the rest of the way first, a page seen leaping — so none
+        // is answered, and the gesture lets the travel go as it is.
+        if (travel && !travel.noPicture && !travel.ended && !travel.reverting) {
+          aimOnePageFurther(travel, sign);
+        }
+        return false;
+      }
+      if (!travel || travel.noPicture || travel.ended || travel.reverting || !CAN_KEEP_PICTURE) {
         return false;
       }
       // Where the page in hand is coming from, said the way the gesture says
@@ -33654,11 +30990,24 @@ const RouteTravel = ({
         travelOn: sign < 0
       };
     },
+    // The next swipe over a page still arriving: the page after it, and the
+    // travel in flight goes there — the same pictures, the router pointed one
+    // page further, exactly what a tab pressed while it plays does (see
+    // retargetTravel). Nothing is held and nothing restarts.
+    onPushOn: ({
+      sign
+    }) => {
+      const travel = travelRef.current;
+      if (!travel || travel.noPicture || travel.ended || travel.reverting || travel.scrub) {
+        return false;
+      }
+      aimOnePageFurther(travel, sign);
+      return true;
+    },
     onEnd: ({
       travels
     }) => {
       gestureRef.current = null;
-      caughtAtPressRef.current = null;
       const travel = travelRef.current;
       if (!travel) {
         // The travel this gesture was holding ended under it. Nothing left to
@@ -33685,39 +31034,30 @@ const RouteTravel = ({
     if (!travelByDrag || gestureRef.current) {
       return;
     }
-    // Touching something that is moving STOPS it, right there, before the
-    // gesture has said anything about itself. Waiting for the first pixels that
-    // decide an axis would let the pages travel on under a finger that has
-    // already landed on them, which is the one moment a hand expects to be
-    // obeyed without asking. If the press turns out to be nothing, the travel
-    // is let go of again and carries on (see onGiveUp).
-    const travelToCatch = travelRef.current;
-    if (travelToCatch && !travelToCatch.noPicture && !travelToCatch.ended && !travelToCatch.reverting) {
-      holdTravel(travelToCatch);
-      caughtAtPressRef.current = travelToCatch;
-    }
-    // A travel already playing is not a reason to refuse the press: a hand
-    // reaching for a page that is still sliding is reaching for THAT page, and
-    // the gesture takes it over (see onStart).
+    // A travel playing under the press is left playing: a hand landing on a
+    // page still sliding is far more often the next swipe than a catch, and
+    // stopping the pages at the press is what that swipe feels as a stall. The
+    // gesture listens to the hand first and says which it was — the next page
+    // (onPushOn) or this one, held (onStart) — see inFlight in
+    // drag_to_travel.js. Either way the press is not refused: a gesture given
+    // back to the browser is a page that rocks under a travel already moving.
+    const travelInFlight = travelRef.current;
+    const leftPlaying = travelInFlight && !travelInFlight.noPicture && !travelInFlight.ended && !travelInFlight.reverting && !travelInFlight.scrub;
     if (currentIndex === -1) {
       return;
     }
-    // A press that never became a gesture: whatever it stopped goes on its way,
-    // from where the finger caught it.
     const giveUp = () => {
       gestureRef.current = null;
-      const caught = caughtAtPressRef.current;
-      caughtAtPressRef.current = null;
-      if (caught && !caught.ended) {
-        releaseHold(caught);
-      }
     };
     const gesture = startDragToTravel(pointerDownEvent, {
       element: elementRef.current,
       axes: axis,
-      // Caught in flight: the hand is already in the gesture (see above), so it
-      // is answered from its first pixel, on the axis the pages travel.
-      immediate: caughtAtPressRef.current ? axis : false,
+      inFlight: leftPlaying ? {
+        axis,
+        // The way a pull bringing in the page on its way would go:
+        // dragging towards the end of the axis brings in what is BEFORE.
+        way: travelInFlight.direction === "back" ? 1 : -1
+      } : false,
       ...travelHandlers,
       onGiveUp: giveUp
     });
@@ -59190,13 +56530,10 @@ const SlideContainer = ({
     });
   };
 
-  // A travel that is playing when a gesture arrives is STOPPED where it stands,
-  // before the gesture has said anything about itself. Not at the first pixels
-  // that decide an axis: over those the slides go on at their own speed under a
-  // hand already resting on them, and when the gesture finally takes them they
-  // are pinned to a hand moving at a quite different pace — the slide does not
-  // jump, it stops dead, which is what one reads as a jolt and as "it got away
-  // from me".
+  // A travel that is playing when a gesture takes hold of it is STOPPED where it
+  // stands, at the moment the hand holds it (see readTravelInFlight for when
+  // that is): the track stays exactly under the eye, and the hand answers it
+  // from there.
   // A gesture that turns out to be nothing lets the travel carry on from where
   // it was caught (see onGiveUp).
   const catchTravelInFlight = () => {
@@ -59222,15 +56559,31 @@ const SlideContainer = ({
       to: moving.to
     };
   };
-  // Which way a caught travel was going: a hand reaching for something moving
-  // has no axis left to decide, and a first pixel of tremor read as one gives
-  // the gesture up — and lets go of what it just caught.
-  const axisOfCaughtTravel = caught => {
-    const boxRect = caught.trackElement.getBoundingClientRect();
-    const targetPx = offsetToPx(caught.offsetTarget, boxRect);
-    const towardsX = Math.abs(targetPx.x - caught.onScreenPx.x);
-    const towardsY = Math.abs(targetPx.y - caught.onScreenPx.y);
-    return towardsX >= towardsY ? "x" : "y";
+  // Which way a travel still playing is going, read without touching it: a
+  // hand landing on something moving has no axis left to decide (a first pixel
+  // of tremor read as one gives the gesture up), and which WAY along it the
+  // travel goes is what tells the next swipe from a catch. `way` is the sign a
+  // pull going the same way would have.
+  const readTravelInFlight = () => {
+    const trackElement = trackRef.current;
+    const animation = trackAnimationRef.current;
+    if (!animation || animation.playState !== "running") {
+      return null;
+    }
+    const onScreenPx = trackOffsetPx(trackElement, containerRef.current);
+    const targetPx = offsetToPx(offsetRef.current, trackElement.getBoundingClientRect());
+    const towardsX = targetPx.x - onScreenPx.x;
+    const towardsY = targetPx.y - onScreenPx.y;
+    const axis = Math.abs(towardsX) >= Math.abs(towardsY) ? "x" : "y";
+    const towards = axis === "x" ? towardsX : towardsY;
+    if (Math.abs(towards) < 1) {
+      // On its last pixel: nothing left to catch or to push.
+      return null;
+    }
+    return {
+      axis,
+      way: towards > 0 ? 1 : -1
+    };
   };
 
   // What a travel gesture does to the slides, whoever asked for it: a pointer
@@ -59264,8 +56617,14 @@ const SlideContainer = ({
       onStart: ({
         axis,
         sign,
-        target
+        target,
+        caught
       }) => {
+        // A travel left playing under the press, which the hand has now taken
+        // hold of: stopped here, where it stands at this moment.
+        if (caught) {
+          caughtTravel = catchTravelInFlight();
+        }
         // Everything positional is read HERE rather than when the pointer
         // landed: the travel that was playing then may have arrived since, and
         // it is what the slides are doing at the moment the gesture takes them
@@ -59558,16 +56917,40 @@ const SlideContainer = ({
     if (!canStartTravel()) {
       return;
     }
-    const caughtTravel = catchTravelInFlight();
-    const caughtAxis = caughtTravel ? axisOfCaughtTravel(caughtTravel) : null;
+    const travelInFlight = readTravelInFlight();
+    // Left playing when the hand can take it: the press is then far more
+    // likely the next swipe than a catch, and stopping the travel under it is
+    // what that swipe feels as a stall — the gesture listens to the hand first
+    // and says which it was (see inFlight in drag_to_travel.js). On an axis the
+    // hand cannot drag, it is caught at the press, as a travel under a finger
+    // that starts something else.
+    const leftPlaying = Boolean(travelInFlight && dragAxes.includes(travelInFlight.axis));
+    const caughtTravel = travelInFlight && !leftPlaying ? catchTravelInFlight() : null;
     const handlers = createTravelHandlers(caughtTravel);
     const gesture = startDragToTravel(pointerDownEvent, {
       element: containerRef.current,
       axes: dragAxes,
-      // Caught in flight: the hand is already in the gesture, so it is answered
-      // from its first pixel rather than after a threshold it has no reason to
-      // cross twice — on the axis what it caught is travelling on.
-      immediate: caughtAxis && dragAxes.includes(caughtAxis) ? caughtAxis : false,
+      inFlight: leftPlaying ? travelInFlight : false,
+      // The next swipe over a travel still playing: one slide further, and the
+      // travel goes on there from where it is — the way a second arrow press
+      // sends it — without ever having stopped under the hand.
+      onPushOn: ({
+        axis,
+        sign,
+        event
+      }) => {
+        if (trackAnimationRef.current?.playState !== "running") {
+          return false;
+        }
+        // Nothing is held: the box is free for the travel that follows.
+        dragRef.current = null;
+        if (axis === "x") {
+          move(-sign, 0, event);
+        } else {
+          move(0, -sign, event);
+        }
+        return true;
+      },
       ...handlers
     });
     if (!gesture) {
@@ -70299,25 +67682,12 @@ const ListUI = props => {
     });
   } else if (loading && loadingFallback) {
     if (loadingFallback === "skeleton") {
-      // Skeleton rows draw their own separators: they never reach ListItemUI
-      // (where real items get theirs from SeparatorContext), and without them
-      // the list would visibly gain its dividers only once loaded.
-      const skeletons = [];
-      let skeletonIndex = 0;
-      while (skeletonIndex < loadingSkeletonCount) {
-        if (separator && skeletonIndex > 0) {
-          skeletons.push(cloneElement(resolveSeparatorVnode(separator, skeletonIndex - 1), {
-            key: `navi-list-skeleton-separator-${skeletonIndex}`
-          }));
-        }
-        skeletons.push(jsx(Fragment$1, {
-          children: renderSkeleton ? renderSkeleton(skeletonIndex) : jsx(ListItem, {
-            skeleton: true
-          })
-        }, `navi-list-skeleton-${skeletonIndex}`));
-        skeletonIndex++;
-      }
-      content = skeletons;
+      // Held to the render budget like the rows they stand for: a list
+      // expecting a hundred rows draws the ones its window frames, and the
+      // room of the others is there, so nothing moves when they arrive.
+      content = jsx(ListLoadingRows, {
+        count: loadingSkeletonCount
+      }, "navi-list-loading-rows");
     } else if (loadingFallback === "loader") {
       content = jsx(ListItem, {
         role: "presentation",
@@ -73064,18 +70434,59 @@ const VISIBILITY_HIDDEN_STYLE = {
  *   unmounted while asking says `busy: false` on its way out.
  */
 const ListItems = ({
-  renderItem,
   items,
   itemsAction,
   count,
-  pageSize,
   memoryBudget,
+  onRequestStateChange,
+  ...rowProps
+}) => {
+  const store = useItemStore({
+    items,
+    count,
+    itemsAction,
+    memoryBudget,
+    onRequestStateChange
+  });
+  return useRunRows(store, rowProps);
+};
+
+// The rows a `loading` list is told to expect (loadingSkeletonCount): a run
+// holding none of them, and asking for none — they arrive through the app.
+// Drawn as a run's missing rows are, under the render window with fillers
+// holding the room of the rest, since that is what they stand for.
+const ListLoadingRows = ({
+  count
+}) => {
+  return useRunRows(createStoreHoldingNothing(count), LOADING_ROWS_PROPS);
+};
+const LOADING_ROWS_PROPS = {};
+const createStoreHoldingNothing = rowCount => {
+  return {
+    rowCount,
+    failure: null,
+    refreshing: false,
+    forget: () => {},
+    retry: () => {},
+    getItem: () => undefined,
+    eachHeld: () => {},
+    holds: () => false,
+    useRequestMissing: () => {}
+  };
+};
+
+// What a run draws: the rows its window frames, a skeleton for each one the
+// store does not hold, and fillers holding the room of the rows outside it.
+// Which rows are held, and fetching the others, is the store's (see
+// useItemStore).
+const useRunRows = (store, {
+  renderItem,
+  pageSize,
   groupBy,
   renderGroupLabel,
   groupLabelProps,
   renderSkeleton,
-  renderError,
-  onRequestStateChange
+  renderError
 }) => {
   const ownerId = useId();
   const listRows = useContext(ListRowsContext);
@@ -73097,13 +70508,6 @@ const ListItems = ({
     };
   }
   const rowVnodesByItem = rowVnodesRef.current.byItem;
-  const store = useItemStore({
-    items,
-    count,
-    itemsAction,
-    memoryBudget,
-    onRequestStateChange
-  });
   const renderRowSkeleton = renderSkeleton === undefined ? listRows.renderSkeleton : renderSkeleton;
   // A row on its way takes the room the list reserves for it: anything else
   // and the rows drawn stop short of where the scroll says they are. Read
@@ -74164,13 +71568,16 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   `loadingSkeletonCount` placeholder rows (look:
  *   `renderSkeleton`), `"loader"` a single centered spinner, and
  *   anything else is rendered as-is in a row of its own. A falsy value
- *   displays nothing. A list that knows how many rows it will have has no use
- *   for this — see `<List.Items count>`, whose not-yet-loaded rows are drawn
- *   as skeletons in place, one per row, virtualized like the rest.
+ *   displays nothing. A list read a slice at a time has no use for this — see
+ *   `<List.Items count>`, whose not-yet-loaded rows are drawn as skeletons in
+ *   place, one per row, virtualized like the rest.
  * @param {number} [props.loadingSkeletonCount=3]
- *   How many placeholder rows `loadingFallback="skeleton"` draws. `0` says the
- *   list is already known to be empty: the empty `fallback` shows right away
- *   rather than an empty frame, so nothing moves when the response arrives.
+ *   How many rows `loadingFallback="skeleton"` stands for — the number the
+ *   answer will hold, so nothing moves when it arrives. Drawn under
+ *   `renderBudget` like the rows they stand for: the ones the window frames
+ *   are skeletons, the others hold their room. `0` says the list is already
+ *   known to be empty: the empty `fallback` shows right away rather than an
+ *   empty frame.
  * @param {"start"|"end"|number|{id: string, offset?: number}} [props.defaultScrolled="start"]
  *   Where the list opens, after which the user owns the scroll — unless it is
  *   being come back to (see `scrollResetOnNavigation`). `"end"` is a
@@ -89384,5 +86791,5 @@ const UserSvg = () => jsx("svg", {
   })
 });
 
-export { ActionRenderer, ActiveKeyboardShortcuts, Address, Badge, BadgeCount, BadgeList, Binder, Box, Button, ButtonCopyToClipboard, CalloutStatusIcon, Caption, CardLayout, CheckSvg, CheckboxGroup, CloseSvg, Code, Col, Colgroup, Color, ConstructionSvg, ControlGroup, ControlSwap, DaySpin, Details, Dialog, Editable, ErrorBoundary, ErrorBoundaryContext, ExclamationSvg, Expandable, EyeClosedSvg, EyeSvg, Field, FixedBar, Form, Group, Head, HeartSvg, HomeSvg, Icon, Image, InfoSvg, Input, InputDuration, Interpolate, Label, Link, LinkAnchorSvg, LinkBlankTargetSvg, LinkCurrentSvg, List, ListItem, ListItemGroup, ListItems, Loading, LoadingDotsSvg, LoadingIndicator, LoadingIndicatorFluid, LoadingOutline, MessageBox, Meter, Nav, NaviDebug, NetworkPolicyError, NumberSpin, Paragraph, Picker, Popover, Popup, Quantity, RadioGroup, Route, RouteTransitionArea, RouteTravel, RowNumberCol, RowNumberTableCell, SVGMaskOverlay, SearchSvg, Select, SelectableInput, SelectionContext, Separator, SettingsSvg, SidePanel, Slide, SlideContainer, Spin, SpinGroup, SplitButton, StarSvg, Step, StepList, SummaryMarker, Svg, Table, TableCell, Tbody, Text, TextBox, Textarea, TextareaCharCount, Thead, Time, TimeRange, TimeRangeSpin, TimeRangeWheel, TimeSpin, TimeWheel, Title, Tr, UITransition, Unit, UserSvg, ViewportLayout, Wheel, WheelGroup, WheelItem, actionRunEffect, anyMatchingRouteSignal, applySearch, arraySignalMembership, canNavBackSignal, canNavForwardSignal, coarsePointerSignal, compareTwoJsValues, constraintFromValidityRule, createAction, createAvailableConstraint, createRequestCanceller, createSearch, createSelectionKeyboardShortcuts, createSlot, defineInteractionDetector, defineRouteDefaultTransition, defineRouteTransition, detectHorizontalOverflow, dispatchRequestSetUIState, enableDebugActions, enableDebugOnDocumentLoading, ensureDocumentStartViewTransition, errorIsDisplayed, filterTableSelection, getNowHours, getNowHoursRoundedToStep, isCellSelected, isColumnSelected, isNetworkPolicyError, isRowSelected, isScrolling, isToday, languagesSignal, localStorageSignal, markAsOutsideTextFlow, markErrorAsDisplayedBy, moveArrayItemByIndex, moveFocusTo, navBack, navForward, navIntegratedVia, navTo, naviI18n, openCallout, preloadUrl, rawUrlPart, registerGlobalConstraint, reload, rerunActions, resource, route, routeAction, routeFallback, scrollActivitySignal, setBaseUrl, setNetworkPolicy, setPreferredLanguage, setSupportedLanguages, setUrlTargetOptions, setupRoutes, smallTouchScreenSignal, stateSignal, stopLoad, stringifyTableSelectionValue, swapArrayItemByIndex, syncOwnedResourceToSignals, syncResourceToSignals, triggerNaviCommand, updateActions, useActionStatus, useArraySignalMembership, useAsyncData, useCalloutElement, useCalloutRequestClose, useCanNavBack, useCanNavForward, useCancelPrevious, useCellGridFromRows, useConstraintValidityState, useDependenciesDiff, useDisplayedLayoutEffect, useDocumentResource, useDocumentState, useDocumentUrl, useEditionController, useFocusGroup, useInputGroup, useKeyboardShortcuts, useNavState, useNetworkPolicyReason, useOrderedColumns, usePickerState, usePopupMode, useRouteStatus, useSearchText, useSelectableElement, useSelectionController, useSignalSync, useSlideContainer, useSlideValue, useStateArray, useTitleLevel, useTransitionCover, useUrlSearchParam, useUrlTargetId, valueInLocalStorage, windowWidthSignal };
+export { ActionRenderer, ActiveKeyboardShortcuts, Address, Badge, BadgeCount, BadgeList, Binder, Box, Button, ButtonCopyToClipboard, CalloutStatusIcon, Caption, CardLayout, CheckSvg, CheckboxGroup, CloseSvg, Code, Col, Colgroup, Color, ConstructionSvg, ControlGroup, ControlSwap, DaySpin, Details, Dialog, Editable, ErrorBoundary, ErrorBoundaryContext, ExclamationSvg, Expandable, EyeClosedSvg, EyeSvg, Field, FixedBar, Form, Group, Head, HeartSvg, HomeSvg, Icon, Image, InfoSvg, Input, InputDuration, Interpolate, Label, Link, LinkAnchorSvg, LinkBlankTargetSvg, LinkCurrentSvg, List, ListItem, ListItemGroup, ListItems, Loading, LoadingDotsSvg, LoadingIndicator, LoadingIndicatorFluid, LoadingOutline, MessageBox, Meter, Nav, NaviDebug, NetworkPolicyError, NumberSpin, Paragraph, Picker, Popover, Popup, Quantity, RadioGroup, Route, RouteTransitionArea, RouteTravel, RowNumberCol, RowNumberTableCell, SVGMaskOverlay, SearchSvg, Select, SelectableInput, SelectionContext, Separator, SettingsSvg, SidePanel, Slide, SlideContainer, Spin, SpinGroup, SplitButton, StarSvg, Step, StepList, SummaryMarker, Svg, Table, TableCell, Tbody, Text, TextBox, Textarea, TextareaCharCount, Thead, Time, TimeRange, TimeRangeSpin, TimeRangeWheel, TimeSpin, TimeWheel, Title, Tr, UITransition, Unit, UserSvg, ViewportLayout, Wheel, WheelGroup, WheelItem, actionRunEffect, anyMatchingRouteSignal, applySearch, arraySignalMembership, canNavBackSignal, canNavForwardSignal, coarsePointerSignal, compareTwoJsValues, constraintFromValidityRule, createAction, createAvailableConstraint, createRequestCanceller, createSearch, createSelectionKeyboardShortcuts, createSlot, defineInteractionDetector, defineRouteDefaultTransition, defineRouteTransition, detectHorizontalOverflow, dispatchRequestSetUIState, enableDebugActions, enableDebugOnDocumentLoading, ensureDocumentStartViewTransition, errorIsDisplayed, filterTableSelection, isCellSelected, isColumnSelected, isNetworkPolicyError, isRowSelected, isScrolling, languagesSignal, localStorageSignal, markAsOutsideTextFlow, markErrorAsDisplayedBy, moveArrayItemByIndex, moveFocusTo, navBack, navForward, navIntegratedVia, navTo, naviI18n, openCallout, preloadUrl, rawUrlPart, registerGlobalConstraint, reload, rerunActions, resource, route, routeAction, routeFallback, scrollActivitySignal, setBaseUrl, setNetworkPolicy, setPreferredLanguage, setSupportedLanguages, setUrlTargetOptions, setupRoutes, smallTouchScreenSignal, stateSignal, stopLoad, stringifyTableSelectionValue, swapArrayItemByIndex, syncOwnedResourceToSignals, syncResourceToSignals, triggerNaviCommand, updateActions, useActionStatus, useArraySignalMembership, useAsyncData, useCalloutElement, useCalloutRequestClose, useCanNavBack, useCanNavForward, useCancelPrevious, useCellGridFromRows, useConstraintValidityState, useDependenciesDiff, useDisplayedLayoutEffect, useDocumentResource, useDocumentState, useDocumentUrl, useEditionController, useFocusGroup, useInputGroup, useKeyboardShortcuts, useNavState, useNetworkPolicyReason, useOrderedColumns, usePickerState, usePopupMode, useRouteStatus, useSearchText, useSelectableElement, useSelectionController, useSignalSync, useSlideContainer, useSlideValue, useStateArray, useTitleLevel, useTransitionCover, useUrlSearchParam, useUrlTargetId, valueInLocalStorage, windowWidthSignal };
 //# sourceMappingURL=jsenv_navi.js.map