@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/core/oklch.d.ts

@@ -14,7 +14,7 @@
  * sRGB is the wire format terminals consume (what ANSI escape codes
  * carry); OKLCH is the perceptual manipulation space (where equal
  * numerical deltas mean equal perceptual deltas, which is the property
- * "transposition" requires). Two types, mutual conversion, no hybrid.
+ * "adjustment" requires). Two types, mutual conversion, no hybrid.
  *
  * [LAW:one-way-deps] This module imports `ColorRgba` from core/color and
  * nothing else from inside the project. Nothing in core/ depends back on
@@ -25,13 +25,13 @@ import { ColorRgba } from "./color.js";
  * A perceptually-uniform color transform.
  *
  * [LAW:dataflow-not-control-flow] Identity is *data* (`IDENTITY`), not a
- * special case. Every transposition runs the same code path — the values
+ * special case. Every adjustment runs the same code path — the values
  * decide whether the operation is a no-op or a 180° rotation.
  *
  * Lightness is parameterized as `L' = clamp01(L * scale + shift)` to make
  * "invert" expressible as `{scale: -1, shift: 1}` without a boolean knob.
  */
-export interface ThemeKey {
+export interface ColorAdjustment {
     /** Hue offset in degrees; positive rotates toward warmer→cooler→back. */
     readonly hueShift: number;
     /** Multiplier on chroma. 0 = grayscale, 1 = identity, >1 = more saturated. */
@@ -48,22 +48,22 @@ export interface OklchWeights {
     readonly h: number;
     readonly alpha: number;
 }
-export declare const IDENTITY: ThemeKey;
+export declare const IDENTITY: ColorAdjustment;
 /**
  * Flip lightness around the midpoint (`L' = 1 - L`) with hue and chroma
- * untouched. Combined with the anchor logic in `transposePalette`, this
+ * untouched. Combined with the anchor logic in `adjustPalette`, this
  * converts a dark theme to its light "octave": semantic anchors
  * (error/success/warning) still lightness-invert — only their *hue* is
  * preserved — so errors stay red and dark-on-light becomes light-on-dark.
  */
-export declare const INVERT_LIGHTNESS: ThemeKey;
+export declare const INVERT_LIGHTNESS: ColorAdjustment;
 /**
  * Whether a key is the no-op transform. Exported so that callers
- * (`transposePalette`) can fast-path byte-exact identity without going
+ * (`adjustPalette`) can fast-path byte-exact identity without going
  * through the lossy sRGB↔OKLCH round-trip. [LAW:one-source-of-truth] —
  * the predicate lives once, here.
  */
-export declare function isIdentityKey(k: ThemeKey): boolean;
+export declare function isIdentityKey(k: ColorAdjustment): boolean;
 export declare function srgbToLinear(v: number): number;
 export declare function linearToSrgb(v: number): number;
 /**
@@ -96,13 +96,13 @@ export declare class Oklch {
      */
     toRgba(): ColorRgba;
     /**
-     * Apply a `ThemeKey`. Returns a new `Oklch`; pure.
+     * Apply a `ColorAdjustment`. Returns a new `Oklch`; pure.
      *
      * [LAW:dataflow-not-control-flow] Identity short-circuits to `this` —
      * same shape as `ColorRgba.compositeOver(bg)` returning `this` when
      * `alpha === 1`. Callers invoke unconditionally; the data decides.
      */
-    applyKey(k: ThemeKey): Oklch;
+    applyKey(k: ColorAdjustment): Oklch;
     /**
      * The color `t` of the way from this one toward `toward`, in OKLCH.
      * `t = 0` is this color, `t = 1` is `toward`; pure.
@@ -115,7 +115,7 @@ export declare class Oklch {
      * that gains chroma, instead of rotating through the wheel from 0°.
      *
      * `t` must lie in [0, 1]: this is interpolation, not extrapolation, and a
-     * `t` outside it (NaN included) is a RangeError, never a colour off the
+     * `t` outside it (NaN included) is a RangeError, never a color off the
      * far end of the segment. [LAW:no-silent-failure]
      *
      * [LAW:one-source-of-truth] Achromatic means the same `ACHROMATIC_EPS`
@@ -133,19 +133,19 @@ export declare class Oklch {
      * whichever is called.
      *
      * It exists because perceptual axes are independent: a tint can take most of
-     * a hue's colourfulness while keeping close to the lightness it started at,
+     * a hue's colorfulness while keeping close to the lightness it started at,
      * which a single `t` cannot say — raising `t` for chroma drags lightness with
      * it. Every weight is required: an axis left out would need a default, and
      * "unchanged" (0) and "same as the others" are both plausible readings.
      *
-     * A weak `h` beside a strong `c` shows the starting colour's hue at high
+     * A weak `h` beside a strong `c` shows the starting color's hue at high
      * chroma. The powerless rule covers only a truly achromatic start, so a
      * near-grey whose hue is noise (a theme surface at c ≈ 0.004) keeps that
      * noise in proportion. To land on the target's hue, pass `h: 1`.
      */
     mixAxes(toward: Oklch, weights: OklchWeights): Oklch;
     /**
-     * ΔE_OK — the Euclidean distance between this colour and `other` in OKLab
+     * ΔE_OK — the Euclidean distance between this color and `other` in OKLab
      * (CSS Color 4's `deltaEOK`), where ~0.02 is the smallest difference the eye
      * resolves. Alpha is not a coordinate of the space and does not count.
      * Symmetric and pure.

package/dist/core/oklch.js

@@ -14,7 +14,7 @@
  * sRGB is the wire format terminals consume (what ANSI escape codes
  * carry); OKLCH is the perceptual manipulation space (where equal
  * numerical deltas mean equal perceptual deltas, which is the property
- * "transposition" requires). Two types, mutual conversion, no hybrid.
+ * "adjustment" requires). Two types, mutual conversion, no hybrid.
  *
  * [LAW:one-way-deps] This module imports `ColorRgba` from core/color and
  * nothing else from inside the project. Nothing in core/ depends back on
@@ -33,7 +33,7 @@ export const IDENTITY = Object.freeze({
 });
 /**
  * Flip lightness around the midpoint (`L' = 1 - L`) with hue and chroma
- * untouched. Combined with the anchor logic in `transposePalette`, this
+ * untouched. Combined with the anchor logic in `adjustPalette`, this
  * converts a dark theme to its light "octave": semantic anchors
  * (error/success/warning) still lightness-invert — only their *hue* is
  * preserved — so errors stay red and dark-on-light becomes light-on-dark.
@@ -46,7 +46,7 @@ export const INVERT_LIGHTNESS = Object.freeze({
 });
 /**
  * Whether a key is the no-op transform. Exported so that callers
- * (`transposePalette`) can fast-path byte-exact identity without going
+ * (`adjustPalette`) can fast-path byte-exact identity without going
  * through the lossy sRGB↔OKLCH round-trip. [LAW:one-source-of-truth] —
  * the predicate lives once, here.
  */
@@ -179,7 +179,7 @@ export class Oklch {
         return new ColorRgba(sR, sG, sB, this.alpha);
     }
     /**
-     * Apply a `ThemeKey`. Returns a new `Oklch`; pure.
+     * Apply a `ColorAdjustment`. Returns a new `Oklch`; pure.
      *
      * [LAW:dataflow-not-control-flow] Identity short-circuits to `this` —
      * same shape as `ColorRgba.compositeOver(bg)` returning `this` when
@@ -205,7 +205,7 @@ export class Oklch {
      * that gains chroma, instead of rotating through the wheel from 0°.
      *
      * `t` must lie in [0, 1]: this is interpolation, not extrapolation, and a
-     * `t` outside it (NaN included) is a RangeError, never a colour off the
+     * `t` outside it (NaN included) is a RangeError, never a color off the
      * far end of the segment. [LAW:no-silent-failure]
      *
      * [LAW:one-source-of-truth] Achromatic means the same `ACHROMATIC_EPS`
@@ -228,12 +228,12 @@ export class Oklch {
      * whichever is called.
      *
      * It exists because perceptual axes are independent: a tint can take most of
-     * a hue's colourfulness while keeping close to the lightness it started at,
+     * a hue's colorfulness while keeping close to the lightness it started at,
      * which a single `t` cannot say — raising `t` for chroma drags lightness with
      * it. Every weight is required: an axis left out would need a default, and
      * "unchanged" (0) and "same as the others" are both plausible readings.
      *
-     * A weak `h` beside a strong `c` shows the starting colour's hue at high
+     * A weak `h` beside a strong `c` shows the starting color's hue at high
      * chroma. The powerless rule covers only a truly achromatic start, so a
      * near-grey whose hue is noise (a theme surface at c ≈ 0.004) keeps that
      * noise in proportion. To land on the target's hue, pass `h: 1`.
@@ -265,7 +265,7 @@ export class Oklch {
         return new _a(lerp(this.l, toward.l, wl), c, hueOf(c, wrapHue(lerp(fromU, toU, wh))), lerp(this.alpha, toward.alpha, walpha));
     }
     /**
-     * ΔE_OK — the Euclidean distance between this colour and `other` in OKLab
+     * ΔE_OK — the Euclidean distance between this color and `other` in OKLab
      * (CSS Color 4's `deltaEOK`), where ~0.02 is the smallest difference the eye
      * resolves. Alpha is not a coordinate of the space and does not count.
      * Symmetric and pure.
@@ -276,9 +276,9 @@ export class Oklch {
         return Math.hypot(this.l - other.l, a - otherA, b - otherB);
     }
     /**
-     * This colour's OKLab a and b, kept with it: a colour matched against a
+     * This color's OKLab a and b, kept with it: a color matched against a
      * palette is measured against every entry, and each entry against every
-     * colour it is matched with, so the trigonometry is paid once a colour
+     * color it is matched with, so the trigonometry is paid once a color
      * rather than once a comparison.
      */
     #lab;

package/dist/core/orient.d.ts

@@ -42,7 +42,7 @@ export declare function drawnTail(text: string): string;
  */
 export declare function hangingWhitespace(line: Segment[]): number;
 /** What a row of a directed line is, given the text it started as and its offset in the line. */
-export interface Directed {
+export interface ReorderedLine {
     /** The line to cut: X9's removals gone where the terminal will not need them. */
     readonly line: readonly Segment[];
     /** Whether a row's cells may not be merged with the padding beside them. */
@@ -51,7 +51,7 @@ export interface Directed {
     orient(shown: readonly Segment[], start: number, source: string): Segment[];
 }
 /** What `order` does with `line`, one logical line of drawn segments. */
-export declare function directed(line: readonly Segment[], order: TextOrder): Directed;
+export declare function reorder(line: readonly Segment[], order: TextOrder): ReorderedLine;
 /** `text` as `order` measures it: what `directed` removes ahead of wrapping is no word. */
 export declare function measured(text: string, order: TextOrder): string;
 /** The offsets in `text`, one row, of the characters `order` shows at its left and right edges. */
@@ -65,4 +65,4 @@ export declare function edges(text: string, order: TextOrder): {
  * button's brackets would be mirrored around it. A label `directed` leaves alone
  * is one segment with its frame, as it always was.
  */
-export declare function labelled(before: string, label: string, after: string, style: Style | undefined, order: TextOrder | undefined): Segment[];
+export declare function labeled(before: string, label: string, after: string, style: Style | undefined, order: TextOrder | undefined): Segment[];

package/dist/core/orient.js

@@ -147,7 +147,7 @@ const REMOVALS = {
     visual: (text) => withoutMarks(withoutExplicit(text)),
 };
 /** What `order` does with `line`, one logical line of drawn segments. */
-export function directed(line, order) {
+export function reorder(line, order) {
     if (!isBidi(Segment.plainOf(line)))
         return UNTOUCHED(line);
     if (order === "plain")
@@ -215,8 +215,8 @@ function ordered(text) {
  * button's brackets would be mirrored around it. A label `directed` leaves alone
  * is one segment with its frame, as it always was.
  */
-export function labelled(before, label, after, style, order) {
-    const { line, oriented, orient } = directed([new Segment(label, style)], order ?? "plain");
+export function labeled(before, label, after, style, order) {
+    const { line, oriented, orient } = reorder([new Segment(label, style)], order ?? "plain");
     const text = Segment.plainOf(line);
     if (!oriented)
         return [new Segment(before + text + after, style)];

package/dist/core/paint.d.ts

@@ -5,7 +5,7 @@
  * back.
  *
  * [LAW:one-source-of-truth] Where the cursor rests between frames, and how
- * many rows the next paint goes back over, is one fact, and a `SurfacePainter`
+ * many rows the next paint goes back over, is one fact, and a `SurfaceRenderer`
  * is its only owner: `App` holds one, and so does `Live` on a terminal, so
  * they cannot disagree about it. They once did: `Live` wrote a newline after its last row, and on a
  * frame as tall as the terminal that newline scrolled the screen, so every
@@ -13,7 +13,7 @@
  * the last row, and the newline that ends it is written once, when the frame
  * is handed back.
  */
-import type { Destination } from "./color.js";
+import type { OutputTarget } from "./color.js";
 import type { Height } from "./protocol.js";
 import { Segment } from "./segment.js";
 /**
@@ -36,7 +36,7 @@ export type FrameSource = () => Segment[][];
 /**
  * What paints a run of frames on an output, from `take` to `handBack`.
  */
-export interface Painter {
+export interface Renderer {
     /** The budget a frame renders under, on a screen `screenRows` tall. */
     height(screenRows: number): Height;
     /** Take the output. */
@@ -45,12 +45,12 @@ export interface Painter {
      * Paint `frame` over the last frame. `frame` is already shaped to its
      * height by whoever set its budget. An empty frame erases the last one.
      */
-    paint(frame: FrameSource, screen: Screen, destination: Destination): void;
+    paint(frame: FrameSource, screen: Screen, destination: OutputTarget): void;
     /**
      * The bytes that write `text` while `frame` is the frame standing on the
      * output, for the caller to write in one piece.
      */
-    around(text: string, frame: FrameSource, screen: Screen, destination: Destination): string;
+    around(text: string, frame: FrameSource, screen: Screen, destination: OutputTarget): string;
     /** Hand the output back. The next `take` starts from wherever it then is. */
     handBack(): void;
 }
@@ -59,7 +59,7 @@ export interface Painter {
  * rows on the terminal — what the next paint goes back over — from `take` to
  * `handBack`.
  */
-export declare class SurfacePainter implements Painter {
+export declare class SurfaceRenderer implements Renderer {
     private readonly write;
     private readonly geometry;
     private rows;
@@ -74,13 +74,13 @@ export declare class SurfacePainter implements Painter {
      * not go back over. The rows returned are what `destination` shows
      * (`shownOn`): under reduced motion, nothing in them blinks.
      */
-    paint(frame: FrameSource, screen: Screen, destination: Destination): Segment[][];
+    paint(frame: FrameSource, screen: Screen, destination: OutputTarget): Segment[][];
     /**
      * The frame erased, `text` written, and `frame` painted again on the line
      * under it — in one string, so no terminal ever shows the frame gone. The
      * frame fills whole lines, so text that stops mid-line is ended before it.
      */
-    around(text: string, frame: FrameSource, screen: Screen, destination: Destination): string;
+    around(text: string, frame: FrameSource, screen: Screen, destination: OutputTarget): string;
     private over;
     /**
      * Hand the terminal back: style reset, then the cursor shown on the
@@ -96,7 +96,7 @@ export declare class SurfacePainter implements Painter {
  * the output is handed back. What is written around the frame goes out as it
  * was given. No frame is drawn but the one handed back.
  */
-export declare class FinalFramePainter implements Painter {
+export declare class FinalFrameRenderer implements Renderer {
     private readonly print;
     private last;
     constructor(print: (frame: Segment[][]) => void);

package/dist/core/paint.js

@@ -5,7 +5,7 @@
  * back.
  *
  * [LAW:one-source-of-truth] Where the cursor rests between frames, and how
- * many rows the next paint goes back over, is one fact, and a `SurfacePainter`
+ * many rows the next paint goes back over, is one fact, and a `SurfaceRenderer`
  * is its only owner: `App` holds one, and so does `Live` on a terminal, so
  * they cannot disagree about it. They once did: `Live` wrote a newline after its last row, and on a
  * frame as tall as the terminal that newline scrolled the screen, so every
@@ -65,7 +65,7 @@ const fitRows = (frame, screen) => frame.map((line) => Segment.adjustLineLength(
  * rows on the terminal — what the next paint goes back over — from `take` to
  * `handBack`.
  */
-export class SurfacePainter {
+export class SurfaceRenderer {
     write;
     geometry;
     rows = 0;
@@ -138,7 +138,7 @@ export class SurfacePainter {
  * the output is handed back. What is written around the frame goes out as it
  * was given. No frame is drawn but the one handed back.
  */
-export class FinalFramePainter {
+export class FinalFrameRenderer {
     print;
     last = () => [];
     constructor(print) {

package/dist/core/pretty.d.ts

@@ -46,7 +46,7 @@ export interface PrettyOptions {
      */
     indentGuides?: boolean;
     /**
-     * Who colours the formatted text. Defaults to a `ReprHighlighter`.
+     * Who colors the formatted text. Defaults to a `ReprHighlighter`.
      *
      * Passed rather than imported so a caller's choice survives. `Console.print`
      * routes data arguments through here, and its `highlight` flag and custom

package/dist/core/pretty.js

@@ -16,7 +16,7 @@
  * once to probe it and again to place it, so a node at depth d was visited 2^d
  * times.
  */
-import { asCellCol, cellColToCodeUnitOffset, cellLen, graphemes, replaceWithheld, splitAtCells, unicodeEscape, wireText } from "./cells.js";
+import { asCellCol, cellColToCodeUnitOffset, cellLen, graphemes, replaceZeroWidth, splitAtCells, unicodeEscape, wireText } from "./cells.js";
 import { divideLine } from "./wrap.js";
 import { Memo } from "./memo.js";
 import { Segment } from "./segment.js";
@@ -233,7 +233,7 @@ function fitOneLine(lines, budget) {
  * A typed array is an array with a fixed element type, and neither of the two
  * questions asked elsewhere in this file recognises it: `Array.isArray` says
  * false, and its own `toString` answers the bare `1,2,3` — no brackets, nothing
- * for the highlighter to colour per element. Both spellings reach the one arm
+ * for the highlighter to color per element. Both spellings reach the one arm
  * that knows what a sequence looks like. `DataView` is excluded because it is a
  * window onto bytes, not a sequence of values.
  *
@@ -472,7 +472,7 @@ const BARE_KEY = pattern(/^(?![^]*\p{Default_Ignorable_Code_Point})(?:[\p{ID_Sta
  */
 const unprintable = () => /(?! )[\p{Cc}\p{Cf}\p{Co}\p{Cn}\p{Zl}\p{Zp}\p{Zs}]/gu;
 /** `value` in double quotes, every character that does not print or that the wire would withhold escaped. */
-const quoted = (value) => replaceWithheld(JSON.stringify(value), unicodeEscape).replace(unprintable(), unicodeEscape);
+const quoted = (value) => replaceZeroWidth(JSON.stringify(value), unicodeEscape).replace(unprintable(), unicodeEscape);
 export class Pretty {
     data;
     indent;

package/dist/core/protocol.d.ts

@@ -3,7 +3,7 @@
  * [LAW:one-source-of-truth] These interfaces are the single authority for the rendering contract.
  */
 import type { Segment } from "./segment.js";
-import { Style, type Hold, type StyleSyntaxError, type Theme } from "./style.js";
+import { Style, type ValidityInterval, type StyleSyntaxError, type Theme } from "./style.js";
 import { ColorDepth, type TerminalColors } from "./color.js";
 import type { TextOrder } from "./text-order.js";
 import type { Highlighter } from "./highlighter.js";
@@ -20,7 +20,7 @@ import type { Highlighter } from "./highlighter.js";
 export type OverflowMethod = "fold" | "crop" | "ellipsis" | "ignore";
 /**
  * The frame being drawn, as a value: `time`, the moment it is drawn for, in
- * seconds, on the clock its cells' `nextChange` stamps are read on, and
+ * seconds, on the clock its cells' `validUntil` stamps are read on, and
  * `host`, the identity of what drew it — nothing to read, so what draws in
  * the frame has one time, this one, and cannot ask the host for another.
  * [LAW:types-are-the-program] A `Progress` keeps the identity to refuse a
@@ -91,18 +91,18 @@ export interface RenderOptions {
      */
     highlighter?: Highlighter;
     /**
-     * The depth the output will be encoded at, `null` when it carries no colour.
+     * The depth the output will be encoded at, `null` when it carries no color.
      * A renderable that measures what it draws — the strip's joiner, holding a
-     * seam's ink off its ground — measures the colours the terminal will draw at
-     * this depth, which at 256 colours or fewer are not the colours it was
+     * seam's ink off its ground — measures the colors the terminal will draw at
+     * this depth, which at 256 colors or fewer are not the colors it was
      * handed. Absent means truecolor.
      */
     colorSystem?: ColorDepth | null;
     /** What the output's destination does with direction. Absent is `"plain"`. */
     textOrder?: TextOrder;
     /**
-     * The terminal the output is drawn on: the colours a cell that sets none is
-     * drawn in, and the sixteen an ANSI colour names. The terminal's own palette
+     * The terminal the output is drawn on: the colors a cell that sets none is
+     * drawn in, and the sixteen an ANSI color names. The terminal's own palette
      * is never queried, so the program says what it is, once, where the output
      * is decided; a renderable reads it here (`Effected`, `ProgressBar`) and
      * nothing hands it down to one. Absent is the terminal the depth assumes
@@ -125,7 +125,7 @@ export interface RenderOptions {
      * The reader asked for reduced motion — CSS's `prefers-reduced-motion`,
      * which a terminal has no way to report, so a host is told. Every placed
      * animation is drawn reduced, its motion taken out and its content kept on
-     * time (`shownAt`, `Animation.reduced`, `./animation.ts`), and a `Destination`
+     * time (`shownAt`, `Animation.reduced`, `./animation.ts`), and an `OutputTarget`
      * told the same writes no blink (`shownOn`, `./render.ts`). Absent, everything
      * moves. Nothing here reads it from the environment.
      */
@@ -142,13 +142,13 @@ export interface RenderOptions {
     /**
      * Told of every renderable `render` is asked for, as it is asked, so the
      * calls arrive in document order: a container before what it holds, what
-     * it holds in the order it renders it. `"drawn"` is a renderable drawn at
-     * the width it was handed; `"held"` is one handed no column, which is still
+     * it holds in the order it renders it. `"visible"` is a renderable drawn at
+     * the width it was handed; `"hidden"` is one handed no column, which is still
      * in the view but has nothing drawn for it (`render`). A renderable rendered
      * twice is told twice. A render made to measure is not drawing and is not
      * told (`measuring`).
      */
-    onPresent?: (renderable: Renderable, presence: Presence) => void;
+    onVisibility?: (renderable: Renderable, visibility: Visibility) => void;
     /**
      * Told of a hold the frame is in that no cell of it may carry: an animation
      * placed in the view reports its own, whether or not it drew a cell — one
@@ -159,16 +159,16 @@ export interface RenderOptions {
      * (`measuring`) and a held render (`holding`) tell too: what they find
      * decides the frame's layout, so when it changes, the frame may.
      */
-    onHold?: (hold: Hold) => void;
+    onValidity?: (validity: ValidityInterval) => void;
     /**
      * Told of the hold the element `key` names, drawn for a time on its own
      * clock, is in: an effect's frame, which alone knows, since the answer
-     * depends on what it drew. `t` is that clock's, not the frame's, so this cannot be `onHold`:
+     * depends on what it drew. `t` is that clock's, not the frame's, so this cannot be `onValidity`:
      * the animation placed around the value carries the answer back through the
-     * combinators that remapped the time (`Moves`, `./animation.ts`). It reaches
+     * combinators that remapped the time (`Reads`, `./animation.ts`). It reaches
      * whatever `frame` reaches.
      */
-    onMoved?: (t: number, key: string, hold: Hold) => void;
+    onReads?: (t: number, key: string, validity: ValidityInterval) => void;
 }
 /** The one field of the render options that says whether the reader wants motion. */
 export type Motion = Pick<RenderOptions, "reducedMotion">;
@@ -176,7 +176,7 @@ export type Motion = Pick<RenderOptions, "reducedMotion">;
  * Whether a renderable the view holds was drawn, or held: in the view, handed
  * no column, and so not drawn (`render`).
  */
-export type Presence = "drawn" | "held";
+export type Visibility = "visible" | "hidden";
 /** Whether `text` is all ASCII — what an `asciiOnly` output can draw. */
 export declare const isAscii: (text: string) => boolean;
 /**
@@ -285,19 +285,19 @@ export type StyleErrorHandler = (error: StyleSyntaxError, style: string) => void
 export declare function getStyle(options: RenderOptions, style: string | Style): Style;
 /**
  * `style` as the depth the render is encoded at can draw it. A style that
- * paints its own ground in fixed colours chose its ink and ground as a pair;
- * at sixteen colours the writer rounds a fixed colour to an ANSI slot, which
- * the terminal paints in its own theme's colour, and no pair of slots reads in
- * every bundled theme. So where the depth would turn a fixed colour of the
+ * paints its own ground in fixed colors chose its ink and ground as a pair;
+ * at sixteen colors the writer rounds a fixed color to an ANSI slot, which
+ * the terminal paints in its own theme's color, and no pair of slots reads in
+ * every bundled theme. So where the depth would turn a fixed color of the
  * pair into a slot, the pair is dropped and the run is drawn on the
  * terminal's own foreground and background, which its theme does make
  * readable; its attributes still set it apart. Both are named, not left
- * unset, so the colour of whatever the run sits in — a quote, a link — does
- * not show through: Rich's code keeps its own colours inside a quote, and the
- * terminal's are the ones it keeps here. A style whose colours are
+ * unset, so the color of whatever the run sits in — a quote, a link — does
+ * not show through: Rich's code keeps its own colors inside a quote, and the
+ * terminal's are the ones it keeps here. A style whose colors are
  * slots already (`white on blue`), or that paints no ground (`bold magenta`),
- * was written for the terminal's own colours and is drawn as written. Rich
- * draws a highlighted line number the same way below 256 colours
+ * was written for the terminal's own colors and is drawn as written. Rich
+ * draws a highlighted line number the same way below 256 colors
  * (`Syntax._get_number_styles`).
  */
 export declare function groundedStyle(options: RenderOptions, style: Style): Style;
@@ -374,7 +374,7 @@ export declare function afterPass(effect: () => void): void;
  * write during render is refused at: a `State` set in a pass that did not make
  * it throws (`./state.ts`).
  *
- * It is also the one reporter of what the view holds (`onPresent`). Under one
+ * It is also the one reporter of what the view holds (`onVisibility`). Under one
  * column a renderable is held: in the view, with nothing of it on the frame.
  * It is drawn all the same and what it drew dropped (`holding`), so what a held
  * container is reported holding is what it draws, under the options it hands

package/dist/core/protocol.js

@@ -65,19 +65,19 @@ export function getStyle(options, style) {
 const TERMINAL_GROUND = Style.parse("default on default");
 /**
  * `style` as the depth the render is encoded at can draw it. A style that
- * paints its own ground in fixed colours chose its ink and ground as a pair;
- * at sixteen colours the writer rounds a fixed colour to an ANSI slot, which
- * the terminal paints in its own theme's colour, and no pair of slots reads in
- * every bundled theme. So where the depth would turn a fixed colour of the
+ * paints its own ground in fixed colors chose its ink and ground as a pair;
+ * at sixteen colors the writer rounds a fixed color to an ANSI slot, which
+ * the terminal paints in its own theme's color, and no pair of slots reads in
+ * every bundled theme. So where the depth would turn a fixed color of the
  * pair into a slot, the pair is dropped and the run is drawn on the
  * terminal's own foreground and background, which its theme does make
  * readable; its attributes still set it apart. Both are named, not left
- * unset, so the colour of whatever the run sits in — a quote, a link — does
- * not show through: Rich's code keeps its own colours inside a quote, and the
- * terminal's are the ones it keeps here. A style whose colours are
+ * unset, so the color of whatever the run sits in — a quote, a link — does
+ * not show through: Rich's code keeps its own colors inside a quote, and the
+ * terminal's are the ones it keeps here. A style whose colors are
  * slots already (`white on blue`), or that paints no ground (`bold magenta`),
- * was written for the terminal's own colours and is drawn as written. Rich
- * draws a highlighted line number the same way below 256 colours
+ * was written for the terminal's own colors and is drawn as written. Rich
+ * draws a highlighted line number the same way below 256 colors
  * (`Syntax._get_number_styles`).
  */
 export function groundedStyle(options, style) {
@@ -230,7 +230,7 @@ const ITERATOR_PROTOTYPE = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol
  * write during render is refused at: a `State` set in a pass that did not make
  * it throws (`./state.ts`).
  *
- * It is also the one reporter of what the view holds (`onPresent`). Under one
+ * It is also the one reporter of what the view holds (`onVisibility`). Under one
  * column a renderable is held: in the view, with nothing of it on the frame.
  * It is drawn all the same and what it drew dropped (`holding`), so what a held
  * container is reported holding is what it draws, under the options it hands
@@ -239,13 +239,13 @@ const ITERATOR_PROTOTYPE = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol
  */
 export function render(renderable, options) {
     const opens = active === undefined;
-    const presence = drawsNothing(options) ? "held" : "drawn";
-    const { phase, drawing } = presence === "drawn" ? { phase: phaseHere(), drawing: options } : holding(options);
+    const visibility = drawsNothing(options) ? "hidden" : "visible";
+    const { phase, drawing } = visibility === "visible" ? { phase: phaseHere(), drawing: options } : holding(options);
     const drawn = runIn(phase, () => {
-        options.onPresent?.(renderable, presence);
+        options.onVisibility?.(renderable, visibility);
         return renderable.render(drawing);
     });
-    if (presence === "held") {
+    if (visibility === "hidden") {
         runIn(phase, () => {
             for (const _ of drawn)
                 ;
@@ -257,7 +257,7 @@ export function render(renderable, options) {
 /**
  * Where a held renderable is drawn, and the options it is drawn under: what
  * it draws is dropped, and everything it draws is reported held, whatever
- * width it hands it. What it tells of its hold (`onHold`) still reaches the
+ * width it hands it. What it tells of its hold (`onValidity`) still reaches the
  * frame: an element not yet entered is held at no width, and must say when it
  * enters and takes some. A motion held at no width therefore wakes its host
  * for frames that look the same: when it next takes room is not a moment its
@@ -275,14 +275,14 @@ export function render(renderable, options) {
  * can repeat.
  */
 function holding(options) {
-    const { onPresent, onMoved } = options;
+    const { onVisibility, onReads } = options;
     return {
         phase: { pass: phaseHere().pass, effects: [] },
         drawing: {
             ...options,
             maxWidth: 0,
-            onPresent: onPresent && ((content) => onPresent(content, "held")),
-            onMoved: onMoved && ((t, key) => onMoved(t, key, NEVER_CHANGES)),
+            onVisibility: onVisibility && ((content) => onVisibility(content, "hidden")),
+            onReads: onReads && ((t, key) => onReads(t, key, NEVER_CHANGES)),
         },
     };
 }
@@ -300,16 +300,16 @@ export function measure(measurable, options) {
 }
 /**
  * `options` as a measurement is asked with. A `measure` that renders to learn
- * its shape draws nothing on the frame, so it reports nothing to `onPresent` —
+ * its shape draws nothing on the frame, so it reports nothing to `onVisibility` —
  * one that did would put a widget in the view at the moment a container
  * measured it, and keep one the frame then cropped away — and nothing to
- * `onMoved`, which speaks only for what the frame shows. It still tells its
- * hold (`onHold`): a layout decided by a measurement changes when it does.
+ * `onReads`, which speaks only for what the frame shows. It still tells its
+ * hold (`onValidity`): a layout decided by a measurement changes when it does.
  *
  * [LAW:single-enforcer] Every measurement starts here: `measure` asks with it.
  */
 function measuring(options) {
-    return { ...options, onPresent: undefined, onMoved: undefined };
+    return { ...options, onVisibility: undefined, onReads: undefined };
 }
 /**
  * The options a renderable should *lay out against*: `withCellWidth`, with an