@bendyline/squisq-editor-react 2.11.17 → 2.11.18

package/dist/{chunk-HTO5MTTJ.js → chunk-45NQUR62.js}

@@ -1,3 +1,7 @@
+import {
+  isSpeechInputProviderFactory,
+  resolveSpeechInputProvider
+} from "./chunk-DNEVUOBZ.js";
 import {
   markdownToTiptap
 } from "./chunk-DPAMJV6A.js";
@@ -87,6 +91,175 @@ function sliceIndexAtOffset(slices, offset) {
   return slices.findIndex((s) => offset >= s.range.startOffset && offset < s.range.endOffset);
 }
 
+// src/sourceEdits.ts
+import { parseMarkdown as parseMarkdown2 } from "@bendyline/squisq/markdown";
+import { isContainerTemplate } from "@bendyline/squisq/doc";
+function normalizeSourceEdits(source, edits) {
+  const sorted = edits.map((edit, order) => ({ edit, order })).sort((a, b) => a.edit.start - b.edit.start || a.edit.end - b.edit.end || a.order - b.order).map(({ edit }) => edit);
+  let previousEnd = 0;
+  for (const edit of sorted) {
+    if (!Number.isInteger(edit.start) || !Number.isInteger(edit.end) || typeof edit.text !== "string" || edit.start < 0 || edit.end < edit.start || edit.end > source.length || edit.start < previousEnd) {
+      return null;
+    }
+    previousEnd = edit.end;
+  }
+  return sorted;
+}
+function applySourceEditsToText(source, edits) {
+  const sorted = normalizeSourceEdits(source, edits);
+  if (!sorted) throw new RangeError("Source edits are out of range or overlap.");
+  let output = "";
+  let cursor = 0;
+  for (const edit of sorted) {
+    output += source.slice(cursor, edit.start) + edit.text;
+    cursor = edit.end;
+  }
+  return output + source.slice(cursor);
+}
+function minimalReplaceEdit(previous, next) {
+  if (previous === next) return null;
+  const limit = Math.min(previous.length, next.length);
+  let prefix = 0;
+  while (prefix < limit && previous.charCodeAt(prefix) === next.charCodeAt(prefix)) prefix++;
+  let suffix = 0;
+  while (suffix < limit - prefix && previous.charCodeAt(previous.length - 1 - suffix) === next.charCodeAt(next.length - 1 - suffix)) {
+    suffix++;
+  }
+  return {
+    start: prefix,
+    end: previous.length - suffix,
+    text: next.slice(prefix, next.length - suffix)
+  };
+}
+function containerOwners(blocks) {
+  const owners = [];
+  let active = null;
+  blocks.forEach((block, index) => {
+    if (block.headingDepth !== null) {
+      if (active && block.headingDepth <= active.depth) active = null;
+      if (!active && block.container) active = { index, depth: block.headingDepth };
+    }
+    owners.push(active ? active.index : -1);
+  });
+  return owners;
+}
+function resolveOutlineInsertion(blocks, cursorIndex, placement) {
+  const owners = containerOwners(blocks);
+  const cursor = Math.min(Math.max(cursorIndex, -1), blocks.length - 1);
+  const firstHeadingFrom = (from) => {
+    for (let i = Math.max(from, 0); i < blocks.length; i++) {
+      if (blocks[i]?.headingDepth !== null) return i;
+    }
+    return blocks.length;
+  };
+  let index;
+  const container = cursor >= 0 ? owners[cursor] ?? -1 : -1;
+  if (container >= 0) {
+    const depth = blocks[container]?.headingDepth ?? 1;
+    if (placement === "afterBlock") {
+      index = container;
+    } else {
+      index = blocks.length;
+      for (let i = container + 1; i < blocks.length; i++) {
+        const headingDepth = blocks[i]?.headingDepth ?? null;
+        if (headingDepth !== null && headingDepth <= depth) {
+          index = i;
+          break;
+        }
+      }
+    }
+  } else if (placement === "afterBlock") {
+    index = cursor + 1;
+  } else {
+    index = firstHeadingFrom(cursor + 1);
+  }
+  const nextHeading = firstHeadingFrom(index);
+  const nextHeadingDepth = nextHeading < blocks.length ? blocks[nextHeading]?.headingDepth ?? null : null;
+  let previousHeading = -1;
+  for (let i = index - 1; i >= 0; i--) {
+    if (blocks[i]?.headingDepth !== null) {
+      previousHeading = i;
+      break;
+    }
+  }
+  let sectionDepth = 0;
+  let maxHeadingDepth = 6;
+  if (previousHeading >= 0) {
+    const owner = owners[previousHeading] ?? -1;
+    if (owner >= 0) {
+      const ownerDepth = blocks[owner]?.headingDepth ?? 1;
+      sectionDepth = ownerDepth - 1;
+      maxHeadingDepth = ownerDepth;
+    } else {
+      sectionDepth = blocks[previousHeading]?.headingDepth ?? 0;
+    }
+  }
+  return { index, sectionDepth, nextHeadingDepth, maxHeadingDepth };
+}
+function headingDepthForInsertion(context, options = {}) {
+  const deepest = Math.min(context.maxHeadingDepth, 6 - (options.childLevels ?? 0));
+  const wanted = Math.max(context.sectionDepth + 1, 2, context.nextHeadingDepth ?? 0);
+  const depth = Math.min(wanted, deepest);
+  if (depth < 1 || depth < (context.nextHeadingDepth ?? 1)) return null;
+  return depth;
+}
+function sourceOutline(source) {
+  const blocks = [];
+  const ranges = [];
+  const bodyStart = frontmatterEndOffset(source);
+  let children;
+  try {
+    children = parseMarkdown2(source).children;
+  } catch {
+    return { blocks, ranges };
+  }
+  for (const node of children) {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (typeof start !== "number" || typeof end !== "number" || start < bodyStart) continue;
+    if (node.type === "heading") {
+      blocks.push({
+        headingDepth: node.depth,
+        container: isContainerTemplate(node.templateAnnotation?.template)
+      });
+    } else {
+      blocks.push({ headingDepth: null, container: false });
+    }
+    ranges.push({ start, end });
+  }
+  return { blocks, ranges };
+}
+function blockInsertionPoint(source, cursorOffset, placement) {
+  const { blocks, ranges } = sourceOutline(source);
+  let cursorIndex = -1;
+  for (let i = 0; i < ranges.length; i++) {
+    if ((ranges[i]?.start ?? Infinity) <= cursorOffset) cursorIndex = i;
+    else break;
+  }
+  const { index, ...context } = resolveOutlineInsertion(blocks, cursorIndex, placement);
+  const offset = index > 0 ? ranges[index - 1]?.end ?? source.length : ranges[0]?.start ?? source.length;
+  return { offset, ...context };
+}
+function joinBlockAt(source, offset, block) {
+  const bodyStart = frontmatterEndOffset(source);
+  const isSpace = (char) => char === "\n" || char === "\r" || char === " " || char === "	";
+  let start = Math.min(Math.max(offset, bodyStart), source.length);
+  while (start > bodyStart && isSpace(source[start - 1])) start--;
+  let end = Math.max(start, Math.min(offset, source.length));
+  while (end < source.length) {
+    const newline = source.indexOf("\n", end);
+    const lineEnd = newline === -1 ? source.length : newline + 1;
+    if (source.slice(end, lineEnd).trim() !== "") break;
+    end = lineEnd;
+  }
+  const body = block.replace(/^\s*\n/, "").replace(/\s+$/, "");
+  const before = source.slice(0, start);
+  const trailingNewlines = before.endsWith("\n\n") ? 2 : before.endsWith("\n") ? 1 : 0;
+  const prefix = before.length === 0 ? "" : "\n".repeat(2 - trailingNewlines);
+  const suffix = end >= source.length ? "\n" : "\n\n";
+  return { start, end, text: prefix + body + suffix };
+}
+
 // src/fileKind.ts
 var DATA_MODE_EXTENSIONS = /* @__PURE__ */ new Set(["csv", "tsv", "parquet"]);
 var EXT_TO_LANGUAGE = {
@@ -258,20 +431,679 @@ function useBlockNavigator(source, setSource, opts) {
 }
 
 // src/EditorContext.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useState as useState3,
+  useCallback as useCallback3,
+  useMemo as useMemo3,
+  useRef as useRef2,
+  useEffect as useEffect2
+} from "react";
+import { parseMarkdown as parseMarkdown3, stringifyMarkdown } from "@bendyline/squisq/markdown";
+import { markdownToDoc } from "@bendyline/squisq/doc";
+
+// src/speech/useDictationController.ts
 import {
   createContext,
-  useContext,
-  useState as useState2,
   useCallback as useCallback2,
+  useContext,
+  useEffect,
   useMemo as useMemo2,
   useRef,
-  useEffect
+  useState as useState2
 } from "react";
