@promptctl/rich-js 0.24.0 → 0.25.0

package/dist/renderables/table.js

@@ -7,10 +7,11 @@ 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";
+import { ListState, State } from "../core/state.js";
 /** A `want` no budget can satisfy: the column takes every cell its weight earns. */
 const UNBOUNDED = Number.MAX_SAFE_INTEGER;
 /**
@@ -106,8 +107,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 +118,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 +130,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 +143,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 +
@@ -304,10 +257,9 @@ export class Column {
     noWrap;
     overflow;
     highlight;
-    _cells;
     constructor(options) {
-        this.header = options?.header;
-        this.footer = options?.footer;
+        this._header = new State(embed(options?.header));
+        this._footer = new State(embed(options?.footer));
         this.headerStyle = options?.headerStyle ?? NULL_STYLE;
         this.footerStyle = options?.footerStyle ?? NULL_STYLE;
         this.style = options?.style ?? NULL_STYLE;
@@ -319,7 +271,6 @@ export class Column {
         this.noWrap = options?.noWrap ?? false;
         this.overflow = options?.overflow ?? "ellipsis";
         this.highlight = options?.highlight ?? false;
-        this._cells = [];
     }
     /**
      * The two stamped cells, stamped on assignment rather than at the constructor.
@@ -339,30 +290,30 @@ export class Column {
      * which is why the setters take `undefined` rather than defaulting around it.
      */
     get header() {
-        return this._header;
+        return this._header.get();
     }
     set header(content) {
-        this._header = embed(content);
+        this._header.set(embed(content));
     }
     get footer() {
-        return this._footer;
+        return this._footer.get();
     }
     set footer(content) {
-        this._footer = embed(content);
+        this._footer.set(embed(content));
     }
     get flexible() {
         return columnShare(this) > 0;
     }
