@promptctl/rich-js 0.27.0 → 0.29.0

package/dist/core/strip.js

@@ -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
@@ -34,22 +34,22 @@ import { fnv1a } from "./fnv1a.js";
 import { drawable, getStyle, isAscii, render } from "./protocol.js";
 /**
  * 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 const JOIN = Object.freeze({ name: "join" });
 /**
- * [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 function drawJoin(joiner, left, right, context) {
-    const join = joiner.join(left, right, context);
+export function drawJoin(separator, left, right, context) {
+    const join = separator.join(left, right, context);
     return { render: (options) => Segment.anchorLines([[...render(join, options)]], JOIN)[0] };
 }
 /**
@@ -64,10 +64,10 @@ export function drawItem(item) {
 // --- Strip ---
 export class Strip {
     items;
-    joiner;
-    constructor(items, joiner) {
+    separator;
+    constructor(items, separator) {
         this.items = items;
-        this.joiner = joiner;
+        this.separator = separator;
     }
     *render(options) {
         const items = this.items;
@@ -82,12 +82,12 @@ export class Strip {
         // `left` fills the canvas, and the first item would pad over the rest of
         // the row. Where the row sits in the width is its container's to say.
         const row = { ...options, justify: undefined };
-        yield* render(drawJoin(this.joiner, null, items[0], { index: 0 }), row);
+        yield* render(drawJoin(this.separator, null, items[0], { index: 0 }), row);
         for (let i = 0; i < items.length; i++) {
             const item = items[i];
             yield* render(drawItem(item), row);
             const next = i + 1 < items.length ? items[i + 1] : null;
-            yield* render(drawJoin(this.joiner, item, next, { index: i + 1 }), row);
+            yield* render(drawJoin(this.separator, item, next, { index: i + 1 }), row);
         }
         // [LAW:one-source-of-truth] `Strip`'s sibling `FlexStrip` ends every line
         // it emits, including the last, and the other block-level renderables
@@ -144,7 +144,7 @@ const cellWidth = (cell) => cellLen(glyphsOf(cell)[0] ?? "");
 // name, because the part is also drawn where that neighbour does not exist.
 function parsePaint(raw, absent, refuse) {
     if (raw === "ground")
-        return refuse("mixes ground, whose colour is unknown");
+        return refuse("mixes ground, whose color is unknown");
     const p = (typeof raw === "object" && raw !== null ? raw : {});
     if ((p.edge === "left" || p.edge === "right") && (p.part === "bg" || p.part === "fg")) {
         if (p.edge === absent)
@@ -159,7 +159,7 @@ function parsePaint(raw, absent, refuse) {
             refuse(`mixes at ${String(t)}, outside 0..1`);
         return Object.freeze({ mix: Object.freeze([parsePaint(from, absent, refuse), parsePaint(to, absent, refuse), t]) });
     }
-    return refuse(`has a colour that is not a Paint: ${JSON.stringify(raw)}`);
+    return refuse(`has a color that is not a Paint: ${JSON.stringify(raw)}`);
 }
 const parseColor = (raw, absent, refuse) => raw === "ground" ? raw : parsePaint(raw, absent, refuse);
 const ABSENT = { seam: undefined, lead: "left", tail: "right" };
@@ -248,8 +248,8 @@ function formOf(shape) {
         cells: { seam: cells("seam"), lead: cells("lead"), tail: cells("tail") },
     };
 }
-// A bg with a real colour to paint. `undefined` (no bg) and the terminal
-// DEFAULT colour (transparent — identical to the terminal background) are the
+// A bg with a real color to paint. `undefined` (no bg) and the terminal
+// DEFAULT color (transparent — identical to the terminal background) are the
 // two representations of "nothing to paint", so an explicit `… on default`
 // cannot smuggle a seam.
 function paintableBg(bg) {
@@ -262,13 +262,13 @@ function drawnGround(bg) {
     return bg.flattenAlpha(SURFACE_BLACK);
 }
 // Whether ink stands off its ground, both as a depth draws them, by the floor a
-// seam is seen at. A colour whose RGB is the terminal theme's own (ANSI 0–15, a
+// seam is seen at. A color whose RGB is the terminal theme's own (ANSI 0–15, a
 // blend reaching one) has no value here, so two of them stand apart unless they
 // are one expression: the same palette slot — its `number`, never the name or
 // the depth that spells it ("red", "color(1)", an EIGHT_BIT spec on 0–15 are
 // one slot) — or the same blend, whose name spells each end by its slot for the
-// same reason. At sixteen colours, then, the floor is a different slot. The
-// terminal's default colour is nobody's to measure, and stands apart.
+// same reason. At sixteen colors, then, the floor is a different slot. The
+// terminal's default color is nobody's to measure, and stands apart.
 function standsOff(ink, ground) {
     if (ink.isDefault || ground.isDefault)
         return true;
@@ -277,7 +277,7 @@ function standsOff(ink, ground) {
         ? Oklch.fromRgba(a).deltaE(Oklch.fromRgba(b)) >= SEAM_MIN_DELTA_E
         : ink.number !== undefined ? ink.number !== ground.number : ink.name !== ground.name;
 }
-// A step along a lightness ray: finer than the steps between the colours a
+// A step along a lightness ray: finer than the steps between the colors a
 // truecolor writer draws, so the walk passes over none of them.
 const LIFT_STEP = 0.001;
 // The steps along `origin`'s lightness ray, its chroma and hue held, in the
@@ -292,21 +292,21 @@ function* lightnessRay(origin) {
     }
 }
 /**
- * `ink`, a glyph's colour on `ground`, held at least `SEAM_MIN_DELTA_E` off it
+ * `ink`, a glyph's color on `ground`, held at least `SEAM_MIN_DELTA_E` off it
  * as `depth` draws both (`Style.drawnColors`). Ink that already stands off is
  * returned as it is. Ink that does not becomes the drawn form of the nearest
  * step along its own OKLCH lightness ray, chroma and hue held, that stands off:
  * the smaller step, toward white or toward black. Every step is measured as the
- * depth draws it, so at 256 colours and at sixteen the candidates are the
+ * depth draws it, so at 256 colors and at sixteen the candidates are the
  * entries the depth draws, and the side the ink moves to can differ between
- * depths. A floor measured on rounded colours is not monotone along a ray, so
- * the walk enumerates and never bisects. A side with no colour to measure is
+ * depths. A floor measured on rounded colors is not monotone along a ray, so
+ * the walk enumerates and never bisects. A side with no color to measure is
  * left alone.
  *
- * [LAW:one-source-of-truth] The colour returned is the one measured — the
+ * [LAW:one-source-of-truth] The color returned is the one measured — the
  * entry the depth draws, not the step that rounds to it — so a reader of the
  * cell at another depth (an export reads a recording in truecolor) sees the
- * colour that cleared the floor, never a step one unit off its ground.
+ * color that cleared the floor, never a step one unit off its ground.
  *
  * [LAW:single-enforcer] The one place a join cell's visibility is decided:
  * nothing outside the joiner predicts whether a seam will show.
@@ -319,14 +319,14 @@ function standOff(ink, ground, depth) {
     if (standsOff(shown, under))
         return ink;
     // The ray starts from the ink as it is laid on its ground, before a depth
-    // rounds it; ink the terminal's theme draws starts from the colour the
+    // rounds it; ink the terminal's theme draws starts from the color the
     // default terminal theme gives it. Ink that vanishes is drawn in the same
     // kind as its ground — both fixed, or both the theme's — and every step is
     // drawn in that kind too, so it is measured as the ink was. Ink the depth
     // draws as the theme's (a slot, or a mix reaching one at truecolor) steps
-    // between slots: an RGB beside a colour only the terminal knows could be
-    // that very colour. Ink the depth fixes (that same mix is a cube entry at
-    // 256) steps between fixed colours, for the same reason turned round.
+    // between slots: an RGB beside a color only the terminal knows could be
+    // that very color. Ink the depth fixes (that same mix is a cube entry at
+    // 256) steps between fixed colors, for the same reason turned round.
     const laid = drawn(ink).color;
     const kind = shown.fixedValue === undefined ? ColorDepth.STANDARD : ColorDepth.TRUECOLOR;
     for (const step of lightnessRay(Oklch.fromRgba(laid.getTruecolor()))) {
@@ -336,7 +336,7 @@ function standOff(ink, ground, depth) {
     }
     // [LAW:no-silent-failure] Unreachable: the ray runs out to black and to
     // white, and no ground lies within the floor of both, nor is one slot both.
-    throw new Error(`no colour on the lightness ray of ${ink.name} stands off ${ground.name} at depth ${ColorDepth[depth]}`);
+    throw new Error(`no color on the lightness ray of ${ink.name} stands off ${ground.name} at depth ${ColorDepth[depth]}`);
 }
 function resolvePaint(paint, edges, options) {
     if ("edge" in paint) {
@@ -351,15 +351,15 @@ function resolvePaint(paint, edges, options) {
     const [from, to, t] = paint.mix;
     const a = resolvePaint(from, edges, options);
     const b = resolvePaint(to, edges, options);
-    // A mix with no colour at one end has nothing to blend toward.
+    // A mix with no color at one end has nothing to blend toward.
     return a && b && ColorSpec.blend(a, b, t);
 }
 // [LAW:single-enforcer] The one resolution of a join cell's paints: at join
 // time, and again whenever an effect moves the neighbours it reads
 // (`JoinedCell`).
 function cellStyle(cell, edges, options) {
-    // [LAW:dataflow-not-control-flow] "ground" is the absence of a colour on its
-    // side; as the fg it is reverse video over the bg colour, so the glyph's ink
+    // [LAW:dataflow-not-control-flow] "ground" is the absence of a color on its
+    // side; as the fg it is reverse video over the bg color, so the glyph's ink
     // is the terminal's own background.
     if (cell.fg === "ground")
         return new Style({ color: cell.bg === "ground" ? undefined : resolvePaint(cell.bg, edges, options), reverse: true });
@@ -369,19 +369,19 @@ function cellStyle(cell, edges, options) {
     return new Style({ color: standOff(resolvePaint(cell.fg, edges, options), bgcolor, options.colorSystem ?? ColorDepth.TRUECOLOR), bgcolor });
 }
 /**
- * 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.
  */
