brookmd 0.25.0 → 0.25.2

package/CHANGELOG.md

@@ -4,6 +4,138 @@ Notable changes to brookmd (formerly `flux-md`). Format based on
 [Keep a Changelog](https://keepachangelog.com/); this project aims to follow
 [Semantic Versioning](https://semver.org/).
 
+## 0.25.2 — 2026-07-27
+
+Performance only. Rendered output is unchanged — byte-identical mid-stream, not
+just at finalize.
+
+### Fixed
+
+- **An open component block no longer re-scans its whole body on every blank
+  line — O(n²) → O(n).** `try_incremental_component` bailed whenever the fed
+  buffer ended on a blank line, and because the cache had already been taken the
+  bail dropped it, forcing a full tail re-scan, a full re-render, and a fresh
+  nested parser over the entire body. Blank lines are legal component-body
+  content, so that fired once per body paragraph.
+
+  The bail existed for a real reason: when the buffer ends blank the full rescan
+  renders the component and all its sub-blocks with `open_tail = false`, which
+  the nested parser's `force_open_tail = true` commits can never match. Rather
+  than work around it with a trigger-byte heuristic (measured: still 3.9×/doubling
+  on any body containing a backtick or bracket — i.e. all real ones), the cache
+  now carries a **settled twin**: a second nested parser with `force_open_tail`
+  off, fed lazily only on the appends that read it, so each catch-up spans just
+  the bytes since the previous blank line. A body with no blank lines never
+  allocates it. The cache now arms once per stream instead of once per paragraph.
+
+  Streaming a 64 KB `<Thinking>` body, scan work and wall time:
+
+  | body | before | after |
+  | --- | --- | --- |
+  | plain paragraphs | 117,333,095 B / 11,954 ms | 229,837 B / **269 ms** |
+  | with inline code | 101,046,887 B / 9,316 ms | 224,977 B / **226 ms** |
+  | with links | 86,362,310 B / 6,837 ms | 220,835 B / **180 ms** |
+  | with `$` and `<` | 117,333,095 B / 7,333 ms | 229,837 B / **388 ms** |
+
+  Scan and render work are now 2.00×/doubling (dead linear); the residual
+  3.3–3.6×/doubling in wall time is a separate, pre-existing cliff —
+  `assemble_wrapped_body` re-materializes an open block's HTML every append —
+  which the already-registered `open-block-html-reemit` shape sits in too.
+
+  **Trade-off:** the twin holds a second copy of an open component's body bytes
+  plus one rendered-HTML set, freed when the block closes. Roughly 2× transient
+  memory for open component blocks *that contain blank lines*; blank-free bodies
+  are unaffected.
+
+### Added
+
+- `tests/scaling.rs` gains `component_multi_para` and `component_multi_para_rich`
+  (backticks, brackets, `$`, `<`), both gated `Linear`. The existing
+  `component_block_open` shape generates no blank lines and so was structurally
+  blind to this: its `scanned` is a flat 249 B from 8 KB to 64 KB. The new shapes
+  measure 252.4× on the pre-fix parser (gate fails) and 16.0× over a 16× span
+  after.
+
+## 0.25.1 — 2026-07-27
+
+A correction release. 0.25.0 shipped one user-visible regression and a dev-gate
+that failed open in production; both are fixed here, along with a pre-existing
+memory leak on the opt-in `childMemo` path. Upgrade from 0.25.0.
+
+### Fixed
+
+- **WITHDRAWN: the streaming component-tag deferral from 0.25.0.** That change
+  gated component rendering on `open_tail`, which a container propagates
+  UNCHANGED to every sub-block of every list item. A component tag alone in a
+  **non-last list item** — whose one-line body carries no trailing newline of its
+  own — therefore never satisfied the gate again, and rendered as the literal
+  text `<Thinking>` for the entire rest of the stream instead of mounting the
+  consumer's component. Measured 201/201 ticks affected in a 200-item list, and
+  the deferral bought exactly one tick across the three shapes it was written
+  for. `brookmd-core` is reverted to its pre-0.24.0 behavior here (0.24.1); the
+  convergence property 0.25.0 claimed is withdrawn with it. The one-tick issue it
+  was chasing is already contained by the per-block error boundary.
+- **Dev-only warnings ran in production.** The gate read `globalThis.process?.env`,
+  which is a different member path from the `process.env.NODE_ENV` free
+  identifier that esbuild / Vite / Next substitute — so in every bundled browser
+  production build it evaluated to "development", printed to real users, and
+  prevented dead-code elimination of the message strings. Every gate is now at
+  the call site in the literal form bundlers fold. Verified against a real Vite
+  build: 11 dev-warning strings survived a production bundle before, 0 now.
+  (Note the trade: in a realm with no `process` at all — an unbundled CDN
+  consumer — these six development warnings no longer fire. Error reporting via
+  `onBlockError` / `console.error` is NOT gated and is unaffected.)
+- **`childMemo` retained every intermediate tree on a single-element block**
+  (pre-existing, opt-in path). The cache key embeds the segment text, so a block
+  whose HTML is ONE top-level element — which is every core-emitted block kind —
+  could never hit: each patch wrote an entry that was never read again, and
+  `CHILD_MEMO_CAP` bounds entry count, not bytes. Peak RSS grew 154 MB → 1.65 GB
+  over 800 patches of a streaming table. Such blocks now take the ordinary
+  whole-block walk.
+
+### Changed
+
+- Shipped bundles are smaller than 0.25.0: gzipped, minified, production —
+  `index` 14,232 → 13,407 B, `react` 14,185 → 13,365 B, `client` 4,651 → 4,283 B.
+  The boundary's `console.error` keeps everything actionable in production (block
+  id, kind, override keys, HTML excerpt, the error) and moves only the
+  explanatory prose behind the dev gate.
+
+## brookmd-react-native 0.1.6 — 2026-07-27
+
+### Fixed
+
+- Vendored native binaries rebuilt against `brookmd-core` 0.24.2, which makes an
+  open component block's streaming cost linear in its body. This matters more
+  on-device than in the browser: the pre-fix path spent ~24 s of native CPU on a
+  64 KB token-streamed `<Thinking>` body. No JS changes.
+
+## brookmd-react-native 0.1.5 — 2026-07-27
+
+### Fixed
+
+- Vendored native binaries rebuilt against `brookmd-core` 0.24.1, so the on-device
+  parser no longer carries the component-tag deferral regression withdrawn in
+  brookmd 0.25.1 (a component tag alone in a non-last list item rendered as
+  literal text for the rest of the stream). No JS changes.
+
+## brookmd-react-native 0.1.4 — 2026-07-26
+
+### Fixed
+
+- **The native transport shim routes worker listeners by event type.** brookmd
+  0.24.0 taught `BrookPool` to listen on `error` / `messageerror` (the browser's
+  out-of-band worker-failure channels). `NativeWorker.addEventListener` ignored
+  its `type` argument and registered every listener in one set, so the pool's
+  fatal handler received the ordinary `ready` / `patch` envelopes and read the
+  first as `brookmd worker failed to load`, killing every stream before it
+  started. Neither channel can fire for an in-process shim — there is no script
+  URL to fetch and no structured-clone step — so they are now accepted and never
+  fired. This was latent: the package pinned `brookmd` to `^0.23.0`, which
+  predates those listeners, so it only surfaced when the range moved.
+- `brookmd` dependency range corrected `^0.23.0` → `^0.25.0`; vendored native
+  binaries rebuilt against `brookmd-core` 0.24.0.
+
 ## 0.25.0 — 2026-07-26
 
 Fixes a crash class where a `components` override could be invoked with the

package/dist/client.js

@@ -29,10 +29,12 @@ function applyPatch(store, patch) {
   for (let i = 0; i < store.committedOrder.length; i++) {
     const b = store.committed.get(store.committedOrder[i]);
     if (b === void 0) {
-      warnOnce(
-        "orphan-committed",
-        `brookmd: committed block ${store.committedOrder[i]} is missing from the store and was dropped. This is a bug in brookmd \u2014 please report it.`
-      );
+      if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+        warnOnce(
+          "orphan-committed",
+          `brookmd: committed block ${store.committedOrder[i]} is missing from the store and was dropped. This is a bug in brookmd \u2014 please report it.`
+        );
+      }
       continue;
     }
     next[w++] = b;
@@ -40,7 +42,9 @@ function applyPatch(store, patch) {
   for (let i = 0; i < store.active.length; i++) {
     const b = store.active[i];
     if (b === void 0) {
-      warnOnce("orphan-active", `brookmd: active block at index ${i} is undefined and was dropped.`);
+      if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+        warnOnce("orphan-active", `brookmd: active block at index ${i} is undefined and was dropped.`);
+      }
       continue;
     }
     next[w++] = b;
@@ -476,10 +480,12 @@ class BrookClient {
     if (this.failedError === null) return;
     this.pendingRebind = false;
     if (this.store.snapshot.length === 0 && !this.staleSnapshot) return;
-    warnOnce(
-      "rebind-reset",
-      "brookmd: the parser was rebuilt on a new worker after a fatal failure, so the document restarted. Blocks rendered before the failure were dropped because the fresh parser renumbers from zero. Enable `recovery` (the default) to re-feed and heal invisibly instead."
-    );
+    if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+      warnOnce(
+        "rebind-reset",
+        "brookmd: the parser was rebuilt on a new worker after a fatal failure, so the document restarted. Blocks rendered before the failure were dropped because the fresh parser renumbers from zero. Enable `recovery` (the default) to re-feed and heal invisibly instead."
+      );
+    }
     this.resetParser();
   }
   get ready() {
@@ -816,7 +822,9 @@ class BrookClient {
       view[i] = { ...nb, id: this.idNamespace + nb.id };
     }
     if (dropped) {
-      warnOnce("merge-hole", "brookmd: the stale-merge produced an empty position \u2014 compacting.");
+      if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+        warnOnce("merge-hole", "brookmd: the stale-merge produced an empty position \u2014 compacting.");
+      }
       this.mergeDropped = true;
       return view.filter((b) => b !== void 0);
     }

package/dist/html-to-react.js

@@ -238,7 +238,7 @@ function pushDecoratedText(out, text, decorators, ancestors, keyBase) {
 function resolveTagType(tag, components) {
   const c = tag.charCodeAt(0);
   if (c >= 65 && c <= 90 && BLOCK_KIND_KEYS.has(tag)) {
-    if (components[tag] !== void 0) {
+    if (components[tag] !== void 0 && typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
       warnOnce(
         "kind-key-as-tag:" + tag,
         `brookmd: raw <${tag}> in the rendered HTML collides with the block-kind override key "${tag}". A block-kind override receives \`BlockComponentProps\` (with \`block\`), which an inline element cannot supply, so the raw tag is rendered as a plain element instead. Rename the raw tag or the override key.`
@@ -335,6 +335,7 @@ function htmlToReact(html, components, childMemoMap, opts) {
   const ctx = opts && (opts.decorators || opts.urlTransform) ? { decorators: opts.decorators, urlTransform: opts.urlTransform } : void 0;
   if (!childMemoMap) return nodesToReact(parseTrustedHtml(html), components, "", ctx, []);
   const segs = topLevelSegments(html);
+  if (segs.length < 2) return nodesToReact(parseTrustedHtml(html), components, "", ctx, []);
   const out = [];
   for (let idx = 0; idx < segs.length; idx++) {
     const seg = segs[idx];

package/dist/react.js

@@ -19,10 +19,12 @@ import { warnOnce } from "./warn.js";
 const NO_DEFER_BLOCKS = [];
 const EMPTY_KEYS = [];
 function skipBadBlock(index) {
-  warnOnce(
-    "bad-block",
-    `brookmd: snapshot position ${index} has no block kind and was skipped. This indicates a corrupted block store \u2014 please report it.`
-  );
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+    warnOnce(
+      "bad-block",
+      `brookmd: snapshot position ${index} has no block kind and was skipped. This indicates a corrupted block store \u2014 please report it.`
+    );
+  }
   return null;
 }
 const warnedUnstable = /* @__PURE__ */ new Set();
@@ -32,8 +34,7 @@ function useUnstablePropWarning(name, value) {
     const prevDefined = ref.current !== void 0 && ref.current !== null;
     const nextDefined = value !== void 0 && value !== null;
     ref.current = value;
-    const env = globalThis.process?.env;
-    if (prevDefined && nextDefined && !warnedUnstable.has(name) && (!env || env.NODE_ENV !== "production")) {
+    if (prevDefined && nextDefined && !warnedUnstable.has(name) && typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
       warnedUnstable.add(name);
       console.warn(
         `<BrookMarkdown>: the \`${name}\` prop changed identity between renders. Hoist it to module scope or wrap it in useMemo \u2014 a fresh identity each render busts the per-block memo and re-parses every block on every patch.`
@@ -625,8 +626,9 @@ class BlockBoundary extends Component {
       this.props.onBlockError(error, info);
       return;
     }
+    const hint = typeof process !== "undefined" && process.env.NODE_ENV !== "production" ? ` This is almost always a \`components\` override throwing. If it is registered for a block-kind or component-tag key, note that the SAME key is also dispatched for a matching element nested inside a block's HTML \u2014 that call gets attributes + children only, with no \`block\` prop. Guard with \`if (!block) return <>{children}</>\`.` : "";
     console.error(
-      `brookmd: block ${info.blockId} (${info.kind}) failed to render and was skipped. This is almost always a \`components\` override throwing. If the override is registered for a block-kind or component-tag key, note that the SAME key is also dispatched for a matching element nested inside a block's HTML \u2014 that call gets attributes + children only, with no \`block\` prop. Guard with \`if (!block) return <>{children}</>\`.`,
+      `brookmd: block ${info.blockId} (${info.kind}) failed to render and was skipped.${hint}`,
       { componentKeys: info.componentKeys, html: info.html },
       error
     );

package/dist/warn.d.ts

@@ -1,9 +1,4 @@
-/** True unless the bundler/runtime says NODE_ENV === "production". Read off
- *  `globalThis` so there is no @types/node dependency; bundlers inline
- *  `process.env.NODE_ENV`, and absence is treated as dev (same rule as the
- *  unstable-prop tripwire in react.tsx). */
-export declare function isDev(): boolean;
-/** Warn once per `id` (dev only). Returns true if it actually warned. */
+/** Warn once per `id`. Callers own the production gate — see the contract above. */
 export declare function warnOnce(id: string, message: string): boolean;
 /** Test-only: clear the latch so a test can assert a warning fires. */
 export declare function __resetWarnOnce(): void;

package/dist/warn.js

@@ -1,10 +1,6 @@
 const warned = /* @__PURE__ */ new Set();
-function isDev() {
-  const env = globalThis.process?.env;
-  return !env || env.NODE_ENV !== "production";
-}
 function warnOnce(id, message) {
-  if (!isDev() || warned.has(id)) return false;
+  if (warned.has(id)) return false;
   warned.add(id);
   console.warn(message);
   return true;
@@ -14,6 +10,5 @@ function __resetWarnOnce() {
 }
 export {
   __resetWarnOnce,
-  isDev,
   warnOnce
 };

package/package.json

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