@fusion.dev/helix-headless 0.212.1 → 0.213.0

package/dist/chat/root/chat-root.d.ts

@@ -346,6 +346,8 @@ export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
     private grower;
     /** What `grower` is watching, so a render that changed nothing re-observes nothing. */
     private watched;
+    /** The frame `watchSizes` will observe in, while one is booked. */
+    private watchFrame;
     /** The scroll offset this element last set, which the reader has not moved from. */
     private stuckAt;
     /** The turn at the top of the reader's view, and how far below the top it sat. */
@@ -424,7 +426,15 @@ export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
      * a reader asking to go to the bottom means.
      */
     resume(): void;
-    /** Scrolls to the bottom, and remembers where that was. */
+    /**
+     * Scrolls to the bottom, and remembers where that was.
+     *
+     * **At once, whatever `scroll-behavior` the page gives the log.** Pinned,
+     * this runs on every update, every token of a streaming turn included, and a
+     * smooth scroll sent again each time never arrives: in WebKit, a log that had
+     * streamed for a second under `scroll-behavior: smooth` rested 6 pixels short
+     * of the bottom, and `stuckAt` held where each scroll began.
+     */
     private stick;
     /**
      * Asks to pin or unpin, and reports whether the request stood.
@@ -496,8 +506,34 @@ export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
      * in a conversation of several knows who spoke.
      */
     private phrase;
-    /** Watches what is drawn for size, re-observing only when that changed. */
+    /**
+     * Watches what is drawn for size, re-observing only when that changed.
+     *
+     * **In the next frame's animation callbacks, never in the update that asked.**
+     * A resize notice asks for an update, the update draws new turns while the
+     * browser is still delivering notices, and turns observed then are held to
+     * the next frame with "ResizeObserver loop completed with undelivered
+     * notifications": twice in WebKit's run of Chat's specs and once in
+     * Chromium's, on October 11, 2026. Observed from the next frame's callbacks,
+     * their first notice comes before that frame paints, and a turn drawn for the
+     * first time is answered sooner still, by `settleDrawn`.
+     */
     private watchSizes;
