@fusion.dev/helix-headless 0.160.0 → 0.161.0

package/custom-elements.json

@@ -15622,7 +15622,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "A board of cards and connectors, drawn by Helix. On a canvas every position\nis data that someone placed, so drawing is arithmetic over rectangles with no\nlayout to compute. `Map` takes a slotted map, because another renderer draws\nits tiles.\n\nThe format is [JSON Canvas](https://jsoncanvas.org), an open format. Each\nnode has an `x`, `y`, `width`, `height`, and a type. Each edge names the two\nnodes it joins and the sides it leaves and arrives on. A card belongs to a\ngroup when it sits inside the group's bounds.\n\nThe cards are text in the DOM, so a screen reader can read them. The family\nadds a reading order and states each card's connections as text. `order` sets\nthe reading order:\n- `spatial` bands the cards into rows.\n- `edges` follows the arrows, starting from the cards that nothing points to.\n\n**Cards move by default.** The board writes the new `x` and `y` onto the\ncard, the way an input writes its own value, and dispatches two events:\n- `helix-before-move` for every step. Cancel it to hold the positions in your\n  own state and apply them yourself.\n- `helix-move` once the move is finished.\n\nA resize dispatches the same pair with a size. Set `readonly` on the board to\nkeep every card in place, such as on a published board. Set `readonly` on one\ncard or connection to keep only that one in place.\n\nSet `snap` to a length in the document's units, such as `32`, and a card\nthat is moved or resized lands on a multiple of it. Carrying a card, a\ncorner, a connection, or the selection box near the edge of the board moves\nthe board under it, so a card can be taken to a place off screen in one\ndrag. A connection let go within 20 pixels of a card arrives at it. A\ndouble click on the empty board zooms in about that point, and Shift with a\ndouble click zooms out.\n\nKeyboard behavior:\n- One card holds the board's tab stop.\n- The arrow keys move through the cards in reading order. The card you land\n  on scrolls into view, and its connections are announced with it.\n- The card you land on is selected. Control or Command with an arrow key,\n  Home, or End moves without changing the selection, and Space adds the card\n  to the selection or takes it out, so you can select cards that are not\n  next to each other.\n- Shift with an arrow key moves the card: by 16 units, or to the next\n  multiple of `snap` where it is set. Alt with an arrow key resizes it from\n  its bottom right corner the same way.\n- The connections leaving a card are stops of their own, straight after it.\n  Enter on one moves to the card it arrives at.\n- What a key changes that a reader cannot see is said: where a card moved\n  to, its new size, how many cards are selected, and the zoom. A selected\n  card or connection says so when a reader arrives on it.\n\nEvery drag also works with clicks, as WCAG 2.5.7 requires for a pointer that\ncannot hold a button down. Click a selected card's move handle, a corner, a\ncard's connection point, or the end of a selected connection to pick it up.\nIt follows the pointer with no button held, and the next click puts it down\nwhere a drag would have. On touch, the next tap sets where it lands. Escape,\nor a press outside the board, puts it back. So a finger connects two cards\nwith three taps: the card, one of its points, and the card to connect to.\n\nConnecting and removing dispatch requests, and your code applies them:\n- Drawing from a card's handle to another card, or pressing C on one card and\n  Enter on another, dispatches `helix-connect`.\n- Delete on a card or a connection dispatches `helix-remove`. The event names\n  every connection that removing the card would leave without an end.\n\nOnce your page removes what Delete asked for, focus moves to the next stop,\nto the one before where it was the last, and to the board where none is\nleft. A focused card your page removes for its own reasons hands focus on\nthe same way, unless the reader has already moved focus somewhere else.\n\nThe board applies a move itself, because the card already exists. A\nconnection is a new element, and React discards an element the board adds to\nits markup on the next render, so you write the connection.\n\nCards and connections are `helix-canvas-node` and `helix-canvas-edge`\nelements, so they are in the served markup whichever renderer wrote them. The\nlibrary fetches nothing, and an array passed to an element is missing from\nthe first paint of a server-rendered React page. `fromJsonCanvas` turns a\nJSON Canvas document into their props, and `toJsonCanvas()` writes a board\nback out.",
+          "description": "A board of cards and connectors, drawn by Helix. On a canvas every position\nis data that someone placed, so drawing is arithmetic over rectangles with no\nlayout to compute. `Map` takes a slotted map, because another renderer draws\nits tiles.\n\nThe format is [JSON Canvas](https://jsoncanvas.org), an open format. Each\nnode has an `x`, `y`, `width`, `height`, and a type. Each edge names the two\nnodes it joins and the sides it leaves and arrives on. A card belongs to a\ngroup when it sits inside the group's bounds.\n\nThe cards are text in the DOM, so a screen reader can read them. The family\nadds a reading order and states each card's connections as text. `order` sets\nthe reading order:\n- `spatial` bands the cards into rows.\n- `edges` follows the arrows, starting from the cards that nothing points to.\n\n**Cards move by default.** The board writes the new `x` and `y` onto the\ncard, the way an input writes its own value, and dispatches two events:\n- `helix-before-move` for every step. Cancel it to hold the positions in your\n  own state and apply them yourself.\n- `helix-move` once the move is finished.\n\nA resize dispatches the same pair with a size. Set `readonly` on the board to\nkeep every card in place, such as on a published board. Set `readonly` on one\ncard or connection to keep only that one in place.\n\nSet `snap` to a length in the document's units, such as `32`, and a card\nthat is moved or resized lands on a multiple of it. Carrying a card, a\ncorner, a connection, or the selection box near the edge of the board moves\nthe board under it, so a card can be taken to a place off screen in one\ndrag. A connection let go within 20 pixels of a card arrives at it. A\ndouble click on the empty board zooms in about that point, and Shift with a\ndouble click zooms out.\n\nKeyboard behavior:\n- One card holds the board's tab stop.\n- The arrow keys move through the cards in reading order. The card you land\n  on scrolls into view, and its connections are announced with it.\n- The card you land on is selected. Control or Command with an arrow key,\n  Home, or End moves without changing the selection, and Space adds the card\n  to the selection or takes it out, so you can select cards that are not\n  next to each other.\n- Shift with an arrow key moves the card: by 16 units, or to the next\n  multiple of `snap` where it is set. Alt with an arrow key resizes it from\n  its bottom right corner the same way.\n- The connections leaving a card are stops of their own, straight after it.\n  Enter on one moves to the card it arrives at.\n- What a key changes that a reader cannot see is said: where a card moved\n  to, its new size, how many cards are selected, and the zoom. A selected\n  card or connection says so when a reader arrives on it.\n- Control or Command with C copies the selected cards, and the connections\n  between them, as a JSON Canvas document in text, which another board or\n  an app that reads the format takes. A paste is your page's: listen for\n  `paste` on the board, read the text with `fromJsonCanvas`, and add the\n  cards it holds.\n- Control or Command with Z undoes the last move or resize the board made,\n  and with Shift, or Control with Y, makes it again. `undo()` and `redo()`\n  do the same from a script. Each asks with `helix-before-move` and tells\n  with `helix-move`, as a move does, so a board that holds its positions in\n  your state is undone through your state.\n\nEvery drag also works with clicks, as WCAG 2.5.7 requires for a pointer that\ncannot hold a button down. Click a selected card's move handle, a corner, a\ncard's connection point, or the end of a selected connection to pick it up.\nIt follows the pointer with no button held, and the next click puts it down\nwhere a drag would have. On touch, the next tap sets where it lands. Escape,\nor a press outside the board, puts it back. So a finger connects two cards\nwith three taps: the card, one of its points, and the card to connect to.\n\nConnecting and removing dispatch requests, and your code applies them:\n- Drawing from a card's handle to another card, or pressing C on one card and\n  Enter on another, dispatches `helix-connect`.\n- Delete on a card or a connection dispatches `helix-remove`. The event names\n  every connection that removing the card would leave without an end.\n\nOnce your page removes what Delete asked for, focus moves to the next stop,\nto the one before where it was the last, and to the board where none is\nleft. A focused card your page removes for its own reasons hands focus on\nthe same way, unless the reader has already moved focus somewhere else.\n\nThe board applies a move itself, because the card already exists. A\nconnection is a new element, and React discards an element the board adds to\nits markup on the next render, so you write the connection.\n\nCards and connections are `helix-canvas-node` and `helix-canvas-edge`\nelements, so they are in the served markup whichever renderer wrote them. The\nlibrary fetches nothing, and an array passed to an element is missing from\nthe first paint of a server-rendered React page. `fromJsonCanvas` turns a\nJSON Canvas document into their props, and `toJsonCanvas()` writes a board\nback out.",
           "name": "HelixHeadlessCanvas",
           "cssProperties": [
             {
@@ -15898,6 +15898,19 @@
                 "module": "src/mixins/mixin-viewport/mixin-viewport.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "copiedLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {# card copied} other {# cards copied}}'",
+              "description": "What screen readers hear after a copy, with `{count}` for the cards copied.",
+              "attribute": "copied-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "fallbackLabel",
@@ -16017,6 +16030,19 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "redoneLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Move made again'",
+              "description": "What screen readers hear after a move or a resize is made again.",
+              "attribute": "redone-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "resizedLabel",
@@ -16088,15 +16114,6 @@
               "description": "Snaps the cards a reader moves or resizes to a multiple of this many of the\ndocument's units, such as `32` to land on the lines `grid` draws.\n\n**A drag lets go on the nearest line and a key goes to the next one.**\nShift with an arrow moves a card to the next line that way, rather than\nby its step of 16, and Alt with an arrow moves its bottom right corner\nthe same way. A group moves with what it carries, so a card inside one\nkeeps its place in it. Absent, cards land where they are let go.",
               "attribute": "snap"
             },
-            {
-              "kind": "field",
-              "name": "editing",
-              "type": {
-                "text": "{ target: 'edge' | 'group'; key: string; was: string } | undefined"
-              },
-              "privacy": "private",
-              "description": "A label being edited in place: whose, and what it said before."
-            },
             {
               "kind": "field",
               "name": "stoppedLabel",
@@ -16110,6 +16127,15 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "editing",
+              "type": {
+                "text": "{ target: 'edge' | 'group'; key: string; was: string } | undefined"
+              },
+              "privacy": "private",
+              "description": "A label being edited in place: whose, and what it said before."
+            },
             {
               "kind": "field",
               "name": "toneLabels",
@@ -16137,6 +16163,19 @@
                 "module": "src/mixins/mixin-viewport/mixin-viewport.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "undoneLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Move undone'",
+              "description": "What screen readers hear after a move or a resize is undone.",
+              "attribute": "undone-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "usingLabel",
@@ -17416,6 +17455,141 @@
               ],
               "description": "Moves cards, having asked first.\n\n**The same contract as `open` on a dialog.** The request goes out before\nanything moves; refused, nothing does, because the consumer is holding the\npositions and will render them. Unrefused, the board writes them onto the\ncards, which is the uncontrolled board a consumer gets by doing nothing.\nReturns whether it applied, so a caller knows whether to report a finish."
             },
+            {
+              "kind": "field",
+              "name": "undoable",
+              "type": {
+                "text": "Array<{ after: MoveDetail; before: MoveDetail }>"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "The moves and resizes the board made, oldest first, each as where its\ncards stood before and after, for `undo` to take back. At most 100."
+            },
+            {
+              "kind": "field",
+              "name": "redoable",
+              "type": {
+                "text": "Array<{ after: MoveDetail; before: MoveDetail }>"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "The moves undone, most recent last, for `redo` to make again."
+            },
+            {
+              "kind": "field",
+              "name": "moving",
+              "type": {
+                "text": "Map<string, { height: number; width: number; x: number; y: number }> | undefined"
+              },
+              "privacy": "private",
+              "description": "Where the cards of the gesture in progress stood before its first step."
+            },
+            {
+              "kind": "field",
+              "name": "replaying",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether a move is an undo or a redo, which history does not record again."
+            },
+            {
+              "kind": "method",
+              "name": "finishMove",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "detail",
+                  "type": {
+                    "text": "MoveDetail"
+                  }
+                }
+              ],
+              "description": "Says a move is finished, and keeps it for `undo`: where its cards stood\nbefore the gesture, and where they stand now."
+            },
+            {
+              "kind": "method",
+              "name": "undo",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Puts the cards of the last move or resize back where they stood, asking\nwith `helix-before-move` first. Returns whether anything moved: false\nwith nothing to undo, or when the request was refused.",
+              "type": {
+                "text": "undo() => boolean"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "redo",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Makes the last move or resize `undo` took back again, asking with\n`helix-before-move` first. Returns whether anything moved.",
+              "type": {
+                "text": "redo() => boolean"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "replay",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "from",
+                  "type": {
+                    "text": "Array<{ after: MoveDetail; before: MoveDetail }>"
+                  }
+                },
+                {
+                  "name": "to",
+                  "type": {
+                    "text": "Array<{ after: MoveDetail; before: MoveDetail }>"
+                  }
+                },
+                {
+                  "name": "side",
+                  "type": {
+                    "text": "'after' | 'before'"
+                  }
+                },
+                {
+                  "name": "words",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Moves the cards of the last entry of `from` to its `side`, and files it in `to`."
+            },
+            {
+              "kind": "field",
+              "name": "handleCopy",
+              "privacy": "private",
+              "readonly": true,
+              "description": "A copy on the board with cards selected writes them, and the connections\nbetween them, as a JSON Canvas document in text. Not from a field a card\nholds, nor over text a reader selected, which are the platform's to copy."
+            },
+            {
+              "kind": "field",
+              "name": "handleHistoryKey",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Control or Command with Z undoes, and with Shift, or Control with Y,\nredoes, from anywhere on the board but a field a card holds, where the\nkeys are the field's."
+            },
             {
               "kind": "field",
               "name": "edgePan",
@@ -19396,6 +19570,15 @@
               "description": "The name of the group of controls, read by screen readers, which names\nwhat the controls drive rather than the mechanism.",
               "fieldName": "controlsLabel"
             },
+            {
+              "name": "copied-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {# card copied} other {# cards copied}}'",
+              "description": "What screen readers hear after a copy, with `{count}` for the cards copied.",
+              "fieldName": "copiedLabel"
+            },
             {
               "name": "fallback-label",
               "type": {
@@ -19484,6 +19667,15 @@
               "description": "The text announced when a connection's end is picked up, with `{from}` and\n`{to}`.",
               "fieldName": "reconnectingLabel"
             },
+            {
+              "name": "redone-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Move made again'",
+              "description": "What screen readers hear after a move or a resize is made again.",
+              "fieldName": "redoneLabel"
+            },
             {
               "name": "resized-label",
               "type": {
@@ -19564,6 +19756,15 @@
               "description": "The hint shown when one finger swipes over the board with `gestures=\"cooperative\"`.",
               "fieldName": "twoFingerHintLabel"
             },
+            {
+              "name": "undone-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Move undone'",
+              "description": "What screen readers hear after a move or a resize is undone.",
+              "fieldName": "undoneLabel"
+            },
             {
               "name": "using-label",
               "type": {
@@ -24625,7 +24826,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Chat has no positioning, no backdrop, and no trigger, so you can put it in\nany container, such as a page, a sidebar, a modal, or a floating panel.\n\nThe transcript stays pinned to the bottom, including while a streamed answer\ngrows, until the user scrolls more than `threshold` away from it.\n\nWith `history` set to `more`, reaching the top fires `helix-history`. Set\n`loading` while you fetch, then prepend the older turns. The turn the user\nwas reading stays in place on screen.\n\nThe log is `aria-live=\"off\"`. A separate status region announces each new\nturn once, when it has finished arriving. It skips the user's own turns\nunless they failed to send, turns loaded as history, and the turns already\nthere when the transcript opened. A turn is said with its author first, such\nas \"Ada: It ships today\" (`arrival-label`), where its author can be named.\n\nPass the turns as children or as `turns` data. Do not use both. Children\nrender from the server and suit most conversations. `turns` draws a long\ntranscript one window at a time, so the log needs a block size of its own.\n\n**A conversation is built from three elements.** The chat holds the\ntranscript, a `Chat.Message` stands for each turn, and a `Chat.Composer` sits\nin the `composer` slot. When the user sends, `helix-send` reaches the chat:\nadd their turn with `author=\"me\"` and `state=\"sending\"`, then set `state` to\n`sent` or `failed` when your server answers. Add the reply as a turn with\n`state=\"streaming\"`, write its text as it arrives, and set `state` to `sent`\nwhen it is complete. While the user types, the composer sends\n`helix-typing`, which you can pass on to the other side. When the other side\ntypes, set `typing` to their name: the status band draws three dots and\n\"Ada is typing\" (`typing-label`), which a screen reader hears, and clearing\nit takes them away. Anything slotted into `status` is drawn first.\n\nA screen reader names each turn by its author and its time, such as \"You, 2\nminutes ago\". Set `me-label` and `message-label` to say it in your language,\nand give each turn by `them` an `author-label`. A turn with neither an author\nlabel nor a time is named by `turn-label`, \"Message\".\n\nA turn from `turns` is drawn in the chat's shadow root, so style it through\nthe forwarded `message-*` parts. A turn by `me` also gets each part with\n`-mine` added, and the turn's state adds `message-meta-failed`,\n`message-content-sending`, and `message-content-streaming`. To style each\nparticipant differently, give `author-styles` the declarations for each\nauthor, such as `{\"ada\": \"--chat-message-background-color: …\"}`: the message\ndrawn for each of their turns takes them as its `style`, so the message's\ncustom properties change for that author alone. Turns passed as children are\nstyled by their `author`, such as `helix-chat-message[author=\"ada\"]`.",
+          "description": "Chat has no positioning, no backdrop, and no trigger, so you can put it in\nany container, such as a page, a sidebar, a modal, or a floating panel.\n\nThe transcript stays pinned to the bottom, including while a streamed answer\ngrows, until the user scrolls more than `threshold` away from it.\n\nWith `history` set to `more`, reaching the top fires `helix-history`. Set\n`loading` while you fetch, then prepend the older turns. The turn the user\nwas reading stays in place on screen.\n\nThe log is `aria-live=\"off\"`. A separate status region announces each new\nturn once, when it has finished arriving. It skips the user's own turns\nunless they failed to send, turns loaded as history, and the turns already\nthere when the transcript opened. A turn is said with its author first, such\nas \"Ada: It ships today\" (`arrival-label`), where its author can be named.\n\nPass the turns as children or as `turns` data. Do not use both. Children\nrender from the server and suit most conversations. `turns` draws a long\ntranscript one window at a time, so the log needs a block size of its own.\n\n**A conversation is built from three elements.** The chat holds the\ntranscript, a `Chat.Message` stands for each turn, and a `Chat.Composer` sits\nin the `composer` slot. When the user sends, `helix-send` reaches the chat:\nadd their turn with `author=\"me\"` and `state=\"sending\"`, then set `state` to\n`sent` or `failed` when your server answers. Add the reply as a turn with\n`state=\"streaming\"`, write its text as it arrives, and set `state` to `sent`\nwhen it is complete. While the user types, the composer sends\n`helix-typing`, which you can pass on to the other side. When the other side\ntypes, set `typing` to their name: the status band draws three dots and\n\"Ada is typing\" (`typing-label`), which a screen reader hears, and clearing\nit takes them away. Anything slotted into `status` is drawn first.\n\n**Keyboard.** The transcript moves between turns the way a feed does. Each\nturn says its place, such as \"3 of 40\", windowed or not.\n\n| Key | What it does |\n|---|---|\n| Page Down, Page Up | On a turn or inside one, moves focus to the next or the previous turn. On the transcript itself, moves focus to the turn at the top of the view. |\n| Control with End | Moves focus to the composer. |\n| Control with Home | Moves focus to the first control above the transcript, or to the transcript. |\n\nWhile you are scrolled away from the newest turn, the `resume` region shows\na button that takes you back, named by `resume-label`, \"Jump to latest\".\nSlot your own control into `resume` to replace it.\n\nA screen reader names each turn by its author and its time, such as \"You, 2\nminutes ago\". Set `me-label` and `message-label` to say it in your language,\nand give each turn by `them` an `author-label`. A turn with neither an author\nlabel nor a time is named by `turn-label`, \"Message\".\n\nA turn from `turns` is drawn in the chat's shadow root, so style it through\nthe forwarded `message-*` parts. A turn by `me` also gets each part with\n`-mine` added, and the turn's state adds `message-meta-failed`,\n`message-content-sending`, and `message-content-streaming`. To style each\nparticipant differently, give `author-styles` the declarations for each\nauthor, such as `{\"ada\": \"--chat-message-background-color: …\"}`: the message\ndrawn for each of their turns takes them as its `style`, so the message's\ncustom properties change for that author alone. Turns passed as children are\nstyled by their `author`, such as `helix-chat-message[author=\"ada\"]`.",
           "name": "HelixHeadlessChat",
           "cssParts": [
             {
@@ -24756,6 +24957,14 @@
               "description": "The control shown while the user is scrolled away from the bottom.",
               "name": "resume"
             },
+            {
+              "description": "The button the `resume` region shows when nothing is slotted into it.",
+              "name": "resume-button"
+            },
+            {
+              "description": "The arrow on the default `resume-button`.",
+              "name": "resume-mark"
+            },
             {
               "description": "The status region, outside the log.",
               "name": "status"
@@ -24787,7 +24996,7 @@
               "name": "header"
             },
             {
-              "description": "The control that returns to the bottom, shown while the user has scrolled away.",
+              "description": "The control that returns to the bottom, shown while the user has scrolled away. Defaults to a button named by `resume-label`.",
               "name": "resume"
             },
             {
@@ -24971,6 +25180,19 @@
               "description": "Whether the transcript follows new turns to the bottom.\n\nThe reader's scrolling asks first: `helix-before-pin` is cancelable, so a\nconsumer refusing it takes the decision and assigns their own value.\n`default-pinned` seeds the state this element then owns, and it defaults to\npinned because a conversation opens at its most recent turn.\n\n**Not reflected, and the default is why.** A reflected property that\ndefaults to true writes its attribute on upgrade whether or not the\nconsumer wrote one, so the server serves `<helix-headless-chat label=\"x\">`\nand the client turns it into `<helix-headless-chat label=\"x\" pinned>`: a\nhydration mismatch a React consumer reports and does not patch up. Nothing\nneeds the attribute either, because the one thing that changes with the pin\nis the way back, and that is a part inside the shadow tree where a\nstylesheet can already reach it. Measured rather than assumed: `label,\npinned` after upgrade against `label` from the server.",
               "attribute": "pinned"
             },
+            {
+              "kind": "field",
+              "name": "resumeLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Jump to latest'",
+              "description": "The words on the button that returns to the newest turn, where `resume` is empty.",
+              "attribute": "resume-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "threshold",
@@ -25521,6 +25743,81 @@
               },
               "description": "Hands each turn written as a child the words it is named with, once it\nhas hydrated, so its first render is the server's."
             },
+            {
+              "kind": "method",
+              "name": "turnFrom",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "number | undefined"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "path",
+                  "type": {
+                    "text": "readonly EventTarget[]"
+                  }
+                }
+              ],
+              "description": "Which turn an event came from, by its place, `-1` for the transcript\nitself, or `undefined` for anywhere else."
+            },
+            {
+              "kind": "method",
+              "name": "topTurn",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "number"
+                }
+              },
+              "description": "The place of the turn at the top of the view, or the first turn."
+            },
+            {
+              "kind": "method",
+              "name": "focusTurn",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Promise<void>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "at",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "Moves focus to turn `at`, drawing it first where the transcript is\nwindowed and it is not drawn.\n\n**A turn takes focus only once a reader moves to it**, so the\n`tabindex=\"-1\"` a turn written as a child needs is written then, long\nafter any server's markup has hydrated, and never on a turn nobody moved\nto."
+            },
+            {
+              "kind": "method",
+              "name": "firstControlIn",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "HTMLElement | undefined"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "names",
+                  "type": {
+                    "text": "readonly string[]"
+                  }
+                }
+              ],
+              "description": "The first control in the regions `names` holds, in their order."
+            },
+            {
+              "kind": "field",
+              "name": "handleKeydown",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Page Down and Page Up move between turns, and Control with End or Home\nleaves the transcript, the keys the APG's feed answers."
+            },
             {
               "kind": "field",
               "name": "handleSlotChange",
@@ -25551,6 +25848,17 @@
               },
               "description": "The turns fed as data, a window of them, between the room the rest would take."
             },
