@jsenv/navi 0.29.435 → 0.29.437

package/dist/jsenv_navi.js

@@ -7,11 +7,11 @@ import { createPubSub, elementIsFocusable, createIterableWeakSet, dispatchIntern
 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 as render$1, h, toChildArray, createRef, cloneElement, createElement, Fragment as Fragment$1 } from "preact";
-import { useErrorBoundary, useLayoutEffect, useContext, useState, useMemo, useRef, useEffect, useCallback, useReducer, useId } from "preact/hooks";
+import { useErrorBoundary, useLayoutEffect, useContext, useState, useMemo, useRef, useReducer, useEffect, useCallback, useId } from "preact/hooks";
 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, createValidity, TYPE_RULE, durationContainsNaN, compareTwoDurations, durationToSeconds, DISPLAYABLE_RULE, MAX_LINE_BREAKS_RULE, NO_EMOJI_RULE, SINGLE_SPACE_RULE, resolveCharClass, getCharClassMessageKey, compileCharClassAnchored, compileCharClass, parseDuration, durationToISOString } from "@jsenv/validity";
+import { CHAR_CLASS_PRESETS, createValidity, durationContainsNaN, compareTwoDurations, TYPE_RULE, durationToSeconds, DISPLAYABLE_RULE, MAX_LINE_BREAKS_RULE, NO_EMOJI_RULE, SINGLE_SPACE_RULE, 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";
 
@@ -944,8 +944,10 @@ naviI18n.addAll({
   },
 });
 
