@fusion.dev/helix-headless 0.199.0 → 0.200.0

package/custom-elements.json

@@ -85957,6 +85957,14 @@
             "module": "src/loader/index.js"
           }
         },
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/log/index.js"
+          }
+        },
         {
           "kind": "js",
           "name": "*",
@@ -101305,6 +101313,3924 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/log/ansi.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "ANSI_NAMES",
+          "type": {
+            "text": "[\n  'black',\n  'red',\n  'green',\n  'yellow',\n  'blue',\n  'magenta',\n  'cyan',\n  'white',\n  'bright-black',\n  'bright-red',\n  'bright-green',\n  'bright-yellow',\n  'bright-blue',\n  'bright-magenta',\n  'bright-cyan',\n  'bright-white',\n]"
+          },
+          "default": "[ 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white', 'bright-black', 'bright-red', 'bright-green', 'bright-yellow', 'bright-blue', 'bright-magenta', 'bright-cyan', 'bright-white', ]",
+          "description": "The sixteen colors a terminal names, in the order SGR numbers them: the\neight at `30` to `37`, then their bright forms at `90` to `97`.\n\nA run in one of them carries the name, and is drawn in the `--log-ansi-`\ncolor of that name, so the stylesheet says what red is in its theme. The\npalette's own index above fifteen is a fact about the color and is carried\nas the color itself."
+        },
+        {
+          "kind": "function",
+          "name": "paletteColor",
+          "return": {
+            "type": {
+              "text": "string | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "index",
+              "type": {
+                "text": "number"
+              }
+            }
+          ],
+          "description": "Entry `index` of the 256-color palette: a name below 16, and the CSS color\nof the cube to 231 and of the ramp of grays from 232 to 255."
+        },
+        {
+          "kind": "function",
+          "name": "applySgr",
+          "return": {
+            "type": {
+              "text": "LogStyle"
+            }
+          },
+          "parameters": [
+            {
+              "name": "style",
+              "type": {
+                "text": "LogStyle"
+              }
+            },
+            {
+              "name": "codes",
+              "type": {
+                "text": "readonly number[]"
+              }
+            }
+          ],
+          "description": "The style `codes` leave behind, applied over `style`."
+        },
+        {
+          "kind": "function",
+          "name": "parseAnsi",
+          "return": {
+            "type": {
+              "text": "{ runs: LogRun[]; style: LogStyle }"
+            }
+          },
+          "parameters": [
+            {
+              "name": "text",
+              "type": {
+                "text": "string"
+              }
+            },
+            {
+              "name": "style",
+              "default": "{}",
+              "type": {
+                "text": "LogStyle"
+              }
+            }
+          ],
+          "description": "Splits one line of text into runs, starting from `style`, and says what\nstyle the line ends in, which is where the next line starts.\n\nA run with no style left is plain. Adjacent runs that draw the same are\nmerged, so a line that resets to the style it already had stays one run."
+        },
+        {
+          "kind": "function",
+          "name": "stripAnsi",
+          "return": {
+            "type": {
+              "text": "string"
+            }
+          },
+          "parameters": [
+            {
+              "name": "text",
+              "type": {
+                "text": "string"
+              }
+            }
+          ],
+          "description": "The text of a line with every escape sequence taken out."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "ANSI_NAMES",
+          "declaration": {
+            "name": "ANSI_NAMES",
+            "module": "src/log/ansi.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "paletteColor",
+          "declaration": {
+            "name": "paletteColor",
+            "module": "src/log/ansi.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "applySgr",
+          "declaration": {
+            "name": "applySgr",
+            "module": "src/log/ansi.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "parseAnsi",
+          "declaration": {
+            "name": "parseAnsi",
+            "module": "src/log/ansi.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "stripAnsi",
+          "declaration": {
+            "name": "stripAnsi",
+            "module": "src/log/ansi.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/log/buffer.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "The text of a run, kept as lines.\n\n**Written text arrives in pieces that do not end at line breaks**, so the\nline still being written is held apart and shown as it stands, the way a\nterminal shows a prompt or a progress bar before its line ends. A line is\nfinished by `\\n` or `\\r\\n`.\n\n**A carriage return on its own starts the line over.** A progress bar is\none line rewritten a hundred times, and drawing each rewrite as a line of\nits own is the failure every log viewer is judged by. The text after the\nlast `\\r` replaces the line. A terminal overwrites only as many characters\nas were written, so `abc\\rxy` reads `xyc` there and `xy` here; a program\nthat redraws a line writes the whole line, which reads the same in both.\n\n**Color carries from line to line**, as it does in a terminal, so a block\nthat opens with green and closes many lines later is green throughout. It\ncarries through text a carriage return replaced as well.",
+          "name": "LogBuffer",
+          "members": [
+            {
+              "kind": "field",
+              "name": "lines",
+              "type": {
+                "text": "LogLine[]"
+              },
+              "default": "[]",
+              "description": "The finished lines kept, oldest first."
+            },
+            {
+              "kind": "field",
+              "name": "dropped",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "How many finished lines were let go from the start to stay within `limit`."
+            },
+            {
+              "kind": "field",
+              "name": "limit",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "The most finished lines kept, or 0 to keep them all."
+            },
+            {
+              "kind": "field",
+              "name": "parse",
+              "type": {
+                "text": "LogParser | undefined"
+              },
+              "default": "undefined",
+              "description": "Reads each finished line of written text."
+            },
+            {
+              "kind": "field",
+              "name": "partial",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "private",
+              "default": "''",
+              "description": "The line still being written, as it reads now."
+            },
+            {
+              "kind": "field",
+              "name": "returned",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the next text written starts the line over."
+            },
+            {
+              "kind": "field",
+              "name": "lineStyle",
+              "type": {
+                "text": "LogStyle"
+              },
+              "privacy": "private",
+              "default": "{}",
+              "description": "The style the line being written started in."
+            },
+            {
+              "kind": "field",
+              "name": "runs",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new WeakMap<LogLine, LogRun[]>()",
+              "description": "The runs of each line, read once."
+            },
+            {
+              "kind": "field",
+              "name": "shown",
+              "type": {
+                "text": "LogLine | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "The line `current` last returned, which stands until the text changes."
+            },
+            {
+              "kind": "method",
+              "name": "write",
+              "return": {
+                "type": {
+                  "text": "number"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "chunk",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Adds text, finishing a line at every line break, and returns how many\nlines it finished."
+            },
+            {
+              "kind": "method",
+              "name": "replace",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "lines",
+                  "type": {
+                    "text": "readonly LogLine[]"
+                  }
+                }
+              ],
+              "description": "Replaces every line, starting a fresh buffer that keeps its `parse` and `limit`."
+            },
+            {
+              "kind": "method",
+              "name": "clear",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Lets every line go."
+            },
+            {
+              "kind": "method",
+              "name": "current",
+              "return": {
+                "type": {
+                  "text": "LogLine | undefined"
+                }
+              },
+              "description": "The line still being written, or undefined where the last line ended."
+            },
+            {
+              "kind": "method",
+              "name": "runsOf",
+              "return": {
+                "type": {
+                  "text": "LogRun[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "line",
+                  "type": {
+                    "text": "LogLine"
+                  }
+                }
+              ],
+              "description": "The runs a line is drawn in. A written line was read with the color the\nline before it left; a line handed over in `lines` starts plain."
+            },
+            {
+              "kind": "method",
+              "name": "finish",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Finishes the line being written."
+            },
+            {
+              "kind": "method",
+              "name": "trim",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Lets the oldest lines go past `limit`, all at once."
+            }
+          ],
+          "helix": {}
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "LogBuffer",
+          "declaration": {
+            "name": "LogBuffer",
+            "module": "src/log/buffer.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/log/group/log-group.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "A group is a disclosure: its heading is a button that shows and hides the\nlines inside it, and says whether they are shown with `aria-expanded`. Put\n`Log.Line` elements inside it, and nest groups for steps within steps.\n\n`status` draws a mark before the heading, and a screen reader hears the\nstatus after the heading (`status-label`). `duration` stands at the end of\nthe heading, as you write it, such as `12s`.\n\nA group starts shut. Write `default-open` on the step a reader should see,\nsuch as the one that failed.",
+          "name": "HelixHeadlessLogGroup",
+          "cssParts": [
+            {
+              "description": "The lines, hidden while the group is shut.",
+              "name": "content"
+            },
+            {
+              "description": "How long the step took.",
+              "name": "duration"
+            },
+            {
+              "description": "The heading.",
+              "name": "heading"
+            },
+            {
+              "description": "The caret that turns as the group opens, an `<svg>` you size.",
+              "name": "mark"
+            },
+            {
+              "description": "The mark for the status, an `<svg>` you size.",
+              "name": "status"
+            },
+            {
+              "description": "The button that opens and closes the group.",
+              "name": "summary"
+            }
+          ],
+          "slots": [
+            {
+              "description": "The lines of the step, and any groups inside it.",
+              "name": ""
+            },
+            {
+              "description": "The heading, where it holds more than text. Defaults to `heading`.",
+              "name": "heading"
+            }
+          ],
+          "members": [
+            {
+              "kind": "field",
+              "name": "markRules",
+              "type": {
+                "text": "[SPOKEN_RULE]"
+              },
+              "privacy": "protected",
+              "static": true,
+              "default": "[SPOKEN_RULE]",
+              "description": "The rules from `mark-rules.ts` for the marks this element writes in its\nown shadow root: `data-scroller`, `data-virtual`, `data-spoken` and\n`data-mirror`.\n\nA component that writes a mark names its rule here, and a subclass\ninherits the list. One that writes none takes only the three rules every\nshadow root gets, which is what keeps the other four out of a Button.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "words",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-log'",
+              "description": "The key this family's words are registered under, its styled tag."
+            },
+            {
+              "kind": "field",
+              "name": "duration",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "How long the step took, as it should read, such as `12s`.",
+              "attribute": "duration"
+            },
+            {
+              "kind": "field",
+              "name": "heading",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "What the step is called. The `heading` slot replaces it.",
+              "attribute": "heading"
+            },
+            {
+              "kind": "field",
+              "name": "status",
+              "type": {
+                "text": "'done' | 'failed' | 'pending' | 'running' | 'skipped' | undefined"
+              },
+              "description": "Where the step stands, which draws a mark before the heading.",
+              "attribute": "status",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "statusLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{status, select, pending {waiting} running {running} done {finished} failed {failed} skipped {skipped} other {}}'",
+              "description": "What a screen reader hears for the status, after the heading.\n`{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`.",
+              "attribute": "status-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "handlePress",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "defaultOpen",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the element starts open. Ignored once `open` is written.",
+              "attribute": "default-open",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "open",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the element is open.\n\nOne property, not two, so `dialog.open` answers the question anyone\nasking it meant. Writing always applies; `<helix-dialog open>` is the\nsame statement in markup.\n\n**Not reflected, and that is required rather than tidy.** Reflection\nwrites the resolved state back as an attribute, so an element that opened\nitself would put `open` on its own host: cloned, serialized for\nhydration, or diffed by a framework, it comes back holding whatever the\nlast reader did rather than what the author wrote. `:state(open)` carries\nthe resolved state for stylesheets, which is what the mirror is for.",
+              "attribute": "open",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "openState",
+              "type": {
+                "text": "boolean | undefined"
+              },
+              "privacy": "private",
+              "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.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "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.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "requestOpen",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Requests that the element open or close, and returns whether the change\nwas applied.\n\nAnnounces before it acts, so `preventDefault()` on the `helix-before-open` or\n`helix-before-close` is a refusal and nothing moves. Nobody refusing means the\nelement opens or closes itself, whether or not a consumer declared\n`open`: a declared property is a seed and a correction, and a consumer\nwho wants the decision for themselves refuses it and assigns their own.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              },
+              "type": {
+                "text": "requestOpen(next: boolean) => boolean"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "announceToggle",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "open",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Says the state moved, under the platform's own name and in its shape.\n\n**A native `toggle` from inside a shadow root reaches nobody**, because\nit neither bubbles nor composes, so the ten families showing a\n`popover=\"manual\"` panel and the two rendering a real `<dialog>` announce\nnothing to a consumer. The disclosures have no native element to fire\nanything at all: `AccordionItem` and `TreeItem` are `aria-expanded` and\n`hidden` written by hand, which is `<details>`'s job done manually.\n\n**From here rather than from `PopoverController`.** The controller covers\neleven families and the mixin covers sixteen, so announcing from both\nwould announce twice on the ten they share. What `toggle` reports is the\n*state*, and the state is this mixin's; the controller is a way of\nputting a panel on the screen.\n\n**`newState` and `oldState`, because that is the platform's shape**, so a\nconsumer arriving from `<details>` reads the same two words. Not\ncancelable: the before events are the request, and a second cancelable\nevent for one transition is two answers to one question.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleOpen",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "description": "Requests the opposite of the current state.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              },
+              "type": {
+                "text": "toggleOpen() => boolean"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "tier",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-headless-'",
+              "description": "The prefix this tier registers its elements under.\n\n**A component that renders another renders its own tier's version of it**,\nso `helix-headless-pagination-size` composes `helix-headless-select` and\n`helix-pagination-size` composes `helix-select`. One template says\n`${this.tag('select')}` and each tier answers with its own name.\n\n**The public tag may not be the composed one, in either tier.** Using it\ncosts three things: the name means two different things depending on what a\nconsumer imported, the headless tier composes an element it does not ship,\nand the composition cannot be tested there at all, because there is no\n`helix-select` on that tier to test it against.\n\n**A prefix rather than an override per composition**, which was the first\nplan and does not compile. An override re-renders the fragment from the\nsubclass, and the fragment reads members the base keeps private:\n`PaginationSize` alone would have had to widen `options`, `current` and\n`handleChange` to `protected` so a subclass could say the same thing again.\nSixteen families of that is a lot of encapsulation spent on saying one\nword differently.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "tag",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "StaticValue"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One composed tag, as a static value a template can interpolate.\n\nWhat `unsafeStatic` returns, safe by construction: the name is a literal in\nour own source and the prefix is one of two strings this class defines.\nCalled per render and not cached, which costs nothing, because\n`static-html` keys its template cache on the joined string rather than on\nthe object.\n\n**Written out rather than imported, for every element that never renders\none.** `lit/static-html.js` declares no side effects, so importing\n`unsafeStatic` alone kept the module's three `withStatic` calls in every\nbundle: about 210 bytes gzipped on each of the families that compose no\ntag, Divider and Badge among them. The value is lit's cross-copy protocol,\nkeyed by `Symbol.for('')` so that two copies of lit on a page read each\nother's, and a spec holds it equal to `unsafeStatic`'s.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "partNamed",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "T | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One of this element's own parts, by name, or null where it is not rendered.\n\nNot `part`, which every element already has: `Element.part` is the\n`DOMTokenList` of the names the element itself carries, and a method under\nthat name is a type error on every subclass.\n\n**One guard for every lookup.** Lit's server shim has no `querySelector`\non the render root, so a lookup reached during a server render, from a\ngetter a template reads or from `willUpdate`, throws there and nowhere\nelse. Four spellings of the same guard had grown across the library, and\na fifth site with none. Null on the server, which is what the rest of the\ncode already treats a part that has not rendered as.\n\n**`~=` and not `=`.** A part drawn in a state carries a second name while\nthe state holds, `part=\"page page-current\"`, and an exact match stops\nfinding it for exactly as long as it is the one that matters.\n\n`helix component`'s `selectors` reads these calls the way it reads a\n`querySelector('[part=\"x\"]')`, so a name nothing renders is a finding\nrather than a null an optional chain swallows.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "internals",
+              "type": {
+                "text": "ElementInternals"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The element's semantics, set without touching the DOM.\n\n`ElementInternals` sets the implicit role, which an author's own `role`\nattribute still overrides, and it writes no attribute. Setting `role` on the\nhost directly would: that is an attribute the element gives itself after it\nupgrades, which a React consumer's server markup never had, and hydration\nreports it as a mismatch.\n\nAvailable during server rendering. Lit's shim implements `attachInternals`,\nso nothing here needs a guard.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleState",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "on",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Records a boolean fact about this element as a custom state.\n\n**The host belongs to whoever rendered it, and a component's own\nbookkeeping may not be kept there.** An attribute written on the first\nupdate is markup a consumer's server never sent, so a React consumer\nhydrates a DOM that has gained attributes since and reports a mismatch it\nwill not patch up. A custom state is not in the DOM at all: it carries the\nfact to a stylesheet through `:state()` and leaves the markup alone, so the\nserver's output and the client's agree by construction.\n\n`SETTLED` carries the long version of that argument; `checked`, `open`,\n`invalid` and `has-label` are recorded the same way, each of them a state a\n`default-*` attribute resolves before React reaches the node.\n\n**Deferring the definitions is not a fix and could not be.** Importing them\nfrom an effect so the upgrades fall the other side of hydration works only\nwhile hydration is one pass: anything that splits it, a streamed segment or\na suspended boundary, puts an upgrade back inside the window. Timing cannot\nbe the guarantee when the fact is kept somewhere React reconciles.\n\nFeature-tested rather than assumed, the way `hostAria` tests element\nreferences. An engine without `CustomStateSet` records nothing and keeps\nwhatever the resting rule draws, which is the safe direction to fail.\n\n**The engines the test is for are browsers**: Safari below 17.4 and Firefox\nbelow 126, where the write is a `TypeError`, so a component bypassing this\nfails to render rather than rendering without whatever the state draws.\nLit's server shim sets `states`, so the guard passes there and records a\nstate nothing reads, which is harmless.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "whenSettled",
+              "type": {
+                "text": "Promise<void>"
+              },
+              "readonly": true,
+              "description": "Resolves a frame after the first update, when transitions are switched on.\n\n**Named `whenSettled` because `settled` is taken four times over**, by\nImage, Splitter and both color controls, none of them about transitions. A\nbase class takes the name every subclass then cannot use.\n\n**The state it reports cannot be watched, which is why this exists.** A\ncustom state is deliberately not in the DOM, so there is no\n`MutationObserver` equivalent for `ElementInternals.states`. Await this\ninstead.\n\nSeparate from `updateComplete`, which resolves in the microtask checkpoint\nthe suppression is still active in. That is the distinction `readyToMove`\nin `@fusion.dev/helix-testing` is written around.\n\nIt never resolves where `requestAnimationFrame` never fires, which is a\nserver, a hidden tab, and happy-dom. Callers that must not hang there race\nit against a timeout, as the happy-dom harness's `readyToMove` does. The\nbrowser harness's awaits it alone: a browser always runs the frame, and a\ntimer beside it was a bet on how long one takes, which a busy run lost.",
+              "default": "new Promise<void>((resolve) => { this.resolveSettled = resolve })",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "resolveSettled",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "private",
+              "description": "Resolves `whenSettled`, once, from the frame that records the state.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fromServer",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the shadow root was a server's, parsed from declarative shadow DOM.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "hydrating",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this update is hydrating a server's markup, and so has to render\nexactly what the server rendered.\n\n**Lit hydrates by assuming the markup already shows the first render.** A\nvalue that differs is recorded and never written, so the page keeps the\nserver's, and a template that differs throws. The server has no children,\nso anything a component reads from its children waits for the update after\nhydration, which `finishHydration` asks for. Without a server's markup the\nfirst render reads them and there is one render.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "serverRendered",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element hydrated a server's markup rather than rendering its own.\n\nFor what happened before hydration and cannot be heard after it: an image\nthe parser fetched fires `load` or `error` before any listener exists, so a\ncomponent asks the image instead, once, when this is true.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finishHydration",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks for the update a hydration put off, so the reads it skipped happen.\n\nCalled from `firstUpdated`, the end of the hydrating update. The render it\nschedules can only follow that one, which is the exception Lit's\nchange-in-update warning names, and it happens only on a page a server\nrendered.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "childrenKnown",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this render can know the children.\n\nA server cannot: its element shim carries attributes and no tree, so\n`children` is undefined there. A render hydrating what a server sent must\nnot, because it has to be the server's render. Anywhere else it can. A\ncomponent whose render depends on its children reads them through\n`knownChildren`, and treats \"not known\" as its own answer rather than as\n\"none\": a list that renders its empty state because nobody has looked yet is\nthe one thing an empty state must never do.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "knownChildren",
+              "type": {
+                "text": "Element[]"
+              },
+              "privacy": "protected",
+              "description": "The children a render may read: all of them where they are known, and none otherwise.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "assignsByName",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element's slots route by name although it asked to assign them\nby hand.\n\n**A declarative shadow root is always the by-name kind.** HTML has no way to\nask for manual assignment, so a component that assigns by hand and hydrates\na server's root gets one where `slot.assign()` does nothing, and its\nchildren land wherever their `slot` attribute sends them. The way through is\nto write that attribute, which is what `route` does. Only there: on a root\nthis element made, assignment stays manual and the consumer's markup is\nnever touched, which is what a React consumer's hydration requires.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "route",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "child",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string | undefined"
+                  }
+                }
+              ],
+              "description": "Sends a child to a slot by name, on a root that routes by name.\n\n`undefined` is the default slot. Written only when it differs, so routing\nthe same child again on every update writes nothing.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "stopInner",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Stops an inner control's own announcement at this element's boundary.\n\n**A composed control is one control to a consumer, and the natives had no\nequivalent of the stop the prefixed events already get.** `<helix-select>`\nrenders a `<helix-listbox>`, and both announce: the listbox dispatches\n`input` and `change` from its own host, `input` is composed by\nspecification, and a consumer listening on the select therefore heard one\nchoice twice. Measured before this existed, on the styled tier, one choice\non the inner listbox: select `input` twice and `change` three times,\ncombobox, date input, time input and color input twice each. `Command` was\nthe only one that was right, because it happened to reach for\n`stopImmediatePropagation` for a different reason.\n\nBound on the child in the parent's template, so it runs while the event is\nstill at the child and before it can cross. The guard is for the case where\na component binds this on itself: an element must never stop its own\nannouncement, which is the one it exists to make.\n\nThis is the same job the `helix-before-*` handlers do with their own\n`stopPropagation`, and it is separate rather than folded into them because\na consumer may legitimately refuse a request without the notification ever\nhappening: the two travel at different times and one can be absent.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "relayNativeEvent",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                },
+                {
+                  "name": "init",
+                  "optional": true,
+                  "type": {
+                    "text": "EventInit"
+                  }
+                }
+              ],
+              "description": "Re-emits a native event from the host, under its own name.\n\nA native event fired by an inner `<input>` or `<textarea>` is not composed,\nso it stops at the shadow boundary and a consumer listening on\n`<helix-input>` hears nothing. Re-dispatching it from the host is what\nmakes the component behave like the control it wraps.\n\nThe relayed event keeps the native name deliberately. `change` is `change`,\nwhich is what a consumer already knows to listen for, and it is what\nreaches React: its synthetic system claims `onChange` and wires it to that\nname, so a prefixed one would never arrive.\n\n`composed` is not forced. It defaults to the original event's own value, so\na relayed `change` stops at the next shadow boundary exactly as a native\none would. Pass it explicitly only where escaping is the intent, and say so\nwhere you do.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finalizeStyles",
+              "privacy": "protected",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "CSSResultOrNative[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "styles",
+                  "optional": true,
+                  "type": {
+                    "text": "CSSResultOrNative | CSSResultOrNative[]"
+                  }
+                }
+              ],
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it, with the rules for the marks it writes.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "events": [
+            {
+              "type": {
+                "text": "HelixBeforeCloseEvent"
+              },
+              "description": "Fired before the group closes. Cancelable.",
+              "name": "helix-before-close",
+              "reactProp": "onhelix-before-close"
+            },
+            {
+              "type": {
+                "text": "HelixBeforeOpenEvent"
+              },
+              "description": "Fired before the group opens. Cancelable.",
+              "name": "helix-before-open",
+              "reactProp": "onhelix-before-open"
+            },
+            {
+              "name": "toggle",
+              "type": {
+                "text": "ToggleEvent"
+              },
+              "description": "Fired after the group opens or closes, with `newState` and `oldState`.",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              },
+              "reactProp": "ontoggle"
+            }
+          ],
+          "attributes": [
+            {
+              "name": "duration",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "How long the step took, as it should read, such as `12s`.",
+              "fieldName": "duration"
+            },
+            {
+              "name": "heading",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "What the step is called. The `heading` slot replaces it.",
+              "fieldName": "heading"
+            },
+            {
+              "name": "status",
+              "type": {
+                "text": "'done' | 'failed' | 'pending' | 'running' | 'skipped' | undefined"
+              },
+              "description": "Where the step stands, which draws a mark before the heading.",
+              "fieldName": "status"
+            },
+            {
+              "name": "status-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{status, select, pending {waiting} running {running} done {finished} failed {failed} skipped {skipped} other {}}'",
+              "description": "What a screen reader hears for the status, after the heading.\n`{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`.",
+              "fieldName": "statusLabel"
+            },
+            {
+              "name": "default-open",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the element starts open. Ignored once `open` is written.",
+              "fieldName": "defaultOpen",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            },
+            {
+              "name": "open",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the element is open.\n\nOne property, not two, so `dialog.open` answers the question anyone\nasking it meant. Writing always applies; `<helix-dialog open>` is the\nsame statement in markup.\n\n**Not reflected, and that is required rather than tidy.** Reflection\nwrites the resolved state back as an attribute, so an element that opened\nitself would put `open` on its own host: cloned, serialized for\nhydration, or diffed by a framework, it comes back holding whatever the\nlast reader did rather than what the author wrote. `:state(open)` carries\nthe resolved state for stylesheets, which is what the mirror is for.",
+              "fieldName": "open",
+              "inheritedFrom": {
+                "name": "MixinControllerOpen",
+                "module": "src/mixins/mixin-controller-open/mixin-controller-open.ts"
+              }
+            }
+          ],
+          "cssStates": [
+            {
+              "description": "The group shows its lines.",
+              "name": "open"
+            },
+            {
+              "description": "Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.",
+              "name": "settled",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "mixins": [
+            {
+              "name": "MixinControllerOpen",
+              "package": "@fusion.dev/helix-core"
+            }
+          ],
+          "superclass": {
+            "name": "HelixElement",
+            "package": "@fusion.dev/helix-core"
+          },
+          "summary": "One step of a log, which folds its lines under a heading with its status and how long it took.",
+          "helix": {
+            "since": "0.199.0",
+            "status": "experimental",
+            "documentation": "https://fusion.dev/helix/components/log",
+            "tier": "headless",
+            "group": "BaseLog",
+            "part": "Group"
+          },
+          "tagName": "helix-headless-log-group",
+          "customElement": true,
+          "modulePath": "src/log/group/log-group.ts",
+          "definitionPath": "src/log/group/log-group.ts"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "HelixHeadlessLogGroup",
+          "declaration": {
+            "name": "HelixHeadlessLogGroup",
+            "module": "src/log/group/log-group.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "helix-headless-log-group",
+          "declaration": {
+            "name": "HelixHeadlessLogGroup",
+            "module": "src/log/group/log-group.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/log/index.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "LogRun",
+          "declaration": {
+            "name": "LogRun",
+            "module": "./ansi.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogStyle",
+          "declaration": {
+            "name": "LogStyle",
+            "module": "./ansi.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "parseAnsi",
+          "declaration": {
+            "name": "parseAnsi",
+            "module": "./ansi.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "stripAnsi",
+          "declaration": {
+            "name": "stripAnsi",
+            "module": "./ansi.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogGroup",
+          "declaration": {
+            "name": "LogGroup",
+            "module": "./buffer.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogLevel",
+          "declaration": {
+            "name": "LogLevel",
+            "module": "./buffer.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogLine",
+          "declaration": {
+            "name": "LogLine",
+            "module": "./buffer.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogParser",
+          "declaration": {
+            "name": "LogParser",
+            "module": "./buffer.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogStatus",
+          "declaration": {
+            "name": "LogStatus",
+            "module": "./buffer.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "HelixHeadlessLogGroup",
+          "declaration": {
+            "name": "HelixHeadlessLogGroup",
+            "module": "./group/log-group.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "HelixHeadlessLogLine",
+          "declaration": {
+            "name": "HelixHeadlessLogLine",
+            "module": "./line/log-line.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogTimes",
+          "declaration": {
+            "name": "LogTimes",
+            "module": "./line/log-line.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "HelixHeadlessLog",
+          "declaration": {
+            "name": "HelixHeadlessLog",
+            "module": "./root/log-root.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogScrollOptions",
+          "declaration": {
+            "name": "LogScrollOptions",
+            "module": "./root/log-root.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "LogSource",
+          "declaration": {
+            "name": "LogSource",
+            "module": "./root/log-root.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/log/line/log-line.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "timeOf",
+          "return": {
+            "type": {
+              "text": "number | undefined"
+            }
+          },
+          "parameters": [
+            {
+              "name": "at",
+              "type": {
+                "text": "number | string | undefined"
+              }
+            }
+          ],
+          "description": "Milliseconds since the epoch for `at`, or undefined where it names no time."
+        },
+        {
+          "kind": "class",
+          "description": "Write one for each line of a log you serve whole, inside a `Log` or a\n`Log.Group`. The log numbers each line, counting the lines of every group,\nand tells it whether to show its number and its time.\n\n`level` says how much a line matters, and the styled tier draws `warn` and\n`error` lines apart. The text is the line's own content, so you can mark it\nup yourself.",
+          "name": "HelixHeadlessLogLine",
+          "cssProperties": [
+            {
+              "description": "Written on a `run` with a background, in the same form as `--log-run-color`.",
+              "name": "--log-run-background-color"
+            },
+            {
+              "description": "Written on a `run` with a text color: one of the sixteen `--log-ansi-*` colors the log publishes, or the color itself.",
+              "name": "--log-run-color"
+            }
+          ],
+          "cssParts": [
+            {
+              "description": "The row the number, the time, and the text sit in.",
+              "name": "line"
+            },
+            {
+              "description": "The row of a line at `debug`.",
+              "name": "line-debug"
+            },
+            {
+              "description": "The row of a line at `error`.",
+              "name": "line-error"
+            },
+            {
+              "description": "The row of a line `mark-lines` names on the log.",
+              "name": "line-marked"
+            },
+            {
+              "description": "The row of a line at `warn`.",
+              "name": "line-warn"
+            },
+            {
+              "description": "Text that matches the log's `query`, in a line the log draws from data.",
+              "name": "match"
+            },
+            {
+              "description": "The line's number, shown with `line-numbers`, and a link with `line-href`.",
+              "name": "number"
+            },
+            {
+              "description": "A stretch of text drawn in an ANSI style, in a line the log draws from data. Its color is `--log-run-color` and its background `--log-run-background-color`.",
+              "name": "run"
+            },
+            {
+              "description": "A run drawn bold.",
+              "name": "run-bold"
+            },
+            {
+              "description": "A run drawn faint.",
+              "name": "run-dim"
+            },
+            {
+              "description": "A run drawn italic.",
+              "name": "run-italic"
+            },
+            {
+              "description": "A run drawn struck through.",
+              "name": "run-strike"
+            },
+            {
+              "description": "A run drawn underlined.",
+              "name": "run-underline"
+            },
+            {
+              "description": "The text of the line.",
+              "name": "text"
+            },
+            {
+              "description": "When the line was written, shown with `timestamps`.",
+              "name": "time"
+            }
+          ],
+          "slots": [
+            {
+              "description": "The text of the line.",
+              "name": ""
+            }
+          ],
+          "members": [
+            {
+              "kind": "field",
+              "name": "words",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-log'",
+              "description": "The key this family's words are registered under, its styled tag."
+            },
+            {
+              "kind": "field",
+              "name": "at",
+              "type": {
+                "text": "number | string"
+              },
+              "default": "''",
+              "description": "When the line was written: milliseconds since the epoch, or anything `Date` parses.",
+              "attribute": "at"
+            },
+            {
+              "kind": "field",
+              "name": "level",
+              "type": {
+                "text": "'debug' | 'error' | 'info' | 'warn' | undefined"
+              },
+              "description": "How much the line matters. Absent is `info`.",
+              "attribute": "level",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "lineLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Line {number}'",
+              "description": "What a screen reader hears for the link on a line's number. `{number}` is the number.",
+              "attribute": "line-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "method",
+              "name": "renderNumber",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "description": "The number, as a link where the log gave one, or as text a screen reader skips."
+            },
+            {
+              "kind": "method",
+              "name": "renderTime",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "description": "The time, on the clock or into the run, where the log asked for one and the line has one."
+            },
+            {
+              "kind": "method",
+              "name": "renderText",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
+              },
+              "description": "The text: the default slot, falling back to the runs a log drew from data.\nThe slot answers a page, and this answers the tier above."
+            },
+            {
+              "kind": "method",
+              "name": "renderRuns",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "unknown[]"
+                }
+              },
+              "description": "The runs a log drew from data, each match of its query marked.\n\n**The parts are literals**, each name written where it is decided, so a\nrule reading the source finds every name a run can carry. A named color\nis written into `style` as the `--log-ansi-` color of that name, and any\nother as itself. A bright color is written apart from the rest, so a rule\nreading the source sees the `--log-ansi-bright-` colors read as well as\nthe plain ones. Inverse swaps the two, each falling back to the log's own\nink."
+            },
+            {
+              "kind": "field",
+              "name": "tier",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-headless-'",
+              "description": "The prefix this tier registers its elements under.\n\n**A component that renders another renders its own tier's version of it**,\nso `helix-headless-pagination-size` composes `helix-headless-select` and\n`helix-pagination-size` composes `helix-select`. One template says\n`${this.tag('select')}` and each tier answers with its own name.\n\n**The public tag may not be the composed one, in either tier.** Using it\ncosts three things: the name means two different things depending on what a\nconsumer imported, the headless tier composes an element it does not ship,\nand the composition cannot be tested there at all, because there is no\n`helix-select` on that tier to test it against.\n\n**A prefix rather than an override per composition**, which was the first\nplan and does not compile. An override re-renders the fragment from the\nsubclass, and the fragment reads members the base keeps private:\n`PaginationSize` alone would have had to widen `options`, `current` and\n`handleChange` to `protected` so a subclass could say the same thing again.\nSixteen families of that is a lot of encapsulation spent on saying one\nword differently.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "tag",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "StaticValue"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One composed tag, as a static value a template can interpolate.\n\nWhat `unsafeStatic` returns, safe by construction: the name is a literal in\nour own source and the prefix is one of two strings this class defines.\nCalled per render and not cached, which costs nothing, because\n`static-html` keys its template cache on the joined string rather than on\nthe object.\n\n**Written out rather than imported, for every element that never renders\none.** `lit/static-html.js` declares no side effects, so importing\n`unsafeStatic` alone kept the module's three `withStatic` calls in every\nbundle: about 210 bytes gzipped on each of the families that compose no\ntag, Divider and Badge among them. The value is lit's cross-copy protocol,\nkeyed by `Symbol.for('')` so that two copies of lit on a page read each\nother's, and a spec holds it equal to `unsafeStatic`'s.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "partNamed",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "T | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One of this element's own parts, by name, or null where it is not rendered.\n\nNot `part`, which every element already has: `Element.part` is the\n`DOMTokenList` of the names the element itself carries, and a method under\nthat name is a type error on every subclass.\n\n**One guard for every lookup.** Lit's server shim has no `querySelector`\non the render root, so a lookup reached during a server render, from a\ngetter a template reads or from `willUpdate`, throws there and nowhere\nelse. Four spellings of the same guard had grown across the library, and\na fifth site with none. Null on the server, which is what the rest of the\ncode already treats a part that has not rendered as.\n\n**`~=` and not `=`.** A part drawn in a state carries a second name while\nthe state holds, `part=\"page page-current\"`, and an exact match stops\nfinding it for exactly as long as it is the one that matters.\n\n`helix component`'s `selectors` reads these calls the way it reads a\n`querySelector('[part=\"x\"]')`, so a name nothing renders is a finding\nrather than a null an optional chain swallows.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "internals",
+              "type": {
+                "text": "ElementInternals"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The element's semantics, set without touching the DOM.\n\n`ElementInternals` sets the implicit role, which an author's own `role`\nattribute still overrides, and it writes no attribute. Setting `role` on the\nhost directly would: that is an attribute the element gives itself after it\nupgrades, which a React consumer's server markup never had, and hydration\nreports it as a mismatch.\n\nAvailable during server rendering. Lit's shim implements `attachInternals`,\nso nothing here needs a guard.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleState",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "on",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Records a boolean fact about this element as a custom state.\n\n**The host belongs to whoever rendered it, and a component's own\nbookkeeping may not be kept there.** An attribute written on the first\nupdate is markup a consumer's server never sent, so a React consumer\nhydrates a DOM that has gained attributes since and reports a mismatch it\nwill not patch up. A custom state is not in the DOM at all: it carries the\nfact to a stylesheet through `:state()` and leaves the markup alone, so the\nserver's output and the client's agree by construction.\n\n`SETTLED` carries the long version of that argument; `checked`, `open`,\n`invalid` and `has-label` are recorded the same way, each of them a state a\n`default-*` attribute resolves before React reaches the node.\n\n**Deferring the definitions is not a fix and could not be.** Importing them\nfrom an effect so the upgrades fall the other side of hydration works only\nwhile hydration is one pass: anything that splits it, a streamed segment or\na suspended boundary, puts an upgrade back inside the window. Timing cannot\nbe the guarantee when the fact is kept somewhere React reconciles.\n\nFeature-tested rather than assumed, the way `hostAria` tests element\nreferences. An engine without `CustomStateSet` records nothing and keeps\nwhatever the resting rule draws, which is the safe direction to fail.\n\n**The engines the test is for are browsers**: Safari below 17.4 and Firefox\nbelow 126, where the write is a `TypeError`, so a component bypassing this\nfails to render rather than rendering without whatever the state draws.\nLit's server shim sets `states`, so the guard passes there and records a\nstate nothing reads, which is harmless.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "whenSettled",
+              "type": {
+                "text": "Promise<void>"
+              },
+              "readonly": true,
+              "description": "Resolves a frame after the first update, when transitions are switched on.\n\n**Named `whenSettled` because `settled` is taken four times over**, by\nImage, Splitter and both color controls, none of them about transitions. A\nbase class takes the name every subclass then cannot use.\n\n**The state it reports cannot be watched, which is why this exists.** A\ncustom state is deliberately not in the DOM, so there is no\n`MutationObserver` equivalent for `ElementInternals.states`. Await this\ninstead.\n\nSeparate from `updateComplete`, which resolves in the microtask checkpoint\nthe suppression is still active in. That is the distinction `readyToMove`\nin `@fusion.dev/helix-testing` is written around.\n\nIt never resolves where `requestAnimationFrame` never fires, which is a\nserver, a hidden tab, and happy-dom. Callers that must not hang there race\nit against a timeout, as the happy-dom harness's `readyToMove` does. The\nbrowser harness's awaits it alone: a browser always runs the frame, and a\ntimer beside it was a bet on how long one takes, which a busy run lost.",
+              "default": "new Promise<void>((resolve) => { this.resolveSettled = resolve })",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "resolveSettled",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "private",
+              "description": "Resolves `whenSettled`, once, from the frame that records the state.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fromServer",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the shadow root was a server's, parsed from declarative shadow DOM.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "hydrating",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this update is hydrating a server's markup, and so has to render\nexactly what the server rendered.\n\n**Lit hydrates by assuming the markup already shows the first render.** A\nvalue that differs is recorded and never written, so the page keeps the\nserver's, and a template that differs throws. The server has no children,\nso anything a component reads from its children waits for the update after\nhydration, which `finishHydration` asks for. Without a server's markup the\nfirst render reads them and there is one render.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "serverRendered",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element hydrated a server's markup rather than rendering its own.\n\nFor what happened before hydration and cannot be heard after it: an image\nthe parser fetched fires `load` or `error` before any listener exists, so a\ncomponent asks the image instead, once, when this is true.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finishHydration",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks for the update a hydration put off, so the reads it skipped happen.\n\nCalled from `firstUpdated`, the end of the hydrating update. The render it\nschedules can only follow that one, which is the exception Lit's\nchange-in-update warning names, and it happens only on a page a server\nrendered.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "childrenKnown",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this render can know the children.\n\nA server cannot: its element shim carries attributes and no tree, so\n`children` is undefined there. A render hydrating what a server sent must\nnot, because it has to be the server's render. Anywhere else it can. A\ncomponent whose render depends on its children reads them through\n`knownChildren`, and treats \"not known\" as its own answer rather than as\n\"none\": a list that renders its empty state because nobody has looked yet is\nthe one thing an empty state must never do.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "knownChildren",
+              "type": {
+                "text": "Element[]"
+              },
+              "privacy": "protected",
+              "description": "The children a render may read: all of them where they are known, and none otherwise.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "assignsByName",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element's slots route by name although it asked to assign them\nby hand.\n\n**A declarative shadow root is always the by-name kind.** HTML has no way to\nask for manual assignment, so a component that assigns by hand and hydrates\na server's root gets one where `slot.assign()` does nothing, and its\nchildren land wherever their `slot` attribute sends them. The way through is\nto write that attribute, which is what `route` does. Only there: on a root\nthis element made, assignment stays manual and the consumer's markup is\nnever touched, which is what a React consumer's hydration requires.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "route",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "child",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string | undefined"
+                  }
+                }
+              ],
+              "description": "Sends a child to a slot by name, on a root that routes by name.\n\n`undefined` is the default slot. Written only when it differs, so routing\nthe same child again on every update writes nothing.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "stopInner",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Stops an inner control's own announcement at this element's boundary.\n\n**A composed control is one control to a consumer, and the natives had no\nequivalent of the stop the prefixed events already get.** `<helix-select>`\nrenders a `<helix-listbox>`, and both announce: the listbox dispatches\n`input` and `change` from its own host, `input` is composed by\nspecification, and a consumer listening on the select therefore heard one\nchoice twice. Measured before this existed, on the styled tier, one choice\non the inner listbox: select `input` twice and `change` three times,\ncombobox, date input, time input and color input twice each. `Command` was\nthe only one that was right, because it happened to reach for\n`stopImmediatePropagation` for a different reason.\n\nBound on the child in the parent's template, so it runs while the event is\nstill at the child and before it can cross. The guard is for the case where\na component binds this on itself: an element must never stop its own\nannouncement, which is the one it exists to make.\n\nThis is the same job the `helix-before-*` handlers do with their own\n`stopPropagation`, and it is separate rather than folded into them because\na consumer may legitimately refuse a request without the notification ever\nhappening: the two travel at different times and one can be absent.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "relayNativeEvent",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                },
+                {
+                  "name": "init",
+                  "optional": true,
+                  "type": {
+                    "text": "EventInit"
+                  }
+                }
+              ],
+              "description": "Re-emits a native event from the host, under its own name.\n\nA native event fired by an inner `<input>` or `<textarea>` is not composed,\nso it stops at the shadow boundary and a consumer listening on\n`<helix-input>` hears nothing. Re-dispatching it from the host is what\nmakes the component behave like the control it wraps.\n\nThe relayed event keeps the native name deliberately. `change` is `change`,\nwhich is what a consumer already knows to listen for, and it is what\nreaches React: its synthetic system claims `onChange` and wires it to that\nname, so a prefixed one would never arrive.\n\n`composed` is not forced. It defaults to the original event's own value, so\na relayed `change` stops at the next shadow boundary exactly as a native\none would. Pass it explicitly only where escaping is the intent, and say so\nwhere you do.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "markRules",
+              "type": {
+                "text": "readonly string[]"
+              },
+              "privacy": "protected",
+              "static": true,
+              "default": "[]",
+              "description": "The rules from `mark-rules.ts` for the marks this element writes in its\nown shadow root: `data-scroller`, `data-virtual`, `data-spoken` and\n`data-mirror`.\n\nA component that writes a mark names its rule here, and a subclass\ninherits the list. One that writes none takes only the three rules every\nshadow root gets, which is what keeps the other four out of a Button.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finalizeStyles",
+              "privacy": "protected",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "CSSResultOrNative[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "styles",
+                  "optional": true,
+                  "type": {
+                    "text": "CSSResultOrNative | CSSResultOrNative[]"
+                  }
+                }
+              ],
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it, with the rules for the marks it writes.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "attributes": [
+            {
+              "name": "at",
+              "type": {
+                "text": "number | string"
+              },
+              "default": "''",
+              "description": "When the line was written: milliseconds since the epoch, or anything `Date` parses.",
+              "fieldName": "at"
+            },
+            {
+              "name": "level",
+              "type": {
+                "text": "'debug' | 'error' | 'info' | 'warn' | undefined"
+              },
+              "description": "How much the line matters. Absent is `info`.",
+              "fieldName": "level"
+            },
+            {
+              "name": "line-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Line {number}'",
+              "description": "What a screen reader hears for the link on a line's number. `{number}` is the number.",
+              "fieldName": "lineLabel"
+            }
+          ],
+          "cssStates": [
+            {
+              "description": "The log's `query` does not match the line, so it draws nothing.",
+              "name": "filtered"
+            },
+            {
+              "description": "Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.",
+              "name": "settled",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "superclass": {
+            "name": "HelixElement",
+            "package": "@fusion.dev/helix-core"
+          },
+          "summary": "One line of a log, with its number, its time, and its text.",
+          "helix": {
+            "since": "0.199.0",
+            "status": "experimental",
+            "documentation": "https://fusion.dev/helix/components/log",
+            "tier": "headless",
+            "group": "BaseLog",
+            "part": "Line"
+          },
+          "tagName": "helix-headless-log-line",
+          "customElement": true,
+          "modulePath": "src/log/line/log-line.ts",
+          "definitionPath": "src/log/line/log-line.ts"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "timeOf",
+          "declaration": {
+            "name": "timeOf",
+            "module": "src/log/line/log-line.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "HelixHeadlessLogLine",
+          "declaration": {
+            "name": "HelixHeadlessLogLine",
+            "module": "src/log/line/log-line.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "helix-headless-log-line",
+          "declaration": {
+            "name": "HelixHeadlessLogLine",
+            "module": "src/log/line/log-line.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/log/root/log-root.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "A log holds lines in the order they were written and keeps the reader at\nthe newest one, until they scroll up to read. It stays where they left it\nwhile lines keep arriving, and a button returns them to the end\n(`resume-label`, \"Jump to latest\").\n\n**Lines arrive two ways.** For a log you serve whole, write `Log.Line`\nelements as children, inside `Log.Group` elements for the steps. For a log\nthat is still being written, hand it text: `write(chunk)` takes text as it\narrives, in pieces that need not end at a line break, and `source` takes a\n`ReadableStream` or an async iterable and reads it to the end. `lines` takes\nthe lines as data. Text drawn from data is drawn one window at a time, so a\nlog of a hundred thousand lines holds a screenful of elements, and the log\nneeds a block size of its own. Do not use both ways at once.\n\n**Written text is read the way a terminal shows it.** A carriage return\nstarts the line over, so a progress bar stays one line, and the line still\nbeing written is shown as it stands. ANSI colors and weights are drawn, in\nthe sixteen colors the styled tier takes from your theme, and every other\nescape code is dropped. Give `parse` a function to read each finished line,\nsuch as a level off its prefix or a group off a marker.\n\n**Steps fold.** Lines that name a group in `groups` stand under its heading,\nwhich shows its status and how long it took and opens and closes the lines.\nA group a reader opens or closes fires `helix-expand` with every open group.\n\n**Search with `query`.** The log shows only the lines that hold it, marks\neach match, opens the groups that hold one, and says how many lines match.\n\n`line-numbers` numbers the lines from the first ever written, so a number\nstill names its line once `limit` has let older lines go, and `line-href`\nmakes each number a link, such as `#L{n}`. `scrollToLine(n)` takes a reader\nto one. `timestamps` shows each line's `at`, on the clock or as the time\ninto the run. `mark-lines` marks lines, such as `12, 40-44`.\n\n**What a screen reader hears.** The log is a `log` and stays quiet as lines\narrive, since reading a build aloud line by line helps nobody. A separate\nstatus region says each line at `error` once it arrives, each step once it\nfinishes or fails, and the end of the run once `done` is set or `source`\nends. Set `done` yourself when output you `write` is complete.\n\nThe log scrolls on this tier. It carries `data-scroller`, so following the\nnewest line and drawing a window work with no stylesheet. Give the log a\nblock size, such as `helix-headless-log::part(log) { block-size: 20rem }`.\n\n```js\nimport '@fusion.dev/helix/log'\n```",
+          "name": "HelixHeadlessLog",
+          "cssProperties": [
+            {
+              "description": "The background a run takes where ANSI swaps the colors and named none. Defaults to the log's own background on the styled tier.",
+              "name": "--log-ansi-background"
+            },
+            {
+              "description": "The ANSI color black, which codes `30` and `40` draw.",
+              "name": "--log-ansi-black"
+            },
+            {
+              "description": "The ANSI color blue, which codes `34` and `44` draw.",
+              "name": "--log-ansi-blue"
+            },
+            {
+              "description": "The ANSI color bright black, which codes `90` and `100` draw.",
+              "name": "--log-ansi-bright-black"
+            },
+            {
+              "description": "The ANSI color bright blue, which codes `94` and `104` draw.",
+              "name": "--log-ansi-bright-blue"
+            },
+            {
+              "description": "The ANSI color bright cyan, which codes `96` and `106` draw.",
+              "name": "--log-ansi-bright-cyan"
+            },
+            {
+              "description": "The ANSI color bright green, which codes `92` and `102` draw.",
+              "name": "--log-ansi-bright-green"
+            },
+            {
+              "description": "The ANSI color bright magenta, which codes `95` and `105` draw.",
+              "name": "--log-ansi-bright-magenta"
+            },
+            {
+              "description": "The ANSI color bright red, which codes `91` and `101` draw.",
+              "name": "--log-ansi-bright-red"
+            },
+            {
+              "description": "The ANSI color bright white, which codes `97` and `107` draw.",
+              "name": "--log-ansi-bright-white"
+            },
+            {
+              "description": "The ANSI color bright yellow, which codes `93` and `103` draw.",
+              "name": "--log-ansi-bright-yellow"
+            },
+            {
+              "description": "The ANSI color cyan, which codes `36` and `46` draw.",
+              "name": "--log-ansi-cyan"
+            },
+            {
+              "description": "The text color a run takes where ANSI swaps the colors and named none. Defaults to the log's own text color on the styled tier.",
+              "name": "--log-ansi-foreground"
+            },
+            {
+              "description": "The ANSI color green, which codes `32` and `42` draw.",
+              "name": "--log-ansi-green"
+            },
+            {
+              "description": "The ANSI color magenta, which codes `35` and `45` draw.",
+              "name": "--log-ansi-magenta"
+            },
+            {
+              "description": "The ANSI color red, which codes `31` and `41` draw.",
+              "name": "--log-ansi-red"
+            },
+            {
+              "description": "The ANSI color white, which codes `37` and `47` draw.",
+              "name": "--log-ansi-white"
+            },
+            {
+              "description": "The ANSI color yellow, which codes `33` and `43` draw.",
+              "name": "--log-ansi-yellow"
+            },
+            {
+              "description": "Written on the `log`: how many digits the largest line number has, while `line-numbers` is set, so a stylesheet can size the column of numbers.",
+              "name": "--log-digits"
+            }
+          ],
+          "cssParts": [
+            {
+              "description": "The space the rows below the drawn ones would take. Only for lines drawn from data.",
+              "name": "after"
+            },
+            {
+              "description": "The space the rows above the drawn ones would take. Only for lines drawn from data.",
+              "name": "before"
+            },
+            {
+              "description": "The line above the log that says how many earlier lines `limit` let go.",
+              "name": "dropped"
+            },
+            {
+              "description": "Shown when the log has no lines.",
+              "name": "empty"
+            },
+            {
+              "description": "Not drawn: a group drawn from data stands for its heading, and its lines are rows beside it.",
+              "name": "group-content"
+            },
+            {
+              "description": "How long a step drawn from `groups` took.",
+              "name": "group-duration"
+            },
+            {
+              "description": "The heading of a step drawn from `groups`.",
+              "name": "group-heading"
+            },
+            {
+              "description": "The caret of a step drawn from `groups`.",
+              "name": "group-mark"
+            },
+            {
+              "description": "The status mark of a step drawn from `groups`.",
+              "name": "group-status"
+            },
+            {
+              "description": "The button that opens and closes a step drawn from `groups`.",
+              "name": "group-summary"
+            },
+            {
+              "description": "The button of a step drawn from `groups` that is `done`.",
+              "name": "group-summary-done"
+            },
+            {
+              "description": "The button of a step drawn from `groups` that `failed`.",
+              "name": "group-summary-failed"
+            },
+            {
+              "description": "The button of a step drawn from `groups` that is `pending`.",
+              "name": "group-summary-pending"
+            },
+            {
+              "description": "The button of a step drawn from `groups` that is `running`.",
+              "name": "group-summary-running"
+            },
+            {
+              "description": "The button of a step drawn from `groups` that was `skipped`.",
+              "name": "group-summary-skipped"
+            },
+            {
+              "description": "The row of a line drawn from data.",
+              "name": "line"
+            },
+            {
+              "description": "The row of a line drawn from data at `debug`.",
+              "name": "line-debug"
+            },
+            {
+              "description": "The row of a line drawn from data at `error`.",
+              "name": "line-error"
+            },
+            {
+              "description": "The row of a line drawn from data that `mark-lines` names.",
+              "name": "line-marked"
+            },
+            {
+              "description": "Text in a line drawn from data that matches `query`.",
+              "name": "line-match"
+            },
+            {
+              "description": "The number of a line drawn from data.",
+              "name": "line-number"
+            },
+            {
+              "description": "A stretch of a line drawn from data in an ANSI style.",
+              "name": "line-run"
+            },
+            {
+              "description": "A run drawn bold.",
+              "name": "line-run-bold"
+            },
+            {
+              "description": "A run drawn faint.",
+              "name": "line-run-dim"
+            },
+            {
+              "description": "A run drawn italic.",
+              "name": "line-run-italic"
+            },
+            {
+              "description": "A run drawn struck through.",
+              "name": "line-run-strike"
+            },
+            {
+              "description": "A run drawn underlined.",
+              "name": "line-run-underline"
+            },
+            {
+              "description": "The text of a line drawn from data.",
+              "name": "line-text"
+            },
+            {
+              "description": "The time of a line drawn from data.",
+              "name": "line-time"
+            },
+            {
+              "description": "The row of a line drawn from data at `warn`.",
+              "name": "line-warn"
+            },
+            {
+              "description": "The region where screen readers hear errors, finished steps, and the end of the run.",
+              "name": "live"
+            },
+            {
+              "description": "Shown while `loading` is set.",
+              "name": "loading"
+            },
+            {
+              "description": "The lines, which scroll. On this tier, it needs only a block size.",
+              "name": "log"
+            },
+            {
+              "description": "The control shown while the reader is scrolled away from the newest line.",
+              "name": "resume"
+            },
+            {
+              "description": "The button the `resume` region shows when nothing is slotted into it.",
+              "name": "resume-button"
+            },
+            {
+              "description": "The arrow on the default `resume-button`.",
+              "name": "resume-mark"
+            },
+            {
+              "description": "The wrapper around one row drawn from data, a line or a group's heading.",
+              "name": "row"
+            },
+            {
+              "description": "The `toolbar` slot, above the log.",
+              "name": "toolbar"
+            }
+          ],
+          "slots": [
+            {
+              "description": "The lines, as `Log.Line` and `Log.Group` elements.",
+              "name": ""
+            },
+            {
+              "description": "The control that returns to the newest line, shown while the reader is scrolled away. Defaults to a button named by `resume-label`.",
+              "name": "resume"
+            },
+            {
+              "description": "Controls above the log, such as a search field or a button that wraps lines.",
+              "name": "toolbar"
+            }
+          ],
+          "members": [
+            {
+              "kind": "field",
+              "name": "markRules",
+              "type": {
+                "text": "[SCROLLER_RULE, VIRTUAL_RULE]"
+              },
+              "privacy": "protected",
+              "static": true,
+              "default": "[SCROLLER_RULE, VIRTUAL_RULE]",
+              "description": "The rules from `mark-rules.ts` for the marks this element writes in its\nown shadow root: `data-scroller`, `data-virtual`, `data-spoken` and\n`data-mirror`.\n\nA component that writes a mark names its rule here, and a subclass\ninherits the list. One that writes none takes only the three rules every\nshadow root gets, which is what keeps the other four out of a Button.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "words",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-log'",
+              "description": "The key this family's words are registered under, its styled tag:\n`registerWords('de', { 'helix-log': { resumeLabel: 'Zum Ende' } })`.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "ESTIMATE",
+              "type": {
+                "text": "number"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "20",
+              "description": "How tall a row is assumed to be before one has been drawn, in pixels."
+            },
+            {
+              "kind": "field",
+              "name": "defaultPinned",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Whether the log opens following its newest line, when `pinned` is not set.\n`default-pinned=\"false\"` opens it where it starts.",
+              "attribute": "default-pinned"
+            },
+            {
+              "kind": "field",
+              "name": "done",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the run is over, which a screen reader is told once.\n\nSet it when output you `write` is complete. A `source` sets it when the\nstream ends.",
+              "attribute": "done"
+            },
+            {
+              "kind": "field",
+              "name": "doneLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Finished'",
+              "description": "What a screen reader hears when the run is over.",
+              "attribute": "done-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "droppedLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {# earlier line is} other {# earlier lines are}} not kept'",
+              "description": "What the line above the log says once `limit` has let lines go. `{count}` is how many.",
+              "attribute": "dropped-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "emptyText",
+              "type": {
+                "text": "string"
+              },
+              "default": "'No output yet'",
+              "description": "The text shown and announced when the log has no lines.",
+              "attribute": "empty-text",
+              "helix": {
+                "words": true
+              },
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "errorLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {Error} other {# errors}}: {text}'",
+              "description": "What a screen reader hears when lines at `error` arrive. `{count}` is how\nmany arrived together and `{text}` is the first of them.",
+              "attribute": "error-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fallbackLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Log'",
+              "description": "The log's name, read by screen readers, where `label` is empty.",
+              "attribute": "fallback-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "groupLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{status, select, failed {{heading} failed} other {{heading} finished}}'",
+              "description": "What a screen reader hears when a step finishes or fails. `{heading}` is\nthe step's heading and `{status}` is `done` or `failed`.",
+              "attribute": "group-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "groups",
+              "type": {
+                "text": "readonly LogGroup[]"
+              },
+              "default": "[]",
+              "description": "The steps the lines from data name in `group`. A step stands where its\nfirst line is, and one with no line yet stands at the end.\n\nReplaced rather than mutated, as `lines` is: a step finishing is a new\narray with its `status` changed."
+            },
+            {
+              "kind": "field",
+              "name": "label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The log's name, read by screen readers.",
+              "attribute": "label"
+            },
+            {
+              "kind": "field",
+              "name": "limit",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "The most lines kept, or 0 to keep them all. Past it the oldest lines are\nlet go, and the line above the log says how many.",
+              "attribute": "limit"
+            },
+            {
+              "kind": "field",
+              "name": "lineHref",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "A link for each line number, with `{n}` where the number goes, such as\n`#L{n}`. Empty leaves the numbers as text.",
+              "attribute": "line-href"
+            },
+            {
+              "kind": "field",
+              "name": "lineLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Line {number}'",
+              "description": "What a screen reader hears for the link on a line's number, handed to each\nline the log draws. `{number}` is the number.",
+              "attribute": "line-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "lineNumbers",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether each line shows its number.",
+              "attribute": "line-numbers"
+            },
+            {
+              "kind": "field",
+              "name": "lines",
+              "type": {
+                "text": "readonly LogLine[]"
+              },
+              "description": "The lines as data. Reading it gives every line kept, oldest first, with\nthe line still being written left out.\n\nReplaced rather than mutated: setting it starts the log over with these\nlines, and `write` adds to them. Set it or write children, not both."
+            },
+            {
+              "kind": "field",
+              "name": "markLines",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Lines to mark, as numbers and ranges such as `12, 40-44`.",
+              "attribute": "mark-lines"
+            },
+            {
+              "kind": "field",
+              "name": "matchesLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, =0 {No lines match} one {# line matches} other {# lines match}}'",
+              "description": "What a screen reader hears when `query` changes. `{count}` is how many lines match.",
+              "attribute": "matches-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "parse",
+              "type": {
+                "text": "LogParser | undefined"
+              },
+              "description": "Reads each finished line of written text: return the fields to set, such\nas `level` or `group`, or `null` to drop the line. Lines in `lines` are\ntaken as they are."
+            },
+            {
+              "kind": "field",
+              "name": "pinned",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the log follows its newest line.\n\nThe reader's scrolling asks first: `helix-before-pin` is cancelable, so a\nconsumer refusing it takes the decision and assigns their own value. Not\nreflected, for the reason `Chat` gives at its own `pinned`: a default of\ntrue would write the attribute on upgrade.",
+              "attribute": "pinned"
+            },
+            {
+              "kind": "field",
+              "name": "query",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Text a line has to hold to be shown, ignoring case. Empty shows every line.",
+              "attribute": "query"
+            },
+            {
+              "kind": "field",
+              "name": "resumeLabel",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Jump to latest'",
+              "description": "The words on the button that returns to the newest line, where `resume` is empty.",
+              "attribute": "resume-label",
+              "helix": {
+                "words": true
+              }
+            },
+            {
+              "kind": "field",
+              "name": "source",
+              "type": {
+                "text": "LogSource | null"
+              },
+              "description": "Text to read as it arrives, to the end: a `ReadableStream` of text or\nbytes, such as a `fetch` response's body, or an async iterable. Bytes are\nread as UTF-8. The log sets `done` when it ends, and a new source stops\nreading the last one."
+            },
+            {
+              "kind": "field",
+              "name": "threshold",
+              "type": {
+                "text": "number"
+              },
+              "default": "48",
+              "description": "How near the newest line still counts as being at it, in pixels.",
+              "attribute": "threshold"
+            },
+            {
+              "kind": "field",
+              "name": "timestamps",
+              "type": {
+                "text": "'absolute' | 'relative' | undefined"
+              },
+              "description": "How each line shows its `at`: `absolute` on the clock, `relative` as the\ntime since the first line. Absent shows no time.",
+              "attribute": "timestamps"
+            },
+            {
+              "kind": "field",
+              "name": "wrap",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether a line longer than the box wraps onto the next row. Otherwise the log scrolls sideways.",
+              "attribute": "wrap",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "pinnedState",
+              "type": {
+                "text": "boolean | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined"
+            },
+            {
+              "kind": "field",
+              "name": "doneState",
+              "type": {
+                "text": "boolean | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined"
+            },
+            {
+              "kind": "field",
+              "name": "reading",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether a source is being read, which the log says with `aria-busy`."
+            },
+            {
+              "kind": "field",
+              "name": "announcement",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "private",
+              "default": "''",
+              "description": "The last thing said, and how many times something has been."
+            },
+            {
+              "kind": "field",
+              "name": "said",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0"
+            },
+            {
+              "kind": "field",
+              "name": "buffer",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new LogBuffer()",
+              "description": "The text written and handed over as data."
+            },
+            {
+              "kind": "field",
+              "name": "sourceValue",
+              "type": {
+                "text": "LogSource | null"
+              },
+              "privacy": "private",
+              "default": "null"
+            },
+            {
+              "kind": "field",
+              "name": "readToken",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "Which read of a source is current, so an older one stops writing."
+            },
+            {
+              "kind": "field",
+              "name": "stopReading",
+              "type": {
+                "text": "(() => void) | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "Stops the read in progress."
+            },
+            {
+              "kind": "field",
+              "name": "opened",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new Map<string, boolean>()",
+              "description": "Whether each group drawn from data is open, from the first time it was seen."
+            },
+            {
+              "kind": "field",
+              "name": "view",
+              "type": {
+                "text": "LogRows"
+              },
+              "privacy": "private",
+              "default": "{ matched: 0, rows: [] }",
+              "description": "The rows drawn from data, worked out before each render."
+            },
+            {
+              "kind": "field",
+              "name": "fresh",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the lines were replaced, so measurements no longer name the same rows."
+            },
+            {
+              "kind": "field",
+              "name": "droppedBefore",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "How many lines `limit` had let go at the last render."
+            },
+            {
+              "kind": "field",
+              "name": "owed",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "Scroll offset the rows let go from the top took with them, owed back to a reader who is not following."
+            },
+            {
+              "kind": "field",
+              "name": "childLines",
+              "type": {
+                "text": "HelixHeadlessLogLine[]"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "The lines written as children, in order through every group, read on each change."
+            },
+            {
+              "kind": "field",
+              "name": "childGroups",
+              "type": {
+                "text": "HelixHeadlessLogGroup[]"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "The groups written as children, in order."
+            },
+            {
+              "kind": "field",
+              "name": "watcher",
+              "type": {
+                "text": "MutationObserver | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "Watches the children and their groups for lines arriving and steps changing status."
+            },
+            {
+              "kind": "field",
+              "name": "grower",
+              "type": {
+                "text": "ResizeObserver | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "Watches the log's box for size, which scrolling does not report."
+            },
+            {
+              "kind": "field",
+              "name": "stuckAt",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "-1",
+              "description": "The scroll offset this element last set, which the reader has not moved from."
+            },
+            {
+              "kind": "field",
+              "name": "opening",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "true",
+              "description": "Until the first frame, what is in the log is what it opened with."
+            },
+            {
+              "kind": "field",
+              "name": "heard",
+              "type": {
+                "text": "Heard | undefined"
+              },
+              "privacy": "private",
+              "default": "undefined",
+              "description": "What the status region compared against last time."
+            },
+            {
+              "kind": "field",
+              "name": "virtualize",
+              "privacy": "private",
+              "readonly": true,
+              "default": "new VirtualizeController(this, { anchor: () => !this.pinned, container: () => (this.fed ? this.log : null), count: () => this.view.rows.length, estimate: () => HelixHeadlessLog.ESTIMATE, measured: () => this.wrap, rows: () => (this.fed ? this.drawn() : []), })"
+            },
+            {
+              "kind": "field",
+              "name": "fed",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether the lines are data rather than children.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "log",
+              "type": {
+                "text": "HTMLElement | null"
+              },
+              "privacy": "private",
+              "description": "The element that scrolls, once there is one.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "text",
+              "type": {
+                "text": "string"
+              },
+              "description": "Every line kept, as plain text with the escape codes taken out, one to a\nrow: what a download or a copy of the log should hold.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "write",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "chunk",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Adds text as it arrives. A line ends at each line break, and the text\nafter the last one is the line still being written.",
+              "type": {
+                "text": "write(chunk: string) => void"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "clear",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Lets every line go, and forgets which groups the reader opened, keeping\n`groups`, `parse`, and `limit`.",
+              "type": {
+                "text": "clear() => void"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "resume",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Puts the log back at its newest line, and follows it again.",
+              "type": {
+                "text": "resume() => void"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "scrollToLine",
+              "return": {
+                "type": {
+                  "text": "Promise<boolean>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "number",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "options",
+                  "default": "{}",
+                  "type": {
+                    "text": "LogScrollOptions"
+                  }
+                }
+              ],
+              "description": "Scrolls to line `number`, counted from the first line ever written, and\nstops following the newest. Opens a shut group the line is in. Resolves\nto whether the line is shown: false for a line `limit` let go or `query`\nhides.",
+              "type": {
+                "text": "scrollToLine(number: number, options: LogScrollOptions = {}) => Promise<boolean>"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "isOpen",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "id",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "Whether a group drawn from data is open: as the reader left it, or as `groups` seeded it."
+            },
+            {
+              "kind": "method",
+              "name": "reopen",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "previous",
+                  "type": {
+                    "text": "readonly LogGroup[] | undefined"
+                  }
+                }
+              ],
+              "description": "Follows a group's `open` where the page changed it, so a page can open the\nstep that failed. A group whose `open` did not change keeps what the\nreader left it at."
+            },
+            {
+              "kind": "field",
+              "name": "atBottom",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "description": "Whether the reader is within `threshold` of the newest line right now.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "stick",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Scrolls to the newest line, and remembers where that was."
+            },
+            {
+              "kind": "method",
+              "name": "requestPinned",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "next",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Asks to follow or let go of the newest line, and reports whether the request stood."
+            },
+            {
+              "kind": "method",
+              "name": "drawn",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "{ element: HTMLElement; index: number }[]"
+                }
+              },
+              "description": "The rows drawn from data that are in the tree, each with its place in the whole set."
+            },
+            {
+              "kind": "method",
+              "name": "readChildren",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Reads the lines and groups written as children, through every group, in\nthe order they are written. Nothing on a server, or while hydrating what\none sent."
+            },
+            {
+              "kind": "method",
+              "name": "tellLines",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Tells each line written as a child its number and what the log shows, once\nit has hydrated, so its first render is the server's. Opens a group that\nholds a match while `query` is set."
+            },
+            {
+              "kind": "method",
+              "name": "markScroller",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Makes the log a tab stop while it scrolls, so a keyboard can scroll it in every browser."
+            },
+            {
+              "kind": "method",
+              "name": "listen",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Heard"
+                }
+              },
+              "description": "What the status region compares, as things stand."
+            },
+            {
+              "kind": "method",
+              "name": "announce",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Says what changed since the last time it looked: lines at `error`, steps\nthat finished or failed, the end of the run, and how many lines a new\n`query` matches. Nothing is said for what the log opened with."
+            },
+            {
+              "kind": "method",
+              "name": "readSource",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Promise<void>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "source",
+                  "type": {
+                    "text": "LogSource | null"
+                  }
+                }
+              ],
+              "description": "Reads a source to its end, writing what it gives, and sets `done` when it ends."
+            },
+            {
+              "kind": "field",
+              "name": "handleResize",
+              "privacy": "private",
+              "readonly": true,
+              "description": "The log changed size, which moves nothing on its own: following, the\nnewest line is followed."
+            },
+            {
+              "kind": "field",
+              "name": "handleMutation",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "handleScroll",
+              "privacy": "private",
+              "readonly": true,
+              "description": "The reader's own scrolling, which is the only thing that lets go of the\nnewest line. Bound to the log in the template, since `scroll` is not\ncomposed and never reaches the host. A scroll this element made, and the\nlog growing under a reader who has not moved, are not the reader leaving:\n`Chat` carries the measurement."
+            },
+            {
+              "kind": "field",
+              "name": "handleResume",
+              "privacy": "private",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "handleGroupToggle",
+              "privacy": "private",
+              "readonly": true,
+              "description": "A reader opened or closed a group drawn from data."
+            },
+            {
+              "kind": "method",
+              "name": "renderRow",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "row",
+                  "type": {
+                    "text": "LogRow"
+                  }
+                },
+                {
+                  "name": "marks",
+                  "type": {
+                    "text": "ReadonlyArray<[number, number]>"
+                  }
+                },
+                {
+                  "name": "start",
+                  "type": {
+                    "text": "number | undefined"
+                  }
+                }
+              ],
+              "description": "One row drawn from data: a line, or a group's heading."
+            },
+            {
+              "kind": "field",
+              "name": "firstTime",
+              "type": {
+                "text": "number | undefined"
+              },
+              "privacy": "private",
+              "description": "When the first line kept was written, which `relative` counts from.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "digits",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "description": "How many digits the largest line number has, which a stylesheet sizes the\ncolumn of numbers by, or 0 where nobody can know: a server, or a log with\nno numbers shown.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "renderRows",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
+              },
+              "description": "The rows drawn from data, a window of them, between the room the rest would take."
+            },
+            {
+              "kind": "method",
+              "name": "renderResume",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
+              },
+              "description": "The `resume` slot, with the way back drawn where nothing is slotted, behind\na seam: the slot answers a page, and this answers the tier above."
+            },
+            {
+              "kind": "field",
+              "name": "loading",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the rows are still loading.\n\nReflected, because a stylesheet needs it: the rows that are already there\nare dimmed rather than removed while a new set arrives, and only CSS can\nsay that without the component knowing what a row looks like.",
+              "attribute": "loading",
+              "reflects": true,
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "loadingText",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Loading'",
+              "description": "The text shown and announced while the rows load.",
+              "attribute": "loading-text",
+              "helix": {
+                "words": true
+              },
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "slotCounted",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the rows have been looked at yet.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "slotRows",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "How many there were, the last time anyone looked.\n\n**Never name this `rows`.** TypeScript's `private` is a compile-time\nclaim and the runtime field is whatever it is named, so a subclass\ndeclaring `@property() rows` for the data a consumer hands it would share\none field with this counter: the slot count would overwrite the\nconsumer's array on every update, and `hasRows` would read the array's\nlength as a slot count. Nothing would throw. `helix-data-table` takes\nexactly that property.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "countRows",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                }
+              ],
+              "description": "Counts what a rows slot was given.\n\nEmptiness is a fact about light DOM children and the server has none to\ncount. `slotchange` never fires there, so `counted` is false exactly when\nthe answer is unknown, and an unknown answer is not \"empty\": a list that\nshipped \"Nothing to show\" over markup about to have rows in it is the one\nthing an empty state must never do.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "hasRows",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "slotted",
+              "type": {
+                "text": "Element[]"
+              },
+              "privacy": "protected",
+              "description": "What the rows slot is given: every child without a `slot`.\n\nThe default slot, because that is where every collection in this library\nputs its rows: Listbox its options, Tree its items, Table its rows, Menu\nand Drilldown their pages. A named slot is a header or a footer, and\nneither is content.\n\n**The host's children rather than the slot's assigned elements**, which\nare the same elements, because a slot exists only once a render has made\nit and the count is wanted by the first render. A collection that assigns\nits slots by hand says what it assigns.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "renderStatus",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "TemplateResult | typeof nothing"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "hasContent",
+                  "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.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "renderLive",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "TemplateResult"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "hasContent",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "The same words for a screen reader, in a region that is always there.\n\n**A region is heard when what it holds changes, not when it arrives.**\nThe loading line was a `role=\"status\"` inserted with its words already\nin it, which is read inconsistently at best, and the empty line was no\nregion at all, so a filter that emptied a list said nothing. This one is\nrendered on every pass and only its words move: \"Loading\", then\n\"No matches\", then nothing once there are rows.\n\n**Outside the rows, which is the component's to place.** A status is not\na child a `listbox`, a `table` or a `tree` may hold, so the component\nrenders this beside its container rather than inside it. The styled\ntier clips it; the visible lines are `renderStatus`.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "announced",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "protected",
+              "default": "''",
+              "description": "What the region says while there are rows and nothing is loading, which\nis nothing unless the component has news of its own.\n\n**One region, so two messages never talk over each other.** Data Table\nsays a sort and a selection here; a second `role=\"status\"` beside this\none would be heard in whichever order the reader happens to queue them.\nLoading and empty win, being the larger news. Set before the render that\nshows it, in `willUpdate`, and not reactive: it changes only when\nsomething else already asked for a render.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "statusSlots",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "default": "false",
+              "description": "Whether the status line is an `empty` or `loading` slot, with\n`empty-text` or `loading-text` as its fallback.\n\n**Off unless a family turns it on**, because a slot is published API:\neach family that renders one documents it in its own manifest. The live\nregion keeps saying the text either way, because a slotted picture has no\nwords to say.",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "tier",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "default": "'helix-headless-'",
+              "description": "The prefix this tier registers its elements under.\n\n**A component that renders another renders its own tier's version of it**,\nso `helix-headless-pagination-size` composes `helix-headless-select` and\n`helix-pagination-size` composes `helix-select`. One template says\n`${this.tag('select')}` and each tier answers with its own name.\n\n**The public tag may not be the composed one, in either tier.** Using it\ncosts three things: the name means two different things depending on what a\nconsumer imported, the headless tier composes an element it does not ship,\nand the composition cannot be tested there at all, because there is no\n`helix-select` on that tier to test it against.\n\n**A prefix rather than an override per composition**, which was the first\nplan and does not compile. An override re-renders the fragment from the\nsubclass, and the fragment reads members the base keeps private:\n`PaginationSize` alone would have had to widen `options`, `current` and\n`handleChange` to `protected` so a subclass could say the same thing again.\nSixteen families of that is a lot of encapsulation spent on saying one\nword differently.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "tag",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "StaticValue"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One composed tag, as a static value a template can interpolate.\n\nWhat `unsafeStatic` returns, safe by construction: the name is a literal in\nour own source and the prefix is one of two strings this class defines.\nCalled per render and not cached, which costs nothing, because\n`static-html` keys its template cache on the joined string rather than on\nthe object.\n\n**Written out rather than imported, for every element that never renders\none.** `lit/static-html.js` declares no side effects, so importing\n`unsafeStatic` alone kept the module's three `withStatic` calls in every\nbundle: about 210 bytes gzipped on each of the families that compose no\ntag, Divider and Badge among them. The value is lit's cross-copy protocol,\nkeyed by `Symbol.for('')` so that two copies of lit on a page read each\nother's, and a spec holds it equal to `unsafeStatic`'s.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "partNamed",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "T | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "One of this element's own parts, by name, or null where it is not rendered.\n\nNot `part`, which every element already has: `Element.part` is the\n`DOMTokenList` of the names the element itself carries, and a method under\nthat name is a type error on every subclass.\n\n**One guard for every lookup.** Lit's server shim has no `querySelector`\non the render root, so a lookup reached during a server render, from a\ngetter a template reads or from `willUpdate`, throws there and nowhere\nelse. Four spellings of the same guard had grown across the library, and\na fifth site with none. Null on the server, which is what the rest of the\ncode already treats a part that has not rendered as.\n\n**`~=` and not `=`.** A part drawn in a state carries a second name while\nthe state holds, `part=\"page page-current\"`, and an exact match stops\nfinding it for exactly as long as it is the one that matters.\n\n`helix component`'s `selectors` reads these calls the way it reads a\n`querySelector('[part=\"x\"]')`, so a name nothing renders is a finding\nrather than a null an optional chain swallows.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "internals",
+              "type": {
+                "text": "ElementInternals"
+              },
+              "privacy": "protected",
+              "readonly": true,
+              "description": "The element's semantics, set without touching the DOM.\n\n`ElementInternals` sets the implicit role, which an author's own `role`\nattribute still overrides, and it writes no attribute. Setting `role` on the\nhost directly would: that is an attribute the element gives itself after it\nupgrades, which a React consumer's server markup never had, and hydration\nreports it as a mismatch.\n\nAvailable during server rendering. Lit's shim implements `attachInternals`,\nso nothing here needs a guard.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "toggleState",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "on",
+                  "type": {
+                    "text": "boolean"
+                  }
+                }
+              ],
+              "description": "Records a boolean fact about this element as a custom state.\n\n**The host belongs to whoever rendered it, and a component's own\nbookkeeping may not be kept there.** An attribute written on the first\nupdate is markup a consumer's server never sent, so a React consumer\nhydrates a DOM that has gained attributes since and reports a mismatch it\nwill not patch up. A custom state is not in the DOM at all: it carries the\nfact to a stylesheet through `:state()` and leaves the markup alone, so the\nserver's output and the client's agree by construction.\n\n`SETTLED` carries the long version of that argument; `checked`, `open`,\n`invalid` and `has-label` are recorded the same way, each of them a state a\n`default-*` attribute resolves before React reaches the node.\n\n**Deferring the definitions is not a fix and could not be.** Importing them\nfrom an effect so the upgrades fall the other side of hydration works only\nwhile hydration is one pass: anything that splits it, a streamed segment or\na suspended boundary, puts an upgrade back inside the window. Timing cannot\nbe the guarantee when the fact is kept somewhere React reconciles.\n\nFeature-tested rather than assumed, the way `hostAria` tests element\nreferences. An engine without `CustomStateSet` records nothing and keeps\nwhatever the resting rule draws, which is the safe direction to fail.\n\n**The engines the test is for are browsers**: Safari below 17.4 and Firefox\nbelow 126, where the write is a `TypeError`, so a component bypassing this\nfails to render rather than rendering without whatever the state draws.\nLit's server shim sets `states`, so the guard passes there and records a\nstate nothing reads, which is harmless.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "whenSettled",
+              "type": {
+                "text": "Promise<void>"
+              },
+              "readonly": true,
+              "description": "Resolves a frame after the first update, when transitions are switched on.\n\n**Named `whenSettled` because `settled` is taken four times over**, by\nImage, Splitter and both color controls, none of them about transitions. A\nbase class takes the name every subclass then cannot use.\n\n**The state it reports cannot be watched, which is why this exists.** A\ncustom state is deliberately not in the DOM, so there is no\n`MutationObserver` equivalent for `ElementInternals.states`. Await this\ninstead.\n\nSeparate from `updateComplete`, which resolves in the microtask checkpoint\nthe suppression is still active in. That is the distinction `readyToMove`\nin `@fusion.dev/helix-testing` is written around.\n\nIt never resolves where `requestAnimationFrame` never fires, which is a\nserver, a hidden tab, and happy-dom. Callers that must not hang there race\nit against a timeout, as the happy-dom harness's `readyToMove` does. The\nbrowser harness's awaits it alone: a browser always runs the frame, and a\ntimer beside it was a bet on how long one takes, which a busy run lost.",
+              "default": "new Promise<void>((resolve) => { this.resolveSettled = resolve })",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "resolveSettled",
+              "type": {
+                "text": "() => void"
+              },
+              "privacy": "private",
+              "description": "Resolves `whenSettled`, once, from the frame that records the state.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "fromServer",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Whether the shadow root was a server's, parsed from declarative shadow DOM.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "hydrating",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this update is hydrating a server's markup, and so has to render\nexactly what the server rendered.\n\n**Lit hydrates by assuming the markup already shows the first render.** A\nvalue that differs is recorded and never written, so the page keeps the\nserver's, and a template that differs throws. The server has no children,\nso anything a component reads from its children waits for the update after\nhydration, which `finishHydration` asks for. Without a server's markup the\nfirst render reads them and there is one render.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "serverRendered",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element hydrated a server's markup rather than rendering its own.\n\nFor what happened before hydration and cannot be heard after it: an image\nthe parser fetched fires `load` or `error` before any listener exists, so a\ncomponent asks the image instead, once, when this is true.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finishHydration",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Asks for the update a hydration put off, so the reads it skipped happen.\n\nCalled from `firstUpdated`, the end of the hydrating update. The render it\nschedules can only follow that one, which is the exception Lit's\nchange-in-update warning names, and it happens only on a page a server\nrendered.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "childrenKnown",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this render can know the children.\n\nA server cannot: its element shim carries attributes and no tree, so\n`children` is undefined there. A render hydrating what a server sent must\nnot, because it has to be the server's render. Anywhere else it can. A\ncomponent whose render depends on its children reads them through\n`knownChildren`, and treats \"not known\" as its own answer rather than as\n\"none\": a list that renders its empty state because nobody has looked yet is\nthe one thing an empty state must never do.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "knownChildren",
+              "type": {
+                "text": "Element[]"
+              },
+              "privacy": "protected",
+              "description": "The children a render may read: all of them where they are known, and none otherwise.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "assignsByName",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "protected",
+              "description": "Whether this element's slots route by name although it asked to assign them\nby hand.\n\n**A declarative shadow root is always the by-name kind.** HTML has no way to\nask for manual assignment, so a component that assigns by hand and hydrates\na server's root gets one where `slot.assign()` does nothing, and its\nchildren land wherever their `slot` attribute sends them. The way through is\nto write that attribute, which is what `route` does. Only there: on a root\nthis element made, assignment stays manual and the consumer's markup is\nnever touched, which is what a React consumer's hydration requires.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "route",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "child",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string | undefined"
+                  }
+                }
+              ],
+              "description": "Sends a child to a slot by name, on a root that routes by name.\n\n`undefined` is the default slot. Written only when it differs, so routing\nthe same child again on every update writes nothing.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "stopInner",
+              "privacy": "protected",
+              "readonly": true,
+              "description": "Stops an inner control's own announcement at this element's boundary.\n\n**A composed control is one control to a consumer, and the natives had no\nequivalent of the stop the prefixed events already get.** `<helix-select>`\nrenders a `<helix-listbox>`, and both announce: the listbox dispatches\n`input` and `change` from its own host, `input` is composed by\nspecification, and a consumer listening on the select therefore heard one\nchoice twice. Measured before this existed, on the styled tier, one choice\non the inner listbox: select `input` twice and `change` three times,\ncombobox, date input, time input and color input twice each. `Command` was\nthe only one that was right, because it happened to reach for\n`stopImmediatePropagation` for a different reason.\n\nBound on the child in the parent's template, so it runs while the event is\nstill at the child and before it can cross. The guard is for the case where\na component binds this on itself: an element must never stop its own\nannouncement, which is the one it exists to make.\n\nThis is the same job the `helix-before-*` handlers do with their own\n`stopPropagation`, and it is separate rather than folded into them because\na consumer may legitimately refuse a request without the notification ever\nhappening: the two travel at different times and one can be absent.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "relayNativeEvent",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "event",
+                  "type": {
+                    "text": "Event"
+                  }
+                },
+                {
+                  "name": "init",
+                  "optional": true,
+                  "type": {
+                    "text": "EventInit"
+                  }
+                }
+              ],
+              "description": "Re-emits a native event from the host, under its own name.\n\nA native event fired by an inner `<input>` or `<textarea>` is not composed,\nso it stops at the shadow boundary and a consumer listening on\n`<helix-input>` hears nothing. Re-dispatching it from the host is what\nmakes the component behave like the control it wraps.\n\nThe relayed event keeps the native name deliberately. `change` is `change`,\nwhich is what a consumer already knows to listen for, and it is what\nreaches React: its synthetic system claims `onChange` and wires it to that\nname, so a prefixed one would never arrive.\n\n`composed` is not forced. It defaults to the original event's own value, so\na relayed `change` stops at the next shadow boundary exactly as a native\none would. Pass it explicitly only where escaping is the intent, and say so\nwhere you do.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "finalizeStyles",
+              "privacy": "protected",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "CSSResultOrNative[]"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "styles",
+                  "optional": true,
+                  "type": {
+                    "text": "CSSResultOrNative | CSSResultOrNative[]"
+                  }
+                }
+              ],
+              "description": "Prepends the shadow-root reset to every subclass's styles, so no component\nhas to remember to include it, with the rules for the marks it writes.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "performUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "The first update, timed where a page asked to measure what the components\ncost, and a property read where it did not: see `reportRender`.",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "events": [
+            {
+              "type": {
+                "text": "HelixBeforePinEvent"
+              },
+              "description": "Fired when the reader leaves the newest line by scrolling, or comes back to it. Cancelable.",
+              "name": "helix-before-pin",
+              "reactProp": "onhelix-before-pin"
+            },
+            {
+              "type": {
+                "text": "HelixExpandEvent"
+              },
+              "description": "Fired after a reader opens or closes a group drawn from `groups`, with the `id` of every open group in `detail.value`, separated by commas.",
+              "name": "helix-expand",
+              "reactProp": "onhelix-expand"
+            },
+            {
+              "type": {
+                "text": "HelixPinEvent"
+              },
+              "description": "Fired after the log follows the newest line or lets go of it, with `true` or `false` in `detail.value`.",
+              "name": "helix-pin",
+              "reactProp": "onhelix-pin"
+            }
+          ],
+          "attributes": [
+            {
+              "name": "default-pinned",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Whether the log opens following its newest line, when `pinned` is not set.\n`default-pinned=\"false\"` opens it where it starts.",
+              "fieldName": "defaultPinned"
+            },
+            {
+              "name": "done",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the run is over, which a screen reader is told once.\n\nSet it when output you `write` is complete. A `source` sets it when the\nstream ends.",
+              "fieldName": "done"
+            },
+            {
+              "name": "done-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Finished'",
+              "description": "What a screen reader hears when the run is over.",
+              "fieldName": "doneLabel"
+            },
+            {
+              "name": "dropped-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {# earlier line is} other {# earlier lines are}} not kept'",
+              "description": "What the line above the log says once `limit` has let lines go. `{count}` is how many.",
+              "fieldName": "droppedLabel"
+            },
+            {
+              "name": "empty-text",
+              "type": {
+                "text": "string"
+              },
+              "default": "'No output yet'",
+              "description": "The text shown and announced when the log has no lines.",
+              "fieldName": "emptyText",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "name": "error-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, one {Error} other {# errors}}: {text}'",
+              "description": "What a screen reader hears when lines at `error` arrive. `{count}` is how\nmany arrived together and `{text}` is the first of them.",
+              "fieldName": "errorLabel"
+            },
+            {
+              "name": "fallback-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Log'",
+              "description": "The log's name, read by screen readers, where `label` is empty.",
+              "fieldName": "fallbackLabel"
+            },
+            {
+              "name": "group-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{status, select, failed {{heading} failed} other {{heading} finished}}'",
+              "description": "What a screen reader hears when a step finishes or fails. `{heading}` is\nthe step's heading and `{status}` is `done` or `failed`.",
+              "fieldName": "groupLabel"
+            },
+            {
+              "name": "label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The log's name, read by screen readers.",
+              "fieldName": "label"
+            },
+            {
+              "name": "limit",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "The most lines kept, or 0 to keep them all. Past it the oldest lines are\nlet go, and the line above the log says how many.",
+              "fieldName": "limit"
+            },
+            {
+              "name": "line-href",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "A link for each line number, with `{n}` where the number goes, such as\n`#L{n}`. Empty leaves the numbers as text.",
+              "fieldName": "lineHref"
+            },
+            {
+              "name": "line-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Line {number}'",
+              "description": "What a screen reader hears for the link on a line's number, handed to each\nline the log draws. `{number}` is the number.",
+              "fieldName": "lineLabel"
+            },
+            {
+              "name": "line-numbers",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether each line shows its number.",
+              "fieldName": "lineNumbers"
+            },
+            {
+              "name": "mark-lines",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Lines to mark, as numbers and ranges such as `12, 40-44`.",
+              "fieldName": "markLines"
+            },
+            {
+              "name": "matches-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'{count, plural, =0 {No lines match} one {# line matches} other {# lines match}}'",
+              "description": "What a screen reader hears when `query` changes. `{count}` is how many lines match.",
+              "fieldName": "matchesLabel"
+            },
+            {
+              "name": "pinned",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the log follows its newest line.\n\nThe reader's scrolling asks first: `helix-before-pin` is cancelable, so a\nconsumer refusing it takes the decision and assigns their own value. Not\nreflected, for the reason `Chat` gives at its own `pinned`: a default of\ntrue would write the attribute on upgrade.",
+              "fieldName": "pinned"
+            },
+            {
+              "name": "query",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Text a line has to hold to be shown, ignoring case. Empty shows every line.",
+              "fieldName": "query"
+            },
+            {
+              "name": "resume-label",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Jump to latest'",
+              "description": "The words on the button that returns to the newest line, where `resume` is empty.",
+              "fieldName": "resumeLabel"
+            },
+            {
+              "name": "threshold",
+              "type": {
+                "text": "number"
+              },
+              "default": "48",
+              "description": "How near the newest line still counts as being at it, in pixels.",
+              "fieldName": "threshold"
+            },
+            {
+              "name": "timestamps",
+              "type": {
+                "text": "'absolute' | 'relative' | undefined"
+              },
+              "description": "How each line shows its `at`: `absolute` on the clock, `relative` as the\ntime since the first line. Absent shows no time.",
+              "fieldName": "timestamps"
+            },
+            {
+              "name": "wrap",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether a line longer than the box wraps onto the next row. Otherwise the log scrolls sideways.",
+              "fieldName": "wrap"
+            },
+            {
+              "name": "loading",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Whether the rows are still loading.\n\nReflected, because a stylesheet needs it: the rows that are already there\nare dimmed rather than removed while a new set arrives, and only CSS can\nsay that without the component knowing what a row looks like.",
+              "fieldName": "loading",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            },
+            {
+              "name": "loading-text",
+              "type": {
+                "text": "string"
+              },
+              "default": "'Loading'",
+              "description": "The text shown and announced while the rows load.",
+              "fieldName": "loadingText",
+              "inheritedFrom": {
+                "name": "MixinCollection",
+                "module": "src/mixins/mixin-collection/mixin-collection.ts"
+              }
+            }
+          ],
+          "cssStates": [
+            {
+              "description": "The run is over: `done` is set, or `source` ended.",
+              "name": "done"
+            },
+            {
+              "description": "The log has no lines.",
+              "name": "empty"
+            },
+            {
+              "description": "`query` is set, so only matching lines are shown.",
+              "name": "filtered"
+            },
+            {
+              "description": "The log follows its newest line.",
+              "name": "pinned"
+            },
+            {
+              "description": "Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.",
+              "name": "settled",
+              "inheritedFrom": {
+                "name": "HelixElement",
+                "module": "src/helix-element/helix-element.ts"
+              }
+            }
+          ],
+          "mixins": [
+            {
+              "name": "MixinCollection",
+              "package": "@fusion.dev/helix-core"
+            }
+          ],
+          "superclass": {
+            "name": "HelixElement",
+            "package": "@fusion.dev/helix-core"
+          },
+          "summary": "Output that arrives while you watch it, such as a CI run, a deployment, or a build, in a box that follows the newest line.",
+          "helix": {
+            "category": "feedback",
+            "since": "0.199.0",
+            "status": "experimental",
+            "documentation": "https://fusion.dev/helix/components/log",
+            "aliases": [
+              "Console",
+              "Terminal output",
+              "Build log",
+              "Deploy log",
+              "Log viewer",
+              "Output"
+            ],
+            "tier": "headless",
+            "renders": [
+              "log-group",
+              "log-line"
+            ],
+            "group": "BaseLog",
+            "part": "Root",
+            "examples": [
+              {
+                "description": "A deployment's output with numbered lines, its steps folded, and the step that failed open.",
+                "layout": "padded",
+                "slug": "preview"
+              }
+            ],
+            "source": "helix/headless/src/log"
+          },
+          "tagName": "helix-headless-log",
+          "customElement": true,
+          "modulePath": "src/log/root/log-root.ts",
+          "definitionPath": "src/log/root/log-root.ts"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "HelixHeadlessLog",
+          "declaration": {
+            "name": "HelixHeadlessLog",
+            "module": "src/log/root/log-root.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "helix-headless-log",
+          "declaration": {
+            "name": "HelixHeadlessLog",
+            "module": "src/log/root/log-root.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/log/rows.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "logRows",
+          "return": {
+            "type": {
+              "text": "LogRows"
+            }
+          },
+          "parameters": [
+            {
+              "name": "{ current, groups, lines, open, query, start }",
+              "type": {
+                "text": "LogRowsInput"
+              }
+            }
+          ],
+          "description": "Lays the lines out as rows, a group's heading before its first line.\n\n**A group stands where its first line is.** A group in `groups` with no line\nyet stands after every line, in the order `groups` gives, which is the step\nthat has started and written nothing, where it comes after every group that\nhas a line. A line naming a group nobody declared is drawn with no heading.\n\n**A search opens every group and shows only what matched.** A group shows\nits heading while it holds a match, so a match inside a folded step is found\nwhere it is rather than hidden by the fold. A group with no match is left\nout, heading and all."
+        },
+        {
+          "kind": "function",
+          "name": "markMatches",
+          "return": {
+            "type": {
+              "text": "LogPiece[]"
+            }
+          },
+          "parameters": [
+            {
+              "name": "runs",
+              "type": {
+                "text": "readonly LogRun[]"
+              }
+            },
+            {
+              "name": "query",
+              "type": {
+                "text": "string"
+              }
+            }
+          ],
+          "description": "Splits runs where the search matches, ignoring case, so each match can be\nmarked. Runs are returned as they are where there is no search."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "logRows",
+          "declaration": {
+            "name": "logRows",
+            "module": "src/log/rows.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "markMatches",
+          "declaration": {
+            "name": "markMatches",
+            "module": "src/log/rows.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/map/area/map-area.ts",
@@ -215359,6 +219285,6 @@
   ],
   "helix": {
     "package": "@fusion.dev/helix-headless",
-    "version": "0.199.0"
+    "version": "0.200.0"
   }
 }