+            {
+              "kind": "method",
+              "name": "renderResume",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
+              },
+              "description": "The `resume` slot, with the way back drawn where nothing is slotted, behind a seam:\nthe slot answers a page, and this answers the tier above."
+            },
             {
               "kind": "field",
               "name": "emptyText",
@@ -26241,6 +26549,15 @@
               "description": "Whether the transcript follows new turns to the bottom.\n\nThe reader's scrolling asks first: `helix-before-pin` is cancelable, so a\nconsumer refusing it takes the decision and assigns their own value.\n`default-pinned` seeds the state this element then owns, and it defaults to\npinned because a conversation opens at its most recent turn.\n\n**Not reflected, and the default is why.** A reflected property that\ndefaults to true writes its attribute on upgrade whether or not the\nconsumer wrote one, so the server serves `<helix-headless-chat label=\"x\">`\nand the client turns it into `<helix-headless-chat label=\"x\" pinned>`: a\nhydration mismatch a React consumer reports and does not patch up. Nothing\nneeds the attribute either, because the one thing that changes with the pin\nis the way back, and that is a part inside the shadow tree where a\nstylesheet can already reach it. Measured rather than assumed: `label,\npinned` after upgrade against `label` from the server.",
               "fieldName": "pinned"
             },
+            {
+              "name": "resume-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Jump to latest'",
+              "description": "The words on the button that returns to the newest turn, where `resume` is empty.",
+              "fieldName": "resumeLabel"
+            },
             {
               "name": "threshold",
               "type": {
@@ -30109,6 +30426,42 @@
             }
           ],
           "description": "The numbers for a gutter of `count` lines, one to a line, as the text a\n`<pre>` draws beside the code. The stylesheet aligns them to the end."
+        },
+        {
+          "kind": "function",
+          "name": "lineRuns",
+          "return": {
+            "type": {
+              "text": "Array<[number, number]>"
+            }
+          },
+          "parameters": [
+            {
+              "name": "list",
+              "type": {
+                "text": "string"
+              }
+            }
+          ],
+          "description": "The runs of lines a list of numbers and ranges names, such as `2, 4-6`, as\n`[first, last]` pairs counted from 1, in order and merged where they touch.\nAnything that is not a whole number or a range of them is passed over, and\na range written backward is read forward."
+        },
+        {
+          "kind": "function",
+          "name": "lineSpans",
+          "return": {
+            "type": {
+              "text": "Array<[number, number]>"
+            }
+          },
+          "parameters": [
+            {
+              "name": "text",
+              "type": {
+                "text": "string"
+              }
+            }
+          ],
+          "description": "Where each line of `text` starts and ends, as character offsets, the line\nbreak left out. A final line break ends the last line, as `lineCount` reads it."
         }
       ],
       "exports": [
@@ -30127,6 +30480,22 @@
             "name": "gutterNumbers",
             "module": "src/code-block/lines.ts"
           }
+        },
+        {
+          "kind": "js",
+          "name": "lineRuns",
+          "declaration": {
+            "name": "lineRuns",
+            "module": "src/code-block/lines.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "lineSpans",
+          "declaration": {
+            "name": "lineSpans",
+            "module": "src/code-block/lines.ts"
+          }
         }
       ]
     },
@@ -30196,9 +30565,31 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Renders a `<pre><code>` pair: `pre` keeps the whitespace, and `code` marks it\nas code. Long lines scroll inside the block and do not wrap, because a line\nbreak can be significant in code.\n\nA copy button is on by default. Set `no-copy` to remove it. The button copies\nthe slotted text, so there is no second copy of the code to keep in sync.\n\nFor a fragment of code inside a sentence, use `Code`.\n\nSet `line-numbers` to number the lines in a gutter beside the code, hidden\nfrom the accessibility tree and left out of a copy. Set `highlight` to a\nfunction that turns the code into highlighted markup, such as one wrapping\nShiki or Prism, and the block draws what it returns; it is handed the\nblock's `language`, so one function serves every block. The code stays in\nthe slot, so the copy button and the page's own text are the code as\nwritten.\n\nSet `expandable` on a block whose height is capped, such as by\n`--code-block-max-block-size`, and a button under it shows every line and\nthen fewer again, as a docs site's long example does. The button is drawn\nonly while the cap hides something, says whether the block is expanded with\n`aria-expanded`, names the block it opens with `aria-controls`, and the block\ncarries `:state(expanded)` while it is.\n\nSet `diff` to show a change. Put a unified diff, the output of `git diff` or\n`diff -u`, in the same slot, and the block draws the lines it added and\nremoved. The block never computes a diff itself. Line numbers come from the\nhunk headers and are hidden from the accessibility tree. Changed lines are\n`<ins>` and `<del>` with the `+` and `-` kept as text, so the change does not\ndepend on color. Each file in the patch is its own block under its own name,\nand its copy button copies the new version of the file. `variant=\"split\"`\nshows the old version beside the new, each removal opposite its replacement.\n\n**A block that scrolls is a tab stop.** While its lines run past its width or\nits cap, the scroller is a region named for the block, such as \"Code,\napp.ts\", that Tab reaches, so a keyboard scrolls it with the arrow keys in\nevery browser. Chromium and Firefox make a scrolling box focusable on their\nown, and Safari does not. A block that fits is no stop at all.\n\n**The code the block draws is marked untranslated**, `translate=\"no\"` on\nits `<pre>`, so a page translator leaves highlighted lines and a diff as\nwritten. Code in the slot takes its translation mode from the element, which\nwrites nothing onto itself, so set `translate=\"no\"` on the element to keep a\ntranslator off plain code too.\n\nOn the server, the slot renders as ordinary code, so a diff first appears as\nthe patch text in a `<pre>`. The client makes the same first render, which\nkeeps hydration clean, and draws the diff once it can read the content. Diff\nmode is experimental. The rest of the family is stable.",
+          "description": "Renders a `<pre><code>` pair: `pre` keeps the whitespace, and `code` marks it\nas code. Long lines scroll inside the block and do not wrap, because a line\nbreak can be significant in code.\n\nA copy button is on by default. Set `no-copy` to remove it. The button copies\nthe slotted text, so there is no second copy of the code to keep in sync.\n\nFor a fragment of code inside a sentence, use `Code`.\n\nSet `line-numbers` to number the lines in a gutter beside the code, hidden\nfrom the accessibility tree and left out of a copy. Set `mark-lines` to\nmark lines a reader should look at, such as `2, 4-6`: the block draws a\nband behind each run, placed where the lines are laid out, so it follows a\nhighlighter's markup and lines that wrap. Set `wrap` to wrap long lines\nrather than scroll them; a gutter then numbers each line where it starts.\nSet `wrappable` for a button in the header that turns `wrap` on and off,\npressed while the lines wrap.\n\nThe header holds the name, the `actions` slot, and the copy button. Slot a\ncontrol into `actions`, such as a button that sets `wrap` or one that opens\nthe code in an editor, and the block draws a header for it even with no\nname. `copy-icon` and `copied-icon` replace the copy button's two icons. Set `highlight` to a\nfunction that turns the code into highlighted markup, such as one wrapping\nShiki or Prism, and the block draws what it returns; it is handed the\nblock's `language`, so one function serves every block. The code stays in\nthe slot, so the copy button and the page's own text are the code as\nwritten.\n\nSet `expandable` on a block whose height is capped, such as by\n`--code-block-max-block-size`, and a button under it shows every line and\nthen fewer again, as a docs site's long example does. The button is drawn\nonly while the cap hides something, says whether the block is expanded with\n`aria-expanded`, names the block it opens with `aria-controls`, and the block\ncarries `:state(expanded)` while it is.\n\nSet `diff` to show a change. Put a unified diff, the output of `git diff` or\n`diff -u`, in the same slot, and the block draws the lines it added and\nremoved. The block never computes a diff itself. Line numbers come from the\nhunk headers and are hidden from the accessibility tree. Changed lines are\n`<ins>` and `<del>` with the `+` and `-` kept as text, so the change does not\ndepend on color. Each file in the patch is its own block under its own name,\nand its copy button copies the new version of the file. `variant=\"split\"`\nshows the old version beside the new, each removal opposite its replacement.\n\n**A block that scrolls is a tab stop.** While its lines run past its width or\nits cap, the scroller is a region named for the block, such as \"Code,\napp.ts\", that Tab reaches, so a keyboard scrolls it with the arrow keys in\nevery browser. Chromium and Firefox make a scrolling box focusable on their\nown, and Safari does not. A block that fits is no stop at all.\n\n**The code the block draws is marked untranslated**, `translate=\"no\"` on\nits `<pre>`, so a page translator leaves highlighted lines and a diff as\nwritten. Code in the slot takes its translation mode from the element, which\nwrites nothing onto itself, so set `translate=\"no\"` on the element to keep a\ntranslator off plain code too.\n\nOn the server, the slot renders as ordinary code, so a diff first appears as\nthe patch text in a `<pre>`. The client makes the same first render, which\nkeeps hydration clean, and draws the diff once it can read the content. Diff\nmode is experimental. The rest of the family is stable.",
           "name": "HelixHeadlessCodeBlock",
