flux-md 0.16.0 → 0.16.2

package/package.json

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

package/src/dom.ts

@@ -455,7 +455,7 @@ export function mountFluxMarkdown(
   function renderKeyedList(b: Block): HTMLElement | null {
     const ld = b.kind.data as ListData | undefined;
     const items = ld?.items;
-    if (!items || items.length === 0) return null;
+    if (!Array.isArray(items) || items.length === 0) return null;
     const node = document.createElement("div");
     node.className =
       "flux-block flux-block-list" +
@@ -803,7 +803,18 @@ export function mountFluxMarkdown(
 function tableData(b: Block): TableData | undefined {
   if (b.kind.type !== "Table") return undefined;
   const data = b.kind.data as TableData | undefined;
-  return data && Array.isArray(data.rows) ? data : undefined;
+  // Validate the shapes the keyed path indexes (rows/aligns/headers) so a
+  // drifted/malformed blockData wire falls back to the full-HTML path instead
+  // of crashing makeRow/makeCell on `aligns[j]`/`headers.map` of undefined.
+  if (
+    !data ||
+    !Array.isArray(data.rows) ||
+    !Array.isArray(data.aligns) ||
+    !Array.isArray(data.headers)
+  ) {
+    return undefined;
+  }
+  return data;
 }
 
 // HTML void elements: they self-terminate, so they never push element depth.

package/src/element.ts

@@ -385,7 +385,13 @@ export function defineFluxMarkdown(tag = "flux-markdown"): void {
         // A supersede/disconnect aborts the fetch — intentional, not an error.
         if (abort.signal.aborted || !current()) return;
         // eslint-disable-next-line no-console
-        console.error("<flux-markdown>: failed to stream src", src, err);
+        // Log only the message — `src` can carry a tokenized URL and `err` can be
+        // a large structured body; both would otherwise be shipped verbatim by any
+        // console-forwarding monitoring. (src is still on the element for debugging.)
+        console.error(
+          "<flux-markdown>: failed to stream src",
+          err instanceof Error ? err.message : String(err),
+        );
       }
     }
   }

package/src/html-to-react.ts

@@ -149,11 +149,19 @@ function safeStyle(style: Record<string, string>): Record<string, string> {
   return out;
 }
 
+// Single-char classifiers for parseOpenTag, hoisted to module scope so the
+// scan loops don't re-evaluate a fresh regex literal per character on every
+// block render (parseTrustedHtml runs this for every open streaming block).
+const TAG_CHAR = /[a-zA-Z0-9-]/;
+const WS_CHAR = /\s/;
+const ATTR_NAME_END = /[\s=>/]/;
+const UNQUOTED_VALUE_END = /[\s>]/;
+
 /** Parse one opening tag starting at `start` (the `<`). */
 function parseOpenTag(html: string, start: number) {
   let i = start + 1;
   let j = i;
-  while (j < html.length && /[a-zA-Z0-9-]/.test(html[j])) j++;
+  while (j < html.length && TAG_CHAR.test(html[j])) j++;
   // Preserve the tag's ORIGINAL case so an inline custom-component element (e.g.
   // `<Cite>`) dispatches to `components.Cite`. Standard elements the core emits
   // are already lowercase; the semantic checks below (VOID, `input`, close-tag
@@ -163,18 +171,18 @@ function parseOpenTag(html: string, start: number) {
   const attrs: Record<string, string | true> = {};
   while (i < html.length) {
     const loopStart = i;
-    while (i < html.length && /\s/.test(html[i])) i++;
+    while (i < html.length && WS_CHAR.test(html[i])) i++;
     if (html[i] === ">") return { tag, attrs, selfClose: false, next: i + 1 };
     if (html[i] === "/" && html[i + 1] === ">") return { tag, attrs, selfClose: true, next: i + 2 };
     if (i >= html.length) break;
     let k = i;
-    while (k < html.length && !/[\s=>/]/.test(html[k])) k++;
+    while (k < html.length && !ATTR_NAME_END.test(html[k])) k++;
     const name = html.slice(i, k);
     i = k;
-    while (i < html.length && /\s/.test(html[i])) i++;
+    while (i < html.length && WS_CHAR.test(html[i])) i++;
     if (html[i] === "=") {
       i++;
-      while (i < html.length && /\s/.test(html[i])) i++;
+      while (i < html.length && WS_CHAR.test(html[i])) i++;
       let value = "";
       const q = html[i];
       if (q === '"' || q === "'") {
@@ -184,7 +192,7 @@ function parseOpenTag(html: string, start: number) {
         i = e === -1 ? html.length : e + 1;
       } else {
         let v = i;
-        while (v < html.length && !/[\s>]/.test(html[v])) v++;
+        while (v < html.length && !UNQUOTED_VALUE_END.test(html[v])) v++;
         value = html.slice(i, v);
         i = v;
       }

package/src/react.tsx

@@ -185,8 +185,13 @@ function FluxMarkdownFromClient({
   const rendered = deferTail ? deferred : blocks;
   const isDeferring = deferTail ? rendered !== blocks : false;
   // Normalize "no overrides" to a stable `undefined` so memo comparisons and
-  // the fast path don't churn on an empty object identity.
-  const comps = components && Object.keys(components).length > 0 ? components : undefined;
+  // the fast path don't churn on an empty object identity. Memoized on
+  // [components] so the Object.keys scan runs only when the prop changes, not
+  // on every tail patch (identity is unchanged, so blocksEqual still holds).
+  const comps = useMemo(
+    () => (components && Object.keys(components).length > 0 ? components : undefined),
+    [components],
+  );
   // Wrap the user hook so each fire also advances the client's aggregate
   // renderCount. Memoized on (client, hook) so its identity stays stable across
   // tail patches — a fresh closure would bust every block's memo. When no hook
@@ -329,9 +334,10 @@ export function useFluxMarkdownString(
 
   // Reconcile the parser to the controlled string. setContent diffs internally,
   // so this stays correct whether `content` grows by a token or is swapped wholesale.
+  const streaming = options?.streaming;
   useEffect(() => {
-    client.setContent(content, { done: options?.streaming === false });
-  }, [client, content, options?.streaming]);
+    client.setContent(content, { done: streaming === false });
+  }, [client, content, streaming]);
 
   return client;
 }
@@ -931,7 +937,7 @@ function renderBlockContent({
     const items = ld?.items;
     const tagOverride =
       !!components && (!!components.ul || !!components.ol || !!components.li);
-    if (items && items.length > 0 && !tagOverride) {
+    if (Array.isArray(items) && items.length > 0 && !tagOverride) {
       return (
         <KeyedList
           className={className}

package/src/server.tsx

@@ -68,7 +68,13 @@ export function initFlux(opts?: { wasm?: BufferSource | WebAssembly.Module }): P
         await initWasmAsync({ module_or_path: wasmUrl });
         ready = true;
       }
-    })();
+    })().catch((err) => {
+      // Drop the cached rejected promise so a transient failure (e.g. a flaky
+      // .wasm fetch on the web path) can be retried by the next initFlux()
+      // instead of poisoning every subsequent call until a process restart.
+      initPromise = null;
+      throw err;
+    });
   }
   return initPromise;
 }