@bendyline/squisq-editor-react 2.11.4 → 2.11.6

package/dist/chunk-DUO5XZQK.js

@@ -0,0 +1,1653 @@
+import {
+  markdownToTiptap
+} from "./chunk-ES6CPRCW.js";
+
+// src/blockRange.ts
+import { parseMarkdown } from "@bendyline/squisq/markdown";
+
+// src/frontmatter.ts
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?(?:[ \t]*\r?\n)*/;
+function stripFrontmatter(md) {
+  const m = md.match(FRONTMATTER_RE);
+  if (!m) return { body: md, frontmatter: "" };
+  return { body: md.slice(m[0].length), frontmatter: m[0] };
+}
+function frontmatterEndOffset(source) {
+  const m = source.match(FRONTMATTER_RE);
+  return m ? m[0].length : 0;
+}
+
+// src/blockRange.ts
+function computeLineStarts(source) {
+  const starts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\n") starts.push(i + 1);
+  }
+  return starts;
+}
+function makeSlice(source, startOffset, endOffset) {
+  return { text: source.slice(startOffset, endOffset), range: { startOffset, endOffset } };
+}
+function getBlockSlices(fullSource) {
+  const bodyStart = frontmatterEndOffset(fullSource);
+  let doc;
+  try {
+    doc = parseMarkdown(fullSource);
+  } catch {
+    return [makeSlice(fullSource, bodyStart, fullSource.length)];
+  }
+  const lineStarts = computeLineStarts(fullSource);
+  const headingOffsets = [];
+  for (const node of doc.children) {
+    if (node.type !== "heading") continue;
+    const line = node.position?.start.line;
+    if (typeof line !== "number") continue;
+    const off = lineStarts[line - 1];
+    if (typeof off === "number") headingOffsets.push(off);
+  }
+  if (headingOffsets.length === 0) {
+    return [makeSlice(fullSource, bodyStart, fullSource.length)];
+  }
+  const slices = [];
+  const firstHeading = headingOffsets[0];
+  if (fullSource.slice(bodyStart, firstHeading).trim().length > 0) {
+    slices.push(makeSlice(fullSource, bodyStart, firstHeading));
+  }
+  for (let i = 0; i < headingOffsets.length; i++) {
+    const start = headingOffsets[i];
+    const end = i + 1 < headingOffsets.length ? headingOffsets[i + 1] : fullSource.length;
+    slices.push(makeSlice(fullSource, start, end));
+  }
+  return slices;
+}
+function spliceBlock(fullSource, range, newText) {
+  return fullSource.slice(0, range.startOffset) + newText + fullSource.slice(range.endOffset);
+}
+function lineToOffset(source, line) {
+  const starts = computeLineStarts(source);
+  return starts[Math.max(0, line - 1)] ?? source.length;
+}
+function offsetToLine(source, offset) {
+  const starts = computeLineStarts(source);
+  let lo = 0;
+  let hi = starts.length - 1;
+  let ans = 0;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (starts[mid] <= offset) {
+      ans = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return ans + 1;
+}
+function sliceIndexAtOffset(slices, offset) {
+  return slices.findIndex((s) => offset >= s.range.startOffset && offset < s.range.endOffset);
+}
+
+// src/fileKind.ts
+var DATA_MODE_EXTENSIONS = /* @__PURE__ */ new Set(["csv", "tsv", "parquet"]);
+var EXT_TO_LANGUAGE = {
+  md: "markdown",
+  markdown: "markdown",
+  mdown: "markdown",
+  txt: "plaintext",
+  ts: "typescript",
+  tsx: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  json: "json",
+  jsonc: "json",
+  html: "html",
+  htm: "html",
+  css: "css",
+  scss: "scss",
+  less: "less",
+  py: "python",
+  go: "go",
+  rs: "rust",
+  rb: "ruby",
+  java: "java",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  hpp: "cpp",
+  cc: "cpp",
+  cs: "csharp",
+  php: "php",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "ini",
+  ini: "ini",
+  xml: "xml",
+  svg: "xml",
+  sql: "sql",
+  lua: "lua",
+  swift: "swift",
+  kt: "kotlin",
+  kts: "kotlin",
+  dockerfile: "dockerfile",
+  png: "image",
+  jpg: "image",
+  jpeg: "image",
+  gif: "image",
+  webp: "image",
+  bmp: "image",
+  ico: "image",
+  avif: "image"
+};
+var MARKDOWN_MODE_LANGUAGES = /* @__PURE__ */ new Set(["markdown", "plaintext"]);
+var IMAGE_MODE_LANGUAGES = /* @__PURE__ */ new Set(["image"]);
+var MONACO_LANGUAGE_ALIASES = {
+  jsonc: "json"
+};
+function extractExtension(fileName) {
+  const trimmed = fileName.trim();
+  if (!trimmed) return null;
+  const base = trimmed.replace(/^.*[/\\]/, "");
+  if (!base) return null;
+  const dotIdx = base.lastIndexOf(".");
+  if (dotIdx === -1) {
+    return base.toLowerCase();
+  }
+  if (dotIdx === base.length - 1) return null;
+  return base.slice(dotIdx + 1).toLowerCase();
+}
+function detectLanguageFromFileName(fileName) {
+  const ext = extractExtension(fileName);
+  if (!ext) return null;
+  return EXT_TO_LANGUAGE[ext] ?? null;
+}
+function resolveFileKind(fileName, language) {
+  if (!language && fileName) {
+    const ext = extractExtension(fileName);
+    if (ext && DATA_MODE_EXTENSIONS.has(ext)) {
+      return { mode: "data", language: "plaintext" };
+    }
+  }
+  const requestedLanguage = language ?? (fileName ? detectLanguageFromFileName(fileName) : null);
+  const resolvedLanguage = requestedLanguage ? MONACO_LANGUAGE_ALIASES[requestedLanguage.toLowerCase()] ?? requestedLanguage : null;
+  if (!resolvedLanguage) {
+    return { mode: "markdown", language: "markdown" };
+  }
+  let mode;
+  if (IMAGE_MODE_LANGUAGES.has(resolvedLanguage)) {
+    mode = "image";
+  } else if (MARKDOWN_MODE_LANGUAGES.has(resolvedLanguage)) {
+    mode = "markdown";
+  } else {
+    mode = "code";
+  }
+  return { mode, language: resolvedLanguage };
+}
+
+// src/useBlockNavigator.ts
+import { useCallback, useMemo, useState } from "react";
+var NEW_BLOCK_MARKDOWN = "## New section\n\n";
+function useBlockNavigator(source, setSource, opts) {
+  const enabled = opts?.enabled ?? false;
+  const slices = useMemo(() => getBlockSlices(source), [source]);
+  const blockCount = slices.length;
+  const [rawKey, setRawKey] = useState(0);
+  const activeBlockKey = blockCount === 0 ? 0 : Math.min(Math.max(rawKey, 0), blockCount - 1);
+  const active = slices[activeBlockKey] ?? null;
+  const goToBlock = useCallback((key) => {
+    setRawKey(key);
+  }, []);
+  const prevBlock = useCallback(() => {
+    setRawKey(activeBlockKey - 1);
+  }, [activeBlockKey]);
+  const nextBlock = useCallback(() => {
+    setRawKey(activeBlockKey + 1);
+  }, [activeBlockKey]);
+  const goToBlockByLine = useCallback(
+    (line) => {
+      const offset = lineToOffset(source, line);
+      const idx = sliceIndexAtOffset(slices, offset);
+      if (idx >= 0) setRawKey(idx);
+    },
+    [source, slices]
+  );
+  const activeBlockStartLine = active ? offsetToLine(source, active.range.startOffset) : null;
+  const editorSource = enabled && active ? active.text : source;
+  const setEditorSource = useCallback(
+    (next) => {
+      if (!enabled || !active) {
+        setSource(next);
+        return;
+      }
+      const hasFollowing = active.range.endOffset < source.length;
+      const normalized = hasFollowing ? next.replace(/\s*$/, "") + "\n\n" : next;
+      setSource(spliceBlock(source, active.range, normalized));
+    },
+    [enabled, active, source, setSource]
+  );
+  const addBlock = useCallback(() => {
+    if (!active) {
+      const base = source.replace(/\s*$/, "");
+      setSource((base ? base + "\n\n" : "") + NEW_BLOCK_MARKDOWN);
+      setRawKey(blockCount);
+      return;
+    }
+    const insertAt = active.range.endOffset;
+    const before = source.slice(0, insertAt);
+    const after = source.slice(insertAt);
+    const lead = before === "" || before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
+    setSource(before + lead + NEW_BLOCK_MARKDOWN + after);
+    setRawKey(activeBlockKey + 1);
+  }, [active, source, setSource, activeBlockKey, blockCount]);
+  return {
+    editorSource,
+    setEditorSource,
+    blockCount,
+    activeBlockKey,
+    goToBlock,
+    goToBlockByLine,
+    activeBlockStartLine,
+    prevBlock,
+    nextBlock,
+    addBlock
+  };
+}
+
+// src/EditorContext.tsx
+import {
+  createContext,
+  useContext,
+  useState as useState2,
+  useCallback as useCallback2,
+  useMemo as useMemo2,
+  useRef,
+  useEffect
+} from "react";
+import { parseMarkdown as parseMarkdown2, stringifyMarkdown } from "@bendyline/squisq/markdown";
+import { markdownToDoc } from "@bendyline/squisq/doc";
+import {
+  DocumentVersionManager
+} from "@bendyline/squisq/versions";
+
+// src/scene/text/sceneTextChannel.ts
+function createSceneTextChannel() {
+  let current = null;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    set(handle) {
+      current = handle;
+      for (const listener of listeners) listener(handle);
+    },
+    get() {
+      return current;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/editorScrollSync.ts
+function clampRatio(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+function scrollRatio(scrollTop, scrollHeight, viewportHeight) {
+  const availableScroll = scrollHeight - viewportHeight;
+  if (availableScroll <= 0) return 0;
+  return clampRatio(scrollTop / availableScroll);
+}
+function scrollTopForRatio(ratio, scrollHeight, viewportHeight) {
+  return clampRatio(ratio) * Math.max(0, scrollHeight - viewportHeight);
+}
+function readMonacoScrollRatio(editor) {
+  return scrollRatio(
+    editor.getScrollTop(),
+    editor.getScrollHeight(),
+    editor.getLayoutInfo().height
+  );
+}
+function restoreMonacoScrollRatio(editor, ratio) {
+  editor.setScrollTop(
+    scrollTopForRatio(ratio, editor.getScrollHeight(), editor.getLayoutInfo().height)
+  );
+}
+function findWysiwygScrollElement(editor) {
+  return editor.view.dom.closest(".squisq-wysiwyg-container");
+}
+function readWysiwygScrollRatio(editor) {
+  const element = findWysiwygScrollElement(editor);
+  if (!element) return null;
+  return scrollRatio(element.scrollTop, element.scrollHeight, element.clientHeight);
+}
+function restoreWysiwygScrollRatio(editor, ratio) {
+  const element = findWysiwygScrollElement(editor);
+  if (!element) return false;
+  element.scrollTop = scrollTopForRatio(ratio, element.scrollHeight, element.clientHeight);
+  return true;
+}
+
+// src/EditorContext.tsx
+import { jsx } from "react/jsx-runtime";
+var EditorContext = createContext(null);
+function useEditorContext() {
+  const ctx = useContext(EditorContext);
+  if (!ctx) {
+    throw new Error("useEditorContext must be used within an <EditorProvider>");
+  }
+  return ctx;
+}
+var DEFAULT_PRUNE_POLICY = { type: "keep-last-n", n: 50 };
+var DEFAULT_AUTOSAVE_IDLE_MS = 5e3;
+function normalizeBlockTagVisibility(value) {
+  if (value === false || value === "none") return "none";
+  if (value === void 0 || value === "active") return "active";
+  return "always";
+}
+function EditorProvider({
+  initialMarkdown = "",
+  initialView = "raw",
+  articleId = "untitled",
+  colorScheme: initialColorScheme = "light",
+  workspaceContainer = null,
+  allowVersioning = false,
+  versionBasename,
+  versioningPrunePolicy = DEFAULT_PRUNE_POLICY,
+  versioningAutoSaveIdleMs = DEFAULT_AUTOSAVE_IDLE_MS,
+  onSaveVersion,
+  mediaProvider = null,
+  imageDisplayMode = "inline",
+  mentionProvider = null,
+  proofing = null,
+  proofingDefaultEnabled = true,
+  proofingSpellingEnabled = true,
+  proofingGrammarEnabled = true,
+  proofingIgnoreStore = null,
+  documentLinkProvider = null,
+  fenceRenderers = null,
+  onCopyCode,
+  linkSchemes,
+  allowRecording = true,
+  allowNarrate = true,
+  preserveSourceWrapping = true,
+  fileName,
+  saveCoverImageOutput,
+  saveDashboardImageOutput,
+  language,
+  findMode: controlledFindMode,
+  onFindModeChange,
+  inlinePreview = false,
+  showStatusBar = true,
+  outline = false,
+  blockTags,
+  blockTagVisibility: initialBlockTagVisibility,
+  themeInheritance = "fonts",
+  layoutMode = "document",
+  viewPreferences,
+  onViewPreferencesChange,
+  children
+}) {
+  const effectiveInlinePreview = viewPreferences?.inlinePreview ?? inlinePreview;
+  const effectiveShowStatusBar = viewPreferences?.showStatusBar ?? showStatusBar;
+  const effectiveOutline = viewPreferences?.outline ?? outline;
+  const effectiveBlockTagVisibility = normalizeBlockTagVisibility(
+    viewPreferences?.blockTagVisibility ?? viewPreferences?.blockTags ?? initialBlockTagVisibility ?? blockTags
+  );
+  const effectiveThemeInheritance = viewPreferences?.themeInheritance ?? themeInheritance;
+  const effectiveLayoutMode = viewPreferences?.layoutMode ?? layoutMode;
+  const { mode: fileMode, language: resolvedLanguage } = useMemo2(
+    () => resolveFileKind(fileName, language),
+    [fileName, language]
+  );
+  const editorMode = fileMode === "data" ? "code" : fileMode;
+  const [markdownSource, setMarkdownSourceRaw] = useState2(initialMarkdown);
+  const [markdownDoc, setMarkdownDocState] = useState2(null);
+  const [doc, setDoc] = useState2(null);
+  const [activeView, setActiveViewRaw] = useState2(
+    editorMode === "markdown" ? initialView : "raw"
+  );
+  const [uncontrolledFindMode, setUncontrolledFindMode] = useState2(false);
+  const findMode = editorMode !== "image" && (controlledFindMode ?? uncontrolledFindMode);
+  const setFindMode = useCallback2(
+    (active) => {
+      if (editorMode === "image") return;
+      if (controlledFindMode === void 0) setUncontrolledFindMode(active);
+      onFindModeChange?.(active);
+    },
+    [controlledFindMode, editorMode, onFindModeChange]
+  );
+  const activeViewRef = useRef(activeView);
+  activeViewRef.current = activeView;
+  const tiptapEditorRef = useRef(null);
+  const monacoEditorRef = useRef(null);
+  const pendingEditorScrollRef = useRef(null);
+  const setActiveView = useCallback2(
+    (view) => {
+      if (editorMode === "code" && view !== "raw") return;
+      if (editorMode === "image") return;
+      const currentView = activeViewRef.current;
+      if (view === currentView) return;
+      let ratio = null;
+      let targetView = null;
+      if (currentView === "raw" && view === "wysiwyg" && monacoEditorRef.current) {
+        ratio = readMonacoScrollRatio(monacoEditorRef.current);
+        targetView = "wysiwyg";
+      } else if (currentView === "wysiwyg" && view === "raw" && tiptapEditorRef.current) {
+        ratio = readWysiwygScrollRatio(tiptapEditorRef.current);
+        targetView = "raw";
+      }
+      pendingEditorScrollRef.current = ratio === null || targetView === null ? null : { view: targetView, ratio };
+      setActiveViewRaw(view);
+    },
+    [editorMode]
+  );
+  const [parseError, setParseError] = useState2(null);
+  const [isParsing, setIsParsing] = useState2(false);
+  const [colorScheme, setColorScheme] = useState2(initialColorScheme);
+  const [inlinePreviewVisible, setInlinePreviewVisibleRaw] = useState2(effectiveInlinePreview);
+  useEffect(() => {
+    if (viewPreferences?.inlinePreview === void 0) setInlinePreviewVisibleRaw(inlinePreview);
+  }, [inlinePreview, viewPreferences?.inlinePreview]);
+  const [statusBarVisible, setStatusBarVisibleRaw] = useState2(effectiveShowStatusBar);
+  useEffect(() => {
+    if (viewPreferences?.showStatusBar === void 0) setStatusBarVisibleRaw(showStatusBar);
+  }, [showStatusBar, viewPreferences?.showStatusBar]);
+  const [outlineVisible, setOutlineVisibleRaw] = useState2(effectiveOutline);
+  useEffect(() => {
+    if (viewPreferences?.outline === void 0) setOutlineVisibleRaw(outline);
+  }, [outline, viewPreferences?.outline]);
+  const [blockTagVisibilityState, setBlockTagVisibilityRaw] = useState2(
+    effectiveBlockTagVisibility
+  );
+  const blockTagsVisible = blockTagVisibilityState !== "none";
+  useEffect(() => {
+    if (viewPreferences?.blockTagVisibility === void 0 && viewPreferences?.blockTags === void 0) {
+      setBlockTagVisibilityRaw(normalizeBlockTagVisibility(initialBlockTagVisibility ?? blockTags));
+    }
+  }, [blockTags, initialBlockTagVisibility, viewPreferences]);
+  const [themeInheritanceState, setThemeInheritanceRaw] = useState2(effectiveThemeInheritance);
+  useEffect(() => {
+    if (viewPreferences?.themeInheritance === void 0) {
+      setThemeInheritanceRaw(themeInheritance);
+    }
+  }, [themeInheritance, viewPreferences?.themeInheritance]);
+  const [layoutModeState, setLayoutModeRaw] = useState2(effectiveLayoutMode);
+  useEffect(() => {
+    if (viewPreferences?.layoutMode === void 0) setLayoutModeRaw(layoutMode);
+  }, [layoutMode, viewPreferences?.layoutMode]);
+  const [imageEditTarget, setImageEditTarget] = useState2(null);
+  const [mediaRevision, setMediaRevision] = useState2(0);
+  const openImageEdit = useCallback2((relativePath) => {
+    setImageEditTarget(relativePath);
+  }, []);
+  const closeImageEdit = useCallback2(() => {
+    setImageEditTarget(null);
+  }, []);
+  const bumpMediaRevision = useCallback2(() => {
+    setMediaRevision((n) => n + 1);
+  }, []);
+  useEffect(() => {
+    if (!viewPreferences) return;
+    if (viewPreferences.inlinePreview !== void 0) {
+      setInlinePreviewVisibleRaw(viewPreferences.inlinePreview);
+    }
+    if (viewPreferences.showStatusBar !== void 0) {
+      setStatusBarVisibleRaw(viewPreferences.showStatusBar);
+    }
+    if (viewPreferences.outline !== void 0) {
+      setOutlineVisibleRaw(viewPreferences.outline);
+    }
+    if (viewPreferences.blockTagVisibility !== void 0) {
+      setBlockTagVisibilityRaw(normalizeBlockTagVisibility(viewPreferences.blockTagVisibility));
+    } else if (viewPreferences.blockTags !== void 0) {
+      setBlockTagVisibilityRaw(normalizeBlockTagVisibility(viewPreferences.blockTags));
+    }
+    if (viewPreferences.themeInheritance !== void 0) {
+      setThemeInheritanceRaw(viewPreferences.themeInheritance);
+    }
+    if (viewPreferences.layoutMode !== void 0) {
+      setLayoutModeRaw(viewPreferences.layoutMode);
+    }
+  }, [viewPreferences]);
+  const onViewPreferencesChangeRef = useRef(onViewPreferencesChange);
+  onViewPreferencesChangeRef.current = onViewPreferencesChange;
+  const inlinePreviewRef = useRef(inlinePreviewVisible);
+  inlinePreviewRef.current = inlinePreviewVisible;
+  const statusBarRef = useRef(statusBarVisible);
+  statusBarRef.current = statusBarVisible;
+  const outlineRef = useRef(outlineVisible);
+  outlineRef.current = outlineVisible;
+  const blockTagVisibilityRef = useRef(blockTagVisibilityState);
+  blockTagVisibilityRef.current = blockTagVisibilityState;
+  const themeInheritanceRef = useRef(themeInheritanceState);
+  themeInheritanceRef.current = themeInheritanceState;
+  const layoutModeRef = useRef(layoutModeState);
+  layoutModeRef.current = layoutModeState;
+  const setInlinePreviewVisible = useCallback2((visible) => {
+    setInlinePreviewVisibleRaw(visible);
+    onViewPreferencesChangeRef.current?.({
+      inlinePreview: visible,
+      showStatusBar: statusBarRef.current,
+      outline: outlineRef.current,
+      blockTags: blockTagVisibilityRef.current !== "none",
+      blockTagVisibility: blockTagVisibilityRef.current,
+      themeInheritance: themeInheritanceRef.current,
+      layoutMode: layoutModeRef.current
+    });
+  }, []);
+  const setStatusBarVisible = useCallback2((visible) => {
+    setStatusBarVisibleRaw(visible);
+    onViewPreferencesChangeRef.current?.({
+      inlinePreview: inlinePreviewRef.current,
+      showStatusBar: visible,
+      outline: outlineRef.current,
+      blockTags: blockTagVisibilityRef.current !== "none",
+      blockTagVisibility: blockTagVisibilityRef.current,
+      themeInheritance: themeInheritanceRef.current,
+      layoutMode: layoutModeRef.current
+    });
+  }, []);
+  const setOutlineVisible = useCallback2((visible) => {
+    setOutlineVisibleRaw(visible);
+    onViewPreferencesChangeRef.current?.({
+      inlinePreview: inlinePreviewRef.current,
+      showStatusBar: statusBarRef.current,
+      outline: visible,
+      blockTags: blockTagVisibilityRef.current !== "none",
+      blockTagVisibility: blockTagVisibilityRef.current,
+      themeInheritance: themeInheritanceRef.current,
+      layoutMode: layoutModeRef.current
+    });
+  }, []);
+  const setBlockTagVisibility = useCallback2((visibility) => {
+    setBlockTagVisibilityRaw(visibility);
+    onViewPreferencesChangeRef.current?.({
+      inlinePreview: inlinePreviewRef.current,
+      showStatusBar: statusBarRef.current,
+      outline: outlineRef.current,
+      blockTags: visibility !== "none",
+      blockTagVisibility: visibility,
+      themeInheritance: themeInheritanceRef.current,
+      layoutMode: layoutModeRef.current
+    });
+  }, []);
+  const setBlockTagsVisible = useCallback2(
+    (visible) => setBlockTagVisibility(visible ? "always" : "none"),
+    [setBlockTagVisibility]
+  );
+  const setThemeInheritance = useCallback2((mode) => {
+    setThemeInheritanceRaw(mode);
+    onViewPreferencesChangeRef.current?.({
+      inlinePreview: inlinePreviewRef.current,
+      showStatusBar: statusBarRef.current,
+      outline: outlineRef.current,
+      blockTags: blockTagVisibilityRef.current !== "none",
+      blockTagVisibility: blockTagVisibilityRef.current,
+      themeInheritance: mode,
+      layoutMode: layoutModeRef.current
+    });
+  }, []);
+  const setLayoutMode = useCallback2((mode) => {
+    setLayoutModeRaw(mode);
+    onViewPreferencesChangeRef.current?.({
+      inlinePreview: inlinePreviewRef.current,
+      showStatusBar: statusBarRef.current,
+      outline: outlineRef.current,
+      blockTags: blockTagVisibilityRef.current !== "none",
+      blockTagVisibility: blockTagVisibilityRef.current,
+      themeInheritance: themeInheritanceRef.current,
+      layoutMode: mode
+    });
+  }, []);
+  const [tiptapEditor, setTiptapEditorRaw] = useState2(null);
+  const [monacoEditor, setMonacoEditorRaw] = useState2(null);
+  const setTiptapEditor = useCallback2((editor) => {
+    tiptapEditorRef.current = editor;
+    setTiptapEditorRaw(editor);
+  }, []);
+  const setMonacoEditor = useCallback2((editor) => {
+    monacoEditorRef.current = editor;
+    setMonacoEditorRaw(editor);
+  }, []);
+  useEffect(() => {
+    const pending = pendingEditorScrollRef.current;
+    if (!pending || pending.view !== activeView) return;
+    const restore = activeView === "raw" && monacoEditor ? () => restoreMonacoScrollRatio(monacoEditor, pending.ratio) : activeView === "wysiwyg" && tiptapEditor ? () => restoreWysiwygScrollRatio(tiptapEditor, pending.ratio) : null;
+    if (!restore) return;
+    let cancelled = false;
+    const apply = () => {
+      if (cancelled) return;
+      restore();
+      if (pendingEditorScrollRef.current === pending) pendingEditorScrollRef.current = null;
+    };
+    if (typeof requestAnimationFrame === "function") {
+      const frame = requestAnimationFrame(apply);
+      return () => {
+        cancelled = true;
+        cancelAnimationFrame(frame);
+      };
+    }
+    const timeout = setTimeout(apply, 0);
+    return () => {
+      cancelled = true;
+      clearTimeout(timeout);
+    };
+  }, [activeView, monacoEditor, tiptapEditor]);
+  const [activeSceneText, setActiveSceneText] = useState2(null);
+  const sceneTextChannel = useMemo2(createSceneTextChannel, []);
+  useEffect(() => sceneTextChannel.subscribe(setActiveSceneText), [sceneTextChannel]);
+  const articleIdRef = useRef(articleId);
+  articleIdRef.current = articleId;
+  const fileNameRef = useRef(fileName);
+  fileNameRef.current = fileName;
+  useEffect(() => {
+    setColorScheme(initialColorScheme);
+  }, [initialColorScheme]);
+  const parseTimeoutRef = useRef(null);
+  const skipInitialDebouncedParseRef = useRef(Boolean(initialMarkdown));
+  const doParse = useCallback2((source) => {
+    setIsParsing(true);
+    try {
+      const parsed = parseMarkdown2(source);
+      setMarkdownDocState(parsed);
+      setParseError(null);
+      try {
+        const generatedDoc = markdownToDoc(parsed, {
+          articleId: articleIdRef.current,
+          fileName: fileNameRef.current
+        });
+        setDoc(generatedDoc);
+      } catch (docErr) {
+        setDoc(null);
+        console.warn("Doc generation failed:", docErr instanceof Error ? docErr.message : docErr);
+      }
+    } catch (err) {
+      setParseError(err instanceof Error ? err.message : "Parse error");
+      setMarkdownDocState(null);
+      setDoc(null);
+    } finally {
+      setIsParsing(false);
+    }
+  }, []);
+  useEffect(() => {
+    if (editorMode !== "markdown") return;
+    if (skipInitialDebouncedParseRef.current) {
+      skipInitialDebouncedParseRef.current = false;
+      return;
+    }
+    if (parseTimeoutRef.current) {
+      clearTimeout(parseTimeoutRef.current);
+    }
+    setIsParsing(true);
+    parseTimeoutRef.current = setTimeout(() => {
+      doParse(markdownSource);
+    }, 150);
+    return () => {
+      if (parseTimeoutRef.current) {
+        clearTimeout(parseTimeoutRef.current);
+      }
+    };
+  }, [markdownSource, doParse, editorMode]);
+  useEffect(() => {
+    if (editorMode !== "markdown") return;
+    if (initialMarkdown) {
+      doParse(initialMarkdown);
+    }
+  }, []);
+  const setMarkdownSource = useCallback2((source) => {
+    setMarkdownSourceRaw(source);
+  }, []);
+  const blockNav = useBlockNavigator(markdownSource, setMarkdownSource, {
+    enabled: (layoutModeState === "block" || layoutModeState === "timeline") && editorMode === "markdown"
+  });
+  const {
+    editorSource,
+    setEditorSource,
+    blockCount,
+    activeBlockKey,
+    activeBlockStartLine,
+    goToBlock,
+    goToBlockByLine,
+    prevBlock,
+    nextBlock,
+    addBlock
+  } = blockNav;
+  const [selectionVersion, setSelectionVersion] = useState2(0);
+  useEffect(() => {
+    const bump = () => setSelectionVersion((version) => version + 1);
+    const disposers = [];
+    if (typeof tiptapEditor?.on === "function" && typeof tiptapEditor.off === "function") {
+      tiptapEditor.on("selectionUpdate", bump);
+      disposers.push(() => tiptapEditor.off("selectionUpdate", bump));
+    }
+    if (typeof monacoEditor?.onDidChangeCursorSelection === "function") {
+      const subscription = monacoEditor.onDidChangeCursorSelection(bump);
+      if (typeof subscription?.dispose === "function") {
+        disposers.push(() => subscription.dispose());
+      }
+    }
+    return () => {
+      for (const dispose of disposers) dispose();
+    };
+  }, [tiptapEditor, monacoEditor]);
+  const getSelection = useCallback2(() => {
+    if (activeView === "wysiwyg" && tiptapEditor) {
+      const { from, to, empty } = tiptapEditor.state.selection;
+      return {
+        view: "wysiwyg",
+        text: empty ? "" : tiptapEditor.state.doc.textBetween(from, to, "\n", " "),
+        empty
+      };
+    }
+    if (activeView === "raw" && monacoEditor) {
+      const selection = monacoEditor.getSelection();
+      const model = monacoEditor.getModel();
+      if (!selection || !model) return null;
+      const text = model.getValueInRange(selection);
+      return { view: "raw", text, empty: text.length === 0 };
+    }
+    return null;
+  }, [activeView, tiptapEditor, monacoEditor]);
+  const replaceSelection = useCallback2(
+    (markdown) => {
+      if (activeView === "wysiwyg" && tiptapEditor) {
+        tiptapEditor.chain().focus().insertContent(markdownToTiptap(markdown)).run();
+        return true;
+      }
+      if (activeView === "raw" && monacoEditor) {
+        const selection = monacoEditor.getSelection();
+        if (!selection) return false;
+        monacoEditor.pushUndoStop();
+        monacoEditor.executeEdits("replace-selection", [{ range: selection, text: markdown }]);
+        monacoEditor.pushUndoStop();
+        monacoEditor.focus();
+        return true;
+      }
+      return false;
+    },
+    [activeView, tiptapEditor, monacoEditor]
+  );
+  const getBlockAtCursor = useCallback2(() => {
+    if (activeView !== "raw" || !monacoEditor) return null;
+    const model = monacoEditor.getModel();
+    const position = monacoEditor.getPosition();
+    if (!model || !position) return null;
+    const slices = getBlockSlices(model.getValue());
+    if (slices.length === 0) return null;
+    return slices[sliceIndexAtOffset(slices, model.getOffsetAt(position))] ?? null;
+  }, [activeView, monacoEditor]);
+  const insertAtCursor = useCallback2(
+    (text) => {
+      if (activeView === "wysiwyg" && tiptapEditor) {
+        const html = markdownToTiptap(text);
+        tiptapEditor.chain().focus().insertContent(html).run();
+      } else if (activeView === "raw" && monacoEditor) {
+        const position = monacoEditor.getPosition();
+        if (position) {
+          const model = monacoEditor.getModel();
+          if (model) {
+            const range = {
+              startLineNumber: position.lineNumber,
+              startColumn: position.column,
+              endLineNumber: position.lineNumber,
+              endColumn: position.column
+            };
+            monacoEditor.executeEdits("drop", [{ range, text }]);
+          }
+        } else {
+          setMarkdownSourceRaw((prev) => prev + "\n\n" + text);
+        }
+      } else {
+        setMarkdownSourceRaw((prev) => prev + "\n\n" + text);
+      }
+    },
+    [activeView, tiptapEditor, monacoEditor]
+  );
+  const replaceAll = useCallback2((text) => {
+    setMarkdownSourceRaw(text);
+  }, []);
+  const versioningWarnedRef = useRef(false);
+  useEffect(() => {
+    if (allowVersioning && !workspaceContainer && !versioningWarnedRef.current) {
+      console.warn(
+        "[squisq-editor] allowVersioning requires a `workspaceContainer` prop; versioning is disabled."
+      );
+      versioningWarnedRef.current = true;
+    }
+  }, [allowVersioning, workspaceContainer]);
+  const versioning = useMemo2(() => {
+    if (!allowVersioning || !workspaceContainer) return null;
+    return new DocumentVersionManager(workspaceContainer, { basename: versionBasename });
+  }, [allowVersioning, workspaceContainer, versionBasename]);
+  const onSaveVersionRef = useRef(onSaveVersion);
+  onSaveVersionRef.current = onSaveVersion;
+  const prunePolicyRef = useRef(versioningPrunePolicy);
+  prunePolicyRef.current = versioningPrunePolicy;
+  const saveVersion = useCallback2(
+    async (options) => {
+      if (!versioning) {
+        const skipped = { saved: false, version: null, reason: "no-document" };
+        onSaveVersionRef.current?.(skipped);
+        return skipped;
+      }
+      const result = await versioning.saveVersion(options);
+      onSaveVersionRef.current?.(result);
+      if (result.saved) {
+        versioning.pruneVersions(prunePolicyRef.current).catch((err) => {
+          console.warn(
+            "[squisq-editor] pruneVersions failed:",
+            err instanceof Error ? err.message : err
+          );
+        });
+      }
+      return result;
+    },
+    [versioning]
+  );
+  const autoSaveSourceRef = useRef(null);
+  useEffect(() => {
+    if (!versioning) return;
+    if (versioningAutoSaveIdleMs <= 0) return;
+    const previous = autoSaveSourceRef.current;
+    autoSaveSourceRef.current = markdownSource;
+    if (previous !== null && previous === markdownSource) return;
+    const timer = setTimeout(() => {
+      saveVersion({ content: markdownSource }).catch((err) => {
+        console.warn(
+          "[squisq-editor] auto-save version failed:",
+          err instanceof Error ? err.message : err
+        );
+      });
+    }, versioningAutoSaveIdleMs);
+    return () => clearTimeout(timer);
+  }, [markdownSource, versioning, versioningAutoSaveIdleMs, saveVersion]);
+  const setMarkdownDoc = useCallback2((newDoc) => {
+    setMarkdownDocState(newDoc);
+    try {
+      const newSource = stringifyMarkdown(newDoc);
+      setMarkdownSourceRaw(newSource);
+      setParseError(null);
+      try {
+        const generatedDoc = markdownToDoc(newDoc, {
+          articleId: articleIdRef.current,
+          fileName: fileNameRef.current
+        });
+        setDoc(generatedDoc);
+      } catch (docErr) {
+        setDoc(null);
+        console.warn("Doc generation failed:", docErr instanceof Error ? docErr.message : docErr);
+      }
+    } catch (err) {
+      setParseError(err instanceof Error ? err.message : "Stringify error");
+    }
+  }, []);
+  const value = useMemo2(
+    () => ({
+      markdownSource,
+      markdownDoc,
+      doc,
+      activeView,
+      parseError,
+      isParsing,
+      colorScheme,
+      editorMode,
+      findMode,
+      language: resolvedLanguage,
+      inlinePreviewVisible,
+      statusBarVisible,
+      outlineVisible,
+      blockTagVisibility: blockTagVisibilityState,
+      blockTagsVisible,
+      themeInheritance: themeInheritanceState,
+      layoutMode: layoutModeState,
+      editorSource,
+      blockCount,
+      activeBlockKey,
+      activeBlockStartLine,
+      selectionVersion,
+      imageEditTarget,
+      mediaRevision,
+      allowRecording,
+      allowNarrate,
+      preserveSourceWrapping,
+      tiptapEditor,
+      monacoEditor,
+      activeSceneText,
+      sceneTextChannel,
+      workspaceContainer,
+      versioning,
+      saveVersion,
+      mediaProvider,
+      imageDisplayMode,
+      mentionProvider,
+      proofing,
+      proofingDefaultEnabled,
+      proofingSpellingEnabled,
+      proofingGrammarEnabled,
+      proofingIgnoreStore,
+      articleId,
+      documentLinkProvider,
+      fenceRenderers,
+      onCopyCode,
+      linkSchemes,
+      fileName,
+      saveCoverImageOutput,
+      saveDashboardImageOutput,
+      setMarkdownSource,
+      setEditorSource,
+      setLayoutMode,
+      goToBlock,
+      goToBlockByLine,
+      prevBlock,
+      nextBlock,
+      addBlock,
+      setMarkdownDoc,
+      setActiveView,
+      setFindMode,
+      setTiptapEditor,
+      setMonacoEditor,
+      setColorScheme,
+      setInlinePreviewVisible,
+      setStatusBarVisible,
+      setOutlineVisible,
+      setBlockTagVisibility,
+      setBlockTagsVisible,
+      setThemeInheritance,
+      getSelection,
+      replaceSelection,
+      getBlockAtCursor,
+      insertAtCursor,
+      replaceAll,
+      openImageEdit,
+      closeImageEdit,
+      bumpMediaRevision
+    }),
+    [
+      markdownSource,
+      markdownDoc,
+      doc,
+      activeView,
+      parseError,
+      isParsing,
+      colorScheme,
+      editorMode,
+      findMode,
+      resolvedLanguage,
+      inlinePreviewVisible,
+      statusBarVisible,
+      outlineVisible,
+      blockTagVisibilityState,
+      blockTagsVisible,
+      themeInheritanceState,
+      layoutModeState,
+      editorSource,
+      blockCount,
+      activeBlockKey,
+      activeBlockStartLine,
+      selectionVersion,
+      tiptapEditor,
+      monacoEditor,
+      activeSceneText,
+      sceneTextChannel,
+      workspaceContainer,
+      versioning,
+      saveVersion,
+      mediaProvider,
+      imageDisplayMode,
+      mentionProvider,
+      proofing,
+      proofingDefaultEnabled,
+      proofingSpellingEnabled,
+      proofingGrammarEnabled,
+      proofingIgnoreStore,
+      articleId,
+      documentLinkProvider,
+      fenceRenderers,
+      onCopyCode,
+      linkSchemes,
+      fileName,
+      saveCoverImageOutput,
+      saveDashboardImageOutput,
+      setMarkdownSource,
+      setEditorSource,
+      setLayoutMode,
+      goToBlock,
+      goToBlockByLine,
+      prevBlock,
+      nextBlock,
+      addBlock,
+      setMarkdownDoc,
+      setActiveView,
+      setFindMode,
+      setTiptapEditor,
+      setMonacoEditor,
+      setColorScheme,
+      setInlinePreviewVisible,
+      setStatusBarVisible,
+      setOutlineVisible,
+      setBlockTagVisibility,
+      setBlockTagsVisible,
+      setThemeInheritance,
+      getSelection,
+      replaceSelection,
+      getBlockAtCursor,
+      insertAtCursor,
+      replaceAll,
+      imageEditTarget,
+      mediaRevision,
+      allowRecording,
+      allowNarrate,
+      preserveSourceWrapping,
+      openImageEdit,
+      closeImageEdit,
+      bumpMediaRevision
+    ]
+  );
+  return /* @__PURE__ */ jsx(EditorContext.Provider, { value, children });
+}
+
+// src/review/decorations.ts
+function reviewUnderlineClass(hue) {
+  return `squisq-review-underline squisq-review-underline--${hue}`;
+}
+function findUniqueTextRange(doc, text) {
+  if (text.length === 0) return null;
+  const matches = [];
+  doc.descendants((node, pos) => {
+    if (!node.isText || typeof node.text !== "string") return true;
+    let index = node.text.indexOf(text);
+    while (index !== -1) {
+      matches.push({ from: pos + index, to: pos + index + text.length });
+      if (matches.length > 1) return false;
+      index = node.text.indexOf(text, index + 1);
+    }
+    return true;
+  });
+  return matches.length === 1 ? matches[0] ?? null : null;
+}
+function buildWriteViewDecorations(doc, findings, hueFor) {
+  const specs = [];
+  for (const finding of findings) {
+    const range = findUniqueTextRange(doc, finding.originalText);
+    if (!range) continue;
+    specs.push({
+      findingId: finding.id,
+      source: finding.source,
+      hue: hueFor(finding.source),
+      from: range.from,
+      to: range.to
+    });
+  }
+  return specs;
+}
+function buildSourceViewDecorations(model, findings, hueFor) {
+  const total = model.getValueLength();
+  const decorations = [];
+  for (const finding of findings) {
+    if (finding.start >= finding.end || finding.end > total) continue;
+    const start = model.getPositionAt(finding.start);
+    const end = model.getPositionAt(finding.end);
+    decorations.push({
+      range: {
+        startLineNumber: start.lineNumber,
+        startColumn: start.column,
+        endLineNumber: end.lineNumber,
+        endColumn: end.column
+      },
+      options: {
+        inlineClassName: reviewUnderlineClass(hueFor(finding.source)),
+        hoverMessage: { value: reviewHoverMarkdown(finding) },
+        // NeverGrowsWhenTypingAtEdges: typing at a mark's edge belongs to the
+        // surrounding text, not to the finding.
+        stickiness: 1
+      }
+    });
+  }
+  return decorations;
+}
+function reviewHoverMarkdown(finding) {
+  const lines = [finding.message];
+  if (finding.rationale) lines.push("", finding.rationale);
+  if (finding.suggestions.length > 0) {
+    lines.push("", ...finding.suggestions.map((s) => `- ${s.label ?? suggestionLabel(s.kind)}`));
+  }
+  return lines.join("\n");
+}
+function suggestionLabel(kind) {
+  if (kind === "remove") return "Remove";
+  if (kind === "insertAfter") return "Insert after";
+  if (kind === "replaceBlock") return "Rewrite this block";
+  return "Replace";
+}
+
+// src/review/ReviewExtension.ts
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var REVIEW_KEY = new PluginKey("squisq-review");
+function buildSet(doc, specs) {
+  const max = doc.content.size;
+  const decorations = [];
+  for (const spec of specs) {
+    if (spec.from >= spec.to || spec.to > max) continue;
+    decorations.push(
+      Decoration.inline(
+        spec.from,
+        spec.to,
+        {
+          class: reviewUnderlineClass(spec.hue),
+          "data-review-id": spec.findingId,
+          "data-review-source": spec.source
+        },
+        { findingId: spec.findingId, source: spec.source, hue: spec.hue }
+      )
+    );
+  }
+  return DecorationSet.create(doc, decorations);
+}
+var ReviewExtension = Extension.create({
+  name: "squisqReview",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: REVIEW_KEY,
+        state: {
+          init: () => ({ decorations: DecorationSet.empty }),
+          apply: (transaction, previous) => {
+            const meta = transaction.getMeta(REVIEW_KEY);
+            if (meta) return { decorations: buildSet(transaction.doc, meta.specs) };
+            if (transaction.docChanged) {
+              return {
+                decorations: previous.decorations.map(transaction.mapping, transaction.doc)
+              };
+            }
+            return previous;
+          }
+        },
+        props: {
+          decorations: (state) => REVIEW_KEY.getState(state)?.decorations ?? null
+        }
+      })
+    ];
+  }
+});
+function updateReviewDecorations(editor, specs) {
+  editor.view.dispatch(editor.state.tr.setMeta(REVIEW_KEY, { specs }));
+}
+function clearReviewDecorations(editor) {
+  updateReviewDecorations(editor, []);
+}
+function resolve(hit) {
+  if (!hit) return null;
+  const spec = hit.spec;
+  return {
+    findingId: spec.findingId,
+    source: spec.source,
+    hue: spec.hue,
+    from: hit.from,
+    to: hit.to
+  };
+}
+function reviewDecorationAt(state, pos) {
+  const set = REVIEW_KEY.getState(state)?.decorations;
+  return set ? resolve(set.find(pos, pos)[0]) : null;
+}
+function reviewDecorationById(state, findingId) {
+  const set = REVIEW_KEY.getState(state)?.decorations;
+  if (!set) return null;
+  return resolve(
+    set.find(
+      void 0,
+      void 0,
+      (spec) => spec.findingId === findingId
+    )[0]
+  );
+}
+
+// src/review/buildRequest.ts
+import { blankProtectedSpans } from "@bendyline/squisq/proof";
+var HEADING = /^\s{0,3}#{1,6}\s+(.+)$/;
+function buildReviewRequest(options) {
+  const { source, documentRef } = options;
+  const masked = blankProtectedSpans(source, { markdownCode: true }).text;
+  const slices = getBlockSlices(source);
+  const blocks = [];
+  let heading = null;
+  let line = 1;
+  let consumed = 0;
+  for (const [key, slice] of slices.entries()) {
+    line += countNewlines(source.slice(consumed, slice.range.startOffset));
+    consumed = slice.range.startOffset;
+    const firstLine = slice.text.slice(0, indexOfNewline(slice.text));
+    const headingMatch = HEADING.exec(firstLine.trimEnd());
+    if (headingMatch) heading = headingMatch[1]?.trim() || null;
+    const text = masked.slice(slice.range.startOffset, slice.range.endOffset);
+    if (text.trim().length === 0) continue;
+    blocks.push({
+      key,
+      startLine: line,
+      heading,
+      text,
+      offset: slice.range.startOffset
+    });
+  }
+  return {
+    source,
+    blocks,
+    documentRef,
+    ...options.changedBlockKeys ? { changedBlockKeys: options.changedBlockKeys } : {},
+    ...options.language ? { language: options.language } : {}
+  };
+}
+function changedBlockKeys(previous, next) {
+  const before = new Map(previous.map((block) => [block.key, block.text]));
+  const changed = [];
+  for (const block of next) {
+    if (before.get(block.key) !== block.text) changed.push(block.key);
+  }
+  return changed;
+}
+function indexOfNewline(text) {
+  const index = text.indexOf("\n");
+  return index === -1 ? text.length : index;
+}
+function countNewlines(text) {
+  let count = 0;
+  for (let i = 0; i < text.length; i += 1) {
+    if (text[i] === "\n") count += 1;
+  }
+  return count;
+}
+
+// src/review/types.ts
+function resolveReviewProvider(capability) {
+  return typeof capability === "function" ? capability() : capability;
+}
+var DEFAULT_REVIEW_DEBOUNCE_MS = 2e3;
+var DEFAULT_REVIEW_HUE = "style";
+
+// src/review/runner.ts
+var ReviewRunner = class {
+  constructor(options) {
+    this.disposed = false;
+    this.options = options;
+    this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
+    this.runtimes = options.providers.map((provider) => ({
+      provider,
+      status: {
+        id: provider.id,
+        label: provider.label,
+        phase: "idle",
+        findings: [],
+        error: null
+      },
+      timer: null,
+      controller: null,
+      dirty: false,
+      setupDone: false
+    }));
+  }
+  /** The document changed. Reschedule every provider. */
+  schedule() {
+    if (this.disposed) return;
+    for (const runtime of this.runtimes) this.scheduleOne(runtime);
+  }
+  /** Run now, skipping the debounce — the user asked for a review. */
+  runNow() {
+    if (this.disposed) return;
+    for (const runtime of this.runtimes) {
+      if (runtime.timer !== null) {
+        this.clearTimer(runtime.timer);
+        runtime.timer = null;
+      }
+      void this.runPass(runtime);
+    }
+  }
+  snapshot() {
+    const providers = this.runtimes.map((runtime) => runtime.status);
+    return {
+      findings: providers.flatMap((status) => status.findings),
+      providers,
+      running: providers.some(
+        (status) => status.phase === "running" || status.phase === "preparing"
+      )
+    };
+  }
+  /** Drop a finding from the visible set without re-running anything. */
+  removeFinding(findingId) {
+    for (const runtime of this.runtimes) {
+      const next = runtime.status.findings.filter((finding) => finding.id !== findingId);
+      if (next.length !== runtime.status.findings.length) {
+        runtime.status = { ...runtime.status, findings: next };
+        this.emit();
+        return;
+      }
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    for (const runtime of this.runtimes) {
+      if (runtime.timer !== null) this.clearTimer(runtime.timer);
+      runtime.timer = null;
+      runtime.controller?.abort();
+      runtime.controller = null;
+      runtime.provider.dispose?.();
+    }
+  }
+  scheduleOne(runtime) {
+    if (runtime.controller) {
+      runtime.dirty = true;
+      return;
+    }
+    if (runtime.timer !== null) this.clearTimer(runtime.timer);
+    const delay = runtime.provider.debounceMs ?? DEFAULT_REVIEW_DEBOUNCE_MS;
+    runtime.timer = this.setTimer(() => {
+      runtime.timer = null;
+      void this.runPass(runtime);
+    }, delay);
+  }
+  async runPass(runtime) {
+    if (this.disposed || runtime.controller) return;
+    const request = this.options.buildRequest();
+    if (!request) return;
+    const startedAt = this.options.revision();
+    const controller = new AbortController();
+    runtime.controller = controller;
+    runtime.dirty = false;
+    if (!runtime.setupDone && runtime.provider.setup) {
+      this.setPhase(runtime, "preparing");
+      try {
+        await runtime.provider.setup();
+        runtime.setupDone = true;
+      } catch (error) {
+        runtime.controller = null;
+        this.fail(runtime, error);
+        return;
+      }
+      if (this.disposed) {
+        runtime.controller = null;
+        return;
+      }
+    }
+    this.setPhase(runtime, "running");
+    const collected = [];
+    let failure = null;
+    try {
+      for await (const event of runtime.provider.review(request, controller.signal)) {
+        if (controller.signal.aborted || this.disposed) break;
+        if (event.type === "findings") collected.push(...event.findings);
+        else if (event.type === "error") failure = event.message;
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) failure = messageOf(error);
+    }
+    runtime.controller = null;
+    if (this.disposed) return;
+    const stale = this.options.revision() !== startedAt;
+    if (!controller.signal.aborted && !stale) {
+      runtime.status = failure ? { ...runtime.status, phase: "error", error: failure } : { ...runtime.status, phase: "ready", error: null, findings: collected };
+      this.emit();
+    }
+    if (runtime.dirty || stale) {
+      runtime.dirty = false;
+      this.scheduleOne(runtime);
+    }
+  }
+  setPhase(runtime, phase) {
+    runtime.status = { ...runtime.status, phase };
+    this.emit();
+  }
+  fail(runtime, error) {
+    runtime.status = { ...runtime.status, phase: "error", error: messageOf(error) };
+    this.emit();
+  }
+  emit() {
+    if (!this.disposed) this.options.onChange(this.snapshot());
+  }
+};
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/review/useReview.ts
+import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo3, useRef as useRef2, useState as useState3 } from "react";
+var EMPTY = [];
+var EMPTY_FINDINGS = [];
+function useReview(capabilities = EMPTY) {
+  const {
+    markdownSource,
+    activeView,
+    tiptapEditor,
+    monacoEditor,
+    fileName,
+    articleId,
+    goToBlockByLine
+  } = useEditorContext();
+  const providers = useMemo3(
+    () => capabilities.map(resolveReviewProvider),
+    [capabilities]
+  );
+  const [snapshot, setSnapshot] = useState3(null);
+  const sourceRef = useRef2(markdownSource);
+  const revisionRef = useRef2(0);
+  const blocksRef = useRef2([]);
+  const runnerRef = useRef2(null);
+  sourceRef.current = markdownSource;
+  const hueFor = useMemo3(() => {
+    const hues = new Map(
+      providers.map((provider) => [provider.id, provider.hue ?? DEFAULT_REVIEW_HUE])
+    );
+    return (source) => hues.get(source) ?? DEFAULT_REVIEW_HUE;
+  }, [providers]);
+  useEffect2(() => {
+    if (providers.length === 0) {
+      setSnapshot(null);
+      return;
+    }
+    const runner = new ReviewRunner({
+      providers,
+      revision: () => revisionRef.current,
+      buildRequest: () => {
+        const request = buildReviewRequest({
+          source: sourceRef.current,
+          documentRef: { articleId, ...fileName ? { fileName } : {} },
+          language: "markdown"
+        });
+        const changed = changedBlockKeys(blocksRef.current, request.blocks);
+        blocksRef.current = request.blocks;
+        return { ...request, changedBlockKeys: changed };
+      },
+      onChange: setSnapshot
+    });
+    runnerRef.current = runner;
+    setSnapshot(runner.snapshot());
+    return () => {
+      runner.dispose();
+      runnerRef.current = null;
+    };
+  }, [providers, articleId, fileName]);
+  useEffect2(() => {
+    revisionRef.current += 1;
+    runnerRef.current?.schedule();
+  }, [markdownSource]);
+  const findings = useMemo3(() => snapshot?.findings ?? EMPTY_FINDINGS, [snapshot]);
+  useEffect2(() => {
+    if (!tiptapEditor || activeView !== "wysiwyg") return;
+    if (findings.length === 0) {
+      clearReviewDecorations(tiptapEditor);
+      return;
+    }
+    updateReviewDecorations(
+      tiptapEditor,
+      buildWriteViewDecorations(tiptapEditor.state.doc, findings, hueFor)
+    );
+  }, [tiptapEditor, activeView, findings, hueFor]);
+  const collectionRef = useRef2(null);
+  useEffect2(() => {
+    if (!monacoEditor || activeView !== "raw") return;
+    const model = monacoEditor.getModel();
+    if (!model) return;
+    collectionRef.current ?? (collectionRef.current = monacoEditor.createDecorationsCollection([]));
+    collectionRef.current.set(buildSourceViewDecorations(model, findings, hueFor));
+    return () => {
+      collectionRef.current?.clear();
+    };
+  }, [monacoEditor, activeView, findings, hueFor]);
+  const goToFinding = useCallback3(
+    (findingId) => {
+      const finding = findings.find((candidate) => candidate.id === findingId);
+      if (!finding) return;
+      if (finding.blockKey !== void 0) {
+        const block = blocksRef.current.find((candidate) => candidate.key === finding.blockKey);
+        if (block) goToBlockByLine(block.startLine);
+      }
+    },
+    [findings, goToBlockByLine]
+  );
+  const reviewNow = useCallback3(() => runnerRef.current?.runNow(), []);
+  const dismissFinding = useCallback3((findingId) => {
+    runnerRef.current?.removeFinding(findingId);
+  }, []);
+  return useMemo3(
+    () => snapshot ? { ...snapshot, reviewNow, dismissFinding, goToFinding } : null,
+    [snapshot, reviewNow, dismissFinding, goToFinding]
+  );
+}
+
+// src/review/ReviewContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ReviewStateContext = createContext2(null);
+function useReviewState() {
+  return useContext2(ReviewStateContext);
+}
+function ReviewRoot({
+  providers,
+  children
+}) {
+  const state = useReview(providers);
+  return /* @__PURE__ */ jsx2(ReviewStateContext.Provider, { value: state, children });
+}
+
+// src/review/ReviewPanel.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function ReviewPanel() {
+  const state = useReviewState();
+  if (!state || state.providers.length === 0) return null;
+  const total = state.findings.length;
+  return /* @__PURE__ */ jsxs("aside", { className: "squisq-review-panel", "aria-label": "Review findings", children: [
+    /* @__PURE__ */ jsxs("div", { className: "squisq-review-panel-header", children: [
+      /* @__PURE__ */ jsxs("span", { className: "squisq-review-panel-title", children: [
+        "Review",
+        /* @__PURE__ */ jsx3("span", { className: "squisq-review-panel-count", children: total })
+      ] }),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          className: "squisq-review-panel-button",
+          onClick: state.reviewNow,
+          disabled: state.running,
+          children: state.running ? "Reviewing\u2026" : "Review now"
+        }
+      )
+    ] }),
+    state.providers.map((provider) => /* @__PURE__ */ jsx3(ProviderGroup, { provider, state }, provider.id))
+  ] });
+}
+function ProviderGroup({
+  provider,
+  state
+}) {
+  return /* @__PURE__ */ jsxs("section", { className: "squisq-review-panel-group", children: [
+    /* @__PURE__ */ jsx3("h3", { className: "squisq-review-panel-group-title", children: provider.label }),
+    provider.phase === "preparing" && /* @__PURE__ */ jsx3("div", { className: "squisq-review-panel-empty", children: "Preparing\u2026" }),
+    provider.phase === "running" && /* @__PURE__ */ jsx3("div", { className: "squisq-review-panel-empty", children: "Reviewing\u2026" }),
+    provider.phase === "error" && // The provider's own message, verbatim: a reviewer that cannot reach
+    // its model and one whose engine is missing need different fixes.
+    /* @__PURE__ */ jsx3("div", { className: "squisq-review-panel-empty", role: "status", children: provider.error ?? "Review failed." }),
+    provider.phase === "ready" && provider.findings.length === 0 && /* @__PURE__ */ jsx3("div", { className: "squisq-review-panel-empty", children: "Nothing to report." }),
+    /* @__PURE__ */ jsx3("ul", { className: "squisq-review-panel-list", children: provider.findings.map((finding) => /* @__PURE__ */ jsx3("li", { children: /* @__PURE__ */ jsx3(Row, { finding, onGo: state.goToFinding, onDismiss: state.dismissFinding }) }, finding.id)) })
+  ] });
+}
+function Row({
+  finding,
+  onGo,
+  onDismiss
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "squisq-review-panel-row", children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        className: "squisq-review-panel-row-main",
+        onClick: () => onGo(finding.id),
+        children: [
+          /* @__PURE__ */ jsx3(
+            "span",
+            {
+              className: `squisq-review-dot squisq-review-dot--${finding.severity}`,
+              "aria-hidden": true
+            }
+          ),
+          /* @__PURE__ */ jsxs("span", { className: "squisq-review-panel-row-body", children: [
+            /* @__PURE__ */ jsx3("span", { className: "squisq-review-panel-excerpt", children: finding.originalText }),
+            /* @__PURE__ */ jsx3("span", { className: "squisq-review-panel-message", children: finding.message }),
+            finding.rationale && /* @__PURE__ */ jsx3("span", { className: "squisq-review-panel-rationale", children: finding.rationale })
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      "button",
+      {
+        type: "button",
+        className: "squisq-review-panel-button",
+        title: "Dismiss",
+        "aria-label": `Dismiss: ${finding.message}`,
+        onClick: () => onDismiss(finding.id),
+        children: "\xD7"
+      }
+    )
+  ] });
+}
+
+export {
+  stripFrontmatter,
+  getBlockSlices,
+  spliceBlock,
+  lineToOffset,
+  offsetToLine,
+  sliceIndexAtOffset,
+  detectLanguageFromFileName,
+  resolveFileKind,
+  useBlockNavigator,
+  useEditorContext,
+  EditorProvider,
+  reviewUnderlineClass,
+  findUniqueTextRange,
+  buildWriteViewDecorations,
+  buildSourceViewDecorations,
+  reviewHoverMarkdown,
+  ReviewExtension,
+  updateReviewDecorations,
+  clearReviewDecorations,
+  reviewDecorationAt,
+  reviewDecorationById,
+  buildReviewRequest,
+  changedBlockKeys,
+  resolveReviewProvider,
+  DEFAULT_REVIEW_DEBOUNCE_MS,
+  DEFAULT_REVIEW_HUE,
+  ReviewRunner,
+  useReview,
+  useReviewState,
+  ReviewRoot,
+  ReviewPanel
+};