+          "cssProperties": [
+            {
+              "description": "Written by the block on each `number` in a `wrap` block with `line-numbers`: how tall the line it numbers is laid out. Do not set it.",
+              "name": "--code-block-line-size"
+            },
+            {
+              "description": "Written by the block on each `mark`: how wide the code is, scrolled part included. Do not set it.",
+              "name": "--code-block-mark-inline-size"
+            },
+            {
+              "description": "Written by the block on each `mark`: how tall its run of lines is. Do not set it.",
+              "name": "--code-block-mark-size"
+            },
+            {
+              "description": "Written by the block on each `mark`: how far down the code its run of lines starts. Do not set it.",
+              "name": "--code-block-mark-start"
+            }
+          ],
           "cssParts": [
+            {
+              "description": "The box in the header that holds the `actions` slot, drawn while something is slotted there.",
+              "name": "actions"
+            },
             {
               "description": "In a diff, a line only the new version has, an `<ins>`.",
               "name": "added"
@@ -30311,6 +30702,10 @@
               "description": "The block's name: its `label`, or its `language` where it has no label.",
               "name": "label"
             },
+            {
+              "description": "The band behind a run of lines `mark-lines` names. The block writes where the run is laid out into `--code-block-mark-start`, `--code-block-mark-size`, and `--code-block-mark-inline-size` on it. Hidden from the accessibility tree.",
+              "name": "mark"
+            },
             {
               "description": "In a diff, the `+`, `-`, or space that starts a line.",
               "name": "marker"
@@ -30320,7 +30715,7 @@
               "name": "new"
             },
             {
-              "description": "In a diff, a line number.",
+              "description": "In a diff, a line number. In a `wrap` block with `line-numbers`, one line's number in the gutter, which the block makes as tall as the line it numbers through `--code-block-line-size`.",
               "name": "number"
             },
             {
@@ -30338,12 +30733,28 @@
             {
               "description": "In a diff, a line's code.",
               "name": "text"
+            },
+            {
+              "description": "The button in the header that wraps the lines and unwraps them, drawn when `wrappable` is set.",
+              "name": "wrap-toggle"
             }
           ],
           "slots": [
             {
               "description": "The code.",
               "name": ""
+            },
+            {
+              "description": "Controls for the block, in the header before the copy button.",
+              "name": "actions"
+            },
+            {
+              "description": "The copy button's icon after a copy. Defaults to a check mark.",
+              "name": "copied-icon"
+            },
+            {
+              "description": "The copy button's icon before a copy. Defaults to a clipboard.",
+              "name": "copy-icon"
             }
           ],
           "members": [
@@ -30508,6 +30919,16 @@
               "attribute": "line-numbers",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "markLines",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The lines to mark, as numbers and ranges counted from 1, such as `2, 4-6`.\nEach run is drawn as a band behind its lines. Not for a diff, which marks\nits own changes.",
+              "attribute": "mark-lines"
+            },
             {
               "kind": "field",
               "name": "noCopy",
@@ -30529,6 +30950,51 @@
               "attribute": "variant",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "wrap",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether long lines wrap. Without it they scroll.\n\nOff by default, so long lines scroll, because a line break can be\nsignificant in code and a wrapped line reads as two. For prose-like code,\nsuch as a long command or a log line, a wrap reads better than a scroll.\nWith `line-numbers`, each number stands beside the line it numbers\nhowever many rows that line takes. Reflected, because the stylesheet\nwraps the lines.",
+              "attribute": "wrap",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "wrapLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Wrap lines'",
+              "description": "The wrap button's name, which it keeps whether it is pressed or not.",
+              "attribute": "wrap-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "wrappable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the header has a button that wraps the lines and unwraps them. The\nblock draws a header for it even with no name.",
+              "attribute": "wrappable"
+            },
+            {
+              "kind": "method",
+              "name": "toggleWrap",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks to wrap or unwrap the lines, and says so once it has."
+            },
             {
               "kind": "field",
               "name": "parsed",
@@ -30615,6 +31081,36 @@
               },
               "description": "Makes each box that scrolls a tab stop and a region named for its block,\nand takes both away from a box that fits.\n\n**A reader on a keyboard scrolls the code from the box itself.** Chromium\nand Firefox make a scrolling box focusable on their own, and Safari does\nnot, so there the arrow keys could not reach the end of a long line. A\nbox counts while its sheet lets it scroll and its content is wider or\ntaller than it is drawn: an unstyled `<pre>` overflows without scrolling,\nand a stop on it would scroll nothing."
             },
+            {
+              "kind": "method",
+              "name": "lineBoxes",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Array<{ bottom: number; top: number }>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "code",
+                  "type": {
+                    "text": "HTMLElement"
+                  }
+                }
+              ],
+              "description": "Where each line of the code is laid out in the `<code>`, from the top of\nits content, as the browser placed the text: one row, or several where it\nwraps."
+            },
+            {
+              "kind": "method",
+              "name": "placeLines",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Places each mark behind its run of lines, and makes each number in a\nwrapping gutter as tall as its line, from where the lines are laid out.\n\n**Written onto the elements as custom properties**, which are facts the\nblock computed and CSS cannot, and no render follows from them."
+            },
             {
               "kind": "method",
               "name": "renderExpand",
@@ -30626,6 +31122,25 @@
               },
               "description": "The button that shows every line of a capped block, and fewer again, or\nnothing while the cap hides nothing. Not on a server, which cannot\nmeasure, so a served block draws none and the client adds it."
             },
+            {
+              "kind": "method",
+              "name": "headed",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Whether the block draws a header: it has a name, a wrap button, or a control in `actions`."
+            },
             {
               "kind": "method",
               "name": "renderHeader",
@@ -30650,7 +31165,37 @@
                   }
                 }
               ],
-              "description": "The name with the copy button beside it, or nothing when there is no name.\n\n**The button is in the header wherever there is one**, because beside the\ncode it stands over the block and the block has to make room for it. A\ndiff cannot: its washes run to the edge, so the button stood on the hunk\nline and the line under it. In the header it is over nothing.\n\n**No name draws no header**, rather than a bar to hold one button, which\nturned a `Usage` section of one-line imports into a run of empty strips.\nThe button then stands beside the code, in room the block keeps for it."
+              "description": "The name with the copy button beside it, or nothing when there is no name.\n\n**The button is in the header wherever there is one**, because beside the\ncode it stands over the block and the block has to make room for it. A\ndiff cannot: its washes run to the edge, so the button stood on the hunk\nline and the line under it. In the header it is over nothing.\n\n**No name draws no header**, unless the page put a control in `actions`\nor asked for the wrap button. A bar holding the copy button alone turned a\n`Usage` section of one-line imports into a run of empty strips. The button\nthen stands beside the code, in room the block keeps for it."
+            },
+            {
+              "kind": "method",
+              "name": "renderWrapToggle",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "description": "The button that wraps the lines and unwraps them, where `wrappable` asks for one. Not for a diff."
+            },
+            {
+              "kind": "method",
+              "name": "slotted",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Whether the page slotted something into `name`. Not known on a server or\nwhile hydrating what one sent, which render as though nothing were."
             },
             {
               "kind": "method",
@@ -30704,6 +31249,17 @@
               ],
               "description": "The button that takes the code, behind a seam the styled tier can move.\n\nA method rather than a fragment inline, so a tier above can render its own\ncopy control, wrap this one, or pass it something the base does not know\nabout, without reimplementing the whole template to do it. The tag is\ninterpolated rather than written, so `tier` resolves it: this renders the\nbase button, and a styled subclass that sets `tier` renders the styled one\nfrom the same template."
             },
+            {
+              "kind": "method",
+              "name": "renderCopyIcons",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
+              },
+              "description": "The page's own icons for the copy button, passed on through slots of the\nblock's, where the page slotted them. A slot passed on with nothing in it\nwould stand in for the button's own icon and draw nothing, so it is drawn\nonly for an icon the page gave. In a diff, the first file's button takes\nthem, a slotted element going to one slot."
+            },
             {
               "kind": "method",
               "name": "renderNumber",
@@ -31166,6 +31722,24 @@
               }
             }
           ],
+          "events": [
+            {
+              "type": {
+                "text": "HelixBeforeToggleEvent"
+              },
+              "description": "The wrap button was pressed, with the `wrap` it asks for in `detail.checked`. Cancelable: cancel it to keep the lines as they are.",
+              "name": "helix-before-toggle",
+              "reactProp": "onhelix-before-toggle"
+            },
+            {
+              "type": {
+                "text": "HelixToggleEvent"
+              },
+              "description": "Fired after the wrap button changed `wrap`, with the new value in `detail.checked`.",
+              "name": "helix-toggle",
+              "reactProp": "onhelix-toggle"
+            }
+          ],
           "attributes": [
             {
               "name": "code-label",
@@ -31275,6 +31849,15 @@
               "description": "Whether the lines are numbered in a gutter beside the code.\n\nThe numbers are hidden from the accessibility tree and are not part of a\ncopy, which takes the code alone. Reflected, because the stylesheet lays\nthe gutter out beside the code. A diff numbers its lines from its hunks\nwhether or not this is set.",
               "fieldName": "lineNumbers"
             },
+            {
+              "name": "mark-lines",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The lines to mark, as numbers and ranges counted from 1, such as `2, 4-6`.\nEach run is drawn as a band behind its lines. Not for a diff, which marks\nits own changes.",
+              "fieldName": "markLines"
+            },
             {
               "name": "no-copy",
               "type": {
@@ -31291,6 +31874,33 @@
               },
               "description": "How a diff's two versions are arranged. It has no effect without `diff`.\n\nAbsent is unified, each removal above its replacement, which fits any\nwidth. `split` sets the old version beside the new one. Optional rather\nthan defaulted, so the host carries no attribute the consumer did not write.",
               "fieldName": "variant"
+            },
+            {
+              "name": "wrap",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether long lines wrap. Without it they scroll.\n\nOff by default, so long lines scroll, because a line break can be\nsignificant in code and a wrapped line reads as two. For prose-like code,\nsuch as a long command or a log line, a wrap reads better than a scroll.\nWith `line-numbers`, each number stands beside the line it numbers\nhowever many rows that line takes. Reflected, because the stylesheet\nwraps the lines.",
+              "fieldName": "wrap"
+            },
+            {
+              "name": "wrap-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Wrap lines'",
+              "description": "The wrap button's name, which it keeps whether it is pressed or not.",
+              "fieldName": "wrapLabel"
+            },
+            {
+              "name": "wrappable",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the header has a button that wraps the lines and unwraps them. The\nblock draws a header for it even with no name.",
+              "fieldName": "wrappable"
             }
           ],
           "cssStates": [
@@ -73962,15 +74572,22 @@
                   "type": {
                     "text": "string"
                   }
+                },
+                {
+                  "name": "cause",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
                 }
               ],
-              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction.",
+              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction. `cause` says why, where the family names its\ncauses, and reaches the event as `detail.cause`.",
               "inheritedFrom": {
                 "name": "MixinControllerActive",
                 "module": "src/mixins/mixin-controller-active/mixin-controller-active.ts"
               },
               "type": {
-                "text": "requestActive(next: string) => boolean"
+                "text": "requestActive(next: string, cause?: string) => boolean"
               }
             },
             {
@@ -86449,15 +87066,22 @@
                   "type": {
                     "text": "string"
                   }
+                },
+                {
+                  "name": "cause",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
                 }
               ],
-              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction.",
+              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction. `cause` says why, where the family names its\ncauses, and reaches the event as `detail.cause`.",
               "inheritedFrom": {
                 "name": "MixinControllerActive",
                 "module": "src/mixins/mixin-controller-active/mixin-controller-active.ts"
               },
               "type": {
-                "text": "requestActive(next: string) => boolean"
+                "text": "requestActive(next: string, cause?: string) => boolean"
               }
             },
             {
@@ -146587,6 +147211,19 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "cornerValueLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{across} across, {down} down'",
+              "description": "What the handle where two dividers cross says it is set to, both dividers\nat once: `{across}` is where the divider that runs down stands, and\n`{down}` where the one that runs across stands, each a percentage.\n\n**Both, because the handle moves both**, and a number names one: the\nhandle's `aria-valuenow` is the divider its `aria-orientation` names, and\nthese words are the whole of where it is.",
+              "attribute": "corner-value-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "defaultCollapsed",
@@ -147080,6 +147717,31 @@
               },
               "description": "Starts or stops watching, according to what the axis was asked to be.\n\nCalled from `firstUpdated` and from `updated`, so a consumer switching to\n`auto` after mount is observed and one switching away stops being: an\nobserver left running would keep writing `stacked` that nothing reads, and\na splitter told `horizontal` has been given its answer already."
             },
+            {
+              "kind": "method",
+              "name": "cornerWords",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "own",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "theirs",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "Where a crossing stands in words: this splitter's divider at `own` and the\nnested one's at `theirs`, as `corner-value-label` puts them."
+            },
             {
               "kind": "field",
               "name": "vertical",
@@ -147705,6 +148367,15 @@
               "description": "The name of the handle where two dividers cross, read by screen readers.",
               "fieldName": "cornerLabel"
             },
+            {
+              "name": "corner-value-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{across} across, {down} down'",
+              "description": "What the handle where two dividers cross says it is set to, both dividers\nat once: `{across}` is where the divider that runs down stands, and\n`{down}` where the one that runs across stands, each a percentage.\n\n**Both, because the handle moves both**, and a number names one: the\nhandle's `aria-valuenow` is the divider its `aria-orientation` names, and\nthese words are the whole of where it is.",
+              "fieldName": "cornerValueLabel"
+            },
             {
               "name": "default-collapsed",
               "type": {
@@ -149415,15 +150086,22 @@
                   "type": {
                     "text": "string"
                   }
+                },
+                {
+                  "name": "cause",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
                 }
               ],
