@vincemakes/kiso-tui-cells 0.46.2 → 0.47.0

package/dist/components.d.ts

@@ -89,6 +89,36 @@ export declare class Container implements Component {
     constructor(children: Component[]);
     render(width: number, ctx: FrameCtx): string[];
 }
+/** Graphite §1.8 — THE CONTENT EDGE. Every block begins at column 2
+ *  (owner, 2026-09-29: the 0.44 geometry); columns 0–1 are the mark
+ *  column — the seal's `✦`, a streaming thought's twinkle, the live row's
+ *  mark, the person's `▌`, a card's edge and its mark cell. */
+export declare const EDGE = "  ";
+/** Graphite §7.12 — the one word of a notice's sentence that carries the
+ *  weight, and its colour: the failure colour, the plan's blue, ink, and
+ *  (the tasks round) the success colour of an outcome that went well and
+ *  the gold of one nobody can know. */
+export interface NoticeMark {
+    readonly text: string;
+    readonly tone: "fail" | "blue" | "ink" | "ok" | "gold";
+}
+/** The tasks round — a further row of a one-row notice, drawn under the
+ *  first with its own label (`""`: none) in the same cell, so the rows of
+ *  one notice stay together (two cells would be a blank apart, D1). */
+export interface NoticeRow {
+    readonly label: string;
+    readonly sentence: string;
+    readonly mark?: NoticeMark;
+}
+/** The last sweep (owner, 2026-10-06) — one part of what `/think` or
+ *  `/last` brings back: a dim title (`input`, `output`) when it has one,
+ *  and its text in the look of what it is — thinking's grey italic, or a
+ *  call's output in `ink2`, hung under the title. */
+export interface RecallSection {
+    readonly title?: string;
+    readonly text: string;
+    readonly style: "thinking" | "output";
+}
 export type BodyCell = {
     kind: "user";
     text: string;
@@ -157,10 +187,27 @@ export type BodyCell = {
     kind: "md";
     block: MdBlock;
     done: boolean;
-} | {
+}
+/** Graphite §7.12 — `label` and `sentence` are the meta row's two
+ *  halves, derived from `text` by the compositor; `text` is what a
+ *  pipe prints, unchanged. */
+ | {
     kind: "notice";
     text: string;
     done: true;
+    label?: string;
+    sentence?: string;
+    mark?: NoticeMark;
+    stacked?: true;
+    oneRow?: true;
+    also?: readonly NoticeRow[];
+}
+/** Graphite §7.11 — the turn's seal: its forms, widest first; the
+ *  widest that fits is drawn, and the narrowest is cut. */
+ | {
+    kind: "seal";
+    tiers: readonly string[];
+    done: true;
 }
 /** 4c — the resumed session's earlier history, replayed into cells and
  *  FOLDED: the row is ONE line on screen and never expands there (a
@@ -186,6 +233,27 @@ export type BodyCell = {
     lines: string[];
     done: true;
     wrap?: "words";
+}
+/** Graphite §7.13 (G3, R2d) — the person's own `!!cmd`: run and shown,
+ *  never sent (a `!cmd` is a user turn and draws the same way from its
+ *  text, see `bangOf`). */
+ | {
+    kind: "bang";
+    command: string;
+    output: string;
+    isError: boolean;
+    done: true;
+}
+/** The last sweep — what `/think` or `/last` brings back, on the
+ *  terminal: a meta row (`THINKING`, `LAST CALL`) and the sections
+ *  under it. `text` is what a pipe prints, unchanged. */
+ | {
+    kind: "recall";
+    text: string;
+    label: string;
+    sentence: string;
+    sections: readonly RecallSection[];
+    done: true;
 } | {
     kind: "terminal";
     label: string;
@@ -196,15 +264,33 @@ declare const TOOL_SUMMARY_MAX = 60;
 /** The component for one cell — the mapping table lives here so the
  *  compositor stays a pure writer. */
 export declare function cellComponent(cell: BodyCell): Component;
-/** W22: the pending-queue chips — queued user lines pre-render above
- *  the input row as the SAME UserMessage chip (undimmed: reverse video
- *  inverts the CURRENT colours, so a dim span would invert into a
- *  dimmed block), the dim `□` gutter marking the queued
- *  state (the gutter rides EVERY row — the gutterFold precedent: the
- *  left edge alone distinguishes the states). Each chip folds at W−3
- *  (the gutter's 2 cells), so a long line hard-folds INSIDE the chip
- *  and invariant ① holds on the band. */
-export declare function pendingQueueRows(lines: readonly string[], W: number): string[];
+/** G3 (R2d) — the block `!cmd` sends: a `console` fence holding `$ <command>`
+ *  and what it printed (apps/cli dispatch.ts `runBang`). Null for any
+ *  other text. */
+export declare function bangOf(text: string): {
+    command: string;
+    output: string;
+} | null;
+/**
+ * Graphite §8.7, the main-sync round (owner, 2026-09-30) — a STEER that
+ * has not landed is ONE row in the live zone:
+ *
+ *   ◇ <the message's first line>                  next step · ↑ takes back
+ *
+ * ADR-0057: Enter while a run works steers it — there is no queue on a
+ * terminal — and the steer lands inside the same run at its next quiet
+ * step, or after an open approval, which it never answers. The gold `◇`
+ * (a message the person sent that has not landed, §4) in the mark column
+ * and the text at the content edge; no label word (owner: the mark says
+ * it). The keys at the right say what happens next and give way first
+ * when the row is short. DECLARED REVERSAL of the `◇ queued … after this
+ * turn · ↑ edit` row, whose queue main retired in 0.45.0.
+ */
+export declare function pendingQueueRows(lines: readonly string[], W: number, waiting?: "step" | "approval"): string[];
+/** A line of text folded to `width` cells, breaking after the last space
+ *  that fits (the space is the break), or hard at the width when a run has
+ *  none. Every other character is kept, in order. */
+export declare function foldAtSpaces(text: string, width: number): string[];
 /**
  * TUI2-R1.5 ⑨ (VD-10) — the WORD-aware fold, for text a human reads.
  *
@@ -225,14 +311,6 @@ export declare function pendingQueueRows(lines: readonly string[], W: number): s
  */
 export declare function foldWords(line: string, W: number): string[];
 export declare function gutterFold(gutter: string, line: string, W: number): string[];
-/** A6: the tool-header variant — ONE cut row, never a fold. A wide
- *  header (a long target path, a wordy denial reason) used to wrap
- *  through foldLine — every wrapped row repeated the gutter, the
- *  settled row grew past its previewed height. The header names the
- *  call — the ellipsis marks the cut, the body below still carries the
- *  full content. The budget: the gutter's own visible width + the
- *  ellipsis ride the row (the invariant ① cap holds). */
-export declare function gutterCut(gutter: string, line: string, W: number): string[];
 export declare function foldTerms(reads: number, edits: number, others: readonly [string, number][]): string[];
 /**
  * R3i phase 5 — THE ANSWERED QUESTION'S BLOCK.
@@ -267,7 +345,7 @@ export declare function askedBlock(resultText: string, seconds: number | null, W
  *  the shell was the only settled call with rows on screen. */
 export declare const CAP_PREVIEW = 5;
 /** 0.24.2 ② — the live region's `thinking…` placeholder: dim italic at
- *  column 2, no glyph, the SAME shape a thinking paragraph takes so that
+ *  the content edge, no glyph, the SAME shape a thinking paragraph takes so that
  *  whatever arrives replaces it in place. Never committed — see the
  *  compositor's #project for why that is what makes it allowed. */
 export declare function thinkingRow(): string;
@@ -384,11 +462,63 @@ export declare function selectionBar(styled: string, visible: number, W: number)
  * columns the walls were taking.
  */
 export declare function boxTop(W: number): string;
-/** R2 — the same rule below. Named for its POSITION, not its shape, so
- *  the compositor's two call sites did not have to move. */
+/** Graphite R3e — a read-only sheet over the input (`/status`): the band's
+ *  named hairline, one fact per row — its label dim in a column, its value
+ *  folded by word under itself — and the row that says how it closes.
+ *  It closes like the keys sheet, but what is typed after it is typed. */
+export declare function infoSheetRows(title: string, facts: readonly {
+    readonly label: string;
+    readonly value: string;
+}[], W: number): string[];
+/** R2 — the same rule below, in the hairline colour (§1.1). Named for its
+ *  POSITION, not its shape, so the compositor's two call sites did not
+ *  have to move. */
 export declare function boxBottom(W: number): string;
 /** The terminal label + rhythm gap (the pipe path's v2c bytes — the
  *  exact render the passthrough needs). */
 export declare function terminalPipe(label: string, statusLineText: string): string;
 /** The pipe-path pieces the passthrough reuses (byte-identical). */
 export { foldThinking, foldResult, renderToolSummary, TOOL_SUMMARY_MAX };
+/**
+ * The subsequence embedding, TIGHTENED — the two-pass walk every good
+ * fuzzy finder uses, and the reason `@ra` emboldens the "ra" of
+ * "src/range.js" rather than the r of "src" and the a of "range".
+ *
+ * Pass 1 walks forward and stops at the EARLIEST index that completes
+ * the query — this both answers "does it match at all" and fixes the
+ * right-hand edge. Pass 2 walks backward from that edge, taking the
+ * LATEST position for each query character in turn, which slides every
+ * matched character as far right as it can go without crossing the
+ * next one. The result is the most clustered embedding that ends where
+ * the earliest match ends.
+ *
+ * Case-insensitive: both sides are lowercased by the caller once per
+ * query rather than once per character.
+ *
+ * Returns the ascending match indices, or null when the query is not a
+ * subsequence of the path at all.
+ */
+export declare function atEmbed(lowerPath: string, lowerQuery: string): number[] | null;
+/**
+ * Graphite P2 (owner, 2026-10-03) — the band's window, shared by the file
+ * picker, the command list and the session picker: EIGHT rows on a
+ * terminal 30 rows or taller, five below.
+ */
+export declare function bandVisible(height: number): number;
+/** The window over a list, with a scroll-off of one: while more lies past
+ *  an edge the cursor stays a row inside it, so the edge row that carries
+ *  a more-mark is never the selected one. Stateless, like bandWindow. */
+export declare function bandWindow(total: number, selected: number, visible: number): {
+    first: number;
+    count: number;
+};
+/** The more-mark for row `i` of a window: `↑` on its first row when the
+ *  list goes on above, `↓` on its last when it goes on below. */
+export declare function moreMark(i: number, first: number, count: number, total: number): string | null;
+/** The key row that closes a band: what the keys do, then the selection's
+ *  place in the list at the right edge. The keys give way from the least
+ *  needed (the first in `keys`); the counter stays. */
+export declare function bandKeyRow(keys: readonly string[], selected: number, total: number, W: number): string;
+/** Text with the given code-unit positions in bold gold — what the person
+ *  typed, in the colour of what the person says — and the rest in `base`. */
+export declare function goldHits(text: string, hits: ReadonlySet<number>, base: string): string;