@fusion.dev/helix-headless 0.212.2 → 0.214.0

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`.

package/dist/log/root/log-root.js

@@ -9,7 +9,7 @@ import { repeat } from 'lit/directives/repeat.js';
 import { html } from 'lit/static-html.js';
 import { lineRuns } from '../../code-block/lines.js';
 import { stripAnsi } from '../ansi.js';
-import { LogBuffer, timeOf, } from '../buffer.js';
+import { LogBuffer, loudEnough, timeOf, } from '../buffer.js';
 import { LOG_FORMATS } from '../parsers.js';
 import { logRows } from '../rows.js';
 const STATUS_NAMES = {
@@ -24,6 +24,7 @@ const inRuns = (runs, number) => runs.some(([first, last]) => number >= first &&
 let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixElement) {
     constructor() {
         super(...arguments);
+        this.collapse = false;
         this.defaultPinned = true;
         this.doneLabel = 'Finished';
         this.droppedLabel = '{count, plural, one {# earlier line is} other {# earlier lines are}} not kept';
@@ -199,15 +200,15 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
         this.doneState = next;
         this.requestUpdate('done', previous);
     }
-    get format() {
-        return this.formatValue;
-    }
     set format(next) {
         const previous = this.formatValue;
         this.formatValue = next;
         this.buffer.parse = this.parseValue ?? this.formatParser;
         this.requestUpdate('format', previous);
     }
+    get format() {
+        return this.formatValue;
+    }
     get lines() {
         return this.buffer.lines;
     }
@@ -292,6 +293,10 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
         this.buffer.write(chunk);
         this.requestUpdate();
     }
+    writeLine(line) {
+        this.buffer.push(line);
+        this.requestUpdate();
+    }
     clear() {
         this.buffer.clear();
         this.opened.clear();
@@ -519,7 +524,8 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
         const start = this.childLines.map((line) => timeOf(line.at)).find((time) => time !== undefined);
         const stop = this.interactive ? this.stopAmong(this.reachable()) : 0;
         this.childLines.forEach((line, at) => {
-            const filtered = needle !== '' && !(line.textContent ?? '').toLowerCase().includes(needle);
+            const filtered = (needle !== '' && !(line.textContent ?? '').toLowerCase().includes(needle)) ||
+                !loudEnough(line.level, this.level);
             whenHydrated(line, () => {
                 line.logNumber = at + 1;
                 line.logNumbers = this.lineNumbers;
@@ -533,7 +539,7 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
                 line.logStop = at + 1 === stop;
                 line.logGrouped = this.childGroups.some((group) => group.contains(line));
             });
-            if (!filtered && needle !== '') {
+            if (!filtered && (needle !== '' || this.level !== undefined)) {
                 for (const group of this.childGroups) {
                     if (!group.open && group.contains(line)) {
                         whenHydrated(group, () => {
@@ -719,6 +725,7 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
         this.lastGroups = this.allGroups;
         if (changed.has('limit')) {
             this.buffer.limit = Math.max(0, Math.floor(this.limit || 0));
+            this.buffer.collapse = this.collapse;
             this.buffer.write('');
         }
         if (!this.fed) {
@@ -742,6 +749,7 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
             this.view = logRows({
                 current: this.buffer.current(),
                 groups: this.allGroups,
+                level: this.level,
                 lines: this.buffer.lines,
                 open: (id) => this.isOpen(id),
                 query: this.query,
@@ -753,7 +761,7 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
         }
         this.toggleState('pinned', this.pinned);
         this.toggleState('done', this.done);
-        this.toggleState('filtered', this.query.trim() !== '');
+        this.toggleState('filtered', this.query.trim() !== '' || this.level !== undefined);
         this.toggleState('empty', this.childrenKnown && !this.fed && this.childLines.length === 0);
     }
     updated(changed) {
@@ -798,7 +806,8 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
         const line = this.tag('log-line');
         const { at, level } = row.line;
         return html `<${line}
-      exportparts="line, line-debug, line-error, line-grouped, line-marked, line-selected, line-warn, match: line-match,
+      exportparts="line, line-debug, line-error, line-grouped, line-marked, line-selected, line-warn, count: line-count,
+        count-label: line-count-label, level: line-level, match: line-match,
         number: line-number, run: line-run, run-bold: line-run-bold, run-dim: line-run-dim,
         run-italic: line-run-italic, run-strike: line-run-strike, run-underline: line-run-underline,
         text: line-text, time: line-time"
@@ -813,6 +822,7 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
       .logSelectable=${this.selectable}
       .logSelected=${this.selected(row.number)}
       .logStop=${row.number === stop}
+      .logCount=${row.line.count ?? 1}
       .logGrouped=${row.line.group !== undefined}
       .logStart=${start}
       .logTimes=${this.timestamps ?? ''}
