@jsenv/navi 0.29.481 → 0.29.483

package/dist/dev/jsenv_navi.js

@@ -980,6 +980,14 @@ const buttonI18n = /*#__PURE__*/ defineNaviMessages({
     en: "Remove",
     fr: "Retirer",
   },
+  "button.copy": {
+    en: "Copy",
+    fr: "Copier",
+  },
+  "button.copied": {
+    en: "Copied!",
+    fr: "Copié !",
+  },
 });
 
 // Spin messages — the ends of what one steps through when the control holding
@@ -2964,6 +2972,78 @@ const mergeTwoJsValues = (firstValue, secondValue) => {
   return objectMerge;
 };
 
+// An option a function does not read does nothing, and what is built on it
+// still looks plausible: `persists` written `persist` keeps nothing across a
+// reload, and nothing says so. Said out loud in dev, with the option it most
+// likely meant, because the caller cannot tell "ignored" from "broken".
+
+/**
+ * Warns, once per `where` and key, about each key of `options` that is not
+ * in `knownKeys`. `hints` maps a key to a sentence saying where that wish
+ * belongs instead.
+ */
+const warnUnknownOptions = (where, options, knownKeys, hints = {}) => {
+  for (const key of Object.keys(options)) {
+    if (knownKeys.has(key)) {
+      continue;
+    }
+    const warnedKey = `${where} ${key}`;
+    if (warnedKeySet.has(warnedKey)) {
+      continue;
+    }
+    warnedKeySet.add(warnedKey);
+    let message = `${where}: "${key}" is not an option it reads, it does nothing.`;
+    const closest = findClosestKey(key, knownKeys);
+    if (closest) {
+      message += ` Did you mean "${closest}"?`;
+    }
+    if (hints[key]) {
+      message += ` ${hints[key]}`;
+    }
+    console.warn(message);
+  }
+};
+
+const warnedKeySet = new Set();
+
+// A slip of a letter or two (`persist`, `debounceURL`), or the same word
+// with a different case.
+const findClosestKey = (key, knownKeys) => {
+  const keyLowerCase = key.toLowerCase();
+  let closest;
+  let closestDistance = 3;
+  for (const knownKey of knownKeys) {
+    const distance = editDistance(keyLowerCase, knownKey.toLowerCase());
+    if (distance < closestDistance) {
+      closest = knownKey;
+      closestDistance = distance;
+    }
+  }
+  return closest;
+};
+
+const editDistance = (a, b) => {
+  let previousRow = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = previousRow[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+      const insertion = row[j - 1] + 1;
+      const deletion = previousRow[j] + 1;
+      let smallest = substitution;
+      if (insertion < smallest) {
+        smallest = insertion;
+      }
+      if (deletion < smallest) {
+        smallest = deletion;
+      }
+      row.push(smallest);
+    }
+    previousRow = row;
+  }
+  return previousRow[b.length];
+};
+
 /**
  * Creates an effect that uses WeakRef to prevent garbage collection of referenced values.
  *
@@ -3759,6 +3839,33 @@ const mergeActionParams = (currentParams, newParams) => {
   return mergeTwoJsValues(currentParams, newParams);
 };
 
+// What createActionCore reads off the options (see warnUnknownOptions):
+// `{ dependencies: [X] }` would otherwise be accepted and never rerun anything.
+const OPTIONS_CREATE_ACTION_READS = new Set([
+  "keep",
+  "name",
+  "params",
+  "isPrerun",
+  "runningState",
+  "aborted",
+  "error",
+  "value",
+  "resultToValue",
+  "valueToData",
+  "provisionalValue",
+  "inheritData",
+  "dataDefault",
+  "data",
+  "completed",
+  "sideEffect",
+  "meta",
+  "outputSignal",
+  "completeSideEffect",
+]);
+const OPTIONS_CREATE_ACTION_HINTS = {
+  dependencies: `A read that follows writes is a resource (docs/actions.md, "Reruns").`,
+  rerunOn: `A read that follows writes is a resource (docs/actions.md, "Reruns").`,
+};
 const actionWeakMap = new WeakMap();
 /**
  * Wraps an async callback into an action: a question, its answer, and the
@@ -3801,6 +3908,14 @@ const createAction = (callback, rootOptions = {}) => {
   if (existing) {
     return existing;
   }
+  {
+    warnUnknownOptions(
+      `createAction(${callback.name || "anonymous"})`,
+      rootOptions,
+      OPTIONS_CREATE_ACTION_READS,
+      OPTIONS_CREATE_ACTION_HINTS,
+    );
+  }
 
   const keptAnswerRegistry = rootOptions.keep
     ? createKeptAnswerRegistry(rootOptions.keep)
@@ -7316,6 +7431,32 @@ const notePageChange = () => {
 
 const isRenderingPageChange = () => renderingPageChange;
 
+// A browser refusing storage (blocked site data, some private windows) throws
+// on the first touch of window.localStorage, and a full one throws on setItem.
+// Either way what was to be kept lives in memory for the session, which is all
+// a persisted value can fall back to — so every access goes through here.
+
+const readLocalStorage = (key) => {
+  try {
+    const raw = window.localStorage.getItem(key);
+    return raw === null ? undefined : raw;
+  } catch {
+    return undefined;
+  }
+};
+
+const writeLocalStorage = (key, value) => {
+  try {
+    if (value === undefined) {
+      window.localStorage.removeItem(key);
+    } else {
+      window.localStorage.setItem(key, value);
+    }
+  } catch {
+    // Full, or refused: the value lives for the session only.
+  }
+};
+
 // Global signal registry for route template detection
 const globalSignalRegistry = new Map();
 
@@ -7351,6 +7492,26 @@ const generateSignalId = () => {
   return id;
 };
 
+// Read by stateSignal, or off the options it stores by route_pattern.js
+// (itemType).
+const STATE_SIGNAL_OPTIONS = new Set([
+  "id",
+  "type",
+  "itemType",
+  "min",
+  "max",
+  "step",
+  "oneOf",
+  "localStorageRepresentation",
+  "persists",
+  "debug",
+  "default",
+  "ignoreArrayOrder",
+  "autoFix",
+  "weak",
+  "history",
+  "debounceUrl",
+]);
 /**
  * Creates an advanced signal with dynamic default value, local storage persistence, and validation.
  *
@@ -7493,6 +7654,9 @@ const stateSignal = (defaultValue, options = {}) => {
     history = "replace",
     debounceUrl = 0,
   } = options;
+  {
+    warnUnknownOptions(`stateSignal "${id}"`, options, STATE_SIGNAL_OPTIONS);
+  }
 
   if (history !== "replace" && history !== "push") {
     throw new TypeError(
@@ -7561,27 +7725,19 @@ const stateSignal = (defaultValue, options = {}) => {
     }
   }
   const readFromLocalStorage = persists
-    ? () => {
-        const raw = window.localStorage.getItem(localStorageKey);
-        if (raw === null) {
-          return undefined;
-        }
-        return raw;
-      }
+    ? () => readLocalStorage(localStorageKey)
     : () => undefined;
   const updateLocalStorage = persists
     ? () => {
-        const localStorageValue = validity.representations.localStorage.value;
-        if (localStorageValue === undefined) {
-          window.localStorage.removeItem(localStorageKey);
-        } else {
-          window.localStorage.setItem(localStorageKey, localStorageValue);
-        }
+        writeLocalStorage(
+          localStorageKey,
+          validity.representations.localStorage.value,
+        );
       }
     : () => {};
   const removeFromLocalStorage = persists
     ? () => {
-        window.localStorage.removeItem(localStorageKey);
+        writeLocalStorage(localStorageKey, undefined);
       }
     : () => {};
 
@@ -10289,6 +10445,13 @@ const getRoutePrivateProperties = (route) => {
 const ROUTE_NOT_MATCHING_PARAMS = {};
 // Flag to prevent signal-to-URL synchronization during URL-to-signal synchronization
 let isUpdatingRoutesFromUrl = false;
+const ROUTE_OPTIONS = new Set([
+  "searchParams",
+  "params",
+  "redirectRoute",
+  "redirectRouteParams",
+  "dropSearchParams",
+]);
 /**
  * Declares a route from an url pattern.
  *
@@ -10371,16 +10534,17 @@ let isUpdatingRoutesFromUrl = false;
  *   route(`/games/:gameId=${gamePageIdSignal}`, { dropSearchParams: ["v"] });
  *   ```
  */
