@fusion.dev/helix-core 0.142.1 → 0.143.0

package/custom-elements.json

@@ -8,7 +8,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Carries a host's ARIA references down to the control inside it.\n\n**The gap this closes, measured.** `<helix-button aria-describedby=\"tip\">` puts\nthe description on the host, and the host is not what a reader is on: the\naccessibility tree exposes the `<button>` in the shadow root, and the host\nbeside it is a generic with a description nobody hears. Read from Chrome's own\ntree:\n\n```\nhost           role=generic  name=\"\"       desc=\"Helix description\"\ninner button   role=button   name=\"Helix\"  desc=\"\"\n```\n\nA plain `<button>` with the identical attribute reads `desc=\"Helix\ndescription\"`, so the reference itself is fine and only its destination is\nwrong. This moves it.\n\n**An IDREF cannot make that trip and an element reference can.** The ids are\nwritten in the consumer's tree and the control is in a shadow root, so\n`aria-describedby` copied onto the inner element resolves to nothing.\n`ariaDescribedByElements` takes the elements themselves, and a reference is\nvalid into the same tree *or a shadow-including ancestor* of it: from inside\nthe shadow root looking out, the document is exactly that. Measured, the\nassignment reads back with the node intact, where the inward direction, from a\nlight-DOM trigger to a node in a shadow root, reads back empty. This is the\none direction that works, which is why `Tooltip` needs `for` and this does\nnot.\n\n**The attributes stay on the host.** Nothing is removed and nothing is added:\nthe consumer's markup is exactly what they wrote, which is the same reason\n`hostAria` exists. What changes is only that the control now also holds the\nreference, so a screen reader on the focused element hears it.\n\nWatched with a `MutationObserver`, because a reference can arrive at any time:\na framework rendering a tooltip after this element upgrades, or a consumer\npointing `aria-describedby` at a different id, changes an attribute and\nnothing schedules a Lit update.",
+          "description": "Carries a host's ARIA references down to the control inside it.\n\n**The gap this closes, measured.** `<helix-button aria-describedby=\"tip\">` puts\nthe description on the host, and the host is not what a reader is on: the\naccessibility tree exposes the `<button>` in the shadow root, and the host\nbeside it is a generic with a description nobody hears. Read from Chrome's own\ntree:\n\n```\nhost           role=generic  name=\"\"       desc=\"Helix description\"\ninner button   role=button   name=\"Helix\"  desc=\"\"\n```\n\nA plain `<button>` with the identical attribute reads `desc=\"Helix\ndescription\"`, so the reference itself is fine and only its destination is\nwrong. This moves it.\n\n**An IDREF cannot make that trip and an element reference can.** The ids are\nwritten in the consumer's tree and the control is in a shadow root, so\n`aria-describedby` copied onto the inner element resolves to nothing.\n`ariaDescribedByElements` takes the elements themselves, and a reference is\nvalid into the same tree *or a shadow-including ancestor* of it: from inside\nthe shadow root looking out, the document is exactly that. Measured, the\nassignment reads back with the node intact, where the inward direction, from a\nlight-DOM trigger to a node in a shadow root, reads back empty. This is the\none direction that works, which is why `Tooltip` needs `for` and this does\nnot.\n\n**The attributes stay on the host.** Nothing is removed and nothing is added:\nthe consumer's markup is exactly what they wrote, which is the same reason\n`hostAria` exists. What changes is only that the control now also holds the\nreference, so a screen reader on the focused element hears it.\n\nWatched with a `MutationObserver`, because a reference can arrive at any time:\na framework rendering a tooltip after this element upgrades, or a consumer\npointing `aria-describedby` at a different id, changes an attribute and\nnothing schedules a Lit update.\n\n**A `<label>` that names the host names the control too**, when the control\nhas no name of its own. The platform gives a form-associated host its labels\nand the host is a generic the reader never lands on, so a `<label for>` or a\nwrapping `<label>` left the textbox unnamed. The labels travel the same way a\nforwarded `aria-labelledby` does, as element references, and are read again\nwhen focus arrives, since a label can be added without the host hearing.",
           "name": "AriaForwardController",
           "members": [
             {
@@ -55,6 +55,83 @@
               "privacy": "private",
               "description": "The control the record above is about, so a replacement resets it."
             },
+            {
+              "kind": "field",
+              "name": "asked",
+              "type": {
+                "text": "boolean | (() => boolean)"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "description": "Whether a host `aria-label` is carried down. See the option."
+            },
+            {
+              "kind": "field",
+              "name": "label",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "named",
+              "type": {
+                "text": "(() => boolean) | undefined"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "description": "The component's own answer to whether the control is named. See the option."
+            },
+            {
+              "kind": "field",
+              "name": "after",
+              "type": {
+                "text": "(() => Element[]) | undefined"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "description": "What is read after the host's names. See the option."
+            },
+            {
+              "kind": "method",
+              "name": "namedByItself",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "target",
+                  "type": {
+                    "text": "HTMLElement"
+                  }
+                }
+              ],
+              "description": "Whether the control has a name that did not come from this controller: an\n`aria-label`, an `aria-labelledby` of its own, or a label of its own with\nwords in it."
+            },
+            {
+              "kind": "method",
+              "name": "hostLabels",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "HTMLElement[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "target",
+                  "type": {
+                    "text": "HTMLElement"
+                  }
+                }
+              ],
+              "description": "The labels the platform associated with the host, for a control with no\nname of its own, and none otherwise."
+            },
             {
               "kind": "method",
               "name": "forward",
@@ -83,6 +160,13 @@
                 }
               }
             },