-              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction.",
+              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction. `cause` says why, where the family names its\ncauses, and reaches the event as `detail.cause`.",
               "inheritedFrom": {
                 "name": "MixinControllerActive",
                 "module": "src/mixins/mixin-controller-active/mixin-controller-active.ts"
               },
               "type": {
-                "text": "requestActive(next: string) => boolean"
+                "text": "requestActive(next: string, cause?: string) => boolean"
               }
             },
             {
@@ -154256,7 +154934,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Lays out the rows on a CSS grid, so every column lines up across rows and\neach row stays a real element that can be styled, hidden, or made\ninteractive. A `<table>` layout aligns columns but limits almost everything\nelse.\n\nA grid of elements has no table structure for assistive technology, so the\nroles are set explicitly: `table`, `row`, `cell`, `columnheader`, and\n`rowheader` for a `header` cell in a row of values. Rows are\n`display: contents`, so their cells become items of the one grid.\n\n**Sorting.** A column with `sortable` and a `field` draws its heading as a\nbutton that sorts the rows by the text of its cells, numbers by their value.\nYour markup is not reordered: the table draws the rows in the sorted order.\n\n1. Each press cycles the column through ascending, descending, and the\n   order the rows were written in, which keeps a server's own ranking\n   reachable.\n2. `helix-sort` asks first, with `field:direction`, or empty for the written\n   order. Refuse it to keep the order, or to sort the rows yourself and set\n   `sort`.\n3. `helix-sorted` follows once the order stands, and `sort` holds it.\n4. The heading carries `aria-sort`, and a screen reader hears `sorted-label`\n   (\"Sorted by Name, ascending\") or `unsorted-label` from a polite region.\n\nTab reaches each sort button, and Enter or Space presses it.\n\nThe `heading` slot names the table: slot a heading or a line of text into\nit, and the table is named by its words. An `aria-label` or `aria-labelledby` on the\nhost wins over it.\n\n**Selecting.** `selectable` adds a column of checkboxes.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, and `selected` holds the chosen keys, comma separated, the same\n   shape `DataTable` uses. `default-selected` is where it starts.\n2. A row's checkbox is named by `select-row-label` (\"Select {row}\") with the\n   words of the row's first cell. The checkbox in the heading selects every\n   row, and shows a dash while only some are chosen.\n3. `helix-select` asks first, with every key the change would leave.\n   Refuse it to keep the selection. `helix-selected` follows once it stands.\n4. A chosen row takes `:state(selected)`, and a screen reader hears\n   `selected-label` (\"2 selected\") from a polite region.\n\nTab reaches each checkbox, and Space ticks it. To act on one row, put a\nlink or a button in a cell, or give the row an `href`.\n\n**Moving rows.** `reorderable` adds a column of grips before the checkboxes,\nunder a heading named by `row-grips-label`.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, as for selecting. Give rows a `value` when they move, so a key\n   stays with its row.\n2. A grip is a button named by `move-row-label` (\"Move {row}\") with the\n   words of the row's first cell. Drag it to move its row, and the page\n   scrolls near an edge. Or press it with Space, Enter, or a click to pick\n   the row up, move it with Up, Down, Home, and End, and press it again to\n   drop it. A click on another row drops it there, and Escape puts it back.\n3. `helix-before-reorder` asks first, and `helix-reorder` follows with\n   `keys`, every row's key in the new order. **You move the rows**: the\n   table moves no element of yours, and focus goes back to the moved row's\n   grip once you have.\n4. Each step is said in the table's live region, in words you can change:\n   `picked-up-label`, `moved-label`, `dropped-label`, and `canceled-label`.\n   The grips do nothing while a sort is set.\n\n**A grid.** `grid` makes the table one tab stop that the arrow keys move\nthrough cell by cell, the headings included, as React Aria's table is. The\ntable is then a `grid` and each value a `gridcell`, and the table gives\nevery cell a `tabindex` so focus can rest on it: set `grid` only where the\ncells may carry one.\n\n| Key | What it does |\n|---|---|\n| Right, Left | Moves one cell along the row. Left moves on, on a right-to-left page. |\n| Down, Up | Moves one row, the headings included. |\n| Home, End | Moves to the first or the last cell of the row. |\n| Control with Home or End | Moves to the first or the last cell of the table. |\n| Page Down, Page Up | Moves by the rows that fit in view. |\n| Enter, F2 | Moves into the cell's links and controls. Escape or F2 moves back to the cell, and Tab moves between the controls of one cell. |\n| Enter on a cell of a row with `href` | Follows the row's link. |\n| Enter, Space on a sortable heading | Sorts by the column. |\n| Space on a row, Enter or Space on its checkbox cell | Selects the row, in a `selectable` table. |\n| Enter or Space on a grip cell | Picks the row up, or drops it, in a `reorderable` table. Up, Down, Home, and End move a row picked up, and Escape puts it back. |\n| Shift with Down or Up | Selects the rows it moves across, in a `selectable` table. |\n| Shift with Space | Selects every row from the one last chosen, in a `selectable` table. |\n| Control or Command with A | Selects every row, in a `selectable` table. |\n| A letter or a word | Moves to the next row whose first cell starts with what you typed. |\n| Tab | Leaves the table. |\n\nWhen the rows did not load, set `error-text`, such as \"The orders did not\nload\", and put a button that tries again in the `error` slot. The line shows\nafter the rows in place of the empty and loading lines, the live region says\nit, and the table takes the `error` state. Clear it once you try again.\n\nThe CSS custom properties listed for this component are written by it and\nread by the stylesheet that draws it. Do not set them. Each holds a number\nthe component computes and CSS cannot, so the stylesheet can draw the table\nwithout measuring anything.",
+          "description": "Lays out the rows on a CSS grid, so every column lines up across rows and\neach row stays a real element that can be styled, hidden, or made\ninteractive. A `<table>` layout aligns columns but limits almost everything\nelse.\n\nA grid of elements has no table structure for assistive technology, so the\nroles are set explicitly: `table`, `row`, `cell`, `columnheader`, and\n`rowheader` for a `header` cell in a row of values. Rows are\n`display: contents`, so their cells become items of the one grid.\n\n**Sorting.** A column with `sortable` and a `field` draws its heading as a\nbutton that sorts the rows by the text of its cells, numbers by their value.\nYour markup is not reordered: the table draws the rows in the sorted order.\n\n1. Each press cycles the column through ascending, descending, and the\n   order the rows were written in, which keeps a server's own ranking\n   reachable.\n2. `helix-sort` asks first, with `field:direction`, or empty for the written\n   order. Refuse it to keep the order, or to sort the rows yourself and set\n   `sort`.\n3. `helix-sorted` follows once the order stands, and `sort` holds it.\n4. The heading carries `aria-sort`, and a screen reader hears `sorted-label`\n   (\"Sorted by Name, ascending\") or `unsorted-label` from a polite region.\n\nTab reaches each sort button, and Enter or Space presses it.\n\nThe `heading` slot names the table: slot a heading or a line of text into\nit, and the table is named by its words. An `aria-label` or `aria-labelledby` on the\nhost wins over it.\n\n**Selecting.** `selectable` adds a column of checkboxes.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, and `selected` holds the chosen keys, comma separated, the same\n   shape `DataTable` uses. `default-selected` is where it starts.\n2. A row's checkbox is named by `select-row-label` (\"Select {row}\") with the\n   words of the row's first cell. The checkbox in the heading selects every\n   row, and shows a dash while only some are chosen.\n3. `helix-select` asks first, with every key the change would leave.\n   Refuse it to keep the selection. `helix-selected` follows once it stands.\n4. A chosen row takes `:state(selected)`, and a screen reader hears\n   `selected-label` (\"2 selected\") from a polite region.\n\nTab reaches each checkbox, and Space ticks it. To act on one row, put a\nlink or a button in a cell, or give the row an `href`.\n\n`selection-mode=\"single\"` selects one row at a time: ticking a row lets go\nof the one before, the heading holds no checkbox, and Shift and Control with\nA take in nothing more. `selection-behavior=\"replace\"` makes a press on a\nrow, anywhere but its own controls, select it alone, as a file list does,\nand in a `grid` table the arrow keys carry the selection with them. Control\nor Command with a press adds or takes out the row, and with an arrow moves\nwithout selecting. Shift with a press takes in the rows from the one last\nchosen.\n\n**Nesting rows.** A row with `parent` sits under the row of that key, as\na file sits in a folder. The table then draws a column of disclosure\nbuttons, under a heading named by `expand-column-label`: a row with rows\nunder it has a button named by `expand-row-label` (\"Expand {row}\") that\nsays with `aria-expanded` whether it is open, and the rows under a shut row\nare not drawn. `expanded` holds the open rows' keys, comma separated, and\n`default-expanded` is where it starts. A press asks with\n`helix-before-toggle` and tells with `helix-toggle`, both from the row, so\nyou can refuse it or load the rows on the way. A sort orders the rows\nunder each row among themselves, and in a `grid` table the table is a\n`treegrid` whose rows say their depth.\n\n**Moving rows.** `reorderable` adds a column of grips before the checkboxes,\nunder a heading named by `row-grips-label`.\n\n1. Each row is known by its `value`, or by its place among the rows where it\n   has none, as for selecting. Give rows a `value` when they move, so a key\n   stays with its row.\n2. A grip is a button named by `move-row-label` (\"Move {row}\") with the\n   words of the row's first cell. Drag it to move its row, and the page\n   scrolls near an edge. Or press it with Space, Enter, or a click to pick\n   the row up, move it with Up, Down, Home, and End, and press it again to\n   drop it. A click on another row drops it there, and Escape puts it back.\n3. `helix-before-reorder` asks first, and `helix-reorder` follows with\n   `keys`, every row's key in the new order. **You move the rows**: the\n   table moves no element of yours, and focus goes back to the moved row's\n   grip once you have.\n4. Each step is said in the table's live region, in words you can change:\n   `picked-up-label`, `moved-label`, `dropped-label`, and `canceled-label`.\n   The grips do nothing while a sort is set.\n\n**A grid.** `grid` makes the table one tab stop that the arrow keys move\nthrough cell by cell, the headings included, as React Aria's table is. The\ntable is then a `grid` and each value a `gridcell`, and the table gives\nevery cell a `tabindex` so focus can rest on it: set `grid` only where the\ncells may carry one.\n\n| Key | What it does |\n|---|---|\n| Right, Left | Moves one cell along the row. Left moves on, on a right-to-left page. |\n| Down, Up | Moves one row, the headings included. |\n| Home, End | Moves to the first or the last cell of the row. |\n| Control with Home or End | Moves to the first or the last cell of the table. |\n| Page Down, Page Up | Moves by the rows that fit in view. |\n| Enter, F2 | Moves into the cell's links and controls. Escape or F2 moves back to the cell, and Tab moves between the controls of one cell. |\n| Enter on a cell of a row with `href` | Follows the row's link. |\n| Enter, Space on a sortable heading | Sorts by the column. |\n| Space on a row, Enter or Space on its checkbox cell | Selects the row, in a `selectable` table. |\n| Enter or Space on a disclosure cell | Shows or hides the rows under the row, in a table whose rows nest. |\n| Enter or Space on a grip cell | Picks the row up, or drops it, in a `reorderable` table. Up, Down, Home, and End move a row picked up, and Escape puts it back. |\n| Down, Up, Page Down, Page Up under `selection-behavior=\"replace\"` | Selects the row it moves to alone. Control or Command with the key moves without selecting. |\n| Shift with Down or Up | Selects the rows it moves across, in a `selectable` table. |\n| Shift with Space | Selects every row from the one last chosen, in a `selectable` table. |\n| Control or Command with A | Selects every row, in a `selectable` table. |\n| A letter or a word | Moves to the next row whose first cell starts with what you typed. |\n| Tab | Leaves the table. |\n\n**Loading more.** `load-more` sends `helix-load-more` once the end of the\ntable comes within a screen of view, in the box that scrolls it or the\npage, once for each number of rows: add rows and it can send it again. Set\n`loading` while you fetch, and the table asks for nothing until it clears.\n\nWhen the rows did not load, set `error-text`, such as \"The orders did not\nload\", and put a button that tries again in the `error` slot. The line shows\nafter the rows in place of the empty and loading lines, the live region says\nit, and the table takes the `error` state. Clear it once you try again.\n\nThe CSS custom properties listed for this component are written by it and\nread by the stylesheet that draws it. Do not set them. Each holds a number\nthe component computes and CSS cannot, so the stylesheet can draw the table\nwithout measuring anything.",
           "name": "HelixHeadlessTable",
           "cssProperties": [
             {
@@ -154321,6 +154999,10 @@
               "description": "The line shown after the rows while `error-text` is set, in place of the empty and loading text.",
               "name": "error"
             },
+            {
+              "description": "The heading over the disclosure buttons, in a table whose rows nest.",
+              "name": "expand-head"
+            },
             {
               "description": "An empty box after the rows, in a `grid` table. Tab focuses it on its way out of the table, so the key leaves from the end.",
               "name": "grid-end"
@@ -154441,6 +155123,16 @@
               "description": "The column widths as one track list, written once on the table.\n\nWith `TableColumn` children, each track sizes the column in its place, a\nhidden column counted, so hiding one takes its track with it and the rest\nkeep theirs. The columns decide how many tracks there are and this list\nonly how wide: a track past the last column is dropped, and a column past\nthe last track shares what is left. With no columns declared it is the\nwhole track list. Tracks count as the grid counts them, so `minmax(0, 1fr)`\nis one and `repeat(2, 8rem)` is two, and one the grid would refuse leaves\nits column at the default rather than taking the table down to one column.\n\n**A column's own `width` wins over its track here.** The width is written\non the column it sizes, which is the more particular statement, and it is\nwhere a resize lands: a reader dragging a column's edge writes `width`, so\nwere this list to win, the drag would move the separator and leave the\ntrack where the list put it. This is the table's default for its columns,\nand each column may say otherwise.\n\n**It is also the only track list a server can send.** The shim has no tree\nto walk, so a render there knows of no columns and this attribute is the\nwhole answer: a table given one lays its grid out in the first paint, and a\ntable sized only by its columns is one track wide until it upgrades.\n\n**Data Table has none of this, and should not.** Its columns are its schema\nrather than an option, so there is always a column to write a `width` on\nand a list here would be a second way to say what that says. This table's\ncells are markup, and a table written as rows of cells with no column\ndeclared in it has nowhere else to be sized from.",
               "attribute": "columns"
             },
+            {
+              "kind": "field",
+              "name": "defaultExpanded",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The keys of the rows whose rows are shown at the start, separated by\ncommas. Used until `expanded` is set.",
+              "attribute": "default-expanded"
+            },
             {
               "kind": "field",
               "name": "defaultSelected",
@@ -154497,6 +155189,41 @@
               "description": "The text shown and announced when the rows could not load. Set it when a\nfetch fails, and clear it once you try again. Empty, the default, shows\nnothing.\n\nWhile it is set, a line after the rows shows it, or your own content in the\n`error` slot, in place of the empty and loading lines, and the live region\nsays it.",
               "attribute": "error-text"
             },
+            {
+              "kind": "field",
+              "name": "expandColumnLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Expand'",
+              "description": "The name of the heading over the disclosure buttons.",
+              "attribute": "expand-column-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "expanded",
+              "type": {
+                "text": "string"
+              },
+              "description": "The keys of the rows whose rows are shown, separated by commas, in a table\nwhose rows nest. A press on a row's disclosure button asks first, and\n`default-expanded` seeds what this element then owns.",
+              "attribute": "expanded"
+            },
+            {
+              "kind": "field",
+              "name": "expandRowLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Expand {row}'",
+              "description": "The name of a row's disclosure button. `{row}` is the words of the row's first cell.",
+              "attribute": "expand-row-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "fallbackLabel",
@@ -154530,6 +155257,16 @@
               "description": "Accessible name for the table.\n\nAn `aria-label` or `aria-labelledby` on the host names the table too, and\nwins over this.",
               "attribute": "label"
             },
+            {
+              "kind": "field",
+              "name": "loadMore",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Sends `helix-load-more` once the end of the table comes within a screen\nof view, so you can add the next rows as a reader nears them.",
+              "attribute": "load-more"
+            },
             {
               "kind": "field",
               "name": "movedLabel",
@@ -154615,6 +155352,19 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "selectColumnLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Select'",
+              "description": "The name of the heading over the checkboxes under\n`selection-mode=\"single\"`, where it holds no checkbox of its own.",
+              "attribute": "select-column-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "selected",
@@ -154637,6 +155387,25 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "selectionBehavior",
+              "type": {
+                "text": "'replace' | 'toggle'"
+              },
+              "default": "'toggle'",
+              "description": "What a press on a row, or in a `grid` table a key that moves to one, does\nto the rows already selected: `toggle`, the default, leaves them to the\ncheckboxes, and `replace` selects the row alone.",
+              "attribute": "selection-behavior"
+            },
+            {
+              "kind": "field",
+              "name": "selectionMode",
+              "type": {
+                "text": "'multiple' | 'single' | undefined"
+              },
+              "description": "How many rows a `selectable` table selects: `multiple`, the default, or\n`single`, one at a time.",
+              "attribute": "selection-mode"
+            },
             {
               "kind": "field",
               "name": "selectRowLabel",
@@ -154703,6 +155472,54 @@
               "privacy": "private",
               "default": "undefined"
             },
+            {
+              "kind": "field",
+              "name": "expandedState",
+              "type": {
+                "text": "string | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined"
+            },
+            {
+              "kind": "field",
+              "name": "nests",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether any row sits under another, which makes the table a tree.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "open",
+              "type": {
+                "text": "Set<string>"
+              },
+              "privacy": "private",
+              "description": "The keys of the rows whose rows are shown.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "toggleRow",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Shows or hides the rows under the row of `key`, asking first from the row,\nand saying so from it once it stands."
+            },
             {
               "kind": "field",
               "name": "headed",
@@ -154726,7 +155543,7 @@
               "name": "gridKeys",
               "privacy": "private",
               "readonly": true,
-              "default": "new TableGridController(this, { activate: (place, event) => this.activate(place, event), columns: () => this.tableColumns.filter((column) => column.shown), lead: () => this.lead, on: () => this.grid, part: (name) => this.partNamed(name), rows: () => (this.childrenKnown ? this.arrangedRows : []), rowWords: () => this.arrangedRows.map((row) => textOf(row.children[0])), selectAll: () => this.selectable && this.requestSelected(new Set([...this.chosen, ...this.enabledKeys])), selectRange: (to, from) => this.selectRange(to, from), })",
+              "default": "new TableGridController(this, { activate: (place, event) => this.activate(place, event), arrive: (to, control) => { if (this.replaces && !control) { this.chooseOnly(to) } }, columns: () => this.tableColumns.filter((column) => column.shown), lead: () => this.lead, on: () => this.grid, part: (name) => this.partNamed(name), rows: () => (this.childrenKnown ? this.arrangedRows : []), rowWords: () => this.arrangedRows.map((row) => textOf(row.children[0])), selectAll: () => this.selectable && !this.single && this.requestSelected(new Set([...this.chosen, ...this.enabledKeys])), selectRange: (to, from) => this.selectRange(to, from), })",
               "description": "The keyboard of a `grid` table, in `grid-controller.ts`."
             },
             {
@@ -154835,6 +155652,36 @@
               "description": "The rows in the order they are drawn: sorted by `sort`, and as written\nwhere there is no sort.\n\n**Drawn in order by assignment.** A manually assigned slot draws its nodes\nin the order they were assigned, so the rows move on screen and in the\naccessibility tree while the consumer's markup stays as it was written,\nwhich is what a framework holding those rows needs.",
               "readonly": true
             },
+            {
+              "kind": "method",
+              "name": "nested",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Element[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rows",
+                  "type": {
+                    "text": "Element[]"
+                  }
+                }
+              ],
+              "description": "The rows of a tree in the order they are drawn: each row followed by the\nrows under it while it is open, at every depth, keeping the order `rows`\nis in among the rows under one row. A row under a key no row has is drawn\nat the top."
+            },
+            {
+              "kind": "method",
+              "name": "shape",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Map<string, { branch: boolean; level: number }>"
+                }
+              },
+              "description": "How deep each row sits, from 1, and whether rows sit under it, by key."
+            },
             {
               "kind": "field",
               "name": "heardSort",
@@ -154997,6 +155844,52 @@
               },
               "description": "The checkbox in the heading: every row that can be chosen, or none of\nthem where each already is. A `disabled` row keeps what it had."
             },
