emptyState(availability: any) → void

What the panel shows in place of a conversation when no DotBot surface is present. `availability` is the source's `available()`.

usageLine(agent: any, usage: any) → string

**How much is left, permanently, under the composer.** The AMOUNT and nothing else. It used to open with "Runs on your ChatGPT plan", which every turn's own meta line already says, so who pays was on screen twice; this carries the figure and lets the meta line carry the payer. Removing the whole row instead was the wrong half to cut: the figure is the part somebody wants standing there, and the duplicate was the sentence around it. Nil when there is nothing honest to say: an agent nobody connected, or one with a problem in front of it, has no reading to report.

scalarText(v: any) → string

isArray(t: any) → boolean

summaryOf(v: any) → string

What a table is worth saying when there is no room to open it: a count, never a stringified table.

describeInto(value: any, depth: number, out: { DataLine }, label: string?) → void

Render a decoded value as lines a person reads. **JSON pretty-printed is still JSON.** The braces, the quotes and the commas are three quarters of the characters and none of the content, and a grey block of them is unreadable however neatly it is indented. So nothing here prints punctuation: a record is its name and then its fields, a list is its items and then how many were not shown, and a nested table too deep to open says how big it is instead of being flattened into a string.

describeValue(value: any) → void

A decoded tool answer as lines a person reads. The panel's entry point: one call, one list of lines. Exported from here rather than kept in the panel so it can be tested against the shapes the engine really answers with, which is the only way a claim about how a result READS can be checked at all.

usageNotice(agent: any, usage: any, models: { any }?, alternatives: { any }?) → Notice

The banner above the composer, or nil when the reading warrants none. `models` is the agent's model list; a cheaper model is offered only when it is one of them, so the panel never points at a model it cannot run. `alternatives` are the connected accounts with room left (the source's `alternativesTo`): a spent window names them and offers the first.

composerState(availability: any, agent: any, usage: any) → Composer

Whether the composer takes typing, what it says while empty, and whether it carries the model and thinking chips.

problemNotice(agent: any) → Notice

The banner a problem puts above the composer, or nil when there is none.

metaLine(meta: any) → string

The per-turn meta line's left half: model, thinking level, tokens, tool calls and duration, separated by middle dots.

metaWho(meta: any) → string

Who paid for a turn — the right half of the meta line.

pickerSubtitle(agent: any) → string

What the picker shows under an agent's name.

pickerAction(agent: any) → string

The word on an agent's picker row when it needs an action, or nil.

linkPlace(url: any) → string

The sheet a disconnected or blocked agent shows in place of a conversation: a heading, the paragraphs under it, and the button that moves it on. Nil when the agent has a conversation to show instead. Where a link code is entered, as a person would type it: the URL's host and path, with no scheme and no query.

