@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/core/render.d.ts

@@ -12,12 +12,12 @@
  *
  * [LAW:single-enforcer] The Segment-to-ANSI conversion lives in `segmentToString`
  * and is the single way a segment becomes wire bytes. `segmentsToString` is
- * that encoding joined, and `Console._writeSegments`, `Painter` (every `Live`
+ * that encoding joined, and `Console._writeSegments`, `Renderer` (every `Live`
  * and `App` frame) and `renderToString` all go through it, so terminal output,
  * live and app frames and string export agree by construction.
  *
  * [LAW:one-source-of-truth] What the encoding needs from where it writes
- * arrives as one `Destination` value. Each caller resolves its destination
+ * arrives as one `OutputTarget` value. Each caller resolves its destination
  * once — spec, detection, and its own overrides — and hands it through whole,
  * so a depth is never paired with a link setting taken from somewhere else.
  *
@@ -34,18 +34,18 @@
  * cell lines do. A link split across segments still hovers as one link,
  * because every pair it becomes carries the id `osc8Open` derives from the URL.
  *
- * Colour and hyperlinks are two facts about the destination:
+ * Color and hyperlinks are two facts about the destination:
  * `colorSystem === null` empties every segment's SGR codes, and
- * `hyperlinks === false` drops every segment's link. A colour depth never
- * removes a link — a hyperlink is not a colour, and a NO_COLOR terminal still
+ * `hyperlinks === false` drops every segment's link. A color depth never
+ * removes a link — a hyperlink is not a color, and a NO_COLOR terminal still
  * follows OSC 8. This is where the port departs from the reference, whose
- * `Style.render` returns bare text for a null colour system.
+ * `Style.render` returns bare text for a null color system.
  *
  * The third fact, `reducedMotion`, changes the segment rather than its
  * encoding: `shownOn` takes the style's blink out before it is encoded.
  */
 import { ColorDepth } from "./color.js";
-import type { ColorSystemName, Destination } from "./color.js";
+import type { ColorSystemName, OutputTarget } from "./color.js";
 import type { Env } from "./env.js";
 import { Segment } from "./segment.js";
 import type { Renderable, RenderOptions } from "./protocol.js";
@@ -74,7 +74,7 @@ export interface RenderToStringOptions extends Pick<RenderOptions, "asciiOnly" |
     noColor?: boolean;
     /**
      * Whether OSC 8 hyperlinks are emitted. Independent of `colorSystem`: a
-     * null colour system strips SGR and keeps links. Default: what the
+     * null color system strips SGR and keeps links. Default: what the
      * destination takes — true for an explicit depth, detected under `"auto"`
      * (no TTY or TERM=dumb: false). `false` with `colorSystem: null` is plain text.
      */
@@ -89,17 +89,17 @@ export interface RenderToStringOptions extends Pick<RenderOptions, "asciiOnly" |
  * what was drawn, after `render`. The encoder writes what this returns, and a
  * recording console records it, so every export replays what was written.
  */
-export declare function shownOn(segment: Segment, destination: Destination): Segment;
+export declare function shownOn(segment: Segment, destination: OutputTarget): Segment;
 /**
  * Encodes one segment as ANSI bytes for `destination`: the reference's
  * `Style.render` for that segment, and nothing for a control segment. It seals
  * the segment alone, and a `logical` row's isolate spans its segments, so a row
  * goes through `segmentsToString` whole.
  */
-export declare function segmentToString(segment: Segment, destination: Destination): string;
+export declare function segmentToString(segment: Segment, destination: OutputTarget): string;
 /**
  * Encodes a sequence of segments as ANSI bytes for `destination`, one segment
  * at a time, over what `sealed` lets reach the wire.
  */
-export declare function segmentsToString(segments: Iterable<Segment>, destination: Destination): string;
+export declare function segmentsToString(segments: Iterable<Segment>, destination: OutputTarget): string;
 export declare function renderToString(renderable: Renderable, options?: RenderToStringOptions): string;

package/dist/core/render.js

@@ -12,12 +12,12 @@
  *
  * [LAW:single-enforcer] The Segment-to-ANSI conversion lives in `segmentToString`
  * and is the single way a segment becomes wire bytes. `segmentsToString` is
- * that encoding joined, and `Console._writeSegments`, `Painter` (every `Live`
+ * that encoding joined, and `Console._writeSegments`, `Renderer` (every `Live`
  * and `App` frame) and `renderToString` all go through it, so terminal output,
  * live and app frames and string export agree by construction.
  *
  * [LAW:one-source-of-truth] What the encoding needs from where it writes
- * arrives as one `Destination` value. Each caller resolves its destination
+ * arrives as one `OutputTarget` value. Each caller resolves its destination
  * once — spec, detection, and its own overrides — and hands it through whole,
  * so a depth is never paired with a link setting taken from somewhere else.
  *
@@ -34,17 +34,17 @@
  * cell lines do. A link split across segments still hovers as one link,
  * because every pair it becomes carries the id `osc8Open` derives from the URL.
  *
- * Colour and hyperlinks are two facts about the destination:
+ * Color and hyperlinks are two facts about the destination:
  * `colorSystem === null` empties every segment's SGR codes, and
- * `hyperlinks === false` drops every segment's link. A colour depth never
- * removes a link — a hyperlink is not a colour, and a NO_COLOR terminal still
+ * `hyperlinks === false` drops every segment's link. A color depth never
+ * removes a link — a hyperlink is not a color, and a NO_COLOR terminal still
  * follows OSC 8. This is where the port departs from the reference, whose
- * `Style.render` returns bare text for a null colour system.
+ * `Style.render` returns bare text for a null color system.
  *
  * The third fact, `reducedMotion`, changes the segment rather than its
  * encoding: `shownOn` takes the style's blink out before it is encoded.
  */
-import { ColorDepth, resolveDestination } from "./color.js";
+import { ColorDepth, resolveOutputTarget } from "./color.js";
 import { Segment } from "./segment.js";
 import { render } from "./protocol.js";
 import { OSC8_CLOSE, osc8Open } from "./osc8.js";
@@ -79,8 +79,8 @@ function encoded(segment, destination) {
     // As the reference's `if not text` and `if style:` — no pair around nothing.
     if (text.length === 0 || style === undefined)
         return text;
-    // [LAW:one-type-per-behavior] Colour depth governs SGR only; hyperlinks are
-    // their own fact. Coupling them let a colour setting delete every control.
+    // [LAW:one-type-per-behavior] Color depth governs SGR only; hyperlinks are
+    // their own fact. Coupling them let a color setting delete every control.
     const codes = destination.colorSystem === null ? "" : style.toSgrCodes(destination.colorSystem);
     const styled = codes.length > 0 ? `\x1b[${codes}m${text}\x1b[0m` : text;
     const link = destination.hyperlinks ? style.link : undefined;
@@ -100,7 +100,7 @@ export function renderToString(renderable, options) {
     const width = options?.width ?? DEFAULT_WIDTH;
     // [LAW:dataflow-not-control-flow] An absent spec is truecolor; an explicit
     // `null` stays null (`??` would collapse it).
-    // [LAW:single-enforcer] Specs resolve through `resolveDestination`.
+    // [LAW:single-enforcer] Specs resolve through `resolveOutputTarget`.
     // Stated, never detected: this call's bytes have no known destination, and
     // its output is deterministic.
     const destinationOptions = { reducedMotion: options?.reducedMotion, textOrder: options?.textOrder ?? "plain" };
@@ -109,10 +109,10 @@ export function renderToString(renderable, options) {
     if (options?.isTTY !== undefined)
         destinationOptions.isTTY = options.isTTY;
     const rawSpec = options?.colorSystem;
-    const resolved = resolveDestination(rawSpec === undefined ? ColorDepth.TRUECOLOR : rawSpec, destinationOptions);
+    const resolved = resolveOutputTarget(rawSpec === undefined ? ColorDepth.TRUECOLOR : rawSpec, destinationOptions);
     // [LAW:single-enforcer] This call's overrides are applied here, once, to
     // make the one destination everything below is drawn for. `noColor` is a
-    // colour choice, so it overrides the depth and leaves hyperlinks to the
+    // color choice, so it overrides the depth and leaves hyperlinks to the
     // destination; an explicit `hyperlinks` overrides what the destination takes.
     const destination = {
         ...resolved,

package/dist/core/segment.d.ts

@@ -69,15 +69,15 @@ export declare class Segment {
      * again: a frame of frames answers the next frame's start, a transition
      * `t` until it is done, still content never.
      */
-    static nextChange(segments: Iterable<Segment>): number;
+    static validUntil(segments: Iterable<Segment>): number;
     /**
      * Since when what `segments` show has been what it is, on the same
      * timeline: the latest `Style.hold` among them, the other end of the
-     * hold `nextChange` reads — `t` for a frame something in moves every
+     * hold `validUntil` reads — `t` for a frame something in moves every
      * frame, `-Infinity` for one that always was. What a host running its
      * timeline backwards asks before drawing again.
      */
-    static lastChange(segments: Iterable<Segment>): number;
+    static validFrom(segments: Iterable<Segment>): number;
     /**
      * 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.

package/dist/core/segment.js

@@ -99,23 +99,23 @@ export class Segment {
      * again: a frame of frames answers the next frame's start, a transition
      * `t` until it is done, still content never.
      */
-    static nextChange(segments) {
+    static validUntil(segments) {
         let soonest = Number.POSITIVE_INFINITY;
         for (const segment of segments)
-            soonest = Math.min(soonest, segment.style?.hold.nextChange ?? Number.POSITIVE_INFINITY);
+            soonest = Math.min(soonest, segment.style?.validity.validUntil ?? Number.POSITIVE_INFINITY);
         return soonest;
     }
     /**
      * Since when what `segments` show has been what it is, on the same
      * timeline: the latest `Style.hold` among them, the other end of the
-     * hold `nextChange` reads — `t` for a frame something in moves every
+     * hold `validUntil` reads — `t` for a frame something in moves every
      * frame, `-Infinity` for one that always was. What a host running its
      * timeline backwards asks before drawing again.
      */
-    static lastChange(segments) {
+    static validFrom(segments) {
         let latest = Number.NEGATIVE_INFINITY;
         for (const segment of segments)
-            latest = Math.max(latest, segment.style?.hold.lastChange ?? Number.NEGATIVE_INFINITY);
+            latest = Math.max(latest, segment.style?.validity.validFrom ?? Number.NEGATIVE_INFINITY);
         return latest;
     }
     /**

package/dist/core/strip.d.ts

@@ -1,7 +1,7 @@
 /**
- * Strip + Joiner — edge-aware horizontal layout primitive.
+ * Strip + Separator — edge-aware horizontal layout primitive.
  *
- * A `Strip` renders a horizontal sequence of styled items with a `Joiner`
+ * A `Strip` renders a horizontal sequence of styled items with a `Separator`
  * deciding how each transition between adjacent items looks. The joiner is
  * a pure function of `(leftItem | null, rightItem | null) -> Renderable`,
  * so endpoint joins (the start and end of the strip) are explicit positions
@@ -35,12 +35,12 @@ import { type Measurable, type Renderable, type RenderOptions } from "./protocol
  * transition glyph at each boundary.
  *
  * `edgeStyle("left", options)` reports the style of the item's leftmost cell
- * column; `edgeStyle("right", options)` reports the rightmost. Joiners read
+ * column; `edgeStyle("right", options)` reports the rightmost. Separators read
  * only these — the item's interior may carry any per-column variation without
  * breaking the join.
  *
  * The edge is asked in a render, with that render's options, because a style
- * name only becomes a colour against the render's theme. A joiner therefore
+ * name only becomes a color against the render's theme. A joiner therefore
  * reads edges inside the `render` of what it returns, never in `join`.
  */
 export interface StyledRenderable extends Renderable {
@@ -56,7 +56,7 @@ export interface StyledRenderable extends Renderable {
 export interface JoinContext {
     readonly index: number;
 }
-export interface Joiner<T extends StyledRenderable = StyledRenderable> {
+export interface Separator<T extends StyledRenderable = StyledRenderable> {
     /**
      * `left === null` marks the start endpoint; `right === null` marks the end
      * endpoint. The joiner decides what an endpoint looks like — typically
@@ -66,21 +66,21 @@ export interface Joiner<T extends StyledRenderable = StyledRenderable> {
 }
 /**
  * The owner every cell a strip's joiner draws is stamped with
- * (`Segment.anchorLines`), whatever the joiner: a seam is told by what drew
+ * (`Segment.anchorLines`), whatever the separator: a seam is told by what drew
  * it, never by its glyph, which an ASCII joiner draws otherwise and a lead may
  * not draw at all. An effect reads it to leave a seam out of the words it
  * keeps legible (`drawnOf`, `../renderables/effect.ts`).
  *
- * Inside it, every cell a `CellJoiner` draws is stamped with what it was
+ * Inside it, every cell a `CellSeparator` draws is stamped with what it was
  * resolved from (`JoinedCell`), so a cell whose neighbours an effect moves is
  * resolved again from where they moved to.
  */
 export declare const JOIN: object;
 /**
- * [LAW:single-enforcer] What `joiner` draws at one join, every cell stamped
+ * [LAW:single-enforcer] What `separator` draws at one join, every cell stamped
  * as `JOIN`'s: the one way `Strip` and `FlexStrip` draw a join.
  */
-export declare function drawJoin<T extends StyledRenderable>(joiner: Joiner<T>, left: T | null, right: T | null, context: JoinContext): Renderable;
+export declare function drawJoin<T extends StyledRenderable>(separator: Separator<T>, left: T | null, right: T | null, context: JoinContext): Renderable;
 /**
  * [LAW:single-enforcer] What `item` draws, every cell stamped as the item's,
  * so whoever holds the composed row reads which item drew a cell however the
@@ -90,8 +90,8 @@ export declare function drawJoin<T extends StyledRenderable>(joiner: Joiner<T>,
 export declare function drawItem(item: StyledRenderable): Renderable;
 export declare class Strip<T extends StyledRenderable = StyledRenderable> implements Renderable, Measurable {
     readonly items: readonly T[];
-    readonly joiner: Joiner<T>;
-    constructor(items: readonly T[], joiner: Joiner<T>);
+    readonly separator: Separator<T>;
+    constructor(items: readonly T[], separator: Separator<T>);
     render(options: RenderOptions): Iterable<Segment>;
     /**
      * [LAW:one-source-of-truth] The width of the one row it draws, and that is
@@ -106,13 +106,13 @@ export declare class Strip<T extends StyledRenderable = StyledRenderable> implem
     };
 }
 /**
- * A colour a joiner's cell is drawn in. Each variant names where the colour
+ * A color a joiner's cell is drawn in. Each variant names where the color
  * comes from when the join is drawn:
  *   • an `edge` — a neighbour's ground (`bg`) or text (`fg`) at the column
  *     facing the join, read through `StyledRenderable.edgeStyle`;
  *   • a `role` — a style name, resolved against the render's theme, whose
- *     foreground colour is the colour;
- *   • a `mix` — two colours blended at `t` (0 is the first, 1 the second).
+ *     foreground color is the color;
+ *   • a `mix` — two colors blended at `t` (0 is the first, 1 the second).
  */
 export type Paint = {
     readonly edge: "left" | "right";
@@ -123,11 +123,11 @@ export type Paint = {
     readonly mix: readonly [Paint, Paint, number];
 };
 /**
- * A `Paint`, or `"ground"`: the terminal's own background, whose colour nobody
+ * A `Paint`, or `"ground"`: the terminal's own background, whose color nobody
  * knows. That is why it is never mixed (`Paint` excludes it), and why a cell
  * may put it on one side only. As a cell's `fg` it is drawn in reverse video —
  * the glyph's ink shows the terminal's background through a cell filled with
- * the `bg` colour — so an inverted shape is the same glyph, never a glyph of
+ * the `bg` color — so an inverted shape is the same glyph, never a glyph of
  * its own.
  */
 export type CellColor = Paint | "ground";
@@ -137,7 +137,7 @@ export type CellColor = Paint | "ground";
  * measure a join by rendering it. Which member stands is hashed from the
  * join's part, its `index` and the cell's place in it, so it holds still from
  * frame to frame while the items before it do, and differs from seam to seam
- * even between the same two colours.
+ * even between the same two colors.
  */
 export interface JoinCell {
     readonly glyph: string | {
@@ -175,15 +175,15 @@ export interface CapsForm {
     readonly tail: readonly JoinCell[];
 }
 /**
- * The middle of a joiner: its seam, and the `ascii` seam an ASCII-only output
+ * The middle of a separator: its seam, and the `ascii` seam an ASCII-only output
  * draws instead. Picked apart from the caps, so any seam ends in any caps.
  */
-export interface JoinSeam {
+export interface SeparatorSeam {
     readonly glyph: SeamForm;
     readonly ascii: SeamForm;
 }
-/** The ends of a joiner: its caps, and the `ascii` caps an ASCII-only output draws instead. */
-export interface JoinCaps {
+/** The ends of a separator: its caps, and the `ascii` caps an ASCII-only output draws instead. */
+export interface EndCaps {
     readonly glyph: CapsForm;
     readonly ascii: CapsForm;
 }
@@ -219,19 +219,19 @@ export interface EdgeMove {
     readonly bgcolor?: ColorSpec;
 }
 /**
- * A cell a `CellJoiner` drew, as what it is: one function of its two
+ * A cell a `CellSeparator` drew, as what it is: one function of its two
  * neighbours' edges. It holds the cell's paints, the neighbour each side of
  * them reads, and the edges and render it was resolved from, and it is stamped
  * on the cell as the owner of its innermost anchor level.
  *
- * [LAW:one-source-of-truth] A seam's colours are its neighbours', so nothing
+ * [LAW:one-source-of-truth] A seam's colors are its neighbours', so nothing
  * paints them but this resolution. An effect paints a strip's items and never
  * a join cell that `follows` them; once the items are painted, each such cell
  * is handed what moved at the item cells beside it and resolved again through
  * `cellStyle`, the path the join was drawn by, lift included
  * (`../renderables/effect.ts`). A seam then follows its neighbours wherever an
  * effect takes them, a mix of the two included, and an effect that paints
- * both one colour leaves the seam's ink lifted off it. A cell painted from
+ * both one color leaves the seam's ink lifted off it. A cell painted from
  * roles and the terminal's ground alone, as `plain`'s separator is, follows
  * nobody, and an effect paints it as it paints any cell.
  */
@@ -272,11 +272,11 @@ export declare class JoinedCell {
         readonly style: Style;
     } | undefined;
 }
-/** The record a `CellJoiner` stamped on the cell `anchor` names, or none for a cell no `CellJoiner` drew. */
+/** The record a `CellSeparator` stamped on the cell `anchor` names, or none for a cell no `CellSeparator` drew. */
 export declare function joinedCell(anchor: Anchor | undefined): JoinedCell | undefined;
 /**
- * The one joiner: what it draws is a `JoinSeam` between neighbours and a
- * `JoinCaps` at the ends of each run, picked independently, so a new joiner is
+ * The one separator: what it draws is a `SeparatorSeam` between neighbours and a
+ * `EndCaps` at the ends of each run, picked independently, so a new joiner is
  * a pair of values, never a class.
  *
  * Which part a join draws is read off its two neighbours. A neighbour is
@@ -291,11 +291,11 @@ export declare function joinedCell(anchor: Anchor | undefined): JoinedCell | und
  *
  * An ASCII-only output draws the `ascii` form of both, whole.
  */
-export declare class CellJoiner<T extends StyledRenderable = StyledRenderable> implements Joiner<T> {
-    readonly seam: JoinSeam;
-    readonly caps: JoinCaps;
+export declare class CellSeparator<T extends StyledRenderable = StyledRenderable> implements Separator<T> {
+    readonly seam: SeparatorSeam;
+    readonly caps: EndCaps;
     private readonly _forms;
-    constructor(seam: JoinSeam, caps: JoinCaps);
+    constructor(seam: SeparatorSeam, caps: EndCaps);
     join(left: T | null, right: T | null, { index }: JoinContext): Renderable;
 }
 /**
@@ -303,65 +303,65 @@ export declare class CellJoiner<T extends StyledRenderable = StyledRenderable> i
  * What each draws is `docs/strip.md`'s "Seams"; any of them ends in any of
  * `CAPS`.
  */
-export declare const SEAMS: Readonly<{
-    powerline: JoinSeam;
-    prism: JoinSeam;
-    slant: JoinSeam;
-    backslant: JoinSeam;
-    flame: JoinSeam;
-    pixel: JoinSeam;
-    ice: JoinSeam;
-    bubble: JoinSeam;
-    capsule: JoinSeam;
-    wrapper: JoinSeam;
-    metro: JoinSeam;
-    stitch: JoinSeam;
-    torn: JoinSeam;
-    plain: JoinSeam;
+export declare const SEPARATORS: Readonly<{
+    powerline: SeparatorSeam;
+    prism: SeparatorSeam;
+    slant: SeparatorSeam;
+    backslant: SeparatorSeam;
+    flame: SeparatorSeam;
+    pixel: SeparatorSeam;
+    ice: SeparatorSeam;
+    bubble: SeparatorSeam;
+    capsule: SeparatorSeam;
+    wrapper: SeparatorSeam;
+    metro: SeparatorSeam;
+    stitch: SeparatorSeam;
+    torn: SeparatorSeam;
+    plain: SeparatorSeam;
 }>;
 /**
  * The bundled caps, by name: what a joiner draws where a run begins and ends.
  * What each draws is `docs/strip.md`'s "Caps"; any of them ends any of
- * `SEAMS`.
+ * `SEPARATORS`.
  */
-export declare const CAPS: Readonly<{
-    powerline: JoinCaps;
-    slant: JoinCaps;
-    backslant: JoinCaps;
-    flame: JoinCaps;
-    pixel: JoinCaps;
-    ice: JoinCaps;
-    bubble: JoinCaps;
-    capsule: JoinCaps;
-    wrapper: JoinCaps;
-    flat: JoinCaps;
+export declare const END_CAPS: Readonly<{
+    powerline: EndCaps;
+    slant: EndCaps;
+    backslant: EndCaps;
+    flame: EndCaps;
+    pixel: EndCaps;
+    ice: EndCaps;
+    bubble: EndCaps;
+    capsule: EndCaps;
+    wrapper: EndCaps;
+    flat: EndCaps;
 }>;
 /**
- * The bundled joiners, by name: each a seam from `SEAMS` ended in caps from
+ * The bundled joiners, by name: each a seam from `SEPARATORS` ended in caps from
  * `CAPS`. What each draws is `docs/strip.md`'s "Built-in joiners"; a name from
- * config is read with `joinerNamed`.
+ * config is read with `separatorNamed`.
  */
-export declare const JOINERS: Readonly<{
-    powerline: CellJoiner<StyledRenderable>;
-    prism: CellJoiner<StyledRenderable>;
-    slant: CellJoiner<StyledRenderable>;
-    backslant: CellJoiner<StyledRenderable>;
-    flame: CellJoiner<StyledRenderable>;
-    pixel: CellJoiner<StyledRenderable>;
-    ice: CellJoiner<StyledRenderable>;
-    bubble: CellJoiner<StyledRenderable>;
-    capsule: CellJoiner<StyledRenderable>;
-    wrapper: CellJoiner<StyledRenderable>;
-    metro: CellJoiner<StyledRenderable>;
-    stitch: CellJoiner<StyledRenderable>;
-    torn: CellJoiner<StyledRenderable>;
-    plain: CellJoiner<StyledRenderable>;
+export declare const SEPARATOR_STYLES: Readonly<{
+    powerline: CellSeparator<StyledRenderable>;
+    prism: CellSeparator<StyledRenderable>;
+    slant: CellSeparator<StyledRenderable>;
+    backslant: CellSeparator<StyledRenderable>;
+    flame: CellSeparator<StyledRenderable>;
+    pixel: CellSeparator<StyledRenderable>;
+    ice: CellSeparator<StyledRenderable>;
+    bubble: CellSeparator<StyledRenderable>;
+    capsule: CellSeparator<StyledRenderable>;
+    wrapper: CellSeparator<StyledRenderable>;
+    metro: CellSeparator<StyledRenderable>;
+    stitch: CellSeparator<StyledRenderable>;
+    torn: CellSeparator<StyledRenderable>;
+    plain: CellSeparator<StyledRenderable>;
 }>;
 /**
- * A joiner as config names it: one of `JOINERS`, or a seam from `SEAMS` ended
+ * A joiner as config names it: one of `SEPARATOR_STYLES`, or a seam from `SEPARATORS` ended
  * in caps from `CAPS`, each named apart.
  */
-export type JoinerSpec = string | {
+export type SeparatorSpec = string | {
     readonly seam: string;
     readonly caps: string;
 };
@@ -370,17 +370,17 @@ export type JoinerSpec = string | {
  * name its table lacks, naming the ones there are; an own-key test, so
  * `toString` and the rest of `Object.prototype` are no one's name.
  */
-export declare function joinerNamed(spec: JoinerSpec): CellJoiner;
+export declare function separatorNamed(spec: SeparatorSpec): CellSeparator;
 /**
  * A ramp of `steps` cells from the left ground to the right, each cell filled
- * with one colour: cell `i` is the colour `(i + 1/2) / steps` of the way
+ * with one color: cell `i` is the color `(i + 1/2) / steps` of the way
  * across, so no cell is either neighbour's ground. A cell is a space whose ink
- * is the terminal's ground, so its one colour is its fill, the same in ASCII.
- * Beside a neighbour with no ground there is no colour to ramp toward, so that
+ * is the terminal's ground, so its one color is its fill, the same in ASCII.
+ * Beside a neighbour with no ground there is no color to ramp toward, so that
  * join draws the caps the ramp is ended in.
  *
  * [LAW:dataflow-not-control-flow] A ramp cell is fill alone: a space has no
- * ink, and `"ground"` as its `fg` is the absence of a colour on that side
+ * ink, and `"ground"` as its `fg` is the absence of a color on that side
  * (`cellStyle`). So the lift, the path every seam cell is drawn by, has no ink
  * to hold off its ground, and the ramp is the blend, monotone however close
  * its grounds or however many its steps. Two samples to a cell, ink over
@@ -388,5 +388,5 @@ export declare function joinerNamed(spec: JoinerSpec): CellJoiner;
  * `steps` such cells rise without turning back only between grounds `steps`
  * floors apart.
  */
-export declare function gradientSeam(steps?: number): JoinSeam;
+export declare function gradientSeam(steps?: number): SeparatorSeam;
 export {};