+            {
+              "kind": "field",
+              "name": "refresh",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Forwards again as focus arrives, for a label added since the last update."
+            },
             {
               "kind": "method",
               "name": "hostUpdated",
@@ -113,7 +197,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "The words of an element that is announced when it appears, for a region that\nis there before they are.\n\n**A live region is heard when what it holds changes, not when it arrives.**\nAn element the page inserts with its message already inside is a region\narriving with its words, which a screen reader reads inconsistently at best:\nan empty state after a search, a banner raised mid-session. So the element\nrenders its region empty and this fills it a frame later, which is a change.\n\n**Left empty when the element came with the page**, served or parsed in the\nfirst pass, because a message that was always there is content rather than\nnews, and a region that spoke on every page load would interrupt a reader\nbefore they had read anything. Its words are the baseline instead, and the\nregion speaks only when they change. Filling it at once also drew the words a\nsecond time on the headless tier, which has no sheet to clip the region, and\na served page changed its picture on hydrating.\n\nThe component renders `said` into its region and calls `say` when what it\nholds changes, from a `slotchange`.",
+          "description": "The words of an element that is announced when it appears, for a region that\nis there before they are.\n\n**A live region is heard when what it holds changes, not when it arrives.**\nAn element the page inserts with its message already inside is a region\narriving with its words, which a screen reader reads inconsistently at best:\nan empty state after a search, a banner raised mid-session. So the element\nrenders its region empty and this fills it a frame later, which is a change.\n\n**Left empty when the element came with the page**, served or parsed in the\nfirst pass, because a message that was always there is content rather than\nnews, and a region that spoke on every page load would interrupt a reader\nbefore they had read anything. Its words are the baseline instead, and the\nregion speaks only when they change. Filling it at once also drew the words a\nsecond time on the headless tier, which has no sheet to clip the region, and\na served page changed its picture on hydrating.\n\n**And emptied again once it has been heard.** The words stay in the element\nitself, so a region that kept its copy put the message in the accessibility\ntree twice, and a reader moving through the page met it twice. The region\nkeeps the copy for `hold` and then lets it go, which a polite region does not\nread out, removals being no news.\n\nThe component renders `said` into its region and calls `say` when what it\nholds changes, from a `slotchange`.",
           "name": "ArrivalController",
           "members": [
             {
@@ -144,6 +228,14 @@
               "privacy": "private",
               "default": "0"
             },
+            {
+              "kind": "field",
+              "name": "timer",
+              "type": {
+                "text": "ReturnType<typeof setTimeout> | undefined"
+              },
+              "privacy": "private"
+            },
             {
               "kind": "method",
               "name": "hostConnected",
@@ -288,6 +380,24 @@
               "description": "Whether the drawing is turned to run right to left, which it is on a\nright-to-left page.\n\n`HelixElement` mirrors a drawing marked `data-mirror` there, so a reading\ndrawn at 10% of the plot's width stands 10% in from its right edge. What is\nread against the drawing has to be read the same way: the pointer from the\nplot's right, and a bubble beside a bar's far end on its left. Asked of the\nhost through `isRtl`, which is the one question the table and the splitter\nask for their own arrow keys.\n\nOn the controller because it is what reads the pointer against the drawing,\nand a chart deciding which side a bubble goes asks here rather than\nrepeating the question. Asked when needed rather than held, since a page\ncan change its direction without the chart updating.",
               "readonly": true
             },
+            {
+              "kind": "method",
+              "name": "accepts",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                }
+              ],
+              "description": "Whether a pointer event may move the reading, which only a mouse or a pen\nmay.\n\nPublic for a chart that hears the pointer itself, a donut's slices and a\nheatmap's cells, so the rule a coarse pointer gets is this one everywhere.\nHeard unfiltered, a touch opened the bubble under the finger and left it\nthere after the finger lifted."
+            },
             {
               "kind": "method",
               "name": "set",
@@ -1619,9 +1729,123 @@
       "kind": "javascript-module",
       "path": "src/controllers/keyboard-navigation-controller/keyboard-navigation-controller.ts",
       "declarations": [
+        {
+          "kind": "function",
+          "name": "typesCharacter",
+          "return": {
+            "type": {
+              "text": "boolean"
+            }
+          },
+          "parameters": [
+            {
+              "name": "event",
+              "type": {
+                "text": "KeyboardEvent"
+              }
+            }
+          ],
+          "description": "Whether a press types a character, which is what typeahead reads.\n\nOne character with no Control, Command or Alt held, so a shortcut such as\nControl+A is never taken for the letter A. Shift is allowed, because a\ncapital is still a letter."
+        },
+        {
+          "kind": "class",
+          "description": "Finds an item by the letters a reader types at a set, the way a native\n`<select>` does.\n\nLetters typed within `timeout` milliseconds of each other build one search,\nso typing \"ca\" moves to \"Canada\" past \"Cambodia\". The same letter typed again\nmoves to the next item that starts with it, so pressing \"c\" three times visits\nthe first three. A pause starts a new search.\n\nMatching ignores case and leading spaces, and searches from the reader's\nposition, wrapping at the end. A search that matches nothing moves nothing.\n\nHolds only the letters, so one instance serves any set: the caller passes the\nwords of the items and where the reader is on every key.",
+          "name": "Typeahead",
+          "members": [
+            {
+              "kind": "field",
+              "name": "letters",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "private",
+              "default": "''"
+            },
+            {
+              "kind": "field",
+              "name": "last",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0"
+            },
+            {
+              "kind": "field",
+              "name": "timeout",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "default": "timeout"
+            },
+            {
+              "kind": "method",
+              "name": "typing",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "now",
+                  "default": "Date.now()"
+                }
+              ],
+              "description": "Whether a search is under way.\n\nA set that chooses on Space asks this first, because a Space typed in the\nmiddle of a search is part of the words, as in \"New York\"."
+            },
+            {
+              "kind": "method",
+              "name": "match",
+              "return": {
+                "type": {
+                  "text": "number"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "texts",
+                  "type": {
+                    "text": "readonly string[]"
+                  }
+                },
+                {
+                  "name": "from",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "now",
+                  "default": "Date.now()"
+                }
+              ],
+              "description": "Adds a character to the search, and returns the index of the item it\nmatches, or `-1` where none does.\n\n`texts` are the words of the items a reader can reach, in order, and\n`from` is the index of the item the reader is on, or `-1`."
+            },
+            {
+              "kind": "method",
+              "name": "reset",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Ends the search, so the next letter starts a new one."
+            }
+          ],
+          "helix": {}
+        },
         {
           "kind": "class",
-          "description": "Moves through a set of items with the arrow keys, and chooses as it goes.\n\n**Moving and choosing are one act here, not two.** That is the radio group\npattern and it is the difference from a listbox: moving focus without\nchoosing leaves a keyboard reader sitting on an item they have not selected,\nwith nothing on screen saying which of the two is true. A pointer user\nchooses by arriving, so a keyboard user does too.\n\n**Both axes, always.** A vertical set still answers left and right, and a\nhorizontal one still answers up and down. Binding only the axis the items\nhappen to be laid out on means a reader who guesses wrong gets nothing, and\n`orientation` is presentation: the same set of choices reads the same way\nwhichever direction it runs.\n\n**The horizontal pair turns with the line.** On a right-to-left page the\nfirst item is on the right, so left is forward there, which is what a native\nradio group does, measured in Chromium on 15 Sep 2026. Vertical sets\nincluded: the key a reader guesses on a column is the one that goes forward\nalong a row of the same items, and the two answering differently would make\n`orientation` more than presentation after all.\n\nDisabled items are skipped rather than stopped at, so a set with a gap in it\nstill moves in one press.\n\nA set that starts from focus rather than from the selection, or that moves\nwithout choosing, says so through `origin` and `selects`. Neither is a reason\nto keep a hand-written copy, and neither exempts a set from both axes.",
+          "description": "Moves through a set of items with the arrow keys, and chooses as it goes.\n\n**Moving and choosing are one act here, not two.** That is the radio group\npattern and it is the difference from a listbox: moving focus without\nchoosing leaves a keyboard reader sitting on an item they have not selected,\nwith nothing on screen saying which of the two is true. A pointer user\nchooses by arriving, so a keyboard user does too.\n\n**Both axes, always.** A vertical set still answers left and right, and a\nhorizontal one still answers up and down. Binding only the axis the items\nhappen to be laid out on means a reader who guesses wrong gets nothing, and\n`orientation` is presentation: the same set of choices reads the same way\nwhichever direction it runs.\n\n**The horizontal pair turns with the line.** On a right-to-left page the\nfirst item is on the right, so left is forward there, which is what a native\nradio group does, measured in Chromium on 15 Sep 2026. Vertical sets\nincluded: the key a reader guesses on a column is the one that goes forward\nalong a row of the same items, and the two answering differently would make\n`orientation` more than presentation after all.\n\nDisabled items are skipped rather than stopped at, so a set with a gap in it\nstill moves in one press.\n\n**Typeahead is opt-in.** Pass `typeahead` with a function that returns an\nitem's words, and a printable key moves to the next item whose words start\nwith the letters typed, choosing it where arriving chooses. A key that a text\nfield inside the set is typing into is left to the field.\n\nA set that starts from focus rather than from the selection, or that moves\nwithout choosing, says so through `origin` and `selects`. Neither is a reason\nto keep a hand-written copy, and neither exempts a set from both axes.",
           "name": "KeyboardNavigationController",
           "members": [
             {
@@ -1684,6 +1908,86 @@
               "readonly": true,
               "default": "wrap"
             },
+            {
+              "kind": "field",
+              "name": "words",
+              "type": {
+                "text": "((item: NavigableItem) => string) | undefined"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "default": "typeahead"
+            },
+            {
+              "kind": "field",
+              "name": "typeahead",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new Typeahead()"
+            },
+            {
+              "kind": "method",
+              "name": "arrive",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "target",
+                  "type": {
+                    "text": "NavigableItem | undefined"
+                  }
+                }
+              ],
+              "description": "Moves to an item, and chooses it where arriving is choosing."
+            },
+            {
+              "kind": "method",
+              "name": "current",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "number"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "items",
+                  "type": {
+                    "text": "NavigableItem[]"
+                  }
+                },
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "KeyboardEvent"
+                  }
+                }
+              ],
+              "description": "Where the reader is: the item the press came from, or the selection.\n\n**Focus first, where nothing is chosen.** A reader who tabs into an\nunanswered set lands on its first item, and the selection then says `-1`.\nStarting from `-1`, a forward step lands on that same first item, so the\nfirst press appeared to do nothing and the second one moved. A native radio\ngroup moves to the second radio on that press, and so does this."
+            },
+            {
+              "kind": "method",
+              "name": "handleTypeahead",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "KeyboardEvent"
+                  }
+                }
+              ],
+              "description": "Moves to the item whose words start with what was typed, if any."
+            },
             {
               "kind": "field",
               "name": "handleKeydown",
@@ -1715,14 +2019,30 @@
       "exports": [
         {
           "kind": "js",
-          "name": "KeyboardNavigationController",
+          "name": "typesCharacter",
           "declaration": {
-            "name": "KeyboardNavigationController",
+            "name": "typesCharacter",
             "module": "src/controllers/keyboard-navigation-controller/keyboard-navigation-controller.ts"
           }
-        }
-      ]
-    },
+        },
+        {
+          "kind": "js",
+          "name": "Typeahead",
+          "declaration": {
+            "name": "Typeahead",
+            "module": "src/controllers/keyboard-navigation-controller/keyboard-navigation-controller.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "KeyboardNavigationController",
+          "declaration": {
+            "name": "KeyboardNavigationController",
+            "module": "src/controllers/keyboard-navigation-controller/keyboard-navigation-controller.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/controllers/media-session-controller/media-session-controller.ts",
@@ -2177,6 +2497,16 @@
               "default": "false",
               "description": "Whether the surface is currently shown, so the calls can be idempotent."
             },
+            {
+              "kind": "field",
+              "name": "host",
+              "type": {
+                "text": "ReactiveControllerHost & HTMLElement"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "default": "host"
+            },
             {
               "kind": "field",
               "name": "open",
@@ -2254,6 +2584,16 @@
                   "text": "void"
                 }
               }
+            },
+            {
+              "kind": "method",
+              "name": "hostConnected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks a reconnected host that is still open to update, so the panel is shown\nagain.\n\nThe flag above lets it show, and nothing asked it to: a host moved in the\nDOM while open kept `open` and `aria-expanded=\"true\"` with the panel\nhidden until something else updated it, and Escape did not close it,\nbecause the dismissal is started by showing."
             }
           ],
           "helix": {}
@@ -2391,7 +2731,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "Resolves the element a chart reads from, and follows it.\n\nEvery chart that takes a `for` wants exactly this, and wants it to behave\nidentically, so it is a controller rather than a paragraph in each of them.\n\nA controller and not a pure function, by the test the rules set: it reacts to\nthe host's lifecycle. It has to start watching when the host connects, stop\nwhen it leaves, and re-resolve when `for` changes.\n\n**What it refuses is as much the point as what it accepts.** A `<table>` or\nanything built from grid roles, including this library's own `helix-table`,\nwhose roles live in `ElementInternals` and therefore write no attribute at\nall. Anything else resolves to null, so a `for` pointed at a paragraph draws\nnothing rather than something arbitrary.\n\nThe element is watched for `childList` and `characterData` alike, because\nrenaming a series edits a text node in place rather than replacing a cell,\nand nothing in a page has reason to know a chart is reading it.",
+          "description": "Resolves the element a chart reads from, and follows it.\n\nEvery chart that takes a `for` wants exactly this, and wants it to behave\nidentically, so it is a controller rather than a paragraph in each of them.\n\nA controller and not a pure function, by the test the rules set: it reacts to\nthe host's lifecycle. It has to start watching when the host connects, stop\nwhen it leaves, and re-resolve when `for` changes.\n\n**What it refuses is as much the point as what it accepts.** A `<table>` or\nanything built from grid roles, including this library's own `helix-table`,\nwhose roles live in `ElementInternals` and therefore write no attribute at\nall. Anything else resolves to null, so a `for` pointed at a paragraph draws\nnothing rather than something arbitrary.\n\nThe element is watched for `childList` and `characterData` alike, because\nrenaming a series edits a text node in place rather than replacing a cell,\nand nothing in a page has reason to know a chart is reading it.\n\n**The tree around it is watched as well, for the table that is not there\nyet.** A framework page renders a chart first and its table once the data\nloads, or re-keys the table and so replaces it under the same id. Watching\nonly the element resolved on connect found nothing in the first case and\nkept a detached table in the second, and the chart drew neither until some\nunrelated property changed. So the root the id resolves in is watched for\nnodes arriving and leaving and for `id` and `role` changing, and each batch\nasks the id again. That is one lookup by id per batch, and a chart redraws\nonly when the answer is a different element.",
           "name": "SourceController",
           "members": [
             {
@@ -2411,6 +2751,25 @@
               },
               "privacy": "private"
             },
