flux-md 0.19.0 → 0.20.1

package/CHANGELOG.md

@@ -4,6 +4,78 @@ Notable changes to flux-md. Format based on
 [Keep a Changelog](https://keepachangelog.com/); this project aims to follow
 [Semantic Versioning](https://semver.org/).
 
+## 0.20.0 — 2026-07-02
+
+### Added
+
+- **Streaming links render cleanly from the first character.** An open link's
+  label used to show as raw bracketed text (`[Earnings Call](`) until the URL
+  started arriving, then snap into an anchor. The label now renders inside an
+  inert pending anchor from its first character — no brackets, no raw URL, and
+  the pending HTML is byte-stable through the whole URL so completion is a
+  single attribute swap (no DOM churn). Pending anchors carry
+  `data-flux-pending=""` (gone the moment `href` lands, never in final output)
+  so you can style them like settled links immediately; the optional theme
+  does this out of the box. Deliberate exclusions so common non-link brackets
+  never flash as links: footnote refs (`[^1]`), task checkboxes, alert
+  markers, and all-digit citation labels (`[1]`, `[12]`).
+- **`gfmTagfilter`** — the GFM "Disallowed Raw HTML" extension, opt-in like
+  the other GFM options (`gfm-tagfilter` on the custom element,
+  `with_gfm_tagfilter` in the core). With raw HTML enabled, the nine
+  page-hijacking tags (`title`, `textarea`, `style`, `xmp`, `iframe`,
+  `noembed`, `noframes`, `script`, `plaintext`) get their leading `<`
+  escaped, matching GitHub's rendering. The GFM extension suite is now 24/24.
+
+### Performance
+
+- **Fourteen classes of streaming O(n²) eliminated.** An adversarial
+  multi-agent audit probed 137 document shapes, confirmed 17 quadratic
+  root-cause groups at the work-counter level, and this release fixes 14 —
+  every one now streams in O(new bytes) and is pinned linear by the
+  deterministic complexity gate (now three counters: slow-path scans,
+  inline-render bytes, emitted bytes). Highlights at 512 KB streamed in
+  256-byte chunks unless noted:
+  - **CRLF input** made every incremental cache bail — a plain list cost
+    49.4 s; now line endings normalize at ingest and CRLF streams cost the
+    same as LF (210 ms).
+  - **Footnotes**: a no-blank run of definitions stalled commits and every
+    append recloned the footnote maps — a list with per-item refs cost 48 s
+    at 256 KB; now 200 ms.
+  - **Link-reference definitions inside blockquotes** armed no cache
+    (44 s → 134 ms); lazy continuation lines no longer disarm quote caches.
+  - **Open list items with multi-line bodies** re-rendered whole every
+    append (23 s → 0.3 s); legal interior blank lines no longer permanently
+    disarm the list/indented-code caches (5 s → 54 ms).
+  - **Tables**: the growing trailing row re-split and re-rendered every
+    append (23.8 s → 254 ms; a thousand-column row 25.4 s → 65 ms).
+  - **`blockData` mode** disabled the container cache outright (a 256 KB
+    alert cost 41.7 s → 226 ms, 185×) and rebuilt code/math/list/table data
+    channels from scratch per append (512 KB math fence 7.4 s → 132 ms).
+  - **Streaming component blocks** (`<Chart>` bodies), giant headings,
+    thematic breaks, and growing fence info strings had no incremental cache
+    at all (a 256 KB component body 48 s → 345 ms).
+  - **Inline engine**: emphasis edits now apply in one forward pass instead
+    of per-pair splicing, unpairable delimiters no longer rescan the whole
+    stack (the CommonMark mod-3 pathology was 54 s for a one-shot 256 KB
+    render — now 51 ms, and it hit server-side rendering too), unmatched `$`
+    with math enabled no longer rescans to end-of-input per candidate
+    (57.7 s → 33 ms), and space-free text (entities, long tokens) commits
+    incrementally instead of pinning the whole paragraph.
+  - HTML blocks whose appends landed exactly on line boundaries dropped
+    their cache every append (7.7 s → 59 ms).
+- WASM binary: 197 KB (+28 KB), the cost of seven new incremental caches.
+
+### Fixed
+
+- CRLF documents no longer leak raw `\r` bytes into rendered code blocks;
+  CRLF output is byte-identical to the LF equivalent (line endings are
+  equivalent per CommonMark).
+- Two latent mid-stream parity divergences (speculative rendering at
+  whitespace-only tails; a link-reference definition on an alert's first
+  body line) now match the one-shot render exactly.
+- A link awaiting its title (`[label](url "ti…`) no longer flashes literal
+  source mid-stream.
+
 ## 0.19.0 — 2026-06-30
 
 ### Added

package/README.md

@@ -156,7 +156,12 @@ use it from any binding.
 > append-only so parsing stays incremental. Re-transforming the *whole* string
 > each token (so earlier bytes change) forces `setContent` to reparse every tick
 > (O(n²)); that's what render-time overrides avoid. `setContent`'s reset path is
-> for the **once**-at-the-end reprocess swap, not per-token rewrites.
+> for the **once**-at-the-end reprocess swap, not per-token rewrites. That swap
+> is seamless: the current view stays on screen while the new string reparses —
+> the document never blanks, scroll never moves, and blocks whose rendered
+> content is unchanged keep their identity (and React keys), so only genuinely
+> changed blocks re-render. (`setContent("")` is an explicit clear and resets
+> immediately.)
 
 <details>
 <summary>Full manual control (caller-owned client)</summary>
@@ -467,9 +472,41 @@ export default function Doc({ md }: { md: string }) {
 | Where parse runs | Web Worker (off main thread) | Main thread |
 | Block identity across chunks | Stable monotonic IDs | New keys on every render |
 | Mid-stream unclosed `` ``` `` / `*` / `**` | Speculatively closed in render, replaced cleanly | Often renders raw or breaks |
+| Half-streamed link `[label](https://…` | Label-only inert anchor (`data-flux-pending`), URL never leaks | Raw brackets + partial URL flash |
 | Heavy renderers (syntax, math, mermaid) | Deferred until block close | Re-run per chunk |
 | XSS sanitization | Allowlist in Rust + URL scheme check | Downstream sanitizer pass on the JS thread |
 
+### Streaming links
+
+A link's destination is the last thing a model emits — `[Earnings Call](https://…`
+often spans many tokens. While a link is still streaming, flux-md renders it as
+an **inert, label-only anchor**: the label text inside an `<a>` with no `href`
+(the half-typed URL never flashes on screen), marked so you can style it:
+
+```html
+<a data-flux-pending="" target="_blank" rel="noopener noreferrer nofollow">Earnings Call</a>
+```
+
+An anchor without an `href` gets **no default link styling** from the browser, so
+without a rule for the marker the link would "pop" blue only when the URL
+completes. The bundled theme (`import "flux-md/styles.css"`) already styles it;
+if you bring your own CSS, copy this:
+
+```css
+.flux-md a[data-flux-pending] {
+  color: var(--flux-accent, #0969da); /* match your settled link's resting style */
+  cursor: default;                    /* not clickable yet */
+}
+```
+
+The moment the closing `)` arrives, the `href` appears and `data-flux-pending`
+is dropped — committed and finalized output never carry the marker, and the
+finished block is byte-identical to a one-shot parse. Two composition notes:
+`urlTransform` runs only on a real `href`, so it never sees a half-streamed URL
+prefix — only the complete one (it may run again on re-renders while the
+surrounding block is still open); `decorators` skip text
+inside `<a>` by default (`skipInside`), pending or not.
+
 ## Styling
 
 flux-md emits semantic HTML under a `.flux-md` root and **ships no CSS by
@@ -520,9 +557,9 @@ class FluxClient {
   ): Promise<void>;
   finalize(): void;                                 // mark stream complete
   setContent(                                       // drive from a controlled full string
-    full: string,                                   // diffs vs last: prefix → append delta; else reset+reparse
-    opts?: { done?: boolean },                      // done:true → finalize
-  ): void;
+    full: string,                                   // diffs vs last: prefix → append delta; else seamless
+    opts?: { done?: boolean },                      //   reset+reparse (view held, unchanged blocks keep identity)
+  ): void;                                          // done:true → finalize
   reset(): void;                                    // wipe and reuse
   destroy(): void;                                  // free this stream's parser
   whenReady(): Promise<void>;                       // resolves once WASM loaded; rejects on init failure
@@ -555,6 +592,7 @@ const client = new FluxClient({
   config: {
     gfmAutolinks: true,   // bare www./http(s):// URLs + emails → links (default true)
     gfmAlerts: true,      // > [!NOTE] → callouts (default true)
+    gfmTagfilter: false,  // GFM disallowed raw HTML: escape <script>/<title>/… under unsafeHtml (default false)
     gfmFootnotes: true,   // [^1] + [^1]: → footnote section (default false)
     gfmMath: true,        // $…$ / \(…\) inline + $$…$$ / \[…\] display math (default false)
     dirAuto: true,        // per-block dir="auto" for RTL/bidi text (default false)
@@ -591,6 +629,13 @@ When to enable each flag:
 - `unsafeHtml: true` — only when rendering trusted HTML. For untrusted /
   LLM-produced HTML, pair this with `<FluxMarkdown sanitize={…} />` (DOMPurify or
   similar — see [Security](#security)).
+- `gfmTagfilter: true` — the GFM "Disallowed Raw HTML" extension, for use with
+  `unsafeHtml`: the nine disallowed tags (`<title>`, `<textarea>`, `<style>`,
+  `<xmp>`, `<iframe>`, `<noembed>`, `<noframes>`, `<script>`, `<plaintext>`) get
+  their leading `<` escaped so they display as text instead of taking effect —
+  opening and closing forms, any case, in blocks and inline. Off by default
+  (strict CommonMark passes them through under `unsafeHtml`); it's a tag
+  denylist, **not** a sanitizer — untrusted input still wants `sanitize`.
 - `componentTags: ["Thinking", …]` — when your LLM emits **block** custom tags
   like `<Thinking>…</Thinking>` (on their own line) and you want their inner
   content parsed as markdown and dispatched to a React component. Safe without

package/dist/client.d.ts

@@ -133,6 +133,10 @@ export declare class FluxClient {
     private rafHandle;
     private finalizePending;
     private epoch;
+    private staleSnapshot;
+    private staleTrimmed;
+    private idNamespace;
+    private mergeCache;
     private appendedBytes;
     private patchCount;
     private totalParseMicros;
@@ -221,7 +225,12 @@ export declare class FluxClient {
      *   - **prefix-extension** (the streaming-growth case) → append only the new
      *     suffix, so committed blocks stay put and only the active tail re-parses;
      *   - **any other change** (e.g. a finished stream swapped for a re-processed
-     *     final string) → `reset()` + reparse the whole new string.
+     *     final string) → reset + reparse the whole new string, keeping the
+     *     current view on screen until the reparse lands: the document never
+     *     blanks, scroll never moves, and blocks whose rendered content is
+     *     unchanged keep their identity (and React keys) so only genuinely
+     *     changed blocks re-render. An empty new string is an explicit clear and
+     *     hard-resets immediately.
      *
      * This is the first-class bridge for UIs that hold a streaming message as a
      * single growing string prop (the common React shape) — no hand-rolled diff,
@@ -243,6 +252,27 @@ export declare class FluxClient {
         done?: boolean;
     }): void;
     reset(): void;
+    /**
+     * setContent's divergence reset: rebuild the parser exactly like {@link reset},
+     * but keep `preserve` (the currently displayed view) on screen while the new
+     * content reparses. No notify fires here — subscribers keep reading the same
+     * snapshot reference until the first new-generation patch merges over it, so
+     * the swap is seamless: no empty frame, no container collapse, no scroll
+     * clamp, and blocks whose content survives the reprocess never re-render.
+     */
+    private softReset;
+    /**
+     * Finish a preserved-view divergence swap by making the merged view THE
+     * store: adopted ids become the committed keys, the merged array becomes the
+     * snapshot, and every scrap of merge state drops. From here getSnapshot() is
+     * a plain field read again (zero steady-state overhead) and the superseded
+     * generation's blocks are garbage — only one document stays in memory.
+     * Runs on the terminal (final) patch, which commits everything — if anything
+     * is somehow still open, the lazy merge simply stays live instead (the
+     * incremental reuse keeps it linear).
+     */
+    private collapseStale;
+    private resetParser;
     destroy(): void;
     /**
      * Re-register with the pool after {@link destroy} so the client receives
@@ -253,6 +283,28 @@ export declare class FluxClient {
     reattach(): void;
     subscribe: (fn: () => void) => () => boolean;
     getSnapshot: () => Block[];
+    /**
+     * Positional merge of the preserved pre-divergence view over the rebuilding
+     * store (see {@link softReset}). Per position:
+     *   - identical committed block (html + kind + open + speculative) → the OLD
+     *     block object, so its id and reference survive the swap and the block
+     *     never re-renders (blocksEqual / the DOM keyed reconcile hold);
+     *   - changed committed block → the new block, its id offset into this
+     *     generation's namespace (adopted old ids and raw new ids could collide);
+     *   - still-open block over old content → the old block (never a shrinking
+     *     partial where complete content was already on screen); past the old
+     *     document's end the live tail streams in as-is;
+     *   - position the reparse hasn't reached → the old block, until the terminal
+     *     patch sets `staleTrimmed` and the view clamps to the new length.
+     *
+     * LINEARITY: committed blocks are reference-stable across patches (the store
+     * contract), so a base entry pointer-equal to the previous merge's reproduces
+     * its previous decision without re-running the O(html) equality compare. Each
+     * block is string-compared exactly once — when it first commits — keeping a
+     * long post-divergence stream linear instead of quadratic. Only the active
+     * tail (fresh references each patch, small by design) re-compares per patch.
+     */
+    private mergeStale;
     /**
      * Internal: a renderer with an `onRenderMetrics` hook calls this once per
      * actual React block render so `getMetrics().renderCount` aggregates churn.

package/dist/client.js

@@ -162,6 +162,7 @@ class FluxPool {
     }
   }
 }
+const ID_NAMESPACE_STRIDE = 4294967296;
 function poolCap() {
   const hc = typeof navigator !== "undefined" ? navigator.hardwareConcurrency : 0;
   return Math.min(hc || 4, 8);
@@ -213,6 +214,29 @@ class FluxClient {
   // echoed back on each patch; a patch whose epoch is older than this is a
   // pre-reset straggler and is dropped before it can repopulate the cleared store.
   epoch = 0;
+  // --- Preserved-view divergence swap (setContent's reset+reparse path) ---
+  // The displayed snapshot captured by softReset(). While set, getSnapshot()
+  // returns a positional merge of this view over the rebuilding store, so the
+  // document never blanks out during a divergence reparse and unchanged blocks
+  // keep their object identity AND id (React key / DOM node key) across the
+  // swap. It persists after the reparse completes — dropping it would revert
+  // the adopted ids and remount every block one notify later.
+  staleSnapshot = null;
+  // Set when the reparse's terminal (final) patch lands: the merge stops
+  // padding with the old document's tail, so a shorter replacement trims to the
+  // new length on that very notify.
+  staleTrimmed = false;
+  // Id offset applied to non-adopted new blocks in a merged view. A divergence
+  // reparse restarts core block ids at 0 (fresh parser), and streamed ids are
+  // chunk-dependent (tail reparses burn ids) — so a changed block's new id can
+  // collide with a retained old block's id in the same merged snapshot.
+  // Bumped by ID_NAMESPACE_STRIDE per generation, which keeps every merged id
+  // provably unique: adopted ids are all below the current namespace.
+  idNamespace = 0;
+  // getSnapshot() cache: (store.snapshot ref, trimmed) → merged array. Repeated
+  // reads between notifies must return the SAME reference — the
+  // useSyncExternalStore cached-snapshot contract.
+  mergeCache = null;
   // Perf
   appendedBytes = 0;
   patchCount = 0;
@@ -366,7 +390,12 @@ class FluxClient {
    *   - **prefix-extension** (the streaming-growth case) → append only the new
    *     suffix, so committed blocks stay put and only the active tail re-parses;
    *   - **any other change** (e.g. a finished stream swapped for a re-processed
-   *     final string) → `reset()` + reparse the whole new string.
+   *     final string) → reset + reparse the whole new string, keeping the
+   *     current view on screen until the reparse lands: the document never
+   *     blanks, scroll never moves, and blocks whose rendered content is
+   *     unchanged keep their identity (and React keys) so only genuinely
+   *     changed blocks re-render. An empty new string is an explicit clear and
+   *     hard-resets immediately.
    *
    * This is the first-class bridge for UIs that hold a streaming message as a
    * single growing string prop (the common React shape) — no hand-rolled diff,
@@ -389,7 +418,9 @@ class FluxClient {
       if (!this.contentDone && content.startsWith(this.lastContent)) {
         this.append(content.slice(this.lastContent.length));
       } else {
-        this.reset();
+        const displayed = this.getSnapshot();
+        if (content.length > 0 && displayed.length > 0) this.softReset(displayed);
+        else this.reset();
         this.append(content);
       }
       this.lastContent = content;
@@ -401,7 +432,57 @@ class FluxClient {
     }
   }
   reset() {
-    const hadContent = this.store.snapshot.length > 0;
+    const hadContent = this.getSnapshot().length > 0;
+    this.staleSnapshot = null;
+    this.staleTrimmed = false;
+    this.mergeCache = null;
+    this.resetParser();
+    if (hadContent) this.emit(true);
+  }
+  /**
+   * setContent's divergence reset: rebuild the parser exactly like {@link reset},
+   * but keep `preserve` (the currently displayed view) on screen while the new
+   * content reparses. No notify fires here — subscribers keep reading the same
+   * snapshot reference until the first new-generation patch merges over it, so
+   * the swap is seamless: no empty frame, no container collapse, no scroll
+   * clamp, and blocks whose content survives the reprocess never re-render.
+   */
+  softReset(preserve) {
+    this.staleSnapshot = preserve;
+    this.staleTrimmed = false;
+    this.idNamespace += ID_NAMESPACE_STRIDE;
+    this.resetParser();
+    this.mergeCache = { base: this.store.snapshot, trimmed: false, view: preserve };
+  }
+  /**
+   * Finish a preserved-view divergence swap by making the merged view THE
+   * store: adopted ids become the committed keys, the merged array becomes the
+   * snapshot, and every scrap of merge state drops. From here getSnapshot() is
+   * a plain field read again (zero steady-state overhead) and the superseded
+   * generation's blocks are garbage — only one document stays in memory.
+   * Runs on the terminal (final) patch, which commits everything — if anything
+   * is somehow still open, the lazy merge simply stays live instead (the
+   * incremental reuse keeps it linear).
+   */
+  collapseStale() {
+    if (this.store.active.length > 0) return;
+    const view = this.getSnapshot();
+    const committed = /* @__PURE__ */ new Map();
+    const committedOrder = new Array(view.length);
+    for (let i = 0; i < view.length; i++) {
+      committedOrder[i] = view[i].id;
+      committed.set(view[i].id, view[i]);
+    }
+    this.store = { committed, committedOrder, active: [], snapshot: view };
+    this.staleSnapshot = null;
+    this.staleTrimmed = false;
+    this.mergeCache = null;
+  }
+  // Shared generation teardown: swap in an empty store, zero the metrics and
+  // the setContent baseline, invalidate any coalesced frame, bump the epoch,
+  // and tell the worker to drop the parser. View concerns (stale preservation,
+  // subscriber notify) belong to the callers — reset() and softReset().
+  resetParser() {
     this.store = emptyBlockStore();
     this.appendedBytes = 0;
     this.patchCount = 0;
@@ -417,7 +498,6 @@ class FluxClient {
     this.epoch += 1;
     const pw = this.ensureAcquired();
     this.pool.send(pw, { type: "reset", streamId: this.streamId, epoch: this.epoch });
-    if (hadContent) this.emit(true);
   }
   destroy() {
     if (!this.attached) return;
@@ -449,7 +529,65 @@ class FluxClient {
     this.listeners.add(fn);
     return () => this.listeners.delete(fn);
   };
-  getSnapshot = () => this.store.snapshot;
+  getSnapshot = () => {
+    const base = this.store.snapshot;
+    if (!this.staleSnapshot) return base;
+    const cache = this.mergeCache;
+    if (cache && cache.base === base && cache.trimmed === this.staleTrimmed) return cache.view;
+    const view = this.mergeStale(base, cache && cache.trimmed === this.staleTrimmed ? cache : null);
+    this.mergeCache = { base, trimmed: this.staleTrimmed, view };
+    return view;
+  };
+  /**
+   * Positional merge of the preserved pre-divergence view over the rebuilding
+   * store (see {@link softReset}). Per position:
+   *   - identical committed block (html + kind + open + speculative) → the OLD
+   *     block object, so its id and reference survive the swap and the block
+   *     never re-renders (blocksEqual / the DOM keyed reconcile hold);
+   *   - changed committed block → the new block, its id offset into this
+   *     generation's namespace (adopted old ids and raw new ids could collide);
+   *   - still-open block over old content → the old block (never a shrinking
+   *     partial where complete content was already on screen); past the old
+   *     document's end the live tail streams in as-is;
+   *   - position the reparse hasn't reached → the old block, until the terminal
+   *     patch sets `staleTrimmed` and the view clamps to the new length.
+   *
+   * LINEARITY: committed blocks are reference-stable across patches (the store
+   * contract), so a base entry pointer-equal to the previous merge's reproduces
+   * its previous decision without re-running the O(html) equality compare. Each
+   * block is string-compared exactly once — when it first commits — keeping a
+   * long post-divergence stream linear instead of quadratic. Only the active
+   * tail (fresh references each patch, small by design) re-compares per patch.
+   */
+  mergeStale(base, prev) {
+    const stale = this.staleSnapshot;
+    const len = this.staleTrimmed ? base.length : Math.max(base.length, stale.length);
+    const view = new Array(len);
+    for (let i = 0; i < len; i++) {
+      const nb = i < base.length ? base[i] : void 0;
+      if (nb !== void 0 && prev !== null && i < prev.base.length && prev.base[i] === nb) {
+        view[i] = prev.view[i];
+        continue;
+      }
+      const ob = i < stale.length ? stale[i] : void 0;
+      if (!nb) {
+        view[i] = ob;
+        continue;
+      }
+      if (ob) {
+        if (nb.open && !this.staleTrimmed) {
+          view[i] = ob;
+          continue;
+        }
+        if (nb.html === ob.html && nb.kind.type === ob.kind.type && nb.open === ob.open && nb.speculative === ob.speculative) {
+          view[i] = ob;
+          continue;
+        }
+      }
+      view[i] = { ...nb, id: this.idNamespace + nb.id };
+    }
+    return view;
+  }
   /**
    * Internal: a renderer with an `onRenderMetrics` hook calls this once per
    * actual React block render so `getMetrics().renderCount` aggregates churn.
@@ -497,7 +635,7 @@ class FluxClient {
    */
   outline() {
     const out = [];
-    for (const b of this.store.snapshot) {
+    for (const b of this.getSnapshot()) {
       if (b.kind.type === "Heading") {
         const d = b.kind.data;
         const level = typeof d === "number" ? d : d?.level ?? 1;
@@ -515,7 +653,7 @@ class FluxClient {
    */
   toPlaintext() {
     const parts = [];
-    for (const b of this.store.snapshot) {
+    for (const b of this.getSnapshot()) {
       const t = htmlToText(b.html);
       if (t) parts.push(t);
     }
@@ -535,6 +673,11 @@ class FluxClient {
           break;
         }
         applyPatch(this.store, patch);
+        if (msg.final === true && this.staleSnapshot) {
+          this.staleTrimmed = true;
+          this.mergeCache = null;
+          this.collapseStale();
+        }
         this.appendedBytes = msg.appendedBytes;
         this.totalParseMicros += msg.parseMicros;
         this.retainedBytes = msg.retainedBytes;

package/dist/element.js

@@ -146,6 +146,7 @@ function defineFluxMarkdown(tag = "flux-markdown") {
       };
       set("gfm-autolinks", "gfmAutolinks");
       set("gfm-alerts", "gfmAlerts");
+      set("gfm-tagfilter", "gfmTagfilter");
       set("gfm-footnotes", "gfmFootnotes");
       set("gfm-math", "gfmMath");
       set("dir-auto", "dirAuto");

package/dist/server.js

@@ -36,6 +36,7 @@ function makeParser(config) {
   const p = new FluxParser();
   p.setGfmAutolinks(config?.gfmAutolinks ?? true);
   p.setGfmAlerts(config?.gfmAlerts ?? true);
+  p.setGfmTagfilter(config?.gfmTagfilter ?? false);
   p.setGfmFootnotes(config?.gfmFootnotes ?? false);
   p.setGfmMath(config?.gfmMath ?? false);
   p.setDirAuto(config?.dirAuto ?? false);

package/dist/styles.css

@@ -113,6 +113,12 @@
 /* ---- inline ---------------------------------------------------------------- */
 .flux-md a { color: var(--flux-accent); text-decoration: none; }
 .flux-md a:hover { text-decoration: underline; }
+/* A streaming link whose URL hasn't finished arriving renders as an inert
+   `<a data-flux-pending>` with no href — the UA gives an href-less anchor no
+   link styling, so restate the settled resting style here (identical color and
+   decoration, so completion changes nothing visually). Cursor stays default:
+   not clickable yet. */
+.flux-md a[data-flux-pending] { color: var(--flux-accent); text-decoration: none; cursor: default; }
 .flux-md strong { font-weight: 600; }
 .flux-md em { font-style: italic; }
 .flux-md del { color: var(--flux-fg-muted); }

package/dist/types-core.d.ts

@@ -296,6 +296,15 @@ export interface ParserConfig {
     gfmAutolinks?: boolean;
     /** GitHub alerts (`> [!NOTE]` → callouts). Default true. */
     gfmAlerts?: boolean;
+    /**
+     * GFM "Disallowed Raw HTML" (tagfilter): with `unsafeHtml` on, the nine
+     * disallowed tags (`<title>`, `<textarea>`, `<style>`, `<xmp>`, `<iframe>`,
+     * `<noembed>`, `<noframes>`, `<script>`, `<plaintext>`) get their leading
+     * `<` escaped so they display as text instead of taking effect. Default
+     * false (strict CommonMark passes them through under `unsafeHtml`); no
+     * effect while raw HTML is escaped (default) or sanitized — already inert.
+     */
+    gfmTagfilter?: boolean;
     /** GFM footnotes (`[^1]` + `[^1]:` → footnote section). Default false. */
     gfmFootnotes?: boolean;
     /**

package/dist/wasm/flux_md_core.d.ts

@@ -82,6 +82,14 @@ export class FluxParser {
      * `<div class="math math-display">` for a KaTeX pass on the JS side.
      */
     setGfmMath(on: boolean): void;
+    /**
+     * Enable the GFM "Disallowed Raw HTML" extension (tagfilter): with raw
+     * HTML passing through (`setUnsafeHtml(true)`), the nine disallowed tags
+     * (`<title>`, `<script>`, `<iframe>`, …) get their leading `<` escaped so
+     * they display as text instead of taking effect. Off by default; no
+     * effect while raw HTML is escaped or sanitized (already inert).
+     */
+    setGfmTagfilter(on: boolean): void;
     /**
      * Engage the safe raw-HTML sanitizer. When `on`, inline raw HTML renders
      * sanitized without full unsafe HTML: `allow` empty = allow all tags except
@@ -125,6 +133,7 @@ export interface InitOutput {
     readonly fluxparser_setGfmAutolinks: (a: number, b: number) => void;
     readonly fluxparser_setGfmFootnotes: (a: number, b: number) => void;
     readonly fluxparser_setGfmMath: (a: number, b: number) => void;
+    readonly fluxparser_setGfmTagfilter: (a: number, b: number) => void;
     readonly fluxparser_setHtmlSanitize: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly fluxparser_setInlineComponentTags: (a: number, b: number, c: number) => void;
     readonly fluxparser_setUnsafeHtml: (a: number, b: number) => void;

package/dist/wasm/flux_md_core.js

@@ -205,6 +205,17 @@ export class FluxParser {
     setGfmMath(on) {
         wasm.fluxparser_setGfmMath(this.__wbg_ptr, on);
     }
+    /**
+     * Enable the GFM "Disallowed Raw HTML" extension (tagfilter): with raw
+     * HTML passing through (`setUnsafeHtml(true)`), the nine disallowed tags
+     * (`<title>`, `<script>`, `<iframe>`, …) get their leading `<` escaped so
+     * they display as text instead of taking effect. Off by default; no
+     * effect while raw HTML is escaped or sanitized (already inert).
+     * @param {boolean} on
+     */
+    setGfmTagfilter(on) {
+        wasm.fluxparser_setGfmTagfilter(this.__wbg_ptr, on);
+    }
     /**
      * Engage the safe raw-HTML sanitizer. When `on`, inline raw HTML renders
      * sanitized without full unsafe HTML: `allow` empty = allow all tags except

package/dist/wasm/flux_md_core_bg.wasm.d.ts

@@ -16,6 +16,7 @@ export const fluxparser_setGfmAlerts: (a: number, b: number) => void;
 export const fluxparser_setGfmAutolinks: (a: number, b: number) => void;
 export const fluxparser_setGfmFootnotes: (a: number, b: number) => void;
 export const fluxparser_setGfmMath: (a: number, b: number) => void;
+export const fluxparser_setGfmTagfilter: (a: number, b: number) => void;
 export const fluxparser_setHtmlSanitize: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const fluxparser_setInlineComponentTags: (a: number, b: number, c: number) => void;
 export const fluxparser_setUnsafeHtml: (a: number, b: number) => void;

package/dist/worker-core.js

@@ -125,8 +125,9 @@ class WorkerCore {
     try {
       const parser = this.getOrCreate(streamId);
       if (buffered && buffered.length > 0) {
-        parser.append(buffered);
+        const drained = parser.append(buffered);
         this.totalAppended.set(streamId, (this.totalAppended.get(streamId) ?? 0) + buffered.length);
+        this.emitPatch(streamId, drained, parser, 0, false);
       }
       const patch = parser.finalize();
       this.emitPatch(streamId, patch, parser, 0, true);

package/dist/worker.js

@@ -11,6 +11,7 @@ const core = new WorkerCore({
     const p = new FluxParser();
     p.setGfmAutolinks(c?.gfmAutolinks ?? true);
     p.setGfmAlerts(c?.gfmAlerts ?? true);
+    p.setGfmTagfilter(c?.gfmTagfilter ?? false);
     p.setGfmFootnotes(c?.gfmFootnotes ?? false);
     p.setGfmMath(c?.gfmMath ?? false);
     p.setDirAuto(c?.dirAuto ?? false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flux-md",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "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"],