@promptctl/rich-js 0.16.0 → 0.18.0

package/dist/renderables/columns.d.ts

@@ -1,61 +0,0 @@
-/**
- * Columns — arranges renderables in a multi-column layout.
- */
-import { Segment } from "../core/segment.js";
-import type { PaddingDimensions } from "./padding.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
-export interface ColumnsOptions {
-    expand?: boolean;
-    equal?: boolean;
-    width?: number;
-    padding?: PaddingDimensions;
-    columnFirst?: boolean;
-}
-export declare class Columns implements Renderable, Measurable {
-    renderables: (Renderable & Partial<Measurable>)[];
-    readonly expand: boolean;
-    readonly equal: boolean;
-    readonly colWidth: number | undefined;
-    readonly columnFirst: boolean;
-    readonly gutterWidth: number;
-    constructor(items?: Iterable<unknown>, options?: ColumnsOptions);
-    render(rawOptions: RenderOptions): Iterable<Segment>;
-    /**
-     * The requested width divided into columns, once.
-     *
-     * [LAW:single-enforcer] The three modes disagree only about how many columns
-     * there are and how wide each one is, so they disagree in one place. `render`
-     * lays out against this division and `_naturalWidth` is the width at which it
-     * comes out as one row of every item.
-     */
-    private _divide;
-    /**
-     * The widest any one item wants to be.
-     *
-     * An item that cannot measure itself wants the offer, which is what `Panel`,
-     * `Padding`, `Layout` and `Tree` all answer for the same case — and under an
-     * unbounded offer that is `Infinity`, so `withBoundedWidth` throws and says
-     * the request was unanswerable. Counting it as one cell instead reported a
-     * natural width of 1, which resolved an unbounded offer to a single column and
-     * cropped forty cells of content down to `"x"` with no error at all.
-     */
-    private _itemWidth;
-    /**
-     * The declared column width, bounded by the width offered.
-     *
-     * [LAW:single-enforcer] A declared width is what a column asks for, not what
-     * it takes — the contract `Table._outerWidth` keeps for a declared table
-     * width. Read by `_divide` for render and by `_naturalWidth` for measure, so
-     * the two answer from one number: laid out at the raw declared width, a
-     * six-cell column offered three emitted six-cell lines while `measure`
-     * reported three, and the terminal's soft wrap took the frame of everything
-     * printed after it.
-     */
-    private _declaredWidth;
-    /** The width at which every item sits on one row: n columns and the gutters between them. */
-    private _naturalWidth;
-    measure(rawOptions: RenderOptions): {
-        minimum: number;
-        maximum: number;
-    };
-}

package/dist/renderables/columns.js

