@promptctl/rich-js 0.28.0 → 0.29.0

package/README.md

@@ -385,19 +385,19 @@ npm run demo
 | `npm run demo-inputs` | rich-config | The widgets — checkbox, toggle, slider, dropdown, text input, button — driving a theme and palette viewer. |
 | `npm run demo:dropdown` | dropdown-demo | Three `Dropdown` widgets: a plain one, one filtered as you type, and one whose options change every few seconds. |
 | `npm run template-bindings` | rich-template-bindings | Type a template on the left and watch it render on the right. |
-| `npm run themes-and-color-studio` | themes-and-color-studio | A printed tour of colours, palettes, bundled themes, and contrast. Prints once and exits; set any of `EXPORT_HTML=out.html`, `EXPORT_SVG=out.svg` and `EXPORT_TEXT=out.txt` to also save it to each file named. |
-| `npm run strip` | rich-strip | Every built-in `Joiner`, printed side by side. Prints once and exits. |
-| `npm run effects-feel` | effects-feel | Shimmer, a gentle pulse on chosen elements, sparkle, a hue wheel, fade-in and a dissolve-out that eddies back before it goes, on a powerline strip and a run of text, at a colour depth you choose, with keys to step the frame rate, the demo's pace and the theme while it runs. A demo for agreeing how the effects feel; `npm run effects-feel -- --help` lists the flags and keys. |
+| `npm run themes-and-color-studio` | themes-and-color-studio | A printed tour of colors, palettes, bundled themes, and contrast. Prints once and exits; set any of `EXPORT_HTML=out.html`, `EXPORT_SVG=out.svg` and `EXPORT_TEXT=out.txt` to also save it to each file named. |
+| `npm run strip` | rich-strip | Every built-in `Separator`, printed side by side. Prints once and exits. |
+| `npm run effects-feel` | effects-feel | Shimmer, a gentle pulse on chosen elements, sparkle, a hue wheel, fade-in and a dissolve-out that eddies back before it goes, on a powerline strip and a run of text, at a color depth you choose, with keys to step the frame rate, the demo's pace and the theme while it runs. A demo for agreeing how the effects feel; `npm run effects-feel -- --help` lists the flags and keys. |
 | `npm run glyph-effects` | glyph-effects | Text typed, scrambled until it resolves, crossed by a wave of capitals, and rained and snowed on, each glyph effect in the catalogue and a few made by hand, for twenty seconds. |
-| `npm run attribute-effects` | attribute-effects | A line that blinks, pulses bold, and blinks its underline and its italics on beats of its own: the attribute effects in the catalogue and two made by hand from `blink`, for twenty seconds. |
-| `npm run gradient-effects` | gradient-effects | A colour ramp laid across three rules and three panel borders, one scrolling, one turning its hues, one swaying and settling a quarter turn round, while the titles and the words inside keep their own colour, for twenty seconds. |
+| `npm run attribute-effects` | attribute-effects | A line that blinks, pulses bold, and blinks its underline and its italics on steps of its own: the attribute effects in the catalogue and two made by hand from `blink`, for twenty seconds. |
+| `npm run gradient-effects` | gradient-effects | A color ramp laid across three rules and three panel borders, one scrolling, one turning its hues, one swaying and settling a quarter turn round, while the titles and the words inside keep their own color, for twenty seconds. |
 | `npm run transitions` | transitions | A build status changing state every three seconds, crossfaded in one panel and wiped in the other, each cell passing through the terminal's ground and nothing beside it moving while it changes, for twenty seconds. |
 | `npm run lifecycle` | lifecycle | A build log whose lines type themselves in as they are appended and leave four seconds later, dissolved, backspaced or scrambled away in turn, each dropped from the log once it is gone, for twenty seconds. |
 | `npm run scroll` | scroll | A marquee crossing a fixed width, a log tail stepping a row a second, and a panel sliding in from the left and holding: one window moved three ways, for twenty seconds. |
-| `npm run animation-playground` | animation-playground | Every kind of motion — tweens, moving ramps, a marching border, glyph and attribute effects, transitions, a list that comes and goes, a marquee, staggers and a blinking caret — on one timeline, with buttons to pause, reverse, scrub, change speed, reduce motion, drop to sixteen colours or none, and paint at one frame a second or sixty. |
+| `npm run animation-playground` | animation-playground | Every kind of motion — tweens, moving ramps, a marching border, glyph and attribute effects, transitions, a list that comes and goes, a marquee, staggers and a blinking caret — on one timeline, with buttons to pause, reverse, scrub, change speed, reduce motion, drop to sixteen colors or none, and paint at one frame a second or sixty. |
 | `npm run markup-plugins` | rich-markup-plugins | Custom markup tags registered through `MarkupRegistry`. Prints once and exits. |
 | `npm run viewport` | rich-viewport | A selection you move through a list taller than its window with the arrow keys, `j`/`k`, PgUp/PgDn and Home/End, kept in view by `Viewport.ensureVisible`; the mouse wheel scrolls the window, and `q` quits. |
