@fusion.dev/helix-headless 0.208.0 → 0.209.0

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

@@ -0,0 +1,489 @@
+import { HelixElement, type TerminalResizeDetail } from '@fusion.dev/helix-core';
+import { nothing, type PropertyValues, type TemplateResult } from 'lit';
+import '../../button/index.js';
+import '../../icon-button/index.js';
+import '../../toolbar/index.js';
+/** How a search through a terminal's output moves. */
+export interface TerminalFindOptions {
+    /** Toward the top of the output, for the previous match. */
+    backward: boolean;
+    /** Whether the search is the reader still typing, which stays on the match it has where it still matches. */
+    incremental: boolean;
+}
+/** What the frame asks of whatever draws the terminal, as the frame's settings stand. */
+export interface TerminalSettings {
+    /** The grid's width in cells, or `undefined` for as many as fit the frame. */
+    columns: number | undefined;
+    /** Whether the cursor is drawn, which it is not while `readonly`. */
+    cursor: boolean;
+    /** Whether the reader's keys reach the program: not while `readonly`, and not once its process has exited. */
+    input: boolean;
+    /** The grid's height in lines, or `undefined` for as many as fit the frame. */
+    rows: number | undefined;
+    /** Whether the renderer keeps an accessible copy of the grid and says new output. */
+    screenReader: boolean;
+}
+/**
+ * What draws a terminal for the frame: `connectTerminal` from
+ * `@fusion.dev/helix-terminal` builds one from a driver, and a page drawing its
+ * own terminal hands the frame its own.
+ *
+ * `write` is the one method it must have. Each other one turns on what it is
+ * named for, and the frame leaves out the control a renderer cannot answer.
+ */
+export interface TerminalRenderer {
+    /** Clears the scrollback, keeping the line the cursor is on. */
+    clear?(): void;
+    /** Searches the output for `query` and highlights the matches, reporting them through `found`. */
+    find?(query: string, options: TerminalFindOptions): void;
+    /** Takes the highlights off once the find bar closes. */
+    findEnd?(): void;
+    /** Focuses the renderer's input. */
+    focus?(): void;
+    /** The element that takes the reader's keys, which the frame names. */
+    input?(): HTMLElement | null | undefined;
+    /** Inputs text as a paste does, in bracketed paste mode where the program asked for it. */
+    paste?(text: string): void;
+    /** Resets the emulator: its modes, its colors, and its screen. */
+    reset?(): void;
+    /** The text selected in the grid, or an empty string. */
+    selection?(): string;
+    /** Applies the frame's settings. Called when attached and whenever one changes. */
+    settings?(settings: TerminalSettings): void;
+    /** The grid as plain text: the lines on screen, or every line the scrollback holds. */
+    text?(scope: 'all' | 'screen'): string;
+    /** Writes the program's output, and calls `done` once it has been parsed. */
+    write(data: string | Uint8Array, done: () => void): void;
+}
+/** A color the frame reads, by the name a renderer's theme gives it. */
+export type TerminalColorName = 'activeMatch' | 'activeMatchBorder' | 'background' | 'black' | 'blue' | 'brightBlack' | 'brightBlue' | 'brightCyan' | 'brightGreen' | 'brightMagenta' | 'brightRed' | 'brightWhite' | 'brightYellow' | 'cursor' | 'cyan' | 'foreground' | 'green' | 'magenta' | 'match' | 'red' | 'scrollbar' | 'selection' | 'white' | 'yellow';
+/**
+ * The colors and the face the terminal is to be drawn in, as the `--terminal-*`
+ * properties where the frame is resolve them: each color as the browser
+ * computed it, and none for a property nothing set.
+ */
+export interface TerminalLook {
+    colors: Partial<Record<TerminalColorName, string>>;
+    /** The viewport's face, which the grid's cells are measured in. */
+    font: {
+        family: string;
+        size: number;
+    } | undefined;
+}
+/** What the frame gives back to whatever it is attached to: how a renderer tells the frame what happened. */
+export interface TerminalSink {
+    /** The program rang the bell. */
+    bell(): void;
+    /** Detaches the renderer, which the frame stops writing to and asking. */
+    detach(): void;
+    /** A search found `count` matches, the one at `index` current, counting from `0`, or `-1` for none. */
+    found(index: number, count: number): void;
+    /** The reader typed or pasted `data`, encoded for the program. */
+    input(data: string, binary?: boolean): void;
+    /** A link in the output was activated. */
+    link(href: string): void;
+    /** The grid changed size. */
+    resized(size: TerminalResizeDetail): void;
+    /** Whether any text is selected now, which the copy control follows. */
+    selected(any: boolean): void;
+    /** The program set its title. */
+    title(title: string): void;
+}
+/**
+ * @summary A frame around a terminal emulator that runs a shell you connect.
+ *
+ * @description
+ * Wraps a terminal drawn by xterm.js or another emulator. The frame adds a
+ * header with the terminal's name and its controls, a find bar, and a status
+ * line. `connectTerminal` in `@fusion.dev/helix-terminal` connects it to the
+ * emulator and draws the terminal in the colors the `--terminal-*` properties
+ * set, which the styled tier sets from your theme. Helix does not start a
+ * process: you connect the stream. Write the program's output with `write()`, send what the
+ * reader types to the process from `helix-terminal-input`, and resize the
+ * process's pseudo-terminal from `helix-terminal-resize`.
+ *
+ * Output written before a renderer is connected is held and written first, so
+ * the process can start before the emulator loads. `write()` resolves once
+ * the renderer has parsed the output, which is how a page pauses a process
+ * that writes faster than the terminal draws.
+ *
+ * The controls are a row in the header, and `controls` names which ones:
+ * `find`, `copy`, `clear`, and `fullscreen`. `find clear` by default. A control
+ * the renderer cannot answer is left out once it is connected. Set `exit-code`
+ * when the process exits: the frame says how it exited, stops sending input,
+ * and shows a Restart button that sends `helix-terminal-restart`.
+ *
+ * **Keyboard.** Every key goes to the program, Tab, Shift+Tab, and Escape
+ * included, except these:
+ *
+ * - Control+Shift+F, or Command+F on a Mac, opens the find bar. Enter and
+ *   Shift+Enter move between the matches, and Escape closes the bar and
+ *   returns focus to the terminal.
+ * - Control+Shift+C copies the selection. On a Mac, Command+C does.
+ * - Control+M, or Control+Shift+M on a Mac, switches Tab between typing in the
+ *   terminal and moving focus out of it. The status line says when Tab moves
+ *   focus, and the terminal's input describes the key to a screen reader.
+ *
+ * **Screen readers.** A terminal draws its grid as a picture of text, so a
+ * screen reader reads nothing in it by default. Set `screen-reader-mode` to
+ * have the renderer keep the grid as lines a screen reader can move through
+ * and announce new output as it arrives, which xterm.js calls screen reader
+ * mode. It costs time on every write, so it is off by default: connect it to
+ * a setting your reader can turn on.
+ *
+ * @since 0.209.0
+ * @status experimental
+ * @category media
+ * @aliases Terminal emulator, Shell, xterm
+ * @documentation https://fusion.dev/helix/components/terminal
+ *
+ * @slot - The element your renderer draws the terminal in.
+ * @slot actions - Controls of your own in the header, before the built-in ones, such as a button that splits the pane.
+ * @slot clear-icon - Replaces the glyph inside the clear button.
+ * @slot copy-icon - Replaces the glyph inside the copy button.
+ * @slot exit-actions - Controls of your own beside Restart, shown once the process exits, such as a button that opens the whole log.
+ * @slot find-actions - Controls of your own in the find bar, between the count and the buttons that move between matches.
+ * @slot find-close-icon - Replaces the glyph inside the button that closes the find bar.
+ * @slot find-icon - Replaces the glyph inside the find button.
+ * @slot find-next-icon - Replaces the glyph inside the next match button.
+ * @slot find-previous-icon - Replaces the glyph inside the previous match button.
+ * @slot fullscreen-icon - Replaces the glyph inside the fullscreen button.
+ * @slot label - The terminal's name in the header, such as an icon beside the shell's name. Replaces `label` there.
+ * @slot restart-icon - Replaces the glyph inside the Restart button.
+ *
+ * @event {HelixCopyEvent} helix-copy - The copy control or its key put the selection on the clipboard.
+ * @event {HelixTerminalBellEvent} helix-terminal-bell - The program rang the bell. The frame flashes once.
+ * @event {HelixTerminalInputEvent} helix-terminal-input - The reader typed or pasted, with `data` encoded for the program. Write it to the process. Not sent while `readonly`, or once `exit-code` is set.
+ * @event {HelixTerminalLinkEvent} helix-terminal-link - A link in the output was activated, with its `href`. Cancelable: cancel it to open the link yourself. Left alone, a web address opens in a new tab.
+ * @event {HelixTerminalResizeEvent} helix-terminal-resize - The grid changed size, with `columns`, `rows`, `width`, and `height`. Resize the process's pseudo-terminal to match.
+ * @event {HelixTerminalRestartEvent} helix-terminal-restart - The Restart button was pressed after the process exited. Start a new process and clear `exit-code`.
+ * @event {HelixTerminalTitleEvent} helix-terminal-title - The program set its title, with `title`. The frame keeps its own `label`.
+ *
+ * @csspart actions - The `actions` slot, first in the header's toolbar.
+ * @csspart clear - The button that clears the scrollback.
+ * @csspart clear-button - The clear button's inner button.
+ * @csspart clear-live - The clear button's live region, which speaks while the button is pending.
+ * @csspart clear-spinner - The ring the clear button turns while it is pending.
+ * @csspart clear-text - The box the clear button's icon sits in.
+ * @csspart controls - The toolbar at the end of the header: your actions, then the built-in buttons, one tab stop that the arrows move along.
+ * @csspart controls-toolbar - The box inside the header's toolbar that lays its buttons out.
+ * @csspart copy - The button that copies the selection. Disabled while nothing is selected.
+ * @csspart copy-button - The copy button's inner button.
+ * @csspart copy-live - The copy button's live region, which speaks while the button is pending.
+ * @csspart copy-spinner - The ring the copy button turns while it is pending.
+ * @csspart copy-text - The box the copy button's icon sits in.
+ * @csspart exit-actions - The `exit-actions` slot, beside Restart in the status line.
+ * @csspart find - The button that opens and closes the find bar. Expanded while it is open.
+ * @csspart find-actions - The `find-actions` slot, first in the find bar's toolbar.
+ * @csspart find-bar - The bar under the header where the reader searches the output.
+ * @csspart find-button - The find button's inner button.
+ * @csspart find-close - The button that closes the find bar.
+ * @csspart find-close-button - The find bar's close button's inner button.
+ * @csspart find-close-live - The find bar's close button's live region, which speaks while the button is pending.
+ * @csspart find-close-spinner - The ring the find bar's close button turns while it is pending.
+ * @csspart find-close-text - The box the find bar's close button's icon sits in.
+ * @csspart find-controls - The toolbar at the end of the find bar: your find actions, then the buttons that move between matches and close the bar.
+ * @csspart find-controls-toolbar - The box inside the find bar's toolbar that lays its buttons out.
+ * @csspart find-count - Which match is current and how many there are, such as "3 of 12 matches".
+ * @csspart find-field - The search field in the find bar.
+ * @csspart find-live - The find button's live region, which speaks while the button is pending.
+ * @csspart find-next - The button that moves to the next match.
+ * @csspart find-next-button - The next match button's inner button.
+ * @csspart find-next-live - The next match button's live region, which speaks while the button is pending.
+ * @csspart find-next-spinner - The ring the next match button turns while it is pending.
+ * @csspart find-next-text - The box the next match button's icon sits in.
+ * @csspart find-previous - The button that moves to the previous match.
+ * @csspart find-previous-button - The previous match button's inner button.
+ * @csspart find-previous-live - The previous match button's live region, which speaks while the button is pending.
+ * @csspart find-previous-spinner - The ring the previous match button turns while it is pending.
+ * @csspart find-previous-text - The box the previous match button's icon sits in.
+ * @csspart find-spinner - The ring the find button turns while it is pending.
+ * @csspart find-text - The box the find button's icon sits in.
+ * @csspart fullscreen - The button that makes the terminal fill the screen. Pressed while it does.
+ * @csspart fullscreen-button - The fullscreen button's inner button.
+ * @csspart fullscreen-live - The fullscreen button's live region, which speaks while the button is pending.
+ * @csspart fullscreen-spinner - The ring the fullscreen button turns while it is pending.
+ * @csspart fullscreen-text - The box the fullscreen button's icon sits in.
+ * @csspart header - The strip above the terminal, with its name, your actions, and the controls.
+ * @csspart label - The terminal's name in the header.
+ * @csspart live - What screen readers hear after the frame acts: a match count, a copy, or a change to what Tab does. Visually hidden in the styled tier.
+ * @csspart region - The named group the terminal sits in.
+ * @csspart restart - The button in the status line that asks for a new process after the last one exited.
+ * @csspart restart-button - The Restart button's inner button.
+ * @csspart restart-live - The Restart button's live region, which speaks while the button is pending.
+ * @csspart restart-spinner - The ring the Restart button turns while it is pending.
+ * @csspart restart-text - The Restart button's label.
+ * @csspart status - The line under the terminal that says the process exited, or that Tab moves focus.
+ * @csspart viewport - The box the terminal is drawn in.
+ *
+ * @cssproperty --terminal-active-match-background-color - The ground of the current match of a search.
+ * @cssproperty --terminal-active-match-border-color - The edge of the current match of a search.
+ * @cssproperty --terminal-ansi-black - ANSI black, which codes `30` and `40` draw.
+ * @cssproperty --terminal-ansi-blue - ANSI blue, which codes `34` and `44` draw.
+ * @cssproperty --terminal-ansi-bright-black - ANSI bright black, which codes `90` and `100` draw.
+ * @cssproperty --terminal-ansi-bright-blue - ANSI bright blue, which codes `94` and `104` draw.
+ * @cssproperty --terminal-ansi-bright-cyan - ANSI bright cyan, which codes `96` and `106` draw.
+ * @cssproperty --terminal-ansi-bright-green - ANSI bright green, which codes `92` and `102` draw.
+ * @cssproperty --terminal-ansi-bright-magenta - ANSI bright magenta, which codes `95` and `105` draw.
+ * @cssproperty --terminal-ansi-bright-red - ANSI bright red, which codes `91` and `101` draw.
+ * @cssproperty --terminal-ansi-bright-white - ANSI bright white, which codes `97` and `107` draw.
+ * @cssproperty --terminal-ansi-bright-yellow - ANSI bright yellow, which codes `93` and `103` draw.
+ * @cssproperty --terminal-ansi-cyan - ANSI cyan, which codes `36` and `46` draw.
+ * @cssproperty --terminal-ansi-green - ANSI green, which codes `32` and `42` draw.
+ * @cssproperty --terminal-ansi-magenta - ANSI magenta, which codes `35` and `45` draw.
+ * @cssproperty --terminal-ansi-red - ANSI red, which codes `31` and `41` draw.
+ * @cssproperty --terminal-ansi-white - ANSI white, which codes `37` and `47` draw.
+ * @cssproperty --terminal-ansi-yellow - ANSI yellow, which codes `33` and `43` draw.
+ * @cssproperty --terminal-background-color - The ground of the grid.
+ * @cssproperty --terminal-color - The text of the grid where the program sets no color.
+ * @cssproperty --terminal-cursor-color - The cursor.
+ * @cssproperty --terminal-match-background-color - The ground of every match of a search but the current one.
+ * @cssproperty --terminal-scrollbar-thumb-color - The grid's scrollbar.
+ * @cssproperty --terminal-selection-background-color - The ground of selected text. See-through, so the text keeps its color.
+ *
+ * @cssstate bell - The program rang the bell, held for a moment for a visual bell.
+ * @cssstate exited - The process has exited, by `exit-code`.
+ * @cssstate find-open - The find bar is open.
+ * @cssstate fullscreen - The terminal fills the screen.
+ * @cssstate tab-moves-focus - Tab moves focus out of the terminal, after Control+M.
+ */
+export declare class HelixHeadlessTerminal extends HelixElement {
+    /**
+     * The key this family's words are registered under, its styled tag:
+     * `registerWords('de', { 'helix-terminal': { findLabel: 'Suchen' } })`.
+     */
+    static words: string;
+    /** The clear button's label. */
+    clearLabel: string;
+    /** The grid's width in character cells. Set it with `rows` to fix the grid's size; unset, the grid fills the frame. */
+    columns?: number | undefined;
+    /**
+     * Which built-in controls the header shows, as a list of `find`, `copy`,
+     * `clear`, and `fullscreen`, or `none`. Absent is `find clear`.
+     */
+    controls?: string;
+    /** The name of the row of controls, read by screen readers. */
+    controlsLabel: string;
+    /** What screen readers hear after a copy. */
+    copiedLabel: string;
+    /** The copy button's label. */
+    copyLabel: string;
+    /**
+     * How the process exited, which the page sets when it does. While it is set,
+     * the status line says it, the frame sends no input, and Restart is shown.
+     * Clear it when a new process starts.
+     */
+    exitCode?: number | undefined;
+    /**
+     * What the status line says once the process has exited. `{code}` is its
+     * exit code, written as the process gave it, and code `0` is a clean exit.
+     */
+    exitedLabel: string;
+    /** The terminal's name where `label` is empty and the host has no `aria-label`. */
+    fallbackLabel: string;
+    /** The label of the button that closes the find bar. */
+    findCloseLabel: string;
+    /** The name of the find bar's row of buttons, read by screen readers. */
+    findControlsLabel: string;
+    /** The find button's label, and the find field's name and placeholder. */
+    findLabel: string;
+    /** The next match button's label. */
+    findNextLabel: string;
+    /** The previous match button's label. */
+    findPreviousLabel: string;
+    /** The fullscreen button's label. */
+    fullscreenLabel: string;
+    /** The name of the element the reader types into, which the renderer draws. */
+    inputLabel: string;
+    /**
+     * The terminal's name, in the header and for screen readers, such as the
+     * shell or the folder it runs in. Several terminals on a page need names
+     * that tell them apart.
+     */
+    label: string;
+    /**
+     * What the find bar says of its matches. `{index}` is the current match,
+     * counting from 1, and `{count}` how many there are.
+     */
+    matchesLabel: string;
+    /**
+     * Draws the output and sends no input, with no cursor, for a transcript or
+     * a command an agent ran. The attribute is `readonly`, the platform's
+     * spelling.
+     */
+    readOnly: boolean;
+    /** The Restart button's label. */
+    restartLabel: string;
+    /** The grid's height in lines. Set it with `columns` to fix the grid's size; unset, the grid fills the frame. */
+    rows?: number | undefined;
+    /**
+     * Keeps the grid as lines a screen reader moves through, and says new
+     * output as it arrives. Off by default, since it costs time on every
+     * write. Connect it to a setting your reader can turn on.
+     */
+    screenReaderMode: boolean;
+    /** What the terminal's input describes to a screen reader. `{key}` is the key that switches Tab. */
+    tabHintLabel: string;
+    /** What the status line says while Tab moves focus. `{key}` is the key that switches it back. */
+    tabMovesFocusLabel: string;
+    /** What screen readers hear when Tab goes back to typing in the terminal. */
+    tabTypesLabel: string;
+    /** Whether the find bar is open. */
+    private findOpen;
+    /** What the find field holds. */
+    private query;
+    /** The current match, counting from `0`, or `-1` for none. */
+    private matchIndex;
+    /** How many matches the search found, or `undefined` before one ran. */
+    private matchCount;
+    /** Whether Tab moves focus, after Control+M. */
+    private tabMovesFocus;
+    /** Whether any text is selected in the grid. */
+    private anySelected;
+    /** Whether the page slotted controls of its own into the header. */
+    private hasActions;
+    /** Whether the page slotted a name of its own into the header. */
+    private hasLabel;
+    /** What the live region says now, and how many times something has been said. */
+    private announcement;
+    private said;
+    /** What draws the terminal, while one is attached. */
+    private renderer;
+    /** Output written before a renderer was attached, in order. */
+    private pending;
+    /** The attributes the frame wrote on the renderer's input, as they were before, to put back. */
+    private inputWas;
+    /** The wait before the bell's flash ends. */
+    private ringing;
+    private readonly copier;
+    /** Whether the terminal fills the screen. */
+    private filled;
+    private readonly fullscreen;
+    /**
+     * Writes the program's output. Resolves once the renderer has parsed it,
+     * which is how a page pauses a process that writes faster than the
+     * terminal draws. Output written before a renderer is attached is held and
+     * written first.
+     */
+    write(data: string | Uint8Array): Promise<void>;
+    /**
+     * Inputs text as a paste does, in bracketed paste mode where the program
+     * asked for it. It arrives as `helix-terminal-input`, like typed text.
+     */
+    paste(text: string): void;
+    /** Clears the scrollback, keeping the line the cursor is on. */
+    clear(): void;
+    /** Resets the emulator: its modes, its colors, and its screen. */
+    reset(): void;
+    /**
+     * The terminal as plain text, as the renderer drew it: the lines on screen,
+     * or with `all`, every line the scrollback holds. Empty before a renderer is
+     * attached.
+     */
+    text(scope?: 'all' | 'screen'): string;
+    /**
+     * The colors and the face the terminal is to be drawn in, as the
+     * `--terminal-*` properties resolve where the frame is. `connectTerminal`
+     * themes the renderer from it. A color nothing sets is left out, so the
+     * renderer keeps its own: the headless tier sets none, and the styled tier
+     * sets every one from the theme.
+     */
+    look(): TerminalLook;
+    /** Focuses the terminal's input, where a renderer is attached. */
+    focus(options?: FocusOptions): void;
+    /**
+     * Attaches what draws the terminal, and returns how it tells the frame what
+     * happened. `connectTerminal` calls it; a page drawing its own terminal calls
+     * it with its own renderer. Attaching another detaches the first.
+     */
+    attach(renderer: TerminalRenderer): TerminalSink;
+    /** The settings a renderer applies, as the frame's properties stand. */
+    private get settings();
+    /** Sends input to the page, unless input is closed. */
+    private send;
+    /** Offers a link to the page, and opens a web address where the page did not take it. */
+    private follow;
+    /** Flashes for the bell, and says so to the page. */
+    private ring;
+    /** Says something in the live region, once, even where it is what was said last. */
+    private say;
+    /** Whether `controls`, or the resting controls, names a control the renderer can answer. */
+    private draws;
+    /** The find bar's count, as the reader reads it. */
+    private get countText();
+    /** The chord that switches Tab, as a reader says it. */
+    private get tabKey();
+    /**
+     * Names the renderer's input for a screen reader: what it is, how Tab
+     * leaves it, and which keys the frame takes. What was there is kept, and put
+     * back on detach.
+     */
+    private nameInput;
+    /** Puts the renderer's input back as it was before the frame named it. */
+    private restoreInput;
+    /** Lets go of the renderer that is attached: its input put back, and the find bar closed. */
+    private release;
+    /** Whether the frame answers a shortcut with the renderer it has. */
+    private takes;
+    /**
+     * The frame's keys, heard before the renderer's: in the capture phase, on
+     * the host, which is an ancestor of the renderer's element in the page, so
+     * a key the frame takes never reaches the program.
+     */
+    private readonly handleKeys;
+    /** Opens the find bar and puts focus in its field, searching again for what it holds. */
+    private openFind;
+    /** Closes the find bar, takes its highlights off, and returns focus to the terminal. */
+    private closeFind;
+    /** Searches for what the field holds, toward the bottom or with `backward` toward the top. */
+    private search;
+    private readonly handleFindInput;
+    private readonly handleFindKeys;
+    /** Copies the selection, and says so. */
+    private copySelection;
+    private readonly handleActions;
+    private readonly handleLabel;
+    private readonly handleRestart;
+    /**
+     * Says the process exited, where it exited after the first render: an exit
+     * written in the markup is shown and not news. Here and not in `updated`, so
+     * the words go out in the update the exit caused rather than in another one.
+     */
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Whether any built-in control is drawn. */
+    private get drawsAny();
+    /**
+     * The header's toolbar: the page's `actions`, then the built-in controls,
+     * one tab stop between them, the arrows moving along it.
+     *
+     * **Always drawn**, empty where nothing is in it, because the `actions` slot
+     * is inside it and a slot drawn only once something is slotted is a slot
+     * nothing can be slotted into.
+     */
+    protected renderControls(): TemplateResult;
+    /**
+     * The find bar, kept in the tree while closed so its field keeps what was
+     * typed. The field stands before the toolbar and outside it, because a
+     * toolbar leaves the arrows to a text field, and the buttons in one with it
+     * would be out of their reach.
+     */
+    protected renderFind(): TemplateResult | typeof nothing;
+    /**
+     * One probe for each color `look()` reads, each painted in its property,
+     * inside a box painted transparent: a property nothing sets leaves its probe
+     * the box's color, which is how an unset one is told from a set one. Hidden,
+     * and read only by `look()`.
+     */
+    protected renderLook(): TemplateResult;
+    /** The status line: how the process exited and Restart, and what Tab does while it moves focus. */
+    protected renderStatus(): TemplateResult;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'helix-headless-terminal': HelixHeadlessTerminal;
+    }
+}