@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/core/style.js

@@ -6,7 +6,7 @@ import { shiftAnchor } from "./anchor.js";
 import { Memo } from "./memo.js";
 import { pattern } from "./pattern.js";
 // [LAW:one-way-deps] `core/style` depends only on `core/color`. The substrate
-// a translucent colour is flattened over is `SURFACE_BLACK`, defined beside
+// a translucent color is flattened over is `SURFACE_BLACK`, defined beside
 // `compositeOver`.
 // --- Attribute definitions ---
 /**
@@ -21,11 +21,11 @@ export const ATTRIBUTE_NAMES = [
     "italic",
     "underline",
     "blink",
-    "blink2",
+    "rapidBlink",
     "reverse",
     "conceal",
     "strike",
-    "underline2",
+    "doubleUnderline",
     "frame",
     "encircle",
     "overline",
@@ -37,11 +37,11 @@ export const ATTRIBUTE_SGR = {
     italic: 3,
     underline: 4,
     blink: 5,
-    blink2: 6,
+    rapidBlink: 6,
     reverse: 7,
     conceal: 8,
     strike: 9,
-    underline2: 21,
+    doubleUnderline: 21,
     frame: 51,
     encircle: 52,
     overline: 53,
@@ -60,13 +60,13 @@ export const ATTRIBUTE_SHORT_ALIASES = {
     s: "strike",
     r: "reverse",
     o: "overline",
-    uu: "underline2",
+    uu: "doubleUnderline",
 };
 /** The hold of a cell that never changes: always was, and always will be. */