+            {
+              "kind": "field",
+              "name": "tree",
+              "type": {
+                "text": "MutationObserver | undefined"
+              },
+              "privacy": "private",
+              "description": "Watches the tree `for` resolves in, for the table arriving, leaving or being replaced."
+            },
+            {
+              "kind": "field",
+              "name": "watched",
+              "type": {
+                "text": "Element | null"
+              },
+              "privacy": "private",
+              "default": "null",
+              "description": "The element the watcher is on, or null where `for` named nothing."
+            },
             {
               "kind": "field",
               "name": "deferred",
@@ -2546,6 +2905,17 @@
                 }
               },
               "description": "Points the watcher at whatever `for` names now.\n\nCalled on connect and by the host when `for` changes. Safe to call when\nthere is no `MutationObserver`, which is the server."
+            },
+            {
+              "kind": "method",
+              "name": "watchTree",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Watches the root `for` resolves in, so a table that arrives, leaves or is\nreplaced under the same id is followed.\n\nOnly while `for` names something and the host sits in a tree that can\nresolve an id, which a detached host and a server render do not."
             }
           ],
           "helix": {}
@@ -3147,6 +3517,46 @@
               ],
               "description": "Tells the controller the set grew by `by` items at its start.\n\nFor a host that prepends, which is what a transcript loading its history\ndoes. Every index the controller knew now names the item `by` places later,\nso the heights and the window move with them, and the scroll offset is moved\nby the room the new items take once they have been drawn. The reader stays\non the turn they were reading rather than on whatever now sits at their old\noffset, which is what loading history upward has to look like.\n\nCall it from `willUpdate`, before the render that draws the grown set."
             },
+            {
+              "kind": "method",
+              "name": "sizeOf",
+              "return": {
+                "type": {
+                  "text": "number"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "index",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "How tall item `index` is: what was measured, or the estimate.\n\nFor a host that draws an item outside the window, the row holding focus\nsay, and has to take that item's room out of a spacer."
+            },
+            {
+              "kind": "method",
+              "name": "reveal",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "index",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "inset",
+                  "default": "0"
+                }
+              ],
+              "description": "Scrolls the box the least distance that shows item `index` whole.\n\nFor a host moving focus to an item outside the window, whose own element\ncannot be scrolled to because it is not drawn where it belongs. `inset` is\nhow far into the box the items start, for a heading that sticks at its\ntop and covers that much of every item scrolled under it."
+            },
             {
               "kind": "method",
               "name": "forget",
@@ -4061,6 +4471,28 @@
           },
           "helix": {}
         },
+        {
+          "kind": "class",
+          "description": "A transcript was pinned to the bottom, or let go of it.\n\nThe notification half of `helix-before-pin`, sent once `pinned` has moved,\nso `currentTarget.pinned` is the new state and `detail.value` says it as\n`true` or `false`. Not cancelable: the decision was the request's.",
+          "name": "HelixPinEvent",
+          "members": [
+            {
+              "kind": "field",
+              "name": "eventName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'helix-pin'"
+            }
+          ],
+          "superclass": {
+            "name": "CustomEvent",
+            "module": "src/events/events.ts"
+          },
+          "helix": {}
+        },
         {
           "kind": "class",
           "description": "A divider is about to move, and can be refused.",
@@ -4083,6 +4515,28 @@
           },
           "helix": {}
         },
+        {
+          "kind": "class",
+          "description": "A divider settled somewhere new.\n\nThe notification half of `helix-before-resize`, sent once `position` has\nmoved, with the new position. Not cancelable: the decision was the\nrequest's.\n\n**Past tense, because `helix-resize` was already taken** by a measurement,\nthe height a sandboxed preview reports for what it drew, and one name cannot\ncarry both.",
+          "name": "HelixResizedEvent",
+          "members": [
+            {
+              "kind": "field",
+              "name": "eventName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'helix-resized'"
+            }
+          ],
+          "superclass": {
+            "name": "CustomEvent",
+            "module": "src/events/events.ts"
+          },
+          "helix": {}
+        },
         {
           "kind": "class",
           "description": "The divider between a sandbox's panes is about to move, and can be refused.\n\nIts own verb rather than a `helix-before-resize` carrying which divider moved:\na sandbox has two, and they were told apart by a field on a detail every other\nrequest in this file also carries.",
@@ -4149,6 +4603,28 @@
           },
           "helix": {}
         },
+        {
+          "kind": "class",
+          "description": "A pane shut or reopened.\n\nThe notification half of `helix-before-collapse`, sent once `collapsed` has\nmoved. `detail.value` is the side that is shut, or empty where both panes\nare open. Not cancelable: the decision was the request's.",
+          "name": "HelixCollapseEvent",
+          "members": [
+            {
+              "kind": "field",
+              "name": "eventName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'helix-collapse'"
+            }
+          ],
+          "superclass": {
+            "name": "CustomEvent",
+            "module": "src/events/events.ts"
+          },
+          "helix": {}
+        },
         {
           "kind": "class",
           "description": "Source is about to be edited, and can be refused.",
@@ -4457,6 +4933,28 @@
           },
           "helix": {}
         },
+        {
+          "kind": "class",
+          "description": "The rows are in a different order.\n\nThe notification after `helix-sort`, sent once `sort` has moved, with the\norder now in force. Not cancelable: the decision was the request's.\n\n**Past tense, because the plain verb is the request.** `helix-sort` was\ncancelable before the library had a word for its notification, and\nconsumers bind it by that name, so the notification takes the one after it.",
+          "name": "HelixSortedEvent",
+          "members": [
+            {
+              "kind": "field",
+              "name": "eventName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'helix-sorted'"
+            }
+          ],
+          "superclass": {
+            "name": "CustomEvent",
+            "module": "src/events/events.ts"
+          },
+          "helix": {}
+        },
         {
           "kind": "class",
           "description": "Fired when the reader changes which values a field is filtered by.\n\n**Not `helix-filter`, which is a different thing already taken.** That one\nsays a list narrowed itself to a string, and `Data Table` and `Listbox` both\ndispatch it with exactly that meaning. This one carries a structured filter:\na field, a comparison and a set of values, which is a shape neither of those\nhas and neither should grow.\n\nCancelable, and refusing it is how a consumer takes the decision for one\ninteraction, the way `requestChange` documents for every stateful change here.",
@@ -4501,6 +4999,28 @@
           },
           "helix": {}
         },
+        {
+          "kind": "class",
+          "description": "A component is showing a narrower or a wider set.\n\nThe notification after `helix-filter`, sent once the query has moved, with\nthe query now in force. Not cancelable, and past tense for the reason\n`helix-sorted` is.",
+          "name": "HelixFilteredEvent",
+          "members": [
+            {
+              "kind": "field",
+              "name": "eventName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'helix-filtered'"
+            }
+          ],
+          "superclass": {
+            "name": "CustomEvent",
+            "module": "src/events/events.ts"
+          },
+          "helix": {}
+        },
         {
           "kind": "class",
           "description": "Fired when a shortcut's chord is pressed.\n\nCancelable, and the key event is only consumed where this is not refused: a\nconsumer that decides the moment is wrong, a dialog is over the control or\nthe reader is mid-composition, calls `preventDefault()` and the keystroke\ngoes on to whatever would have had it.",
@@ -4545,6 +5065,28 @@
           },
           "helix": {}
         },
+        {
+          "kind": "class",
+          "description": "A set holds a different selection.\n\nThe notification after a `helix-select` that asked to change what is\nselected, sent once the selection has moved, with the selection now in\nforce. Not cancelable, and past tense for the reason `helix-sorted` is.",
+          "name": "HelixSelectedEvent",
+          "members": [
+            {
+              "kind": "field",
+              "name": "eventName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'helix-selected'"
+            }
+          ],
+          "superclass": {
+            "name": "CustomEvent",
+            "module": "src/events/events.ts"
+          },
+          "helix": {}
+        },
         {
           "kind": "class",
           "description": "Fired when the reader asks for the columns in a different order.\n\nCancelable, and refusing it leaves the columns where they were, so a consumer\nwho stores the order, in a URL or a preference, can take the decision the way\na server-side sort takes `helix-sort`. The detail is the whole order as\nspace-separated fields rather than one move, because the order is the fact a\nconsumer stores, and a move is only meaningful against an order they would\nthen have to keep in step.\n\nNot `helix-sort`: that reorders the rows, this reorders the columns, and a\nconsumer listening for one should not hear the other.",
@@ -4567,6 +5109,28 @@
           },
           "helix": {}
         },
