@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/renderables/lifecycle.js

@@ -23,11 +23,11 @@
  * them with its hold at the frame's time (`placedRender`). The exit is
  * drawn over whatever the arrival draws, so an element told to leave while
  * it is still arriving leaves from where it is, never shown whole first —
- * though a colour exit is spread over the cells each frame shows, so a cell
+ * though a color exit is spread over the cells each frame shows, so a cell
  * the arrival adds can move one already leaving back toward whole
  * (`ownChange`, `./effects.ts`). [LAW:dataflow-not-control-flow]
  *
- * A half draws the element through a colour transition (`throughColors`, a
+ * A half draws the element through a color transition (`throughColors`, a
  * `fadeIn`) or a glyph one (`throughGlyphs`, a `typewriter`): each binds its
  * transition to the one wrapper that draws it, so nothing here asks which kind
  * a half is, and a line can type itself in and dissolve out. A half
@@ -46,11 +46,11 @@ import { firstReaching } from "../core/easing.js";
 import { Timeline } from "../core/timeline.js";
 import { Effected } from "./effect.js";
 import { GlyphEffected } from "./glyph-effect.js";
-/** `transition`'s colours drawn over an element, arriving from and leaving to the ground of the terminal the frame is drawn on. */
+/** `transition`'s colors drawn over an element, arriving from and leaving to the ground of the terminal the frame is drawn on. */
 export function throughColors(transition) {
     return (element, key) => scheduled(new Effected(element, transition.effect, { key }), transition.schedule);
 }
-/** `transition`'s glyphs drawn over an element, at every depth, with no colour too. */
+/** `transition`'s glyphs drawn over an element, at every depth, with no color too. */
 export function throughGlyphs(transition) {
     return (element, key) => scheduled(new GlyphEffected(element, transition.effect, { key }), transition.schedule);
 }
@@ -59,14 +59,14 @@ export function throughGlyphs(transition) {
  * `schedule`, the transition's own, says: its frames with the one word on
  * when they change that the transition has and the wrapper lacks, whose own
  * answer is "now" until it is drawn. [LAW:one-source-of-truth] Reduced,
- * both are reduced together, as `onBeat` steps both: a one-shot's effect
+ * both are reduced together, as `sampleAndHold` steps both: a one-shot's effect
  * and its schedule each reduce to a cut at 0 (`transition`, `./effects.ts`).
  */
 function scheduled(placed, schedule) {
     return Animation.of({
         at: (t) => placed.at(t),
-        nextChange: (t) => schedule.nextChange(t),
-        lastChange: (t) => schedule.lastChange(t),
+        validUntil: (t) => schedule.validUntil(t),
+        validFrom: (t) => schedule.validFrom(t),
         reduced: () => scheduled(placed.reduced(), schedule.reduced()),
     });
 }
@@ -120,7 +120,7 @@ function life(element, options, halves, entered, left) {
     const arriving = Timeline.run(Timeline.play(entered), arrival);
     // What the element draws by `t` if it is not leaving: arriving through `enter`, then itself.
     const shown = (t) => (t < arrived ? arrival.at(t - entered) : element);
-    const held = (schedule, t) => ({ last: schedule.lastChange(t), next: schedule.nextChange(t) });
+    const held = (schedule, t) => ({ last: schedule.validFrom(t), next: schedule.validUntil(t) });
     // [LAW:one-source-of-truth] Each phase's frame and its hold, side by side, so the two cannot disagree.
     // The frames say nothing of when they change — the hold does, stamped where the lifecycle is placed.
     const phase = (t) => {
@@ -146,16 +146,16 @@ function life(element, options, halves, entered, left) {
             : { frame: NOTHING, last: left, next: t < goneAt ? goneAt : Number.POSITIVE_INFINITY };
     const present = Animation.of({
         at: (t) => there(t).frame,
-        nextChange: (t) => there(t).next,
-        lastChange: (t) => there(t).last,
+        validUntil: (t) => there(t).next,
+        validFrom: (t) => there(t).last,
         reduced: () => present,
     });
     return Animation.of({
         entered,
         left,
         at: (t) => phase(t).frame,
-        nextChange: (t) => phase(t).next,
-        lastChange: (t) => phase(t).last,
+        validUntil: (t) => phase(t).next,
+        validFrom: (t) => phase(t).last,
         // Reduced, the element is there from when it entered until it is told to leave: no arrival or exit to show, and the times kept.
         reduced: () => present,
         // [LAW:one-source-of-truth] The moment `phase` draws nothing from, so an element not yet told to leave is never asked its exit at -Infinity.

package/dist/renderables/live.d.ts

@@ -14,7 +14,7 @@
  * when the display stops, as Rich's `Live` does.
  *
  * Live is not built on `App`, though both take a terminal, paint a frame over
- * the last and hand the terminal back. That much is the `Painter`'s, and both
+ * the last and hand the terminal back. That much is the `Renderer`'s, and both
  * hold one. The rest differs in who owns what. An `App` owns its terminal: it
  * starts and stops a `TerminalHost`, sets raw mode, reads keys and pointers,
  * suspends, and builds its own `Console` from the host. A `Live` owns none of
@@ -35,7 +35,7 @@ export interface LiveOptions {
      * positive and finite, fractional included. The next frame comes a frame
      * interval after the last one drawn, a `refresh()` of your own included,
      * or sooner when that frame's content says it changes sooner
-     * (`Segment.nextChange`).
+     * (`Segment.validUntil`).
      */
     refreshPerSecond?: number;
     /** What the auto-refresh waits on. The platform's, unless given. */

package/dist/renderables/live.js

@@ -14,7 +14,7 @@
  * when the display stops, as Rich's `Live` does.
  *
  * Live is not built on `App`, though both take a terminal, paint a frame over
- * the last and hand the terminal back. That much is the `Painter`'s, and both
+ * the last and hand the terminal back. That much is the `Renderer`'s, and both
  * hold one. The rest differs in who owns what. An `App` owns its terminal: it
  * starts and stops a `TerminalHost`, sets raw mode, reads keys and pointers,
  * suspends, and builds its own `Console` from the host. A `Live` owns none of
@@ -27,7 +27,7 @@
 import { frameRate, systemClock } from "../core/clock.js";
 import { Console } from "../core/console.js";
 import { Segment } from "../core/segment.js";
-import { FinalFramePainter, SurfacePainter } from "../core/paint.js";
+import { FinalFrameRenderer, SurfaceRenderer } from "../core/paint.js";
 import { fitHeight, render } from "../core/protocol.js";
 import { Timeline } from "../core/timeline.js";
 import { drawView, frameNow, hostView, undrawn } from "../core/view.js";
@@ -71,8 +71,8 @@ export class Live {
         // The final frame is a print, as in Rich, so a recording or a capture
         // holds it with everything else the console wrote.
         this._painter = this._console.isInteractive
-            ? new SurfacePainter(options?.altScreen ? "alternate" : "inline", (bytes) => void this._console.file.write(bytes))
-            : new FinalFramePainter((frame) => this._console.print(linesOf(frame)));
+            ? new SurfaceRenderer(options?.altScreen ? "alternate" : "inline", (bytes) => void this._console.file.write(bytes))
+            : new FinalFrameRenderer((frame) => this._console.print(linesOf(frame)));
     }
     /**
      * The console to print through while this Live runs: what it prints lands
@@ -177,7 +177,7 @@ export class Live {
         this._wake(held, said ?? undrawn(this._clock.now()));
     }
     // Arm the one wait for the next auto-refresh frame while `held`, from what
-    // the frame says: at its `nextChange` when it holds until a moment sooner
+    // the frame says: at its `validUntil` when it holds until a moment sooner
     // than the rate, and at the rate otherwise — every view is drawn from state
     // that may change without saying so, which the auto-refresh polls, as
     // Rich's does, a paused timeline's included. Every moment is measured from the
@@ -185,11 +185,11 @@ export class Live {
     // does not stretch by what a frame cost to draw, and a change that fell
     // due while it was drawn is drawn at once (`Clock.at` fires now for a time
     // already past).
-    _wake(held, { t, nextChange }) {
+    _wake(held, { t, validUntil }) {
         this._waking.get()?.stop();
         this._waking.set(undefined);
         const rate = t + this._rate.interval;
-        const at = nextChange <= t ? rate : Math.min(nextChange, rate);
+        const at = validUntil <= t ? rate : Math.min(validUntil, rate);
         if (!this._autoRefresh)
             return;
         // No caller is on the stack to run `stop()` for a frame that throws

package/dist/renderables/markdown-parse.js

@@ -13,7 +13,7 @@
  */
 import { linkHref, normalizeLinkText } from "./markdown-url.js";
 import { PY_WHITESPACE, pyStrip } from "./python-space.js";
-import { namedReference } from "./html-entities.js";
+import { namedCharacterReference } from "./html-entities.js";
 import { pattern } from "../core/pattern.js";
 /** A line of the source as the top level holds it. */
 function sourceLine(text) {
@@ -807,7 +807,7 @@ function referenceAt(text, i) {
     const named = matchAt(NAMED_REFERENCE, text, i);
     if (!named)
         return undefined;
-    const chars = namedReference(named[1]);
+    const chars = namedCharacterReference(named[1]);
     return chars === undefined ? undefined : { kind: "text", text: chars, end: i + named[0].length };
 }
 /**
@@ -821,7 +821,7 @@ function unescapeAll(text) {
         if (escaped !== undefined)
             return escaped;
         const numeric = DESTINATION_NUMERIC.exec(whole);
-        const chars = numeric ? referencedCharacter(referencedCode(numeric[1])) : namedReference(whole.slice(1, -1));
+        const chars = numeric ? referencedCharacter(referencedCode(numeric[1])) : namedCharacterReference(whole.slice(1, -1));
         return chars ?? whole;
     });
 }

package/dist/renderables/panel.js

@@ -1,7 +1,7 @@
 /**
  * Panel — a bordered box that wraps content, with optional title and subtitle.
  */
-import { labelled } from "../core/orient.js";
+import { labeled } from "../core/orient.js";
 import { cellLen, setCellSize, asCellCol, cellCount } from "../core/cells.js";
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
@@ -40,7 +40,7 @@ function borderTitle(label, options) {
 }
 /**
  * The style of text set into a border — title, subtitle and accessory alike:
- * its own laid over the border's, the one rule for "what colour is the title
+ * its own laid over the border's, the one rule for "what color is the title
  * text in". Laid over rather than in place of it, as Rich's `stylize_before`
  * does, because the border's style carries the panel's own: a title that
  * replaced it cut a hole in the panel's background on the top row. The text
@@ -243,7 +243,7 @@ export class Panel {
         const corner = box.bottom.right.repeat(geometry.right);
         const [close, afterAccessory] = accessoryText === "" ? [corner, ""] : ["", corner];
         yield* borderRow(options, box.bottom, geometry, geometry.spanWidth - cellLen(accessoryText), this._subtitleLabel, subtitleStyle, border, close);
-        yield* labelled("", accessoryText, "", borderTextStyle(border, accessoryOwn), options.textOrder);
+        yield* labeled("", accessoryText, "", borderTextStyle(border, accessoryOwn), options.textOrder);
         yield new Segment(afterAccessory, border);
         yield Segment.line();
     }

package/dist/renderables/progress.d.ts

@@ -89,7 +89,7 @@ export declare class BarColumn implements ProgressColumn {
      * toward, pulses, and a pulse draws no fill. Otherwise the bar is the
      * task's `fill` drawn at the frame's time, every cell stamped with when the
      * fill next moves, so a host draws while it eases and the bar asks for
-     * nothing once it lands. Its colour is the task's: an ease that overshoots
+     * nothing once it lands. Its color is the task's: an ease that overshoots
      * the total does not finish the bar, and one that dips back does not
      * unfinish it.
      */

package/dist/renderables/progress.js

@@ -113,7 +113,7 @@ export class BarColumn {
      * toward, pulses, and a pulse draws no fill. Otherwise the bar is the
      * task's `fill` drawn at the frame's time, every cell stamped with when the
      * fill next moves, so a host draws while it eases and the bar asks for
-     * nothing once it lands. Its colour is the task's: an ease that overshoots
+     * nothing once it lands. Its color is the task's: an ease that overshoots
      * the total does not finish the bar, and one that dips back does not
      * unfinish it.
      */

package/dist/renderables/progressBar.d.ts

@@ -44,7 +44,7 @@ export declare class ProgressBar implements Renderable, Measurable {
     set finished(value: boolean | undefined);
     render(options: RenderOptions): Iterable<Segment>;
     /**
-     * The shimmer over this bar's back colour as `Effected` sees it drawn,
+     * The shimmer over this bar's back color as `Effected` sees it drawn,
      * toward `bar.pulse`. A bar has no words to keep legible, so its back takes
      * the whole of the light.
      */

package/dist/renderables/progressBar.js

@@ -20,7 +20,7 @@ const HALF_BAR_LEFT = "╺";
  */
 const PULSE_CURVE = { ...EFFECT_CURVES.shimmer, seconds: 5 };
 const PULSE_REACH = 10;
-/** Rich's pulse back where the back style names no colour. */
+/** Rich's pulse back where the back style names no color. */
 const PULSE_BACK = ColorSpec.fromRgba(new ColorRgba(0, 0, 0));
 export class ProgressBar {
     // Rich's ProgressBar is updated after it is built: `bar.completed = n`.
@@ -70,11 +70,11 @@ export class ProgressBar {
             return;
         }
         const depth = options.colorSystem ?? ColorDepth.TRUECOLOR;
-        // Rich's pulse resolves its colours on the terminal a depth assumes, as
+        // Rich's pulse resolves its colors on the terminal a depth assumes, as
         // `get_truecolor` does with no theme; so does this with none named.
         const terminal = resolveTerminal(options.terminal, depth);
-        // Rich writes the pulse's back as a colour of its own, black where the
-        // back style names none, so the light always has the bar's colour to fall
+        // Rich writes the pulse's back as a color of its own, black where the
+        // back style names none, so the light always has the bar's color to fall
         // on: one the terminal supplies takes no light.
         const style = getStyle(options, this.style);
         const ink = style.color?.isDefault === false ? style.color : ColorSpec.fromRgba((style.color ?? PULSE_BACK).getTruecolor(terminal, true));
@@ -85,7 +85,7 @@ export class ProgressBar {
         yield* render(new Effected(track, this.pulseEffect(options, back), { key: "progress-bar" }), options);
     }
     /**
-     * The shimmer over this bar's back colour as `Effected` sees it drawn,
+     * The shimmer over this bar's back color as `Effected` sees it drawn,
      * toward `bar.pulse`. A bar has no words to keep legible, so its back takes
      * the whole of the light.
      */
@@ -117,7 +117,7 @@ export class ProgressBar {
             yield new Segment(bar.repeat(barCount), fillStyle);
         if (halfBarCount)
             yield new Segment(drawable(options, HALF_BAR_RIGHT, " "), fillStyle);
-        // The back is drawn in colour alone, so an output with none leaves it blank.
+        // The back is drawn in color alone, so an output with none leaves it blank.
         if (options.colorSystem === null)
             return;
         let remaining = width - barCount - halfBarCount;

package/dist/renderables/prompt.d.ts

@@ -29,7 +29,7 @@ import { RichText } from "../core/text.js";
  * on, and resolves with the raw user response. Implementations decide where
  * the input comes from (stdin readline, network, in-memory queue, etc.); the
  * console is what the prompt is drawn with, as Rich's `Console.input` draws
- * it — its theme, its colours, the target it writes to.
+ * it — its theme, its colors, the target it writes to.
  *
  * [LAW:effects-at-boundaries] The prompt arrives as a `RichText`, not bytes:
  * encoding it is the console's job, and the console arrives with it.

package/dist/renderables/scroll.d.ts

@@ -5,7 +5,7 @@
  *
  * [LAW:one-type-per-behavior] A marquee, a scroll and a slide are one window
  * and differ only in the motion handed in: the offset along each axis is an
- * `Animation<number>`, so a marquee is a looping `Phase` scaled to the span
+ * `Animation<number>`, so a marquee is a looping `WrapMode` scaled to the span
  * it crosses and a slide-in is a `tween` to 0, and when the window next
  * changes is `Animation.all`'s answer over the two. Nothing here knows which
  * one it is drawing.

package/dist/renderables/scroll.js

@@ -5,7 +5,7 @@
  *
  * [LAW:one-type-per-behavior] A marquee, a scroll and a slide are one window
  * and differ only in the motion handed in: the offset along each axis is an
- * `Animation<number>`, so a marquee is a looping `Phase` scaled to the span
+ * `Animation<number>`, so a marquee is a looping `WrapMode` scaled to the span
  * it crosses and a slide-in is a `tween` to 0, and when the window next
  * changes is `Animation.all`'s answer over the two. Nothing here knows which
  * one it is drawing.
@@ -91,8 +91,8 @@ class ScrollFrame {
         // [LAW:one-source-of-truth] What the window shows is cut from the whole content, so it may change
         // when anything in the content does — a row above the slot entering pushes every row down, and run
         // backwards, leaving it pulls them up. The cut throws away the cells that hold rode on, so it is
-        // told to the frame (`RenderOptions.onHold`).
-        options.onHold?.({ lastChange: Segment.lastChange(drawn), nextChange: Segment.nextChange(drawn) });
+        // told to the frame (`RenderOptions.onValidity`).
+        options.onValidity?.({ validFrom: Segment.validFrom(drawn), validUntil: Segment.validUntil(drawn) });
         for (let r = 0; r < this.height; r++) {
             const line = lines[this.row + r] ?? [];
             const shown = Segment.divide(line, [start, start + width - blank])[1] ?? [];

package/dist/renderables/spinner.d.ts

@@ -75,8 +75,8 @@ export declare class Spinner implements Animation<Renderable & Measurable> {
     private readonly _ascii;
     /**
      * The spinner drawn at the frame's time, its cells saying the hold it is in
-     * on the host's clock (`stampFrame`) — exactly, for the frames the output
-     * draws, where `nextChange` must answer for both. Under reduced motion it
+     * on the host's clock (`stampValidityFrame`) — exactly, for the frames the output
+     * draws, where `validUntil` must answer for both. Under reduced motion it
      * is the spinner reduced, which never turns (`shownAt`).
      */
     private readonly _placed;
@@ -109,9 +109,9 @@ export declare class Spinner implements Animation<Renderable & Measurable> {
      * output keeps its own interval. An early answer, on the output that draws
      * the other one, which the contract allows; the drawn cells carry the exact one.
      */
-    nextChange(t: number): number;
+    validUntil(t: number): number;
     /** When the spinner drawn at `t` began to be drawn: the later of its two sequences' answers, by the same argument. */
-    lastChange(t: number): number;
+    validFrom(t: number): number;
     private _render;
     /**
      * The frame in progress and the label as one text, as Rich's

package/dist/renderables/spinner.js

@@ -46,7 +46,7 @@
  * frame forever, which a paused timeline is and a rate is not, and the
  * timeline refuses it.
  */
-import { Animation, frameTimeOf, holdOf, shownAt, stampFrame } from "../core/animation.js";
+import { Animation, frameTimeOf, validityOf, shownAt, stampValidityFrame } from "../core/animation.js";
 import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
 import { RichText } from "../core/text.js";
@@ -88,8 +88,8 @@ export class Spinner {
     _ascii;
     /**
      * The spinner drawn at the frame's time, its cells saying the hold it is in
-     * on the host's clock (`stampFrame`) — exactly, for the frames the output
-     * draws, where `nextChange` must answer for both. Under reduced motion it
+     * on the host's clock (`stampValidityFrame`) — exactly, for the frames the output
+     * draws, where `validUntil` must answer for both. Under reduced motion it
      * is the spinner reduced, which never turns (`shownAt`).
      */
     _placed;
@@ -113,7 +113,7 @@ export class Spinner {
         this._placed = this._frame((played, options) => {
             const t = frameTimeOf(options);
             const shown = shownAt(played, t, options);
-            return { value: shown.value, hold: holdOf(shown, t) };
+            return { value: shown.value, validity: validityOf(shown, t) };
         });
     }
     get frames() {
@@ -150,9 +150,9 @@ export class Spinner {
         const drawn = (options) => drawable(options, this._named, this._ascii, sequenceGlyphs);
         return {
             render: (options) => {
-                const { value, hold } = choose(drawn(options).played, options);
+                const { value, validity } = choose(drawn(options).played, options);
                 const segments = this._render(value, options);
-                return hold === undefined ? segments : stampFrame(segments, hold);
+                return validity === undefined ? segments : stampValidityFrame(segments, validity);
             },
             // Measured at the frames' one width, the widest frame's, so a column
             // holding it never narrows as it turns, and never offered less than
@@ -172,12 +172,12 @@ export class Spinner {
      * output keeps its own interval. An early answer, on the output that draws
      * the other one, which the contract allows; the drawn cells carry the exact one.
      */
-    nextChange(t) {
-        return Math.min(this._named.played.nextChange(t), this._ascii.played.nextChange(t));
+    validUntil(t) {
+        return Math.min(this._named.played.validUntil(t), this._ascii.played.validUntil(t));
     }
     /** When the spinner drawn at `t` began to be drawn: the later of its two sequences' answers, by the same argument. */
-    lastChange(t) {
-        return Math.max(this._named.played.lastChange(t), this._ascii.played.lastChange(t));
+    validFrom(t) {
+        return Math.max(this._named.played.validFrom(t), this._ascii.played.validFrom(t));
     }
     *_render(frame, options) {
         yield* render(this._line(frame, options), options);

package/dist/renderables/syntax.d.ts

@@ -2,10 +2,10 @@
  * Syntax — renders source code with basic syntax highlighting.
  * Uses built-in tokenization (no external dependency).
  *
- * Colours are names in the console's theme (`syntax.keyword`,
+ * Colors are names in the console's theme (`syntax.keyword`,
  * `syntax.line_number`, …), not a per-instance palette: a theme is how every
  * other renderable here is restyled, and a second styling vocabulary on this
- * one class would be a second answer to "what colour is a keyword".
+ * one class would be a second answer to "what color is a keyword".
  */
 import { Segment } from "../core/segment.js";
 import { type Measurable, type Renderable, type RenderOptions } from "../core/protocol.js";

package/dist/renderables/syntax.js

@@ -2,10 +2,10 @@
  * Syntax — renders source code with basic syntax highlighting.
  * Uses built-in tokenization (no external dependency).
  *
- * Colours are names in the console's theme (`syntax.keyword`,
+ * Colors are names in the console's theme (`syntax.keyword`,
  * `syntax.line_number`, …), not a per-instance palette: a theme is how every
  * other renderable here is restyled, and a second styling vocabulary on this
- * one class would be a second answer to "what colour is a keyword".
+ * one class would be a second answer to "what color is a keyword".
  */
 import { escaped } from "../core/bidi.js";
 import { cellLen, expandTabs, parseTabSize, unicodeEscape } from "../core/cells.js";

package/dist/renderables/table.js

@@ -6,7 +6,7 @@ import { Segment } from "../core/segment.js";
 import { NULL_STYLE } from "../core/style.js";
 import { HEAVY_HEAD } from "../core/box.js";
 import { RichText } from "../core/text.js";
-import { EmbeddedText, embed, present } from "./embed.js";
+import { EmbeddedText, embed, mounted } from "./embed.js";
 import { Padding, normalizePadding } from "./padding.js";
 import { exactWeights, ratioDistribute, ratioReduce } from "./ratio.js";
 import { getStyle, render, stackedHeight, withBoundedWidth, withCellWidth } from "../core/protocol.js";
@@ -367,9 +367,9 @@ export class Table {
         // An empty title draws no row, as the reference's `if self.title` draws
         // none; markup that styles nothing is a title, and draws a blank one.
         const titleVal = options?.title;
-        this._title = present(titleVal) ? new EmbeddedText(titleVal) : undefined;
+        this._title = mounted(titleVal) ? new EmbeddedText(titleVal) : undefined;
         const captionVal = options?.caption;
-        this._caption = present(captionVal) ? new EmbeddedText(captionVal) : undefined;
+        this._caption = mounted(captionVal) ? new EmbeddedText(captionVal) : undefined;
         // A declared width is the table's size, not a ceiling on it: the
         // reference's `expand` is `self._expand or self.width is not None`, and a
         // port that sized to content inside it drew Rich code narrower than Rich.

package/dist/renderables/traceback.d.ts

@@ -13,7 +13,7 @@
  * an inspector session pausing on exceptions — would have to pause on every
  * throw, caught ones included, to serve `new Traceback(caughtError)`, and it
  * cannot exist in a browser at all. Nor is there a `width` or `theme`: those
- * sized and coloured a source-code excerpt this renderer does not produce.
+ * sized and colored a source-code excerpt this renderer does not produce.
  */
 import { Segment } from "../core/segment.js";
 import { type Renderable, type RenderOptions } from "../core/protocol.js";

package/dist/renderables/traceback.js

@@ -13,7 +13,7 @@
  * an inspector session pausing on exceptions — would have to pause on every
  * throw, caught ones included, to serve `new Traceback(caughtError)`, and it
  * cannot exist in a browser at all. Nor is there a `width` or `theme`: those
- * sized and coloured a source-code excerpt this renderer does not produce.
+ * sized and colored a source-code excerpt this renderer does not produce.
  */
 import { Segment } from "../core/segment.js";
 import { RichText } from "../core/text.js";

package/dist/renderables/tree.js

@@ -18,15 +18,15 @@ const ASCII_GUIDES = { fork: "+-- ", end: "`-- ", continue: "|   ", space: "
  * The guide attributes a glyph set stands for, switched off on the guide itself
  * as Rich's `remove_guide_styles` does: a bold guide is drawn heavy, not bold.
  */
-const REMOVE_GUIDE_STYLES = new Style({ bold: false, underline2: false });
+const REMOVE_GUIDE_STYLES = new Style({ bold: false, doubleUnderline: false });
 const guideGlyphs = (glyphs) => Object.values(glyphs).join("");
 /**
  * The glyphs a column of guide is drawn with, read off its resolved guide style
- * as Rich does: heavy when bold, double when underline2, light otherwise — and
+ * as Rich does: heavy when bold, double when doubleUnderline, light otherwise — and
  * ASCII whenever the terminal cannot draw the chosen set.
  */
 function glyphsFor(options, style) {
-    const weight = style.bold === true ? HEAVY_GUIDES : style.underline2 === true ? DOUBLE_GUIDES : LIGHT_GUIDES;
+    const weight = style.bold === true ? HEAVY_GUIDES : style.doubleUnderline === true ? DOUBLE_GUIDES : LIGHT_GUIDES;
     return drawable(options, weight, ASCII_GUIDES, guideGlyphs);
 }
 /** A row a label is known to draw, unread. */

package/dist/template-bindings/animation-funcs.d.ts

@@ -29,36 +29,36 @@
  * arguments on every evaluation, so the sequence is prepared on every one:
  * a template has nowhere to keep it, and keeping it here would be the memo
  * keyed on the arguments that `FrameSequence` is instead of. `stepped <seconds>
- * <color> <seconds> <color> …` is the colour in progress at the moment, a
- * colour value like every colour function's (`./color-funcs.ts`), so it
- * nests where a colour goes — `fg (stepped …)`, `readableOn (stepped …) $bg
+ * <color> <seconds> <color> …` is the color in progress at the moment, a
+ * color value like every color function's (`./color-funcs.ts`), so it
+ * nests where a color goes — `fg (stepped …)`, `ensureContrast (stepped …) $bg
  * 4.5` — and the ground it must read on is the template's to name, as it
- * is for any colour. Either argument list is one float/value cycle end to
+ * is for any color. Either argument list is one float/value cycle end to
  * end, so the engine's `alternating` gate types every slot and lifts each
  * string frame to a fragment; the pairing — a trailing hold with no frame or
- * colour — is parsed in `pairs`, once. [LAW:types-are-the-program]
+ * color — is parsed in `pairs`, once. [LAW:types-are-the-program]
  *
  * The rest start at a moment the template names, on the timeline's clock —
  * a field of the host's state, the moment a value changed — and each is the
  * animation `Timeline.play(start)` runs, so a start is a timeline like any
  * other and nothing here offsets a time by hand. `tween <seconds> <ease>
  * <start> <from> <to>` is a number eased from one value to another and held
- * (`core/tween.ts`), its ease spelled by name (`parseEase`); `loop <seconds>
+ * (`core/tween.ts`), its ease spelled by name (`parseEasing`); `loop <seconds>
  * <start>` is the way through a period, 0 to 1 and round again — two
  * cells started a step apart are a stagger. Each is a number, so it goes
- * wherever a number goes: a colour tween is `ramp (tween …) "linear" 0 $from
+ * wherever a number goes: a color tween is `ramp (tween …) "linear" 0 $from
  * 1 $to` and a ramp scrolling is `ramp (loop …) …`, because `ColorRamp` is
- * the one place two colours are blended and a colour tween is a two-stop
+ * the one place two colors are blended and a color tween is a two-stop
  * ramp read over time (`ColorRamp.over`). [LAW:one-source-of-truth] A
  * second blender here would be a second answer to what lies between two
- * colours. `glyphs <name> <start> <fragment>` is the fragment through a
+ * colors. `glyphs <name> <start> <fragment>` is the fragment through a
  * glyph effect from the catalogue (`GLYPH_EFFECT_CATALOGUE`), at its
  * defaults, before any render (`reglyphText`). Every argument list is an
  * exact arity of typed slots, so a slot of the wrong kind fails at the gate.
  *
  * Every function says when what it drew changes, so a host paints a
  * template while it moves and not after — and says it only for what the
- * output depends on. A number or a colour has no cells to carry a hold, and
+ * output depends on. A number or a color has no cells to carry a hold, and
  * a fragment's cells lose theirs the moment it is flattened (`printf "%s"`),
  * so no function stamps cells or tells the frame itself. Each marks its
  * return with the hold its value is in (`marked`, the engine's evaluation
@@ -67,7 +67,7 @@
  * the output depends on it. `emitted` is where a template's cells take a
  * hold: every fragment the template emits, stamped with the holds of the
  * marked values its action read. `decided` is the route for a hold no cell
- * can carry, told to the frame (`TemplateFrame.onHold`): a mark an
+ * can carry, told to the frame (`TemplateFrame.onValidity`): a mark an
  * `if`/`with`/`range` consumed, whichever arm it took, because the frame may
  * show cells for it later and must say when without a cell to say it on, as
  * a placed animation of no cells does (`placed`) — and, by the same rule, a
@@ -93,7 +93,7 @@ export interface AnimationOptions {
 }
 /**
  * The frame a template is evaluated for, in the fields a render's options
- * carry under the same names: `time` in seconds, `onHold`, told the hold of
+ * carry under the same names: `time` in seconds, `onValidity`, told the hold of
  * an animated value the output may depend on with no cell to carry it — one
  * a decision read, whichever arm it took, a writing function's input, a
  * throwing action's (the engine's `decided`) — and the reader's preferences,
@@ -103,12 +103,12 @@ export interface AnimationOptions {
  * [LAW:one-source-of-truth]
  *
  * `time` is on the clock `AnimationOptions.timeline` maps from, and
- * `onHold` hears on that clock. A host outside rich-js hands its own clock's
+ * `onValidity` hears on that clock. A host outside rich-js hands its own clock's
  * time. Inside a rich-js frame the time is the frame's, which its host's
  * timeline has already mapped, so a template drawn there registers no
  * `timeline` and is handed `templateFrame(options)`.
  */
-export interface TemplateFrame extends Pick<RenderOptions, "onHold" | "reducedMotion" | "asciiOnly"> {
+export interface TemplateFrame extends Pick<RenderOptions, "onValidity" | "reducedMotion" | "asciiOnly"> {
     readonly time: number;
 }
 /** The frame a renderable is drawn in, as the frame a template it evaluates there is drawn for. */