-export const NEVER_CHANGES = { lastChange: Number.NEGATIVE_INFINITY, nextChange: Number.POSITIVE_INFINITY };
-/** The moments both `a` and `b` hold through: the later `lastChange` and the sooner `nextChange`. */
+export const NEVER_CHANGES = { validFrom: Number.NEGATIVE_INFINITY, validUntil: Number.POSITIVE_INFINITY };
+/** The moments both `a` and `b` hold through: the later `validFrom` and the sooner `validUntil`. */
 export function intersection(a, b) {
-    return { lastChange: Math.max(a.lastChange, b.lastChange), nextChange: Math.min(a.nextChange, b.nextChange) };
+    return { validFrom: Math.max(a.validFrom, b.validFrom), validUntil: Math.min(a.validUntil, b.validUntil) };
 }
 export class StyleSyntaxError extends Error {
     constructor(message, options) {
@@ -85,11 +85,11 @@ export class Style {
     italic;
     underline;
     blink;
-    blink2;
+    rapidBlink;
     reverse;
     conceal;
     strike;
-    underline2;
+    doubleUnderline;
     frame;
     encircle;
     overline;
@@ -120,30 +120,30 @@ export class Style {
     bidi;
     /**
      * 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.
      */
-    hold;
+    validity;
     constructor(options = {}) {
-        const hold = options.hold ?? NEVER_CHANGES;
-        const { lastChange, nextChange } = hold;
+        const validity = options.validity ?? NEVER_CHANGES;
+        const { validFrom, validUntil } = validity;
         // [LAW:parse-dont-validate] A time or never, settled where the style is
         // made: NaN and the far infinity fail here, so no reader of a frame meets one.
-        if (!(nextChange > Number.NEGATIVE_INFINITY)) {
-            throw new RangeError(`Style nextChange must be a time in seconds or Infinity, got ${nextChange}`);
+        if (!(validUntil > Number.NEGATIVE_INFINITY)) {
+            throw new RangeError(`Style validUntil must be a time in seconds or Infinity, got ${validUntil}`);
         }
-        if (!(lastChange < Number.POSITIVE_INFINITY)) {
-            throw new RangeError(`Style lastChange must be a time in seconds or -Infinity, got ${lastChange}`);
+        if (!(validFrom < Number.POSITIVE_INFINITY)) {
+            throw new RangeError(`Style validFrom must be a time in seconds or -Infinity, got ${validFrom}`);
         }
-        this.hold = hold;
+        this.validity = validity;
         this.color = resolveColor(options.color);
         this.bgcolor = resolveBackground(options.bgcolor);
         this.bold = options.bold;
@@ -151,11 +151,11 @@ export class Style {
         this.italic = options.italic;
         this.underline = options.underline;
         this.blink = options.blink;
-        this.blink2 = options.blink2;
+        this.rapidBlink = options.rapidBlink;
         this.reverse = options.reverse;
         this.conceal = options.conceal;
         this.strike = options.strike;
-        this.underline2 = options.underline2;
+        this.doubleUnderline = options.doubleUnderline;
         this.frame = options.frame;
         this.encircle = options.encircle;
         this.overline = options.overline;
@@ -174,11 +174,11 @@ export class Style {
             this.italic === undefined &&
             this.underline === undefined &&
             this.blink === undefined &&
-            this.blink2 === undefined &&
+            this.rapidBlink === undefined &&
             this.reverse === undefined &&
             this.conceal === undefined &&
             this.strike === undefined &&
-            this.underline2 === undefined &&
+            this.doubleUnderline === undefined &&
             this.frame === undefined &&
             this.encircle === undefined &&
             this.overline === undefined &&
@@ -187,8 +187,8 @@ export class Style {
             this.anchor === undefined &&
             this.boxFrame === undefined &&
             this.bidi === undefined &&
-            this.hold.nextChange === Number.POSITIVE_INFINITY &&
-            this.hold.lastChange === Number.NEGATIVE_INFINITY);
+            this.validity.validUntil === Number.POSITIVE_INFINITY &&
+            this.validity.validFrom === Number.NEGATIVE_INFINITY);
     }
     get transparentBackground() {
         return this.bgcolor === undefined || this.bgcolor.isDefault;
@@ -243,16 +243,16 @@ export class Style {
      */
     withAttributes(attributes) {
         // Only the attribute names are read: a wider object — a `Style`, say —
-        // satisfies the type and must not carry its colours or anchor in with it.
+        // satisfies the type and must not carry its colors or anchor in with it.
         return this.with(Object.fromEntries(ATTRIBUTE_NAMES.filter((name) => name in attributes).map((name) => [name, attributes[name]])));
     }
     /**
      * 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() {
-        return this.blink || this.blink2 ? this.withAttributes({ blink: undefined, blink2: undefined }) : this;
+        return this.blink || this.rapidBlink ? this.withAttributes({ blink: undefined, rapidBlink: undefined }) : this;
     }
     /**
      * This style on the cell `cells` to the right: its anchor shifted along its
@@ -277,11 +277,11 @@ export class Style {
             italic: other.italic ?? this.italic,
             underline: other.underline ?? this.underline,
             blink: other.blink ?? this.blink,
-            blink2: other.blink2 ?? this.blink2,
+            rapidBlink: other.rapidBlink ?? this.rapidBlink,
             reverse: other.reverse ?? this.reverse,
             conceal: other.conceal ?? this.conceal,
             strike: other.strike ?? this.strike,
-            underline2: other.underline2 ?? this.underline2,
+            doubleUnderline: other.doubleUnderline ?? this.doubleUnderline,
             frame: other.frame ?? this.frame,
             encircle: other.encircle ?? this.encircle,
             overline: other.overline ?? this.overline,
@@ -293,7 +293,7 @@ export class Style {
             boxFrame: other.boxFrame ?? this.boxFrame,
             bidi: other.bidi ?? this.bidi,
             // Cells under both change when either does.
-            hold: intersection(this.hold, other.hold),
+            validity: intersection(this.validity, other.validity),
         });
     }
     equals(other) {
@@ -306,11 +306,11 @@ export class Style {
             this.italic === other.italic &&
             this.underline === other.underline &&
             this.blink === other.blink &&
-            this.blink2 === other.blink2 &&
+            this.rapidBlink === other.rapidBlink &&
             this.reverse === other.reverse &&
             this.conceal === other.conceal &&
             this.strike === other.strike &&
-            this.underline2 === other.underline2 &&
+            this.doubleUnderline === other.doubleUnderline &&
             this.frame === other.frame &&
             this.encircle === other.encircle &&
             this.overline === other.overline &&
@@ -318,11 +318,11 @@ export class Style {
             anchorsEqual(this.anchor, other.anchor) &&
             this.boxFrame === other.boxFrame &&
             this.bidi === other.bidi &&
-            this.hold.nextChange === other.hold.nextChange &&
-            this.hold.lastChange === other.hold.lastChange);
+            this.validity.validUntil === other.validity.validUntil &&
+            this.validity.validFrom === other.validity.validFrom);
     }
     /**
-     * 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
@@ -368,7 +368,7 @@ export class Style {
     }
     /**
      * 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.
+     * 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.
@@ -516,7 +516,7 @@ export class Theme {
 // --- Parse helpers ---
 const ATTRIBUTE_SET = new Set(ATTRIBUTE_NAMES);
 // The words each position of a definition can hold: a bare token is a keyword,
-// an attribute or a colour name; `on` takes a colour name; `not` an attribute.
+// an attribute or a color name; `on` takes a color name; `not` an attribute.
 // The short aliases are left out, since `b` is no help to someone who typed
 // `bolt` and a one-letter name sits one edit from every other short word.
 // [LAW:one-source-of-truth] Derived from the lists the parser accepts from; the
@@ -548,8 +548,8 @@ function editDistance(a, b) {
  * Plausible means within one edit per three letters, at least one, which lets
  * `rd` reach `red` and keeps `hello` from reaching `yellow`. Every name tied
  * for nearest is offered: `gold` is one edit from `bold` and from three
- * `goldN` colours, and choosing among them would be a guess the reader cannot
- * tell from a finding. Case is not an edit, because the colour parser ignores
+ * `goldN` colors, and choosing among them would be a guess the reader cannot
+ * tell from a finding. Case is not an edit, because the color parser ignores
  * it: `Cyna` is as near `cyan` as `cyna` is.
  *
  * This runs on every render that meets the bad style, since only successful
@@ -571,12 +571,12 @@ function nearMiss(word, words) {
     return names.length === 0 ? "" : ` (did you mean ${names.join(" or ")}?)`;
 }
 /**
- * A style token read as a colour. The colour parser's own error is the reason
+ * A style token read as a color. The color parser's own error is the reason
  * the token failed, so it rides along twice: in the message, for a reader with
  * only the text, and as `cause`, for code that wants the original error.
  *
- * [LAW:single-enforcer] Both colour positions in a definition rewrap here, and
- * the near miss is named here rather than by the colour parser: only a
+ * [LAW:single-enforcer] Both color positions in a definition rewrap here, and
+ * the near miss is named here rather than by the color parser: only a
  * definition knows whether the token could also have been an attribute.
  */
 function parseStyleColor(token, failure, words) {
@@ -655,7 +655,7 @@ function resolveColor(c) {
 // so it is no background: a style added on top of another keeps that one's,
 // which is what Textual's `#00000000` means. A transparent foreground is not
 // the same, it draws its glyph in whatever lies beneath it — the background,
-// or `SURFACE_BLACK` when there is none — so it stays a colour.
+// or `SURFACE_BLACK` when there is none — so it stays a color.
 function resolveBackground(c) {
     const spec = resolveColor(c);
     return spec?.value?.alpha === 0 ? undefined : spec;
@@ -672,11 +672,11 @@ export const DEFAULT_STYLES = {
         italic: false,
         underline: false,
         blink: false,
-        blink2: false,
+        rapidBlink: false,
         reverse: false,
         conceal: false,
         strike: false,
-        underline2: false,
+        doubleUnderline: false,
         frame: false,
         encircle: false,
         overline: false,
@@ -686,11 +686,11 @@ export const DEFAULT_STYLES = {
     italic: new Style({ italic: true }),
     underline: new Style({ underline: true }),
     blink: new Style({ blink: true }),
-    blink2: new Style({ blink2: true }),
+    rapidBlink: new Style({ rapidBlink: true }),
     reverse: new Style({ reverse: true }),
     conceal: new Style({ conceal: true }),
     strike: new Style({ strike: true }),
-    underline2: new Style({ underline2: true }),
+    doubleUnderline: new Style({ doubleUnderline: true }),
     frame: new Style({ frame: true }),
     encircle: new Style({ encircle: true }),
     overline: new Style({ overline: true }),
@@ -755,9 +755,9 @@ export const DEFAULT_STYLES = {
     "syntax.number": Style.parse("cyan"),
     "syntax.comment": Style.parse("dim italic"),
     "syntax.line_number": Style.parse("dim"),
-    // Ink and ground both from the fixed 256-colour greys: the terminal theme's
+    // Ink and ground both from the fixed 256-color greys: the terminal theme's
     // own foreground is dark on a light theme and would vanish on grey27. At 16
-    // colours `Syntax` draws it without the pair (`groundedStyle`).
+    // colors `Syntax` draws it without the pair (`groundedStyle`).
     "syntax.line_number.highlight": Style.parse("bold grey93 on grey27"),
     // Markdown
     "markdown.h1": Style.parse("bold underline"),
@@ -767,7 +767,7 @@ export const DEFAULT_STYLES = {
     "markdown.h5": Style.parse("italic"),
     "markdown.h6": Style.parse("dim"),
     // A fixed cyan, not the theme's: `cyan` is dark enough on some themes to
-    // sink into grey11. Bold, as Rich's is: at 16 colours a renderable draws it
+    // sink into grey11. Bold, as Rich's is: at 16 colors a renderable draws it
     // without its pair (`groundedStyle`), and bold is what still marks code.
     "markdown.code": Style.parse("bold dark_turquoise on grey11"),
     "markdown.em": Style.parse("italic"),

package/dist/core/text.d.ts

@@ -85,8 +85,8 @@ export declare class RichText implements Renderable, Measurable {
      * any spans covering the leftmost (side="left") or rightmost (side="right")
      * character.
      *
-     * [LAW:locality-or-seam] Used by `Joiner`s to paint the transition between
-     * adjacent `Strip` items. Joiners only ever need the column adjacent to
+     * [LAW:locality-or-seam] Used by `Separator`s to paint the transition between
+     * adjacent `Strip` items. Separators only ever need the column adjacent to
      * them, so the cell type exposes that column rather than constraining its
      * interior to be uniform. For RichText with uniform styling, both edges
      * return the same style; for RichText with edge variation, each edge

package/dist/core/text.js

@@ -4,7 +4,7 @@
 import { cellLen, cellCount, cellFit, cellFitEnd, asCellCol, expandTabs, parseTabSize } from "./cells.js";
 import { closed, closing } from "./bidi.js";
 import { controlClass, dispositionOf, pictureOf } from "./control-codes.js";
-import { directed, drawnTail, edges, hangingWhitespace, measured } from "./orient.js";
+import { reorder, drawnTail, edges, hangingWhitespace, measured } from "./orient.js";
 import { divideLine, wordWidths } from "./wrap.js";
 import { Segment } from "./segment.js";
 import { Style, NULL_STYLE, StyleSyntaxError } from "./style.js";
@@ -67,7 +67,7 @@ function sanitizeStyleLink(style) {
  * lays its text out anew, so a stamp naming where a cell sat in the output it
  * came from would name the wrong cell once it wraps, slices or overlaps; the
  * owner that renders the RichText is the one that stamps its cells. A
- * hold stays — `lastChange` and `nextChange`: when a span's cells began and
+ * hold stays — `validFrom` and `validUntil`: when a span's cells began and
  * next change is true of them wherever the text lays them, so a frame
  * appended into a line still says when it turns.
  */
@@ -264,8 +264,8 @@ export class RichText {
      * any spans covering the leftmost (side="left") or rightmost (side="right")
      * character.
      *
-     * [LAW:locality-or-seam] Used by `Joiner`s to paint the transition between
-     * adjacent `Strip` items. Joiners only ever need the column adjacent to
+     * [LAW:locality-or-seam] Used by `Separator`s to paint the transition between
+     * adjacent `Strip` items. Separators only ever need the column adjacent to
      * them, so the cell type exposes that column rather than constraining its
      * interior to be uniform. For RichText with uniform styling, both edges
      * return the same style; for RichText with edge variation, each edge
@@ -757,7 +757,7 @@ export class RichText {
         for (let index = 0; index < logicalLines.length; index += 1) {
             // [LAW:dataflow-not-control-flow] Every line runs the same steps; the
             // order is the value `directed` and `orient` take.
-            const { line, oriented, orient } = directed(logicalLines[index], order);
+            const { line, oriented, orient } = reorder(logicalLines[index], order);
             const free = spanFree[index];
             const terminateLine = index < logicalLines.length - 1;
             // Wrap first, overflow last — the reference's order, and the reason a

package/dist/core/timeline.d.ts

@@ -15,13 +15,13 @@
  * one time it holds, so there is no origin for it to be wrong about.
  * [LAW:types-are-the-program]
  *
- * `run` is an animation on host time. Its `nextChange` is the host moment
+ * `run` is an animation on host time. Its `validUntil` is the host moment
  * the mapped time reaches the animation's own answer, which is what
  * `Spinner`'s speed scaled its holds for before this existed: an answer a
  * host reads is on the host's timeline, and a beat over scaled time answers
  * on the scaled one. Run backwards, the host next sees a change when the
  * mapped time drops under where the value began — the animation's
- * `lastChange` — so a reversed loop turns exactly at its hold boundaries,
+ * `validFrom` — so a reversed loop turns exactly at its hold boundaries,
  * and a reversed one-shot changes at its switch and never before its start.
  * Paused, nothing changes: never, and never did. The host moment is the
  * first host float the map carries past the edge, searched out from the sum
@@ -50,7 +50,7 @@
  * hands in, so the same host time maps to the same animation time at one
  * sample a second or sixty.
  */
-import { Animation, type Timed } from "./animation.js";
+import { Animation, type Behavior } from "./animation.js";
 /**
  * A map from host time to animation time. Playing, it is `time` at `origin`
  * moving `rate` animation seconds a host second; paused, it is `time` at
@@ -95,7 +95,7 @@ export declare const Timeline: {
      * Reduced, it is the animation reduced on the same timeline: what shows
      * still follows the timeline, and only the motion is gone.
      */
-    run<T>(timeline: Timeline, animation: Timed<T>): Animation<T>;
+    run<T>(timeline: Timeline, animation: Behavior<T>): Animation<T>;
     /**
      * Every one of `animations` at once, each on a timeline playing from its
      * index times `delay` seconds after the earliest, their values in order, on
@@ -105,5 +105,5 @@ export declare const Timeline: {
      * Reduced, the offsets are the cascade's choreography, which is motion: every
      * child reduced at once, so from 0 everyone has arrived.
      */
-    stagger<T>(animations: readonly Timed<T>[], delay: number): Animation<readonly T[]>;
+    stagger<T>(animations: readonly Behavior<T>[], delay: number): Animation<readonly T[]>;
 };

package/dist/core/timeline.js

@@ -15,13 +15,13 @@
  * one time it holds, so there is no origin for it to be wrong about.
  * [LAW:types-are-the-program]
  *
- * `run` is an animation on host time. Its `nextChange` is the host moment
+ * `run` is an animation on host time. Its `validUntil` is the host moment
  * the mapped time reaches the animation's own answer, which is what
  * `Spinner`'s speed scaled its holds for before this existed: an answer a
  * host reads is on the host's timeline, and a beat over scaled time answers
  * on the scaled one. Run backwards, the host next sees a change when the
  * mapped time drops under where the value began — the animation's
- * `lastChange` — so a reversed loop turns exactly at its hold boundaries,
+ * `validFrom` — so a reversed loop turns exactly at its hold boundaries,
  * and a reversed one-shot changes at its switch and never before its start.
  * Paused, nothing changes: never, and never did. The host moment is the
  * first host float the map carries past the edge, searched out from the sum
@@ -82,10 +82,10 @@ function played(animation, { origin, time, rate }) {
     // Forwards, the host next sees the animation's own next change, and the
     // value began when the animation says it did; backwards, it next sees a
     // change where the value began, and the value began where the animation
-    // says it ends. A hold is `[lastChange, nextChange)`, so the far side of
+    // says it ends. A hold is `[validFrom, validUntil)`, so the far side of
     // an edge is at it going up and strictly under it coming down.
-    const ahead = forward ? (t, moves) => animation.nextChange(t, moves) : (t, moves) => animation.lastChange(t, moves);
-    const behind = forward ? (t, moves) => animation.lastChange(t, moves) : (t, moves) => animation.nextChange(t, moves);
+    const ahead = forward ? (t, moves) => animation.validUntil(t, moves) : (t, moves) => animation.validFrom(t, moves);
+    const behind = forward ? (t, moves) => animation.validFrom(t, moves) : (t, moves) => animation.validUntil(t, moves);
     const past = forward ? (t, edge) => t >= edge : (t, edge) => t < edge;
     // The first host moment the map carries past `edge`, an animation time.
     // An edge at infinity, or one so far off at this rate that no host float
@@ -97,13 +97,13 @@ function played(animation, { origin, time, rate }) {
     };
     return Animation.of({
         at: (host) => animation.at(mapped(hostTime(host))),
-        nextChange(host, moves) {
+        validUntil(host, moves) {
             const h = hostTime(host);
             const t = mapped(h);
             const edge = ahead(t, moves);
             return edge === t ? h : Math.max(h, hostOf(edge));
         },
-        lastChange(host, moves) {
+        validFrom(host, moves) {
             const h = hostTime(host);
             const t = mapped(h);
             const edge = behind(t, moves);
@@ -154,8 +154,8 @@ export const Timeline = {
             return played(animation, timeline);
         return Animation.of({
             at: (host) => animation.at(Timeline.at(timeline, host)),
-            nextChange: (host) => (hostTime(host), Number.POSITIVE_INFINITY),
-            lastChange: (host) => (hostTime(host), Number.NEGATIVE_INFINITY),
+            validUntil: (host) => (hostTime(host), Number.POSITIVE_INFINITY),
+            validFrom: (host) => (hostTime(host), Number.NEGATIVE_INFINITY),
             reduced: () => Timeline.run(timeline, animation.reduced()),
         });
     },

package/dist/core/tween.d.ts

@@ -2,11 +2,11 @@
  * Tween — a value eased from one number to another over seconds, then held:
  * the animation a progress bar's fill, a counter or a width is handed so it
  * moves to its new value instead of jumping. The first `Animation` of a
- * value that is never drawn as cells, so its `nextChange` is its only way of
+ * value that is never drawn as cells, so its `validUntil` is its only way of
  * saying when to look again (`./animation.ts`).
  *
  * The value at `t` is the `Timing`'s ease of the way from `from` to `to`
- * through `Phase.once(0, seconds)`: `from` at `t ≤ 0` whenever the ease
+ * through `WrapMode.once(0, seconds)`: `from` at `t ≤ 0` whenever the ease
  * starts at 0, as every built-in does but `step-start` and the steps that
  * jump at the start of their interval, which show their first jump before
  * the tween begins, as `ColorRamp.at` does; `to` from `seconds` on. It is
@@ -25,9 +25,9 @@
  * tween(old.at(t₁), to, timing))` — and starts from where it is because
  * that is where it was built from. [LAW:no-ambient-temporal-coupling]
  *
- * Over colours it is a `ColorRamp` read over time (`../themes/ramp.ts`,
- * `over`): the ramp is already the one place two colours are blended, in
- * OKLCH, and a colour tween is a two-stop ramp over its seconds, not a
+ * Over colors it is a `ColorRamp` read over time (`../themes/ramp.ts`,
+ * `over`): the ramp is already the one place two colors are blended, in
+ * OKLCH, and a color tween is a two-stop ramp over its seconds, not a
  * second blender. [LAW:one-source-of-truth]
  *
  * Tier 6 of `src/core/`: `./easing.ts` and `./animation.ts`, nothing else.
@@ -41,7 +41,7 @@ import { type Timing } from "./easing.js";
  * every ease that starts at 0), `to` after, and so
  * seen at its end, never mid-way, by a host whose frames are further apart
  * than it is long. `from` and `to` must be finite; the seconds are checked
- * where every one-shot's are, in `Phase.once`. A tween to where it already
+ * where every one-shot's are, in `WrapMode.once`. A tween to where it already
  * is is `Animation.constant(from)`, decided here once: the blend would land
  * one ulp off `from` at some `p`, and a value that never moves is one that
  * never changes, so a host is told not to look again. [LAW:parse-dont-validate]

package/dist/core/tween.js

@@ -2,11 +2,11 @@
  * Tween — a value eased from one number to another over seconds, then held:
  * the animation a progress bar's fill, a counter or a width is handed so it
  * moves to its new value instead of jumping. The first `Animation` of a
- * value that is never drawn as cells, so its `nextChange` is its only way of
+ * value that is never drawn as cells, so its `validUntil` is its only way of
  * saying when to look again (`./animation.ts`).
  *
  * The value at `t` is the `Timing`'s ease of the way from `from` to `to`
- * through `Phase.once(0, seconds)`: `from` at `t ≤ 0` whenever the ease
+ * through `WrapMode.once(0, seconds)`: `from` at `t ≤ 0` whenever the ease
  * starts at 0, as every built-in does but `step-start` and the steps that
  * jump at the start of their interval, which show their first jump before
  * the tween begins, as `ColorRamp.at` does; `to` from `seconds` on. It is
@@ -25,23 +25,23 @@
  * tween(old.at(t₁), to, timing))` — and starts from where it is because
  * that is where it was built from. [LAW:no-ambient-temporal-coupling]
  *
- * Over colours it is a `ColorRamp` read over time (`../themes/ramp.ts`,
- * `over`): the ramp is already the one place two colours are blended, in
- * OKLCH, and a colour tween is a two-stop ramp over its seconds, not a
+ * Over colors it is a `ColorRamp` read over time (`../themes/ramp.ts`,
+ * `over`): the ramp is already the one place two colors are blended, in
+ * OKLCH, and a color tween is a two-stop ramp over its seconds, not a
  * second blender. [LAW:one-source-of-truth]
  *
  * Tier 6 of `src/core/`: `./easing.ts` and `./animation.ts`, nothing else.
  * [LAW:one-way-deps]
  */
 import { Animation } from "./animation.js";
-import { Phase } from "./easing.js";
+import { WrapMode } from "./easing.js";
 /**
  * `from` eased to `to` over `timing`, as an `Animation<number>`: moving from
  * 0 to `timing.seconds` on its own clock, the ease of 0 before (`from`, for
  * every ease that starts at 0), `to` after, and so
  * seen at its end, never mid-way, by a host whose frames are further apart
  * than it is long. `from` and `to` must be finite; the seconds are checked
- * where every one-shot's are, in `Phase.once`. A tween to where it already
+ * where every one-shot's are, in `WrapMode.once`. A tween to where it already
  * is is `Animation.constant(from)`, decided here once: the blend would land
  * one ulp off `from` at some `p`, and a value that never moves is one that
  * never changes, so a host is told not to look again. [LAW:parse-dont-validate]
@@ -52,7 +52,7 @@ export function tween(from, to, timing) {
             throw new RangeError(`tween ${name} must be finite, got ${v}`);
     }
     const { ease, seconds } = timing;
-    const phase = Phase.once(0, seconds);
+    const phase = WrapMode.once(0, seconds);
     if (from === to)
         return Animation.constant(from);
     return Animation.of({
@@ -63,8 +63,8 @@ export function tween(from, to, timing) {
         // Before it begins the value is held until 0; while it moves, every
         // frame; from `seconds` on, never again — and it became what it is at
         // `seconds`, or always was before it began.
-        nextChange: (t) => (t < 0 ? 0 : t < seconds ? t : Number.POSITIVE_INFINITY),
-        lastChange: (t) => (t < 0 ? Number.NEGATIVE_INFINITY : t < seconds ? t : seconds),
+        validUntil: (t) => (t < 0 ? 0 : t < seconds ? t : Number.POSITIVE_INFINITY),
+        validFrom: (t) => (t < 0 ? Number.NEGATIVE_INFINITY : t < seconds ? t : seconds),
         // A one-shot, reduced, cuts from where it starts to where it arrives.
         reduced: () => Animation.cut(from, to),
     });

package/dist/core/view.d.ts

@@ -22,9 +22,9 @@
  * anything it draws. What the drawn frame says about when it changes is on
  * the timeline's clock, and `drawView` carries it back onto the host's by
  * running the frame through the same timeline: the frame is a sample held
- * for the intersection of its cells' holds (`Segment.lastChange`,
- * `Segment.nextChange`) and the holds it was told that no cell carries
- * (`RenderOptions.onHold`), and `Timeline.run` is the one place a hold is
+ * for the intersection of its cells' holds (`Segment.validFrom`,
+ * `Segment.validUntil`) and the holds it was told that no cell carries
+ * (`RenderOptions.onValidity`), and `Timeline.run` is the one place a hold is
  * mapped onto host time, forwards, backwards or paused.
  *
  * What a host does with that is its own policy, and it reads it off the
@@ -86,7 +86,7 @@ export interface FrameSays {
     /** The host time the frame was drawn at. */
     readonly t: number;
     /** The first host moment, never before `t`, at which the frame may stop showing this: `t` while it moves, `Infinity` once it never will. */
-    readonly nextChange: number;
+    readonly validUntil: number;
 }
 /** A frame drawn from a view: its lines, and what it says. */
 export interface DrawnView extends FrameSays {

package/dist/core/view.js

@@ -22,9 +22,9 @@
  * anything it draws. What the drawn frame says about when it changes is on
  * the timeline's clock, and `drawView` carries it back onto the host's by
  * running the frame through the same timeline: the frame is a sample held
- * for the intersection of its cells' holds (`Segment.lastChange`,
- * `Segment.nextChange`) and the holds it was told that no cell carries
- * (`RenderOptions.onHold`), and `Timeline.run` is the one place a hold is
+ * for the intersection of its cells' holds (`Segment.validFrom`,
+ * `Segment.validUntil`) and the holds it was told that no cell carries
+ * (`RenderOptions.onValidity`), and `Timeline.run` is the one place a hold is
  * mapped onto host time, forwards, backwards or paused.
  *
  * What a host does with that is its own policy, and it reads it off the
@@ -78,9 +78,9 @@ export function frameNow(host, time) {
     return { time: frameTime(time), host };
 }
 /** What a frame not yet drawn at host time `t` says: nothing. */
-export const undrawn = (t) => ({ t, nextChange: Number.POSITIVE_INFINITY });
+export const undrawn = (t) => ({ t, validUntil: Number.POSITIVE_INFINITY });
 /** The hold of the frame `lines` draw, told `told` besides: the intersection of its cells' holds and it. */
-const frameHold = (lines, told) => lines.reduce((hold, row) => intersection(hold, { lastChange: Segment.lastChange(row), nextChange: Segment.nextChange(row) }), told);
+const frameValidity = (lines, told) => lines.reduce((validity, row) => intersection(validity, { validFrom: Segment.validFrom(row), validUntil: Segment.validUntil(row) }), told);
 /**
  * `view` drawn by `drawnBy` at `time` under `options`, its lines shaped by
  * `draw` — the host's own render under those options, with its height and
@@ -93,16 +93,16 @@ const frameHold = (lines, told) => lines.reduce((hold, row) => intersection(hold
 export function drawView(view, time, drawnBy, options, draw) {
     const { now: host, timeline } = time;
     let told = NEVER_CHANGES;
-    const onHold = (hold) => {
-        told = intersection(told, hold);
+    const onValidity = (validity) => {
+        told = intersection(told, validity);
     };
     // Made before the render opens: the one time the frame has.
     const frame = frameNow(drawnBy, time);
-    const lines = draw(view, { ...options, frame, onHold });
-    const hold = frameHold(lines, told);
+    const lines = draw(view, { ...options, frame, onValidity });
+    const validity = frameValidity(lines, told);
     // The frame as the sample of the view it is, on the timeline's clock; the
     // timeline says when the host's clock leaves its hold.
-    const sample = { at: () => lines, nextChange: () => hold.nextChange, lastChange: () => hold.lastChange, reduced: () => sample };
-    const nextChange = Timeline.run(timeline, sample).nextChange(host);
-    return { t: host, lines, nextChange };
+    const sample = { at: () => lines, validUntil: () => validity.validUntil, validFrom: () => validity.validFrom, reduced: () => sample };
+    const validUntil = Timeline.run(timeline, sample).validUntil(host);
+    return { t: host, lines, validUntil };
 }