-| `npm run terminal-colors` | terminal-colors | Your terminal asked for its own foreground and background with OSC 10 and OSC 11, shown as swatches, and whether it answered or the colours are assumed. |
+| `npm run terminal-colors` | terminal-colors | Your terminal asked for its own foreground and background with OSC 10 and OSC 11, shown as swatches, and whether it answered or the colors are assumed. |
 | `npm run terminal-host` | terminal-host | Each key you press printed as the bytes the terminal sends for it, and each resize as the new size — a program written against `TerminalHost` alone. `examples/terminal-host/embed.ts` runs the same program on an xterm.js terminal in your own page. |
 
 `Ctrl-C` quits any demo that stays running.

package/dist/core/animation.d.ts

@@ -2,7 +2,7 @@
  * Animation — a value for a time, and when it next changes: the one type
  * anything in rich-js that changes with time is an instance of.
  *
- * `at(t)` is the value at `t` seconds. `nextChange(t)` is the first moment,
+ * `at(t)` is the value at `t` seconds. `validUntil(t)` is the first moment,
  * on `t`'s own timeline, at which the value may stop being `at(t)`: never
  * before `t`. A later time says the value is held until then, `Infinity`
  * that it never changes again, and `t` itself that it is moving at `t` — it
@@ -10,16 +10,16 @@
  * answer costs a host a frame that draws what the last one did; a late one
  * skips a change. So an animation that cannot say answers `t`, as
  * `continuous` does. An answer that depends on what the frame drew, an
- * effect's, is told by that drawing (`Moves`). A value drawn as cells carries this answer on every
+ * effect's, is told by that drawing (`Reads`). A value drawn as cells carries this answer on every
  * cell (`Style.hold`, both ends of the hold below), so a host holding
- * the composed frame reads it there (`Segment.nextChange`); a value that is
- * not drawn — a number, a colour — has `nextChange` as its only way to say
+ * the composed frame reads it there (`Segment.validUntil`); a value that is
+ * not drawn — a number, a color — has `validUntil` as its only way to say
  * when to look again.
  *
- * `lastChange(t)` is the other end of the same hold: the last moment, never
+ * `validFrom(t)` is the other end of the same hold: the last moment, never
  * after `t`, at which the value may have become `at(t)` — `-Infinity` if it
- * always was, `t` while it moves. Together they bound the hold, `[lastChange(t),
- * nextChange(t))`, and the answer may be narrower than the truth and never
+ * always was, `t` while it moves. Together they bound the hold, `[validFrom(t),
+ * validUntil(t))`, and the answer may be narrower than the truth and never
  * wider. It is what a host running the animation backwards reads
  * (`./timeline.ts`): run down the timeline, the value next changes where it
  * began. An animation that cannot say answers `t` here too.
@@ -38,10 +38,10 @@
  * which content shows is a fact about time that motion is not: a value with
  * no time could only show a scheduled exit as already gone.
  *
- * The instances already in the tree: a `Beat` is an animation of which hold
+ * The instances already in the tree: a `StepSequence` is an animation of which hold
  * is in progress (`./easing.ts`), a `FrameSequence` of the frame shown and a
  * `Spinner` of the spinner drawn (`../renderables/`), and an `Effect` is, for
- * what an element draws in a frame, an animation of how its cells' colours
+ * what an element draws in a frame, an animation of how its cells' colors
  * move (`../renderables/effect.ts`). Every kind of motion is one more.
  *
  * An animation of renderables is a renderable — its face, `placedRender`:
@@ -67,16 +67,16 @@
  * of motion is built from — a constant, a value moving every moment, a map
  * over the value, several at once, one animation after another, and one
  * played again every period — and each says how
- * `nextChange` composes, so an animation built from them answers it without
+ * `validUntil` composes, so an animation built from them answers it without
  * its author doing anything.
  *
  * Tier 5 of `src/core/`: `./easing.ts`, `./measure.ts`, `./protocol.ts`,
  * `./segment.ts` and `./style.ts`, nothing else. [LAW:one-way-deps]
  */
-import { type Beat } from "./easing.js";
+import { type StepSequence } from "./easing.js";
 import { type Measurable, type Motion, type Renderable, type RenderOptions } from "./protocol.js";
 import { Segment } from "./segment.js";
-import { Style, type Hold } from "./style.js";
+import { Style, type ValidityInterval } from "./style.js";
 /**
  * What a frame's drawing said of the hold the element named `key`, drawn at
  * `t`, is in, or nothing if the frame heard of no such drawing: handed to an
@@ -93,15 +93,15 @@ import { Style, type Hold } from "./style.js";
  * frame's one drawing says it, so the answer cannot disagree with what the
  * frame shows.
  */
-export type Moves = (t: number, key: string) => Hold | undefined;
+export type Reads = (t: number, key: string) => ValidityInterval | undefined;
 /** A value of `T` at a time in seconds, and the hold it is in: what every animation answers, whatever its values. */