+    /** Observes the log and the turns drawn now, where that changed. */
+    private observeSizes;
+    /**
+     * Answers the turns this render drew for the first time, once each has drawn
+     * what is in it: a microtask after this update, and before the frame.
+     *
+     * **Sooner than the resize observer, which `watchSizes` starts a frame
+     * later.** A turn is drawn empty and fills in after this update, and until
+     * it is measured the reader's turn sits where the estimates put it. A timer
+     * that ran before the next frame read that place as the reader's: on a Linux
+     * runner, the controller's rest after a scroll left a reader's turn 55.5
+     * pixels from where it was when history arrived above it, in WebKit, on
+     * October 11, 2026. Answered here, the history is held before any timer runs.
+     */
+    private settleDrawn;
     /**
      * A turn or the log changed size, which moves nothing on its own.
      *

package/dist/chat/root/chat-root.js

@@ -62,6 +62,7 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
         this.settling = undefined;
         this.grower = undefined;
         this.watched = [];
+        this.watchFrame = 0;
         this.stuckAt = -1;
         this.anchor = undefined;
         this.asked = false;
@@ -259,7 +260,12 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
     stick() {
         const log = this.log;
         if (log) {
-            log.scrollTop = log.scrollHeight;
+            if (typeof log.scrollTo === 'function') {
+                log.scrollTo({ behavior: 'instant', top: log.scrollHeight });
+            }
+            else {
+                log.scrollTop = log.scrollHeight;
+            }
             this.stuckAt = log.scrollTop;
         }
     }
@@ -335,7 +341,7 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
         }
         const found = turns[low];
         this.anchor = found
-            ? { id: found.id, offset: found.element.getBoundingClientRect().top - top }
+            ? { at: log.scrollTop, id: found.id, offset: found.element.getBoundingClientRect().top - top }
             : undefined;
     }
     restore() {
@@ -344,6 +350,10 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
         if (!log || !anchor || (this.fed && this.virtualize.scrolling())) {
             return;
         }
+        if (!this.fed && Math.abs(log.scrollTop - anchor.at) >= 1) {
+            this.remember();
+            return;
+        }
         const found = this.rendered().find((turn) => turn.id === anchor.id);
         if (!found) {
             return;
@@ -418,9 +428,21 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
             : formatWords(this, 'arrivalLabel', { author: turn.by, text: turn.text });
     }
     watchSizes() {
-        if (typeof ResizeObserver === 'undefined') {
+        if (typeof ResizeObserver === 'undefined' || this.watchFrame !== 0) {
+            return;
+        }
+        if (typeof requestAnimationFrame !== 'function') {
+            this.observeSizes();
             return;
         }
+        this.watchFrame = requestAnimationFrame(() => {
+            this.watchFrame = 0;
+            if (this.isConnected) {
+                this.observeSizes();
+            }
+        });
+    }
+    observeSizes() {
         const log = this.log;
         const targets = [...(log ? [log] : []), ...this.rendered().map((turn) => turn.element)];
         if (targets.length === this.watched.length &&
@@ -434,6 +456,18 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
         }
         this.watched = targets;
     }
+    settleDrawn() {
+        const waiting = this.drawn().filter((row) => !drawnInFull(row));
+        if (waiting.length === 0) {
+            return;
+        }
+        void Promise.all(waiting.map(({ element }) => element.firstElementChild
+            ?.updateComplete)).then(() => {
+            if (this.isConnected && this.fed) {
+                this.handleResize();
+            }
+        });
+    }
     connectedCallback() {
         super.connectedCallback();
         this.addEventListener('keydown', this.handleKeydown);
@@ -458,6 +492,10 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
         this.settling = undefined;
         this.grower?.disconnect();
         this.watched = [];
+        if (this.watchFrame !== 0) {
+            cancelAnimationFrame(this.watchFrame);
+            this.watchFrame = 0;
+        }
     }
     willUpdate(changed) {
         super.willUpdate(changed);
@@ -518,6 +556,7 @@ let HelixHeadlessChat = class HelixHeadlessChat extends MixinCollection(HelixEle
         }
         if (this.fed) {
             this.virtualize.measure();
+            this.settleDrawn();
         }
         this.watchSizes();
         this.markScroller();

package/dist/log/buffer.d.ts

@@ -1,6 +1,21 @@
 import { type LogRun } from './ansi.js';
 /** How much a line matters, which a stylesheet draws and a screen reader may hear. */
-export type LogLevel = 'debug' | 'error' | 'info' | 'warn';
+export type LogLevel = 'debug' | 'error' | 'info' | 'log' | 'warn';
+/**
+ * The levels from the quietest to the loudest, which `level` on a log counts
+ * up from: `log` is a plain line, a console's `console.log`, below `info`.
+ */
+export declare const LOG_LEVELS: readonly LogLevel[];
+/** Whether a line at `level` shows under a log whose quietest level shown is `floor`. A line with no level is `info`. */
+export declare const loudEnough: (level: LogLevel | undefined, floor: LogLevel | undefined) => boolean;
+/**
+ * The words a screen reader hears before a line's text, or nothing where the
+ * text already starts with them: `console.error(error)` writes `Error: …`,
+ * which `Error:` before it would read twice. The words' closing colon is not
+ * needed, and a word that only starts the text's first word, such as `Error`
+ * before `Errors`, is still said.
+ */
+export declare const levelSaid: (words: string | undefined, text: string) => string | undefined;
 /** Where a step of the run stands. */
 export type LogStatus = 'done' | 'failed' | 'pending' | 'running' | 'skipped';
 /** One line of output, as `lines` holds it and `parse` returns it. */
