flux-md 0.19.0 → 0.20.0

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

@@ -467,9 +467,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
@@ -555,6 +587,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 +624,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/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.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.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"],