+        {
+          "kind": "class",
+          "description": "The columns are in a different order.\n\nThe notification after `helix-reorder`, sent once the order has moved, with\nevery field in the new one. Not cancelable, and past tense for the reason\n`helix-sorted` is.",
+          "name": "HelixReorderedEvent",
+          "members": [
+            {
+              "kind": "field",
+              "name": "eventName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'helix-reordered'"
+            }
+          ],
+          "superclass": {
+            "name": "CustomEvent",
+            "module": "src/events/events.ts"
+          },
+          "helix": {}
+        },
         {
           "kind": "class",
           "description": "Fired when a reader reaches the oldest turn a transcript holds, while there are\nolder ones to fetch.\n\n**A report of where the reader is, not a request to be granted**, so it is not\ncancelable: there is nothing for the transcript to do if nobody refuses, and\nnothing to stop if somebody does. The consumer answers by fetching, and says\nso through the transcript's `history` while the older turns are on their way.\n\nNo detail. The consumer holds the transcript and knows its oldest turn, which\nis the one thing a fetch needs.",
@@ -4896,6 +5460,14 @@
             "module": "src/events/events.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixPinEvent",
+          "declaration": {
+            "name": "HelixPinEvent",
+            "module": "src/events/events.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixBeforeResizeEvent",
@@ -4904,6 +5476,14 @@
             "module": "src/events/events.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixResizedEvent",
+          "declaration": {
+            "name": "HelixResizedEvent",
+            "module": "src/events/events.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixBeforeSplitEvent",
@@ -4928,6 +5508,14 @@
             "module": "src/events/events.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixCollapseEvent",
+          "declaration": {
+            "name": "HelixCollapseEvent",
+            "module": "src/events/events.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixBeforeEditEvent",
@@ -5040,6 +5628,14 @@
             "module": "src/events/events.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixSortedEvent",
+          "declaration": {
+            "name": "HelixSortedEvent",
+            "module": "src/events/events.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixFacetEvent",
@@ -5056,6 +5652,14 @@
             "module": "src/events/events.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixFilteredEvent",
+          "declaration": {
+            "name": "HelixFilteredEvent",
+            "module": "src/events/events.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixShortcutEvent",
@@ -5072,6 +5676,14 @@
             "module": "src/events/events.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixSelectedEvent",
+          "declaration": {
+            "name": "HelixSelectedEvent",
+            "module": "src/events/events.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixReorderEvent",
@@ -5080,6 +5692,14 @@
             "module": "src/events/events.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixReorderedEvent",
+          "declaration": {
+            "name": "HelixReorderedEvent",
+            "module": "src/events/events.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixHistoryEvent",
@@ -5590,7 +6210,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "`HelixFormElement` is a class because the browser reads `formAssociated` from\nthe constructor during element upgrade, and a mixin or controller cannot\nsupply it.\n\n`internals` comes from `HelixElement`, which attaches it for every component.\n`attachInternals()` throws on a second call, so only one class attaches it.\n\nThe class carries only what every form participant needs. `value`, validity,\nand the reset and restore callbacks are added with the first input component.",
+          "description": "`HelixFormElement` is a class because the browser reads `formAssociated` from\nthe constructor during element upgrade, and a mixin or controller cannot\nsupply it.\n\n`internals` comes from `HelixElement`, which attaches it for every component.\n`attachInternals()` throws on a second call, so only one class attaches it.\n\nThe class carries only what every form participant needs. `value` and the\nreset and restore callbacks are added with the first input component.\n\n**The validity API is the platform's, read through `internals`**, so\n`checkValidity()`, `reportValidity()` and `setCustomValidity()` work on the\nhost as they do on a native control. A custom message is laid over whatever\nthe control itself reports, which is why `setValidity` is wrapped below.\n\n**Focus goes to the control's first tab stop**, for `focus()` and for a\npress on a `<label>` that names the host. A host is not focusable itself, so\nwithout this a label press focused nothing on half the controls.",
           "name": "HelixFormElement",
           "members": [
             {
@@ -5617,17 +6237,243 @@
             },
             {
               "kind": "field",
-              "name": "formDisabled",
+              "name": "formDisabled",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "default": "false",
+              "description": "Whether an ancestor `<fieldset disabled>` has switched this control off.\n\nThe platform tells a form-associated element through `formDisabledCallback`\nand nothing else does, so without this a control inside a disabled fieldset\nstays fully typeable and announces itself as enabled.\n\nThe submission half is already the platform's: measured, the fieldset's\ncontrols are absent from the form's entry list and the host matches\n`:disabled`, so the value never goes anywhere. What is missing without this\nis everything a reader can see or touch.\n\nState rather than the `disabled` property. Writing that would reflect an\nattribute the consumer's server markup does not have, which React reports\non hydration and does not patch up, and it would also silently overwrite\nwhat the consumer set."
+            },
+            {
+              "kind": "method",
+              "name": "formDisabledCallback",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "disabled",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Called by the browser when an ancestor fieldset is disabled or enabled.\n\n**The argument is the effective state, and taking it whole is what latched\nevery control in the library.** The platform calls this for the element's\nown `disabled` as well as for a fieldset, and our own arrives here at the\nworst possible moment: reflecting `disabled` to the attribute happens\ninside Lit's `update()`, the UA fires this synchronously from that write,\nand a reactive write during an update is a change-in-update Lit does not\nre-render for. So `formDisabled` ran exactly one update behind forever.\n\nMeasured on Slider, logging what `render` saw:\n\n```\nset true    disabled true   formDisabled false  isDisabled true\nset false   disabled false  formDisabled true   isDisabled true   <- stale\n(no third render)\n```\n\nThe host came out right every time, `disabled` false, `:disabled` not\nmatching, and the inner control kept the attribute, so a control disabled\nonce could never be re-enabled. It only shows when something re-enables,\nwhich is the same shape of bug `inheritDisabled` was written for.\n\nOur own half is already in `this.disabled` and `isDisabled` is an or, so\nthis records only what the fieldset adds. That also removes the write\nentirely on the own-disabled path rather than moving it.\n\nThe one case this cannot see is a control that is disabled itself *and*\ninside a disabled fieldset, whose own `disabled` is then removed: the\neffective state does not change, so the platform does not call again, and\nthe fieldset's hold is not recorded. There is no callback to learn it from\nand reading `:disabled` here would answer about the attribute we are in the\nmiddle of removing."
+            },
+            {
+              "kind": "field",
+              "name": "heldByFieldset",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether an ancestor `<fieldset disabled>` holds the control, outside its\nfirst `<legend>`, read from the tree.\n\nFor the one case the callback cannot report: a control disabled itself and\nby a fieldset, whose own `disabled` is then removed. The effective state does\nnot change, so the platform does not call, and the fieldset's hold has to\nbe read.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "formResetCallback",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Called by the browser when the form is reset. It does nothing here, and\nevery override calls it.\n\n**A chain rather than a leaf**, because more than one layer owes a reset\nsomething: the value mixin its default, and the field mixin beneath it the\nforgetting of a reader's past attempt, whose message otherwise showed over\nthe emptied control the moment the form was reset."
+            },
+            {
+              "kind": "method",
+              "name": "announceInput",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Announces `input` from the host, the way the control it stands for would.\n\nComposed, as the native one is: `input` crosses shadow boundaries by\nspecification, so a consumer listening above a composition hears it."
+            },
+            {
+              "kind": "method",
+              "name": "announceChange",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Announces `change` from the host, the way the control it stands for would.\n\n**Not composed, and that is the shape of the native event rather than a\nchoice made here.** `change` stops at a shadow boundary, so a composed\ncontrol hears its inner control's and relays it under the same name from\nits own host, which is what `onChange` binds. Every control here that\ncommits a value announces it through this, whether the commit came from an\ninner control's own `change`, a step, a scrub or a completed code, so the\nevent is one shape in one place."
+            },
+            {
+              "kind": "field",
+              "name": "name",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The name the control's value is submitted under.\n\n**Reflected, and it is the exception to \"reflect only what CSS selects\non\".** The platform builds a form's entry list from the `name` *content\nattribute*, not from the property, so a control named through the property\nsubmitted under no name at all and was silently dropped. Measured: two\ninputs in one form, one named by attribute and one by property, and the\nform carried a single entry.\n\nSafe for a React consumer, which is what the rule is protecting: React\nrenders a custom element's props as attributes on the server, so the name\nis already in the markup being hydrated and reflecting it writes what is\nthere. It is only a change to the markup when a consumer assigns it\nimperatively later, and nothing is hydrating by then.\n\nHere rather than on each control.",
+              "attribute": "name",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "reportValidityTo",
+              "type": {
+                "text": "ElementInternals['setValidity']"
+              },
+              "privacy": "private",
+              "readonly": true,
+              "description": "The platform's own `setValidity`, which the wrapper above calls.",
+              "default": "report"
+            },
+            {
+              "kind": "field",
+              "name": "reported",
+              "type": {
+                "text": "Reported"
+              },
+              "privacy": "private",
+              "default": "{ anchor: undefined, flags: {}, message: '' }",
+              "description": "What the control last reported, before any custom error is laid over it."
+            },
+            {
+              "kind": "field",
+              "name": "customValidity",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "private",
+              "default": "''",
+              "description": "The message `setCustomValidity` was given."
+            },
+            {
+              "kind": "field",
+              "name": "appliedFeedback",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "private",
+              "default": "''",
+              "description": "The `validityFeedback` the platform was last told about."
+            },
+            {
+              "kind": "method",
+              "name": "applyValidity",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Hands the platform the control's own verdict with any custom error on top,\nanchored where focus can go."
+            },
+            {
+              "kind": "method",
+              "name": "validationAnchor",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "HTMLElement | undefined"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "anchor",
+                  "optional": true,
+                  "type": {
+                    "text": "HTMLElement"
+                  }
+                }
+              ],
+              "description": "Where the browser points its bubble: the anchor a control gave if focus\ncan go there, and its first tab stop otherwise.\n\nA group anchors on a part that holds its members and cannot take focus,\nand the platform then refuses the submission, logs that the control is\nnot focusable, and leaves the reader on the submit button."
+            },
+            {
+              "kind": "field",
+              "name": "validity",
+              "type": {
+                "text": "ValidityState"
+              },
+              "description": "Whether the control meets its constraints, and why not.",
+              "readonly": true,
+              "helix": {
+                "references": [
+                  {
+                    "label": "ElementInternals.validity",
+                    "url": "https://developer.mozilla.org/docs/Web/API/ElementInternals/validity"
+                  }
+                ]
+              }
+            },
+            {
+              "kind": "field",
+              "name": "validationMessage",
+              "type": {
+                "text": "string"
+              },
+              "description": "The message the browser would show for the control, or an empty string.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "willValidate",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the control is checked when its form is submitted.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "checkValidity",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Returns whether the control is valid, and fires `invalid` on it when it is\nnot."
+            },
+            {
+              "kind": "method",
+              "name": "reportValidity",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Returns whether the control is valid, and when it is not, fires `invalid`\nand shows the browser's message at the control."
+            },
+            {
+              "kind": "method",
+              "name": "setCustomValidity",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "message",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Marks the control invalid with `message`, or clears that with an empty\nstring, as on a native control. The form does not submit while it is set."
+            },
+            {
+              "kind": "field",
+              "name": "focusTarget",
               "type": {
-                "text": "boolean"
+                "text": "HTMLElement | null"
               },
               "privacy": "protected",
-              "default": "false",
-              "description": "Whether an ancestor `<fieldset disabled>` has switched this control off.\n\nThe platform tells a form-associated element through `formDisabledCallback`\nand nothing else does, so without this a control inside a disabled fieldset\nstays fully typeable and announces itself as enabled.\n\nThe submission half is already the platform's: measured, the fieldset's\ncontrols are absent from the form's entry list and the host matches\n`:disabled`, so the value never goes anywhere. What is missing without this\nis everything a reader can see or touch.\n\nState rather than the `disabled` property. Writing that would reflect an\nattribute the consumer's server markup does not have, which React reports\non hydration and does not patch up, and it would also silently overwrite\nwhat the consumer set."
+              "description": "The element focus goes to: the control's first tab stop, or `null` where\nthere is none.\n\nRead through shadow roots and slots, so a group lands on the member that\nholds its tab stop, which is the chosen radio in a radio group.",
+              "readonly": true
             },
             {
               "kind": "method",
-              "name": "formDisabledCallback",
+              "name": "focus",
               "return": {
                 "type": {
                   "text": "void"
@@ -5635,56 +6481,113 @@
               },
               "parameters": [
                 {
-                  "name": "disabled",
+                  "name": "options",
+                  "optional": true,
                   "type": {
-                    "text": "boolean"
+                    "text": "FocusOptions"
                   }
                 }
               ],
-              "description": "Called by the browser when an ancestor fieldset is disabled or enabled.\n\n**The argument is the effective state, and taking it whole is what latched\nevery control in the library.** The platform calls this for the element's\nown `disabled` as well as for a fieldset, and our own arrives here at the\nworst possible moment: reflecting `disabled` to the attribute happens\ninside Lit's `update()`, the UA fires this synchronously from that write,\nand a reactive write during an update is a change-in-update Lit does not\nre-render for. So `formDisabled` ran exactly one update behind forever.\n\nMeasured on Slider, logging what `render` saw:\n\n```\nset true    disabled true   formDisabled false  isDisabled true\nset false   disabled false  formDisabled true   isDisabled true   <- stale\n(no third render)\n```\n\nThe host came out right every time, `disabled` false, `:disabled` not\nmatching, and the inner control kept the attribute, so a control disabled\nonce could never be re-enabled. It only shows when something re-enables,\nwhich is the same shape of bug `inheritDisabled` was written for.\n\nOur own half is already in `this.disabled` and `isDisabled` is an or, so\nthis records only what the fieldset adds. That also removes the write\nentirely on the own-disabled path rather than moving it.\n\nThe one case this cannot see is a control that is disabled itself *and*\ninside a disabled fieldset, whose own `disabled` is then removed: the\neffective state does not change, so the platform does not call again, and\nthe fieldset's hold is not recorded. There is no callback to learn it from\nand reading `:disabled` here would answer about the attribute we are in the\nmiddle of removing."
+              "description": "Moves focus to the control, as focusing a native control does."
+            },
+            {
+              "kind": "field",
+              "name": "focusFromLabel",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Focuses the control when its `<label>` is pressed.\n\nThe label sends the host a click of the browser's own after trying to\nfocus it, and a host that is not focusable takes nothing from that try.\nOnly a click that starts at the host and that the browser sent: one from\ninside has landed where it meant to, and `click()` from a script does not\nfocus a native control either."
+            },
+            {
+              "kind": "field",
+              "name": "refreshAnchor",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Re-anchors the verdict as the form checks it, because the control's\nmembers may have rendered since it last reported, and the anchor read then\nwas the best there was."
             },
             {
               "kind": "method",
-              "name": "formResetCallback",
+              "name": "submitImplicitly",
+              "privacy": "protected",
               "return": {
                 "type": {
                   "text": "void"
                 }
               },
-              "description": "Called by the browser when the form is reset. It does nothing here, and\nevery override calls it.\n\n**A chain rather than a leaf**, because more than one layer owes a reset\nsomething: the value mixin its default, and the field mixin beneath it the\nforgetting of a reader's past attempt, whose message otherwise showed over\nthe emptied control the moment the form was reset."
+              "description": "Submits the form the way pressing Enter in a native text field does.\n\nThe control's own input is in a shadow root and has no form owner, so the\nplatform never runs implicit submission for it. This runs it: the form's\ndefault button is activated, the first submit button in it, a Helix one\nincluded. With none, the form is submitted when it holds no more than one\nfield that counts against implicit submission, and nothing happens\notherwise.",
+              "helix": {
+                "references": [
+                  {
+                    "label": "implicit submission",
+                    "url": "https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#implicit-submission"
+                  }
+                ]
+              }
             },
             {
               "kind": "method",
-              "name": "announceInput",
+              "name": "defaultButton",
               "privacy": "protected",
+              "static": true,
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "Element | undefined"
                 }
               },
-              "description": "Announces `input` from the host, the way the control it stands for would.\n\nComposed, as the native one is: `input` crosses shadow boundaries by\nspecification, so a consumer listening above a composition hears it."
+              "parameters": [
+                {
+                  "name": "form",
+                  "type": {
+                    "text": "HTMLFormElement"
+                  }
+                }
+              ],
+              "description": "The form's default button, the first submit button in it, native or Helix."
             },
             {
               "kind": "method",
-              "name": "announceChange",
+              "name": "submitsOnEnter",
               "privacy": "protected",
+              "static": true,
               "return": {
                 "type": {
-                  "text": "void"
+                  "text": "boolean"
                 }
               },
-              "description": "Announces `change` from the host, the way the control it stands for would.\n\n**Not composed, and that is the shape of the native event rather than a\nchoice made here.** `change` stops at a shadow boundary, so a composed\ncontrol hears its inner control's and relays it under the same name from\nits own host, which is what `onChange` binds. Every control here that\ncommits a value announces it through this, whether the commit came from an\ninner control's own `change`, a step, a scrub or a completed code, so the\nevent is one shape in one place."
+              "parameters": [
+                {
+                  "name": "target",
+                  "type": {
+                    "text": "EventTarget | undefined"
+                  }
+                },
+                {
+                  "name": "form",
+                  "type": {
+                    "text": "HTMLFormElement"
+                  }
+                }
+              ],
+              "description": "Whether `target` is a native field of `form` that Enter submits it from."
             },
             {
-              "kind": "field",
-              "name": "name",
-              "type": {
-                "text": "string"
+              "kind": "method",
+              "name": "submits",
+              "privacy": "protected",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
               },
-              "default": "''",
-              "description": "The name the control's value is submitted under.\n\n**Reflected, and it is the exception to \"reflect only what CSS selects\non\".** The platform builds a form's entry list from the `name` *content\nattribute*, not from the property, so a control named through the property\nsubmitted under no name at all and was silently dropped. Measured: two\ninputs in one form, one named by attribute and one by property, and the\nform carried a single entry.\n\nSafe for a React consumer, which is what the rule is protecting: React\nrenders a custom element's props as attributes on the server, so the name\nis already in the markup being hydrated and reflecting it writes what is\nthere. It is only a change to the markup when a consumer assigns it\nimperatively later, and nothing is hydrating by then.\n\nHere rather than on each control.",
-              "attribute": "name",
-              "reflects": true
+              "parameters": [
+                {
+                  "name": "element",
+                  "type": {
+                    "text": "Element"
+                  }
+                }
+              ],
+              "description": "Whether `element` is a submit button, native or Helix."
             },
             {
               "kind": "field",
@@ -6416,6 +7319,22 @@
             "module": "./controllers/keyboard-navigation-controller/keyboard-navigation-controller.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "Typeahead",
+          "declaration": {
+            "name": "Typeahead",
+            "module": "./controllers/keyboard-navigation-controller/keyboard-navigation-controller.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "typesCharacter",
+          "declaration": {
+            "name": "typesCharacter",
+            "module": "./controllers/keyboard-navigation-controller/keyboard-navigation-controller.js"
+          }
+        },
         {
           "kind": "js",
           "name": "MediaSessionController",
@@ -6864,6 +7783,14 @@
             "module": "./events/events.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixCollapseEvent",
+          "declaration": {
+            "name": "HelixCollapseEvent",
+            "module": "./events/events.js"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixCompleteEvent",
@@ -6928,6 +7855,14 @@
             "module": "./events/events.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixFilteredEvent",
+          "declaration": {
+            "name": "HelixFilteredEvent",
+            "module": "./events/events.js"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixGraphFilterEvent",
@@ -7072,6 +8007,14 @@
             "module": "./events/events.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixPinEvent",
+          "declaration": {
+            "name": "HelixPinEvent",
+            "module": "./events/events.js"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixPreviousEvent",
@@ -7120,6 +8063,22 @@
             "module": "./events/events.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixReorderedEvent",
+          "declaration": {
+            "name": "HelixReorderedEvent",
+            "module": "./events/events.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "HelixResizedEvent",
+          "declaration": {
+            "name": "HelixResizedEvent",
+            "module": "./events/events.js"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixResizeEvent",
@@ -7160,6 +8119,14 @@
             "module": "./events/events.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixSelectedEvent",
+          "declaration": {
+            "name": "HelixSelectedEvent",
+            "module": "./events/events.js"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixSendEvent",
@@ -7184,6 +8151,14 @@
             "module": "./events/events.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "HelixSortedEvent",
+          "declaration": {
+            "name": "HelixSortedEvent",
+            "module": "./events/events.js"
+          }
+        },
         {
           "kind": "js",
           "name": "HelixTourAskEvent",
@@ -8040,6 +9015,14 @@
             "module": "./utils/read-color/read-color.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "byRow",
+          "declaration": {
+            "name": "byRow",
+            "module": "./utils/read-series/read-series.js"
+          }
+        },
         {
           "kind": "js",
           "name": "Row",
@@ -8088,6 +9071,14 @@
             "module": "./utils/read-series/read-series.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "unbroken",
+          "declaration": {
+            "name": "unbroken",
+            "module": "./utils/read-series/read-series.js"
+          }
+        },
         {
           "kind": "js",
           "name": "Relative",
@@ -8304,6 +9295,30 @@
             "module": "./utils/scroll-item-into-view/scroll-item-into-view.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "lockScroll",
+          "declaration": {
+            "name": "lockScroll",
+            "module": "./utils/scroll-lock/scroll-lock.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "scrollHolders",
+          "declaration": {
+            "name": "scrollHolders",
+            "module": "./utils/scroll-lock/scroll-lock.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "unlockScroll",
+          "declaration": {
+            "name": "unlockScroll",
+            "module": "./utils/scroll-lock/scroll-lock.js"
+          }
+        },
         {
           "kind": "js",
           "name": "slotFilled",
@@ -8688,6 +9703,14 @@
               },
               "description": "The chart's name, which starts the chart's text summary.\n\nAbsent falls back to the table's own caption, which is usually the right\nwords and is already written."
             },
+            {
+              "kind": "field",
+              "name": "locale",
+              "type": {
+                "text": "string"
+              },
+              "description": "The locale the chart's own numbers are written in: its axis, its\npercentages and its totals, such as `de` for `1.240` and `32 %`.\n\nAbsent uses the runtime's own. The table's cells are shown as the table\nwrites them, whatever this says."
+            },
             {
               "kind": "field",
               "name": "series",
@@ -8802,6 +9825,16 @@
               "description": "The chart's name, which starts the chart's text summary.\n\nAbsent falls back to the table's own caption, which is usually the right\nwords and is already written.",
               "attribute": "label"
             },
+            {
+              "kind": "field",
+              "name": "locale",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The locale the chart's own numbers are written in: its axis, its\npercentages and its totals, such as `de` for `1.240` and `32 %`.\n\nAbsent uses the runtime's own. The table's cells are shown as the table\nwrites them, whatever this says.",
+              "attribute": "locale"
+            },
             {
               "kind": "field",
               "name": "series",
@@ -8884,6 +9917,15 @@
               "default": "''",
               "description": "The chart's name, which starts the chart's text summary.\n\nAbsent falls back to the table's own caption, which is usually the right\nwords and is already written.",
               "fieldName": "label"
+            },
+            {
+              "name": "locale",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The locale the chart's own numbers are written in: its axis, its\npercentages and its totals, such as `de` for `1.240` and `32 %`.\n\nAbsent uses the runtime's own. The table's cells are shown as the table\nwrites them, whatever this says.",
+              "fieldName": "locale"
             }
           ],
           "parameters": [
@@ -9003,9 +10045,16 @@
                   "type": {
                     "text": "boolean"
                   }
+                },
+                {
+                  "name": "cell",
+                  "optional": true,
+                  "type": {
+                    "text": "'cell' | 'gridcell'"
+                  }
                 }
               ],
-              "description": "The status line, or nothing where the collection has content to show.\n\nRendered by the component wherever its rows would be."
+              "description": "The status line, or nothing where the collection has content to show.\n\nRendered by the component wherever its rows would be. `cell` makes the line\na row holding one cell of that role, for a table or a grid, whose children\nmay only be rows."
             },
             {
               "kind": "method",
@@ -9186,6 +10235,13 @@
                   "type": {
                     "text": "boolean"
                   }
+                },
+                {
+                  "name": "cell",
+                  "optional": true,
+                  "type": {
+                    "text": "'cell' | 'gridcell'"
+                  }
                 }
               ],
               "description": "The status line, or nothing where there is content to show.\n\nLoading wins over empty. A collection that has not answered yet is not\nempty, and saying so is the most common version of this fault: the reader\nis told there is nothing a moment before there is something."
@@ -9792,6 +10848,16 @@
               "default": "undefined",
               "description": "The state, whoever set it, and `undefined` until somebody has.\n\nPrefixed, and it has to be. These mixins compose onto one prototype\nchain, `Select` takes this one and `MixinControllerValue` together, and\nTypeScript's `private` is a compile-time fiction: two mixins with a field\ncalled `state` share one property on the instance, and the second one\nsilently overwrites the first. Measured, as a select whose `value` came\nback holding its `open` boolean.\n\nOne field and not two. Writing always applies, the way a native control\ndoes when a script assigns to it."
             },
+            {
+              "kind": "field",
+              "name": "announcedOpen",
+              "type": {
+                "text": "boolean | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "The state `toggle` last reported, and `undefined` before the first update.\n\n`requestOpen` announces at once. An assignment to `open` announces here,\nonce it has rendered, so a consumer binding `toggle` hears every change\nthat a `close` listener on a dialog hears. The first update sets it and\nannounces nothing, because a seed is where the element starts."
+            },
             {
               "kind": "method",
               "name": "requestOpen",
@@ -9840,6 +10906,14 @@
               "description": "Requests the opposite of the current state."
             }
           ],
+          "events": [
+            {
+              "name": "toggle",
+              "type": {
+                "text": "ToggleEvent"
+              }
+            }
+          ],
           "attributes": [
             {
               "name": "default-open",
@@ -10218,6 +11292,36 @@
                 }
               },
               "description": "Fires `helix-dismiss`, and returns `false` if a listener cancels it."
+            },
+            {
+              "kind": "method",
+              "name": "neighbors",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "HTMLElement[]"
+                }
+              },
+              "description": "The elements of the same kind beside this one, where focus goes if this\none is removed: the next ones nearest first, then the previous ones\nnearest first.\n\nRead before the event, while this element is still beside them."
+            },
+            {
+              "kind": "method",
+              "name": "keepFocus",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "neighbors",
+                  "type": {
+                    "text": "HTMLElement[]"
+                  }
+                }
+              ],
+              "description": "Moves focus to a neighbor's dismiss control if removing this element dropped it."
             }
           ],
           "attributes": [
@@ -10519,13 +11623,46 @@
             },
             {
               "kind": "field",
-              "name": "labeled",
-              "type": {
-                "text": "boolean"
+              "name": "labeled",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether a label is drawn at all, in either shape.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "filledSlots",
+              "privacy": "private",
+              "default": "new Set<string>()",
+              "description": "The named slots a consumer has put content in, among `label` and `hint`.\n\n**Asked of the slot, because the property cannot answer.** A label or a\nhint is drawn only when there is something in it, and slotted content\nchanges no property, so a field given `<span slot=\"label\">` and no\n`label` drew no label at all and its control went unnamed. With nothing\nelse to show, each renders a bare slot, which takes no box, and the slot\nreports what arrives in it."
+            },
+            {
+              "kind": "field",
+              "name": "noteSlotted",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Records whether the `label` or `hint` slot has content, which moves it\ninto its part.\n\nOn the render root, so the binding leaves the served markup as it was."
+            },
+            {
+              "kind": "method",
+              "name": "bareSlot",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
               },
-              "privacy": "protected",
-              "description": "Whether a label is drawn at all, in either shape.",
-              "readonly": true
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "'hint' | 'label'"
+                  }
+                }
+              ],
+              "description": "A slot with no part around it, for content that may arrive."
             },
             {
               "kind": "field",
@@ -10740,8 +11877,7 @@
               "type": {
                 "text": "string | null"
               },
-              "default": "null",
-              "fieldName": "namedBy"
+              "default": "null"
             },
             {
               "name": "feedback",
@@ -10880,13 +12016,31 @@
                 }
               ],
               "description": "Requests a new value. While `readOnly` is set, nothing changes and it\nreturns `false`."