@@ -1,168 +0,0 @@
-/**
- * Columns — arranges renderables in a multi-column layout.
- */
-import { Segment } from "../core/segment.js";
-import { Measurement } from "../core/measure.js";
-import { RichText } from "../core/text.js";
-import { isMeasurable, withBoundedWidth, withCellWidth } from "../core/protocol.js";
-import { cellCount } from "../core/cells.js";
-function toRenderable(item) {
-    // [LAW:single-enforcer] A `RichText` passed directly implements `render`
-    // and would otherwise leave through the passthrough arm below untouched,
-    // keeping its default `end: "\n"` (rich-text-5ai) — the same gap the code
-    // review found in table.ts's `toRenderable`. A column item is a row
-    // fragment, not a printed unit, same as every other embedding site.
-    if (item instanceof RichText) {
-        const copy = item.copy();
-        copy.end = "";
-        return copy;
-    }
-    if (typeof item === "object" && item !== null && "render" in item) {
-        return item;
-    }
-    return new RichText(String(item ?? ""), { end: "" });
-}
-export class Columns {
-    renderables;
-    expand;
-    equal;
-    colWidth;
-    columnFirst;
-    gutterWidth;
-    constructor(items, options) {
-        this.renderables = items ? [...items].map(toRenderable) : [];
-        this.expand = options?.expand ?? false;
-        this.equal = options?.equal ?? false;
-        // A declared column width is a cell count like any other, and it reaches
-        // the layout without passing through `withCellWidth`, which parses only
-        // what the *caller of render* supplied. Left raw, `width: NaN` made
-        // `Math.max(1, NaN)` a NaN column count and `new Array` threw `Invalid
-        // array length` before a single column was laid out. Absence is preserved
-        // rather than parsed: `undefined` selects auto-fit, and `cellCount` would
-        // read it as a declared zero.
-        this.colWidth = options?.width === undefined ? undefined : cellCount(options.width);
-        this.columnFirst = options?.columnFirst ?? false;
-        this.gutterWidth = 2; // default gutter between columns
-    }
-    *render(rawOptions) {
-        const items = this.renderables;
-        if (items.length === 0)
-            return;
-        // The parsed options, not just a parsed local: `_divide` hands them to
-        // `Measurement.get`, and a raw NaN reaching it comes back as a NaN item
-        // width, then a NaN column count, then `Invalid array length` out of
-        // `new Array(numCols)` before a single column is laid out. An unbounded
-        // width reaches the same `new Array` by the same route, which is why the
-        // parse here is the bounded one.
-        const options = withBoundedWidth(rawOptions, this);
-        const { numCols, colWidths } = this._divide(options);
-        // Layout items into rows
-        const numRows = Math.ceil(items.length / numCols);
-        // [LAW:types-are-the-program] The element type is Renderable — any number
-        // of lines. Each grid cell renders to its full set of lines; an out-of-range
-        // slot (the last row is rarely full) is an empty cell. mergeHorizontal then
-        // stacks every row of every cell line-by-line, so multi-line children
-        // (Panels, Tables) compose instead of being truncated to their first row.
-        for (let row = 0; row < numRows; row++) {
-            const cells = colWidths.map((width, col) => {
-                const idx = this.columnFirst ? col * numRows + row : row * numCols + col;
-                const item = items[idx];
-                const lines = item === undefined
-                    ? []
-                    : Segment.splitLines([
-                        ...item.render({ ...options, maxWidth: width }),
-                    ]);
-                return { lines, width };
-            });
-            yield* Segment.mergeHorizontal(cells, this.gutterWidth);
-        }
-    }
-    /**
-     * The requested width divided into columns, once.
-     *
-     * [LAW:single-enforcer] The three modes disagree only about how many columns
-     * there are and how wide each one is, so they disagree in one place. `render`
-     * lays out against this division and `_naturalWidth` is the width at which it
-     * comes out as one row of every item.
-     */
-    _divide(options) {
-        const maxWidth = options.maxWidth;
-        const gutter = this.gutterWidth;
-        const declared = this._declaredWidth(options);
-        if (declared !== undefined) {
-            const numCols = Math.max(1, Math.floor((maxWidth + gutter) / (declared + gutter)));
-            return { numCols, colWidths: new Array(numCols).fill(declared) };
-        }
-        if (this.equal) {
-            const itemWidth = this._itemWidth(options);
-            const numCols = Math.max(1, Math.floor((maxWidth + gutter) / (itemWidth + gutter)));
-            const equalWidth = Math.floor((maxWidth - gutter * (numCols - 1)) / numCols);
-            return { numCols, colWidths: new Array(numCols).fill(equalWidth) };
-        }
-        // Auto: as many columns as the widest item fits into, capped at the item
-        // count. Sized from the content rather than from a flat four cells per
-        // column, because `_naturalWidth` below is the inverse of *this* expression
-        // and a constant has no inverse: six two-cell items reported a natural
-        // width of 22 and then wrapped into two rows at 22, since `floor(22 / 4)`
-        // is five columns no matter how narrow the items are.
-        const itemWidth = this._itemWidth(options);
-        const numCols = Math.min(this.renderables.length, Math.max(1, Math.floor((maxWidth + gutter) / (itemWidth + gutter))));
-        const colW = Math.floor((maxWidth - gutter * (numCols - 1)) / numCols);
-        return { numCols, colWidths: new Array(numCols).fill(colW) };
-    }
-    /**
-     * The widest any one item wants to be.
-     *
-     * An item that cannot measure itself wants the offer, which is what `Panel`,
-     * `Padding`, `Layout` and `Tree` all answer for the same case — and under an
-     * unbounded offer that is `Infinity`, so `withBoundedWidth` throws and says
-     * the request was unanswerable. Counting it as one cell instead reported a
-     * natural width of 1, which resolved an unbounded offer to a single column and
-     * cropped forty cells of content down to `"x"` with no error at all.
-     */
-    _itemWidth(options) {
-        let widest = 1;
-        for (const item of this.renderables) {
-            widest = Math.max(widest, isMeasurable(item)
-                ? Measurement.get(options, item).maximum
-                : options.maxWidth);
-        }
-        return widest;
-    }
-    /**
-     * The declared column width, bounded by the width offered.
-     *
-     * [LAW:single-enforcer] A declared width is what a column asks for, not what
-     * it takes — the contract `Table._outerWidth` keeps for a declared table
-     * width. Read by `_divide` for render and by `_naturalWidth` for measure, so
-     * the two answer from one number: laid out at the raw declared width, a
-     * six-cell column offered three emitted six-cell lines while `measure`
-     * reported three, and the terminal's soft wrap took the frame of everything
-     * printed after it.
-     */
-    _declaredWidth(options) {
-        return this.colWidth === undefined ? undefined : Math.min(this.colWidth, options.maxWidth);
-    }
-    /** The width at which every item sits on one row: n columns and the gutters between them. */
-    _naturalWidth(options) {
-        const count = this.renderables.length;
-        if (count === 0)
-            return 0;
-        const width = this._declaredWidth(options) ?? this._itemWidth(options);
-        return count * width + this.gutterWidth * (count - 1);
-    }
-    measure(rawOptions) {
-        // A floor of one cell is what Columns asks for; the ceiling is what it was
-        // offered, and the ceiling wins. Stated as a bare `minimum: 1`, a Columns
-        // measured into no width at all reported the range 1..0 — a floor above
-        // its own ceiling, which the parent that asked cannot divide.
-        //
-        // The ceiling is not the whole answer, though: reported as the offer alone,
-        // a Columns claimed every cell it was shown, so `Panel` in fit mode drew a
-        // 40-cell frame around five cells of content and an unbounded offer came
-        // back unbounded.
-        const parsed = withCellWidth(rawOptions);
-        const maximum = Math.min(this._naturalWidth(parsed), parsed.maxWidth);
-        return { minimum: Math.min(1, maximum), maximum };
-    }
-}