-    /** @internal */
-    addCell(cell) {
-        this._cells.push(cell);
-    }
-    /** @internal */
-    getCells() {
-        return this._cells;
-    }
     copy() {
-        const col = new Column({
+        return new Column({
+            // Shared, not copied, as a row's cells are: `embed` already copied a
+            // caller's `RichText`, what it hands back is never changed, and `embed`
+            // passes a renderable through.
+            header: this.header,
+            footer: this.footer,
+            headerStyle: this.headerStyle,
+            footerStyle: this.footerStyle,
+            style: this.style,
             justify: this.justify,
             width: this.width,
             minWidth: this.minWidth,
@@ -372,19 +323,16 @@ export class Column {
             overflow: this.overflow,
             highlight: this.highlight,
         });
-        col.headerStyle = this.headerStyle;
-        col.footerStyle = this.footerStyle;
-        col.style = this.style;
-        // Shared, not copied, as a row's cells are: `embed` already copied a
-        // caller's `RichText`, and what it hands back is never changed.
-        col._header = this._header;
-        col._footer = this._footer;
-        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;
+    // Rich's Table grows by addColumn and addRow after it is built.
+    _columns = new ListState();
+    _rows = new ListState();
     box;
     _title;
     _caption;
@@ -415,8 +363,6 @@ export class Table {
         return this._caption;
     }
     constructor(options) {
-        this._columns = [];
-        this._rows = [];
         this.box = options?.box !== undefined ? options.box : HEAVY_HEAD;
         // An empty title draws no row, as the reference's `if self.title` draws
         // none; markup that styles nothing is a title, and draws a blank one.
@@ -449,10 +395,10 @@ export class Table {
         this.highlight = options?.highlight ?? false;
     }
     get columns() {
-        return this._columns;
+        return this._columns.get();
     }
     get rowCount() {
-        return this._rows.length;
+        return this._rows.get().length;
     }
     addColumn(header, options) {
         const col = new Column({ ...options, header: header ?? options?.header, highlight: options?.highlight ?? this.highlight });
@@ -481,20 +427,18 @@ export class Table {
         // behind. [LAW:no-ambient-temporal-coupling]
         const resolved = cells.map(embed);
         // Auto-create columns if needed
-        while (this._columns.length < resolved.length) {
+        while (this._columns.get().length < resolved.length) {
             this.addColumn();
         }
-        this._rows.push({ cells: resolved, endSection });
+        this._rows.push({ cells: resolved, endSection: new State(endSection) });
         return this;
     }
     addSection() {
-        if (this._rows.length > 0) {
-            this._rows[this._rows.length - 1].endSection = true;
-        }
+        this._rows.get().at(-1)?.endSection.set(true);
         return this;
     }
     *render(rawOptions) {
-        if (this._columns.length === 0) {
+        if (this._columns.get().length === 0) {
             yield Segment.line();
             return;
         }
@@ -527,17 +471,17 @@ export class Table {
         // once per cell, as the reference's `_get_cells` does per column.
         const headerStyle = getStyle(options, this.headerStyle);
         const footerStyle = getStyle(options, this.footerStyle);
-        const columnStyles = this._columns.map((c) => getStyle(options, c.style));
+        const columnStyles = this._columns.get().map((c) => getStyle(options, c.style));
         const stripes = this.rowStyles.map((s) => getStyle(options, s));
         // Each row's padding above and below, by where it stands among every row
         // the table draws, header and footer included, as the reference counts them.
         const firstBody = this.showHeader ? 1 : 0;
-        const lastRow = firstBody + this._rows.length + (this.showFooter ? 1 : 0) - 1;
+        const lastRow = firstBody + this._rows.get().length + (this.showFooter ? 1 : 0) - 1;
         const rowPadding = (position) => this._rowPadding(position === 0, position === lastRow);
         // Header row
         if (this.showHeader) {
-            const headerCells = this._columns.map((c) => c.header);
-            const headerStyles = this._columns.map((c) => headerStyle.add(getStyle(options, c.headerStyle)));
+            const headerCells = this._columns.get().map((c) => c.header);
+            const headerStyles = this._columns.get().map((c) => headerStyle.add(getStyle(options, c.headerStyle)));
             yield* this._renderRow(options, headerCells, headerStyles, NULL_STYLE, geometry, rowPadding(0), box, "head", border);
             // Header separator
             if (box) {
@@ -545,15 +489,15 @@ 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));
+        for (let rowIdx = 0; rowIdx < this._rows.get().length; rowIdx++) {
+            const row = this._rows.get()[rowIdx];
+            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);
             // Row separator
-            const showSep = this.showLines || row.endSection;
-            if (showSep && box && rowIdx < this._rows.length - 1) {
+            const showSep = this.showLines || row.endSection.get();
+            if (showSep && box && rowIdx < this._rows.get().length - 1) {
                 yield* box.getRow(geometry.cellWidths, "row", border, edge);
             }
         }
@@ -562,8 +506,8 @@ export class Table {
             if (box) {
                 yield* box.getRow(geometry.cellWidths, "foot", border, edge);
             }
-            const footerCells = this._columns.map((c) => c.footer);
-            const footerStyles = this._columns.map((c) => footerStyle.add(getStyle(options, c.footerStyle)));
+            const footerCells = this._columns.get().map((c) => c.footer);
+            const footerStyles = this._columns.get().map((c) => footerStyle.add(getStyle(options, c.footerStyle)));
             yield* this._renderRow(options, footerCells, footerStyles, NULL_STYLE, geometry, rowPadding(lastRow), box, "foot", border);
         }
         // Bottom border
@@ -678,23 +622,25 @@ 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();
         const inner = {
             ...options,
-            maxWidth: Math.max(0, outerWidth - frame.edge * 2 - frame.divider * Math.max(0, this._columns.length - 1)),
+            maxWidth: Math.max(0, outerWidth - frame.edge * 2 - frame.divider * Math.max(0, this._columns.get().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 };
+        return this._columns.get().map((col, index) => {
+            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 +649,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 +680,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 +691,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 +704,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,
@@ -784,7 +740,7 @@ export class Table {
     _columnPadding(index) {
         const [, right, , left] = this.padding;
         const first = index === 0;
-        const last = index === this._columns.length - 1;
+        const last = index === this._columns.get().length - 1;
         const collapsed = this.collapsePadding && !first ? Math.max(0, left - right) : left;
         return [!this.padEdge && first ? 0 : collapsed, !this.padEdge && last ? 0 : right];
     }
@@ -793,6 +749,9 @@ 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];
     }
+    _rowCells(row) {
+        return this._columns.get().map((_, index) => cellAt(row, index));
+    }
     /**
      * Every cell column `index` draws, in draw order.
      *
@@ -807,19 +766,20 @@ export class Table {
     *_columnCells(col, index) {
         if (this.showHeader)
             yield col.header;
-        for (const row of this._rows)
-            yield row.cells[index] ?? new EmbeddedText(undefined);
+        for (const row of this._rows.get())
+            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 +788,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 +800,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 +824,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 col = this._columns[index];
-            const cell = cells[index] ?? embed("");
+        const cellLines = cellWidths.map((cellWidth, index) => {
+            const col = this._columns.get()[index];
+            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 +864,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 +921,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,