brookmd 0.22.0

package/dist/client.js

@@ -0,0 +1,754 @@
+function emptyBlockStore() {
+  return { committed: /* @__PURE__ */ new Map(), committedOrder: [], active: [], snapshot: [] };
+}
+function htmlToText(html) {
+  return html.replace(/<[^>]*>/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim();
+}
+function applyPatch(store, patch) {
+  for (const b of patch.newly_committed) {
+    if (!store.committed.has(b.id)) store.committedOrder.push(b.id);
+    store.committed.set(b.id, b);
+  }
+  store.active = patch.active;
+  const next = new Array(store.committedOrder.length + store.active.length);
+  for (let i = 0; i < store.committedOrder.length; i++) {
+    next[i] = store.committed.get(store.committedOrder[i]);
+  }
+  for (let i = 0; i < store.active.length; i++) {
+    next[store.committedOrder.length + i] = store.active[i];
+  }
+  store.snapshot = next;
+}
+class BrookPool {
+  constructor(factory, cap) {
+    this.factory = factory;
+    this.cap = cap;
+  }
+  factory;
+  cap;
+  workers = [];
+  handlers = /* @__PURE__ */ new Map();
+  nextStreamId = 1;
+  /** Reserve a stream id and assign a worker, registering its message handler. */
+  acquire(handler) {
+    const streamId = this.nextStreamId++;
+    const pw = this.pick();
+    pw.streamCount++;
+    pw.streamIds.add(streamId);
+    this.handlers.set(streamId, handler);
+    return { streamId, pw };
+  }
+  /** Free a stream's parser in its worker; keep the worker warm for siblings. */
+  release(streamId, pw) {
+    this.handlers.delete(streamId);
+    pw.streamIds.delete(streamId);
+    pw.streamCount = Math.max(0, pw.streamCount - 1);
+    try {
+      pw.worker.postMessage({ type: "dispose", streamId });
+    } catch {
+    }
+  }
+  /** Inverse of {@link release}: re-register a stream's handler so it receives
+   *  patches again. For React StrictMode's dev double-mount, which destroys a
+   *  client on the simulated unmount and remounts the SAME instance. The worker
+   *  lazily recreates the disposed parser on the next append. */
+  reattach(streamId, pw, handler) {
+    if (!this.handlers.has(streamId)) {
+      pw.streamCount++;
+      pw.streamIds.add(streamId);
+    }
+    this.handlers.set(streamId, handler);
+  }
+  send(pw, msg) {
+    pw.worker.postMessage(msg);
+  }
+  /** Resolves when the given worker has finished WASM init; rejects if it failed. */
+  whenWorkerReady(pw) {
+    if (pw.ready) return Promise.resolve();
+    if (pw.failed) return Promise.reject(pw.failed);
+    return new Promise((resolve, reject) => pw.readyWaiters.push({ resolve, reject }));
+  }
+  /**
+   * Eagerly spin up one worker so WASM init starts BEFORE the first stream —
+   * taking the one-time init off the first-token critical path (e.g. call
+   * `getDefaultPool().warm()` on app load / route entry). Reuses a live worker
+   * if one exists; the warm worker is the one the first stream attaches to (it
+   * has spare capacity), so the work is not wasted. Resolves when that worker has
+   * finished initializing WASM; rejects if init fails fatally. Browser-only (it
+   * constructs a `Worker`).
+   */
+  warm() {
+    const live = this.workers.filter((w) => !w.failed);
+    const pw = live[0] ?? this.create();
+    return this.whenWorkerReady(pw);
+  }
+  /** Terminate every worker (test teardown / full shutdown). */
+  disposeAll() {
+    for (const pw of this.workers) {
+      try {
+        pw.worker.terminate();
+      } catch {
+      }
+    }
+    this.workers = [];
+    this.handlers.clear();
+  }
+  get workerCount() {
+    return this.workers.length;
+  }
+  // Create a new worker while under cap and every live worker is busy; otherwise
+  // attach to the least-loaded LIVE worker. A fatally-failed worker is never
+  // handed out (a stream on it would post into a dead worker and hang) — it is
+  // retained only to reject outstanding whenWorkerReady waiters.
+  pick() {
+    const live = this.workers.filter((w) => !w.failed);
+    if (this.workers.length < this.cap && live.every((w) => w.streamCount > 0)) {
+      return this.create();
+    }
+    if (live.length === 0) return this.create();
+    return live.reduce((a, b) => b.streamCount < a.streamCount ? b : a);
+  }
+  create() {
+    const pw = {
+      worker: this.factory(),
+      ready: false,
+      failed: null,
+      streamCount: 0,
+      streamIds: /* @__PURE__ */ new Set(),
+      readyWaiters: []
+    };
+    pw.worker.addEventListener("message", (ev) => this.onMessage(pw, ev.data));
+    this.workers.push(pw);
+    return pw;
+  }
+  onMessage(pw, msg) {
+    if (msg.type === "ready") {
+      pw.ready = true;
+      const waiters = pw.readyWaiters;
+      pw.readyWaiters = [];
+      for (const w of waiters) w.resolve();
+      return;
+    }
+    if (msg.type === "error" && msg.fatal) {
+      const err = new Error(msg.message);
+      pw.failed = err;
+      const waiters = pw.readyWaiters;
+      pw.readyWaiters = [];
+      for (const w of waiters) {
+        try {
+          w.reject(err);
+        } catch {
+        }
+      }
+      for (const sid of pw.streamIds) this.dispatch(sid, msg);
+      try {
+        pw.worker.terminate();
+      } catch {
+      }
+      const idx = this.workers.indexOf(pw);
+      if (idx !== -1) this.workers.splice(idx, 1);
+      return;
+    }
+    this.dispatch(msg.streamId, msg);
+  }
+  // Route a message to a stream's handler, isolating a throwing client callback
+  // (e.g. a user-supplied onError) so it can neither break the worker message
+  // loop nor starve sibling streams sharing this worker.
+  dispatch(streamId, msg) {
+    try {
+      this.handlers.get(streamId)?.(msg);
+    } catch (e) {
+      console.error("brookmd: stream message handler threw", e);
+    }
+  }
+}
+const ID_NAMESPACE_STRIDE = 4294967296;
+function poolCap() {
+  const hc = typeof navigator !== "undefined" ? navigator.hardwareConcurrency : 0;
+  return Math.min(hc || 4, 8);
+}
+let defaultPool = null;
+function getDefaultPool() {
+  if (!defaultPool) {
+    defaultPool = new BrookPool(
+      () => new Worker(new URL("./worker.js", import.meta.url), { type: "module" }),
+      poolCap()
+    );
+  }
+  return defaultPool;
+}
+function __resetDefaultPool() {
+  defaultPool = null;
+}
+class BrookClient {
+  pool;
+  pw = null;
+  streamId = 0;
+  config;
+  configSent = false;
+  listeners = /* @__PURE__ */ new Set();
+  store = emptyBlockStore();
+  onError;
+  onBlock;
+  attached = true;
+  // Diff baseline for setContent(): the full string fed in so far, and whether
+  // it has been finalized. Cleared by reset()/reattach() (the worker drops the
+  // parser there, so the baseline is stale and the document must be re-fed).
+  lastContent = "";
+  contentDone = false;
+  // Opt-in rAF coalescing (see constructor `coalesce`). When on AND
+  // requestAnimationFrame exists, intra-frame emit()s collapse into ONE
+  // rAF-scheduled flush to listeners — the React useSyncExternalStore path then
+  // renders once per frame instead of once per patch (the DOM renderer already
+  // batches to 1/frame independently). Lossless: committed blocks are
+  // reference-stable, so a dropped intermediate notify only skips a tail-only
+  // render that the next flush supersedes. The finalize/done patch is exempt and
+  // flushes synchronously, never deferred to the next frame.
+  coalesce = false;
+  rafHandle = null;
+  // Set by finalize(); the next patch's emit flushes synchronously (a 'done'
+  // notification must not be deferred a frame) and clears it. Belt-and-suspenders
+  // alongside the per-patch `final` flag, which is the authoritative signal.
+  finalizePending = false;
+  // Stream generation, bumped on reset(). Stamped on every worker message and
+  // 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;
+  totalParseMicros = 0;
+  lastPatchMs = 0;
+  firstAppendMs = 0;
+  retainedBytes = 0;
+  wasmMemoryBytes = 0;
+  // Render-path observability (advanced ONLY when an onRenderMetrics hook is
+  // wired into a renderer; zero-cost otherwise). renderCount = React BlockView
+  // body renders; rebuildCount = DOM node rebuilds.
+  renderCount = 0;
+  rebuildCount = 0;
+  /**
+   * @param options.pool   worker pool to join (defaults to the shared
+   *   process-wide pool — pass a dedicated `BrookPool` only for isolation).
+   * @param options.config per-stream parser flags (see {@link ParserConfig});
+   *   omitted fields use library defaults. Applied once, immutable thereafter.
+   * @param options.onError invoked on a worker/parse error or a fatal WASM-init
+   *   failure (`fatal: true`). Without it, errors are only `console.error`d and
+   *   a load failure surfaces solely as a rejected {@link BrookClient.whenReady}.
+   * @param options.onBlock invoked once per block as it commits (in document
+   *   order, after the store updates) — for side effects like lazily
+   *   highlighting a finished code block or analytics. A committed block never
+   *   re-fires; the streaming tail does not (subscribe for live tail updates).
+   *   NOTE: this is a PARSER-commit hook — the block carries the parser's raw
+   *   id. During a setContent divergence swap the rendered view may show that
+   *   block under a different id (an adopted old id, or a namespaced one), so
+   *   correlate with rendered blocks via subscribe()+getSnapshot(), not this id.
+   * @param options.coalesce opt-in (default `false`): collapse multiple
+   *   intra-frame patch notifications into ONE `requestAnimationFrame`-scheduled
+   *   flush to subscribers, so a React `useSyncExternalStore` consumer renders at
+   *   most once per frame instead of once per patch. Lossless — committed blocks
+   *   are reference-stable, so only superseded tail-only renders are skipped. The
+   *   stream-completion (finalize) patch always flushes synchronously, and a
+   *   pending frame is cancelled on `reset()`/`destroy()`. No effect when
+   *   `requestAnimationFrame` is unavailable (e.g. SSR) — emits stay synchronous.
+   */
+  constructor(options = {}) {
+    this.pool = options.pool ?? getDefaultPool();
+    this.config = options.config;
+    this.onError = options.onError;
+    this.onBlock = options.onBlock;
+    this.coalesce = options.coalesce ?? false;
+  }
+  /**
+   * Lazily reserve this client's stream id and bind it to a pool worker. The
+   * SOLE place that calls pool.acquire() — so the worker is created on the FIRST
+   * worker-bound operation (append/finalize/reset/pipeFrom/whenReady), never at
+   * construct time. This is what makes `new BrookClient()` SSR-safe: nothing here
+   * runs during an SSR render (which only subscribes + reads the snapshot).
+   *
+   * Idempotent: once this.pw is set it returns it immediately and never
+   * re-acquires — this.pw is never nulled (destroy() deliberately keeps it so
+   * StrictMode's destroy()→reattach() on the SAME instance re-registers the same
+   * slot). Note: streamId/worker assignment now follows first-worker-bound-op
+   * order, not construction order — a client constructed first no longer
+   * necessarily owns the lowest streamId. This affects neither the pool cap nor
+   * multiplexing (pick() is unchanged and remains the only path to create()).
+   */
+  ensureAcquired() {
+    if (this.pw && !this.pw.failed) return this.pw;
+    this.pw = null;
+    const { streamId, pw } = this.pool.acquire((msg) => this.onMessage(msg));
+    this.streamId = streamId;
+    this.pw = pw;
+    return pw;
+  }
+  get ready() {
+    return this.pw?.ready ?? false;
+  }
+  whenReady() {
+    const pw = this.ensureAcquired();
+    return this.pool.whenWorkerReady(pw);
+  }
+  // The config rides on the first message a stream sends; the worker applies it
+  // when it creates the parser. postMessage is FIFO per worker, so it always
+  // lands before any append is processed. Returns undefined after the first use.
+  firstConfig() {
+    if (this.configSent || !this.config) return void 0;
+    this.configSent = true;
+    return this.config;
+  }
+  append(chunk) {
+    const pw = this.ensureAcquired();
+    if (this.firstAppendMs === 0) this.firstAppendMs = performance.now();
+    this.pool.send(pw, { type: "append", streamId: this.streamId, chunk, config: this.firstConfig(), epoch: this.epoch });
+  }
+  finalize() {
+    const pw = this.ensureAcquired();
+    this.finalizePending = true;
+    this.pool.send(pw, { type: "finalize", streamId: this.streamId, config: this.firstConfig(), epoch: this.epoch });
+  }
+  /**
+   * Pipe a source straight in: read it to completion, `append()` each chunk,
+   * then `finalize()`. The LLM-native path — e.g.
+   * `await client.pipeFrom(await fetch("/api/chat"))`. Accepts:
+   *   - a `Response` or its `ReadableStream<Uint8Array>` body (bytes; decoded
+   *     with `TextDecoder({ stream: true })` so a multibyte sequence straddling
+   *     a chunk boundary carries into the next read), or
+   *   - an `AsyncIterable<string>` (e.g. an SSE delta generator) — string chunks
+   *     appended verbatim.
+   *
+   * Pass `opts.signal` to supersede/cancel: the signal is checked on every
+   * iteration, so once aborted no further chunk is appended and **finalize is
+   * skipped** (a superseded stream must not finalize). For a byte source the
+   * reader is also `cancel()`'d to tear down the upstream. Resolves once
+   * finalized (or cleanly on abort); rejects if the source itself errors.
+   * Browser-only for byte sources (uses `TextDecoder`).
+   */
+  async pipeFrom(source, opts) {
+    const signal = opts?.signal;
+    if (signal?.aborted) return;
+    if (!("getReader" in source) && !("body" in source)) {
+      for await (const chunk of source) {
+        if (signal?.aborted) return;
+        this.append(chunk);
+      }
+      if (!signal?.aborted) this.finalize();
+      return;
+    }
+    const body = "body" in source ? source.body : source;
+    if (!body) {
+      this.finalize();
+      return;
+    }
+    const reader = body.getReader();
+    const onAbort = () => {
+      reader.cancel().catch(() => {
+      });
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const decoder = new TextDecoder();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (signal?.aborted) return;
+        if (done) break;
+        if (value) this.append(decoder.decode(value, { stream: true }));
+      }
+      this.append(decoder.decode());
+      this.finalize();
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Drive the parser from a CONTROLLED full string instead of manual appends.
+   * Pass the whole document-so-far each time; setContent diffs it against the
+   * last value and does the minimal work:
+   *   - **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, 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,
+   * no readiness gate (appends before WASM is ready are buffered). Pass
+   * `{ done: true }` once the content is final to `finalize()` (idempotent within
+   * a generation; a content change *after* done reopens the stream via a fresh
+   * reparse, since a finalized parser is terminal and can't be appended to).
+   * Drive a given client with `setContent` *or* manual `append()`/`finalize()`,
+   * not both — they share the internal diff baseline.
+   *
+   * v1 note: the non-prefix path is a full reparse, not a partial rewind —
+   * committed blocks are frozen, so there is no truncate-to-offset. For the
+   * common case (append-growth + one end-of-stream swap) that is optimal. A
+   * transform that rewrites *earlier* bytes on every update is an anti-pattern
+   * here (it forces a reparse each tick); do that enrichment at render time via
+   * `components` instead, keeping the source append-only.
+   */
+  setContent(content, opts) {
+    if (content !== this.lastContent) {
+      if (!this.contentDone && content.startsWith(this.lastContent)) {
+        if (this.lastContent === "" && content.length > 0 && this.getSnapshot().length > 0) {
+          this.softReset(this.getSnapshot());
+        }
+        this.append(content.slice(this.lastContent.length));
+      } else {
+        const displayed = this.getSnapshot();
+        if (content.length > 0 && displayed.length > 0) this.softReset(displayed);
+        else this.reset();
+        this.append(content);
+      }
+      this.lastContent = content;
+      this.contentDone = false;
+    }
+    if (opts?.done && !this.contentDone) {
+      this.finalize();
+      this.contentDone = true;
+    }
+  }
+  reset() {
+    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;
+    this.totalParseMicros = 0;
+    this.lastPatchMs = 0;
+    this.firstAppendMs = 0;
+    this.retainedBytes = 0;
+    this.wasmMemoryBytes = 0;
+    this.lastContent = "";
+    this.contentDone = false;
+    this.cancelFrame();
+    this.finalizePending = false;
+    this.epoch += 1;
+    const pw = this.ensureAcquired();
+    this.pool.send(pw, { type: "reset", streamId: this.streamId, epoch: this.epoch });
+  }
+  destroy() {
+    if (!this.attached) return;
+    if (this.pw) this.pool.release(this.streamId, this.pw);
+    this.cancelFrame();
+    this.finalizePending = false;
+    this.listeners.clear();
+    this.attached = false;
+  }
+  /**
+   * Re-register with the pool after {@link destroy} so the client receives
+   * patches again. Needed only for React StrictMode's dev double-mount, where
+   * the renderer destroys on the simulated unmount then remounts the SAME
+   * client instance; apps don't normally call this. No-op if still attached.
+   */
+  reattach() {
+    if (this.attached) return;
+    this.lastContent = "";
+    this.contentDone = false;
+    if (!this.pw) {
+      this.attached = true;
+      return;
+    }
+    this.pool.reattach(this.streamId, this.pw, (msg) => this.onMessage(msg));
+    this.attached = true;
+    this.configSent = false;
+  }
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  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 CARRYING THE OLD BLOCK'S id, so
+   *     the same keyed component re-renders in place and its state (pagination,
+   *     expansion…) survives the swap; only a NET-NEW position (past the old
+   *     document's end) takes a namespace-offset id, where a raw parser id
+   *     could genuinely collide with a retained old id;
+   *   - 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: ob.id };
+        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.
+   * No-op cost when no hook is wired (it is simply never called). Not part of
+   * the public API surface — the underscore marks it renderer-internal.
+   */
+  __noteRender() {
+    this.renderCount++;
+  }
+  /**
+   * Internal: the DOM renderer calls this once per actual node rebuild (the
+   * changed-block branch) when an `onRenderMetrics` hook is wired, so
+   * `getMetrics().rebuildCount` aggregates churn. Never called without a hook.
+   */
+  __noteRebuild() {
+    this.rebuildCount++;
+  }
+  getMetrics() {
+    const elapsed = this.firstAppendMs ? Math.max(1, performance.now() - this.firstAppendMs) : 1;
+    return {
+      bytes: this.appendedBytes,
+      patches: this.patchCount,
+      meanParseMicros: this.patchCount > 0 ? this.totalParseMicros / this.patchCount : 0,
+      totalParseMs: this.totalParseMicros / 1e3,
+      throughputKBs: this.appendedBytes / 1024 / (elapsed / 1e3),
+      committedBlocks: this.store.committed.size,
+      activeBlocks: this.store.active.length,
+      lastPatchAgoMs: this.lastPatchMs === 0 ? 0 : performance.now() - this.lastPatchMs,
+      retainedBytes: this.retainedBytes,
+      // NOTE: with the worker pool, this is the *shared* worker's WASM heap —
+      // clients on the same worker report the same number. Use Math.max (not
+      // sum) when aggregating across clients; summing double-counts.
+      wasmMemoryBytes: this.wasmMemoryBytes,
+      // Render-path churn (0 unless an onRenderMetrics hook is wired into a
+      // renderer): renderCount = React block-body renders, rebuildCount = DOM
+      // node rebuilds. Committed blocks memo-skip, so they contribute once.
+      renderCount: this.renderCount,
+      rebuildCount: this.rebuildCount
+    };
+  }
+  /**
+   * A heading outline of the current snapshot (committed + active), in document
+   * order — for a table of contents. Works mid-stream; entries appear as their
+   * headings stream in. The `id` is stable, so a built ToC won't re-key.
+   */
+  outline() {
+    const out = [];
+    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;
+        out.push({ level, text: htmlToText(b.html), id: b.id });
+      }
+    }
+    return out;
+  }
+  /**
+   * The rendered document as plain text — tags stripped, entities decoded,
+   * blocks separated by blank lines. Derived from the rendered HTML (the source
+   * markdown is parsed away in WASM and not retained client-side), so it is a
+   * readable approximation for search indexing / summaries, not a round-trip of
+   * the original source.
+   */
+  toPlaintext() {
+    const parts = [];
+    for (const b of this.getSnapshot()) {
+      const t = htmlToText(b.html);
+      if (t) parts.push(t);
+    }
+    return parts.join("\n\n");
+  }
+  onMessage(msg) {
+    switch (msg.type) {
+      case "patch": {
+        if (msg.epoch !== void 0 && msg.epoch < this.epoch) break;
+        let patch;
+        try {
+          patch = JSON.parse(msg.patch);
+        } catch (e) {
+          const message = e instanceof Error ? e.message : String(e);
+          if (this.onError) this.onError({ message: `brookmd: malformed patch (${message})` });
+          else console.error("brookmd: malformed patch:", message);
+          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;
+        this.wasmMemoryBytes = msg.wasmMemoryBytes;
+        this.patchCount += 1;
+        this.lastPatchMs = performance.now();
+        const sync = this.finalizePending || msg.final === true;
+        this.finalizePending = false;
+        this.emit(sync);
+        if (this.onBlock) {
+          for (const b of patch.newly_committed) this.onBlock(b);
+        }
+        break;
+      }
+      case "error":
+        if (this.onError) {
+          this.onError({ message: msg.message, fatal: msg.fatal });
+        } else {
+          console.error("brookmd worker error:", msg.message);
+        }
+        break;
+    }
+  }
+  /**
+   * Notify subscribers of a new snapshot.
+   *
+   * With `coalesce` off (default) this is fully synchronous, exactly as before.
+   * With it on and `requestAnimationFrame` available, a normal emit only
+   * *schedules* a single per-frame flush — repeated intra-frame emits collapse
+   * into one notify. `sync` forces an immediate flush (stream completion / reset)
+   * and cancels any frame already pending so the snapshot is delivered once.
+   */
+  emit(sync = false) {
+    if (this.coalesce && !sync && typeof requestAnimationFrame === "function") {
+      if (this.rafHandle !== null) return;
+      this.rafHandle = requestAnimationFrame(() => {
+        this.rafHandle = null;
+        this.flushNow();
+      });
+      return;
+    }
+    this.cancelFrame();
+    this.flushNow();
+  }
+  flushNow() {
+    for (const fn of this.listeners) fn();
+  }
+  cancelFrame() {
+    if (this.rafHandle !== null) {
+      if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(this.rafHandle);
+      this.rafHandle = null;
+    }
+  }
+}
+export {
+  BrookClient,
+  BrookPool,
+  __resetDefaultPool,
+  applyPatch,
+  emptyBlockStore,
+  getDefaultPool
+};