@jsenv/navi 0.29.238 → 0.29.299

package/dist/dev/jsenv_navi.js

@@ -20677,16 +20677,16 @@ const useComposeElementRef = (syncElement, externalRef) => {
   const cleanupRef = useRef(null);
   const elRef = useRef(null);
   const prevSyncElementRef = useRef(undefined);
-  const stableRef = useRef(null);
+  const holderRef = useRef(null);
   const externalRefRef = useRef(externalRef);
   const syncElementRef = useRef(syncElement);
   syncElementRef.current = syncElement;
-  // Detect external ref identity change between renders. The refCallback is
-  // stable across renders, so when the parent passes a new ref object (or
-  // switches from null to a ref), Preact does NOT re-fire the callback while
-  // the DOM element is unchanged. We must manually clear the old ref and
-  // populate the new one with the current element to avoid leaving the new
-  // ref's `.current` stuck at `null`.
+  // Detect external ref identity change between renders. The refCallback keeps
+  // its identity once it holds the element, so when the parent passes a new
+  // ref object (or switches from null to a ref), Preact does NOT re-fire the
+  // callback while the DOM element is unchanged. We must manually clear the
+  // old ref and populate the new one with the current element to avoid
+  // leaving the new ref's `.current` stuck at `null`.
   const prevExternalRefRef = useRef(externalRef);
   if (prevExternalRefRef.current !== externalRef) {
     const previous = prevExternalRefRef.current;
@@ -20704,12 +20704,12 @@ const useComposeElementRef = (syncElement, externalRef) => {
   }
   externalRefRef.current = externalRef;
 
-  if (!stableRef.current) {
-    // Created once, like the ref callback that calls it, and reading the sync
-    // function through a ref for that reason: the element can be replaced long
-    // after the first render — a tag that changes, a box hidden then shown —
-    // and what the new element gets must be the current render's sync, not
-    // the one the first render closed over.
+  if (!holderRef.current) {
+    // Created once, and reading the sync function through a ref for that
+    // reason: the element can be replaced long after the first render — a tag
+    // that changes, a box hidden then shown — and what the new element gets
+    // must be the current render's sync, not the one the first render closed
+    // over.
     const runSync = (el) => {
       if (cleanupRef.current) {
         cleanupRef.current();
@@ -20722,6 +20722,18 @@ const useComposeElementRef = (syncElement, externalRef) => {
         cleanupRef.current = cleanup;
       }
     };
+    holderRef.current = { runSync, refCallback: null };
+  }
+  const { runSync } = holderRef.current;
+
+  // A new callback on every render until Preact has handed it the element,
+  // the same one afterwards. Preact re-applies a ref only when its identity
+  // changes, and a diff that throws with no error boundary above skips
+  // commitRoot: its refs are dropped while its DOM stays and is adopted as
+  // mounted by the next render. A callback that never fired would then never
+  // fire, and a Box would stay raw HTML for the life of the document. Free on
+  // a healthy mount, where the first callback is the only one ever created.
+  if (!elRef.current) {
     const refCallback = (el) => {
       elRef.current = el;
       // Keep .current in sync immediately so useEffect callbacks that read
@@ -20745,9 +20757,9 @@ const useComposeElementRef = (syncElement, externalRef) => {
         prevSyncElementRef.current = undefined;
       }
     };
-    stableRef.current = { refCallback, runSync };
+    holderRef.current.refCallback = refCallback;
   }
-  const { refCallback, runSync } = stableRef.current;
+  const { refCallback } = holderRef.current;
 
   // If element already mounted, re-sync when syncElement reference changed.
   if (elRef.current && syncElement !== prevSyncElementRef.current) {
@@ -32258,6 +32270,17 @@ registerNaviCommand("--navi-send", (source, event, { requester }) => {
         return sent;
       }
       if (isRunning) {
+        // An optimistic control takes its send as done on its own word: what
+        // follows it runs at once and the run goes on detached — still
+        // watched, still able to fail, its error callout then drawn on what
+        // surrounds the closed surface it was typed in (see openCallout's
+        // anchor resolution in callout.js).
+        const sendController = (findControlHost(target) || target)
+          .__uiStateController__;
+        if (sendController?.optimistic) {
+          runAfterSend();
+          return sent;
+        }
         // The send is committing but has not finished: leaving now would take
         // the form off the screen mid-submission (a popup closing over its own
         // running action, a slide moving on before it is answered). What
@@ -36849,6 +36872,16 @@ const useControlProps = (props, {
           if (!deferredCommand) {
             return;
           }
+          if (uiStateController.optimistic) {
+            // An optimistic button takes its action as done on its own word:
+            // the command runs at once and the run goes on detached, the same
+            // release the form counterpart gives the send (see --navi-send in
+            // commands.js). Only a refused press has nothing to follow.
+            if (completion.result !== false) {
+              deferredCommand();
+            }
+            return;
+          }
           runWhenActionSucceeded(completion, deferredCommand);
         };
         return {
@@ -48795,6 +48828,7 @@ const COMMAND_DEFAULT_PROPS_FACTORIES = {
  *   replace?: boolean,
  *   actionStandalone?: boolean,
  *   actionAbortable?: boolean,
+ *   optimistic?: boolean,
  *   [key: string]: any,
  * }>}
  * @param {boolean} [replace] Go where the press leads — an `href`, a
@@ -48838,6 +48872,12 @@ const COMMAND_DEFAULT_PROPS_FACTORIES = {
  *   running, which the app watches from somewhere else; never for one holding
  *   an answer the screen is the only place to read (see
  *   docs/interactions.md#the-fourth-question-whose-wait-is-it).
+ * @param {boolean} [optimistic] The action is taken as done on the button's own
+ *   word: no busy state, a second press queues behind the run, and its
+ *   `command` runs at once — the popup it sits in closes over the run, which
+ *   goes on behind. A failure then has no popup to be read in: `resetOnError`
+ *   puts the button back and the error callout is drawn on what surrounds the
+ *   closed popup (see docs/popup_open.md#the-popup-owns-its-open-state).
  * @param {boolean} [actionAbortable] The person waiting may give up on this
  *   button's action: closing the popup the run holds calls it off and goes
  *   through, instead of being refused. For a run whose answer may never come —
@@ -48877,7 +48917,7 @@ const COMMAND_DEFAULT_PROPS_FACTORIES = {
  *   (it wears it itself) and loses the shrink under the finger, which has
  *   nothing left to scale but the interactive area itself.
  */
-const Button = createComponentResolver([ButtonFirstResolver, ButtonRouteResolver, ButtonCommandPropResolver, ButtonConfirmResolver, ButtonUI]);
+const Button = /*#__PURE__*/createComponentResolver([ButtonFirstResolver, ButtonRouteResolver, ButtonCommandPropResolver, ButtonConfirmResolver, ButtonUI]);
 
 installImportMetaCssBuild(import.meta);
 const css$O = /* css */`.navi_control_swap {
@@ -52248,7 +52288,7 @@ const InputTextualFirstResolver = props => {
     ...props
   });
 };
-const InputTextual = createComponentResolver([InputTextualAsTextResolver, InputTextualFirstResolver, InputWithListResolver, InputWithSuggestionsResolver, InputTypeResolver, InputModeResolver, InputHeadlessResolver, InputTextualUI]);
+const InputTextual = /*#__PURE__*/createComponentResolver([InputTextualAsTextResolver, InputTextualFirstResolver, InputWithListResolver, InputWithSuggestionsResolver, InputTypeResolver, InputModeResolver, InputHeadlessResolver, InputTextualUI]);
 const RealInput = ({
   maxLength,
   ...domProps
@@ -65850,209 +65890,6 @@ const ListFirstResolver = props => {
     })
   });
 };
-
-/**
- * List — generic virtualized scroll container.
- * Items must use <List.Item> to participate in tracking.
- *
- * @type {import("ignore:preact").FunctionComponent<{
- *   selectable?: boolean,
- *   multiple?: boolean,
- *   deselectable?: boolean,
- *   maxLength?: number,
- *   maxLengthGuard?: number,
- *   parallelGuard?: number,
- *   standalone?: boolean,
- *   action?: (value: any) => void,
- *   uiAction?: (value: any) => void,
- *   popover?: boolean,
- *   role?: string,
- *   renderBudget?: number | string,
- *   renderBudgetSkipCheck?: boolean,
- *   virtualItemSize?: number,
- *   onListVisibleItemsChange?: (visibleItems: any[]) => void,
- *   scrolled?: "start" | "end" | number | {id: string, offset?: number},
- *   defaultScrolled?: "start" | "end" | number | {id: string, offset?: number},
- *   onScrolledChange?: (scrolled: {id: string, index: number, offset: number}) => void,
- *   scroller?: "self" | "parent" | "document" | Element | {current: Element},
- *   hoverWhileScrolling?: boolean,
- *   fallback?: import("ignore:preact").ComponentChildren,
- *   searchFallback?: import("ignore:preact").ComponentChildren,
- *   searchText?: string,
- *   searchNoMatchMode?: "remove" | "invisible_and_inert" | "muted",
- *   loading?: boolean,
- *   loadingFallback?: "skeleton" | "loader" | import("ignore:preact").ComponentChildren,
- *   loadingSkeletonCount?: number,
- *   renderSkeleton?: false | ((index: number) => import("ignore:preact").ComponentChildren),
- *   error?: boolean | import("ignore:preact").ComponentChildren,
- *   separator?: boolean | import("ignore:preact").ComponentChildren,
- *   itemTransition?: boolean,
- *   lockSize?: boolean,
- *   horizontal?: boolean,
- *   spacing?: string,
- *   columns?: string,
- *   itemColumns?: string,
- *   alignX?: string,
- *   alignY?: string,
- *   flexWrap?: boolean,
- *   expandX?: boolean,
- *   expandY?: boolean,
- *   expand?: boolean,
- *   children?: import("ignore:preact").ComponentChildren,
- *   [key: string]: any,
- * }>}
- * @param {string} [props.columns]
- *   The list's own columns: a `grid-template-columns` value the ITEMS are laid
- *   into — a sheet of icons (`repeat(auto-fill, minmax(2.5rem, 1fr))`), a row of
- *   choices (`repeat(3, minmax(0, 1fr))`). Each item takes one cell, and an item
- *   meant to take a whole line says so for itself
- *   (`style={{ gridColumn: "1 / -1" }}`). Several items to a line is a shape the
- *   list cannot virtualize — its render window and the room it holds for the
- *   rows it does not draw both count one item per line — so it is for a set of
- *   items the caller renders whole, not for a `<List.Items>` collection.
- * @param {string} [props.itemColumns]
- *   The columns inside an ITEM: a `grid-template-columns` value each item fills
- *   with its own children, a table whose cells line up down the list. Every item
- *   becomes a subgrid row spanning all the columns, so a column is as wide as
- *   the widest cell in it among the rows actually in the DOM — real column
- *   sizing that stays right as the window moves. Rows of a table, then, where
- *   `columns` above is a grid of items; the two cannot both be set.
- * @param {string} [props.alignX]
- *   Where the items sit across the track — `alignX="center"` centres a
- *   horizontal list's row of items inside a list wider than they are. Together
- *   with `alignY`, `align` and `flexWrap`, this reaches the `<ul>` holding the
- *   items rather than the frame drawn around it: the frame's only child is the
- *   scroll box, which fills it and has nothing to arrange.
- * @param {boolean} [props.flexWrap]
- *   Lets a horizontal list's items fall to the next line instead of running
- *   past the edge — a row of choices under a `maxWidth`, say. Same caveat as
- *   `columns` above: a line holding several items is not virtualizable.
- * @param {string} [props.overflow]
- *   `"visible"` lets the items paint outside the list — a check in a row's
- *   corner, a badge crossing the edge. A list clips by default, which is what
- *   its rounded corners and its scroll box need, and the two cannot both be
- *   true: asking for visible gives up the clipping, corners included.
- * @param {boolean} [props.itemTransition]
- *   Names each row, so a change the application wraps in
- *   `document.startViewTransition` is seen row by row — rows moving to their new
- *   place, an arriving row appearing where it lands — instead of the list
- *   cross-fading as a block. The rows are drawn inside the list's own picture,
- *   so one coming from outside the visible part of the list is cut at the list's
- *   edge like any other overflow. Requires nested view transition groups
- *   (Chrome/Edge 140+): elsewhere the rows are left unnamed and the change
- *   simply happens — but the browser still names the document root, so the page
- *   cross-fades as a whole unless the application says otherwise, which is its
- *   call and not the list's:
- *   ```css
- *   @supports not (view-transition-group: contain) {
- *     :root { view-transition-name: none; }
- *   }
- *   ```
- * @param {false|((index: number) => any)} [props.renderSkeleton]
- *   What a row on its way looks like — a row of the shape the real ones will
- *   have, so nothing moves when they arrive. Used for the rows a `<List.Items>`
- *   stands for and does not hold yet, and for the placeholder rows drawn while
- *   the whole list is `loading`. Defaults to a bare `<List.Item skeleton>`.
- * @param {"skeleton"|"loader"|import("ignore:preact").ComponentChildren} [props.loadingFallback="skeleton"]
- *   What to display in place of the items while `loading` — that is, while
- *   there is nothing to show at all: `"skeleton"` renders
- *   `loadingSkeletonCount` placeholder rows (look:
- *   `renderSkeleton`), `"loader"` a single centered spinner, and
- *   anything else is rendered as-is in a row of its own. A falsy value
- *   displays nothing. A list that knows how many rows it will have has no use
- *   for this — see `<List.Items count>`, whose not-yet-loaded rows are drawn
- *   as skeletons in place, one per row, virtualized like the rest.
- * @param {number} [props.loadingSkeletonCount=3]
- *   How many placeholder rows `loadingFallback="skeleton"` draws. `0` says the
- *   list is already known to be empty: the empty `fallback` shows right away
- *   rather than an empty frame, so nothing moves when the response arrives.
- * @param {"start"|"end"|number|{id: string, offset?: number}} [props.defaultScrolled="start"]
- *   Where the list opens, after which the user owns the scroll. `"end"` is a
- *   thread read backwards — the last rows are the ones to show, and the ones
- *   asked for first. A number opens on that row of the collection. `{id,
- *   offset}` — what `onScrolledChange` hands out — opens on a NAMED row,
- *   `offset` pixels below where the row would land on its own: the row is asked
- *   for by name (see the range's own `around`), then put back by MEASURING it,
- *   so it lands where it was even if rows were inserted before it, and whatever
- *   the screen it was saved on. `offset: 0` is where a `scrollIntoView()` puts
- *   it — in front of the fixed bar the scroller gives room for, below the
- *   sticky header and the group label the row lives under — so nothing of that
- *   room has to be restated as a number by whoever asks.
- * @param {"start"|"end"|number|{id: string, offset?: 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`
- *   elsewhere in navi for the same pair). When the named row turns out not to
- *   exist — a message deleted since — the list opens at `defaultScrolled`
- *   instead.
- *
- *   In every form the list holds itself there while it is still finding out
- *   how many rows there are and how tall one is, and lets go the moment the
- *   user reaches for the list.
- * @param {(scrolled: {id: string, index: number, offset: number}) => void} [props.onScrolledChange]
- *   Where the list is, as the user scrolls: the row at the top of the view and
- *   how far below the place a row lands on its own (see `defaultScrolled`) it
- *   starts. Keep it to come back to it
- *   later through `scrolled`/`defaultScrolled` — an index would not do, since
- *   rows get inserted while a list is being read.
- * @param {"self"|"parent"|"document"|Element|{current: Element}} [props.scroller="self"]
- *   Which box scrolls. `"self"` gives the list a scroll box of its own;
- *   `"parent"` makes it virtualize against the scrollable ancestor it lives in
- *   (the page, a panel) — no scroll box nested inside another one, no height
- *   to compute.
- *
- *   `"parent"` finds that ancestor by measuring: the nearest one whose content
- *   actually overflows it, the page if none does. Declaring `overflow` is not
- *   enough to be picked (a box with `overflow-x: auto` that grows with its
- *   content computes `overflow-y: auto` without ever scrolling), and the
- *   answer is taken again as the geometry moves, so an ancestor that starts to
- *   scroll once it fills up is picked up then. When that is still not the box
- *   you mean, say so: `"document"`, or the element itself (a ref works) —
- *   nothing is guessed then.
- * @param {boolean} [props.hoverWhileScrolling=false]
- *   Whether the rows still answer the pointer while the scroller they live in
- *   is moving. They do not by default: a scroll slides the rows under a
- *   motionless pointer, so the browser reports a hover on each of them, and
- *   the user asked to scroll, not to hover. The cost of taking them at face
- *   value is paid by whatever hover triggers — a highlight elsewhere in the
- *   tree, a prefetch, a map — at the worst moment, mid-scroll.
- *
- *   Pass `true` for a list whose rows must stay live under the pointer while
- *   it scrolls. The trade of the default is the mirror one: right after a
- *   scroll, the row under the pointer lights up only once the pointer moves.
- * @param {boolean} [props.deselectable]
- *   A single-select list allowed to hold nothing: the selected row, pressed
- *   again, lets go. Without it the list is a radio group — a choice, once
- *   made, moves to another row but never goes away. A `multiple` list toggles
- *   its rows already.
- * @param {number} [props.maxLength]
- *   How many items a `selectable multiple` list accepts — the same word, and
- *   the same behaviour, as `maxLength` on a text field: a rule the list is
- *   judged against, not a wall. A longer selection is allowed to exist and is
- *   reported as invalid, which is what lets a value coming from elsewhere (an
- *   API, a URL) be shown and then corrected.
- * @param {number} [props.maxLengthGuard]
- *   The same limit, enforced as the selection is made: while the list holds as
- *   many items as it accepts, the ones not selected go read-only — still
- *   pointable, focusable and pressable, answering `"[max] max."` instead of
- *   taking — and `uiAction` is not called. The selected ones stay takeable
- *   back, so a selection that arrived too long can always be brought back
- *   under the limit. Implies `maxLength` for validity.
- * @param {number} [props.parallelGuard=4]
- *   How many runs the rows may have in flight at once, for a list whose rows
- *   carry their own `action` (a button per row). While that many are out, every
- *   row that is not running goes read-only and says how many it is waiting on;
- *   the next press is possible again as soon as one comes back. `Infinity`
- *   lifts it. Counts runs, not values — `maxLengthGuard` above is the one that
- *   says how many things the selection may hold.
- * @param {boolean} [props.standalone]
- *   This list answers for itself: it does not register with the control group
- *   or picker around it, so its selection stays out of that value and nothing
- *   coming down — a distributed value, a reset — reaches it. What a popup whose
- *   one answer is spread over several lists says, so that none of them is taken
- *   for the answer itself.
- */
-const List = createComponentResolver([ListFirstResolver, ListSelectableResolver, ListUI]);
 const ListContent = ({
   role,
   fallback,
@@ -68318,14 +68155,13 @@ const LIST_ITEM_STYLE_CSS_VARS = {
  *   search-driven scroll-to-top-match behavior. `matchRanges` are [start, end]
  *   ranges highlighted via the CSS Highlight API.
  */
-const ListItem = createComponentResolver([ListItemFirstResolver, ListItemRowResolver, ListItemSkeletonResolver, ListItemSelectableResolver, ListItemHeaderOrFooterResolver, ListItemPresentationResolver, ListItemUI],
+const ListItem = /*#__PURE__*/createComponentResolver([ListItemFirstResolver, ListItemRowResolver, ListItemSkeletonResolver, ListItemSelectableResolver, ListItemHeaderOrFooterResolver, ListItemPresentationResolver, ListItemUI],
 // Rendered by the hundred, and almost always with the same primitive props:
 // a selection change re-renders the list, and every row but two has nothing
 // to change.
 {
   pure: true
 });
-List.Item = ListItem;
 
 // Everything the list knows about the collection while its children are being
 // rendered: how many rows it has in total, which of them are actually held, and
@@ -69085,7 +68921,6 @@ const ListItems = ({
   }
   return rows;
 };
-List.Items = ListItems;
 
 // What is drawn where rows were asked for and never came: the sentence and the
 // way out, in the row itself — the rest of the list is fine, so replacing all
@@ -69695,6 +69530,219 @@ const resolveSeparatorVnode = (separator, gapIndex) => {
   }
   return separator;
 };
+const ListResolved = /*#__PURE__*/createComponentResolver([ListFirstResolver, ListSelectableResolver, ListUI]);
+
+// Declared last because Item and Items are consts defined above, and they are
+// folded into the declaration rather than written onto List afterwards
+// (`List.Item = ListItem`): List is what createComponentResolver returns, an
+// object a bundler cannot see through, so a property assigned to it later is a
+// side effect it has to keep — and with it List, its rows and everything they
+// import, in a bundle that never renders a list. See Picker for the same shape.
+/**
+ * List — generic virtualized scroll container.
+ * Items must use <List.Item> to participate in tracking.
+ *
+ * @type {import("ignore:preact").FunctionComponent<{
+ *   selectable?: boolean,
+ *   multiple?: boolean,
+ *   deselectable?: boolean,
+ *   maxLength?: number,
+ *   maxLengthGuard?: number,
+ *   parallelGuard?: number,
+ *   standalone?: boolean,
+ *   action?: (value: any) => void,
+ *   uiAction?: (value: any) => void,
+ *   popover?: boolean,
+ *   role?: string,
+ *   renderBudget?: number | string,
+ *   renderBudgetSkipCheck?: boolean,
+ *   virtualItemSize?: number,
+ *   onListVisibleItemsChange?: (visibleItems: any[]) => void,
+ *   scrolled?: "start" | "end" | number | {id: string, offset?: number},
+ *   defaultScrolled?: "start" | "end" | number | {id: string, offset?: number},
+ *   onScrolledChange?: (scrolled: {id: string, index: number, offset: number}) => void,
+ *   scroller?: "self" | "parent" | "document" | Element | {current: Element},
+ *   hoverWhileScrolling?: boolean,
+ *   fallback?: import("ignore:preact").ComponentChildren,
+ *   searchFallback?: import("ignore:preact").ComponentChildren,
+ *   searchText?: string,
+ *   searchNoMatchMode?: "remove" | "invisible_and_inert" | "muted",
+ *   loading?: boolean,
+ *   loadingFallback?: "skeleton" | "loader" | import("ignore:preact").ComponentChildren,
+ *   loadingSkeletonCount?: number,
+ *   renderSkeleton?: false | ((index: number) => import("ignore:preact").ComponentChildren),
+ *   error?: boolean | import("ignore:preact").ComponentChildren,
+ *   separator?: boolean | import("ignore:preact").ComponentChildren,
+ *   itemTransition?: boolean,
+ *   lockSize?: boolean,
+ *   horizontal?: boolean,
+ *   spacing?: string,
+ *   columns?: string,
+ *   itemColumns?: string,
+ *   alignX?: string,
+ *   alignY?: string,
+ *   flexWrap?: boolean,
+ *   expandX?: boolean,
+ *   expandY?: boolean,
+ *   expand?: boolean,
+ *   children?: import("ignore:preact").ComponentChildren,
+ *   [key: string]: any,
+ * }>}
+ * @param {string} [props.columns]
+ *   The list's own columns: a `grid-template-columns` value the ITEMS are laid
+ *   into — a sheet of icons (`repeat(auto-fill, minmax(2.5rem, 1fr))`), a row of
+ *   choices (`repeat(3, minmax(0, 1fr))`). Each item takes one cell, and an item
+ *   meant to take a whole line says so for itself
+ *   (`style={{ gridColumn: "1 / -1" }}`). Several items to a line is a shape the
+ *   list cannot virtualize — its render window and the room it holds for the
+ *   rows it does not draw both count one item per line — so it is for a set of
+ *   items the caller renders whole, not for a `<List.Items>` collection.
+ * @param {string} [props.itemColumns]
+ *   The columns inside an ITEM: a `grid-template-columns` value each item fills
+ *   with its own children, a table whose cells line up down the list. Every item
+ *   becomes a subgrid row spanning all the columns, so a column is as wide as
+ *   the widest cell in it among the rows actually in the DOM — real column
+ *   sizing that stays right as the window moves. Rows of a table, then, where
+ *   `columns` above is a grid of items; the two cannot both be set.
+ * @param {string} [props.alignX]
+ *   Where the items sit across the track — `alignX="center"` centres a
+ *   horizontal list's row of items inside a list wider than they are. Together
+ *   with `alignY`, `align` and `flexWrap`, this reaches the `<ul>` holding the
+ *   items rather than the frame drawn around it: the frame's only child is the
+ *   scroll box, which fills it and has nothing to arrange.
+ * @param {boolean} [props.flexWrap]
+ *   Lets a horizontal list's items fall to the next line instead of running
+ *   past the edge — a row of choices under a `maxWidth`, say. Same caveat as
+ *   `columns` above: a line holding several items is not virtualizable.
+ * @param {string} [props.overflow]
+ *   `"visible"` lets the items paint outside the list — a check in a row's
+ *   corner, a badge crossing the edge. A list clips by default, which is what
+ *   its rounded corners and its scroll box need, and the two cannot both be
+ *   true: asking for visible gives up the clipping, corners included.
+ * @param {boolean} [props.itemTransition]
+ *   Names each row, so a change the application wraps in
+ *   `document.startViewTransition` is seen row by row — rows moving to their new
+ *   place, an arriving row appearing where it lands — instead of the list
+ *   cross-fading as a block. The rows are drawn inside the list's own picture,
+ *   so one coming from outside the visible part of the list is cut at the list's
+ *   edge like any other overflow. Requires nested view transition groups
+ *   (Chrome/Edge 140+): elsewhere the rows are left unnamed and the change
+ *   simply happens — but the browser still names the document root, so the page
+ *   cross-fades as a whole unless the application says otherwise, which is its
+ *   call and not the list's:
+ *   ```css
+ *   @supports not (view-transition-group: contain) {
+ *     :root { view-transition-name: none; }
+ *   }
+ *   ```
+ * @param {false|((index: number) => any)} [props.renderSkeleton]
+ *   What a row on its way looks like — a row of the shape the real ones will
+ *   have, so nothing moves when they arrive. Used for the rows a `<List.Items>`
+ *   stands for and does not hold yet, and for the placeholder rows drawn while
+ *   the whole list is `loading`. Defaults to a bare `<List.Item skeleton>`.
+ * @param {"skeleton"|"loader"|import("ignore:preact").ComponentChildren} [props.loadingFallback="skeleton"]
+ *   What to display in place of the items while `loading` — that is, while
+ *   there is nothing to show at all: `"skeleton"` renders
+ *   `loadingSkeletonCount` placeholder rows (look:
+ *   `renderSkeleton`), `"loader"` a single centered spinner, and
+ *   anything else is rendered as-is in a row of its own. A falsy value
+ *   displays nothing. A list that knows how many rows it will have has no use
+ *   for this — see `<List.Items count>`, whose not-yet-loaded rows are drawn
+ *   as skeletons in place, one per row, virtualized like the rest.
+ * @param {number} [props.loadingSkeletonCount=3]
+ *   How many placeholder rows `loadingFallback="skeleton"` draws. `0` says the
+ *   list is already known to be empty: the empty `fallback` shows right away
+ *   rather than an empty frame, so nothing moves when the response arrives.
+ * @param {"start"|"end"|number|{id: string, offset?: number}} [props.defaultScrolled="start"]
+ *   Where the list opens, after which the user owns the scroll. `"end"` is a
+ *   thread read backwards — the last rows are the ones to show, and the ones
+ *   asked for first. A number opens on that row of the collection. `{id,
+ *   offset}` — what `onScrolledChange` hands out — opens on a NAMED row,
+ *   `offset` pixels below where the row would land on its own: the row is asked
+ *   for by name (see the range's own `around`), then put back by MEASURING it,
+ *   so it lands where it was even if rows were inserted before it, and whatever
+ *   the screen it was saved on. `offset: 0` is where a `scrollIntoView()` puts
+ *   it — in front of the fixed bar the scroller gives room for, below the
+ *   sticky header and the group label the row lives under — so nothing of that
+ *   room has to be restated as a number by whoever asks.
+ * @param {"start"|"end"|number|{id: string, offset?: 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`
+ *   elsewhere in navi for the same pair). When the named row turns out not to
+ *   exist — a message deleted since — the list opens at `defaultScrolled`
+ *   instead.
+ *
+ *   In every form the list holds itself there while it is still finding out
+ *   how many rows there are and how tall one is, and lets go the moment the
+ *   user reaches for the list.
+ * @param {(scrolled: {id: string, index: number, offset: number}) => void} [props.onScrolledChange]
+ *   Where the list is, as the user scrolls: the row at the top of the view and
+ *   how far below the place a row lands on its own (see `defaultScrolled`) it
+ *   starts. Keep it to come back to it
+ *   later through `scrolled`/`defaultScrolled` — an index would not do, since
+ *   rows get inserted while a list is being read.
+ * @param {"self"|"parent"|"document"|Element|{current: Element}} [props.scroller="self"]
+ *   Which box scrolls. `"self"` gives the list a scroll box of its own;
+ *   `"parent"` makes it virtualize against the scrollable ancestor it lives in
+ *   (the page, a panel) — no scroll box nested inside another one, no height
+ *   to compute.
+ *
+ *   `"parent"` finds that ancestor by measuring: the nearest one whose content
+ *   actually overflows it, the page if none does. Declaring `overflow` is not
+ *   enough to be picked (a box with `overflow-x: auto` that grows with its
+ *   content computes `overflow-y: auto` without ever scrolling), and the
+ *   answer is taken again as the geometry moves, so an ancestor that starts to
+ *   scroll once it fills up is picked up then. When that is still not the box
+ *   you mean, say so: `"document"`, or the element itself (a ref works) —
+ *   nothing is guessed then.
+ * @param {boolean} [props.hoverWhileScrolling=false]
+ *   Whether the rows still answer the pointer while the scroller they live in
+ *   is moving. They do not by default: a scroll slides the rows under a
+ *   motionless pointer, so the browser reports a hover on each of them, and
+ *   the user asked to scroll, not to hover. The cost of taking them at face
+ *   value is paid by whatever hover triggers — a highlight elsewhere in the
+ *   tree, a prefetch, a map — at the worst moment, mid-scroll.
+ *
+ *   Pass `true` for a list whose rows must stay live under the pointer while
+ *   it scrolls. The trade of the default is the mirror one: right after a
+ *   scroll, the row under the pointer lights up only once the pointer moves.
+ * @param {boolean} [props.deselectable]
+ *   A single-select list allowed to hold nothing: the selected row, pressed
+ *   again, lets go. Without it the list is a radio group — a choice, once
+ *   made, moves to another row but never goes away. A `multiple` list toggles
+ *   its rows already.
+ * @param {number} [props.maxLength]
+ *   How many items a `selectable multiple` list accepts — the same word, and
+ *   the same behaviour, as `maxLength` on a text field: a rule the list is
+ *   judged against, not a wall. A longer selection is allowed to exist and is
+ *   reported as invalid, which is what lets a value coming from elsewhere (an
+ *   API, a URL) be shown and then corrected.
+ * @param {number} [props.maxLengthGuard]
+ *   The same limit, enforced as the selection is made: while the list holds as
+ *   many items as it accepts, the ones not selected go read-only — still
+ *   pointable, focusable and pressable, answering `"[max] max."` instead of
+ *   taking — and `uiAction` is not called. The selected ones stay takeable
+ *   back, so a selection that arrived too long can always be brought back
+ *   under the limit. Implies `maxLength` for validity.
+ * @param {number} [props.parallelGuard=4]
+ *   How many runs the rows may have in flight at once, for a list whose rows
+ *   carry their own `action` (a button per row). While that many are out, every
+ *   row that is not running goes read-only and says how many it is waiting on;
+ *   the next press is possible again as soon as one comes back. `Infinity`
+ *   lifts it. Counts runs, not values — `maxLengthGuard` above is the one that
+ *   says how many things the selection may hold.
+ * @param {boolean} [props.standalone]
+ *   This list answers for itself: it does not register with the control group
+ *   or picker around it, so its selection stays out of that value and nothing
+ *   coming down — a distributed value, a reset — reaches it. What a popup whose
+ *   one answer is spread over several lists says, so that none of them is taken
+ *   for the answer itself.
+ */
+const List = /*#__PURE__*/Object.assign(ListResolved, {
+  Item: ListItem,
+  Items: ListItems
+});
 
 const PickerNaviTime = props => {
   const Next = useNextResolver();
@@ -70627,7 +70675,7 @@ const PickerObject = props => {
     "navi-state-shape": "object"
   });
 };
-const PickerObjectUI = asPickerOwnUI(() => {
+const PickerObjectUI = /*#__PURE__*/asPickerOwnUI(() => {
   const {
     value,
     placeholder
@@ -70662,7 +70710,7 @@ const PickerArray = props => {
     "navi-state-shape": "array"
   });
 };
-const PickerArrayUI = asPickerOwnUI(() => {
+const PickerArrayUI = /*#__PURE__*/asPickerOwnUI(() => {
   const {
     value,
     placeholder,
@@ -70745,7 +70793,7 @@ const PickerColor = props => {
     ...props
   });
 };
-const PickerColorUI = asPickerOwnUI(() => {
+const PickerColorUI = /*#__PURE__*/asPickerOwnUI(() => {
   const {
     value,
     placeholder
@@ -70769,7 +70817,7 @@ const PickerDate = props => {
     type: "date"
   });
 };
-const PickerDateUI = asPickerOwnUI(props => {
+const PickerDateUI = /*#__PURE__*/asPickerOwnUI(props => {
   const {
     value,
     placeholder
@@ -70801,7 +70849,7 @@ const PickerMonth = props => {
     type: "month"
   });
 };
-const PickerMonthUI = asPickerOwnUI(props => {
+const PickerMonthUI = /*#__PURE__*/asPickerOwnUI(props => {
   const {
     value,
     placeholder
@@ -70832,7 +70880,7 @@ const PickerWeek = props => {
     type: "week"
   });
 };
-const PickerWeekUI = asPickerOwnUI(props => {
+const PickerWeekUI = /*#__PURE__*/asPickerOwnUI(props => {
   const {
     value,
     placeholder
@@ -70863,7 +70911,7 @@ const PickerTime = props => {
     type: "time"
   });
 };
-const PickerTimeUI = asPickerOwnUI(props => {
+const PickerTimeUI = /*#__PURE__*/asPickerOwnUI(props => {
   const {
     value,
     placeholder
@@ -70894,7 +70942,7 @@ const PickerDuration = props => {
     "navi-input-type": "duration"
   });
 };
-const PickerDurationUI = asPickerOwnUI(props => {
+const PickerDurationUI = /*#__PURE__*/asPickerOwnUI(props => {
   const {
     value,
     placeholder
@@ -70924,7 +70972,7 @@ const PickerDatetime = props => {
     type: "datetime-local"
   });
 };
-const PickerDatetimeUI = asPickerOwnUI(props => {
+const PickerDatetimeUI = /*#__PURE__*/asPickerOwnUI(props => {
   const {
     value,
     placeholder
@@ -70953,7 +71001,7 @@ const PickerFile = props => {
     ...props
   });
 };
-const PickerFileUI = asPickerOwnUI(() => {
+const PickerFileUI = /*#__PURE__*/asPickerOwnUI(() => {
   const {
     value,
     placeholder
@@ -72509,26 +72557,37 @@ const warnOnUnknownPickerType = props => {
   pickerTypeWarnedSet.add(type);
   console.warn(`[navi] <Picker type="${type}"> — "${type}" is not a picker type. ` + `The picker holds a single text value instead, so an object given to it is written as "[object Object]". ` + `Types are: date, month, week, time, datetime, duration, color, file, text, array, object, confirm — ` + `"object" being the one for a popup holding several named controls.`);
 };
-const Picker = createComponentResolver([PickerFirstResolver, PickerPresetResolver, PickerConfirmResolver, PickerCustomResolver, PickerTypeResolver, PickerButton]);
-Picker.Chip = PickerChip;
-Picker.Clear = PickerClear;
-Picker.UI = PickerDefaultUI;
-Picker.UI.Date = PickerDateUI;
-Picker.UI.Time = PickerTimeUI;
-Picker.UI.Duration = PickerDurationUI;
-Picker.UI.Week = PickerWeekUI;
-Picker.UI.Datetime = PickerDatetimeUI;
-Picker.UI.File = PickerFileUI;
-Picker.UI.Color = PickerColorUI;
-Picker.UI.Object = PickerObjectUI;
-Picker.UI.Multiple = PickerArrayUI;
-Picker.UI.PencilSvg = PencilSvg;
-Picker.UI.ChevronDownSvg = ChevronDownSvg$1;
-Picker.UI.ClockSvg = ClockSvg;
-Picker.UI.DurationSvg = DurationSvg;
-Picker.UI.CalendarSvg = CalendarSvg;
-Picker.UI.FileSvg = FileSvg;
-Picker.UI.ColorSvg = ColorSvg;
+const PickerResolved = /*#__PURE__*/createComponentResolver([PickerFirstResolver, PickerPresetResolver, PickerConfirmResolver, PickerCustomResolver, PickerTypeResolver, PickerButton]);
+const PickerUI = /*#__PURE__*/Object.assign(PickerDefaultUI, {
+  Date: PickerDateUI,
+  Time: PickerTimeUI,
+  Duration: PickerDurationUI,
+  Week: PickerWeekUI,
+  Datetime: PickerDatetimeUI,
+  File: PickerFileUI,
+  Color: PickerColorUI,
+  Object: PickerObjectUI,
+  Multiple: PickerArrayUI,
+  PencilSvg,
+  ChevronDownSvg: ChevronDownSvg$1,
+  ClockSvg,
+  DurationSvg,
+  CalendarSvg,
+  FileSvg,
+  ColorSvg
+});
+
+// Assembled in pure expressions rather than written onto Picker afterwards
+// (`Picker.Chip = PickerChip`): what createComponentResolver returns is an object
+// a bundler cannot see through, so a property assigned to it later is a side
+// effect it has to keep — and with it Picker, every UI and everything they
+// import, in a bundle that never renders a picker. The annotations say these
+// calls only create and return; an unused Picker then disappears whole.
+const Picker = /*#__PURE__*/Object.assign(PickerResolved, {
+  Chip: PickerChip,
+  Clear: PickerClear,
+  UI: PickerUI
+});
 
 installImportMetaCssBuild(import.meta);
 const css$s = /* css */`@layer navi {
@@ -78508,7 +78567,7 @@ const useTableDragContextValue = ({
     };
   }, [grabTarget, canChangeColumnOrder]);
 };
-const TableDragCloneContainer = forwardRef((props, ref) => {
+const TableDragCloneContainer = /*#__PURE__*/forwardRef((props, ref) => {
   import.meta.css = [css$k, "@jsenv/navi/src/control/table/drag/table_drag.jsx"];
   const {
     tableId
@@ -78519,7 +78578,7 @@ const TableDragCloneContainer = forwardRef((props, ref) => {
     "data-overlay-for": tableId
   });
 });
-const TableColumnDropPreview = forwardRef((props, ref) => {
+const TableColumnDropPreview = /*#__PURE__*/forwardRef((props, ref) => {
   return jsxs("div", {
     ref: ref,
     className: "navi_table_column_drop_preview",
@@ -80615,7 +80674,7 @@ const css$f = /* css */`.navi_table_ui {
   overflow: hidden;
 }
 `;
-const TableUI = forwardRef((props, ref) => {
+const TableUI = /*#__PURE__*/forwardRef((props, ref) => {
   import.meta.css = [css$f, "@jsenv/navi/src/control/table/table_ui.jsx"];
   const {
     tableRef,