brookmd 0.27.0 → 0.29.0

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/element.js

@@ -20,7 +20,8 @@ const CONFIG_ATTRS = [
   "soft-breaks",
   "a11y",
   "unsafe-html",
-  "block-html"
+  "block-html",
+  "retain-committed-html"
 ];
 function defineBrookMarkdown(tag = "brook-markdown") {
   if (typeof customElements === "undefined") return;
@@ -162,6 +163,7 @@ function defineBrookMarkdown(tag = "brook-markdown") {
       set("a11y", "a11y");
       set("unsafe-html", "unsafeHtml");
       set("block-html", "blockHtml");
+      set("retain-committed-html", "retainCommittedHtml");
       const tags = this.getAttribute("component-tags");
       if (tags !== null) {
         const list = tags.split(/[\s,]+/).filter(Boolean);

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/index.d.ts

@@ -15,7 +15,8 @@
  *     // ... wherever your tokens land: client.append(deltaText);
  *     client.finalize();
  */
-export { BrookClient, BrookPool, getDefaultPool } from "./client.js";
+export { BrookClient, BrookPool, getDefaultPool, sourceFingerprint } from "./client.js";
+export type { PersistableSnapshot } from "./client.js";
 export { BrookMarkdown, useBrookStream, useBrookMarkdownString } from "./react.js";
 export { highlight, supportedLangs } from "./hi.js";
 export { htmlToReact, parseTrustedHtml, safeUrl, wrapLink } from "./html-to-react.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { BrookClient, BrookPool, getDefaultPool } from "./client.js";
+import { BrookClient, BrookPool, getDefaultPool, sourceFingerprint } from "./client.js";
 import { BrookMarkdown, useBrookStream, useBrookMarkdownString } from "./react.js";
 import { highlight, supportedLangs } from "./hi.js";
 import { htmlToReact, parseTrustedHtml, safeUrl, wrapLink } from "./html-to-react.js";
@@ -11,6 +11,7 @@ export {
   htmlToReact,
   parseTrustedHtml,
   safeUrl,
+  sourceFingerprint,
   supportedLangs,
   useBrookMarkdownString,
   useBrookStream,

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;