@promptctl/rich-js 0.17.0 → 0.18.1

package/dist/core/place.js

@@ -0,0 +1,51 @@
+/**
+ * place — a renderable's output set down as one block inside a wider width.
+ *
+ * The block is placed, not its lines. The renderable is measured, drawn at the
+ * width it asked for and at its own height — a region's height is dropped, as
+ * the reference's `Align` drops it — and every line is padded to the widest, so the block is a
+ * rectangle; only then is the rectangle padded to the offered width. A
+ * multi-line paragraph keeps its own shape under `"center"` — `hi` over `hello`
+ * stays a 5-cell block, centred as one — where padding each line to the full
+ * width on its own would centre `hi` against the whole terminal. That is
+ * Rich's `Align`, and `test/core/console.test.ts` pins it against the
+ * reference's bytes.
+ *
+ * It lives in `core/` because `Console.print` places with it: Rich's `print`
+ * wraps what it prints in `Align` for the three alignments, and `console.ts`
+ * reaching for `renderables/align.ts` would be a third upward edge out of this
+ * layer. [LAW:one-way-deps] `Align` is this function behind the `Renderable`
+ * interface. [LAW:one-source-of-truth]
+ */
+import { Segment } from "./segment.js";
+import { Measurement } from "./measure.js";
+import { isMeasurable } from "./protocol.js";
+// The share of the spare cells that goes on the left; the rest go on the right.
+// Right-alignment pads no right side at all, which is the reference's choice
+// and not a zero: a line that ends at the edge carries no trailing blanks.
+const PADS = {
+    left: (spare) => [0, spare],
+    center: (spare) => [Math.floor(spare / 2), spare - Math.floor(spare / 2)],
+    right: (spare) => [spare, 0],
+};
+/**
+ * `renderable`'s lines, the block they form placed by `align` in
+ * `options.maxWidth`. `options.maxWidth` must be finite: the spare cells are
+ * written out as spaces. A block wider than the offer — a line with nowhere to
+ * break, drawn by a renderable that does not cut its own — is left unpadded at
+ * its full width, for whatever holds it to crop or keep.
+ */
+export function placeBlock(renderable, align, options) {
+    // A renderable that cannot say how wide it wants to be is offered all of it,
+    // and the block is then only as wide as what it actually drew.
+    const width = isMeasurable(renderable)
+        ? Measurement.get(options, renderable).maximum
+        : options.maxWidth;
+    const drawn = Segment.splitLines(renderable.render({ ...options, maxWidth: width, height: undefined }));
+    const [blockWidth, height] = Segment.getShape(drawn);
+    const [left, right] = PADS[align](Math.max(0, options.maxWidth - blockWidth));
+    return Segment.setShape(drawn, blockWidth, height).map((line) => [...pad(left), ...line, ...pad(right)]);
+}
+// [LAW:dataflow-not-control-flow] no spare room is a pad of no segments, not a
+// step skipped.
+const pad = (cells) => (cells > 0 ? [new Segment(" ".repeat(cells))] : []);

package/dist/core/pretty.d.ts

@@ -17,6 +17,7 @@
  * times.
  */
 import { Segment } from "./segment.js";