+            {
+              "kind": "field",
+              "name": "single",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether the table selects one row at a time.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "replaces",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether a press or a move on a row selects it alone.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "chooseOnly",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "at",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "Selects the drawn row `at` alone, and makes it where a range runs from.\nAsks nothing where it is already the only one selected."
+            },
+            {
+              "kind": "field",
+              "name": "handleRowClick",
+              "privacy": "private",
+              "readonly": true,
+              "description": "A press on a row under `selection-behavior=\"replace\"`: it selects the row\nalone, Control or Command adds or takes out the row, and Shift takes in\nthe rows from the one last chosen. A press on the row's own controls, its\ncheckbox or its grip is theirs."
+            },
             {
               "kind": "field",
               "name": "anchorKey",
@@ -155267,6 +156160,65 @@
               },
               "description": "Tells every row which edge each of its cells lines up against.\n\n**A rule in each row's shadow root, keyed on position and written by this\ntable.** The cells are the consumer's markup, so nothing may be written onto\nthem, and each of the other ways fails somewhere a table goes:\n\n- This element's own sheet cannot reach them. `::slotted()` matches what is\n  assigned here, which is the rows, and never a row's children.\n- A property per column published here, `--table-align-2: end`, still needs\n  a rule that knows which column a cell is in, and a fixed ladder of\n  `:nth-child` rules in a static sheet is a ceiling on the column count.\n- A custom state set on each cell by script is right only until a cell\n  moves, and a cell moving inside a row changes no child list this element\n  watches.\n\n`:nth-child` is matched by the browser against wherever a cell is now, so a\ncell that moves takes its new column's edge with no script at all; a column\nthat moves rewrites the rules on the render the watcher asks for; and a\ncolumn hidden along with its cells keeps its place in both counts, since\n`:nth-child` counts a hidden sibling the way `tableColumns` counts a hidden\ncolumn. The row is where they go because only the shadow root holding a\nslot can style what is assigned to it.\n\n**A custom property and nothing else**, which is how this tier publishes a\nfact: the edge is the author's declaration, and what lining up means, a\n`justify-content` or a `text-align`, belongs to whoever draws the cell.\n`initial` on every cell first, so a table nested in an aligned cell does not\ntake the outer column's edge for columns of its own that set none."
             },
+            {
+              "kind": "field",
+              "name": "endWatcher",
+              "type": {
+                "text": "IntersectionObserver | undefined"
+              },
+              "privacy": "private",
+              "description": "Watches the end of a `load-more` table coming near the box that scrolls it."
+            },
+            {
+              "kind": "field",
+              "name": "watchedEnd",
+              "type": {
+                "text": "Element | undefined"
+              },
+              "privacy": "private",
+              "description": "The end being watched, so a new one is watched again."
+            },
+            {
+              "kind": "field",
+              "name": "askedAt",
+              "type": {
+                "text": "number | undefined"
+              },
+              "privacy": "private",
+              "description": "The number of rows `helix-load-more` was last sent for."
+            },
+            {
+              "kind": "method",
+              "name": "watchEnd",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Starts or stops watching the end of the table, against the box that\nscrolls it, or the page, with a screen of room below it, so the next rows\nare asked for before a reader reaches the last. List does the same."
+            },
+            {
+              "kind": "field",
+              "name": "endInView",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the end of the table was in reach when last measured."
+            },
+            {
+              "kind": "method",
+              "name": "askForMore",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Sends `helix-load-more`, once for each number of rows, and never while loading."
+            },
             {
               "kind": "method",
               "name": "renderGripHead",
@@ -155278,6 +156230,17 @@
               },
               "description": "The heading over the row grips, named by `row-grips-label`."
             },
+            {
+              "kind": "method",
+              "name": "renderExpandHead",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "description": "The heading over the disclosure buttons, in a table whose rows nest."
+            },
             {
               "kind": "method",
               "name": "renderSelectAll",
@@ -155818,6 +156781,22 @@
               "name": "helix-before-reorder",
               "reactProp": "onhelix-before-reorder"
             },
+            {
+              "type": {
+                "text": "HelixBeforeToggleEvent"
+              },
+              "description": "Fired from a row when its disclosure button is pressed, with whether it would be open in `detail.checked`. Cancelable: cancel it to keep the row as it is.",
+              "name": "helix-before-toggle",
+              "reactProp": "onhelix-before-toggle"
+            },
+            {
+              "type": {
+                "text": "HelixLoadMoreEvent"
+              },
+              "description": "Fired, in a table with `load-more`, when the end of the table comes within a screen of view, once for each number of rows.",
+              "name": "helix-load-more",
+              "reactProp": "onhelix-load-more"
+            },
             {
               "type": {
                 "text": "HelixReorderEvent"
@@ -155857,6 +156836,14 @@
               "description": "Fired after the sort order changes, with the new order.",
               "name": "helix-sorted",
               "reactProp": "onhelix-sorted"
+            },
+            {
+              "type": {
+                "text": "HelixToggleEvent"
+              },
+              "description": "Fired from a row once the rows under it are shown or hidden, with whether it is open in `detail.checked`.",
+              "name": "helix-toggle",
+              "reactProp": "onhelix-toggle"
             }
           ],
           "attributes": [
@@ -155887,6 +156874,15 @@
               "description": "The column widths as one track list, written once on the table.\n\nWith `TableColumn` children, each track sizes the column in its place, a\nhidden column counted, so hiding one takes its track with it and the rest\nkeep theirs. The columns decide how many tracks there are and this list\nonly how wide: a track past the last column is dropped, and a column past\nthe last track shares what is left. With no columns declared it is the\nwhole track list. Tracks count as the grid counts them, so `minmax(0, 1fr)`\nis one and `repeat(2, 8rem)` is two, and one the grid would refuse leaves\nits column at the default rather than taking the table down to one column.\n\n**A column's own `width` wins over its track here.** The width is written\non the column it sizes, which is the more particular statement, and it is\nwhere a resize lands: a reader dragging a column's edge writes `width`, so\nwere this list to win, the drag would move the separator and leave the\ntrack where the list put it. This is the table's default for its columns,\nand each column may say otherwise.\n\n**It is also the only track list a server can send.** The shim has no tree\nto walk, so a render there knows of no columns and this attribute is the\nwhole answer: a table given one lays its grid out in the first paint, and a\ntable sized only by its columns is one track wide until it upgrades.\n\n**Data Table has none of this, and should not.** Its columns are its schema\nrather than an option, so there is always a column to write a `width` on\nand a list here would be a second way to say what that says. This table's\ncells are markup, and a table written as rows of cells with no column\ndeclared in it has nowhere else to be sized from.",
               "fieldName": "columns"
             },
