@promptctl/rich-js 0.28.0 → 0.29.0

package/dist/renderables/embed.d.ts

@@ -107,7 +107,7 @@ export declare function cutLabel(text: RichText, width: number, marker: string):
  * `Text` are not, and markup that styles nothing is — it reads as empty text,
  * but the string that holds it is not empty.
  */
-export declare function present(content: string | RichText | undefined): content is string | RichText;
+export declare function mounted(content: string | RichText | undefined): content is string | RichText;
 /**
  * A label's text as one line of segments at its natural width, its own styles
  * laid over `base`. The caller has already cut it to its room, so it leaves as

package/dist/renderables/embed.js

@@ -159,7 +159,7 @@ export function cutLabel(text, width, marker) {
  * `Text` are not, and markup that styles nothing is — it reads as empty text,
  * but the string that holds it is not empty.
  */
-export function present(content) {
+export function mounted(content) {
     // Asked of what the content is rather than of what it is not, so a `null`
     // from untyped JS is no content, as Rich's `None` is.
     return typeof content === "string" ? content !== "" : content instanceof RichText && content.plain !== "";
@@ -180,5 +180,5 @@ export function drawLabel(text, options, base) {
  * label, which still opens a gap in the rule, as Rich's does.
  */
 export function inlineLabel(content) {
-    return present(content) ? new InlineLabel(content) : undefined;
+    return mounted(content) ? new InlineLabel(content) : undefined;
 }

package/dist/renderables/flexStrip.d.ts

@@ -2,10 +2,10 @@
  * FlexStrip — wrap-to-width horizontal layout for `StyledRenderable` items.
  *
  * Pack as many items as fit on a line, then break and continue. Each line is
- * an independent sub-strip: optional `Joiner` end-caps fire at every line
+ * an independent sub-strip: optional `Separator` end-caps fire at every line
  * boundary (not just the strip's first/last position), so a line break looks
- * the same as an endpoint to the joiner. Composes with the Strip + Joiner
- * primitive in `core/strip` — same `Joiner` protocol, no new join semantics.
+ * the same as an endpoint to the joiner. Composes with the Strip + Separator
+ * primitive in `core/strip` — same `Separator` protocol, no new join semantics.
  *
  * [LAW:dataflow-not-control-flow] The pack walk is the same shape every
  * render: measure each item, render every joiner form (start-cap, end-cap,
@@ -17,11 +17,11 @@
  */
 import { Segment } from "../core/segment.js";
 import type { Renderable, Measurable, RenderOptions } from "../core/protocol.js";
-import { type Joiner, type StyledRenderable } from "../core/strip.js";
+import { type Separator, type StyledRenderable } from "../core/strip.js";
 export type FlexAlign = "left" | "center" | "right" | "justify";
 export interface FlexStripOptions<T extends StyledRenderable> {
-    /** Joiner used between items within a line, and at line endpoints. */
-    joiner?: Joiner<T>;
+    /** Separator used between items within a line, and at line endpoints. */
+    separator?: Separator<T>;
     /** Cells of horizontal space inserted on each side of an inter-item joiner (default 0). */
     gap?: number;
     /** Line alignment when packed items don't fill the available width (default "left"). */
@@ -29,7 +29,7 @@ export interface FlexStripOptions<T extends StyledRenderable> {
 }
 export declare class FlexStrip<T extends StyledRenderable = StyledRenderable> implements Renderable, Measurable {
     readonly items: readonly T[];
-    readonly joiner: Joiner<T> | undefined;
+    readonly separator: Separator<T> | undefined;
     readonly gap: number;
     readonly align: FlexAlign;
     constructor(items: readonly T[], options?: FlexStripOptions<T>);

package/dist/renderables/flexStrip.js

@@ -2,10 +2,10 @@
  * FlexStrip — wrap-to-width horizontal layout for `StyledRenderable` items.
  *
  * Pack as many items as fit on a line, then break and continue. Each line is
- * an independent sub-strip: optional `Joiner` end-caps fire at every line
+ * an independent sub-strip: optional `Separator` end-caps fire at every line
  * boundary (not just the strip's first/last position), so a line break looks
- * the same as an endpoint to the joiner. Composes with the Strip + Joiner
- * primitive in `core/strip` — same `Joiner` protocol, no new join semantics.
+ * the same as an endpoint to the joiner. Composes with the Strip + Separator
+ * primitive in `core/strip` — same `Separator` protocol, no new join semantics.
  *
  * [LAW:dataflow-not-control-flow] The pack walk is the same shape every
  * render: measure each item, render every joiner form (start-cap, end-cap,
@@ -47,12 +47,12 @@ function computeSlotFills(align, isFinalLine, spare, itemCount) {
 }
 export class FlexStrip {
     items;
-    joiner;
+    separator;
     gap;
     align;
     constructor(items, options) {
         this.items = items;
-        this.joiner = options?.joiner;
+        this.separator = options?.separator;
         this.gap = options?.gap ?? 0;
         this.align = options?.align ?? "left";
     }
@@ -62,7 +62,7 @@ export class FlexStrip {
             return;
         const maxWidth = Math.max(1, options.maxWidth);
         const gap = this.gap;
-        const joiner = this.joiner;
+        const joiner = this.separator;
         // Pre-render every item and every joiner form we might need. Doing this
         // up-front turns packing into a pure data computation over widths.
         const itemBlocks = items.map((it) => renderToBlock(drawItem(it), options));
@@ -178,24 +178,24 @@ export class FlexStrip {
         let maximum = 0;
         for (let i = 0; i < items.length; i++) {
             const itemWidth = renderToBlock(items[i], options).width;
-            const sc = this.joiner
-                ? renderToBlock(drawJoin(this.joiner, null, items[i], { index: i }), options).width
+            const sc = this.separator
+                ? renderToBlock(drawJoin(this.separator, null, items[i], { index: i }), options).width
                 : 0;
-            const ec = this.joiner
-                ? renderToBlock(drawJoin(this.joiner, items[i], null, { index: i + 1 }), options).width
+            const ec = this.separator
+                ? renderToBlock(drawJoin(this.separator, items[i], null, { index: i + 1 }), options).width
                 : 0;
             minimum = Math.max(minimum, itemWidth + sc + ec);
             maximum += itemWidth;
             if (i > 0) {
                 maximum += this.gap * 2;
-                if (this.joiner) {
-                    maximum += renderToBlock(drawJoin(this.joiner, items[i - 1], items[i], { index: i }), options).width;
+                if (this.separator) {
+                    maximum += renderToBlock(drawJoin(this.separator, items[i - 1], items[i], { index: i }), options).width;
                 }
             }
         }
-        if (this.joiner) {
-            maximum += renderToBlock(drawJoin(this.joiner, null, items[0], { index: 0 }), options).width;
-            maximum += renderToBlock(drawJoin(this.joiner, items[items.length - 1], null, { index: items.length }), options).width;
+        if (this.separator) {
+            maximum += renderToBlock(drawJoin(this.separator, null, items[0], { index: 0 }), options).width;
+            maximum += renderToBlock(drawJoin(this.separator, items[items.length - 1], null, { index: items.length }), options).width;
         }
         return { minimum, maximum };
     }

package/dist/renderables/frames.d.ts

@@ -3,7 +3,7 @@
  * for its own seconds and looping, drawn as the one in progress at a time
  * the host hands in.
  *
- * An effect moves a cell's colours and may never change a glyph
+ * An effect moves a cell's colors and may never change a glyph
  * (`./effect.ts`: "It changes how cells look, never which cells exist or who
  * drew them"). A frame is the other kind of motion — what the element shows
  * changes — so it is its own primitive and not a wider `Effect`, and the two
@@ -30,7 +30,7 @@
  * placed sequence stamps them with its hold (`Style.hold`,
  * `placedRender` in `core/animation.ts`), which rides up
  * through every container to whoever holds the composed frame
- * (`Segment.nextChange`), so a host drawing at `t` knows when to draw again,
+ * (`Segment.validUntil`), so a host drawing at `t` knows when to draw again,
  * and one drawing slower than the frames turn can see that it is skipping
  * them. Nothing an animation's `at` returns carries a stamp of its own: the
  * stamp is put on where the frame's time is known.
@@ -45,7 +45,7 @@
  * children do.
  */
 import { Animation } from "../core/animation.js";
-import { type Beat } from "../core/easing.js";
+import { type StepSequence } from "../core/easing.js";
 import type { RenderOptions } from "../core/protocol.js";
 import type { Segment } from "../core/segment.js";
 import { RichText } from "../core/text.js";
@@ -57,7 +57,7 @@ export interface Frame {
 /** A sequence of frames prepared to be drawn: built once, asked for the frame at a time. */
 export declare class FrameSequence implements Animation<RichText> {
     /** Which frame is in progress when: the holds are the frames' seconds, in order. */
-    readonly beat: Beat;
+    readonly stepSequence: StepSequence;
     /** The width every frame draws at: the widest frame's, in cells. */
     readonly width: number;
     private readonly _shown;
@@ -70,9 +70,9 @@ export declare class FrameSequence implements Animation<RichText> {
      */
     at(t: number): RichText;
     /** When the frame in progress at `t` gives way to the next: the beat's answer, its holds being the frames'. */
-    nextChange(t: number): number;
+    validUntil(t: number): number;
     /** When the frame in progress at `t` began: the beat's answer. */
-    lastChange(t: number): number;
+    validFrom(t: number): number;
     /** The frames with their motion taken out: the beat's first frame, held, a copy as `at`'s is. */
     reduced(): Animation<RichText>;
     render(options: RenderOptions): Iterable<Segment>;

package/dist/renderables/frames.js

@@ -3,7 +3,7 @@
  * for its own seconds and looping, drawn as the one in progress at a time
  * the host hands in.
  *
- * An effect moves a cell's colours and may never change a glyph
+ * An effect moves a cell's colors and may never change a glyph
  * (`./effect.ts`: "It changes how cells look, never which cells exist or who
  * drew them"). A frame is the other kind of motion — what the element shows
  * changes — so it is its own primitive and not a wider `Effect`, and the two
@@ -30,7 +30,7 @@
  * placed sequence stamps them with its hold (`Style.hold`,
  * `placedRender` in `core/animation.ts`), which rides up
  * through every container to whoever holds the composed frame
- * (`Segment.nextChange`), so a host drawing at `t` knows when to draw again,
+ * (`Segment.validUntil`), so a host drawing at `t` knows when to draw again,
  * and one drawing slower than the frames turn can see that it is skipping
  * them. Nothing an animation's `at` returns carries a stamp of its own: the
  * stamp is put on where the frame's time is known.
@@ -45,18 +45,18 @@
  * children do.
  */
 import { Animation, placedRender } from "../core/animation.js";
-import { beat } from "../core/easing.js";
+import { stepSequence } from "../core/easing.js";
 import { setIntoLine } from "./embed.js";
 /** A sequence of frames prepared to be drawn: built once, asked for the frame at a time. */
 export class FrameSequence {
     /** Which frame is in progress when: the holds are the frames' seconds, in order. */
-    beat;
+    stepSequence;
     /** The width every frame draws at: the widest frame's, in cells. */
     width;
     // Each frame as it draws: a line fragment padded to `width`, made once.
     _shown;
     constructor(frames) {
-        this.beat = beat(frames.map((frame) => frame.seconds));
+        this.stepSequence = stepSequence(frames.map((frame) => frame.seconds));
         const texts = frames.map((frame) => setIntoLine(frame.text.copy()));
         const widths = texts.map((text) => text.cellLength);
         this.width = Math.max(...widths);
@@ -75,19 +75,19 @@ export class FrameSequence {
      * refuses a `t` that is not finite.
      */
     at(t) {
-        return this._shown[this.beat.at(t)].copy();
+        return this._shown[this.stepSequence.at(t)].copy();
     }
     /** When the frame in progress at `t` gives way to the next: the beat's answer, its holds being the frames'. */
-    nextChange(t) {
-        return this.beat.nextChange(t);
+    validUntil(t) {
+        return this.stepSequence.validUntil(t);
     }
     /** When the frame in progress at `t` began: the beat's answer. */
-    lastChange(t) {
-        return this.beat.lastChange(t);
+    validFrom(t) {
+        return this.stepSequence.validFrom(t);
     }
     /** The frames with their motion taken out: the beat's first frame, held, a copy as `at`'s is. */
     reduced() {
-        return Animation.map(this.beat.reduced(), (i) => this._shown[i].copy());
+        return Animation.map(this.stepSequence.reduced(), (i) => this._shown[i].copy());
     }
     render(options) {
         return placedRender(this, options);

package/dist/renderables/glyph-effect.d.ts

@@ -3,8 +3,8 @@
  * glyph effect at a moment `t`: the glyph half of `Effected` (`./effect.ts`),
  * built to its contract.
  *
- * A glyph effect is the colour effect's two-stage shape with a glyph where
- * the colours were: for the cells an element draws in a frame, an
+ * A glyph effect is the color effect's two-stage shape with a glyph where
+ * the colors were: for the cells an element draws in a frame, an
  * `Animation` (`../core/animation.ts`) of what is done to them. The first
  * stage is handed every cell once a frame (`GlyphCell`), blanks included —
  * rain and stars live there — and whether the output draws ASCII alone
@@ -14,15 +14,15 @@
  * scramble, a wave of case changes and particles on blank cells are all this
  * one shape (`./glyph-effects.ts`) [LAW:one-type-per-behavior].
  *
- * Colour and glyph are not two kinds of animation: each is an `Animation` of
+ * Color and glyph are not two kinds of animation: each is an `Animation` of
  * a per-cell map, and they differ only in what a cell is mapped to. The
- * wrappers are two because the stages are handed different facts. A colour
- * effect is settled against the depth, the terminal and the colours of the
- * words (`Drawn`), and with no colour output there is nothing for it to
+ * wrappers are two because the stages are handed different facts. A color
+ * effect is settled against the depth, the terminal and the colors of the
+ * words (`Drawn`), and with no color output there is nothing for it to
  * change. A glyph effect needs none of that, and is written at every depth,
- * with no colour too. Over one element the two compose by nesting:
- * `new Effected(new GlyphEffected(child, glyphs, …), colours, …)` moves the
- * colours of the glyphs the glyph effect left, since each wrapper measures
+ * with no color too. Over one element the two compose by nesting:
+ * `new Effected(new GlyphEffected(child, glyphs, …), colors, …)` moves the
+ * colors of the glyphs the glyph effect left, since each wrapper measures
  * what its child drew.
  *
  * A `GlyphEffected` is the element under its glyph effect over time, an
@@ -51,7 +51,7 @@
  * Positions are the child's own: row and column count from the top-left of
  * what the child drew.
  */
-import { Animation, type Moves } from "../core/animation.js";
+import { Animation, type Reads } from "../core/animation.js";
 import type { Measurable, Renderable, RenderOptions } from "../core/protocol.js";
 import { Segment } from "../core/segment.js";
 import { type RichText } from "../core/text.js";
@@ -85,7 +85,7 @@ export interface DrawnGlyphs {
 }
 /**
  * For an element drawing `drawn`, the animation of what is done to its
- * glyphs. Its `nextChange` is when the frame next changes, as an `Effect`'s is.
+ * glyphs. Its `validUntil` is when the frame next changes, as an `Effect`'s is.
  */
 export type GlyphEffect = (drawn: DrawnGlyphs) => Animation<GlyphFrame>;
 export interface GlyphEffectedOptions {
@@ -96,7 +96,7 @@ export interface GlyphEffectedOptions {
  * A `GlyphEffected` at `t`, or an element through a glyph effect at a time an
  * animation's `at` was handed: `renderable` with its cells' glyphs passed
  * through `effect` at `t`, telling the hold it drew in as a `Recolored` does
- * (`RenderOptions.onMoved`, `./effect.ts`). [LAW:one-type-per-behavior]
+ * (`RenderOptions.onReads`, `./effect.ts`). [LAW:one-type-per-behavior]
  */
 export declare class Reglyphed implements Renderable, Measurable {
     readonly renderable: Renderable;
@@ -117,7 +117,7 @@ export declare class Reglyphed implements Renderable, Measurable {
  * as an `Effected` is (`./effect.ts`): with nothing drawn its answer is `t`,
  * and placed, on its own or as a part of any combinator, it says the glyph
  * effect's exact hold at that time and the output's `asciiOnly`, which the
- * frame's drawing told (`Moves`).
+ * frame's drawing told (`Reads`).
  */
 export declare class GlyphEffected implements Animation<Renderable> {
     readonly renderable: Renderable;
@@ -126,8 +126,8 @@ export declare class GlyphEffected implements Animation<Renderable> {
     constructor(renderable: Renderable, effect: GlyphEffect, options: GlyphEffectedOptions);
     /** The element through the glyph effect at `t`, unstamped. */
     at(t: number): Reglyphed;
-    nextChange(t: number, moves?: Moves): number;
-    lastChange(t: number, moves?: Moves): number;
+    validUntil(t: number, moves?: Reads): number;
+    validFrom(t: number, moves?: Reads): number;
     /** The element under the glyph effect with its motion taken out. */
     reduced(): GlyphEffected;
     /** Drawn at the frame's time, its cells stamped with the glyph effect's exact hold there. */

package/dist/renderables/glyph-effect.js

@@ -3,8 +3,8 @@
  * glyph effect at a moment `t`: the glyph half of `Effected` (`./effect.ts`),
  * built to its contract.
  *
- * A glyph effect is the colour effect's two-stage shape with a glyph where
- * the colours were: for the cells an element draws in a frame, an
+ * A glyph effect is the color effect's two-stage shape with a glyph where
+ * the colors were: for the cells an element draws in a frame, an
  * `Animation` (`../core/animation.ts`) of what is done to them. The first
  * stage is handed every cell once a frame (`GlyphCell`), blanks included —
  * rain and stars live there — and whether the output draws ASCII alone
@@ -14,15 +14,15 @@
  * scramble, a wave of case changes and particles on blank cells are all this
  * one shape (`./glyph-effects.ts`) [LAW:one-type-per-behavior].
  *
- * Colour and glyph are not two kinds of animation: each is an `Animation` of
+ * Color and glyph are not two kinds of animation: each is an `Animation` of
  * a per-cell map, and they differ only in what a cell is mapped to. The
- * wrappers are two because the stages are handed different facts. A colour
- * effect is settled against the depth, the terminal and the colours of the
- * words (`Drawn`), and with no colour output there is nothing for it to
+ * wrappers are two because the stages are handed different facts. A color
+ * effect is settled against the depth, the terminal and the colors of the
+ * words (`Drawn`), and with no color output there is nothing for it to
  * change. A glyph effect needs none of that, and is written at every depth,
- * with no colour too. Over one element the two compose by nesting:
- * `new Effected(new GlyphEffected(child, glyphs, …), colours, …)` moves the
- * colours of the glyphs the glyph effect left, since each wrapper measures
+ * with no color too. Over one element the two compose by nesting:
+ * `new Effected(new GlyphEffected(child, glyphs, …), colors, …)` moves the
+ * colors of the glyphs the glyph effect left, since each wrapper measures
  * what its child drew.
  *
  * A `GlyphEffected` is the element under its glyph effect over time, an
@@ -58,13 +58,13 @@ import { render } from "../core/protocol.js";
 import { Segment } from "../core/segment.js";
 import { finiteTime } from "../core/easing.js";
 import { sanitized } from "../core/text.js";
-import { cellSeed, holdOver, walkGlyphs } from "./effect.js";
+import { cellSeed, validityOver, walkGlyphs } from "./effect.js";
 import { pattern } from "../core/pattern.js";
 /**
  * A `GlyphEffected` at `t`, or an element through a glyph effect at a time an
  * animation's `at` was handed: `renderable` with its cells' glyphs passed
  * through `effect` at `t`, telling the hold it drew in as a `Recolored` does
- * (`RenderOptions.onMoved`, `./effect.ts`). [LAW:one-type-per-behavior]
+ * (`RenderOptions.onReads`, `./effect.ts`). [LAW:one-type-per-behavior]
  */
 export class Reglyphed {
     renderable;
@@ -83,7 +83,7 @@ export class Reglyphed {
         const animation = this.effect({ cells, asciiOnly: options.asciiOnly === true });
         const frame = shownAt(animation, this._t, options);
         const shown = showGlyphs(placed, frame.value);
-        options.onMoved?.(this._t, this.key, holdOver(cells.length > 0, frame, this._t));
+        options.onReads?.(this._t, this.key, validityOver(cells.length > 0, frame, this._t));
         return segments.map((segment, i) => (shown[i].every((text, j) => text === placed[i][j].glyph) ? segment : new Segment(shown[i].join(""), segment.style)));
     }
     measure(options) {
@@ -95,7 +95,7 @@ export class Reglyphed {
  * as an `Effected` is (`./effect.ts`): with nothing drawn its answer is `t`,
  * and placed, on its own or as a part of any combinator, it says the glyph
  * effect's exact hold at that time and the output's `asciiOnly`, which the
- * frame's drawing told (`Moves`).
+ * frame's drawing told (`Reads`).
  */
 export class GlyphEffected {
     renderable;
@@ -110,11 +110,11 @@ export class GlyphEffected {
     at(t) {
         return new Reglyphed(this.renderable, this.effect, { t, key: this.key });
     }
-    nextChange(t, moves) {
-        return moves?.(t, this.key)?.nextChange ?? t;
+    validUntil(t, moves) {
+        return moves?.(t, this.key)?.validUntil ?? t;
     }
-    lastChange(t, moves) {
-        return moves?.(t, this.key)?.lastChange ?? t;
+    validFrom(t, moves) {
+        return moves?.(t, this.key)?.validFrom ?? t;
     }
     /** The element under the glyph effect with its motion taken out. */
     reduced() {

package/dist/renderables/glyph-effects.d.ts

@@ -3,15 +3,15 @@
  * are done, each with its way out for an element leaving (`backspace`,
  * `scrambleOut`), and a wave of case changes, rain, stars and marching ants,
  * which loop for as long as they are drawn. Each is a `GlyphEffect` for
- * `GlyphEffected` (`./glyph-effect.ts`), built as the colour catalogue's are
+ * `GlyphEffected` (`./glyph-effect.ts`), built as the color catalogue's are
  * (`./effects.ts`): one function each over the one shape, at the defaults in
  * `GLYPH_DEFAULTS`. `GLYPH_EFFECT_CATALOGUE` makes by name those a template's
  * `glyphs` takes.
  *
- * Where a colour loop glides, a glyph cannot: a cell shows one glyph or
+ * Where a color loop glides, a glyph cannot: a cell shows one glyph or
  * another, so every loop here moves in steps, on a `beat`, and says when its
  * next step is. The transitions are `Transition`s by the one rule the
- * colour transitions follow (`transition`): they move every frame until
+ * color transitions follow (`transition`): they move every frame until
  * their seconds are up, and never after.
  *
  * [LAW:no-ambient-temporal-coupling] No effect reads a clock, and what a cell
@@ -113,19 +113,19 @@ export type GlyphTransitionName = "typewriter" | "scramble" | "backspace" | "scr
 export declare const GLYPH_DEFAULTS: {
     readonly typewriter: {
         readonly seconds: 2;
-        readonly ease: import("../core/easing.js").Ease;
+        readonly ease: import("../core/easing.js").Easing;
     };
     readonly scramble: {
         readonly seconds: 2.5;
-        readonly ease: import("../core/easing.js").Ease;
+        readonly ease: import("../core/easing.js").Easing;
     };
     readonly backspace: {
         readonly seconds: 1.5;
-        readonly ease: import("../core/easing.js").Ease;
+        readonly ease: import("../core/easing.js").Easing;
     };
     readonly scrambleOut: {
         readonly seconds: 2.5;
-        readonly ease: import("../core/easing.js").Ease;
+        readonly ease: import("../core/easing.js").Easing;
     };
     readonly wave: {
         readonly step: 0.06;

package/dist/renderables/glyph-effects.js

@@ -3,15 +3,15 @@
  * are done, each with its way out for an element leaving (`backspace`,
  * `scrambleOut`), and a wave of case changes, rain, stars and marching ants,
  * which loop for as long as they are drawn. Each is a `GlyphEffect` for
- * `GlyphEffected` (`./glyph-effect.ts`), built as the colour catalogue's are
+ * `GlyphEffected` (`./glyph-effect.ts`), built as the color catalogue's are
  * (`./effects.ts`): one function each over the one shape, at the defaults in
  * `GLYPH_DEFAULTS`. `GLYPH_EFFECT_CATALOGUE` makes by name those a template's
  * `glyphs` takes.
  *
- * Where a colour loop glides, a glyph cannot: a cell shows one glyph or
+ * Where a color loop glides, a glyph cannot: a cell shows one glyph or
  * another, so every loop here moves in steps, on a `beat`, and says when its
  * next step is. The transitions are `Transition`s by the one rule the
- * colour transitions follow (`transition`): they move every frame until
+ * color transitions follow (`transition`): they move every frame until
  * their seconds are up, and never after.
  *
  * [LAW:no-ambient-temporal-coupling] No effect reads a clock, and what a cell
@@ -22,7 +22,7 @@
  */
 import { Animation } from "../core/animation.js";
 import { cellLen, graphemes } from "../core/cells.js";
-import { EASES, Phase, beat, positiveSeconds, settled } from "../core/easing.js";
+import { EASES, WrapMode, stepSequence, positiveSeconds, withSettlingTime } from "../core/easing.js";
 import { hash } from "../core/noise.js";
 import { drawable, isAscii } from "../core/protocol.js";
 import { inked } from "./effect.js";
@@ -67,11 +67,11 @@ function arrived(n, p) {
  * the change shows. The beat is made once, for every frame drawn on it.
  */
 function stepped(seconds) {
-    const pace = beat([seconds]);
+    const pace = stepSequence([seconds]);
     return (frame, still) => Animation.of({
-        at: (t) => frame(Math.round(pace.lastChange(t) / seconds)),
-        nextChange: (t) => pace.nextChange(t),
-        lastChange: (t) => pace.lastChange(t),
+        at: (t) => frame(Math.round(pace.validFrom(t) / seconds)),
+        validUntil: (t) => pace.validUntil(t),
+        validFrom: (t) => pace.validFrom(t),
         reduced: () => Animation.constant(still),
     });
 }
@@ -85,9 +85,9 @@ const AS_WRITTEN = (cell) => cell.glyph;
  * with are not text, so no second is spent on them.
  */
 export function typewriter(timing) {
-    const phase = Phase.once(0, timing.seconds);
+    const phase = WrapMode.once(0, timing.seconds);
     // Settled, so the last cell is typed at the seconds whatever ease was handed.
-    const ease = settled(timing.ease);
+    const ease = withSettlingTime(timing.ease);
     return transition(timing.seconds, ({ cells }) => {
         const { length, place } = text(cells);
         return Animation.continuous((t) => {
@@ -110,9 +110,9 @@ const FLICKER = 1 / 15;
  */
 export function scramble(timing, z) {
     requireZ("scramble", z);
-    const phase = Phase.once(0, timing.seconds);
+    const phase = WrapMode.once(0, timing.seconds);
     // Settled, so the last cell resolves at the seconds whatever ease was handed.
-    const ease = settled(timing.ease);
+    const ease = withSettlingTime(timing.ease);
     const flicker = stepped(FLICKER)((step) => step, 0);
     return transition(timing.seconds, ({ cells }) => {
         const { length, place } = text(cells);
@@ -134,9 +134,9 @@ function churned(cell, z, step) {
  * element ends blank and nothing is left to vanish when it goes.
  */
 export function backspace(timing) {
-    const phase = Phase.once(0, timing.seconds);
+    const phase = WrapMode.once(0, timing.seconds);
     // Settled, so the first cell is erased at the seconds whatever ease was handed.
-    const ease = settled(timing.ease);
+    const ease = withSettlingTime(timing.ease);
     return transition(timing.seconds, ({ cells }) => {
         const { length, place } = text(cells);
         return Animation.continuous((t) => {
@@ -156,9 +156,9 @@ const CHURN = 0.3;
  */
 export function scrambleOut(timing, z) {
     requireZ("scrambleOut", z);
-    const phase = Phase.once(0, timing.seconds);
+    const phase = WrapMode.once(0, timing.seconds);
     // Settled, so the last cell is blank at the seconds whatever ease was handed.
-    const ease = settled(timing.ease);
+    const ease = withSettlingTime(timing.ease);
     const flicker = stepped(FLICKER)((step) => step, 0);
     return transition(timing.seconds, ({ cells }) => {
         const { length, place } = text(cells);

package/dist/renderables/html-entities.d.ts

@@ -5,4 +5,4 @@
  * `html.entities.html5`; regenerate rather than edit.
  */
 /** The characters `name`, a reference's name without its `&` and `;`, stands for, if it names any. */
-export declare function namedReference(name: string): string | undefined;
+export declare function namedCharacterReference(name: string): string | undefined;

package/dist/renderables/html-entities.js

@@ -380,7 +380,7 @@ const NAMED_REFERENCES = {
     zwnj: "\u200c",
 };
 /** The characters `name`, a reference's name without its `&` and `;`, stands for, if it names any. */
-export function namedReference(name) {
+export function namedCharacterReference(name) {
     // An own key only: `constructor` names nothing here, whatever the prototype holds.
     return Object.hasOwn(NAMED_REFERENCES, name) ? NAMED_REFERENCES[name] : undefined;
 }

package/dist/renderables/lifecycle.d.ts

@@ -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
@@ -57,9 +57,9 @@ import type { GlyphTransition } from "./glyph-effects.js";
  * `throughColors` and `throughGlyphs` lend one the transition's schedule.
  */
 export type Half = (element: Renderable, key: string) => Animation<Renderable>;
-/** `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 declare function throughColors(transition: Transition): Half;
-/** `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 declare function throughGlyphs(transition: GlyphTransition): Half;
 /** How an element arrives and leaves, and what it is named for their seeds. */
 export interface LifecycleOptions {