+            },
+            {
+              "kind": "method",
+              "name": "requestOpen",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Requests the panel open or closed. While `readOnly` is set, it does not\nopen, and it returns `false`."
             }
           ],
           "helix": {}
         },
         {
           "kind": "mixin",
-          "description": "Grafts the typing half of a picker field: it opens on arrival, holds the\nvalue while the caret is in it, and refuses while read-only.\n\n**Over `MixinPickerField` and not part of it, because Color Input takes the\none and not the other.** Date Input and Time Input show a rendering while\nnobody is in the field, `4 August 2026` and `2:30 PM`, and the value itself\nwhile somebody is, because `Intl` formats and does not parse and a document\nbeing edited must not be a rendering of something else. That split needs to\nknow when the caret is in the field, which is `editing`; and a reader who\nreaches such a field is choosing, so arriving opens the picker. A color has\nneither: `#ff0000` is what is typed and what is shown, and a reader who has\nthe hex pastes it and never opens anything. `readOnly` is the third thing\nColor Input does not have, and a mixin cannot give it one without changing\nits API.",
+          "description": "Grafts the typing half of a picker field: it opens on arrival, holds the\nvalue while the caret is in it, and refuses while read-only.\n\n**Over `MixinPickerField` and not part of it, because Color Input takes the\none and not the other.** Date Input and Time Input show a rendering while\nnobody is in the field, `4 August 2026` and `2:30 PM`, and the value itself\nwhile somebody is, because `Intl` formats and does not parse and a document\nbeing edited must not be a rendering of something else. That split needs to\nknow when the caret is in the field, which is `editing`; and a reader who\nreaches such a field is choosing, so arriving opens the picker. A color has\nneither: `#ff0000` is what is typed and what is shown, and a reader who has\nthe hex pastes it and never opens anything. `readOnly` comes along here for\nthe two that take this mixin; Color Input declares its own, the same\nproperty refusing the same two requests.",
           "name": "MixinPickerEditing",
           "members": [
             {
@@ -10928,6 +12082,24 @@
               ],
               "description": "Requests a new value. While `readOnly` is set, nothing changes and it\nreturns `false`."
             },
+            {
+              "kind": "method",
+              "name": "requestOpen",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Requests the panel open or closed. While `readOnly` is set, it does not\nopen, and it returns `false`.\n\nA read-only field opened its picker on focus and on its trigger, and\nthen refused every pick in it, so the panel offered choices that went\nnowhere. A native read-only `<input type=\"date\">` opens nothing."
+            },
             {
               "kind": "field",
               "name": "handleBlur",
@@ -11059,6 +12231,36 @@
               ],
               "description": "Puts the caret in the field, as clicking its label does."
             },
