@promptctl/rich-js 0.18.0 → 0.19.0

package/dist/renderables/embed.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The one crossing where content a caller hands a renderable — a table cell, a
+ * panel's body, title or subtitle, a padding's body, a tree label, a column
+ * item, a layout pane, a rule's title — becomes something that renderable can
+ * lay out.
+ * [LAW:single-enforcer]
+ *
+ * A string is kept as written and read when it is drawn, through `readStr`,
+ * under the options it is drawn with. That is where a console's settings
+ * arrive: its `markup` decides whether the string is markup, and its
+ * highlighter highlights it, exactly as they do for a string handed to `print`.
+ * Parsed when the renderable was built, a string was markup under a console
+ * that had turned markup off, never met the console's highlighter, and an
+ * unmatched closing tag threw from a constructor rather than from the render
+ * that would draw it, where Rich's does (rich-markup-3sw).
+ *
+ * Text keeps its own `end`, as a body does in Rich: `RichText("foo\n")` draws
+ * the blank row its default `"\n"` end makes, and a string reads with that
+ * default end as `render_str` gives it. Only a label, set into a line it
+ * shares, clears it. A `RichText` is copied when it is handed over, since the
+ * caller still holds it, and every text drawn from it is a copy again, since
+ * the drawing site may change it.
+ */
+import type { Measurable, Renderable, RenderOptions } from "../core/protocol.js";
+import { Segment } from "../core/segment.js";
+import type { Style } from "../core/style.js";
+import { RichText } from "../core/text.js";
+/**
+ * Caller content as text an embedding site lays out. A string is the only kind
+ * of content that can contain markup, so it is the only kind whose reading
+ * waits for the options; any other value is its `String` form as written, so an
+ * object's `[object Object]` is not eaten as a tag.
+ */
+export declare class EmbeddedText implements Renderable, Measurable {
+    private readonly _source;
+    private readonly _readings;
+    constructor(content: unknown);
+    /**
+     * The text this content draws under `options`. A string reads with `base` as
+     * its style, as Rich's `render_str(style=)` gives one; text handed over
+     * keeps its own, since the caller already said how it looks — so a table's
+     * `Text` title draws without the title style, as Rich's does.
+     */
+    text(options: RenderOptions, base?: Style): RichText;
+    render(options: RenderOptions): Iterable<Segment>;
+    /**
+     * Measured unhighlighted, as Rich's `Measurement.get` reads a string with
+     * `highlight=False`: so a container that clears the highlighter for what it
+     * draws measures what it draws, whether or not it clears it for what it
+     * measures, and no highlighter runs just to be thrown away.
+     */
+    measure(options: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+}
+/**
+ * Caller content as something an embedding site can render. A non-text
+ * `Renderable` (a nested `Panel` or `Table`) passes through: it has no markup
+ * to parse. Everything else is `EmbeddedText`.
+ */
+export declare function embed(content: unknown): Renderable & Partial<Measurable>;
+/**
+ * Caller content set into a line it shares with other drawing — a panel's
+ * title or subtitle in its border, a rule's title — read as Rich's `_title`
+ * reads it: newlines become spaces, so the label stays on its line, and tabs
+ * are widened to their stops. Whatever sets it off from the line around it —
+ * a panel's space either side, a rule's gaps — is the embedding site's.
+ *
+ * Held once by the renderable that owns it, so a string's markup is read once
+ * and every measure and render after reuses that reading.
+ */
+export declare class InlineLabel {
+    private readonly _content;
+    constructor(content: string | RichText);
+    /** The label drawn under `options`: one line, its own overflow kept for the caller's cut. */
+    text(options: RenderOptions): RichText;
+}
+/**
+ * A label cut to `width` cells as Rich's `Text.truncate` cuts one: its plain
+ * text set to the width less `marker` — a wide character the cut splits leaves
+ * a space in its cell rather than a cell of the line around it — then the
+ * marker, with every span that ran past the cut trimmed to the new end, so the
+ * pad and the marker take the styling of what they replace. A label that fits
+ * is left as it is.
+ */
+export declare function cutLabel(text: RichText, width: number, marker: string): void;
+/**
+ * Whether caller content is there at all, decided on the content as given, as
+ * Rich's `if self.title` decides it: absent, an empty string and an empty
+ * `Text` are not, and markup that styles nothing is — it reads as empty text,
+ * but the string that holds it is not empty.
+ */
+export declare function present(content: string | RichText | undefined): content is string | RichText;
+/**
+ * A label's text as one line of segments at its natural width, its own styles
+ * laid over `base`. The caller has already cut it to its room, so it leaves as
+ * it stands: `"ignore"` also leaves it unjustified, its spaces where `pad` put
+ * them.
+ */
+export declare function drawLabel(text: RichText, options: RenderOptions, base: Style | undefined): Segment[];
+/**
+ * Caller content as a label, or no label at all: content that is not
+ * `present` draws the plain rule, and markup that styles nothing is an empty
+ * label, which still opens a gap in the rule, as Rich's does.
+ */
+export declare function inlineLabel(content: string | RichText | undefined): InlineLabel | undefined;

package/dist/renderables/embed.js

@@ -0,0 +1,160 @@
+/**
+ * The one crossing where content a caller hands a renderable — a table cell, a
+ * panel's body, title or subtitle, a padding's body, a tree label, a column
+ * item, a layout pane, a rule's title — becomes something that renderable can
+ * lay out.
+ * [LAW:single-enforcer]
+ *
+ * A string is kept as written and read when it is drawn, through `readStr`,
+ * under the options it is drawn with. That is where a console's settings
+ * arrive: its `markup` decides whether the string is markup, and its
+ * highlighter highlights it, exactly as they do for a string handed to `print`.
+ * Parsed when the renderable was built, a string was markup under a console
+ * that had turned markup off, never met the console's highlighter, and an
+ * unmatched closing tag threw from a constructor rather than from the render
+ * that would draw it, where Rich's does (rich-markup-3sw).
+ *
+ * Text keeps its own `end`, as a body does in Rich: `RichText("foo\n")` draws
+ * the blank row its default `"\n"` end makes, and a string reads with that
+ * default end as `render_str` gives it. Only a label, set into a line it
+ * shares, clears it. A `RichText` is copied when it is handed over, since the
+ * caller still holds it, and every text drawn from it is a copy again, since
+ * the drawing site may change it.
+ */
+import { cellCount, cellLen, setCellSize } from "../core/cells.js";
+import { activeHighlighter, readStr } from "../core/markup.js";
+import { Segment } from "../core/segment.js";
+import { RichText } from "../core/text.js";
+/**
+ * Caller content as text an embedding site lays out. A string is the only kind
+ * of content that can contain markup, so it is the only kind whose reading
+ * waits for the options; any other value is its `String` form as written, so an
+ * object's `[object Object]` is not eaten as a tag.
+ */
+export class EmbeddedText {
+    // [LAW:types-are-the-program] Two kinds, and the kind is the discriminator: a
+    // string still to be read, or text whose reading is already fixed.
+    _source;
+    // A string's reading under each markup setting, made the first time one is
+    // asked for. Parsing is the costly half of drawing a string, and a table
+    // measures every cell more than once per print; read on every call, a
+    // 500-row table of markup printed 75% slower.
+    _readings = new Map();
+    constructor(content) {
+        if (typeof content === "string") {
+            this._source = content;
+        }
+        else {
+            this._source = content instanceof RichText ? content.copy() : new RichText(String(content ?? ""));
+        }
+    }
+    /**
+     * The text this content draws under `options`. A string reads with `base` as
+     * its style, as Rich's `render_str(style=)` gives one; text handed over
+     * keeps its own, since the caller already said how it looks — so a table's
+     * `Text` title draws without the title style, as Rich's does.
+     */
+    text(options, base) {
+        if (typeof this._source !== "string")
+            return this._source.copy();
+        const markup = options.markup !== false;
+        const reading = this._readings.get(markup) ?? readStr(this._source, markup);
+        this._readings.set(markup, reading);
+        const text = reading.copy();
+        if (base)
+            text.style = base;
+        activeHighlighter(options)?.highlight(text);
+        return text;
+    }
+    render(options) {
+        return this.text(options).render(options);
+    }
+    /**
+     * Measured unhighlighted, as Rich's `Measurement.get` reads a string with
+     * `highlight=False`: so a container that clears the highlighter for what it
+     * draws measures what it draws, whether or not it clears it for what it
+     * measures, and no highlighter runs just to be thrown away.
+     */
+    measure(options) {
+        return this.text({ ...options, highlight: false }).measure(options);
+    }
+}
+/**
+ * Caller content as something an embedding site can render. A non-text
+ * `Renderable` (a nested `Panel` or `Table`) passes through: it has no markup
+ * to parse. Everything else is `EmbeddedText`.
+ */
+export function embed(content) {
+    if (!(content instanceof RichText) && typeof content === "object" && content !== null && "render" in content) {
+        return content;
+    }
+    return new EmbeddedText(content);
+}
+/**
+ * Caller content set into a line it shares with other drawing — a panel's
+ * title or subtitle in its border, a rule's title — read as Rich's `_title`
+ * reads it: newlines become spaces, so the label stays on its line, and tabs
+ * are widened to their stops. Whatever sets it off from the line around it —
+ * a panel's space either side, a rule's gaps — is the embedding site's.
+ *
+ * Held once by the renderable that owns it, so a string's markup is read once
+ * and every measure and render after reuses that reading.
+ */
+export class InlineLabel {
+    _content;
+    constructor(content) {
+        this._content = new EmbeddedText(content);
+    }
+    /** The label drawn under `options`: one line, its own overflow kept for the caller's cut. */
+    text(options) {
+        const text = this._content.text(options);
+        // A fragment of the line, so its own end is not drawn, as Rich's `_title` clears it.
+        text.end = "";
+        text.plain = text.plain.replaceAll("\n", " ");
+        // Tabs widened before anything measures it, so a cut to the border and
+        // the width a title asks for count the cells the label will draw.
+        return text.expandTabs();
+    }
+}
+/**
+ * A label cut to `width` cells as Rich's `Text.truncate` cuts one: its plain
+ * text set to the width less `marker` — a wide character the cut splits leaves
+ * a space in its cell rather than a cell of the line around it — then the
+ * marker, with every span that ran past the cut trimmed to the new end, so the
+ * pad and the marker take the styling of what they replace. A label that fits
+ * is left as it is.
+ */
+export function cutLabel(text, width, marker) {
+    if (text.cellLength <= width)
+        return;
+    text.plain = setCellSize(text.plain, cellCount(width - cellLen(marker))) + marker;
+}
+/**
+ * Whether caller content is there at all, decided on the content as given, as
+ * Rich's `if self.title` decides it: absent, an empty string and an empty
+ * `Text` are not, and markup that styles nothing is — it reads as empty text,
+ * but the string that holds it is not empty.
+ */
+export function present(content) {
+    // Asked of what the content is rather than of what it is not, so a `null`
+    // from untyped JS is no content, as Rich's `None` is.
+    return typeof content === "string" ? content !== "" : content instanceof RichText && content.plain !== "";
+}
+/**
+ * A label's text as one line of segments at its natural width, its own styles
+ * laid over `base`. The caller has already cut it to its room, so it leaves as
+ * it stands: `"ignore"` also leaves it unjustified, its spaces where `pad` put
+ * them.
+ */
+export function drawLabel(text, options, base) {
+    text.overflow = "ignore";
+    return [...Segment.applyStyle(text.render(options), base)];
+}
+/**
+ * Caller content as a label, or no label at all: content that is not
+ * `present` draws the plain rule, and markup that styles nothing is an empty
+ * label, which still opens a gap in the rule, as Rich's does.
+ */
+export function inlineLabel(content) {
+    return present(content) ? new InlineLabel(content) : undefined;
+}

package/dist/renderables/flexStrip.d.ts

@@ -0,0 +1,41 @@
+/**
+ * FlexStrip — wrap-to-width horizontal layout for `StyledRenderable` items.
+ *
+ * Pack as many items as fit on a line, then break and continue. Each line is
+ * an independent sub-strip: optional `Joiner` end-caps fire at every line
+ * boundary (not just the strip's first/last position), so a line break looks
+ * the same as an endpoint to the joiner. Composes with the Strip + Joiner
+ * primitive in `core/strip` — same `Joiner` protocol, no new join semantics.
+ *
+ * [LAW:dataflow-not-control-flow] The pack walk is the same shape every
+ * render: measure each item, render every joiner form (start-cap, end-cap,
+ * mid-join) up-front, then sweep items into lines. Line breaks are decided by
+ * width data, not by control-flow special cases.
+ *
+ * [LAW:one-source-of-truth] The Strip primitive owns the join protocol;
+ * FlexStrip reuses it verbatim. There is no second concept of "join."
+ */
+import { Segment } from "../core/segment.js";
+import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
+import type { Joiner, StyledRenderable } from "../core/strip.js";
+export type FlexAlign = "left" | "center" | "right" | "justify";
+export interface FlexStripOptions<T extends StyledRenderable> {
+    /** Joiner used between items within a line, and at line endpoints. */
+    joiner?: Joiner<T>;
+    /** Cells of horizontal space inserted on each side of an inter-item joiner (default 0). */
+    gap?: number;
+    /** Line alignment when packed items don't fill the available width (default "left"). */
+    align?: FlexAlign;
+}
+export declare class FlexStrip<T extends StyledRenderable = StyledRenderable> implements Renderable, Measurable {
+    readonly items: readonly T[];
+    readonly joiner: Joiner<T> | undefined;
+    readonly gap: number;
+    readonly align: FlexAlign;
+    constructor(items: readonly T[], options?: FlexStripOptions<T>);
+    render(options: RenderOptions): Iterable<Segment>;
+    measure(options: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+}

package/dist/renderables/flexStrip.js

@@ -0,0 +1,200 @@
+/**
+ * FlexStrip — wrap-to-width horizontal layout for `StyledRenderable` items.
+ *
+ * Pack as many items as fit on a line, then break and continue. Each line is
+ * an independent sub-strip: optional `Joiner` end-caps fire at every line
+ * boundary (not just the strip's first/last position), so a line break looks
+ * the same as an endpoint to the joiner. Composes with the Strip + Joiner
+ * primitive in `core/strip` — same `Joiner` protocol, no new join semantics.
+ *
+ * [LAW:dataflow-not-control-flow] The pack walk is the same shape every
+ * render: measure each item, render every joiner form (start-cap, end-cap,
+ * mid-join) up-front, then sweep items into lines. Line breaks are decided by
+ * width data, not by control-flow special cases.
+ *
+ * [LAW:one-source-of-truth] The Strip primitive owns the join protocol;
+ * FlexStrip reuses it verbatim. There is no second concept of "join."
+ */
+import { Segment } from "../core/segment.js";
+function renderToBlock(r, options) {
+    const segments = [...r.render(options)];
+    let width = 0;
+    for (const s of segments)
+        width += s.cellLength;
+    return { segments, width };
+}
+const EMPTY_BLOCK = { segments: [], width: 0 };
+const PAD_LEFT_BY_ALIGN = {
+    left: () => 0,
+    justify: () => 0,
+    center: (spare) => Math.floor(spare / 2),
+    right: (spare) => spare,
+};
+function computePadLeft(align, spare) {
+    return PAD_LEFT_BY_ALIGN[align](spare);
+}
+// Return per-slot fill widths (length = itemCount - 1, possibly empty).
+// Non-justify cases produce all zeros — the emit loop runs the same way.
+function computeSlotFills(align, isFinalLine, spare, itemCount) {
+    const slots = Math.max(0, itemCount - 1);
+    const distribute = align === "justify" && !isFinalLine && slots > 0 && spare > 0;
+    const totalFill = distribute ? spare : 0;
+    const base = slots > 0 ? Math.floor(totalFill / slots) : 0;
+    const extra = totalFill - base * slots;
+    return Array.from({ length: slots }, (_, k) => base + (k < extra ? 1 : 0));
+}
+export class FlexStrip {
+    items;
+    joiner;
+    gap;
+    align;
+    constructor(items, options) {
+        this.items = items;
+        this.joiner = options?.joiner;
+        this.gap = options?.gap ?? 0;
+        this.align = options?.align ?? "left";
+    }
+    *render(options) {
+        const items = this.items;
+        if (items.length === 0)
+            return;
+        const maxWidth = Math.max(1, options.maxWidth);
+        const gap = this.gap;
+        const joiner = this.joiner;
+        // Pre-render every item and every joiner form we might need. Doing this
+        // up-front turns packing into a pure data computation over widths.
+        const itemBlocks = items.map((it) => renderToBlock(it, options));
+        const startCap = (i) => joiner ? renderToBlock(joiner.join(null, items[i]), options) : EMPTY_BLOCK;
+        const endCap = (i) => joiner ? renderToBlock(joiner.join(items[i], null), options) : EMPTY_BLOCK;
+        const midJoin = (i, j) => joiner ? renderToBlock(joiner.join(items[i], items[j]), options) : EMPTY_BLOCK;
+        const lines = [];
+        let line = null;
+        const gapBlock = gap > 0
+            ? { segments: [new Segment(" ".repeat(gap))], width: gap }
+            : EMPTY_BLOCK;
+        for (let i = 0; i < items.length; i++) {
+            const item = itemBlocks[i];
+            if (line === null) {
+                const sc = startCap(i);
+                const ec = endCap(i);
+                const blocks = sc.width > 0 ? [sc, item] : [item];
+                const itemBlockIndices = [blocks.length - 1];
+                line = { blocks, width: sc.width + item.width, lastIndex: i, itemBlockIndices };
+                // Tentatively reserve space for the line's eventual end-cap by
+                // tracking it separately below — `line.width` is the open width
+                // (without end-cap). We test fit using width + endCap on each step.
+                // Always start a new line with at least the first item (overflow ok
+                // per ticket: graceful fallback when an item is wider than terminal).
+                // Stash end-cap for the close step.
+                line.endCap = ec;
+                continue;
+            }
+            const prev = line.lastIndex;
+            const mid = midJoin(prev, i);
+            const newEndCap = endCap(i);
+            const addCost = (gap > 0 ? gap : 0) + mid.width + (gap > 0 ? gap : 0) + item.width;
+            const closedWidthIfAdded = line.width + addCost + newEndCap.width;
+            if (closedWidthIfAdded <= maxWidth) {
+                if (gap > 0)
+                    line.blocks.push(gapBlock);
+                if (mid.width > 0)
+                    line.blocks.push(mid);
+                if (gap > 0)
+                    line.blocks.push(gapBlock);
+                line.blocks.push(item);
+                line.itemBlockIndices.push(line.blocks.length - 1);
+                line.width += addCost;
+                line.lastIndex = i;
+                line.endCap = newEndCap;
+            }
+            else {
+                // Close current line and start a new one with this item.
+                const closing = line.endCap;
+                if (closing.width > 0)
+                    line.blocks.push(closing);
+                line.width += closing.width;
+                lines.push(line);
+                const sc = startCap(i);
+                const ec = endCap(i);
+                const blocks = sc.width > 0 ? [sc, item] : [item];
+                const itemBlockIndices = [blocks.length - 1];
+                line = { blocks, width: sc.width + item.width, lastIndex: i, itemBlockIndices };
+                line.endCap = ec;
+            }
+        }
+        // Close final line. `line` is non-null here: the loop runs at least once
+        // (items.length > 0 was handled above).
+        const finalLine = line;
+        {
+            const closing = finalLine.endCap;
+            if (closing.width > 0)
+                finalLine.blocks.push(closing);
+            finalLine.width += closing.width;
+            lines.push(finalLine);
+        }
+        // [LAW:dataflow-not-control-flow] Single emission path for every line:
+        // emit pad, walk every block, optionally emit a per-slot fill before each
+        // non-first item. Variability lives in two precomputed value sequences
+        // (`padLeft` and `slotFills`); the emit loop has no per-mode branch.
+        //
+        // - `padLeft` pushes the line right by 0 (left/justify), spare/2 (center),
+        //   or full spare (right). Justify-on-final-line follows the left rule.
+        // - `slotFills[k]` is the cells of fill emitted before the (k+1)-th item.
+        //   Always 0 unless align=justify on a non-final line with ≥2 items.
+        //
+        // Putting the variability in data means the emit loop is the same shape
+        // every render, and "what happens between two items" can never accidentally
+        // become "what happens between joiner halves" — the data decides.
+        const align = this.align;
+        for (let li = 0; li < lines.length; li++) {
+            const ln = lines[li];
+            const isLast = li === lines.length - 1;
+            const spare = Math.max(0, maxWidth - ln.width);
+            const padLeft = computePadLeft(align, spare);
+            const slotFills = computeSlotFills(align, isLast, spare, ln.itemBlockIndices.length);
+            const itemRankOf = new Map();
+            ln.itemBlockIndices.forEach((blockIdx, rank) => itemRankOf.set(blockIdx, rank));
+            if (padLeft > 0)
+                yield new Segment(" ".repeat(padLeft));
+            for (let bi = 0; bi < ln.blocks.length; bi++) {
+                const rank = itemRankOf.get(bi);
+                if (rank !== undefined && rank > 0) {
+                    const fill = slotFills[rank - 1];
+                    if (fill > 0)
+                        yield new Segment(" ".repeat(fill));
+                }
+                yield* ln.blocks[bi].segments;
+            }
+            yield Segment.line();
+        }
+    }
+    measure(options) {
+        const items = this.items;
+        if (items.length === 0)
+            return { minimum: 0, maximum: 0 };
+        let minimum = 0;
+        let maximum = 0;
+        for (let i = 0; i < items.length; i++) {
+            const itemWidth = renderToBlock(items[i], options).width;
+            const sc = this.joiner
+                ? renderToBlock(this.joiner.join(null, items[i]), options).width
+                : 0;
+            const ec = this.joiner
+                ? renderToBlock(this.joiner.join(items[i], null), options).width
+                : 0;
+            minimum = Math.max(minimum, itemWidth + sc + ec);
+            maximum += itemWidth;
+            if (i > 0) {
+                maximum += this.gap * 2;
+                if (this.joiner) {
+                    maximum += renderToBlock(this.joiner.join(items[i - 1], items[i]), options).width;
+                }
+            }
+        }
+        if (this.joiner) {
+            maximum += renderToBlock(this.joiner.join(null, items[0]), options).width;
+            maximum += renderToBlock(this.joiner.join(items[items.length - 1], null), options).width;
+        }
+        return { minimum, maximum };
+    }
+}

package/dist/renderables/group.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Group — renders multiple renderables in sequence.
+ * No visual chrome — purely a container.
+ */
+import type { Segment } from "../core/segment.js";
+import { type Measurement } from "../core/measure.js";
+import type { Measurable, Renderable, RenderOptions } from "../core/protocol.js";
+export declare class Group implements Renderable, Measurable {
+    readonly renderables: Renderable[];
+    constructor(...renderables: Renderable[]);
+    render(options: RenderOptions): Iterable<Segment>;
+    /** As wide as its widest member: the reference's `measure_renderables`. */
+    measure(options: RenderOptions): Measurement;
+}

package/dist/renderables/group.js

@@ -0,0 +1,22 @@
+/**
+ * Group — renders multiple renderables in sequence.
+ * No visual chrome — purely a container.
+ */
+import { measureRenderables } from "../core/measure.js";
+import { stackedHeight } from "../core/protocol.js";
+export class Group {
+    renderables;
+    constructor(...renderables) {
+        this.renderables = renderables;
+    }
+    *render(options) {
+        const memberOptions = { ...options, height: stackedHeight(options.height) };
+        for (const renderable of this.renderables) {
+            yield* renderable.render(memberOptions);
+        }
+    }
+    /** As wide as its widest member: the reference's `measure_renderables`. */
+    measure(options) {
+        return measureRenderables(options, this.renderables);
+    }
+}

package/dist/renderables/layout.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Layout — divides the screen into rectangular regions.
+ */
+import { Segment } from "../core/segment.js";
+import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
+import type { CellCol } from "../core/cells.js";
+import type { Weight } from "./ratio.js";
+export interface LayoutOptions {
+    name?: string;
+    ratio?: number;
+    size?: number;
+    minimumSize?: number;
+    visible?: boolean;
+}
+export declare class Layout implements Renderable, Measurable {
+    name: string | undefined;
+    visible: boolean;
+    private _ratio;
+    private _size;
+    private _minimumSize;
+    private _renderable;
+    private _children;
+    private _splitDirection;
+    constructor(renderable?: Renderable | string, options?: LayoutOptions);
+    /**
+     * The three declared numbers, parsed on assignment rather than at the
+     * constructor. All three are public and a caller reaches them long after
+     * construction — `layout.getByName("pane")!.ratio = -1` walked straight past a
+     * constructor-only parse and put a negative weight back into the division that
+     * `ratioResolve` and `ratioBudget` are written to trust.
+     *
+     * [LAW:parse-dont-validate] The setter is the border, so the guarantee holds
+     * for the object's whole lifetime and nothing downstream re-checks. `size` and
+     * `minimumSize` are cell counts; `ratio` is a share weight and keeps its
+     * fractions. Absence is preserved rather than parsed: an undefined `size`
+     * selects a flex pane, and `cellCount` would read it as a declared zero.
+     */
+    get ratio(): Weight;
+    set ratio(value: number);
+    get size(): CellCol | undefined;
+    set size(value: number | undefined);
+    get minimumSize(): CellCol;
+    set minimumSize(value: number);
+    get children(): Layout[];
+    /**
+     * Whether this layout draws `_renderable` or its children.
+     *
+     * [LAW:one-source-of-truth] `render` and `_naturalWidth` must answer this the
+     * same way. Asked separately they did not: `_naturalWidth` read it off the
+     * *visible* children, so a layout holding content and a single hidden child
+     * reported that content's width while `render` emitted nothing at all, and a
+     * fit-mode `Panel` framed twelve cells of air.
+     */
+    private get _isLeaf();
+    splitColumn(...layouts: Layout[]): void;
+    splitRow(...layouts: Layout[]): void;
+    update(renderable: Renderable | string): void;
+    getByName(name: string): Layout | undefined;
+    render(rawOptions: RenderOptions): Iterable<Segment>;
+    private _renderColumn;
+    private _renderRow;
+    /**
+     * The width this layout would take if nothing constrained it: its content's
+     * for a leaf, its children's laid out the way the split lays them out.
+     *
+     * A `size` counts only across a row, which is the one direction in which it
+     * is a width — down a column the same field is a height, and reading it as a
+     * width there would report a two-line pane as two cells wide.
+     */
+    private _naturalWidth;
+    measure(rawOptions: RenderOptions): {
+        minimum: number;
+        maximum: number;
+    };
+}