linkText(id: string, label: string, onClick: () → void

Text that looks like a link and acts like one. There is one of these rather than an `edui.text` in link blue at each site, because the two halves drifted apart the moment they were written separately: the sign-in sheet painted "Open sign-in again" in `#3794ff` and attached no handler, so the only way back out of a stale paste step was a blue word that did nothing. Taking the callback as a required argument is what stops that shape existing: there is no way to ask for the colour without saying what the click does. `flexShrink = 0` so it keeps its width beside a growing sibling — a link crushed to "Open sig…" is the other way this reads as broken.

codeBox(text: string, size: number, spacing: string, pad: number) → any

The box a sign-in code is drawn in. Selectable, because the code is copied into another page: highlighted and copied with Ctrl+C.

connectSheet(agent: any, flow: any, link: any?) → any

connectedNotice(agent: any, account: any) → string

The line a freshly-connected agent shows above its first turn, or nil.

rowKey(row: any) → string

One row's identity, for deciding whether two lists hold the same row. **A row is not its text.** The key was the kind, the tool's name and the trimmed text, which for a tool row, a meta line and a thinking row is nothing at all: two `tool_exec` calls, or two turns' usage lines, had the same key. Merged against the stored history they collapsed into one, so the second turn's tool rows and usage line simply did not appear. A row that carries an identity of its own is keyed by it: * a tool row by the call's id, which the live event and the stored `tool_use` block both carry; * a live-only row (thinking, the usage line) by the `uid` it was given when it was made. Everything else is what a person would call the same message: its kind and its text.

historyIndex(history: { any }) → void

mergeRows(history: { any }, live: { any }) → void

What the plugin has stored, then what this session watched run, WITHOUT showing the overlap twice. History keeps its order, and a live row is shown only if history does not already hold one with the same identity (`rowKey`). Two identical messages a person really did send both survive, because both are in the history by then.

groupCarrierRows(messages: { any }, toolsRunIn: (any) → void

Collapse runs of carrier calls into one row that names what actually ran. **Six rows saying `tool_exec` tell a person nothing.** Each one is a script that called real tools, and the answer carries the trace of which. So a run of consecutive carrier rows becomes a single row carrying every tool those calls ran, in order, and every other row is passed through untouched. A carrier call that ran no tools, or whose answer cannot be read, keeps its own row and its own name: there is nothing better to call it than what the model called it, and inventing a label for an unreadable answer would be inventing the contents of the answer. `toolsRunIn` is the source's reader of an answer's trace, passed in so this stays pure.

thinkingLabel(row: any, now: number?) → string

What a thinking row's header says. **Thinking is never hidden, only folded.** While the model is thinking the row says so (`Thinking…`, with how long it has been going, when the row knows when it started); once it has finished it says how long it thought. The text itself is behind the chevron either way. `now` is a clock reading in seconds from the same clock as `row.startedAt`.

finishThinking(row: any, now: number) → void

Close a thinking row: stop it streaming and fix how long it took.

toggleOpen(state: { [string]: boolean }, key: string) → boolean

Flip one entry of an open/closed table and answer the new state. The panel keeps which rows are open OUTSIDE the rows, keyed by a stable identity, because a transcript is recomposed from history plus live events on every redraw and a flag stored on a row is lost the moment anything streams.

foldThinking(rows: { any }, from: number?) → void

A turn's thinking rows folded into ONE, once the turn has ended. What it thought is worth watching while it thinks and worth little afterwards: a turn with eight tool calls has up to eight thinking phases, and eight "Thought for 2 s" rows between the question and the answer are clutter. They become a single row at the place the first one stood, carrying ALL of the thoughts (joined with a blank line) and the total time spent thinking, so folding loses nothing and the row stays unfoldable. It keeps the first row's `uid`, so a row the reader had open is still the one that is open. **Only the turn that ended is folded.** The live rows hold every turn this session watched, one after another, so folding "the thinking rows" folded every turn's thinking into the first turn's row and left the later turns with none. `from` is where the ended turn's rows begin (the row after the previous turn's usage line); rows before it are left exactly as they were. Returns the new list and the uids of the rows that were merged away.

trimmed(line: string) → string

isTableLine(line: string) → boolean

isTableSeparator(line: string) → boolean

A table's separator line: `|---|:---:|`. Only dashes, colons, pipes and spaces, with at least one dash.

tableCells(line: string) → void

The cells of one table line, without the outer pipes.

splitMarkdown(md: string) → void

An answer's markdown split into the parts the panel draws itself and the prose the shared renderer draws. **The shared renderer cannot be left to draw these two.** It draws a table as raw `| a | b |` lines in monospace that run past the panel's right edge, and a fenced code block as one unwrapped run that is clipped or overflows. Neither can wrap, and neither can be selected. So they are lifted out here: * `{ kind = "prose", text }`: handed to the renderer as it was; * `{ kind = "code", lang, text }`: a fenced block, an unterminated one (an answer still streaming) included; * `{ kind = "table", header = {cells}?, rows = {{cells}} }`: a run of lines that start with a pipe. The header is the first row when the second is a separator; a run with no separator is all rows.

flushProse( ) → void

tableWeights(header: { string }?, rows: { { string } }) → void

How much of a table's width each column asks for. Proportional to the longest cell in it, within bounds: a column of one-word labels does not take as much as a column of sentences, and a column of long sentences cannot take the table whole. Every column can shrink to nothing, so the table is never wider than the panel whatever its cells hold.

see(cells: { string }?) → void

tableNode(P: any, header: { string }?, rows: { { string } }, inline: (string) → void

A table as a widget: one wrapping row per table row, every cell a box that may grow and may shrink and starts from nothing (`flexBasis = 0`), so the row is exactly the panel's width however long a cell's text is and a long cell wraps inside its own column.

rowNode(cells: { string }, isHeader: boolean, striped: boolean) → any

markSelectable(node: any) → void

Mark every piece of text under `node` selectable: styled runs (`richText`) and plain labels (headings, quotes) alike. The shared markdown renderer builds an answer out of those widgets, and each takes part in text selection only when it says so with `props.selectable`. Selection then reaches every piece of an answer — paragraphs, list items, headings — the way it reaches a plain label, and one drag can cross from one to the next. Walks `children`, so a list item's run inside its row is marked too.

codeNode(P: any, text: string) → any

A fenced code block as a widget: monospace text that WRAPS at the panel's edge and can be selected and copied. A block of code is the thing a person most often copies out of an answer.

imageNode(P: any, key: string, path: string, exists: boolean) → any

What a tool row shows for a picture its answer named. The picture is a file, and the file may be gone: a capture from an earlier session, written under a scratch folder that was cleared since. Drawn as an image the transcript showed a broken tile and said nothing. When the file is not there the row says so instead.