+            {
+              "kind": "field",
+              "name": "handleCommit",
+              "type": {
+                "text": "(event: Event) => void"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The text control's own `change`, which a reader's edit ends with, said\nunder the host's name."
+            },
+            {
+              "kind": "field",
+              "name": "handleTriggerClick",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The trigger's press: opens the panel with focus in the picker, or closes\nit."
+            },
+            {
+              "kind": "field",
+              "name": "handleKeypress",
+              "type": {
+                "text": "(event: KeyboardEvent) => void"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Enter in the text submits the form, as it does in a native text field."
+            },
             {
               "kind": "field",
               "name": "handleKeydown",
@@ -11067,7 +12269,7 @@
               },
               "privacy": "protected",
               "readonly": true,
-              "description": "Escape shuts the panel without moving the value."
+              "description": "Escape shuts the panel without moving the value, Tab out of the text shuts\na panel the reader is passing, and ArrowDown in the text moves into it."
             },
             {
               "kind": "field",
@@ -11098,6 +12300,25 @@
               ],
               "description": "Told the panel has been placed, and how wide the window leaves it room to\nbe, in pixels.\n\nNothing, unless a family fits what its panel holds to the room it has."
             },
+            {
+              "kind": "method",
+              "name": "requestPicked",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Takes a value the reader picked in the panel, and says it is settled.\n\nReturns whether it was taken. A family whose typing announces `input`\nalone sends `change` from here for a pick, since a pick is a finished\nchoice."
+            },
             {
               "kind": "method",
               "name": "restore",
@@ -11156,7 +12377,7 @@
         },
         {
           "kind": "mixin",
-          "description": "Grafts a floating picker onto a text field, and the protocol between them.\n\n**Three families are this shape and were three copies of it.** Date Input,\nTime Input and Color Input each render a text control, a trigger and a\n`popover=\"manual\"` surface holding a picker that already exists on its own,\nand each owed the same wiring: the panel that floats the surface against the\nfield, the Escape that shuts it and hands the caret back, the restore that\nputs the control back where a refusal left the value, and the sync that\nreports the value and a verdict the platform cannot reach. Measured on the\ndiff that made the lift, 14 Sep 2026, comments counted: 223 lines left Date\nInput and 32 came back, 185 left Time Input and 32 came back, 87 left\nColor Input and 11 came back.\n\n**What it does not own is the picker, the typing or the value's shape.**\nWhich element floats in the surface, what a keystroke means, what the field\nshows when idle and what is wrong with a value are each the family's, which\nis why `display` and `validate` are seams here and the template stays where\nit was. A family renders `field`, `control`, `trigger` and `surface`; this\nreads them.\n\n**The parts this reads are the host's, so the name is a parameter.** A\nliteral `[part=\"control\"]` here would be a lookup nothing in this file\nrenders, which is the fault `helix component`'s `selectors` exists to catch\nand would rightly report. `MixinField.reportRequired` takes its anchor the\nsame way, and for the same reason: a mixin reads a part out of whatever host\napplies it.\n\n**Opening on focus, `readOnly` and the idle rendering are not here.** They\nare `MixinPickerEditing`'s, because Color Input has none of the three: a hex\nis pasted and read at a glance, so its field neither renders nor opens on\narrival, and giving it `readOnly` would be a property its API does not have.\n\n**Three things the two typed families share stay with them.** `renderTrigger`\ndiffers only by its icon and would still be the wrong thing to lift: a part a\nmixin renders belongs to every host that applies it, which is how\n`helix component`'s `parts` reads a chain, so `trigger-icon` would be\ncredited to Color Input, whose trigger is a swatch and documents no such\npart. `renderTag` names its part after the family, `date` or `time`, and\nwrites the label on the remove control differently in each. `valueAsDate`\nand `valueAsNumber` are public, convert a different way, and carry a\ndifferent note onto each family's page, which a mixin could only carry as\none.\n\n**Four more families look like this and are not.** Select has no text to\nhand the caret to: its panel hangs off the trigger and dismissal refocuses\nthat. Combobox has the text and a different agreement with it: a press\nanywhere in the field is inside, the gap is four, Escape closes without the\n`returning` flag because nothing there opens on arrival, and the control is\nreconciled against a completion rather than restored to a value. Input and\nTextarea open nothing, and their `readOnly` is the native attribute rather\nthan a gate on `requestValue`, so a programmatic change still lands. What\nthose two share with this is `focus()` and the platform's verdict copied in\n`sync`, which is not a protocol.",
+          "description": "Grafts a floating picker onto a text field, and the protocol between them.\n\n**Three families are this shape and were three copies of it.** Date Input,\nTime Input and Color Input each render a text control, a trigger and a\n`popover=\"manual\"` surface holding a picker that already exists on its own,\nand each owed the same wiring: the panel that floats the surface against the\nfield, the Escape that shuts it and hands the caret back, the restore that\nputs the control back where a refusal left the value, and the sync that\nreports the value and a verdict the platform cannot reach. Measured on the\ndiff that made the lift, 14 Sep 2026, comments counted: 223 lines left Date\nInput and 32 came back, 185 left Time Input and 32 came back, 87 left\nColor Input and 11 came back.\n\n**What it does not own is the picker, the typing or the value's shape.**\nWhich element floats in the surface, what a keystroke means, what the field\nshows when idle and what is wrong with a value are each the family's, which\nis why `display` and `validate` are seams here and the template stays where\nit was. A family renders `field`, `control`, `trigger` and `surface`; this\nreads them.\n\n**The parts this reads are the host's, so the name is a parameter.** A\nliteral `[part=\"control\"]` here would be a lookup nothing in this file\nrenders, which is the fault `helix component`'s `selectors` exists to catch\nand would rightly report. `MixinField.reportRequired` takes its anchor the\nsame way, and for the same reason: a mixin reads a part out of whatever host\napplies it.\n\n**Opening on focus, `readOnly` and the idle rendering are not here.** They\nare `MixinPickerEditing`'s, because Color Input takes neither of the first\nand last: a hex is pasted and read at a glance, so its field neither renders\nnor opens on arrival. Color Input declares its own `readOnly`.\n\n**Three things the two typed families share stay with them.** `renderTrigger`\ndiffers only by its icon and would still be the wrong thing to lift: a part a\nmixin renders belongs to every host that applies it, which is how\n`helix component`'s `parts` reads a chain, so `trigger-icon` would be\ncredited to Color Input, whose trigger is a swatch and documents no such\npart. `renderTag` names its part after the family, `date` or `time`, and\nwrites the label on the remove control differently in each. `valueAsDate`\nand `valueAsNumber` are public, convert a different way, and carry a\ndifferent note onto each family's page, which a mixin could only carry as\none.\n\n**Four more families look like this and are not.** Select has no text to\nhand the caret to: its panel hangs off the trigger and dismissal refocuses\nthat. Combobox has the text and a different agreement with it: a press\nanywhere in the field is inside, the gap is four, Escape closes without the\n`returning` flag because nothing there opens on arrival, and the control is\nreconciled against a completion rather than restored to a value. Input and\nTextarea open nothing, and their `readOnly` is the native attribute rather\nthan a gate on `requestValue`, so a programmatic change still lands. What\nthose two share with this is `focus()` and the platform's verdict copied in\n`sync`, which is not a protocol.",
           "name": "MixinPickerField",
           "members": [
             {
@@ -11273,7 +12494,71 @@
               "name": "handleKeydown",
               "privacy": "protected",
               "readonly": true,
-              "description": "Escape shuts the panel without moving the value."
+              "description": "Escape shuts the panel without moving the value, Tab out of the text\nshuts a panel the reader is passing, and ArrowDown in the text moves\ninto it.\n\n**Tab is for a reader moving through a form.** The panel opens when the\ntext is reached, which is `MixinPickerEditing`'s, and left open it added\nits own controls to the Tab order: a reader passing a Date Input pressed\nTab five times for one field. Leaving the text by Tab closes it, so the\npanel is reached by its trigger, which moves focus into it."
+            },
+            {
+              "kind": "field",
+              "name": "handleSurfaceKeydown",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Escape pressed inside the panel, which `handleKeydown` never hears.\n\nA family binds `handleKeydown` on the field, and the surface is the\nfield's sibling, so a key pressed in the grid or the list went past it to\nthe document, where the dismissal closed the panel and left focus on a\ncell that was no longer shown. Measured: focus fell to the body. Here the\nkey is taken on the host, and focus goes back to the text."
+            },
+            {
+              "kind": "field",
+              "name": "handleFocusOut",
+              "privacy": "private",
+              "readonly": true,
+              "description": "Closes the panel when focus leaves the whole control.\n\nOnly for a move to somewhere else that can hold focus. Focus that goes\nnowhere, which is a press on the panel's own padding or a hidden cell\ngiving it up, has no `relatedTarget`, and closing then would shut the\npanel under a reader who pressed inside it."
+            },
+            {
+              "kind": "field",
+              "name": "handleCommit",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The text control's own `change`, which a reader's edit ends with, said\nunder the host's name.\n\nA native `change` is not composed, so it stops at this shadow root. The\nfamilies whose typing announces `input` alone send this one when the\nreader is done, as `<input>` does."
+            },
+            {
+              "kind": "field",
+              "name": "fromTrigger",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the trigger opened the panel, so focus moves into the picker."
+            },
+            {
+              "kind": "field",
+              "name": "handleKeypress",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Enter in the text submits the form, as it does in a native text field.\n\nThe text is in a shadow root and has no form owner, so the platform\nnever runs implicit submission for it. On `keypress`, where the platform\nruns its own, so an Enter a family or a consumer prevented on `keydown`,\nsuch as one that adds a date in `multiple`, submits nothing."
+            },
+            {
+              "kind": "field",
+              "name": "handleTriggerClick",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The trigger's press: opens the panel with focus in the picker, or closes\nit.\n\n**Focus moves only when the trigger opened it**, which is what the APG\ndate picker dialog does: the panel is a dialog, and opening one from a\nbutton takes focus into it. Measured before this: Enter on the trigger\nleft focus there, three Tab presses from the selected day. Focusing the\ntext opens the panel too, on the families that open on arrival, and\nmoving focus from there would take the caret from a reader who came to\ntype."
+            },
+            {
+              "kind": "method",
+              "name": "requestPicked",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Takes a value the reader picked in the panel, and says it is settled."
             },
             {
               "kind": "field",
@@ -11294,7 +12579,7 @@
                   "text": "void"
                 }
               },
-              "description": "Puts the caret back in the field without the field reopening the panel."
+              "description": "Puts the caret back in the field without the field reopening the panel.\n\nThe anchor rather than the text, which is the trigger where there is no\ntext: Color Input's swatch dropped focus to the body on Escape."
             },
             {
               "kind": "method",
@@ -13629,7 +14914,7 @@
               }
             }
           ],