-export interface Timed<T> {
+export interface Behavior<T> {
     /** The value at `t` seconds. */
     at(t: number): T;
     /** The first moment, never before `t`, at which the value may stop being `at(t)`: `t` while it moves, `Infinity` once it never will. */
-    nextChange(t: number, moves?: Moves): number;
+    validUntil(t: number, moves?: Reads): number;
     /** The last moment, never after `t`, at which the value may have become `at(t)`: `t` while it moves, `-Infinity` if it always was. */
-    lastChange(t: number, moves?: Moves): number;
+    validFrom(t: number, moves?: Reads): number;
     /** This animation with its motion taken out — a loop at its first value, a one-shot cut to its end — drawn in its place under reduced motion. */
     reduced(): Animation<T>;
 }
@@ -113,12 +113,12 @@ export interface Timed<T> {
  * number is no renderable and a `Panel` refuses it; a tween mapped to a
  * `RichText` is one, and a `Panel` holds it.
  */
-export type Animation<T> = Timed<T> & ([T] extends [Renderable] ? Renderable & Measurable : unknown);
+export type Animation<T> = Behavior<T> & ([T] extends [Renderable] ? Renderable & Measurable : unknown);
 /** What a frame drawn at a time shows of an animation, and what that says. */
 export interface Shown<T> {
     readonly value: T;
     /** The animation the value is drawn from: the one handed in, or under reduced motion its reduced form. */
-    readonly drawn: Timed<T>;
+    readonly drawn: Behavior<T>;
     /** Whether it is the animation reduced: drawn under reduced motion, changing only where content does. */
     readonly reduced: boolean;
 }
@@ -130,19 +130,19 @@ export interface Shown<T> {
  * the template functions choose here, so a host told once
  * reduces every one.
  */
-export declare function shownAt<T>(animation: Timed<T>, t: number, motion: Motion): Shown<T>;
+export declare function shownAt<T>(animation: Behavior<T>, t: number, motion: Motion): Shown<T>;
 /** The hold `shown`, drawn at `t`, is in: its animation's two answers there, given what its drawing said. */
-export declare function holdOf(shown: Shown<unknown>, t: number, moves?: Moves): Hold;
+export declare function validityOf(shown: Shown<unknown>, t: number, moves?: Reads): ValidityInterval;
 /** The style saying a cell is in `hold`. */
-export declare function stamp(hold: Hold): Style;
+export declare function stampValidity(validity: ValidityInterval): Style;
 /**
  * `segments`, every one carrying `hold` under whatever it already said: the
- * later `lastChange` and the sooner `nextChange` win (`Style.add`), so a
+ * later `validFrom` and the sooner `validUntil` win (`Style.add`), so a
  * frame's hold is the intersection of its cells', narrower than the truth
  * and never wider. [LAW:single-enforcer] The one way a time is put on drawn
  * cells, by whatever draws for a time it knows.
  */
-export declare function stampFrame(segments: Iterable<Segment>, hold: Hold): Iterable<Segment>;
+export declare function stampValidityFrame(segments: Iterable<Segment>, validity: ValidityInterval): Iterable<Segment>;
 /**
  * The moment a frame drawn under `options` is drawn for: the frame's time,
  * which the host writes once a frame (`RenderOptions.frame`), or with no
@@ -156,10 +156,10 @@ export declare function frameTimeOf(options: RenderOptions): number;
  * An animation placed in the frame `options` draws: its value at the frame's
  * time (`frameTimeOf`, `shownAt`), drawn whole by `draw` under the options it
  * is handed, every segment then stamped with its hold there under whatever
- * its own cells say, and the hold told to the frame (`RenderOptions.onHold`),
+ * its own cells say, and the hold told to the frame (`RenderOptions.onValidity`),
  * because a frame of no cells — an element not yet entered — may have cells
  * later, and must say when without taking a row to say it in. Drawn first,
- * because the hold is asked with what the drawing said (`Moves`); each report
+ * because the hold is asked with what the drawing said (`Reads`); each report
  * goes on outward too, since a value drawn inside a placement in this value
  * may be a part of an animation placed further out. [LAW:single-enforcer]
  * The one placement: an animation of renderables (`placedRender`), an effect
@@ -167,25 +167,25 @@ export declare function frameTimeOf(options: RenderOptions): number;
  * blink) place through it, so how a time reaches an animation and how its
  * hold reaches the frame is written once.
  */
-export declare function placed<T>(animation: Timed<T>, options: RenderOptions, draw: (value: T, options: RenderOptions) => Iterable<Segment>): Iterable<Segment>;
+export declare function placed<T>(animation: Behavior<T>, options: RenderOptions, draw: (value: T, options: RenderOptions) => Iterable<Segment>): Iterable<Segment>;
 /**
  * An animation's face, `render`: `placed`, its value drawn as the renderable
  * it is. A container — the library's or a user's — that draws its children
  * through `render` draws an animation among them with no word about time:
  * the hold goes back the way the time came in. [LAW:composability]
  */
-export declare function placedRender(animation: Timed<unknown>, options: RenderOptions): Iterable<Segment>;
+export declare function placedRender(animation: Behavior<unknown>, options: RenderOptions): Iterable<Segment>;
 /**
  * An animation's face, `measure`: what it shows at the frame's time, measured,
- * and its hold there told (`RenderOptions.onHold`), because a container lays
+ * and its hold there told (`RenderOptions.onValidity`), because a container lays
  * out from the measurement and must lay out again when it changes.
  */
-export declare function placedMeasure(animation: Timed<unknown>, options: RenderOptions): {
+export declare function placedMeasure(animation: Behavior<unknown>, options: RenderOptions): {
     minimum: number;
     maximum: number;
 };
 /** What `Animation.of` makes of `X`: `X`, with the face its values call for. */
-export type Faced<X extends Timed<unknown>> = X & Animation<X extends Timed<infer T> ? T : never>;
+export type Faced<X extends Behavior<unknown>> = X & Animation<X extends Behavior<infer T> ? T : never>;
 export declare const Animation: {
     /**
      * `timed` as an animation: every member it carries kept (`membersOf`),
@@ -196,7 +196,7 @@ export declare const Animation: {
      * animation made here has the face, and one whose values are not
      * renderables throws when it is drawn.
      */
-    of<X extends Timed<unknown>>(timed: X): Faced<NoInfer<X>>;
+    of<X extends Behavior<unknown>>(timed: X): Faced<NoInfer<X>>;
     /**
      * Whether `animation` never changes again from `t`: a one-shot that has
      * run, a loop at a depth that shows no motion. [LAW:single-enforcer] The
@@ -205,7 +205,7 @@ export declare const Animation: {
      * once. An early answer the contract allows is a finite one, so `Infinity`
      * is only ever a true never.
      */
-    done(animation: Timed<unknown>, t: number): boolean;
+    done(animation: Behavior<unknown>, t: number): boolean;
     /** `value` at every time, never changing. */
     constant<T>(value: T): Animation<T>;
     /**
@@ -233,14 +233,14 @@ export declare const Animation: {
      * `animation`'s value through `f`, changing when it does. Two values `f`
      * maps alike make an early answer, which the contract allows.
      */
-    map<T, U>(animation: Timed<T>, f: (value: T) => U): Animation<U>;
+    map<T, U>(animation: Behavior<T>, f: (value: T) => U): Animation<U>;
     /**
      * Every one of `animations` at once, their values in order, changing when
      * the soonest of them does — so a stack of effects drawn together holds
      * still exactly while each of them does, and reduced each reduced — a
      * stagger with every child arrived. None never changes.
      */
-    all<const T extends readonly unknown[]>(animations: { readonly [K in keyof T]: Timed<T[K]>; }): Animation<T>;
+    all<const T extends readonly unknown[]>(animations: { readonly [K in keyof T]: Behavior<T[K]>; }): Animation<T>;
     /**
      * `animation` sampled once a hold of `beat`: within a hold, its value at
      * the hold's start, and at each hold's start it moves on. It changes at the
@@ -253,7 +253,7 @@ export declare const Animation: {
      * [LAW:one-source-of-truth] The one stepping rule, for an effect's frames
      * and a transition's schedule alike.
      */
-    onBeat<T>(animation: Timed<T>, beat: Beat): Animation<T>;
+    sampleAndHold<T>(animation: Behavior<T>, stepSequence: StepSequence): Animation<T>;
     /**
      * `first` until `seconds`, then `then`, handed the time since it began —
      * each part on its own clock from 0, as every effect is. Before the switch
@@ -263,7 +263,7 @@ export declare const Animation: {
      * shows on time; a one-shot that is the motion into what follows says its
      * own end (`transition`, `../renderables/effects.ts`).
      */
-    sequence<T>(first: Timed<T>, seconds: number, then: Timed<T>): Animation<T>;
+    sequence<T>(first: Behavior<T>, seconds: number, then: Behavior<T>): Animation<T>;
     /**
      * `nth(n)` for every time in the `n`th turn, `[n·period, (n+1)·period)`,
      * handed the time since that turn began — a one-shot played again every
@@ -276,5 +276,5 @@ export declare const Animation: {
      * something new still shows it on time and a one-shot inside cuts to its
      * end there. Nothing is walked through: a call reads only its turn.
      */
-    repeat<T>(period: number, nth: (n: number) => Timed<T>): Animation<T>;
+    repeat<T>(period: number, nth: (n: number) => Behavior<T>): Animation<T>;
 };

package/dist/core/animation.js

@@ -2,7 +2,7 @@
  * Animation — a value for a time, and when it next changes: the one type
  * anything in rich-js that changes with time is an instance of.
  *
- * `at(t)` is the value at `t` seconds. `nextChange(t)` is the first moment,
+ * `at(t)` is the value at `t` seconds. `validUntil(t)` is the first moment,
  * on `t`'s own timeline, at which the value may stop being `at(t)`: never
  * before `t`. A later time says the value is held until then, `Infinity`
  * that it never changes again, and `t` itself that it is moving at `t` — it
@@ -10,16 +10,16 @@
  * answer costs a host a frame that draws what the last one did; a late one
  * skips a change. So an animation that cannot say answers `t`, as
  * `continuous` does. An answer that depends on what the frame drew, an
- * effect's, is told by that drawing (`Moves`). A value drawn as cells carries this answer on every
+ * effect's, is told by that drawing (`Reads`). A value drawn as cells carries this answer on every
  * cell (`Style.hold`, both ends of the hold below), so a host holding
- * the composed frame reads it there (`Segment.nextChange`); a value that is
- * not drawn — a number, a colour — has `nextChange` as its only way to say
+ * the composed frame reads it there (`Segment.validUntil`); a value that is
+ * not drawn — a number, a color — has `validUntil` as its only way to say
  * when to look again.
  *
- * `lastChange(t)` is the other end of the same hold: the last moment, never
+ * `validFrom(t)` is the other end of the same hold: the last moment, never
  * after `t`, at which the value may have become `at(t)` — `-Infinity` if it
- * always was, `t` while it moves. Together they bound the hold, `[lastChange(t),
- * nextChange(t))`, and the answer may be narrower than the truth and never
+ * always was, `t` while it moves. Together they bound the hold, `[validFrom(t),
+ * validUntil(t))`, and the answer may be narrower than the truth and never
  * wider. It is what a host running the animation backwards reads
  * (`./timeline.ts`): run down the timeline, the value next changes where it
  * began. An animation that cannot say answers `t` here too.
@@ -38,10 +38,10 @@
  * which content shows is a fact about time that motion is not: a value with
  * no time could only show a scheduled exit as already gone.
  *
- * The instances already in the tree: a `Beat` is an animation of which hold
+ * The instances already in the tree: a `StepSequence` is an animation of which hold
  * is in progress (`./easing.ts`), a `FrameSequence` of the frame shown and a
  * `Spinner` of the spinner drawn (`../renderables/`), and an `Effect` is, for
- * what an element draws in a frame, an animation of how its cells' colours
+ * what an element draws in a frame, an animation of how its cells' colors
  * move (`../renderables/effect.ts`). Every kind of motion is one more.
  *
  * An animation of renderables is a renderable — its face, `placedRender`:
@@ -67,13 +67,13 @@
  * of motion is built from — a constant, a value moving every moment, a map
  * over the value, several at once, one animation after another, and one
  * played again every period — and each says how
- * `nextChange` composes, so an animation built from them answers it without
+ * `validUntil` composes, so an animation built from them answers it without
  * its author doing anything.
  *
  * Tier 5 of `src/core/`: `./easing.ts`, `./measure.ts`, `./protocol.ts`,
  * `./segment.ts` and `./style.ts`, nothing else. [LAW:one-way-deps]
  */
-import { beat, firstReaching, passAt, positiveSeconds } from "./easing.js";
+import { stepSequence, firstReaching, passAt, positiveSeconds } from "./easing.js";
 import { Measurement } from "./measure.js";
 import { isRenderable, render } from "./protocol.js";
 import { Segment } from "./segment.js";
@@ -92,22 +92,22 @@ export function shownAt(animation, t, motion) {
     return { value: drawn.at(t), drawn, reduced };
 }
 /** The hold `shown`, drawn at `t`, is in: its animation's two answers there, given what its drawing said. */
-export function holdOf(shown, t, moves) {
-    return { lastChange: shown.drawn.lastChange(t, moves), nextChange: shown.drawn.nextChange(t, moves) };
+export function validityOf(shown, t, moves) {
+    return { validFrom: shown.drawn.validFrom(t, moves), validUntil: shown.drawn.validUntil(t, moves) };
 }
 /** The style saying a cell is in `hold`. */
-export function stamp(hold) {
-    return new Style({ hold });
+export function stampValidity(validity) {
+    return new Style({ validity });
 }
 /**
  * `segments`, every one carrying `hold` under whatever it already said: the
- * later `lastChange` and the sooner `nextChange` win (`Style.add`), so a
+ * later `validFrom` and the sooner `validUntil` win (`Style.add`), so a
  * frame's hold is the intersection of its cells', narrower than the truth
  * and never wider. [LAW:single-enforcer] The one way a time is put on drawn
  * cells, by whatever draws for a time it knows.
  */
-export function stampFrame(segments, hold) {
-    return Segment.applyStyle(segments, stamp(hold));
+export function stampValidityFrame(segments, validity) {
+    return Segment.applyStyle(segments, stampValidity(validity));
 }
 /**
  * The moment a frame drawn under `options` is drawn for: the frame's time,
@@ -130,10 +130,10 @@ function drawable(value) {
  * An animation placed in the frame `options` draws: its value at the frame's
  * time (`frameTimeOf`, `shownAt`), drawn whole by `draw` under the options it
  * is handed, every segment then stamped with its hold there under whatever
- * its own cells say, and the hold told to the frame (`RenderOptions.onHold`),
+ * its own cells say, and the hold told to the frame (`RenderOptions.onValidity`),
  * because a frame of no cells — an element not yet entered — may have cells
  * later, and must say when without taking a row to say it in. Drawn first,
- * because the hold is asked with what the drawing said (`Moves`); each report
+ * because the hold is asked with what the drawing said (`Reads`); each report
  * goes on outward too, since a value drawn inside a placement in this value
  * may be a part of an animation placed further out. [LAW:single-enforcer]
  * The one placement: an animation of renderables (`placedRender`), an effect
@@ -146,15 +146,15 @@ export function* placed(animation, options, draw) {
     const shown = shownAt(animation, t, options);
     const said = new Map();
     const part = (at, key) => `${at} ${key}`;
-    const onMoved = (at, key, hold) => {
+    const onReads = (at, key, validity) => {
         const known = said.get(part(at, key));
-        said.set(part(at, key), known === undefined ? hold : intersection(known, hold));
-        options.onMoved?.(at, key, hold);
+        said.set(part(at, key), known === undefined ? validity : intersection(known, validity));
+        options.onReads?.(at, key, validity);
     };
-    const segments = [...draw(shown.value, { ...options, onMoved })];
-    const hold = holdOf(shown, t, (at, key) => said.get(part(at, key)));
-    options.onHold?.(hold);
-    yield* stampFrame(segments, hold);
+    const segments = [...draw(shown.value, { ...options, onReads })];
+    const validity = validityOf(shown, t, (at, key) => said.get(part(at, key)));
+    options.onValidity?.(validity);
+    yield* stampValidityFrame(segments, validity);
 }
 /**
  * An animation's face, `render`: `placed`, its value drawn as the renderable
@@ -167,13 +167,13 @@ export function placedRender(animation, options) {
 }
 /**
  * An animation's face, `measure`: what it shows at the frame's time, measured,
- * and its hold there told (`RenderOptions.onHold`), because a container lays
+ * and its hold there told (`RenderOptions.onValidity`), because a container lays
  * out from the measurement and must lay out again when it changes.
  */
 export function placedMeasure(animation, options) {
     const t = frameTimeOf(options);
     const shown = shownAt(animation, t, options);
-    options.onHold?.(holdOf(shown, t, UNLAID));
+    options.onValidity?.(validityOf(shown, t, UNLAID));
     return Measurement.get(options, drawable(shown.value));
 }
 /**
@@ -229,11 +229,11 @@ export const Animation = {
      * is only ever a true never.
      */
     done(animation, t) {
-        return animation.nextChange(t) === Number.POSITIVE_INFINITY;
+        return animation.validUntil(t) === Number.POSITIVE_INFINITY;
     },
     /** `value` at every time, never changing. */
     constant(value) {
-        const still = Animation.of({ at: () => value, nextChange: () => Number.POSITIVE_INFINITY, lastChange: () => Number.NEGATIVE_INFINITY, reduced: () => still });
+        const still = Animation.of({ at: () => value, validUntil: () => Number.POSITIVE_INFINITY, validFrom: () => Number.NEGATIVE_INFINITY, reduced: () => still });
         return still;
     },
     /**
@@ -243,8 +243,8 @@ export const Animation = {
     cut(before, after) {
         const cut = Animation.of({
             at: (t) => (t < 0 ? before : after),
-            nextChange: (t) => (t < 0 ? 0 : Number.POSITIVE_INFINITY),
-            lastChange: (t) => (t < 0 ? Number.NEGATIVE_INFINITY : 0),
+            validUntil: (t) => (t < 0 ? 0 : Number.POSITIVE_INFINITY),
+            validFrom: (t) => (t < 0 ? Number.NEGATIVE_INFINITY : 0),
             reduced: () => cut,
         });
         return cut;
@@ -256,7 +256,7 @@ export const Animation = {
      * it says its own end (`transition`, `../renderables/effects.ts`).
      */
     continuous(at) {
-        return Animation.of({ at, nextChange: (t) => t, lastChange: (t) => t, reduced: () => Animation.constant(at(0)) });
+        return Animation.of({ at, validUntil: (t) => t, validFrom: (t) => t, reduced: () => Animation.constant(at(0)) });
     },
     /**
      * The time itself, in seconds, moving at every moment: what a clock, a
@@ -267,7 +267,7 @@ export const Animation = {
      * [LAW:types-are-the-program]
      */
     time() {
-        const time = Animation.of({ at: (t) => t, nextChange: (t) => t, lastChange: (t) => t, reduced: () => time });
+        const time = Animation.of({ at: (t) => t, validUntil: (t) => t, validFrom: (t) => t, reduced: () => time });
         return time;
     },
     /**
@@ -277,8 +277,8 @@ export const Animation = {
     map(animation, f) {
         return Animation.of({
             at: (t) => f(animation.at(t)),
-            nextChange: (t, moves) => animation.nextChange(t, moves),
-            lastChange: (t, moves) => animation.lastChange(t, moves),
+            validUntil: (t, moves) => animation.validUntil(t, moves),
+            validFrom: (t, moves) => animation.validFrom(t, moves),
             reduced: () => Animation.map(animation.reduced(), f),
         });
     },
@@ -295,8 +295,8 @@ export const Animation = {
             at: (t) => animations.map((animation) => animation.at(t)),
             // A fold, not a spread: a stagger over a table's rows is a list as long
             // as the table, past what an engine takes as arguments.
-            nextChange: (t, moves) => animations.reduce((soonest, animation) => Math.min(soonest, animation.nextChange(t, moves)), Number.POSITIVE_INFINITY),
-            lastChange: (t, moves) => animations.reduce((latest, animation) => Math.max(latest, animation.lastChange(t, moves)), Number.NEGATIVE_INFINITY),
+            validUntil: (t, moves) => animations.reduce((soonest, animation) => Math.min(soonest, animation.validUntil(t, moves)), Number.POSITIVE_INFINITY),
+            validFrom: (t, moves) => animations.reduce((latest, animation) => Math.max(latest, animation.validFrom(t, moves)), Number.NEGATIVE_INFINITY),
             reduced: () => Animation.all(animations.map((animation) => animation.reduced())),
         });
     },
@@ -312,24 +312,24 @@ export const Animation = {
      * [LAW:one-source-of-truth] The one stepping rule, for an effect's frames
      * and a transition's schedule alike.
      */
-    onBeat(animation, beat) {
+    sampleAndHold(animation, stepSequence) {
         return Animation.of({
-            at: (t) => animation.at(beat.lastChange(t)),
-            nextChange(t, moves) {
-                const moved = animation.nextChange(beat.lastChange(t), moves);
+            at: (t) => animation.at(stepSequence.validFrom(t)),
+            validUntil(t, moves) {
+                const moved = animation.validUntil(stepSequence.validFrom(t), moves);
                 if (moved === Number.POSITIVE_INFINITY)
                     return moved;
-                const end = beat.nextChange(t);
+                const end = stepSequence.validUntil(t);
                 // The hold boundaries after `t` are `end`, then each hold's end in turn;
                 // the value turns at the first one the animation has moved by.
-                return moved <= end ? end : beat.lastChange(moved) === moved ? moved : beat.nextChange(moved);
+                return moved <= end ? end : stepSequence.validFrom(moved) === moved ? moved : stepSequence.validUntil(moved);
             },
             // The value held now began at this hold's start at the latest: an early
             // answer where the animation had not moved by it, which the contract
             // allows. One that always was never turned on any beat.
-            lastChange(t, moves) {
-                const began = beat.lastChange(t);
-                const moved = animation.lastChange(began, moves);
+            validFrom(t, moves) {
+                const began = stepSequence.validFrom(t);
+                const moved = animation.validFrom(began, moves);
                 return moved === Number.NEGATIVE_INFINITY ? moved : began;
             },
             // Reduced, nothing moves between beats, so there is nothing to sample on them.
@@ -355,19 +355,19 @@ export const Animation = {
         const carried = (local) => (Number.isFinite(local) ? firstReaching(local + seconds, (x) => x - seconds >= local) : local);
         return Animation.of({
             at: (t) => (t - seconds >= 0 ? then.at(t - seconds) : first.at(t)),
-            nextChange(t, moves) {
+            validUntil(t, moves) {
                 const into = t - seconds;
                 if (into < 0)
-                    return Math.min(first.nextChange(t, moves), seconds);
-                return Math.max(t, carried(then.nextChange(into, moves)));
+                    return Math.min(first.validUntil(t, moves), seconds);
+                return Math.max(t, carried(then.validUntil(into, moves)));
             },
             // After the switch the value became what it is at the switch or when
             // `then`'s did since, whichever is later; before it, when `first`'s did.
-            lastChange(t, moves) {
+            validFrom(t, moves) {
                 const into = t - seconds;
                 if (into < 0)
-                    return first.lastChange(t, moves);
-                return Math.min(t, Math.max(seconds, carried(then.lastChange(into, moves))));
+                    return first.validFrom(t, moves);
+                return Math.min(t, Math.max(seconds, carried(then.validFrom(into, moves))));
             },
             reduced: () => Animation.sequence(first.reduced(), seconds, then.reduced()),
         });
@@ -387,10 +387,10 @@ export const Animation = {
     repeat(period, nth) {
         positiveSeconds("Animation.repeat period", period);
         // [LAW:single-enforcer] Which turn a time is in, and how far into it, is
-        // `passAt`, the wrap a `beat` and `Phase.loop` read time through, so a
+        // `passAt`, the wrap a `beat` and `WrapMode.loop` read time through, so a
         // repeat beside a loop of the same period turns on the same float; where
         // a turn begins and the next begins are a one-hold beat's two ends.
-        const turns = beat([period]);
+        const turns = stepSequence([period]);
         // The turn's moment `local`, on its own clock, carried onto this one: the
         // first float the wrap places at or past `local` in turn `n`, or in a
         // later turn, found as `sequence` carries its second part's.
@@ -405,14 +405,14 @@ export const Animation = {
                 const { pass, into } = passAt("Animation.repeat", t, period);
                 return nth(pass).at(into);
             },
-            nextChange(t, moves) {
+            validUntil(t, moves) {
                 const { pass, into } = passAt("Animation.repeat", t, period);
-                return Math.max(t, Math.min(turns.nextChange(t), carried(pass, turns.lastChange(t), nth(pass).nextChange(into, moves))));
+                return Math.max(t, Math.min(turns.validUntil(t), carried(pass, turns.validFrom(t), nth(pass).validUntil(into, moves))));
             },
-            lastChange(t, moves) {
+            validFrom(t, moves) {
                 const { pass, into } = passAt("Animation.repeat", t, period);
-                const began = turns.lastChange(t);
-                return Math.min(t, Math.max(began, carried(pass, began, nth(pass).lastChange(into, moves))));
+                const began = turns.validFrom(t);
+                return Math.min(t, Math.max(began, carried(pass, began, nth(pass).validFrom(into, moves))));
             },
             reduced: () => Animation.repeat(period, (n) => nth(n).reduced()),
         });

package/dist/core/ansi.d.ts

@@ -7,12 +7,12 @@
  * own `new Console()`, a CLI's output shown inside a Panel, a log replayed into
  * a Table cell.
  *
- * [LAW:types-are-the-program] Every colour decodes to the `ColorSpec` its
- * escape names — `31` the standard colour 1, `38;5;n` palette index n,
+ * [LAW:types-are-the-program] Every color decodes to the `ColorSpec` its
+ * escape names — `31` the standard color 1, `38;5;n` palette index n,
  * `38;2;r;g;b` that truecolor — and none is resolved to RGB here. A standard
- * colour is a slot in whatever theme draws it, so one captured run exports
+ * color is a slot in whatever theme draws it, so one captured run exports
  * correctly under a light theme and a dark one; resolved here, dark mode would
- * show light mode's colours. Resolution belongs to `export-lines`.
+ * show light mode's colors. Resolution belongs to `export-lines`.
  *
  * [LAW:types-are-the-program] The link is decoder state of its own, beside
  * the SGR style, not a field of it: a terminal ends a hyperlink only at an OSC

package/dist/core/ansi.js

@@ -7,12 +7,12 @@
  * own `new Console()`, a CLI's output shown inside a Panel, a log replayed into
  * a Table cell.
  *
- * [LAW:types-are-the-program] Every colour decodes to the `ColorSpec` its
- * escape names — `31` the standard colour 1, `38;5;n` palette index n,
+ * [LAW:types-are-the-program] Every color decodes to the `ColorSpec` its
+ * escape names — `31` the standard color 1, `38;5;n` palette index n,
  * `38;2;r;g;b` that truecolor — and none is resolved to RGB here. A standard
- * colour is a slot in whatever theme draws it, so one captured run exports
+ * color is a slot in whatever theme draws it, so one captured run exports
  * correctly under a light theme and a dark one; resolved here, dark mode would
- * show light mode's colours. Resolution belongs to `export-lines`.
+ * show light mode's colors. Resolution belongs to `export-lines`.
  *
  * [LAW:types-are-the-program] The link is decoder state of its own, beside
  * the SGR style, not a field of it: a terminal ends a hyperlink only at an OSC
@@ -70,7 +70,7 @@ const STRING_ESCAPE = String.raw `\x1b[\]P_^X][^\n]*?(?:\x07|\x1b\\|\x9c|\n|$)`;
 const ESCAPES = [
     String.raw `\r|\x1b\[(?<sgr>[0-9;:]*)m|\x1b\[(?<mode>[012]?)K|\x1b\[[0-?]*[ -/]*[@-~]|${STRING_ESCAPE}|\x1b[ -/]*[0-~]`,
     String.raw `(?<underscore>_\x08)?(?<struck>\P{Cc})(?:\x08\k<struck>)+|_\x08(?<underlined>\P{Cc})|\x08`,
-    controlClass((disposition) => disposition !== "keep" && disposition !== "withheld"),
+    controlClass((disposition) => disposition !== "keep" && disposition !== "zeroWidth"),
 ].join("|");
 const escapes = () => new RegExp(ESCAPES, "gu");
 // A string escape goes first so a line break in its payload stays in the payload.
@@ -120,7 +120,7 @@ function next(rest) {
 }
 /**
  * `5;n` or `2;r;g;b`, the arguments of `38` and `48`. A sequence cut short
- * names no colour, and the codes it did consume are spent, as in Rich.
+ * names no color, and the codes it did consume are spent, as in Rich.
  */
 function extendedColor(rest) {
     const kind = next(rest);
@@ -145,8 +145,8 @@ const SGR_OPS = new Map([
     [23, adding({ italic: false })],
     // ECMA-48: 24 is "neither singly nor doubly underlined", 25 "steady" at
     // either speed. Rich's table clears only the first of each pair.
-    [24, adding({ underline: false, underline2: false })],
-    [25, adding({ blink: false, blink2: false })],
+    [24, adding({ underline: false, doubleUnderline: false })],
+    [25, adding({ blink: false, rapidBlink: false })],
     [27, adding({ reverse: false })],
     [28, adding({ conceal: false })],
     [29, adding({ strike: false })],
@@ -154,7 +154,7 @@ const SGR_OPS = new Map([
     [39, adding({ color: ColorSpec.default() })],
     [48, (style, rest) => style.add(new Style({ bgcolor: extendedColor(rest) }))],
     [49, adding({ bgcolor: ColorSpec.default() })],
-    // Underline colour has no field on Style; its arguments are still spent, or
+    // Underline color has no field on Style; its arguments are still spent, or
     // `58;2;1;2;3` would read on as bold, dim and italic.
     [58, (style, rest) => (extendedColor(rest), style)],
     [54, adding({ frame: false, encircle: false })],