+            {
+              "name": "default-expanded",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The keys of the rows whose rows are shown at the start, separated by\ncommas. Used until `expanded` is set.",
+              "fieldName": "defaultExpanded"
+            },
             {
               "name": "default-selected",
               "type": {
@@ -155932,6 +156928,32 @@
               "description": "The text shown and announced when the rows could not load. Set it when a\nfetch fails, and clear it once you try again. Empty, the default, shows\nnothing.\n\nWhile it is set, a line after the rows shows it, or your own content in the\n`error` slot, in place of the empty and loading lines, and the live region\nsays it.",
               "fieldName": "errorText"
             },
+            {
+              "name": "expand-column-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Expand'",
+              "description": "The name of the heading over the disclosure buttons.",
+              "fieldName": "expandColumnLabel"
+            },
+            {
+              "name": "expanded",
+              "type": {
+                "text": "string"
+              },
+              "description": "The keys of the rows whose rows are shown, separated by commas, in a table\nwhose rows nest. A press on a row's disclosure button asks first, and\n`default-expanded` seeds what this element then owns.",
+              "fieldName": "expanded"
+            },
+            {
+              "name": "expand-row-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Expand {row}'",
+              "description": "The name of a row's disclosure button. `{row}` is the words of the row's first cell.",
+              "fieldName": "expandRowLabel"
+            },
             {
               "name": "fallback-label",
               "type": {
@@ -155959,6 +156981,15 @@
               "description": "Accessible name for the table.\n\nAn `aria-label` or `aria-labelledby` on the host names the table too, and\nwins over this.",
               "fieldName": "label"
             },
+            {
+              "name": "load-more",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Sends `helix-load-more` once the end of the table comes within a screen\nof view, so you can add the next rows as a reader nears them.",
+              "fieldName": "loadMore"
+            },
             {
               "name": "moved-label",
               "type": {
@@ -156022,6 +157053,15 @@
               "description": "The name of the checkbox in the heading that selects every row.",
               "fieldName": "selectAllLabel"
             },
+            {
+              "name": "select-column-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Select'",
+              "description": "The name of the heading over the checkboxes under\n`selection-mode=\"single\"`, where it holds no checkbox of its own.",
+              "fieldName": "selectColumnLabel"
+            },
             {
               "name": "selected",
               "type": {
@@ -156039,6 +157079,23 @@
               "description": "What screen readers hear when the chosen rows change. `{count}` is how many\nrows are chosen, written in the locale, and a language that needs plural\nforms writes them: `{count, plural, one {# wybrany} few {# wybrane} many\n{# wybranych} other {# wybranego}}`.",
               "fieldName": "selectedLabel"
             },
+            {
+              "name": "selection-behavior",
+              "type": {
+                "text": "'replace' | 'toggle'"
+              },
+              "default": "'toggle'",
+              "description": "What a press on a row, or in a `grid` table a key that moves to one, does\nto the rows already selected: `toggle`, the default, leaves them to the\ncheckboxes, and `replace` selects the row alone.",
+              "fieldName": "selectionBehavior"
+            },
+            {
+              "name": "selection-mode",
+              "type": {
+                "text": "'multiple' | 'single' | undefined"
+              },
+              "description": "How many rows a `selectable` table selects: `multiple`, the default, or\n`single`, one at a time.",
+              "fieldName": "selectionMode"
+            },
             {
               "name": "select-row-label",
               "type": {
@@ -156197,8 +157254,14 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The row renders its cells straight through and lays out none of them, so a\nstylesheet can place them in the table's grid and every column lines up\nacross rows. The row still exists as an element, so you can style it, hide\nit, or make it interactive.\n\nIn a `selectable` table the row draws a checkbox cell before its own cells,\nand `value` is the key the table's `selected` lists it by. `disabled` keeps\nthe row out of the selection and out of its link.\n\nIn a `reorderable` table the row draws a grip cell before those, holding a\nbutton named by the table's `move-row-label`, and `value` is the key\n`helix-reorder` lists it by. The table says which row is moving and where\nthe drop indicator is, with the `dragging`, `drop-before`, and `drop-after`\nstates.\n\n**`href` makes the whole row a link**, as a row action does in React Aria's\ntable: a press anywhere on the row follows it, except on a link or a control\nof the row's own, and Control, Command or Shift open it the way they open a\nlink. A drag that selects text follows nothing. A row in a table is not a\nstop of its own, so put the same link in a cell, usually the row header,\nwhich is what the keyboard and a screen reader reach. In a `grid` table,\nEnter on any cell of the row follows it as well.",
+          "description": "The row renders its cells straight through and lays out none of them, so a\nstylesheet can place them in the table's grid and every column lines up\nacross rows. The row still exists as an element, so you can style it, hide\nit, or make it interactive.\n\nIn a `selectable` table the row draws a checkbox cell before its own cells,\nand `value` is the key the table's `selected` lists it by. `disabled` keeps\nthe row out of the selection and out of its link.\n\nIn a `reorderable` table the row draws a grip cell before those, holding a\nbutton named by the table's `move-row-label`, and `value` is the key\n`helix-reorder` lists it by. The table says which row is moving and where\nthe drop indicator is, with the `dragging`, `drop-before`, and `drop-after`\nstates.\n\n**`parent` nests the row under another**, by that row's key. The table\nthen draws a column of disclosure buttons: a row with rows under it has one,\nnamed by the table's `expand-row-label` and saying whether it is open with\n`aria-expanded`, and its rows are drawn only while it is open. The cell is\nindented by the row's depth through `--table-row-level`.\n\n**`href` makes the whole row a link**, as a row action does in React Aria's\ntable: a press anywhere on the row follows it, except on a link or a control\nof the row's own, and Control, Command or Shift open it the way they open a\nlink. A drag that selects text follows nothing. A row in a table is not a\nstop of its own, so put the same link in a cell, usually the row header,\nwhich is what the keyboard and a screen reader reach. In a `grid` table,\nEnter on any cell of the row follows it as well.",
           "name": "HelixHeadlessTableRow",
+          "cssProperties": [
+            {
+              "description": "Written by the row on its `expand` cell: how deep the row sits, from 1. Do not set it.",
+              "name": "--table-row-level"
+            }
+          ],
           "cssParts": [
             {
               "description": "The row's checkbox, in a `selectable` table.",
@@ -156244,6 +157307,18 @@
               "description": "Added to `checkbox-mark` while only some rows are selected.",
               "name": "checkbox-mark-indeterminate"
             },
+            {
+              "description": "The cell that holds the row's disclosure button, in a table whose rows nest. It carries `--table-row-level`, the row's depth from 1.",
+              "name": "expand"
+            },
+            {
+              "description": "The button that shows and hides the rows under this one.",
+              "name": "expand-button"
+            },
+            {
+              "description": "The caret on the disclosure button, which points along the line, turned down by the styled tier while the row is open.",
+              "name": "expand-mark"
+            },
             {
               "description": "The cell that holds the row's grip, in a `reorderable` table.",
               "name": "grip"
@@ -156293,6 +157368,16 @@
               "description": "The URL a press on the row follows, which makes the whole row a link.\nEmpty, the default, leaves presses to the row's cells.",
               "attribute": "href"
             },
+            {
+              "kind": "field",
+              "name": "parent",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The key of the row this one sits under, in a table whose rows nest: that\nrow's `value`, or its place among the rows where it has none. Empty, the\ndefault, is a row at the top.",
+              "attribute": "parent"
+            },
             {
               "kind": "field",
               "name": "rel",
@@ -156369,6 +157454,17 @@
               },
               "description": "The grip cell, in a `reorderable` table: a cell of the row's own before the\ncheckbox cell, holding the button that moves the row. In a grid the cell\ntakes focus and Space or Enter on it picks the row up, and the button\nleaves the tab order. `aria-disabled` while a sort decides the order."
             },
+            {
+              "kind": "method",
+              "name": "renderExpand",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "description": "The disclosure cell, in a table whose rows nest: a button where rows sit\nunder this one, and an empty cell where none do, so the columns stay in\nline. In a grid the cell takes focus and Space or Enter on it presses the\nbutton, which leaves the tab order."
+            },
             {
               "kind": "field",
               "name": "tier",
@@ -156728,6 +157824,15 @@
               "description": "The URL a press on the row follows, which makes the whole row a link.\nEmpty, the default, leaves presses to the row's cells.",
               "fieldName": "href"
             },
+            {
+              "name": "parent",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The key of the row this one sits under, in a table whose rows nest: that\nrow's `value`, or its place among the rows where it has none. Empty, the\ndefault, is a row at the top.",
+              "fieldName": "parent"
+            },
             {
               "name": "rel",
               "type": {
@@ -156769,6 +157874,10 @@
               "description": "The row being moved goes before this one when it is dropped.",
               "name": "drop-before"
             },
+            {
+              "description": "While the rows under this one are shown.",
+              "name": "expanded"
+            },
             {
               "description": "While the row has `href` and is not `disabled`, so a press on it follows the link.",
               "name": "link"
@@ -157825,15 +158934,22 @@
                   "type": {
                     "text": "string"
                   }
+                },
+                {
+                  "name": "cause",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
                 }
               ],
-              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction.",
+              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction. `cause` says why, where the family names its\ncauses, and reaches the event as `detail.cause`.",
               "inheritedFrom": {
                 "name": "MixinControllerActive",
                 "module": "src/mixins/mixin-controller-active/mixin-controller-active.ts"
               },
               "type": {
-                "text": "requestActive(next: string) => boolean"
+                "text": "requestActive(next: string, cause?: string) => boolean"
               }
             },
             {
@@ -170171,7 +171287,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Given `datetime`, the label you write is wrapped in a `<time>` element, so a\nmachine-readable value such as \"2026-08-19\" travels with a label such as\n\"yesterday\". Without `datetime`, the label is a `<span>`.\n\n**`relative` writes the time for you** as how long ago it was, such as \"3\nhours ago\", from `datetime`, where the `time` slot is empty. The words move\non as they go stale, \"3 hours ago\" becoming \"4 hours ago\", with one wakeup\nshared by every reading on the page, as `FormatDate` keeps its own. They are\nin the language of the page, or of the nearest `lang`.\n\nEach entry draws the connector line that arrives at it and hides it when it\nis the first entry, using `:host(:first-child)`. This needs no index, no\ncounting parent, and no script. `Steps` and `Breadcrumbs` work the same way.\n\n`tone` sets the kind of event and is the only thing that colors the mark. It\nuses the same values as `Announcement`.",
+          "description": "Given `datetime`, the label you write is wrapped in a `<time>` element, so a\nmachine-readable value such as \"2026-08-19\" travels with a label such as\n\"yesterday\". Without `datetime`, the label is a `<span>`.\n\n**`relative` writes the time for you** as how long ago it was, such as \"3\nhours ago\", from `datetime`, where the `time` slot is empty. The words move\non as they go stale, \"3 hours ago\" becoming \"4 hours ago\", with one wakeup\nshared by every reading on the page, as `FormatDate` keeps its own. They are\nin the language of the page, or of the nearest `lang`.\n\nEach entry draws the connector line that arrives at it and hides it when it\nis the first entry, using `:host(:first-child)`. This needs no index, no\ncounting parent, and no script. `Steps` and `Breadcrumbs` work the same way.\n\n`tone` sets the kind of event and is the only thing that colors the mark. It\nuses the same values as `Announcement`. **A screen reader hears the tone as\na word**, from `tone-labels`: the mark is an image named \"Error\",\n\"Information\", \"Success\" or \"Warning\", so the color is not the only place\nthe meaning is. `neutral` and `primary` say nothing unless you name them.\n\n**`pending` marks an event that has not happened yet**, such as one that is\nscheduled. The mark is the open circle, and a screen reader hears\n`pending-label`, \"Scheduled\", with the tone's word.",
           "name": "HelixHeadlessTimelineItem",
           "cssParts": [
             {
@@ -170183,7 +171299,7 @@
               "name": "dot"
             },
             {
-              "description": "The mark on the line.",
+              "description": "The mark on the line. An image named by the tone's word, and by `pending-label`, where either applies.",
               "name": "marker"
             },
             {
@@ -170201,7 +171317,7 @@
               "name": ""
             },
             {
-              "description": "The mark on the line. Defaults to a dot, which is the slot's fallback content.",
+              "description": "The mark on the line. Defaults to a dot, which is the slot's fallback content. A mark you slot is read as the tone's word, where the entry has one.",
               "name": "marker"
             },
             {
@@ -170210,6 +171326,16 @@
             }
           ],
           "members": [
+            {
+              "kind": "field",
+              "name": "words",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-timeline-item'",
+              "description": "The key this part's words are registered under, its styled tag:\n`registerWords('de', { 'helix-timeline-item': { toneLabels: { danger: 'Fehler' } } })`."
+            },
             {
               "kind": "field",
               "name": "datetime",
@@ -170222,12 +171348,14 @@
             },
             {
               "kind": "field",
-              "name": "relative",
+              "name": "pending",
               "type": {
-                "text": "'long' | 'narrow' | 'short' | undefined"
+                "text": "boolean"
               },
-              "description": "Writes the time as how long ago it was, or how long until it, from\n`datetime`, where the `time` slot is empty: `long` (\"3 hours ago\"),\n`short` (\"3 hr. ago\") or `narrow` (\"3h ago\"). Set with no value, it is\n`long`. The words move on as they go stale.",
-              "attribute": "relative"
+              "default": "false",
+              "description": "Marks an event that has not happened yet, such as one that is scheduled.\nThe mark is the open circle, and a screen reader hears `pending-label`.",
+              "attribute": "pending",
+              "reflects": true
             },
             {
               "kind": "field",
@@ -170282,16 +171410,71 @@
               ],
               "description": "What the reading says at `now`, and when it stops being true."
             },
+            {
+              "kind": "field",
+              "name": "pendingLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Scheduled'",
+              "description": "What a screen reader hears for an entry that is `pending`.",
+              "attribute": "pending-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "relative",
+              "type": {
+                "text": "'long' | 'narrow' | 'short' | undefined"
+              },
+              "description": "Writes the time as how long ago it was, or how long until it, from\n`datetime`, where the `time` slot is empty: `long` (\"3 hours ago\"),\n`short` (\"3 hr. ago\") or `narrow` (\"3h ago\"). Set with no value, it is\n`long`. The words move on as they go stale.",
+              "attribute": "relative"
+            },
             {
               "kind": "field",
               "name": "tone",
               "type": {
                 "text": "'danger' | 'info' | 'neutral' | 'primary' | 'success' | 'warning' | undefined"
               },
-              "description": "The kind of event. It sets the color of the mark and nothing else.",
+              "description": "The kind of event. It sets the color of the mark, and a screen reader\nhears it as the word `tone-labels` gives it.",
               "attribute": "tone",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "toneLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "What a screen reader is told this entry's tone is, such as \"Failed\".\nAbsent is the tone's word in `tone-labels`.",
+              "attribute": "tone-label"
+            },
+            {
+              "kind": "field",
+              "name": "toneLabels",
+              "type": {
+                "text": "Partial<Record<TimelineTone, string>>"
+              },
+              "default": "{ danger: 'Error', info: 'Information', success: 'Success', warning: 'Warning', }",
+              "description": "What a screen reader is told each tone is, by the tone's name, written as\nJSON in the attribute: `tone-labels='{\"danger\":\"Failed\"}'`. A tone with no\nword is not read, which is `neutral` and `primary` in English.",
+              "attribute": "tone-labels",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "markName",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "private",
+              "description": "What the mark says: the tone's word and the pending word, where either applies.",
+              "readonly": true
+            },
             {
               "kind": "method",
               "name": "renderMarker",
@@ -170301,7 +171484,7 @@
                   "text": "TemplateResult"
                 }
               },
-              "description": "The mark for an entry that slotted none, which the tone decides.\n\n**A seam is a `protected render…()` and never a getter.** A slot's fallback\nanswers a consumer and a seam answers the tier above, and a getter answers\nneither. The check tests for parentheses, `${this.x}` being permitted\nbecause a property is not markup a tier would redraw, so a getter returning\na template reads as a bare reference and is let through.\n\nToned entries are reporting something, so they take the circle with a\ncenter, which is `Steps` drawing the stage a reader is standing on. Untoned\nones are just things that happened and take the open circle, which is\n`Steps` drawing a stage nobody has reached. The same two glyphs in both\ncomponents rather than two that resemble each other: a shape drawn twice\ndrifts, and these are already the marks a reader has learned one page over."
+              "description": "The mark for an entry that slotted none, which the tone decides.\n\n**A seam is a `protected render…()` and never a getter.** A slot's fallback\nanswers a consumer and a seam answers the tier above, and a getter answers\nneither. The check tests for parentheses, `${this.x}` being permitted\nbecause a property is not markup a tier would redraw, so a getter returning\na template reads as a bare reference and is let through.\n\nToned entries are reporting something, so they take the circle with a\ncenter, which is `Steps` drawing the stage a reader is standing on. Untoned\nones are just things that happened and take the open circle, which is\n`Steps` drawing a stage nobody has reached, and so does a `pending`\nentry, which nobody has reached yet either. The same two glyphs in both\ncomponents rather than two that resemble each other: a shape drawn twice\ndrifts, and these are already the marks a reader has learned one page over."
             },
             {
               "kind": "field",
@@ -170653,6 +171836,24 @@
               "description": "When it happened, in machine-readable form. Setting it wraps the time in a\n`<time>` element.\n\nWhatever `<time>` accepts, which is a date, a time, both, a duration or a\nweek. Unset, the label is written as it was given and nothing claims to\nknow what instant it names.",
               "fieldName": "datetime"
             },
+            {
+              "name": "pending",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Marks an event that has not happened yet, such as one that is scheduled.\nThe mark is the open circle, and a screen reader hears `pending-label`.",
+              "fieldName": "pending"
+            },
+            {
+              "name": "pending-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Scheduled'",
+              "description": "What a screen reader hears for an entry that is `pending`.",
+              "fieldName": "pendingLabel"
+            },
             {
               "name": "relative",
               "type": {
@@ -170666,8 +171867,26 @@
               "type": {
                 "text": "'danger' | 'info' | 'neutral' | 'primary' | 'success' | 'warning' | undefined"
               },
-              "description": "The kind of event. It sets the color of the mark and nothing else.",
+              "description": "The kind of event. It sets the color of the mark, and a screen reader\nhears it as the word `tone-labels` gives it.",
               "fieldName": "tone"
+            },
+            {
+              "name": "tone-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "What a screen reader is told this entry's tone is, such as \"Failed\".\nAbsent is the tone's word in `tone-labels`.",
+              "fieldName": "toneLabel"
+            },
+            {
+              "name": "tone-labels",
+              "type": {
+                "text": "Partial<Record<TimelineTone, string>>"
+              },
+              "default": "{ danger: 'Error', info: 'Information', success: 'Success', warning: 'Warning', }",
+              "description": "What a screen reader is told each tone is, by the tone's name, written as\nJSON in the attribute: `tone-labels='{\"danger\":\"Failed\"}'`. A tone with no\nword is not read, which is `neutral` and `primary` in English.",
+              "fieldName": "toneLabels"
             }
           ],
           "superclass": {
@@ -181857,15 +183076,22 @@
                   "type": {
                     "text": "string"
                   }
+                },
+                {
+                  "name": "cause",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
                 }
               ],
-              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction.",
+              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction. `cause` says why, where the family names its\ncauses, and reaches the event as `detail.cause`.",
               "inheritedFrom": {
                 "name": "MixinControllerActive",
                 "module": "src/mixins/mixin-controller-active/mixin-controller-active.ts"
               },
               "type": {
-                "text": "requestActive(next: string) => boolean"
+                "text": "requestActive(next: string, cause?: string) => boolean"
               }
             },
             {
@@ -183515,6 +184741,10 @@
               "description": "The list item that holds the button.",
               "name": "container"
             },
+            {
+              "description": "The `indicator` slot, at the end of the row, rendered only while the entry is playing. It draws no box until you give it one.",
+              "name": "indicator"
+            },
             {
               "description": "The row, which is a button.",
               "name": "item"
@@ -183541,6 +184771,10 @@
               "description": "The entry's name.",
               "name": ""
             },
+            {
+              "description": "A mark shown on the entry that is playing, such as an equalizer icon. Rendered only while the entry is current.",
+              "name": "indicator"
+            },
             {
               "description": "A thumbnail. Defaults to an image of `poster`.",
               "name": "media"
@@ -183571,6 +184805,14 @@
               "attribute": "disabled",
               "reflects": true
             },
+            {
+              "kind": "field",
+              "name": "focusable",
+              "type": {
+                "text": "boolean | undefined"
+              },
+              "description": "Whether the entry holds the playlist's tab stop. Unset, every entry is in\nthe tab order, which is what a server renders.\n\n**Written by the playlist, with no attribute, and it reaches the button.**\nThe playlist gives the stop to the entry a reader last focused, or to the\ncurrent one, and the arrow keys reach the rest."
+            },
             {
               "kind": "field",
               "name": "poster",
@@ -184241,6 +185483,25 @@
               "readonly": true,
               "description": "Notes the menu opening and closing, for the built-in trigger.\n\nThe trigger is this element's own button, so the state is written onto it\nhere. The menu cannot write onto a plain button slotted into it."
             },
+            {
+              "kind": "method",
+              "name": "focusPlaying",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "menu",
+                  "type": {
+                    "text": "HTMLElement & { updateComplete?: Promise<unknown> }"
+                  }
+                }
+              ],
+              "description": "Puts focus on the entry playing once the menu has opened, as a list of\nchoices opens on the one chosen. The menu focuses its first row as it\nopens, so this follows that."
+            },
             {
               "kind": "field",
               "name": "observer",
@@ -184895,9 +186156,13 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "**You slot the player**, so it keeps your appearance, extra controls,\ncaptions, and poster treatment. `Sandbox` takes its preview and `Menu` its\ntrigger the same way.\n\n**Entries are markup.** React skips properties it would set imperatively\nduring hydration, so an array property on a custom element is missing on the\nfirst paint of a server-rendered page. `using-the-elements.mdx` has the\nmeasurement. Markup also makes each entry a real button with its name inside.\n\n**The playlist does not play media.** It sets `src` on the player and tracks\nwhich entry is current. The current entry moves when:\n\n- an entry is pressed,\n- the player dispatches `helix-next` or `helix-previous`, or\n- the player reaches the end.\n\nOn `ended` the playlist advances and the next clip starts playing, because\nthe user already pressed play once. `repeat` decides what happens at the\nend: `one` plays the same entry again, and `all` goes from the last entry\nback to the first. Without it, the playlist stops on the last entry and\nsends `helix-end`. `shuffle` plays the entries in a random order, starting\nfrom the one that is current, and `previous` retraces that order.\n\n**The player is named by the current entry**, and the device's own media\ncontrols show the entry as the title. A player you gave a `label` keeps\nyour name, and only the title follows the entry.\n\n**Keyboard.** Each entry is a button in the tab order, and Enter or Space\nplays it. The arrow keys move focus to the entry before or after, and Home\nand End to the first and the last, passing over disabled entries. The\ncurrent entry carries `aria-current`. While focus is on the player, the\nplayer's own keys work, and `Video` lists them, and Shift with N or P plays\nthe next or the previous entry. The player's previous and next controls\nmove through the entries in the same order the playlist does.\n\n**What a screen reader hears.** A list named by `label`, with a button for\neach entry. When the playlist moves to another entry, by a press, by the\nplayer's controls, or at the end of a clip, a live region says\n`playing-label`, \"Now playing\" and the entry's name.",
+          "description": "**You slot the player**, so it keeps your appearance, extra controls,\ncaptions, and poster treatment. `Sandbox` takes its preview and `Menu` its\ntrigger the same way.\n\n**Entries are markup.** React skips properties it would set imperatively\nduring hydration, so an array property on a custom element is missing on the\nfirst paint of a server-rendered page. `using-the-elements.mdx` has the\nmeasurement. Markup also makes each entry a real button with its name inside.\n\n**The playlist does not play media.** It sets `src` on the player and tracks\nwhich entry is current. The current entry moves when:\n\n- an entry is pressed,\n- the player dispatches `helix-next` or `helix-previous`, or\n- the player reaches the end.\n\nOn `ended` the playlist advances and the next clip starts playing, because\nthe user already pressed play once. `no-advance` turns that off, and the\nplaylist stays on the entry that ended. `repeat` decides what happens at the\nend: `one` plays the same entry again, and `all` goes from the last entry\nback to the first. Without it, the playlist stops on the last entry and\nsends `helix-end`. `shuffle` plays the entries in a random order, starting\nfrom the one that is current, and `previous` retraces that order.\n\n**`helix-before-activate` says why the playlist is moving**, in\n`detail.cause`: `press` for an entry or a menu choice, `next` and\n`previous` for the player's controls and the methods, `ended` at the end of\na clip, and `removed` when the current entry leaves the playlist. Cancel an\n`ended` move to show your own \"Up next\" countdown, then call `next()`.\n\n**Removing the current entry moves the playlist on**, to the entry after it,\nor to the one before it when it was the last. A clip that was playing keeps\nplaying in the entry that takes its place.\n\n**The player is named by the current entry**, and the device's own media\ncontrols show the entry as the title. A player you gave a `label` keeps\nyour name, and only the title follows the entry.\n\n**Keyboard.** The entries take one stop in the tab order: the entry you\nlast focused, or the current entry before you have focused one. Enter or\nSpace plays it. The arrow keys move focus to the entry before or after, and\nHome and End to the first and the last, passing over disabled entries. The\ncurrent entry carries `aria-current`. While focus is on the player, the\nplayer's own keys work, and `Video` lists them, and Shift with N or P plays\nthe next or the previous entry. The player's previous and next controls\nmove through the entries in the same order the playlist does.\n\n**What a screen reader hears.** A list named by `label`, with a button for\neach entry. When the playlist moves to another entry, by a press, by the\nplayer's controls, or at the end of a clip, a live region says\n`playing-label`, \"Now playing\" and the entry's name.",
           "name": "HelixHeadlessVideoPlaylist",
           "cssParts": [
+            {
+              "description": "The box that holds the `empty` slot, drawn while there are no entries.",
+              "name": "empty"
+            },
             {
               "description": "The list of entries.",
               "name": "items"
@@ -184916,6 +186181,10 @@
               "description": "The entries.",
               "name": ""
             },
+            {
+              "description": "Shown while the playlist has no entries. Defaults to `empty-label`.",
+              "name": "empty"
+            },
             {
               "description": "The player that plays the entries.",
               "name": "player"
@@ -184932,6 +186201,19 @@
               "default": "'helix-video-playlist'",
               "description": "The key this family's words are registered under, its styled tag:\n`registerWords('de', { 'helix-video-playlist': { label: 'Wiedergabeliste' } })`."
             },
+            {
+              "kind": "field",
+              "name": "emptyLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'No videos'",
+              "description": "What the playlist says while it has no entries. The `empty` slot replaces it.",
+              "attribute": "empty-label",
+              "helix": {
+                "words": true
+              }
+            },
             {
               "kind": "field",
               "name": "label",
@@ -184945,6 +186227,16 @@
                 "words": true
               }
             },
+            {
+              "kind": "field",
+              "name": "noAdvance",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Stays on an entry when its clip ends, where the playlist would otherwise\nplay the next one. The player's controls, a press, and `next()` still\nmove. `repeat=\"one\"` still plays the entry again.",
+              "attribute": "no-advance"
+            },
             {
               "kind": "field",
               "name": "playingLabel",
@@ -185014,6 +186306,43 @@
               "default": "false",
               "description": "Whether the entry changed because somebody moved through the playlist.\n\nAll three ways it moves are the reader going somewhere: pressing an entry,\npressing next or previous, or a clip ending and the next one following it.\nEvery one of those means play, and the one case that does not is the first\nrender, where the playlist is simply pointing the player at its opening\nentry and nobody has asked for anything yet.\n\nA press is also what makes the play legal. Autoplay is refused when nothing\nthe reader did asked for it, so starting here works because this is inside\nthe gesture that chose the entry, and where it is refused anyway the player\nshows its start control and waits."
             },
+            {
+              "kind": "field",
+              "name": "known",
+              "type": {
+                "text": "{ current: string | undefined; values: string[] }"
+              },
+              "privacy": "private",
+              "default": "{ current: undefined, values: [], }",
+              "description": "The entries' values in the order of the last update, and the one that was\ncurrent then. Read when entries leave, to find the neighbor of a current\nentry that has gone."
+            },
+            {
+              "kind": "field",
+              "name": "stop",
+              "type": {
+                "text": "string | undefined"
+              },
+              "privacy": "private",
+              "description": "The entry that holds the list's tab stop: the one a reader last focused.\nBefore they focus one, the current entry holds it."
+            },
+            {
+              "kind": "field",
+              "name": "pointed",
+              "type": {
+                "text": "HelixHeadlessVideoPlaylistItem | undefined"
+              },
+              "privacy": "private",
+              "description": "The entry the player was last pointed at."
+            },
+            {
+              "kind": "field",
+              "name": "watcher",
+              "type": {
+                "text": "MutationObserver | undefined"
+              },
+              "privacy": "private",
+              "description": "Hears entries arrive and leave, which change no property here."
+            },
             {
               "kind": "field",
               "name": "player",
@@ -185058,6 +186387,12 @@
                   "type": {
                     "text": "number"
                   }
+                },
+                {
+                  "name": "cause",
+                  "type": {
+                    "text": "'ended' | 'next' | 'previous'"
+                  }
                 }
               ],
               "description": "Moves by one in the playing order and plays what it lands on. At an end it\nstays, unless `repeat` is `all`.\n\nA move a consumer refuses with `helix-before-activate` plays nothing, and\nleaves nothing behind to play on a later change."
