brookmd 0.27.0 → 0.29.0

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

@@ -54,6 +54,7 @@ function makeParser(config) {
   p.setBlockHtml(config?.blockHtml ?? false);
   p.setAllowSchemes(config?.allowSchemes ?? []);
   p.setBlockData(config?.blockData ?? false);
+  p.setRetainCommittedHtml(true);
   return p;
 }
 function requireReady() {

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/dist/types-core.d.ts

@@ -513,6 +513,22 @@ export interface ParserConfig {
      * serde bytes; output and the `kind` serde shape stay byte-identical when off).
      */
     blockData?: boolean;
+    /**
+     * Keep every committed block's rendered HTML retained **inside the parser**.
+     *
+     * Defaults to **false on the streaming path** (the worker), which is what you
+     * want: the client receives each committed block exactly once, in the patch
+     * that commits it, and stores it itself — so a second copy sitting in WASM for
+     * the life of the stream serves nobody. Dropping it roughly halves a long
+     * stream's retained bytes (`onPatch`'s `retainedBytes`); the wire is
+     * byte-identical either way.
+     *
+     * Set `true` only if you need the parser itself to still hold the whole
+     * rendered document. The server one-shot renderers (`renderToString`,
+     * `parseToBlocks`) read the document back out of the parser and therefore pin
+     * this on regardless of what you pass.
+     */
+    retainCommittedHtml?: boolean;
 }
 export type ToWorker = {
     type: "append";

package/dist/wasm/brook_md_core.d.ts

@@ -139,6 +139,18 @@ export class BrookParser {
      * markers all stay strictly conformant.
      */
     setLenientLists(on: boolean): void;
+    /**
+     * Keep every committed block's rendered HTML retained inside the parser for
+     * `allBlocks()`. ON by default. Turn it OFF in a pure STREAMING consumer —
+     * one that reads each committed block exactly once out of its patch and
+     * never calls `allBlocks()` (the npm worker): the HTML is then released the
+     * moment the block is emitted, so a long stream retains the source buffer
+     * plus the open tail instead of the whole rendered document (`retainedBytes`
+     * reflects it). Patch bytes are identical either way; the only cost is that
+     * `allBlocks()` then reports committed blocks with an EMPTY `html` (id,
+     * kind, start, end, open, speculative all stay exact).
+     */
+    setRetainCommittedHtml(on: boolean): void;
     /**
      * Render a CommonMark SOFT line break (a bare `\n` in inline content) as a
      * `<br>` — the `remark-breaks` convention, where one Enter is one visual
@@ -188,6 +200,7 @@ export interface InitOutput {
     readonly brookparser_setHtmlSanitize: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly brookparser_setInlineComponentTags: (a: number, b: number, c: number) => void;
     readonly brookparser_setLenientLists: (a: number, b: number) => void;
+    readonly brookparser_setRetainCommittedHtml: (a: number, b: number) => void;
     readonly brookparser_setSoftBreaks: (a: number, b: number) => void;
     readonly brookparser_setUnsafeHtml: (a: number, b: number) => void;
     readonly brookparser_setWireDelta: (a: number, b: number) => void;

package/dist/wasm/brook_md_core.js

@@ -290,6 +290,21 @@ export class BrookParser {
     setLenientLists(on) {
         wasm.brookparser_setLenientLists(this.__wbg_ptr, on);
     }
+    /**
+     * Keep every committed block's rendered HTML retained inside the parser for
+     * `allBlocks()`. ON by default. Turn it OFF in a pure STREAMING consumer —
+     * one that reads each committed block exactly once out of its patch and
+     * never calls `allBlocks()` (the npm worker): the HTML is then released the
+     * moment the block is emitted, so a long stream retains the source buffer
+     * plus the open tail instead of the whole rendered document (`retainedBytes`
+     * reflects it). Patch bytes are identical either way; the only cost is that
+     * `allBlocks()` then reports committed blocks with an EMPTY `html` (id,
+     * kind, start, end, open, speculative all stay exact).
+     * @param {boolean} on
+     */
+    setRetainCommittedHtml(on) {
+        wasm.brookparser_setRetainCommittedHtml(this.__wbg_ptr, on);
+    }
     /**
      * Render a CommonMark SOFT line break (a bare `\n` in inline content) as a
      * `<br>` — the `remark-breaks` convention, where one Enter is one visual

package/dist/wasm/brook_md_core_bg.wasm.d.ts

@@ -22,6 +22,7 @@ export const brookparser_setGfmTagfilter: (a: number, b: number) => void;
 export const brookparser_setHtmlSanitize: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const brookparser_setInlineComponentTags: (a: number, b: number, c: number) => void;
 export const brookparser_setLenientLists: (a: number, b: number) => void;
+export const brookparser_setRetainCommittedHtml: (a: number, b: number) => void;
 export const brookparser_setSoftBreaks: (a: number, b: number) => void;
 export const brookparser_setUnsafeHtml: (a: number, b: number) => void;
 export const brookparser_setWireDelta: (a: number, b: number) => void;

package/dist/worker.js

@@ -29,6 +29,7 @@ const core = new WorkerCore({
     p.setBlockHtml(c?.blockHtml ?? false);
     p.setAllowSchemes(c?.allowSchemes ?? []);
     p.setBlockData(c?.blockData ?? false);
+    p.setRetainCommittedHtml(c?.retainCommittedHtml ?? false);
     p.setWireDelta(true);
     return p;
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brookmd",
-  "version": "0.27.0",
+  "version": "0.29.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"],