-import { parseMarkdown as parseMarkdown2, stringifyMarkdown } from "@bendyline/squisq/markdown";
-import { markdownToDoc } from "@bendyline/squisq/doc";
+
+// src/speech/dictationInsertion.ts
+import { Selection, TextSelection } from "@tiptap/pm/state";
+import { closeHistory } from "@tiptap/pm/history";
+var INLINE_OBJECT = "\uFFFC";
+function normalizeDictatedText(transcript) {
+  return transcript.replace(/\s+/g, " ").trim();
+}
+function needsLeadingSpace(charBefore, text) {
+  if (charBefore === null || charBefore === "") return false;
+  if (/\s/.test(charBefore)) return false;
+  if (/^[.,;:!?…)\]}]/.test(text)) return false;
+  return true;
+}
+function needsTrailingSpace(charAfter) {
+  if (charAfter === null || charAfter === "") return false;
+  if (/\s/.test(charAfter)) return false;
+  return !/^[.,;:!?…)\]}]/.test(charAfter);
+}
+function composeDictatedInsertion(charBefore, transcript, charAfter = null) {
+  const words = normalizeDictatedText(transcript);
+  if (!words) return null;
+  const lead = needsLeadingSpace(charBefore, words) ? " " : "";
+  const trail = needsTrailingSpace(charAfter) ? " " : "";
+  return { text: `${lead}${words}${trail}`, caret: lead.length + words.length };
+}
+function focusIsInOtherEditable() {
+  if (typeof document === "undefined") return false;
+  const active = document.activeElement;
+  if (!active || active === document.body) return false;
+  if (active instanceof HTMLInputElement || active instanceof HTMLTextAreaElement || active instanceof HTMLSelectElement) {
+    return true;
+  }
+  return active instanceof HTMLElement && active.isContentEditable;
+}
+function charBeforeInTiptap($pos) {
+  if ($pos.parentOffset === 0) return null;
+  const before = $pos.nodeBefore;
+  if (!before) return null;
+  if (before.isText) return before.text ? before.text.slice(-1) : null;
+  if (before.type.name === "hardBreak") return null;
+  return INLINE_OBJECT;
+}
+function charAfterInTiptap($pos) {
+  if ($pos.parentOffset === $pos.parent.content.size) return null;
+  const after = $pos.nodeAfter;
+  if (!after) return null;
+  if (after.isText) return after.text ? after.text.charAt(0) : null;
+  if (after.type.name === "hardBreak") return null;
+  return INLINE_OBJECT;
+}
+function insertDictationIntoTiptap(editor, transcript) {
+  if (editor.isDestroyed || !editor.isEditable) return false;
+  const { state } = editor;
+  let pos = state.selection.to;
+  let $pos = state.doc.resolve(pos);
+  if (!$pos.parent.inlineContent) {
+    const near = Selection.near($pos, 1);
+    if (!(near instanceof TextSelection)) return false;
+    pos = near.head;
+    $pos = near.$head;
+  }
+  const insertion = composeDictatedInsertion(
+    charBeforeInTiptap($pos),
+    transcript,
+    charAfterInTiptap($pos)
+  );
+  if (insertion === null) return false;
+  const alreadyFocused = editor.view.hasFocus();
+  const chain = alreadyFocused || focusIsInOtherEditable() ? editor.chain() : editor.chain().focus();
+  const inserted = chain.command(({ tr }) => {
+    closeHistory(tr);
+    tr.insertText(insertion.text, pos, pos);
+    tr.setSelection(TextSelection.create(tr.doc, pos + insertion.caret));
+    tr.scrollIntoView();
+    return true;
+  }).run();
+  if (inserted && !editor.isDestroyed) {
+    editor.view.dispatch(closeHistory(editor.state.tr).setMeta("addToHistory", false));
+  }
+  return inserted;
+}
+function insertDictationIntoMonaco(editor, transcript) {
+  const model = editor.getModel();
+  if (!model) return false;
+  const selection = editor.getSelection();
+  const caret = selection ? { lineNumber: selection.endLineNumber, column: selection.endColumn } : editor.getPosition();
+  if (!caret) return false;
+  const line = model.getLineContent(caret.lineNumber);
+  const charBefore = caret.column > 1 ? line.charAt(caret.column - 2) : null;
+  const charAfter = caret.column <= line.length ? line.charAt(caret.column - 1) : null;
+  const insertion = composeDictatedInsertion(charBefore, transcript, charAfter);
+  if (insertion === null) return false;
+  const range = {
+    startLineNumber: caret.lineNumber,
+    startColumn: caret.column,
+    endLineNumber: caret.lineNumber,
+    endColumn: caret.column
+  };
+  editor.pushUndoStop();
+  const applied = editor.executeEdits("squisq-dictation", [
+    { range, text: insertion.text, forceMoveMarkers: true }
+  ]);
+  editor.pushUndoStop();
+  if (applied === false) return false;
+  const end = { lineNumber: caret.lineNumber, column: caret.column + insertion.caret };
+  editor.setPosition(end);
+  editor.revealPositionInCenterIfOutsideViewport(end);
+  if (!editor.hasTextFocus() && !focusIsInOtherEditable()) editor.focus();
+  return true;
+}
+
+// src/speech/DictationExtension.ts
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var DICTATION_KEY = new PluginKey("squisq-dictation-interim");
+var DICTATION_INTERIM_CLASS = "squisq-dictation-interim";
+function interimElement(doc, label) {
+  const span = doc.createElement("span");
+  span.className = DICTATION_INTERIM_CLASS;
+  span.setAttribute("contenteditable", "false");
+  span.setAttribute("aria-hidden", "true");
+  span.dataset.squisqDictation = "interim";
+  span.textContent = label;
+  return span;
+}
+var DictationExtension = Extension.create({
+  name: "squisqDictation",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: DICTATION_KEY,
+        state: {
+          init: () => ({ label: null }),
+          apply: (transaction, previous) => transaction.getMeta(DICTATION_KEY) ?? previous
+        },
+        props: {
+          decorations: (state) => {
+            const label = DICTATION_KEY.getState(state)?.label;
+            if (!label) return null;
+            return DecorationSet.create(state.doc, [
+              Decoration.widget(
+                state.selection.to,
+                (view) => interimElement(view.dom.ownerDocument, label),
+                {
+                  // Same key ⇒ ProseMirror reuses the DOM node as the caret moves.
+                  key: `squisq-dictation:${label}`,
+                  // Drawn after the caret, so typed or dictated text lands before it.
+                  side: 1,
+                  ignoreSelection: true
+                }
+              )
+            ]);
+          }
+        }
+      })
+    ];
+  }
+});
+function setDictationInterim(editor, label) {
+  if (editor.isDestroyed || !editor.state) return;
+  const current = DICTATION_KEY.getState(editor.state);
+  if (!current || current.label === label) return;
+  editor.view.dispatch(
+    editor.state.tr.setMeta(DICTATION_KEY, { label }).setMeta("addToHistory", false)
+  );
+}
+
+// src/speech/monacoDictationInterim.ts
+function createMonacoDictationInterim(editor) {
+  const collection = editor.createDecorationsCollection();
+  let label = null;
+  let cursorListener = null;
+  const render = () => {
+    const selection = editor.getSelection();
+    if (!label || !selection) {
+      collection.clear();
+      return;
+    }
+    const lineNumber = selection.endLineNumber;
+    const column = selection.endColumn;
+    collection.set([
+      {
+        range: {
+          startLineNumber: lineNumber,
+          startColumn: column,
+          endLineNumber: lineNumber,
+          endColumn: column
+        },
+        options: {
+          showIfCollapsed: true,
+          after: {
+            content: label,
+            inlineClassName: `${DICTATION_INTERIM_CLASS} ${DICTATION_INTERIM_CLASS}--source`
+          }
+        }
+      }
+    ]);
+  };
+  const safely = (action) => {
+    try {
+      action();
+    } catch {
+    }
+  };
+  return {
+    update(next) {
+      label = next;
+      safely(() => {
+        if (label && !cursorListener) cursorListener = editor.onDidChangeCursorSelection(render);
+        if (!label && cursorListener) {
+          cursorListener.dispose();
+          cursorListener = null;
+        }
+        render();
+      });
+    },
+    dispose() {
+      label = null;
+      safely(() => {
+        cursorListener?.dispose();
+        cursorListener = null;
+        collection.clear();
+      });
+    }
+  };
+}
+
+// src/speech/dictationErrors.ts
+function humanizeDictationError(caught) {
+  const error = caught instanceof Error ? caught : new Error(String(caught));
+  const name = error.name;
+  const message = error.message || String(caught);
+  if (name === "NotAllowedError" || name === "SecurityError" || /permission|not allowed|denied/i.test(message)) {
+    return "Microphone access was not granted. Allow it in your system settings, then try again.";
+  }
+  if (name === "OverconstrainedError" || /constraint|selected microphone/i.test(message)) {
+    return "The selected microphone is unavailable. Choose another microphone, then try again.";
+  }
+  if (name === "NotFoundError" || /requested device not found|no microphone/i.test(message)) {
+    return "No microphone is available.";
+  }
+  if (name === "NotReadableError" || /could not start audio source/i.test(message)) {
+    return "The microphone is in use by another application.";
+  }
+  if (/getUserMedia is not available|MediaRecorder is not defined/i.test(message)) {
+    return "Voice input is unavailable in this browser.";
+  }
+  return `Dictation stopped: ${message}`;
+}
+var NO_SPEECH_DETECTED_MESSAGE = "No speech was detected, so dictation stopped. Check that the right microphone is selected.";
+function setupRequiredMessage(reason) {
+  return reason ? `Dictation needs a one-time setup first: ${reason}` : "Dictation needs a one-time setup before it can start.";
+}
+
+// src/speech/useDictationController.ts
+var DICTATION_METER_BARS = 12;
+var EMPTY_LEVELS = Object.freeze(
+  Array.from({ length: DICTATION_METER_BARS }, () => 0)
+);
+function normalizeMeterLevel(level) {
+  return Math.min(1, Math.max(0, level * 14));
+}
+function createLevelStore() {
+  let levels = EMPTY_LEVELS;
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot: () => levels,
+    push(level) {
+      levels = [...levels.slice(1), normalizeMeterLevel(level)];
+      notify();
+    },
+    reset() {
+      if (levels === EMPTY_LEVELS) return;
+      levels = EMPTY_LEVELS;
+      notify();
+    }
+  };
+}
+var DictationStateContext = createContext(null);
+function useDictationState() {
+  return useContext(DictationStateContext);
+}
+function dictationInterimText(status, pendingTakes) {
+  switch (status) {
+    case "preparing":
+      return "Starting\u2026";
+    case "listening":
+      return pendingTakes > 0 ? "Transcribing\u2026" : "Listening\u2026";
+    case "transcribing":
+      return "Transcribing\u2026";
+    default:
+      return null;
+  }
+}
+function isTextView(view) {
+  return view === "wysiwyg" || view === "raw";
+}
+function useDictationController({
+  capability,
+  activeView,
+  editorMode,
+  tiptapEditor,
+  monacoEditor
+}) {
+  const [provider, setProvider] = useState2(null);
+  const [readiness, setReadiness] = useState2(null);
+  const [status, setStatus] = useState2("idle");
+  const [pendingTakes, setPendingTakes] = useState2(0);
+  const [error, setError] = useState2(null);
+  const levelsRef = useRef(null);
+  if (!levelsRef.current) levelsRef.current = createLevelStore();
+  const levels = levelsRef.current;
+  const providerRef = useRef(provider);
+  providerRef.current = provider;
+  const readinessRef = useRef(readiness);
+  readinessRef.current = readiness;
+  const activeViewRef = useRef(activeView);
+  activeViewRef.current = activeView;
+  const tiptapRef = useRef(tiptapEditor);
+  tiptapRef.current = tiptapEditor;
+  const monacoRef = useRef(monacoEditor);
+  monacoRef.current = monacoEditor;
+  const sessionRef = useRef(null);
+  const heldPhrasesRef = useRef([]);
+  const textViewActive = editorMode === "markdown" && isTextView(activeView);
+  const available = provider !== null && readiness !== null && readiness.state !== "unavailable" && textViewActive;
+  const availableRef = useRef(available);
+  availableRef.current = available;
+  const restoreEditorFocus = useCallback2(() => {
+    if (typeof document === "undefined") return;
+    const active = document.activeElement;
+    const reclaimable = !active || active === document.body || active instanceof Element && active.closest(".squisq-dictation") !== null;
+    if (!reclaimable) return;
+    const view = activeViewRef.current;
+    const tiptap = tiptapRef.current;
+    if (view === "wysiwyg" && tiptap && !tiptap.isDestroyed) {
+      tiptap.commands.focus();
+      return;
+    }
+    const monaco = monacoRef.current;
+    if (view === "raw" && monaco) monaco.focus();
+  }, []);
+  const endSession = useCallback2(
+    (session, options = {}) => {
+      if (sessionRef.current !== session) return;
+      sessionRef.current = null;
+      session.abort.abort();
+      levels.reset();
+      setPendingTakes(0);
+      setStatus("idle");
+      if (options.restoreFocus) restoreEditorFocus();
+    },
+    [levels, restoreEditorFocus]
+  );
+  const cancel = useCallback2(() => {
+    const session = sessionRef.current;
+    if (!session) return;
+    session.handle?.cancel();
+    endSession(session, { restoreFocus: true });
+  }, [endSession]);
+  const stop = useCallback2(async () => {
+    const session = sessionRef.current;
+    if (!session) return;
+    if (!session.handle) {
+      cancel();
+      return;
+    }
+    if (session.stopping) return;
+    session.stopping = true;
+    setStatus("transcribing");
+    try {
+      await session.handle.stop();
+    } finally {
+      endSession(session, { restoreFocus: true });
+    }
+  }, [cancel, endSession]);
+  const insertPhrase = useCallback2((text) => {
+    const view = activeViewRef.current;
+    const tiptap = tiptapRef.current;
+    if (view === "wysiwyg" && tiptap && !tiptap.isDestroyed) {
+      insertDictationIntoTiptap(tiptap, text);
+      return true;
+    }
+    const monaco = monacoRef.current;
+    if (view === "raw" && monaco) {
+      insertDictationIntoMonaco(monaco, text);
+      return true;
+    }
+    return false;
+  }, []);
+  const start = useCallback2(async () => {
+    const active = providerRef.current;
+    if (!active || sessionRef.current) return;
+    const session = { abort: new AbortController(), handle: null, stopping: false };
+    sessionRef.current = session;
+    const isCurrent = () => sessionRef.current === session;
+    setError(null);
+    setPendingTakes(0);
+    levels.reset();
+    setStatus("preparing");
+    try {
+      const fresh = await active.status();
+      if (!isCurrent()) return;
+      setReadiness(fresh);
+      if (fresh.state === "download-required" || fresh.state === "unavailable") {
+        endSession(session);
+        if (fresh.state === "download-required") {
+          if (active.requestSetup) active.requestSetup();
+          else setError(setupRequiredMessage(fresh.reason));
+        }
+        return;
+      }
+      const { startDictationSession } = await import("./dictationSession-PN3OT5LJ.js");
+      if (!isCurrent()) return;
+      const handle = await startDictationSession({
+        provider: active,
+        signal: session.abort.signal,
+        onTranscript: (text) => {
+          if (!isCurrent()) return;
+          if (!insertPhrase(text)) heldPhrasesRef.current.push(text);
+        },
+        onAudioLevel: (level) => {
+          if (isCurrent()) levels.push(level);
+        },
+        onPendingChange: (pending) => {
+          if (isCurrent()) setPendingTakes(pending);
+        },
+        onLongPause: (hadTranscript) => {
+          if (!isCurrent()) return;
+          if (!hadTranscript) setError(NO_SPEECH_DETECTED_MESSAGE);
+          void stop();
+        },
+        onError: (caught) => {
+          if (!isCurrent()) return;
+          session.handle?.cancel();
+          endSession(session, { restoreFocus: true });
+          setError(humanizeDictationError(caught));
+        }
+      });
+      if (!isCurrent()) {
+        handle.cancel();
+        return;
+      }
+      session.handle = handle;
+      setStatus("listening");
+    } catch (caught) {
+      if (!isCurrent()) return;
+      endSession(session, { restoreFocus: true });
+      setError(humanizeDictationError(caught));
+    }
+  }, [endSession, insertPhrase, levels, stop]);
+  const toggle = useCallback2(() => {
+    const session = sessionRef.current;
+    if (session) {
+      void stop();
+      return;
+    }
+    const active = providerRef.current;
+    if (!active || !availableRef.current) return;
+    const known = readinessRef.current;
+    if (known?.state === "download-required") {
+      setError(null);
+      if (active.requestSetup) active.requestSetup();
+      else setError(setupRequiredMessage(known.reason));
+      active.status().then(
+        (next) => {
+          if (providerRef.current === active) setReadiness(next);
+        },
+        () => void 0
+      );
+      return;
+    }
+    void start();
+  }, [start, stop]);
+  const dismissError = useCallback2(() => setError(null), []);
+  useEffect(() => {
+    if (!capability) {
+      setProvider(null);
+      setReadiness(null);
+      return;
+    }
+    const owned = isSpeechInputProviderFactory(capability);
+    const instance = resolveSpeechInputProvider(capability);
+    let alive = true;
+    setProvider(instance);
+    setReadiness(null);
+    instance.status().then(
+      (next) => {
+        if (alive) setReadiness(next);
+      },
+      (caught) => {
+        if (!alive) return;
+        const reason = caught instanceof Error ? caught.message : String(caught);
+        setReadiness({ state: "unavailable", reason });
+      }
+    );
+    const unsubscribe = instance.onStatus?.((next) => {
+      if (alive) setReadiness(next);
+    });
+    return () => {
+      alive = false;
+      unsubscribe?.();
+      const session = sessionRef.current;
+      if (session) {
+        session.handle?.cancel();
+        sessionRef.current = null;
+        session.abort.abort();
+      }
+      setStatus("idle");
+      setPendingTakes(0);
+      if (owned) instance.dispose?.();
+    };
+  }, [capability]);
+  useEffect(
+    () => () => {
+      const session = sessionRef.current;
+      if (!session) return;
+      session.handle?.cancel();
+      sessionRef.current = null;
+      session.abort.abort();
+    },
+    []
+  );
+  useEffect(() => {
+    if (!textViewActive && sessionRef.current) void stop();
+  }, [textViewActive, stop]);
+  const sessionActive = status !== "idle";
+  useEffect(() => {
+    if (!sessionActive || typeof window === "undefined") return;
+    const onKeyDown = (event) => {
+      if (event.key !== "Escape" || event.defaultPrevented) return;
+      void stop();
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [sessionActive, stop]);
+  useEffect(() => {
+    if (heldPhrasesRef.current.length === 0) return;
+    const held = heldPhrasesRef.current;
+    heldPhrasesRef.current = [];
+    for (let index = 0; index < held.length; index += 1) {
+      if (!insertPhrase(held[index])) {
+        heldPhrasesRef.current = held.slice(index);
+        return;
+      }
+    }
+  }, [activeView, tiptapEditor, monacoEditor, insertPhrase]);
+  const hasCapability = capability !== null;
+  const interimLabel = hasCapability ? dictationInterimText(status, pendingTakes) : null;
+  useEffect(() => {
+    if (!tiptapEditor || !hasCapability) return;
+    setDictationInterim(tiptapEditor, activeView === "wysiwyg" ? interimLabel : null);
+  }, [tiptapEditor, hasCapability, activeView, interimLabel]);
+  useEffect(() => {
+    if (!tiptapEditor || !hasCapability) return;
+    return () => setDictationInterim(tiptapEditor, null);
+  }, [tiptapEditor, hasCapability]);
+  const monacoInterimRef = useRef(null);
+  useEffect(() => {
+    if (!monacoEditor) return;
+    return () => {
+      monacoInterimRef.current?.dispose();
+      monacoInterimRef.current = null;
+    };
+  }, [monacoEditor]);
+  useEffect(() => {
+    if (!monacoEditor) return;
+    const label = activeView === "raw" ? interimLabel : null;
+    if (!label && !monacoInterimRef.current) return;
+    if (!monacoInterimRef.current)
+      monacoInterimRef.current = createMonacoDictationInterim(monacoEditor);
+    monacoInterimRef.current.update(label);
+  }, [monacoEditor, activeView, interimLabel]);
+  const control = useMemo2(
+    () => hasCapability ? { active: sessionActive, available, toggle } : null,
+    [hasCapability, sessionActive, available, toggle]
+  );
+  const providerLabel = provider?.label ?? "";
+  const state = useMemo2(
+    () => hasCapability ? {
+      status,
+      readiness,
+      available,
+      providerLabel,
+      pendingTakes,
+      error,
+      levels,
+      toggle,
+      dismissError
+    } : null,
+    [
+      hasCapability,
+      status,
+      readiness,
+      available,
+      providerLabel,
+      pendingTakes,
+      error,
+      levels,
+      toggle,
+      dismissError
+    ]
+  );
+  return { control, state };
+}
+
+// src/EditorContext.tsx
 import {
   DocumentVersionManager
 } from "@bendyline/squisq/versions";
+import { createDocument } from "@tiptap/core";
+import { closeHistory as closeHistory2 } from "@tiptap/pm/history";
+
+// src/blockInsertion.ts
+import { isContainerTemplate as isContainerTemplate2 } from "@bendyline/squisq/doc";
+function tiptapOutline(doc) {
+  const blocks = [];
+  const positions = [];
+  doc.forEach((node, offset) => {
+    positions.push(offset);
+    if (node.type.name === "heading") {
+      const attrs = node.attrs;
+      blocks.push({
+        headingDepth: attrs.level ?? 1,
+        container: isContainerTemplate2(attrs.dataTemplate ?? void 0)
+      });
+    } else {
+      blocks.push({ headingDepth: null, container: false });
+    }
+  });
+  return { blocks, positions };
+}
+function tiptapBlockInsertion(state, placement) {
+  const { blocks, positions } = tiptapOutline(state.doc);
+  const { $to } = state.selection;
+  const cursorIndex = $to.depth > 0 ? $to.index(0) : $to.index(0) - 1;
+  const { index, ...context } = resolveOutlineInsertion(blocks, cursorIndex, placement);
+  const pos = index < positions.length ? positions[index] ?? 0 : state.doc.content.size;
+  return { pos, ...context };
+}
 
 // src/mediaEdit/mediaEditTargets.ts
 import { collectDocMediaClips } from "@bendyline/squisq/mediaEdit";
@@ -569,16 +1401,16 @@ function restoreWysiwygScrollRatio(editor, ratio) {
 
 // src/EditorContext.tsx
 import { jsx } from "react/jsx-runtime";
-var EditorContext = createContext(null);
+var EditorContext = createContext2(null);
 function useEditorContext() {
-  const ctx = useContext(EditorContext);
+  const ctx = useContext2(EditorContext);
   if (!ctx) {
     throw new Error("useEditorContext must be used within an <EditorProvider>");
   }
   return ctx;
 }
 function useEditorContextOptional() {
-  return useContext(EditorContext);
+  return useContext2(EditorContext);
 }
 var MEDIA_EDIT_GC_DELAY_MS = 5e3;
 var DEFAULT_PRUNE_POLICY = { type: "keep-last-n", n: 50 };
@@ -608,6 +1440,7 @@ function EditorProvider({
   proofingSpellingEnabled = true,
   proofingGrammarEnabled = true,
   proofingIgnoreStore = null,
+  speechInput = null,
   documentLinkProvider = null,
   fenceRenderers = null,
   onCopyCode,
@@ -640,20 +1473,22 @@ function EditorProvider({
   );
   const effectiveThemeInheritance = viewPreferences?.themeInheritance ?? themeInheritance;
   const effectiveLayoutMode = viewPreferences?.layoutMode ?? layoutMode;
-  const { mode: fileMode, language: resolvedLanguage } = useMemo2(
+  const { mode: fileMode, language: resolvedLanguage } = useMemo3(
     () => 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(
+  const [markdownSource, setMarkdownSourceRaw] = useState3(initialMarkdown);
+  const markdownSourceRef = useRef2(markdownSource);
+  markdownSourceRef.current = markdownSource;
+  const [markdownDoc, setMarkdownDocState] = useState3(null);
+  const [doc, setDoc] = useState3(null);
+  const [activeView, setActiveViewRaw] = useState3(
     editorMode === "markdown" ? initialView : "raw"
   );
-  const [uncontrolledFindMode, setUncontrolledFindMode] = useState2(false);
+  const [uncontrolledFindMode, setUncontrolledFindMode] = useState3(false);
   const findMode = editorMode !== "image" && (controlledFindMode ?? uncontrolledFindMode);
-  const setFindMode = useCallback2(
+  const setFindMode = useCallback3(
     (active) => {
       if (editorMode === "image") return;
       if (controlledFindMode === void 0) setUncontrolledFindMode(active);
@@ -661,12 +1496,12 @@ function EditorProvider({
     },
     [controlledFindMode, editorMode, onFindModeChange]
   );
-  const activeViewRef = useRef(activeView);
+  const activeViewRef = useRef2(activeView);
   activeViewRef.current = activeView;
-  const tiptapEditorRef = useRef(null);
-  const monacoEditorRef = useRef(null);
-  const pendingEditorScrollRef = useRef(null);
-  const setActiveView = useCallback2(
+  const tiptapEditorRef = useRef2(null);
+  const monacoEditorRef = useRef2(null);
+  const pendingEditorScrollRef = useRef2(null);
+  const setActiveView = useCallback3(
     (view) => {
       if (editorMode === "code" && view !== "raw") return;
       if (editorMode === "image") return;
@@ -686,59 +1521,59 @@ function EditorProvider({
     },
     [editorMode]
   );
-  const [parseError, setParseError] = useState2(null);
-  const [isParsing, setIsParsing] = useState2(false);
-  const [colorScheme, setColorScheme] = useState2(initialColorScheme);
-  const [inlinePreviewVisible, setInlinePreviewVisibleRaw] = useState2(effectiveInlinePreview);
-  useEffect(() => {
+  const [parseError, setParseError] = useState3(null);
+  const [isParsing, setIsParsing] = useState3(false);
+  const [colorScheme, setColorScheme] = useState3(initialColorScheme);
+  const [inlinePreviewVisible, setInlinePreviewVisibleRaw] = useState3(effectiveInlinePreview);
+  useEffect2(() => {
     if (viewPreferences?.inlinePreview === void 0) setInlinePreviewVisibleRaw(inlinePreview);
   }, [inlinePreview, viewPreferences?.inlinePreview]);
-  const [statusBarVisible, setStatusBarVisibleRaw] = useState2(effectiveShowStatusBar);
-  useEffect(() => {
+  const [statusBarVisible, setStatusBarVisibleRaw] = useState3(effectiveShowStatusBar);
+  useEffect2(() => {
     if (viewPreferences?.showStatusBar === void 0) setStatusBarVisibleRaw(showStatusBar);
   }, [showStatusBar, viewPreferences?.showStatusBar]);
-  const [outlineVisible, setOutlineVisibleRaw] = useState2(effectiveOutline);
-  useEffect(() => {
+  const [outlineVisible, setOutlineVisibleRaw] = useState3(effectiveOutline);
+  useEffect2(() => {
     if (viewPreferences?.outline === void 0) setOutlineVisibleRaw(outline);
   }, [outline, viewPreferences?.outline]);
-  const [blockTagVisibilityState, setBlockTagVisibilityRaw] = useState2(
+  const [blockTagVisibilityState, setBlockTagVisibilityRaw] = useState3(
     effectiveBlockTagVisibility
   );
   const blockTagsVisible = blockTagVisibilityState !== "none";
-  useEffect(() => {
+  useEffect2(() => {
     if (viewPreferences?.blockTagVisibility === void 0 && viewPreferences?.blockTags === void 0) {
       setBlockTagVisibilityRaw(normalizeBlockTagVisibility(initialBlockTagVisibility ?? blockTags));
     }
   }, [blockTags, initialBlockTagVisibility, viewPreferences]);
-  const [themeInheritanceState, setThemeInheritanceRaw] = useState2(effectiveThemeInheritance);
-  useEffect(() => {
+  const [themeInheritanceState, setThemeInheritanceRaw] = useState3(effectiveThemeInheritance);
+  useEffect2(() => {
     if (viewPreferences?.themeInheritance === void 0) {
       setThemeInheritanceRaw(themeInheritance);
     }
   }, [themeInheritance, viewPreferences?.themeInheritance]);
-  const [layoutModeState, setLayoutModeRaw] = useState2(effectiveLayoutMode);
-  useEffect(() => {
+  const [layoutModeState, setLayoutModeRaw] = useState3(effectiveLayoutMode);
+  useEffect2(() => {
     if (viewPreferences?.layoutMode === void 0) setLayoutModeRaw(layoutMode);
   }, [layoutMode, viewPreferences?.layoutMode]);
-  const [imageEditTarget, setImageEditTarget] = useState2(null);
-  const [mediaRevision, setMediaRevision] = useState2(0);
-  const openImageEdit = useCallback2((relativePath) => {
+  const [imageEditTarget, setImageEditTarget] = useState3(null);
+  const [mediaRevision, setMediaRevision] = useState3(0);
+  const openImageEdit = useCallback3((relativePath) => {
     setImageEditTarget(relativePath);
   }, []);
-  const closeImageEdit = useCallback2(() => {
+  const closeImageEdit = useCallback3(() => {
     setImageEditTarget(null);
   }, []);
-  const [mediaEditTarget, setMediaEditTarget] = useState2(null);
-  const openMediaEdit = useCallback2((target) => {
+  const [mediaEditTarget, setMediaEditTarget] = useState3(null);
+  const openMediaEdit = useCallback3((target) => {
     setMediaEditTarget(target);
   }, []);
-  const closeMediaEdit = useCallback2(() => {
+  const closeMediaEdit = useCallback3(() => {
     setMediaEditTarget(null);
   }, []);
-  const bumpMediaRevision = useCallback2(() => {
+  const bumpMediaRevision = useCallback3(() => {
     setMediaRevision((n) => n + 1);
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     if (!viewPreferences) return;
     if (viewPreferences.inlinePreview !== void 0) {
       setInlinePreviewVisibleRaw(viewPreferences.inlinePreview);
@@ -761,21 +1596,21 @@ function EditorProvider({
       setLayoutModeRaw(viewPreferences.layoutMode);
     }
   }, [viewPreferences]);
-  const onViewPreferencesChangeRef = useRef(onViewPreferencesChange);
+  const onViewPreferencesChangeRef = useRef2(onViewPreferencesChange);
   onViewPreferencesChangeRef.current = onViewPreferencesChange;
-  const inlinePreviewRef = useRef(inlinePreviewVisible);
+  const inlinePreviewRef = useRef2(inlinePreviewVisible);
   inlinePreviewRef.current = inlinePreviewVisible;
-  const statusBarRef = useRef(statusBarVisible);
+  const statusBarRef = useRef2(statusBarVisible);
   statusBarRef.current = statusBarVisible;
-  const outlineRef = useRef(outlineVisible);
+  const outlineRef = useRef2(outlineVisible);
   outlineRef.current = outlineVisible;
-  const blockTagVisibilityRef = useRef(blockTagVisibilityState);
+  const blockTagVisibilityRef = useRef2(blockTagVisibilityState);
   blockTagVisibilityRef.current = blockTagVisibilityState;
-  const themeInheritanceRef = useRef(themeInheritanceState);
+  const themeInheritanceRef = useRef2(themeInheritanceState);
   themeInheritanceRef.current = themeInheritanceState;
-  const layoutModeRef = useRef(layoutModeState);
+  const layoutModeRef = useRef2(layoutModeState);
   layoutModeRef.current = layoutModeState;
-  const setInlinePreviewVisible = useCallback2((visible) => {
+  const setInlinePreviewVisible = useCallback3((visible) => {
     setInlinePreviewVisibleRaw(visible);
     onViewPreferencesChangeRef.current?.({
       inlinePreview: visible,
@@ -787,7 +1622,7 @@ function EditorProvider({
       layoutMode: layoutModeRef.current
     });
   }, []);
-  const setStatusBarVisible = useCallback2((visible) => {
+  const setStatusBarVisible = useCallback3((visible) => {
     setStatusBarVisibleRaw(visible);
     onViewPreferencesChangeRef.current?.({
       inlinePreview: inlinePreviewRef.current,
@@ -799,7 +1634,7 @@ function EditorProvider({
       layoutMode: layoutModeRef.current
     });
   }, []);
-  const setOutlineVisible = useCallback2((visible) => {
+  const setOutlineVisible = useCallback3((visible) => {
     setOutlineVisibleRaw(visible);
     onViewPreferencesChangeRef.current?.({
       inlinePreview: inlinePreviewRef.current,
@@ -811,7 +1646,7 @@ function EditorProvider({
       layoutMode: layoutModeRef.current
     });
   }, []);
-  const setBlockTagVisibility = useCallback2((visibility) => {
+  const setBlockTagVisibility = useCallback3((visibility) => {
     setBlockTagVisibilityRaw(visibility);
     onViewPreferencesChangeRef.current?.({
       inlinePreview: inlinePreviewRef.current,
@@ -823,11 +1658,11 @@ function EditorProvider({
       layoutMode: layoutModeRef.current
     });
   }, []);
-  const setBlockTagsVisible = useCallback2(
+  const setBlockTagsVisible = useCallback3(
     (visible) => setBlockTagVisibility(visible ? "always" : "none"),
     [setBlockTagVisibility]
   );
-  const setThemeInheritance = useCallback2((mode) => {
+  const setThemeInheritance = useCallback3((mode) => {
     setThemeInheritanceRaw(mode);
     onViewPreferencesChangeRef.current?.({
       inlinePreview: inlinePreviewRef.current,
@@ -839,7 +1674,7 @@ function EditorProvider({
       layoutMode: layoutModeRef.current
     });
   }, []);
-  const setLayoutMode = useCallback2((mode) => {
+  const setLayoutMode = useCallback3((mode) => {
     setLayoutModeRaw(mode);
     onViewPreferencesChangeRef.current?.({
       inlinePreview: inlinePreviewRef.current,
@@ -851,17 +1686,17 @@ function EditorProvider({
       layoutMode: mode
     });
   }, []);
-  const [tiptapEditor, setTiptapEditorRaw] = useState2(null);
-  const [monacoEditor, setMonacoEditorRaw] = useState2(null);
-  const setTiptapEditor = useCallback2((editor) => {
+  const [tiptapEditor, setTiptapEditorRaw] = useState3(null);
+  const [monacoEditor, setMonacoEditorRaw] = useState3(null);
+  const setTiptapEditor = useCallback3((editor) => {
     tiptapEditorRef.current = editor;
     setTiptapEditorRaw(editor);
   }, []);
-  const setMonacoEditor = useCallback2((editor) => {
+  const setMonacoEditor = useCallback3((editor) => {
     monacoEditorRef.current = editor;
     setMonacoEditorRaw(editor);
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     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;
@@ -885,22 +1720,22 @@ function EditorProvider({
       clearTimeout(timeout);
     };
   }, [activeView, monacoEditor, tiptapEditor]);
-  const [activeSceneText, setActiveSceneText] = useState2(null);
-  const sceneTextChannel = useMemo2(createSceneTextChannel, []);
-  useEffect(() => sceneTextChannel.subscribe(setActiveSceneText), [sceneTextChannel]);
-  const articleIdRef = useRef(articleId);
+  const [activeSceneText, setActiveSceneText] = useState3(null);
+  const sceneTextChannel = useMemo3(createSceneTextChannel, []);
+  useEffect2(() => sceneTextChannel.subscribe(setActiveSceneText), [sceneTextChannel]);
+  const articleIdRef = useRef2(articleId);
   articleIdRef.current = articleId;
-  const fileNameRef = useRef(fileName);
+  const fileNameRef = useRef2(fileName);
   fileNameRef.current = fileName;
-  useEffect(() => {
+  useEffect2(() => {
     setColorScheme(initialColorScheme);
   }, [initialColorScheme]);
-  const parseTimeoutRef = useRef(null);
-  const skipInitialDebouncedParseRef = useRef(Boolean(initialMarkdown));
-  const doParse = useCallback2((source) => {
+  const parseTimeoutRef = useRef2(null);
+  const skipInitialDebouncedParseRef = useRef2(Boolean(initialMarkdown));
+  const doParse = useCallback3((source) => {
     setIsParsing(true);
     try {
-      const parsed = parseMarkdown2(source);
+      const parsed = parseMarkdown3(source);
       setMarkdownDocState(parsed);
       setParseError(null);
       try {
@@ -921,7 +1756,7 @@ function EditorProvider({
       setIsParsing(false);
     }
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     if (editorMode !== "markdown") return;
     if (skipInitialDebouncedParseRef.current) {
       skipInitialDebouncedParseRef.current = false;
@@ -940,13 +1775,13 @@ function EditorProvider({
       }
     };
   }, [markdownSource, doParse, editorMode]);
-  useEffect(() => {
+  useEffect2(() => {
     if (editorMode !== "markdown") return;
     if (initialMarkdown) {
       doParse(initialMarkdown);
     }
   }, []);
-  const setMarkdownSource = useCallback2((source) => {
+  const setMarkdownSource = useCallback3((source) => {
     setMarkdownSourceRaw(source);
   }, []);
   const blockNav = useBlockNavigator(markdownSource, setMarkdownSource, {
@@ -964,8 +1799,8 @@ function EditorProvider({
     nextBlock,
     addBlock
   } = blockNav;
-  const [selectionVersion, setSelectionVersion] = useState2(0);
-  useEffect(() => {
+  const [selectionVersion, setSelectionVersion] = useState3(0);
+  useEffect2(() => {
     const bump = () => setSelectionVersion((version) => version + 1);
     const disposers = [];
     if (typeof tiptapEditor?.on === "function" && typeof tiptapEditor.off === "function") {
@@ -982,7 +1817,7 @@ function EditorProvider({
       for (const dispose of disposers) dispose();
     };
   }, [tiptapEditor, monacoEditor]);
-  const getSelection = useCallback2(() => {
+  const getSelection = useCallback3(() => {
     if (activeView === "wysiwyg" && tiptapEditor) {
       const { from, to, empty } = tiptapEditor.state.selection;
       return {
@@ -1000,7 +1835,7 @@ function EditorProvider({
     }
     return null;
   }, [activeView, tiptapEditor, monacoEditor]);
-  const replaceSelection = useCallback2(
+  const replaceSelection = useCallback3(
     (markdown) => {
       if (activeView === "wysiwyg" && tiptapEditor) {
         tiptapEditor.chain().focus().insertContent(markdownToTiptap(markdown)).run();
@@ -1019,7 +1854,7 @@ function EditorProvider({
     },
     [activeView, tiptapEditor, monacoEditor]
   );
-  const getBlockAtCursor = useCallback2(() => {
+  const getBlockAtCursor = useCallback3(() => {
     if (activeView !== "raw" || !monacoEditor) return null;
     const model = monacoEditor.getModel();
     const position = monacoEditor.getPosition();
@@ -1028,7 +1863,7 @@ function EditorProvider({
     if (slices.length === 0) return null;
     return slices[sliceIndexAtOffset(slices, model.getOffsetAt(position))] ?? null;
   }, [activeView, monacoEditor]);
-  const insertAtCursor = useCallback2(
+  const insertAtCursor = useCallback3(
     (text) => {
       if (activeView === "wysiwyg" && tiptapEditor) {
         const html = markdownToTiptap(text);
@@ -1055,11 +1890,126 @@ function EditorProvider({
     },
     [activeView, tiptapEditor, monacoEditor]
   );
-  const replaceAll = useCallback2((text) => {
-    setMarkdownSourceRaw(text);
-  }, []);
-  const versioningWarnedRef = useRef(false);
-  useEffect(() => {
+  const applySourceEdits = useCallback3(
+    (edits, options) => {
+      if (editorMode !== "markdown" || layoutModeState !== "document") return false;
+      if (activeView === "raw" && monacoEditor) {
+        const model = monacoEditor.getModel();
+        if (!model) return false;
+        const base = model.getValue();
+        if (options?.baseSource !== void 0 && options.baseSource !== base) return false;
+        const sorted = normalizeSourceEdits(base, edits);
+        if (!sorted) return false;
+        if (sorted.length === 0) return true;
+        const ops = sorted.map((edit) => {
+          const start = model.getPositionAt(edit.start);
+          const end = model.getPositionAt(edit.end);
+          return {
+            range: {
+              startLineNumber: start.lineNumber,
+              startColumn: start.column,
+              endLineNumber: end.lineNumber,
+              endColumn: end.column
+            },
+            text: edit.text
+          };
+        });
+        monacoEditor.pushUndoStop();
+        monacoEditor.executeEdits("squisq-source-edits", ops);
+        monacoEditor.pushUndoStop();
+        return true;
+      }
+      if (activeView === "wysiwyg" && tiptapEditor) {
+        const base = markdownSourceRef.current;
+        if (options?.baseSource !== void 0 && options.baseSource !== base) return false;
+        const sorted = normalizeSourceEdits(base, edits);
+        if (!sorted) return false;
+        if (sorted.length === 0) return true;
+        setMarkdownSourceRaw(applySourceEditsToText(base, sorted));
+        return true;
+      }
+      return false;
+    },
+    [activeView, editorMode, layoutModeState, monacoEditor, tiptapEditor]
+  );
+  const replaceAll = useCallback3(
+    (text) => {
+      const base = activeView === "raw" && monacoEditor ? monacoEditor.getModel()?.getValue() ?? null : markdownSourceRef.current;
+      const edit = base === null ? null : minimalReplaceEdit(base, text);
+      if (edit && applySourceEdits([edit])) return;
+      setMarkdownSourceRaw(text);
+    },
+    [activeView, monacoEditor, applySourceEdits]
+  );
+  const insertBlockAfterCursor = useCallback3(
+    (block, options) => {
+      if (editorMode !== "markdown") return false;
+      const placement = options?.placement ?? "afterBlock";
+      const build = (context) => {
+        const markdown = typeof block === "function" ? block(context) : block;
+        return markdown && markdown.trim() ? markdown : null;
+      };
+      if (activeView === "wysiwyg" && tiptapEditor) {
+        const { pos, ...context } = tiptapBlockInsertion(tiptapEditor.state, placement);
+        const markdown = build(context);
+        if (markdown === null) return false;
+        let content;
+        try {
+          content = createDocument(markdownToTiptap(markdown), tiptapEditor.schema).content;
+        } catch {
+          return false;
+        }
+        if (content.size === 0) return false;
+        const inserted = tiptapEditor.chain().command(({ tr, dispatch }) => {
+          if (dispatch) {
+            closeHistory2(tr);
+            tr.insert(pos, content);
+          }
+          return true;
+        }).run();
+        if (inserted) {
+          const dom = tiptapEditor.view.nodeDOM(pos);
+          if (dom instanceof HTMLElement && typeof dom.scrollIntoView === "function") {
+            dom.scrollIntoView({ block: "nearest" });
+          }
+        }
+        return inserted;
+      }
+      if (activeView === "raw" && monacoEditor) {
+        const model = monacoEditor.getModel();
+        const selection = monacoEditor.getSelection();
+        if (!model || !selection) return false;
+        const source = model.getValue();
+        const cursorOffset = model.getOffsetAt(selection.getEndPosition());
+        const { offset, ...context } = blockInsertionPoint(source, cursorOffset, placement);
+        const markdown = build(context);
+        if (markdown === null) return false;
+        const edit = joinBlockAt(source, offset, markdown);
+        const start = model.getPositionAt(edit.start);
+        const end = model.getPositionAt(edit.end);
+        monacoEditor.pushUndoStop();
+        monacoEditor.executeEdits("squisq-insert-block", [
+          {
+            range: {
+              startLineNumber: start.lineNumber,
+              startColumn: start.column,
+              endLineNumber: end.lineNumber,
+              endColumn: end.column
+            },
+            text: edit.text
+          }
+        ]);
+        monacoEditor.pushUndoStop();
+        const firstLine = model.getPositionAt(Math.min(edit.start + 1, model.getValueLength()));
+        monacoEditor.revealLineInCenterIfOutsideViewport?.(firstLine.lineNumber);
+        return true;
+      }
+      return false;
+    },
+    [activeView, editorMode, monacoEditor, tiptapEditor]
+  );
+  const versioningWarnedRef = useRef2(false);
+  useEffect2(() => {
     if (allowVersioning && !workspaceContainer && !versioningWarnedRef.current) {
       console.warn(
         "[squisq-editor] allowVersioning requires a `workspaceContainer` prop; versioning is disabled."
@@ -1067,15 +2017,15 @@ function EditorProvider({
       versioningWarnedRef.current = true;
     }
   }, [allowVersioning, workspaceContainer]);
-  const versioning = useMemo2(() => {
+  const versioning = useMemo3(() => {
     if (!allowVersioning || !workspaceContainer) return null;
     return new DocumentVersionManager(workspaceContainer, { basename: versionBasename });
   }, [allowVersioning, workspaceContainer, versionBasename]);
-  const onSaveVersionRef = useRef(onSaveVersion);
+  const onSaveVersionRef = useRef2(onSaveVersion);
   onSaveVersionRef.current = onSaveVersion;
-  const prunePolicyRef = useRef(versioningPrunePolicy);
+  const prunePolicyRef = useRef2(versioningPrunePolicy);
   prunePolicyRef.current = versioningPrunePolicy;
-  const saveVersion = useCallback2(
+  const saveVersion = useCallback3(
     async (options) => {
       if (!versioning) {
         const skipped = { saved: false, version: null, reason: "no-document" };
@@ -1096,8 +2046,8 @@ function EditorProvider({
     },
     [versioning]
   );
-  const autoSaveSourceRef = useRef(null);
-  useEffect(() => {
+  const autoSaveSourceRef = useRef2(null);
+  useEffect2(() => {
     if (!versioning) return;
     if (versioningAutoSaveIdleMs <= 0) return;
     const previous = autoSaveSourceRef.current;
@@ -1113,7 +2063,7 @@ function EditorProvider({
     }, versioningAutoSaveIdleMs);
     return () => clearTimeout(timer);
   }, [markdownSource, versioning, versioningAutoSaveIdleMs, saveVersion]);
-  const setMarkdownDoc = useCallback2((newDoc) => {
+  const setMarkdownDoc = useCallback3((newDoc) => {
     setMarkdownDocState(newDoc);
     try {
       const newSource = stringifyMarkdown(newDoc);
@@ -1133,12 +2083,12 @@ function EditorProvider({
       setParseError(err instanceof Error ? err.message : "Stringify error");
     }
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     if (mediaEditRenders && doc) mediaEditRenders.sync(doc, embeddedMediaClips(doc));
   }, [mediaEditRenders, doc]);
-  const latestDocRef = useRef(doc);
+  const latestDocRef = useRef2(doc);
   latestDocRef.current = doc;
-  useEffect(() => {
+  useEffect2(() => {
     if (!mediaEditRenders) return;
     const timer = setTimeout(() => {
       const current = latestDocRef.current;
@@ -1147,7 +2097,15 @@ function EditorProvider({
     }, MEDIA_EDIT_GC_DELAY_MS);
     return () => clearTimeout(timer);
   }, [mediaEditRenders]);
-  const value = useMemo2(
+  const dictationController = useDictationController({
+    capability: speechInput,
+    activeView,
+    editorMode,
+    tiptapEditor,
+    monacoEditor
+  });
+  const dictation = dictationController.control;
+  const value = useMemo3(
     () => ({
       markdownSource,
       markdownDoc,
@@ -1193,6 +2151,7 @@ function EditorProvider({
       proofingSpellingEnabled,
       proofingGrammarEnabled,
       proofingIgnoreStore,
+      dictation,
       articleId,
       documentLinkProvider,
       fenceRenderers,
@@ -1226,6 +2185,8 @@ function EditorProvider({
       getBlockAtCursor,
       insertAtCursor,
       replaceAll,
+      applySourceEdits,
+      insertBlockAfterCursor,
       openImageEdit,
       closeImageEdit,
       openMediaEdit,
@@ -1271,6 +2232,7 @@ function EditorProvider({
       proofingSpellingEnabled,
       proofingGrammarEnabled,
       proofingIgnoreStore,
+      dictation,
       articleId,
       documentLinkProvider,
       fenceRenderers,
@@ -1304,6 +2266,8 @@ function EditorProvider({
       getBlockAtCursor,
       insertAtCursor,
       replaceAll,
+      applySourceEdits,
+      insertBlockAfterCursor,
       imageEditTarget,
       mediaEditTarget,
       mediaRevision,
@@ -1317,7 +2281,7 @@ function EditorProvider({
       bumpMediaRevision
     ]
   );
-  return /* @__PURE__ */ jsx(EditorContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx(EditorContext.Provider, { value, children: /* @__PURE__ */ jsx(DictationStateContext.Provider, { value: dictationController.state, children }) });
 }
 
 // src/review/decorations.ts
@@ -1395,17 +2359,17 @@ function suggestionLabel(kind) {
 }
 
 // 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");
+import { Extension as Extension2 } from "@tiptap/core";
+import { Plugin as Plugin2, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+var REVIEW_KEY = new PluginKey2("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(
+      Decoration2.inline(
         spec.from,
         spec.to,
         {
@@ -1417,16 +2381,16 @@ function buildSet(doc, specs) {
       )
     );
   }
-  return DecorationSet.create(doc, decorations);
+  return DecorationSet2.create(doc, decorations);
 }
-var ReviewExtension = Extension.create({
+var ReviewExtension = Extension2.create({
   name: "squisqReview",
   addProseMirrorPlugins() {
     return [
-      new Plugin({
+      new Plugin2({
         key: REVIEW_KEY,
         state: {
-          init: () => ({ decorations: DecorationSet.empty }),
+          init: () => ({ decorations: DecorationSet2.empty }),
           apply: (transaction, previous) => {
             const meta = transaction.getMeta(REVIEW_KEY);
             if (meta) return { decorations: buildSet(transaction.doc, meta.specs) };
@@ -1685,7 +2649,7 @@ function messageOf(error) {
 }
 
 // src/review/useReview.ts
-import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo3, useRef as useRef2, useState as useState3 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useMemo as useMemo4, useRef as useRef3, useState as useState4 } from "react";
 var EMPTY = [];
 var EMPTY_FINDINGS = [];
 function useReview(capabilities = EMPTY) {
@@ -1698,23 +2662,23 @@ function useReview(capabilities = EMPTY) {
     articleId,
     goToBlockByLine
   } = useEditorContext();
-  const providers = useMemo3(
+  const providers = useMemo4(
     () => capabilities.map(resolveReviewProvider),
     [capabilities]
   );
-  const [snapshot, setSnapshot] = useState3(null);
-  const sourceRef = useRef2(markdownSource);
-  const revisionRef = useRef2(0);
-  const blocksRef = useRef2([]);
-  const runnerRef = useRef2(null);
+  const [snapshot, setSnapshot] = useState4(null);
+  const sourceRef = useRef3(markdownSource);
+  const revisionRef = useRef3(0);
+  const blocksRef = useRef3([]);
+  const runnerRef = useRef3(null);
   sourceRef.current = markdownSource;
-  const hueFor = useMemo3(() => {
+  const hueFor = useMemo4(() => {
     const hues = new Map(
       providers.map((provider) => [provider.id, provider.hue ?? DEFAULT_REVIEW_HUE])
     );
     return (source) => hues.get(source) ?? DEFAULT_REVIEW_HUE;
   }, [providers]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (providers.length === 0) {
       setSnapshot(null);
       return;
@@ -1741,12 +2705,12 @@ function useReview(capabilities = EMPTY) {
       runnerRef.current = null;
     };
   }, [providers, articleId, fileName]);
-  useEffect2(() => {
+  useEffect3(() => {
     revisionRef.current += 1;
     runnerRef.current?.schedule();
   }, [markdownSource]);
-  const findings = useMemo3(() => snapshot?.findings ?? EMPTY_FINDINGS, [snapshot]);
-  useEffect2(() => {
+  const findings = useMemo4(() => snapshot?.findings ?? EMPTY_FINDINGS, [snapshot]);
+  useEffect3(() => {
     if (!tiptapEditor || activeView !== "wysiwyg") return;
     if (findings.length === 0) {
       clearReviewDecorations(tiptapEditor);
@@ -1757,8 +2721,8 @@ function useReview(capabilities = EMPTY) {
       buildWriteViewDecorations(tiptapEditor.state.doc, findings, hueFor)
     );
   }, [tiptapEditor, activeView, findings, hueFor]);
-  const collectionRef = useRef2(null);
-  useEffect2(() => {
+  const collectionRef = useRef3(null);
+  useEffect3(() => {
     if (!monacoEditor || activeView !== "raw") return;
     const model = monacoEditor.getModel();
     if (!model) return;
@@ -1768,7 +2732,7 @@ function useReview(capabilities = EMPTY) {
       collectionRef.current?.clear();
     };
   }, [monacoEditor, activeView, findings, hueFor]);
-  const goToFinding = useCallback3(
+  const goToFinding = useCallback4(
     (findingId) => {
       const finding = findings.find((candidate) => candidate.id === findingId);
       if (!finding) return;
@@ -1779,22 +2743,22 @@ function useReview(capabilities = EMPTY) {
     },
     [findings, goToBlockByLine]
   );
-  const reviewNow = useCallback3(() => runnerRef.current?.runNow(), []);
-  const dismissFinding = useCallback3((findingId) => {
+  const reviewNow = useCallback4(() => runnerRef.current?.runNow(), []);
+  const dismissFinding = useCallback4((findingId) => {
     runnerRef.current?.removeFinding(findingId);
   }, []);
-  return useMemo3(
+  return useMemo4(
     () => snapshot ? { ...snapshot, reviewNow, dismissFinding, goToFinding } : null,
     [snapshot, reviewNow, dismissFinding, goToFinding]
   );
 }
 
 // src/review/ReviewContext.tsx
-import { createContext as createContext2, useContext as useContext2 } from "react";
+import { createContext as createContext3, useContext as useContext3 } from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
-var ReviewStateContext = createContext2(null);
+var ReviewStateContext = createContext3(null);
 function useReviewState() {
-  return useContext2(ReviewStateContext);
+  return useContext3(ReviewStateContext);
 }
 function ReviewRoot({
   providers,
@@ -1888,12 +2852,23 @@ function Row({
 }
 
 export {
+  DictationExtension,
+  useDictationState,
   stripFrontmatter,
   getBlockSlices,
   spliceBlock,
   lineToOffset,
   offsetToLine,
   sliceIndexAtOffset,
+  normalizeSourceEdits,
+  applySourceEditsToText,
+  minimalReplaceEdit,
+  resolveOutlineInsertion,
+  headingDepthForInsertion,
+  sourceOutline,
+  blockInsertionPoint,
+  joinBlockAt,
+  tiptapBlockInsertion,
   detectLanguageFromFileName,
   resolveFileKind,
   useBlockNavigator,