@@ -9,6 +24,11 @@ export interface LogLine {
     at?: number | string;
     /** The `id` of the group in `groups` the line belongs to. */
     group?: string;
+    /**
+     * How many times it was written in a row, where the log folds repeats with
+     * `collapse`. Absent is once.
+     */
+    count?: number;
     /** How much it matters. Absent is `info`. */
     level?: LogLevel;
     /** What was written, with any ANSI escape codes still in it. */
@@ -95,6 +115,8 @@ export declare class LogBuffer {
     dropped: number;
     /** The most finished lines kept, or 0 to keep them all. */
     limit: number;
+    /** Whether a line written again straight after itself folds into it, with a count. */
+    collapse: boolean;
     /** Reads each finished line of written text. */
     parse: LogParser | undefined;
     /** The steps `parse` opened, in order, replaced as a whole when one changes. */
@@ -119,8 +141,13 @@ export declare class LogBuffer {
      * lines it finished.
      */
     write(chunk: string): number;
-    /** Replaces every line, starting a fresh buffer that keeps its `parse` and `limit`. */
+    /** Replaces every line, starting a fresh buffer that keeps its `parse`, `limit` and `collapse`. */
     replace(lines: readonly LogLine[]): void;
+    /**
+     * Adds one finished line as data, after the lines held, folding it where
+     * `collapse` says, and lets the oldest go past `limit`.
+     */
+    push(line: LogLine): void;
     /** Lets every line go. */
     clear(): void;
     /** The line still being written, or undefined where the last line ended. */
@@ -142,6 +169,12 @@ export declare class LogBuffer {
      * as a CI page folds a step that passed.
      */
     private closeStep;
+    /**
+     * Keeps a finished line, or folds it into the line before it where it
+     * repeats that line and `collapse` is set. The fold is a new object, so a
+     * log comparing lines sees it change, drawn in the runs of the first.
+     */
+    private add;
     /** Lets the oldest lines go past `limit`, all at once. */
     private trim;
 }

package/dist/log/buffer.js

@@ -1,4 +1,20 @@
 import { parseAnsi } from './ansi.js';
+export const LOG_LEVELS = ['debug', 'log', 'info', 'warn', 'error'];
+export const loudEnough = (level, floor) => floor === undefined || LOG_LEVELS.indexOf(level ?? 'info') >= LOG_LEVELS.indexOf(floor);
+export const levelSaid = (words, text) => {
+    const word = words?.trim().replace(/:$/, '').toLocaleLowerCase();
+    if (!word) {
+        return undefined;
+    }
+    const start = text.trimStart();
+    const repeats = start.slice(0, word.length).toLocaleLowerCase() === word &&
+        !/^[\p{L}\p{N}]/u.test(start.slice(word.length));
+    return repeats ? undefined : words;
+};
+const repeats = (line, last) => last !== undefined &&
+    last.text === line.text &&
+    last.level === line.level &&
+    last.group === line.group;
 export const stepDuration = (seconds) => {
     const whole = Math.max(0, Math.round(seconds));
     if (whole < 60) {
@@ -23,6 +39,7 @@ export class LogBuffer {
         this.lines = [];
         this.dropped = 0;
         this.limit = 0;
+        this.collapse = false;
         this.parse = undefined;
         this.steps = [];
         this.openStep = undefined;
@@ -60,7 +77,10 @@ export class LogBuffer {
         return finished;
     }
     replace(lines) {
-        this.lines = [...lines];
+        this.lines = [];
+        for (const line of lines) {
+            this.add(line);
+        }
         this.dropped = 0;
         this.partial = '';
         this.returned = false;
@@ -72,6 +92,10 @@ export class LogBuffer {
         this.stepStarted = undefined;
         this.trim();
     }
+    push(line) {
+        this.add(line);
+        this.trim();
+    }
     clear() {
         this.replace([]);
     }
@@ -126,7 +150,7 @@ export class LogBuffer {
                     this.stepEnded = at ?? this.stepEnded;
                 }
                 this.runs.set(line, line.text === raw ? flow.runs : parseAnsi(line.text, this.lineStyle).runs);
-                this.lines.push(line);
+                this.add(line);
             }
         }
         this.lineStyle = flow.style;
@@ -166,6 +190,19 @@ export class LogBuffer {
         this.steps = this.steps.map((each, place) => (place === index ? closed : each));
         this.openStep = undefined;
     }
+    add(line) {
+        const last = this.lines.at(-1);
+        if (!this.collapse || !last || !repeats(line, last)) {
+            this.lines.push(line);
+            return;
+        }
+        const folded = { ...last, count: (last.count ?? 1) + (line.count ?? 1) };
+        const runs = this.runs.get(last);
+        if (runs) {
+            this.runs.set(folded, runs);
+        }
+        this.lines[this.lines.length - 1] = folded;
+    }
     trim() {
         const over = this.limit > 0 ? this.lines.length - this.limit : 0;
         if (over > 0) {

package/dist/log/index.d.ts

@@ -1,5 +1,5 @@
 export { type LogRun, type LogStyle, parseAnsi, stripAnsi } from './ansi.js';
-export type { LogGroup, LogLevel, LogLine, LogParsed, LogParser, LogStatus } from './buffer.js';
+export { type LogGroup, type LogLevel, type LogLine, type LogParsed, type LogParser, type LogStatus, levelSaid, } from './buffer.js';
 export { HelixHeadlessLogGroup } from './group/log-group.js';
 export { HelixHeadlessLogLine, type LogTimes } from './line/log-line.js';
 export { parseGitHubActions, parseVercel } from './parsers.js';

package/dist/log/index.js

@@ -1,4 +1,5 @@
 export { parseAnsi, stripAnsi } from './ansi.js';
+export { levelSaid, } from './buffer.js';
 export { HelixHeadlessLogGroup } from './group/log-group.js';
 export { HelixHeadlessLogLine } from './line/log-line.js';
 export { parseGitHubActions, parseVercel } from './parsers.js';

package/dist/log/line/log-line.d.ts

@@ -13,8 +13,10 @@ export type LogTimes = 'absolute' | 'relative';
  * 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.
+ * `error` lines apart. A line at `debug`, `warn` or `error` says its level in
+ * words before its text, so a reader moving through the log hears it as well
+ * as the color shows it. The text is the line's own content, so you can mark
+ * it up yourself.
  *
  * @since 0.200.0
  * @status experimental
@@ -22,6 +24,9 @@ export type LogTimes = 'absolute' | 'relative';
  *
  * @slot - The text of the line.
  *
+ * @csspart count - How many times a line written again straight after itself was written, where the log's `collapse` folds repeats. Hidden from screen readers, which hear `count-label`.
+ * @csspart count-label - What a screen reader hears for the count, such as "3 times". Visually hidden in the styled tier.
+ * @csspart level - What a screen reader hears before the text for a line at `debug`, `warn` or `error`, such as "Warning:". Visually hidden in the styled tier.
  * @csspart line - The row the number, the time, and the text sit in.
  * @csspart line-debug - The row of a line at `debug`.
  * @csspart line-error - The row of a line at `error`.
@@ -43,7 +48,7 @@ export type LogTimes = 'absolute' | 'relative';
  * @cssproperty --log-run-background-color - Written on a `run` with a background, in the same form as `--log-run-color`.
  * @cssproperty --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.
  *
- * @cssstate filtered - The log's `query` does not match the line, so it draws nothing.
+ * @cssstate filtered - The log's `query` does not match the line, or its `level` is quieter than the log shows, so it draws nothing.
  */
 export declare class HelixHeadlessLogLine extends HelixElement {
     /** The key this family's words are registered under, its styled tag. */
@@ -52,8 +57,18 @@ export declare class HelixHeadlessLogLine extends HelixElement {
     at: number | string;
     /** How much the line matters. Absent is `info`. */
     level?: LogLevel;
+    /**
+     * What a screen reader hears before the text of a line at each level, for a
+     * page in another language, keyed by level, such as `{ warn: 'Warnung:' }`.
+     * A line at `info` or `log` hears nothing extra, and nor does a line whose
+     * text already starts with its words, such as `Error: Cannot find module`.
+     * As an attribute it is that object as JSON.
+     */
+    levelWords: Partial<Record<LogLevel, string>>;
     /** What a screen reader hears for the link on a line's number. `{number}` is the number. */
     lineLabel: string;
+    /** @internal Set by the log: how many times the line was written in a row, where `collapse` folds repeats. */
+    logCount: number;
     /** @internal Set by the log: whether the query hides the line. */
     logFiltered: boolean;
     /** @internal Set by the log: whether the line belongs to a step. */
@@ -80,11 +95,23 @@ export declare class HelixHeadlessLogLine extends HelixElement {
     logTimes: '' | LogTimes;
     /** @internal Set by the log: the text as styled runs, for a line drawn from data. */
     runs: readonly LogRun[] | undefined;
+    /**
+     * What a screen reader hears after a line written more than once in a row.
+     * `{count}` is how many times, in the locale.
+     */
+    timesLabel: string;
     /**
      * @internal Read by the log to find its lines among its children and inside
      * its groups, which is cheaper than `instanceof`.
      */
     readonly isLogLine = true;
+    /**
+     * How the text a page wrote starts, so a line whose text already says its
+     * level does not hear it twice. Read from the second update on, which a log
+     * asks for once it has hydrated, as the server has no children to read and
+     * the first render is the server's.
+     */
+    private written;
     protected willUpdate(changed: PropertyValues): void;
     /**
      * The number: a link where the log gave `line-href`, a button where the log
@@ -116,6 +143,10 @@ export declare class HelixHeadlessLogLine extends HelixElement {
      * ink.
      */
     private renderRuns;
+    /** The count of a folded line, shown as a number and heard as words. */
+    private renderCount;
+    /** Reads the new text where the line says a level, which it may already say. */
+    private readonly handleSlot;
     protected render(): TemplateResult | typeof nothing;
 }
 declare global {

package/dist/log/line/log-line.js

@@ -1,8 +1,8 @@
 import { __decorate } from "tslib";
-import { customElement, formatWords, HelixElement, words, wordsLocale, } from '@fusion.dev/helix-core';
+import { customElement, formatWords, HelixElement, words, wordsConverter, wordsLocale, } from '@fusion.dev/helix-core';
 import { html, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
-import { timeOf } from '../buffer.js';
+import { levelSaid, timeOf } from '../buffer.js';
 import { markMatches } from '../rows.js';
 const NAME = /^[a-z-]+$/;
 const elapsed = (seconds) => {
@@ -16,7 +16,13 @@ let HelixHeadlessLogLine = class HelixHeadlessLogLine extends HelixElement {
     constructor() {
         super(...arguments);
         this.at = '';
+        this.levelWords = {
+            debug: 'Debug:',
+            error: 'Error:',
+            warn: 'Warning:',
+        };
         this.lineLabel = 'Line {number}';
+        this.logCount = 1;
         this.logFiltered = false;
         this.logGrouped = false;
         this.logHref = '';
@@ -30,12 +36,22 @@ let HelixHeadlessLogLine = class HelixHeadlessLogLine extends HelixElement {
         this.logStop = false;
         this.logTimes = '';
         this.runs = undefined;
+        this.timesLabel = '{count} times';
         this.isLogLine = true;
+        this.written = '';
+        this.handleSlot = () => {
+            if (this.level !== undefined && this.levelWords[this.level]) {
+                this.requestUpdate();
+            }
+        };
     }
     static { this.words = 'helix-log'; }
     willUpdate(changed) {
         super.willUpdate(changed);
         this.toggleState('filtered', this.logFiltered);
+        if (this.hasUpdated && !this.runs) {
+            this.written = (this.textContent ?? '').trimStart().slice(0, 40);
+        }
     }
     renderNumber() {
         if (!this.logNumbers || this.logNumber <= 0) {
@@ -83,7 +99,7 @@ let HelixHeadlessLogLine = class HelixHeadlessLogLine extends HelixElement {
         return html `<time part="time" datetime=${new Date(time).toISOString()}>${reads}</time>`;
     }
     renderText() {
-        return html `<slot>${this.runs ? this.renderRuns() : nothing}</slot>`;
+        return html `<slot @slotchange=${this.handleSlot}>${this.runs ? this.renderRuns() : nothing}</slot>`;
     }
     renderRuns() {
         return markMatches(this.runs ?? [], this.logQuery).map((piece) => {
@@ -106,14 +122,23 @@ let HelixHeadlessLogLine = class HelixHeadlessLogLine extends HelixElement {
             return piece.match ? html `<mark part="match">${run}</mark>` : run;
         });
     }
+    renderCount() {
+        if (this.logCount < 2) {
+            return nothing;
+        }
+        return html ` <span part="count" aria-hidden="true">${this.logCount}</span><span part="count-label"
+        >${formatWords(this, 'timesLabel', { count: this.logCount })}</span
+      >`;
+    }
     render() {
         if (this.logFiltered) {
             return nothing;
         }
         const level = this.level;
+        const said = levelSaid(level === undefined ? undefined : this.levelWords[level], this.runs ? this.runs.map((run) => run.text).join('') : this.written);
         return html `<div
-      part="line${level ? { debug: ' line-debug', error: ' line-error', info: '', warn: ' line-warn' }[level] : ''}${this.logMarked ? ' line-marked' : ''}${this.logSelected ? ' line-selected' : ''}${this.logGrouped ? ' line-grouped' : ''}"
-    >${this.renderNumber()}${this.renderTime()}<span part="text">${this.renderText()}</span></div>`;
+      part="line${level ? { debug: ' line-debug', error: ' line-error', info: '', log: '', warn: ' line-warn' }[level] : ''}${this.logMarked ? ' line-marked' : ''}${this.logSelected ? ' line-selected' : ''}${this.logGrouped ? ' line-grouped' : ''}"
+    >${this.renderNumber()}${this.renderTime()}${said ? html `<span part="level">${said} </span>` : nothing}<span part="text">${this.renderText()}</span>${this.renderCount()}</div>`;
     }
 };
 __decorate([
@@ -122,10 +147,17 @@ __decorate([
 __decorate([
     property({ reflect: true })
 ], HelixHeadlessLogLine.prototype, "level", void 0);
+__decorate([
+    words,
+    property({ attribute: 'level-words', converter: wordsConverter })
+], HelixHeadlessLogLine.prototype, "levelWords", void 0);
 __decorate([
     words,
     property({ attribute: 'line-label' })
 ], HelixHeadlessLogLine.prototype, "lineLabel", void 0);
+__decorate([
+    property({ attribute: false })
+], HelixHeadlessLogLine.prototype, "logCount", void 0);
 __decorate([
     property({ attribute: false })
 ], HelixHeadlessLogLine.prototype, "logFiltered", void 0);
@@ -165,6 +197,10 @@ __decorate([
 __decorate([
     property({ attribute: false })
 ], HelixHeadlessLogLine.prototype, "runs", void 0);
+__decorate([
+    words,
+    property({ attribute: 'times-label' })
+], HelixHeadlessLogLine.prototype, "timesLabel", void 0);
 HelixHeadlessLogLine = __decorate([
     customElement('helix-headless-log-line')
 ], HelixHeadlessLogLine);

package/dist/log/root/log-root.d.ts

@@ -1,6 +1,6 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
-import { type LogGroup, type LogLine, type LogParser } from '../buffer.js';
+import { type LogGroup, type LogLevel, type LogLine, type LogParser } from '../buffer.js';
 import type { LogTimes } from '../line/log-line.js';
 /** Text a log reads as it arrives: a stream, or anything `for await` reads. */
 export type LogSource = AsyncIterable<string | Uint8Array> | ReadableStream<string | Uint8Array>;
@@ -117,9 +117,12 @@ declare const HelixHeadlessLog_base: (new (...args: any[]) => import("@fusion.de
  * @csspart group-summary-running - The button of a step drawn from `groups` that is `running`.
  * @csspart group-summary-skipped - The button of a step drawn from `groups` that was `skipped`.
  * @csspart line - The row of a line drawn from data.
+ * @csspart line-count - How many times a folded line was written, under `collapse`. Hidden from screen readers, which hear `line-count-label`.
+ * @csspart line-count-label - What a screen reader hears for a folded line's count, such as "3 times". Visually hidden in the styled tier.
  * @csspart line-debug - The row of a line drawn from data at `debug`.
  * @csspart line-error - The row of a line drawn from data at `error`.
  * @csspart line-grouped - The row of a line drawn from data that belongs to a step.
+ * @csspart line-level - What a screen reader hears before the text of a line drawn from data at `debug`, `warn` or `error`. Visually hidden in the styled tier.
  * @csspart line-marked - The row of a line drawn from data that `mark-lines` names.
  * @csspart line-match - Text in a line drawn from data that matches `query`.
  * @csspart line-number - The number of a line drawn from data.
@@ -164,7 +167,7 @@ declare const HelixHeadlessLog_base: (new (...args: any[]) => import("@fusion.de
  *
  * @cssstate done - The run is over: `done` is set, or `source` ended.
  * @cssstate empty - The log has no lines.
- * @cssstate filtered - `query` is set, so only matching lines are shown.
+ * @cssstate filtered - `query` or `level` is set, so only the lines they keep are shown.
  * @cssstate pinned - The log follows its newest line.
  */
 export declare class HelixHeadlessLog extends HelixHeadlessLog_base {
@@ -176,6 +179,13 @@ export declare class HelixHeadlessLog extends HelixHeadlessLog_base {
     static words: string;
     /** How tall a row is assumed to be before one has been drawn, in pixels. */
     static readonly ESTIMATE = 20;
+    /**
+     * Folds a line written again straight after itself into it, with a count,
+     * as a browser's console does, so a loop writing one warning a thousand
+     * times is one line. For lines written or given as data, read as they
+     * arrive; numbers, `line-href` and the selection count a folded line once.
+     */
+    collapse: boolean;
     /**
      * Whether the log opens following its newest line, when `pinned` is not set.
      * `default-pinned="false"` opens it where it starts.
@@ -202,6 +212,7 @@ export declare class HelixHeadlessLog extends HelixHeadlessLog_base {
     errorLabel: string;
     /** The log's name, read by screen readers, where `label` is empty. */
     fallbackLabel: string;
+    set format(next: 'github-actions' | 'vercel' | undefined);
     /**
      * The format written text is in, read with a parser Helix ships:
      * `github-actions` reads a GitHub Actions log's workflow commands into steps
@@ -209,7 +220,6 @@ export declare class HelixHeadlessLog extends HelixHeadlessLog_base {
      * reads none. `parse` wins over it.
      */
     get format(): 'github-actions' | 'vercel' | undefined;
-    set format(next: 'github-actions' | 'vercel' | undefined);
     /**
      * What a screen reader hears when a step finishes or fails. `{heading}` is
      * the step's heading and `{status}` is `done` or `failed`.
@@ -225,6 +235,13 @@ export declare class HelixHeadlessLog extends HelixHeadlessLog_base {
     groups: readonly LogGroup[];
     /** The log's name, read by screen readers. */
     label: string;
+    /**
+     * The quietest level shown: `info` hides `debug` and `log` lines, `warn`
+     * shows warnings and errors, and `error` errors only. Unset shows every line.
+     * Lines it hides are kept, so lowering it shows them again, and a step shows
+     * while it holds a line that shows.
+     */
+    level?: LogLevel;
     /**
      * 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.
@@ -382,6 +399,13 @@ export declare class HelixHeadlessLog extends HelixHeadlessLog_base {
      * after the last one is the line still being written.
      */
     write(chunk: string): void;
+    /**
+     * Adds one line as data, after the lines the log holds: its text, and its
+     * level, time and group where it has them. For lines that arrive one at a
+     * time with a level of their own, such as a console's, where `write` takes
+     * text.
+     */
+    writeLine(line: LogLine): void;
     /**
      * Lets every line go, and forgets which groups the reader opened, keeping
      * `groups`, `parse`, and `limit`.