@promptctl/rich-js 0.24.1 → 0.25.1

package/dist/core/strip.js

@@ -39,41 +39,11 @@ import { drawable, getStyle, isAscii, render } from "./protocol.js";
  * not draw at all. An effect reads it to leave a seam out of the words it
  * keeps legible (`drawnOf`, `../renderables/effect.ts`).
  *
- * Inside it, every cell a `CellJoiner` draws names whose colour each of its
- * two sides shows (`colorsOwnedBy`). One seam cell can show two neighbours —
- * a powerline arrow is inked in the fill it points out of, over the fill it
- * points into — so a cell has no single owner; each side has one.
+ * Inside it, every cell a `CellJoiner` draws is stamped with what it was
+ * resolved from (`JoinedCell`), so a cell whose neighbours an effect moves is
+ * resolved again from where they moved to.
  */
 export const JOIN = Object.freeze({ name: "join" });
-/**
- * Whose colour each side of a join cell shows on screen, its ink and its
- * ground: the neighbour whose edge a `Paint` names, or `null` for a role, a
- * mix or the terminal's ground, which are no neighbour's.
- */
-class ColorOwners {
-    fg;
-    bg;
-    constructor(fg, bg) {
-        this.fg = fg;
-        this.bg = bg;
-    }
-}
-/**
- * Which of a cell's two colours on screen are one of `owners`': both, for a
- * cell one of them drew, itself or through an owner nested in its output; for
- * a cell a `CellJoiner` drew, the sides shown in one of their colours.
- */
-export function colorsOwnedBy(anchor, owners) {
-    for (let level = anchor; level; level = level.inner) {
-        if (owners.has(level.owner))
-            return { fg: true, bg: true };
-        if (level.owner instanceof ColorOwners) {
-            const { fg, bg } = level.owner;
-            return { fg: fg !== null && owners.has(fg), bg: bg !== null && owners.has(bg) };
-        }
-    }
-    return { fg: false, bg: false };
-}
 /**
  * [LAW:single-enforcer] What `joiner` draws at one join, every cell stamped
  * as `JOIN`'s: the one way `Strip` and `FlexStrip` draw a join.
@@ -131,10 +101,6 @@ export class Strip {
         // of which renderables end their own line and which are fragments.
         yield Segment.line();
     }
-    // The items; a join is drawn from what the joiner emits for it, not held.
-    contents() {
-        return this.items;
-    }
     /**
      * [LAW:one-source-of-truth] The width of the one row it draws, and that is
      * both bounds: the row never wraps and no item is offered less than the whole
@@ -149,12 +115,12 @@ export class Strip {
         return { minimum: width, maximum: width };
     }
 }
-const PARTS = ["seam", "divider", "lead", "tail"];
+const PARTS = ["seam", "lead", "tail"];
 /**
- * The least ΔE_OK a seam cell's ink must differ from its own ground by for the
- * seam to be seen. Below it the eye cannot tell the ink from the ground,
- * so the joiner draws the divider instead. Twice the ~.02 threshold of a visible difference, because a seam is
- * one cell wide.
+ * The least ΔE_OK a join cell's ink must stand off its own ground by to be
+ * seen. Below it the eye cannot tell the ink from the ground, so the joiner
+ * lifts the ink to it (`standOff`). Twice the ~.02 threshold of a visible
+ * difference, because a seam is one cell wide.
  */
 export const SEAM_MIN_DELTA_E = 0.04;
 function* paintsIn(paint) {
@@ -174,7 +140,6 @@ const pickGlyph = (cell, part, index, at) => {
     return glyphs[Math.floor((parseInt(fnv1a(`${part}:${index}:${at}`), 16) / 2 ** 32) * glyphs.length)];
 };
 const cellWidth = (cell) => cellLen(glyphsOf(cell)[0] ?? "");
-const partWidth = (cells) => cells.reduce((width, cell) => width + cellWidth(cell), 0);
 // `raw` as a `Paint`, or refused. `absent` is the neighbour this part may not
 // name, because the part is also drawn where that neighbour does not exist.
 function parsePaint(raw, absent, refuse) {
@@ -197,9 +162,9 @@ function parsePaint(raw, absent, refuse) {
     return refuse(`has a colour that is not a Paint: ${JSON.stringify(raw)}`);
 }
 const parseColor = (raw, absent, refuse) => raw === "ground" ? raw : parsePaint(raw, absent, refuse);
-const ABSENT = { seam: undefined, divider: undefined, lead: "left", tail: "right" };
+const ABSENT = { seam: undefined, lead: "left", tail: "right" };
 // Which argument of a joiner a part is authored in, so a refusal names it.
-const AUTHORED_IN = { seam: "seam", divider: "seam", lead: "caps", tail: "caps" };
+const AUTHORED_IN = { seam: "seam", lead: "caps", tail: "caps" };
 function parseCell(cell, form, part, refuse) {
     const glyph = cell.glyph;
     const oneOf = typeof glyph === "object" && glyph !== null ? glyph.oneOf : undefined;
@@ -247,14 +212,6 @@ const asSeamCell = (form, part) => (cell, refuse) => {
         refuse("names a cap and draws cells of its own; a cell is one or the other");
     return cap === "lead" || cap === "tail" ? Object.freeze({ cap }) : refuse(`names a cap that is neither lead nor tail: ${JSON.stringify(cap)}`);
 };
-// A seam's width as a sum over whatever caps stand in it: its own cells', and
-// how many times it names each cap. Two parts equal in all three are the same
-// width under every caps.
-const seamWidth = (cells) => [
-    partWidth(cells.filter((cell) => !("cap" in cell))),
-    cells.filter((cell) => "cap" in cell && cell.cap === "lead").length,
-    cells.filter((cell) => "cap" in cell && cell.cap === "tail").length,
-];
 /**
  * [LAW:parse-dont-validate] The one place a seam is checked, so every rule
  * the cell model states is refused at construction and the render reads cells
@@ -263,16 +220,7 @@ const seamWidth = (cells) => [
  * back is a frozen copy the caller can no longer change.
  */
 function parseSeam(raw) {
-    const parseForm = (form) => {
-        const seam = parseCells(raw, form, "seam", asSeamCell(form, "seam"));
-        // A divider authored as the seam itself stays the seam, so a render can see
-        // it has no choice to make.
-        const divider = raw[form].divider === raw[form].seam ? seam : parseCells(raw, form, "divider", asSeamCell(form, "divider"));
-        const [seamAt, dividerAt] = [seamWidth(seam), seamWidth(divider)];
-        if (seamAt.some((n, i) => n !== dividerAt[i]))
-            throw new Error(`seam: ${form} divider is not the width of the seam under every caps`);
-        return Object.freeze({ seam, divider });
-    };
+    const parseForm = (form) => Object.freeze({ seam: parseCells(raw, form, "seam", asSeamCell(form, "seam")) });
     return Object.freeze({ glyph: parseForm("glyph"), ascii: parseForm("ascii") });
 }
 /** [LAW:parse-dont-validate] `parseSeam`'s twin for the caps. */
@@ -282,21 +230,22 @@ function parseCaps(raw) {
 }
 // One form of the seam joined with that form of the caps.
 function joinForms(seam, caps) {
-    const splice = (cells) => cells.flatMap((cell) => ("cap" in cell ? caps[cell.cap] : [cell]));
-    const seamCells = splice(seam.seam);
-    return { seam: seamCells, divider: seam.divider === seam.seam ? seamCells : splice(seam.divider), lead: caps.lead, tail: caps.tail };
+    return { seam: seam.seam.flatMap((cell) => ("cap" in cell ? caps[cell.cap] : [cell])), lead: caps.lead, tail: caps.tail };
 }
+// The parts of `side`'s edge `cell` paints with: its ground (`bg`), its text (`fg`).
+const partsRead = (cell, side) => new Set([cell.fg, cell.bg].flatMap((color) => (color === "ground" ? [] : [...paintsIn(color)].flatMap((p) => ("edge" in p && p.edge === side ? [p.part] : [])))));
 // Whether any of `cells` paints with `side`'s ground.
 const readsGround = (cells, side) => cells.some((cell) => [cell.fg, cell.bg].some((color) => color !== "ground" && [...paintsIn(color)].some((p) => "edge" in p && p.edge === side && p.part === "bg")));
 function formOf(shape) {
-    const between = [...shape.seam, ...shape.divider];
+    const cells = (part) => shape[part].map((cell) => ({ cell, parts: { left: partsRead(cell, "left"), right: partsRead(cell, "right") } }));
     return {
         shape,
         reads: {
-            seam: { left: readsGround(between, "left"), right: readsGround(between, "right") },
+            seam: { left: readsGround(shape.seam, "left"), right: readsGround(shape.seam, "right") },
             lead: readsGround(shape.lead, "right"),
             tail: readsGround(shape.tail, "left"),
         },
+        cells: { seam: cells("seam"), lead: cells("lead"), tail: cells("tail") },
     };
 }
 // A bg with a real colour to paint. `undefined` (no bg) and the terminal
@@ -312,29 +261,82 @@ function paintableBg(bg) {
 function drawnGround(bg) {
     return bg.flattenAlpha(SURFACE_BLACK);
 }
-// A cell whose ink the eye cannot tell from its ground, read off the style it
-// is drawn in. What is measured is what is drawn — `Style.drawnColors`, the
-// colours the writer encodes: the ink flattened onto the cell's own ground and
-// the ground onto the terminal's black, both downgraded to the depth the
-// render encodes at, so two colours that depth rounds to one entry are the one
-// entry they render as. A colour whose RGB is the terminal theme's own (ANSI
-// 0–15, a blend reaching one) has no value here, so two of them are the same
-// only when they are one expression: the same palette slot — its `number`,
-// never the name or the depth that spells it ("red", "color(1)", an EIGHT_BIT
-// spec on 0–15 are one slot) — or the same blend, whose name spells each end
-// by its slot for the same reason. A cell on the terminal's ground, or in
-// reverse video over it, has a colour nobody knows on one side, and is seen.
-function vanishes(style, colorSystem) {
-    if (style.reverse)
-        return false;
-    const { color, bgcolor } = style.drawnColors(colorSystem ?? ColorDepth.TRUECOLOR);
-    if (color === undefined || bgcolor === undefined)
-        return false;
-    const av = color.fixedValue;
-    const bv = bgcolor.fixedValue;
-    return av !== undefined && bv !== undefined
-        ? Oklch.fromRgba(av).deltaE(Oklch.fromRgba(bv)) < SEAM_MIN_DELTA_E
-        : color.number !== undefined ? color.number === bgcolor.number : color.name === bgcolor.name;
+// Whether ink stands off its ground, both as a depth draws them, by the floor a
+// seam is seen at. A colour whose RGB is the terminal theme's own (ANSI 0–15, a
+// blend reaching one) has no value here, so two of them stand apart unless they
+// are one expression: the same palette slot — its `number`, never the name or
+// the depth that spells it ("red", "color(1)", an EIGHT_BIT spec on 0–15 are
+// one slot) — or the same blend, whose name spells each end by its slot for the
+// same reason. At sixteen colours, then, the floor is a different slot. The
+// terminal's default colour is nobody's to measure, and stands apart.
+function standsOff(ink, ground) {
+    if (ink.isDefault || ground.isDefault)
+        return true;
+    const [a, b] = [ink.fixedValue, ground.fixedValue];
+    return a !== undefined && b !== undefined
+        ? Oklch.fromRgba(a).deltaE(Oklch.fromRgba(b)) >= SEAM_MIN_DELTA_E
+        : ink.number !== undefined ? ink.number !== ground.number : ink.name !== ground.name;
+}
+// A step along a lightness ray: finer than the steps between the colours a
+// truecolor writer draws, so the walk passes over none of them.
+const LIFT_STEP = 0.001;
+// The steps along `origin`'s lightness ray, its chroma and hue held, in the
+// order the lift tries them: the smaller move first, and at an equal move the
+// lighter, out to black and to white.
+function* lightnessRay(origin) {
+    for (let k = 1; k * LIFT_STEP <= 1; k++) {
+        for (const l of [origin.l + k * LIFT_STEP, origin.l - k * LIFT_STEP]) {
+            if (l >= 0 && l <= 1)
+                yield new Oklch(l, origin.c, origin.h);
+        }
+    }
+}
+/**
+ * `ink`, a glyph's colour on `ground`, held at least `SEAM_MIN_DELTA_E` off it
+ * as `depth` draws both (`Style.drawnColors`). Ink that already stands off is
+ * returned as it is. Ink that does not becomes the drawn form of the nearest
+ * step along its own OKLCH lightness ray, chroma and hue held, that stands off:
+ * the smaller step, toward white or toward black. Every step is measured as the
+ * depth draws it, so at 256 colours and at sixteen the candidates are the
+ * entries the depth draws, and the side the ink moves to can differ between
+ * depths. A floor measured on rounded colours is not monotone along a ray, so
+ * the walk enumerates and never bisects. A side with no colour to measure is
+ * left alone.
+ *
+ * [LAW:one-source-of-truth] The colour returned is the one measured — the
+ * entry the depth draws, not the step that rounds to it — so a reader of the
+ * cell at another depth (an export reads a recording in truecolor) sees the
+ * colour that cleared the floor, never a step one unit off its ground.
+ *
+ * [LAW:single-enforcer] The one place a join cell's visibility is decided:
+ * nothing outside the joiner predicts whether a seam will show.
+ */
+function standOff(ink, ground, depth) {
+    if (ink === undefined || ground === undefined)
+        return ink;
+    const drawn = (color, at) => new Style({ color, bgcolor: ground }).drawnColors(at);
+    const { color: shown, bgcolor: under } = drawn(ink, depth);
+    if (standsOff(shown, under))
+        return ink;
+    // The ray starts from the ink as it is laid on its ground, before a depth
+    // rounds it; ink the terminal's theme draws starts from the colour the
+    // default terminal theme gives it. Ink that vanishes is drawn in the same
+    // kind as its ground — both fixed, or both the theme's — and every step is
+    // drawn in that kind too, so it is measured as the ink was. Ink the depth
+    // draws as the theme's (a slot, or a mix reaching one at truecolor) steps
+    // between slots: an RGB beside a colour only the terminal knows could be
+    // that very colour. Ink the depth fixes (that same mix is a cube entry at
+    // 256) steps between fixed colours, for the same reason turned round.
+    const laid = drawn(ink).color;
+    const kind = shown.fixedValue === undefined ? ColorDepth.STANDARD : ColorDepth.TRUECOLOR;
+    for (const step of lightnessRay(Oklch.fromRgba(laid.getTruecolor()))) {
+        const candidate = drawn(ColorSpec.fromRgba(step.toRgba()).downgrade(kind), depth).color;
+        if (standsOff(candidate, under))
+            return candidate;
+    }
+    // [LAW:no-silent-failure] Unreachable: the ray runs out to black and to
+    // white, and no ground lies within the floor of both, nor is one slot both.
+    throw new Error(`no colour on the lightness ray of ${ink.name} stands off ${ground.name} at depth ${ColorDepth[depth]}`);
 }
 function resolvePaint(paint, edges, options) {
     if ("edge" in paint) {
@@ -352,14 +354,97 @@ function resolvePaint(paint, edges, options) {
     // A mix with no colour at one end has nothing to blend toward.
     return a && b && ColorSpec.blend(a, b, t);
 }
+// [LAW:single-enforcer] The one resolution of a join cell's paints: at join
+// time, and again whenever an effect moves the neighbours it reads
+// (`JoinedCell`).
 function cellStyle(cell, edges, options) {
     // [LAW:dataflow-not-control-flow] "ground" is the absence of a colour on its
     // side; as the fg it is reverse video over the bg colour, so the glyph's ink
     // is the terminal's own background.
     if (cell.fg === "ground")
         return new Style({ color: cell.bg === "ground" ? undefined : resolvePaint(cell.bg, edges, options), reverse: true });
-    const color = resolvePaint(cell.fg, edges, options);
-    return new Style({ color, bgcolor: cell.bg === "ground" ? undefined : resolvePaint(cell.bg, edges, options) });
+    const bgcolor = cell.bg === "ground" ? undefined : resolvePaint(cell.bg, edges, options);
+    // [LAW:dataflow-not-control-flow] Every cell's ink is held off its ground;
+    // the gap measured between them decides how far it moves, usually not at all.
+    return new Style({ color: standOff(resolvePaint(cell.fg, edges, options), bgcolor, options.colorSystem ?? ColorDepth.TRUECOLOR), bgcolor });
+}
+/**
+ * A cell a `CellJoiner` drew, as what it is: one function of its two
+ * neighbours' edges. It holds the cell's paints, the neighbour each side of
+ * them reads, and the edges and render it was resolved from, and it is stamped
+ * on the cell as the owner of its innermost anchor level.
+ *
+ * [LAW:one-source-of-truth] A seam's colours are its neighbours', so nothing
+ * paints them but this resolution. An effect paints a strip's items and never
+ * a join cell that `follows` them; once the items are painted, each such cell
+ * is handed what moved at the item cells beside it and resolved again through
+ * `cellStyle`, the path the join was drawn by, lift included
+ * (`../renderables/effect.ts`). A seam then follows its neighbours wherever an
+ * effect takes them, a mix of the two included, and an effect that paints
+ * both one colour leaves the seam's ink lifted off it. A cell painted from
+ * roles and the terminal's ground alone, as `plain`'s separator is, follows
+ * nobody, and an effect paints it as it paints any cell.
+ */
+export class JoinedCell {
+    cell;
+    parts;
+    neighbours;
+    edges;
+    options;
+    /** What the cell's paints read on each side: that neighbour and its edge as the cell was resolved from it, or `null` for a side they read nothing of. */
+    reads;
+    /** Whether the cell's paints read either neighbour, so it follows them under an effect. */
+    follows;
+    /** The cell as drawn from its edges: the one resolution, at join time and after an effect alike. */
+    style;
+    constructor(cell, parts, neighbours, edges, options) {
+        this.cell = cell;
+        this.parts = parts;
+        this.neighbours = neighbours;
+        this.edges = edges;
+        this.options = options;
+        const read = (side) => {
+            if (parts[side].size === 0)
+                return null;
+            const [owner, edge] = [neighbours[side], edges[side]];
+            // [LAW:no-silent-failure] Unreachable: a join draws a part only beside
+            // the neighbours its cells may name: a cap naming the one it is drawn
+            // without is refused when parsed (`parsePaint`).
+            if (owner === null || edge === undefined)
+                throw new Error(`a join cell paints with its ${side} neighbour's edge, and the join has no ${side} neighbour`);
+            return { owner, edge };
+        };
+        this.reads = { left: read("left"), right: read("right") };
+        this.follows = this.reads.left !== null || this.reads.right !== null;
+        this.style = cellStyle(cell, edges, options);
+    }
+    /**
+     * The cell resolved again once each side's edge has moved as `moves` says:
+     * its `colors`, as `cellStyle` draws them, and `style`, the cell's own, with
+     * the record of that stamped where this one was, so an effect drawn over
+     * this one moves on from these edges. Resolved, lift included, at `depth`,
+     * the depth the effect writes the frame at. None when nothing moved of what
+     * the cell paints with: a seam of arrows in two grounds is as it was drawn
+     * while an effect moves only the lettering beside it, and its lift is not
+     * walked again for a frame that cannot change it.
+     */
+    rederived(moves, style, depth) {
+        const reaches = (side) => (moves[side]?.color !== undefined && this.parts[side].has("fg")) || (moves[side]?.bgcolor !== undefined && this.parts[side].has("bg"));
+        if (!reaches("left") && !reaches("right"))
+            return undefined;
+        const moved = (edge, move) => move === undefined ? edge : new Style({ color: move.color ?? edge?.color, bgcolor: move.bgcolor ?? edge?.bgcolor });
+        const edges = { left: moved(this.edges.left, moves.left), right: moved(this.edges.right, moves.right) };
+        const next = new JoinedCell(this.cell, this.parts, this.neighbours, edges, { ...this.options, colorSystem: depth });
+        const restamp = (level) => ({ ...level, owner: level.owner === this ? next : level.owner, inner: level.inner && restamp(level.inner) });
+        return { colors: next.style, style: style.withAnchor(style.anchor && restamp(style.anchor)) };
+    }
+}
+/** The record a `CellJoiner` stamped on the cell `anchor` names, or none for a cell no `CellJoiner` drew. */
+export function joinedCell(anchor) {
+    for (let level = anchor; level; level = level.inner)
+        if (level.owner instanceof JoinedCell)
+            return level.owner;
+    return undefined;
 }
 const shapeGlyphs = (shape) => PARTS.flatMap((part) => shape[part].flatMap(glyphsOf)).join("");
 /**
@@ -370,9 +455,10 @@ const shapeGlyphs = (shape) => PARTS.flatMap((part) => shape[part].flatMap(glyph
  * Which part a join draws is read off its two neighbours. A neighbour is
  * missing at the strip's ends, and counts as missing — an endpoint — when the
  * seam paints with its ground anywhere and it has none to paint. With both
- * present the join is the seam, or the divider where every seam cell's ink is
- * drawn indistinct from its ground at `options.colorSystem`; with only the
- * right, the lead; with only the left, the tail; with neither, nothing. A cap
+ * present the join is the seam; with only the right, the lead; with only the
+ * left, the tail; with neither, nothing. Every cell is drawn with its ink held
+ * off its ground at `options.colorSystem` (`standOff`), measured per cell, so a
+ * seam stepping in thirds shows every step however close its grounds. A cap
  * that paints with its neighbour's ground is drawn only beside a neighbour
  * with one, so caps that need grounds never stop a seam that needs none.
  *
@@ -391,7 +477,7 @@ export class CellJoiner {
         const forms = this._forms;
         return {
             *render(options) {
-                const { shape: drawn, reads } = drawable(options, forms.glyph, forms.ascii, (form) => shapeGlyphs(form.shape));
+                const { cells, reads } = drawable(options, forms.glyph, forms.ascii, (form) => shapeGlyphs(form.shape));
                 const edges = { left: left?.edgeStyle("right", options), right: right?.edgeStyle("left", options) };
                 const leftBg = paintableBg(edges.left?.bgcolor);
                 const rightBg = paintableBg(edges.right?.bgcolor);
@@ -400,25 +486,16 @@ export class CellJoiner {
                 const leads = hasRight && (!reads.lead || rightBg !== undefined);
                 const tails = hasLeft && (!reads.tail || leftBg !== undefined);
                 const neighbours = { left, right };
-                // On screen a cell's ink is its `fg` paint and its ground its `bg`,
-                // reverse video or not (`cellStyle`).
-                const ownerOf = (color) => (color !== "ground" && "edge" in color ? neighbours[color.edge] : null);
-                const styled = (part) => drawn[part].map((cell, at) => {
-                    const owners = new ColorOwners(ownerOf(cell.fg), ownerOf(cell.bg));
-                    return new Segment(pickGlyph(cell, part, index, at), cellStyle(cell, edges, options).withAnchor({ owner: owners, row: 0, col: 0, inner: undefined }));
+                const styled = (part) => cells[part].map(({ cell, parts }, at) => {
+                    const joined = new JoinedCell(cell, parts, neighbours, edges, options);
+                    return new Segment(pickGlyph(cell, part, index, at), joined.style.withAnchor({ owner: joined, row: 0, col: 0, inner: undefined }));
                 });
                 if (!hasLeft || !hasRight) {
                     if (leads || tails)
                         yield* styled(leads ? "lead" : "tail");
                     return;
                 }
-                // A seam is lost only when every cell of it is: one cell rounded into
-                // its ground at a shallow depth still leaves the others to show the
-                // step, and measuring per cell, not across the two grounds, divides a
-                // seam stepping in thirds where each third would not be seen.
-                const seam = styled("seam");
-                const lost = drawn.divider !== drawn.seam && seam.every((segment) => segment.style !== undefined && vanishes(segment.style, options.colorSystem));
-                yield* lost ? styled("divider") : seam;
+                yield* styled("seam");
             },
         };
     }
@@ -432,52 +509,35 @@ const GROUND = "ground";
 const LEAD = { cap: "lead" };
 const TAIL = { cap: "tail" };
 const both = (glyph, ascii) => ({ glyph, ascii });
-const POWERLINE = { glyph: "\ue0b0", thin: "\ue0b1", ascii: ">", asciiThin: ">" };
-const SLANT = { glyph: "\ue0bc", thin: "\ue0bd", ascii: "/", asciiThin: "/" };
-const BACKSLANT = { glyph: "\ue0b8", thin: "\ue0b9", ascii: "\\", asciiThin: "\\" };
-const FLAME = { glyph: "\ue0c0", thin: "\ue0c1", ascii: "}", asciiThin: "}" };
-const PIXEL = { glyph: "\ue0c4", thin: "\ue0b1", ascii: "#", asciiThin: ">" };
-const ICE = { glyph: "\ue0c8", thin: "\ue0b1", ascii: "]", asciiThin: ">" };
-const BUBBLE = { glyph: "\ue0b4", thin: "\ue0b5", ascii: ")", asciiThin: ")" };
-// `glyph` in the left ground over the right; divided by `thin` in the left
-// item's text.
-const arrow = (glyph, thin) => ({
-    seam: [{ glyph, fg: LEFT_BG, bg: RIGHT_BG }],
-    divider: [{ glyph: thin, fg: LEFT_FG, bg: LEFT_BG }],
-});
-const arrowSeam = (f) => both(arrow(f.glyph, f.thin), arrow(f.ascii, f.asciiThin));
+const POWERLINE = { glyph: "\ue0b0", ascii: ">" };
+const SLANT = { glyph: "\ue0bc", ascii: "/" };
+const BACKSLANT = { glyph: "\ue0b8", ascii: "\\" };
+const FLAME = { glyph: "\ue0c0", ascii: "}" };
+const PIXEL = { glyph: "\ue0c4", ascii: "#" };
+const ICE = { glyph: "\ue0c8", ascii: "]" };
+const BUBBLE = { glyph: "\ue0b4", ascii: ")" };
+// `glyph` in the left ground over the right.
+const arrow = (glyph) => ({ seam: [{ glyph, fg: LEFT_BG, bg: RIGHT_BG }] });
+const arrowSeam = (f) => both(arrow(f.glyph), arrow(f.ascii));
 // Three arrows stepping through the two thirds between the grounds.
-function prism(glyph, thin) {
+function prism(glyph) {
     const third = (t) => ({ mix: [LEFT_BG, RIGHT_BG, t] });
-    const pad = { glyph: " ", fg: LEFT_FG, bg: LEFT_BG };
     return {
         seam: [
             { glyph, fg: LEFT_BG, bg: third(1 / 3) },
             { glyph, fg: third(1 / 3), bg: third(2 / 3) },
             { glyph, fg: third(2 / 3), bg: RIGHT_BG },
         ],
-        divider: [pad, { glyph: thin, fg: LEFT_FG, bg: LEFT_BG }, pad],
     };
 }
 // The runs parted: the caps close the one and open the other, `between` —
 // cells on the terminal's ground — set between them.
-function parted(between) {
-    const seam = [TAIL, ...between, LEAD];
-    return { seam, divider: seam };
-}
+const parted = (between) => ({ seam: [TAIL, ...between, LEAD] });
 // One cell drawn over the two grounds' midpoint, so it reads as neither item's.
-function midpoint(glyph, fg) {
-    const seam = [{ glyph, fg, bg: HALF }];
-    return { seam, divider: seam };
-}
-// A ragged tear in the left ground over the midpoint; where that ink would
-// vanish into the midpoint — grounds a few steps apart, or one ground — the
-// same tear in the left item's text.
-function torn(glyphs) {
-    return { seam: midpoint({ oneOf: glyphs }, LEFT_BG).seam, divider: [{ glyph: { oneOf: glyphs }, fg: LEFT_FG, bg: HALF }] };
-}
-const PLAIN_SEAM = [{ glyph: " | ", fg: { role: "strip.separator" }, bg: GROUND }];
-const PLAIN = { seam: PLAIN_SEAM, divider: PLAIN_SEAM };
+const midpoint = (glyph, fg) => ({ seam: [{ glyph, fg, bg: HALF }] });
+// A ragged tear in the left ground over the midpoint.
+const torn = (glyphs) => midpoint({ oneOf: glyphs }, LEFT_BG);
+const PLAIN = { seam: [{ glyph: " | ", fg: { role: "strip.separator" }, bg: GROUND }] };
 const SPACE = { glyph: " ", fg: LEFT_FG, bg: GROUND };
 const rail = (glyph) => ({ glyph, fg: { role: "strip.rail" }, bg: GROUND });
 /**
@@ -487,7 +547,7 @@ const rail = (glyph) => ({ glyph, fg: { role: "strip.rail" }, bg: GROUND });
  */
 export const SEAMS = Object.freeze({
     powerline: parseSeam(arrowSeam(POWERLINE)),
-    prism: parseSeam(both(prism(POWERLINE.glyph, POWERLINE.thin), prism(POWERLINE.ascii, POWERLINE.asciiThin))),
+    prism: parseSeam(both(prism(POWERLINE.glyph), prism(POWERLINE.ascii))),
     slant: parseSeam(arrowSeam(SLANT)),
     backslant: parseSeam(arrowSeam(BACKSLANT)),
     flame: parseSeam(arrowSeam(FLAME)),
@@ -572,12 +632,13 @@ function gradient(steps, glyph) {
     // samples 2i (its ink, the left half) and 2i+1 (its ground, the right half),
     // so no sample equals either neighbour's ground.
     const samples = 2 * steps;
-    const seam = Array.from({ length: steps }, (_, i) => ({
-        glyph,
-        fg: { mix: [LEFT_BG, RIGHT_BG, (2 * i + 0.5) / samples] },
-        bg: { mix: [LEFT_BG, RIGHT_BG, (2 * i + 1.5) / samples] },
-    }));
-    return { seam, divider: seam };
+    return {
+        seam: Array.from({ length: steps }, (_, i) => ({
+            glyph,
+            fg: { mix: [LEFT_BG, RIGHT_BG, (2 * i + 0.5) / samples] },
+            bg: { mix: [LEFT_BG, RIGHT_BG, (2 * i + 1.5) / samples] },
+        })),
+    };
 }
 /**
  * A ramp of `steps` cells from the left ground to the right. Each cell is the

package/dist/core/style.d.ts

@@ -11,6 +11,13 @@ import { type Anchor } from "./anchor.js";
  */
 export declare const ATTRIBUTE_NAMES: readonly ["bold", "dim", "italic", "underline", "blink", "blink2", "reverse", "conceal", "strike", "underline2", "frame", "encircle", "overline"];
 export type AttributeName = (typeof ATTRIBUTE_NAMES)[number];
+/**
+ * Each text attribute as a style sets it: on, off, or unset — and an unset
+ * one lets a style laid beneath (`Style.add`) show through.
+ */
+export type Attributes = {
+    readonly [A in AttributeName]: boolean | undefined;
+};
 export declare const ATTRIBUTE_SGR: Record<AttributeName, number>;
 /**
  * Canonical short-attribute aliases (`b` → `bold`, `i` → `italic`, …).
@@ -18,7 +25,7 @@ export declare const ATTRIBUTE_SGR: Record<AttributeName, number>;
  * bindings — adding an alias here makes it available everywhere.
  * [LAW:one-source-of-truth]
  */
-export declare const ATTRIBUTE_SHORT_ALIASES: Record<string, AttributeName>;
+export declare const ATTRIBUTE_SHORT_ALIASES: Readonly<Record<string, AttributeName>>;
 export interface StyleOptions {
     color?: string | ColorSpec;
     bgcolor?: string | ColorSpec;
@@ -38,7 +45,18 @@ export interface StyleOptions {
     link?: string;
     meta?: Record<string, unknown>;
     anchor?: Anchor;
-    nextChange?: number;
+    /**
+     * The hold the style's cells are in, both ends or neither: a cell saying
+     * only when it next changes would claim, by default, that it always was,
+     * and a timeline run backwards past its change would never wake for it.
+     * [LAW:types-are-the-program] Absent, the cells never change.
+     */
+    hold?: Hold;
+}
+/** A hold: since when a sample has been what it is, and until when it stays so, on one clock. */
+export interface Hold {
+    readonly lastChange: number;
+    readonly nextChange: number;
 }
 export declare class StyleSyntaxError extends Error {
     constructor(message: string, options?: ErrorOptions);
@@ -60,7 +78,7 @@ export declare class Style {
     readonly encircle: boolean | undefined;
     readonly overline: boolean | undefined;
     readonly link: string | undefined;
-    readonly meta: Record<string, unknown> | undefined;
+    readonly meta: Readonly<Record<string, unknown>> | undefined;
     /**
      * Where this style's cells sat in the output of whatever drew them; see
      * `./anchor.ts`. It draws nothing, and it makes two styles that draw alike
@@ -68,17 +86,19 @@ export declare class Style {
      */
     readonly anchor: Anchor | undefined;
     /**
-     * When what this style's cells show next changes, in seconds on the
-     * timeline of whoever drew the frame — `t` itself for a cell drawn by
-     * something that moves every frame, and `Infinity`, the default, for one
+     * 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
+     * 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 (`Frames`, `Effected`), the stamp rides up
-     * through every container as the anchor does (`./anchor.ts`), and
-     * whoever holds the composed frame reads the soonest off it
-     * (`Segment.nextChange`), so a host knows when to draw again without
-     * asking each container. Two styles laid together change at the sooner.
+     * 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
+     * host knows when to draw again without asking each container. Two styles
+     * laid together are in the intersection of their holds.
      */
-    readonly nextChange: number;
+    readonly hold: Hold;
     constructor(options?: StyleOptions);
     get isNull(): boolean;
     get transparentBackground(): boolean;
@@ -97,6 +117,19 @@ export declare class Style {
      * The same look, drawn from the place `anchor` names, or from nowhere.
      */
     withAnchor(anchor: Anchor | undefined): Style;
+    /** The style's text attributes, each as it sets it. */
+    get attributes(): Attributes;
+    /**
+     * The same style with each attribute `attributes` names set as it says —
+     * on, off, or unset — and every other field as it was.
+     */
+    withAttributes(attributes: Partial<Attributes>): Style;
+    /**
+     * 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
+     * other field as it was. A style that does not blink is its own.
+     */
+    reduced(): Style;
     /**
      * This style on the cell `cells` to the right: its anchor shifted along its
      * row, or the style itself when it has no anchor.
@@ -130,7 +163,7 @@ export declare 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.
-     * What a style carries beyond its look — `meta`, `anchor`, `nextChange` —
+     * What a style carries beyond its look — `meta`, `anchor`, `hold` —
      * has no spelling and is not here, so two styles that differ only there
      * read alike; `equals` tells them apart.
      */
@@ -198,7 +231,7 @@ export declare class Theme {
     resolve(style: TextStyle): Style;
     has(name: string): boolean;
 }
-export declare const DEFAULT_STYLES: Record<string, Style>;
+export declare const DEFAULT_STYLES: Readonly<Record<string, Style>>;
 /**
  * The theme a render resolves names against when nothing supplied one — what
  * a renderable sees outside a `Console`, as in `renderToString`.