@promptctl/rich-js 0.24.1 → 0.25.0

package/dist/core/console.js

@@ -16,9 +16,10 @@ import { ReprHighlighter, NullHighlighter } from "./highlighter.js";
 // orchestrator reaching down for `Rule`. `RuleOptions` rides the same edge
 // rather than being restated here; see `rule()`.
 import { Rule } from "../renderables/rule.js";
-import { segmentsToString } from "./render.js";
+import { segmentsToString, shownOn } from "./render.js";
 import { placeBlock } from "./place.js";
-import { isRenderable, render } from "./protocol.js";
+import { activePass, isRenderable, measure, render } from "./protocol.js";
+import { ListState, State, refuseRenderWrite } from "./state.js";
 // [LAW:dataflow-not-control-flow] With no live region claimed, stepping around
 // it is the text itself: every write takes the same path.
 const NO_LIVE_REGION = { around: (text) => text };
@@ -71,7 +72,7 @@ class TextRun {
         yield this.end;
     }
     measure(options) {
-        return this.text.measure(options);
+        return measure(this.text, options);
     }
 }
 // A host with an environment but no streams — what a browser looks like from
@@ -177,7 +178,7 @@ export class Console {
     // compared with: the reference's `LogRender._last_time`, one per console.
     // [LAW:no-ambient-temporal-coupling] "same as the previous row" is a fact
     // about an earlier call, so it is state this console owns, not order luck.
-    _lastLogTime = null;
+    _lastLogTime = new State(null);
     _style;
     _isTerminal;
     _interactive;
@@ -193,14 +194,15 @@ export class Console {
     _onStyleError;
     _asciiOnly;
     _highlighter;
-    _recorded;
+    _recorded = new ListState();
     // [LAW:types-are-the-program] The capture state is carried in the *type*
     // of this field, not in a sentinel value. `null` = not capturing; any
     // string (including "") = capturing, this is the buffer. A paired
     // boolean+string would admit the impossible state "not capturing, buffer
     // non-empty" — `string | null` makes that unrepresentable.
-    _capture;
-    _liveRegion;
+    _capture = new State(null);
+    _liveRegion = new State(NO_LIVE_REGION);
+    _madeIn = activePass();
     constructor(options) {
         const environment = options?.environment ?? ambientEnvironment();
         const stream = boundStream(environment, options?.stderr ?? false);
@@ -209,14 +211,13 @@ export class Console {
         // [LAW:dataflow-not-control-flow] `isTTY` and `env` are forwarded
         // unconditionally, so detection stays inside the console's injected
         // environment rather than the ambient process's.
-        const resolved = resolveDestination(options?.colorSystem === undefined ? "auto" : options.colorSystem, { isTTY: this._isTerminal, env: environment.env });
+        const resolved = resolveDestination(options?.colorSystem === undefined ? "auto" : options.colorSystem, { isTTY: this._isTerminal, env: environment.env, reducedMotion: options?.reducedMotion });
         // [LAW:single-enforcer] The console's one override, an explicit
         // `hyperlinks`, is applied here and nowhere else; every write encodes for
-        // this value whole.
-        this._destination = {
-            colorSystem: resolved.colorSystem,
-            hyperlinks: options?.hyperlinks ?? resolved.hyperlinks,
-        };
+        // this value whole. [LAW:one-source-of-truth] The reader's motion
+        // preference lives here too, and `options` reads it back from here, so
+        // what is drawn and how it is encoded take one preference.
+        this._destination = { ...resolved, hyperlinks: options?.hyperlinks ?? resolved.hyperlinks };
         this._getSize = resolveGetSize(options, environment, stream);
         this._getDatetime = options?.getDatetime ?? (() => new Date());
         // [LAW:no-ambient-temporal-coupling] The theme is assigned before the
@@ -232,9 +233,6 @@ export class Console {
         this._highlighter = options?.highlighter ?? new ReprHighlighter();
         this._onStyleError = options?.onStyleError;
         this._asciiOnly = options?.asciiOnly ?? false;
-        this._recorded = [];
-        this._capture = null;
-        this._liveRegion = NO_LIVE_REGION;
     }
     // --- Properties ---
     get size() {
@@ -256,8 +254,9 @@ export class Console {
         return this._destination.colorSystem;
     }
     /**
-     * Where this console writes: the colour depth it draws at and whether it
-     * emits OSC 8 hyperlinks, overrides applied — the value its output is
+     * Where this console writes: the colour depth it draws at, whether it
+     * emits OSC 8 hyperlinks, and whether its reader asked for reduced motion,
+     * overrides applied — the value its output is
      * encoded for, for anything that encodes on its behalf (`Live`).
      */
     get destination() {
@@ -287,6 +286,7 @@ export class Console {
             height: { rows: height, exact: false },
             isTerminal: this.isTerminal,
             asciiOnly: this._asciiOnly,
+            reducedMotion: this._destination.reducedMotion,
             theme: this._theme,
             onStyleError: this._onStyleError,
             colorSystem: this._destination.colorSystem,
@@ -474,7 +474,7 @@ export class Console {
     log(...args) {
         const options = this.options;
         const stamped = logTime(this._getDatetime());
-        const repeated = stamped === this._lastLogTime;
+        const repeated = stamped === this._lastLogTime.get();
         const time = new RichText(stamped, { end: "" });
         time.stylize("log.time");
         const width = Math.min(time.cellLength, options.maxWidth - 1);
@@ -492,7 +492,7 @@ export class Console {
         this._writeSegments(emit({ rows: grid, closed: true, cropWidth: cropWidth + width }));
         // Remembered only once the row is written: a log that threw printed no
         // stamp, so the next row's must show.
-        this._lastLogTime = stamped;
+        this._lastLogTime.set(stamped);
     }
     // [LAW:one-source-of-truth] `RuleOptions` is `Rule`'s, not a restatement of
     // it. `console.ts` used to declare its own copy and field-by-field forward
@@ -519,15 +519,15 @@ export class Console {
      * painted over by the first, so claiming one while another is held throws.
      */
     claimLiveRegion(region) {
-        if (this._liveRegion !== NO_LIVE_REGION) {
+        if (this._liveRegion.get() !== NO_LIVE_REGION) {
             throw new Error("A live display is already running on this console; stop it before starting another.");
         }
-        this._liveRegion = region;
+        this._liveRegion.set(region);
         // Letting go of a region no longer held — a second call, or after another
         // was claimed — leaves the one that is.
         return () => {
-            if (this._liveRegion === region)
-                this._liveRegion = NO_LIVE_REGION;
+            if (this._liveRegion.get() === region)
+                this._liveRegion.set(NO_LIVE_REGION);
         };
     }
     // --- Capture ---
@@ -537,60 +537,65 @@ export class Console {
     // the full text that would otherwise have been written. This is not a
     // tee — callers wanting both must compose explicitly.
     beginCapture() {
-        this._capture = "";
+        this._capture.set("");
     }
     endCapture() {
-        const result = this._capture ?? "";
-        this._capture = null;
+        const result = this._capture.get() ?? "";
+        this._capture.set(null);
         return result;
     }
     // --- Export (when record:true) ---
     exportText({ clear = true } = {}) {
-        const text = this._recorded.map((s) => s.text).join("");
+        const text = this._recorded.get().map((s) => s.text).join("");
         if (clear)
-            this._recorded = [];
+            this._recorded.set([]);
         return text;
     }
     // [LAW:single-enforcer] `encodeHtml` draws the picture `exportLines`
     // resolves; nothing here interprets a `Style`.
     exportHtml({ theme, clear = true } = {}) {
-        const html = encodeHtml(this._recorded, theme);
+        const html = encodeHtml(this._recorded.get(), theme);
         if (clear)
-            this._recorded = [];
+            this._recorded.set([]);
         return html;
     }
     // [LAW:single-enforcer] As `exportHtml`: `encodeSvg` draws, this clears.
     exportSvg({ theme, title = "Rich", clear = true } = {}) {
-        const svg = encodeSvg(this._recorded, { theme, title, width: this.width });
+        const svg = encodeSvg(this._recorded.get(), { theme, title, width: this.width });
         if (clear)
-            this._recorded = [];
+            this._recorded.set([]);
         return svg;
     }
     // --- Internal ---
     // [LAW:single-enforcer] One encode call per write batch routes through the
     // same `segmentsToString` used by `renderToString`. Recording captures every
-    // non-control segment for replay.
+    // non-control segment for replay, as its destination shows it.
     _writeSegments(segments) {
+        const shown = segments.map((segment) => shownOn(segment, this._destination));
         if (this._record) {
-            for (const segment of segments) {
+            for (const segment of shown) {
                 if (!segment.isControl)
                     this._recorded.push(segment);
             }
         }
-        const encoded = segmentsToString(segments, this._destination);
+        const encoded = segmentsToString(shown, this._destination);
         if (encoded.length > 0)
             this._write(encoded);
     }
     _write(text) {
+        // [LAW:single-enforcer] Every write is refused during a render this console was not made in, whatever
+        // the console records or captures: output is an effect, and one made mid-frame lands inside the frame.
+        refuseRenderWrite(this._madeIn);
         // [LAW:types-are-the-program] `_capture !== null` is a discriminator
         // narrow on `string | null`, not a sentinel comparison — the type
         // carries the active/inactive state. The early return is what makes
         // this a redirect (not a tee); see beginCapture for semantics.
-        if (this._capture !== null) {
-            this._capture += text;
+        const captured = this._capture.get();
+        if (captured !== null) {
+            this._capture.set(captured + text);
             return;
         }
         const target = this._file ?? defaultSink(this._stream);
-        target.write(this._liveRegion.around(text));
+        target.write(this._liveRegion.get().around(text));
     }
 }

package/dist/core/easing.d.ts

@@ -63,6 +63,18 @@ export type StepPosition = "jump-start" | "jump-end" | "jump-none" | "jump-both"
  * the very end.
  */
 export declare function steps(n: number, position?: StepPosition): Ease;
+/**
+ * The curve `shape` over [0, 1) as an ease that has arrived: its argument
+ * held to [0, 1], and exactly 1 at 1. Every built-in ease is one, so the two
+ * halves of the `Ease` contract — an argument in [0, 1], the end landed on —
+ * are enforced here and nowhere else. [LAW:single-enforcer] The end matters
+ * because a curve is 1 at its end only in the limit or up to a rounding — a
+ * spring settles to within `SPRING_REST`, the elastic's ringing never quite
+ * stops, a back curve's cubic or a bezier's Newton step lands an ulp off —
+ * and a count or a width eased by it must land on its target, not a
+ * thousandth or an ulp short.
+ */
+export declare const settled: (shape: (p: number) => number) => Ease;
 /**
  * A spring's physics: the mass on it, the stiffness of its coil and the
  * damping it moves against, in the units every animation library spells them
@@ -180,7 +192,25 @@ export interface Beat {
      * (`./animation.ts`).
      */
     nextChange(t: number): number;
+    /** The beat with its motion taken out: its first hold, held for good, as a loop holds its first value. */
+    reduced(): Beat;
 }
+/**
+ * `t`, unless it is not a finite number of seconds, which throws naming
+ * `what`. [LAW:single-enforcer] The one refusal of a moment to draw at, for
+ * every loop and beat that reads time and every renderable drawn at a time.
+ */
+export declare function finiteTime(what: string, t: number): number;
+/**
+ * Which pass of a `period` `t` is in, as a whole number of either sign, and
+ * the seconds into it, read through the one wrap: what a `beat` and an
+ * `Animation.repeat` (`./animation.ts`) both ask, so the two agree on the
+ * pass of every float, a boundary included.
+ */
+export declare function passAt(what: string, t: number, period: number): {
+    readonly pass: number;
+    readonly into: number;
+};
 /**
  * The first float from `sum` up at which `reached` holds: a time built as a
  * sum to land on a boundary — where a hold begins, where an animation's next

package/dist/core/easing.js

@@ -128,7 +128,7 @@ export function steps(n, position = "jump-end") {
  * and a count or a width eased by it must land on its target, not a
  * thousandth or an ulp short.
  */
-const settled = (shape) => (x) => {
+export const settled = (shape) => (x) => {
     const p = Math.min(1, Math.max(0, x));
     return p === 1 ? 1 : shape(p);
 };
@@ -330,6 +330,25 @@ function positive(what, v, unit = "") {
 export function positiveSeconds(what, seconds) {
     positive(what, seconds, " of seconds");
 }
+/** A beat of one hold that never ends: hold 0 at every time, never changing — what every beat is reduced to. */
+const STILL = {
+    holds: [Number.POSITIVE_INFINITY],
+    period: Number.POSITIVE_INFINITY,
+    at: () => 0,
+    lastChange: () => Number.NEGATIVE_INFINITY,
+    nextChange: () => Number.POSITIVE_INFINITY,
+    reduced: () => STILL,
+};
+/**
+ * `t`, unless it is not a finite number of seconds, which throws naming
+ * `what`. [LAW:single-enforcer] The one refusal of a moment to draw at, for
+ * every loop and beat that reads time and every renderable drawn at a time.
+ */
+export function finiteTime(what, t) {
+    if (!Number.isFinite(t))
+        throw new RangeError(`${what} needs a finite t, got ${t}`);
+    return t;
+}
 /**
  * The seconds into the current pass of a `period` at `t`: `t` taken modulo
  * the period, into [0, period), before zero too. [LAW:single-enforcer] The
@@ -340,9 +359,7 @@ export function positiveSeconds(what, seconds) {
  * on the pass that begins there, and the answer is always under the period.
  */
 function wrapSeconds(what, t, period) {
-    if (!Number.isFinite(t))
-        throw new RangeError(`${what} needs a finite t, got ${t}`);
-    const into = t % period;
+    const into = finiteTime(what, t) % period;
     if (into >= 0)
         return into;
     // A negative epsilon carried up rounds to the period itself; that is the
@@ -350,19 +367,44 @@ function wrapSeconds(what, t, period) {
     const carried = into + period;
     return carried >= period ? 0 : carried;
 }
+/**
+ * Which pass of a `period` `t` is in, as a whole number of either sign, and
+ * the seconds into it, read through the one wrap: what a `beat` and an
+ * `Animation.repeat` (`./animation.ts`) both ask, so the two agree on the
+ * pass of every float, a boundary included.
+ */
+export function passAt(what, t, period) {
+    const into = wrapSeconds(what, t, period);
+    // `t - into` is a whole number of periods but for rounding, which `round`
+    // takes off; carrying a pass's start out of `t` itself would leave each
+    // sample its own rounding. `+ 0` turns the `-0` a small negative `t` rounds
+    // to into pass 0, so the pass is a plain integer whoever reads it.
+    return { pass: Math.round((t - into) / period) + 0, into };
+}
+/** The least normal double, 2^-1022: below it every double is a multiple of `Number.MIN_VALUE`. */
+const MIN_NORMAL = 2 ** -1022;
 /**
  * The float after `x`: one ulp up, away from zero for a positive `x` and
- * toward it for a negative one, read through the bits of the double.
+ * toward it for a negative one. Computed, not read through the bits of the
+ * double: a buffer per call costs an allocation on every boundary walked, and
+ * one at module scope is state every caller shares.
  */
 function nextUp(x) {
     if (x === 0)
         return Number.MIN_VALUE;
-    DOUBLE[0] = x;
-    BITS[0] = BITS[0] + (x > 0 ? 1n : -1n);
-    return DOUBLE[0];
+    const a = Math.abs(x);
+    if (a < MIN_NORMAL)
+        return x + Number.MIN_VALUE;
+    // `log2` may round across a power of two; the two checks put `a` in [2^e, 2^(e+1)).
+    let e = Math.floor(Math.log2(a));
+    if (2 ** e > a)
+        e -= 1;
+    else if (2 ** (e + 1) <= a)
+        e += 1;
+    const ulp = 2 ** (e - 52);
+    // Toward zero from a power of two, the floats below it are half as far apart.
+    return x > 0 ? x + ulp : x + (a === 2 ** e && a > MIN_NORMAL ? ulp / 2 : ulp);
 }
-const DOUBLE = new Float64Array(1);
-const BITS = new BigUint64Array(DOUBLE.buffer);
 /** How many ulps the roundings in a sum naming a boundary can put it under that boundary; a walk past this is a boundary finer than time resolves there. */
 const ULPS_OF_ROUNDING = 8;
 /**
@@ -461,12 +503,14 @@ export function beat(holds) {
     // are not exact in binary — a tenth of a second is not — and `at` would
     // then read it as the hold before, so it is walked up to the first float
     // `at` places in the hold. The walk is a function of the pass and the hold
-    // alone, so every `t` in the hold still answers one float.
-    const boundary = (what, pass, i, t) => walkUp(pass * period + starts[i], (began) => index(wrapSeconds(what, began, period)) === i, () => `${what}: hold ${i} (${own[i]} s) is finer than time resolves near t = ${t}`);
-    // Which pass `t` is in, as a whole number: `t - into` is a whole number of
-    // periods but for rounding, which `round` takes off; carrying `starts[i]`
-    // out of `t` itself would leave each sample its own rounding.
-    const pass = (t, into) => Math.round((t - into) / period);
+    // alone, so every `t` in the hold still answers one float. It is walked
+    // until `at` places it in this hold of this pass: with one hold, every
+    // float is in hold 0, and only the pass tells the boundary from the float
+    // under it.
+    const boundary = (what, p, i, t) => walkUp(p * period + starts[i], (began) => {
+        const { pass, into } = passAt(what, began, period);
+        return index(into) === i && pass === p;
+    }, () => `${what}: hold ${i} (${own[i]} s) is finer than time resolves near t = ${t}`);
     return {
         holds: own,
         period,
@@ -474,16 +518,17 @@ export function beat(holds) {
             return index(wrapSeconds("Beat.at", t, period));
         },
         lastChange(t) {
-            const into = wrapSeconds("Beat.lastChange", t, period);
-            return boundary("Beat.lastChange", pass(t, into), index(into), t);
+            const { pass, into } = passAt("Beat.lastChange", t, period);
+            return boundary("Beat.lastChange", pass, index(into), t);
         },
         // The next hold's start, in the next pass when this hold is the last.
         nextChange(t) {
-            const into = wrapSeconds("Beat.nextChange", t, period);
+            const { pass, into } = passAt("Beat.nextChange", t, period);
             const i = index(into);
             const last = i === own.length - 1;
-            return boundary("Beat.nextChange", pass(t, into) + (last ? 1 : 0), last ? 0 : i + 1, t);
+            return boundary("Beat.nextChange", pass + (last ? 1 : 0), last ? 0 : i + 1, t);
         },
+        reduced: () => STILL,
     };
 }
 /** The three phase shapes. Each takes seconds and returns a `Phase`. */

package/dist/core/emoji.d.ts

@@ -4,7 +4,7 @@
 import { Segment } from "./segment.js";
 import type { Style } from "./style.js";
 import type { Renderable, RenderOptions } from "./protocol.js";
-export declare const EMOJI: Record<string, string>;
+export declare const EMOJI: Readonly<Record<string, string>>;
 /**
  * Replaces :shortcode: patterns in text with emoji characters.
  */

package/dist/core/emoji.js

@@ -324,12 +324,11 @@ export const EMOJI = {
     radioactive: "☢",
     biohazard: "☣",
 };
-const EMOJI_PATTERN = /:([a-z0-9_]+(?:-(?:emoji|text))?):/g;
 /**
  * Replaces :shortcode: patterns in text with emoji characters.
  */
 export function emojiReplace(text, defaultVariant) {
-    return text.replace(EMOJI_PATTERN, (_match, code) => {
+    return text.replace(/:([a-z0-9_]+(?:-(?:emoji|text))?):/g, (_match, code) => {
         let variant = defaultVariant;
         let name = code;
         // Check for inline variant suffix

package/dist/core/export-html.js

@@ -14,6 +14,7 @@
  */
 import { cellLen, graphemes } from "./cells.js";
 import { escapeAttribute, escapeText, exportCanvas, exportLines, } from "./export-lines.js";
+import { pattern } from "./pattern.js";
 const BLINK_KEYFRAMES = "rich-blink";
 // [LAW:dataflow-not-control-flow] Each enum-valued field of a look is a table
 // from its values to the declarations it adds, so every value is spelled once
@@ -68,7 +69,7 @@ function glyphCss(look) {
 const ANCHOR_CSS = "all:unset;cursor:revert;outline:revert";
 const span = (css, content) => `<span style="${escapeAttribute(css.join(";"))}">${content}</span>`;
 /** Text of printable ASCII only: one cell a character, nothing to box. */
-const ONE_CELL = /^[\x20-\x7e]*$/;
+const ONE_CELL = pattern(/^[\x20-\x7e]*$/);
 /**
  * A box exactly `cells` of the monospace font wide (`ch` is one of its cells)
  * for glyphs the browser would otherwise draw at a fallback font's width,

package/dist/core/export-lines.js

@@ -62,15 +62,15 @@ const ENTITIES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
  * surrogates. One of them leaves a whole SVG unparsable, not one glyph missing.
  * Each takes no cell, so dropping it moves nothing on the grid.
  */
-const NOT_XML = /[\x00-\x08\x0B\x0C\x0E-\x1F￾￿]|\p{Cs}/gu;
+const withoutNotXml = (text) => text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F￾￿]|\p{Cs}/gu, "");
 /**
  * Text as character data in HTML or SVG markup. Both exporters write markup,
  * and [LAW:single-enforcer] one escaper is what keeps a title or a run that is
  * safe in one format from being live markup, or no markup at all, in the other.
  */
-export const escapeText = (text) => text.replace(NOT_XML, "").replace(/[&<>]/g, (c) => ENTITIES[c]);
+export const escapeText = (text) => withoutNotXml(text).replace(/[&<>]/g, (c) => ENTITIES[c]);
 /** A value inside a double-quoted attribute in HTML or SVG markup. */
-export const escapeAttribute = (value) => value.replace(NOT_XML, "").replace(/[&"<>]/g, (c) => ENTITIES[c]);
+export const escapeAttribute = (value) => withoutNotXml(value).replace(/[&"<>]/g, (c) => ENTITIES[c]);
 /**
  * How far a dim glyph moves toward its background — Rich's own factor, so an
  * export of the same program matches the library this ports.

package/dist/core/highlighter.d.ts

@@ -10,24 +10,25 @@ export declare class NullHighlighter extends Highlighter {
     highlight(_text: RichText): void;
 }
 export declare class RegexHighlighter extends Highlighter {
-    static highlights: (string | RegExp)[];
+    /** Each pattern's `source` and `flags`: a regex is compiled from them per call, so a held one keeps no cursor. */
+    static readonly highlights: readonly (string | Pick<RegExp, "source" | "flags">)[];
     /** Style applied to matches. When ending with "." it acts as a namespace
      *  prefix: named groups become `baseStyle + groupName` (e.g. "repr." + "url"
      *  → "repr.url"). Otherwise it's used as a literal style for all matches
      *  (e.g. "bold red" applies "bold red" to every named group). */
-    static baseStyle: string;
+    static readonly baseStyle: string;
     highlight(text: RichText): void;
 }
 export declare class ReprHighlighter extends RegexHighlighter {
-    static baseStyle: string;
-    static highlights: RegExp[];
+    static readonly baseStyle = "repr.";
+    static readonly highlights: typeof RegexHighlighter.highlights;
 }
 export declare class JSONHighlighter extends RegexHighlighter {
-    static baseStyle: string;
-    static highlights: RegExp[];
+    static readonly baseStyle = "json.";
+    static readonly highlights: typeof RegexHighlighter.highlights;
     highlight(text: RichText): void;
 }
 export declare class ISO8601Highlighter extends RegexHighlighter {
-    static baseStyle: string;
-    static highlights: string[];
+    static readonly baseStyle = "iso8601.";
+    static readonly highlights: typeof RegexHighlighter.highlights;
 }

package/dist/core/highlighter.js

@@ -18,6 +18,7 @@ export class NullHighlighter extends Highlighter {
 }
 // --- RegexHighlighter ---
 export class RegexHighlighter extends Highlighter {
+    /** Each pattern's `source` and `flags`: a regex is compiled from them per call, so a held one keeps no cursor. */
     static highlights = [];
     /** Style applied to matches. When ending with "." it acts as a namespace
      *  prefix: named groups become `baseStyle + groupName` (e.g. "repr." + "url"
@@ -34,8 +35,8 @@ export class RegexHighlighter extends Highlighter {
             // `d` reports where each group matched, as Python's `match.span(name)`
             // does; searching the match for the group's text finds the first copy
             // of it, which is not always the one the group captured.
-            const source = pattern instanceof RegExp ? pattern.source : pattern;
-            const flags = new Set([...(pattern instanceof RegExp ? pattern.flags : ""), "g", "d"]);
+            const source = typeof pattern === "string" ? pattern : pattern.source;
+            const flags = new Set([...(typeof pattern === "string" ? "" : pattern.flags), "g", "d"]);
             for (const match of text.plain.matchAll(new RegExp(source, [...flags].join("")))) {
                 if (match.indices === undefined)
                     throw new Error("a match of a `d`-flag pattern carries indices");

package/dist/core/json.js

@@ -8,7 +8,7 @@
  */
 import { RichText } from "./text.js";
 import { JSONHighlighter } from "./highlighter.js";
-import { render } from "./protocol.js";
+import { measure, render } from "./protocol.js";
 const highlighter = new JSONHighlighter();
 export class JSONRenderable {
     text;
@@ -49,6 +49,6 @@ export class JSONRenderable {
         yield* render(this.text, options);
     }
     measure(options) {
-        return this.text.measure(options);
+        return measure(this.text, options);
     }
 }

package/dist/core/markup.js

@@ -21,6 +21,8 @@ import { cellLen } from "./cells.js";
 import { Style, StyleSyntaxError } from "./style.js";
 import { RichText, stripControlChars } from "./text.js";
 import { emojiReplace } from "./emoji.js";
+import { pattern } from "./pattern.js";
+import { State } from "./state.js";
 // --- Tag ---
 export class Tag {
     name;
@@ -159,7 +161,7 @@ function excerpt(text, index) {
  */
 export function escape(text) {
     return text
-        .replace(ESCAPE_RE, (_, run, live) => live === undefined ? `${run}\\[` : `${run}${run}\\[`)
+        .replace(new RegExp(ESCAPE_RE.source, "g"), (_, run, live) => live === undefined ? `${run}\\[` : `${run}${run}\\[`)
         .replace(TRAILING_RUN_RE, "$&$&");
 }
 // --- render ---
@@ -188,18 +190,18 @@ export function escape(text) {
 // run, on exactly the untrusted text `escape` is for.
 const TAG_BODY = String.raw `[a-z#/@][^[]*?\]`;
 const RUN = String.raw `(?<!\\)(\\*)`;
-const TAG_RE = new RegExp(String.raw `${RUN}(\[${TAG_BODY})`, "g");
+const TAG_RE = pattern(new RegExp(String.raw `${RUN}(\[${TAG_BODY})`));
 /**
  * Every bracket and the run in front of it; the empty second group is set when
  * a tag starts there or could, once more text is joined after the end. It is an
  * alternation rather than `(…)?` because a quantified group may not match empty.
  */
-const ESCAPE_RE = new RegExp(String.raw `${RUN}\[(?:(?=${TAG_BODY}|(?:[a-z#/@][^[\]]*)?$)()|)`, "g");
-const TRAILING_RUN_RE = /(?<!\\)\\+$/;
+const ESCAPE_RE = pattern(new RegExp(String.raw `${RUN}\[(?:(?=${TAG_BODY}|(?:[a-z#/@][^[\]]*)?$)()|)`));
+const TRAILING_RUN_RE = pattern(/(?<!\\)\\+$/);
 function tokenize(markup) {
     const tokens = [];
     let position = 0;
-    for (const match of markup.matchAll(TAG_RE)) {
+    for (const match of markup.matchAll(new RegExp(TAG_RE.source, "g"))) {
         const run = match[1];
         const captured = match[2];
         let start = match.index;
@@ -292,9 +294,9 @@ function findLastIndex(items, match) {
 // could never fire. This tracked `[A-Za-z]` while `TAG_RE` wrongly admitted
 // uppercase, which is the same drift, one subset down (rich-markup-sec).
 const PLUGIN_TAG_NAME_SRC = "[a-z][A-Za-z0-9_-]*";
-const LEGAL_PLUGIN_TAG_NAME = new RegExp(`^${PLUGIN_TAG_NAME_SRC}$`);
+const LEGAL_PLUGIN_TAG_NAME = pattern(new RegExp(`^${PLUGIN_TAG_NAME_SRC}$`));
 export class MarkupRegistry {
-    _handlers = new Map();
+    _handlers = new State(new Map());
     register(name, handler) {
         // [LAW:no-silent-failure] Registration used to accept any string, including
         // names markup can never address (`a.b` stops the tag scan at the dot), and
@@ -305,16 +307,18 @@ export class MarkupRegistry {
         if (isReservedTagName(name)) {
             throw new MarkupError(`Cannot register markup tag "${name}": name is reserved by a built-in style.`);
         }
-        this._handlers.set(name, handler);
+        this._handlers.set(new Map(this._handlers.get()).set(name, handler));
     }
     unregister(name) {
-        this._handlers.delete(name);
+        const handlers = new Map(this._handlers.get());
+        handlers.delete(name);
+        this._handlers.set(handlers);
     }
     has(name) {
-        return this._handlers.has(name);
+        return this._handlers.get().has(name);
     }
     get(name) {
-        return this._handlers.get(name);
+        return this._handlers.get().get(name);
     }
 }
 // [LAW:one-source-of-truth] Reserved-name detection delegates to Style.parse —
@@ -356,7 +360,7 @@ function isSpace(c) {
 // continues with the whitespace that introduces attributes. Anything else —
 // `[table.header]`, `[table=x]` — is the built-in dialect's, and falls through
 // exactly as an unregistered name would.
-const PLUGIN_TAG_HEAD = new RegExp(`^(${PLUGIN_TAG_NAME_SRC})(?=$|[ \\t])`);
+const PLUGIN_TAG_HEAD = pattern(new RegExp(`^(${PLUGIN_TAG_NAME_SRC})(?=$|[ \\t])`));
 function parsePluginAttrs(after) {
     // Hand-written tokenizer. Walks `key=value` pairs separated by whitespace;
     // values may be bare, single-quoted, or double-quoted. Matches the syntax

package/dist/core/measure.js

@@ -1,7 +1,7 @@
 /**
  * Measurement — min/max cell width calculation for renderables.
  */
-import { drawsNothing, isMeasurable, measuring } from "./protocol.js";
+import { drawsNothing, isMeasurable, measure } from "./protocol.js";
 export class Measurement {
     minimum;
     maximum;
@@ -49,7 +49,7 @@ export class Measurement {
             return new Measurement(0, 0);
         if (!isMeasurable(renderable))
             return new Measurement(0, options.maxWidth);
-        const { minimum, maximum } = renderable.measure(measuring(options));
+        const { minimum, maximum } = measure(renderable, options);
         return new Measurement(minimum, Math.min(maximum, options.maxWidth)).normalize();
     }
 }