-const route = (
-  pattern,
-  {
+const route = (pattern, options = {}) => {
+  const {
     searchParams,
     params,
     redirectRoute,
     redirectRouteParams,
     dropSearchParams,
-  } = {},
-) => {
+  } = options;
+  {
+    warnUnknownOptions(`route("${pattern}")`, options, ROUTE_OPTIONS);
+  }
   const routePattern = createRoutePattern(pattern, { searchParams, params });
   const { cleanPattern } = routePattern;
   const [publishStatus, subscribeStatus] = createPubSub();
@@ -12086,6 +12250,13 @@ const activeRouteReadsSignal = computed(() => {
   return reads;
 });
 
+// Besides `when` and `prefetch`, what the binding reads (actionRunEffect,
+// then bindParams).
+const ROUTE_ACTION_BINDING_OPTIONS = new Set([
+  "debounce",
+  "inheritData",
+  "rerunOnChange",
+]);
 /**
  * Binds an action to a route: it runs when the route matches, with the params
  * the effect reads off the address, runs again on a `reload()`, and is aborted
@@ -12135,6 +12306,9 @@ const routeAction = (
   paramsEffect,
   { when, prefetch = true, ...options } = {},
 ) => {
+  {
+    warnUnknownOptions("routeAction", options, ROUTE_ACTION_BINDING_OPTIONS);
+  }
   if (typeof action === "function") {
     action = createAction(action);
   }
@@ -13977,6 +14151,12 @@ const stopLoad = (reason = "stopLoad() called") => {
  * actions of the routes matching the url run again (see routeAction), one that
  * failed included — what a "Retry" under a page that could not load calls.
  * The address, the history and the scroll stay as they are.
+ *
+ * Route actions only: a component's `useAsyncData(fn)`, or an action no route
+ * reads, is not asked again. Nor does it bring back code whose `import()`
+ * failed — the document refuses that address again without a request — so
+ * the way out of a failed import is a fresh document,
+ * `window.location.reload()` (docs/dynamic_import.md).
  */
 const reload = browserIntegration.reload;
 /**
@@ -25212,16 +25392,11 @@ const arraySignalMembership = (...args) => {
 };
 
 const localStorageSignal = (key) => {
-  const initialValue = localStorage.getItem(key);
-
-  const valueSignal = signal(initialValue === null ? undefined : initialValue);
+  const valueSignal = signal(readLocalStorage(key));
   effect(() => {
     const value = valueSignal.value;
-    if (value === undefined) {
-      localStorage.removeItem(key);
-    } else {
-      localStorage.setItem(key, value);
-    }
+    // Storage keeps strings: a null written as is would come back as "null".
+    writeLocalStorage(key, value === null ? undefined : value);
   });
 
   return valueSignal;
@@ -26067,12 +26242,51 @@ const resolveRerunOn = (rerunOn, inheritedRerunOn = defaultRerunOn) => {
   if (!rerunOn) {
     return inheritedRerunOn;
   }
+  assertRerunOnCanFire(rerunOn);
   return {
     GET: rerunOn.GET ?? inheritedRerunOn.GET,
     GET_MANY: rerunOn.GET_MANY ?? inheritedRerunOn.GET_MANY,
     GET_RANGE: rerunOn.GET_RANGE ?? inheritedRerunOn.GET_RANGE,
   };
 };
+// What can never fire throws, as a dependency name does (see
+// resolveDependency): a rerun that never happens leaves a read on its old
+// value with nothing to say so.
+const RERUN_READS = ["GET", "GET_MANY", "GET_RANGE"];
+const RERUN_VERBS = ["POST", "PUT", "PATCH", "DELETE", "*"];
+const assertRerunOnCanFire = (rerunOn) => {
+  for (const read of Object.keys(rerunOn)) {
+    if (!RERUN_READS.includes(read)) {
+      throw new Error(
+        `rerunOn: "${read}" is not a read that reruns — rerunOn takes GET, GET_MANY and GET_RANGE`,
+      );
+    }
+    const verbs = rerunOn[read];
+    if (
+      verbs === undefined ||
+      verbs === null ||
+      verbs === false ||
+      verbs === "*"
+    ) {
+      continue;
+    }
+    if (!Array.isArray(verbs)) {
+      throw new Error(
+        `rerunOn.${read}: ${JSON.stringify(verbs)} never fires — it takes false, "*" or a list of verbs`,
+      );
+    }
+    for (const verb of verbs) {
+      if (
+        typeof verb !== "string" ||
+        !RERUN_VERBS.includes(verb.toUpperCase())
+      ) {
+        throw new Error(
+          `rerunOn.${read}: ${JSON.stringify(verb)} never fires — rerunOn names verbs (POST, PUT, PATCH, DELETE or "*"): POST covers POST_MANY`,
+        );
+      }
+    }
+  }
+};
 
 // What a `dependencies` entry names are callbacks, not verbs (`rerunOn` names
 // verbs, where `PATCH` covers `PATCH_MANY`): one callback of a resource can be
@@ -27101,6 +27315,24 @@ const debug$2 = (...args) => {
   }
 };
 
+const RESOURCE_OPTIONS = new Set([
+  "idKey",
+  "uniqueKeys",
+  "rerunOn",
+  "dependencies",
+  "persist",
+  "GET",
+  "GET_MANY",
+  "GET_RANGE",
+  "POST",
+  "POST_MANY",
+  "PUT",
+  "PUT_MANY",
+  "PATCH",
+  "PATCH_MANY",
+  "DELETE",
+  "DELETE_MANY",
+]);
 /**
  * Creates a reactive REST resource backed by a shared signal store.
  * Returns a `stateFacade` exposing one action per REST callback provided
@@ -27159,9 +27391,8 @@ const debug$2 = (...args) => {
  *   DELETE: ({ id }) => fetchJson(`/users/${id}`, { method: "DELETE" }),
  * });
  */
-const resource = (
-  name,
-  {
+const resource = (name, restCallbacks = {}) => {
+  const {
     // configuration options
     idKey = "id",
     uniqueKeys = [],
@@ -27180,8 +27411,10 @@ const resource = (
     PATCH_MANY,
     DELETE,
     DELETE_MANY,
-  } = {},
-) => {
+  } = restCallbacks;
+  {
+    warnUnknownOptions(`resource(${name})`, restCallbacks, RESOURCE_OPTIONS);
+  }
   const declarationSite = getDeclarationSite();
   const setupCallbackSet = new Set();
   const addItemSetup = (callback) => {
@@ -29073,8 +29306,8 @@ const valueInLocalStorage = (key, { type = "any" } = {}) => {
   const converter = TYPE_CONVERTERS[type];
 
   const get = () => {
-    let valueInLocalStorage = window.localStorage.getItem(key);
-    if (valueInLocalStorage === null) {
+    const valueInLocalStorage = readLocalStorage(key);
+    if (valueInLocalStorage === undefined) {
       return undefined;
     }
     let valueToReturn = valueInLocalStorage;
@@ -29098,7 +29331,7 @@ const valueInLocalStorage = (key, { type = "any" } = {}) => {
 
   const set = (value) => {
     if (value === undefined) {
-      window.localStorage.removeItem(key);
+      writeLocalStorage(key, undefined);
       return;
     }
     let valueToStore = value;
@@ -29106,10 +29339,10 @@ const valueInLocalStorage = (key, { type = "any" } = {}) => {
       const valueEncoded = converter.encode(valueToStore);
       valueToStore = valueEncoded;
     }
-    window.localStorage.setItem(key, valueToStore);
+    writeLocalStorage(key, valueToStore);
   };
   const remove = () => {
-    window.localStorage.removeItem(key);
+    writeLocalStorage(key, undefined);
   };
 
   return [get, set, remove];
@@ -29329,7 +29562,8 @@ const useForceRender = () => {
  *
  * @example <caption>Handle error inline</caption>
  * const [user, , error] = useAsyncData(userAction, { error: true });
- * if (error) return <ErrorCard message={error.message} />;
+ * // A failed refresh keeps `user`: only a first load has nothing else to show.
+ * if (error && user === undefined) return <ErrorCard message={error.message} />;
  *
  * @example <caption>Say the failure over the rows already on screen</caption>
  * const [items, , error, dismissError] = useAsyncData(listAction, { error: true });
@@ -41288,9 +41522,12 @@ const confirmCommand = (source, event) => {
         event,
         source: commandSource,
       });
+      // Carried by the close too: a Dialog or a Popover answers the yes in
+      // its onClose (detail.isConfirm), the twin of isCancel.
       return dispatchCustomEvent(target, "navi_request_close", {
         event,
         source: commandSource,
+        isConfirm: true,
       });
     },
   };
@@ -43058,6 +43295,14 @@ const useParallelGuard = (max) => {
  * `getAssociatedLabels` in control_hooks.jsx. Both channels carry the same
  * values and land on the same setters, so a control reachable through both is
  * simply told twice.
+ *
+ * The link also runs the other way, for a control whose role is on its root
+ * (`nameOn: "root"`, a wheel): a label[for] can only point at its host, an
+ * aria-hidden carrier, and names nothing. That control says so in the state it
+ * publishes; its label then drops `for` and publishes its own id under the
+ * control's id instead, and the control names its root with the ids it finds
+ * there (aria-labelledby). A label[for] kept as well would name the carrier
+ * too, and a lookup by label would find two elements.
  */
 
 const stateByControlId = new Map();
@@ -43110,6 +43355,68 @@ const subscribeToControlState = (controlId, callback) => {
   };
 };
 
+const labelIdSetByControlId = new Map();
+const labelCallbackSetByControlId = new Map();
+
+const notifyLabelIds = (controlId) => {
+  const callbackSet = labelCallbackSetByControlId.get(controlId);
+  if (!callbackSet) {
+    return;
+  }
+  const labelIds = readLabelIds(controlId);
+  for (const callback of callbackSet) {
+    callback(labelIds);
+  }
+};
+// One string ("label_a label_b"), the shape aria-labelledby takes, and equal
+// from one call to the next while nothing changed.
+const readLabelIds = (controlId) => {
+  const labelIdSet = labelIdSetByControlId.get(controlId);
+  return labelIdSet ? Array.from(labelIdSet).join(" ") : undefined;
+};
+
+/**
+ * Publishes `labelId` as a label of the control identified by `controlId`.
+ * Returns the teardown.
+ */
+const publishLabelToControl = (controlId, labelId) => {
+  let labelIdSet = labelIdSetByControlId.get(controlId);
+  if (!labelIdSet) {
+    labelIdSet = new Set();
+    labelIdSetByControlId.set(controlId, labelIdSet);
+  }
+  labelIdSet.add(labelId);
+  notifyLabelIds(controlId);
+  return () => {
+    labelIdSet.delete(labelId);
+    if (labelIdSet.size === 0) {
+      labelIdSetByControlId.delete(controlId);
+    }
+    notifyLabelIds(controlId);
+  };
+};
+
+/**
+ * Subscribes to the ids of the labels published for `controlId`. The callback
+ * is called right away (with `undefined` when there is none), then on every
+ * change. Returns the teardown.
+ */
+const subscribeToControlLabels = (controlId, callback) => {
+  let callbackSet = labelCallbackSetByControlId.get(controlId);
+  if (!callbackSet) {
+    callbackSet = new Set();
+    labelCallbackSetByControlId.set(controlId, callbackSet);
+  }
+  callbackSet.add(callback);
+  callback(readLabelIds(controlId));
+  return () => {
+    callbackSet.delete(callback);
+    if (callbackSet.size === 0) {
+      labelCallbackSetByControlId.delete(controlId);
+    }
+  };
+};
+
 const FormContext = createContext();
 
 /**
@@ -47522,17 +47829,11 @@ const useControlProps = (props, {
           };
         }
         if (defaultAction === "activate") {
-          // activating the control (e.g. space on a button/range)
           return {
             name: `keydown to activate`,
             prevented: () => e.preventDefault(),
             allowed: () => {
               triggerUIAction(e);
-              if (controlType === "button" && e.key === " ") {
-                // prevent browser dispatching click
-                // it could lead to duplicates as we explicitely handled the space to click here
-                e.preventDefault();
-              }
             }
           };
         }
@@ -47669,7 +47970,15 @@ const useControlProps = (props, {
           runWhenActionSucceeded(completion, deferredCommand);
         };
         return {
-          keyDown: keyDownDefault,
+          keyDown: e => {
+            if (getKeyboardEventDefaultAction(e) === "activate") {
+              // The browser presses the button itself — Enter clicks on
+              // keydown, Space on keyup — and the click reaction below answers
+              // that press, once: ui action, action and command together.
+              return null;
+            }
+            return keyDownDefault(e);
+          },
           mouseDown: e => {
             if (actsOnMouseDown) {
               return {
@@ -47688,7 +47997,9 @@ const useControlProps = (props, {
             return null;
           },
           click: e => {
-            if (actsOnMouseDown) {
+            // A click no mousedown came before (the keyboard, a label) is a
+            // press the mousedown reaction never saw.
+            if (actsOnMouseDown && e.detail !== 0) {
               return null;
             }
             return {
@@ -48617,26 +48928,33 @@ const useControlUIState = (ref, uiStateInitial) => {
     if (!element) {
       return undefined;
     }
-    // The host, not the box around it: a control is a whole little tree (a
-    // picker is a box holding an input) and the state is announced on the one
-    // element that holds it. Same resolution every request goes through, see
-    // ui_state_dom.js.
-    const host = findControlHost(element) || element;
-    // Asked once here rather than trusted from the props above: between the
-    // first render and this effect the control has read its own value prop, its
-    // defaultValue and any signal it was bound to, and settled which of them
-    // wins — the answer to that is on the element, not in what we were handed.
-    setUIState(getUIStateFromElement(host));
-    const onUIStateChange = e => {
-      setUIState(e.detail.value);
-    };
-    host.addEventListener("navi_ui_state_change", onUIStateChange);
-    return () => {
-      host.removeEventListener("navi_ui_state_change", onUIStateChange);
-    };
+    return subscribeToControlUIState(element, setUIState);
   }, [ref]);
   return uiState;
 };
+/**
+ * Calls `callback` with what the control `element` holds, right away and on
+ * every change. Returns the teardown.
+ */
+const subscribeToControlUIState = (element, callback) => {
+  // The host, not the box around it: a control is a whole little tree (a
+  // picker is a box holding an input) and the state is announced on the one
+  // element that holds it. Same resolution every request goes through, see
+  // ui_state_dom.js.
+  const host = findControlHost(element) || element;
+  // Asked once here rather than trusted from props: by the time this runs the
+  // control has read its own value prop, its defaultValue and any signal it
+  // was bound to, and settled which of them wins — the answer to that is on
+  // the element.
+  callback(getUIStateFromElement(host));
+  const onUIStateChange = e => {
+    callback(e.detail.value);
+  };
+  host.addEventListener("navi_ui_state_change", onUIStateChange);
+  return () => {
+    host.removeEventListener("navi_ui_state_change", onUIStateChange);
+  };
+};
 
 /**
  * Like `useControlProps` but also establishes a 1:1 facade sync between the
@@ -48932,7 +49250,8 @@ const useInteractiveProps = (props, {
       const controlState = {
         disabled: disabledResolved,
         readOnly,
-        required: requiredResolved
+        required: requiredResolved,
+        nameOn
       };
       for (const label of getAssociatedLabels(element)) {
         label.dispatchEvent(new CustomEvent("navi_control_state", {
@@ -48953,6 +49272,22 @@ const useInteractiveProps = (props, {
         unpublishControlStateToLabels(publishedIdRef.current);
       };
     }, []);
+    // Named on its root, the control is named by its labels' ids: they drop
+    // their `for` for it (see control_label_state.js). A name the caller gives
+    // wins.
+    const [labelledBy, setLabelledBy] = useState();
+    const {
+      id
+    } = props;
+    useLayoutEffect(() => {
+      if (nameOn !== "root" || !id) {
+        return undefined;
+      }
+      return subscribeToControlLabels(id, setLabelledBy);
+    }, [id]);
+    if (labelledBy && controlRootProps["aria-label"] === undefined && controlRootProps["aria-labelledby"] === undefined) {
+      controlRootProps["aria-labelledby"] = labelledBy;
+    }
   }
   {
     const isCheckable = isCheckableInput(uiStateController.controlType, props.type);
@@ -53265,8 +53600,8 @@ const LinkPseudoElements = ["::-navi-loader", "::-navi-indicator"];
  *   those instead.
  * @param {string} [props.value] - Value emitted by the control facade
  *   (`navi_value`); defaults to `href`.
- * @param {boolean} [props.current] - Forces the "current" state on (otherwise
- *   derived from the href/route).
+ * @param {boolean} [props.current] - Forces the "current" state: `true` on,
+ *   `false` off. Left out, it is derived from the href/route.
  * @param {object|object[]} [props.currentExcept] -
  *   Route(s) inside this link's own that are NOT it: while one of them matches,
  *   the link is not current even though its route still is. A bar entry
@@ -53424,7 +53759,10 @@ const LinkWithRoute = ({
     except: currentExcept,
     also: currentAlso
   });
-  const innerCurrent = current || linkMatching;
+  // Always a boolean from here: LinkPlain takes a given `current` as the
+  // answer, so an href matching the address cannot relight what
+  // currentExcept turned off.
+  const innerCurrent = current ?? linkMatching;
 
   // What a childless link shows is LinkPlain's call (hrefFallback); a route
   // only says it the way its pattern writes it, not as the resolved href.
@@ -53508,7 +53846,7 @@ const LinkPlain = props => {
   } = getHrefTargetInfo(href, documentUrlSignal.peek());
   // A tab that is a SLIDE is current when the container is on it — which the
   // <Nav> around reads off that container, so nothing here has to be told.
-  const innerCurrent = current || (slide ? nav?.currentSlideArea === slide : isCurrent);
+  const innerCurrent = current ?? (slide ? nav?.currentSlideArea === slide : isCurrent);
   useReportCurrentToBinderItem(innerCurrent);
   controlHostProps.basePseudoState = {
     ...basePseudoState,
@@ -58239,6 +58577,8 @@ const ButtonUI = props => {
   // Where the href leads next to the page one is on (the target, the rel, the
   // current state) is resolved above, by ButtonHrefResolver.
   const as = href === undefined ? "button" : "a";
+  // What `data-href-current` paints, said to assistive tech as a link says it.
+  const ariaCurrent = as === "a" && props.pseudoState?.[":-navi-href-current"] ? "page" : undefined;
 
   // Worn as an attribute, like a link's (see link_replace.js): read off the
   // anchor by the click handler, off the source by --navi-nav-to.
@@ -58275,6 +58615,7 @@ const ButtonUI = props => {
     // caller's props, so their own flex direction wins.
     ,
     flex: icon ? "x" : undefined,
+    "aria-current": ariaCurrent,
     ...buttonControlRootProps,
     ...buttonControlHostProps,
     // eslint-disable-next-line react/no-children-prop
@@ -58627,7 +58968,10 @@ const ButtonHrefResolver = props => {
 // Whether the href is the page one is on depends on the address, and re-renders
 // the button only when it flips (see useHrefTargetFlag). Whether it leaves the
 // site does not depend on the address.
-const ButtonWithHref = props => {
+const ButtonWithHref = ({
+  current,
+  ...props
+}) => {
   const Next = useNextResolver();
   const {
     href,
@@ -58648,7 +58992,7 @@ const ButtonWithHref = props => {
     // the state.
     ,
     pseudoState: {
-      ":-navi-href-current": isCurrent,
+      ":-navi-href-current": current ?? isCurrent,
       ...pseudoState
     }
   });
@@ -58659,6 +59003,9 @@ const ButtonRouteResolver = props => {
   if (props.route) {
     return renderResolver(ButtonWithRoute, props);
   }
+  if ((props.currentExcept || props.currentAlso)) {
+    console.warn(`currentExcept/currentAlso amend what the button's own route says about being current, so they need a "route" prop.`);
+  }
   return jsx(Next, {
     ...props
   });
@@ -58670,6 +59017,9 @@ const ButtonWithRoute = props => {
   const {
     route,
     routeParams,
+    current,
+    currentExcept,
+    currentAlso,
     children,
     pseudoState,
     href,
@@ -58680,9 +59030,18 @@ const ButtonWithRoute = props => {
     if (href !== undefined) {
       console.warn(`A button with a "route" ignores its "href" (${href}): the route builds the address.`);
     }
+    for (const amendingRoute of [currentExcept, currentAlso].flat()) {
+      if (amendingRoute) {
+        assertRoute(amendingRoute);
+      }
+    }
   }
   const url = route.buildUrl(routeParams);
-  const linkMatching = useRouteCurrent(route, routeParams);
+  // What a route Link reads, with the same amendments (see link.jsx).
+  const linkMatching = useRouteCurrent(route, routeParams, {
+    except: currentExcept,
+    also: currentAlso
+  });
 
   // Merged into whatever the caller already holds: a button can be forced into
   // a state for a demo and still learn its own current-ness from its route.
@@ -58690,7 +59049,7 @@ const ButtonWithRoute = props => {
     href: url,
     pseudoState: {
       ...pseudoState,
-      ":-navi-href-current": linkMatching
+      ":-navi-href-current": current ?? linkMatching
     },
     ...rest,
     children: children || route.buildRelativeUrl(routeParams)
@@ -58809,8 +59168,23 @@ const COMMAND_DEFAULT_PROPS_FACTORIES = {
  *   actionStandalone?: boolean,
  *   actionAbortable?: boolean,
  *   optimistic?: boolean,
+ *   route?: object,
+ *   routeParams?: object,
+ *   current?: boolean,
+ *   currentExcept?: object | object[],
+ *   currentAlso?: object | object[],
  *   [key: string]: any,
  * }>}
+ * @param {object} [route] Where the press leads, as a `<Link route>` says it:
+ *   the button is drawn as an `<a>` to the route's url (with `routeParams`),
+ *   and says whether it is the page one is on — `[data-href-current]` for the
+ *   eye, `aria-current="page"` for assistive tech. A bar entry drawn as a
+ *   button for its press feedback.
+ * @param {boolean} [current] Forces that "current" state: `true` on, `false`
+ *   off. Left out, it is read from the route (or the `href`).
+ * @param {object|object[]} [currentExcept] Route(s) inside the button's own
+ *   that are NOT it, and `currentAlso` route(s) beside it that are: what they
+ *   mean on a `<Link>`.
  * @param {boolean} [replace] Go where the press leads — an `href`, a
  *   `--navi-nav-to` command — by TAKING THE PLACE of the current history entry
  *   rather than stacking on it: what `<Link replace>` says, for a press drawn
@@ -60123,6 +60497,7 @@ const Label = props => {
   const [readOnly, setReadOnly] = useState(false);
   const [required, setRequired] = useState(false);
   const [connected, setConnected] = useState(false);
+  const [namesControlRoot, setNamesControlRoot] = useState(false);
   // Set htmlFor only when we know the correct target id:
   //   - caller explicitly provided one (even undefined to opt out)
   //   - a parent Field provided one via ControlIdContext
@@ -60149,8 +60524,37 @@ const Label = props => {
       setDisabled(Boolean(controlState?.disabled));
       setReadOnly(Boolean(controlState?.readOnly));
       setRequired(Boolean(controlState?.required));
+      setNamesControlRoot(controlState?.nameOn === "root");
     });
   }, [htmlFor]);
+  // A control whose role is on its root (a wheel) is named by this label's id
+  // rather than by `for`, which can only point at its aria-hidden host (see
+  // control_label_state.js).
+  const labelId = props.id;
+  useLayoutEffect(() => {
+    if (!htmlFor || !namesControlRoot) {
+      return undefined;
+    }
+    return publishLabelToControl(htmlFor, labelId);
+  }, [htmlFor, namesControlRoot, labelId]);
+  // …and without `for`, the press that focuses the control is this label's
+  // to answer. A press on something interactive inside the label stays that
+  // thing's, as the browser does for a label[for].
+  const onClickFocusingControlRoot = e => {
+    props.onClick?.(e);
+    if (e.defaultPrevented) {
+      return;
+    }
+    const interactive = e.target.closest("a[href], button, input, select, textarea, [tabindex]");
+    if (interactive && e.currentTarget.contains(interactive)) {
+      return;
+    }
+    const host = document.getElementById(htmlFor);
+    const controlRoot = host && findControlRoot(host);
+    if (controlRoot) {
+      moveFocusTo(controlRoot);
+    }
+  };
   const [messageProps, remainingProps] = extractMessageAndRemainingProps({
     ...props,
     requiredIndicator: undefined
@@ -60167,6 +60571,8 @@ const Label = props => {
       ":read-only": readOnly
     },
     ...remainingProps,
+    htmlFor: namesControlRoot ? undefined : htmlFor,
+    onClick: namesControlRoot ? onClickFocusingControlRoot : props.onClick,
     onnavi_control_state: e => {
       setConnected(true);
       setDisabled(e.detail.disabled);
@@ -62763,36 +63169,61 @@ const Textarea = ({
  * typed over how many the limit allows, the way Material writes it (just the
  * count when there is no `maxLength`). Where it goes is the caller's call,
  * which is why it is a separate component rather than something the textarea
- * draws: put it under the box, in a form footer, next to a label, and feed it
- * the same value or signal as the textarea.
+ * draws: put it under the box, in a form footer, next to a label, and point
+ * it at the textarea with `for`.
  *
  * @type {import("preact").FunctionComponent<{
+ *   for?: string,
  *   value?: string,
  *   signal?: import("@preact/signals").Signal<string>,
  *   maxLength?: number,
  *   [key: string]: any,
  * }>}
- * @param {string} [value] The text being counted. Say `signal` instead for a
- *   two-way bound textarea: reading it here subscribes the count to it.
+ * @param {string} [for] The `id` of the Textarea counted: the count reads
+ *   what it holds, so the field stays a plain one (`defaultValue={record.bio}`)
+ *   with no signal bound only for the counter's sake. The limit defaults to
+ *   that Textarea's `maxLength` (or `maxLengthGuard`).
+ * @param {string} [value] The text being counted, when it is not read from a
+ *   Textarea. Say `signal` instead to subscribe the count to it.
  * @param {number} [maxLength] The limit, shown after the count ("50/200").
  *   Without it the count stands alone.
  */
 const TextareaCharCount = ({
+  for: controlId,
   value,
   signal,
   maxLength,
   ...rest
 }) => {
   import.meta.css = [css$J, "@jsenv/navi/src/control/input/textarea.jsx"];
-  const resolvedValue = signal ? signal.value : value;
+  const [controlText, controlMaxLength] = useTextOfControl(controlId);
+  const resolvedValue = controlId ? controlText : signal ? signal.value : value;
   const length = typeof resolvedValue === "string" ? resolvedValue.length : 0;
+  const limit = maxLength ?? controlMaxLength;
   return jsx(Box, {
     as: "span",
     baseClassName: "navi_textarea_char_count",
     ...rest,
-    children: maxLength === undefined ? length : `${length}/${maxLength}`
+    children: limit === undefined ? length : `${length}/${limit}`
   });
 };
+const useTextOfControl = controlId => {
+  const [text, setText] = useState();
+  const [maxLength, setMaxLength] = useState();
+  useLayoutEffect(() => {
+    if (!controlId) {
+      return undefined;
+    }
+    const element = document.getElementById(controlId);
+    if (!element) {
+      return undefined;
+    }
+    const controlProps = getUIStateControllerById(controlId)?.props;
+    setMaxLength(controlProps?.maxLength ?? controlProps?.maxLengthGuard);
+    return subscribeToControlUIState(element, setText);
+  }, [controlId]);
+  return [text, maxLength];
+};
 
 // `field-sizing: content` sizes the box from the value, and an empty field has
 // none — the placeholder is text the browser refuses to make room for. So the
@@ -67150,6 +67581,11 @@ const Time = props => {
   const {
     type
   } = props;
+  if (props.value !== undefined && props.children === undefined) {
+    // Otherwise drawn as the placeholder, a plausible screen with nothing wrong
+    // on it.
+    console.warn(`<Time> reads what it writes from its children, not from "value": <Time type="${type}">{value}</Time>.`);
+  }
   if (type === "date") {
     return jsx(TimeDate, {
       ...props
@@ -67508,10 +67944,12 @@ const TimeHour = ({
       children: String(children)
     });
   }
+  const dateTime = formatClock(hours * 3600);
   if (format === "timestring") {
     const totalMinutes = Math.round(hours * 60);
     const date = new Date(1970, 0, 1, Math.floor(totalMinutes / 60), totalMinutes % 60, 0);
     return jsx(TimeText, {
+      dateTime: dateTime,
       ...props,
       children: formatTime(date, {
         lang
@@ -67524,6 +67962,7 @@ const TimeHour = ({
     forceUnit
   });
   return jsx(TimeText, {
+    dateTime: dateTime,
     ...props,
     children: text
   });
@@ -71626,6 +72065,8 @@ const css$C = /* css */`
  *   actually closes — not preventable: it is the close happening, not a
  *   request. What refuses a close is navi's: a control inside still
  *   running its action (see popup_busy.js for the runs that let it through).
+ *   `event.detail.isCancel` says the close meant "revert", and
+ *   `event.detail.isConfirm` that a `--navi-confirm` said yes.
  * @param {boolean|string|{id?: string, type?: "push"|"replace"}} [props.navState] -
  *   Keeps the open state in the history entry, so a screen left and come back
  *   to finds this popup as it was — open, and without an entrance playing: it
@@ -71864,6 +72305,7 @@ const UncontrolledDialog = props => {
     onnavi_request_close: e => {
       const closing = openController.requestClose(e, {
         isCancel: e.detail?.isCancel,
+        isConfirm: e.detail?.isConfirm,
         requester: e.detail?.source
       });
       if (!closing) {
@@ -73712,6 +74154,8 @@ const css$B = /* css */`
  *   actually closes — not preventable: it is the close happening, not a
  *   request. What refuses a close is navi's: a control inside still
  *   running its action (see popup_busy.js for the runs that let it through).
+ *   `event.detail.isCancel` says the close meant "revert", and
+ *   `event.detail.isConfirm` that a `--navi-confirm` said yes.
  * @param {boolean|string|{id?: string, type?: "push"|"replace"}} [props.navState] -
  *   Keeps the open state in the history entry, so a screen left and come back
  *   to finds this popup as it was — open, and without an entrance playing: it
@@ -73833,7 +74277,8 @@ const UncontrolledPopover = props => {
     },
     onnavi_request_close: e => {
       const closing = openController.requestClose(e, {
-        isCancel: e.detail?.isCancel
+        isCancel: e.detail?.isCancel,
+        isConfirm: e.detail?.isConfirm
       });
       if (!closing) {
         // Said back to whoever asked: --navi-close:all stops climbing here.
@@ -75928,6 +76373,7 @@ const PickerCustom = props => {
           allowed: () => {
             const closing = requestClose(e, {
               isCancel: e.detail.isCancel,
+              isConfirm: e.detail.isConfirm,
               isSend: e.detail.isSend
             });
             if (!closing) {
@@ -78982,6 +79428,11 @@ const css$v = /* css */`@property --list-group-label-height {
     --list-item-background-color-highlight: #ffe066;
     display: inline-block;
   }
+
+  .navi_list_item_group[data-label-in-flow] > .navi_list_item_group_label {
+    background-color: #0000;
+    display: block;
+  }
 }
 
 .navi_list_item_group_label {
@@ -79329,16 +79780,7 @@ const css$v = /* css */`@property --list-group-label-height {
   min-width: 100%;
 
   & .navi_list_item_group_label {
-    top: var(--list-group-label-top, var(--x-list-group-label-top, 0px));
-    z-index: var(--list-group-label-z-index);
-    background-color: var(--list-group-label-background-color);
     user-select: none;
-    display: block;
-    position: sticky;
-
-    &[navi-stuck] {
-      z-index: var(--list-group-label-z-index-stuck);
-    }
 
     &[navi-default] {
       color: light-dark(#888, #aaa);
@@ -79354,6 +79796,18 @@ const css$v = /* css */`@property --list-group-label-height {
     }
   }
 
+  &:not([data-label-in-flow]) > .navi_list_item_group_label {
+    top: var(--list-group-label-top, var(--x-list-group-label-top, 0px));
+    z-index: var(--list-group-label-z-index);
+    background-color: var(--list-group-label-background-color);
+    display: block;
+    position: sticky;
+
+    &[navi-stuck] {
+      z-index: var(--list-group-label-z-index-stuck);
+    }
+  }
+
   & .navi_list_item_group_list {
     --list-group-label-height: inherit;
     flex-direction: column;
@@ -79372,6 +79826,20 @@ const css$v = /* css */`@property --list-group-label-height {
     }
   }
 
+  &[data-label-in-flow] {
+    & .navi_list_item_group_list .navi_list_item {
+      scroll-margin-top: var(--x-list-scroll-spacing-top);
+    }
+
+    & .navi_list_item_group_list > .navi_list_item:first-child {
+      scroll-margin-top: calc(var(--x-list-scroll-spacing-top) + var(--list-group-label-height));
+    }
+
+    &[data-continued] > .navi_list_item_group_label {
+      visibility: hidden;
+    }
+  }
+
   &[data-hidden-while-empty]:not(:has([navi-list-item-real])) {
     display: none;
   }
@@ -80183,6 +80651,15 @@ const useListScrollSync = ({
   // partly in view. After it, the quarter a window keeps behind the screen
   // (see evaluateWindow), until the screen sizes it around that item.
   const itemsAboveOpening = (openAt, windowSize) => {
+    // An item placed in the middle of the view, or at its end, has the items
+    // before it on screen from the first paint.
+    const align = openAt && typeof openAt === "object" ? openAt.align : undefined;
+    if (align === "center") {
+      return Math.floor(windowSize / 2);
+    }
+    if (align === "end") {
+      return windowSize - 1;
+    }
     if (stageRef.current !== "steady") {
       return openAt && typeof openAt === "object" && openAt.offset > 0 ? 1 : 0;
     }
@@ -80736,22 +81213,30 @@ const useListScrollSync = ({
       return;
     }
     if (typeof openAt === "object" && openAt.id !== undefined) {
-      placeItem(findItemElement(getListEl(), openAt.id), openAt.offset || 0);
+      placeItem(findItemElement(getListEl(), openAt.id), openAt.offset || 0, openAt.align);
     }
   };
   // An item is placed by measuring it where it is drawn — named, or at the
   // place a number says — so it lands where it should whatever the items
   // above it weigh, and wherever the list starts in the box that scrolls it.
   // The window frames it from the first commit on (see holdWindow).
-  const placeItem = (itemEl, offset) => {
+  const placeItem = (itemEl, offset, align = "start") => {
     if (!itemEl) {
       return;
     }
     const scrollerEl = getScroller();
+    // Measured in the scroller's own pixels, the ones a scroll is written in.
+    const scale = readScrollerScale(scrollerEl, horizontal);
     const viewportRect = getScrollerViewportRect(scrollerEl);
     const itemRect = itemEl.getBoundingClientRect();
-    const offsetWanted = resolveOpenOffset(getItemScrollInset(scrollerEl, itemEl, horizontal) + offset, horizontal ? viewportRect.width : viewportRect.height, horizontal ? itemRect.width : itemRect.height);
-    const offsetNow = horizontal ? itemRect.left - viewportRect.left : itemRect.top - viewportRect.top;
+    const viewportSize = (horizontal ? viewportRect.width : viewportRect.height) / scale;
+    const itemSize = (horizontal ? itemRect.width : itemRect.height) / scale;
+    const scrollInset = getItemScrollInset(scrollerEl, itemEl, horizontal);
+    // Centred in what the room at the start leaves of the view (a fixed bar,
+    // a sticky header), not in the whole of it.
+    const alignedOffset = align === "center" ? scrollInset + (viewportSize - scrollInset - itemSize) / 2 : align === "end" ? viewportSize - itemSize : scrollInset;
+    const offsetWanted = resolveOpenOffset(alignedOffset + offset, viewportSize, itemSize);
+    const offsetNow = (horizontal ? itemRect.left - viewportRect.left : itemRect.top - viewportRect.top) / scale;
     const scrollNow = horizontal ? scrollerEl.scrollLeft : scrollerEl.scrollTop;
     const delta = offsetNow - offsetWanted;
     if (delta > -0.5 && delta < 0.5) {
@@ -81614,6 +82099,25 @@ const useListScrollSync = ({
 // The band of the scroller the user actually sees. A page-level scroller is
 // the viewport itself — its own box is the whole document, which says nothing
 // about what is on screen.
+// A scroller drawn under a transform (a popup scaling in from its trigger)
+// shows a rect of another size than the box it scrolls: the ratio of the two
+// turns what the screen measures into the scroller's own pixels. A rounding
+// of the box's size is not a scale.
+const readScrollerScale = (scrollerEl, horizontal) => {
+  if (scrollerEl === document.scrollingElement) {
+    return 1;
+  }
+  const size = horizontal ? scrollerEl.offsetWidth : scrollerEl.offsetHeight;
+  if (!size) {
+    return 1;
+  }
+  const rect = scrollerEl.getBoundingClientRect();
+  const scale = (horizontal ? rect.width : rect.height) / size;
+  if (!scale || scale > 0.99 && scale < 1.01) {
+    return 1;
+  }
+  return scale;
+};
 const getScrollerViewportRect = scrollerEl => {
   if (scrollerEl === document.scrollingElement) {
     const width = document.documentElement.clientWidth;
@@ -81727,7 +82231,7 @@ const canScrollerScroll = (scrollerEl, axis) => {
 // horizontally on mobile, where `overflow-x: clip` keeps that guarantee without
 // making a scroll container, or to let a wide table scroll sideways, where the
 // header cannot stick to both boxes.
-const STICKY_LIST_PART_SELECTOR = `.navi_list_item_header, .navi_list_item_footer, .navi_list_item_group_label`;
+const STICKY_LIST_PART_SELECTOR = `.navi_list_item_header, .navi_list_item_footer, .navi_list_item_group:not([data-label-in-flow]) > .navi_list_item_group_label`;
 const useStickyScrollportWarning = (ref, scroller, getScroller, horizontal) => {
   const doneRef = useRef(false);
   useLayoutEffect(() => {
@@ -83838,6 +84342,7 @@ const VISIBILITY_HIDDEN_STYLE = {
  *   groupBy?: (item: any, index: number) => any,
  *   renderGroupLabel?: (item: any, index: number) => import("preact").ComponentChildren,
  *   groupLabelProps?: (item: any, index: number) => object,
+ *   groupLabelSticky?: boolean,
  *   pageSize?: number,
  *   memoryBudget?: number,
  *   renderSkeleton?: false | ((index: number) => import("preact").ComponentChildren),
@@ -83902,6 +84407,12 @@ const VISIBILITY_HIDDEN_STYLE = {
  *   its group (a day behind us, today, one ahead) rather than just naming it:
  *   the state then sits on the element the CSS styles, instead of being read
  *   back from a child.
+ * @param {boolean} [props.groupLabelSticky=true]
+ *   `false`: the label stays in the flow, a boundary scrolled past with its
+ *   group instead of riding the top of the screen — a thread of days whose
+ *   cards must not slide under a band, a "past" line in a list the page
+ *   scrolls. It paints nothing of its own then: its display and background
+ *   are defaults a `groupLabelProps` class takes back.
  * @param {number} [props.pageSize=100]
  *   How many items to ask for at a time. A turn of the wheel opens a hole three
  *   items wide; asking for exactly that would ask again at the next turn.
@@ -84086,6 +84597,7 @@ const useRunItems = (store, {
   groupBy,
   renderGroupLabel,
   groupLabelProps,
+  groupLabelSticky = true,
   renderSkeleton,
   renderError
 }) => {
@@ -84345,6 +84857,7 @@ const useRunItems = (store, {
     nodes.push(jsx(ListItemGroup, {
       label: group.label,
       labelProps: group.labelProps,
+      labelSticky: groupLabelSticky,
       continued: group.continued,
       children: group.children
     }, groupCount === 1 ? `${ownerId}_group_${group.key}` : `${ownerId}_group_${group.key}_${groupCount}`));
@@ -85349,6 +85862,7 @@ const useItemStore = ({
 const ListItemGroup = ({
   label,
   labelProps,
+  labelSticky = true,
   hiddenWhileEmpty,
   continued,
   children,
@@ -85394,6 +85908,7 @@ const ListItemGroup = ({
     role: "presentation",
     "data-hidden-while-empty": hiddenWhileEmpty ? "" : undefined,
     "data-continued": continued,
+    "data-label-in-flow": labelSticky ? undefined : "",
     children: [jsx("span", {
       ...labelRest,
       ref: labelRef,
@@ -85461,8 +85976,8 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   renderBudget?: number | string | {initial?: number | string, after?: number | string},
  *   virtualItemSize?: number,
  *   onListVisibleItemsChange?: (visibleItems: any[]) => void,
- *   scrolled?: "start" | "end" | number | {id: string, offset?: number},
- *   defaultScrolled?: "start" | "end" | number | {id: string, offset?: number},
+ *   scrolled?: "start" | "end" | number | {id: string, offset?: number, align?: "start" | "center" | "end"},
+ *   defaultScrolled?: "start" | "end" | number | {id: string, offset?: number, align?: "start" | "center" | "end"},
  *   onScrolledChange?: (scrolled: {id: string, index: number, offset: number}) => void,
  *   scroller?: "self" | "parent" | "document" | Element | {current: Element},
  *   hoverWhileScrolling?: boolean,
@@ -85566,7 +86081,7 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   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, index?: number, offset?: number, visibleCount?: number}} [props.defaultScrolled="start"]
+ * @param {"start"|"end"|number|{id: string, index?: number, offset?: number, align?: "start"|"center"|"end", visibleCount?: 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
  *   thread read backwards — the last items are the ones to show, and the ones
@@ -85581,10 +86096,13 @@ const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, Li
  *   room has to be restated as a number by whoever asks. The `index` and
  *   `visibleCount` it also hands out say where to aim before the item is found,
  *   and how many items to draw before the first paint (see `renderBudget`).
+ *   `align: "center"` puts the item in the middle of the view instead (`"end"`:
+ *   at its far edge) — the chosen level of a horizontal scale opening on it —
+ *   and keeps it there while the box around it grows, until the user scrolls.
  *   A value that changes before anyone has moved the list is followed (a place
  *   read from a count that answered again): it is compared by value, so it can
  *   be computed at every render.
- * @param {"start"|"end"|number|{id: string, index?: number, offset?: number, visibleCount?: number}} [props.scrolled]
+ * @param {"start"|"end"|number|{id: string, index?: number, offset?: number, align?: "start"|"center"|"end", visibleCount?: number}} [props.scrolled]
  *   The same, but held: the list goes back there every time this changes, even
  *   after the user has scrolled — the caller owns where the list is (see
  *   `defaultScrolled` for the uncontrolled form, and `open`/`defaultOpen`
@@ -87086,6 +87604,7 @@ const css$r = /* css */`@layer navi {
     --picker-font-size: var(--navi-control-font-size);
     --picker-font-family: var(--navi-control-font-family, inherit);
     --picker-loader-color: var(--navi-loader-color);
+    --picker-cta-background-color: var(--navi-accent-color);
     --picker-border-color: var(--navi-control-border-color);
     --picker-background-color: white;
     --picker-color: currentColor;
@@ -87184,7 +87703,7 @@ const css$r = /* css */`@layer navi {
     line-height: inherit;
   }
 
-  .navi_picker[data-variant="button"] {
+  .navi_picker:is([data-variant="button"], [data-variant="border"], [data-variant="discrete-border"]) {
     --picker-padding-x-default: var(--navi-button-padding-x-default);
     --picker-padding-y-default: var(--navi-button-padding-y-default);
     --picker-align-x-default: center;
@@ -87202,6 +87721,49 @@ const css$r = /* css */`@layer navi {
     --picker-text-align-default: center;
   }
 
+  .navi_picker[data-variant="border"] {
+    --picker-background-color: transparent;
+    --picker-background-color-hover: color-mix(in srgb,
+        currentColor 8%,
+        var(--picker-background-color));
+    --picker-background-color-readonly: var(--picker-background-color);
+    --picker-background-color-disabled: var(--picker-background-color);
+  }
+
+  .navi_picker[data-variant="discrete-border"] {
+    --picker-background-color: transparent;
+    --picker-background-color-hover: var(--picker-background-color);
+    --picker-background-color-readonly: var(--picker-background-color);
+    --picker-background-color-disabled: var(--picker-background-color);
+  }
+
+  .navi_picker[data-cta] {
+    --picker-background-color: var(--picker-cta-background-color);
+    --picker-border-color: var(--picker-cta-background-color);
+    --picker-color: white;
+    --picker-background-color-hover: color-mix(in srgb,
+        var(--picker-background-color) 85%,
+        white);
+    --picker-border-color-hover: color-mix(in srgb,
+        var(--picker-border-color) 85%,
+        white);
+    --picker-background-color-readonly: color-mix(in srgb,
+        var(--picker-background-color) 50%,
+        white);
+    --picker-border-color-readonly: color-mix(in srgb,
+        var(--picker-border-color) 50%,
+        white);
+    --picker-background-color-disabled: color-mix(in srgb,
+        var(--picker-background-color) 40%,
+        white);
+    --picker-border-color-disabled: color-mix(in srgb,
+        var(--picker-border-color) 40%,
+        white);
+    --picker-color-disabled: color-mix(in srgb,
+        var(--picker-color) 60%,
+        transparent);
+  }
+
   .navi_picker[data-variant="text"] {
     --picker-padding-x-default: 0;
     --picker-padding-y-default: 0;
@@ -87482,6 +88044,18 @@ const css$r = /* css */`@layer navi {
     --x-picker-cursor: default;
   }
 
+  &[data-variant="discrete-border"] {
+    --x-picker-border-color: transparent;
+
+    &[data-hover] {
+      --x-picker-border-color: var(--picker-border-color-hover);
+    }
+
+    &[data-readonly], &[data-disabled] {
+      --x-picker-border-color: transparent;
+    }
+  }
+
   &[data-callout] {
     --x-picker-border-color: var(--callout-color);
   }
@@ -87555,6 +88129,7 @@ const PickerButton = props => {
   import.meta.css = [css$r, "@jsenv/navi/src/control/picker/picker.jsx"];
   warnOnUnknownPickerType(props);
   warnOnUIDrawnByNobody(props);
+  warnOnMaxLinesNotClamped(props);
   if (typeof props.maxLines === "string") {
     props.maxLines = parseInt(props.maxLines);
   }
@@ -87564,6 +88139,8 @@ const PickerButton = props => {
     // The trigger is one icon — its box is that icon's, the way <Button icon>
     // means it. A shape, so it composes with the variant painting around it.
     icon,
+    // A call to action, filled with the accent: what `cta` is on a Button.
+    cta,
     rightSlotIcon,
     rightSlotIconSize = "inherit",
     // What goes in the right slot as-is — no <Icon> around it, so a caller can
@@ -87642,7 +88219,9 @@ const PickerButton = props => {
   const isBare = variant === "bare";
   const bareChevron = isBare && chevron !== undefined ? chevron : undefined;
   warnOnChevronOffBare(props, isBare);
-  const hasRightSlot = !picksNothing && rightSlot !== null && !isIcon && variant !== "headless" && variant !== "button" && variant !== "text" && (!isBare || bareChevron !== undefined) && ui !== "default";
+  // The Button's own looks: a label, no slot after it.
+  const drawnAsButton = variant === "button" || variant === "border" || variant === "discrete-border";
+  const hasRightSlot = !picksNothing && rightSlot !== null && !isIcon && variant !== "headless" && !drawnAsButton && variant !== "text" && (!isBare || bareChevron !== undefined) && ui !== "default";
   warnOnClearableWithoutSlot(props, hasRightSlot);
   // How far the press must follow a hanging chevron: its size, as a length the
   // input's inset can add up. "inherit" is 1em of the picker's own font, which
@@ -87741,6 +88320,7 @@ const PickerButton = props => {
         baseClassName: "navi_picker",
         pseudoClasses: PICKER_BUTTON_PSEUDO_CLASSES,
         "data-variant": variant,
+        "data-cta": cta ? "" : undefined,
         "data-icon": isIcon ? "" : undefined,
         "data-chevron": hasRightSlot ? bareChevron : undefined,
         "navi-picker": "",
@@ -87751,6 +88331,7 @@ const PickerButton = props => {
         basePseudoState: basePseudoState,
         styleCSSVars: PickerStyleCSSVars,
         variant: undefined,
+        cta: undefined,
         icon: undefined
         // The caller's own role goes onto the host, beside the name (see
         // control_context.js): a role and a name on two different elements
@@ -87909,7 +88490,7 @@ const PickerButton = props => {
               // caller is drawing there ("no filter", "anywhere"), so how it
               // looks empty stays theirs (documented on the ui prop below).
               ,
-              "navi-placeholder": (ui === undefined || pickerUIIsNaviOwn(ui)) && variant !== "button" && variant !== "text" && uiStateHoldsNothing(value) ? "" : undefined,
+              "navi-placeholder": (ui === undefined || pickerUIIsNaviOwn(ui)) && !drawnAsButton && variant !== "text" && uiStateHoldsNothing(value) ? "" : undefined,
               maxLines: maxLines,
               children: jsx(PickerOwnContent, {
                 children: jsx(MaxLinesContext.Provider, {
@@ -88363,6 +88944,24 @@ const warnOnClearableWithoutSlot = (props, hasRightSlot) => {
   }
   console.warn(`[navi] <Picker ${cause} clearable> — that leaves no right slot, so no cross is drawn. ` + `Draw it where it belongs instead: <Picker ${cause} ui={<YourDrawing>… <Picker.Clear /></YourDrawing>}>. ` + `It is the same cross, and it takes itself away when there is nothing left to clear.`);
 };
+
+// A text or bare picker clamps nothing (see where maxLines is resolved), so a
+// `maxLines` written on one is dropped without a word.
+const maxLinesNotClampedWarnedSet = new Set();
+const warnOnMaxLinesNotClamped = props => {
+  const {
+    maxLines,
+    variant
+  } = props;
+  if (maxLines === undefined || variant !== "text" && variant !== "bare") {
+    return;
+  }
+  if (maxLinesNotClampedWarnedSet.has(variant)) {
+    return;
+  }
+  maxLinesNotClampedWarnedSet.add(variant);
+  console.warn(`[navi] <Picker variant="${variant}" maxLines={${maxLines}}> — a ${variant} picker clamps nothing: its drawing is the caller's own. ` + `Put maxLines on the Text in its ui: <Picker variant="${variant}" ui={<Text maxLines={${maxLines}}>…</Text>}>.`);
+};
 let chevronOffBareWarned = false;
 const warnOnChevronOffBare = (props, isBare) => {
   const {
@@ -88463,7 +89062,8 @@ const PickerUI = /*#__PURE__*/Object.assign(PickerDefaultUI, {
  *   popupWidthFitContent?: boolean,
  *   loadingOutline?: "custom",
  *   loadingOutlineInset?: number,
- *   variant?: "icon" | "circle" | "headless" | "discrete" | "button" | "text" | "bare" | "picker",
+ *   variant?: "icon" | "circle" | "headless" | "discrete" | "button" | "border" | "discrete-border" | "text" | "bare" | "picker",
+ *   cta?: boolean,
  *   icon?: boolean,
  *   alignX?: "start" | "center" | "end",
  *   alignY?: "start" | "center" | "end" | "stretch",
@@ -88728,10 +89328,13 @@ const PickerUI = /*#__PURE__*/Object.assign(PickerDefaultUI, {
  *   receives the cleared value like any other choice. A cut (Ctrl+X) on such a
  *   picker copies the value and leaves it in place: no clear without the
  *   question.
- * @param {"icon"|"headless"|"discrete"|"button"|"text"|"bare"|"picker"} [variant]
+ * @param {"icon"|"headless"|"discrete"|"button"|"border"|"discrete-border"|"text"|"bare"|"picker"} [variant]
  *   How the trigger is drawn. `"button"` is a Button's drawing — surface,
  *   padding, a centered label, no chevron — and what a `type="confirm"` picker
  *   draws unless told otherwise: nothing is picked, the popup is a question.
+ *   `"border"` and `"discrete-border"` are the Button's two other looks, from
+ *   its own formulas: a picker swapped in for a Button that opened a popup
+ *   looks the same at rest, on hover and read-only.
  *   `"text"` is a word in a sentence, underlined with dots, no box and no
  *   slot: what `mode="callout"` uses for a callout on a term rather than on an
  *   icon (`"icon"` being its default, with an info icon in place of the
@@ -88755,6 +89358,9 @@ const PickerUI = /*#__PURE__*/Object.assign(PickerDefaultUI, {
  *   nearest positioned ancestor it happens to find. `"picker"` (or an explicit
  *   `variant={undefined}`) asks a confirm or callout picker for the field-like
  *   drawing every other picker has.
+ * @param {boolean} [cta] A call to action: filled with the accent, its border
+ *   matching, as `cta` draws a Button — for a confirm picker that is a row's
+ *   main action.
  * @param {"custom"} [loadingOutline] Who draws the loading outline while the
  *   action runs. Left unsaid, the picker does, around its own box. `"custom"`
  *   says someone else does — what it means on a `Button` too — for a picker
@@ -89264,8 +89870,13 @@ const TRAVELS_NONE = [];
  *   vertical?: boolean,
  *   previousLabel?: string,
  *   nextLabel?: string,
+ *   previousTestId?: string,
+ *   nextTestId?: string,
  *   [key: string]: any,
  * }>}
+ * @param {string} [previousTestId] The `data-testid` of the way out to the
+ *   previous value, which navi builds and the caller has no other way to name.
+ *   `nextTestId` is its twin.
  * @param {any} [value] The value shown. Held from above: `uiAction` says when
  *   it should move. Say `signal` for a two-way binding instead, or
  *   `defaultValue` to let the spin hold the value itself.
@@ -89347,6 +89958,8 @@ const Spin = ({
   maxLines,
   previousLabel,
   nextLabel,
+  previousTestId,
+  nextTestId,
   ...rest
 }) => {
   import.meta.css = [css$q, "@jsenv/navi/src/control/picker/picker_spin.jsx"];
@@ -89658,6 +90271,7 @@ const Spin = ({
       unavailable: !allowed || loadingResolved || readOnlyResolved,
       unavailableMessage: () => wayOutMessage(allowed, isNext),
       label: isNext ? nextLabel ?? spinI18n("spin.next") : previousLabel ?? spinI18n("spin.previous"),
+      testId: isNext ? nextTestId : previousTestId,
       onPress: e => {
         focusMiddle();
         if (editable) {
@@ -89888,6 +90502,7 @@ const WayOut = ({
   unavailable,
   unavailableMessage,
   label,
+  testId,
   onPress,
   onPointerDown,
   children
@@ -89926,6 +90541,7 @@ const WayOut = ({
     ,
     role: "button",
     "aria-label": label,
+    "data-testid": testId,
     "aria-disabled": unavailable ? "true" : undefined,
     "data-unavailable": unavailable ? "" : undefined
     // At the chevron, not beside it: a callout aims its arrow at where the
@@ -98886,6 +99502,7 @@ const css$b = /* css */`@layer navi {
 `;
 const ButtonCopyToClipboard = ({
   children,
+  "aria-label": ariaLabel = buttonI18n("button.copy"),
   ...props
 }) => {
   import.meta.css = [css$b, "@jsenv/navi/src/control/input/button_copy_to_clipboard.jsx"];
@@ -98902,11 +99519,15 @@ const ButtonCopyToClipboard = ({
     ...props,
     children: [jsx(Box, {
       className: "navi_copied_notif",
-      "aria-hidden": copied ? "false" : "true",
+      role: "status",
       opacity: copied ? 1 : 0,
-      children: "Copié !"
+      children: copied ? buttonI18n("button.copied") : null
     }), jsx(Button, {
-      className: "navi_copy_button",
+      className: "navi_copy_button"
+      // The props land on the container; the name belongs to the button,
+      // which shows only an icon.
+      ,
+      "aria-label": ariaLabel,
       icon: true,
       revealOnInteraction: true,
       square: true,