-          "description": "What a pointer resting on a reading shows, as `Tooltip` pointed at a mark.\n\n**A chart does not draw its own tooltip, and the top layer is why.** `Tooltip`\nrenders `popover=\"manual\"` through `PopoverController`, so it clears every\nstacking context and every `overflow` on the page. A box drawn by the chart is\n`position: absolute` inside the plot and is confined to the chart's own\ncontext, so it is clipped by, or layered under, whatever sits beside the\nchart. Escaping that means reimplementing `PopoverController`, which is\n`Tooltip` with extra steps and a second copy of the hard part.\n\n**`for` was already the anchor and needed nothing added.** It resolves in the\ntree the tooltip sits in, and the mark is in the same shadow root, so a chart\nnames an element inside itself and `Tooltip` finds it. What the chart\nprovides is an invisible mark at the reading's point.\n\n**An HTML mark rather than the `<rect>` or `<circle>` already there.**\n`FloatingController` types its anchor as `HTMLElement` and an SVG element is\nnot one; and a slice's `<circle>` has the bounding box of the whole ring\nrather than of its arc, so anchoring to it would point at the ring's center\nfor every slice.\n\n**And the arrow now follows from placement rather than from a compass.** The\nchart says which side it prefers and `FloatingController` moves it if that\nside does not fit, which is how a slice at any bearing gets a bubble that\npoints at it. Four hard-coded sides could not express a bearing, which is what\nmade the donut's arrow miss its own ring.\n\n**It shows the table's text and not the chart's numbers.** `$128k` is what the\ncell says and `128000` is what the drawing measured. Every cell of the row is\nhere, including columns nothing was plotted from, because a note beside the\nfigures is most of the reason to want a tooltip.\n\n**Hidden from assistive technology, on purpose.** The table is the accessible\nrepresentation and the drawing is `aria-hidden`; a reader on a keyboard gets\nthe table, which they can reach, rather than a tooltip which they cannot."
+          "description": "What a pointer resting on a reading shows, as `Tooltip` pointed at a mark.\n\n**A chart does not draw its own tooltip, and the top layer is why.** `Tooltip`\nrenders `popover=\"manual\"` through `PopoverController`, so it clears every\nstacking context and every `overflow` on the page. A box drawn by the chart is\n`position: absolute` inside the plot and is confined to the chart's own\ncontext, so it is clipped by, or layered under, whatever sits beside the\nchart. Escaping that means reimplementing `PopoverController`, which is\n`Tooltip` with extra steps and a second copy of the hard part.\n\n**`for` was already the anchor and needed nothing added.** It resolves in the\ntree the tooltip sits in, and the mark is in the same shadow root, so a chart\nnames an element inside itself and `Tooltip` finds it. What the chart\nprovides is an invisible mark at the reading's point.\n\n**An HTML mark rather than the `<rect>` or `<circle>` already there.**\n`FloatingController` types its anchor as `HTMLElement` and an SVG element is\nnot one; and a slice's `<circle>` has the bounding box of the whole ring\nrather than of its arc, so anchoring to it would point at the ring's center\nfor every slice.\n\n**And the arrow now follows from placement rather than from a compass.** The\nchart says which side it prefers and `FloatingController` moves it if that\nside does not fit, which is how a slice at any bearing gets a bubble that\npoints at it. Four hard-coded sides could not express a bearing, which is what\nmade the donut's arrow miss its own ring.\n\n**It shows the table's text and not the chart's numbers.** `$128k` is what the\ncell says and `128000` is what the drawing measured. Every cell of the row is\nhere, including columns nothing was plotted from, because a note beside the\nfigures is most of the reason to want a tooltip.\n\n**Hidden from assistive technology, on purpose.** The table is the accessible\nrepresentation and the drawing is `aria-hidden`; a reader on a keyboard gets\nthe table, which they can reach, rather than a tooltip which they cannot.\nThe mark and the bubble carry `aria-hidden` themselves, so they stay hidden\nin a chart whose plot also holds something a reader should hear, such as\nthe middle of a donut."
         }
       ],
       "exports": [
@@ -14368,7 +15653,49 @@
               }
             }
           ],
