flux-md 0.16.2 → 0.17.0

package/{src → dist}/wasm/flux_md_core.js

@@ -13,31 +13,48 @@ export class FluxParser {
     }
     /**
      * All blocks currently parsed (committed + active), in document order — the
-     * whole rendered document as a JS array of `Block`. The one-shot /
-     * server-side render primitive: feed the full markdown via `append`, call
-     * `finalize`, then read `allBlocks()` (no worker, no patch accumulation).
-     * @returns {any}
+     * whole rendered document as a **JSON string** of a `Block[]` (parse with
+     * `JSON.parse`). The one-shot / server-side render primitive: feed the full
+     * markdown via `append`, call `finalize`, then read `allBlocks()` (no worker,
+     * no patch accumulation).
+     * @returns {string}
      */
     allBlocks() {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             wasm.fluxparser_allBlocks(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
             }
-            return takeObject(r0);
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
         }
     }
     /**
+     * Returns the patch as a **JSON string** (parsed with `JSON.parse` on the
+     * main thread), not a live JS object. This is deliberate: serializing once to
+     * a string in Rust avoids serde-wasm-bindgen's per-node boundary calls, and a
+     * string is far cheaper than an object graph to `structuredClone` across the
+     * worker→main `postMessage` (the worker forwards the string verbatim).
      * @param {string} chunk
-     * @returns {any}
+     * @returns {string}
      */
     append(chunk) {
+        let deferred3_0;
+        let deferred3_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(chunk, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -46,12 +63,19 @@ export class FluxParser {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
             }
-            return takeObject(r0);
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
         }
     }
     /**
@@ -62,21 +86,31 @@ export class FluxParser {
         return ret >>> 0;
     }
     /**
-     * @returns {any}
+     * JSON-string patch — see [`FluxParser::append`].
+     * @returns {string}
      */
     finalize() {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             wasm.fluxparser_finalize(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
             }
-            return takeObject(r0);
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
         }
     }
     constructor() {
@@ -215,17 +249,6 @@ if (Symbol.dispose) FluxParser.prototype[Symbol.dispose] = FluxParser.prototype.
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_ef53bc310eb298a0: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_String_8564e559799eccda: function(arg0, arg1) {
-            const ret = String(getObject(arg1));
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
         __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(arg0, arg1) {
             const obj = getObject(arg1);
             const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -237,39 +260,11 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_new_ce1ab61c1c2b300d: function() {
-            const ret = new Object();
-            return addHeapObject(ret);
-        },
-        __wbg_new_d90091b82fdf5b91: function() {
-            const ret = new Array();
-            return addHeapObject(ret);
-        },
-        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
-        },
-        __wbg_set_dca99999bba88a9a: function(arg0, arg1, arg2) {
-            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-        },
-        __wbindgen_cast_0000000000000001: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000003: function(arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return addHeapObject(ret);
-        },
-        __wbindgen_object_clone_ref: function(arg0) {
-            const ret = getObject(arg0);
-            return addHeapObject(ret);
-        },
         __wbindgen_object_drop_ref: function(arg0) {
             takeObject(arg0);
         },

package/{src → dist}/wasm/flux_md_core_bg.wasm.d.ts

@@ -22,3 +22,4 @@ export const fluxparser_setUnsafeHtml: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number) => void;

package/dist/worker-core.d.ts

@@ -0,0 +1,60 @@
+import type { FromWorker, ParserConfig, ToWorker } from "./types-core.js";
+/** The slice of `FluxParser` the worker drives — narrowed to an interface so the
+ *  message/readiness state machine is unit-testable with a fake parser, no WASM.
+ *  (Same testability move as {@link FluxPool} taking an injected worker factory.)
+ *
+ *  `append`/`finalize` return the patch as a **JSON string**, not an object: the
+ *  worker forwards it verbatim to the main thread (a string structuredClones far
+ *  cheaper than an object graph) where it is `JSON.parse`d exactly once. */
+export interface ParserLike {
+    append(chunk: string): string;
+    finalize(): string;
+    free(): void;
+    retainedBytes(): number;
+}
+/** Dependencies injected into {@link WorkerCore}, isolating it from the worker
+ *  globals (`self`, `queueMicrotask`) and the WASM module so it can be tested. */
+export interface WorkerCoreDeps {
+    /** Create + configure a parser for a stream (prod: `new FluxParser()` + setX). */
+    makeParser(config: ParserConfig | undefined): ParserLike;
+    /** Post a message to the main thread (prod: `self.postMessage`). */
+    post(msg: FromWorker): void;
+    /** Current WASM heap size in bytes, reported on each patch (0 if unknown). */
+    memBytes(): number;
+    /** Defer a flush to a future microtask (prod: `queueMicrotask`). */
+    schedule(fn: () => void): void;
+}
+/**
+ * The worker's message reducer + WASM-readiness gate, extracted from the worker
+ * shell so its trickiest invariant is testable without a real Worker or WASM.
+ *
+ * **The invariant:** WASM `init()` is async, and the client does NOT wait for
+ * readiness before appending — so chunks can arrive first. A parser must never
+ * be constructed before init resolves (`new FluxParser()` against an
+ * uninitialized module throws `fluxparser_new of undefined` and silently drops
+ * that chunk). So while `ready` is false, appends only accumulate in `pending`
+ * (scheduleFlush is a no-op) and `finalize` is deferred; {@link markReady}
+ * drains both — appends first (creating each parser + applying buffered text),
+ * then any deferred finalize — once init has completed.
+ */
+export declare class WorkerCore {
+    private deps;
+    private parsers;
+    private config;
+    private pending;
+    private totalAppended;
+    private finalizePending;
+    private flushScheduled;
+    private ready;
+    constructor(deps: WorkerCoreDeps);
+    /** Handle one message from the main thread (append/finalize/reset/dispose). */
+    handle(msg: ToWorker): void;
+    /** Called once WASM init resolves: open the gate and drain what was buffered. */
+    markReady(): void;
+    private getOrCreate;
+    private dispose;
+    private emitPatch;
+    private scheduleFlush;
+    private flush;
+    private doFinalize;
+}

package/dist/worker-core.js

@@ -0,0 +1,121 @@
+class WorkerCore {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  // One parser per stream id; WASM is loaded once and shared by all of them.
+  parsers = /* @__PURE__ */ new Map();
+  config = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  totalAppended = /* @__PURE__ */ new Map();
+  finalizePending = /* @__PURE__ */ new Set();
+  flushScheduled = false;
+  ready = false;
+  /** Handle one message from the main thread (append/finalize/reset/dispose). */
+  handle(msg) {
+    const id = msg.streamId;
+    if ((msg.type === "append" || msg.type === "finalize") && msg.config) {
+      this.config.set(id, msg.config);
+    }
+    switch (msg.type) {
+      case "append":
+        this.pending.set(id, (this.pending.get(id) ?? "") + msg.chunk);
+        this.scheduleFlush();
+        break;
+      case "finalize":
+        if (!this.ready) this.finalizePending.add(id);
+        else this.doFinalize(id);
+        break;
+      case "reset":
+        this.parsers.get(id)?.free();
+        this.parsers.delete(id);
+        this.pending.delete(id);
+        this.finalizePending.delete(id);
+        this.totalAppended.delete(id);
+        break;
+      case "dispose":
+        this.dispose(id);
+        break;
+    }
+  }
+  /** Called once WASM init resolves: open the gate and drain what was buffered. */
+  markReady() {
+    this.ready = true;
+    this.deps.post({ type: "ready" });
+    if (this.pending.size > 0) this.flush();
+    if (this.finalizePending.size > 0) {
+      for (const id of this.finalizePending) this.doFinalize(id);
+      this.finalizePending.clear();
+    }
+  }
+  getOrCreate(streamId) {
+    let p = this.parsers.get(streamId);
+    if (!p) {
+      p = this.deps.makeParser(this.config.get(streamId));
+      this.parsers.set(streamId, p);
+    }
+    return p;
+  }
+  dispose(streamId) {
+    this.parsers.get(streamId)?.free();
+    this.parsers.delete(streamId);
+    this.config.delete(streamId);
+    this.pending.delete(streamId);
+    this.finalizePending.delete(streamId);
+    this.totalAppended.delete(streamId);
+  }
+  emitPatch(streamId, patch, parser, parseMicros) {
+    this.deps.post({
+      type: "patch",
+      streamId,
+      patch,
+      appendedBytes: this.totalAppended.get(streamId) ?? 0,
+      parseMicros,
+      retainedBytes: parser.retainedBytes(),
+      wasmMemoryBytes: this.deps.memBytes()
+    });
+  }
+  scheduleFlush() {
+    if (this.flushScheduled || !this.ready) return;
+    this.flushScheduled = true;
+    this.deps.schedule(() => this.flush());
+  }
+  flush() {
+    this.flushScheduled = false;
+    if (!this.ready || this.pending.size === 0) return;
+    for (const [streamId, chunk] of this.pending) {
+      this.pending.delete(streamId);
+      if (chunk.length === 0) continue;
+      const t0 = performance.now();
+      try {
+        const parser = this.getOrCreate(streamId);
+        const patch = parser.append(chunk);
+        const dt = (performance.now() - t0) * 1e3;
+        this.totalAppended.set(streamId, (this.totalAppended.get(streamId) ?? 0) + chunk.length);
+        this.emitPatch(streamId, patch, parser, dt);
+      } catch (e) {
+        this.deps.post({ type: "error", streamId, message: e instanceof Error ? e.message : String(e) });
+      }
+    }
+  }
+  // Drain a stream's buffered input (if any), then finalize its parser. Shared by
+  // the `finalize` message path and markReady()'s post-ready drain.
+  doFinalize(streamId) {
+    const buffered = this.pending.get(streamId);
+    this.pending.delete(streamId);
+    try {
+      const parser = this.getOrCreate(streamId);
+      if (buffered && buffered.length > 0) {
+        parser.append(buffered);
+        this.totalAppended.set(streamId, (this.totalAppended.get(streamId) ?? 0) + buffered.length);
+      }
+      const patch = parser.finalize();
+      this.emitPatch(streamId, patch, parser, 0);
+    } catch (e) {
+      this.deps.post({ type: "error", streamId, message: e instanceof Error ? e.message : String(e) });
+    }
+  }
+}
+export {
+  WorkerCore
+};

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker.js

@@ -0,0 +1,48 @@
+import init, { FluxParser } from "./wasm/flux_md_core.js";
+import { WorkerCore } from "./worker-core.js";
+const wasmUrl = new URL("./wasm/flux_md_core_bg.wasm", import.meta.url);
+const ctx = self;
+let wasmExports = null;
+const core = new WorkerCore({
+  // Create + configure a parser for a stream. Omitted config fields fall back to
+  // the library defaults — autolinks + alerts on (LLM output is full of bare
+  // URLs and `> [!NOTE]` blocks), raw HTML escaped, footnotes/math off.
+  makeParser(c) {
+    const p = new FluxParser();
+    p.setGfmAutolinks(c?.gfmAutolinks ?? true);
+    p.setGfmAlerts(c?.gfmAlerts ?? true);
+    p.setGfmFootnotes(c?.gfmFootnotes ?? false);
+    p.setGfmMath(c?.gfmMath ?? false);
+    p.setDirAuto(c?.dirAuto ?? false);
+    p.setA11y(c?.a11y ?? false);
+    p.setUnsafeHtml(c?.unsafeHtml ?? false);
+    p.setComponentTags(c?.componentTags ?? []);
+    p.setInlineComponentTags(c?.inlineComponentTags ?? []);
+    p.setHtmlSanitize(
+      c?.htmlAllowlist !== void 0 || c?.dropHtmlTags !== void 0,
+      c?.htmlAllowlist ?? [],
+      c?.dropHtmlTags ?? []
+    );
+    p.setBlockData(c?.blockData ?? false);
+    return p;
+  },
+  post: (msg) => ctx.postMessage(msg),
+  memBytes: () => {
+    try {
+      return wasmExports?.memory?.buffer?.byteLength ?? 0;
+    } catch {
+      return 0;
+    }
+  },
+  schedule: (fn) => queueMicrotask(fn)
+});
+ctx.addEventListener("message", (ev) => core.handle(ev.data));
+async function setup() {
+  try {
+    wasmExports = await init({ module_or_path: wasmUrl });
+    core.markReady();
+  } catch (e) {
+    ctx.postMessage({ type: "error", streamId: -1, message: e instanceof Error ? e.message : String(e), fatal: true });
+  }
+}
+setup();

package/package.json

@@ -1,27 +1,28 @@
 {
   "name": "flux-md",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "Zero-dep streaming markdown for the browser. Rust→WASM core, Web Worker per stream, incremental parse with speculative closure.",
   "type": "module",
-  "sideEffects": ["./src/worker.ts", "./src/styles.css"],
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "sideEffects": ["./dist/worker.js", "./dist/styles.css"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./client": "./src/client.ts",
-    "./react": "./src/react.tsx",
-    "./server": "./src/server.tsx",
-    "./dom": "./src/dom.ts",
-    "./element": "./src/element.ts",
-    "./vue": "./src/vue.ts",
-    "./svelte": "./src/svelte.ts",
-    "./solid": "./src/solid.tsx",
-    "./highlight": "./src/hi.ts",
-    "./types": "./src/types.ts",
-    "./styles.css": "./src/styles.css"
+    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
+    "./client": { "types": "./dist/client.d.ts", "import": "./dist/client.js" },
+    "./react": { "types": "./dist/react.d.ts", "import": "./dist/react.js" },
+    "./server": { "types": "./dist/server.d.ts", "import": "./dist/server.js" },
+    "./dom": { "types": "./dist/dom.d.ts", "import": "./dist/dom.js" },
+    "./element": { "types": "./dist/element.d.ts", "import": "./dist/element.js" },
+    "./vue": { "types": "./dist/vue.d.ts", "import": "./dist/vue.js" },
+    "./svelte": { "types": "./dist/svelte.d.ts", "import": "./dist/svelte.js" },
+    "./solid": { "types": "./dist/solid.d.ts", "import": "./dist/solid.js" },
+    "./highlight": { "types": "./dist/hi.d.ts", "import": "./dist/hi.js" },
+    "./types": { "types": "./dist/types.d.ts", "import": "./dist/types.js" },
+    "./styles.css": "./dist/styles.css",
+    "./package.json": "./package.json"
   },
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
   "peerDependencies": {
@@ -48,6 +49,7 @@
     "@types/bun": "^1.3.14",
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
+    "esbuild": "^0.28.1",
     "happy-dom": "^15.11.6",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -57,10 +59,12 @@
     "vue": "^3.4.0"
   },
   "scripts": {
+    "build": "node scripts/build.mjs",
     "test": "bun test",
     "test:ssr-cold": "bun test/ssr-cold.mjs",
+    "test:consumer-smoke": "bash test/consumer-smoke/run.sh",
     "typecheck:test": "tsc --noEmit -p tsconfig.test.json",
-    "prepublishOnly": "cd ../.. && bun run build:wasm"
+    "prepublishOnly": "cd ../.. && bun run build:wasm && cd packages/flux-md && node scripts/build.mjs"
   },
   "keywords": ["markdown", "streaming", "wasm", "rust", "react", "vue", "svelte", "solid", "web-component", "custom-element", "incremental", "llm", "ai", "math", "katex", "latex", "bidi", "rtl"],
   "license": "MIT",

package/src/block-props.ts

@@ -1,141 +0,0 @@
-import type {
-  Block,
-  BlockComponentProps,
-  CodeBlockData,
-  ContainerData,
-  HeadingData,
-  ListData,
-  MathBlockData,
-  TableData,
-} from "./types-core";
-
-// Pure helpers duplicated from the JSX renderer / its CodeBlock so the
-// framework-neutral DOM renderer carries no framework dependency. The JSX
-// renderer is held byte-identical, so these are copies — match it exactly.
-
-/** Decode the small entity set the core emits (amp last so `<` → `<`).
- *  This is the simple ordered chain, not the numeric/named-entity decoder. */
-function decodeEntities(s: string): string {
-  return s
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&amp;/g, "&");
-}
-
-/** Decoded source text inside `<pre><code>…</code></pre>`. */
-function decodeCodeText(html: string): string {
-  const m = html.match(/<pre><code[^>]*>([\s\S]*?)<\/code><\/pre>/);
-  return m ? decodeEntities(m[1]) : "";
-}
-
-/**
- * The LaTeX source for a MathBlock. Display math (`$$…$$` / `\[…\]`) renders as
- * `<div class="math math-display">…</div>`; a fenced ```math block renders as
- * `<pre><code>…</code></pre>`. Either way the body is the HTML-escaped LaTeX —
- * decode it back so a `components.MathBlock` override gets the raw source.
- */
-function decodeMathText(html: string): string {
-  const d = html.match(/<div class="math math-display">([\s\S]*?)<\/div>/);
-  if (d) return decodeEntities(d[1]);
-  return decodeCodeText(html);
-}
-
-/** Info-string language from a code block's `data-lang="…"`. */
-export function extractLang(html: string): string {
-  const m = html.match(/data-lang="([^"]+)"/);
-  return m ? m[1] : "";
-}
-
-/** Strip the `<tag …>` open and trailing `</tag>` from a component block's HTML,
- *  leaving the inner (already-rendered markdown) HTML. Handles open (unclosed)
- *  blocks, where there is no close tag yet. */
-function componentInnerHtml(html: string, tag: string): string {
-  const gt = html.indexOf(">");
-  if (gt < 0) return "";
-  let inner = html.slice(gt + 1);
-  const close = `</${tag}>`;
-  if (inner.endsWith(close)) inner = inner.slice(0, -close.length);
-  return inner.replace(/^\n/, "").replace(/\n$/, "");
-}
-
-/**
- * Convert sanitized HTML attribute pairs into a spreadable object, keeping the
- * HTML-form names (`class`, `for`) verbatim. This is the deliberate divergence
- * from the JSX renderer (which renames to `className`/`htmlFor` for a prop
- * spread): the DOM renderer applies them via `el.setAttribute(name, value)`,
- * which wants the literal HTML names.
- */
-export function htmlAttrs(pairs: [string, string][]): Record<string, string> {
-  const out: Record<string, string> = {};
-  for (const [k, v] of pairs) out[k] = v;
-  return out;
-}
-
-/**
- * Build the props a block-kind / component-tag override receives — the same
- * shape the JSX renderer's block-kind props carry, with ONE deliberate
- * divergence: for `Component` blocks `attrs` stay in HTML form (`class`/`for`)
- * because DOM overrides apply them via `setAttribute` (see {@link htmlAttrs}).
- */
-export function blockProps(block: Block): BlockComponentProps {
-  const props: BlockComponentProps = {
-    block,
-    html: block.html,
-    open: block.open,
-    speculative: block.speculative,
-  };
-  const data = block.kind.data as
-    | { lang?: string | null; code?: string; latex?: string; start?: number; ordered?: boolean; items?: { html: string }[]; tag?: string; attrs?: [string, string][] }
-    | undefined;
-  if (block.kind.type === "CodeBlock") {
-    // Prefer the structured `code` (present when blockData is on) over the HTML
-    // regex — it is the lossless decoded source. Fall back to the regex when off.
-    props.text = data?.code ?? decodeCodeText(block.html);
-    props.language = data?.lang ?? "";
-    // Surface the typed convenience field only when the opt-in `code` is present.
-    if (typeof data?.code === "string") {
-      props.code = { lang: data.lang ?? null, code: data.code } as CodeBlockData;
-    }
-  } else if (block.kind.type === "MathBlock") {
-    // Prefer the structured `latex` (present when blockData is on) over the regex.
-    props.text = data?.latex ?? decodeMathText(block.html);
-    if (typeof data?.latex === "string") {
-      props.math = { latex: data.latex } as MathBlockData;
-    }
-  } else if (block.kind.type === "List") {
-    // Structured list data is present only when blockData is on (the `start` key
-    // rides the opt-in channel); surface it as the typed convenience field,
-    // including the opt-in per-item HTML (`items`) for a keyed renderer.
-    if (data && typeof data.start === "number") {
-      props.list = { ordered: !!data.ordered, start: data.start, items: data.items } as ListData;
-    }
-  } else if (block.kind.type === "Component") {
-    props.tag = data?.tag ?? "";
-    props.attrs = htmlAttrs(data?.attrs ?? []);
-    // An override replaces the `<tag>` wrapper, so it gets the *inner* HTML
-    // (markdown already rendered) rather than the full wrapped block.
-    props.html = componentInnerHtml(block.html, props.tag);
-  } else if (block.kind.type === "Table") {
-    // Structured data is present only when `blockData` is on (else `undefined`).
-    // Pure data — identical for the DOM and JSX renderers, no name-form divergence.
-    props.table = block.kind.data as TableData | undefined;
-  } else if (block.kind.type === "Heading") {
-    // When `blockData` is on, `kind.data` is the `{ level, text, id }` object;
-    // when off it is the bare level `number`. Surface the rich object only — the
-    // `typeof === "object"` guard keeps the off-path naked int out of `heading`.
-    if (typeof block.kind.data === "object" && block.kind.data !== null) {
-      props.heading = block.kind.data as HeadingData;
-    }
-  } else if (block.kind.type === "Blockquote" || block.kind.type === "Alert") {
-    // When `blockData` is on, a Blockquote's `kind.data` is `{ nested }` and an
-    // Alert's is `{ kind, nested }`; off, a Blockquote has no `data` and an Alert
-    // only `{ kind }`. Surface the keyed `nested` sub-blocks only when present.
-    const cd = block.kind.data as { nested?: { html: string }[] } | undefined;
-    if (cd && Array.isArray(cd.nested)) {
-      props.container = { nested: cd.nested } as ContainerData;
-    }
-  }
-  return props;
-}