@zenera/cli 1.1.19 → 1.1.20

package/dist/tui/wrap.d.ts

@@ -28,8 +28,8 @@ export declare const CHROME_ROWS = 7;
  */
 export declare const THINKING_ROWS = 1;
 /** How much of the frame the work in flight may take. A branch is a box now,
- *  not a row, so a fan-out of two costs fourteen of these. */
-export declare const ACTIVITY_ROWS = 16;
+ *  not a row, so a fan-out of two costs twenty-two of these. */
+export declare const ACTIVITY_ROWS = 24;
 /** The width of the elapsed-time column every call row is drawn behind. */
 export declare const TIME_COL = 5;
 export interface Budget {
@@ -58,8 +58,18 @@ export interface Budget {
  * reasoning, none otherwise — and it never takes the answer's last row.
  */
 export declare function budgetOf(rows: number, activity: number, thinking: number): Budget;
-/** The rows a branch box may spend on its own calls and its reasoning. */
-export declare const BRANCH_ROWS = 5;
+/** The rows a branch box may spend on its own calls, prose and reasoning. */
+export declare const BRANCH_ROWS = 9;
+/**
+ * The fewest a box is worth drawing at.
+ *
+ * One row per branch fit more of them on screen and said nothing about any of
+ * them: a box holding a single call is a label, and the reason it is a box at
+ * all is that what a branch just did and said is why it is doing this. Below
+ * six rows there is no *what it just did* — so a fork too wide to give every
+ * branch six is cut to the ones that fit and counted, which is `fitActivity`.
+ */
+export declare const BRANCH_MIN = 6;
 /** Rows a branch box spends on chrome: the title rule and the closing one. */
 export declare const BOX_CHROME = 2;
 /**
@@ -67,18 +77,27 @@ export declare const BOX_CHROME = 2;
  * activity region has to divide between them.
  *
  * Every branch gets the same number, because they are the same kind of thing
- * and a fan-out is read across, not down. A wide fork spends its rows on being
- * complete rather than on being detailed: eight branches showing one call each
- * is a picture of the fork, eight rows of one branch is not.
+ * and a fan-out is read across, not down.
  */
 export declare function branchRows(count: number, allowance: number): number;
 /**
- * How wide the answer is drawn. A line of prose spanning a 200-column terminal
- * is measurably harder to read than one that stops, which is why every demo in
+ * How wide *prose* is drawn. A line spanning a 200-column terminal is
+ * measurably harder to read than one that stops, which is why every demo in
  * `examples/sdk/` puts its answer in a box of bounded width — the terminal is the
  * page, not the paragraph.
+ *
+ * `boxWidth` is what a whole answer is drawn at; this is the floor it starts from.
  */
 export declare function answerWidth(columns: number): number;
+/**
+ * How wide the box holding `text` has to be.
+ *
+ * Prose stops at the comfort width, but a fence and a table cannot be
+ * reflowed — fold a table row and the columns stop lining up, which is the one
+ * thing the table was for — so the box grows to hold the widest of them, as far
+ * as the terminal allows and no further.
+ */
+export declare function boxWidth(text: string, columns: number): number;
 /**
  * A tool payload as a person would read it, rather than as it was serialised.
  *
@@ -112,18 +131,81 @@ export declare function summarise(name: string, preview: string): string;
  * still proof that something is happening.
  */
 export declare function gistOf(text: string, width: number): string;
-/** A run of lines from an answer, and whether it was fenced as code. */
-export interface Segment {
-    code: boolean;
+/** A run of inline text and what it is. Style rides beside the text, never in it. */
+export interface Span {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    /** an inline code span, taken verbatim and never scanned again */
+    code?: boolean;
+    /** where a link points, when its own text does not say */
+    href?: string;
+}
+export type BlockKind = 'paragraph' | 'heading' | 'item' | 'quote' | 'code' | 'table' | 'rule';
+/** How a table column is set, when its rule row said. */
+export type Align = 'left' | 'right' | 'center';
+/**
+ * One block of an answer.
+ *
+ * `lines`, `cells` and `spans` are exclusive and say how the block may be
+ * drawn: `lines` is verbatim and must be cut rather than wrapped, `cells` is a
+ * grid to be laid out by `gridOf`, `spans` is prose and the renderer may do as
+ * it likes with it.
+ */
+export interface Block {
+    kind: BlockKind;
+    /** `heading`: its depth, 1–6. `item`: how deep it is nested. */
+    level?: number;
     /** the fence's info string, when it had one */
     title?: string;
-    lines: string[];
+    /** what a list item is drawn behind — a bullet, or the number that was written */
+    marker?: string;
+    /** `code` only, whose indentation is its meaning */
+    lines?: string[];
+    /** `table` only: every row but the rule, as cells, with their markup resolved */
+    cells?: Span[][][];
+    /** `table` only: how each column is set, and that the first row is a header */
+    align?: Align[];
+    /** every other kind, with its inline markup resolved */
+    spans?: Span[];
 }
 /**
- * Splits an answer on ``` fences. Prose is left exactly as it was — the common
- * answer has no fence in it and comes back in one piece — but a fenced block is
- * the one thing a terminal must not reflow: its indentation is its meaning, and
- * wrapping it as prose destroys it.
+ * The inline markup of one block, resolved.
+ *
+ * Order is the correctness argument. Code is settled first and never entered
+ * again, which is why this is a scanner and not a chain of replaces: in
+ * "use `[a](b)` syntax" the brackets are prose, and no regex over the whole
+ * string can know that. Everything else recurses on the text between its own
+ * markers, so `**bold with `code` in it**` keeps both.
+ */
+export declare function inlineOf(text: string, style?: Omit<Span, 'text'>, depth?: number): Span[];
+/**
+ * An answer, as the blocks it is made of.
+ *
+ * Read top down, one line at a time, because that is the order the text
+ * arrives in and a stream must be readable before it is finished. The two
+ * verbatim kinds win over everything: a pipe inside a fence is whatever the
+ * code says it is, and a `#` inside one is a comment, not a heading.
+ */
+export declare function blocksOf(text: string): Block[];
+/**
+ * A table as its rows, each one a single run of spans.
+ *
+ * Columns are laid out here and nowhere else, so the drawn table and the plain
+ * one are the same table: a cell's width is the length of its text, which is
+ * what a `Span` measures whatever styling rides beside it. Nothing a model
+ * writes in a cell can move the cell after it.
+ */
+export declare function gridOf(block: Block): Span[][];
+/**
+ * A block as the row or rows it reads as, with its markers resolved rather
+ * than shown, and nothing styled.
+ *
+ * This is what a sink that cannot style gets — the pre-answer stream, and the
+ * plain box `zen meta` draws — so that the text does not visibly change shape
+ * at the moment it settles.
  */
-export declare function segmentsOf(text: string): Segment[];
+export declare function textOf(block: Block, width?: number): string;
+/** A whole answer with its markup resolved instead of shown. Still plain text. */
+export declare function unmarked(text: string, width?: number): string;
 //# sourceMappingURL=wrap.d.ts.map