@@ -439,7 +439,7 @@ export class JoinedCell {
         return { colors: next.style, style: style.withAnchor(style.anchor && restamp(style.anchor)) };
     }
 }
-/** 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 function joinedCell(anchor) {
     for (let level = anchor; level; level = level.inner)
         if (level.owner instanceof JoinedCell)
@@ -448,8 +448,8 @@ export function joinedCell(anchor) {
 }
 const shapeGlyphs = (shape) => PARTS.flatMap((part) => shape[part].flatMap(glyphsOf)).join("");
 /**
- * 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
@@ -464,7 +464,7 @@ const shapeGlyphs = (shape) => PARTS.flatMap((part) => shape[part].flatMap(glyph
  *
  * An ASCII-only output draws the `ascii` form of both, whole.
  */
-export class CellJoiner {
+export class CellSeparator {
     seam;
     caps;
     _forms;
@@ -545,7 +545,7 @@ const rail = (glyph) => ({ glyph, fg: { role: "strip.rail" }, bg: GROUND });
  * What each draws is `docs/strip.md`'s "Seams"; any of them ends in any of
  * `CAPS`.
  */
-export const SEAMS = Object.freeze({
+export const SEPARATORS = Object.freeze({
     powerline: parseSeam(arrowSeam(POWERLINE)),
     prism: parseSeam(both(prism(POWERLINE.glyph), prism(POWERLINE.ascii))),
     slant: parseSeam(arrowSeam(SLANT)),
@@ -575,9 +575,9 @@ const FLAT = { lead: [], tail: [] };
 /**
  * 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 const CAPS = Object.freeze({
+export const END_CAPS = Object.freeze({
     powerline: parseCaps(flowCaps(POWERLINE)),
     slant: parseCaps(flowCaps(SLANT)),
     backslant: parseCaps(flowCaps(BACKSLANT)),
@@ -590,37 +590,37 @@ export const CAPS = Object.freeze({
     flat: parseCaps(both(FLAT, FLAT)),
 });
 /**
- * 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 const JOINERS = Object.freeze({
-    powerline: new CellJoiner(SEAMS.powerline, CAPS.powerline),
-    prism: new CellJoiner(SEAMS.prism, CAPS.powerline),
-    slant: new CellJoiner(SEAMS.slant, CAPS.slant),
-    backslant: new CellJoiner(SEAMS.backslant, CAPS.backslant),
-    flame: new CellJoiner(SEAMS.flame, CAPS.flame),
-    pixel: new CellJoiner(SEAMS.pixel, CAPS.pixel),
-    ice: new CellJoiner(SEAMS.ice, CAPS.ice),
-    bubble: new CellJoiner(SEAMS.bubble, CAPS.bubble),
-    capsule: new CellJoiner(SEAMS.capsule, CAPS.capsule),
-    wrapper: new CellJoiner(SEAMS.wrapper, CAPS.wrapper),
-    metro: new CellJoiner(SEAMS.metro, CAPS.capsule),
-    stitch: new CellJoiner(SEAMS.stitch, CAPS.flat),
-    torn: new CellJoiner(SEAMS.torn, CAPS.flat),
-    plain: new CellJoiner(SEAMS.plain, CAPS.flat),
+export const SEPARATOR_STYLES = Object.freeze({
+    powerline: new CellSeparator(SEPARATORS.powerline, END_CAPS.powerline),
+    prism: new CellSeparator(SEPARATORS.prism, END_CAPS.powerline),
+    slant: new CellSeparator(SEPARATORS.slant, END_CAPS.slant),
+    backslant: new CellSeparator(SEPARATORS.backslant, END_CAPS.backslant),
+    flame: new CellSeparator(SEPARATORS.flame, END_CAPS.flame),
+    pixel: new CellSeparator(SEPARATORS.pixel, END_CAPS.pixel),
+    ice: new CellSeparator(SEPARATORS.ice, END_CAPS.ice),
+    bubble: new CellSeparator(SEPARATORS.bubble, END_CAPS.bubble),
+    capsule: new CellSeparator(SEPARATORS.capsule, END_CAPS.capsule),
+    wrapper: new CellSeparator(SEPARATORS.wrapper, END_CAPS.wrapper),
+    metro: new CellSeparator(SEPARATORS.metro, END_CAPS.capsule),
+    stitch: new CellSeparator(SEPARATORS.stitch, END_CAPS.flat),
+    torn: new CellSeparator(SEPARATORS.torn, END_CAPS.flat),
+    plain: new CellSeparator(SEPARATORS.plain, END_CAPS.flat),
 });
 /**
  * The joiner `spec` names — a joiner read from config, parsed. Throws on a
  * 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 function joinerNamed(spec) {
+export function separatorNamed(spec) {
     if (typeof spec === "string")
-        return named(JOINERS, "joiner", "joiners", spec);
+        return named(SEPARATOR_STYLES, "separator", "separators", spec);
     if (typeof spec !== "object" || spec === null)
-        throw new Error(`a joiner is a name or { seam, caps }, not ${JSON.stringify(spec)}`);
-    return new CellJoiner(named(SEAMS, "seam", "seams", spec.seam), named(CAPS, "caps", "caps", spec.caps));
+        throw new Error(`a separator is a name or { seam, caps }, not ${JSON.stringify(spec)}`);
+    return new CellSeparator(named(SEPARATORS, "seam", "seams", spec.seam), named(END_CAPS, "caps", "caps", spec.caps));
 }
 function named(table, kind, kinds, name) {
     if (!Object.hasOwn(table, name))
@@ -629,14 +629,14 @@ function named(table, kind, kinds, name) {
 }
 /**
  * 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
@@ -647,7 +647,7 @@ function named(table, kind, kinds, name) {
 export function gradientSeam(steps = 4) {
     // [LAW:no-silent-failure] A count that is no whole number of cells would draw
     // a lopsided ramp without a word, and no cells is no ramp: a seam that reads
-    // neither ground, joining a colourless neighbour where a ramp draws the caps.
+    // neither ground, joining a colorless neighbour where a ramp draws the caps.
     if (!(Number.isInteger(steps) && steps > 0))
         throw new RangeError(`gradientSeam steps must be a positive whole number of cells, got ${steps}`);
     const ramp = {

package/dist/core/style.d.ts

@@ -3,13 +3,14 @@
  */
 import { ColorSpec, ColorDepth } from "./color.js";
 import { type Anchor } from "./anchor.js";
+import type { BidiStamp } from "./text-order.js";
 /**
  * Canonical text-attribute inventory. Single source of truth consumed by
  * `Style.parse` / `Style.toString` and the template bindings — adding an
  * attribute here propagates to every styling surface without a second
  * list to keep in sync. [LAW:one-source-of-truth]
  */
-export declare const ATTRIBUTE_NAMES: readonly ["bold", "dim", "italic", "underline", "blink", "blink2", "reverse", "conceal", "strike", "underline2", "frame", "encircle", "overline"];
+export declare const ATTRIBUTE_NAMES: readonly ["bold", "dim", "italic", "underline", "blink", "rapidBlink", "reverse", "conceal", "strike", "doubleUnderline", "frame", "encircle", "overline"];
 export type AttributeName = (typeof ATTRIBUTE_NAMES)[number];
 /**
  * Each text attribute as a style sets it: on, off, or unset — and an unset
@@ -34,30 +35,36 @@ export interface StyleOptions {
     italic?: boolean;
     underline?: boolean;
     blink?: boolean;
-    blink2?: boolean;
+    rapidBlink?: boolean;
     reverse?: boolean;
     conceal?: boolean;
     strike?: boolean;
-    underline2?: boolean;
+    doubleUnderline?: boolean;
     frame?: boolean;
     encircle?: boolean;
     overline?: boolean;
     link?: string;
     meta?: Record<string, unknown>;
     anchor?: Anchor;
+    boxFrame?: object;
+    bidi?: BidiStamp;
     /**
      * The hold the style's cells are in, both ends or neither: a cell saying
      * only when it next changes would claim, by default, that it always was,
      * and a timeline run backwards past its change would never wake for it.
      * [LAW:types-are-the-program] Absent, the cells never change.
      */
-    hold?: Hold;
+    validity?: ValidityInterval;
 }
 /** A hold: since when a sample has been what it is, and until when it stays so, on one clock. */
-export interface Hold {
-    readonly lastChange: number;
-    readonly nextChange: number;
+export interface ValidityInterval {
+    readonly validFrom: number;
+    readonly validUntil: number;
 }
+/** The hold of a cell that never changes: always was, and always will be. */
+export declare const NEVER_CHANGES: ValidityInterval;
+/** The moments both `a` and `b` hold through: the later `validFrom` and the sooner `validUntil`. */
+export declare function intersection(a: ValidityInterval, b: ValidityInterval): ValidityInterval;
 export declare class StyleSyntaxError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
@@ -69,11 +76,11 @@ export declare class Style {
     readonly italic: boolean | undefined;
     readonly underline: boolean | undefined;
     readonly blink: boolean | undefined;
-    readonly blink2: boolean | undefined;
+    readonly rapidBlink: boolean | undefined;
     readonly reverse: boolean | undefined;
     readonly conceal: boolean | undefined;
     readonly strike: boolean | undefined;
-    readonly underline2: boolean | undefined;
+    readonly doubleUnderline: boolean | undefined;
     readonly frame: boolean | undefined;
     readonly encircle: boolean | undefined;
     readonly overline: boolean | undefined;
@@ -85,20 +92,37 @@ export declare class Style {
      * unequal, because they came from different places.
      */
     readonly anchor: Anchor | undefined;
+    /**
+     * The drawing of a box these cells are the frame of (`Box.frame`), compared
+     * by identity. A frame is told by what drew it, never by its glyphs, as a
+     * strip's seam is (`JOIN`, `./strip.ts`): a box may draw its frame in blanks,
+     * and what it draws in ink an element's own content may draw too. It is a
+     * drawing and not a box, so two panels of one `ROUNDED` are two frames, and
+     * it is no `Anchor`: a frame's cells say whose they are and not where, since
+     * a table draws its top rule before it knows its height. It draws nothing.
+     */
+    readonly boxFrame: object | undefined;
+    /**
+     * What drawing said of these cells' direction, compared by identity, as a
+     * link is a fact the encoder turns into bytes: `Segment` never holds a control
+     * the library wrote, so no cut of a row can unbalance one, and what survives a
+     * cut still names its stamp (`./seal.ts`). It draws nothing.
+     */
+    readonly bidi: BidiStamp | undefined;
     /**
      * The hold this style's cells are in, on the timeline of whoever drew the
-     * frame: since when what they show has been what it is (`lastChange`), and
-     * when it next changes (`nextChange`) — both `t` for a cell drawn by
+     * frame: since when what they show has been what it is (`validFrom`), and
+     * when it next changes (`validUntil`) — both `t` for a cell drawn by
      * something that moves every frame, and `-Infinity`/`Infinity` for one
      * that never changes. It draws nothing. Whatever draws for a handed time
      * stamps its cells with it (`placedRender`, `Effected`), the stamp rides up
      * through every container as the anchor does (`./anchor.ts`), and whoever
-     * holds the composed frame reads it off (`Segment.nextChange`, and
-     * `Segment.lastChange` for a host running its timeline backwards), so a
+     * holds the composed frame reads it off (`Segment.validUntil`, and
+     * `Segment.validFrom` for a host running its timeline backwards), so a
      * host knows when to draw again without asking each container. Two styles
      * laid together are in the intersection of their holds.
      */
-    readonly hold: Hold;
+    readonly validity: ValidityInterval;
     constructor(options?: StyleOptions);
     get isNull(): boolean;
     get transparentBackground(): boolean;
@@ -117,6 +141,10 @@ export declare class Style {
      * The same look, drawn from the place `anchor` names, or from nowhere.
      */
     withAnchor(anchor: Anchor | undefined): Style;
+    /** The same look, as the frame of the drawing `boxFrame` names, or of none. */
+    withBoxFrame(boxFrame: object | undefined): Style;
+    /** The same look, its cells' direction as `bidi` says. */
+    withBidi(bidi: BidiStamp | undefined): Style;
     /** The style's text attributes, each as it sets it. */
     get attributes(): Attributes;
     /**
@@ -126,7 +154,7 @@ export declare class Style {
     withAttributes(attributes: Partial<Attributes>): Style;
     /**
      * This style with its motion taken out, what reduced motion draws: `blink`
-     * and `blink2`, the motion a terminal makes on its own, unset, and every
+     * and `rapidBlink`, the motion a terminal makes on its own, unset, and every
      * other field as it was. A style that does not blink is its own.
      */
     reduced(): Style;
@@ -141,7 +169,7 @@ export declare class Style {
     add(other: Style | undefined): Style;
     equals(other: Style): boolean;
     /**
-     * The colours this style puts on screen at `colorSystem`: each flattened
+     * The colors this style puts on screen at `colorSystem`: each flattened
      * onto what lies beneath it — the background onto the terminal's black, the
      * foreground onto that background — then downgraded to the depth. The one
      * account of what a style draws: `toSgrCodes` encodes exactly these, and a
@@ -162,8 +190,8 @@ export declare class Style {
     toSgrCodes(colorSystem: ColorDepth): string;
     /**
      * The look as a canonical string that round-trips through `Style.parse()`:
-     * colours, attributes and the link, which is all a style string can spell.
-     * What a style carries beyond its look — `meta`, `anchor`, `hold` —
+     * colors, attributes and the link, which is all a style string can spell.
+     * What a style carries beyond its look — `meta`, `anchor`, `boxFrame`, `bidi`, `hold` —
      * has no spelling and is not here, so two styles that differ only there
      * read alike; `equals` tells them apart.
      */