@promptctl/rich-js 0.24.0 → 0.24.1

package/dist/renderables/table.js

@@ -7,9 +7,9 @@ import { NULL_STYLE } from "../core/style.js";
 import { HEAVY_HEAD } from "../core/box.js";
 import { RichText } from "../core/text.js";
 import { EmbeddedText, embed, present } from "./embed.js";
-import { normalizePadding } from "./padding.js";
+import { Padding, normalizePadding } from "./padding.js";
 import { exactWeights, ratioDistribute, ratioReduce } from "./ratio.js";
-import { getStyle, stackedHeight, withBoundedWidth, withCellWidth } from "../core/protocol.js";
+import { getStyle, render, stackedHeight, withBoundedWidth, withCellWidth } from "../core/protocol.js";
 import { Measurement } from "../core/measure.js";
 /** A `want` no budget can satisfy: the column takes every cell its weight earns. */
 const UNBOUNDED = Number.MAX_SAFE_INTEGER;
@@ -106,8 +106,7 @@ function distribute(total, demands) {
  * column evenly (`ratio_reduce(excess, [1] * n, widths, widths)`). Wants that
  * fit come back as they are.
  *
- * A column's width is its want plus the `kept` cells — seat and padding — the
- * table paid it first and it never gives up. One divergence: the reference's
+ * One divergence: the reference's
  * even cut runs once, and where a column too narrow to give its share leaves
  * cells over, the table draws past its width. Here the cut repeats over the
  * columns with cells left, so the table fits. Each round either fits or
@@ -118,7 +117,7 @@ function reduceToFit(budget, demands) {
     const excess = () => wants.reduce((sum, want) => sum + want, 0) - budget;
     for (let over = excess(); over > 0; over = excess()) {
         // A column with nothing left to give, or that may not wrap, is out of the round.
-        const widths = wants.map((want, index) => (demands[index].wrapable && want > 0 ? demands[index].kept + want : 0));
+        const widths = wants.map((want, index) => (demands[index].wrapable && want > 0 ? want : 0));
         const widest = Math.max(...widths);
         if (widest === 0)
             break;
@@ -130,23 +129,6 @@ function reduceToFit(budget, demands) {
     }
     return wants;
 }
-/**
- * The most padding every column can have alike: each side is granted
- * `min(want, level)`, and `level` is the highest those grants fit `budget` at.
- * A padding level is bought for every column at once or not at all, so a
- * budget too small for everyone's padding leaves it uneven by no column.
- */
-function padLevel(wants, budget) {
-    const sorted = [...wants].sort((a, b) => a - b);
-    let left = budget;
-    for (const [rank, want] of sorted.entries()) {
-        const sharing = sorted.length - rank;
-        if (want * sharing > left)
-            return Math.floor(left / sharing);
-        left -= want;
-    }
-    return sorted.at(-1) ?? 0;
-}
 function layoutTable(outerWidth, demands, frame) {
     // Plain `number`, not the `CellCol` `cells` hands back: this budget is spent
     // down by arithmetic, and arithmetic on a branded type produces a number.
@@ -160,117 +142,87 @@ function layoutTable(outerWidth, demands, frame) {
     // flag for the pair, so half a frame is not a shape this renderer can emit.
     const edge = budget >= frame.edge * 2 ? frame.edge : 0;
     take(edge * 2);
-    // A first content cell per column, in column order, each paying for the
-    // divider that precedes it. The first column the budget cannot seat is where
-    // the table ends; the rest are dropped. A column that wants no cells is
-    // seated at zero — the queue exists to stop one column taking a second cell
-    // before another has its first, and a spacer never joins it.
-    const seats = [];
-    while (seats.length < demands.length) {
-        const seat = Math.min(1, demands[seats.length].want);
-        const cost = (seats.length > 0 ? frame.divider : 0) + seat;
-        if (budget < cost)
-            break;
-        take(cost);
-        seats.push(seat);
-    }
-    const seated = seats.length;
-    // Padding is bought one side at a time, to one level across every seated
-    // column (`padLevel`), so no column is padded while another that wants the
-    // same padding goes without.
+    // Every column whose divider fits is drawn, in column order, at whatever
+    // width the division below leaves it — none at all included, as Rich draws a
+    // column it collapsed to nothing. The first divider the budget cannot hold
+    // is where the table ends; the rest are dropped, never drawn outside the
+    // frame.
+    let seated = demands.length > 0 ? 1 : 0;
+    while (seated < demands.length && budget >= frame.divider) {
+        take(frame.divider);
+        seated++;
+    }
+    // Every column's minimum is paid next, a declared width and a `noWrap`
+    // column alike, and a budget too small for them all cuts them in the
+    // reference's order, `reduceToFit`'s — never the table's frame. The rest of
+    // what each column wanted comes only after. A table whose columns all fit
+    // leaves this budget partly unspent.
     const seatedDemands = demands.slice(0, seated);
-    const takeLevelled = (wants) => {
-        const level = padLevel(wants, budget);
-        return wants.map((want) => take(Math.min(want, level)));
-    };
-    const padLeft = takeLevelled(seatedDemands.map((demand) => demand.pad[0]));
-    const padRight = takeLevelled(seatedDemands.map((demand) => demand.pad[1]));
-    // Reservations are paid in column order, each already holding the cell the
-    // seating pass gave it. A budget too small to cover them all runs out
-    // partway, which costs the trailing columns their width but never costs the
-    // table its frame.
-    const reserved = seatedDemands.map((demand, index) => take(demand.reserved - seats[index]));
-    // What is left to apportion is the rest of what each column wanted: its
-    // minimum first, for every column, and only then the width past it. A table
-    // whose columns all fit leaves this budget partly unspent.
     const spent = (granted) => granted.reduce((sum, width) => sum + width, 0);
-    const base = seatedDemands.map((_, index) => seats[index] + reserved[index]);
-    const holding = (...passes) => base.map((start, index) => passes.reduce((sum, granted) => sum + granted[index], start));
-    const needed = reduceToFit(budget, seatedDemands.map((demand, index) => ({
-        want: Math.max(0, demand.minimum - base[index]),
-        kept: padLeft[index] + base[index] + padRight[index],
-        wrapable: demand.wrapable,
-    })));
-    const afterNeeded = holding(needed);
+    const holding = (...passes) => seatedDemands.map((_, index) => passes.reduce((sum, granted) => sum + granted[index], 0));
+    const needed = reduceToFit(budget, seatedDemands.map((demand) => ({ want: demand.minimum, wrapable: demand.wrapable })));
     const beyond = distribute(budget - spent(needed), seatedDemands.map((demand, index) => ({
-        want: Math.max(0, demand.want - afterNeeded[index]),
+        want: Math.max(0, demand.want - needed[index]),
         weight: demand.weight,
     })));
     const wanted = needed.map((width, index) => width + beyond[index]);
     // The unspent part goes first to the columns with nothing to size to, each
     // alike, up to its `fill` — the reference's `Measurement(1, max_width)`, a
     // maximum of the whole offer that no content measured.
-    const afterWant = holding(wanted);
     const filled = distribute(budget - spent(wanted), seatedDemands.map((demand, index) => ({
-        want: Math.max(0, demand.fill - afterWant[index]),
+        want: Math.max(0, demand.fill - wanted[index]),
         weight: demand.fill > 0 ? 1 : 0,
     })));
     // Then to the ratio columns, by the reference's flexible split:
     // `ratio_distribute(max_width - fixed_widths, ratios, flex_minimum)`. What
     // is split is every cell the bounded columns leave, the cells the ratio
-    // columns already hold and their padding included, because Rich's widths
-    // are padded widths; each is held to at least its padding and its floor.
-    // The floor is the reference's `column.width or 1`, reading `minWidth`
-    // where there is no `width`, where the reference reads none and draws a
-    // `min_width=12` ratio column five cells wide.
+    // columns already hold included; each is held to at least its want, which is
+    // its padding and its floor. The floor is the reference's `column.width or
+    // 1`, reading `minWidth` where there is no `width`, where the reference
+    // reads none and draws a `min_width=12` ratio column five cells wide.
     // A ratio column is paid the rest of its part out of the budget, in column
     // order, so a part the minimums push past what is left is cut there rather
     // than drawn past the width.
     const afterFill = holding(wanted, filled);
     const flexible = seatedDemands.flatMap((demand, index) => (demand.ratio > 0 ? [index] : []));
-    const padded = (index, content) => padLeft[index] + content + padRight[index];
     // `UNBOUNDED` holds an unbounded offer, as it does for the stretch below;
     // it caps the whole split, so the total stays an integer a double holds.
     const pool = budget - spent(wanted) - spent(filled);
     let unshared = Math.min(pool, UNBOUNDED);
-    const parts = ratioDistribute(Math.min(pool + flexible.reduce((sum, index) => sum + padded(index, afterFill[index]), 0), UNBOUNDED), flexible.map((index) => seatedDemands[index].ratio), flexible.map((index) => padded(index, seatedDemands[index].want)));
+    const parts = ratioDistribute(Math.min(pool + flexible.reduce((sum, index) => sum + afterFill[index], 0), UNBOUNDED), flexible.map((index) => seatedDemands[index].ratio), flexible.map((index) => seatedDemands[index].want));
     const shared = seatedDemands.map(() => 0);
     flexible.forEach((index, slot) => {
-        shared[index] = Math.min(Math.max(0, parts[slot] - padded(index, afterFill[index])), unshared);
+        shared[index] = Math.min(Math.max(0, parts[slot] - afterFill[index]), unshared);
         unshared -= shared[index];
     });
     // What the shares leave goes to the columns that stretch, by the width each
-    // already holds with its padding: its natural width, since nothing is left
-    // over while any column is short, or the cap a fill stopped at. The split is
-    // the reference's `ratio_distribute(max_width - table_width, widths)`,
-    // rounding included; the columns it runs over are this port's. A table that
-    // does not expand has no column that stretches, and an empty list takes
-    // nothing, which is how it stays narrower than the width it was offered. The
-    // order is the reference's: Rich pads an expanding table only
-    // once `table_width < max_width`, never while it is collapsing a column.
+    // already holds: its natural width, since nothing is left over while any
+    // column is short, or the cap a fill stopped at. The split is the
+    // reference's `ratio_distribute(max_width - table_width, widths)`, rounding
+    // included; the columns it runs over are this port's. A table that does not
+    // expand has no column that stretches, and an empty list takes nothing,
+    // which is how it stays narrower than the width it was offered. The order is
+    // the reference's: Rich pads an expanding table only once
+    // `table_width < max_width`, never while it is collapsing a column.
     const held = holding(wanted, filled, shared);
     const stretchers = seatedDemands.flatMap((demand, index) => (demand.stretch ? [index] : []));
     const stretches = ratioDistribute(
     // An unbounded offer is held to `UNBOUNDED`, this model's own infinity, as
     // `demandCells` holds a want: `Infinity` is not an integer to split.
-    Math.min(budget - spent(wanted) - spent(filled) - spent(shared), UNBOUNDED), stretchers.map((index) => padded(index, held[index])));
+    Math.min(budget - spent(wanted) - spent(filled) - spent(shared), UNBOUNDED), stretchers.map((index) => held[index]));
     // A table that does not fit gives back each column's `floor`: Rich
     // re-measures a collapsed table's columns at the widths it gave them, and a
     // column with nothing to draw measures 0 there however many cells the collapse
     // left it. Those cells go unspent, as they do in Rich.
-    const natural = demands.reduce((sum, demand) => sum + demand.pad[0] + demand.want + demand.pad[1], frame.edge * 2 + Math.max(0, demands.length - 1) * frame.divider);
+    const natural = demands.reduce((sum, demand) => sum + demand.want, frame.edge * 2 + Math.max(0, demands.length - 1) * frame.divider);
     const squeezed = natural > outerWidth;
-    const columns = held.map((width, index) => squeezed ? width - Math.min(width, seatedDemands[index].floor) : width);
+    const cellWidths = held.map((width, index) => squeezed ? width - Math.min(width, seatedDemands[index].floor) : width);
     stretchers.forEach((index, slot) => {
-        columns[index] += stretches[slot];
+        cellWidths[index] += stretches[slot];
     });
-    const cellWidths = columns.map((width, index) => padded(index, width));
     return {
         edge,
         divider: frame.divider,
-        padLeft,
-        padRight,
-        columns,
         cellWidths,
         totalWidth: edge * 2 +
             Math.max(0, seated - 1) * frame.divider +
@@ -382,6 +334,10 @@ export class Column {
         return col;
     }
 }
+// A row's cell in column `index`: a column the row is short of draws a blank one.
+function cellAt(row, index) {
+    return row.cells[index] ?? new EmbeddedText(undefined);
+}
 export class Table {
     _columns;
     _rows;
@@ -547,7 +503,7 @@ export class Table {
         // Data rows
         for (let rowIdx = 0; rowIdx < this._rows.length; rowIdx++) {
             const row = this._rows[rowIdx];
-            const rowCells = this._columns.map((_, colIdx) => row.cells[colIdx] ?? new EmbeddedText(undefined));
+            const rowCells = this._rowCells(row);
             const rowStyle = stripes[rowIdx % stripes.length] ?? NULL_STYLE;
             const cellStyles = columnStyles.map((s) => s.add(rowStyle));
             yield* this._renderRow(options, rowCells, cellStyles, rowStyle, geometry, rowPadding(firstBody + rowIdx), box, "row", border);
@@ -678,8 +634,11 @@ export class Table {
      * mode gets its own path through the width division.
      *
      * Cells are measured against the width left once the frame is paid, as the
-     * reference's `_measure_column` measures them. Padding and the floor are laid
-     * over whichever sizing the column has: they are the same for all three.
+     * reference's `_measure_column` measures them. Padding is part of every
+     * width the demand names, because the reference measures a cell wrapped in
+     * its `Padding`, and each sizing adds it where the reference does — a
+     * rowless column's minimum is the one width it never reaches. The floor is
+     * laid over whichever sizing the column has.
      */
     _columnDemands(options, outerWidth) {
         const frame = this._frame();
@@ -688,13 +647,12 @@ export class Table {
             maxWidth: Math.max(0, outerWidth - frame.edge * 2 - frame.divider * Math.max(0, this._columns.length - 1)),
         };
         return this._columns.map((col, index) => {
-            const pad = this._columnPadding(index);
-            const sizing = this._columnSizing(col, index, inner);
-            const floor = pad[0] + sizing.want + pad[1] === 0 ? 1 : 0;
-            return { ...sizing, minimum: sizing.minimum + floor, want: sizing.want + floor, pad, floor };
+            const sizing = this._columnSizing(col, index, inner, this._columnPadding(index));
+            const floor = sizing.want === 0 ? 1 : 0;
+            return { ...sizing, minimum: sizing.minimum + floor, want: sizing.want + floor, floor };
         });
     }
-    _columnSizing(col, index, options) {
+    _columnSizing(col, index, options, [left, right]) {
         // A flexible column takes its share of whatever the bounded columns
         // leave; every other column asks for its natural width, whether or not a
         // neighbour is flexible. The split is the reference's —
@@ -703,17 +661,27 @@ export class Table {
         // here a ratio is honoured either way. Its bounded part is its floor —
         // the reference's `column.width or 1`, reading `minWidth` where there is
         // no `width` — bid for in cells like any content column, so a squeezed
-        // table still pays it. A `width` beside a `ratio` is that floor, not a
-        // reservation, as the reference's `flex_minimum` reads it.
+        // table still pays it. A `width` beside a `ratio` is that floor, as the
+        // reference's `flex_minimum` reads it, held to the frame as a declared
+        // width is.
         // [LAW:one-source-of-truth] `columnShare` decides first, so a column that
         // `Column.flexible` calls elastic is one the division shares out.
+        const pad = left + right;
+        const padded = (content) => demandCells(content + pad);
+        // [LAW:single-enforcer] A width a column insists on, held to the width
+        // inside the frame — the reference's `with_maximum(max_width)` on a
+        // fixed-width column's measurement — so an even cut starts from what the
+        // table can hold. It holds a declared width and every ratio floor; a
+        // content column's `minWidth` is not held, as the reference clamps to
+        // `min_width` after `with_maximum`.
+        const held = (width) => Math.min(padded(demandCells(width)), options.maxWidth);
         const share = columnShare(col);
         if (share > 0) {
             const floor = Math.max(1, demandCells(col.width ?? col.minWidth ?? 0));
+            const bid = held(floor);
             return {
-                reserved: 0,
-                minimum: floor,
-                want: floor,
+                minimum: bid,
+                want: bid,
                 weight: floor,
                 fill: 0,
                 ratio: share,
@@ -724,11 +692,10 @@ export class Table {
         if (col.width !== undefined) {
             // [LAW:single-enforcer] floored where it is parsed, the same rule
             // `normalizePadding` applies to a negative padding side.
-            const declared = demandCells(col.width);
+            const bid = held(col.width);
             return {
-                reserved: declared,
-                minimum: declared,
-                want: declared,
+                minimum: bid,
+                want: bid,
                 weight: 0,
                 fill: 0,
                 ratio: 0,
@@ -736,8 +703,8 @@ export class Table {
                 wrapable: false,
             };
         }
-        const range = this._cellRange(col, index, options);
-        const natural = demandCells(this._bounded(col, range?.maximum ?? 1));
+        const range = this._cellRange(col, index, options, [left, right]);
+        const natural = demandCells(this._bounded(col, range?.maximum ?? padded(1), pad));
         // `expand` is a stretch rather than a larger want: the column still
         // competes for its natural width like any other, and only the cells left
         // once every column has that are shared out. A larger want looks
@@ -749,25 +716,26 @@ export class Table {
         // One deliberate divergence: Rich stretches declared-width columns as
         // well, so `width: 6` under `expand` renders 21 cells wide — an option
         // quietly meaning something else, the defect rich-justify-0cr exists to
-        // remove. A reservation's stretch is zero above.
+        // remove. A declared width's stretch is zero above.
         //
         // A column with no cell at all — no rows, and neither header nor footer
         // drawn — has nothing to size to, which is not sizing to nothing. The
         // reference measures it `Measurement(1, max_width)`: one cell of content,
         // and a maximum of the whole offer, so a rowless table fills it. Reading
-        // "no cells" as zero sized it to a two-cell box instead. The one cell is
-        // its want, so a `minWidth` is paid like any column's, and the offer is
-        // its `fill`, held to its `maxWidth`.
+        // "no cells" as zero sized it to a two-cell box instead. The one cell and
+        // its padding are its want, so a `minWidth` is paid like any column's,
+        // and the offer is its `fill`, held to its `maxWidth`. Its minimum is the
+        // reference's bare 1, unpadded: `_measure_column` adds the padding only to
+        // a declared width and to the `min_width`/`max_width` clamp.
         //
         // A column that may not wrap has no narrower width than its natural one
         // that keeps its content whole — the reference leaves `no_wrap` columns out
         // of the ones it collapses.
         return {
-            reserved: 0,
-            minimum: col.noWrap ? natural : Math.min(natural, demandCells(this._bounded(col, range?.minimum ?? 1))),
+            minimum: col.noWrap ? natural : Math.min(natural, demandCells(this._bounded(col, range?.minimum ?? 1, pad))),
             want: natural,
             weight: natural,
-            fill: range === undefined ? demandCells(this._bounded(col, UNBOUNDED)) : 0,
+            fill: range === undefined ? demandCells(this._bounded(col, UNBOUNDED, pad)) : 0,
             ratio: 0,
             stretch: this.expand,
             wrapable: !col.noWrap,
@@ -793,6 +761,19 @@ export class Table {
         const collapsed = this.collapsePadding && !last ? Math.max(0, top - bottom) : bottom;
         return [!this.padEdge && first ? 0 : top, !this.padEdge && last ? 0 : collapsed];
     }
+    // Every cell `render` draws, in the order it draws them: row by row, the
+    // header and footer when it shows them.
+    *contents() {
+        if (this.showHeader)
+            yield* this._columns.map((c) => c.header);
+        for (const row of this._rows)
+            yield* this._rowCells(row);
+        if (this.showFooter)
+            yield* this._columns.map((c) => c.footer);
+    }
+    _rowCells(row) {
+        return this._columns.map((_, index) => cellAt(row, index));
+    }
     /**
      * Every cell column `index` draws, in draw order.
      *
@@ -808,18 +789,19 @@ export class Table {
         if (this.showHeader)
             yield col.header;
         for (const row of this._rows)
-            yield row.cells[index] ?? new EmbeddedText(undefined);
+            yield cellAt(row, index);
         if (this.showFooter)
             yield col.footer;
     }
     /**
-     * The widest any cell in a column draws, and the narrowest the column can be
-     * without cutting one — the reference's `_measure_column` — or `undefined`
-     * when the column has no cell to measure. Zero is a column whose cells draw
-     * nothing — a gutter asks for its padding and nothing else — and is not the
-     * same answer. [LAW:types-are-the-program]
+     * The widest any cell in a column draws, its padding included, and the
+     * narrowest the column can be without cutting one — the reference's
+     * `_measure_column` — or `undefined` when the column has no cell to measure.
+     * A column whose cells draw nothing measures its padding — a gutter asks for
+     * that and nothing else — which is not the same answer.
+     * [LAW:types-are-the-program]
      */
-    _cellRange(col, index, options) {
+    _cellRange(col, index, options, [left, right]) {
         let range;
         for (const cell of this._columnCells(col, index)) {
             // The stamped cell, so the width a column asks for is the width its text
@@ -828,7 +810,10 @@ export class Table {
             // [LAW:one-source-of-truth] Measured as the cell measures itself, so a
             // multi-line cell asks for its widest line and a `Panel` for its frame;
             // one that cannot measure itself asks for every cell there is, as in Rich.
-            const measured = Measurement.get(options, cell);
+            // Wrapped in its padding, as the reference's `_get_cells` hands it to
+            // `_measure_column`, so a cell measures what it draws and never past the
+            // width it was offered.
+            const measured = Measurement.get(options, new Padding(cell, [0, right, 0, left]));
             range = {
                 minimum: Math.max(range?.minimum ?? 0, measured.minimum),
                 maximum: Math.max(range?.maximum ?? 0, measured.maximum),
@@ -837,18 +822,20 @@ export class Table {
         return range;
     }
     /**
-     * A natural width held to the column's own `minWidth`/`maxWidth`.
+     * A natural width held to the column's own `minWidth`/`maxWidth`, each
+     * widened by the column's `pad`, as the reference clamps a padded
+     * measurement to `min_width + padding_width`.
      *
      * A bound is a count of cells, read by the rule every width is read by: NaN
      * and a negative are zero cells, so a NaN floor bounds nothing and a NaN
-     * ceiling is a ceiling of zero, as `width: NaN` is. A bare `Math.max` returns
+     * ceiling holds the column to its padding alone, as `width: NaN` does. A bare `Math.max` returns
      * NaN instead, and the column vanishes. [LAW:one-source-of-truth]
      */
-    _bounded(col, natural) {
-        return Math.min(Math.max(natural, cells(col.minWidth ?? 0)), cells(col.maxWidth ?? Infinity));
+    _bounded(col, natural, pad) {
+        return Math.min(Math.max(natural, col.minWidth === undefined ? 0 : cells(col.minWidth) + pad), cells(col.maxWidth ?? Infinity) + pad);
     }
     *_renderRow(options, cells, styles, rowStyle, geometry, [top, bottom], box, level, border) {
-        const { padLeft, padRight, columns } = geometry;
+        const { cellWidths } = geometry;
         // [LAW:dataflow-not-control-flow] Header, body and footer share this path;
         // the level crosses as a value the box answers with glyphs, not a branch.
         const frame = box?.getContentChars(level);
@@ -859,39 +846,36 @@ export class Table {
         const divider = frame && (frame.vertical.trim() === ""
             ? new Segment(frame.vertical, rowStyle.backgroundStyle.add(border))
             : new Segment(frame.vertical, border));
-        // Render each cell onto the canvas the geometry gave its column. Columns
-        // the width could not seat are absent from `columns` and so are never
+        // Render each cell at the width the geometry gave its column. Columns the
+        // width could not seat are absent from `cellWidths` and so are never
         // rendered at all.
-        const paddedWidths = columns.map((cellWidth, index) => padLeft[index] + cellWidth + padRight[index]);
-        const cellLines = columns.map((cellWidth, index) => {
+        const cellLines = cellWidths.map((cellWidth, index) => {
             const col = this._columns[index];
-            const cell = cells[index] ?? embed("");
+            const [left, right] = this._columnPadding(index);
+            // [LAW:single-enforcer] The padding on every side is part of the cell,
+            // drawn by `Padding` as the reference's `_get_cells` wraps each cell in
+            // one: its sides are paid before its content, so a cell too narrow for
+            // them draws as blanks, and a content line sits between its left and
+            // right blanks.
+            const padded = new Padding(cells[index] ?? embed(""), [top, right, bottom, left]);
             // The render's own options with the column's canvas laid over them, so a
             // cell resolves its style names against the same theme as the table. A
             // table stacks its cells, so each is handed the table's rows as a
             // ceiling, never a region to fill — the `Height` contract's
             // `stackedHeight`, where the reference hands a cell `height=None`.
             // Highlighted as its column says, Rich's `highlight=column.highlight`.
-            const segs = [...cell.render({
-                    ...options,
-                    highlight: col.highlight,
-                    maxWidth: cellWidth,
-                    justify: col.justify,
-                    overflow: col.overflow,
-                    noWrap: col.noWrap,
-                    height: stackedHeight(options.height),
-                })];
-            // The padding on every side is part of the cell, as the reference's
-            // `Padding` makes it: a content line sits between its left and right
-            // blanks, and a line above or below is one blank the cell's width.
-            const left = blank(padLeft[index]);
-            const right = blank(padRight[index]);
-            const padLine = () => blank(paddedWidths[index]);
-            return [
-                ...Array.from({ length: top }, padLine),
-                ...Segment.splitAndCropLines(segs, cellWidth).map((line) => [...left, ...line, ...right]),
-                ...Array.from({ length: bottom }, padLine),
-            ];
+            // A cell left no column draws nothing at all, its padding included, as
+            // the reference's `render_lines` draws nothing under one column.
+            const cellOptions = {
+                ...options,
+                highlight: col.highlight,
+                maxWidth: cellWidth,
+                justify: col.justify,
+                overflow: col.overflow,
+                noWrap: col.noWrap,
+                height: stackedHeight(options.height),
+            };
+            return Segment.splitLines(render(padded, cellOptions));
         });
         const maxLines = cellLines.reduce((most, lines) => Math.max(most, lines.length), 1);
         // How many blank lines stand above each cell's content. A header sits on
@@ -902,14 +886,14 @@ export class Table {
             if (frame && geometry.edge === 1) {
                 yield new Segment(frame.left, border);
             }
-            for (let colIdx = 0; colIdx < columns.length; colIdx++) {
+            for (let colIdx = 0; colIdx < cellWidths.length; colIdx++) {
                 if (colIdx > 0 && divider) {
                     yield divider;
                 }
                 const style = styles[colIdx];
                 // A cell with fewer lines than the row contributes blanks, so every
                 // column spans the same number of rows and the frame stays rectangular.
-                const line = cellLines[colIdx][lineIdx - drop[colIdx]] ?? blank(paddedWidths[colIdx]);
+                const line = cellLines[colIdx][lineIdx - drop[colIdx]] ?? blank(cellWidths[colIdx]);
                 // The cell's style is the base its content's own spans layer over, and
                 // it covers the whole cell — its padding and its blank lines too, as
                 // the reference's does — so a background fills the column rather than
@@ -959,7 +943,7 @@ export class Table {
         // lines, and `end="!!"` runs on into the top border there too. Splitting
         // and re-ending each line moved a non-newline `end` onto the title's own
         // row, wider than the table.
-        yield* source.render({
+        yield* render(source, {
             ...options,
             maxWidth: tableWidth,
             justify,

package/dist/renderables/traceback.d.ts

@@ -16,7 +16,7 @@
  * sized and coloured a source-code excerpt this renderer does not produce.
  */
 import { Segment } from "../core/segment.js";
-import type { Renderable, RenderOptions } from "../core/protocol.js";
+import { type Renderable, type RenderOptions } from "../core/protocol.js";
 export interface TracebackOptions {
     suppress?: string[];
     maxFrames?: number;

package/dist/renderables/traceback.js

@@ -18,7 +18,8 @@
 import { Segment } from "../core/segment.js";
 import { RichText } from "../core/text.js";
 import { Pretty, UNSEEN_DATA_BOUNDS } from "../core/pretty.js";
-import { layoutPadding } from "./padding.js";
+import { render } from "../core/protocol.js";
+import { paddedContentWidth } from "./padding.js";
 /**
  * [LAW:parse-dont-validate] The checkpoint between whatever a `catch` caught —
  * JavaScript lets a program throw any value — and the report. Anything with a
@@ -225,7 +226,7 @@ export class Traceback {
         // width that is left on that line rather than overrunning it.
         header.append(message({ ...options, maxWidth: Math.max(1, options.maxWidth - header.cellLength) }));
         header.append("\n\n");
-        yield* header.render(options);
+        yield* render(header, options);
         // A suppressed frame keeps its place and shows its file and line only: it
         // is the same frame with no function name to show.
         const frames = this.caught.frames.map((frame) => this.suppress.some((s) => frame.location.includes(s)) ? { ...frame, function: undefined } : frame);
@@ -253,10 +254,10 @@ export class Traceback {
         // frame of its own. The width is divided as `Padding` divides it; the rows
         // are not padded out on the right, as `Padding`'s are, because trailing
         // blanks on every line of a crash report are bytes nobody asked for.
-        const { left, contentWidth } = layoutPadding(options.maxWidth, 2, 0);
-        const indent = new Segment(" ".repeat(left));
+        const frameOptions = { ...options, maxWidth: paddedContentWidth(options.maxWidth, 2, 0) };
+        const indent = new Segment("  ");
         for (const entry of entries) {
-            for (const line of Segment.splitLines(entry.render({ ...options, maxWidth: contentWidth }))) {
+            for (const line of Segment.splitLines(render(entry, frameOptions))) {
                 yield indent;
                 yield* line;
                 yield Segment.line();

package/dist/renderables/tree.d.ts

@@ -4,14 +4,14 @@
 import { Segment } from "../core/segment.js";
 import { Style } from "../core/style.js";
 import { RichText } from "../core/text.js";
-import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
+import type { Composite, Renderable, Measurable, RenderOptions } from "../core/protocol.js";
 export interface TreeOptions {
     expanded?: boolean;
     hideRoot?: boolean;
     guide_style?: string | Style;
     style?: string | Style;
 }
-export declare class Tree implements Renderable, Measurable {
+export declare class Tree implements Renderable, Measurable, Composite {
     readonly label: Renderable;
     readonly children: Tree[];
     expanded: boolean;
@@ -21,6 +21,7 @@ export declare class Tree implements Renderable, Measurable {
     constructor(label: string | RichText | Renderable, options?: TreeOptions);
     add(label: string | RichText | Renderable, options?: TreeOptions): Tree;
     render(rawOptions: RenderOptions): Iterable<Segment>;
+    contents(): Iterable<Renderable>;
     /**
      * The rows `render` and `measure` both read, entered in exactly one place so
      * the two cannot start the walk differently. A hidden root takes its own row
@@ -59,9 +60,9 @@ export declare class Tree implements Renderable, Measurable {
      * [LAW:single-enforcer] Tree also owns its row boundaries here rather than
      * depending on label renderables to invent trailing newlines: the label's
      * output is cut into lines and every line ends where Tree ends it. A label
-     * that emits nothing still holds its row, and one that ends in a newline of
-     * its own gets the blank row that line is, as in Rich — padded to the label's
-     * width when the label is justified.
+     * that emits nothing — one left no column, say — has no row, and one
+     * that ends in a newline of its own gets the blank row that line is, as in
+     * Rich — padded to the label's width when the label is justified.
      *
      * The node's style sits under the label's own, as Rich's `Styled` puts it, so
      * markup in the label still wins; its background alone reaches under the