@@ -185114,6 +186449,39 @@
               "privacy": "private",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "handleFocusIn",
+              "privacy": "private",
+              "readonly": true,
+              "description": "An entry that takes focus takes the tab stop with it."
+            },
+            {
+              "kind": "field",
+              "name": "handleEntries",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Entries arrived or left. Where the current entry left, the playlist moves\nto the entry after it, or to the one before it when it was the last, and\nkeeps playing where it was playing."
+            },
+            {
+              "kind": "method",
+              "name": "placeStop",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "items",
+                  "type": {
+                    "text": "HelixHeadlessVideoPlaylistItem[]"
+                  }
+                }
+              ],
+              "description": "Gives one entry the tab stop and takes it from the rest: the entry last\nfocused, then the current entry, then the first that can be chosen."
+            },
             {
               "kind": "field",
               "name": "handleKeydown",
@@ -185221,15 +186589,22 @@
                   "type": {
                     "text": "string"
                   }
+                },
+                {
+                  "name": "cause",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
                 }
               ],
-              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction.",
+              "description": "Requests a new current item, and returns whether the change was applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-activate` is\na refusal and nothing moves. Unlike a native control, nothing has moved\nby the time this runs, so refusing is simply not writing: there is\nnothing to put back. Nobody refusing means the set updates itself,\nwhether or not a consumer declared `active`, a declared property being a\nseed and a correction. `cause` says why, where the family names its\ncauses, and reaches the event as `detail.cause`.",
               "inheritedFrom": {
                 "name": "MixinControllerActive",
                 "module": "src/mixins/mixin-controller-active/mixin-controller-active.ts"
               },
               "type": {
-                "text": "requestActive(next: string) => boolean"
+                "text": "requestActive(next: string, cause?: string) => boolean"
               }
             },
             {
@@ -185637,7 +187012,7 @@
               "type": {
                 "text": "HelixBeforeActivateEvent"
               },
-              "description": "The current entry is about to change. Cancelable: cancel it to keep the current entry.",
+              "description": "The current entry is about to change, and `detail.cause` says why: `press`, `next`, `previous`, `ended`, or `removed`. Cancelable: cancel it to keep the current entry.",
               "name": "helix-before-activate",
               "reactProp": "onhelix-before-activate"
             },
@@ -185651,6 +187026,15 @@
             }
           ],
           "attributes": [
+            {
+              "name": "empty-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'No videos'",
+              "description": "What the playlist says while it has no entries. The `empty` slot replaces it.",
+              "fieldName": "emptyLabel"
+            },
             {
               "name": "label",
               "type": {
@@ -185660,6 +187044,15 @@
               "description": "The list's name, read by screen readers.",
               "fieldName": "label"
             },
+            {
+              "name": "no-advance",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Stays on an entry when its clip ends, where the playlist would otherwise\nplay the next one. The player's controls, a press, and `next()` still\nmove. `repeat=\"one\"` still plays the entry again.",
+              "fieldName": "noAdvance"
+            },
             {
               "name": "playing-label",
               "type": {
@@ -189016,7 +190409,7 @@
               }
             }
           ],
-          "description": "Fills one element's holes, its own and those below it, from an item."
+          "description": "Fills one element's holes, its own and those below it, from an item.\n\nThe element itself whatever hole it carries, so a row whose root is a link\ntakes its `data-field-href` as readily as its text."
         },
         {
           "kind": "function",
@@ -189169,6 +190562,52 @@
             }
           ],
           "description": "Which item a key moves to in a list of `count` items laid out `across`\nitems to a line, from `at`.\n\nIndex arithmetic, because most of the items are not drawn: the list moves to\nan index, scrolls it into view, and focuses the row once it is there. The\nkeys are the ones a listbox answers, and in a grid the ones a grid of\noptions answers:\n\n- Up and Down move one line, to the item in the same column. Down from the\n  line above a shorter last line goes to the last item.\n- Left and Right move one item, in a grid only, with `forward` naming the\n  one that moves ahead along the line: Right, or Left on a right-to-left\n  page. In a list they move nothing, and are left to the row.\n- Home and End move to the first and the last item.\n- Page Up and Page Down move by `page` lines, the number of lines on screen\n  less one, so the line at one edge of the box lands at the other.\n\n`undefined` for a key the list does not take, and for an empty list."
+        },
+        {
+          "kind": "function",
+          "name": "skipDisabled",
+          "return": {
+            "type": {
+              "text": "number | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "key",
+              "type": {
+                "text": "string"
+              }
+            },
+            {
+              "name": "from",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "to",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "count",
+              "type": {
+                "text": "number"
+              }
+            },
+            {
+              "name": "disabled",
+              "type": {
+                "text": "(index: number) => boolean"
+              }
+            },
+            {
+              "name": "across",
+              "default": "1"
+            }
+          ],
+          "description": "Where a key lands once disabled items are passed over: from `to`, which\n`stepIndex` gave, on in the way the key moves until an item that is not\ndisabled. A line move steps a line at a time, in the same column. Home looks\nforward from the first item and End back from the last. `undefined` where\nevery item that way is disabled, and the key moves nothing."
         }
       ],
       "exports": [
@@ -189179,6 +190618,14 @@
             "name": "stepIndex",
             "module": "src/virtual-list/keys.ts"
           }
+        },
+        {
+          "kind": "js",
+          "name": "skipDisabled",
+          "declaration": {
+            "name": "skipDisabled",
+            "module": "src/virtual-list/keys.ts"
+          }
         }
       ]
     },