-// Spin messages — the ends of what one steps through, said without naming
-// what it is made of: the same words fit days, months, pages or sizes.
+// Spin messages — the ends of what one steps through when the control holding
+// it has no sentence of its own for a bound (a day or a number says its
+// constraint.min/max one, see picker_spin.jsx): said without naming what it is
+// made of, so they fit pages, sizes or any list of items.
 naviI18n.addAll({
   "spin.previous": {
     en: "Previous",
@@ -3546,8 +3548,11 @@ const actionWeakMap = new WeakMap();
  *   than a first load (data_states.md). Called at the start of every run whose
  *   value is undefined; the answer replaces it as usual, and `undefined` means
  *   "nothing known". A resource `GET` uses it to draw the row its store holds.
- *   An action declaring it is asked for it by a binding moving to new params,
- *   rather than handed the previous params' answer (see inheritData).
+ * @param {boolean} [rootOptions.inheritData=true] - `false`: a binding moving
+ *   to new params starts the new instance without the previous params' answer
+ *   (see createActionProxyFromSignal). For an answer that would say something
+ *   false about the new params (a `GET` drawing another row), not for one that
+ *   stands in while the next one comes (a list of search results).
  * @param {{ ms?: number, max?: number }} [rootOptions.keep] - how long an
  *   answer stays good once it has landed. Without it an answer lives exactly as
  *   long as something references it: the screen that asked goes away, and
@@ -3590,6 +3595,7 @@ const createAction = (callback, rootOptions = {}) => {
       resultToValue,
       valueToData,
       provisionalValue,
+      inheritData = true,
       dataDefault,
       data = dataDefault,
 
@@ -4253,6 +4259,7 @@ const createAction = (callback, rootOptions = {}) => {
       const privateProperties = {
         valueInitial,
         provisionalValue,
+        inheritData,
 
         performRun,
         performReset,
@@ -4285,7 +4292,7 @@ const createAction = (callback, rootOptions = {}) => {
  *   a list of filters changes, providing real-time results without user interaction.
  * @param {boolean} options.inheritData - When false, each new target action starts fresh with no inherited state.
  *   By default (true), the proxy carries over the previous target's value and error into the new action —
- *   unless the action declares a `provisionalValue`, which then says what the new one holds.
+ *   unless the action itself declares `inheritData: false` (createAction), which a resource `GET` does.
  *   This keeps the facade in sync with the latest known data: `action.dataSignal.value` only changes when a
  *   new action completes, not when it starts loading. Code that needs to distinguish loading state can still
  *   check `action.runningState`, while code that just reads `action.data` always sees the most recent
@@ -4332,12 +4339,12 @@ const createActionProxyFromSignal = (
   let currentActionPrivateProperties = getActionPrivateProperties(action);
   let actionTargetPreviousWeakRef = null;
 
-  // An action saying for itself what it holds for params it has not answered
-  // (provisionalValue: a resource GET draws the row its store holds) is not
-  // handed the previous params' answer — an answer about another row. What it
-  // does not know stays unknown: a skeleton, never a different row.
+  // An action whose answer for other params would be false for these (a
+  // resource GET: another row) says so itself, and is not handed it. What it
+  // does not know stays unknown: a skeleton, or its provisionalValue, never a
+  // different row.
   const inheritsAnswer =
-    inheritData && !getActionPrivateProperties(action).provisionalValue;
+    inheritData && getActionPrivateProperties(action).inheritData;
   const createTarget = (params) => {
     if (inheritsAnswer) {
       const previousActionTarget = actionTargetPreviousWeakRef?.deref();
@@ -10240,6 +10247,9 @@ const paramsTargetCanPlace = (redirectRoute, urlParams) => {
 
 let setupRoutesCalled = false;
 let activeRouteSet = null;
+// True once the routes have been matched against an address. Before that, no
+// route matching says nothing about the page: nothing has been asked yet.
+const routedSignal = signal(false);
 
 const routePreloadMap = new WeakMap();
 const registerRoutePreload = (route, preload) => {
@@ -10664,6 +10674,7 @@ This prevents cross-test pollution and ensures clean state.`,
       }
       // Reset flag after URL -> Signal synchronization is complete
       isUpdatingRoutesFromUrl = false;
+      routedSignal.value = true;
       Object.assign(returnValue, { matchingRouteSet });
       for (const [route, repairedParams] of repairedParamsByRoute) {
         route.replaceParams(repairedParams, {
@@ -10713,6 +10724,7 @@ This prevents cross-test pollution and ensures clean state.`,
     droppingRouteSet = null;
     setupRoutesCalled = false;
     activeRouteSet = null;
+    routedSignal.value = false;
   };
   return {
     updateRoutes,
@@ -10779,6 +10791,42 @@ const urlWithoutSearchAndHash = (url) => {
   return `${urlObject.origin}${urlObject.pathname}`;
 };
 
+/**
+ * What a component can learn about the page it is rendered in, from the route
+ * container rendering that page (see useContentKeepingLeavingPages in
+ * route.jsx). `null` outside of any route container.
+ *
+ * - `isShown()` — whether the container would still show the page. False as
+ *   soon as the address leads elsewhere: the page is about to be taken down, or
+ *   hidden until the route transition leaving it is over, and nothing it reads
+ *   is worth a render any more. False for good once it is kept while leaving: a
+ *   return to its route mounts the page anew. Asked outside any render — by a
+ *   subscription deciding whether to re-render — and it reads the routes
+ *   untracked, so asking subscribes nobody to them.
+ * - `leavingSignal` — true once the page is hidden and kept while its movement
+ *   plays: still mounted, so what it fills outside its own nodes (a slot in a
+ *   bar) steps out rather than showing with the page arriving.
+ */
+const RoutePageContext = createContext(null);
+
+/**
+ * A container has put its page on screen — or as much of it as it can.
+ *
+ * A route matching is a signal changing, and the page it selects reaches the
+ * DOM only once Preact has rendered — an unknown number of passes later, in an
+ * unknown number of microtasks. Anyone who needs the page as it IS rather than
+ * as it has been decided (a travel about to have its picture taken by the
+ * browser, see route_travel.jsx) waits for this instead of counting.
+ *
+ * A page waiting on data is announced too, by the boundary showing its loading
+ * state (see Loading in use_async_data.jsx): what the container could put on
+ * screen is what the browser is about to take a picture of, and a page that
+ * cannot render yet would otherwise be waited on until the transition dies of
+ * it. It lives in a module of its own for that: the async layer says it as much
+ * as the router does, and neither can import the other.
+ */
+const [publishRouteRender, observeRouteRender] = createPubSub();
+
 const documentStateSignal = signal(null);
 const useDocumentState = () => {
   return documentStateSignal.value;
@@ -11038,24 +11086,6 @@ const readTopInWindow = element => {
   return element.getBoundingClientRect().top;
 };
 
-/**
- * A container has put its page on screen — or as much of it as it can.
- *
- * A route matching is a signal changing, and the page it selects reaches the
- * DOM only once Preact has rendered — an unknown number of passes later, in an
- * unknown number of microtasks. Anyone who needs the page as it IS rather than
- * as it has been decided (a travel about to have its picture taken by the
- * browser, see route_travel.jsx) waits for this instead of counting.
- *
- * A page waiting on data is announced too, by the boundary showing its loading
- * state (see Loading in use_async_data.jsx): what the container could put on
- * screen is what the browser is about to take a picture of, and a page that
- * cannot render yet would otherwise be waited on until the transition dies of
- * it. It lives in a module of its own for that: the async layer says it as much
- * as the router does, and neither can import the other.
- */
-const [publishRouteRender, observeRouteRender] = createPubSub();
-
 /**
  * Where a page was left, given back when one comes back to it.
  *
@@ -12450,6 +12480,7 @@ browserIntegration.handleActionTask;
 
 const NO_OP = () => {};
 const NO_ID_GIVEN = [undefined, NO_OP, NO_OP];
+const countRenders$1 = (count) => count + 1;
 // What the computed below answers for a key the document state does not hold:
 // key presence is the flag, and the value under a present key may be anything,
 // undefined included.
@@ -12478,7 +12509,36 @@ const useNavStateBasic = (
     [id],
   );
   const keyValue = keyValueComputed.value;
-  const keyInState = keyValue !== KEY_NOT_IN_STATE;
+  // A page the address has left keeps reading the entry it was shown on until
+  // it is taken down (kept hidden while a route transition plays): the new
+  // entry would close what was open there — a Picker as a cancel — where the
+  // same page taken down at once is only unmounted. Its render still happens:
+  // the state is written before the routes say the page is left.
+  const routePage = useContext(RoutePageContext);
+  const keyValueReadRef = useRef(keyValue);
+  const keyValueWithheld =
+    keyValue !== keyValueReadRef.current &&
+    routePage !== null &&
+    !routePage.isShown();
+  if (!keyValueWithheld) {
+    keyValueReadRef.current = keyValue;
+  }
+  const keyValueRead = keyValueReadRef.current;
+  // Owed rather than dropped, as in useAsyncData: the address can come back
+  // before the container renders (a redirect straight back), and the page then
+  // stays on screen.
+  const [, rerender] = useReducer(countRenders$1, 0);
+  useEffect(() => {
+    if (!keyValueWithheld) {
+      return undefined;
+    }
+    return observeRouteRender(() => {
+      if (routePage.isShown()) {
+        rerender();
+      }
+    });
+  }, [keyValueWithheld]);
+  const keyInState = keyValueRead !== KEY_NOT_IN_STATE;
   const onLeaveRef = useRef(onLeave);
   onLeaveRef.current = onLeave;
   const prevKeyInStateRef = useRef(keyInState);
@@ -12508,7 +12568,7 @@ const useNavStateBasic = (
     effectiveType = "replace";
   }
 
-  const currentValue = keyInState ? keyValue : defaultValue;
+  const currentValue = keyInState ? keyValueRead : defaultValue;
 
   if (debug) {
     console.debug(`useNavState(${id}) current value is ${currentValue}`);
@@ -12576,6 +12636,8 @@ const useNavStateBasic = (
 /**
  * Stores a named value in the browser's document state and returns it reactively.
  * The component re-renders whenever the value changes (navigation, back/forward button).
+ * In a page the address has left — kept hidden while a route transition plays —
+ * the value stays the one of the entry that page was shown on.
  *
  * @param {string} id
  *   Unique key used to store the value in document state. Must be stable across renders.
@@ -14981,6 +15043,13 @@ const createOpenController = (
     change();
   };
   const runChange = (change, { opened, event }) => {
+    // What the controller answers about itself is the decision, written before
+    // the change runs, whatever runs it. Whoever asks meanwhile reads it: the
+    // render an opening forces (onOpen, mountContent) reads the open state
+    // the caller holds, and an onOpen writing the popup's own `signal` has
+    // useOpenPropsEffectOnOpenController asking for this very opening — a
+    // second one, nested in the first, if `opened` still said closed.
+    controller.opened = opened;
     const applyChange = () => {
       // Recorded with the change itself: what the DOM shows is what a render
       // landing between the ask and the picture must draw (see `openedInDom`).
@@ -14996,12 +15065,8 @@ const createOpenController = (
       applyChange();
       return;
     }
-    // What the controller answers about itself does not wait for the picture:
-    // whoever just asked reads `opened` on the spot (see
-    // useOpenPropsEffectOnOpenController, which writes it back into the
-    // caller's own signal), and a request arriving before the change lands
-    // runs it first rather than reading a DOM that disagrees.
-    controller.opened = opened;
+    // A request arriving before the change lands runs it first rather than
+    // reading a DOM that disagrees.
     changeAwaitingTransition = applyChange;
     transitionChange(
       () => {
@@ -15014,7 +15079,6 @@ const createOpenController = (
   };
 
   const performClose = (closeEvent) => {
-    controller.opened = false;
     // Read before any close effect touches the DOM: closing a native <dialog>
     // hands the focus back to whatever held it at showModal() time, so by the
     // time the close cleanup runs, the popup's content has already lost the
@@ -15282,7 +15346,6 @@ const createOpenController = (
           // told it opened right after (see popup_content_mount.js and
           // use_displayed_layout_effect.js).
           controller.openedInDom = true;
-          controller.opened = true;
           // Which press it opened during, so the release of that press is not
           // read as somebody dismissing it (see openedDuringThisPress).
           controller.pressCountAtOpen = pressCount;
@@ -15709,8 +15772,10 @@ const useOpenPropsEffectOnOpenController = (
       return undefined;
     }
     // Skip when the controller is already in the desired state.
-    // openController.opened tracks actual open/close (updated by onopen/onclose,
-    // not by renders) so it is the authoritative check against feedback loops.
+    // openController.opened is what the controller decided, written before an
+    // opening renders anything (see runChange), so it is the authoritative
+    // check against feedback loops — the popup's own onOpen writing its
+    // `signal` included.
     if (open === openController.opened) {
       return undefined;
     }
@@ -19553,18 +19618,17 @@ const MIN_CONSTRAINT = {
       if (cmp === null || cmp >= 0) {
         return null;
       }
-
-      return naviI18n("constraint.min.duration.default", {
-        min: formatDuration(min),
-      });
+      return boundMessage(field, "min");
     }
     if (field.controlType !== "input" && field.controlType !== "picker") {
       return null;
     }
-    const minString = field.controlHostProps.min;
-    if (!minString) {
+    const min = field.controlHostProps.min;
+    // 0 is a bound like any other: only a bound nobody gave is skipped.
+    if (min === undefined || min === null || min === "") {
       return null;
     }
+    const minString = String(min);
     const type = field.controlHostProps.type;
     const naviInputType = field.controlHostProps["navi-input-type"];
     const valueAsString = uiStateAsText(field.uiState);
@@ -19580,40 +19644,16 @@ const MIN_CONSTRAINT = {
       if (isNaN(numericValue)) {
         return null;
       }
-      if (numericValue < minNumber) {
-        if (naviInputType === "hour") {
-          return naviI18n(`constraint.min.hour.default`, {
-            min: minString,
-          });
-        }
-        if (naviInputType === "minute") {
-          return naviI18n(`constraint.min.minute.default`, {
-            min: minString,
-          });
-        }
-        if (naviInputType === "second") {
-          return naviI18n(`constraint.min.second.default`, {
-            min: minString,
-          });
-        }
-        if (naviInputType === "percentage") {
-          return naviI18n(`constraint.min.percentage.default`, {
-            min: minString,
-          });
-        }
-        return naviI18n(`constraint.min.number.default`, {
-          min: minString,
-        });
+      if (numericValue >= minNumber) {
+        return null;
       }
-      return null;
+      return boundMessage(field, "min");
     }
     if (type === "time") {
       const [minHours, minMinutes] = minString.split(":").map(Number);
       const [hours, minutes] = valueAsString.split(":").map(Number);
       if (hours < minHours || (hours === minHours && minutes < minMinutes)) {
-        return naviI18n("constraint.min.time.default", {
-          min: minString,
-        });
+        return boundMessage(field, "min");
       }
       return null;
     }
@@ -19621,18 +19661,13 @@ const MIN_CONSTRAINT = {
     // so they never need a min/max validation message.
     if (DATE_INPUT_TYPE_SET.has(type)) {
       if (valueAsString < minString) {
-        const todayIso = getTodayIso(type);
-        if (minString === todayIso) {
-          return naviI18n("constraint.min.date.today.default");
-        }
-        return naviI18n("constraint.min.date.default", {
-          min: formatDateIso(minString, type),
-        });
+        return boundMessage(field, "min");
       }
       return null;
     }
     return null;
   },
+  messageAtBound: (field) => boundMessage(field, "min"),
 };
 CONSTRAINT_ATTRIBUTE_SET.add("min");
 
@@ -19652,18 +19687,17 @@ const MAX_CONSTRAINT = {
       if (cmp === null || cmp <= 0) {
         return null;
       }
-
-      return naviI18n("constraint.max.duration.default", {
-        max: formatDuration(max),
-      });
+      return boundMessage(field, "max");
     }
     if (field.controlType !== "input" && field.controlType !== "picker") {
       return null;
     }
-    const maxString = field.controlHostProps.max;
-    if (!maxString) {
+    const max = field.controlHostProps.max;
+    // 0 is a bound like any other: only a bound nobody gave is skipped.
+    if (max === undefined || max === null || max === "") {
       return null;
     }
+    const maxString = String(max);
     const type = field.controlHostProps.type;
     const naviInputType = field.controlHostProps["navi-input-type"];
     const valueAsString = uiStateAsText(field.uiState);
@@ -19682,38 +19716,13 @@ const MAX_CONSTRAINT = {
       if (numericValue <= maxNumber) {
         return null;
       }
-
-      if (naviInputType === "hour") {
-        return naviI18n(`constraint.max.hour.default`, {
-          max: maxString,
-        });
-      }
-      if (naviInputType === "minute") {
-        return naviI18n(`constraint.max.minute.default`, {
-          max: maxString,
-        });
-      }
-      if (naviInputType === "second") {
-        return naviI18n(`constraint.max.second.default`, {
-          max: maxString,
-        });
-      }
-      if (naviInputType === "percentage") {
-        return naviI18n(`constraint.max.percentage.default`, {
-          max: maxString,
-        });
-      }
-      return naviI18n(`constraint.max.number.default`, {
-        max: maxString,
-      });
+      return boundMessage(field, "max");
     }
     if (type === "time") {
       const [maxHours, maxMinutes] = maxString.split(":").map(Number);
       const [hours, minutes] = valueAsString.split(":").map(Number);
       if (hours > maxHours || (hours === maxHours && minutes > maxMinutes)) {
-        return naviI18n("constraint.max.time.default", {
-          max: maxString,
-        });
+        return boundMessage(field, "max");
       }
       return null;
     }
@@ -19721,17 +19730,11 @@ const MAX_CONSTRAINT = {
       if (valueAsString <= maxString) {
         return null;
       }
-
-      const todayIso = getTodayIso(type);
-      if (maxString === todayIso) {
-        return naviI18n("constraint.max.date.today.default");
-      }
-      return naviI18n("constraint.max.date.default", {
-        max: formatDateIso(maxString, type),
-      });
+      return boundMessage(field, "max");
     }
     return null;
   },
+  messageAtBound: (field) => boundMessage(field, "max"),
 };
 CONSTRAINT_ATTRIBUTE_SET.add("max");
 
@@ -19926,6 +19929,51 @@ const formatMsToTime = (ms, showSeconds) => {
   return `${hh}:${mm}:${ss}`;
 };
 
+// What a bound says, whatever the value: the sentence `check` gives a value
+// past it, and the one a spin gives when its chevron is refused there
+// (picker_spin.jsx) — one sentence, so the two refuse in the same words. null
+// for a type that has nothing to say about a bound.
+const boundMessage = (field, bound) => {
+  const boundValue = field.controlHostProps[bound];
+  if (field.controlType === "duration_group") {
+    return naviI18n(`constraint.${bound}.duration.default`, {
+      [bound]: formatDuration(boundValue),
+    });
+  }
+  const type = field.controlHostProps.type;
+  const naviInputType = field.controlHostProps["navi-input-type"];
+  if (isNumberInput(type, naviInputType)) {
+    const numberKind = NUMBER_BOUND_KIND_SET.has(naviInputType)
+      ? naviInputType
+      : "number";
+    return naviI18n(`constraint.${bound}.${numberKind}.default`, {
+      [bound]: String(boundValue),
+    });
+  }
+  if (type === "time") {
+    return naviI18n(`constraint.${bound}.time.default`, {
+      [bound]: boundValue,
+    });
+  }
+  if (DATE_INPUT_TYPE_SET.has(type)) {
+    if (boundValue === getTodayIso(type)) {
+      return naviI18n(`constraint.${bound}.date.today.default`);
+    }
+    return naviI18n(`constraint.${bound}.date.default`, {
+      [bound]: formatDateIso(boundValue, type),
+    });
+  }
+  return null;
+};
+// The numbers whose bound is said with what they count ("Max 23 heures");
+// any other is "Ce nombre".
+const NUMBER_BOUND_KIND_SET = new Set([
+  "hour",
+  "minute",
+  "second",
+  "percentage",
+]);
+
 const getTodayIso = (inputType) => {
   const now = new Date();
   const yyyy = now.getFullYear();
@@ -25793,6 +25841,171 @@ const isOwnerReadBy = (childResource, childAction, ownerGetAction) => {
   return childStore !== undefined && childStore === getChildStore(ownerId);
 };
 
+/*
+ * What a previous document kept of the page it was on (see keepPageOnScreen in
+ * nav/page_kept.js), waiting for the reads that draw it again, and what those
+ * reads are made of on the way out: rows with their relations inline.
+ *
+ * A kept read is found by the read's name and the params it was asked with
+ * (getKeptReadKey). It is handed out once: the first run of the read draws it
+ * while its request is out, and from then on the store holds the rows. Handed
+ * out again, after a reset say, it would write the previous document's rows
+ * over a fresher answer.
+ *
+ * This module is the half the resources see: `resource()` and the range reader
+ * take from it, and say which of their reads can be kept at all. Which reads
+ * are on the page on screen, and what the slot is written into, is
+ * page_kept.js.
+ */
+
+// key → what the read answered in the previous document, not handed out yet
+const offeredReadMap = new Map();
+const offerKeptReads = (entryMap) => {
+  offeredReadMap.clear();
+  for (const [key, entry] of entryMap) {
+    offeredReadMap.set(key, entry);
+  }
+};
+const withdrawKeptReads = () => {
+  offeredReadMap.clear();
+};
+const takeKeptRead = (key) => {
+  const entry = offeredReadMap.get(key);
+  if (entry === undefined) {
+    return undefined;
+  }
+  offeredReadMap.delete(key);
+  return entry;
+};
+
+// The root actions whose answer is rows of a store, written and read back the
+// same way: a resource's GET and GET_MANY. Anything else a route runs (a page's
+// code, a computation) has nothing a later document could draw.
+const keepableReadWeakSet = new WeakSet();
+const markKeepableRead = (rootAction) => {
+  keepableReadWeakSet.add(rootAction);
+};
+const isKeepableRead = (action) => {
+  const rootAction = action.rootAction || action;
+  return keepableReadWeakSet.has(rootAction);
+};
+
+// The range readers a <List.Items> on screen reads through, each with the number
+// of lists reading it: the reads of the page a route action does not cover.
+const shownRangeReadersSignal = signal(new Map());
+const showRangeReader = (reader) => {
+  const shownMap = new Map(shownRangeReadersSignal.peek());
+  shownMap.set(reader, (shownMap.get(reader) || 0) + 1);
+  shownRangeReadersSignal.value = shownMap;
+  return () => {
+    const shownMapNow = new Map(shownRangeReadersSignal.peek());
+    const count = shownMapNow.get(reader);
+    if (count === 1) {
+      shownMapNow.delete(reader);
+    } else {
+      shownMapNow.set(reader, count - 1);
+    }
+    shownRangeReadersSignal.value = shownMapNow;
+  };
+};
+
+// A row already in the store is the fresher one: the kept copy only stands in
+// for rows nothing has answered yet. Its relations are written as they were
+// kept, which a real answer corrects like any other.
+const upsertKeptItem = (store, keptItem) => {
+  const id = keptItem[store.idKey];
+  if (id !== undefined) {
+    const existing = store.select(id);
+    if (existing) {
+      return existing;
+    }
+  }
+  return store.upsert(keptItem);
+};
+
+const getKeptReadKey = (name, params) => {
+  return `${name}|${getParamsKey(params)}`;
+};
+// `true` is what a route action without params is bound to (see routeAction),
+// and a key holding undefined says nothing a missing one does not.
+const getParamsKey = (params) => {
+  if (params === undefined || params === NO_PARAMS || params === true) {
+    return "";
+  }
+  if (isPlainParams(params)) {
+    const keys = Object.keys(params).filter((key) => params[key] !== undefined);
+    if (keys.length === 0) {
+      return "";
+    }
+  }
+  return stableStringify(params);
+};
+const isPlainParams = (value) => {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+const stableStringify = (value) => {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const keys = Object.keys(value)
+    .filter((key) => value[key] !== undefined)
+    .sort();
+  const parts = [];
+  for (const key of keys) {
+    parts.push(`${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  }
+  return `{${parts.join(",")}}`;
+};
+
+// What a read's data is made of, ready to be written: a row, or the rows of a
+// list, each with its relations inline.
+const serializeData = (data) => {
+  if (Array.isArray(data)) {
+    return data.map((item) => serializeItem(item, new Set()));
+  }
+  return serializeItem(data, new Set());
+};
+// The item with its relations inline: a relation value stands for what its
+// signal holds (the child row, the child rows, or nothing), a row reached
+// twice on the same path is written as its id — the setters accept both.
+const serializeItem = (item, ancestorSet) => {
+  ancestorSet.add(item);
+  const serialized = {};
+  for (const key of Object.keys(item)) {
+    serialized[key] = serializeValue(item[key], ancestorSet);
+  }
+  ancestorSet.delete(item);
+  return serialized;
+};
+const serializeValue = (value, ancestorSet) => {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => serializeValue(entry, ancestorSet));
+  }
+  const objectSignal = value[SYMBOL_OBJECT_SIGNAL];
+  if (objectSignal) {
+    const held = objectSignal.value;
+    if (held === undefined || held === null) {
+      return null;
+    }
+    return serializeValue(held, ancestorSet);
+  }
+  if (typeof value.toJSON === "function") {
+    return value;
+  }
+  if (ancestorSet.has(value)) {
+    return Object.hasOwn(value, SYMBOL_IDENTITY)
+      ? value[SYMBOL_IDENTITY]
+      : null;
+  }
+  return serializeItem(value, ancestorSet);
+};
+
 const paramScopeWeakSet = createIterableWeakSet();
 let paramScopeIdCounter = 0;
 const getParamScope = (params) => {
@@ -25963,66 +26176,6 @@ const createResourcePersistence = (
   };
 };
 
-const getParamsKey = (params) => {
-  if (params === undefined || params === NO_PARAMS) {
-    return "";
-  }
-  return stableStringify(params);
-};
-
-const stableStringify = (value) => {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(stableStringify).join(",")}]`;
-  }
-  const keys = Object.keys(value).sort();
-  const parts = [];
-  for (const key of keys) {
-    parts.push(`${JSON.stringify(key)}:${stableStringify(value[key])}`);
-  }
-  return `{${parts.join(",")}}`;
-};
-
-// The item with its relations inline: a relation value stands for what its
-// signal holds (the child row, the child rows, or nothing), a row reached
-// twice on the same path is written as its id — the setters accept both.
-const serializeItem = (item, ancestorSet) => {
-  ancestorSet.add(item);
-  const serialized = {};
-  for (const key of Object.keys(item)) {
-    serialized[key] = serializeValue(item[key], ancestorSet);
-  }
-  ancestorSet.delete(item);
-  return serialized;
-};
-const serializeValue = (value, ancestorSet) => {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => serializeValue(entry, ancestorSet));
-  }
-  const objectSignal = value[SYMBOL_OBJECT_SIGNAL];
-  if (objectSignal) {
-    const held = objectSignal.value;
-    if (held === undefined || held === null) {
-      return null;
-    }
-    return serializeValue(held, ancestorSet);
-  }
-  if (typeof value.toJSON === "function") {
-    return value;
-  }
-  if (ancestorSet.has(value)) {
-    return Object.hasOwn(value, SYMBOL_IDENTITY)
-      ? value[SYMBOL_IDENTITY]
-      : null;
-  }
-  return serializeItem(value, ancestorSet);
-};
-
 /*
  * GET_RANGE: reading a resource one slice at a time, for a list that draws its
  * rows as it goes (`<List.Items itemsAction>`).
@@ -26059,9 +26212,23 @@ const serializeValue = (value, ancestorSet) => {
  * of what a rerun is for an action. Every reader made by `bindParams` shares
  * the signal and the compositions of the one it comes from: the params say
  * which slices are read, not which collection.
+ *
+ * A composition also outlives the document when a list on the page on screen
+ * reads it (see keepPageOnScreen): the ranks around the window it draws are
+ * written with their rows, and the first read of the next document finds them
+ * as a composition left by a list that went away — the same return, after a
+ * longer absence.
  */
 
 
+// The ranks kept of a composition for the next document: the window a list
+// draws, widened by at least one step on each side, and snapped to steps so a
+// scroll within one draws the same ranks and writes nothing.
+const KEPT_RANK_STEP = 20;
+// Counts the answers every composition took, so that one landing can be told
+// from one seen before (see readKept).
+let answerSequence = 0;
+
 const createRangeReader = (
   actionName,
   callback,
@@ -26070,6 +26237,9 @@ const createRangeReader = (
     params: boundParams,
     invalidationSignal = signal(0),
     compositionSet = new Set(),
+    // Bumped whenever what is kept of a composition for the next document
+    // changes (see readKept); shared like the compositions themselves.
+    keptVersionSignal = signal(0),
   },
 ) => {
   // Which composition this reader is about: the values its params hold, not its
@@ -26086,6 +26256,40 @@ const createRangeReader = (
     }
     return null;
   };
+  const keptKeyOf = (params) => getKeptReadKey(actionName, params);
+  const bumpKeptVersion = () => {
+    keptVersionSignal.value = keptVersionSignal.peek() + 1;
+  };
+  // The composition the previous document kept for these params, entering the
+  // store and the compositions as if a list had just left it.
+  const restoreKeptComposition = (params) => {
+    const kept = takeKeptRead(keptKeyOf(params));
+    if (!kept || typeof kept.count !== "number" || !kept.items) {
+      return null;
+    }
+    const composition = {
+      params,
+      idByIndex: new Map(),
+      count: kept.count,
+      keptFrom: undefined,
+      keptTo: undefined,
+      answeredAt: 0,
+    };
+    for (const rank of Object.keys(kept.items)) {
+      const index = Number(rank);
+      const item = upsertKeptItem(store, kept.items[rank]);
+      composition.idByIndex.set(index, item[store.idKey]);
+      if (composition.keptFrom === undefined || index < composition.keptFrom) {
+        composition.keptFrom = index;
+      }
+      if (composition.keptTo === undefined || index + 1 > composition.keptTo) {
+        composition.keptTo = index + 1;
+      }
+    }
+    compositionSet.add(composition);
+    bumpKeptVersion();
+    return composition;
+  };
   const readRange = async (range = {}) => {
     const { signal, ...rangeParams } = range;
     const paramsResolved = { ...resolveParams(boundParams), ...rangeParams };
@@ -26119,11 +26323,15 @@ const createRangeReader = (
   readRange.invalidate = () => {
     compositionSet.clear();
     invalidationSignal.value = invalidationSignal.peek() + 1;
+    bumpKeptVersion();
   };
   // The rows of a composition, drawn from the store: a rank whose row is gone
   // from the store resolves to nothing and is asked for again.
   readRange.readComposition = () => {
-    const composition = findComposition(currentParams());
+    const params = currentParams();
+    const composition = untracked(
+      () => findComposition(params) || restoreKeptComposition(params),
+    );
     if (!composition) {
       return null;
     }
@@ -26147,18 +26355,85 @@ const createRangeReader = (
     const params = currentParams();
     let composition = findComposition(params);
     if (!composition) {
-      composition = { params, idByIndex: new Map(), count };
+      composition = {
+        params,
+        idByIndex: new Map(),
+        count,
+        keptFrom: undefined,
+        keptTo: undefined,
+        answeredAt: 0,
+      };
       compositionSet.add(composition);
     } else if (replace) {
       composition.idByIndex = new Map();
     }
     composition.count = count;
+    answerSequence++;
+    composition.answeredAt = answerSequence;
     for (const [index, item] of byIndex) {
       const id = item ? item[store.idKey] : undefined;
       if (id !== undefined) {
         composition.idByIndex.set(index, id);
       }
     }
+    bumpKeptVersion();
+  };
+  // The ranks [windowFrom, windowTo) a list draws of this composition: what is
+  // kept of it for the next document is around them (see readKept).
+  readRange.frameComposition = (windowFrom, windowTo) => {
+    const composition = findComposition(currentParams());
+    if (!composition) {
+      return;
+    }
+    let keptFrom =
+      Math.floor((windowFrom - KEPT_RANK_STEP) / KEPT_RANK_STEP) *
+      KEPT_RANK_STEP;
+    if (keptFrom < 0) {
+      keptFrom = 0;
+    }
+    const keptTo =
+      Math.ceil((windowTo + KEPT_RANK_STEP) / KEPT_RANK_STEP) * KEPT_RANK_STEP;
+    if (composition.keptFrom === keptFrom && composition.keptTo === keptTo) {
+      return;
+    }
+    composition.keptFrom = keptFrom;
+    composition.keptTo = keptTo;
+    bumpKeptVersion();
+  };
+  // What a document keeps of the composition these params read, for the
+  // next one (see keepPageOnScreen): the count, and the ranks around the
+  // window last drawn with their rows inline. Read inside an effect, it
+  // follows the composition and the rows. `answeredAt` grows with every answer
+  // the composition takes (0: none in this document, restored from a kept one).
+  readRange.readKept = () => {
+    // eslint-disable-next-line no-unused-expressions
+    keptVersionSignal.value;
+    const params = resolveParams(boundParams);
+    const key = keptKeyOf(params);
+    const composition = findComposition(params);
+    if (!composition || composition.count === undefined) {
+      return { key, answeredAt: 0, readEntry: () => undefined };
+    }
+    const readEntry = () => {
+      const items = {};
+      for (const [index, id] of composition.idByIndex) {
+        if (
+          composition.keptFrom !== undefined &&
+          index < composition.keptFrom
+        ) {
+          continue;
+        }
+        if (composition.keptTo !== undefined && index >= composition.keptTo) {
+          continue;
+        }
+        const item = store.select(id);
+        if (item) {
+          items[index] = serializeItem(item, new Set());
+        }
+      }
+      return { count: composition.count, items };
+    };
+    return { key, answeredAt: composition.answeredAt, readEntry };
   };
   // The same trade a list makes with the rows it holds, applied to what is kept
   // for the next mount. Two lists on one collection each trim by their own
@@ -26169,11 +26444,16 @@ const createRangeReader = (
     if (!composition || composition.idByIndex.size <= budget) {
       return;
     }
+    let trimmed = false;
     for (const index of composition.idByIndex.keys()) {
       if (index < keepFrom || index > keepTo) {
         composition.idByIndex.delete(index);
+        trimmed = true;
       }
     }
+    if (trimmed) {
+      bumpKeptVersion();
+    }
   };
   // Memoized for the reasons an action's bindParams is (see actions.js): params
   // and the reader they make have synchronized lifetimes, and params equal in
@@ -26189,6 +26469,7 @@ const createRangeReader = (
       params: boundParams ? { ...boundParams, ...paramsToBind } : paramsToBind,
       invalidationSignal,
       compositionSet,
+      keptVersionSignal,
     });
     readerByParams.set(paramsToBind, reader);
     return reader;
@@ -27623,7 +27904,7 @@ const createRestActionFactoryForRoot = (
       `${name}.${verb}`,
       declarationSite,
     );
-    return createAction(callback, {
+    const action = createAction(callback, {
       name: `${name}.${verb}`,
       meta: { verb, isMany: false, paramScope },
       resultToValue: (result, action) => {
@@ -27659,17 +27940,33 @@ const createRestActionFactoryForRoot = (
       },
       valueToData: (itemId) => store.select(itemId),
       // While the request is out, the row the store already holds for these
-      // params is drawn: the action starts on the "refresh over a known
+      // params is drawn, or the row the page kept from the previous document
+      // (kept_reads.js): the action starts on the "refresh over a known
       // answer" line of data_states.md rather than the first-load one.
       provisionalValue:
         verb === "GET"
-          ? (params) => {
-              const item = untracked(() => findItemForGet(params));
+          ? (params, action) => {
+              const item = untracked(() => {
+                const itemForGet = findItemForGet(params);
+                if (itemForGet) {
+                  return itemForGet;
+                }
+                const keptItem = takeKeptRead(
+                  getKeptReadKey(action.name, params),
+                );
+                return keptItem ? upsertKeptItem(store, keptItem) : null;
+              });
               return item ? item[idKey] : undefined;
             }
           : undefined,
+      // Another params' answer is another row.
+      inheritData: verb !== "GET",
       completeSideEffect: onActionComplete,
     });
+    if (verb === "GET") {
+      markKeepableRead(action);
+    }
+    return action;
   };
   const createActionAffectingManyItems = (
     verb,
@@ -27684,7 +27981,7 @@ const createRestActionFactoryForRoot = (
             return itemArray.map((item) => item[idKey]);
           };
 
-    return createAction(callback, {
+    const action = createAction(callback, {
       meta: { verb, isMany: true, paramScope },
       name: `${name}.${verb}_MANY`,
       resultToValue: applyResultToValue,
@@ -27692,6 +27989,25 @@ const createRestActionFactoryForRoot = (
       // undefined so a screen can tell "not asked yet" from "answered: none".
       valueToData: (idArray) =>
         idArray === undefined ? undefined : store.selectAll(idArray),
+      // The rows the page kept from the previous document (kept_reads.js),
+      // drawn while the request is out. A binding moving to new params still
+      // hands over the previous answer when there are none: a list standing
+      // in for the next one beats a skeleton.
+      provisionalValue:
+        verb === "GET"
+          ? (params, action) =>
+              untracked(() => {
+                const keptItems = takeKeptRead(
+                  getKeptReadKey(action.name, params),
+                );
+                if (!Array.isArray(keptItems)) {
+                  return undefined;
+                }
+                return keptItems.map(
+                  (keptItem) => upsertKeptItem(store, keptItem)[idKey],
+                );
+              })
+          : undefined,
       completeSideEffect: (actionCompleted) => {
         onActionComplete(actionCompleted);
         if (
@@ -27707,6 +28023,10 @@ const createRestActionFactoryForRoot = (
         return syncIdArrayOnRename(store, idKey, actionCompleted.valueSignal);
       },
     });
+    if (verb === "GET") {
+      markKeepableRead(action);
+    }
+    return action;
   };
 
   return createActionForRoot;
@@ -27717,10 +28037,12 @@ const createRestActionFactoryForRoot = (
 // NetworkPolicyError carrying the policy's reason. A read is called or not depending
 // on where the policy answers reads from. Answered from the store, a GET of a
 // root resource completes with the row the store holds for it (see
-// findItemInStore) — handing the item back is an upsert without effect, so the
-// action completes with what it had and nothing is asked; a relationship GET
-// has no row of its own to answer with and settles with the same error. A
-// completed GET asked to rerun never gets here (actions.js holds it).
+// findItemInStore), and a root GET or GET_MANY holding rows for these params
+// (the kept page, drawn while the request is out) with those — handing them
+// back is an upsert without effect, so the action completes with what it had
+// and nothing is asked. A relationship GET has no row of its own to answer
+// with and settles with the same error. A completed GET asked to rerun never
+// gets here (actions.js holds it).
 const applyNetworkPolicy = (
   restCallback,
   { verb, isMany, findItemInStore },
@@ -27734,6 +28056,12 @@ const applyNetworkPolicy = (
       if (!policy.readsFromStore) {
         return restCallback(params, context);
       }
+      if (isKeepableRead(context.action)) {
+        const dataHeld = context.action.dataSignal.peek();
+        if (dataHeld !== undefined) {
+          return dataHeld;
+        }
+      }
       if (!isMany && findItemInStore) {
         const item = findItemInStore(params, context.action);
         if (item) {
@@ -28261,24 +28589,6 @@ const TYPE_CONVERTERS = {
   },
 };
 
-/**
- * What a component can learn about the page it is rendered in, from the route
- * container rendering that page (see useContentKeepingLeavingPages in
- * route.jsx). `null` outside of any route container.
- *
- * - `isShown()` — whether the container would still show the page. False as
- *   soon as the address leads elsewhere: the page is about to be taken down, or
- *   hidden until the route transition leaving it is over, and nothing it reads
- *   is worth a render any more. False for good once it is kept while leaving: a
- *   return to its route mounts the page anew. Asked outside any render — by a
- *   subscription deciding whether to re-render — and it reads the routes
- *   untracked, so asking subscribes nobody to them.
- * - `leavingSignal` — true once the page is hidden and kept while its movement
- *   plays: still mounted, so what it fills outside its own nodes (a slot in a
- *   bar) steps out rather than showing with the page arriving.
- */
-const RoutePageContext = createContext(null);
-
 const promiseStateWeakMap = new WeakMap();
 const usePromiseAsyncData = (
   promise,
@@ -33120,11 +33430,17 @@ const useContentKeepingLeavingPages = (branch, readShownBranch, parentPage) => {
       }
     }
   });
+  // Also run when a Suspense boundary above parks this container — a page
+  // arriving that suspends to a `<Loading>` around both pages: every hook of
+  // the pages kept while leaving has then been cleaned up, which is all that
+  // keeping them saved. Dropped, so the render resuming the container takes
+  // them down, rather than re-running every effect of a hidden page.
   useLayoutEffect(() => {
     return () => {
       for (const entry of leavingRef.current) {
         entry.hold.containers.delete(rerender);
       }
+      leavingRef.current = [];
     };
   }, []);
   if (leaving.length === 0) {
@@ -37896,6 +38212,37 @@ const writeCover = (edge, element, size) => {
   style.setProperty(property, value);
 };
 
+// Every route action, with whether it asks something of the address at the
+// moment: its route matches and its params getter returns something.
+const routeActionEntriesSignal = signal([]);
+let activeRouteActionsPrevious = new Set();
+/**
+ * The route actions asking something for the page on screen: their route
+ * matches and their params getter returns something — the running ones, not
+ * every matching one, so an action bound to every page that asks only when a
+ * popup is open over it counts while it is open. Read to rerun what the page
+ * reads (the app back from the background), and by `keepPageOnScreen`.
+ * The set is handed out again only when its members change.
+ *
+ * A page's code is declared as a route action too; `action.meta.verb` says
+ * which ones read data.
+ *
+ * @type {import("@preact/signals").ReadonlySignal<Set<object>>}
+ */
+const activeRouteActionsSignal = computed(() => {
+  const active = new Set();
+  for (const { routeAction, askingSignal } of routeActionEntriesSignal.value) {
+    if (askingSignal.value) {
+      active.add(routeAction);
+    }
+  }
+  if (haveSameMembers(active, activeRouteActionsPrevious)) {
+    return activeRouteActionsPrevious;
+  }
+  activeRouteActionsPrevious = active;
+  return active;
+});
+
 /**
  * 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
@@ -37953,6 +38300,13 @@ const routeAction = (
     return params;
   };
   const actionBoundToRoute = actionRunEffect(action, readParamsAsked, options);
+  routeActionEntriesSignal.value = [
+    ...routeActionEntriesSignal.peek(),
+    {
+      routeAction: actionBoundToRoute,
+      askingSignal: computed(() => Boolean(readParamsAsked())),
+    },
+  ];
   for (const route of routes) {
     // Asked of the route's params as they are, like the effect asks them.
     registerRouteReload(route, () =>
@@ -38036,6 +38390,343 @@ const anyMatchingRouteSignal = (routes) => {
   return anyMatchingSignal;
 };
 
+const haveSameMembers = (setA, setB) => {
+  if (setA.size !== setB.size) {
+    return false;
+  }
+  for (const value of setA) {
+    if (!setB.has(value)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/*
+ * The page on screen, kept for the next document: what its reads answered,
+ * written into a signal the app hands over, and drawn again by the same reads
+ * in a document opening on the same page (a reload, a tab the system
+ * discarded). The read side is state/rest/kept_reads.js; this is what decides
+ * which reads are the page, and when the slot is written.
+ *
+ * The unit is the page, not the resource. One resource is read by several
+ * screens — a search, someone's games, a game opened from anywhere — and kept
+ * per resource it would keep every row ever opened. The page's reads are what
+ * navi already runs for it: the route actions asking something for the page
+ * (activeRouteActionsSignal) and the compositions the lists on screen read
+ * (shownRangeReadersSignal). A search typed on the page is neither, and is not
+ * kept.
+ *
+ * A read is written once it has answered in this document. Before that it
+ * keeps what the previous document kept for it, never what it shows meanwhile:
+ * an answer handed over from other params (a list standing in for the next
+ * one) says nothing about these.
+ *
+ * The write waits for the page to settle and is flushed when the document is
+ * hidden. A navigation goes through pages half there — the route matched, its
+ * list not mounted yet, the page left still drawn under a transition — and
+ * each would otherwise be written out in full. Hidden is the moment the system
+ * may discard the document, so nothing is lost by waiting until then.
+ *
+ * The signal turning `undefined` from outside (sign-out) forgets the page, and
+ * nothing is written until a read lands again: written at once, the page still
+ * on screen would put back the account just left.
+ */
+
+const WRITE_DELAY = 1000;
+const NOTHING_PENDING = {};
+let stopKeepingCurrent = null;
+
+/**
+ * Keeps what the page on screen reads, so that a new document opening on it —
+ * a reload, a pull-to-refresh, a tab the system discarded in the background —
+ * draws it again while its reads go out, rather than skeletons.
+ *
+ * What the page reads is what navi runs for it: the route actions asking
+ * something for it (see `activeRouteActionsSignal`) whose action is a resource
+ * `GET` or `GET_MANY`, and the `GET_RANGE` compositions the `<List.Items>` on
+ * screen read, around the window they draw. A navigation replaces the slot with
+ * the next page's reads, and the page left is dropped. In the next document,
+ * the first run of the same read with the same params draws the kept answer as
+ * its provisional value: `data` set while `loading` is `true`, the answer
+ * replacing it. Under a network policy answering reads from the store, the
+ * kept answer answers the read. The copy follows the store: a `PUT` on a row
+ * rewrites it.
+ *
+ * Call it before the routes start: the first runs are the ones that look.
+ *
+ * @param {object} options
+ * @param {import("@preact/signals").Signal} options.signal - where the slot is
+ *   written: a `stateSignal` with `persists: true` and `type: "object"`, its
+ *   `id` holding whatever makes a kept page unusable (the deployed version).
+ *   Writing `undefined` into it (sign-out) forgets the page, and nothing is
+ *   written again until a read lands.
+ * @param {() => boolean} [options.when] - read whenever the slot is about to be
+ *   read or written: `false` reads nothing, writes nothing, and empties the
+ *   signal (a tab viewing as someone else). A function, so it can read a signal.
+ * @param {object[]} [options.always] - routes whose reads stay kept once the
+ *   page is left, until it is visited again: the page an app opens on when it
+ *   is launched rather than reloaded.
+ * @returns {() => void} stops keeping the page.
+ * @see docs/resource.md — what is kept and what is not, what stays the app's
+ */
+const keepPageOnScreen = ({
+  signal: keptSignal,
+  when,
+  always = [],
+} = {}) => {
+  if (!isSignal(keptSignal)) {
+    throw new TypeError(
+      `keepPageOnScreen() needs a signal to write the page into, received ${keptSignal}`,
+    );
+  }
+  if (stopKeepingCurrent) {
+    stopKeepingCurrent();
+  }
+  const isAllowed = () => {
+    return when ? Boolean(when()) : true;
+  };
+  const alwaysMatchingSignal = anyMatchingRouteSignal(always);
+
+  // What the signal held when it was read: the previous document's page.
+  let loadedEntryMap = new Map();
+  let loadedAlwaysKeys = [];
+  // Which reads answered in this document (since the last forget): only
+  // those write what they show.
+  let answeredActionWeakSet = new WeakSet();
+  let answeredRangeKeySet = new Set();
+  // The state each action was last seen in, and the last answer seen of each
+  // range reader: a read lands when they move, and not because the slot looks
+  // again at something that had answered before a forget.
+  const stateSeenWeakMap = new WeakMap();
+  const answeredAtSeenWeakMap = new WeakMap();
+  // Forgotten: nothing is written until a read lands.
+  let paused = false;
+  // The reads of the always-kept page, as they were the last time it was on
+  // screen in this document; null until then.
+  let alwaysReads = null;
+
+  const forget = () => {
+    loadedEntryMap = new Map();
+    loadedAlwaysKeys = [];
+    answeredActionWeakSet = new WeakSet();
+    answeredRangeKeySet = new Set();
+    alwaysReads = null;
+    paused = true;
+    withdrawKeptReads();
+  };
+
+  let lastWritten;
+  let pendingWrite = NOTHING_PENDING;
+  let writeTimeout;
+  const flush = () => {
+    clearTimeout(writeTimeout);
+    if (pendingWrite === NOTHING_PENDING) {
+      return;
+    }
+    const value = pendingWrite;
+    pendingWrite = NOTHING_PENDING;
+    if (compareTwoJsValues(value, lastWritten)) {
+      return;
+    }
+    lastWritten = value;
+    keptSignal.value = value;
+  };
+  const scheduleWrite = (value) => {
+    pendingWrite = value;
+    clearTimeout(writeTimeout);
+    writeTimeout = setTimeout(flush, WRITE_DELAY);
+  };
+  const onVisibilityChange = () => {
+    if (document.visibilityState === "hidden") {
+      flush();
+    }
+  };
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  window.addEventListener("pagehide", flush);
+
+  // Runs at once with what the signal already holds (the slot read from
+  // storage), then on every write — the slot's own ones are recognized and
+  // left alone.
+  const unsubscribe = keptSignal.subscribe((value) => {
+    if (value === lastWritten) {
+      return;
+    }
+    lastWritten = value;
+    pendingWrite = NOTHING_PENDING;
+    clearTimeout(writeTimeout);
+    if (
+      value === undefined ||
+      value === null ||
+      typeof value !== "object" ||
+      !isAllowed()
+    ) {
+      forget();
+      return;
+    }
+    const entries =
+      value.entries && typeof value.entries === "object" ? value.entries : {};
+    loadedEntryMap = new Map(Object.entries(entries));
+    loadedAlwaysKeys = Array.isArray(value.always)
+      ? value.always.filter((key) => loadedEntryMap.has(key))
+      : [];
+    alwaysReads = null;
+    paused = false;
+    offerKeptReads(loadedEntryMap);
+  });
+
+  const actionReadWeakMap = new WeakMap();
+  const actionReadOf = (action) => {
+    let read = actionReadWeakMap.get(action);
+    if (read) {
+      return read;
+    }
+    read = () => {
+      const state = action.runningStateSignal.value;
+      const stateSeen = stateSeenWeakMap.get(action);
+      stateSeenWeakMap.set(action, state);
+      const landed = state === COMPLETED && stateSeen !== COMPLETED;
+      if (landed) {
+        answeredActionWeakSet.add(action);
+      }
+      return {
+        key: getKeptReadKey(action.name, action.params),
+        answered: answeredActionWeakSet.has(action),
+        landed,
+        readEntry: () => {
+          const data = action.dataSignal.value;
+          if (data === undefined || data === null) {
+            return undefined;
+          }
+          return serializeData(data);
+        },
+      };
+    };
+    actionReadWeakMap.set(action, read);
+    return read;
+  };
+  const rangeReadWeakMap = new WeakMap();
+  const rangeReadOf = (reader) => {
+    let read = rangeReadWeakMap.get(reader);
+    if (read) {
+      return read;
+    }
+    read = () => {
+      const { key, answeredAt, readEntry } = reader.readKept();
+      const answeredAtSeen = answeredAtSeenWeakMap.get(reader) || 0;
+      answeredAtSeenWeakMap.set(reader, answeredAt);
+      const landed = answeredAt > answeredAtSeen;
+      if (landed) {
+        answeredRangeKeySet.add(key);
+      }
+      return {
+        key,
+        answered: answeredRangeKeySet.has(key),
+        landed,
+        readEntry,
+      };
+    };
+    rangeReadWeakMap.set(reader, read);
+    return read;
+  };
+  const readsOnScreen = () => {
+    const reads = [];
+    for (const routeAction of activeRouteActionsSignal.value) {
+      // The instance is what is kept, so that a page left keeps what it read.
+      // The binding's callSource names that instance and is rewritten once the
+      // binding has moved to another one: read, it brings the slot along.
+      // eslint-disable-next-line no-unused-expressions
+      routeAction.callSource;
+      const action = getActionPrivateProperties(routeAction).currentAction;
+      if (action.params === NO_PARAMS || !isKeepableRead(action)) {
+        continue;
+      }
+      reads.push(actionReadOf(action));
+    }
+    for (const reader of shownRangeReadersSignal.value.keys()) {
+      reads.push(rangeReadOf(reader));
+    }
+    return reads;
+  };
+
+  const stopEffect = effect(() => {
+    const allowed = isAllowed();
+    const routed = routedSignal.value;
+    const alwaysMatching = alwaysMatchingSignal.value;
+    if (!allowed) {
+      forget();
+      pendingWrite = undefined;
+      flush();
+      return;
+    }
+    if (!routed) {
+      // No page yet: the slot is what the first reads will draw.
+      return;
+    }
+    const screenReads = readsOnScreen();
+    if (alwaysMatching) {
+      alwaysReads = screenReads;
+    }
+    const entries = {};
+    let landed = false;
+    const collect = (reads) => {
+      const keys = [];
+      for (const read of reads) {
+        const result = read();
+        if (result.landed) {
+          landed = true;
+        }
+        const entry = result.answered
+          ? result.readEntry()
+          : loadedEntryMap.get(result.key);
+        if (entry === undefined) {
+          continue;
+        }
+        entries[result.key] = entry;
+        keys.push(result.key);
+      }
+      return keys;
+    };
+    const screenKeys = collect(screenReads);
+    let alwaysKeys;
+    if (alwaysReads === screenReads) {
+      alwaysKeys = screenKeys;
+    } else if (alwaysReads) {
+      alwaysKeys = collect(alwaysReads);
+    } else {
+      alwaysKeys = loadedAlwaysKeys;
+      for (const key of alwaysKeys) {
+        entries[key] = loadedEntryMap.get(key);
+      }
+    }
+    if (paused) {
+      if (!landed) {
+        return;
+      }
+      paused = false;
+    }
+    if (screenKeys.length === 0 && alwaysKeys.length === 0) {
+      scheduleWrite(undefined);
+      return;
+    }
+    scheduleWrite({ entries, screen: screenKeys, always: alwaysKeys });
+  });
+
+  const stop = () => {
+    flush();
+    stopEffect();
+    unsubscribe();
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    window.removeEventListener("pagehide", flush);
+    withdrawKeptReads();
+    if (stopKeepingCurrent === stop) {
+      stopKeepingCurrent = null;
+    }
+  };
+  stopKeepingCurrent = stop;
+  return stop;
+};
+
 /**
  * A popup that is the anchor, brought to the front.
  *
@@ -65108,7 +65799,7 @@ const css$E = /* css */`
     /* A plain div, unlike dialogEl itself (a real <dialog>, natively hidden
        by default until .show()/.showModal() adds [open]) — needs its own
        starting-hidden mechanism. [navi-hidden] is set from useDialogProps'
-       own backdropProps (recomputed from openController.opened on every
+       own backdropProps (recomputed from openController.openedInDom on every
        render, present from the very first one), then toggled by plain
        removeAttribute/setAttribute in openEffect/close, never an explicit
        display override — removing the attribute just lets this rule stop
@@ -66709,7 +67400,7 @@ const useDialogProps = props => {
     "navi-out-of-flow": "",
     "baseClassName": "navi_dialog_backdrop",
     "aria-hidden": "true",
-    // Recomputed fresh on every render from openController.opened (not
+    // Recomputed fresh on every render from openController.openedInDom (not
     // driven through a mount-time layout effect, unlike this file's own
     // imperative open/close toggling below) — present in the DOM
     // synchronously from the very first commit, matching this file's own
@@ -66719,7 +67410,7 @@ const useDialogProps = props => {
     // needs — see popover.jsx's own identical prop for the full reasoning.
     "aria-expanded": openController.openedInDom ? "true" : "false",
     // Present from this very first render (recomputed fresh on every one
-    // from openController.opened, not a frozen mount-time constant) so
+    // from openController.openedInDom, not a frozen mount-time constant) so
     // there's no gap for the browser to ever paint this plain-div backdrop
     // visible before anything has actually opened it — see popover.jsx's
     // own identical prop for the full reasoning, and this file's own CSS
@@ -66739,7 +67430,7 @@ const useDialogProps = props => {
     // (kept once, not repeated here).
     "aria-expanded": openController.openedInDom ? "true" : "false",
     // Present from the very first render (recomputed fresh from
-    // openController.opened every time, not a frozen mount-time constant —
+    // openController.openedInDom every time, not a frozen mount-time constant —
     // see popover.jsx's own identical prop for the full reasoning) so a
     // consumer whose own CSS also sets display (e.g. Popup's flex prop)
     // can't silently defeat showModal()/close()'s native open/close — see
@@ -67115,7 +67806,7 @@ const css$D = /* css */`
        without this it would flash visible for one frame on mount, before
        openEffect's own JS ever gets a chance to hide it. [navi-hidden] is
        set from usePopoverProps' own contentProps (recomputed from
-       openController.opened on every render, present from the very first
+       openController.openedInDom on every render, present from the very first
        one — see there for why), then toggled by plain
        removeAttribute/setAttribute in openEffect/close, never an explicit
        display override: removing the attribute just lets this rule stop
@@ -68471,7 +69162,7 @@ const usePopoverProps = props => {
     "navi-out-of-flow": "",
     "baseClassName": "navi_popover_backdrop",
     "aria-hidden": "true",
-    // Recomputed fresh on every render from openController.opened (not a
+    // Recomputed fresh on every render from openController.openedInDom (not a
     // frozen mount-time constant, same pattern as navi-hidden just below)
     // rather than driven through a mount-time layout effect — its own
     // actual open/close toggling is still done entirely imperatively
@@ -68546,7 +69237,7 @@ const usePopoverProps = props => {
     // starting-hidden default) — present from this very first render so
     // there's no gap for the browser to ever paint it visible before
     // anything has actually opened it. Recomputed fresh on every render from
-    // openController.opened (not a frozen mount-time constant) — Preact
+    // openController.openedInDom (not a frozen mount-time constant) — Preact
     // only touches the DOM for a prop whose value actually changed since
     // the last render, so as long as this always reflects the *current*
     // truth, it never fights the imperative
@@ -72972,7 +73663,6 @@ const ListUI = props => {
   // What the runs ask for and stand for, in items: a source paginates in items,
   // and asks for the first picture's items and the rest in one round trip.
   listItems.pageSize = PAGE_SIZE_DEFAULT;
-  listItems.scrolled = scrolled ?? defaultScrolled;
   const {
     virtualItemSizeSignal,
     renderWindow,
@@ -73312,6 +74002,45 @@ const useListScrollSync = ({
   columns
 }) => {
   const debugScroll = useDebugScroll();
+  // Where the list must be: what the caller holds it at (`scrolled`), or where
+  // it opens and then lets go (`defaultScrolled`). A `scrolled` that changes is
+  // the caller moving the list, so the hold is armed again — that is what makes
+  // it controlled. A `defaultScrolled` that changes is where the list opens,
+  // read again from something that answered again (a count fresher than the
+  // one kept from the previous visit): followed for as long as nobody has
+  // moved the list, and compared by value, since it is said at every render.
+  // Nothing to hold it at (a position not saved yet) is not a position: the
+  // list opens where it opens.
+  const startPlaceRef = useRef(null);
+  if (startPlaceRef.current === null) {
+    startPlaceRef.current = {
+      userTookOver: false,
+      wanted: scrolled ?? defaultScrolled,
+      scrolled,
+      defaultScrolled,
+      way: null,
+      arrived: false
+    };
+  } else {
+    const place = startPlaceRef.current;
+    if (place.scrolled !== scrolled) {
+      place.scrolled = scrolled;
+      place.defaultScrolled = defaultScrolled;
+      place.wanted = scrolled ?? defaultScrolled;
+      place.userTookOver = false;
+    } else if ((scrolled === undefined || scrolled === null) && !compareTwoJsValues(place.defaultScrolled, defaultScrolled)) {
+      place.defaultScrolled = defaultScrolled;
+      if (!place.userTookOver) {
+        place.wanted = defaultScrolled;
+        // Placed again from where it stands: the way to the previous place
+        // says nothing about whose the next scrolls are.
+        place.way = null;
+        place.arrived = false;
+      }
+    }
+  }
+  const scrolledWanted = startPlaceRef.current.wanted;
+  listItems.scrolled = scrolledWanted;
   // The items drawn, [start, end) among the list's own. A ref as well as a
   // state: the render moves it where the list is held (holdWindow) without a
   // commit of its own.
@@ -73326,7 +74055,7 @@ const useListScrollSync = ({
   const virtualItemSizeSignal = useVirtualItemSizeSignal(ref, virtualItemSize, horizontal, {
     inLines: Boolean(columns),
     windowLeavesItemsOut,
-    scrolledWanted: scrolled ?? defaultScrolled,
+    scrolledWanted,
     // The fillers hold the room of items above the screen at this size: a
     // size that changes moves what is on screen, like items landing above it.
     beforeSizeChange: () => listItems.captureAnchor()
@@ -73657,25 +74386,7 @@ const useListScrollSync = ({
     const newEnd = newStart + windowSize;
     updateRenderWindow(newStart, newEnd);
   };
-
-  // Where the list must be: what the caller holds it at (`scrolled`), or where
-  // it opens and then lets go (`defaultScrolled`). A `scrolled` that changes is
-  // the caller moving the list, so the hold is armed again — that is what makes
-  // it controlled.
-  // Nothing to hold it at (a position not saved yet) is not a position: the
-  // list opens where it opens.
-  const scrolledWanted = scrolled ?? defaultScrolled;
   const scrolledFallback = scrolled === undefined || scrolled === null ? "start" : defaultScrolled ?? "start";
-  const startPlaceRef = useRef({
-    userTookOver: false,
-    wanted: scrolledWanted,
-    way: null,
-    arrived: false
-  });
-  if (startPlaceRef.current.wanted !== scrolledWanted) {
-    startPlaceRef.current.wanted = scrolledWanted;
-    startPlaceRef.current.userTookOver = false;
-  }
   // Only one thing owns the scroll at a time: while the list is holding itself
   // somewhere, the anchoring stays out of it (holding an item still is precisely
   // not being at the end anymore once what is above it shrinks).
@@ -77395,6 +78106,17 @@ const useItemStore = ({
   }
   const pages = pagesRef.current;
   const [, setPageVersion] = useState(0);
+  // A list on screen is part of what the page reads: the composition it reads
+  // is kept with the page for the next document (see keepPageOnScreen).
+  useLayoutEffect(() => {
+    if (inMemory || typeof itemsAction !== "function") {
+      return undefined;
+    }
+    if (!itemsAction.isRangeReader) {
+      return undefined;
+    }
+    return showRangeReader(itemsAction);
+  }, [inMemory, itemsAction]);
   // The ranks whose item is from before: the run came back to the screen, or
   // the source said the collection moved. They stay drawn until a page confirms
   // or replaces them, rank by rank. A page covers what the window framed when it
@@ -77528,6 +78250,7 @@ const useItemStore = ({
         }
       }
       if (typeof itemsAction === "function" && itemsAction.trimComposition) {
+        itemsAction.frameComposition(windowFrom, windowTo);
         itemsAction.trimComposition(keepFrom, keepTo, budget);
       }
     },
@@ -78097,6 +78820,9 @@ 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`).
+ *   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]
  *   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
@@ -80965,6 +81691,8 @@ const TRAVELS_NONE = [];
  *   name?: string,
  *   min?: any,
  *   max?: any,
+ *   minMessage?: any,
+ *   maxMessage?: any,
  *   step?: number,
  *   type?: string,
  *   editable?: boolean,
@@ -81003,7 +81731,15 @@ const TRAVELS_NONE = [];
  * @param {number} [step=1] How many steps a press covers.
  * @param {number} [duration=250] How long a travel takes, in milliseconds.
  * @param {any} [min] The first value one can reach; `max` is the last. Beyond
- *   them the travel simply does not happen and the chevron that way says so.
+ *   them the travel simply does not happen and the chevron that way says so,
+ *   in the words the control in the middle uses for a value past that end ("La
+ *   date doit être au plus tard le 2 avril 2027", "Max 5"). A value the control
+ *   has no such sentence for — what a plain `Spin` steps through — is "nothing
+ *   after this one".
+ * @param {any} [maxMessage] What is said at `max` instead: by the chevron
+ *   refused there, by a travel asked past it, and by the control in the middle
+ *   for a value past it (picked in the calendar, typed). `minMessage` is its
+ *   twin at `min`.
  * @param {string} [padding] The room around the value, `paddingX`/`paddingY`
  *   and the four sides included. It goes on what is inside the box rather than
  *   on the box: above and below it is taken by the value AND by the two
@@ -81033,6 +81769,8 @@ const Spin = ({
   name,
   min,
   max,
+  minMessage,
+  maxMessage,
   step = 1,
   duration = 250,
   type = "text",
@@ -81158,15 +81896,31 @@ const Spin = ({
   const readOnlyResolved = Boolean(readOnly || readOnlyFromAbove || loadingResolved);
   const disabledResolved = Boolean(disabled || disabledFromAbove);
 
+  // The end of what one may reach, said the way the control in the middle
+  // says it about a value past that end — its `minMessage`/`maxMessage`, or the
+  // sentence its type has for the bound — so a chevron, the calendar and a
+  // typed value refuse in the same words. Asked of the control at the press:
+  // it is not there yet on the first render. `goingNext` is towards the bigger
+  // values, whichever end of the box that is.
+  const boundMessage = goingNext => {
+    const constraint = goingNext ? MAX_CONSTRAINT : MIN_CONSTRAINT;
+    const controlEl = controlRef.current;
+    const controller = (findControlHost(controlEl) || controlEl).__uiStateController__;
+    const {
+      message
+    } = getConstraintMessage(controller, constraint, constraint.messageAtBound(controller), {});
+    return message ?? naviI18n(goingNext ? "spin.nothing_after" : "spin.nothing_before");
+  };
+
   // Why a chevron refuses, in its own words — and only when the reason is
   // ours: the end of what one may reach is something this control knows and
   // navi cannot guess. For everything else the reason belongs to the state the
   // whole control is in, and it is said about the control ("read-only",
   // "busy") rather than about the button, which is not what the user was
   // pressing.
-  const wayOutMessage = (allowed, endKey) => {
+  const wayOutMessage = (allowed, isNext) => {
     if (!allowed) {
-      return naviI18n(endKey);
+      return boundMessage(isNext);
     }
     if (loadingResolved) {
       return naviI18n("constraint.busy.default");
@@ -81278,7 +82032,7 @@ const Spin = ({
       // answer belongs.
       e.preventDefault();
       e.stopPropagation();
-      openCallout(naviI18n(goingNext ? "spin.nothing_after" : "spin.nothing_before"), {
+      openCallout(boundMessage(goingNext), {
         anchorElement: middleRef.current,
         status: "info",
         openingEvent: e.detail.event ?? e
@@ -81337,12 +82091,14 @@ const Spin = ({
   const valueDrawnAtEnd = travelPending?.area === "end" ? travelPending.value : valueAtEnd;
   const wayOut = atStart => {
     const isNext = atStart ? startIsNext : !startIsNext;
+    const allowed = atStart ? startAllowed : endAllowed;
     return jsx(WayOut, {
       atStart: atStart,
       onPointerDown: e => {
         wayOutPointerTypeRef.current = e.pointerType;
       },
-      unavailableMessage: wayOutMessage(atStart ? startAllowed : endAllowed, isNext ? "spin.nothing_after" : "spin.nothing_before"),
+      unavailable: !allowed || loadingResolved || readOnlyResolved,
+      unavailableMessage: () => wayOutMessage(allowed, isNext),
       label: isNext ? nextLabel ?? naviI18n("spin.next") : previousLabel ?? naviI18n("spin.previous"),
       onPress: e => {
         focusMiddle();
@@ -81389,6 +82145,8 @@ const Spin = ({
         ...valueProps,
         min: min,
         max: max,
+        minMessage: minMessage,
+        maxMessage: maxMessage,
         step: step,
         readOnly: readOnly,
         disabled: disabled,
@@ -81422,6 +82180,8 @@ const Spin = ({
           ...valueProps,
           min: min,
           max: max,
+          minMessage: minMessage,
+          maxMessage: maxMessage,
           readOnly: readOnly,
           disabled: disabled,
           loading: loading,
@@ -81532,6 +82292,7 @@ const Spin = ({
 const WayOut = ({
   atStart,
   commandFor,
+  unavailable,
   unavailableMessage,
   label,
   onPress,
@@ -81542,10 +82303,10 @@ const WayOut = ({
   // onPointerUp below).
   const pointerDownRef = useRef(null);
   const press = e => {
-    if (unavailableMessage) {
+    if (unavailable) {
       // Why it does nothing, said where one pressed: a control would have
       // done this through its own interaction gate, and this one has none.
-      openCallout(unavailableMessage, {
+      openCallout(unavailableMessage(), {
         anchorElement: e.currentTarget,
         status: "info",
         openingEvent: e
@@ -81572,8 +82333,8 @@ const WayOut = ({
     ,
     role: "button",
     "aria-label": label,
-    "aria-disabled": unavailableMessage ? "true" : undefined,
-    "data-unavailable": unavailableMessage ? "" : undefined
+    "aria-disabled": unavailable ? "true" : undefined,
+    "data-unavailable": unavailable ? "" : undefined
     // At the chevron, not beside it: a callout aims its arrow at where the
     // anchor's text starts, and there is no text here — only a glyph in the
     // middle of the box, which is what one pressed and what the answer is
@@ -81806,6 +82567,8 @@ SpinGroup.Separator = SpinGroupSeparator;
  *   defaultValue?: number|string,
  *   min?: number,
  *   max?: number,
+ *   minMessage?: any,
+ *   maxMessage?: any,
  *   step?: number,
  *   pad?: number,
  *   loop?: boolean,
@@ -81911,6 +82674,8 @@ const numberAtStep = (value, count, {
  *   name?: string,
  *   min?: string,
  *   max?: string,
+ *   minMessage?: any,
+ *   maxMessage?: any,
  *   step?: number,
  *   lang?: string,
  *   renderDay?: (day: string) => import("ignore:preact").ComponentChildren,
@@ -93478,5 +94243,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, enableVirtualKeyboardOverlay, 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, activeRouteActionsSignal, anyMatchingRouteSignal, applySearch, arraySignalMembership, canNavBackSignal, canNavForwardSignal, coarsePointerSignal, compareTwoJsValues, constraintFromValidityRule, createAction, createAvailableConstraint, createRequestCanceller, createSearch, createSelectionKeyboardShortcuts, createSlot, defineInteractionDetector, defineRouteDefaultTransition, defineRouteTransition, detectHorizontalOverflow, dispatchRequestSetUIState, enableDebugActions, enableDebugOnDocumentLoading, enableVirtualKeyboardOverlay, ensureDocumentStartViewTransition, errorIsDisplayed, filterTableSelection, getNowHours, getNowHoursRoundedToStep, isCellSelected, isColumnSelected, isNetworkPolicyError, isRowSelected, isScrolling, isToday, keepPageOnScreen, 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