@stream-mdx/react 0.3.0 → 0.5.0

package/dist/server.mjs

@@ -0,0 +1,4824 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/mdx-client.ts
+var mdx_client_exports = {};
+__export(mdx_client_exports, {
+  MDXClient: () => MDXClient,
+  MDXComponentFactory: () => MDXComponentFactory,
+  getMDXClient: () => getMDXClient,
+  getMDXComponentFactory: () => getMDXComponentFactory,
+  registerInlineMdxModule: () => registerInlineMdxModule,
+  registerMDXComponents: () => registerMDXComponents
+});
+import React2 from "react";
+import * as ReactJsxRuntime from "react/jsx-runtime";
+function assignMdxChildKey(child, index) {
+  if (child == null) return child;
+  if (Array.isArray(child)) {
+    return child.map((entry, subIndex) => assignMdxChildKey(entry, `${index}-${subIndex}`));
+  }
+  if (React2.isValidElement(child)) {
+    if (child.key !== null && child.key !== void 0) {
+      return child;
+    }
+    return React2.cloneElement(child, { key: index });
+  }
+  return child;
+}
+function getMDXClient(compileEndpoint) {
+  if (!globalMDXClient) {
+    globalMDXClient = new MDXClient(compileEndpoint);
+  }
+  return globalMDXClient;
+}
+function getMDXComponentFactory(compileEndpoint) {
+  if (!globalComponentFactory) {
+    const client = getMDXClient(compileEndpoint);
+    globalComponentFactory = new MDXComponentFactory(client);
+  }
+  return globalComponentFactory;
+}
+function registerMDXComponents(components, options) {
+  const factory = getMDXComponentFactory();
+  factory.registerComponents(components, options);
+}
+function registerInlineMdxModule(compiled) {
+  const factory = getMDXComponentFactory();
+  factory.registerInlineModule({
+    id: compiled.id,
+    code: compiled.code,
+    dependencies: compiled.dependencies ?? []
+  });
+}
+var withClassName, MDXClient, MDXComponentFactory, globalMDXClient, globalComponentFactory;
+var init_mdx_client = __esm({
+  "src/mdx-client.ts"() {
+    "use strict";
+    withClassName = (tag, className) => {
+      return (props) => React2.createElement(tag, { className, ...props });
+    };
+    MDXClient = class {
+      constructor(compileEndpoint = "/api/mdx-compile-v2") {
+        this.cache = /* @__PURE__ */ new Map();
+        this.inlineModules = /* @__PURE__ */ new Map();
+        this.compiledCache = /* @__PURE__ */ new Map();
+        this.compiledInflight = /* @__PURE__ */ new Map();
+        this.compileEndpoint = compileEndpoint;
+      }
+      /**
+       * Compile MDX block on server
+       */
+      async compile(block) {
+        if (block.type !== "mdx") {
+          throw new Error("Block is not MDX type");
+        }
+        const cacheKey = `${block.id}\0${block.payload.raw ?? ""}`;
+        const cachedPromise = this.cache.get(cacheKey);
+        if (cachedPromise) {
+          return cachedPromise;
+        }
+        const compilationPromise = this.doCompile(block);
+        this.cache.set(cacheKey, compilationPromise);
+        try {
+          const result = await compilationPromise;
+          return result;
+        } catch (error) {
+          this.cache.delete(cacheKey);
+          throw error;
+        }
+      }
+      async getCompiledInternal(ref) {
+        const inline = this.inlineModules.get(ref.id);
+        if (inline) {
+          return this.cloneCompiled(inline);
+        }
+        const cached = this.compiledCache.get(ref.id);
+        if (cached) {
+          return this.cloneCompiled(cached);
+        }
+        const inflight = this.compiledInflight.get(ref.id);
+        if (inflight) {
+          const resolved = await inflight;
+          return this.cloneCompiled(resolved);
+        }
+        const fetchPromise = this.fetchCompiled(ref);
+        this.compiledInflight.set(ref.id, fetchPromise);
+        try {
+          const data = await fetchPromise;
+          this.compiledCache.set(ref.id, data);
+          return this.cloneCompiled(data);
+        } finally {
+          this.compiledInflight.delete(ref.id);
+        }
+      }
+      async getCompiled(ref, options) {
+        if (options?.signal) {
+          const inline = this.inlineModules.get(ref.id);
+          if (inline) {
+            return this.cloneCompiled(inline);
+          }
+          const cached = this.compiledCache.get(ref.id);
+          if (cached) {
+            return this.cloneCompiled(cached);
+          }
+          const data = await this.fetchCompiled(ref, options);
+          this.compiledCache.set(ref.id, data);
+          return this.cloneCompiled(data);
+        }
+        return this.getCompiledInternal(ref);
+      }
+      /**
+       * Clear compilation cache
+       */
+      clearCache() {
+        this.cache.clear();
+        this.compiledCache.clear();
+        this.compiledInflight.clear();
+      }
+      registerInlineModule(compiled) {
+        this.inlineModules.set(compiled.id, {
+          ...compiled,
+          dependencies: Array.isArray(compiled.dependencies) ? [...compiled.dependencies] : []
+        });
+      }
+      clearInlineModules() {
+        this.inlineModules.clear();
+      }
+      /**
+       * Actual compilation implementation
+       */
+      async doCompile(block) {
+        const response = await fetch(this.compileEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            content: block.payload.raw,
+            blockId: block.id
+          })
+        });
+        if (!response.ok) {
+          const error = await response.json().catch(() => ({ error: "Unknown error" }));
+          throw new Error(`MDX compilation failed: ${error.error || response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+          id: data.id,
+          code: data.code,
+          dependencies: data.dependencies || [],
+          cached: data.cached || false
+        };
+      }
+      async fetchCompiled(ref, options) {
+        const response = await fetch(`${this.compileEndpoint}?id=${ref.id}`, {
+          signal: options?.signal
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to get compiled MDX: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+          id: data.id,
+          code: data.code,
+          dependencies: data.dependencies || [],
+          timestamp: data.timestamp
+        };
+      }
+      cloneCompiled(compiled) {
+        return {
+          ...compiled,
+          dependencies: Array.isArray(compiled.dependencies) ? [...compiled.dependencies] : []
+        };
+      }
+    };
+    MDXComponentFactory = class {
+      constructor(mdxClient) {
+        this.components = /* @__PURE__ */ new Map();
+        this.customComponents = /* @__PURE__ */ new Map();
+        this.mdxClient = mdxClient;
+        this.baseComponents = this.createBaseComponents();
+      }
+      registerInlineModule(module) {
+        this.mdxClient.registerInlineModule(module);
+        this.components.delete(module.id);
+      }
+      /**
+       * Create React component from compiled MDX
+       */
+      async createComponent(ref) {
+        const cached = this.components.get(ref.id);
+        if (cached) {
+          return cached;
+        }
+        const compiled = await this.mdxClient.getCompiled(ref);
+        const component = this.evaluateCompiledMDX(compiled);
+        this.components.set(ref.id, component);
+        return component;
+      }
+      /**
+       * Safely evaluate compiled MDX code
+       */
+      evaluateCompiledMDX(compiled) {
+        try {
+          const context = this.createEvaluationContext();
+          const argNames = Object.keys(context);
+          const argValues = Object.values(context);
+          const moduleExports = new Function(...argNames, compiled.code)(...argValues);
+          const MDXComponent = this.resolveEvaluatedModule(moduleExports);
+          return (props) => {
+            const registryComponents = this.getComponents();
+            const incomingComponents = props?.components;
+            const mergedComponents = incomingComponents ? { ...registryComponents, ...incomingComponents } : registryComponents;
+            return React2.createElement(MDXComponent, {
+              ...props,
+              components: mergedComponents
+            });
+          };
+        } catch (error) {
+          console.error("Failed to evaluate MDX:", error);
+          return () => React2.createElement(
+            "div",
+            {
+              className: "mdx-error"
+            },
+            `MDX Error: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+      /**
+       * Create safe evaluation context for MDX
+       */
+      createEvaluationContext() {
+        const runtime = ReactJsxRuntime;
+        const createElementWithChildren = (type, props, key) => {
+          const baseProps = props ?? {};
+          const finalProps = key === void 0 || key === null ? baseProps : { ...baseProps, key };
+          if (Array.isArray(finalProps.children)) {
+            finalProps.children = finalProps.children.map((child, index) => assignMdxChildKey(child, index));
+          }
+          return React2.createElement(type, finalProps);
+        };
+        const runtimeJsx = typeof runtime.jsx === "function" ? runtime.jsx.bind(runtime) : createElementWithChildren;
+        const runtimeJsxs = typeof runtime.jsxs === "function" ? runtime.jsxs.bind(runtime) : createElementWithChildren;
+        const runtimeJsxDEV = typeof runtime.jsxDEV === "function" ? runtime.jsxDEV.bind(runtime) : (type, props, key, ..._rest) => createElementWithChildren(type, props, key);
+        const jsxRuntime = {
+          jsx: runtimeJsx,
+          jsxs: runtimeJsxs,
+          jsxDEV: runtimeJsxDEV,
+          Fragment: runtime.Fragment ?? React2.Fragment
+        };
+        return {
+          __mdx_runtime: jsxRuntime,
+          React: React2,
+          Fragment: React2.Fragment,
+          useState: React2.useState,
+          useEffect: React2.useEffect,
+          useMemo: React2.useMemo,
+          useCallback: React2.useCallback,
+          useRef: React2.useRef,
+          useContext: React2.useContext,
+          useReducer: React2.useReducer,
+          useLayoutEffect: React2.useLayoutEffect,
+          console: {
+            log: console.log,
+            warn: console.warn,
+            error: console.error
+          }
+        };
+      }
+      resolveEvaluatedModule(output) {
+        if (!output) {
+          throw new Error("Compiled MDX module returned no exports");
+        }
+        if (typeof output === "function") {
+          return output;
+        }
+        if (typeof output.default === "function") {
+          return output.default;
+        }
+        if (typeof output.MDXContent === "function") {
+          return output.MDXContent;
+        }
+        throw new Error("Compiled MDX module did not export a component");
+      }
+      getComponents() {
+        if (this.customComponents.size === 0) {
+          return { ...this.baseComponents };
+        }
+        const merged = { ...this.baseComponents };
+        for (const [key, component] of this.customComponents) {
+          merged[key] = component;
+        }
+        return merged;
+      }
+      /**
+       * Register or replace custom MDX components
+       */
+      registerComponents(components, options) {
+        if (options?.replace) {
+          this.customComponents.clear();
+        }
+        for (const [key, component] of Object.entries(components)) {
+          if (!component) continue;
+          this.customComponents.set(key, component);
+        }
+      }
+      /**
+       * Get base MDX components
+       */
+      createBaseComponents() {
+        return {
+          // Standard HTML elements
+          h1: withClassName("h1", "mdx-h1"),
+          h2: withClassName("h2", "mdx-h2"),
+          h3: withClassName("h3", "mdx-h3"),
+          h4: withClassName("h4", "mdx-h4"),
+          h5: withClassName("h5", "mdx-h5"),
+          h6: withClassName("h6", "mdx-h6"),
+          p: withClassName("p", "mdx-p"),
+          strong: withClassName("strong", "mdx-strong"),
+          em: withClassName("em", "mdx-em"),
+          code: withClassName("code", "mdx-code"),
+          pre: withClassName("pre", "mdx-pre"),
+          ul: withClassName("ul", "mdx-ul"),
+          ol: withClassName("ol", "mdx-ol"),
+          li: withClassName("li", "mdx-li"),
+          blockquote: withClassName("blockquote", "mdx-blockquote"),
+          a: (props) => React2.createElement("a", {
+            className: "mdx-link",
+            target: props.href?.startsWith("http") ? "_blank" : void 0,
+            rel: props.href?.startsWith("http") ? "noopener noreferrer" : void 0,
+            ...props
+          }),
+          img: (props) => React2.createElement("img", { className: "mdx-img", ...props }),
+          table: withClassName("table", "mdx-table"),
+          thead: withClassName("thead", "mdx-thead"),
+          tbody: withClassName("tbody", "mdx-tbody"),
+          tr: withClassName("tr", "mdx-tr"),
+          th: withClassName("th", "mdx-th"),
+          td: withClassName("td", "mdx-td")
+        };
+      }
+      /**
+       * Clear component cache
+       */
+      clearCache() {
+        this.components.clear();
+      }
+      clearCustomComponents() {
+        this.customComponents.clear();
+      }
+    };
+    globalMDXClient = null;
+    globalComponentFactory = null;
+  }
+});
+
+// src/renderer/blocks-renderer.tsx
+import React8, { useMemo as useMemo3 } from "react";
+import { getBlockKey, PATCH_ROOT_ID as PATCH_ROOT_ID2 } from "@stream-mdx/core";
+
+// src/renderer/hooks.ts
+import { useMemo, useSyncExternalStore } from "react";
+function useRendererNode(store, id) {
+  const selector = useMemo(() => {
+    return () => store.getNodeWithVersion(id);
+  }, [store, id]);
+  const snapshot = useSyncExternalStore(store.subscribe, selector, selector);
+  return snapshot.node;
+}
+function useRendererChildren(store, id) {
+  const selector = useMemo(() => {
+    return () => store.getChildrenWithVersion(id);
+  }, [store, id]);
+  const snapshot = useSyncExternalStore(store.subscribe, selector, selector);
+  return snapshot.children;
+}
+
+// src/renderer/node-views.tsx
+import { getDefaultCodeWrapperAttributes as getDefaultCodeWrapperAttributes2, stripCodeFence } from "@stream-mdx/core";
+import React7 from "react";
+
+// src/components/index.ts
+import { createTrustedHTML, sanitizeHTML } from "@stream-mdx/core";
+
+// src/mdx-hydration-metrics.ts
+var entries = /* @__PURE__ */ new Map();
+var lastHydrationMs = null;
+function now() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function markMdxHydrationStart(id) {
+  if (!id) return;
+  const entry = entries.get(id) ?? { status: "compiled" };
+  if (entry.startedAt === void 0) {
+    entry.startedAt = now();
+  }
+  entry.status = "compiled";
+  entries.set(id, entry);
+}
+function markMdxHydrated(id) {
+  if (!id) return;
+  const entry = entries.get(id) ?? { status: "hydrated" };
+  if (entry.startedAt === void 0) {
+    entry.startedAt = now();
+  }
+  entry.hydratedAt = now();
+  entry.status = "hydrated";
+  entries.set(id, entry);
+  lastHydrationMs = entry.startedAt ? entry.hydratedAt - entry.startedAt : null;
+}
+function markMdxHydrationError(id) {
+  if (!id) return;
+  const entry = entries.get(id) ?? { status: "error" };
+  entry.status = "error";
+  entries.set(id, entry);
+}
+
+// src/mdx-hydration-context.ts
+import React from "react";
+var MdxHydrationContext = React.createContext({ controller: null });
+
+// src/mdx-runtime.ts
+var mdxRuntimePromise = null;
+function loadMdxRuntime() {
+  if (!mdxRuntimePromise) {
+    mdxRuntimePromise = Promise.resolve().then(() => (init_mdx_client(), mdx_client_exports));
+  }
+  return mdxRuntimePromise;
+}
+
+// src/renderer/use-deferred-render.ts
+import { useEffect, useState } from "react";
+function useDeferredRender(ref, options) {
+  const enabled = options?.enabled ?? true;
+  const [shouldRender, setShouldRender] = useState(!enabled);
+  useEffect(() => {
+    if (!enabled) {
+      setShouldRender(true);
+      return;
+    }
+    const target = ref.current;
+    if (!target) {
+      return;
+    }
+    let cancelled = false;
+    let idleId = null;
+    let timerId = null;
+    const scheduleRender = () => {
+      if (cancelled) return;
+      setShouldRender(true);
+    };
+    const runWithIdle = () => {
+      if (typeof globalThis.requestIdleCallback === "function") {
+        idleId = globalThis.requestIdleCallback(scheduleRender, { timeout: options?.idleTimeoutMs ?? 200 });
+      } else {
+        timerId = window.setTimeout(scheduleRender, options?.idleTimeoutMs ?? 200);
+      }
+    };
+    const observer = new IntersectionObserver(
+      (entries2) => {
+        for (const entry of entries2) {
+          if (entry.isIntersecting || entry.intersectionRatio > 0) {
+            observer.disconnect();
+            const debounceMs = options?.debounceMs ?? 80;
+            timerId = window.setTimeout(runWithIdle, debounceMs);
+            return;
+          }
+        }
+      },
+      { rootMargin: options?.rootMargin ?? "200px 0px" }
+    );
+    observer.observe(target);
+    return () => {
+      cancelled = true;
+      observer.disconnect();
+      if (idleId !== null && typeof globalThis.cancelIdleCallback === "function") {
+        globalThis.cancelIdleCallback(idleId);
+      }
+      if (timerId !== null) {
+        window.clearTimeout(timerId);
+      }
+    };
+  }, [enabled, options?.debounceMs, options?.idleTimeoutMs, options?.rootMargin, ref]);
+  return shouldRender;
+}
+
+// src/components/index.ts
+import { removeHeadingMarkers } from "@stream-mdx/core";
+import React4 from "react";
+
+// src/utils/inline-html.ts
+import React3 from "react";
+var BACKTICK_CONTENT = /^`([\s\S]+)`$/;
+var DEFAULT_INLINE_HTML_RENDERERS = {
+  kbd: (descriptor, ctx) => {
+    const trimmed = descriptor.rawInner.trim();
+    const match = BACKTICK_CONTENT.exec(trimmed);
+    if (match) {
+      const codeText = decodeHtmlEntities(match[1]);
+      const props = mapAttributesToProps(descriptor.attributes);
+      if (ctx.key !== void 0 && ctx.key !== null) {
+        props.key = ctx.key;
+      }
+      return React3.createElement("kbd", props, React3.createElement("code", { className: "inline-code" }, codeText));
+    }
+    return ctx.defaultRender();
+  }
+};
+function renderInlineHtmlSegment(raw, sanitized, options = {}) {
+  const descriptor = parseInlineHtmlDescriptor(raw, sanitized);
+  if (!descriptor) {
+    return null;
+  }
+  const className = options.className ?? "markdown-inline-html";
+  const isInlineTag = INLINE_ELEMENTS.has(descriptor.tagName);
+  const defaultRender = () => {
+    if (!descriptor.sanitized || descriptor.sanitized.length === 0) {
+      if (!descriptor.text) {
+        return null;
+      }
+      if (options.key !== void 0 && options.key !== null) {
+        return React3.createElement(React3.Fragment, { key: options.key }, descriptor.text);
+      }
+      return React3.createElement(React3.Fragment, {}, descriptor.text);
+    }
+    if (isInlineTag) {
+      const parsedElement = renderSanitizedHtmlTree(descriptor.sanitized, options.key);
+      if (parsedElement) {
+        return parsedElement;
+      }
+    }
+    const props = {
+      className,
+      dangerouslySetInnerHTML: { __html: descriptor.sanitized }
+    };
+    if (options.key !== void 0 && options.key !== null) {
+      props.key = options.key;
+    }
+    return React3.createElement("span", props);
+  };
+  const allRenderers = options.renderers ? { ...DEFAULT_INLINE_HTML_RENDERERS, ...options.renderers } : DEFAULT_INLINE_HTML_RENDERERS;
+  const renderer = allRenderers[descriptor.tagName];
+  if (renderer) {
+    const rendered = renderer(descriptor, { key: options.key, defaultRender });
+    if (rendered) {
+      if (options.key !== void 0 && options.key !== null && React3.isValidElement(rendered) && rendered.key === null) {
+        return React3.cloneElement(rendered, { key: options.key });
+      }
+      return rendered;
+    }
+  }
+  return defaultRender();
+}
+function parseInlineHtmlDescriptor(raw, sanitized) {
+  const normalizedRaw = typeof raw === "string" ? raw.trim() : "";
+  const normalizedSanitized = typeof sanitized === "string" && sanitized.length > 0 ? sanitized.trim() : normalizedRaw;
+  if (!normalizedSanitized) {
+    return null;
+  }
+  const match = normalizedSanitized.match(/^<([A-Za-z][\w:-]*)(\s[^>]*)?>([\s\S]*)<\/\1>$/);
+  if (!match) {
+    return null;
+  }
+  const [, tagNameRaw, attrString = "", sanitizedInner = ""] = match;
+  const tagName = tagNameRaw.toLowerCase();
+  const attributes = parseAttributes(attrString);
+  let rawInner = "";
+  if (normalizedRaw) {
+    const rawMatch = normalizedRaw.match(/^<([A-Za-z][\w:-]*)(\s[^>]*)?>([\s\S]*)<\/\1>$/);
+    rawInner = rawMatch ? rawMatch[3] ?? "" : normalizedRaw;
+  }
+  const text = extractPlainText(rawInner || sanitizedInner);
+  return {
+    tagName,
+    attributes,
+    raw: normalizedRaw || normalizedSanitized,
+    sanitized: normalizedSanitized,
+    rawInner,
+    sanitizedInner,
+    text
+  };
+}
+function parseAttributes(input) {
+  const attrs = {};
+  if (!input) return attrs;
+  const attrPattern = /([A-Za-z_:][\w:.\-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  let match = attrPattern.exec(input);
+  while (match !== null) {
+    const name = match[1];
+    if (!name) continue;
+    const value = match[2] ?? match[3] ?? match[4] ?? "";
+    attrs[name] = value;
+    match = attrPattern.exec(input);
+  }
+  return attrs;
+}
+function mapAttributesToProps(attrs) {
+  const props = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (key === "class") {
+      props.className = value;
+    } else if (key === "style") {
+      props.style = parseStyleAttribute(value);
+    } else if (key === "tabindex" || key === "tabIndex") {
+      const normalized = normalizeTabIndex(value);
+      if (normalized !== void 0) {
+        props.tabIndex = normalized;
+      }
+    } else {
+      props[key] = value;
+    }
+  }
+  return props;
+}
+function parseStyleAttribute(value) {
+  const style = {};
+  if (!value) return style;
+  const pairs = value.split(";");
+  for (const pair of pairs) {
+    if (!pair.trim()) continue;
+    const [property, rawVal] = pair.split(":");
+    if (!property || rawVal === void 0) continue;
+    const camelProp = property.trim().replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+    style[camelProp] = rawVal.trim();
+  }
+  return style;
+}
+function normalizeTabIndex(value) {
+  const numeric = Number(value);
+  return Number.isNaN(numeric) ? void 0 : numeric;
+}
+function decodeHtmlEntities(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function extractPlainText(value) {
+  if (!value) return "";
+  const withoutTags = value.replace(/<\/?[^>]+>/g, "");
+  return decodeHtmlEntities(withoutTags);
+}
+function renderSanitizedHtmlTree(html, key) {
+  if (typeof DOMParser === "undefined") {
+    return null;
+  }
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, "text/html");
+    const body = doc.body;
+    const nodes = Array.from(body.childNodes);
+    if (nodes.length === 0) {
+      return null;
+    }
+    const baseKey = typeof key === "string" || typeof key === "number" ? String(key) : "inline-html";
+    const children = nodes.map((node, index) => convertDomNode(node, `${baseKey}-${index}`)).filter((child) => child !== null && child !== void 0);
+    if (children.length === 0) {
+      return null;
+    }
+    if (children.length === 1) {
+      const [child] = children;
+      if (React3.isValidElement(child)) {
+        if (key !== void 0 && key !== null) {
+          return React3.cloneElement(child, { key });
+        }
+        return child;
+      }
+      if (typeof child === "string" || typeof child === "number") {
+        if (key !== void 0 && key !== null) {
+          return React3.createElement(React3.Fragment, { key }, child);
+        }
+        return React3.createElement(React3.Fragment, {}, child);
+      }
+      return React3.createElement(React3.Fragment, { key }, child);
+    }
+    return React3.createElement(React3.Fragment, { key }, ...children);
+  } catch {
+    return null;
+  }
+}
+function convertDomNode(node, key) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent ?? "";
+  }
+  if (node.nodeType !== Node.ELEMENT_NODE) {
+    return null;
+  }
+  const element = node;
+  const tagName = element.tagName.toLowerCase();
+  const attrs = getElementAttributes(element);
+  const props = mapAttributesToProps(attrs);
+  props.key = key;
+  const children = [];
+  element.childNodes.forEach((child, index) => {
+    const converted = convertDomNode(child, `${key}-${index}`);
+    if (converted !== null && converted !== void 0) {
+      children.push(converted);
+    }
+  });
+  if (children.length === 0) {
+    return React3.createElement(tagName, props);
+  }
+  return React3.createElement(tagName, props, ...children);
+}
+function getElementAttributes(element) {
+  const attrs = {};
+  for (const attr of Array.from(element.attributes)) {
+    attrs[attr.name] = attr.value;
+  }
+  return attrs;
+}
+var INLINE_ELEMENTS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "b",
+  "bdi",
+  "bdo",
+  "br",
+  "cite",
+  "code",
+  "data",
+  "dfn",
+  "em",
+  "i",
+  "kbd",
+  "mark",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "time",
+  "u",
+  "var",
+  // MathML inline elements commonly emitted by KaTeX
+  "annotation",
+  "semantics",
+  "mtext",
+  "mn",
+  "mo",
+  "mi",
+  "mspace",
+  "mrow",
+  "msup",
+  "msub",
+  "msubsup",
+  "munder",
+  "mover",
+  "munderover",
+  "msqrt",
+  "mroot",
+  "mtable",
+  "mtr",
+  "mtd"
+]);
+
+// src/components/index.ts
+var MdxRuntimeBoundary = class extends React4.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error) {
+    this.props.onError(error);
+  }
+  componentDidUpdate(prevProps) {
+    if (prevProps.resetKey !== this.props.resetKey && this.state.hasError) {
+      this.setState({ hasError: false });
+    }
+  }
+  render() {
+    if (this.state.hasError) {
+      return null;
+    }
+    return this.props.children;
+  }
+};
+function renderInlineNodes(nodes, components) {
+  return nodes.map((node, index) => {
+    const key = `${node.kind}-${index}`;
+    switch (node.kind) {
+      case "text": {
+        const textComponent = components.text;
+        if (textComponent && textComponent !== defaultInlineComponents.text) {
+          return React4.createElement(textComponent, { key, text: node.text });
+        }
+        return React4.createElement(React4.Fragment, { key, children: node.text });
+      }
+      case "strong":
+        return React4.createElement(components.strong, {
+          key,
+          children: renderInlineNodes(node.children, components)
+        });
+      case "em":
+        return React4.createElement(components.em, {
+          key,
+          children: renderInlineNodes(node.children, components)
+        });
+      case "strike": {
+        const StrikeComponent = components.strike ?? ((props) => React4.createElement("del", {}, props.children));
+        return React4.createElement(StrikeComponent, {
+          key,
+          children: renderInlineNodes(node.children, components)
+        });
+      }
+      case "code":
+        return React4.createElement(components.code, { key, text: node.text });
+      case "link":
+        return React4.createElement(
+          components.link,
+          {
+            key,
+            href: node.href,
+            title: node.title,
+            children: renderInlineNodes(node.children, components)
+          }
+        );
+      case "image":
+        return React4.createElement(components.image, {
+          key,
+          src: node.src,
+          alt: node.alt,
+          title: node.title
+        });
+      case "br":
+        return React4.createElement(React4.Fragment, { key }, React4.createElement(components.br, {}));
+      default: {
+        const component = components[node.kind];
+        if (component) {
+          return React4.createElement(component, { key, ...node });
+        }
+        return null;
+      }
+    }
+  });
+}
+var defaultInlineComponents = {
+  text: ({ text }) => React4.createElement(React4.Fragment, {}, text),
+  strong: ({ children }) => React4.createElement("strong", {}, children),
+  em: ({ children }) => React4.createElement("em", {}, children),
+  strike: ({ children }) => React4.createElement("del", {}, children),
+  code: ({ text }) => React4.createElement(
+    "code",
+    {
+      className: "inline-code"
+    },
+    text
+  ),
+  link: ({ href, title, children }) => React4.createElement(
+    "a",
+    {
+      href,
+      title,
+      className: "markdown-link",
+      target: href?.startsWith("http") ? "_blank" : void 0,
+      rel: href?.startsWith("http") ? "noopener noreferrer" : void 0
+    },
+    children
+  ),
+  image: ({ src, alt, title }) => React4.createElement("img", {
+    src,
+    alt,
+    title,
+    className: "markdown-image"
+  }),
+  br: () => React4.createElement("br"),
+  // Custom extensible components
+  mention: ({ handle }) => React4.createElement(
+    "span",
+    {
+      className: "mention",
+      "data-handle": handle
+    },
+    `@${handle}`
+  ),
+  citation: ({ id }) => React4.createElement(
+    "span",
+    {
+      className: "citation",
+      "data-citation-id": id
+    },
+    `[${id}]`
+  ),
+  "math-inline": ({ tex }) => React4.createElement(
+    "span",
+    {
+      className: "math-inline",
+      "data-tex": tex
+    },
+    `$${tex}$`
+  ),
+  "math-display": ({ tex }) => React4.createElement(
+    "div",
+    {
+      className: "math-display markdown-math-display",
+      "data-tex": tex,
+      style: { overflowX: "auto" }
+    },
+    React4.createElement("span", { className: "math-display-content" }, `$$${tex}$$`)
+  ),
+  // Footnote inline reference (superscript anchor)
+  "footnote-ref": ({ label, number }) => {
+    const n = number ?? "?";
+    const href = number ? `#fn:${n}` : void 0;
+    const id = number ? `fnref:${n}` : void 0;
+    return React4.createElement(
+      "sup",
+      { className: "footnote-ref" },
+      React4.createElement("a", { href, id, "data-label": label, style: { color: "var(--foreground)", textDecoration: "underline" } }, String(n))
+    );
+  }
+};
+var defaultBlockComponents = {
+  paragraph: ({ inlines, raw, meta, children }) => {
+    if (children !== void 0) {
+      return React4.createElement(
+        "p",
+        {
+          className: "markdown-paragraph"
+        },
+        children
+      );
+    }
+    const segments = Array.isArray(meta?.mixedSegments) ? meta?.mixedSegments : void 0;
+    if (segments && segments.length > 0) {
+      const structured = renderParagraphMixedSegments(segments, defaultInlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
+      if (structured.length === 1) {
+        return structured[0];
+      }
+      return React4.createElement(React4.Fragment, {}, ...structured);
+    }
+    const filteredInlines = inlines && raw && inlines.length > 0 ? inlines.filter((node) => !(node.kind === "text" && node.text === raw)) : inlines ?? [];
+    const effectiveInlines = filteredInlines.length > 0 ? filteredInlines : raw ? [
+      {
+        kind: "text",
+        text: raw
+      }
+    ] : [];
+    return React4.createElement(
+      "p",
+      {
+        className: "markdown-paragraph"
+      },
+      effectiveInlines.length > 0 ? renderInlineNodes(effectiveInlines, defaultInlineComponents) : raw ?? ""
+    );
+  },
+  heading: ({ level, inlines, text, meta }) => {
+    const tag = `h${level}`;
+    const onlyPlainText = Array.isArray(inlines) && inlines.length > 0 && inlines.every((node) => node.kind === "text");
+    const children = onlyPlainText ? inlines.map((node) => node.kind === "text" ? node.text : "").join("") : renderInlineNodes(inlines, defaultInlineComponents);
+    const headingId = typeof meta?.headingId === "string" && meta.headingId.length > 0 ? meta.headingId : void 0;
+    return React4.createElement(
+      tag,
+      {
+        className: `markdown-heading markdown-h${level}`,
+        ...text ? { "data-heading-text": text } : {},
+        ...headingId ? { id: headingId, "data-heading-id": headingId } : {}
+      },
+      children
+    );
+  },
+  code: ({ html, meta, lines, lang, preAttrs, codeAttrs }) => {
+    const language = typeof lang === "string" ? lang : typeof meta?.lang === "string" ? String(meta.lang) : "text";
+    if (html) {
+      return React4.createElement("div", {
+        className: `markdown-code-block language-${language || "text"}`,
+        /* biome-ignore lint/security/noDangerouslySetInnerHtml: highlighted HTML is generated by our sanitizer */
+        dangerouslySetInnerHTML: { __html: html }
+      });
+    }
+    const code = meta?.code || "";
+    if (lines && lines.length > 0) {
+      const preAttributes = attrsToProps(preAttrs);
+      const codeAttributes = attrsToProps(codeAttrs);
+      return React4.createElement(
+        "pre",
+        {
+          ...preAttributes,
+          className: preAttributes.className ? `${preAttributes.className} markdown-code-block language-${language || "text"}` : `markdown-code-block language-${language || "text"}`
+        },
+        React4.createElement(
+          "code",
+          {
+            ...codeAttributes,
+            className: codeAttributes.className ? `${codeAttributes.className} language-${language || "text"}` : `language-${language || "text"}`
+          },
+          lines.map(
+            (line) => React4.createElement("span", {
+              key: line.id,
+              className: "line",
+              /* biome-ignore lint/security/noDangerouslySetInnerHtml: line HTML is sanitized server-side */
+              dangerouslySetInnerHTML: { __html: line.html ?? escapeHtml(line.text) }
+            })
+          )
+        )
+      );
+    }
+    return React4.createElement("pre", {
+      className: `markdown-code-block language-${language || "text"}`,
+      children: code
+    });
+  },
+  blockquote: ({ inlines, renderedContent }) => React4.createElement(
+    "blockquote",
+    {
+      className: "markdown-blockquote"
+    },
+    renderedContent ?? renderInlineNodes(inlines, defaultInlineComponents)
+  ),
+  hr: (props) => React4.createElement("hr", props),
+  list: ({ ordered, items }) => {
+    if (items.length === 0) {
+      return null;
+    }
+    const tag = ordered ? "ol" : "ul";
+    const listStyle = ordered ? {
+      ["--list-indent"]: `calc(2.5rem + ${String(items.length).length}ch)`
+    } : void 0;
+    const listItems = items.map(
+      (item, index) => React4.createElement(
+        "li",
+        {
+          key: index,
+          className: "markdown-list-item",
+          "data-counter-text": ordered ? `${index + 1}.` : void 0,
+          "data-list-depth": 0
+        },
+        renderInlineNodes(item, defaultInlineComponents)
+      )
+    );
+    return React4.createElement(
+      tag,
+      {
+        className: `markdown-list ${ordered ? "ordered" : "unordered"}`,
+        style: listStyle
+      },
+      listItems
+    );
+  },
+  html: ({ __trustedHtml, elements }) => {
+    const raw = typeof __trustedHtml === "string" ? __trustedHtml : __trustedHtml.toString();
+    const htmlString = typeof window === "undefined" ? raw : sanitizeHTML(raw);
+    if (typeof window !== "undefined" && elements) {
+      const content = mapHtmlToReact(htmlString, elements);
+      return React4.createElement("div", { className: "markdown-html" }, content);
+    }
+    return React4.createElement("div", {
+      className: "markdown-html",
+      /* biome-ignore lint/security/noDangerouslySetInnerHtml: htmlString is sanitized before injection */
+      dangerouslySetInnerHTML: { __html: htmlString }
+    });
+  },
+  mdx: ({ compiledRef, compiledModule, status, errorMessage }) => {
+    const [Comp, setComp] = React4.useState(null);
+    const [internalError, setInternalError] = React4.useState(null);
+    const [renderError, setRenderError] = React4.useState(null);
+    const [retryKey, setRetryKey] = React4.useState(0);
+    const hydrationContext = React4.useContext(MdxHydrationContext);
+    const hydrationController = hydrationContext?.controller ?? null;
+    const hydrationOptions = hydrationContext?.options;
+    const containerRef = React4.useRef(null);
+    const deferHydration = hydrationOptions?.strategy === "visible";
+    const shouldHydrate = useDeferredRender(
+      containerRef,
+      deferHydration ? {
+        enabled: true,
+        rootMargin: hydrationOptions?.rootMargin,
+        idleTimeoutMs: hydrationOptions?.idleTimeoutMs,
+        debounceMs: hydrationOptions?.debounceMs
+      } : { enabled: false }
+    );
+    const resolvedId = compiledModule?.id ?? (compiledRef?.id && compiledRef.id !== "pending" ? compiledRef.id : void 0);
+    const handleRetry = React4.useCallback(() => {
+      setInternalError(null);
+      setRenderError(null);
+      setComp(null);
+      setRetryKey((prev) => prev + 1);
+    }, []);
+    const handleRuntimeError = React4.useCallback(
+      (error) => {
+        const message2 = error instanceof Error ? error.message : String(error);
+        setRenderError(message2);
+        markMdxHydrationError(resolvedId ?? compiledRef?.id);
+      },
+      [resolvedId, compiledRef?.id]
+    );
+    const effectiveStatus = status ? status : resolvedId ? "compiled" : "pending";
+    const failureMessage = errorMessage ?? internalError ?? renderError ?? null;
+    const moduleDependencies = compiledModule?.dependencies;
+    React4.useEffect(() => {
+      if (!shouldHydrate) {
+        return;
+      }
+      if (status === "error") {
+        markMdxHydrationError(resolvedId ?? compiledRef?.id);
+        return;
+      }
+      let cancelled = false;
+      async function ensure() {
+        let permit = null;
+        try {
+          if (status === "error" || !resolvedId || resolvedId === "pending") {
+            if (!cancelled) {
+              setComp(null);
+              setInternalError(null);
+            }
+            return;
+          }
+          if (hydrationController) {
+            permit = await hydrationController.acquire();
+            if (cancelled) {
+              permit.release();
+              return;
+            }
+          }
+          setInternalError(null);
+          setRenderError(null);
+          markMdxHydrationStart(resolvedId);
+          const { getMDXComponentFactory: getMDXComponentFactory2, registerInlineMdxModule: registerInlineMdxModule2 } = await loadMdxRuntime();
+          if (compiledModule?.code) {
+            registerInlineMdxModule2({
+              id: compiledModule.id,
+              code: compiledModule.code,
+              dependencies: moduleDependencies ?? []
+            });
+          }
+          const factory = getMDXComponentFactory2();
+          const C = await factory.createComponent({ id: resolvedId });
+          if (!cancelled) {
+            setComp(() => C);
+            setInternalError(null);
+            markMdxHydrated(resolvedId);
+          }
+        } catch (error) {
+          if (!cancelled) {
+            const message2 = error instanceof Error ? error.message : String(error);
+            setInternalError(message2);
+            markMdxHydrationError(resolvedId);
+          }
+        } finally {
+          permit?.release();
+        }
+      }
+      ensure();
+      return () => {
+        cancelled = true;
+      };
+    }, [compiledModule?.id, compiledModule?.code, moduleDependencies, resolvedId, status, shouldHydrate, retryKey]);
+    const compileMode = compiledModule?.source === "worker" || compiledRef?.id?.startsWith("worker:") ? "worker" : "server";
+    const pendingId = resolvedId && resolvedId !== "pending" ? resolvedId : compiledRef?.id ?? "pending";
+    const waitingForVisibility = deferHydration && !shouldHydrate && Boolean(resolvedId);
+    const pendingLabel = waitingForVisibility ? "MDX ready (hydrate on view)\u2026" : compileMode === "worker" ? "Compiling MDX (client)\u2026" : "Compiling MDX (server)\u2026";
+    const message = failureMessage ?? (compileMode === "worker" ? "MDX compilation failed in client mode. Try switching back to server rendering or restarting the stream." : "MDX compilation failed. Try restarting the stream.");
+    const allowRetry = Boolean(internalError || renderError);
+    const retryButton = allowRetry ? React4.createElement(
+      "button",
+      {
+        type: "button",
+        className: "markdown-mdx-retry",
+        onClick: handleRetry
+      },
+      "Retry hydration"
+    ) : null;
+    const errorPanel = React4.createElement(
+      React4.Fragment,
+      null,
+      React4.createElement("strong", null, "MDX failed"),
+      React4.createElement("div", null, message)
+    );
+    if (Comp && !failureMessage) {
+      return React4.createElement(
+        "div",
+        {
+          className: "markdown-mdx",
+          ref: containerRef,
+          "data-mdx-ref": resolvedId ?? compiledRef?.id ?? "compiled",
+          "data-mdx-status": failureMessage ? "error" : "compiled",
+          "data-mdx-mode": compileMode
+        },
+        React4.createElement(
+          MdxRuntimeBoundary,
+          { resetKey: retryKey, onError: handleRuntimeError },
+          React4.createElement(Comp, {})
+        )
+      );
+    }
+    if (failureMessage) {
+      return React4.createElement(
+        "div",
+        {
+          className: "markdown-mdx error",
+          ref: containerRef,
+          "data-mdx-ref": pendingId,
+          "data-mdx-status": "error",
+          "data-mdx-mode": compileMode
+        },
+        errorPanel,
+        retryButton
+      );
+    }
+    if (!Comp) {
+      return React4.createElement(
+        "div",
+        {
+          className: "markdown-mdx",
+          ref: containerRef,
+          "data-mdx-ref": pendingId,
+          "data-mdx-status": "pending",
+          "data-mdx-mode": compileMode
+        },
+        pendingLabel
+      );
+    }
+  },
+  // Footnotes block rendered at page end
+  footnotes: ({ items }) => {
+    if (!items || items.length === 0) return React4.createElement(React4.Fragment, null);
+    const listItems = items.map(
+      (item) => React4.createElement(
+        "li",
+        { key: item.number, id: `fn:${item.number}` },
+        renderInlineNodes(item.inlines, defaultInlineComponents),
+        " ",
+        React4.createElement(
+          "a",
+          {
+            href: `#fnref:${item.number}`,
+            className: "footnote-backref",
+            "aria-label": "Back to content",
+            style: { color: "var(--foreground)", textDecoration: "underline" }
+          },
+          "\u21A9"
+        )
+      )
+    );
+    return React4.createElement("section", { className: "footnotes" }, React4.createElement("hr", {}), React4.createElement("ol", {}, listItems));
+  },
+  // Footnote definition placeholders (render nothing)
+  "footnote-def": () => React4.createElement(React4.Fragment, null),
+  // Callouts block
+  callout: ({ kind, inlines = [] }) => {
+    const tone = (kind || "NOTE").toUpperCase();
+    const title = tone.charAt(0) + tone.slice(1).toLowerCase();
+    return React4.createElement(
+      "div",
+      { className: `markdown-callout markdown-callout-${tone.toLowerCase()} border rounded p-3 my-3` },
+      React4.createElement("div", { className: "font-semibold mb-1" }, title),
+      inlines.length > 0 ? renderInlineNodes(inlines, defaultInlineComponents) : null
+    );
+  },
+  // Structured table block (GFM)
+  table: ({
+    header,
+    rows,
+    align,
+    elements
+  }) => {
+    const El = getDefaultTableElements(elements);
+    const renderCells = (cells, tag, rowIdx) => cells.map((cell, i) => {
+      const columnAlign = align?.[i] ?? void 0;
+      const cellStyle = columnAlign ? { textAlign: columnAlign } : void 0;
+      return React4.createElement(
+        tag === "th" ? El.Th : El.Td,
+        {
+          key: `${rowIdx}-${i}`,
+          style: cellStyle,
+          // Also pass align attribute so CSS selectors like [&[align=center]] can be used by consumers
+          align: columnAlign ?? void 0
+        },
+        renderInlineNodes(cell, defaultInlineComponents)
+      );
+    });
+    return React4.createElement(
+      El.Table,
+      { className: "markdown-table" },
+      header && header.length > 0 ? React4.createElement(El.Thead, {}, React4.createElement(El.Tr, {}, renderCells(header, "th", -1))) : null,
+      React4.createElement(
+        El.Tbody,
+        {},
+        rows.map((row, r) => React4.createElement(El.Tr, { key: r }, renderCells(row, "td", r)))
+      )
+    );
+  }
+};
+var ComponentRegistry = class {
+  constructor(blockComponents = {}, inlineComponents = {}) {
+    this.blockComponentMapCache = null;
+    this.inlineComponentMapCache = null;
+    this.blockComponents = { ...defaultBlockComponents, ...blockComponents };
+    this.inlineComponents = { ...defaultInlineComponents, ...inlineComponents };
+    this.htmlElements = getDefaultHtmlElements();
+    this.tableElements = getDefaultTableElements();
+  }
+  /**
+   * Update block components
+   */
+  setBlockComponents(components) {
+    this.blockComponents = { ...this.blockComponents, ...components };
+    this.blockComponentMapCache = null;
+  }
+  /**
+   * Update inline components
+   */
+  setInlineComponents(components) {
+    this.inlineComponents = { ...this.inlineComponents, ...components };
+    this.inlineComponentMapCache = null;
+  }
+  /** Update HTML element mapping for html blocks */
+  setHtmlElements(map) {
+    this.htmlElements = { ...this.htmlElements, ...map };
+  }
+  /** Update table element mapping for table blocks */
+  setTableElements(map) {
+    this.tableElements = { ...this.tableElements, ...map };
+  }
+  /**
+   * Get block component
+   */
+  getBlockComponent(type) {
+    return this.blockComponents[type] || this.blockComponents.paragraph;
+  }
+  /**
+   * Get inline components
+   */
+  getInlineComponents() {
+    return this.inlineComponents;
+  }
+  getBlockComponentMap() {
+    if (!this.blockComponentMapCache) {
+      this.blockComponentMapCache = { ...this.blockComponents };
+    }
+    return this.blockComponentMapCache;
+  }
+  getInlineComponentMap() {
+    if (!this.inlineComponentMapCache) {
+      this.inlineComponentMapCache = { ...this.inlineComponents };
+    }
+    return this.inlineComponentMapCache;
+  }
+  getTableElements() {
+    return this.tableElements;
+  }
+  /**
+   * Render a block
+   */
+  renderBlock(block) {
+    const Component = this.getBlockComponent(block.type);
+    const props = this.getBlockProps(block);
+    return React4.createElement(Component, {
+      key: block.id,
+      ...props
+    });
+  }
+  /**
+   * Get props for a block based on its type
+   */
+  getBlockProps(block) {
+    switch (block.type) {
+      case "heading": {
+        const meta = block.payload.meta ?? {};
+        const inlineNodes = Array.isArray(block.payload.inline) ? block.payload.inline : [];
+        const levelFromMeta = typeof meta.headingLevel === "number" ? meta.headingLevel : void 0;
+        const normalizedLevel = Number.isFinite(levelFromMeta) ? Math.min(Math.max(levelFromMeta, 1), 6) : void 0;
+        const rawHeading = typeof block.payload.raw === "string" ? block.payload.raw : "";
+        const headingText = typeof meta.headingText === "string" && meta.headingText.trim().length > 0 ? meta.headingText : removeHeadingMarkers(rawHeading).trim();
+        const level = normalizedLevel ?? this.extractHeadingLevel(rawHeading);
+        return {
+          level,
+          inlines: inlineNodes,
+          text: headingText,
+          meta
+        };
+      }
+      case "paragraph":
+        return {
+          inlines: block.payload.inline || [],
+          raw: block.payload.raw,
+          meta: block.payload.meta
+        };
+      case "blockquote":
+        return {
+          inlines: block.payload.inline || []
+        };
+      case "hr": {
+        const range = block.payload.range;
+        return {
+          className: "markdown-hr",
+          "data-start": typeof range?.from === "number" ? range.from : void 0,
+          "data-end": typeof range?.to === "number" ? range.to : void 0
+        };
+      }
+      case "code":
+        return {
+          html: block.payload.highlightedHtml,
+          meta: block.payload.meta,
+          lang: typeof block.payload.meta?.lang === "string" ? String(block.payload.meta?.lang) : void 0
+        };
+      case "list": {
+        const items = Array.isArray(block.payload.meta?.items) ? block.payload.meta?.items : [];
+        return {
+          ordered: Boolean(block.payload.meta?.ordered),
+          items
+        };
+      }
+      case "html": {
+        const trusted = block.payload.sanitizedHtml ?? block.payload.raw;
+        return {
+          // Server render should not depend on DOMPurify (which requires a DOM `window`).
+          // In worker-compiled flows, `sanitizedHtml` is already sanitized at the source.
+          __trustedHtml: typeof window === "undefined" ? String(trusted ?? "") : createTrustedHTML(String(trusted ?? "")),
+          elements: this.htmlElements
+        };
+      }
+      case "mdx":
+        return (() => {
+          const meta = block.payload.meta;
+          const rawStatus = typeof meta?.mdxStatus === "string" ? meta.mdxStatus : void 0;
+          const status = rawStatus === "pending" || rawStatus === "compiled" || rawStatus === "error" ? rawStatus : void 0;
+          const errorMessage = typeof meta?.mdxError === "string" ? String(meta.mdxError) : void 0;
+          const compiledModule = block.payload.compiledMdxModule ?? null;
+          const compiledRef = block.payload.compiledMdxRef ?? (compiledModule ? { id: compiledModule.id } : void 0);
+          return {
+            compiledRef: compiledRef ?? { id: "pending" },
+            compiledModule,
+            status,
+            errorMessage,
+            raw: typeof block.payload.raw === "string" ? block.payload.raw : void 0
+          };
+        })();
+      case "table": {
+        const header = Array.isArray(block.payload.meta?.header) ? block.payload.meta?.header : void 0;
+        const rows = Array.isArray(block.payload.meta?.rows) ? block.payload.meta?.rows : [];
+        const align = Array.isArray(block.payload.meta?.align) ? block.payload.meta?.align : void 0;
+        return {
+          header,
+          rows,
+          align,
+          elements: this.tableElements
+        };
+      }
+      case "footnotes": {
+        const items = Array.isArray(block.payload.meta?.items) ? block.payload.meta?.items : [];
+        return {
+          items
+        };
+      }
+      case "footnote-def":
+        return {};
+      case "callout": {
+        const kind = typeof block.payload.meta?.kind === "string" ? String(block.payload.meta.kind) : void 0;
+        const inlineNodes = Array.isArray(block.payload.inline) ? block.payload.inline : [];
+        return {
+          kind,
+          inlines: inlineNodes
+        };
+      }
+      default:
+        return {
+          content: block.payload.raw,
+          meta: block.payload.meta
+        };
+    }
+  }
+  /**
+   * Extract heading level from raw markdown
+   */
+  extractHeadingLevel(raw) {
+    const match = raw.match(/^(#{1,6})\s/);
+    if (match) {
+      return Math.min(match[1].length, 6);
+    }
+    return 1;
+  }
+};
+function getDefaultHtmlElements() {
+  return {
+    // Text semantics
+    p: (props) => React4.createElement("p", props),
+    strong: (props) => React4.createElement("strong", props),
+    em: (props) => React4.createElement("em", props),
+    code: (props) => React4.createElement("code", props),
+    pre: (props) => React4.createElement("pre", props),
+    span: (props) => React4.createElement("span", props),
+    br: (props) => React4.createElement("br", props),
+    hr: (props) => React4.createElement("hr", props),
+    // Lists
+    ul: (props) => React4.createElement("ul", props),
+    ol: (props) => React4.createElement("ol", props),
+    li: (props) => React4.createElement("li", props),
+    // Links & media
+    a: (props) => React4.createElement("a", props),
+    img: (props) => React4.createElement("img", props),
+    // Blockquotes
+    blockquote: (props) => React4.createElement("blockquote", props),
+    // Tables
+    table: (props) => React4.createElement("table", props),
+    thead: (props) => React4.createElement("thead", props),
+    tbody: (props) => React4.createElement("tbody", props),
+    tr: (props) => React4.createElement("tr", props),
+    th: (props) => React4.createElement("th", props),
+    td: (props) => React4.createElement("td", props),
+    // Generic
+    div: (props) => React4.createElement("div", props)
+  };
+}
+function getDefaultTableElements(overrides) {
+  const base = {
+    Table: (props) => React4.createElement("table", props),
+    Thead: (props) => React4.createElement("thead", props),
+    Tbody: (props) => React4.createElement("tbody", props),
+    Tr: (props) => React4.createElement("tr", props),
+    Th: (props) => React4.createElement("th", props),
+    Td: (props) => React4.createElement("td", props)
+  };
+  return { ...base, ...overrides || {} };
+}
+function mapHtmlToReact(html, elements) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const children = [];
+  doc.body.childNodes.forEach((node, index) => {
+    const element = toReact(node, elements, `root-${index}`);
+    if (element) {
+      children.push(element);
+    }
+  });
+  return React4.createElement(React4.Fragment, {}, ...children);
+}
+function toReact(node, elements, key) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    const text = node.textContent ?? "";
+    return React4.createElement(React4.Fragment, { key }, text);
+  }
+  if (node.nodeType !== Node.ELEMENT_NODE) {
+    return null;
+  }
+  const el = node;
+  const tag = el.tagName.toLowerCase();
+  const props = {};
+  for (const attr of Array.from(el.attributes)) {
+    const name = attr.name === "class" ? "className" : attr.name;
+    props[name] = attr.value;
+  }
+  const children = [];
+  el.childNodes.forEach((childNode, childIndex) => {
+    const child = toReact(childNode, elements, `${key}-${childIndex}`);
+    if (child) {
+      children.push(child);
+    }
+  });
+  const component = elements[tag];
+  const elementChildren = children.length > 0 ? children : void 0;
+  if (component) {
+    return React4.createElement(component, { ...props, key }, elementChildren);
+  }
+  return React4.createElement(tag, { ...props, key }, elementChildren);
+}
+function attrsToProps(attrs) {
+  if (!attrs) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (key === "class") {
+      result.className = value;
+    } else if (key === "style") {
+      result.style = parseStyleAttribute2(value);
+    } else if (key === "tabindex" || key === "tabIndex") {
+      const numericValue = Number(value);
+      if (!Number.isNaN(numericValue)) {
+        result.tabIndex = numericValue;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function parseStyleAttribute2(value) {
+  const style = {};
+  if (!value) return style;
+  const parts = value.split(";");
+  for (const part of parts) {
+    if (!part.trim()) continue;
+    const [prop, val] = part.split(":");
+    if (!prop || !val) continue;
+    const camelProp = prop.trim().replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+    style[camelProp] = val.trim();
+  }
+  return style;
+}
+function renderParagraphMixedSegments(segments, inlineComponents, inlineHtmlRenderers) {
+  const result = [];
+  let inlineBuffer = [];
+  let inlineGroupIndex = 0;
+  const pushRenderedNodes = (nodes, target, baseKey) => {
+    nodes.forEach((node, idx) => {
+      if (node === null || node === void 0) return;
+      const key = `${baseKey}-${idx}`;
+      if (React4.isValidElement(node)) {
+        target.push(node.key === key ? node : React4.cloneElement(node, { key }));
+      } else if (typeof node === "string" || typeof node === "number") {
+        target.push(React4.createElement(React4.Fragment, { key }, node));
+      } else {
+        target.push(React4.createElement(React4.Fragment, { key }, node));
+      }
+    });
+  };
+  const ensureArray2 = (value) => {
+    if (value === null || value === void 0) {
+      return [];
+    }
+    return Array.isArray(value) ? value : [value];
+  };
+  const flushInline = () => {
+    if (inlineBuffer.length === 0) {
+      return;
+    }
+    const key = `paragraph-inline-group-${inlineGroupIndex++}`;
+    result.push(
+      React4.createElement(
+        "p",
+        {
+          key,
+          className: "markdown-paragraph"
+        },
+        inlineBuffer
+      )
+    );
+    inlineBuffer = [];
+  };
+  segments.forEach((segment, index) => {
+    const key = `paragraph-segment-${index}`;
+    switch (segment.kind) {
+      case "text": {
+        const inlineNodes = Array.isArray(segment.inline) ? segment.inline : [];
+        if (inlineNodes.length === 0) {
+          if (segment.value) {
+            inlineBuffer.push(React4.createElement(React4.Fragment, { key }, segment.value));
+          }
+          break;
+        }
+        let chunk = [];
+        const pushChunk = (chunkNodes, chunkKey) => {
+          if (chunkNodes.length === 0) return;
+          const rendered = renderInlineNodes(chunkNodes, inlineComponents);
+          pushRenderedNodes(ensureArray2(rendered), inlineBuffer, chunkKey);
+        };
+        inlineNodes.forEach((inlineNode, inlineIdx) => {
+          if (inlineNode.kind === "math-display") {
+            pushChunk(chunk, `${key}-chunk-${inlineIdx}`);
+            chunk = [];
+            flushInline();
+            const rendered = renderInlineNodes([inlineNode], inlineComponents);
+            pushRenderedNodes(ensureArray2(rendered), result, `${key}-math-${inlineIdx}`);
+          } else {
+            chunk.push(inlineNode);
+          }
+        });
+        pushChunk(chunk, `${key}-chunk-tail`);
+        break;
+      }
+      case "mdx": {
+        const status = segment.status ?? "pending";
+        let element;
+        if (status === "compiled") {
+          element = React4.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
+        } else if (status === "error") {
+          const message = segment.value || "MDX error";
+          element = React4.createElement("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error" }, message);
+        } else {
+          element = React4.createElement("span", { className: "markdown-mdx-inline", "data-mdx-status": status }, segment.value);
+        }
+        inlineBuffer.push(React4.createElement(React4.Fragment, { key }, element));
+        break;
+      }
+      case "html": {
+        const html = segment.sanitized ?? segment.value;
+        const isBlockLevel = isBlockLevelHtml(html);
+        const element = renderInlineHtmlSegment(segment.value, segment.sanitized, {
+          key,
+          renderers: inlineHtmlRenderers
+        });
+        if (isBlockLevel) {
+          flushInline();
+          if (element) {
+            result.push(element);
+          } else if (html) {
+            result.push(
+              React4.createElement("div", {
+                key,
+                className: "markdown-inline-html-block",
+                dangerouslySetInnerHTML: { __html: html }
+              })
+            );
+          }
+        } else if (element) {
+          inlineBuffer.push(element);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  });
+  flushInline();
+  if (result.length === 0) {
+    return [
+      React4.createElement(
+        "p",
+        {
+          key: "paragraph-inline-group-0",
+          className: "markdown-paragraph"
+        },
+        inlineBuffer
+      )
+    ];
+  }
+  return result;
+}
+function isBlockLevelHtml(html) {
+  if (!html) return false;
+  const trimmed = html.trim();
+  if (!trimmed.startsWith("<")) {
+    return false;
+  }
+  const match = trimmed.match(/^<([A-Za-z][\w:-]*)\b/);
+  if (!match) {
+    return false;
+  }
+  const tag = match[1].toLowerCase();
+  return BLOCK_LEVEL_TAGS.has(tag);
+}
+var BLOCK_LEVEL_TAGS = /* @__PURE__ */ new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "canvas",
+  "div",
+  "dl",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "ul",
+  "math"
+]);
+
+// src/renderer/code-highlight-context.tsx
+import React5 from "react";
+var CodeHighlightRequestContext = React5.createContext(null);
+function useCodeHighlightRequester() {
+  return React5.useContext(CodeHighlightRequestContext);
+}
+
+// src/renderer/deferred-render-context.tsx
+import React6 from "react";
+var DeferredRenderContext = React6.createContext(null);
+
+// src/renderer/store.ts
+import {
+  cloneBlock,
+  createBlockSnapshot,
+  extractCodeWrapperAttributes,
+  getDefaultCodeWrapperAttributes,
+  sanitizeCodeHTML,
+  sanitizeHTML as sanitizeHTML2,
+  PATCH_ROOT_ID
+} from "@stream-mdx/core";
+import { getPatchKind } from "@stream-mdx/core/perf/patch-batching";
+
+// src/renderer/list-utils.ts
+function updateNodeDepth(node, depth) {
+  if (!node) return false;
+  const currentDepth = typeof node.props?.depth === "number" ? node.props.depth : void 0;
+  if (currentDepth === depth) {
+    return false;
+  }
+  const nextProps = { ...node.props ?? {} };
+  nextProps.depth = depth;
+  node.props = nextProps;
+  node.version++;
+  return true;
+}
+function normalizeAllListDepths(map, touched, rootId = "__root__") {
+  const root = map.get(rootId);
+  if (!root) return;
+  for (const childId of root.children) {
+    const child = map.get(childId);
+    if (child && child.type === "list") {
+      normalizeListDepthRecursive(map, child, 0, touched);
+    }
+  }
+}
+function normalizeListDepthsForIds(map, touched, listIds, rootId = "__root__") {
+  if (listIds.size === 0) {
+    normalizeAllListDepths(map, touched, rootId);
+    return;
+  }
+  const visited = /* @__PURE__ */ new Set();
+  for (const listId of listIds) {
+    const base = map.get(listId);
+    if (!base) continue;
+    const listNode = base.type === "list" ? base : findNearestListAncestor(map, base);
+    if (!listNode || visited.has(listNode.id)) continue;
+    visited.add(listNode.id);
+    const depth = computeListDepth(map, listNode, rootId);
+    normalizeListDepthRecursive(map, listNode, depth, touched);
+  }
+}
+function normalizeListDepthRecursive(map, listNode, depth, touched) {
+  if (!listNode) return;
+  if (updateNodeDepth(listNode, depth)) {
+    touched.add(listNode.id);
+  }
+  for (const childId of listNode.children) {
+    const child = map.get(childId);
+    if (!child) continue;
+    if (child.type === "list-item") {
+      if (updateNodeDepth(child, depth)) {
+        touched.add(child.id);
+      }
+      for (const grandchildId of child.children) {
+        const grandchild = map.get(grandchildId);
+        if (!grandchild) continue;
+        if (grandchild.type === "list") {
+          normalizeListDepthRecursive(map, grandchild, depth + 1, touched);
+        }
+      }
+    } else if (child.type === "list") {
+      normalizeListDepthRecursive(map, child, depth + 1, touched);
+    }
+  }
+}
+function findNearestListAncestor(map, node) {
+  let current = node;
+  while (current) {
+    if (current.type === "list") return current;
+    if (!current.parentId) return void 0;
+    current = map.get(current.parentId);
+  }
+  return void 0;
+}
+function computeListDepth(map, listNode, rootId) {
+  let depth = 0;
+  let current = listNode;
+  while (current && current.parentId && current.parentId !== rootId) {
+    const parent = map.get(current.parentId);
+    if (!parent) break;
+    if (parent.type === "list") {
+      depth += 1;
+    }
+    current = parent;
+  }
+  return depth;
+}
+
+// src/renderer/patch-coalescing.ts
+import {
+  DEFAULT_COALESCE_CONFIG,
+  coalescePatches,
+  coalescePatchesLinear,
+  coalescePatchesQuadratic,
+  coalescePatchesWithMetrics
+} from "@stream-mdx/core";
+
+// src/renderer/store.ts
+function snapshotToBlock(node) {
+  const candidate = node.props?.block;
+  if (candidate && typeof candidate === "object") {
+    return cloneBlock(candidate);
+  }
+  return null;
+}
+var nodeSnapshotCacheByMap = /* @__PURE__ */ new WeakMap();
+var childrenSnapshotCacheByMap = /* @__PURE__ */ new WeakMap();
+var NODE_SNAPSHOT_CACHE_LIMIT = 5e4;
+var CHILDREN_SNAPSHOT_CACHE_LIMIT = 5e4;
+var NODE_SNAPSHOT_CACHE_BUFFER = Math.max(200, Math.floor(NODE_SNAPSHOT_CACHE_LIMIT * 0.1));
+var CHILDREN_SNAPSHOT_CACHE_BUFFER = Math.max(200, Math.floor(CHILDREN_SNAPSHOT_CACHE_LIMIT * 0.1));
+function getNodeSnapshotCacheForMap(map) {
+  let cache = nodeSnapshotCacheByMap.get(map);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    nodeSnapshotCacheByMap.set(map, cache);
+  }
+  return cache;
+}
+function getChildrenSnapshotCacheForMap(map) {
+  let cache = childrenSnapshotCacheByMap.get(map);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    childrenSnapshotCacheByMap.set(map, cache);
+  }
+  return cache;
+}
+function pruneCache(cache, max, buffer) {
+  if (cache.size <= max + buffer) return;
+  let remaining = cache.size - max;
+  for (const key of cache.keys()) {
+    cache.delete(key);
+    remaining -= 1;
+    if (remaining <= 0) break;
+  }
+}
+function deleteSnapshotCacheEntry(map, id) {
+  getNodeSnapshotCacheForMap(map).delete(id);
+  getChildrenSnapshotCacheForMap(map).delete(id);
+}
+function clearSnapshotCaches(map) {
+  getNodeSnapshotCacheForMap(map).clear();
+  getChildrenSnapshotCacheForMap(map).clear();
+}
+var EMPTY_CHILDREN = Object.freeze([]);
+var EMPTY_NODE_SNAPSHOT = Object.freeze({ version: -1, node: void 0 });
+var EMPTY_CHILDREN_SNAPSHOT = Object.freeze({
+  version: -1,
+  children: EMPTY_CHILDREN
+});
+function isListPatchDebugEnabled() {
+  if (typeof globalThis !== "undefined") {
+    const flag = globalThis.__STREAMING_LIST_DEBUG__;
+    if (flag === true) return true;
+  }
+  if (typeof process !== "undefined" && process.env.NEXT_PUBLIC_STREAMING_LIST_DEBUG === "true") {
+    return true;
+  }
+  return false;
+}
+var CODE_BLOCK_DEBUG_ENABLED = (() => {
+  try {
+    if (typeof process !== "undefined" && process.env && process.env.NEXT_PUBLIC_STREAMING_DEBUG_CODELINES === "1") {
+      return true;
+    }
+    if (typeof globalThis !== "undefined") {
+      const debug = globalThis?.__STREAMING_DEBUG__;
+      if (debug?.codeLines) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+})() || false;
+var CODE_BLOCK_VALIDATION_ENABLED = typeof process !== "undefined" && process.env ? process.env.NODE_ENV !== "production" : true;
+var PATCH_PERF_HISTORY_LIMIT = 120;
+var getPerfNow = (() => {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return () => performance.now();
+  }
+  return () => Date.now();
+})();
+function isPatchPerfDebugEnabled() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const value = process.env.NEXT_PUBLIC_STREAMING_DEBUG_PATCH_PERF;
+      if (value === "1" || value === "true") {
+        return true;
+      }
+    }
+  } catch {
+  }
+  try {
+    const debug = globalThis.__STREAMING_DEBUG__;
+    if (debug?.patchPerf) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function recordPatchPerf(summary) {
+  try {
+    if (typeof globalThis === "undefined") return;
+    const root = globalThis;
+    const history = root.__STREAM_MDX_PATCH_STATS__ ?? [];
+    history.push(summary);
+    if (history.length > PATCH_PERF_HISTORY_LIMIT) {
+      history.splice(0, history.length - PATCH_PERF_HISTORY_LIMIT);
+    }
+    root.__STREAM_MDX_PATCH_STATS__ = history;
+    root.__STREAM_MDX_PATCH_STATS_LAST__ = summary;
+    const totals = root.__STREAM_MDX_PATCH_STATS_TOTALS__ ?? {
+      calls: 0,
+      totalMs: 0,
+      applyMs: 0,
+      coalesceMs: 0,
+      listNormalizeMs: 0,
+      patches: 0,
+      coalescedPatches: 0,
+      ops: {},
+      setPropsByType: {},
+      setPropsBySize: {}
+    };
+    totals.calls += 1;
+    totals.totalMs += summary.totalMs;
+    totals.applyMs += summary.applyMs;
+    totals.coalesceMs += summary.coalesceMs;
+    totals.listNormalizeMs += summary.listNormalizeMs;
+    totals.patches += summary.patches;
+    totals.coalescedPatches += summary.coalescedPatches;
+    for (const [op, stats] of Object.entries(summary.ops)) {
+      const entry = totals.ops[op] ?? { count: 0, durationMs: 0 };
+      entry.count += stats.count;
+      entry.durationMs += stats.durationMs;
+      totals.ops[op] = entry;
+    }
+    if (summary.setPropsByType) {
+      for (const [key, stats] of Object.entries(summary.setPropsByType)) {
+        const entry = totals.setPropsByType[key] ?? { count: 0, durationMs: 0 };
+        entry.count += stats.count;
+        entry.durationMs += stats.durationMs;
+        totals.setPropsByType[key] = entry;
+      }
+    }
+    if (summary.setPropsBySize) {
+      for (const [key, stats] of Object.entries(summary.setPropsBySize)) {
+        const entry = totals.setPropsBySize[key] ?? { count: 0, durationMs: 0 };
+        entry.count += stats.count;
+        entry.durationMs += stats.durationMs;
+        totals.setPropsBySize[key] = entry;
+      }
+    }
+    root.__STREAM_MDX_PATCH_STATS_TOTALS__ = totals;
+  } catch {
+  }
+}
+function estimateBlockPayloadSize(block) {
+  if (!block || !block.payload) return 0;
+  let size = 0;
+  const payload = block.payload;
+  if (typeof payload.raw === "string") size += payload.raw.length;
+  if (typeof payload.highlightedHtml === "string") size += payload.highlightedHtml.length;
+  if (typeof payload.sanitizedHtml === "string") size += payload.sanitizedHtml.length;
+  if (typeof payload.compiledMdxModule?.code === "string") size += payload.compiledMdxModule.code.length;
+  if (Array.isArray(payload.inline)) size += payload.inline.length * 8;
+  return size;
+}
+function estimatePropsSize(props, block) {
+  let size = 0;
+  if (props) {
+    for (const [key, value] of Object.entries(props)) {
+      if (key === "block") continue;
+      if (typeof value === "string") {
+        size += value.length;
+      } else if (typeof value === "number") {
+        size += 8;
+      } else if (typeof value === "boolean") {
+        size += 4;
+      } else if (Array.isArray(value)) {
+        size += value.length * 4;
+      }
+    }
+  }
+  if (block) {
+    size += estimateBlockPayloadSize(block);
+  }
+  return size;
+}
+function bucketBySize(size) {
+  if (size < 1024) return "<1k";
+  if (size < 10 * 1024) return "1-10k";
+  if (size < 50 * 1024) return "10-50k";
+  if (size < 200 * 1024) return "50-200k";
+  return ">=200k";
+}
+function debugCodeBlock(event, payload) {
+  if (!CODE_BLOCK_DEBUG_ENABLED) return;
+  try {
+    console.debug(`[renderer-store][code-block] ${event}`, payload);
+  } catch {
+  }
+}
+function createRootRecord() {
+  return {
+    id: PATCH_ROOT_ID,
+    type: "__root__",
+    parentId: null,
+    children: [],
+    props: {},
+    version: 0,
+    blockEpoch: 0
+  };
+}
+function readNumericEpoch(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return value;
+}
+function readSnapshotBlockEpoch(snapshot) {
+  return readNumericEpoch(snapshot.meta?.blockEpoch);
+}
+function readPatchBlockEpoch(patch) {
+  if (patch.op === "setHTML") {
+    return readNumericEpoch(patch.patchMeta?.blockEpoch);
+  }
+  return readNumericEpoch(patch.meta?.blockEpoch);
+}
+function readPatchParseEpoch(patch) {
+  if (patch.op === "setHTML") {
+    return readNumericEpoch(patch.patchMeta?.parseEpoch);
+  }
+  return readNumericEpoch(patch.meta?.parseEpoch);
+}
+function readPatchTx(patch) {
+  if (patch.op === "setHTML") {
+    return readNumericEpoch(patch.patchMeta?.tx);
+  }
+  return readNumericEpoch(patch.meta?.tx);
+}
+function assignSubtreeBlockEpoch(map, rootId, blockEpoch, touched) {
+  const root = map.get(rootId);
+  if (!root) return;
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    if (node.blockEpoch !== blockEpoch) {
+      node.blockEpoch = blockEpoch;
+      node.version += 1;
+      touched?.add(node.id);
+    }
+    for (const childId of node.children) {
+      const child = map.get(childId);
+      if (child) {
+        stack.push(child);
+      }
+    }
+  }
+}
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function shallowEqualRecords(a, b) {
+  if (a === b) return true;
+  if (!a || !b) {
+    return !a && !b;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) {
+      return false;
+    }
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function ensureUniqueChildren(parent, touched) {
+  if (!parent || parent.children.length <= 1) {
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  let mutated = false;
+  for (const childId of parent.children) {
+    if (seen.has(childId)) {
+      mutated = true;
+      continue;
+    }
+    seen.add(childId);
+    deduped.push(childId);
+  }
+  if (mutated) {
+    parent.children = deduped;
+    parent.version++;
+    if (touched) {
+      touched.add(parent.id);
+    }
+    console.error("[renderer-store] removed duplicate children", {
+      parentId: parent.id,
+      deduped: parent.children.slice()
+    });
+  }
+}
+function parseLineIndexFromId(id) {
+  const match = id.match(/::line:(\d+)$/);
+  if (!match) return Number.NaN;
+  const value = Number(match[1]);
+  return Number.isFinite(value) ? value : Number.NaN;
+}
+function escapeHtml2(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function stripOuterLineSpan(html) {
+  if (!html) return null;
+  const openTagMatch = html.match(/<span[^>]*class="[^"]*\bline\b[^"]*"[^>]*>/i);
+  if (!openTagMatch) {
+    return null;
+  }
+  const openTag = openTagMatch[0];
+  const startIndex = html.indexOf(openTag);
+  if (startIndex === -1) {
+    return null;
+  }
+  const contentStart = startIndex + openTag.length;
+  const endIndex = html.lastIndexOf("</span>");
+  if (endIndex === -1 || endIndex < contentStart) {
+    return null;
+  }
+  return html.slice(contentStart, endIndex);
+}
+function sanitizeLineInnerHtml(innerHtml, fallbackText) {
+  if (innerHtml && innerHtml.trim().length > 0) {
+    const wrapped = `<span class="line">${innerHtml}</span>`;
+    const sanitized = sanitizeCodeHTML(wrapped);
+    const inner = stripOuterLineSpan(typeof sanitized === "string" ? sanitized : String(sanitized));
+    if (inner !== null) {
+      return inner;
+    }
+  }
+  return escapeHtml2(fallbackText);
+}
+function normalizeCodeBlockChildren(nodes, parent, touched) {
+  if (parent.type !== "code") return;
+  const previousChildren = parent.children.slice();
+  const originalOrder = /* @__PURE__ */ new Map();
+  const seenIds = /* @__PURE__ */ new Set();
+  const codeLineNodes = [];
+  const anomalies = [];
+  for (let idx = 0; idx < previousChildren.length; idx++) {
+    const childId = previousChildren[idx];
+    const node = nodes.get(childId);
+    if (!node) {
+      anomalies.push(`missing:${childId}`);
+      continue;
+    }
+    if (node.parentId !== parent.id) {
+      node.parentId = parent.id;
+      node.version++;
+      touched.add(node.id);
+    }
+    if (node.type !== "code-line") {
+      anomalies.push(`type-mismatch:${node.id}:${node.type}`);
+      nodes.delete(node.id);
+      deleteSnapshotCacheEntry(nodes, node.id);
+      touched.add(node.id);
+      continue;
+    }
+    if (seenIds.has(childId)) {
+      anomalies.push(`duplicate-id:${childId}`);
+      continue;
+    }
+    seenIds.add(childId);
+    codeLineNodes.push(node);
+    originalOrder.set(node.id, idx);
+  }
+  if (anomalies.length > 0) {
+    debugCodeBlock("code-block-anomalies", {
+      parentId: parent.id,
+      anomalies,
+      children: previousChildren
+    });
+    if (anomalies.some((entry) => entry.startsWith("duplicate-id"))) {
+      console.warn("[renderer-store] duplicate code-line ids detected", {
+        parentId: parent.id,
+        anomalies,
+        children: previousChildren
+      });
+    }
+  }
+  const sorted = codeLineNodes.slice().sort((a, b) => {
+    const ai = typeof a.props?.index === "number" ? a.props.index : parseLineIndexFromId(a.id);
+    const bi = typeof b.props?.index === "number" ? b.props.index : parseLineIndexFromId(b.id);
+    if (Number.isFinite(ai) && Number.isFinite(bi) && ai !== bi) {
+      return ai - bi;
+    }
+    const ao = originalOrder.get(a.id) ?? 0;
+    const bo = originalOrder.get(b.id) ?? 0;
+    return ao - bo;
+  });
+  const nextChildren = [];
+  let mutated = false;
+  for (let idx = 0; idx < sorted.length; idx++) {
+    const node = sorted[idx];
+    const desiredId = `${parent.id}::line:${idx}`;
+    const existing = nodes.get(desiredId);
+    if (existing && existing !== node) {
+      nodes.delete(desiredId);
+      deleteSnapshotCacheEntry(nodes, desiredId);
+      touched.add(desiredId);
+      mutated = true;
+    }
+    if (node.id !== desiredId) {
+      const previousId = node.id;
+      nodes.delete(node.id);
+      deleteSnapshotCacheEntry(nodes, previousId);
+      node.id = desiredId;
+      nodes.set(desiredId, node);
+      touched.add(desiredId);
+      mutated = true;
+    } else if (!nodes.has(desiredId)) {
+      nodes.set(desiredId, node);
+    }
+    if (node.parentId !== parent.id) {
+      node.parentId = parent.id;
+      node.version++;
+      touched.add(node.id);
+      mutated = true;
+    }
+    const incoming = { index: idx, text: node.props?.text, html: node.props?.html };
+    if (Object.prototype.hasOwnProperty.call(node.props ?? {}, "tokens")) {
+      incoming.tokens = node.props.tokens;
+    }
+    const normalizedProps = normalizeCodeLineProps(incoming, node.props);
+    if (normalizedProps !== node.props) {
+      node.props = normalizedProps;
+      node.version++;
+      touched.add(node.id);
+      mutated = true;
+    }
+    nextChildren.push(desiredId);
+  }
+  const allowed = new Set(nextChildren);
+  for (const [id, record] of nodes) {
+    if (record.parentId === parent.id && record.type === "code-line" && !allowed.has(id)) {
+      nodes.delete(id);
+      deleteSnapshotCacheEntry(nodes, id);
+      touched.add(id);
+      mutated = true;
+    }
+  }
+  if (!arraysEqual(previousChildren, nextChildren)) {
+    parent.children = nextChildren;
+    parent.version++;
+    touched.add(parent.id);
+    mutated = true;
+  }
+  const duplicateIds = [];
+  const postSeenIds = /* @__PURE__ */ new Set();
+  for (const childId of parent.children) {
+    if (postSeenIds.has(childId)) {
+      duplicateIds.push(childId);
+    } else {
+      postSeenIds.add(childId);
+    }
+  }
+  if (duplicateIds.length > 0) {
+    console.error("[renderer-store] duplicate code-line children detected post-normalize", {
+      parentId: parent.id,
+      duplicates: duplicateIds,
+      children: parent.children.slice()
+    });
+  }
+  if (mutated) {
+    debugCodeBlock("code-block-normalized", {
+      parentId: parent.id,
+      children: parent.children.slice()
+    });
+  }
+  if (CODE_BLOCK_VALIDATION_ENABLED) {
+    const validation = validateCodeBlockChildren(nodes, parent);
+    if (!validation.ok) {
+      debugCodeBlock("code-block-validation-failed", {
+        parentId: parent.id,
+        issues: validation.issues
+      });
+      if (!rebuildCodeBlockFromSnapshot(nodes, parent, touched, validation.issues)) {
+        console.warn("[renderer-store] unable to fully normalize code block", {
+          parentId: parent.id,
+          issues: validation.issues
+        });
+      }
+    }
+  }
+}
+function normalizeCodeLineProps(incoming, previous) {
+  const previousIndex = typeof previous?.index === "number" ? previous?.index : 0;
+  const index = typeof incoming.index === "number" ? incoming.index : previousIndex;
+  const previousText = typeof previous?.text === "string" ? previous?.text : "";
+  const previousHtml = typeof previous?.html === "string" ? previous?.html : null;
+  const previousTokens = Object.prototype.hasOwnProperty.call(previous ?? {}, "tokens") ? previous?.tokens : void 0;
+  const hasIncomingText = typeof incoming.text === "string";
+  const hasIncomingHtml = typeof incoming.html === "string";
+  const hasIncomingTokens = Object.prototype.hasOwnProperty.call(incoming, "tokens");
+  const incomingTokens = hasIncomingTokens ? incoming.tokens : void 0;
+  const rawText = hasIncomingText ? incoming.text : previousText;
+  if (previous && !hasIncomingHtml && !hasIncomingTokens && index === previousIndex && (!hasIncomingText || rawText === previousText)) {
+    return previous;
+  }
+  if (previous && hasIncomingHtml && !hasIncomingTokens && incoming.html === previousHtml && index === previousIndex && (!hasIncomingText || rawText === previousText)) {
+    return previous;
+  }
+  let highlight = null;
+  if (hasIncomingHtml) {
+    highlight = incoming.html;
+  } else if (!hasIncomingText || rawText === previousText) {
+    highlight = previousHtml;
+  }
+  let tokens = void 0;
+  if (hasIncomingTokens) {
+    tokens = incomingTokens ?? null;
+  } else if (!hasIncomingText || rawText === previousText) {
+    tokens = previousTokens;
+  } else {
+    tokens = null;
+  }
+  return createCodeLineProps(index, rawText, highlight, tokens);
+}
+function createCodeLineProps(index, text, highlight, tokens) {
+  const safeText = typeof text === "string" ? text : "";
+  const hasIncomingHighlight = typeof highlight === "string" && highlight.trim().length > 0;
+  const sanitized = hasIncomingHighlight ? sanitizeLineInnerHtml(highlight, safeText) : null;
+  const hasRenderableTokens = tokens !== void 0 && tokens !== null;
+  const html = sanitized && sanitized.length >= safeText.length ? sanitized : hasRenderableTokens ? null : escapeHtml2(safeText);
+  const props = {
+    index,
+    text: safeText,
+    html
+  };
+  if (tokens !== void 0) {
+    props.tokens = tokens;
+  }
+  return props;
+}
+function clampIndex(index, length) {
+  if (!Number.isFinite(index)) return 0;
+  if (length <= 0) return 0;
+  return Math.max(0, Math.min(index, length));
+}
+var INLINE_SEGMENT_TYPES = /* @__PURE__ */ new Set(["paragraph-text", "blockquote-text", "list-item-text"]);
+function isInlineSegmentType(type) {
+  return INLINE_SEGMENT_TYPES.has(type);
+}
+function mergeInlineSegmentProps(previous, incoming) {
+  const result = previous ? { ...previous } : {};
+  for (const [key, value] of Object.entries(incoming)) {
+    if (value === void 0) {
+      delete result[key];
+    } else {
+      result[key] = value;
+    }
+  }
+  const inlineProvided = Object.prototype.hasOwnProperty.call(incoming, "inline");
+  if (inlineProvided) {
+    const inlineValue = Array.isArray(incoming.inline) ? incoming.inline : void 0;
+    if (inlineValue) {
+      result.inline = inlineValue;
+    } else {
+      result.inline = void 0;
+    }
+  } else if (previous && Array.isArray(previous.inline) && !Array.isArray(result.inline)) {
+    result.inline = previous.inline;
+  }
+  const textProvided = Object.prototype.hasOwnProperty.call(incoming, "text");
+  if (textProvided) {
+    result.text = typeof incoming.text === "string" ? incoming.text : "";
+  } else if (previous && typeof previous.text === "string" && typeof result.text !== "string") {
+    result.text = previous.text;
+  }
+  return result;
+}
+function applyCodeBlockMetadata(record) {
+  const block = record.block;
+  const highlightedHtml = block?.payload.highlightedHtml ?? "";
+  const lang = typeof block?.payload.meta?.lang === "string" ? block?.payload.meta?.lang : record.props?.lang;
+  let { preAttrs, codeAttrs } = extractCodeWrapperAttributes(highlightedHtml);
+  if (!preAttrs || !codeAttrs) {
+    const defaults = getDefaultCodeWrapperAttributes(typeof lang === "string" ? lang : void 0);
+    preAttrs = preAttrs ?? defaults.preAttrs;
+    codeAttrs = codeAttrs ?? defaults.codeAttrs;
+  }
+  record.props = {
+    ...record.props ?? {},
+    lang,
+    preAttrs,
+    codeAttrs
+  };
+}
+function normalizeNodeProps(snapshot) {
+  if (snapshot.type === "code-line") {
+    const index = typeof snapshot.props?.index === "number" ? snapshot.props?.index : 0;
+    const text = typeof snapshot.props?.text === "string" ? snapshot.props?.text : "";
+    const html = typeof snapshot.props?.html === "string" ? snapshot.props?.html : null;
+    const tokens = Object.prototype.hasOwnProperty.call(snapshot.props ?? {}, "tokens") ? snapshot.props?.tokens : void 0;
+    return createCodeLineProps(index, text, html, tokens);
+  }
+  if (isInlineSegmentType(snapshot.type)) {
+    const incoming = snapshot.props ? { ...snapshot.props } : {};
+    return mergeInlineSegmentProps(void 0, incoming);
+  }
+  return snapshot.props ? { ...snapshot.props } : {};
+}
+function validateCodeBlockChildren(nodes, parent) {
+  const issues = [];
+  const expectedPrefix = `${parent.id}::line:`;
+  const allowed = /* @__PURE__ */ new Set();
+  for (let idx = 0; idx < parent.children.length; idx++) {
+    const childId = parent.children[idx];
+    allowed.add(childId);
+    const node = nodes.get(childId);
+    if (!node) {
+      issues.push({ kind: "missing-node", id: childId, expected: `${expectedPrefix}${idx}` });
+      continue;
+    }
+    if (node.parentId !== parent.id) {
+      issues.push({ kind: "parent-mismatch", id: childId, expected: parent.id, actual: node.parentId });
+    }
+    if (node.type !== "code-line") {
+      issues.push({ kind: "unexpected-type", id: childId, expected: "code-line", actual: node.type });
+    }
+    const expectedId = `${expectedPrefix}${idx}`;
+    if (childId !== expectedId) {
+      issues.push({ kind: "id-mismatch", id: childId, expected: expectedId, actual: childId });
+    }
+    const indexProp = typeof node.props?.index === "number" ? node.props.index : null;
+    if (indexProp !== idx) {
+      issues.push({ kind: "index-mismatch", id: childId, expected: idx, actual: indexProp });
+    }
+  }
+  for (const [id, record] of nodes) {
+    if (record.parentId === parent.id && record.type === "code-line" && !allowed.has(id)) {
+      issues.push({ kind: "dangling-node", id });
+    }
+  }
+  if (parent.block?.isFinalized) {
+    const snapshot = createBlockSnapshot(cloneBlock(parent.block));
+    const expectedChildren = ensureArray(snapshot.children).filter((child) => child.type === "code-line");
+    if (expectedChildren.length !== parent.children.length) {
+      issues.push({
+        kind: "line-count-mismatch",
+        id: parent.id,
+        expected: expectedChildren.length,
+        actual: parent.children.length
+      });
+    }
+  }
+  return { ok: issues.length === 0, issues };
+}
+function rebuildCodeBlockFromSnapshot(nodes, parent, touched, issues) {
+  if (!parent.block) {
+    return false;
+  }
+  const ancestor = parent.parentId ? nodes.get(parent.parentId) : void 0;
+  if (!ancestor) {
+    return false;
+  }
+  const index = ancestor.children.indexOf(parent.id);
+  if (index === -1) {
+    return false;
+  }
+  const snapshot = createBlockSnapshot(cloneBlock(parent.block));
+  removeSubtree(nodes, parent.id, touched);
+  const inserted = insertSnapshotAt(nodes, ancestor, index, snapshot, touched, parent.blockEpoch);
+  if (!inserted) {
+    return false;
+  }
+  for (const id of inserted.insertedIds) {
+    touched.add(id);
+  }
+  ancestor.version++;
+  touched.add(ancestor.id);
+  console.warn("[renderer-store] rebuilt code block from snapshot", {
+    parentId: parent.id,
+    issues
+  });
+  return true;
+}
+function arraysEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function expectedCodeLineId(parentId, index) {
+  return `${parentId}::line:${index}`;
+}
+function collectStoreInvariantViolations(nodes) {
+  const violations = [];
+  for (const [id, node] of nodes) {
+    if (node.type === "__root__") continue;
+    if (node.children.length > 1) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const childId of node.children) {
+        if (seen.has(childId)) {
+          violations.push(`duplicate child id:${id}:${childId}`);
+        } else {
+          seen.add(childId);
+        }
+      }
+    }
+    if (node.type === "list") {
+      const parent = node.parentId ? nodes.get(node.parentId) : void 0;
+      if (parent?.type === "list-item" && node.children.length === 0) {
+        violations.push(`empty nested list:${id}`);
+      }
+    }
+    if (node.type === "code") {
+      for (let index = 0; index < node.children.length; index += 1) {
+        const childId = node.children[index];
+        const child = nodes.get(childId);
+        if (!child) {
+          violations.push(`missing code-line node:${node.id}:${childId}`);
+          continue;
+        }
+        if (child.type !== "code-line") {
+          violations.push(`non-code child in code block:${node.id}:${child.id}:${child.type}`);
+          continue;
+        }
+        const expectedId = expectedCodeLineId(node.id, index);
+        if (child.id !== expectedId) {
+          violations.push(`code-line id mismatch:${node.id}:${child.id}:${expectedId}`);
+        }
+        const indexProp = typeof child.props?.index === "number" ? child.props.index : null;
+        if (indexProp !== index) {
+          violations.push(`code-line index mismatch:${node.id}:${child.id}:${indexProp}:${index}`);
+        }
+      }
+    }
+  }
+  return violations;
+}
+function buildNodeFromSnapshot(map, snapshot, parentId, blockEpoch) {
+  const record = {
+    id: snapshot.id,
+    type: snapshot.type,
+    parentId,
+    children: [],
+    props: normalizeNodeProps(snapshot),
+    meta: snapshot.meta ? { ...snapshot.meta } : void 0,
+    range: snapshot.range ? { ...snapshot.range } : void 0,
+    version: 0,
+    blockEpoch,
+    block: snapshotToBlock(snapshot) ?? void 0
+  };
+  if (record.type === "code") {
+    applyCodeBlockMetadata(record);
+  }
+  map.set(record.id, record);
+  const childSnapshots = ensureArray(snapshot.children);
+  for (const child of childSnapshots) {
+    const childRecord = buildNodeFromSnapshot(map, child, record.id, blockEpoch);
+    record.children.push(childRecord.id);
+  }
+  return record;
+}
+function removeSubtree(map, id, touched) {
+  const record = map.get(id);
+  if (!record) return;
+  const stack = [record];
+  const affectedParents = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) {
+      continue;
+    }
+    if (node.parentId) {
+      const parent = map.get(node.parentId);
+      if (parent) {
+        const idx = parent.children.indexOf(node.id);
+        if (idx !== -1) {
+          parent.children.splice(idx, 1);
+          parent.version++;
+          touched.add(parent.id);
+          affectedParents.add(parent.id);
+        }
+      }
+    }
+    map.delete(node.id);
+    deleteSnapshotCacheEntry(map, node.id);
+    touched.add(node.id);
+    for (const childId of node.children) {
+      const child = map.get(childId);
+      if (child) stack.push(child);
+    }
+  }
+  for (const parentId of affectedParents) {
+    const parent = map.get(parentId);
+    if (parent && parent.type === "code") {
+      normalizeCodeBlockChildren(map, parent, touched);
+    }
+  }
+}
+function convertNodeToBlocks(map, root) {
+  const result = [];
+  for (const childId of root.children) {
+    const child = map.get(childId);
+    if (!child || !child.block) continue;
+    result.push(cloneBlock(child.block));
+  }
+  return result;
+}
+function resolveParent(map, path) {
+  if (path.nodeId) {
+    return map.get(path.nodeId);
+  }
+  if (path.blockId === PATCH_ROOT_ID) {
+    return map.get(PATCH_ROOT_ID);
+  }
+  return map.get(path.blockId);
+}
+function insertSnapshotAt(map, parent, index, snapshot, touched, blockEpoch) {
+  if (!parent) return null;
+  const existingIndex = parent.children.indexOf(snapshot.id);
+  if (existingIndex !== -1) {
+    removeSubtree(map, parent.children[existingIndex], touched ?? /* @__PURE__ */ new Set());
+  }
+  const record = buildNodeFromSnapshot(map, snapshot, parent.id, blockEpoch ?? readSnapshotBlockEpoch(snapshot) ?? parent.blockEpoch);
+  const insertedIds = [];
+  const queue = [record];
+  while (queue.length > 0) {
+    const node = queue.pop();
+    if (!node) continue;
+    insertedIds.push(node.id);
+    for (const childId of node.children) {
+      const child = map.get(childId);
+      if (child) queue.push(child);
+    }
+  }
+  const clampedIndex = Math.min(Math.max(index, 0), parent.children.length);
+  parent.children.splice(clampedIndex, 0, record.id);
+  parent.version++;
+  ensureUniqueChildren(parent, touched);
+  return { record, insertedIds };
+}
+function replaceSnapshotAt(map, parent, index, snapshot, touched, blockEpoch) {
+  if (!parent) return;
+  if (index < 0 || index >= parent.children.length) return;
+  const targetId = parent.children[index];
+  parent.children.splice(index, 1);
+  removeSubtree(map, targetId, touched);
+  const inserted = insertSnapshotAt(map, parent, index, snapshot, touched, blockEpoch);
+  if (inserted) {
+    for (const id of inserted.insertedIds) {
+      touched.add(id);
+    }
+  }
+  if (parent.type === "code") {
+    normalizeCodeBlockChildren(map, parent, touched);
+  } else {
+    ensureUniqueChildren(parent, touched);
+  }
+}
+function createRendererStore(initialBlocks = []) {
+  let nodes = /* @__PURE__ */ new Map();
+  let version = 0;
+  let blocksCache = [];
+  let blocksDirty = true;
+  const listeners = /* @__PURE__ */ new Set();
+  let notifyScheduled = false;
+  let lastCoalescingMetrics = null;
+  let invariantViolations = [];
+  let transientDiagnostics = [];
+  let nextBlockEpoch = 1;
+  const debugCounters = {
+    appendLineGuardRejected: 0,
+    staleEpochRejected: 0,
+    storeInvariantViolationCount: 0
+  };
+  const allocateBlockEpoch = (preferred) => {
+    const resolved = readNumericEpoch(preferred);
+    if (resolved !== void 0) {
+      nextBlockEpoch = Math.max(nextBlockEpoch, resolved + 1);
+      return resolved;
+    }
+    const epoch = nextBlockEpoch;
+    nextBlockEpoch += 1;
+    return epoch;
+  };
+  const getRaf = () => {
+    if (typeof globalThis !== "undefined" && typeof globalThis.requestAnimationFrame === "function") {
+      return globalThis.requestAnimationFrame;
+    }
+    return null;
+  };
+  function scheduleNotify() {
+    if (notifyScheduled) return;
+    notifyScheduled = true;
+    const raf = getRaf();
+    if (raf) {
+      raf(() => {
+        notifyScheduled = false;
+        notify();
+      });
+    } else {
+      setTimeout(() => {
+        notifyScheduled = false;
+        notify();
+      }, 0);
+    }
+  }
+  function notify() {
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch (error) {
+        console.error("RendererStore listener failed", error);
+      }
+    }
+  }
+  function appendDiagnostic(message) {
+    transientDiagnostics = [...transientDiagnostics, message];
+    invariantViolations = [...invariantViolations, message];
+  }
+  function rebuildFromBlocks(blocks) {
+    clearSnapshotCaches(nodes);
+    nodes = /* @__PURE__ */ new Map();
+    const root = createRootRecord();
+    nodes.set(root.id, root);
+    root.children = [];
+    lastCoalescingMetrics = null;
+    for (let i = 0; i < blocks.length; i++) {
+      const block = cloneBlock(blocks[i]);
+      const snapshot = createBlockSnapshot(block);
+      insertSnapshotAt(nodes, root, root.children.length, snapshot, void 0, allocateBlockEpoch(readSnapshotBlockEpoch(snapshot)));
+    }
+    normalizeAllListDepths(nodes, /* @__PURE__ */ new Set(), PATCH_ROOT_ID);
+    transientDiagnostics = [];
+    invariantViolations = collectStoreInvariantViolations(nodes);
+    debugCounters.storeInvariantViolationCount += invariantViolations.length;
+    version++;
+    blocksDirty = true;
+    scheduleNotify();
+  }
+  rebuildFromBlocks(initialBlocks);
+  const store = {
+    reset(nextBlocks) {
+      rebuildFromBlocks(nextBlocks);
+    },
+    applyPatches(patches, options) {
+      const touched = /* @__PURE__ */ new Set();
+      if (!patches || patches.length === 0) {
+        lastCoalescingMetrics = options?.metrics ?? null;
+        return touched;
+      }
+      const perfEnabled = isPatchPerfDebugEnabled();
+      const perfStart = perfEnabled ? getPerfNow() : 0;
+      const opStats = perfEnabled ? {} : {};
+      const setPropsByType = perfEnabled ? {} : {};
+      const setPropsBySize = perfEnabled ? {} : {};
+      let applyMs = 0;
+      let listNormalizeMs = 0;
+      let coalescedPatches = patches;
+      let metrics = options?.metrics ?? null;
+      if (!options?.coalesced) {
+        const result = coalescePatchesWithMetrics(patches, DEFAULT_COALESCE_CONFIG);
+        coalescedPatches = result.patches;
+        metrics = result.metrics;
+      }
+      lastCoalescingMetrics = metrics;
+      const root = nodes.get(PATCH_ROOT_ID);
+      if (!root) {
+        nodes.set(PATCH_ROOT_ID, createRootRecord());
+      }
+      let mutatedBlocks = false;
+      let listDepthDirty = false;
+      const listDepthDirtyNodes = /* @__PURE__ */ new Set();
+      const debugListPatches = isListPatchDebugEnabled();
+      const isListRelated = (type) => type === "list" || type === "list-item";
+      const logListPatch = (label, details) => {
+        if (!debugListPatches) return;
+        try {
+          console.debug(`[list-patch] ${label}`, details);
+        } catch {
+        }
+      };
+      const findNearestListNode = (nodeId) => {
+        if (!nodeId) return void 0;
+        let current = nodes.get(nodeId);
+        while (current) {
+          if (current.type === "list") return current;
+          if (!current.parentId) return void 0;
+          current = nodes.get(current.parentId);
+        }
+        return void 0;
+      };
+      const markListDepthDirty = (nodeId) => {
+        const listNode = findNearestListNode(nodeId);
+        if (listNode) {
+          listDepthDirtyNodes.add(listNode.id);
+        } else {
+          listDepthDirty = true;
+        }
+      };
+      const semanticTxEpochs = /* @__PURE__ */ new Map();
+      const resolveBlockEpochTarget = (patch, at) => {
+        if ((patch.op === "insertChild" || patch.op === "replaceChild") && at.blockId === PATCH_ROOT_ID) {
+          const nodeId = patch.node?.id;
+          return nodeId ? nodes.get(nodeId) : void 0;
+        }
+        return nodes.get(at.blockId) ?? (at.nodeId ? nodes.get(at.nodeId) : void 0);
+      };
+      const rejectStaleEpochPatch = (patch, at) => {
+        const expectedBlockEpoch = readPatchBlockEpoch(patch);
+        const patchTx = readPatchTx(patch);
+        if (expectedBlockEpoch === void 0) {
+          return false;
+        }
+        if (getPatchKind(patch) !== "semantic" || !at) {
+          return false;
+        }
+        const target = resolveBlockEpochTarget(patch, at);
+        if (!target || target.blockEpoch === expectedBlockEpoch) {
+          return false;
+        }
+        const txEpoch = at.blockId && patchTx !== void 0 ? semanticTxEpochs.get(at.blockId) : void 0;
+        if (txEpoch && txEpoch.tx === patchTx && txEpoch.blockEpoch === target.blockEpoch) {
+          return false;
+        }
+        debugCounters.staleEpochRejected += 1;
+        appendDiagnostic(
+          `stale epoch rejected:${patch.op}:${target.id}:expected=${expectedBlockEpoch}:actual=${target.blockEpoch}`
+        );
+        return true;
+      };
+      const advanceBlockEpoch = (blockId, touchedSet, preferredEpoch, tx) => {
+        if (!blockId || blockId === PATCH_ROOT_ID) {
+          return null;
+        }
+        const blockRoot = nodes.get(blockId);
+        if (!blockRoot) {
+          return null;
+        }
+        const nextEpoch = allocateBlockEpoch(preferredEpoch);
+        assignSubtreeBlockEpoch(nodes, blockRoot.id, nextEpoch, touchedSet);
+        if (tx !== void 0) {
+          semanticTxEpochs.set(blockRoot.id, { tx, blockEpoch: nextEpoch });
+        }
+        return nextEpoch;
+      };
+      const applyPropsUpdate = (at, props, preferredEpoch, tx, semanticUpdate = false) => {
+        const perfStartLocal = perfEnabled ? getPerfNow() : 0;
+        const targetId = at.nodeId ?? at.blockId;
+        if (!targetId) return;
+        let target = nodes.get(targetId);
+        if (!target) return;
+        const parentType = target.parentId ? nodes.get(target.parentId)?.type : void 0;
+        if (debugListPatches && (isListRelated(target.type) || isListRelated(parentType))) {
+          logListPatch("setProps", {
+            id: target.id,
+            type: target.type,
+            parentType,
+            keys: props ? Object.keys(props) : []
+          });
+        }
+        let propsChanged = false;
+        if (target.type === "code-line") {
+          const incoming = {
+            index: props?.index,
+            text: props?.text,
+            html: props?.html
+          };
+          if (Object.prototype.hasOwnProperty.call(props ?? {}, "tokens")) {
+            incoming.tokens = props.tokens;
+          }
+          const normalized = normalizeCodeLineProps(incoming, target.props);
+          if (normalized !== target.props) {
+            target.props = normalized;
+            propsChanged = true;
+          }
+          if (propsChanged) {
+            if (semanticUpdate) {
+              advanceBlockEpoch(at.blockId, touched, preferredEpoch, tx);
+            }
+            target.version++;
+            touched.add(target.id);
+            const parent = target.parentId ? nodes.get(target.parentId) : void 0;
+            if (parent) {
+              parent.version++;
+              touched.add(parent.id);
+              if (parent.type === "code") {
+                normalizeCodeBlockChildren(nodes, parent, touched);
+              }
+            }
+          }
+          if (perfEnabled) {
+            const duration = getPerfNow() - perfStartLocal;
+            const typeKey = target.type || "unknown";
+            const sizeKey = bucketBySize(estimatePropsSize(props, void 0));
+            const typeEntry = setPropsByType[typeKey] ?? { count: 0, durationMs: 0 };
+            typeEntry.count += 1;
+            typeEntry.durationMs += duration;
+            setPropsByType[typeKey] = typeEntry;
+            const sizeEntry = setPropsBySize[sizeKey] ?? { count: 0, durationMs: 0 };
+            sizeEntry.count += 1;
+            sizeEntry.durationMs += duration;
+            setPropsBySize[sizeKey] = sizeEntry;
+          }
+          return;
+        } else if (isInlineSegmentType(target.type)) {
+          const nextProps = props ? { ...props } : {};
+          if ("block" in nextProps) {
+            delete nextProps.block;
+          }
+          const mergedSegments = mergeInlineSegmentProps(target.props, nextProps);
+          if (!shallowEqualRecords(target.props, mergedSegments)) {
+            target.props = mergedSegments;
+            propsChanged = true;
+          }
+        } else {
+          const nextProps = props ? { ...props } : {};
+          if ("block" in nextProps) {
+            delete nextProps.block;
+          }
+          const base = target.props ? { ...target.props } : {};
+          let localChanged = false;
+          if (Object.prototype.hasOwnProperty.call(base, "block")) {
+            delete base.block;
+            localChanged = true;
+          }
+          for (const [key, value] of Object.entries(nextProps)) {
+            if (value === void 0) {
+              if (Object.prototype.hasOwnProperty.call(base, key)) {
+                delete base[key];
+                localChanged = true;
+              }
+            } else if (base[key] !== value) {
+              base[key] = value;
+              localChanged = true;
+            }
+          }
+          if (localChanged) {
+            target.props = base;
+            propsChanged = true;
+          }
+        }
+        let blockChanged = false;
+        let typeChanged = false;
+        let rebuiltFromFinalizedBlock = false;
+        let blockEpochAdvanced = false;
+        const incomingBlock = props?.block;
+        if (incomingBlock && typeof incomingBlock === "object") {
+          target.block = cloneBlock(incomingBlock);
+          const previousType = target.type;
+          const incomingType = typeof target.block.type === "string" ? target.block.type : target.type;
+          if (incomingType !== target.type) {
+            target.type = incomingType;
+            typeChanged = true;
+            if (isListRelated(previousType) || isListRelated(target.type)) {
+              markListDepthDirty(target.id);
+            }
+          }
+          if (target.type === "code") {
+            applyCodeBlockMetadata(target);
+          }
+          if (semanticUpdate) {
+            advanceBlockEpoch(at.blockId, touched, preferredEpoch, tx);
+            blockEpochAdvanced = true;
+          }
+          const shouldRebuildFinalizedTree = !at.nodeId && target.id === at.blockId && Boolean(target.block?.isFinalized) && target.type !== "code" && Boolean(target.parentId);
+          if (shouldRebuildFinalizedTree) {
+            const parent = target.parentId ? nodes.get(target.parentId) : void 0;
+            const index = parent ? parent.children.indexOf(target.id) : -1;
+            if (parent && index !== -1) {
+              const snapshot = createBlockSnapshot(cloneBlock(target.block));
+              replaceSnapshotAt(nodes, parent, index, snapshot, touched, target.blockEpoch);
+              mutatedBlocks = true;
+              blockChanged = true;
+              rebuiltFromFinalizedBlock = true;
+              const rebuilt = nodes.get(target.id);
+              if (isListRelated(previousType) || isListRelated(rebuilt?.type)) {
+                markListDepthDirty(target.id);
+              }
+              target = rebuilt ?? target;
+            }
+          }
+          mutatedBlocks = true;
+          blockChanged = true;
+        }
+        if (rebuiltFromFinalizedBlock) {
+          return;
+        }
+        if (propsChanged || blockChanged || typeChanged) {
+          if (semanticUpdate && !blockEpochAdvanced) {
+            advanceBlockEpoch(at.blockId, touched, preferredEpoch, tx);
+            blockEpochAdvanced = true;
+          }
+          target.version++;
+          touched.add(target.id);
+          let parentForNormalization;
+          if (target.parentId) {
+            const parent = nodes.get(target.parentId);
+            if (parent) {
+              if (target.type === "code-line") {
+                parent.version++;
+                touched.add(parent.id);
+              }
+              if (parent.type === "code") {
+                parentForNormalization = parent;
+              }
+            }
+          }
+          if (target.type === "code") {
+            normalizeCodeBlockChildren(nodes, target, touched);
+          } else if (parentForNormalization) {
+            normalizeCodeBlockChildren(nodes, parentForNormalization, touched);
+          }
+          const parentType2 = target.parentId ? nodes.get(target.parentId)?.type : void 0;
+          if (isListRelated(target.type) || isListRelated(parentType2)) {
+            markListDepthDirty(target.id);
+          }
+        }
+        if (perfEnabled) {
+          const duration = getPerfNow() - perfStartLocal;
+          const typeKey = target.type || "unknown";
+          const sizeKey = bucketBySize(estimatePropsSize(props, incomingBlock && typeof incomingBlock === "object" ? incomingBlock : void 0));
+          const typeEntry = setPropsByType[typeKey] ?? { count: 0, durationMs: 0 };
+          typeEntry.count += 1;
+          typeEntry.durationMs += duration;
+          setPropsByType[typeKey] = typeEntry;
+          const sizeEntry = setPropsBySize[sizeKey] ?? { count: 0, durationMs: 0 };
+          sizeEntry.count += 1;
+          sizeEntry.durationMs += duration;
+          setPropsBySize[sizeKey] = sizeEntry;
+        }
+      };
+      const applyPatch = (patch) => {
+        switch (patch.op) {
+          case "insertChild": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            const parent = resolveParent(nodes, patch.at);
+            const inserted = insertSnapshotAt(
+              nodes,
+              parent,
+              patch.index,
+              patch.node,
+              touched,
+              allocateBlockEpoch(readPatchParseEpoch(patch) ?? readSnapshotBlockEpoch(patch.node))
+            );
+            if (inserted) {
+              for (const id of inserted.insertedIds) {
+                touched.add(id);
+              }
+              mutatedBlocks = true;
+              advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
+              if (isListRelated(inserted.record.type) || isListRelated(parent?.type)) {
+                markListDepthDirty(inserted.record.id);
+                if (parent) {
+                  markListDepthDirty(parent.id);
+                }
+              }
+              if (debugListPatches && (isListRelated(inserted.record.type) || isListRelated(parent?.type))) {
+                logListPatch("insertChild", {
+                  id: inserted.record.id,
+                  type: inserted.record.type,
+                  parentId: parent?.id,
+                  parentType: parent?.type,
+                  index: patch.index
+                });
+              }
+            }
+            break;
+          }
+          case "deleteChild": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            const parent = resolveParent(nodes, patch.at);
+            if (!parent) break;
+            if (patch.index < 0 || patch.index >= parent.children.length) break;
+            const childId = parent.children.splice(patch.index, 1)[0];
+            if (childId) {
+              const removedNode = nodes.get(childId);
+              removeSubtree(nodes, childId, touched);
+              parent.version++;
+              touched.add(parent.id);
+              ensureUniqueChildren(parent, touched);
+              mutatedBlocks = true;
+              advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
+              if (isListRelated(parent.type) || isListRelated(removedNode?.type)) {
+                markListDepthDirty(parent.id);
+              }
+              if (debugListPatches && (isListRelated(parent.type) || isListRelated(removedNode?.type))) {
+                logListPatch("deleteChild", {
+                  id: childId,
+                  type: removedNode?.type,
+                  parentId: parent.id,
+                  parentType: parent.type,
+                  index: patch.index
+                });
+              }
+            }
+            break;
+          }
+          case "replaceChild": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            const parent = resolveParent(nodes, patch.at);
+            if (!parent) break;
+            replaceSnapshotAt(
+              nodes,
+              parent,
+              patch.index,
+              patch.node,
+              touched,
+              allocateBlockEpoch(readPatchParseEpoch(patch) ?? readSnapshotBlockEpoch(patch.node))
+            );
+            touched.add(parent.id);
+            mutatedBlocks = true;
+            advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
+            if (isListRelated(parent.type)) {
+              markListDepthDirty(parent.id);
+            }
+            if (debugListPatches && isListRelated(parent.type)) {
+              logListPatch("replaceChild", {
+                parentId: parent.id,
+                parentType: parent.type,
+                index: patch.index
+              });
+            }
+            break;
+          }
+          case "setProps": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            applyPropsUpdate(patch.at, patch.props, readPatchParseEpoch(patch), readPatchTx(patch), getPatchKind(patch) === "semantic");
+            break;
+          }
+          case "setPropsBatch": {
+            const entries2 = Array.isArray(patch.entries) ? patch.entries : [];
+            for (const entry of entries2) {
+              if (!entry || !entry.at) continue;
+              const entryPatch = {
+                op: "setProps",
+                at: entry.at,
+                props: entry.props,
+                meta: entry.meta ?? patch.meta
+              };
+              if (rejectStaleEpochPatch(entryPatch, entry.at)) continue;
+              applyPropsUpdate(
+                entry.at,
+                entry.props,
+                readPatchParseEpoch(entryPatch),
+                readPatchTx(entryPatch),
+                getPatchKind(entryPatch) === "semantic"
+              );
+            }
+            break;
+          }
+          case "finalize": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            const target = nodes.get(patch.at.nodeId ?? patch.at.blockId);
+            if (!target || !target.block) break;
+            if (!target.block.isFinalized) {
+              target.block = cloneBlock(target.block);
+              target.block.isFinalized = true;
+              target.version++;
+              touched.add(target.id);
+              mutatedBlocks = true;
+              if (!patch.at.nodeId && target.id === patch.at.blockId && target.type !== "code" && target.parentId) {
+                const parent = nodes.get(target.parentId);
+                const index = parent ? parent.children.indexOf(target.id) : -1;
+                if (parent && index !== -1) {
+                  const snapshot = createBlockSnapshot(cloneBlock(target.block));
+                  replaceSnapshotAt(nodes, parent, index, snapshot, touched, target.blockEpoch);
+                  if (isListRelated(target.type) || isListRelated(snapshot.type)) {
+                    markListDepthDirty(target.id);
+                  }
+                }
+              }
+            }
+            if (isListRelated(target.type)) {
+              markListDepthDirty(target.id);
+            }
+            if (debugListPatches && isListRelated(target.type)) {
+              logListPatch("finalize", {
+                id: target.id,
+                type: target.type
+              });
+            }
+            break;
+          }
+          case "reorder": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            const parent = resolveParent(nodes, patch.at);
+            if (!parent) break;
+            const length = parent.children.length;
+            if (length === 0 || patch.count <= 0) break;
+            const from = clampIndex(patch.from, length - 1);
+            const count = Math.max(1, Math.min(patch.count, length - from));
+            let to = clampIndex(patch.to, length);
+            if (to > from) {
+              to = Math.max(0, to - count);
+            }
+            const moved = parent.children.splice(from, count);
+            parent.children.splice(to, 0, ...moved);
+            parent.version++;
+            touched.add(parent.id);
+            if (getPatchKind(patch) === "semantic") {
+              advanceBlockEpoch(patch.at.blockId, touched, readPatchParseEpoch(patch), readPatchTx(patch));
+            }
+            if (isListRelated(parent.type)) {
+              markListDepthDirty(parent.id);
+            }
+            if (debugListPatches && isListRelated(parent.type)) {
+              logListPatch("reorder", {
+                parentId: parent.id,
+                parentType: parent.type,
+                from: patch.from,
+                to: patch.to,
+                count: patch.count
+              });
+            }
+            break;
+          }
+          case "appendLines": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            const parent = resolveParent(nodes, patch.at);
+            if (!parent) break;
+            if (parent.type !== "code") {
+              debugCounters.appendLineGuardRejected += 1;
+              appendDiagnostic(`appendLines target not code:${parent.id}:${parent.type}`);
+              break;
+            }
+            const requestedStartIndex = Math.max(0, patch.startIndex);
+            const startIndex = Math.max(0, Math.min(requestedStartIndex, parent.children.length));
+            const lineCount = patch.lines?.length ?? 0;
+            if (lineCount === 0) break;
+            const prefixMatches = parent.children.every((childId, index) => childId === expectedCodeLineId(parent.id, index));
+            const isStrictTailAppend = requestedStartIndex === parent.children.length;
+            if (!isStrictTailAppend || !prefixMatches) {
+              debugCounters.appendLineGuardRejected += 1;
+              appendDiagnostic(
+                `appendLines guard rejected:${parent.id}:requestedStart=${requestedStartIndex}:childCount=${parent.children.length}:prefixMatches=${prefixMatches}`
+              );
+              break;
+            }
+            const originalChildren = parent.children.slice();
+            const insertedIds = [];
+            const insertedSet = /* @__PURE__ */ new Set();
+            const isTrailingAppend = true;
+            let parentChildrenChanged = false;
+            let codeLinesMutated = false;
+            for (let offset = 0; offset < lineCount; offset++) {
+              const absoluteIndex = startIndex + offset;
+              const lineId = `${parent.id}::line:${absoluteIndex}`;
+              insertedIds.push(lineId);
+              insertedSet.add(lineId);
+              const hasTokens = Object.prototype.hasOwnProperty.call(patch, "tokens");
+              const nextTokens = hasTokens ? patch.tokens?.[offset] ?? null : void 0;
+              const nextLineProps = createCodeLineProps(
+                absoluteIndex,
+                patch.lines[offset] ?? "",
+                patch.highlight?.[offset] ?? null,
+                nextTokens
+              );
+              const existing = nodes.get(lineId);
+              if (existing && existing.type === "code-line") {
+                const existingIndex = parent.children.indexOf(lineId);
+                if (existingIndex !== -1) {
+                  parent.children.splice(existingIndex, 1);
+                  parentChildrenChanged = true;
+                }
+                if (existing.parentId !== parent.id) {
+                  existing.parentId = parent.id;
+                  existing.version++;
+                  touched.add(lineId);
+                  codeLinesMutated = true;
+                }
+                if (!shallowEqualRecords(existing.props, nextLineProps)) {
+                  existing.props = nextLineProps;
+                  existing.version++;
+                  touched.add(lineId);
+                  codeLinesMutated = true;
+                }
+              } else {
+                const record = {
+                  id: lineId,
+                  type: "code-line",
+                  parentId: parent.id,
+                  children: [],
+                  props: nextLineProps,
+                  version: 0,
+                  blockEpoch: parent.blockEpoch
+                };
+                nodes.set(lineId, record);
+                touched.add(lineId);
+                codeLinesMutated = true;
+              }
+            }
+            if (insertedIds.length > 0) {
+              let nextChildren;
+              if (isTrailingAppend) {
+                nextChildren = [...originalChildren, ...insertedIds];
+              } else {
+                const cleanedChildren = originalChildren.filter((childId) => !insertedSet.has(childId));
+                const clampedStart = Math.max(0, Math.min(startIndex, cleanedChildren.length));
+                nextChildren = [...cleanedChildren.slice(0, clampedStart), ...insertedIds, ...cleanedChildren.slice(clampedStart)];
+              }
+              if (!arraysEqual(originalChildren, nextChildren)) {
+                parent.children = nextChildren;
+                parentChildrenChanged = true;
+              }
+            }
+            if (!isTrailingAppend) {
+              for (let idx = 0; idx < parent.children.length; idx++) {
+                const childId = parent.children[idx];
+                const child = nodes.get(childId);
+                if (child && child.type === "code-line") {
+                  const incoming = { index: idx, text: child.props?.text, html: child.props?.html };
+                  if (Object.prototype.hasOwnProperty.call(child.props ?? {}, "tokens")) {
+                    incoming.tokens = child.props.tokens;
+                  }
+                  const normalized = normalizeCodeLineProps(incoming, child.props);
+                  if (normalized !== child.props) {
+                    child.props = normalized;
+                    child.version++;
+                    touched.add(child.id);
+                    codeLinesMutated = true;
+                  }
+                }
+              }
+            }
+            if (parentChildrenChanged || codeLinesMutated) {
+              parent.version++;
+              touched.add(parent.id);
+              if (!isTrailingAppend) {
+                normalizeCodeBlockChildren(nodes, parent, touched);
+              }
+            }
+            break;
+          }
+          case "setHTML": {
+            if (rejectStaleEpochPatch(patch, patch.at)) break;
+            const target = nodes.get(patch.at.nodeId ?? patch.at.blockId);
+            if (!target) break;
+            const sanitized = patch.sanitized ? patch.html : sanitizeHTML2(patch.html);
+            target.props = {
+              ...target.props ?? {},
+              html: sanitized,
+              policy: patch.policy || "markdown-renderer-v2",
+              meta: patch.meta ? { ...patch.meta } : target.props?.meta
+            };
+            if (patch.block) {
+              target.block = cloneBlock(patch.block);
+              if (!target.block.payload.meta) {
+                target.block.payload.meta = {};
+              }
+              target.block.payload.sanitizedHtml = sanitized;
+              mutatedBlocks = true;
+            }
+            target.version++;
+            touched.add(target.id);
+            break;
+          }
+          default:
+            break;
+        }
+      };
+      if (perfEnabled) {
+        const loopStart = getPerfNow();
+        for (const patch of coalescedPatches) {
+          const opStart = getPerfNow();
+          applyPatch(patch);
+          const opDuration = getPerfNow() - opStart;
+          const entry = opStats[patch.op] ?? { count: 0, durationMs: 0 };
+          entry.count += 1;
+          entry.durationMs += opDuration;
+          opStats[patch.op] = entry;
+        }
+        applyMs = getPerfNow() - loopStart;
+      } else {
+        for (const patch of coalescedPatches) {
+          applyPatch(patch);
+        }
+      }
+      const finalizedTableRoots = /* @__PURE__ */ new Set();
+      for (const touchedId of touched) {
+        let cursor = nodes.get(touchedId);
+        while (cursor && cursor.id !== PATCH_ROOT_ID) {
+          if (cursor.type === "table" && cursor.block?.isFinalized && cursor.parentId) {
+            finalizedTableRoots.add(cursor.id);
+            break;
+          }
+          cursor = cursor.parentId ? nodes.get(cursor.parentId) : void 0;
+        }
+      }
+      if (finalizedTableRoots.size > 0) {
+        for (const tableId of finalizedTableRoots) {
+          const tableNode = nodes.get(tableId);
+          if (!tableNode || !tableNode.block || !tableNode.parentId) continue;
+          const parent = nodes.get(tableNode.parentId);
+          if (!parent) continue;
+          const index = parent.children.indexOf(tableNode.id);
+          if (index === -1) continue;
+          const snapshot = createBlockSnapshot(cloneBlock(tableNode.block));
+          replaceSnapshotAt(nodes, parent, index, snapshot, touched, tableNode.blockEpoch);
+          mutatedBlocks = true;
+        }
+      }
+      if (mutatedBlocks) {
+        blocksDirty = true;
+      }
+      if (listDepthDirty) {
+        if (perfEnabled) {
+          const start = getPerfNow();
+          normalizeAllListDepths(nodes, touched, PATCH_ROOT_ID);
+          listNormalizeMs = getPerfNow() - start;
+        } else {
+          normalizeAllListDepths(nodes, touched, PATCH_ROOT_ID);
+        }
+      } else if (listDepthDirtyNodes.size > 0) {
+        if (perfEnabled) {
+          const start = getPerfNow();
+          normalizeListDepthsForIds(nodes, touched, listDepthDirtyNodes, PATCH_ROOT_ID);
+          listNormalizeMs = getPerfNow() - start;
+        } else {
+          normalizeListDepthsForIds(nodes, touched, listDepthDirtyNodes, PATCH_ROOT_ID);
+        }
+      }
+      invariantViolations = [...collectStoreInvariantViolations(nodes), ...transientDiagnostics];
+      debugCounters.storeInvariantViolationCount += invariantViolations.length;
+      if (touched.size > 0 || mutatedBlocks) {
+        version++;
+        scheduleNotify();
+      }
+      if (perfEnabled) {
+        const totalMs = getPerfNow() - perfStart;
+        const coalesceMs = typeof metrics?.durationMs === "number" ? metrics.durationMs : 0;
+        recordPatchPerf({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          totalMs,
+          applyMs,
+          coalesceMs,
+          listNormalizeMs,
+          patches: patches.length,
+          coalescedPatches: coalescedPatches.length,
+          touchedCount: touched.size,
+          mutatedBlocks,
+          ops: opStats,
+          setPropsByType,
+          setPropsBySize
+        });
+      }
+      return touched;
+    },
+    getBlocks() {
+      if (!blocksDirty) {
+        return blocksCache;
+      }
+      const root = nodes.get(PATCH_ROOT_ID);
+      if (!root) {
+        blocksCache = [];
+      } else {
+        blocksCache = convertNodeToBlocks(nodes, root);
+      }
+      blocksDirty = false;
+      return blocksCache;
+    },
+    getVersion() {
+      return version;
+    },
+    getNode(id) {
+      return nodes.get(id);
+    },
+    getNodeWithVersion(id) {
+      const record = nodes.get(id);
+      if (!record) {
+        return EMPTY_NODE_SNAPSHOT;
+      }
+      const nodeSnapshotCache = getNodeSnapshotCacheForMap(nodes);
+      const cached = nodeSnapshotCache.get(id);
+      if (cached && cached.version === record.version && cached.node === record) {
+        return cached;
+      }
+      const snapshot = { version: record.version, node: record };
+      nodeSnapshotCache.set(id, snapshot);
+      pruneCache(nodeSnapshotCache, NODE_SNAPSHOT_CACHE_LIMIT, NODE_SNAPSHOT_CACHE_BUFFER);
+      return snapshot;
+    },
+    getChildren(id) {
+      const record = nodes.get(id);
+      if (!record) return EMPTY_CHILDREN;
+      return record.children;
+    },
+    getChildrenWithVersion(id) {
+      const record = nodes.get(id);
+      if (!record) {
+        return EMPTY_CHILDREN_SNAPSHOT;
+      }
+      const childrenSnapshotCache = getChildrenSnapshotCacheForMap(nodes);
+      const cached = childrenSnapshotCache.get(id);
+      if (cached && cached.version === record.version) {
+        return cached;
+      }
+      const snapshot = { version: record.version, children: record.children.slice() };
+      childrenSnapshotCache.set(id, snapshot);
+      pruneCache(childrenSnapshotCache, CHILDREN_SNAPSHOT_CACHE_LIMIT, CHILDREN_SNAPSHOT_CACHE_BUFFER);
+      return snapshot;
+    },
+    getInvariantViolations() {
+      return invariantViolations.slice();
+    },
+    getDebugCounters() {
+      return { ...debugCounters };
+    },
+    getLastCoalescingMetrics() {
+      return lastCoalescingMetrics;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+  return store;
+}
+
+// src/renderer/virtualized-code.tsx
+import { useCallback, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+var DEFAULT_VIRTUALIZED_CODE_CONFIG = {
+  enabled: true,
+  windowSize: 100,
+  // Render 100 lines at a time
+  bufferSize: 50,
+  // +50 lines buffer above/below
+  virtualizeThreshold: 200
+  // Only virtualize if 200+ lines
+};
+function calculateCodeWindow(lines, scrollTop, containerHeight, lineHeight, config) {
+  const totalLines = lines.length;
+  if (!config.enabled || totalLines < config.virtualizeThreshold) {
+    return {
+      startIndex: 0,
+      endIndex: totalLines,
+      visibleStart: 0,
+      visibleEnd: totalLines,
+      visibleLines: lines,
+      totalLines,
+      mountedLines: totalLines
+    };
+  }
+  const firstVisibleLine = Math.floor(scrollTop / lineHeight);
+  const lastVisibleLine = Math.ceil((scrollTop + containerHeight) / lineHeight);
+  const visibleStart = Math.max(0, firstVisibleLine);
+  const visibleEnd = Math.min(totalLines, Math.max(visibleStart, lastVisibleLine));
+  const startIndex = Math.max(0, visibleStart - config.bufferSize);
+  const endIndex = Math.min(totalLines, visibleEnd + config.bufferSize);
+  return {
+    startIndex,
+    endIndex,
+    visibleStart,
+    visibleEnd,
+    visibleLines: lines.slice(startIndex, endIndex),
+    totalLines,
+    mountedLines: endIndex - startIndex
+  };
+}
+function useVirtualizedCode(lines, config = DEFAULT_VIRTUALIZED_CODE_CONFIG) {
+  const containerRef = useRef(null);
+  const [scrollTop, setScrollTop] = useState2(0);
+  const [containerHeight, setContainerHeight] = useState2(0);
+  const lineHeightRef = useRef(20);
+  useEffect2(() => {
+    if (!containerRef.current || lines.length === 0) return;
+    const timeoutId = setTimeout(() => {
+      if (!containerRef.current) return;
+      const firstLine = containerRef.current.querySelector(".line");
+      if (firstLine) {
+        const measuredHeight = firstLine.offsetHeight || 20;
+        if (measuredHeight !== lineHeightRef.current) {
+          lineHeightRef.current = measuredHeight;
+        }
+      }
+    }, 0);
+    return () => clearTimeout(timeoutId);
+  }, [lines.length]);
+  const handleScroll = useCallback((e) => {
+    const target = e.currentTarget;
+    setScrollTop(target.scrollTop);
+    setContainerHeight(target.clientHeight);
+  }, []);
+  useEffect2(() => {
+    if (!containerRef.current) return;
+    const resizeObserver = new ResizeObserver((entries2) => {
+      for (const entry of entries2) {
+        setContainerHeight(entry.contentRect.height);
+      }
+    });
+    resizeObserver.observe(containerRef.current);
+    return () => resizeObserver.disconnect();
+  }, []);
+  const window2 = useMemo2(() => {
+    return calculateCodeWindow(lines, scrollTop, containerHeight, lineHeightRef.current, config);
+  }, [lines, scrollTop, containerHeight, config]);
+  const scrollToLine = useCallback((lineIndex) => {
+    if (!containerRef.current) return;
+    const targetScrollTop = lineIndex * lineHeightRef.current;
+    containerRef.current.scrollTop = targetScrollTop;
+    setScrollTop(targetScrollTop);
+  }, []);
+  return {
+    containerRef,
+    window: window2,
+    handleScroll,
+    scrollToLine,
+    lineHeight: lineHeightRef.current,
+    config
+  };
+}
+
+// src/renderer/node-views.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var BlockNodeRenderer = ({ store, blockId, registry }) => {
+  const node = useRendererNode(store, blockId);
+  const block = node?.block;
+  if (!node || !block) return null;
+  switch (block.type) {
+    case "paragraph":
+      return /* @__PURE__ */ jsx(ParagraphBlockView, { store, blockId: block.id, registry });
+    case "blockquote":
+      return /* @__PURE__ */ jsx(BlockquoteBlockView, { store, blockId: block.id, registry });
+    case "list":
+      return /* @__PURE__ */ jsx(ListBlockView, { store, blockId: block.id, registry, depth: 0 });
+    case "table":
+      return /* @__PURE__ */ jsx(TableBlockView, { store, blockId: block.id, registry });
+    case "code":
+      return /* @__PURE__ */ jsx(CodeBlockView, { store, blockId: block.id, registry });
+    case "html":
+      return /* @__PURE__ */ jsx(HtmlBlockView, { store, blockId: block.id, registry });
+    case "mdx":
+      return /* @__PURE__ */ jsx(MdxBlockView, { store, blockId: block.id, registry });
+    default:
+      return registry.renderBlock(block);
+  }
+};
+var ParagraphBlockView = React7.memo(({ store, blockId, registry }) => {
+  const node = useRendererNode(store, blockId);
+  const block = node?.block;
+  const childIds = useRendererChildren(store, blockId);
+  if (!node || !block) {
+    return null;
+  }
+  const inlineComponents = registry.getInlineComponents();
+  if (!block.isFinalized) {
+    const raw = typeof block.payload.raw === "string" ? block.payload.raw : "";
+    const meta = block.payload.meta ?? {};
+    const segments2 = Array.isArray(meta.mixedSegments) ? meta.mixedSegments : [];
+    if (segments2.length > 0) {
+      const allowMixedStreaming = Boolean(meta.allowMixedStreaming);
+      if (!allowMixedStreaming) {
+        return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph streaming-partial", children: raw });
+      }
+      const structured = renderParagraphMixedSegments(segments2, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
+      if (structured.length === 1) {
+        const [single] = structured;
+        return React7.isValidElement(single) ? single : single;
+      }
+      return structured;
+    }
+    if (meta.inlineStatus === "complete" || meta.inlineStatus === "anticipated") {
+      const inlineNodes2 = block.payload.inline ?? [];
+      const containsDisplayMath2 = inlineNodes2.some((node2) => node2.kind === "math-display");
+      if (containsDisplayMath2) {
+        const derivedSegments = [
+          {
+            kind: "text",
+            value: raw,
+            inline: inlineNodes2
+          }
+        ];
+        const structured = renderParagraphMixedSegments(derivedSegments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
+        if (structured.length === 1) {
+          const [single] = structured;
+          return React7.isValidElement(single) ? single : single;
+        }
+        return structured;
+      }
+      return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph streaming-partial", children: renderInlineNodes(inlineNodes2, inlineComponents) });
+    }
+    return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph streaming-partial", children: raw });
+  }
+  const propsBlock = node.props?.block;
+  const inlineStatus = propsBlock?.payload?.meta?.inlineStatus ?? block.payload.meta?.inlineStatus ?? node.props?.inlineStatus;
+  if (inlineStatus && inlineStatus !== "complete") {
+    const raw = typeof block.payload.raw === "string" ? block.payload.raw : "";
+    return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph", children: raw });
+  }
+  const segments = Array.isArray(block.payload.meta?.mixedSegments) ? block.payload.meta.mixedSegments : void 0;
+  if (segments && segments.length > 0) {
+    const structured = renderParagraphMixedSegments(segments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
+    if (structured.length === 1) {
+      const [single] = structured;
+      return React7.isValidElement(single) ? single : single;
+    }
+    return structured;
+  }
+  const inlineNodes = block.payload.inline ?? [];
+  const containsDisplayMath = inlineNodes.some((node2) => node2.kind === "math-display");
+  if (containsDisplayMath) {
+    const derivedSegments = [
+      {
+        kind: "text",
+        value: typeof block.payload.raw === "string" ? block.payload.raw : "",
+        inline: inlineNodes
+      }
+    ];
+    const structured = renderParagraphMixedSegments(derivedSegments, inlineComponents, DEFAULT_INLINE_HTML_RENDERERS);
+    if (structured.length === 1) {
+      const [single] = structured;
+      return React7.isValidElement(single) ? single : single;
+    }
+    return structured;
+  }
+  const ParagraphComponent = registry.getBlockComponent("paragraph");
+  const baseElement = React7.createElement(ParagraphComponent, {
+    inlines: block.payload.inline ?? [],
+    raw: block.payload.raw,
+    meta: block.payload.meta
+  });
+  if (childIds.length > 0) {
+    const renderedChildren = childIds.map((childId) => /* @__PURE__ */ jsx(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
+    if (React7.isValidElement(baseElement)) {
+      const { children: _ignored, className = "markdown-paragraph", inlines: _inlines, raw: _raw, meta: _meta, ...rest } = baseElement.props ?? {};
+      return React7.createElement("p", { ...rest, className }, renderedChildren);
+    }
+    return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph", children: renderedChildren });
+  }
+  if (React7.isValidElement(baseElement)) {
+    return baseElement;
+  }
+  return /* @__PURE__ */ jsx("p", { className: "markdown-paragraph", children: renderInlineNodes(block.payload.inline ?? [], inlineComponents) });
+});
+ParagraphBlockView.displayName = "ParagraphBlockView";
+var BlockquoteBlockView = React7.memo(({ store, blockId, registry }) => {
+  const node = useRendererNode(store, blockId);
+  const block = node?.block;
+  const childIds = useRendererChildren(store, blockId);
+  if (!node || !block) {
+    return null;
+  }
+  const meta = block.payload.meta ?? {};
+  const mixedSegments = Array.isArray(meta.mixedSegments) ? meta.mixedSegments : [];
+  const normalizedText = typeof meta.normalizedText === "string" && meta.normalizedText.length > 0 ? meta.normalizedText : typeof block.payload.raw === "string" ? block.payload.raw : "";
+  const inlineComponents = registry.getInlineComponents();
+  const renderTextWithBreaks = (text, keyPrefix) => {
+    const lines = text.split("\n");
+    const lastIndex = lines.length - 1;
+    let offset = 0;
+    return lines.map((line, idx) => {
+      const key = `${keyPrefix}${offset}`;
+      offset += line.length + 1;
+      return /* @__PURE__ */ jsxs("span", { className: "markdown-blockquote-line", children: [
+        line,
+        idx < lastIndex ? /* @__PURE__ */ jsx("br", {}) : null
+      ] }, key);
+    });
+  };
+  const renderInlineContent = (inline, keyPrefix) => {
+    if (inline && inline.length > 0) {
+      return renderInlineNodes(inline, inlineComponents);
+    }
+    return null;
+  };
+  const renderMixedSegments = () => {
+    if (!mixedSegments.length) {
+      return [];
+    }
+    const elements = [];
+    mixedSegments.forEach((segment, segmentIndex) => {
+      switch (segment.kind) {
+        case "html": {
+          const htmlNode = renderInlineHtmlSegment(segment.value, segment.sanitized ?? segment.value, {
+            key: `blockquote-html-${block.id}-${segmentIndex}`,
+            renderers: DEFAULT_INLINE_HTML_RENDERERS
+          });
+          if (htmlNode) {
+            elements.push(htmlNode);
+          } else {
+            elements.push(
+              React7.createElement("span", {
+                key: `blockquote-html-${block.id}-${segmentIndex}`,
+                className: "markdown-inline-html",
+                /* biome-ignore lint/security/noDangerouslySetInnerHtml: segment content is sanitized by the worker before streaming */
+                dangerouslySetInnerHTML: { __html: segment.sanitized ?? segment.value }
+              })
+            );
+          }
+          break;
+        }
+        case "mdx":
+          elements.push(
+            /* @__PURE__ */ jsx("span", { "data-mdx-status": segment.status ?? "pending", children: segment.value }, `blockquote-mdx-${block.id}-${segmentIndex}`)
+          );
+          break;
+        default: {
+          const inline = renderInlineContent(segment.inline, `blockquote-text-inline-${block.id}-${segmentIndex}-`);
+          if (inline) {
+            elements.push(/* @__PURE__ */ jsx(React7.Fragment, { children: inline }, `blockquote-inline-${block.id}-${segmentIndex}`));
+          } else {
+            elements.push(
+              /* @__PURE__ */ jsx(React7.Fragment, { children: renderTextWithBreaks(segment.value, `blockquote-text-${block.id}-${segmentIndex}-`) }, `blockquote-text-${block.id}-${segmentIndex}`)
+            );
+          }
+          break;
+        }
+      }
+    });
+    return elements;
+  };
+  const mixedSegmentElements = renderMixedSegments();
+  const fallbackElements = normalizedText ? renderTextWithBreaks(normalizedText, `blockquote-fallback-${block.id}-`) : null;
+  const inlineNodes = block.payload.inline ?? [];
+  const inlineElements = inlineNodes.length > 0 ? renderInlineNodes(inlineNodes, inlineComponents) : null;
+  if (!block.isFinalized) {
+    const streamingContent = mixedSegmentElements.length ? mixedSegmentElements : inlineElements ? inlineElements : fallbackElements;
+    const shouldShowStreaming = !block.isFinalized && (!streamingContent || Array.isArray(streamingContent) && streamingContent.length === 0);
+    const className = shouldShowStreaming ? "markdown-blockquote streaming-partial" : "markdown-blockquote";
+    return /* @__PURE__ */ jsx("blockquote", { className, children: streamingContent });
+  }
+  const childContent = childIds.map((childId) => /* @__PURE__ */ jsx(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
+  const renderedContent = (() => {
+    if (mixedSegmentElements.length > 0) {
+      return mixedSegmentElements;
+    }
+    if (childIds.length > 0) {
+      const resolved = childContent.filter((child) => child !== null);
+      if (resolved.length > 0) {
+        return resolved;
+      }
+    }
+    if (inlineElements) {
+      return inlineElements;
+    }
+    if (fallbackElements && fallbackElements.length > 0) {
+      return fallbackElements;
+    }
+    return null;
+  })();
+  const BlockquoteComponent = registry.getBlockComponent("blockquote");
+  const baseElement = React7.createElement(
+    BlockquoteComponent,
+    {
+      inlines: block.payload.inline ?? [],
+      renderedContent
+    },
+    renderedContent
+  );
+  if (React7.isValidElement(baseElement)) {
+    return baseElement;
+  }
+  return /* @__PURE__ */ jsx("blockquote", { className: "markdown-blockquote", children: renderedContent });
+});
+BlockquoteBlockView.displayName = "BlockquoteBlockView";
+var MixedSegmentView = React7.memo(({ store, nodeId, inlineComponents }) => {
+  const node = useRendererNode(store, nodeId);
+  if (!node) return null;
+  switch (node.type) {
+    case "paragraph-text":
+    case "blockquote-text":
+    case "list-item-text": {
+      const inline = node.props?.inline ?? [];
+      if (inline.length > 0) {
+        return renderInlineNodes(inline, inlineComponents);
+      }
+      const text = typeof node.props?.text === "string" ? node.props?.text : "";
+      if (!text) return null;
+      return text;
+    }
+    case "paragraph-html":
+    case "blockquote-html":
+    case "list-item-html": {
+      const raw = typeof node.props?.raw === "string" ? node.props.raw : void 0;
+      const html = typeof node.props?.html === "string" ? node.props?.html : "";
+      const rendered = renderInlineHtmlSegment(raw, html, {
+        key: node.id,
+        renderers: DEFAULT_INLINE_HTML_RENDERERS
+      });
+      if (rendered) {
+        return rendered;
+      }
+      if (!html) return null;
+      return React7.createElement("span", {
+        className: "markdown-inline-html",
+        /* biome-ignore lint/security/noDangerouslySetInnerHtml: html is sanitized upstream before reaching the renderer */
+        dangerouslySetInnerHTML: { __html: html }
+      });
+    }
+    case "paragraph-mdx":
+    case "blockquote-mdx":
+    case "list-item-mdx": {
+      const status = node.props?.status ?? "pending";
+      const raw = typeof node.props?.raw === "string" ? node.props?.raw : "";
+      if (status === "compiled") {
+        return /* @__PURE__ */ jsx("span", { className: "markdown-mdx-inline", "data-mdx-status": "compiled" });
+      }
+      if (status === "error") {
+        const message = raw || "MDX error";
+        return /* @__PURE__ */ jsx("span", { className: "markdown-mdx-inline text-destructive", "data-mdx-status": "error", children: message });
+      }
+      return /* @__PURE__ */ jsx("span", { className: "markdown-mdx-inline", "data-mdx-status": status, children: status === "compiled" ? "" : raw });
+    }
+    default:
+      return null;
+  }
+});
+MixedSegmentView.displayName = "MixedSegmentView";
+var HtmlBlockView = React7.memo(({ store, blockId, registry }) => {
+  const node = useRendererNode(store, blockId);
+  if (!node || !node.block) return null;
+  return registry.renderBlock(node.block);
+});
+HtmlBlockView.displayName = "HtmlBlockView";
+var MdxBlockView = React7.memo(({ store, blockId, registry }) => {
+  const node = useRendererNode(store, blockId);
+  if (!node || !node.block) return null;
+  return registry.renderBlock(node.block);
+});
+MdxBlockView.displayName = "MdxBlockView";
+var ListBlockView = React7.memo(
+  ({ store, blockId, registry, depth = 0 }) => {
+    const node = useRendererNode(store, blockId);
+    const block = node?.block;
+    const childIds = useRendererChildren(store, blockId);
+    const inlineComponents = registry.getInlineComponents();
+    const ordered = Boolean(node?.props?.ordered ?? block?.payload.meta?.ordered);
+    const Tag = ordered ? "ol" : "ul";
+    const listDebugEnabled = isListPatchDebugEnabled();
+    const listItemIds = React7.useMemo(() => {
+      const ids = [];
+      for (const childId of childIds) {
+        const childNode = store.getNode(childId);
+        if (childNode?.type === "list-item") {
+          ids.push(childId);
+        }
+      }
+      return ids;
+    }, [childIds, store]);
+    React7.useEffect(() => {
+      if (!listDebugEnabled) return;
+      const childTypes = childIds.map((childId) => store.getNode(childId)?.type ?? "missing");
+      console.info("[stream-mdx:list-render]", {
+        listId: blockId,
+        depth,
+        ordered,
+        childIds,
+        childTypes,
+        listItemIds,
+        listItems: listItemIds.length,
+        totalChildren: childIds.length,
+        isFinalized: block?.isFinalized ?? false
+      });
+    }, [listDebugEnabled, blockId, depth, ordered, childIds, listItemIds, store, block?.isFinalized]);
+    const { listStyle, markerDigits } = React7.useMemo(() => {
+      if (!ordered || listItemIds.length === 0) {
+        return { listStyle: void 0, markerDigits: 1 };
+      }
+      let maxDigits = 1;
+      listItemIds.forEach((childId, index) => {
+        const childNode = store.getNode(childId);
+        const raw = typeof childNode?.block?.payload?.raw === "string" ? childNode.block.payload.raw : void 0;
+        const markerMatch = raw ? raw.match(/^([^\s]+)\s+/) : null;
+        const marker = markerMatch?.[1]?.trim();
+        const text = marker ?? `${index + 1}.`;
+        const digitMatch = text.match(/\d/g);
+        const digits = digitMatch ? digitMatch.length : text.length;
+        if (digits > maxDigits) maxDigits = digits;
+      });
+      const baseIndent = depth === 0 ? "2rem" : depth === 1 ? "1.75rem" : "1.5rem";
+      const extraDigits = Math.max(0, maxDigits - 1);
+      return {
+        markerDigits: maxDigits,
+        listStyle: {
+          ["--list-indent"]: extraDigits > 0 ? `calc(${baseIndent} + ${extraDigits}ch)` : baseIndent,
+          ["--list-marker-digits"]: String(maxDigits)
+        }
+      };
+    }, [ordered, listItemIds, store, depth]);
+    if (listItemIds.length === 0) return null;
+    return /* @__PURE__ */ jsx(
+      Tag,
+      {
+        className: `markdown-list ${ordered ? "ordered" : "unordered"}`,
+        "data-list-depth": depth,
+        "data-marker-digits": ordered ? markerDigits : void 0,
+        "data-list-id": listDebugEnabled ? blockId : void 0,
+        style: listStyle,
+        children: listItemIds.map((childId, index) => /* @__PURE__ */ jsx(
+          ListItemView,
+          {
+            store,
+            nodeId: childId,
+            inlineComponents,
+            registry,
+            ordered,
+            index,
+            depth
+          },
+          childId
+        ))
+      }
+    );
+  }
+);
+ListBlockView.displayName = "ListBlockView";
+var ListItemView = React7.memo(({ store, nodeId, inlineComponents, registry, ordered, index, depth }) => {
+  const node = useRendererNode(store, nodeId);
+  const childIds = useRendererChildren(store, nodeId);
+  const inline = node?.props?.inline ?? [];
+  const isTask = Boolean(node?.props?.task);
+  const isChecked = Boolean(node?.props?.checked);
+  const block = node?.block;
+  const raw = typeof block?.payload?.raw === "string" ? block.payload.raw : void 0;
+  const markerMatch = raw ? raw.match(/^([^\s]+)\s+/) : null;
+  const marker = markerMatch?.[1]?.trim();
+  const inferredIndex = typeof node?.props?.index === "number" ? Number(node?.props?.index) : index;
+  const isOrdered = Boolean(node?.props?.ordered ?? ordered);
+  const counterText = !isTask ? isOrdered ? marker ? marker : `${inferredIndex + 1}.` : "\u2022" : void 0;
+  const listDebugEnabled = isListPatchDebugEnabled();
+  const inlineLength = inline.length;
+  const [segmentChildIds, contentChildIds] = React7.useMemo(() => {
+    const segments = [];
+    const structural = [];
+    for (const childId of childIds) {
+      const childNode = store.getNode(childId);
+      if (!childNode) continue;
+      if (childNode.type?.startsWith("list-item-")) {
+        segments.push(childId);
+      } else {
+        structural.push(childId);
+      }
+    }
+    return [segments, structural];
+  }, [childIds, store]);
+  const segmentElements = React7.useMemo(() => {
+    return segmentChildIds.map((childId) => /* @__PURE__ */ jsx(MixedSegmentView, { store, nodeId: childId, inlineComponents }, childId));
+  }, [segmentChildIds, store, inlineComponents]);
+  const primaryContent = React7.useMemo(() => {
+    if (segmentChildIds.length > 0) {
+      return segmentElements;
+    }
+    return renderInlineNodes(inline, inlineComponents);
+  }, [segmentChildIds, segmentElements, inline, inlineComponents]);
+  const trailingChildren = React7.useMemo(() => {
+    return contentChildIds.map((childId) => {
+      const childNode = store.getNode(childId);
+      if (!childNode) return null;
+      switch (childNode.type) {
+        case "paragraph": {
+          const childInline = childNode.props?.inline ?? [];
+          return /* @__PURE__ */ jsx("p", { className: "markdown-list-item-paragraph", children: renderInlineNodes(childInline, inlineComponents) }, childId);
+        }
+        case "list":
+          return /* @__PURE__ */ jsx(ListBlockView, { store, blockId: childId, registry, depth: depth + 1 }, childId);
+        default:
+          return /* @__PURE__ */ jsx(BlockNodeRenderer, { store, blockId: childId, registry }, childId);
+      }
+    });
+  }, [contentChildIds, store, inlineComponents, registry, depth]);
+  const filteredChildren = trailingChildren.filter((child) => Boolean(child));
+  const hasChildren = filteredChildren.length > 0;
+  React7.useEffect(() => {
+    if (!listDebugEnabled) return;
+    const childTypes = childIds.map((childId) => store.getNode(childId)?.type ?? "missing");
+    console.info("[stream-mdx:list-item-render]", {
+      itemId: nodeId,
+      depth,
+      ordered: isOrdered,
+      inferredIndex,
+      marker,
+      isTask,
+      isChecked,
+      childIds,
+      childTypes,
+      segmentChildIds,
+      contentChildIds,
+      inlineLength,
+      hasChildren,
+      isFinalized: block?.isFinalized ?? false
+    });
+  }, [
+    listDebugEnabled,
+    nodeId,
+    depth,
+    isOrdered,
+    inferredIndex,
+    marker,
+    isTask,
+    isChecked,
+    childIds,
+    segmentChildIds,
+    contentChildIds,
+    inlineLength,
+    hasChildren,
+    store,
+    block?.isFinalized
+  ]);
+  return /* @__PURE__ */ jsxs(
+    "li",
+    {
+      className: `markdown-list-item${isTask ? " markdown-list-item-task" : ""}`,
+      "data-counter-text": counterText,
+      "data-list-depth": depth,
+      "data-list-item-id": listDebugEnabled ? nodeId : void 0,
+      children: [
+        isTask ? /* @__PURE__ */ jsxs("div", { className: "markdown-task", children: [
+          /* @__PURE__ */ jsx("input", { type: "checkbox", className: "markdown-task-checkbox", checked: isChecked, readOnly: true, disabled: true, tabIndex: -1, "aria-checked": isChecked }),
+          /* @__PURE__ */ jsx("span", { className: "markdown-task-content", children: primaryContent })
+        ] }) : primaryContent,
+        hasChildren ? /* @__PURE__ */ jsx("div", { className: "markdown-list-item-children", children: filteredChildren }) : null
+      ]
+    }
+  );
+});
+ListItemView.displayName = "ListItemView";
+var TableBlockView = React7.memo(({ store, blockId, registry }) => {
+  const tableElements = registry.getTableElements();
+  const childIds = useRendererChildren(store, blockId);
+  return /* @__PURE__ */ jsx(tableElements.Table, { className: "markdown-table w-full caption-bottom text-base", children: childIds.map((sectionId) => /* @__PURE__ */ jsx(TableSectionView, { store, nodeId: sectionId, registry }, sectionId)) });
+});
+TableBlockView.displayName = "TableBlockView";
+var TableSectionView = React7.memo(({ store, nodeId, registry }) => {
+  const node = useRendererNode(store, nodeId);
+  if (!node) return null;
+  const tableElements = registry.getTableElements();
+  if (node.type === "table-header") {
+    const childIds = useRendererChildren(store, nodeId);
+    return /* @__PURE__ */ jsx(tableElements.Thead, { children: /* @__PURE__ */ jsx(tableElements.Tr, { children: childIds.map((cellId) => /* @__PURE__ */ jsx(TableCellView, { store, nodeId: cellId, registry }, cellId)) }) });
+  }
+  if (node.type === "table-body") {
+    const rowIds = useRendererChildren(store, nodeId);
+    return /* @__PURE__ */ jsx(tableElements.Tbody, { children: rowIds.map((rowId) => /* @__PURE__ */ jsx(TableRowView, { store, nodeId: rowId, registry }, rowId)) });
+  }
+  return null;
+});
+TableSectionView.displayName = "TableSectionView";
+var TableRowView = React7.memo(({ store, nodeId, registry }) => {
+  const tableElements = registry.getTableElements();
+  const cellIds = useRendererChildren(store, nodeId);
+  return /* @__PURE__ */ jsx(tableElements.Tr, { children: cellIds.map((cellId) => /* @__PURE__ */ jsx(TableCellView, { store, nodeId: cellId, registry }, cellId)) });
+});
+TableRowView.displayName = "TableRowView";
+var TableCellView = React7.memo(({ store, nodeId, registry }) => {
+  const node = useRendererNode(store, nodeId);
+  const inlineComponents = registry.getInlineComponents();
+  const tableElements = registry.getTableElements();
+  if (!node) return null;
+  const Tag = node.type === "table-header-cell" ? tableElements.Th : tableElements.Td;
+  const inline = node.props?.inline ?? [];
+  const align = node.props?.align;
+  const content = renderInlineNodes(inline, inlineComponents);
+  const alignProps = align ? { align } : void 0;
+  return /* @__PURE__ */ jsx(Tag, { ...alignProps, children: content });
+});
+TableCellView.displayName = "TableCellView";
+var CodeBlockView = React7.memo(({ store, blockId, registry }) => {
+  const node = useRendererNode(store, blockId);
+  const childIds = useRendererChildren(store, blockId);
+  const CodeComponent = registry.getBlockComponent("code");
+  const deferredConfig = React7.useContext(DeferredRenderContext);
+  const deferredRef = React7.useRef(null);
+  const shouldRenderDeferred = useDeferredRender(
+    deferredRef,
+    deferredConfig ? { ...deferredConfig, enabled: true } : { enabled: false }
+  );
+  if (!node || !node.block) return null;
+  const blockIsFinalized = node.block.isFinalized;
+  const nodeVersion = node.version;
+  const lines = React7.useMemo(() => {
+    const seenIds = /* @__PURE__ */ new Set();
+    const seenIndices = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const childId of childIds) {
+      const child = store.getNode(childId);
+      if (!child) continue;
+      const index = typeof child.props?.index === "number" ? child.props?.index : deduped.length;
+      const text = typeof child.props?.text === "string" ? child.props?.text : "";
+      const html = typeof child.props?.html === "string" ? child.props?.html : null;
+      const tokens = Object.prototype.hasOwnProperty.call(child.props ?? {}, "tokens") ? child.props?.tokens : void 0;
+      if (seenIds.has(child.id) || seenIndices.has(index)) {
+        console.warn("[renderer-view] duplicate code line detected", {
+          blockId,
+          childId: child.id,
+          index
+        });
+        continue;
+      }
+      seenIds.add(child.id);
+      seenIndices.add(index);
+      deduped.push({ id: child.id, index, text, html, tokens });
+    }
+    deduped.sort((a, b) => a.index - b.index);
+    return deduped;
+  }, [childIds, store, blockId, nodeVersion]);
+  const lang = typeof node.props?.lang === "string" ? node.props?.lang : node.block.payload.meta?.lang;
+  const preAttrs = node.props?.preAttrs ?? void 0;
+  const codeAttrs = node.props?.codeAttrs ?? void 0;
+  const blockMeta = node.block.payload.meta ?? void 0;
+  const lazyEnabled = Boolean(blockMeta?.lazyTokenization);
+  const lazyTokenizedUntil = typeof blockMeta?.lazyTokenizedUntil === "number" ? blockMeta.lazyTokenizedUntil : 0;
+  const lazyHighlightedLines = Array.isArray(blockMeta?.highlightedLines) ? blockMeta.highlightedLines.length : 0;
+  const lazyTokenLines = Array.isArray(blockMeta?.tokenLines) ? blockMeta.tokenLines.length : 0;
+  const lazySourceTextLineCount = React7.useMemo(() => {
+    const raw = typeof node.block?.payload.raw === "string" ? node.block.payload.raw : "";
+    const metaCode = typeof blockMeta?.code === "string" ? blockMeta.code : null;
+    const sourceText = resolveCodeSourceText(raw, metaCode);
+    if (sourceText.length === 0) return 0;
+    return sourceText.split("\n").length;
+  }, [blockMeta, node.block?.payload.raw]);
+  const totalLazyLineCount = Math.max(lines.length, lazyHighlightedLines, lazyTokenLines, lazySourceTextLineCount);
+  const virtualizationConfig = DEFAULT_VIRTUALIZED_CODE_CONFIG;
+  const virtualizationDisabled = typeof process !== "undefined" && typeof process.env === "object" && process.env.STREAM_MDX_DISABLE_VIRTUALIZED_CODE === "true";
+  const canVirtualize = node.block.isFinalized && !lazyEnabled;
+  const shouldVirtualize = canVirtualize && !virtualizationDisabled && virtualizationConfig.enabled && lines.length >= virtualizationConfig.virtualizeThreshold;
+  const virtualization = useVirtualizedCode(lines, shouldVirtualize ? virtualizationConfig : { ...virtualizationConfig, enabled: false });
+  const highlightRequester = useCodeHighlightRequester();
+  const lastRangeRef = React7.useRef(null);
+  const rafRef = React7.useRef(null);
+  const idleRef = React7.useRef(null);
+  React7.useEffect(() => {
+    if (!shouldVirtualize || !lazyEnabled || !highlightRequester) return;
+    const { visibleStart, visibleEnd, startIndex, endIndex } = virtualization.window;
+    if (endIndex <= lazyTokenizedUntil) return;
+    const nextRange = {
+      visibleStart,
+      visibleEnd,
+      prefetchStart: startIndex,
+      prefetchEnd: endIndex,
+      tokenizedUntil: lazyTokenizedUntil
+    };
+    const last = lastRangeRef.current;
+    if (last && last.visibleStart === nextRange.visibleStart && last.visibleEnd === nextRange.visibleEnd && last.prefetchStart === nextRange.prefetchStart && last.prefetchEnd === nextRange.prefetchEnd && last.tokenizedUntil === nextRange.tokenizedUntil) {
+      return;
+    }
+    lastRangeRef.current = nextRange;
+    if (rafRef.current !== null && typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(rafRef.current);
+    }
+    if (typeof requestAnimationFrame === "function") {
+      rafRef.current = requestAnimationFrame(() => {
+        highlightRequester({
+          blockId,
+          startLine: visibleStart,
+          endLine: visibleEnd,
+          priority: "visible",
+          reason: "scroll"
+        });
+        rafRef.current = null;
+      });
+    } else {
+      highlightRequester({
+        blockId,
+        startLine: visibleStart,
+        endLine: visibleEnd,
+        priority: "visible",
+        reason: "scroll"
+      });
+    }
+    const prefetchNeeded = startIndex < visibleStart || endIndex > visibleEnd;
+    if (prefetchNeeded) {
+      const idleCallback = globalThis.requestIdleCallback;
+      const cancelIdle = globalThis.cancelIdleCallback;
+      if (idleRef.current !== null) {
+        if (typeof cancelIdle === "function") {
+          cancelIdle(idleRef.current);
+        } else if (typeof clearTimeout === "function") {
+          clearTimeout(idleRef.current);
+        }
+      }
+      const schedule = () => {
+        highlightRequester({
+          blockId,
+          startLine: startIndex,
+          endLine: endIndex,
+          priority: "prefetch",
+          reason: "buffer"
+        });
+        idleRef.current = null;
+      };
+      if (typeof idleCallback === "function") {
+        idleRef.current = idleCallback(() => schedule());
+      } else if (typeof setTimeout === "function") {
+        idleRef.current = setTimeout(schedule, 80);
+      }
+    }
+  }, [
+    blockId,
+    highlightRequester,
+    lazyEnabled,
+    lazyTokenizedUntil,
+    shouldVirtualize,
+    virtualization.window.visibleStart,
+    virtualization.window.visibleEnd,
+    virtualization.window.startIndex,
+    virtualization.window.endIndex
+  ]);
+  React7.useEffect(() => {
+    if (shouldVirtualize || !blockIsFinalized || !lazyEnabled || !highlightRequester) return;
+    if (totalLazyLineCount <= 0 || lazyTokenizedUntil >= totalLazyLineCount) return;
+    const nextRange = {
+      visibleStart: 0,
+      visibleEnd: totalLazyLineCount,
+      prefetchStart: 0,
+      prefetchEnd: totalLazyLineCount,
+      tokenizedUntil: lazyTokenizedUntil
+    };
+    const last = lastRangeRef.current;
+    if (last && last.visibleStart === nextRange.visibleStart && last.visibleEnd === nextRange.visibleEnd && last.prefetchStart === nextRange.prefetchStart && last.prefetchEnd === nextRange.prefetchEnd && last.tokenizedUntil === nextRange.tokenizedUntil) {
+      return;
+    }
+    lastRangeRef.current = nextRange;
+    if (rafRef.current !== null && typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(rafRef.current);
+    }
+    const requestFullHighlight = () => {
+      highlightRequester({
+        blockId,
+        startLine: 0,
+        endLine: totalLazyLineCount,
+        priority: "visible",
+        reason: "finalize-full"
+      });
+      rafRef.current = null;
+    };
+    if (typeof requestAnimationFrame === "function") {
+      rafRef.current = requestAnimationFrame(requestFullHighlight);
+    } else {
+      requestFullHighlight();
+    }
+  }, [blockId, blockIsFinalized, highlightRequester, lazyEnabled, lazyTokenizedUntil, shouldVirtualize, totalLazyLineCount]);
+  const highlightedHtml = React7.useMemo(() => {
+    const blockHtml = node.block?.payload.highlightedHtml ?? "";
+    const raw = typeof node.block?.payload.raw === "string" ? node.block.payload.raw : "";
+    const metaCode = typeof node.block?.payload.meta?.code === "string" ? (node.block?.payload.meta).code : null;
+    const sourceText = resolveCodeSourceText(raw, metaCode);
+    const sourceEndsWithNewline = sourceText.endsWith("\n");
+    const sourceLines = sourceText.length > 0 ? sourceText.split("\n") : [];
+    const rawFallbackLines = buildCodeFallbackLines(raw);
+    const deterministicWrapperAttrs = getDefaultCodeWrapperAttributes2(lang);
+    const composedPreAttrs = deterministicWrapperAttrs.preAttrs;
+    const composedCodeAttrs = deterministicWrapperAttrs.codeAttrs;
+    const shouldAppendTerminalNewline = (renderedLines) => {
+      if (!sourceEndsWithNewline || renderedLines.length === 0 || lines.length === 0) {
+        return false;
+      }
+      const lastRendered = renderedLines[renderedLines.length - 1];
+      const lastKnown = lines[lines.length - 1];
+      if (!lastRendered || !lastKnown || lastRendered.index !== lastKnown.index || lastRendered.text === "") {
+        return false;
+      }
+      const expectedRenderedLineCount = Math.max(0, sourceLines.length - 1);
+      const expectedLastRenderedLine = sourceLines.length >= 2 ? sourceLines[sourceLines.length - 2] ?? "" : "";
+      return renderedLines.length === expectedRenderedLineCount && lastRendered.text === expectedLastRenderedLine;
+    };
+    if (lines.length > 0) {
+      const hasLineHtml = lines.some((line) => typeof line.html === "string" && line.html.length > 0);
+      if (!hasLineHtml && blockHtml) {
+        return blockHtml;
+      }
+      if (shouldVirtualize) {
+        return composeHighlightedHtml(
+          virtualization.window.visibleLines,
+          composedPreAttrs,
+          composedCodeAttrs,
+          shouldAppendTerminalNewline(virtualization.window.visibleLines)
+        );
+      }
+      return composeHighlightedHtml(lines, composedPreAttrs, composedCodeAttrs, shouldAppendTerminalNewline(lines));
+    }
+    if (!shouldVirtualize && blockHtml) {
+      const hasHighlightedLines = blockHtml.includes('class="line"');
+      if (!hasHighlightedLines && rawFallbackLines.length > 0) {
+        return composeHighlightedHtml(
+          rawFallbackLines,
+          composedPreAttrs,
+          composedCodeAttrs,
+          sourceEndsWithNewline && rawFallbackLines[rawFallbackLines.length - 1]?.text !== ""
+        );
+      }
+      return blockHtml;
+    }
+    if (blockHtml?.trim().match(/^```[\w-]*\s*$/)) {
+      if (rawFallbackLines.length > 0) {
+        return composeHighlightedHtml(
+          rawFallbackLines,
+          composedPreAttrs,
+          composedCodeAttrs,
+          sourceEndsWithNewline && rawFallbackLines[rawFallbackLines.length - 1]?.text !== ""
+        );
+      }
+    }
+    if (!blockHtml && rawFallbackLines.length > 0) {
+      return composeHighlightedHtml(
+        rawFallbackLines,
+        composedPreAttrs,
+        composedCodeAttrs,
+        sourceEndsWithNewline && rawFallbackLines[rawFallbackLines.length - 1]?.text !== ""
+      );
+    }
+    return blockHtml;
+  }, [blockIsFinalized, shouldVirtualize, node.block?.payload.highlightedHtml, node.block?.payload.meta, lines, lang, virtualization.window.visibleLines, node.block?.payload.raw]);
+  const rendered = /* @__PURE__ */ jsx(
+    CodeComponent,
+    {
+      html: highlightedHtml,
+      meta: node.block.payload.meta,
+      lines: shouldVirtualize ? virtualization.window.visibleLines : lines,
+      lang,
+      preAttrs,
+      codeAttrs
+    }
+  );
+  const effectiveLineCount = React7.useMemo(() => {
+    if (lines.length > 0) {
+      return lines.length;
+    }
+    return 1;
+  }, [lines.length]);
+  const codeFrameClass = "not-prose flex flex-col rounded-lg border border-input pt-1 font-mono text-sm";
+  const codeMetricsAttrs = {
+    "data-code-block": "true",
+    "data-block-id": blockId,
+    "data-code-virtualized": shouldVirtualize ? "true" : "false",
+    "data-code-total-lines": String(effectiveLineCount),
+    "data-code-mounted-lines": String(shouldVirtualize ? virtualization.window.mountedLines : effectiveLineCount),
+    "data-code-window-size": String(virtualization.config.windowSize)
+  };
+  const codeView = shouldVirtualize ? (() => {
+    const { containerRef, window: window2, handleScroll, lineHeight } = virtualization;
+    const spacerTop = window2.startIndex * lineHeight;
+    const spacerBottom = (window2.totalLines - window2.endIndex) * lineHeight;
+    return /* @__PURE__ */ jsx("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: containerRef,
+        className: "markdown-code-block-container relative",
+        style: { overflowY: "auto", overflowX: "hidden", maxHeight: "600px" },
+        onScroll: handleScroll,
+        children: [
+          /* @__PURE__ */ jsx("div", { style: { height: spacerTop }, "aria-hidden": "true" }),
+          rendered,
+          /* @__PURE__ */ jsx("div", { style: { height: spacerBottom }, "aria-hidden": "true" })
+        ]
+      }
+    ) });
+  })() : /* @__PURE__ */ jsx("pre", { className: codeFrameClass, ...codeMetricsAttrs, children: rendered });
+  const blockComponentMap = registry.getBlockComponentMap();
+  const MermaidComponent = Object.prototype.hasOwnProperty.call(blockComponentMap, "mermaid") ? blockComponentMap.mermaid : null;
+  if ((lang ?? "").toLowerCase() === "mermaid" && MermaidComponent) {
+    const raw = typeof node.block.payload.raw === "string" ? node.block.payload.raw : "";
+    const fenced = stripCodeFence(raw);
+    const code = fenced.hadFence ? fenced.code : raw;
+    if (deferredConfig) {
+      return /* @__PURE__ */ jsx("div", { ref: deferredRef, children: shouldRenderDeferred ? React7.createElement(MermaidComponent, {
+        code,
+        renderCode: codeView,
+        meta: node.block.payload.meta,
+        isFinalized: node.block.isFinalized
+      }) : codeView });
+    }
+    return React7.createElement(MermaidComponent, {
+      code,
+      renderCode: codeView,
+      meta: node.block.payload.meta,
+      isFinalized: node.block.isFinalized
+    });
+  }
+  return codeView;
+});
+CodeBlockView.displayName = "CodeBlockView";
+function composeHighlightedHtml(lines, preAttrs, codeAttrs, appendTerminalNewline = false) {
+  const lineMarkup = lines.map((line) => {
+    const content = line.html ?? renderTokenLineHtml(line.tokens) ?? escapeHtml3(line.text);
+    const dataLine = Number.isFinite(line.index) ? ` data-line="${line.index + 1}"` : "";
+    return `<span class="line"${dataLine}>${content}</span>`;
+  }).join("\n");
+  const preAttr = attrsToString(preAttrs);
+  const codeAttr = attrsToString(codeAttrs);
+  return `<pre${preAttr}><code${codeAttr}>${lineMarkup}${appendTerminalNewline ? "\n" : ""}</code></pre>`;
+}
+var TOKEN_FONT_STYLE_ITALIC = 1;
+var TOKEN_FONT_STYLE_BOLD = 2;
+var TOKEN_FONT_STYLE_UNDERLINE = 4;
+var TOKEN_FONT_STYLE_STRIKETHROUGH = 8;
+function renderTokenLineHtml(tokens) {
+  if (!tokens || !Array.isArray(tokens.spans)) {
+    return null;
+  }
+  return mergeRenderableTokenSpans(tokens.spans).map((span) => renderTokenSpanHtml(span)).join("");
+}
+function renderTokenSpanHtml(span) {
+  const dark = span.v?.dark;
+  const light = span.v?.light;
+  const single = span.s;
+  const styles = [];
+  if (dark?.fg) {
+    styles.push(`--shiki-dark:${dark.fg}`);
+  }
+  if (light?.fg) {
+    styles.push(`--shiki-light:${light.fg}`);
+  }
+  if (!light?.fg && !dark?.fg && single?.fg) {
+    styles.push(`color:${single.fg}`);
+  }
+  const fontStyle = light?.fs ?? dark?.fs ?? single?.fs;
+  if (typeof fontStyle === "number" && fontStyle > 0) {
+    if (fontStyle & TOKEN_FONT_STYLE_ITALIC) {
+      styles.push("font-style: italic");
+    }
+    if (fontStyle & TOKEN_FONT_STYLE_BOLD) {
+      styles.push("font-weight: bold");
+    }
+    const decorations = [];
+    if (fontStyle & TOKEN_FONT_STYLE_UNDERLINE) {
+      decorations.push("underline");
+    }
+    if (fontStyle & TOKEN_FONT_STYLE_STRIKETHROUGH) {
+      decorations.push("line-through");
+    }
+    if (decorations.length > 0) {
+      styles.push(`text-decoration: ${decorations.join(" ")}`);
+    }
+  }
+  const content = escapeHtml3(span.t ?? "");
+  if (styles.length === 0) {
+    return content;
+  }
+  return `<span style="${styles.join(";")}">${content}</span>`;
+}
+function mergeRenderableTokenSpans(spans) {
+  if (spans.length <= 1) {
+    return spans.slice();
+  }
+  const merged = [];
+  let pendingWhitespace = "";
+  for (const span of spans) {
+    const text = typeof span.t === "string" ? span.t : "";
+    if (/^[\t ]+$/.test(text)) {
+      pendingWhitespace += text;
+      continue;
+    }
+    const nextSpan = pendingWhitespace ? { ...span, t: `${pendingWhitespace}${text}` } : span;
+    pendingWhitespace = "";
+    const previous = merged[merged.length - 1];
+    if (previous && sameTokenSpanStyle(previous, nextSpan)) {
+      previous.t += nextSpan.t;
+    } else {
+      merged.push({ ...nextSpan });
+    }
+  }
+  if (pendingWhitespace) {
+    const previous = merged[merged.length - 1];
+    if (previous) {
+      previous.t += pendingWhitespace;
+    } else {
+      merged.push({ t: pendingWhitespace });
+    }
+  }
+  return merged;
+}
+function sameTokenSpanStyle(a, b) {
+  const variantKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(a.v ?? {}),
+    ...Object.keys(b.v ?? {})
+  ]);
+  for (const key of variantKeys) {
+    const aStyle = a.v?.[key];
+    const bStyle = b.v?.[key];
+    if ((aStyle?.fg ?? null) !== (bStyle?.fg ?? null)) return false;
+    if ((aStyle?.bg ?? null) !== (bStyle?.bg ?? null)) return false;
+    if ((aStyle?.fs ?? null) !== (bStyle?.fs ?? null)) return false;
+  }
+  if ((a.s?.fg ?? null) !== (b.s?.fg ?? null)) return false;
+  if ((a.s?.bg ?? null) !== (b.s?.bg ?? null)) return false;
+  if ((a.s?.fs ?? null) !== (b.s?.fs ?? null)) return false;
+  return true;
+}
+function resolveCodeSourceText(raw, metaCode) {
+  if (metaCode !== null) {
+    return metaCode.replace(/\r\n?/g, "\n");
+  }
+  if (!raw) return "";
+  const normalized = raw.replace(/\r\n?/g, "\n");
+  const fenced = stripCodeFence(normalized);
+  return fenced.hadFence ? fenced.code : normalized;
+}
+function attrsToString(attrs) {
+  if (!attrs) return "";
+  return Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeAttribute(value)}"`).join("");
+}
+function buildCodeFallbackLines(raw) {
+  const normalized = normalizeCodeFallbackRaw(raw);
+  if (normalized.length === 0) {
+    if (/^\s*```[^\n]*\n?\s*$/.test(raw)) {
+      return [{ id: "temp-0", index: 0, text: "", html: null }];
+    }
+    return [];
+  }
+  return normalized.split("\n").map((line, index) => ({
+    id: `temp-${index}`,
+    index,
+    text: line,
+    html: null
+  }));
+}
+function normalizeCodeFallbackRaw(raw) {
+  if (!raw) return "";
+  const normalized = raw.replace(/\r\n?/g, "\n");
+  const fenced = stripCodeFence(normalized);
+  if (!fenced.hadFence) {
+    return normalized.replace(/\n+$/, "");
+  }
+  let code = fenced.code;
+  code = code.replace(/\n+$/, "");
+  return code;
+}
+function escapeHtml3(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeAttribute(value) {
+  return value.replace(/"/g, "&quot;");
+}
+
+// src/renderer/blocks-renderer.tsx
+var MarkdownBlocksRenderer = React8.memo(({ blocks, componentRegistry, className = "markdown-renderer", style, store }) => {
+  if (store) {
+    return React8.createElement(
+      "div",
+      {
+        className,
+        style: { contain: "content", ...style ?? {} }
+        // CSS containment for performance
+      },
+      React8.createElement(StoreBackedBlocks, { store, componentRegistry })
+    );
+  }
+  const renderedBlocks = useMemo3(() => {
+    return blocks.map((block) => {
+      const key = getBlockKey(block);
+      return React8.createElement(BlockRenderer, {
+        key,
+        block,
+        componentRegistry,
+        isFinalized: block.isFinalized
+      });
+    });
+  }, [blocks, componentRegistry]);
+  return React8.createElement(
+    "div",
+    {
+      className,
+      style: { contain: "content", ...style ?? {} }
+      // CSS containment for performance
+    },
+    renderedBlocks
+  );
+});
+var StoreBackedBlocks = React8.memo(
+  ({ store, componentRegistry }) => {
+    const blockIds = useRendererChildren(store, PATCH_ROOT_ID2);
+    return React8.createElement(
+      React8.Fragment,
+      null,
+      blockIds.map((blockId) => React8.createElement(BlockNodeRenderer, { key: blockId, store, blockId, registry: componentRegistry }))
+    );
+  }
+);
+StoreBackedBlocks.displayName = "StoreBackedBlocks";
+var BlockRenderer = React8.memo(({ block, componentRegistry, isFinalized }) => {
+  const element = useMemo3(() => {
+    return componentRegistry.renderBlock(block);
+  }, [block, componentRegistry]);
+  const className = `markdown-block markdown-block-${block.type} ${isFinalized ? "finalized" : "dirty"}`;
+  return React8.cloneElement(element, {
+    className: `${element.props.className || ""} ${className}`.trim(),
+    "data-block-id": block.id,
+    "data-finalized": isFinalized
+  });
+});
+export {
+  ComponentRegistry,
+  MarkdownBlocksRenderer,
+  createRendererStore
+};