package/dist/renderables/constrain.d.ts

@@ -1,15 +0,0 @@
-/**
- * Constrain — wraps a renderable and constrains its maximum width.
- */
-import { Segment } from "../core/segment.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
-export declare class Constrain implements Renderable, Measurable {
-    readonly renderable: Renderable;
-    readonly width: number | undefined;
-    constructor(renderable: Renderable, width?: number);
-    render(options: RenderOptions): Iterable<Segment>;
-    measure(options: RenderOptions): {
-        minimum: number;
-        maximum: number;
-    };
-}

package/dist/renderables/constrain.js

@@ -1,37 +0,0 @@
-/**
- * Constrain — wraps a renderable and constrains its maximum width.
- */
-import { Measurement } from "../core/measure.js";
-import { isMeasurable } from "../core/protocol.js";
-export class Constrain {
-    renderable;
-    width;
-    constructor(renderable, width) {
-        this.renderable = renderable;
-        this.width = width;
-    }
-    *render(options) {
-        // [LAW:dataflow-not-control-flow] Always compute constrainedWidth; undefined means no constraint
-        const constrainedWidth = this.width !== undefined
-            ? Math.min(this.width, options.maxWidth)
-            : options.maxWidth;
-        const innerOptions = {
-            ...options,
-            maxWidth: constrainedWidth,
-        };
-        yield* this.renderable.render(innerOptions);
-    }
-    measure(options) {
-        if (isMeasurable(this.renderable)) {
-            const measurement = Measurement.get(options, this.renderable);
-            const maxWidth = this.width !== undefined
-                ? Math.min(this.width, options.maxWidth)
-                : options.maxWidth;
-            return {
-                minimum: measurement.minimum,
-                maximum: Math.min(measurement.maximum, maxWidth),
-            };
-        }
-        return { minimum: 1, maximum: options.maxWidth };
-    }
-}

package/dist/renderables/flexStrip.d.ts

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,200 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-/**
- * Group — renders multiple renderables in sequence.
- * No visual chrome — purely a container.
- */
-import { Segment } from "../core/segment.js";
-import type { Renderable, RenderOptions } from "../core/protocol.js";
-export declare class Group implements Renderable {
-    readonly renderables: Renderable[];
-    constructor(...renderables: Renderable[]);
-    render(options: RenderOptions): Iterable<Segment>;
-}

package/dist/renderables/group.js

@@ -1,15 +0,0 @@
-/**
- * Group — renders multiple renderables in sequence.
- * No visual chrome — purely a container.
- */
-export class Group {
-    renderables;
-    constructor(...renderables) {
-        this.renderables = renderables;
-    }
-    *render(options) {
-        for (const renderable of this.renderables) {
-            yield* renderable.render(options);
-        }
-    }
-}

package/dist/renderables/layout.d.ts

@@ -1,92 +0,0 @@
-/**
- * Layout — divides the screen into rectangular regions.
- */
-import { Segment } from "../core/segment.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.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
-     * `_rowBudgetFor` and `_distributeSpace` 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(): number;
-    set ratio(value: number);
-    get size(): number | undefined;
-    set size(value: number | undefined);
-    get minimumSize(): number;
-    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;
-    private _distributeSpace;
-    /**
-     * 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;
-    /**
-     * The budget at which `_distributeSpace` gives every child of a row at least
-     * the width it wants — the inverse of the ratio rule above, and the reason
-     * this is not the sum of those widths.
-     *
-     * [LAW:one-source-of-truth] A growing child receives `floor(budget * ratio /
-     * totalRatio)`, so to receive `want` cells it needs the budget to reach
-     * `want * totalRatio / ratio`, and one budget serves them all: the row needs
-     * the largest demand, never their total. Summed instead, a 1:1 split of
-     * "left" and "right" reported 9 and then rendered "right" into the 4 cells
-     * that `floor(9/2)` actually hands it.
-     *
-     * The panes that do not grow are paid first here for the same reason they
-     * are paid first there — and it is the reason this divides by no zero: a
-     * `ratio` of 0 never reaches the division, because a pane that does not grow
-     * demands nothing of a budget for growing.
-     */
-    private _rowBudgetFor;
-    measure(rawOptions: RenderOptions): {
-        minimum: number;
-        maximum: number;
-    };
-}