+import { RichText } from "./text.js";
 import type { Highlighter } from "./highlighter.js";
 import type { Renderable, Measurable, RenderOptions } from "./protocol.js";
 export interface PrettyOptions {
@@ -56,6 +57,8 @@ export declare class Pretty implements Renderable, Measurable {
     readonly highlighter: Highlighter;
     constructor(data: unknown, options?: PrettyOptions);
     render(options: RenderOptions): Iterable<Segment>;
+    /** The value laid out for `options.maxWidth` and highlighted: the text this renders. */
+    toText(options: RenderOptions): RichText;
     measure(_options: RenderOptions): {
         minimum: number;
         maximum: number;

package/dist/core/pretty.js

@@ -163,13 +163,17 @@ export class Pretty {
         this.highlighter = options?.highlighter ?? reprHighlighter;
     }
     *render(options) {
+        yield* this.toText(options).render(options);
+    }
+    /** The value laid out for `options.maxWidth` and highlighted: the text this renders. */
+    toText(options) {
         const formatted = this._format(this.data, rootFrame(options.maxWidth));
         const text = new RichText(formatted, { end: "" });
         this.highlighter.highlight(text);
         if (this.indentGuides) {
             this._addIndentGuides(text);
         }
-        yield* text.render(options);
+        return text;
     }
     measure(_options) {
         const formatted = this._format(this.data, rootFrame(_options.maxWidth));

package/dist/core/protocol.d.ts

@@ -5,6 +5,17 @@
 import type { Segment } from "./segment.js";
 import { type Style, type StyleSyntaxError, type Theme } from "./style.js";
 import type { ColorDepth } from "./color.js";
+/**
+ * What becomes of a line still wider than its width once wrapping is done.
+ * `"fold"` breaks it across lines, `"crop"` cuts it at the edge, `"ellipsis"`
+ * cuts it and marks the cut. `"ignore"` is not a way of cutting: the line has
+ * no edge, so nothing wraps it and nothing cuts it, and it leaves at its
+ * natural width for whatever drew it to crop or not.
+ *
+ * `noWrap` is the other half of Rich's pair and is not `"ignore"`: it stops the
+ * wrapping and leaves the edge, so a line too wide is cut by the method here.
+ */
+export type OverflowMethod = "fold" | "crop" | "ellipsis" | "ignore";
 export interface RenderOptions {
     /**
      * The cells this renderable may occupy. A count of cells, so a non-negative
@@ -15,14 +26,20 @@ export interface RenderOptions {
      */
     maxWidth: number;
     minWidth?: number;
-    height?: number;
-    maxHeight?: number;
+    /**
+     * The rows this renderable may occupy. Absent, nothing limits them.
+     */
+    height?: Height;
     isTerminal?: boolean;
-    encoding?: string;
-    legacyWindows?: boolean;
+    /**
+     * The output can draw only ASCII. Every glyph a renderable chooses — box
+     * lines, tree guides, a check mark — is resolved through `drawable`. Text
+     * the caller hands in is drawn as given. Absent means the output draws any
+     * glyph.
+     */
     asciiOnly?: boolean;
     justify?: "left" | "center" | "right" | "full";
-    overflow?: "fold" | "crop" | "ellipsis";
+    overflow?: OverflowMethod;
     noWrap?: boolean;
     highlight?: unknown;
     markup?: unknown;
@@ -46,7 +63,95 @@ export interface RenderOptions {
      * the render strict: the error leaves `render`.
      */
     onStyleError?: StyleErrorHandler;
+    /**
+     * Told of each owner that stamps its output (`core/anchor`) as it starts to
+     * render, so the calls arrive in document order: a container's children in
+     * the order it renders them, an owner before the owners nested in it. A
+     * container forwards it by passing its options on, which every container
+     * does. An owner rendered twice is told twice. A render made to measure is
+     * not drawing and is not told (`measuring`).
+     */
+    onDraw?: (owner: object) => void;
+}
+/**
+ * `chosen` as this output can draw it: `ascii` in its place when the output is
+ * ASCII-only and `chosen` spends a glyph outside ASCII, otherwise `chosen`
+ * itself. Choosing a glyph that is already ASCII (a rule of `=`, a MARKDOWN box)
+ * picks a frame the terminal can draw, so it is kept. A set of glyphs that must
+ * change together — a box grid, a spinner's frames, a scrollbar — passes
+ * `glyphs` to say which characters it spends, and is replaced whole.
+ *
+ * [LAW:single-enforcer] The one place that decides what `asciiOnly` replaces.
+ * `test/renderables/ascii-only.test.ts` renders every exported renderable to
+ * hold each of them to it.
+ */
+export declare function drawable(options: {
+    readonly asciiOnly?: boolean;
+}, chosen: string, ascii: string): string;
+export declare function drawable<T>(options: {
+    readonly asciiOnly?: boolean;
+}, chosen: T, ascii: T, glyphs: (value: T) => string): T;
+/**
+ * A vertical budget: a count of rows, and whether they are a region the
+ * renderable stands in or a ceiling it stays under.
+ *
+ * `exact: true` is a region — a `Layout` pane, a full-screen frame. The output
+ * is exactly `rows` tall. A renderable may fill the region — a layout divides
+ * it, a frame can stretch to its last row — or ignore it and emit its natural
+ * height; either way, whoever set the region shapes what comes back to it
+ * (`fitHeight`). Setting a region is a promise to shape, so no renderable pads
+ * or crops itself to one.
+ *
+ * `exact: false` is a ceiling — the terminal an inline print lands on. Content
+ * keeps its natural height beneath it, and nothing pads up to the ceiling.
+ * Output taller than the ceiling is its setter's to handle: an inline `Live`
+ * applies its `verticalOverflow`, and a print lets the terminal scroll it.
+ *
+ * A renderable passing its whole space to one child must forward the budget
+ * less the rows it draws itself, and of the same kind (`insetHeight`). One
+ * stacking several children must hand each the rows as a ceiling
+ * (`stackedHeight`): any one of them may use all of it, and none may claim it
+ * as its region. Forwarded unchanged, a layout nested in a panel fills the
+ * panel's whole region and the region's crop takes the panel's bottom border.
+ *
+ * [LAW:types-are-the-program] One field, because the fact is one count and one
+ * bit about it. As two numbers, `height` and `maxHeight`, it admitted a region
+ * taller than its ceiling and a region with no ceiling at all, and the one
+ * reader in the library resolved them `maxHeight ?? height` — the ceiling ahead
+ * of the region it contains.
+ *
+ * There is no vertical `Measurable`. A parent chooses widths from its
+ * children's measurements before any of them renders; nothing chooses rows
+ * that way, because a renderable's height is a consequence of the width it
+ * renders at. Rendering and counting the lines is the measurement.
+ */
+export interface Height {
+    readonly rows: number;
+    readonly exact: boolean;
 }
+/**
+ * The budget a renderable hands the one child filling its space: its own, less
+ * the `rows` it draws itself, and of the same kind.
+ */
+export declare function insetHeight(height: Height | undefined, rows: number): Height | undefined;
+/**
+ * The budget a renderable hands each of several children it stacks: its rows,
+ * as a ceiling.
+ */
+export declare function stackedHeight(height: Height | undefined): Height | undefined;
+/**
+ * The rows a region holds, parsed as a cell count, or `undefined` when there
+ * is no region to fill: a ceiling, no budget, or a region of `Infinity` rows,
+ * which names no count — as an unbounded width resolves to a natural one in
+ * `withBoundedWidth`.
+ */
+export declare function regionRows(height: Height | undefined): number | undefined;
+/**
+ * What came back from a child, held to the region `height` names — blank rows
+ * padded below, overflow cropped from the bottom — or left at its own height
+ * when `height` is no region. This is the shaping a region's setter owes.
+ */
+export declare function fitHeight(lines: Segment[][], height: Height | undefined): Segment[][];
 /**
  * Receives a style error a render would otherwise absorb: the parse failure,
  * and the whole style string it came from — the error names only the token
@@ -58,7 +163,12 @@ export interface RenderOptions {
  */
 export type StyleErrorHandler = (error: StyleSyntaxError, style: string) => void;
 /**
- * The style a `string | Style` stands for in this render.
+ * The style a `string | Style` stands for in this render: a name from the
+ * theme of whatever is drawing, otherwise a style definition. A string that is
+ * neither throws `StyleSyntaxError`. This is how a renderable that yields its
+ * own `Segment`s draws with a theme name, since a `Segment` takes a resolved
+ * `Style`. It is Rich's `console.get_style`, asked of the options because the
+ * options are where the theme travels.
  *
  * [LAW:single-enforcer] Every renderable resolves a style name here, at render
  * time, because only the render knows whose theme it is drawing for. Resolved
@@ -123,6 +233,16 @@ export declare function withCellWidth(options: RenderOptions): RenderOptions;
  * rather than zero, and saying so names the cause — where `String.repeat` and
  * `new Array` only ever name their own argument.
  */
+/**
+ * `options` as a measurement is asked with. A `measure` that renders to learn
+ * its shape draws nothing on the frame, so it reports no owner to `onDraw` —
+ * one that did would put a widget in document order at the moment a
+ * container measured it, and keep one the frame then cropped away.
+ *
+ * [LAW:single-enforcer] Every measurement starts here: `Measurement.get` and
+ * `withBoundedWidth` ask through it, and each `measure` passes it on.
+ */
+export declare function measuring(options: RenderOptions): RenderOptions;
 export declare function withBoundedWidth(options: RenderOptions, self: Measurable): RenderOptions;
 export interface Renderable {
     render(options: RenderOptions): Iterable<Segment>;
@@ -133,5 +253,15 @@ export interface Measurable {
         maximum: number;
     };
 }
+/**
+ * What the wheel scrolls: an owner of anchors on the frame (`./anchor.ts`)
+ * that moves by lines. `canScrollBy` says whether `scrollBy` with the same
+ * `lines` would move it; one that would not passes the wheel outward.
+ */
+export interface Scrollable {
+    canScrollBy(lines: number): boolean;
+    scrollBy(lines: number): void;
+}
 export declare function isRenderable(obj: unknown): obj is Renderable;
 export declare function isMeasurable(obj: unknown): obj is Measurable;
+export declare function isScrollable(obj: object): obj is Scrollable;

package/dist/core/protocol.js

@@ -4,8 +4,52 @@
  */
 import { cellCount } from "./cells.js";
 import { DEFAULT_THEME } from "./style.js";
+const ASCII_TEXT = /^[\x00-\x7F]*$/;
+export function drawable(options, chosen, ascii, glyphs = String) {
+    return options.asciiOnly === true && !ASCII_TEXT.test(glyphs(chosen)) ? ascii : chosen;
+}
+/**
+ * The budget a renderable hands the one child filling its space: its own, less
+ * the `rows` it draws itself, and of the same kind.
+ */
+export function insetHeight(height, rows) {
+    return height && { rows: cellCount(height.rows - rows), exact: height.exact };
+}
+/**
+ * The budget a renderable hands each of several children it stacks: its rows,
+ * as a ceiling.
+ */
+export function stackedHeight(height) {
+    return height && { rows: cellCount(height.rows), exact: false };
+}
+/**
+ * The rows a region holds, parsed as a cell count, or `undefined` when there
+ * is no region to fill: a ceiling, no budget, or a region of `Infinity` rows,
+ * which names no count — as an unbounded width resolves to a natural one in
+ * `withBoundedWidth`.
+ */
+export function regionRows(height) {
+    return height?.exact && height.rows !== Infinity ? cellCount(height.rows) : undefined;
+}
 /**
- * The style a `string | Style` stands for in this render.
+ * What came back from a child, held to the region `height` names — blank rows
+ * padded below, overflow cropped from the bottom — or left at its own height
+ * when `height` is no region. This is the shaping a region's setter owes.
+ */
+export function fitHeight(lines, height) {
+    const rows = regionRows(height) ?? lines.length;
+    const fitted = lines.slice(0, rows);
+    while (fitted.length < rows)
+        fitted.push([]);
+    return fitted;
+}
+/**
+ * The style a `string | Style` stands for in this render: a name from the
+ * theme of whatever is drawing, otherwise a style definition. A string that is
+ * neither throws `StyleSyntaxError`. This is how a renderable that yields its
+ * own `Segment`s draws with a theme name, since a `Segment` takes a resolved
+ * `Style`. It is Rich's `console.get_style`, asked of the options because the
+ * options are where the theme travels.
  *
  * [LAW:single-enforcer] Every renderable resolves a style name here, at render
  * time, because only the render knows whose theme it is drawing for. Resolved
@@ -74,11 +118,23 @@ export function withCellWidth(options) {
  * rather than zero, and saying so names the cause — where `String.repeat` and
  * `new Array` only ever name their own argument.
  */
+/**
+ * `options` as a measurement is asked with. A `measure` that renders to learn
+ * its shape draws nothing on the frame, so it reports no owner to `onDraw` —
+ * one that did would put a widget in document order at the moment a
+ * container measured it, and keep one the frame then cropped away.
+ *
+ * [LAW:single-enforcer] Every measurement starts here: `Measurement.get` and
+ * `withBoundedWidth` ask through it, and each `measure` passes it on.
+ */
+export function measuring(options) {
+    return { ...options, onDraw: undefined };
+}
 export function withBoundedWidth(options, self) {
     const parsed = withCellWidth(options);
     if (Number.isFinite(parsed.maxWidth))
         return parsed;
-    const natural = self.measure(parsed).maximum;
+    const natural = self.measure(measuring(parsed)).maximum;
     if (!Number.isFinite(natural)) {
         throw new RangeError("maxWidth is unbounded and this renderable has no natural width to fall " +
             "back on: its content does not implement measure(), or something inside " +
@@ -99,3 +155,9 @@ export function isMeasurable(obj) {
         "measure" in obj &&
         typeof obj.measure === "function");
 }
+export function isScrollable(obj) {
+    return ("canScrollBy" in obj &&
+        typeof obj.canScrollBy === "function" &&
+        "scrollBy" in obj &&
+        typeof obj.scrollBy === "function");
+}

package/dist/core/render.d.ts

@@ -38,8 +38,8 @@
 import { ColorDepth } from "./color.js";
 import type { Destination } from "./color.js";
 import type { Segment } from "./segment.js";
-import type { Renderable } from "./protocol.js";
-export interface RenderToStringOptions {
+import type { Renderable, RenderOptions } from "./protocol.js";
+export interface RenderToStringOptions extends Pick<RenderOptions, "asciiOnly" | "onStyleError"> {
     /** Cell width to render into. Default 80. */
     width?: number;
     /**

package/dist/core/render.js

@@ -135,8 +135,8 @@ export function renderToString(renderable, options) {
     const renderOptions = {
         maxWidth: width,
         isTerminal: false,
-        encoding: "utf-8",
-        asciiOnly: false,
+        asciiOnly: options?.asciiOnly ?? false,
+        onStyleError: options?.onStyleError,
         // [LAW:one-source-of-truth] The depth the segments below are encoded at,
         // so a renderable measures what this very call will draw.
         colorSystem: destination.colorSystem,

package/dist/core/segment.d.ts

@@ -4,6 +4,7 @@
  */
 import { type CellCol } from "./cells.js";
 import { Style } from "./style.js";
+import { type Anchor } from "./anchor.js";
 export declare enum ControlType {
     BELL = "bell",
     CARRIAGE_RETURN = "carriage_return",
@@ -33,10 +34,27 @@ export declare class Segment {
     get isControl(): boolean;
     /**
      * Splits at a cell position. Returns [left, right].
+     *
+     * [LAW:single-enforcer] The right half starts as many cells further into
+     * whatever drew it as the left half took from this one, and its anchor says
+     * so; see `./anchor.ts`. That is not `leftText`'s width: a cut through a
+     * wide glyph pads the left half and keeps the whole glyph on the right.
      */
     splitCells(position: CellCol): [Segment, Segment];
     private static _line;
     static line(): Segment;
+    /**
+     * `lines`, as drawn by `owner`: every segment stamped with the row and
+     * column of its first cell, wrapping whatever anchor it already carried.
+     * Control segments occupy no cell and are left as they are. `firstRow` is
+     * the owner's row that `lines[0]` is, for output that arrives in pieces.
+     */
+    static anchorLines(lines: Segment[][], owner: object, firstRow?: number): Segment[][];
+    /**
+     * The anchor of the cell at column `x` of row `y` in a composed frame, or
+     * `undefined` when that cell was drawn by no owner or lies outside the frame.
+     */
+    static anchorAt(lines: readonly (readonly Segment[])[], x: number, y: number): Anchor | undefined;
     /**
      * Yields segments with combined styles.
      */
@@ -79,6 +97,11 @@ export declare class Segment {
      * nothing, and a segment the crop did not change leaves as itself.
      */
     static cropLines(segments: Iterable<Segment>, width: number): Iterable<Segment>;
+    /**
+     * Splits a renderable's output into rows, each exactly `width` cells:
+     * short rows padded with spaces, long ones cut.
+     */
+    static splitAndCropLines(segments: Iterable<Segment>, width: number): Segment[][];
     /**
      * Returns total cell width of a line. Ignores control segments.
      */
@@ -135,8 +158,4 @@ export declare class Segment {
      * Forces lines to exactly width x height.
      */
     static setShape(lines: Segment[][], width: number, height: number, style?: Style): Segment[][];
-    /**
-     * Splits segments into lines and adjusts each to exactly `width` cells.
-     */
-    static splitAndCropLines(segments: Iterable<Segment>, width: number, pad?: boolean, includeNewLines?: boolean, style?: Style): Segment[][];
 }

package/dist/core/segment.js

@@ -3,6 +3,8 @@
  * is represented as a Segment: (text, style?, control?).
  */
 import { cellLen, splitText, asCellCol } from "./cells.js";
+import { Style } from "./style.js";
+import { shiftAnchor } from "./anchor.js";
 // --- ControlType ---
 export var ControlType;
 (function (ControlType) {
@@ -44,6 +46,11 @@ export class Segment {
     }
     /**
      * Splits at a cell position. Returns [left, right].
+     *
+     * [LAW:single-enforcer] The right half starts as many cells further into
+     * whatever drew it as the left half took from this one, and its anchor says
+     * so; see `./anchor.ts`. That is not `leftText`'s width: a cut through a
+     * wide glyph pads the left half and keeps the whole glyph on the right.
      */
     splitCells(position) {
         const len = this.cellLength;
@@ -54,7 +61,7 @@ export class Segment {
         const [leftText, rightText] = splitText(this.text, position);
         return [
             new Segment(leftText, this.style),
-            new Segment(rightText, this.style),
+            new Segment(rightText, this.style?.shiftedBy(len - cellLen(rightText))),
         ];
     }
     // --- Static factories ---
@@ -63,10 +70,54 @@ export class Segment {
         return (Segment._line ??= new Segment("\n"));
     }
     // --- Static transformations ---
+    /**
+     * `lines`, as drawn by `owner`: every segment stamped with the row and
+     * column of its first cell, wrapping whatever anchor it already carried.
+     * Control segments occupy no cell and are left as they are. `firstRow` is
+     * the owner's row that `lines[0]` is, for output that arrives in pieces.
+     */
+    static anchorLines(lines, owner, firstRow = 0) {
+        return lines.map((line, i) => {
+            const row = firstRow + i;
+            let col = 0;
+            return line.map((segment) => {
+                if (segment.isControl)
+                    return segment;
+                const style = segment.style ?? Style.null();
+                const anchored = new Segment(segment.text, style.withAnchor({ owner, row, col, inner: style.anchor }));
+                col += segment.cellLength;
+                return anchored;
+            });
+        });
+    }
+    /**
+     * The anchor of the cell at column `x` of row `y` in a composed frame, or
+     * `undefined` when that cell was drawn by no owner or lies outside the frame.
+     */
+    static anchorAt(lines, x, y) {
+        if (!Number.isInteger(x) || x < 0)
+            return undefined;
+        let start = 0;
+        for (const segment of lines[y] ?? []) {
+            const end = start + segment.cellLength;
+            if (x < end) {
+                const anchor = segment.style?.anchor;
+                return anchor && shiftAnchor(anchor, x - start);
+            }
+            start = end;
+        }
+        return undefined;
+    }
     /**
      * Yields segments with combined styles.
      */
     static *applyStyle(segments, style, postStyle) {
+        // Applying no style is the identity, so the segments pass through as they
+        // are instead of each being copied into an equal one.
+        if (!style && !postStyle) {
+            yield* segments;
+            return;
+        }
         for (const segment of segments) {
             if (segment.isControl) {
                 yield segment;
@@ -156,6 +207,22 @@ export class Segment {
         }
         return result;
     }
+    // --- Bounding output to a width ---
+    //
+    // Two primitives, because containers ask two different questions of content.
+    //
+    // `cropLines` — *keep the structure, bound it*. The container needs no line
+    // to overrun and must not pad: a `Layout` leaf and the console's crop pass
+    // the stream on as it is; a `Tree` label splits the cropped stream itself to
+    // hang its guides on each row. The crop never decides how many lines there
+    // are — whoever splits after it owns that.
+    //
+    // `splitAndCropLines` — *decompose into rows of exactly this width*. The
+    // container goes on to compose the rows (a `Table` cell zipped beside its
+    // neighbours), so it needs the two-dimensional shape and every row full.
+    //
+    // The split decides how many lines there are, so it is wrong for the first
+    // question; `cropLines`' header records the two times it was tried there.
     /**
      * Crops a renderable's output so no line exceeds `width`, leaving short lines
      * alone and the line structure exactly as it arrived.
@@ -201,6 +268,13 @@ export class Segment {
             yield cropped === segment.text ? segment : new Segment(cropped, segment.style);
         }
     }
+    /**
+     * Splits a renderable's output into rows, each exactly `width` cells:
+     * short rows padded with spaces, long ones cut.
+     */
+    static splitAndCropLines(segments, width) {
+        return Segment.splitLines(segments).map((line) => Segment.adjustLineLength(line, width));
+    }
     /**
      * Returns total cell width of a line. Ignores control segments.
      */
@@ -407,21 +481,6 @@ export class Segment {
         }
         return result.slice(0, height);
     }
-    /**
-     * Splits segments into lines and adjusts each to exactly `width` cells.
-     */
-    static splitAndCropLines(segments, width, pad = true, includeNewLines = false, style) {
-        const rawLines = Segment.splitLines(segments);
-        const result = [];
-        for (const line of rawLines) {
-            const adjusted = Segment.adjustLineLength(line, width, style, pad);
-            result.push(adjusted);
-            if (includeNewLines) {
-                result[result.length - 1].push(Segment.line());
-            }
-        }
-        return result;
-    }
 }
 // --- Internal helpers ---
 function stylesEqual(a, b) {

package/dist/core/spinnerData.d.ts

@@ -6,5 +6,7 @@ export interface SpinnerData {
     readonly frames: readonly string[];
     readonly interval: number;
 }
+/** The spinner an ASCII-only output draws in place of any other. */
+export declare const LINE_SPINNER: SpinnerData;
 export declare const SPINNERS: Record<string, SpinnerData>;
 export declare const DEFAULT_SPINNER = "dots";

package/dist/core/spinnerData.js

@@ -2,12 +2,14 @@
  * Built-in spinner frame data.
  * [LAW:one-type-per-behavior] All spinners are instances of SpinnerData — differ only by frame data.
  */
+/** The spinner an ASCII-only output draws in place of any other. */
+export const LINE_SPINNER = { frames: ["-", "\\", "|", "/"], interval: 130 };
 // [LAW:one-source-of-truth] Single authoritative collection of spinner definitions
 export const SPINNERS = {
     dots: { frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"], interval: 80 },
     dots2: { frames: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"], interval: 80 },
     dots3: { frames: ["⠋", "⠙", "⠚", "⠞", "⠖", "⠦", "⠴", "⠲", "⠳", "⠓"], interval: 80 },
-    line: { frames: ["-", "\\", "|", "/"], interval: 130 },
+    line: LINE_SPINNER,
     line2: { frames: ["⠂", "-", "–", "—", "–", "-"], interval: 100 },
     pipe: { frames: ["┤", "┘", "┴", "└", "├", "┌", "┬", "┐"], interval: 100 },
     simpleDots: { frames: [".  ", ".. ", "...", "   "], interval: 400 },

package/dist/core/strip.d.ts

@@ -27,7 +27,7 @@
  */
 import { Segment } from "./segment.js";
 import { Style } from "./style.js";
-import type { Renderable, RenderOptions } from "./protocol.js";
+import { type Renderable, type RenderOptions } from "./protocol.js";
 /**
  * Items in a `Strip` expose their per-edge style so joiners can paint the
  * transition glyph at each boundary.
@@ -101,10 +101,7 @@ export interface PowerlineJoinerOptions {
  */
 export declare const POWERLINE_JOINER_GLYPHS: Readonly<PowerlineJoinerOptions>;
 export declare class PowerlineJoiner<T extends StyledRenderable = StyledRenderable> implements Joiner<T> {
-    private readonly _glyph;
-    private readonly _divider;
-    private readonly _lead;
-    private readonly _tail;
+    private readonly _glyphs;
     constructor(options?: PowerlineJoinerOptions);
     join(left: T | null, right: T | null): Renderable;
 }
@@ -117,8 +114,7 @@ export interface CapsuleJoinerOptions {
     separator?: string;
 }
 export declare class CapsuleJoiner<T extends StyledRenderable = StyledRenderable> implements Joiner<T> {
-    private readonly _left;
-    private readonly _right;
+    private readonly _caps;
     private readonly _separator;
     constructor(options?: CapsuleJoinerOptions);
     _emit(left: T | null, right: T | null, options: RenderOptions): Iterable<Segment>;