@@ -189298,7 +190745,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The items arrive as data, in one of two ways:\n\n- `items` takes an array. A framework sets it as a property, and React\n  hydration keeps it.\n- `for` names a `<script type=\"application/json\">` that holds an array, which\n  a server sends as markup.\n\nEach item is drawn into a row in one of two ways:\n\n- `renderItem` is a function from an item and its index to the row's\n  content: a Lit template, a string, or a DOM node.\n- A `<template>` child defines one row. `data-field=\"name\"` fills an element\n  with the item's `name` as text, and `data-field-href=\"url\"` writes the\n  item's `url` into `href`, the same for any attribute. A field may be a path\n  of keys, such as `author.name`.\n\nRows are your markup in the light DOM, so your stylesheet styles them.\n\n**A grid.** `columns` lays the items out that many to a line, as a grid of\nequal columns, and windows the set a line at a time, as React Aria's grid\nlayout does. Each item draws one element, a cell of the grid, and\n`estimate` is the height of a line. Space the items with padding inside\neach one, which the list measures with the line.\n\n**Keyboard.** The list is one tab stop.\n\n| Key | What it does |\n|---|---|\n| Down, Up | Moves to the next or the previous item, or in a grid to the item in the same column on the next or the previous line. |\n| Right, Left | In a grid, moves to the next or the previous item along the line, the other way round on a right-to-left page. |\n| Home, End | Moves to the first or the last item. |\n| Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. |\n| A letter or a word | Moves to the next item whose text starts with what you typed. |\n| Tab | Moves into the focused row's own links and buttons, then out of the list. |\n\nAn item that is not drawn is scrolled into view and focused, so a keyboard\nreaches the whole set. When the row holding the tab stop scrolls away, the\nstop moves to the first row on screen. Typing matches each item's\n`text-field`, which is the first `data-field` of the row template by default,\nor the item itself when it is a string or a number.\n\nEach row says its place in the whole set with `aria-posinset` and\n`aria-setsize`, so a screen reader says \"4,000 of 10,000\". The row holding\nfocus stays drawn when it scrolls out.\n\n**Selecting.** `selection-mode` makes the list a list box a reader chooses\nfrom: `single` selects one item and `multiple` any number. Space or a press\nselects an item, Shift with Space, an arrow, Home, End or a press takes in\nthe items from the last one chosen, and Control or Command with A selects\nthem all, in `multiple`. `value` holds the chosen items' keys, separated by\ncommas, in the order of the set: `key-field` names each item's key, and a\nstring or a number item is its own key. A change asks with\n`helix-before-change` and tells with `change`. Each row is an `option`\nmarked `aria-selected`, so a row's own links and buttons are not reached\nthere: keep those to a list without `selection-mode`.\n\n**Loading more.** `helix-range-change` fires as the items on screen change,\nand `range` holds them. `helix-load-more` fires once a reader is within one\nscreen of the end, once for each length of the set: add to `items` and it can\nfire again. While you fetch, set `loading`: the list is busy, and a row after\nthe last item says \"Loading more\" (`loading-label`, or your own content in\nthe `loading` slot). `scrollToIndex` takes a reader to an item.\n\n**An empty list.** Set `empty-label`, or put your own content in the `empty`\nslot, for a row shown when there are no items and none are loading, such as\n\"No messages yet\" and a link to write one. Without either, an empty list\nshows nothing, since a list whose items have not arrived yet has not said\nit has none.\n\nThe list takes the `empty` state while it has read its items and holds none,\nand the `loading` state while `loading` is set, so your stylesheet can\nchange the box around it for either. A list with no name is reported once\nin a development build. Name it with `label` or `aria-label`.\n\n**Row height.** Rows are placed by `estimate` until they are drawn. Then the\nlist reads the drawn rows' height once and places every row by it, so a\nwrong estimate still reaches the last item. Set `measured` for rows of\ndifferent heights. Once the list draws rows of different heights, such as\nrows that wrap on a narrow screen, it places each row by its own height\nwhether `measured` is set or not.\n\nThe list follows its source. A new `items` array, an edit to the script's\ntext, or a script replaced under the same id draws the new rows. A row that\nstays in view keeps its element as the list scrolls.\n\nThe viewport scrolls on this tier. It carries `data-scroller`, and `core`\nships `[data-scroller] { overflow: auto }` into every shadow root, so\n`scrollTop` works with no stylesheet. You still need to set a block size.",
+          "description": "The items arrive as data, in one of two ways:\n\n- `items` takes an array. A framework sets it as a property, and React\n  hydration keeps it.\n- `for` names a `<script type=\"application/json\">` that holds an array, which\n  a server sends as markup.\n\nEach item is drawn into a row in one of two ways:\n\n- `renderItem` is a function from an item and its index to the row's\n  content: a Lit template, a string, or a DOM node.\n- A `<template>` child defines one row. `data-field=\"name\"` fills an element\n  with the item's `name` as text, and `data-field-href=\"url\"` writes the\n  item's `url` into `href`, the same for any attribute. A field may be a path\n  of keys, such as `author.name`.\n\nRows are your markup in the light DOM, so your stylesheet styles them.\n\n**A grid.** `columns` lays the items out that many to a line, as a grid of\nequal columns, and windows the set a line at a time, as React Aria's grid\nlayout does. Each item draws one element, a cell of the grid, and\n`estimate` is the height of a line. `min-column-width` lays out as many\ncolumns as fit the box instead, as React Aria's grid layout does with its\nsmallest item size, and follows the box as it resizes. `gap` spaces the rows, and the columns\nof a grid, by a number of pixels the list counts in each row's place.\n\n**Keyboard.** The list is one tab stop.\n\n| Key | What it does |\n|---|---|\n| Down, Up | Moves to the next or the previous item, or in a grid to the item in the same column on the next or the previous line. |\n| Right, Left | In a grid, moves to the next or the previous item along the line, the other way round on a right-to-left page. |\n| Home, End | Moves to the first or the last item. |\n| Page Down, Page Up | Moves by the number of items, or of lines in a grid, on screen. |\n| A letter or a word | Moves to the next item whose text starts with what you typed. |\n| Escape | Lets go of every chosen item, in a list with `selection-mode`. |\n| Tab | Moves into the focused row's own links and buttons, then out of the list. |\n\nAn item that is not drawn is scrolled into view and focused, so a keyboard\nreaches the whole set. When the row holding the tab stop scrolls away, the\nstop moves to the first row on screen. Typing matches each item's\n`text-field`, which is the first `data-field` of the row template by default,\nor the item itself when it is a string or a number.\n\nEach row says its place in the whole set with `aria-posinset` and\n`aria-setsize`, so a screen reader says \"4,000 of 10,000\". The row holding\nfocus stays drawn when it scrolls out.\n\n**Selecting.** `selection-mode` makes the list a list box a reader chooses\nfrom: `single` selects one item and `multiple` any number. Space or a press\nselects an item, Shift with Space, an arrow, Home, End or a press takes in\nthe items from the last one chosen, and Control or Command with A selects\nthem all, in `multiple`. Escape lets go of every chosen item, and keeps the\nkey from the dialog or menu around the list while there was something to\nlet go of. `value` holds the chosen items' keys, separated by commas, in\nthe order of the set: `key-field` names each item's key, and a string or a\nnumber item is its own key. A change asks with `helix-before-change` and\ntells with `change`. Each row is an `option` marked `aria-selected`, so a\nrow's own links and buttons are not reached there: keep those to a list\nwithout `selection-mode`.\n\n`selection-behavior=\"replace\"` selects the item pressed alone, as a file\nlist does, and the arrow keys carry the selection with them. Control or\nCommand with a press or with Space adds or takes out one item, and with an\narrow moves without selecting.\n\n**Disabled items.** `disabled-keys` names items by their keys, separated by\ncommas. Their rows carry `aria-disabled`, the keys and typing pass over\nthem, and a press, Space, or Control with A does not select them.\n\n**Loading more.** `helix-range-change` fires as the items on screen change,\nand `range` holds them. `helix-load-more` fires once a reader is within one\nscreen of the end, once for each length of the set: add to `items` and it can\nfire again. While you fetch, set `loading`: the list is busy, and a row after\nthe last item says \"Loading more\" (`loading-label`, or your own content in\nthe `loading` slot). `scrollToIndex` takes a reader to an item.\n\n**An empty list.** Set `empty-label`, or put your own content in the `empty`\nslot, for a row shown when there are no items and none are loading, such as\n\"No messages yet\" and a link to write one. Without either, an empty list\nshows nothing, since a list whose items have not arrived yet has not said\nit has none.\n\nThe list takes the `empty` state while it has read its items and holds none,\nand the `loading` state while `loading` is set, so your stylesheet can\nchange the box around it for either. A list with no name is reported once\nin a development build. Name it with `label` or `aria-label`.\n\n**Row height.** Rows are placed by `estimate` until they are drawn. Then the\nlist reads the drawn rows' height once and places every row by it, so a\nwrong estimate still reaches the last item. Set `measured` for rows of\ndifferent heights. Once the list draws rows of different heights, such as\nrows that wrap on a narrow screen, it places each row by its own height\nwhether `measured` is set or not.\n\nThe list follows its source. A new `items` array, an edit to the script's\ntext, or a script replaced under the same id draws the new rows. A row that\nstays in view keeps its element as the list scrolls.\n\nThe viewport scrolls on this tier. It carries `data-scroller`, and `core`\nships `[data-scroller] { overflow: auto }` into every shadow root, so\n`scrollTop` works with no stylesheet. You still need to set a block size.",
           "name": "HelixHeadlessVirtualList",
           "cssParts": [
             {
@@ -189357,6 +190804,16 @@
               "description": "How many items a line holds. One, the default, is a list; more lays the\nitems out as a grid of that many equal columns, windowed a line at a\ntime, with Left and Right moving along a line.",
               "attribute": "columns"
             },
+            {
+              "kind": "field",
+              "name": "disabledKeys",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The keys of the items a reader cannot choose or move to, separated by\ncommas, as `value` writes keys. Their rows carry `aria-disabled`.",
+              "attribute": "disabled-keys"
+            },
             {
               "kind": "field",
               "name": "emptyLabel",
@@ -189387,6 +190844,16 @@
               "description": "The id of the script element that holds the items as JSON. `items` wins\nwhere both are set.",
               "attribute": "for"
             },
+            {
+              "kind": "field",
+              "name": "gap",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "The space between two rows, and between two columns in a grid, in\npixels. The list counts it in each row's place, so a gap does not walk\nthe rows away from the scroll position the way a margin on each row\nwould.",
+              "attribute": "gap"
+            },
             {
               "kind": "field",
               "name": "items",
@@ -189448,14 +190915,34 @@
               "description": "Places each row by its own measured height. Without it, rows are placed\nby one height: `estimate` until rows are drawn, then the drawn rows' height,\nread once. Rows that come out different heights are placed by their own\nheights either way.\n\n**Off by default, because the straight line is better when it holds.** One\nheight makes offset and index convert by division, which can never\ndisagree with itself; measuring is what a set of genuinely different\nheights needs and costs a read of each row as it renders. A list of\none-line rows should leave this alone.",
               "attribute": "measured"
             },
+            {
+              "kind": "field",
+              "name": "minColumnWidth",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "The narrowest a column of a grid may be, in pixels. Set, the list lays\nout as many columns as fit the box at that width, at least one, and\nfollows the box as it resizes, which `columns` then does not decide.",
+              "attribute": "min-column-width"
+            },
             {
               "kind": "field",
               "name": "renderItem",
               "type": {
-                "text": "VirtualListRenderer | undefined"
+                "text": "VirtualListRenderer<any> | undefined"
               },
               "description": "Draws one item into its row, given the item and its index. Set it as a\nproperty.\n\nIt returns what Lit renders: a template from `html`, a string, or a DOM\nnode. The list wraps each result in a `<div>` that carries the row's role\nand place in the set. Where it is unset, the row `<template>` is used."
             },
+            {
+              "kind": "field",
+              "name": "selectionBehavior",
+              "type": {
+                "text": "'replace' | 'toggle'"
+              },
+              "default": "'toggle'",
+              "description": "What a press does to the items already chosen: `toggle` adds or takes out\nthe item, and `replace` selects it alone and lets the arrow keys carry the\nselection, with Control or Command adding or taking out one item.",
+              "attribute": "selection-behavior"
+            },
             {
               "kind": "field",
               "name": "selectionMode",
@@ -189517,7 +191004,7 @@
               "kind": "field",
               "name": "filledBy",
               "type": {
-                "text": "VirtualListRenderer | undefined"
+                "text": "VirtualListRenderer<any> | undefined"
               },
               "privacy": "private",
               "description": "The function the drawn rows were filled by, so a new one draws them again."
@@ -189587,6 +191074,24 @@
               "privacy": "private",
               "description": "Watches the source and the tree around it.\n\n**The list read its source once per `for`**, so a page that wrote new JSON\ninto the script, the way a framework updates a text child, kept the old\nrows. The script's own text is watched, and the tree it sits in, for a\nscript replaced under the same id."
             },
+            {
+              "kind": "field",
+              "name": "sizes",
+              "type": {
+                "text": "ResizeObserver | undefined"
+              },
+              "privacy": "private",
+              "description": "Watches the drawn rows for a change of size after they were drawn: an\nimage that loads, a row that opens, text a page edits in place.\n\n**Measured once, a row that grew later kept its old height**, so the\nwindow and the spacers placed every row after it by the old one. React\nAria's virtualizer observes its items for the same reason. A frame later,\nso a size the next render changes is not asked of the browser's pass over\nthe observers a second time."
+            },
+            {
+              "kind": "field",
+              "name": "resized",
+              "type": {
+                "text": "number | undefined"
+              },
+              "privacy": "private",
+              "description": "The frame the next measure of resized rows waits for."
+            },
             {
               "kind": "field",
               "name": "aria",
@@ -189600,7 +191105,7 @@
               "name": "virtualize",
               "privacy": "private",
               "readonly": true,
-              "default": "new VirtualizeController(this, { container: () => this.partNamed('viewport'), count: () => Math.ceil(this.data.length / this.across), estimate: () => this.estimate, measured: () => this.measured, rows: () => this.lines(), })"
+              "default": "new VirtualizeController(this, { container: () => this.partNamed('viewport'), count: () => Math.ceil(this.data.length / this.across), estimate: () => this.estimate, gap: () => this.space, measured: () => this.measured, rows: () => this.lines(), })"
             },
             {
               "kind": "field",
@@ -189611,6 +191116,16 @@
               "description": "The items on screen, as `items.slice(first, last)` reads them.\n\nRead from the scroll offset when asked. Both are 0 before the list has a\nbox to measure.",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "space",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "description": "The gap in pixels, none where it is not a positive number.",
+              "readonly": true
+            },
             {
               "kind": "field",
               "name": "across",
@@ -189618,9 +191133,49 @@
                 "text": "number"
               },
               "privacy": "private",
-              "description": "How many items a line holds: `columns`, at least one.",
+              "description": "How many items a line holds: as many as fit at `min-column-width` where\nit is set and the box has a width, and `columns` otherwise, at least one.",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "boxWidth",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "How wide the box is, read for `min-column-width`."
+            },
+            {
+              "kind": "field",
+              "name": "widthWatch",
+              "type": {
+                "text": "ResizeObserver | undefined"
+              },
+              "privacy": "private",
+              "description": "Watches the box's width, for `min-column-width`."
+            },
+            {
+              "kind": "field",
+              "name": "measuredAcross",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "1",
+              "description": "The items to a line the measurements were taken at."
+            },
+            {
+              "kind": "method",
+              "name": "watchWidth",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Watches the box for its width while `min-column-width` asks for it."
+            },
             {
               "kind": "method",
               "name": "itemsOn",
@@ -189700,6 +191255,44 @@
               },
               "description": "The drawn lines, for the controller to measure: each row in a list, and\nthe first item of each line in a grid, whose cell is as tall as its line."
             },
+            {
+              "kind": "method",
+              "name": "keepPlace",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "was",
+                  "type": {
+                    "text": "readonly unknown[] | undefined"
+                  }
+                }
+              ],
+              "description": "Keeps the reader on the item they were reading when items arrive before\nit, as a feed loading newer posts above does.\n\n**Every index moves by what arrived**, so the drawn rows are renumbered,\nthe tab stop moves with its item, and the controller is told, which moves\nthe scroll offset by the room the new items take. Recognized where the\nnew array ends with the old one: the same items, or the same keys under\n`key-field`."
+            },
+            {
+              "kind": "method",
+              "name": "watchSize",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "elements",
+                  "type": {
+                    "text": "Element[]"
+                  }
+                }
+              ],
+              "description": "Watches a row drawn on this pass for a change of size."
+            },
             {
               "kind": "method",
               "name": "handleMutations",
@@ -189751,6 +191344,35 @@
               },
               "description": "The text typing matches for each item: `text-field`, the template's first\n`data-field`, or a string or number item itself."
             },
+            {
+              "kind": "field",
+              "name": "disabled",
+              "type": {
+                "text": "Set<string>"
+              },
+              "privacy": "private",
+              "description": "The keys `disabled-keys` names.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "isDisabled",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "at",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "Whether item `at` is one a reader cannot choose or move to."
+            },
             {
               "kind": "method",
               "name": "indexOf",
@@ -189855,6 +191477,10 @@
                 {
                   "name": "extend",
                   "default": "false"
+                },
+                {
+                  "name": "toggle",
+                  "default": "false"
                 }
               ],
               "description": "Selects item `at`, or lets it go, asking first. With `extend`, in\n`multiple`, the items from the anchor to it are taken in, as Data Table\nand List take in a range. Otherwise the item is where the next range runs\nfrom."
@@ -189995,9 +191621,15 @@
                   "type": {
                     "text": "ReadonlySet<string>"
                   }
+                },
+                {
+                  "name": "off",
+                  "type": {
+                    "text": "ReadonlySet<string>"
+                  }
                 }
               ],
-              "description": "Writes a row's role, and whether it is chosen in a list that selects:\n`option` with `aria-selected` there, and `listitem` otherwise. Every pass,\nsince a choice changes no row's content."
+              "description": "Writes a row's role, and whether it is chosen in a list that selects:\n`option` with `aria-selected` there, and `listitem` otherwise, and\n`aria-disabled` on an item `disabled-keys` names. Every pass,\nsince a choice changes no row's content."
             },
             {
               "kind": "method",
@@ -190085,6 +191717,17 @@
               },
               "description": "Puts the windowed rows into the light DOM, and takes the rest out.\n\n**A row that stays in the window keeps its element.** Clearing and\ncloning every row on every move replaced the node a reader had focused,\nso a link in a row lost focus to the body on any scroll, even with its row\nstill on screen. Rows are keyed by item: the ones leaving go, the ones\narriving are drawn in their place, and the ones staying are not moved.\n\n**The row holding focus is drawn outside the window too**, beside it on the\nside it belongs, and the spacer on that side gives up its room.\n\n**One row holds the tab stop**, the one the reader last focused while it is\ndrawn, and the first row on screen once it is not. Its own links and\nbuttons are in the tab order, and those of every other row wait."
             },
+            {
+              "kind": "method",
+              "name": "spacerSizes",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "{ after: number; before: number }"
+                }
+              },
+              "description": "The spacers' heights: the window's, with the line kept for focus taking its own room."
+            },
             {
               "kind": "field",
               "name": "tier",
@@ -190469,6 +192112,15 @@
               "description": "How many items a line holds. One, the default, is a list; more lays the\nitems out as a grid of that many equal columns, windowed a line at a\ntime, with Left and Right moving along a line.",
               "fieldName": "columns"
             },
+            {
+              "name": "disabled-keys",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The keys of the items a reader cannot choose or move to, separated by\ncommas, as `value` writes keys. Their rows carry `aria-disabled`.",
+              "fieldName": "disabledKeys"
+            },
             {
               "name": "empty-label",
               "type": {
@@ -190496,6 +192148,15 @@
               "description": "The id of the script element that holds the items as JSON. `items` wins\nwhere both are set.",
               "fieldName": "for"
             },
+            {
+              "name": "gap",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "The space between two rows, and between two columns in a grid, in\npixels. The list counts it in each row's place, so a gap does not walk\nthe rows away from the scroll position the way a margin on each row\nwould.",
+              "fieldName": "gap"
+            },
             {
               "name": "key-field",
               "type": {
@@ -190541,6 +192202,24 @@
               "description": "Places each row by its own measured height. Without it, rows are placed\nby one height: `estimate` until rows are drawn, then the drawn rows' height,\nread once. Rows that come out different heights are placed by their own\nheights either way.\n\n**Off by default, because the straight line is better when it holds.** One\nheight makes offset and index convert by division, which can never\ndisagree with itself; measuring is what a set of genuinely different\nheights needs and costs a read of each row as it renders. A list of\none-line rows should leave this alone.",
               "fieldName": "measured"
             },
+            {
+              "name": "min-column-width",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "The narrowest a column of a grid may be, in pixels. Set, the list lays\nout as many columns as fit the box at that width, at least one, and\nfollows the box as it resizes, which `columns` then does not decide.",
+              "fieldName": "minColumnWidth"
+            },
+            {
+              "name": "selection-behavior",
+              "type": {
+                "text": "'replace' | 'toggle'"
+              },
+              "default": "'toggle'",
+              "description": "What a press does to the items already chosen: `toggle` adds or takes out\nthe item, and `replace` selects it alone and lets the arrow keys carry the\nselection, with Control or Command adding or taking out one item.",
+              "fieldName": "selectionBehavior"
+            },
             {
               "name": "selection-mode",
               "type": {
@@ -190635,6 +192314,6 @@
   ],
   "helix": {
     "package": "@fusion.dev/helix-headless",
-    "version": "0.160.0"
+    "version": "0.161.0"
   }
 }