@fusion.dev/helix-headless 0.199.0 → 0.200.0

package/types/jsx.d.ts

@@ -105,6 +105,9 @@ import type {
   HelixHeadlessListItem,
   HelixHeadlessListbox,
   HelixHeadlessLoader,
+  HelixHeadlessLog,
+  HelixHeadlessLogGroup,
+  HelixHeadlessLogLine,
   HelixHeadlessMap,
   HelixHeadlessMapArea,
   HelixHeadlessMapBuildings,
@@ -19662,6 +19665,419 @@ progress. */
   textContent?: (string | number) | undefined;
 };
 
+/** `HelixHeadlessLogGroup` component event */
+export type HelixHeadlessLogGroupElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessLogGroup,
+  E
+>;
+/** `helix-before-close` event type */
+export type HelixHeadlessLogGroupHelixBeforeCloseElementEvent =
+  HelixHeadlessLogGroupElementEvent<HelixBeforeCloseEvent>;
+/** `helix-before-open` event type */
+export type HelixHeadlessLogGroupHelixBeforeOpenElementEvent =
+  HelixHeadlessLogGroupElementEvent<HelixBeforeOpenEvent>;
+/** `toggle` event type */
+export type HelixHeadlessLogGroupToggleElementEvent =
+  HelixHeadlessLogGroupElementEvent<ToggleEvent>;
+
+export type HelixHeadlessLogGroupProps = {
+  /** How long the step took, as it should read, such as `12s`. */
+  duration?: (HelixHeadlessLogGroup["duration"]) | undefined;
+  /** What the step is called. The `heading` slot replaces it. */
+  heading?: (HelixHeadlessLogGroup["heading"]) | undefined;
+  /** Where the step stands, which draws a mark before the heading. */
+  status?: (HelixHeadlessLogGroup["status"]) | undefined;
+  /** What a screen reader hears for the status, after the heading.
+`{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`. */
+  "status-label"?: (HelixHeadlessLogGroup["statusLabel"]) | undefined;
+  /** What a screen reader hears for the status, after the heading.
+`{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`. */
+  statusLabel?: (HelixHeadlessLogGroup["statusLabel"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  "default-open"?: (HelixHeadlessLogGroup["defaultOpen"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  defaultOpen?: (HelixHeadlessLogGroup["defaultOpen"]) | undefined;
+  /** Whether the element is open.
+
+One property, not two, so `dialog.open` answers the question anyone
+asking it meant. Writing always applies; `<helix-dialog open>` is the
+same statement in markup.
+
+**Not reflected, and that is required rather than tidy.** Reflection
+writes the resolved state back as an attribute, so an element that opened
+itself would put `open` on its own host: cloned, serialized for
+hydration, or diffed by a framework, it comes back holding whatever the
+last reader did rather than what the author wrote. `:state(open)` carries
+the resolved state for stylesheets, which is what the mirror is for. */
+  open?: (HelixHeadlessLogGroup["open"]) | undefined;
+
+  /** Fired before the group closes. Cancelable. */
+  "onhelix-before-close"?: ((
+    e: HelixHeadlessLogGroupHelixBeforeCloseElementEvent,
+  ) => void) | undefined;
+  /** Fired before the group opens. Cancelable. */
+  "onhelix-before-open"?: ((
+    e: HelixHeadlessLogGroupHelixBeforeOpenElementEvent,
+  ) => void) | undefined;
+  /** Fired after the group opens or closes, with `newState` and `oldState`. */
+  ontoggle?: ((e: HelixHeadlessLogGroupToggleElementEvent) => void) | undefined;
+};
+
+export type HelixHeadlessLogGroupSolidJsProps = {
+  /** How long the step took, as it should read, such as `12s`. */
+  "prop:duration"?: (HelixHeadlessLogGroup["duration"]) | undefined;
+  /** What the step is called. The `heading` slot replaces it. */
+  "prop:heading"?: (HelixHeadlessLogGroup["heading"]) | undefined;
+  /** Where the step stands, which draws a mark before the heading. */
+  "prop:status"?: (HelixHeadlessLogGroup["status"]) | undefined;
+  /** What a screen reader hears for the status, after the heading.
+`{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`. */
+  "attr:status-label"?: (HelixHeadlessLogGroup["statusLabel"]) | undefined;
+  /** What a screen reader hears for the status, after the heading.
+`{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`. */
+  "prop:statusLabel"?: (HelixHeadlessLogGroup["statusLabel"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  "bool:default-open"?: (HelixHeadlessLogGroup["defaultOpen"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  "prop:defaultOpen"?: (HelixHeadlessLogGroup["defaultOpen"]) | undefined;
+  /** Whether the element is open.
+
+One property, not two, so `dialog.open` answers the question anyone
+asking it meant. Writing always applies; `<helix-dialog open>` is the
+same statement in markup.
+
+**Not reflected, and that is required rather than tidy.** Reflection
+writes the resolved state back as an attribute, so an element that opened
+itself would put `open` on its own host: cloned, serialized for
+hydration, or diffed by a framework, it comes back holding whatever the
+last reader did rather than what the author wrote. `:state(open)` carries
+the resolved state for stylesheets, which is what the mirror is for. */
+  "prop:open"?: (HelixHeadlessLogGroup["open"]) | undefined;
+  /** Fired before the group closes. Cancelable. */
+  "on:helix-before-close"?: ((
+    e: HelixHeadlessLogGroupHelixBeforeCloseElementEvent,
+  ) => void) | undefined;
+  /** Fired before the group opens. Cancelable. */
+  "on:helix-before-open"?: ((
+    e: HelixHeadlessLogGroupHelixBeforeOpenElementEvent,
+  ) => void) | undefined;
+  /** Fired after the group opens or closes, with `newState` and `oldState`. */
+  "on:toggle"?: ((e: HelixHeadlessLogGroupToggleElementEvent) => void) | undefined;
+
+  /** Set the innerHTML of the element */
+  innerHTML?: (string) | undefined;
+  /** Set the textContent of the element */
+  textContent?: (string | number) | undefined;
+};
+
+export type HelixHeadlessLogLineProps = {
+  /** When the line was written: milliseconds since the epoch, or anything `Date` parses. */
+  at?: (HelixHeadlessLogLine["at"]) | undefined;
+  /** How much the line matters. Absent is `info`. */
+  level?: (HelixHeadlessLogLine["level"]) | undefined;
+  /** What a screen reader hears for the link on a line's number. `{number}` is the number. */
+  "line-label"?: (HelixHeadlessLogLine["lineLabel"]) | undefined;
+  /** What a screen reader hears for the link on a line's number. `{number}` is the number. */
+  lineLabel?: (HelixHeadlessLogLine["lineLabel"]) | undefined;
+};
+
+export type HelixHeadlessLogLineSolidJsProps = {
+  /** When the line was written: milliseconds since the epoch, or anything `Date` parses. */
+  "prop:at"?: (HelixHeadlessLogLine["at"]) | undefined;
+  /** How much the line matters. Absent is `info`. */
+  "prop:level"?: (HelixHeadlessLogLine["level"]) | undefined;
+  /** What a screen reader hears for the link on a line's number. `{number}` is the number. */
+  "attr:line-label"?: (HelixHeadlessLogLine["lineLabel"]) | undefined;
+  /** What a screen reader hears for the link on a line's number. `{number}` is the number. */
+  "prop:lineLabel"?: (HelixHeadlessLogLine["lineLabel"]) | undefined;
+
+  /** Set the innerHTML of the element */
+  innerHTML?: (string) | undefined;
+  /** Set the textContent of the element */
+  textContent?: (string | number) | undefined;
+};
+
+/** `HelixHeadlessLog` component event */
+export type HelixHeadlessLogElementEvent<E = Event> = TypedEvent<
+  HelixHeadlessLog,
+  E
+>;
+/** `helix-before-pin` event type */
+export type HelixHeadlessLogHelixBeforePinElementEvent =
+  HelixHeadlessLogElementEvent<HelixBeforePinEvent>;
+/** `helix-expand` event type */
+export type HelixHeadlessLogHelixExpandElementEvent =
+  HelixHeadlessLogElementEvent<HelixExpandEvent>;
+/** `helix-pin` event type */
+export type HelixHeadlessLogHelixPinElementEvent =
+  HelixHeadlessLogElementEvent<HelixPinEvent>;
+
+export type HelixHeadlessLogProps = {
+  /** Whether the log opens following its newest line, when `pinned` is not set.
+`default-pinned="false"` opens it where it starts. */
+  "default-pinned"?: (HelixHeadlessLog["defaultPinned"]) | undefined;
+  /** Whether the log opens following its newest line, when `pinned` is not set.
+`default-pinned="false"` opens it where it starts. */
+  defaultPinned?: (HelixHeadlessLog["defaultPinned"]) | undefined;
+  /** Whether the run is over, which a screen reader is told once.
+
+Set it when output you `write` is complete. A `source` sets it when the
+stream ends. */
+  done?: (HelixHeadlessLog["done"]) | undefined;
+  /** What a screen reader hears when the run is over. */
+  "done-label"?: (HelixHeadlessLog["doneLabel"]) | undefined;
+  /** What a screen reader hears when the run is over. */
+  doneLabel?: (HelixHeadlessLog["doneLabel"]) | undefined;
+  /** What the line above the log says once `limit` has let lines go. `{count}` is how many. */
+  "dropped-label"?: (HelixHeadlessLog["droppedLabel"]) | undefined;
+  /** What the line above the log says once `limit` has let lines go. `{count}` is how many. */
+  droppedLabel?: (HelixHeadlessLog["droppedLabel"]) | undefined;
+  /** The text shown and announced when the log has no lines. */
+  "empty-text"?: (HelixHeadlessLog["emptyText"]) | undefined;
+  /** The text shown and announced when the log has no lines. */
+  emptyText?: (HelixHeadlessLog["emptyText"]) | undefined;
+  /** What a screen reader hears when lines at `error` arrive. `{count}` is how
+many arrived together and `{text}` is the first of them. */
+  "error-label"?: (HelixHeadlessLog["errorLabel"]) | undefined;
+  /** What a screen reader hears when lines at `error` arrive. `{count}` is how
+many arrived together and `{text}` is the first of them. */
+  errorLabel?: (HelixHeadlessLog["errorLabel"]) | undefined;
+  /** The log's name, read by screen readers, where `label` is empty. */
+  "fallback-label"?: (HelixHeadlessLog["fallbackLabel"]) | undefined;
+  /** The log's name, read by screen readers, where `label` is empty. */
+  fallbackLabel?: (HelixHeadlessLog["fallbackLabel"]) | undefined;
+  /** What a screen reader hears when a step finishes or fails. `{heading}` is
+the step's heading and `{status}` is `done` or `failed`. */
+  "group-label"?: (HelixHeadlessLog["groupLabel"]) | undefined;
+  /** What a screen reader hears when a step finishes or fails. `{heading}` is
+the step's heading and `{status}` is `done` or `failed`. */
+  groupLabel?: (HelixHeadlessLog["groupLabel"]) | undefined;
+  /** The log's name, read by screen readers. */
+  label?: (HelixHeadlessLog["label"]) | undefined;
+  /** The most lines kept, or 0 to keep them all. Past it the oldest lines are
+let go, and the line above the log says how many. */
+  limit?: (HelixHeadlessLog["limit"]) | undefined;
+  /** A link for each line number, with `{n}` where the number goes, such as
+`#L{n}`. Empty leaves the numbers as text. */
+  "line-href"?: (HelixHeadlessLog["lineHref"]) | undefined;
+  /** A link for each line number, with `{n}` where the number goes, such as
+`#L{n}`. Empty leaves the numbers as text. */
+  lineHref?: (HelixHeadlessLog["lineHref"]) | undefined;
+  /** What a screen reader hears for the link on a line's number, handed to each
+line the log draws. `{number}` is the number. */
+  "line-label"?: (HelixHeadlessLog["lineLabel"]) | undefined;
+  /** What a screen reader hears for the link on a line's number, handed to each
+line the log draws. `{number}` is the number. */
+  lineLabel?: (HelixHeadlessLog["lineLabel"]) | undefined;
+  /** Whether each line shows its number. */
+  "line-numbers"?: (HelixHeadlessLog["lineNumbers"]) | undefined;
+  /** Whether each line shows its number. */
+  lineNumbers?: (HelixHeadlessLog["lineNumbers"]) | undefined;
+  /** Lines to mark, as numbers and ranges such as `12, 40-44`. */
+  "mark-lines"?: (HelixHeadlessLog["markLines"]) | undefined;
+  /** Lines to mark, as numbers and ranges such as `12, 40-44`. */
+  markLines?: (HelixHeadlessLog["markLines"]) | undefined;
+  /** What a screen reader hears when `query` changes. `{count}` is how many lines match. */
+  "matches-label"?: (HelixHeadlessLog["matchesLabel"]) | undefined;
+  /** What a screen reader hears when `query` changes. `{count}` is how many lines match. */
+  matchesLabel?: (HelixHeadlessLog["matchesLabel"]) | undefined;
+  /** Whether the log follows its newest line.
+
+The reader's scrolling asks first: `helix-before-pin` is cancelable, so a
+consumer refusing it takes the decision and assigns their own value. Not
+reflected, for the reason `Chat` gives at its own `pinned`: a default of
+true would write the attribute on upgrade. */
+  pinned?: (HelixHeadlessLog["pinned"]) | undefined;
+  /** Text a line has to hold to be shown, ignoring case. Empty shows every line. */
+  query?: (HelixHeadlessLog["query"]) | undefined;
+  /** The words on the button that returns to the newest line, where `resume` is empty. */
+  "resume-label"?: (HelixHeadlessLog["resumeLabel"]) | undefined;
+  /** The words on the button that returns to the newest line, where `resume` is empty. */
+  resumeLabel?: (HelixHeadlessLog["resumeLabel"]) | undefined;
+  /** How near the newest line still counts as being at it, in pixels. */
+  threshold?: (HelixHeadlessLog["threshold"]) | undefined;
+  /** How each line shows its `at`: `absolute` on the clock, `relative` as the
+time since the first line. Absent shows no time. */
+  timestamps?: (HelixHeadlessLog["timestamps"]) | undefined;
+  /** Whether a line longer than the box wraps onto the next row. Otherwise the log scrolls sideways. */
+  wrap?: (HelixHeadlessLog["wrap"]) | undefined;
+  /** Whether the rows are still loading.
+
+Reflected, because a stylesheet needs it: the rows that are already there
+are dimmed rather than removed while a new set arrives, and only CSS can
+say that without the component knowing what a row looks like. */
+  loading?: (HelixHeadlessLog["loading"]) | undefined;
+  /** The text shown and announced while the rows load. */
+  "loading-text"?: (HelixHeadlessLog["loadingText"]) | undefined;
+  /** The text shown and announced while the rows load. */
+  loadingText?: (HelixHeadlessLog["loadingText"]) | undefined;
+  /** The steps the lines from data name in `group`. A step stands where its
+first line is, and one with no line yet stands at the end.
+
+Replaced rather than mutated, as `lines` is: a step finishing is a new
+array with its `status` changed. */
+  groups?: (HelixHeadlessLog["groups"]) | undefined;
+  /** The lines as data. Reading it gives every line kept, oldest first, with
+the line still being written left out.
+
+Replaced rather than mutated: setting it starts the log over with these
+lines, and `write` adds to them. Set it or write children, not both. */
+  lines?: (HelixHeadlessLog["lines"]) | undefined;
+  /** Reads each finished line of written text: return the fields to set, such
+as `level` or `group`, or `null` to drop the line. Lines in `lines` are
+taken as they are. */
+  parse?: (HelixHeadlessLog["parse"]) | undefined;
+  /** Text to read as it arrives, to the end: a `ReadableStream` of text or
+bytes, such as a `fetch` response's body, or an async iterable. Bytes are
+read as UTF-8. The log sets `done` when it ends, and a new source stops
+reading the last one. */
+  source?: (HelixHeadlessLog["source"]) | undefined;
+
+  /** Fired when the reader leaves the newest line by scrolling, or comes back to it. Cancelable. */
+  "onhelix-before-pin"?: ((
+    e: HelixHeadlessLogHelixBeforePinElementEvent,
+  ) => void) | undefined;
+  /** 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. */
+  "onhelix-expand"?: ((e: HelixHeadlessLogHelixExpandElementEvent) => void) | undefined;
+  /** Fired after the log follows the newest line or lets go of it, with `true` or `false` in `detail.value`. */
+  "onhelix-pin"?: ((e: HelixHeadlessLogHelixPinElementEvent) => void) | undefined;
+};
+
+export type HelixHeadlessLogSolidJsProps = {
+  /** Whether the log opens following its newest line, when `pinned` is not set.
+`default-pinned="false"` opens it where it starts. */
+  "bool:default-pinned"?: (HelixHeadlessLog["defaultPinned"]) | undefined;
+  /** Whether the log opens following its newest line, when `pinned` is not set.
+`default-pinned="false"` opens it where it starts. */
+  "prop:defaultPinned"?: (HelixHeadlessLog["defaultPinned"]) | undefined;
+  /** Whether the run is over, which a screen reader is told once.
+
+Set it when output you `write` is complete. A `source` sets it when the
+stream ends. */
+  "prop:done"?: (HelixHeadlessLog["done"]) | undefined;
+  /** What a screen reader hears when the run is over. */
+  "attr:done-label"?: (HelixHeadlessLog["doneLabel"]) | undefined;
+  /** What a screen reader hears when the run is over. */
+  "prop:doneLabel"?: (HelixHeadlessLog["doneLabel"]) | undefined;
+  /** What the line above the log says once `limit` has let lines go. `{count}` is how many. */
+  "attr:dropped-label"?: (HelixHeadlessLog["droppedLabel"]) | undefined;
+  /** What the line above the log says once `limit` has let lines go. `{count}` is how many. */
+  "prop:droppedLabel"?: (HelixHeadlessLog["droppedLabel"]) | undefined;
+  /** The text shown and announced when the log has no lines. */
+  "attr:empty-text"?: (HelixHeadlessLog["emptyText"]) | undefined;
+  /** The text shown and announced when the log has no lines. */
+  "prop:emptyText"?: (HelixHeadlessLog["emptyText"]) | undefined;
+  /** What a screen reader hears when lines at `error` arrive. `{count}` is how
+many arrived together and `{text}` is the first of them. */
+  "attr:error-label"?: (HelixHeadlessLog["errorLabel"]) | undefined;
+  /** What a screen reader hears when lines at `error` arrive. `{count}` is how
+many arrived together and `{text}` is the first of them. */
+  "prop:errorLabel"?: (HelixHeadlessLog["errorLabel"]) | undefined;
+  /** The log's name, read by screen readers, where `label` is empty. */
+  "attr:fallback-label"?: (HelixHeadlessLog["fallbackLabel"]) | undefined;
+  /** The log's name, read by screen readers, where `label` is empty. */
+  "prop:fallbackLabel"?: (HelixHeadlessLog["fallbackLabel"]) | undefined;
+  /** What a screen reader hears when a step finishes or fails. `{heading}` is
+the step's heading and `{status}` is `done` or `failed`. */
+  "attr:group-label"?: (HelixHeadlessLog["groupLabel"]) | undefined;
+  /** What a screen reader hears when a step finishes or fails. `{heading}` is
+the step's heading and `{status}` is `done` or `failed`. */
+  "prop:groupLabel"?: (HelixHeadlessLog["groupLabel"]) | undefined;
+  /** The log's name, read by screen readers. */
+  "prop:label"?: (HelixHeadlessLog["label"]) | undefined;
+  /** The most lines kept, or 0 to keep them all. Past it the oldest lines are
+let go, and the line above the log says how many. */
+  "prop:limit"?: (HelixHeadlessLog["limit"]) | undefined;
+  /** A link for each line number, with `{n}` where the number goes, such as
+`#L{n}`. Empty leaves the numbers as text. */
+  "attr:line-href"?: (HelixHeadlessLog["lineHref"]) | undefined;
+  /** A link for each line number, with `{n}` where the number goes, such as
+`#L{n}`. Empty leaves the numbers as text. */
+  "prop:lineHref"?: (HelixHeadlessLog["lineHref"]) | undefined;
+  /** What a screen reader hears for the link on a line's number, handed to each
+line the log draws. `{number}` is the number. */
+  "attr:line-label"?: (HelixHeadlessLog["lineLabel"]) | undefined;
+  /** What a screen reader hears for the link on a line's number, handed to each
+line the log draws. `{number}` is the number. */
+  "prop:lineLabel"?: (HelixHeadlessLog["lineLabel"]) | undefined;
+  /** Whether each line shows its number. */
+  "bool:line-numbers"?: (HelixHeadlessLog["lineNumbers"]) | undefined;
+  /** Whether each line shows its number. */
+  "prop:lineNumbers"?: (HelixHeadlessLog["lineNumbers"]) | undefined;
+  /** Lines to mark, as numbers and ranges such as `12, 40-44`. */
+  "attr:mark-lines"?: (HelixHeadlessLog["markLines"]) | undefined;
+  /** Lines to mark, as numbers and ranges such as `12, 40-44`. */
+  "prop:markLines"?: (HelixHeadlessLog["markLines"]) | undefined;
+  /** What a screen reader hears when `query` changes. `{count}` is how many lines match. */
+  "attr:matches-label"?: (HelixHeadlessLog["matchesLabel"]) | undefined;
+  /** What a screen reader hears when `query` changes. `{count}` is how many lines match. */
+  "prop:matchesLabel"?: (HelixHeadlessLog["matchesLabel"]) | undefined;
+  /** Whether the log follows its newest line.
+
+The reader's scrolling asks first: `helix-before-pin` is cancelable, so a
+consumer refusing it takes the decision and assigns their own value. Not
+reflected, for the reason `Chat` gives at its own `pinned`: a default of
+true would write the attribute on upgrade. */
+  "prop:pinned"?: (HelixHeadlessLog["pinned"]) | undefined;
+  /** Text a line has to hold to be shown, ignoring case. Empty shows every line. */
+  "prop:query"?: (HelixHeadlessLog["query"]) | undefined;
+  /** The words on the button that returns to the newest line, where `resume` is empty. */
+  "attr:resume-label"?: (HelixHeadlessLog["resumeLabel"]) | undefined;
+  /** The words on the button that returns to the newest line, where `resume` is empty. */
+  "prop:resumeLabel"?: (HelixHeadlessLog["resumeLabel"]) | undefined;
+  /** How near the newest line still counts as being at it, in pixels. */
+  "prop:threshold"?: (HelixHeadlessLog["threshold"]) | undefined;
+  /** How each line shows its `at`: `absolute` on the clock, `relative` as the
+time since the first line. Absent shows no time. */
+  "prop:timestamps"?: (HelixHeadlessLog["timestamps"]) | undefined;
+  /** Whether a line longer than the box wraps onto the next row. Otherwise the log scrolls sideways. */
+  "prop:wrap"?: (HelixHeadlessLog["wrap"]) | undefined;
+  /** Whether the rows are still loading.
+
+Reflected, because a stylesheet needs it: the rows that are already there
+are dimmed rather than removed while a new set arrives, and only CSS can
+say that without the component knowing what a row looks like. */
+  "prop:loading"?: (HelixHeadlessLog["loading"]) | undefined;
+  /** The text shown and announced while the rows load. */
+  "attr:loading-text"?: (HelixHeadlessLog["loadingText"]) | undefined;
+  /** The text shown and announced while the rows load. */
+  "prop:loadingText"?: (HelixHeadlessLog["loadingText"]) | undefined;
+  /** The steps the lines from data name in `group`. A step stands where its
+first line is, and one with no line yet stands at the end.
+
+Replaced rather than mutated, as `lines` is: a step finishing is a new
+array with its `status` changed. */
+  "prop:groups"?: (HelixHeadlessLog["groups"]) | undefined;
+  /** The lines as data. Reading it gives every line kept, oldest first, with
+the line still being written left out.
+
+Replaced rather than mutated: setting it starts the log over with these
+lines, and `write` adds to them. Set it or write children, not both. */
+  "prop:lines"?: (HelixHeadlessLog["lines"]) | undefined;
+  /** Reads each finished line of written text: return the fields to set, such
+as `level` or `group`, or `null` to drop the line. Lines in `lines` are
+taken as they are. */
+  "prop:parse"?: (HelixHeadlessLog["parse"]) | undefined;
+  /** Text to read as it arrives, to the end: a `ReadableStream` of text or
+bytes, such as a `fetch` response's body, or an async iterable. Bytes are
+read as UTF-8. The log sets `done` when it ends, and a new source stops
+reading the last one. */
+  "prop:source"?: (HelixHeadlessLog["source"]) | undefined;
+  /** Fired when the reader leaves the newest line by scrolling, or comes back to it. Cancelable. */
+  "on:helix-before-pin"?: ((
+    e: HelixHeadlessLogHelixBeforePinElementEvent,
+  ) => void) | undefined;
+  /** 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. */
+  "on:helix-expand"?: ((e: HelixHeadlessLogHelixExpandElementEvent) => void) | undefined;
+  /** Fired after the log follows the newest line or lets go of it, with `true` or `false` in `detail.value`. */
+  "on:helix-pin"?: ((e: HelixHeadlessLogHelixPinElementEvent) => void) | undefined;
+
+  /** Set the innerHTML of the element */
+  innerHTML?: (string) | undefined;
+  /** Set the textContent of the element */
+  textContent?: (string | number) | undefined;
+};
+
 /** `HelixHeadlessMapArea` component event */
 export type HelixHeadlessMapAreaElementEvent<E = Event> = TypedEvent<
   HelixHeadlessMapArea,
@@ -54205,6 +54621,439 @@ export type CustomElements = {
     HelixHeadlessLoaderProps & BaseProps<HelixHeadlessLoader> & BaseEvents<HelixHeadlessLoader>
   >;
 
+  /**
+   * A group is a disclosure: its heading is a button that shows and hides the
+   * lines inside it, and says whether they are shown with `aria-expanded`. Put
+   * `Log.Line` elements inside it, and nest groups for steps within steps.
+   *
+   * `status` draws a mark before the heading, and a screen reader hears the
+   * status after the heading (`status-label`). `duration` stands at the end of
+   * the heading, as you write it, such as `12s`.
+   *
+   * A group starts shut. Write `default-open` on the step a reader should see,
+   * such as the one that failed.
+   *
+   * ## Attributes & Properties
+   *
+   * Component attributes and properties that can be applied to the element or by using JavaScript.
+   *
+   * - `duration`: How long the step took, as it should read, such as `12s`.
+   * - `heading`: What the step is called. The `heading` slot replaces it.
+   * - `status`: Where the step stands, which draws a mark before the heading.
+   * - `status-label`/`statusLabel`: What a screen reader hears for the status, after the heading.
+   * `{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`.
+   * - `default-open`/`defaultOpen`: Whether the element starts open. Ignored once `open` is written.
+   * - `open`: Whether the element is open.
+   *
+   * One property, not two, so `dialog.open` answers the question anyone
+   * asking it meant. Writing always applies; `<helix-dialog open>` is the
+   * same statement in markup.
+   *
+   * **Not reflected, and that is required rather than tidy.** Reflection
+   * writes the resolved state back as an attribute, so an element that opened
+   * itself would put `open` on its own host: cloned, serialized for
+   * hydration, or diffed by a framework, it comes back holding whatever the
+   * last reader did rather than what the author wrote. `:state(open)` carries
+   * the resolved state for stylesheets, which is what the mirror is for.
+   * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
+   *
+   * **Named `whenSettled` because `settled` is taken four times over**, by
+   * Image, Splitter and both color controls, none of them about transitions. A
+   * base class takes the name every subclass then cannot use.
+   *
+   * **The state it reports cannot be watched, which is why this exists.** A
+   * custom state is deliberately not in the DOM, so there is no
+   * `MutationObserver` equivalent for `ElementInternals.states`. Await this
+   * instead.
+   *
+   * Separate from `updateComplete`, which resolves in the microtask checkpoint
+   * the suppression is still active in. That is the distinction `readyToMove`
+   * in `@fusion.dev/helix-testing` is written around.
+   *
+   * It never resolves where `requestAnimationFrame` never fires, which is a
+   * server, a hidden tab, and happy-dom. Callers that must not hang there race
+   * it against a timeout, as the happy-dom harness's `readyToMove` does. The
+   * browser harness's awaits it alone: a browser always runs the frame, and a
+   * timer beside it was a bet on how long one takes, which a busy run lost. (property only) (readonly)
+   *
+   * ## Events
+   *
+   * Events that will be emitted by the component.
+   *
+   * - `helix-before-close`: Fired before the group closes. Cancelable.
+   * - `helix-before-open`: Fired before the group opens. Cancelable.
+   * - `toggle`: Fired after the group opens or closes, with `newState` and `oldState`.
+   *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `(default)`: The lines of the step, and any groups inside it.
+   * - `heading`: The heading, where it holds more than text. Defaults to `heading`.
+   *
+   * ## Methods
+   *
+   * Methods that can be called to access component functionality.
+   *
+   * - `requestOpen(next: boolean) => boolean`: Requests that the element open or close, and returns whether the change
+   * was applied.
+   *
+   * Announces before it acts, so `preventDefault()` on the `helix-before-open` or
+   * `helix-before-close` is a refusal and nothing moves. Nobody refusing means the
+   * element opens or closes itself, whether or not a consumer declared
+   * `open`: a declared property is a seed and a correction, and a consumer
+   * who wants the decision for themselves refuses it and assigns their own.
+   * - `toggleOpen() => boolean`: Requests the opposite of the current state.
+   *
+   * ## CSS Parts
+   *
+   * Custom selectors for styling elements within the component.
+   *
+   * - `content`: The lines, hidden while the group is shut.
+   * - `duration`: How long the step took.
+   * - `heading`: The heading.
+   * - `mark`: The caret that turns as the group opens, an `<svg>` you size.
+   * - `status`: The mark for the status, an `<svg>` you size.
+   * - `summary`: The button that opens and closes the group.
+   *
+   * ## CSS States
+   *
+   * These can be used to apply styling when a component is in a given state.
+   *
+   * - `open`: The group shows its lines.
+   * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
+   */
+  "helix-headless-log-group": Partial<
+    HelixHeadlessLogGroupProps & BaseProps<HelixHeadlessLogGroup> & BaseEvents<HelixHeadlessLogGroup>
+  >;
+
+  /**
+   * Write one for each line of a log you serve whole, inside a `Log` or a
+   * `Log.Group`. The log numbers each line, counting the lines of every group,
+   * and tells it whether to show its number and its time.
+   *
+   * `level` says how much a line matters, and the styled tier draws `warn` and
+   * `error` lines apart. The text is the line's own content, so you can mark it
+   * up yourself.
+   *
+   * ## Attributes & Properties
+   *
+   * Component attributes and properties that can be applied to the element or by using JavaScript.
+   *
+   * - `at`: When the line was written: milliseconds since the epoch, or anything `Date` parses.
+   * - `level`: How much the line matters. Absent is `info`.
+   * - `line-label`/`lineLabel`: What a screen reader hears for the link on a line's number. `{number}` is the number.
+   * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
+   *
+   * **Named `whenSettled` because `settled` is taken four times over**, by
+   * Image, Splitter and both color controls, none of them about transitions. A
+   * base class takes the name every subclass then cannot use.
+   *
+   * **The state it reports cannot be watched, which is why this exists.** A
+   * custom state is deliberately not in the DOM, so there is no
+   * `MutationObserver` equivalent for `ElementInternals.states`. Await this
+   * instead.
+   *
+   * Separate from `updateComplete`, which resolves in the microtask checkpoint
+   * the suppression is still active in. That is the distinction `readyToMove`
+   * in `@fusion.dev/helix-testing` is written around.
+   *
+   * It never resolves where `requestAnimationFrame` never fires, which is a
+   * server, a hidden tab, and happy-dom. Callers that must not hang there race
+   * it against a timeout, as the happy-dom harness's `readyToMove` does. The
+   * browser harness's awaits it alone: a browser always runs the frame, and a
+   * timer beside it was a bet on how long one takes, which a busy run lost. (property only) (readonly)
+   *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `(default)`: The text of the line.
+   *
+   * ## CSS Custom Properties
+   *
+   * CSS variables available for styling the component.
+   *
+   * - `--log-run-background-color`: Written on a `run` with a background, in the same form as `--log-run-color`.
+   * - `--log-run-color`: Written on a `run` with a text color: one of the sixteen `--log-ansi-*` colors the log publishes, or the color itself.
+   *
+   * ## CSS Parts
+   *
+   * Custom selectors for styling elements within the component.
+   *
+   * - `line`: The row the number, the time, and the text sit in.
+   * - `line-debug`: The row of a line at `debug`.
+   * - `line-error`: The row of a line at `error`.
+   * - `line-marked`: The row of a line `mark-lines` names on the log.
+   * - `line-warn`: The row of a line at `warn`.
+   * - `match`: Text that matches the log's `query`, in a line the log draws from data.
+   * - `number`: The line's number, shown with `line-numbers`, and a link with `line-href`.
+   * - `run`: 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`.
+   * - `run-bold`: A run drawn bold.
+   * - `run-dim`: A run drawn faint.
+   * - `run-italic`: A run drawn italic.
+   * - `run-strike`: A run drawn struck through.
+   * - `run-underline`: A run drawn underlined.
+   * - `text`: The text of the line.
+   * - `time`: When the line was written, shown with `timestamps`.
+   *
+   * ## CSS States
+   *
+   * These can be used to apply styling when a component is in a given state.
+   *
+   * - `filtered`: The log's `query` does not match the line, so it draws nothing.
+   * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
+   */
+  "helix-headless-log-line": Partial<
+    HelixHeadlessLogLineProps & BaseProps<HelixHeadlessLogLine> & BaseEvents<HelixHeadlessLogLine>
+  >;
+
+  /**
+   * A log holds lines in the order they were written and keeps the reader at
+   * the newest one, until they scroll up to read. It stays where they left it
+   * while lines keep arriving, and a button returns them to the end
+   * (`resume-label`, "Jump to latest").
+   *
+   * **Lines arrive two ways.** For a log you serve whole, write `Log.Line`
+   * elements as children, inside `Log.Group` elements for the steps. For a log
+   * that is still being written, hand it text: `write(chunk)` takes text as it
+   * arrives, in pieces that need not end at a line break, and `source` takes a
+   * `ReadableStream` or an async iterable and reads it to the end. `lines` takes
+   * the lines as data. Text drawn from data is drawn one window at a time, so a
+   * log of a hundred thousand lines holds a screenful of elements, and the log
+   * needs a block size of its own. Do not use both ways at once.
+   *
+   * **Written text is read the way a terminal shows it.** A carriage return
+   * starts the line over, so a progress bar stays one line, and the line still
+   * being written is shown as it stands. ANSI colors and weights are drawn, in
+   * the sixteen colors the styled tier takes from your theme, and every other
+   * escape code is dropped. Give `parse` a function to read each finished line,
+   * such as a level off its prefix or a group off a marker.
+   *
+   * **Steps fold.** Lines that name a group in `groups` stand under its heading,
+   * which shows its status and how long it took and opens and closes the lines.
+   * A group a reader opens or closes fires `helix-expand` with every open group.
+   *
+   * **Search with `query`.** The log shows only the lines that hold it, marks
+   * each match, opens the groups that hold one, and says how many lines match.
+   *
+   * `line-numbers` numbers the lines from the first ever written, so a number
+   * still names its line once `limit` has let older lines go, and `line-href`
+   * makes each number a link, such as `#L{n}`. `scrollToLine(n)` takes a reader
+   * to one. `timestamps` shows each line's `at`, on the clock or as the time
+   * into the run. `mark-lines` marks lines, such as `12, 40-44`.
+   *
+   * **What a screen reader hears.** The log is a `log` and stays quiet as lines
+   * arrive, since reading a build aloud line by line helps nobody. A separate
+   * status region says each line at `error` once it arrives, each step once it
+   * finishes or fails, and the end of the run once `done` is set or `source`
+   * ends. Set `done` yourself when output you `write` is complete.
+   *
+   * The log scrolls on this tier. It carries `data-scroller`, so following the
+   * newest line and drawing a window work with no stylesheet. Give the log a
+   * block size, such as `helix-headless-log::part(log) { block-size: 20rem }`.
+   *
+   * ```js
+   * import '@fusion.dev/helix/log'
+   * ```
+   *
+   * ## Attributes & Properties
+   *
+   * Component attributes and properties that can be applied to the element or by using JavaScript.
+   *
+   * - `default-pinned`/`defaultPinned`: Whether the log opens following its newest line, when `pinned` is not set.
+   * `default-pinned="false"` opens it where it starts.
+   * - `done`: Whether the run is over, which a screen reader is told once.
+   *
+   * Set it when output you `write` is complete. A `source` sets it when the
+   * stream ends.
+   * - `done-label`/`doneLabel`: What a screen reader hears when the run is over.
+   * - `dropped-label`/`droppedLabel`: What the line above the log says once `limit` has let lines go. `{count}` is how many.
+   * - `empty-text`/`emptyText`: The text shown and announced when the log has no lines.
+   * - `error-label`/`errorLabel`: What a screen reader hears when lines at `error` arrive. `{count}` is how
+   * many arrived together and `{text}` is the first of them.
+   * - `fallback-label`/`fallbackLabel`: The log's name, read by screen readers, where `label` is empty.
+   * - `group-label`/`groupLabel`: What a screen reader hears when a step finishes or fails. `{heading}` is
+   * the step's heading and `{status}` is `done` or `failed`.
+   * - `label`: The log's name, read by screen readers.
+   * - `limit`: The most lines kept, or 0 to keep them all. Past it the oldest lines are
+   * let go, and the line above the log says how many.
+   * - `line-href`/`lineHref`: A link for each line number, with `{n}` where the number goes, such as
+   * `#L{n}`. Empty leaves the numbers as text.
+   * - `line-label`/`lineLabel`: What a screen reader hears for the link on a line's number, handed to each
+   * line the log draws. `{number}` is the number.
+   * - `line-numbers`/`lineNumbers`: Whether each line shows its number.
+   * - `mark-lines`/`markLines`: Lines to mark, as numbers and ranges such as `12, 40-44`.
+   * - `matches-label`/`matchesLabel`: What a screen reader hears when `query` changes. `{count}` is how many lines match.
+   * - `pinned`: Whether the log follows its newest line.
+   *
+   * The reader's scrolling asks first: `helix-before-pin` is cancelable, so a
+   * consumer refusing it takes the decision and assigns their own value. Not
+   * reflected, for the reason `Chat` gives at its own `pinned`: a default of
+   * true would write the attribute on upgrade.
+   * - `query`: Text a line has to hold to be shown, ignoring case. Empty shows every line.
+   * - `resume-label`/`resumeLabel`: The words on the button that returns to the newest line, where `resume` is empty.
+   * - `threshold`: How near the newest line still counts as being at it, in pixels.
+   * - `timestamps`: How each line shows its `at`: `absolute` on the clock, `relative` as the
+   * time since the first line. Absent shows no time.
+   * - `wrap`: Whether a line longer than the box wraps onto the next row. Otherwise the log scrolls sideways.
+   * - `loading`: Whether the rows are still loading.
+   *
+   * Reflected, because a stylesheet needs it: the rows that are already there
+   * are dimmed rather than removed while a new set arrives, and only CSS can
+   * say that without the component knowing what a row looks like.
+   * - `loading-text`/`loadingText`: The text shown and announced while the rows load.
+   * - `groups`: The steps the lines from data name in `group`. A step stands where its
+   * first line is, and one with no line yet stands at the end.
+   *
+   * Replaced rather than mutated, as `lines` is: a step finishing is a new
+   * array with its `status` changed. (property only)
+   * - `lines`: The lines as data. Reading it gives every line kept, oldest first, with
+   * the line still being written left out.
+   *
+   * Replaced rather than mutated: setting it starts the log over with these
+   * lines, and `write` adds to them. Set it or write children, not both. (property only)
+   * - `parse`: Reads each finished line of written text: return the fields to set, such
+   * as `level` or `group`, or `null` to drop the line. Lines in `lines` are
+   * taken as they are. (property only)
+   * - `source`: Text to read as it arrives, to the end: a `ReadableStream` of text or
+   * bytes, such as a `fetch` response's body, or an async iterable. Bytes are
+   * read as UTF-8. The log sets `done` when it ends, and a new source stops
+   * reading the last one. (property only)
+   * - `text`: Every line kept, as plain text with the escape codes taken out, one to a
+   * row: what a download or a copy of the log should hold. (property only) (readonly)
+   * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
+   *
+   * **Named `whenSettled` because `settled` is taken four times over**, by
+   * Image, Splitter and both color controls, none of them about transitions. A
+   * base class takes the name every subclass then cannot use.
+   *
+   * **The state it reports cannot be watched, which is why this exists.** A
+   * custom state is deliberately not in the DOM, so there is no
+   * `MutationObserver` equivalent for `ElementInternals.states`. Await this
+   * instead.
+   *
+   * Separate from `updateComplete`, which resolves in the microtask checkpoint
+   * the suppression is still active in. That is the distinction `readyToMove`
+   * in `@fusion.dev/helix-testing` is written around.
+   *
+   * It never resolves where `requestAnimationFrame` never fires, which is a
+   * server, a hidden tab, and happy-dom. Callers that must not hang there race
+   * it against a timeout, as the happy-dom harness's `readyToMove` does. The
+   * browser harness's awaits it alone: a browser always runs the frame, and a
+   * timer beside it was a bet on how long one takes, which a busy run lost. (property only) (readonly)
+   *
+   * ## Events
+   *
+   * Events that will be emitted by the component.
+   *
+   * - `helix-before-pin`: Fired when the reader leaves the newest line by scrolling, or comes back to it. Cancelable.
+   * - `helix-expand`: 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.
+   * - `helix-pin`: Fired after the log follows the newest line or lets go of it, with `true` or `false` in `detail.value`.
+   *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `(default)`: The lines, as `Log.Line` and `Log.Group` elements.
+   * - `resume`: The control that returns to the newest line, shown while the reader is scrolled away. Defaults to a button named by `resume-label`.
+   * - `toolbar`: Controls above the log, such as a search field or a button that wraps lines.
+   *
+   * ## Methods
+   *
+   * Methods that can be called to access component functionality.
+   *
+   * - `write(chunk: string) => void`: Adds text as it arrives. A line ends at each line break, and the text
+   * after the last one is the line still being written.
+   * - `clear() => void`: Lets every line go, and forgets which groups the reader opened, keeping
+   * `groups`, `parse`, and `limit`.
+   * - `resume() => void`: Puts the log back at its newest line, and follows it again.
+   * - `scrollToLine(number: number, options: LogScrollOptions = {}) => Promise<boolean>`: Scrolls to line `number`, counted from the first line ever written, and
+   * stops following the newest. Opens a shut group the line is in. Resolves
+   * to whether the line is shown: false for a line `limit` let go or `query`
+   * hides.
+   *
+   * ## CSS Custom Properties
+   *
+   * CSS variables available for styling the component.
+   *
+   * - `--log-ansi-background`: The background a run takes where ANSI swaps the colors and named none. Defaults to the log's own background on the styled tier.
+   * - `--log-ansi-black`: The ANSI color black, which codes `30` and `40` draw.
+   * - `--log-ansi-blue`: The ANSI color blue, which codes `34` and `44` draw.
+   * - `--log-ansi-bright-black`: The ANSI color bright black, which codes `90` and `100` draw.
+   * - `--log-ansi-bright-blue`: The ANSI color bright blue, which codes `94` and `104` draw.
+   * - `--log-ansi-bright-cyan`: The ANSI color bright cyan, which codes `96` and `106` draw.
+   * - `--log-ansi-bright-green`: The ANSI color bright green, which codes `92` and `102` draw.
+   * - `--log-ansi-bright-magenta`: The ANSI color bright magenta, which codes `95` and `105` draw.
+   * - `--log-ansi-bright-red`: The ANSI color bright red, which codes `91` and `101` draw.
+   * - `--log-ansi-bright-white`: The ANSI color bright white, which codes `97` and `107` draw.
+   * - `--log-ansi-bright-yellow`: The ANSI color bright yellow, which codes `93` and `103` draw.
+   * - `--log-ansi-cyan`: The ANSI color cyan, which codes `36` and `46` draw.
+   * - `--log-ansi-foreground`: 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.
+   * - `--log-ansi-green`: The ANSI color green, which codes `32` and `42` draw.
+   * - `--log-ansi-magenta`: The ANSI color magenta, which codes `35` and `45` draw.
+   * - `--log-ansi-red`: The ANSI color red, which codes `31` and `41` draw.
+   * - `--log-ansi-white`: The ANSI color white, which codes `37` and `47` draw.
+   * - `--log-ansi-yellow`: The ANSI color yellow, which codes `33` and `43` draw.
+   * - `--log-digits`: 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.
+   *
+   * ## CSS Parts
+   *
+   * Custom selectors for styling elements within the component.
+   *
+   * - `after`: The space the rows below the drawn ones would take. Only for lines drawn from data.
+   * - `before`: The space the rows above the drawn ones would take. Only for lines drawn from data.
+   * - `dropped`: The line above the log that says how many earlier lines `limit` let go.
+   * - `empty`: Shown when the log has no lines.
+   * - `group-content`: Not drawn: a group drawn from data stands for its heading, and its lines are rows beside it.
+   * - `group-duration`: How long a step drawn from `groups` took.
+   * - `group-heading`: The heading of a step drawn from `groups`.
+   * - `group-mark`: The caret of a step drawn from `groups`.
+   * - `group-status`: The status mark of a step drawn from `groups`.
+   * - `group-summary`: The button that opens and closes a step drawn from `groups`.
+   * - `group-summary-done`: The button of a step drawn from `groups` that is `done`.
+   * - `group-summary-failed`: The button of a step drawn from `groups` that `failed`.
+   * - `group-summary-pending`: The button of a step drawn from `groups` that is `pending`.
+   * - `group-summary-running`: The button of a step drawn from `groups` that is `running`.
+   * - `group-summary-skipped`: The button of a step drawn from `groups` that was `skipped`.
+   * - `line`: The row of a line drawn from data.
+   * - `line-debug`: The row of a line drawn from data at `debug`.
+   * - `line-error`: The row of a line drawn from data at `error`.
+   * - `line-marked`: The row of a line drawn from data that `mark-lines` names.
+   * - `line-match`: Text in a line drawn from data that matches `query`.
+   * - `line-number`: The number of a line drawn from data.
+   * - `line-run`: A stretch of a line drawn from data in an ANSI style.
+   * - `line-run-bold`: A run drawn bold.
+   * - `line-run-dim`: A run drawn faint.
+   * - `line-run-italic`: A run drawn italic.
+   * - `line-run-strike`: A run drawn struck through.
+   * - `line-run-underline`: A run drawn underlined.
+   * - `line-text`: The text of a line drawn from data.
+   * - `line-time`: The time of a line drawn from data.
+   * - `line-warn`: The row of a line drawn from data at `warn`.
+   * - `live`: The region where screen readers hear errors, finished steps, and the end of the run.
+   * - `loading`: Shown while `loading` is set.
+   * - `log`: The lines, which scroll. On this tier, it needs only a block size.
+   * - `resume`: The control shown while the reader is scrolled away from the newest line.
+   * - `resume-button`: The button the `resume` region shows when nothing is slotted into it.
+   * - `resume-mark`: The arrow on the default `resume-button`.
+   * - `row`: The wrapper around one row drawn from data, a line or a group's heading.
+   * - `toolbar`: The `toolbar` slot, above the log.
+   *
+   * ## CSS States
+   *
+   * These can be used to apply styling when a component is in a given state.
+   *
+   * - `done`: The run is over: `done` is set, or `source` ended.
+   * - `empty`: The log has no lines.
+   * - `filtered`: `query` is set, so only matching lines are shown.
+   * - `pinned`: The log follows its newest line.
+   * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
+   */
+  "helix-headless-log": Partial<
+    HelixHeadlessLogProps & BaseProps<HelixHeadlessLog> & BaseEvents<HelixHeadlessLog>
+  >;
+
   /**
    * `connectMap` fills the shape as a layer of the map, under its place names.
    * The frame lists each area by its `label` and `description` for screen
@@ -86079,6 +86928,448 @@ export type CustomElementsSolidJs = {
       BaseEvents<HelixHeadlessLoader>
   >;
 
+  /**
+   * A group is a disclosure: its heading is a button that shows and hides the
+   * lines inside it, and says whether they are shown with `aria-expanded`. Put
+   * `Log.Line` elements inside it, and nest groups for steps within steps.
+   *
+   * `status` draws a mark before the heading, and a screen reader hears the
+   * status after the heading (`status-label`). `duration` stands at the end of
+   * the heading, as you write it, such as `12s`.
+   *
+   * A group starts shut. Write `default-open` on the step a reader should see,
+   * such as the one that failed.
+   *
+   * ## Attributes & Properties
+   *
+   * Component attributes and properties that can be applied to the element or by using JavaScript.
+   *
+   * - `duration`: How long the step took, as it should read, such as `12s`.
+   * - `heading`: What the step is called. The `heading` slot replaces it.
+   * - `status`: Where the step stands, which draws a mark before the heading.
+   * - `status-label`/`statusLabel`: What a screen reader hears for the status, after the heading.
+   * `{status}` is one of `pending`, `running`, `done`, `failed`, and `skipped`.
+   * - `default-open`/`defaultOpen`: Whether the element starts open. Ignored once `open` is written.
+   * - `open`: Whether the element is open.
+   *
+   * One property, not two, so `dialog.open` answers the question anyone
+   * asking it meant. Writing always applies; `<helix-dialog open>` is the
+   * same statement in markup.
+   *
+   * **Not reflected, and that is required rather than tidy.** Reflection
+   * writes the resolved state back as an attribute, so an element that opened
+   * itself would put `open` on its own host: cloned, serialized for
+   * hydration, or diffed by a framework, it comes back holding whatever the
+   * last reader did rather than what the author wrote. `:state(open)` carries
+   * the resolved state for stylesheets, which is what the mirror is for.
+   * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
+   *
+   * **Named `whenSettled` because `settled` is taken four times over**, by
+   * Image, Splitter and both color controls, none of them about transitions. A
+   * base class takes the name every subclass then cannot use.
+   *
+   * **The state it reports cannot be watched, which is why this exists.** A
+   * custom state is deliberately not in the DOM, so there is no
+   * `MutationObserver` equivalent for `ElementInternals.states`. Await this
+   * instead.
+   *
+   * Separate from `updateComplete`, which resolves in the microtask checkpoint
+   * the suppression is still active in. That is the distinction `readyToMove`
+   * in `@fusion.dev/helix-testing` is written around.
+   *
+   * It never resolves where `requestAnimationFrame` never fires, which is a
+   * server, a hidden tab, and happy-dom. Callers that must not hang there race
+   * it against a timeout, as the happy-dom harness's `readyToMove` does. The
+   * browser harness's awaits it alone: a browser always runs the frame, and a
+   * timer beside it was a bet on how long one takes, which a busy run lost. (property only) (readonly)
+   *
+   * ## Events
+   *
+   * Events that will be emitted by the component.
+   *
+   * - `helix-before-close`: Fired before the group closes. Cancelable.
+   * - `helix-before-open`: Fired before the group opens. Cancelable.
+   * - `toggle`: Fired after the group opens or closes, with `newState` and `oldState`.
+   *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `(default)`: The lines of the step, and any groups inside it.
+   * - `heading`: The heading, where it holds more than text. Defaults to `heading`.
+   *
+   * ## Methods
+   *
+   * Methods that can be called to access component functionality.
+   *
+   * - `requestOpen(next: boolean) => boolean`: Requests that the element open or close, and returns whether the change
+   * was applied.
+   *
+   * Announces before it acts, so `preventDefault()` on the `helix-before-open` or
+   * `helix-before-close` is a refusal and nothing moves. Nobody refusing means the
+   * element opens or closes itself, whether or not a consumer declared
+   * `open`: a declared property is a seed and a correction, and a consumer
+   * who wants the decision for themselves refuses it and assigns their own.
+   * - `toggleOpen() => boolean`: Requests the opposite of the current state.
+   *
+   * ## CSS Parts
+   *
+   * Custom selectors for styling elements within the component.
+   *
+   * - `content`: The lines, hidden while the group is shut.
+   * - `duration`: How long the step took.
+   * - `heading`: The heading.
+   * - `mark`: The caret that turns as the group opens, an `<svg>` you size.
+   * - `status`: The mark for the status, an `<svg>` you size.
+   * - `summary`: The button that opens and closes the group.
+   *
+   * ## CSS States
+   *
+   * These can be used to apply styling when a component is in a given state.
+   *
+   * - `open`: The group shows its lines.
+   * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
+   */
+  "helix-headless-log-group": Partial<
+    HelixHeadlessLogGroupProps &
+      HelixHeadlessLogGroupSolidJsProps &
+      BaseProps<HelixHeadlessLogGroup> &
+      BaseEvents<HelixHeadlessLogGroup>
+  >;
+
+  /**
+   * Write one for each line of a log you serve whole, inside a `Log` or a
+   * `Log.Group`. The log numbers each line, counting the lines of every group,
+   * and tells it whether to show its number and its time.
+   *
+   * `level` says how much a line matters, and the styled tier draws `warn` and
+   * `error` lines apart. The text is the line's own content, so you can mark it
+   * up yourself.
+   *
+   * ## Attributes & Properties
+   *
+   * Component attributes and properties that can be applied to the element or by using JavaScript.
+   *
+   * - `at`: When the line was written: milliseconds since the epoch, or anything `Date` parses.
+   * - `level`: How much the line matters. Absent is `info`.
+   * - `line-label`/`lineLabel`: What a screen reader hears for the link on a line's number. `{number}` is the number.
+   * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
+   *
+   * **Named `whenSettled` because `settled` is taken four times over**, by
+   * Image, Splitter and both color controls, none of them about transitions. A
+   * base class takes the name every subclass then cannot use.
+   *
+   * **The state it reports cannot be watched, which is why this exists.** A
+   * custom state is deliberately not in the DOM, so there is no
+   * `MutationObserver` equivalent for `ElementInternals.states`. Await this
+   * instead.
+   *
+   * Separate from `updateComplete`, which resolves in the microtask checkpoint
+   * the suppression is still active in. That is the distinction `readyToMove`
+   * in `@fusion.dev/helix-testing` is written around.
+   *
+   * It never resolves where `requestAnimationFrame` never fires, which is a
+   * server, a hidden tab, and happy-dom. Callers that must not hang there race
+   * it against a timeout, as the happy-dom harness's `readyToMove` does. The
+   * browser harness's awaits it alone: a browser always runs the frame, and a
+   * timer beside it was a bet on how long one takes, which a busy run lost. (property only) (readonly)
+   *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `(default)`: The text of the line.
+   *
+   * ## CSS Custom Properties
+   *
+   * CSS variables available for styling the component.
+   *
+   * - `--log-run-background-color`: Written on a `run` with a background, in the same form as `--log-run-color`.
+   * - `--log-run-color`: Written on a `run` with a text color: one of the sixteen `--log-ansi-*` colors the log publishes, or the color itself.
+   *
+   * ## CSS Parts
+   *
+   * Custom selectors for styling elements within the component.
+   *
+   * - `line`: The row the number, the time, and the text sit in.
+   * - `line-debug`: The row of a line at `debug`.
+   * - `line-error`: The row of a line at `error`.
+   * - `line-marked`: The row of a line `mark-lines` names on the log.
+   * - `line-warn`: The row of a line at `warn`.
+   * - `match`: Text that matches the log's `query`, in a line the log draws from data.
+   * - `number`: The line's number, shown with `line-numbers`, and a link with `line-href`.
+   * - `run`: 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`.
+   * - `run-bold`: A run drawn bold.
+   * - `run-dim`: A run drawn faint.
+   * - `run-italic`: A run drawn italic.
+   * - `run-strike`: A run drawn struck through.
+   * - `run-underline`: A run drawn underlined.
+   * - `text`: The text of the line.
+   * - `time`: When the line was written, shown with `timestamps`.
+   *
+   * ## CSS States
+   *
+   * These can be used to apply styling when a component is in a given state.
+   *
+   * - `filtered`: The log's `query` does not match the line, so it draws nothing.
+   * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
+   */
+  "helix-headless-log-line": Partial<
+    HelixHeadlessLogLineProps &
+      HelixHeadlessLogLineSolidJsProps &
+      BaseProps<HelixHeadlessLogLine> &
+      BaseEvents<HelixHeadlessLogLine>
+  >;
+
+  /**
+   * A log holds lines in the order they were written and keeps the reader at
+   * the newest one, until they scroll up to read. It stays where they left it
+   * while lines keep arriving, and a button returns them to the end
+   * (`resume-label`, "Jump to latest").
+   *
+   * **Lines arrive two ways.** For a log you serve whole, write `Log.Line`
+   * elements as children, inside `Log.Group` elements for the steps. For a log
+   * that is still being written, hand it text: `write(chunk)` takes text as it
+   * arrives, in pieces that need not end at a line break, and `source` takes a
+   * `ReadableStream` or an async iterable and reads it to the end. `lines` takes
+   * the lines as data. Text drawn from data is drawn one window at a time, so a
+   * log of a hundred thousand lines holds a screenful of elements, and the log
+   * needs a block size of its own. Do not use both ways at once.
+   *
+   * **Written text is read the way a terminal shows it.** A carriage return
+   * starts the line over, so a progress bar stays one line, and the line still
+   * being written is shown as it stands. ANSI colors and weights are drawn, in
+   * the sixteen colors the styled tier takes from your theme, and every other
+   * escape code is dropped. Give `parse` a function to read each finished line,
+   * such as a level off its prefix or a group off a marker.
+   *
+   * **Steps fold.** Lines that name a group in `groups` stand under its heading,
+   * which shows its status and how long it took and opens and closes the lines.
+   * A group a reader opens or closes fires `helix-expand` with every open group.
+   *
+   * **Search with `query`.** The log shows only the lines that hold it, marks
+   * each match, opens the groups that hold one, and says how many lines match.
+   *
+   * `line-numbers` numbers the lines from the first ever written, so a number
+   * still names its line once `limit` has let older lines go, and `line-href`
+   * makes each number a link, such as `#L{n}`. `scrollToLine(n)` takes a reader
+   * to one. `timestamps` shows each line's `at`, on the clock or as the time
+   * into the run. `mark-lines` marks lines, such as `12, 40-44`.
+   *
+   * **What a screen reader hears.** The log is a `log` and stays quiet as lines
+   * arrive, since reading a build aloud line by line helps nobody. A separate
+   * status region says each line at `error` once it arrives, each step once it
+   * finishes or fails, and the end of the run once `done` is set or `source`
+   * ends. Set `done` yourself when output you `write` is complete.
+   *
+   * The log scrolls on this tier. It carries `data-scroller`, so following the
+   * newest line and drawing a window work with no stylesheet. Give the log a
+   * block size, such as `helix-headless-log::part(log) { block-size: 20rem }`.
+   *
+   * ```js
+   * import '@fusion.dev/helix/log'
+   * ```
+   *
+   * ## Attributes & Properties
+   *
+   * Component attributes and properties that can be applied to the element or by using JavaScript.
+   *
+   * - `default-pinned`/`defaultPinned`: Whether the log opens following its newest line, when `pinned` is not set.
+   * `default-pinned="false"` opens it where it starts.
+   * - `done`: Whether the run is over, which a screen reader is told once.
+   *
+   * Set it when output you `write` is complete. A `source` sets it when the
+   * stream ends.
+   * - `done-label`/`doneLabel`: What a screen reader hears when the run is over.
+   * - `dropped-label`/`droppedLabel`: What the line above the log says once `limit` has let lines go. `{count}` is how many.
+   * - `empty-text`/`emptyText`: The text shown and announced when the log has no lines.
+   * - `error-label`/`errorLabel`: What a screen reader hears when lines at `error` arrive. `{count}` is how
+   * many arrived together and `{text}` is the first of them.
+   * - `fallback-label`/`fallbackLabel`: The log's name, read by screen readers, where `label` is empty.
+   * - `group-label`/`groupLabel`: What a screen reader hears when a step finishes or fails. `{heading}` is
+   * the step's heading and `{status}` is `done` or `failed`.
+   * - `label`: The log's name, read by screen readers.
+   * - `limit`: The most lines kept, or 0 to keep them all. Past it the oldest lines are
+   * let go, and the line above the log says how many.
+   * - `line-href`/`lineHref`: A link for each line number, with `{n}` where the number goes, such as
+   * `#L{n}`. Empty leaves the numbers as text.
+   * - `line-label`/`lineLabel`: What a screen reader hears for the link on a line's number, handed to each
+   * line the log draws. `{number}` is the number.
+   * - `line-numbers`/`lineNumbers`: Whether each line shows its number.
+   * - `mark-lines`/`markLines`: Lines to mark, as numbers and ranges such as `12, 40-44`.
+   * - `matches-label`/`matchesLabel`: What a screen reader hears when `query` changes. `{count}` is how many lines match.
+   * - `pinned`: Whether the log follows its newest line.
+   *
+   * The reader's scrolling asks first: `helix-before-pin` is cancelable, so a
+   * consumer refusing it takes the decision and assigns their own value. Not
+   * reflected, for the reason `Chat` gives at its own `pinned`: a default of
+   * true would write the attribute on upgrade.
+   * - `query`: Text a line has to hold to be shown, ignoring case. Empty shows every line.
+   * - `resume-label`/`resumeLabel`: The words on the button that returns to the newest line, where `resume` is empty.
+   * - `threshold`: How near the newest line still counts as being at it, in pixels.
+   * - `timestamps`: How each line shows its `at`: `absolute` on the clock, `relative` as the
+   * time since the first line. Absent shows no time.
+   * - `wrap`: Whether a line longer than the box wraps onto the next row. Otherwise the log scrolls sideways.
+   * - `loading`: Whether the rows are still loading.
+   *
+   * Reflected, because a stylesheet needs it: the rows that are already there
+   * are dimmed rather than removed while a new set arrives, and only CSS can
+   * say that without the component knowing what a row looks like.
+   * - `loading-text`/`loadingText`: The text shown and announced while the rows load.
+   * - `groups`: The steps the lines from data name in `group`. A step stands where its
+   * first line is, and one with no line yet stands at the end.
+   *
+   * Replaced rather than mutated, as `lines` is: a step finishing is a new
+   * array with its `status` changed. (property only)
+   * - `lines`: The lines as data. Reading it gives every line kept, oldest first, with
+   * the line still being written left out.
+   *
+   * Replaced rather than mutated: setting it starts the log over with these
+   * lines, and `write` adds to them. Set it or write children, not both. (property only)
+   * - `parse`: Reads each finished line of written text: return the fields to set, such
+   * as `level` or `group`, or `null` to drop the line. Lines in `lines` are
+   * taken as they are. (property only)
+   * - `source`: Text to read as it arrives, to the end: a `ReadableStream` of text or
+   * bytes, such as a `fetch` response's body, or an async iterable. Bytes are
+   * read as UTF-8. The log sets `done` when it ends, and a new source stops
+   * reading the last one. (property only)
+   * - `text`: Every line kept, as plain text with the escape codes taken out, one to a
+   * row: what a download or a copy of the log should hold. (property only) (readonly)
+   * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
+   *
+   * **Named `whenSettled` because `settled` is taken four times over**, by
+   * Image, Splitter and both color controls, none of them about transitions. A
+   * base class takes the name every subclass then cannot use.
+   *
+   * **The state it reports cannot be watched, which is why this exists.** A
+   * custom state is deliberately not in the DOM, so there is no
+   * `MutationObserver` equivalent for `ElementInternals.states`. Await this
+   * instead.
+   *
+   * Separate from `updateComplete`, which resolves in the microtask checkpoint
+   * the suppression is still active in. That is the distinction `readyToMove`
+   * in `@fusion.dev/helix-testing` is written around.
+   *
+   * It never resolves where `requestAnimationFrame` never fires, which is a
+   * server, a hidden tab, and happy-dom. Callers that must not hang there race
+   * it against a timeout, as the happy-dom harness's `readyToMove` does. The
+   * browser harness's awaits it alone: a browser always runs the frame, and a
+   * timer beside it was a bet on how long one takes, which a busy run lost. (property only) (readonly)
+   *
+   * ## Events
+   *
+   * Events that will be emitted by the component.
+   *
+   * - `helix-before-pin`: Fired when the reader leaves the newest line by scrolling, or comes back to it. Cancelable.
+   * - `helix-expand`: 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.
+   * - `helix-pin`: Fired after the log follows the newest line or lets go of it, with `true` or `false` in `detail.value`.
+   *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `(default)`: The lines, as `Log.Line` and `Log.Group` elements.
+   * - `resume`: The control that returns to the newest line, shown while the reader is scrolled away. Defaults to a button named by `resume-label`.
+   * - `toolbar`: Controls above the log, such as a search field or a button that wraps lines.
+   *
+   * ## Methods
+   *
+   * Methods that can be called to access component functionality.
+   *
+   * - `write(chunk: string) => void`: Adds text as it arrives. A line ends at each line break, and the text
+   * after the last one is the line still being written.
+   * - `clear() => void`: Lets every line go, and forgets which groups the reader opened, keeping
+   * `groups`, `parse`, and `limit`.
+   * - `resume() => void`: Puts the log back at its newest line, and follows it again.
+   * - `scrollToLine(number: number, options: LogScrollOptions = {}) => Promise<boolean>`: Scrolls to line `number`, counted from the first line ever written, and
+   * stops following the newest. Opens a shut group the line is in. Resolves
+   * to whether the line is shown: false for a line `limit` let go or `query`
+   * hides.
+   *
+   * ## CSS Custom Properties
+   *
+   * CSS variables available for styling the component.
+   *
+   * - `--log-ansi-background`: The background a run takes where ANSI swaps the colors and named none. Defaults to the log's own background on the styled tier.
+   * - `--log-ansi-black`: The ANSI color black, which codes `30` and `40` draw.
+   * - `--log-ansi-blue`: The ANSI color blue, which codes `34` and `44` draw.
+   * - `--log-ansi-bright-black`: The ANSI color bright black, which codes `90` and `100` draw.
+   * - `--log-ansi-bright-blue`: The ANSI color bright blue, which codes `94` and `104` draw.
+   * - `--log-ansi-bright-cyan`: The ANSI color bright cyan, which codes `96` and `106` draw.
+   * - `--log-ansi-bright-green`: The ANSI color bright green, which codes `92` and `102` draw.
+   * - `--log-ansi-bright-magenta`: The ANSI color bright magenta, which codes `95` and `105` draw.
+   * - `--log-ansi-bright-red`: The ANSI color bright red, which codes `91` and `101` draw.
+   * - `--log-ansi-bright-white`: The ANSI color bright white, which codes `97` and `107` draw.
+   * - `--log-ansi-bright-yellow`: The ANSI color bright yellow, which codes `93` and `103` draw.
+   * - `--log-ansi-cyan`: The ANSI color cyan, which codes `36` and `46` draw.
+   * - `--log-ansi-foreground`: 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.
+   * - `--log-ansi-green`: The ANSI color green, which codes `32` and `42` draw.
+   * - `--log-ansi-magenta`: The ANSI color magenta, which codes `35` and `45` draw.
+   * - `--log-ansi-red`: The ANSI color red, which codes `31` and `41` draw.
+   * - `--log-ansi-white`: The ANSI color white, which codes `37` and `47` draw.
+   * - `--log-ansi-yellow`: The ANSI color yellow, which codes `33` and `43` draw.
+   * - `--log-digits`: 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.
+   *
+   * ## CSS Parts
+   *
+   * Custom selectors for styling elements within the component.
+   *
+   * - `after`: The space the rows below the drawn ones would take. Only for lines drawn from data.
+   * - `before`: The space the rows above the drawn ones would take. Only for lines drawn from data.
+   * - `dropped`: The line above the log that says how many earlier lines `limit` let go.
+   * - `empty`: Shown when the log has no lines.
+   * - `group-content`: Not drawn: a group drawn from data stands for its heading, and its lines are rows beside it.
+   * - `group-duration`: How long a step drawn from `groups` took.
+   * - `group-heading`: The heading of a step drawn from `groups`.
+   * - `group-mark`: The caret of a step drawn from `groups`.
+   * - `group-status`: The status mark of a step drawn from `groups`.
+   * - `group-summary`: The button that opens and closes a step drawn from `groups`.
+   * - `group-summary-done`: The button of a step drawn from `groups` that is `done`.
+   * - `group-summary-failed`: The button of a step drawn from `groups` that `failed`.
+   * - `group-summary-pending`: The button of a step drawn from `groups` that is `pending`.
+   * - `group-summary-running`: The button of a step drawn from `groups` that is `running`.
+   * - `group-summary-skipped`: The button of a step drawn from `groups` that was `skipped`.
+   * - `line`: The row of a line drawn from data.
+   * - `line-debug`: The row of a line drawn from data at `debug`.
+   * - `line-error`: The row of a line drawn from data at `error`.
+   * - `line-marked`: The row of a line drawn from data that `mark-lines` names.
+   * - `line-match`: Text in a line drawn from data that matches `query`.
+   * - `line-number`: The number of a line drawn from data.
+   * - `line-run`: A stretch of a line drawn from data in an ANSI style.
+   * - `line-run-bold`: A run drawn bold.
+   * - `line-run-dim`: A run drawn faint.
+   * - `line-run-italic`: A run drawn italic.
+   * - `line-run-strike`: A run drawn struck through.
+   * - `line-run-underline`: A run drawn underlined.
+   * - `line-text`: The text of a line drawn from data.
+   * - `line-time`: The time of a line drawn from data.
+   * - `line-warn`: The row of a line drawn from data at `warn`.
+   * - `live`: The region where screen readers hear errors, finished steps, and the end of the run.
+   * - `loading`: Shown while `loading` is set.
+   * - `log`: The lines, which scroll. On this tier, it needs only a block size.
+   * - `resume`: The control shown while the reader is scrolled away from the newest line.
+   * - `resume-button`: The button the `resume` region shows when nothing is slotted into it.
+   * - `resume-mark`: The arrow on the default `resume-button`.
+   * - `row`: The wrapper around one row drawn from data, a line or a group's heading.
+   * - `toolbar`: The `toolbar` slot, above the log.
+   *
+   * ## CSS States
+   *
+   * These can be used to apply styling when a component is in a given state.
+   *
+   * - `done`: The run is over: `done` is set, or `source` ended.
+   * - `empty`: The log has no lines.
+   * - `filtered`: `query` is set, so only matching lines are shown.
+   * - `pinned`: The log follows its newest line.
+   * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
+   */
+  "helix-headless-log": Partial<
+    HelixHeadlessLogProps &
+      HelixHeadlessLogSolidJsProps &
+      BaseProps<HelixHeadlessLog> &
+      BaseEvents<HelixHeadlessLog>
+  >;
+
   /**
    * `connectMap` fills the shape as a layer of the map, under its place names.
    * The frame lists each area by its `label` and `description` for screen
@@ -103255,6 +104546,48 @@ export type CustomCssProperties = {
   "--list-first"?: (string) | undefined;
   /** What each row adds to the number before it: `1`, or `-1` where `reversed`. */
   "--list-step"?: (string) | undefined;
+  /** Written on a `run` with a background, in the same form as `--log-run-color`. */
+  "--log-run-background-color"?: (string) | undefined;
+  /** Written on a `run` with a text color: one of the sixteen `--log-ansi-*` colors the log publishes, or the color itself. */
+  "--log-run-color"?: (string) | undefined;
+  /** The background a run takes where ANSI swaps the colors and named none. Defaults to the log's own background on the styled tier. */
+  "--log-ansi-background"?: (string) | undefined;
+  /** The ANSI color black, which codes `30` and `40` draw. */
+  "--log-ansi-black"?: (string) | undefined;
+  /** The ANSI color blue, which codes `34` and `44` draw. */
+  "--log-ansi-blue"?: (string) | undefined;
+  /** The ANSI color bright black, which codes `90` and `100` draw. */
+  "--log-ansi-bright-black"?: (string) | undefined;
+  /** The ANSI color bright blue, which codes `94` and `104` draw. */
+  "--log-ansi-bright-blue"?: (string) | undefined;
+  /** The ANSI color bright cyan, which codes `96` and `106` draw. */
+  "--log-ansi-bright-cyan"?: (string) | undefined;
+  /** The ANSI color bright green, which codes `92` and `102` draw. */
+  "--log-ansi-bright-green"?: (string) | undefined;
+  /** The ANSI color bright magenta, which codes `95` and `105` draw. */
+  "--log-ansi-bright-magenta"?: (string) | undefined;
+  /** The ANSI color bright red, which codes `91` and `101` draw. */
+  "--log-ansi-bright-red"?: (string) | undefined;
+  /** The ANSI color bright white, which codes `97` and `107` draw. */
+  "--log-ansi-bright-white"?: (string) | undefined;
+  /** The ANSI color bright yellow, which codes `93` and `103` draw. */
+  "--log-ansi-bright-yellow"?: (string) | undefined;
+  /** The ANSI color cyan, which codes `36` and `46` draw. */
+  "--log-ansi-cyan"?: (string) | undefined;
+  /** 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. */
+  "--log-ansi-foreground"?: (string) | undefined;
+  /** The ANSI color green, which codes `32` and `42` draw. */
+  "--log-ansi-green"?: (string) | undefined;
+  /** The ANSI color magenta, which codes `35` and `45` draw. */
+  "--log-ansi-magenta"?: (string) | undefined;
+  /** The ANSI color red, which codes `31` and `41` draw. */
+  "--log-ansi-red"?: (string) | undefined;
+  /** The ANSI color white, which codes `37` and `47` draw. */
+  "--log-ansi-white"?: (string) | undefined;
+  /** The ANSI color yellow, which codes `33` and `43` draw. */
+  "--log-ansi-yellow"?: (string) | undefined;
+  /** 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. */
+  "--log-digits"?: (string) | undefined;
   /** How far the needle turns to point north, as an angle. The frame writes it from `bearing`. */
   "--map-needle-turn"?: (string) | undefined;
   /** The height of the panel this one took over from, written on the surface while it is open. */