@promptctl/rich-js 0.7.0 → 0.8.0

package/dist/renderables/table.d.ts

@@ -95,14 +95,50 @@ export declare class Table implements Renderable, Measurable {
     addColumn(header?: string | RichText, options?: ColumnOptions): this;
     addRow(...cells: unknown[]): this;
     addSection(): this;
-    render(options: RenderOptions): Iterable<Segment>;
-    measure(options: RenderOptions): {
+    render(rawOptions: RenderOptions): Iterable<Segment>;
+    /**
+     * [LAW:one-source-of-truth] Both ends of the range are widths the geometry
+     * actually produced — the maximum from the demands as they stand, the
+     * minimum from the same layout with every column asking for a single cell.
+     * Neither can exceed the width offered and the tighter request cannot exceed
+     * the looser one, so the range cannot invert. Deriving the minimum from raw
+     * column and padding counts instead is what used to return
+     * `{minimum: 6, maximum: 1}` at `maxWidth: 1` — a floor above its own ceiling.
+     */
+    measure(rawOptions: RenderOptions): {
         minimum: number;
         maximum: number;
     };
     static grid(options?: Omit<TableOptions, "box" | "showHeader" | "showEdge">): Table;
-    private _calculateWidths;
-    private _totalTableWidth;
+    private _frame;
+    /**
+     * The width this table lays itself out against: what it was told to be, as a
+     * count of cells, never wider than what it was offered.
+     *
+     * [LAW:one-source-of-truth] `render` and `measure` divide the same two fields
+     * and once did it in two places. `measure` bounded the declared width by the
+     * offer and `render` preferred it outright, walking past the value
+     * `withBoundedWidth` had just resolved — so `new Table({width: Infinity})`
+     * with a `{ratio: 1}` column granted that column `UNBOUNDED` cells and threw
+     * `RangeError: Invalid string length` out of the top border, at a perfectly
+     * ordinary 80-cell offer.
+     */
+    private _outerWidth;
+    private _geometry;
+    /**
+     * [LAW:dataflow-not-control-flow] The three ways a column can be sized —
+     * declared width, ratio, natural content — differ only in the `want` and
+     * `weight` they produce. They are resolved once, here, into uniform data, so
+     * `layoutTable` runs the same apportionment for every table and no sizing
+     * mode gets its own path through the width division.
+     */
+    private _columnDemands;
+    /**
+     * The widest cell in a column, bounded by its own `minWidth`/`maxWidth`.
+     * Zero for a column with no header and no content — a gutter asks for its
+     * padding and nothing else.
+     */
+    private _naturalWidth;
     private _renderRow;
     private _renderTitle;
 }

package/dist/renderables/table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/renderables/table.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/renderables/table.ts"],"names":[],"mappings":"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"}

package/dist/renderables/table.js

@@ -1,11 +1,13 @@
 /**
  * Table — tabular data with headers, borders, auto-sizing, and alignment.
  */
-import { cellLen } from "../core/cells.js";
+import { cellLen, setCellSize, asCellCol, cellCount as cells } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { Style, NULL_STYLE } from "../core/style.js";
 import { HEAVY_HEAD } from "../core/box.js";
 import { RichText } from "../core/text.js";
+import { normalizePadding } from "./padding.js";
+import { withBoundedWidth, withCellWidth } from "../core/protocol.js";
 function resolveStyle(style) {
     if (style === undefined)
         return NULL_STYLE;
@@ -21,14 +23,143 @@ function toRenderable(content) {
     }
     return new RichText(String(content ?? ""), { end: "" });
 }
-function normalizePadding(padding) {
-    if (padding === undefined)
-        return [0, 1, 0, 1];
-    if (typeof padding === "number")
-        return [padding, padding, padding, padding];
-    if (padding.length === 2)
-        return [padding[0], padding[1], padding[0], padding[1]];
-    return padding;
+/** A `want` no budget can satisfy: the column takes every cell its weight earns. */
+const UNBOUNDED = Number.MAX_SAFE_INTEGER;
+/**
+ * A column's `want` or `weight`. Finite, because `UNBOUNDED` is this model's
+ * own infinity: a literal `Infinity` reaching `distribute` makes a column's
+ * weighted share `Infinity / Infinity`, which is NaN, and the NaN then skews
+ * every other elastic column in the table.
+ */
+const demandCells = (n) => Math.min(cells(n), UNBOUNDED);
+/**
+ * Hand out `total` cells across `demands`, weighted, and never past a demand's
+ * `want`.
+ *
+ * A column whose proportional share would overshoot its cap is granted its
+ * whole want and dropped, and the cells it could not use are reopened to the
+ * columns still under their caps. That repeats until everyone still open fits
+ * within their share; one largest-remainder pass then places the cells the
+ * shares left as fractions, so the granted widths sum to `total` exactly — or
+ * to the point where every column is capped, which is how a table stays
+ * narrower than a width it was offered.
+ *
+ * Each round caps at least one column or is the last, so the work is bounded by
+ * the number of columns and never by the width. That bound is the point rather
+ * than an optimization: handing cells out one at a time made the iteration
+ * count the width itself, which stalled on a very wide table and — since
+ * `Infinity - 1 === Infinity` — never terminated at all for a `maxWidth` of
+ * `Infinity` held open by a ratio column. Capping by want reaches that case in
+ * one round.
+ */
+function distribute(total, demands) {
+    const granted = demands.map(() => 0);
+    let open = demands
+        .map((_, index) => index)
+        .filter((index) => demands[index].weight > 0 && demands[index].want > 0);
+    let remaining = Math.max(0, total);
+    const weightOf = (indices) => indices.reduce((sum, index) => sum + demands[index].weight, 0);
+    while (open.length > 0 && remaining > 0) {
+        const weightSum = weightOf(open);
+        const capped = open.filter((index) => (remaining * demands[index].weight) / weightSum >= demands[index].want);
+        if (capped.length === 0)
+            break;
+        for (const index of capped) {
+            granted[index] = demands[index].want;
+            remaining -= demands[index].want;
+        }
+        open = open.filter((index) => !capped.includes(index));
+    }
+    if (open.length > 0 && remaining > 0) {
+        const weightSum = weightOf(open);
+        const shares = open.map((index) => (remaining * demands[index].weight) / weightSum);
+        const whole = shares.map(Math.floor);
+        let residue = remaining - whole.reduce((sum, cells) => sum + cells, 0);
+        // The cells the shares left as fractions go to the largest fraction first,
+        // ties to the leftmost column, so the total lands exactly on `remaining`.
+        const byFraction = open
+            .map((_, slot) => slot)
+            .sort((a, b) => shares[b] - whole[b] - (shares[a] - whole[a]) || a - b);
+        for (const slot of byFraction) {
+            if (residue <= 0)
+                break;
+            whole[slot]++;
+            residue--;
+        }
+        open.forEach((index, slot) => {
+            granted[index] = whole[slot];
+        });
+    }
+    return granted;
+}
+function layoutTable(outerWidth, demands, padding, frame) {
+    const [, padRightWanted, , padLeftWanted] = padding;
+    // Plain `number`, not the `CellCol` `cells` hands back: this budget is spent
+    // down by arithmetic, and arithmetic on a branded type produces a number.
+    let budget = cells(outerWidth);
+    const take = (want) => {
+        const got = Math.min(Math.max(0, want), budget);
+        budget -= got;
+        return got;
+    };
+    // Both edge columns or neither: `Box.getTop` and its siblings take a single
+    // 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 uniform across columns or it is not padding, so it is bought
+    // for every seated column at once and skipped entirely when only some could
+    // afford it.
+    const takePerColumn = (want) => {
+        const per = seated === 0
+            ? 0
+            : Math.min(Math.max(0, want), Math.floor(budget / seated));
+        budget -= per * seated;
+        return per;
+    };
+    const padLeft = takePerColumn(padLeftWanted);
+    const padRight = takePerColumn(padRightWanted);
+    // 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 seatedDemands = demands.slice(0, seated);
+    const reserved = seatedDemands.map((demand, index) => take(demand.reserved - seats[index]));
+    // What is left to apportion is the rest of what each column wanted. A table
+    // whose columns all fit leaves this budget partly unspent, which is how it
+    // stays narrower than the width it was offered.
+    const extra = distribute(budget, seatedDemands.map((demand, index) => ({
+        reserved: 0,
+        want: Math.max(0, demand.want - seats[index] - reserved[index]),
+        weight: demand.weight,
+    })));
+    const columns = extra.map((cells, index) => seats[index] + reserved[index] + cells);
+    const cellWidths = columns.map((width) => padLeft + width + padRight);
+    return {
+        edge,
+        divider: frame.divider,
+        padLeft,
+        padRight,
+        columns,
+        cellWidths,
+        totalWidth: edge * 2 +
+            Math.max(0, seated - 1) * frame.divider +
+            cellWidths.reduce((sum, width) => sum + width, 0),
+    };
 }
 export class Column {
     header;
@@ -134,7 +265,7 @@ export class Table {
         this.showFooter = options?.showFooter ?? false;
         this.showLines = options?.showLines ?? false;
         this.showEdge = options?.showEdge !== false;
-        this.padding = normalizePadding(options?.padding);
+        this.padding = normalizePadding(options?.padding ?? [0, 1, 0, 1]);
         this.style = resolveStyle(options?.style);
         this.headerStyle = resolveStyle(options?.headerStyle ?? "table.header");
         this.footerStyle = resolveStyle(options?.footerStyle ?? "table.footer");
@@ -183,78 +314,96 @@ export class Table {
         }
         return this;
     }
-    *render(options) {
+    *render(rawOptions) {
         if (this._columns.length === 0) {
             yield Segment.line();
             return;
         }
+        const options = withBoundedWidth(rawOptions, this);
         const box = this.box
             ? (options.asciiOnly ? this.box.substitute({ asciiOnly: true }) : this.box)
             : null;
         const border = this.borderStyle.isNull ? undefined : this.borderStyle;
-        // Calculate column widths
-        const totalWidth = this.tableWidth ?? (this.expand ? options.maxWidth : undefined);
-        const colWidths = this._calculateWidths(options, totalWidth);
-        const tableActualWidth = this._totalTableWidth(colWidths, box);
-        const [_padTop, padRight, _padBottom, padLeft] = this.padding;
+        // The one division of the width every row below is measured against.
+        const geometry = this._geometry(this._outerWidth(options));
+        const edge = geometry.edge === 1;
         // Title
         if (this.title) {
-            yield* this._renderTitle(this.title, tableActualWidth, this.titleStyle, this.titleJustify);
+            yield* this._renderTitle(this.title, geometry.totalWidth, this.titleStyle, this.titleJustify);
         }
         // Top border
         if (box && this.showEdge) {
-            yield* box.getTop(colWidths.map((w) => w + padLeft + padRight), border, true);
+            yield* box.getTop(geometry.cellWidths, border, edge);
         }
         // Header row
         if (this.showHeader && this._columns.some((c) => c.header.hasContent)) {
             const headerCells = this._columns.map((c) => c.header);
-            yield* this._renderRow(headerCells, colWidths, box, border, this.headerStyle);
+            yield* this._renderRow(headerCells, geometry, box, border, this.headerStyle);
             // Header separator
             if (box) {
-                yield* box.getRow(colWidths.map((w) => w + padLeft + padRight), "head", border, this.showEdge);
+                yield* box.getRow(geometry.cellWidths, "head", border, edge);
             }
         }
         // Data rows
         for (let rowIdx = 0; rowIdx < this._rows.length; rowIdx++) {
             const row = this._rows[rowIdx];
-            const rowCells = [];
-            for (let colIdx = 0; colIdx < this._columns.length; colIdx++) {
-                const cell = row.cells[colIdx];
-                rowCells.push(toRenderable(cell));
-            }
+            const rowCells = this._columns.map((_, colIdx) => toRenderable(row.cells[colIdx]));
             const rowStyle = this.rowStyles.length > 0
                 ? resolveStyle(this.rowStyles[rowIdx % this.rowStyles.length])
                 : NULL_STYLE;
-            yield* this._renderRow(rowCells, colWidths, box, border, rowStyle);
+            yield* this._renderRow(rowCells, geometry, box, border, rowStyle);
             // Row separator
             const showSep = this.showLines || row.endSection;
             if (showSep && box && rowIdx < this._rows.length - 1) {
-                yield* box.getRow(colWidths.map((w) => w + padLeft + padRight), "row", border, this.showEdge);
+                yield* box.getRow(geometry.cellWidths, "row", border, edge);
             }
         }
         // Footer
         if (this.showFooter && this._columns.some((c) => c.footer)) {
             if (box) {
-                yield* box.getRow(colWidths.map((w) => w + padLeft + padRight), "foot", border, this.showEdge);
+                yield* box.getRow(geometry.cellWidths, "foot", border, edge);
             }
             const footerCells = this._columns.map((c) => (c.footer ?? new RichText("", { end: "" })));
-            yield* this._renderRow(footerCells, colWidths, box, border, this.footerStyle);
+            yield* this._renderRow(footerCells, geometry, box, border, this.footerStyle);
         }
         // Bottom border
         if (box && this.showEdge) {
-            yield* box.getBottom(colWidths.map((w) => w + padLeft + padRight), border, true);
+            yield* box.getBottom(geometry.cellWidths, border, edge);
         }
         // Caption
         if (this.caption) {
-            yield* this._renderTitle(this.caption, tableActualWidth, this.captionStyle, this.captionJustify);
+            yield* this._renderTitle(this.caption, geometry.totalWidth, this.captionStyle, this.captionJustify);
         }
     }
-    measure(options) {
-        const colWidths = this._calculateWidths(options);
-        const total = this._totalTableWidth(colWidths, this.box);
+    /**
+     * [LAW:one-source-of-truth] Both ends of the range are widths the geometry
+     * actually produced — the maximum from the demands as they stand, the
+     * minimum from the same layout with every column asking for a single cell.
+     * Neither can exceed the width offered and the tighter request cannot exceed
+     * the looser one, so the range cannot invert. Deriving the minimum from raw
+     * column and padding counts instead is what used to return
+     * `{minimum: 6, maximum: 1}` at `maxWidth: 1` — a floor above its own ceiling.
+     */
+    measure(rawOptions) {
+        const options = withCellWidth(rawOptions);
+        const outerWidth = this._outerWidth(options);
+        const frame = this._frame();
+        const demands = this._columnDemands();
+        const laidOut = layoutTable(outerWidth, demands, this.padding, frame).totalWidth;
+        // `UNBOUNDED` is this table's own infinity, so a layout that reached it has
+        // no natural width to report — a column asked for every cell there is. Said
+        // as the number, it escapes as a width a caller would try to draw:
+        // `minWidth: Infinity` measured 18014398509481988 and rendered
+        // `RangeError: Invalid string length` out of the top border.
+        const maximum = laidOut >= UNBOUNDED ? Infinity : laidOut;
+        const tightest = layoutTable(outerWidth, demands.map((demand) => ({
+            reserved: 0,
+            want: Math.min(1, demand.want),
+            weight: 1,
+        })), this.padding, frame).totalWidth;
         return {
-            minimum: Math.max(this._columns.length * 2, this.minWidth ?? 0),
-            maximum: Math.min(total, options.maxWidth),
+            minimum: Math.min(maximum, Math.max(tightest, this.minWidth ?? 0)),
+            maximum,
         };
     }
     // --- Static ---
@@ -268,142 +417,108 @@ export class Table {
         });
     }
     // --- Private ---
-    _calculateWidths(options, totalWidth) {
-        const numCols = this._columns.length;
-        if (numCols === 0)
-            return [];
-        const [_padTop, padRight, _padBottom, padLeft] = this.padding;
-        const cellPad = padLeft + padRight;
-        const borders = this.box
-            ? (this.showEdge ? 2 : 0) + (numCols - 1)
-            : 0;
-        const availableWidth = (totalWidth ?? options.maxWidth) - borders - cellPad * numCols;
-        const widths = new Array(numCols);
-        // Fixed width columns first
-        let remainingWidth = availableWidth;
-        let flexCols = 0;
-        for (let i = 0; i < numCols; i++) {
-            const col = this._columns[i];
+    _frame() {
+        return {
+            divider: this.box ? 1 : 0,
+            edge: this.box && this.showEdge ? 1 : 0,
+        };
+    }
+    /**
+     * The width this table lays itself out against: what it was told to be, as a
+     * count of cells, never wider than what it was offered.
+     *
+     * [LAW:one-source-of-truth] `render` and `measure` divide the same two fields
+     * and once did it in two places. `measure` bounded the declared width by the
+     * offer and `render` preferred it outright, walking past the value
+     * `withBoundedWidth` had just resolved — so `new Table({width: Infinity})`
+     * with a `{ratio: 1}` column granted that column `UNBOUNDED` cells and threw
+     * `RangeError: Invalid string length` out of the top border, at a perfectly
+     * ordinary 80-cell offer.
+     */
+    _outerWidth(options) {
+        return Math.min(this.tableWidth === undefined ? options.maxWidth : cells(this.tableWidth), options.maxWidth);
+    }
+    _geometry(outerWidth) {
+        return layoutTable(outerWidth, this._columnDemands(), this.padding, this._frame());
+    }
+    /**
+     * [LAW:dataflow-not-control-flow] The three ways a column can be sized —
+     * declared width, ratio, natural content — differ only in the `want` and
+     * `weight` they produce. They are resolved once, here, into uniform data, so
+     * `layoutTable` runs the same apportionment for every table and no sizing
+     * mode gets its own path through the width division.
+     */
+    _columnDemands() {
+        // A ratio on any column makes every non-fixed column elastic: a ratio
+        // expresses a split of the whole width, so a column that declares none
+        // still holds a share of it (1).
+        const elastic = this._columns.some((col) => col.flexible);
+        return this._columns.map((col, index) => {
             if (col.width !== undefined) {
-                widths[i] = col.width;
-                remainingWidth -= col.width;
+                // [LAW:single-enforcer] floored where it is parsed, the same rule
+                // `normalizePadding` applies to a negative padding side.
+                const declared = demandCells(col.width);
+                return { reserved: declared, want: declared, weight: 0 };
             }
-            else {
-                widths[i] = 0;
-                flexCols++;
-            }
-        }
-        // Distribute remaining width among flex columns
-        if (flexCols > 0) {
-            // Measure content to determine natural widths
-            const naturalWidths = [];
-            for (let i = 0; i < numCols; i++) {
-                const col = this._columns[i];
-                if (col.width !== undefined) {
-                    naturalWidths.push(col.width);
-                    continue;
-                }
-                let maxContent = cellLen(col.header.plain);
-                for (const row of this._rows) {
-                    const cell = row.cells[i];
-                    const cellText = String(cell ?? "");
-                    maxContent = Math.max(maxContent, cellLen(cellText));
-                }
-                if (col.minWidth !== undefined)
-                    maxContent = Math.max(maxContent, col.minWidth);
-                if (col.maxWidth !== undefined)
-                    maxContent = Math.min(maxContent, col.maxWidth);
-                naturalWidths.push(maxContent);
-            }
-            // Check if ratio-based distribution applies
-            const hasRatios = this._columns.some((c) => c.flexible);
-            if (hasRatios) {
-                const totalRatio = this._columns.reduce((s, c) => s + (c.ratio ?? 1), 0);
-                for (let i = 0; i < numCols; i++) {
-                    if (this._columns[i].width !== undefined)
-                        continue;
-                    const ratio = this._columns[i].ratio ?? 1;
-                    widths[i] = Math.max(1, Math.floor(remainingWidth * ratio / totalRatio));
-                }
-            }
-            else {
-                // Distribute equally or by natural width
-                const totalNatural = naturalWidths.reduce((s, w, i) => this._columns[i].width !== undefined ? s : s + w, 0);
-                for (let i = 0; i < numCols; i++) {
-                    if (this._columns[i].width !== undefined)
-                        continue;
-                    const natural = naturalWidths[i];
-                    if (totalNatural <= remainingWidth) {
-                        widths[i] = natural;
-                    }
-                    else {
-                        widths[i] = Math.max(1, Math.floor(remainingWidth * natural / totalNatural));
-                    }
-                }
-            }
-        }
-        return widths;
-    }
-    _totalTableWidth(colWidths, box) {
-        const [_padTop, padRight, _padBottom, padLeft] = this.padding;
-        const cellPad = padLeft + padRight;
-        const contentWidth = colWidths.reduce((s, w) => s + w + cellPad, 0);
-        const borders = box
-            ? (this.showEdge ? 2 : 0) + (colWidths.length - 1)
-            : 0;
-        return contentWidth + borders;
+            if (elastic)
+                return { reserved: 0, want: UNBOUNDED, weight: demandCells(col.ratio ?? 1) };
+            const natural = demandCells(this._naturalWidth(col, index));
+            return { reserved: 0, want: natural, weight: natural };
+        });
     }
-    *_renderRow(cells, colWidths, box, border, rowStyle) {
-        const [_padTop, padRight, _padBottom, padLeft] = this.padding;
-        // Render each cell and split into lines
-        const cellLines = [];
-        let maxLines = 1;
-        for (let i = 0; i < this._columns.length; i++) {
-            const col = this._columns[i];
-            const cell = cells[i] ?? toRenderable("");
-            const cellWidth = colWidths[i] ?? 1;
-            const cellOpts = {
-                ...({ maxWidth: cellWidth }),
-                justify: col.justify,
-                overflow: col.overflow,
-                noWrap: col.noWrap,
-            };
-            const segs = [...cell.render(cellOpts)];
-            const lines = Segment.splitLines(segs);
-            const adjusted = lines.map((line) => Segment.adjustLineLength(line, cellWidth));
-            // Ensure at least one line
-            const finalLines = adjusted.length > 0 ? adjusted : [[new Segment(" ".repeat(cellWidth))]];
-            cellLines.push(finalLines);
-            maxLines = Math.max(maxLines, finalLines.length);
+    /**
+     * The widest cell in a column, bounded by its own `minWidth`/`maxWidth`.
+     * Zero for a column with no header and no content — a gutter asks for its
+     * padding and nothing else.
+     */
+    _naturalWidth(col, index) {
+        let natural = cellLen(col.header.plain);
+        for (const row of this._rows) {
+            natural = Math.max(natural, cellLen(String(row.cells[index] ?? "")));
         }
-        // Render line by line
+        if (col.minWidth !== undefined)
+            natural = Math.max(natural, col.minWidth);
+        if (col.maxWidth !== undefined)
+            natural = Math.min(natural, col.maxWidth);
+        return natural;
+    }
+    *_renderRow(cells, geometry, box, border, rowStyle) {
+        const { padLeft, padRight, columns } = geometry;
+        // 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
+        // rendered at all.
+        const cellLines = columns.map((cellWidth, index) => {
+            const col = this._columns[index];
+            const cell = cells[index] ?? toRenderable("");
+            const segs = [...cell.render({
+                    maxWidth: cellWidth,
+                    justify: col.justify,
+                    overflow: col.overflow,
+                    noWrap: col.noWrap,
+                })];
+            const lines = Segment.splitLines(segs).map((line) => Segment.adjustLineLength(line, cellWidth));
+            return lines.length > 0 ? lines : [[new Segment(" ".repeat(cellWidth))]];
+        });
+        const maxLines = cellLines.reduce((most, lines) => Math.max(most, lines.length), 1);
         for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
-            if (box && this.showEdge) {
+            if (box && geometry.edge === 1) {
                 yield new Segment(box.left, border);
             }
-            for (let colIdx = 0; colIdx < this._columns.length; colIdx++) {
+            for (let colIdx = 0; colIdx < columns.length; colIdx++) {
                 if (colIdx > 0 && box) {
                     yield new Segment(box.vertical, border);
                 }
-                const colLines = cellLines[colIdx];
-                const cellWidth = colWidths[colIdx] ?? 1;
-                // Left padding
+                const cellWidth = columns[colIdx];
                 if (padLeft > 0)
                     yield new Segment(" ".repeat(padLeft));
-                const line = colLines[lineIdx];
-                if (line) {
-                    const adjusted = Segment.adjustLineLength(line, cellWidth);
-                    const styled = rowStyle.isNull ? adjusted : [...Segment.applyStyle(adjusted, rowStyle)];
-                    yield* styled;
-                }
-                else {
-                    yield new Segment(" ".repeat(cellWidth));
-                }
-                // Right padding
+                // A cell that ran out of lines contributes blanks, so every column
+                // spans the same number of rows and the frame stays rectangular.
+                const line = cellLines[colIdx][lineIdx] ?? [new Segment(" ".repeat(cellWidth))];
+                yield* rowStyle.isNull ? line : Segment.applyStyle(line, rowStyle);
                 if (padRight > 0)
                     yield new Segment(" ".repeat(padRight));
             }
-            if (box && this.showEdge) {
+            if (box && geometry.edge === 1) {
                 yield new Segment(box.right, border);
             }
             yield Segment.line();
@@ -413,8 +528,11 @@ export class Table {
         const titleStyle = style.isNull ? undefined : style;
         const plain = text.plain;
         const textWidth = cellLen(plain);
+        // Cropped by cells, not by code units: a title of wide characters sliced
+        // at `tableWidth` code units is up to twice `tableWidth` cells on screen,
+        // which is the overflow this crop exists to prevent.
         if (textWidth >= tableWidth) {
-            yield new Segment(plain.slice(0, tableWidth), titleStyle);
+            yield new Segment(setCellSize(plain, asCellCol(tableWidth)), titleStyle);
             yield Segment.line();
             return;
         }