-          "description": "Reads a table as series, one per data column.\n\n**The table is the chart's accessible representation, not a fallback for\none.** Every chart here takes its numbers from real markup rather than from a\nproperty, so the page is readable with no script at all, sortable by anything\nthat sorts tables, and correct in a screen reader without a parallel\ndescription that has to be kept in step by hand. A `values` array would be\neasier to pass and would make the accessible version the thing nobody\nmaintains.\n\nThe shape is the ordinary one: a header row naming the series, a first column\nof row headers, and numbers in the rest. A single-column table has one series\nand takes its name from the caption, since a header row of one is usually\nabsent.\n\n`data-value` wins over the cell's text, because `$1.2k` is what a reader\nshould see and is not a number. `Number()` rather than `parseFloat`, because\nthe second reads `12abc` as 12: a value that is nearly a number is a mistake\nworth dropping rather than rounding off, and a dropped point is visible where\na silently truncated one is not."
+          "description": "Reads a table as series, one per data column.\n\n**The table is the chart's accessible representation, not a fallback for\none.** Every chart here takes its numbers from real markup rather than from a\nproperty, so the page is readable with no script at all, sortable by anything\nthat sorts tables, and correct in a screen reader without a parallel\ndescription that has to be kept in step by hand. A `values` array would be\neasier to pass and would make the accessible version the thing nobody\nmaintains.\n\nThe shape is the ordinary one: a header row naming the series, a first column\nof row headers, and numbers in the rest. A single-column table has one series\nand takes its name from the caption, since a header row of one is usually\nabsent.\n\n`data-value` wins over the cell's text, because `$1.2k` is what a reader\nshould see and is not a number. `Number()` rather than `parseFloat`, because\nthe second reads `12abc` as 12: a value that is nearly a number is a mistake\nworth dropping rather than rounding off, and a dropped point is visible where\na silently truncated one is not.\n\n**A dropped point keeps its place.** Each point carries `at`, the row it was\nread from, and a chart draws it at that row's category. Counted by position\nin `points`, a blank in March slid April's reading under March's label, and a\nblank in the first column took a category off the axis for every series.\n`byRow` lays a series out one slot per row with the blanks left empty."
+        },
+        {
+          "kind": "function",
+          "name": "byRow",
+          "return": {
+            "type": {
+              "text": "(SeriesPoint | undefined)[]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "series",
+              "type": {
+                "text": "Series | undefined"
+              }
+            },
+            {
+              "name": "rows",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "A series laid out one slot per row, with nothing in a slot whose cell was\nblank or did not parse.\n\nThis is the shape a chart drawing categories wants: slot `i` is the reading at\nthe `i`th row, which is the label under it and the row the tooltip reads."
+        },
+        {
+          "kind": "function",
+          "name": "unbroken",
+          "return": {
+            "type": {
+              "text": "SeriesPoint[][]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "series",
+              "type": {
+                "text": "Series"
+              }
+            }
+          ],
+          "description": "A series cut into its unbroken runs, where a run ends at a row with no\nreading.\n\nA line drawn through a gap claims a value in the gap. Drawn as runs, the\nline stops at the last reading before a blank and starts again at the first\none after it."
         },
         {
           "kind": "function",
@@ -14398,6 +15725,22 @@
             "module": "src/utils/read-series/read-series.ts"
           }
         },
+        {
+          "kind": "js",
+          "name": "byRow",
+          "declaration": {
+            "name": "byRow",
+            "module": "src/utils/read-series/read-series.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "unbroken",
+          "declaration": {
+            "name": "unbroken",
+            "module": "src/utils/read-series/read-series.ts"
+          }
+        },
         {
           "kind": "js",
           "name": "readRows",
@@ -14985,6 +16328,84 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/utils/scroll-lock/scroll-lock.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "lockScroll",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "parameters": [
+            {
+              "name": "holder",
+              "type": {
+                "text": "Element"
+              }
+            }
+          ],
+          "description": "Stops the page behind a modal surface from scrolling.\n\n`showModal()` makes the page inert and leaves it scrollable, so a wheel over\nthe backdrop moves the page under the dialog. `overflow: hidden` on the root\nstops that, and `scrollbar-gutter: stable` keeps the space a classic\nscrollbar took, so the page does not shift sideways when it goes. What the\nroot carried before is put back when the last holder lets go.\n\nDialog, Drawer and Lightbox hold it, and Toast reads who does."
+        },
+        {
+          "kind": "function",
+          "name": "unlockScroll",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "parameters": [
+            {
+              "name": "holder",
+              "type": {
+                "text": "Element"
+              }
+            }
+          ],
+          "description": "Lets go of the page, and gives it back once nothing else holds it."
+        },
+        {
+          "kind": "function",
+          "name": "scrollHolders",
+          "return": {
+            "type": {
+              "text": "Element[]"
+            }
+          },
+          "description": "The surfaces holding the page still, in the order they took it."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "lockScroll",
+          "declaration": {
+            "name": "lockScroll",
+            "module": "src/utils/scroll-lock/scroll-lock.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "unlockScroll",
+          "declaration": {
+            "name": "unlockScroll",
+            "module": "src/utils/scroll-lock/scroll-lock.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "scrollHolders",
+          "declaration": {
+            "name": "scrollHolders",
+            "module": "src/utils/scroll-lock/scroll-lock.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/utils/slot-filled/slot-filled.ts",
@@ -15628,7 +17049,7 @@
             {
               "name": "source",
               "type": {
-                "text": "string | undefined"
+                "text": "WrittenList"
               }
             }
           ],
@@ -15646,7 +17067,7 @@
             {
               "name": "source",
               "type": {
-                "text": "string | undefined"
+                "text": "WrittenList"
               }
             }
           ],
@@ -15682,7 +17103,7 @@
           "type": {
             "text": "string"
           },
-          "default": "'0.142.1'",
+          "default": "'0.143.0'",
           "description": "The version of the package this file ships in.\n\n**Written by `fusion/scripts/version.mjs`** wherever it writes the package's\n`package.json`, and stamped back into the repository beside it after a\nrelease, so the two never disagree; a spec beside this holds them to it.\nNothing else in the running code knows which release it is."
         }
       ],
@@ -15700,6 +17121,6 @@
   ],
   "helix": {
     "package": "@fusion.dev/helix-core",
-    "version": "0.142.1"
+    "version": "0.143.0"
   }
 }