@@ -884,6 +894,9 @@ let HelixHeadlessLog = class HelixHeadlessLog extends MixinCollection(HelixEleme
       </div>`;
     }
 };
+__decorate([
+    property({ type: Boolean })
+], HelixHeadlessLog.prototype, "collapse", void 0);
 __decorate([
     property({ attribute: 'default-pinned', converter: onUnlessFalse })
 ], HelixHeadlessLog.prototype, "defaultPinned", void 0);
@@ -923,6 +936,9 @@ __decorate([
 __decorate([
     property()
 ], HelixHeadlessLog.prototype, "label", void 0);
+__decorate([
+    property()
+], HelixHeadlessLog.prototype, "level", void 0);
 __decorate([
     property({ converter: numberConverter('limit', 0) })
 ], HelixHeadlessLog.prototype, "limit", void 0);

package/dist/log/rows.d.ts

@@ -1,5 +1,5 @@
 import { type LogRun } from './ansi.js';
-import type { LogGroup, LogLine } from './buffer.js';
+import { type LogGroup, type LogLevel, type LogLine } from './buffer.js';
 /** One row of a log drawn from data: a line, or the heading of a group. */
 export type LogRow = {
     /** The group, as `groups` holds it. */
@@ -27,6 +27,8 @@ export interface LogRowsInput {
     groups: readonly LogGroup[];
     /** The finished lines, oldest first. */
     lines: readonly LogLine[];
+    /** The quietest level shown, or undefined for every level. */
+    level?: LogLevel | undefined;
     /** Whether a group shows its lines. */
     open: (id: string) => boolean;
     /** Text a line has to hold to be shown, ignoring case. Empty shows every line. */
@@ -47,7 +49,7 @@ export interface LogRowsInput {
  * where it is rather than hidden by the fold. A group with no match is left
  * out, heading and all.
  */
-export declare const logRows: ({ current, groups, lines, open, query, start }: LogRowsInput) => LogRows;
+export declare const logRows: ({ current, groups, level, lines, open, query, start, }: LogRowsInput) => LogRows;
 /** A run, and whether it is part of a match. */
 export interface LogPiece extends LogRun {
     /** Whether the text matches the search. */

package/dist/log/rows.js

@@ -1,4 +1,5 @@
 import { stripAnsi } from './ansi.js';
+import { loudEnough } from './buffer.js';
 const plain = new WeakMap();
 const holds = (line, needle) => {
     if (needle === '') {
@@ -11,12 +12,15 @@ const holds = (line, needle) => {
     }
     return text.includes(needle);
 };
-export const logRows = ({ current, groups, lines, open, query, start }) => {
+export const logRows = ({ current, groups, level, lines, open, query, start, }) => {
     const needle = query.trim().toLowerCase();
     const byId = new Map(groups.map((group) => [group.id, group]));
     const all = current ? [...lines, current] : lines;
     const hits = new Set();
-    const matches = needle === '' ? undefined : all.map((line) => holds(line, needle));
+    const filtering = needle !== '' || level !== undefined;
+    const matches = filtering
+        ? all.map((line) => holds(line, needle) && loudEnough(line.level, level))
+        : undefined;
     let matched = 0;
     if (matches) {
         all.forEach((line, index) => {
@@ -35,22 +39,22 @@ export const logRows = ({ current, groups, lines, open, query, start }) => {
         const group = line.group === undefined ? undefined : byId.get(line.group);
         if (group && !placed.has(group.id)) {
             placed.add(group.id);
-            if (needle === '' || hits.has(group.id)) {
-                rows.push({ group, kind: 'group', open: needle !== '' || open(group.id) });
+            if (!filtering || hits.has(group.id)) {
+                rows.push({ group, kind: 'group', open: filtering || open(group.id) });
             }
         }
-        const shown = group === undefined || needle !== '' || open(group.id);
+        const shown = group === undefined || filtering || open(group.id);
         if (shown && (matches?.[index] ?? true)) {
             rows.push({ kind: 'line', line, number: start + index + 1 });
         }
     }
-    if (needle === '') {
+    if (!filtering) {
         const last = groups.findLastIndex((group) => placed.has(group.id));
         for (const group of groups.slice(last + 1)) {
             rows.push({ group, kind: 'group', open: open(group.id) });
         }
     }
-    return { matched: needle === '' ? all.length : matched, rows };
+    return { matched: filtering ? matched : all.length, rows };
 };
 export const markMatches = (runs, query) => {
     const needle = query.trim().toLowerCase();

package/dist/terminal/keys.d.ts

@@ -1,6 +1,6 @@
 import { type ChordPress } from '@fusion.dev/helix-core';
 /** What a terminal frame does with a key press before the program sees it. */
-export type TerminalShortcut = 'copy' | 'find' | 'tab-focus';
+export type TerminalShortcut = 'copy' | 'find' | 'paste' | 'tab-focus';
 /** The chord for a shortcut on this keyboard, or `undefined` where the frame takes none. */
 export declare const chordOf: (shortcut: TerminalShortcut, apple: boolean) => string | undefined;
 /** Which shortcut a press is, or `null` for a press the program should have. */