brookmd 0.27.0 → 0.28.0

package/CHANGELOG.md

@@ -4,6 +4,63 @@ Notable changes to brookmd (formerly `flux-md`). Format based on
 [Keep a Changelog](https://keepachangelog.com/); this project aims to follow
 [Semantic Versioning](https://semver.org/).
 
+## 0.28.0 — 2026-07-31
+
+**Browser-side linearity.** The parser and wire have been O(new bytes) per
+append for a while; this release makes the *DOM application* match. Before, an
+open (streaming) block was fully rebuilt on every animation frame — a 20 KB
+highlighted code block wrote ~44 million characters of `innerHTML` over its
+lifetime (≈2,150× the wire bytes), and a per-frame `replaceWith` destroyed any
+text selection or `<pre>` scroll position inside the block. Every open-block
+path now applies patches incrementally, measured at **2–3.4× the block's final
+markup, flat across sizes** (1× is the write-it-once floor), and enforced by a
+chars-written regression gate so browser-side linearity is CI-pinned like the
+parser's scaling shapes.
+
+### Performance
+
+- **Open blocks apply the wire's splice instead of rebuilding.** The delta
+  signal (`keep_units`) the wire already computed was being discarded at the
+  client; it now reaches both renderers, which rebuild only the element the
+  splice lands in (fast path fires ~94% of syncs; any ambiguity falls back to
+  a full rebuild, so correctness never depends on the fast path).
+- **Open code blocks reuse the streaming highlighter's frozen prefix**: the
+  frozen markup is appended once and never rewritten; only the bounded
+  speculative tail repaints. 20 KB highlighted stream: ~44 MB written → ~370 KB
+  (**~120× less**).
+- **Keyed list/container sync in the DOM renderer** (`blockData` on): settled
+  `<li>`s / nested container children are never re-rendered — new items append,
+  only the open last item repaints; a tight→loose flip resyncs once, keyed by
+  `(index, html)` so it cannot be silently missed. Streamed 20 KB list: 284× →
+  **2.9×**; blockquote: 318× → **3.4×**.
+- **React's keyed container path now engages by default.** It was accidentally
+  gated behind a `components` map (git history shows the gate was incidental);
+  a default-config streaming blockquote/alert now renders keyed — 22.6× and
+  growing → **3.4× flat**. React and DOM implementations were cross-checked to
+  byte-identical work counts.
+- Known documented fallback: a streamed table with `blockData: false` still
+  takes the full-rebuild path (the splice refuses table tag chains — foster
+  parenting). `blockData: true` tables were already incremental (1.7×). A
+  table-scoped splice was measured (15% improvement) and rejected as not worth
+  the parser-divergence risk.
+
+### Fixed
+
+- **Text selection and `<pre>` scroll survive streaming.** Selecting text in
+  the already-settled part of a streaming block no longer collapses on the
+  next token; a code block's horizontal scroll position is preserved. Both are
+  pinned by tests with negative controls.
+
+### Changed
+
+- The DOM inside an open, streaming `<code>` element is now two spans (frozen +
+  speculative tail) while streaming; it settles to the same single-markup form
+  as before when the block closes. CSS that targets `code > *` structurally
+  may observe the difference mid-stream only. Settled output is unchanged.
+- React's default open blockquote/alert omits inter-block whitespace text
+  nodes mid-stream (matching the DOM renderer's long-standing keyed behavior);
+  layout is unaffected and settle output is byte-identical.
+
 ## 0.27.0 — 2026-07-31
 
 ### Added

package/dist/client.js

@@ -1,5 +1,6 @@
 import { warnOnce } from "./warn.js";
 import { createWorker } from "./asset-urls.js";
+import { noteSplice } from "./splice.js";
 function emptyBlockStore() {
   return { committed: /* @__PURE__ */ new Map(), committedOrder: [], active: [], snapshot: [] };
 }
@@ -18,7 +19,9 @@ function applyPatch(store, patch) {
       const { html_delta, ...rest } = entry;
       const prev = store.active.find((b) => b.id === entry.id);
       if (!prev) throw new Error(`brookmd: html_delta for block ${entry.id} without a base`);
-      active[i] = { ...rest, html: prev.html.slice(0, html_delta.keep_units) + html_delta.append };
+      const next2 = { ...rest, html: prev.html.slice(0, html_delta.keep_units) + html_delta.append };
+      active[i] = next2;
+      noteSplice(next2, prev, html_delta.keep_units);
     } else {
       active[i] = entry;
     }

package/dist/dom.d.ts

@@ -129,7 +129,24 @@ export interface MountOptions {
      * `client.getMetrics().rebuildCount`.
      */
     onRenderMetrics?: RenderMetricsHook;
+    /**
+     * @internal TEST-ONLY. Turn off the incremental apply fast paths — the open
+     * code block's frozen/tail mirror and the delta-driven child splice — so every
+     * changed open block rebuilds its whole node, exactly as it did before those
+     * existed. The DOM-parity fuzz mounts one renderer with this on and one with it
+     * off over the same patch stream and asserts their `innerHTML` matches after
+     * every sync: correctness must never depend on a fast path firing. Not part of
+     * the supported API and never useful in an app.
+     */
+    __fullRebuild?: boolean;
 }
+/** @internal Test-only. */
+export declare function __keyedStats(): {
+    attempts: number;
+    hits: number;
+};
+/** @internal Test-only. */
+export declare function __resetKeyedStats(): void;
 export declare function mountBrookMarkdown(client: BrookClient, container: HTMLElement, options?: MountOptions): MountHandle;
 /**
  * Derive the streaming tail's block id from an ordered snapshot: the id of the

package/dist/dom.js

@@ -1,9 +1,19 @@
 import { highlightDeferred } from "./hi-defer.js";
 import { createInc, incHighlight, incSeed } from "./hi-inc.js";
 import { morph } from "./morph.js";
+import { newIncCode, paintIncCode, spliceHtml, spliceKeep } from "./splice.js";
 import { blockProps, extractLang } from "./block-props.js";
 import { decorateSegments } from "./decorate.js";
 import { safeUrl } from "./url-safety.js";
+let keyedAttempts = 0;
+let keyedHits = 0;
+function __keyedStats() {
+  return { attempts: keyedAttempts, hits: keyedHits };
+}
+function __resetKeyedStats() {
+  keyedAttempts = 0;
+  keyedHits = 0;
+}
 const INTRINSIC_PX = {
   Paragraph: 80,
   Heading: 44,
@@ -32,6 +42,7 @@ function mountBrookMarkdown(client, container, options = {}) {
   const streamingHighlight = options.streamingHighlight !== false;
   const batch = options.batch !== false && typeof requestAnimationFrame === "function";
   const morphOpenBlocks = options.morphOpenBlocks === true;
+  const fullRebuild = options.__fullRebuild === true;
   const root = document.createElement("div");
   root.className = options.className ? `brook-md ${options.className}` : "brook-md";
   if (options.id) root.id = options.id;
@@ -70,6 +81,7 @@ function mountBrookMarkdown(client, container, options = {}) {
           id: b.id,
           node: void 0,
           html: b.html,
+          block: b,
           open: b.open,
           speculative: b.speculative,
           kind: b.kind.type,
@@ -87,6 +99,13 @@ function mountBrookMarkdown(client, container, options = {}) {
         continue;
       }
       const t0 = onRenderMetrics && hasPerf ? performance.now() : 0;
+      if (existing.codeInc && existing.inc && b.open && existing.open && b.kind.type === "CodeBlock" && existing.kind === "CodeBlock" && syncIncCode(existing, b)) {
+        if (onRenderMetrics) noteRender(existing, b, t0);
+        existing.html = b.html;
+        existing.block = b;
+        existing.speculative = b.speculative;
+        continue;
+      }
       if (existing.table && b.open && b.kind.type === "Table") {
         const data = tableData(b);
         if (data) {
@@ -96,15 +115,38 @@ function mountBrookMarkdown(client, container, options = {}) {
             existing.node.classList.toggle("brook-speculative", b.speculative);
           }
           existing.html = b.html;
+          existing.block = b;
           existing.open = b.open;
           existing.speculative = b.speculative;
           continue;
         }
       }
+      if (!fullRebuild && existing.list && b.open && b.kind.type === "List" && existing.kind === "List") {
+        const ld = b.kind.data;
+        if (ld && syncKeyedList(existing.list, ld)) {
+          if (onRenderMetrics) noteRender(existing, b, t0);
+          existing.node.className = genericClassName(b);
+          existing.html = b.html;
+          existing.block = b;
+          existing.open = b.open;
+          existing.speculative = b.speculative;
+          continue;
+        }
+      }
+      if (!fullRebuild && existing.container && b.open && existing.kind === b.kind.type && (b.kind.type === "Blockquote" || b.kind.type === "Alert") && syncKeyedContainer(existing.container, b)) {
+        if (onRenderMetrics) noteRender(existing, b, t0);
+        existing.node.className = genericClassName(b);
+        existing.html = b.html;
+        existing.block = b;
+        existing.open = b.open;
+        existing.speculative = b.speculative;
+        continue;
+      }
       if (morphOpenBlocks && b.open && existing.open && existing.generic && existing.kind === b.kind.type && usesGenericPath(b)) {
         morph(existing.node, sanitize ? sanitize(b.html) : b.html);
         if (onRenderMetrics) noteRender(existing, b, t0);
         existing.html = b.html;
+        existing.block = b;
         existing.speculative = b.speculative;
         existing.node.className = genericClassName(b);
         existing.generic = !sanitize;
@@ -114,9 +156,35 @@ function mountBrookMarkdown(client, container, options = {}) {
         existing.node.insertAdjacentHTML("beforeend", b.html.slice(existing.html.length));
         if (onRenderMetrics) noteRender(existing, b, t0);
         existing.html = b.html;
+        existing.block = b;
         continue;
       }
+      if (!fullRebuild && !sanitize && !hasInlineTransforms && existing.generic && b.open && existing.open && existing.kind === b.kind.type && usesGenericPath(b)) {
+        const keep = spliceKeep(existing.block, b);
+        if (keep !== void 0 && spliceHtml(existing.node, existing.html, b.html, keep)) {
+          if (onRenderMetrics) noteRender(existing, b, t0);
+          existing.html = b.html;
+          existing.block = b;
+          existing.speculative = b.speculative;
+          existing.node.className = genericClassName(b);
+          continue;
+        }
+      }
+      if (!fullRebuild && existing.plainCode && b.open && existing.open && b.kind.type === "CodeBlock" && existing.kind === "CodeBlock") {
+        const keep = spliceKeep(existing.block, b);
+        if (keep !== void 0 && spliceHtml(existing.plainCode, existing.html, b.html, keep)) {
+          if (onRenderMetrics) noteRender(existing, b, t0);
+          existing.html = b.html;
+          existing.block = b;
+          existing.speculative = b.speculative;
+          continue;
+        }
+      }
       existing.table = void 0;
+      existing.list = void 0;
+      existing.container = void 0;
+      existing.codeInc = void 0;
+      existing.plainCode = void 0;
       if (existing.inc && b.kind.type !== "CodeBlock") existing.inc = void 0;
       if (existing.highlight) {
         existing.highlight.cancel();
@@ -127,6 +195,7 @@ function mountBrookMarkdown(client, container, options = {}) {
       existing.node = node;
       if (onRenderMetrics) noteRender(existing, b, t0);
       existing.html = b.html;
+      existing.block = b;
       existing.open = b.open;
       existing.speculative = b.speculative;
       existing.kind = b.kind.type;
@@ -137,6 +206,8 @@ function mountBrookMarkdown(client, container, options = {}) {
         if (!seen.has(id)) {
           if (mb.highlight) mb.highlight.cancel();
           mb.inc = void 0;
+          mb.codeInc = void 0;
+          mb.plainCode = void 0;
           mb.node.remove();
           mounted.delete(id);
         }
@@ -206,13 +277,13 @@ function mountBrookMarkdown(client, container, options = {}) {
       if (data) return buildKeyedTable(b, data, mb);
     }
     if (b.open && kind === "List" && !hasInlineTransforms) {
-      const keyed = renderKeyedList(b);
+      const keyed = renderKeyedList(b, mb);
       if (keyed) return keyed;
     }
     const node = document.createElement("div");
     node.className = genericClassName(b);
     if (b.open && !sanitize && !hasInlineTransforms && (kind === "Blockquote" || kind === "Alert")) {
-      const wrapper = renderKeyedContainer(b);
+      const wrapper = renderKeyedContainer(b, mb);
       if (wrapper) {
         node.appendChild(wrapper);
         return node;
@@ -224,47 +295,122 @@ function mountBrookMarkdown(client, container, options = {}) {
     lastRenderGeneric = !sanitize && !hasInlineTransforms;
     return node;
   }
-  function renderKeyedList(b) {
+  function renderKeyedList(b, mb) {
     const ld = b.kind.data;
     const items = ld?.items;
     if (!Array.isArray(items) || items.length === 0) return null;
     const node = document.createElement("div");
-    node.className = "brook-block brook-block-list" + (b.open ? " brook-open" : "") + (b.speculative ? " brook-speculative" : "");
-    const list = document.createElement(ld?.ordered ? "ol" : "ul");
-    if (ld?.ordered && ld.start !== void 0 && ld.start !== 1) {
+    node.className = genericClassName(b);
+    const ordered = !!ld?.ordered;
+    const list = document.createElement(ordered ? "ol" : "ul");
+    if (ordered && ld.start !== void 0 && ld.start !== 1) {
       list.setAttribute("start", String(ld.start));
     }
-    for (const it of items) {
+    const rendered = new Array(items.length);
+    for (let i = 0; i < items.length; i++) {
       const li = document.createElement("li");
-      li.innerHTML = sanitize ? sanitize(it.html) : it.html;
+      li.innerHTML = sanitize ? sanitize(items[i].html) : items[i].html;
       list.appendChild(li);
+      rendered[i] = items[i].html;
     }
     node.appendChild(list);
+    mb.list = { list, ordered, start: ld?.start, items: rendered };
     return node;
   }
-  function renderKeyedContainer(b) {
+  function syncKeyedList(km, ld) {
+    keyedAttempts++;
+    const items = ld.items;
+    if (!Array.isArray(items) || items.length === 0) return false;
+    if (!!ld.ordered !== km.ordered) return false;
+    const cur = km.items;
+    const kids = km.list.children;
+    if (kids.length !== cur.length) return false;
+    if (ld.start !== km.start) {
+      if (km.ordered && ld.start !== void 0 && ld.start !== 1) {
+        km.list.setAttribute("start", String(ld.start));
+      } else {
+        km.list.removeAttribute("start");
+      }
+      km.start = ld.start;
+    }
+    const n = items.length;
+    while (cur.length > n) {
+      km.list.removeChild(km.list.lastElementChild);
+      cur.pop();
+    }
+    for (let i = 0; i < cur.length; i++) {
+      if (cur[i] === items[i].html) continue;
+      kids[i].innerHTML = sanitize ? sanitize(items[i].html) : items[i].html;
+      cur[i] = items[i].html;
+    }
+    for (let i = cur.length; i < n; i++) {
+      const li = document.createElement("li");
+      li.innerHTML = sanitize ? sanitize(items[i].html) : items[i].html;
+      km.list.appendChild(li);
+      cur.push(items[i].html);
+    }
+    keyedHits++;
+    return true;
+  }
+  function renderKeyedContainer(b, mb) {
     const nested = b.kind.data?.nested;
     if (!Array.isArray(nested)) return null;
     const tagName = b.kind.type === "Alert" ? "div" : "blockquote";
     const wrapper = document.createElement(tagName);
     applyOpenTagAttrs(wrapper, b.html);
+    let offset = 0;
+    let title = "";
     if (b.kind.type === "Alert") {
-      const title = alertTitleHtml(b.html);
+      title = alertTitleHtml(b.html);
       if (title) {
         const t = document.createElement("div");
         t.innerHTML = title;
         const titleNode = t.firstElementChild;
-        if (titleNode) wrapper.appendChild(titleNode);
+        if (titleNode) {
+          wrapper.appendChild(titleNode);
+          offset = 1;
+        }
       }
     }
+    const rendered = new Array(nested.length);
     for (let i = 0; i < nested.length; i++) {
-      const child = document.createElement("div");
-      child.innerHTML = nested[i].html;
-      const inner = child.firstElementChild;
-      wrapper.appendChild(inner ?? child);
+      wrapper.appendChild(nestedChild(nested[i].html));
+      rendered[i] = nested[i].html;
     }
+    mb.container = { wrapper, offset, openTag: openTagOf(b.html), title, nested: rendered };
     return wrapper;
   }
+  function nestedChild(html) {
+    const child = document.createElement("div");
+    child.innerHTML = html;
+    return child.firstElementChild ?? child;
+  }
+  function syncKeyedContainer(kc, b) {
+    keyedAttempts++;
+    const nested = b.kind.data?.nested;
+    if (!Array.isArray(nested)) return false;
+    if (openTagOf(b.html) !== kc.openTag) return false;
+    if (b.kind.type === "Alert" && alertTitleHtml(b.html) !== kc.title) return false;
+    const cur = kc.nested;
+    const kids = kc.wrapper.children;
+    if (kids.length !== kc.offset + cur.length) return false;
+    const n = nested.length;
+    while (cur.length > n) {
+      kc.wrapper.removeChild(kc.wrapper.lastElementChild);
+      cur.pop();
+    }
+    for (let i = 0; i < cur.length; i++) {
+      if (cur[i] === nested[i].html) continue;
+      kc.wrapper.replaceChild(nestedChild(nested[i].html), kids[kc.offset + i]);
+      cur[i] = nested[i].html;
+    }
+    for (let i = cur.length; i < n; i++) {
+      kc.wrapper.appendChild(nestedChild(nested[i].html));
+      cur.push(nested[i].html);
+    }
+    keyedHits++;
+    return true;
+  }
   function buildKeyedTable(b, data, mb) {
     const node = document.createElement("div");
     node.className = "brook-block brook-block-table brook-open" + (b.speculative ? " brook-speculative" : "");
@@ -352,6 +498,8 @@ function mountBrookMarkdown(client, container, options = {}) {
   }
   function renderCodeBlock(b, mb) {
     const lang = extractLang(b.html) || "text";
+    mb.codeInc = void 0;
+    mb.plainCode = void 0;
     const text = b.open ? "" : codeText(b);
     let openMarkup = null;
     if (b.open && streamingHighlight) {
@@ -386,7 +534,9 @@ function mountBrookMarkdown(client, container, options = {}) {
     const body = document.createElement("div");
     body.className = "brook-code-body";
     if (highlighted !== null) {
-      body.appendChild(highlightedPre(lang, highlighted));
+      body.appendChild(
+        openMarkup !== null && mb.inc !== void 0 && !fullRebuild ? incPre(lang, mb, mb.inc, openMarkup) : highlightedPre(lang, highlighted)
+      );
     } else {
       const div = document.createElement("div");
       div.tabIndex = 0;
@@ -394,12 +544,14 @@ function mountBrookMarkdown(client, container, options = {}) {
       div.setAttribute("aria-label", `${lang} code`);
       div.innerHTML = b.html;
       body.appendChild(div);
+      if (b.open) mb.plainCode = div;
       if (run !== null && run.rest !== null) {
         mb.highlight = run;
         run.rest.then((markup) => {
           if (markup === null || dead) return;
           if (mb.highlight !== run || mb.node !== block) return;
           mb.highlight = void 0;
+          mb.plainCode = void 0;
           body.replaceChild(highlightedPre(lang, markup), div);
         });
       }
@@ -407,6 +559,25 @@ function mountBrookMarkdown(client, container, options = {}) {
     block.appendChild(body);
     return block;
   }
+  function syncIncCode(mb, b) {
+    const ic = mb.codeInc;
+    if ((extractLang(b.html) || "text") !== ic.lang) return false;
+    const markup = incHighlight(mb.inc, codeText(b));
+    if (markup === null) return false;
+    return paintIncCode(ic, mb.inc, markup);
+  }
+  function incPre(lang, mb, st, markup) {
+    const pre = document.createElement("pre");
+    pre.tabIndex = 0;
+    pre.setAttribute("role", "region");
+    pre.setAttribute("aria-label", `${lang} code`);
+    const code = document.createElement("code");
+    const ic = newIncCode(code, lang, st);
+    if (paintIncCode(ic, st, markup)) mb.codeInc = ic;
+    else code.innerHTML = markup;
+    pre.appendChild(code);
+    return pre;
+  }
   function highlightedPre(lang, markup) {
     const pre = document.createElement("pre");
     pre.tabIndex = 0;
@@ -515,6 +686,8 @@ function mountBrookMarkdown(client, container, options = {}) {
           mb.highlight = void 0;
         }
         mb.inc = void 0;
+        mb.codeInc = void 0;
+        mb.plainCode = void 0;
       }
       root.remove();
     },
@@ -608,9 +781,12 @@ function decodeCodeText(html) {
   return m[1].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
 }
 const CONTAINER_ATTR_RE = /([a-zA-Z][a-zA-Z0-9-]*)="([^"]*)"/g;
-function applyOpenTagAttrs(el, html) {
+function openTagOf(html) {
   const gt = html.indexOf(">");
-  const open = gt < 0 ? html : html.slice(0, gt);
+  return gt < 0 ? html : html.slice(0, gt);
+}
+function applyOpenTagAttrs(el, html) {
+  const open = openTagOf(html);
   let m;
   CONTAINER_ATTR_RE.lastIndex = 0;
   while (m = CONTAINER_ATTR_RE.exec(open)) {
@@ -669,6 +845,8 @@ function applyUrlTransformDom(root, urlTransform) {
   });
 }
 export {
+  __keyedStats,
+  __resetKeyedStats,
   mountBrookMarkdown,
   tailOpenBlockId
 };

package/dist/hi-inc.d.ts

@@ -53,6 +53,31 @@ export interface IncState {
     c: number;
     /** Markup for `[0, c)`. Always a byte-prefix of the block's final markup. */
     frozenHtml: string;
+    /**
+     * Bumped whenever `frozenHtml` is TRUNCATED or cleared — the one checkpoint of
+     * rewind {@link adopt} performs, or a restart. It never moves while the prefix
+     * merely GROWS.
+     *
+     * A renderer that mirrors the frozen prefix into the DOM append-only reads it
+     * as the "may I splice?" token: same rev ⇒ the prefix only grew, so appending
+     * `frozenHtml.slice(alreadyWritten)` is exact; a changed rev means the prefix
+     * was rewritten underneath and the mirror must be re-seeded. Length alone is
+     * NOT enough — one call can rewind to `c0` and then re-freeze past the old
+     * length, which looks like a plain append but is not one.
+     */
+    frozenRev: number;
+    /**
+     * The length `frozenHtml` was TRUNCATED to at the last {@link frozenRev} bump:
+     * `frozenLen0` for {@link adopt}'s one-checkpoint rewind, `0` for a restart.
+     *
+     * The rev alone says "rewritten"; this says *from where*, which is what lets a
+     * DOM mirror rewind to a boundary it already holds instead of re-seeding the
+     * whole run. It is load-bearing that this is reported rather than inferred:
+     * `adopt` frequently rewinds and then re-freezes PAST the old length within
+     * the same call, so the observable `frozenHtml.length` can come back unchanged
+     * while its bytes have moved.
+     */
+    frozenCut: number;
     /** The checkpoint BEFORE `c`, and the `frozenHtml` length that went with it —
      *  the one step of rewind a tail revision needs (see {@link adopt}). */
     c0: number;

package/dist/hi-inc.js

@@ -72,6 +72,8 @@ function createInc(lang) {
     lang: key,
     c: 0,
     frozenHtml: "",
+    frozenRev: 0,
+    frozenCut: 0,
     c0: 0,
     frozenLen0: 0,
     opener: null,
@@ -97,6 +99,8 @@ function adopt(st, d) {
   }
   if (st.c0 > 0 && d >= st.c0 + GAP) {
     st.frozenHtml = st.frozenHtml.slice(0, st.frozenLen0);
+    st.frozenRev++;
+    st.frozenCut = st.frozenLen0;
     st.c = st.c0;
     st.c0 = 0;
     st.frozenLen0 = 0;
@@ -117,6 +121,8 @@ function dropTail(st) {
 function reset(st) {
   st.c = 0;
   st.frozenHtml = "";
+  st.frozenRev++;
+  st.frozenCut = 0;
   st.c0 = 0;
   st.frozenLen0 = 0;
   st.opener = null;

package/dist/html-to-react.d.ts

@@ -19,6 +19,8 @@ type HNode = {
  */
 export declare function parseStyle(css: string): Record<string, string>;
 export declare function getParseCount(): number;
+/** @internal Test-only. Characters of markup handed to the tokenizer so far. */
+export declare function getParseChars(): number;
 export declare function resetParseCount(): void;
 export declare function parseTrustedHtml(html: string): HNode[];
 /**

package/dist/html-to-react.js

@@ -131,14 +131,20 @@ function parseOpenTag(html, start) {
   return { tag, attrs, selfClose: false, next: i };
 }
 let parseCount = 0;
+let parseChars = 0;
 function getParseCount() {
   return parseCount;
 }
+function getParseChars() {
+  return parseChars;
+}
 function resetParseCount() {
   parseCount = 0;
+  parseChars = 0;
 }
 function parseTrustedHtml(html) {
   parseCount++;
+  parseChars += html.length;
   const root = [];
   const stack = [];
   let i = 0;
@@ -357,6 +363,7 @@ function wrapLink(text, attrs) {
 }
 export {
   decodeEntities,
+  getParseChars,
   getParseCount,
   htmlToReact,
   parseStyle,

package/dist/react-splice.d.ts

@@ -0,0 +1,32 @@
+import { type MutableRefObject } from "react";
+import type { Block } from "./types-core.js";
+/**
+ * Let a layout effect own an element's children so an OPEN block's patch is
+ * applied incrementally (see splice.ts) instead of re-setting the whole
+ * `dangerouslySetInnerHTML` every time it grows.
+ *
+ * ## How React and the effect share the node
+ *
+ * The returned string is the html captured on the FIRST render and never
+ * changes again. Render it as the node's `__html` and React writes the element
+ * exactly once, at mount — its own `lastHtml !== nextHtml` check then keeps it
+ * from touching the children on any later commit, and the effect owns them from
+ * there.
+ *
+ * That is what makes this safe under concurrent rendering: a render that is
+ * thrown away commits nothing and runs no effect, and the effect's own
+ * bookkeeping makes a repeat run (StrictMode's double-invoke) a no-op. It also
+ * leaves SSR and hydration byte-identical, because the first markup React
+ * produces is still the block's full html.
+ *
+ * The caller hands the node BACK to React by rendering a different element
+ * (a closed block's plain `<div dangerouslySetInnerHTML>`), which remounts the
+ * subtree and re-renders the settled html in one pass.
+ *
+ * @param hostRef ref attached to the element whose children are managed
+ * @param block   the block's CURRENT version (identity matters — `spliceKeep`
+ *                is keyed on it)
+ * @param enabled false to stay entirely out of the way
+ * @returns the html to render as `__html`, or `null` when not managing
+ */
+export declare function useHtmlSplice(hostRef: MutableRefObject<HTMLElement | null>, block: Block | undefined, enabled: boolean): string | null;

package/dist/react-splice.js

@@ -0,0 +1,33 @@
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { spliceHtml, spliceKeep } from "./splice.js";
+const useIsoLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function useHtmlSplice(hostRef, block, enabled) {
+  const seed = useRef(block);
+  const applied = useRef(null);
+  useIsoLayoutEffect(() => {
+    const base = seed.current;
+    if (!enabled || block === void 0 || base === void 0) {
+      applied.current = null;
+      return;
+    }
+    const node = hostRef.current;
+    if (node === null) return;
+    let prev = applied.current;
+    if (prev === null || prev.node !== node) prev = { node, block: base };
+    if (prev.block === block) {
+      applied.current = prev;
+      return;
+    }
+    const keep = spliceKeep(prev.block, block);
+    if (keep !== void 0 && spliceHtml(node, prev.block.html, block.html, keep)) {
+      applied.current = { node, block };
+      return;
+    }
+    node.innerHTML = block.html;
+    applied.current = { node, block };
+  });
+  return enabled && seed.current !== void 0 ? seed.current.html : null;
+}
+export {
+  useHtmlSplice
+};

package/dist/react.d.ts

@@ -144,6 +144,15 @@ interface BrookMarkdownProps {
      * the block — an override bypasses the built-in highlighter entirely.
      */
     streamingHighlight?: boolean;
+    /**
+     * @internal TEST-ONLY. Turn off the incremental apply paths (the open code
+     * block's frozen/tail mirror and the open generic block's delta splice) so
+     * every patch re-renders the whole block through React, exactly as it did
+     * before they existed. The DOM-parity fuzz renders one tree with it on and one
+     * with it off and asserts their markup matches after every commit. Not part of
+     * the supported API.
+     */
+    __fullRebuild?: boolean;
     /** Appended to the root's `className` (the `brook-md` class is always present). */
     className?: string;
     /** Set on the root element. */
@@ -281,6 +290,8 @@ interface BlockViewProps {
     sanitize?: (html: string) => string;
     childMemo?: boolean;
     streamingHighlight?: boolean;
+    /** @internal TEST-ONLY — see BrookMarkdownProps.__fullRebuild. */
+    __fullRebuild?: boolean;
     onRenderMetrics?: RenderMetricsHook;
     decorators?: Decorator[];
     urlTransform?: UrlTransform;

package/dist/react.js

@@ -15,6 +15,7 @@ import { CodeBlock } from "./renderers/CodeBlock.js";
 import { MathBlock } from "./renderers/Math.js";
 import { Mermaid } from "./renderers/Mermaid.js";
 import { htmlToReact } from "./html-to-react.js";
+import { useHtmlSplice } from "./react-splice.js";
 import { warnOnce } from "./warn.js";
 const NO_DEFER_BLOCKS = [];
 const EMPTY_KEYS = [];
@@ -53,6 +54,7 @@ function BrookMarkdownFromClient({
   sanitize,
   childMemo,
   streamingHighlight,
+  __fullRebuild,
   className,
   id,
   role,
@@ -106,6 +108,7 @@ function BrookMarkdownFromClient({
                 sanitize,
                 childMemo,
                 streamingHighlight,
+                __fullRebuild,
                 onRenderMetrics: onMetrics,
                 decorators,
                 urlTransform,
@@ -314,6 +317,18 @@ function SafeHtml({
     return htmlToReact(html, components, map, opts);
   }, [html, components, childMemo, decorators, urlTransform]);
 }
+function SplicedBlock({ className, block }) {
+  const host = useRef(null);
+  const seedHtml = useHtmlSplice(host, block, true);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className,
+      ref: host,
+      dangerouslySetInnerHTML: { __html: seedHtml ?? block.html }
+    }
+  );
+}
 function KeyedListItemImpl({
   html,
   components,
@@ -489,6 +504,7 @@ function renderBlockContent({
   sanitize,
   childMemo,
   streamingHighlight,
+  __fullRebuild,
   decorators,
   urlTransform
 }) {
@@ -519,7 +535,9 @@ function renderBlockContent({
             html: block.html,
             open: block.open,
             code: typeof source === "string" ? source : void 0,
-            streamingHighlight
+            streamingHighlight,
+            block,
+            __fullRebuild
           }
         );
       }
@@ -555,13 +573,13 @@ function renderBlockContent({
       );
     }
   }
-  if (components || hasInlineTransforms) {
-    if (components && !hasInlineTransforms && block.open && !sanitize && (kind === "Blockquote" || kind === "Alert")) {
-      const nested = block.kind.data?.nested;
-      if (Array.isArray(nested)) {
-        return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsx(KeyedContainer, { block, nested, components }) });
-      }
+  if (block.open && !sanitize && !hasInlineTransforms && (kind === "Blockquote" || kind === "Alert")) {
+    const nested = block.kind.data?.nested;
+    if (Array.isArray(nested)) {
+      return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsx(KeyedContainer, { block, nested, components: components ?? NO_COMPONENTS }) });
     }
+  }
+  if (components || hasInlineTransforms) {
     const safe = sanitize ? sanitize(block.html) : block.html;
     return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsx(
       SafeHtml,
@@ -574,6 +592,9 @@ function renderBlockContent({
       }
     ) });
   }
+  if (block.open && !sanitize && !__fullRebuild) {
+    return /* @__PURE__ */ jsx(SplicedBlock, { className, block });
+  }
   return /* @__PURE__ */ jsx(
     "div",
     {
@@ -584,7 +605,7 @@ function renderBlockContent({
 }
 function blocksEqual(prev, next) {
   if (prev.block == null || next.block == null) return prev.block === next.block;
-  return prev.block.id === next.block.id && prev.block.html === next.block.html && prev.block.open === next.block.open && prev.block.speculative === next.block.speculative && prev.components === next.components && prev.virtualize === next.virtualize && prev.sanitize === next.sanitize && prev.childMemo === next.childMemo && prev.streamingHighlight === next.streamingHighlight && prev.onRenderMetrics === next.onRenderMetrics && // Identity compare: an unstable decorators/urlTransform (fresh each render)
+  return prev.block.id === next.block.id && prev.block.html === next.block.html && prev.block.open === next.block.open && prev.block.speculative === next.block.speculative && prev.components === next.components && prev.virtualize === next.virtualize && prev.sanitize === next.sanitize && prev.childMemo === next.childMemo && prev.streamingHighlight === next.streamingHighlight && prev.__fullRebuild === next.__fullRebuild && prev.onRenderMetrics === next.onRenderMetrics && // Identity compare: an unstable decorators/urlTransform (fresh each render)
   // busts the memo so every committed block re-decorates — the O(n²) footgun
   // the dev warning calls out. A hoisted/memoized value keeps the memo holding.
   prev.decorators === next.decorators && prev.urlTransform === next.urlTransform && // Same identity rule as onRenderMetrics: an inline `onBlockError={() => …}`

package/dist/renderers/CodeBlock.d.ts

@@ -1,3 +1,4 @@
+import type { Block } from "../types-core.js";
 interface Props {
     html: string;
     open: boolean;
@@ -10,7 +11,18 @@ interface Props {
     code?: string;
     /** Highlight the block while it is still open. Default true. */
     streamingHighlight?: boolean;
+    /**
+     * The block this markup came from, when the renderer is driven by the stream.
+     * Only used to apply the wire's `html_delta` to the PLAIN escaped body of an
+     * open fence (the `streamingHighlight: false` / no-language path) instead of
+     * re-setting its whole innerHTML each patch. Absent → that body rebuilds, as
+     * it always did.
+     */
+    block?: Block;
+    /** @internal TEST-ONLY: force the pre-mirror path (a full `innerHTML` set of
+     *  the whole markup on every patch) so the parity fuzz has a reference. */
+    __fullRebuild?: boolean;
 }
-declare function CodeBlockImpl({ html, open, code, streamingHighlight }: Props): import("react/jsx-runtime").JSX.Element;
+declare function CodeBlockImpl({ html, open, code, streamingHighlight, block, __fullRebuild }: Props): import("react/jsx-runtime").JSX.Element;
 export declare const CodeBlock: import("react").MemoExoticComponent<typeof CodeBlockImpl>;
 export {};

package/dist/renderers/CodeBlock.js

@@ -1,15 +1,18 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { highlight } from "../hi.js";
 import { highlightDeferred, highlightWithin } from "../hi-defer.js";
 import { createInc, incHighlight, incSeed } from "../hi-inc.js";
+import { newIncCode, paintIncCode } from "../splice.js";
+import { useHtmlSplice } from "../react-splice.js";
 import { extractLang } from "../block-props.js";
 function decodeText(html) {
   const m = html.match(/<pre><code[^>]*>([\s\S]*?)<\/code><\/pre>/);
   if (!m) return "";
   return m[1].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
 }
-function CodeBlockImpl({ html, open, code, streamingHighlight }) {
+const useIsoLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function CodeBlockImpl({ html, open, code, streamingHighlight, block, __fullRebuild }) {
   const lang = extractLang(html) || "text";
   const text = useMemo(() => open ? "" : code ?? decodeText(html), [html, open, code]);
   const streaming = open && streamingHighlight !== false;
@@ -19,6 +22,9 @@ function CodeBlockImpl({ html, open, code, streamingHighlight }) {
   );
   const incRef = useRef(null);
   const [inc, setInc] = useState(null);
+  const codeRef = useRef(null);
+  const mirrorRef = useRef(null);
+  const plainRef = useRef(null);
   const sync = useMemo(() => {
     if (!text) return null;
     if (typeof window === "undefined") return highlight(text, lang);
@@ -62,10 +68,30 @@ function CodeBlockImpl({ html, open, code, streamingHighlight }) {
       run.cancel();
     };
   }, [text, lang, sync]);
-  const highlighted = sync ?? (slow !== null && slow.text === text && slow.lang === lang ? slow.html : null) ?? // The streaming tail. Not gated on `openText` identity: the markup lags the
-  // props by one commit, and showing last patch's spans beats flashing the
-  // whole block back to plain every tick. A language change does invalidate it.
-  (streaming && inc !== null && inc.lang === lang ? inc.html : null);
+  const settled = sync ?? (slow !== null && slow.text === text && slow.lang === lang ? slow.html : null);
+  const streamed = streaming && inc !== null && inc.lang === lang ? inc.html : null;
+  const highlighted = settled ?? streamed;
+  const mirrored = settled === null && streamed !== null && !__fullRebuild;
+  useIsoLayoutEffect(() => {
+    if (!mirrored) {
+      mirrorRef.current = null;
+      return;
+    }
+    const node = codeRef.current;
+    const st = incRef.current;
+    if (node === null || st === null || streamed === null) return;
+    let m = mirrorRef.current;
+    if (m === null || m.code !== node || m.lang !== lang) {
+      node.innerHTML = "";
+      m = newIncCode(node, lang, st);
+      mirrorRef.current = m;
+    }
+    if (!paintIncCode(m, st, streamed)) {
+      node.innerHTML = streamed;
+      mirrorRef.current = null;
+    }
+  });
+  const plainSeed = useHtmlSplice(plainRef, block, open && highlighted === null && !__fullRebuild);
   const [copied, setCopied] = useState(false);
   const timerRef = useRef(null);
   useEffect(() => {
@@ -117,8 +143,25 @@ function CodeBlockImpl({ html, open, code, streamingHighlight }) {
     /* @__PURE__ */ jsx("div", { className: "brook-code-body", children: highlighted ? (
       // tabIndex=0 + role/label so keyboard users can scroll long code and
       // screen readers announce the region with its language.
-      /* @__PURE__ */ jsx("pre", { tabIndex: 0, role: "region", "aria-label": `${lang} code`, children: /* @__PURE__ */ jsx("code", { dangerouslySetInnerHTML: { __html: highlighted } }) })
-    ) : /* @__PURE__ */ jsx("div", { tabIndex: 0, role: "region", "aria-label": `${lang} code`, dangerouslySetInnerHTML: { __html: html } }) })
+      /* @__PURE__ */ jsx("pre", { tabIndex: 0, role: "region", "aria-label": `${lang} code`, children: mirrored ? (
+        // Rendered with NO children and NO dangerouslySetInnerHTML, so
+        // React never writes into it; the layout effect above owns it.
+        // Same element type and position as the settled form below, so
+        // the close-time swap updates this node in place rather than
+        // remounting it — and React's own innerHTML write at that point
+        // is what discards the mirror's nodes.
+        /* @__PURE__ */ jsx("code", { ref: codeRef })
+      ) : /* @__PURE__ */ jsx("code", { dangerouslySetInnerHTML: { __html: highlighted } }) })
+    ) : /* @__PURE__ */ jsx(
+      "div",
+      {
+        tabIndex: 0,
+        role: "region",
+        "aria-label": `${lang} code`,
+        ref: plainRef,
+        dangerouslySetInnerHTML: { __html: plainSeed ?? html }
+      }
+    ) })
   ] });
 }
 const CodeBlock = memo(CodeBlockImpl);

package/dist/splice.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Incremental DOM application for a streaming block — the two shapes of
+ * "apply this patch without rewriting everything before it".
+ *
+ * 1. {@link paintIncCode} mirrors hi-inc's frozen-prefix / speculative-tail split
+ *    into an open code fence's live `<code>`.
+ * 2. {@link spliceHtml} applies the wire's `html_delta` to a generic block's
+ *    subtree, guided by {@link spliceKeep}.
+ *
+ * Both are shared by the DOM and React renderers so the invariants below have
+ * exactly one implementation.
+ *
+ * ## The generic splice
+ *
+ * A streaming block's html grows at its END: the core appends bytes and then
+ * SPECULATIVELY CLOSES whatever is open, so patch N's html is patch N+1's html
+ * with a different run of closing tags stitched on. The wire already computes
+ * and verifies that boundary (`html_delta.keep_units`, WIRE.md §11), and
+ * `applyPatch` publishes it to renderers as {@link spliceKeep}. What is left is
+ * to apply it to the DOM without re-parsing everything before it.
+ *
+ * ## Why "top-level children" is not enough
+ *
+ * A block's html is usually ONE top-level element — `<p>…</p>`, `<ul>…</ul>`,
+ * `<blockquote>…</blockquote>` — so splicing at that level degenerates to a full
+ * rebuild. The growth point is at the bottom of the chain of elements still OPEN
+ * at the splice offset, and that is where this splices: it walks down that chain
+ * in the live DOM, appends the new markup in the right context, and never
+ * touches a node before the boundary. Everything earlier — including a user's
+ * text selection and a `<pre>`'s scroll offset — survives untouched.
+ *
+ * ## The precondition, and why it is the honest one
+ *
+ * The old html's discarded suffix (`prevHtml.slice(keep)`) must be **pure
+ * structure**: closing tags and inter-tag whitespace, nothing that contributed
+ * real content. That is exactly the speculative-closure shape, and it is what
+ * makes "the DOM built from `prevHtml[0, keep)`" recoverable from the live tree
+ * by removing a bounded amount of trailing whitespace. Anything else — a link
+ * losing its `data-brook-pending` attribute, a literal `**b` becoming
+ * `<strong>b</strong>` — rewrites bytes the old DOM already committed to, and
+ * this bails so the caller rebuilds. Correctness never depends on the fast path
+ * firing; every check below returns `false` rather than guessing.
+ *
+ * The result is byte-identical to `host.innerHTML = nextHtml` when serialized.
+ * The node COUNT can differ (a splice may leave two adjacent text nodes where a
+ * one-shot parse makes one), which is what any streaming DOM append does and
+ * what `innerHTML` parity is checked against.
+ */
+import type { IncState } from "./hi-inc.js";
+import type { Block } from "./types-core.js";
+/** @internal Called by `applyPatch` for every delta-reconstructed active block. */
+export declare function noteSplice(next: Block, prev: Block, keep: number): void;
+/**
+ * The longest common prefix, in UTF-16 units, that `from.html` and `to.html`
+ * provably share — or `undefined` when the wire did not establish one (delta
+ * mode off, a full re-emit, or `from` is further back than {@link SPLICE_DEPTH}).
+ *
+ * The value is the MINIMUM `keep_units` across the patches between them: each
+ * one guarantees its own prefix, so their minimum is a prefix of all of them.
+ * That is conservative — it can be shorter than the true common prefix — and
+ * never wrong, which is the right side to err on when a caller splices at it.
+ *
+ * @internal Renderer-only; not part of the public API.
+ */
+export declare function spliceKeep(from: Block, to: Block): number | undefined;
+/**
+ * The live `<code>` of an OPEN code block, split the way hi-inc splits its
+ * markup: a **frozen** run of children (proven immutable — appended once and
+ * never touched again) followed by a **speculative tail** (rewritten per patch,
+ * bounded by hi-inc's CAP).
+ *
+ * The two regions are NOT wrapped in elements — `frozenEnd` is simply the last
+ * child that belongs to the frozen run — so the resulting `innerHTML` is
+ * byte-identical to the `code.innerHTML = markup` this replaces. Only the node
+ * *count* differs (a splice can leave two adjacent text nodes where a one-shot
+ * parse would have made one), which serializes the same and is exactly what a
+ * browser does for any streamed append.
+ */
+export interface IncCode {
+    code: Element;
+    /** The language the mirror was built for; a change invalidates it. */
+    lang: string;
+    /** Last child of the frozen run — everything after it is the tail. */
+    frozenEnd: ChildNode | null;
+    /** Chars of `IncState.frozenHtml` already mirrored into the DOM. */
+    frozenLen: number;
+    /** The `IncState.frozenRev` that `frozenLen` belongs to. */
+    frozenRev: number;
+    /** The boundary BEFORE `frozenEnd`, and the length that went with it — one
+     *  step of history mirroring hi-inc's own `c0`/`frozenLen0`, which is exactly
+     *  how far hi-inc's `adopt` can rewind. Without it a rewind would have to re-seed
+     *  the whole run, and 18 of those over a 20 KB fence cost more than everything
+     *  else on the streaming path combined. */
+    frozenEnd0: ChildNode | null;
+    frozenLen0: number;
+    /** The tail markup currently in the DOM, so an unchanged tail is not rewritten. */
+    tail: string;
+}
+/** A fresh, empty mirror for a `<code>` that has nothing painted into it yet. */
+export declare function newIncCode(code: Element, lang: string, st: IncState): IncCode;
+/**
+ * Mirror hi-inc's frozen/tail split into a live `<code>`: append whatever the
+ * frozen prefix settled since the last patch, then replace the speculative
+ * tail. Returns false when the mirror cannot be trusted (see the length
+ * invariant below) so the caller falls back to a full node rebuild.
+ *
+ * Cost per patch is |newly frozen| + |tail|. The frozen term sums, across the
+ * whole stream, to one pass over the final markup; the tail is bounded by
+ * hi-inc's CAP. That is what makes an open fence linear at the DOM, not just
+ * at the tokenizer.
+ */
+export declare function paintIncCode(ic: IncCode, st: IncState, markup: string): boolean;
+/**
+ * Apply `prevHtml → nextHtml` to `host`, whose `innerHTML` is exactly
+ * `prevHtml`, given the wire-verified common-prefix length `keep`. Returns
+ * `false` (having changed NOTHING) when the shape is not one it can prove; the
+ * caller then rebuilds as it always did.
+ */
+export declare function spliceHtml(host: Element, prevHtml: string, nextHtml: string, keep: number): boolean;
+/** @internal Test-only. */
+export declare function __spliceStats(): {
+    attempts: number;
+    hits: number;
+};
+/** @internal Test-only. */
+export declare function __resetSpliceStats(): void;

package/dist/splice.js

@@ -0,0 +1,212 @@
+const SPLICE = /* @__PURE__ */ new WeakMap();
+const SPLICE_DEPTH = 8;
+function noteSplice(next, prev, keep) {
+  let old = prev;
+  for (let d = 1; d < SPLICE_DEPTH && old !== void 0; d++) old = SPLICE.get(old)?.prev;
+  if (old !== void 0) SPLICE.delete(old);
+  SPLICE.set(next, { prev, keep });
+}
+function spliceKeep(from, to) {
+  let keep = Infinity;
+  let cur = to;
+  for (let i = 0; i < SPLICE_DEPTH; i++) {
+    const link = SPLICE.get(cur);
+    if (link === void 0) return void 0;
+    if (link.keep < keep) keep = link.keep;
+    if (link.prev === from) return keep;
+    cur = link.prev;
+  }
+  return void 0;
+}
+function newIncCode(code, lang, st) {
+  return {
+    code,
+    lang,
+    frozenEnd: null,
+    frozenLen: 0,
+    frozenRev: st.frozenRev,
+    frozenEnd0: null,
+    frozenLen0: 0,
+    tail: ""
+  };
+}
+function paintIncCode(ic, st, markup) {
+  const frozen = st.frozenHtml;
+  if (markup.length < frozen.length) return false;
+  let rewound = ic.frozenRev !== st.frozenRev || frozen.length < ic.frozenLen;
+  const tail = markup.slice(frozen.length);
+  if (!rewound && frozen.length === ic.frozenLen && tail === ic.tail) return true;
+  if (rewound && st.frozenRev === ic.frozenRev + 1 && st.frozenCut === ic.frozenLen0) {
+    ic.frozenEnd = ic.frozenEnd0;
+    ic.frozenLen = ic.frozenLen0;
+    ic.frozenRev = st.frozenRev;
+    ic.frozenEnd0 = null;
+    ic.frozenLen0 = 0;
+    rewound = false;
+  }
+  const keep = rewound ? null : ic.frozenEnd;
+  while (ic.code.lastChild !== keep) ic.code.removeChild(ic.code.lastChild);
+  if (rewound) {
+    ic.frozenEnd = null;
+    ic.frozenLen = 0;
+    ic.frozenEnd0 = null;
+    ic.frozenLen0 = 0;
+    ic.frozenRev = st.frozenRev;
+  }
+  if (frozen.length > ic.frozenLen) {
+    ic.frozenEnd0 = ic.frozenEnd;
+    ic.frozenLen0 = ic.frozenLen;
+    ic.code.insertAdjacentHTML("beforeend", frozen.slice(ic.frozenLen));
+    ic.frozenEnd = ic.code.lastChild;
+    ic.frozenLen = frozen.length;
+  }
+  if (tail) ic.code.insertAdjacentHTML("beforeend", tail);
+  ic.tail = tail;
+  return true;
+}
+const UNSAFE_CHAIN = /* @__PURE__ */ new Set([
+  // Content models the fragment parser treats specially (raw text, escapable
+  // raw text, foreign content, or a separate document fragment).
+  "template",
+  "svg",
+  "math",
+  "script",
+  "style",
+  "textarea",
+  "title",
+  "noscript",
+  "noframes",
+  "iframe",
+  "xmp",
+  "plaintext",
+  "listing",
+  // Foster parenting relocates non-table content out of these, so a scaffold
+  // parse would not place the appended nodes where a whole parse does.
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "select",
+  "optgroup"
+]);
+const UNSAFE_TIP = /* @__PURE__ */ new Set(["pre", "listing", "textarea"]);
+const CLOSE_TAG_NAME = /^[a-zA-Z][a-zA-Z0-9-]*$/;
+function scanTail(t) {
+  const ops = [];
+  let i = 0;
+  let closes = 0;
+  while (i < t.length) {
+    if (t.charCodeAt(i) === 60) {
+      if (t.charCodeAt(i + 1) !== 47) return null;
+      const gt = t.indexOf(">", i + 2);
+      if (gt === -1) return null;
+      const name = t.slice(i + 2, gt);
+      if (!CLOSE_TAG_NAME.test(name)) return null;
+      ops.push({ close: name.toLowerCase() });
+      closes++;
+      i = gt + 1;
+      continue;
+    }
+    let j = i;
+    while (j < t.length && t.charCodeAt(j) !== 60) j++;
+    const run = t.slice(i, j);
+    if (/\S/.test(run)) return null;
+    ops.push({ ws: run });
+    i = j;
+  }
+  return closes > 0 ? ops : null;
+}
+function spliceHtml(host, prevHtml, nextHtml, keep) {
+  attempts++;
+  if (keep <= 0 || keep >= prevHtml.length || keep > nextHtml.length) return false;
+  const ops = scanTail(prevHtml.slice(keep));
+  if (ops === null) return false;
+  const closes = [];
+  for (const op of ops) if ("close" in op) closes.push(op.close);
+  const n = closes.length;
+  const chain = new Array(n + 1);
+  chain[0] = host;
+  for (let d2 = 1; d2 <= n; d2++) {
+    const want = closes[n - d2];
+    if (UNSAFE_CHAIN.has(want)) return false;
+    if (d2 === n && UNSAFE_TIP.has(want)) return false;
+    const el = chain[d2 - 1].lastElementChild;
+    if (el === null || el.tagName.toLowerCase() !== want) return false;
+    chain[d2] = el;
+  }
+  const strips = [];
+  const ws = new Array(n + 1);
+  let d = n;
+  for (const op of ops) {
+    if ("close" in op) {
+      d--;
+      continue;
+    }
+    if (ws[d] !== void 0) return false;
+    ws[d] = op.ws;
+  }
+  if (d !== 0) return false;
+  for (let i = 0; i <= n; i++) {
+    const w = ws[i];
+    const last = chain[i].lastChild;
+    if (w === void 0 || w === "") {
+      if (i < n && last !== chain[i + 1]) return false;
+      continue;
+    }
+    if (last === null || last.nodeType !== 3) return false;
+    const data = last.nodeValue ?? "";
+    if (i < n) {
+      if (data !== w || last.previousSibling !== chain[i + 1]) return false;
+    } else if (!data.endsWith(w)) {
+      return false;
+    }
+    strips.push({ text: last, ws: w });
+  }
+  let scaffold = "";
+  for (let i = 1; i <= n; i++) scaffold += `<${chain[i].tagName.toLowerCase()}>`;
+  const tmp = host.ownerDocument.createElement("div");
+  tmp.innerHTML = scaffold + nextHtml.slice(keep);
+  const sc = new Array(n + 1);
+  sc[0] = tmp;
+  for (let i = 1; i <= n; i++) {
+    const el = sc[i - 1].firstChild;
+    if (el === null || el.nodeType !== 1) return false;
+    const e = el;
+    if (e.tagName !== chain[i].tagName) return false;
+    sc[i] = e;
+  }
+  for (const strip of strips) {
+    const data = strip.text.nodeValue ?? "";
+    if (data.length === strip.ws.length) strip.text.parentNode?.removeChild(strip.text);
+    else strip.text.nodeValue = data.slice(0, data.length - strip.ws.length);
+  }
+  for (let i = n; i >= 0; i--) {
+    let node = i === n ? sc[i].firstChild : sc[i + 1].nextSibling;
+    while (node !== null) {
+      const next = node.nextSibling;
+      chain[i].appendChild(node);
+      node = next;
+    }
+  }
+  hits++;
+  return true;
+}
+let attempts = 0;
+let hits = 0;
+function __spliceStats() {
+  return { attempts, hits };
+}
+function __resetSpliceStats() {
+  attempts = 0;
+  hits = 0;
+}
+export {
+  __resetSpliceStats,
+  __spliceStats,
+  newIncCode,
+  noteSplice,
+  paintIncCode,
+  spliceHtml,
+  spliceKeep
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brookmd",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Zero-dep streaming markdown for the browser. Rust→WASM core, Web Worker per stream, incremental parse with speculative closure.",
   "type": "module",
   "sideEffects": ["./dist/worker.js", "./dist/styles.css"],