mrmd-editor 0.7.0 → 0.8.0

package/src/index.js

@@ -31,7 +31,7 @@
 // #region IMPORTS
 import { EditorView, basicSetup } from 'codemirror';
 import { EditorState, StateEffect, Compartment, Text, Transaction } from '@codemirror/state';
-import { keymap, Decoration, ViewPlugin, WidgetType, placeholder } from '@codemirror/view';
+import { keymap, Decoration, ViewPlugin, WidgetType, placeholder, highlightWhitespace } from '@codemirror/view';
 import { StreamLanguage, syntaxTree, syntaxHighlighting, defaultHighlightStyle } from '@codemirror/language';
 import { createCodemirrorTheme } from './widgets/codemirror-theme.js';
 
@@ -64,8 +64,44 @@ import { WebsocketProvider } from 'y-websocket';
 // Internal modules
 import { findCells, getCellAtCursor, countCells, findTerminalBlocks, isTerminalLanguage } from './cells.js';
 import { RuntimeRegistry, createRuntimeRegistry } from './runtime.js';
+import {
+  defaultDocumentTemplate,
+  documentTemplatePresets,
+  normalizeDocumentTemplate,
+  cloneDocumentTemplate,
+  createDocumentTemplateExtension,
+  compileDocumentTemplateCSS,
+  serializeDocumentTemplateToCss,
+  findDocumentTemplatePreset,
+  resolveFontForExport,
+  serializeDocumentTemplateToPandocMeta,
+  serializeDocumentTemplateToPandocYaml,
+  serializeDocumentTemplateToLatexPreamble,
+  serializeDocumentTemplateToHtml,
+  serializeDocumentTemplateToWordStyleMap,
+  buildPandocCommand,
+} from './document-template.js';
+import { parseFrontmatter, readFrontmatterValue, updateFrontmatterField } from './frontmatter-updater.js';
 import { ExecutionManager, createExecutionManager } from './execution.js';
 import { MonitorCoordination, EXECUTION_STATUS, createMonitorCoordination } from './monitor-coordination.js';
+import * as linkedTables from './tables/index.js';
+import {
+  LINKED_TABLE_EVENT,
+  dispatchLinkedTableAction,
+  openLinkedTableWorkspace,
+  canImportLinkedTableFromHost,
+  normalizeLinkedTableBlockInsertion,
+  insertLinkedTableBlock,
+  importLinkedTableFromHost,
+  TableJobsClient,
+  TABLE_JOB_STATUS,
+  createTableJobsClient,
+  createLinkedTableController,
+  LinkedTableController,
+  createLinkedTableBlockAnchor,
+  resolveLinkedTableBlockAnchor,
+  linkedTableMarkdownState,
+} from './tables/index.js';
 import { MRPClient } from './mrp-client.js';
 
 // Shell (status bar, file management, studio layout)
@@ -83,20 +119,8 @@ import * as commentSyntaxModule from './comment-syntax.js';
 // Cell controls (run buttons, queue, status)
 import { createCellControls, CellControlsSystem } from './cell-controls/index.js';
 
-// Runtime CodeLens (inline session controls)
-import {
-  createRuntimeCodeLensExtensions,
-  rebuildRuntimeCodeLens,
-  runtimeCodeLensFacet,
-  runtimeCodeLensPlugin,
-  rebuildRuntimeCodeLensEffect,
-  injectRuntimeCodeLensStyles,
-  removeRuntimeCodeLensStyles,
-  findRuntimeBlocks,
-  findYamlConfigBlocks,
-  findSessionFrontmatter,
-  RuntimeCodeLensWidget,
-} from './runtime-codelens/index.js';
+// Section controls (AI/formatting next to focused line)
+import { sectionControls } from './section-controls/index.js';
 
 // Commands and keymap
 import { commandRegistry } from './commands.js';
@@ -108,10 +132,24 @@ import {
   adaptMRPClient,
   createRuntimeHoverExtension,
   createRuntimeCompletionExtension,
+  createRuntimeSignatureHelpExtension,
   createVariableExplorer,
   injectRuntimeLspStyles,
 } from './runtime-lsp.js';
 
+// Spellcheck (prose-only, disabled in code blocks)
+import { createSpellcheckExtensions } from './spellcheck.js';
+// Grammar diagnostics (LanguageTool host integration)
+import {
+  createLanguageToolDiagnosticsExtension,
+  collectVisibleProseFragments,
+  forceLanguageToolRefresh,
+  refreshLanguageToolDiagnostics,
+  applyFirstLanguageToolSuggestion,
+  getLanguageToolSuggestionMenu,
+  applyLanguageToolSuggestionAt,
+} from './grammar.js';
+
 // Wiki-link completion ([[internal-links]])
 import {
   projectFilesFacet,
@@ -157,6 +195,14 @@ import {
   markdown as markdownRendering,
   markdownRenderer,
   assetResolverFacet,  // Facet for resolving asset URLs in Electron/desktop apps
+  sourceModeFacet,     // Facet to toggle source/raw markdown view
+  wysiwygModeFacet,    // Facet to toggle protected WYSIWYG rendering
+  createWysiwygExtensions,
+  createInlineEditingExtensions,
+  toggleInlineFormat,
+  toggleInlineMark,
+  getSelectionFormattingState,
+  findFencedCodeAt,
   blockDecorations,  // StateField for tables, display math (multi-line replace)
   lineHeightTracker, // ViewPlugin for accurate line height tracking
   markdownStyles,
@@ -174,6 +220,9 @@ import {
   AlertTitleWidget,
 } from './markdown/index.js';
 
+// Page view pagination (spacer-based page breaks)
+import { pageViewPagination } from './page-view-pagination.js';
+
 // Awareness system
 import {
   createAwareness,
@@ -681,6 +730,12 @@ const codeBlockBackground = ViewPlugin.fromClass(class {
           const firstLine = view.state.doc.lineAt(from);
           const lastLine = view.state.doc.lineAt(to);
 
+          // Extract language from the opening fence line
+          const fenceText = firstLine.text;
+          const langMatch = fenceText.match(/^(\s*`{3,}|~{3,})\s*(\S*)/);
+          const rawLang = langMatch?.[2] || '';
+          const language = normalizeCodeLanguage(rawLang);
+
           // Iterate through each line in the code block
           for (let pos = from; pos < to;) {
             const line = view.state.doc.lineAt(pos);
@@ -690,12 +745,18 @@ const codeBlockBackground = ViewPlugin.fromClass(class {
             if (isFirstLine || isLastLine) {
               // Fence lines - subtle styling
               decorations.push(
-                Decoration.line({ class: 'cm-codeblock-fence' }).range(line.from)
+                Decoration.line({
+                  class: 'cm-codeblock-fence',
+                  attributes: language ? { 'data-lang': language } : undefined,
+                }).range(line.from)
               );
             } else {
               // Content lines - normal code block styling
               decorations.push(
-                Decoration.line({ class: 'cm-codeblock-line' }).range(line.from)
+                Decoration.line({
+                  class: 'cm-codeblock-line',
+                  attributes: language ? { 'data-lang': language } : undefined,
+                }).range(line.from)
               );
             }
             pos = line.to + 1;
@@ -754,6 +815,99 @@ const codeBlockStyles = EditorView.theme({
 });
 // #endregion CODE_BLOCK_BACKGROUND
 
+// #region INVISIBLE_CHARACTERS
+/**
+ * Extension that shows newline markers (¶) at the end of each line.
+ * Used in combination with CM6's built-in highlightWhitespace() for
+ * spaces and tabs. Together they provide full invisible character rendering.
+ */
+class NewlineMarkerWidget extends WidgetType {
+  eq() { return true; }
+  toDOM() {
+    const span = document.createElement('span');
+    span.className = 'cm-newline-marker';
+    span.textContent = '¶';
+    span.setAttribute('aria-hidden', 'true');
+    return span;
+  }
+  ignoreEvent() { return true; }
+}
+
+const newlineMarkerPlugin = ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      this.decorations = this.buildDecorations(view);
+    }
+
+    update(update) {
+      if (update.docChanged || update.viewportChanged) {
+        this.decorations = this.buildDecorations(update.view);
+      }
+    }
+
+    buildDecorations(view) {
+      const decorations = [];
+      const doc = view.state.doc;
+
+      for (let i = doc.lineAt(view.viewport.from).number; i <= doc.lineAt(view.viewport.to).number; i++) {
+        const line = doc.line(i);
+        // Add newline marker at the end of each line (except the last line if it has no trailing newline)
+        if (i < doc.lines) {
+          decorations.push(
+            Decoration.widget({
+              widget: new NewlineMarkerWidget(),
+              side: 1, // After the line content
+            }).range(line.to)
+          );
+        }
+      }
+
+      return Decoration.set(decorations, true);
+    }
+  },
+  { decorations: (v) => v.decorations }
+);
+
+/**
+ * Styles for invisible character markers.
+ * Overrides CM6's default whitespace styling with more visible symbols.
+ */
+const invisibleCharStyles = EditorView.theme({
+  // Newline markers (¶)
+  '.cm-newline-marker': {
+    color: 'var(--md-marker-color, #aaa)',
+    opacity: '0.5',
+    fontSize: '0.8em',
+    userSelect: 'none',
+    pointerEvents: 'none',
+  },
+  // Override CM6's default space dots - make them subtler
+  '.cm-highlightSpace': {
+    backgroundImage: 'radial-gradient(circle at 50% 55%, var(--md-marker-color, #aaa) 20%, transparent 5%)',
+    opacity: '0.4',
+  },
+  // Override CM6's tab arrows
+  '.cm-highlightTab': {
+    backgroundImage: `url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="200" height="20"><path stroke="%23aaa" stroke-width="1" fill="none" d="M1 10H196L190 5M190 15L196 10M197 4L197 16"/></svg>')`,
+    opacity: '0.5',
+  },
+});
+
+/**
+ * Create the invisibles extension bundle.
+ * Includes whitespace highlighting + newline markers + styles.
+ *
+ * @returns {import('@codemirror/state').Extension}
+ */
+function createInvisiblesExtension() {
+  return [
+    highlightWhitespace(),
+    newlineMarkerPlugin,
+    invisibleCharStyles,
+  ];
+}
+// #endregion INVISIBLE_CHARACTERS
+
 // #region WRITER
 /**
  * Writer for streaming content into the editor.
@@ -791,6 +945,457 @@ class Writer {
 }
 // #endregion WRITER
 
+// #region INITIAL_CURSOR
+/**
+ * Find the ideal initial cursor position for a markdown document.
+ *
+ * When opening a file, placing the cursor at position 0 shows raw frontmatter
+ * YAML which looks ugly. Instead, we find the first empty line after any
+ * frontmatter block — this causes the frontmatter to render as a nice widget
+ * and gives a clean first impression.
+ *
+ * @param {string} content - Document content
+ * @returns {number} Character position for the cursor
+ */
+function findInitialCursorPosition(content) {
+  if (!content) return 0;
+
+  const lines = content.split('\n');
+  let i = 0;
+
+  // Skip YAML frontmatter if present (--- ... ---)
+  if (lines[0]?.trim() === '---') {
+    i = 1;
+    while (i < lines.length && lines[i]?.trim() !== '---') {
+      i++;
+    }
+    if (i < lines.length) i++; // skip closing ---
+  }
+
+  // Find first empty line from current position
+  while (i < lines.length) {
+    if (lines[i]?.trim() === '') {
+      // Calculate character position (start of this empty line)
+      let pos = 0;
+      for (let j = 0; j < i; j++) {
+        pos += lines[j].length + 1; // +1 for \n
+      }
+      return pos;
+    }
+    i++;
+  }
+
+  return 0; // fallback to start
+}
+
+function wrapSelectionsWith(view, open, close = open, userEvent = 'input.wysiwyg.format') {
+  const state = view.state;
+  const changes = [];
+  const ranges = [];
+  let delta = 0;
+
+  for (const range of state.selection.ranges) {
+    if (range.empty) {
+      changes.push({ from: range.from, insert: open + close });
+      const pos = range.from + open.length + delta;
+      ranges.push({ anchor: pos, head: pos });
+      delta += open.length + close.length;
+    } else {
+      changes.push({ from: range.from, insert: open });
+      changes.push({ from: range.to, insert: close });
+      ranges.push({ anchor: range.from + open.length + delta, head: range.to + open.length + delta });
+      delta += open.length + close.length;
+    }
+  }
+
+  view.dispatch({
+    changes,
+    selection: { ranges, mainIndex: state.selection.mainIndex },
+    userEvent,
+  });
+}
+
+function currentLineStructuralPrefix(lineText) {
+  const heading = lineText.match(/^\s{0,3}(#{1,6})\s+/);
+  if (heading) return heading[0];
+  const quote = lineText.match(/^(\s*>\s?)+/);
+  if (quote) return quote[0];
+  const list = lineText.match(/^(\s*)(?:[-+*]|\d+\.)\s+/);
+  if (list) return list[0];
+  return '';
+}
+
+function getCurrentBlockTypeInfo(view) {
+  const pos = view.state.selection.main.head;
+  const line = view.state.doc.lineAt(pos);
+  const text = line.text;
+
+  // ── Check if inside a fenced code block ──
+  const tree = syntaxTree(view.state);
+  let fencedCode = null;
+  tree.iterate({
+    from: Math.max(0, pos - 1),
+    to: pos + 1,
+    enter: (node) => {
+      if (node.name === 'FencedCode' && node.from <= pos && node.to >= pos) {
+        fencedCode = node;
+      }
+    },
+  });
+
+  if (fencedCode) {
+    // Extract language from the opening fence line (```python, ```r, etc.)
+    const fenceLine = view.state.doc.lineAt(fencedCode.from);
+    const fenceText = fenceLine.text;
+    const langMatch = fenceText.match(/^(\s*`{3,}|~{3,})\s*(\S*)/);
+    const rawLang = langMatch?.[2] || '';
+    const language = normalizeCodeLanguage(rawLang);
+
+    // Determine if cursor is on the fence line itself or inside code content
+    const isOnFence = line.number === fenceLine.number ||
+      line.number === view.state.doc.lineAt(fencedCode.to).number;
+
+    // Detect the syntax token under the cursor
+    const syntaxToken = isOnFence ? null : getSyntaxTokenAtPos(view, pos);
+
+    return {
+      type: 'codeblock',
+      level: 0,
+      label: language ? `codeblock-${language}` : 'codeblock',
+      language,
+      isOnFence,
+      syntaxToken,
+      fenceFrom: fencedCode.from,
+      fenceTo: fencedCode.to,
+    };
+  }
+
+  const heading = text.match(/^\s{0,3}(#{1,6})\s+/);
+  if (heading) {
+    return { type: 'heading', level: heading[1].length, label: `h${heading[1].length}` };
+  }
+
+  if (/^(\s*>\s?)+/.test(text)) {
+    return { type: 'blockquote', level: 1, label: 'blockquote' };
+  }
+
+  if (/^(\s*)(?:[-+*])\s+/.test(text)) {
+    return { type: 'unordered-list', level: 1, label: 'unordered-list' };
+  }
+
+  if (/^(\s*)(?:\d+\.)\s+/.test(text)) {
+    return { type: 'ordered-list', level: 1, label: 'ordered-list' };
+  }
+
+  return { type: 'paragraph', level: 0, label: 'paragraph' };
+}
+
+/**
+ * Normalize code language aliases to canonical names matching template keys.
+ */
+function normalizeCodeLanguage(raw) {
+  if (!raw) return '';
+  const lang = raw.toLowerCase().trim();
+  const map = {
+    'js': 'javascript', 'node': 'javascript', 'ecmascript': 'javascript',
+    'ts': 'typescript',
+    'py': 'python', 'python3': 'python',
+    'rb': 'ruby',
+    'rs': 'rust',
+    'sh': 'shell', 'bash': 'shell', 'zsh': 'shell', 'fish': 'shell',
+    'ps1': 'powershell', 'pwsh': 'powershell',
+    'yml': 'yaml',
+    'htm': 'html',
+    'c': 'cpp', 'c++': 'cpp', 'cxx': 'cpp', 'h': 'cpp', 'hpp': 'cpp',
+    'golang': 'go',
+    'jl': 'julia',
+    'rlang': 'r',
+    'mysql': 'sql', 'postgresql': 'sql', 'postgres': 'sql', 'sqlite': 'sql',
+    'jsonc': 'json',
+    'jsx': 'javascript', 'tsx': 'typescript',
+    'xml': 'html', 'svg': 'html',
+  };
+  return map[lang] || lang;
+}
+
+/**
+ * Get the semantic syntax token type at a position within a code block.
+ * Maps CodeMirror/Lezer highlight tags to our template token names.
+ *
+ * @param {EditorView} view
+ * @param {number} pos
+ * @returns {string|null} Token name like 'keyword', 'string', 'comment', etc.
+ */
+function getSyntaxTokenAtPos(view, pos) {
+  const tree = syntaxTree(view.state);
+  let bestNode = null;
+  let bestSize = Infinity;
+
+  // Find the most specific (smallest) node at pos
+  tree.iterate({
+    from: pos,
+    to: pos + 1,
+    enter: (node) => {
+      const size = node.to - node.from;
+      if (size < bestSize && node.from <= pos && node.to > pos) {
+        bestNode = node;
+        bestSize = size;
+      }
+    },
+  });
+
+  if (!bestNode) return null;
+  const name = bestNode.name;
+
+  // Map Lezer tree node names to our semantic token names.
+  // These are the node names from @lezer/highlight and language parsers.
+  const tokenMap = {
+    // Keywords
+    'Keyword': 'keyword',
+    'keyword': 'keyword',
+    'ControlKeyword': 'controlKeyword',
+    'controlKeyword': 'controlKeyword',
+    'for': 'controlKeyword',
+    'if': 'controlKeyword',
+    'else': 'controlKeyword',
+    'while': 'controlKeyword',
+    'return': 'keyword',
+    'def': 'keyword',
+    'class': 'keyword',
+    'import': 'keyword',
+    'from': 'keyword',
+    'as': 'keyword',
+    'in': 'keyword',
+    'not': 'keyword',
+    'and': 'keyword',
+    'or': 'keyword',
+    'is': 'keyword',
+    'with': 'keyword',
+    'try': 'controlKeyword',
+    'except': 'controlKeyword',
+    'finally': 'controlKeyword',
+    'raise': 'keyword',
+    'yield': 'keyword',
+    'lambda': 'keyword',
+    'pass': 'keyword',
+    'break': 'controlKeyword',
+    'continue': 'controlKeyword',
+    'del': 'keyword',
+    'global': 'keyword',
+    'nonlocal': 'keyword',
+    'assert': 'keyword',
+    'async': 'keyword',
+    'await': 'keyword',
+    'let': 'keyword',
+    'const': 'keyword',
+    'var': 'keyword',
+    'function': 'keyword',
+    'switch': 'controlKeyword',
+    'case': 'controlKeyword',
+    'default': 'controlKeyword',
+    'do': 'controlKeyword',
+    'throw': 'keyword',
+    'catch': 'controlKeyword',
+    'new': 'keyword',
+    'this': 'keyword',
+    'super': 'keyword',
+    'extends': 'keyword',
+    'implements': 'keyword',
+    'interface': 'keyword',
+    'enum': 'keyword',
+    'export': 'keyword',
+    'typeof': 'keyword',
+    'instanceof': 'keyword',
+    'void': 'keyword',
+    'delete': 'keyword',
+
+    // Strings
+    'String': 'string',
+    'string': 'string',
+    'TemplateString': 'string',
+    'FormatString': 'string',
+    'Character': 'string',
+
+    // Numbers
+    'Number': 'number',
+    'number': 'number',
+    'Integer': 'number',
+    'Float': 'number',
+
+    // Comments
+    'Comment': 'comment',
+    'comment': 'comment',
+    'LineComment': 'comment',
+    'BlockComment': 'comment',
+
+    // Functions
+    'FunctionDefinition': 'function',
+    'FunctionDeclaration': 'function',
+    'CallExpression': 'function',
+
+    // Variables
+    'VariableName': 'variable',
+    'VariableDefinition': 'variable',
+
+    // Types
+    'TypeName': 'type',
+    'TypeDefinition': 'type',
+    'ClassName': 'type',
+    'ClassDefinition': 'type',
+
+    // Operators
+    'ArithOp': 'operator',
+    'LogicOp': 'operator',
+    'BitOp': 'operator',
+    'CompareOp': 'operator',
+    'AssignOp': 'operator',
+    'Equals': 'operator',
+
+    // Punctuation
+    'Punctuation': 'punctuation',
+    '(': 'punctuation',
+    ')': 'punctuation',
+    '[': 'punctuation',
+    ']': 'punctuation',
+    '{': 'punctuation',
+    '}': 'punctuation',
+    '.': 'punctuation',
+    ',': 'punctuation',
+    ';': 'punctuation',
+    ':': 'punctuation',
+
+    // Properties
+    'PropertyName': 'property',
+    'PropertyDefinition': 'property',
+
+    // Constants
+    'BooleanLiteral': 'constant',
+    'Boolean': 'constant',
+    'True': 'constant',
+    'False': 'constant',
+    'None': 'constant',
+    'Null': 'constant',
+    'null': 'constant',
+    'undefined': 'constant',
+
+    // Regex
+    'RegExp': 'regexp',
+
+    // Escape
+    'Escape': 'escape',
+    'EscapeSequence': 'escape',
+
+    // Tags (HTML/XML)
+    'TagName': 'tag',
+    'StartTag': 'tag',
+    'EndTag': 'tag',
+    'SelfClosingTag': 'tag',
+
+    // Attributes
+    'AttributeName': 'attribute',
+    'AttributeValue': 'attributeValue',
+
+    // Meta / decorators
+    'Decorator': 'meta',
+    'Annotation': 'meta',
+    'Meta': 'meta',
+    'ProcessingInstruction': 'meta',
+  };
+
+  // Direct match
+  if (tokenMap[name]) return tokenMap[name];
+
+  // Try resolving from the tree directly and walking up parent nodes
+  try {
+    let node = tree.resolveInner(pos, 1);
+    let depth = 0;
+    while (node && depth < 8) {
+      if (tokenMap[node.name]) return tokenMap[node.name];
+      node = node.parent;
+      depth++;
+    }
+  } catch (e) { /* ignore tree resolution errors */ }
+
+  return null;
+}
+
+function getSelectionFormattingInfo(view) {
+  return getSelectionFormattingState(view);
+}
+
+function setCurrentBlockType(view, type, options = {}) {
+  const state = view.state;
+  const pos = state.selection.main.head;
+  const line = state.doc.lineAt(pos);
+  const prefix = currentLineStructuralPrefix(line.text);
+  const contentStart = line.from + prefix.length;
+  let newPrefix = '';
+
+  if (type === 'paragraph') {
+    newPrefix = '';
+  } else if (type === 'heading') {
+    const level = Math.max(1, Math.min(6, Number(options.level) || 1));
+    newPrefix = '#'.repeat(level) + ' ';
+  } else if (type === 'blockquote') {
+    newPrefix = '> ';
+  } else if (type === 'unordered-list') {
+    newPrefix = '- ';
+  } else if (type === 'ordered-list') {
+    newPrefix = '1. ';
+  } else {
+    return false;
+  }
+
+  view.dispatch({
+    changes: { from: line.from, to: contentStart, insert: newPrefix },
+    selection: { anchor: line.from + newPrefix.length + Math.max(0, pos - contentStart) },
+    userEvent: 'input.wysiwyg.blocktype',
+  });
+  return true;
+}
+
+function insertLinkAtSelection(view, url, text = null) {
+  const state = view.state;
+  const range = state.selection.main;
+  const selected = state.sliceDoc(range.from, range.to);
+  const label = text ?? selected ?? 'link';
+  const link = `[${label}](${url})`;
+  const insertFrom = range.from;
+  const insertTo = range.to;
+  view.dispatch({
+    changes: { from: insertFrom, to: insertTo, insert: link },
+    selection: { anchor: insertFrom + 1, head: insertFrom + 1 + label.length },
+    userEvent: 'input.wysiwyg.link',
+  });
+  return true;
+}
+
+function insertImageAtSelection(view, url, alt = 'image') {
+  const pos = view.state.selection.main.head;
+  const image = `![${alt}](${url})`;
+  view.dispatch({
+    changes: { from: pos, insert: image },
+    selection: { anchor: pos + 2, head: pos + 2 + alt.length },
+    userEvent: 'input.wysiwyg.image',
+  });
+  return true;
+}
+
+function insertCodeBlockAtCursor(view, language = '') {
+  const pos = view.state.selection.main.head;
+  const lang = language ? String(language).trim() : '';
+  const prefix = pos > 0 && view.state.sliceDoc(pos - 1, pos) !== '\n' ? '\n' : '';
+  const block = `${prefix}\`\`\`${lang}\n\n\`\`\``;
+  const cursor = pos + prefix.length + 3 + lang.length + 1;
+  view.dispatch({
+    changes: { from: pos, insert: block },
+    selection: { anchor: cursor },
+    userEvent: 'input.wysiwyg.codeblock',
+  });
+  return true;
+}
+// #endregion INITIAL_CURSOR
+
 // #region CREATE
 /**
  * Create a standalone markdown editor
@@ -825,6 +1430,7 @@ function create(target, options = {}) {
   const dark = config.appearance.dark;
   const placeholderText = config.appearance.placeholder;
   const readonly = config.appearance.readonly;
+  const spellcheck = config.appearance.spellcheck;
   const userName = config.user.name;
   const userColor = config.user.color;
   const userType = config.user.type;
@@ -839,6 +1445,11 @@ function create(target, options = {}) {
     awarenessUI = true,
   } = options;
 
+  const linkedTableHostContext = {
+    projectRoot: options.projectRoot || null,
+    documentPath: options.documentPath || null,
+  };
+
   // Runtimes from normalized config
   const runtimes = {};
   for (const [name, rtConfig] of Object.entries(config.runtimes)) {
@@ -891,10 +1502,16 @@ function create(target, options = {}) {
 
   // Always read initial content from Yjs (source of truth)
   const initialContent = yText.toString();
+  const initialDocumentTemplate = normalizeDocumentTemplate(options.documentTemplate || defaultDocumentTemplate);
   const themeCompartment = new Compartment();
+  const documentTemplateCompartment = new Compartment();
   const readonlyCompartment = new Compartment();
   const keymapCompartment = new Compartment();
   const projectFilesCompartment = new Compartment();
+  const sectionControlsCompartment = new Compartment();
+  const sourceModeCompartment = new Compartment();
+  const wysiwygModeCompartment = new Compartment();
+  const invisiblesCompartment = new Compartment();
 
   // Create UndoManager for undo/redo tracking
   // We create it ourselves so we can listen to stack changes
@@ -933,7 +1550,7 @@ function create(target, options = {}) {
   // Use explicit theme if set, otherwise auto-select based on dark mode
   const resolveThemeName = (theme, isDarkMode) => {
     if (theme) return theme;
-    return isDarkMode ? 'midnight' : 'daylight';
+    return 'plain-light';
   };
   const initialThemeName = resolveThemeName(config.appearance?.theme, isDark);
 
@@ -959,8 +1576,11 @@ function create(target, options = {}) {
     documentTheme,
     codeBlockBackground,  // Add gray background to code blocks
     codeBlockStyles,
+    // Spellcheck: enable browser-native spellcheck on prose, disable in code
+    ...(spellcheck !== false ? createSpellcheckExtensions() : []),
     EditorView.lineWrapping, // Always wrap markdown text
     themeCompartment.of(initialCMTheme),
+    documentTemplateCompartment.of(createDocumentTemplateExtension(initialDocumentTemplate)),
     readonlyCompartment.of(readonly ? EditorState.readOnly.of(true) : []),
     placeholderText ? placeholder(placeholderText) : [],
     // Yjs collaboration - y-codemirror.next handles sync and undo
@@ -972,13 +1592,26 @@ function create(target, options = {}) {
     // Initially empty, configured after api is created
     keymapCompartment.of([]),
     outputWidgetPlugin, // ANSI output rendering
+    ...createInlineEditingExtensions(),
     lineHeightTracker,  // ViewPlugin: tracks line height for spacer calculations
+    linkedTableMarkdownState,
     blockDecorations,   // StateField for tables, display math (multi-line)
     markdownRenderer,   // ViewPlugin for everything else (inline)
+    pageViewPagination, // ViewPlugin: page-view spacers at page boundaries
+    ...createWysiwygExtensions(),
+    ...commentSyntaxModule.createCommentSyntaxExtension(),
     // Wiki-link completion - just the facet for project files
     // The actual completion is provided by runtime-lsp (via additionalSources)
     // or by a standalone autocompletion added below if no runtime providers exist
     projectFilesCompartment.of(projectFilesFacet.of([])),
+    // Section controls are configured after API creation
+    sectionControlsCompartment.of([]),
+    // Source mode (show all raw markdown syntax)
+    sourceModeCompartment.of(sourceModeFacet.of(false)),
+    // WYSIWYG mode (fully rendered, syntax-protected editing)
+    wysiwygModeCompartment.of(wysiwygModeFacet.of(false)),
+    // Invisible characters (whitespace visualization)
+    invisiblesCompartment.of([]),
   ];
 
   // Inject markdown styles
@@ -1048,6 +1681,7 @@ function create(target, options = {}) {
 
   // Event handlers
   const changeHandlers = [];
+  const selectionHandlers = [];
   const saveHandlers = [];
   const frontmatterTitleCommitHandlers = [];
   const viewSourceHandlers = [];
@@ -1175,6 +1809,12 @@ function create(target, options = {}) {
     });
     runtimeLspExtensions.push(completionExt);
 
+    const signatureHelpExt = createRuntimeSignatureHelpExtension({
+      providers: runtimeLspProviders,
+      getContent: () => view.state.doc.toString(),
+    });
+    runtimeLspExtensions.push(signatureHelpExt);
+
     // Add extensions to the view
     view.dispatch({
       effects: StateEffect.appendConfig.of(runtimeLspExtensions),
@@ -1241,6 +1881,7 @@ function create(target, options = {}) {
     // Runtime
     registry,
     execution: null, // Set below
+    linkedTables: null, // Set below
 
     // Runtime LSP (hover, completions, variables)
     runtimeLspProviders,
@@ -1266,6 +1907,36 @@ function create(target, options = {}) {
       return yText;
     },
 
+    getLinkedTableHostContext() {
+      return {
+        ...linkedTableHostContext,
+        ...(this.linkedTables?.getHostContext?.() || {}),
+      };
+    },
+
+    setLinkedTableHostContext(context = {}) {
+      if (context.projectRoot !== undefined) linkedTableHostContext.projectRoot = context.projectRoot;
+      if (context.documentPath !== undefined) linkedTableHostContext.documentPath = context.documentPath;
+      this.linkedTables?.setHostContext?.(linkedTableHostContext);
+      return this.getLinkedTableHostContext();
+    },
+
+    canImportLinkedTableFromHost(hostApi) {
+      return canImportLinkedTableFromHost(hostApi);
+    },
+
+    insertLinkedTableBlock(blockMarkdown, options = {}) {
+      return insertLinkedTableBlock(this, blockMarkdown, options);
+    },
+
+    async importLinkedTableFromHost(sourceFilePath, options = {}) {
+      return importLinkedTableFromHost(this, {
+        ...this.getLinkedTableHostContext(),
+        ...options,
+        sourceFilePath,
+      });
+    },
+
     setContent(text) {
       view.dispatch({
         changes: { from: 0, to: view.state.doc.length, insert: text }
@@ -1291,6 +1962,82 @@ function create(target, options = {}) {
       });
     },
 
+    // ===========================================================================
+    // WYSIWYG Editing Helpers
+    // ===========================================================================
+
+    toggleBold() {
+      return toggleInlineMark(view, 'bold');
+    },
+
+    toggleItalic() {
+      return toggleInlineMark(view, 'italic');
+    },
+
+    toggleUnderline() {
+      return toggleInlineMark(view, 'underline');
+    },
+
+    toggleStrikethrough() {
+      return toggleInlineMark(view, 'strike');
+    },
+
+    toggleInlineCode() {
+      return toggleInlineMark(view, 'code');
+    },
+
+    setBlockType(type, options = {}) {
+      return setCurrentBlockType(view, type, options);
+    },
+
+    insertLink(url, text = null) {
+      return insertLinkAtSelection(view, url, text);
+    },
+
+    insertCodeBlock(language = '') {
+      return insertCodeBlockAtCursor(view, language);
+    },
+
+    /**
+     * Delete the fenced code block surrounding the cursor.
+     * @returns {boolean} true if a code block was found and deleted
+     */
+    deleteCodeBlock() {
+      const pos = view.state.selection.main.head;
+      const fence = findFencedCodeAt(view.state, pos);
+      if (!fence) return false;
+      const doc = view.state.doc;
+      let delFrom = fence.from;
+      let delTo = Math.min(fence.to, doc.length);
+      if (delFrom > 0 && doc.sliceString(delFrom - 1, delFrom) === '\n') delFrom--;
+      if (delTo < doc.length && doc.sliceString(delTo, delTo + 1) === '\n') delTo++;
+      view.dispatch({
+        changes: { from: delFrom, to: delTo, insert: '' },
+        userEvent: 'delete.wysiwyg.delete-codeblock',
+      });
+      return true;
+    },
+
+    insertImage(url, alt = 'image') {
+      return insertImageAtSelection(view, url, alt);
+    },
+
+    getCurrentBlockType() {
+      return getCurrentBlockTypeInfo(view);
+    },
+
+    getSelectionFormatting() {
+      return getSelectionFormattingInfo(view);
+    },
+
+    onSelectionChange(callback) {
+      selectionHandlers.push(callback);
+      return () => {
+        const idx = selectionHandlers.indexOf(callback);
+        if (idx >= 0) selectionHandlers.splice(idx, 1);
+      };
+    },
+
     // ===========================================================================
     // Streaming Writer
     // ===========================================================================
@@ -1337,6 +2084,218 @@ function create(target, options = {}) {
       return getThemeNames();
     },
 
+    /**
+     * Apply a semantic document template to the editor content surface.
+     * This is separate from the app/editor chrome theme.
+     *
+     * @param {object} template
+     * @returns {object} normalized template
+     */
+    setDocumentTemplate(template) {
+      const next = normalizeDocumentTemplate(template || defaultDocumentTemplate);
+      this._documentTemplate = cloneDocumentTemplate(next);
+      this._documentTemplateName = next.name || 'Untitled Template';
+      view.dispatch({
+        effects: documentTemplateCompartment.reconfigure(
+          createDocumentTemplateExtension(next)
+        ),
+      });
+      return this.getDocumentTemplate();
+    },
+
+    getDocumentTemplate() {
+      return cloneDocumentTemplate(this._documentTemplate || initialDocumentTemplate);
+    },
+
+    getDocumentTemplateName() {
+      return this._documentTemplateName || this._documentTemplate?.name || initialDocumentTemplate.name;
+    },
+
+    getDocumentTemplatePresets() {
+      return documentTemplatePresets.map(cloneDocumentTemplate);
+    },
+
+    compileDocumentTemplate(template = null) {
+      return compileDocumentTemplateCSS(template || this.getDocumentTemplate());
+    },
+
+    serializeDocumentTemplate(template = null, scope = '.markdown-body') {
+      return serializeDocumentTemplateToCss(template || this.getDocumentTemplate(), scope);
+    },
+
+    /**
+     * Serialize the current document template to Pandoc YAML metadata.
+     * @param {object} [template]
+     * @returns {string} YAML string
+     */
+    serializeDocumentTemplatePandoc(template = null) {
+      return serializeDocumentTemplateToPandocYaml(template || this.getDocumentTemplate());
+    },
+
+    /**
+     * Serialize the current document template to a LaTeX preamble.
+     * @param {object} [template]
+     * @returns {string} LaTeX commands
+     */
+    serializeDocumentTemplateLatex(template = null) {
+      return serializeDocumentTemplateToLatexPreamble(template || this.getDocumentTemplate());
+    },
+
+    /**
+     * Serialize the current document template to a standalone HTML wrapper.
+     * @param {object} [template]
+     * @param {object} [options]
+     * @returns {string} HTML document string
+     */
+    serializeDocumentTemplateHtml(template = null, options = {}) {
+      return serializeDocumentTemplateToHtml(template || this.getDocumentTemplate(), options);
+    },
+
+    /**
+     * Get a Word style mapping for the current document template.
+     * @param {object} [template]
+     * @returns {object}
+     */
+    getDocumentTemplateWordStyleMap(template = null) {
+      return serializeDocumentTemplateToWordStyleMap(template || this.getDocumentTemplate());
+    },
+
+    /**
+     * Generate a recommended Pandoc command for the current document template.
+     * @param {object} options - { format, input, output, referenceDoc, preambleFile }
+     * @returns {string}
+     */
+    buildPandocCommand(options = {}) {
+      return buildPandocCommand(this.getDocumentTemplate(), options);
+    },
+
+    bindDocumentTemplate(name) {
+      const result = updateFrontmatterField(this.getContent(), 'template', name);
+      if (!result) return false;
+      view.dispatch({
+        changes: result.changes,
+        userEvent: 'input.document-template-binding',
+      });
+      return true;
+    },
+
+    /**
+     * Update section controls configuration.
+     * @param {{enabled?: boolean, showAi?: boolean, showFormatting?: boolean, mode?: 'full' | 'dots-hover' | 'dots-click'}} updates
+     */
+    setSectionControls(updates = {}) {
+      this.config.sectionControls = {
+        ...this.config.sectionControls,
+        ...updates,
+      };
+    },
+
+    /**
+     * Get current section controls configuration.
+     * @returns {{enabled: boolean, showAi: boolean, showFormatting: boolean, mode: string}}
+     */
+    getSectionControls() {
+      return { ...(this.config.sectionControls || {}) };
+    },
+
+    // ===========================================================================
+    // Source Mode, WYSIWYG Mode & Invisible Characters
+    // ===========================================================================
+
+    /** @private */
+    _sourceMode: false,
+    /** @private */
+    _wysiwygMode: false,
+    /** @private */
+    _showInvisibles: false,
+    /** @private */
+    _documentTemplate: cloneDocumentTemplate(initialDocumentTemplate),
+    /** @private */
+    _documentTemplateName: initialDocumentTemplate.name || 'Default',
+
+    /**
+     * Toggle source mode (show all raw markdown syntax).
+     * Mutually exclusive with WYSIWYG mode.
+     *
+     * @param {boolean} [value] - true=on, false=off. Omit to toggle.
+     * @returns {boolean} The new state
+     */
+    setSourceMode(value) {
+      const newValue = value !== undefined ? !!value : !this._sourceMode;
+      this._sourceMode = newValue;
+      if (newValue) this._wysiwygMode = false;
+      view.dispatch({
+        effects: [
+          sourceModeCompartment.reconfigure(sourceModeFacet.of(newValue)),
+          wysiwygModeCompartment.reconfigure(wysiwygModeFacet.of(false)),
+        ],
+      });
+      return newValue;
+    },
+
+    /**
+     * Get current source mode state.
+     * @returns {boolean}
+     */
+    getSourceMode() {
+      return this._sourceMode;
+    },
+
+    /**
+     * Toggle WYSIWYG mode (fully rendered, syntax-protected editing).
+     * Mutually exclusive with source mode.
+     *
+     * @param {boolean} [value] - true=on, false=off. Omit to toggle.
+     * @returns {boolean} The new state
+     */
+    setWysiwygMode(value) {
+      const newValue = value !== undefined ? !!value : !this._wysiwygMode;
+      this._wysiwygMode = newValue;
+      if (newValue) this._sourceMode = false;
+      view.dispatch({
+        effects: [
+          wysiwygModeCompartment.reconfigure(wysiwygModeFacet.of(newValue)),
+          sourceModeCompartment.reconfigure(sourceModeFacet.of(false)),
+        ],
+      });
+      return newValue;
+    },
+
+    /**
+     * Get current WYSIWYG mode state.
+     * @returns {boolean}
+     */
+    getWysiwygMode() {
+      return this._wysiwygMode;
+    },
+
+    /**
+     * Toggle invisible characters (spaces, tabs, newlines).
+     * When enabled, spaces are shown as dots, tabs as arrows, and
+     * newlines as ¶ symbols.
+     *
+     * @param {boolean} [value] - true=on, false=off. Omit to toggle.
+     * @returns {boolean} The new state
+     */
+    setShowInvisibles(value) {
+      const newValue = value !== undefined ? !!value : !this._showInvisibles;
+      this._showInvisibles = newValue;
+      view.dispatch({
+        effects: invisiblesCompartment.reconfigure(
+          newValue ? createInvisiblesExtension() : []
+        ),
+      });
+      return newValue;
+    },
+
+    /**
+     * Get current invisible characters state.
+     * @returns {boolean}
+     */
+    getShowInvisibles() {
+      return this._showInvisibles;
+    },
+
     // ===========================================================================
     // Wiki-link completion
     // ===========================================================================
@@ -1981,14 +2940,13 @@ function create(target, options = {}) {
     },
 
     /**
-     * View source code for symbol at cursor position.
+     * Get source code for symbol at cursor position, without emitting UI callbacks.
      * Calls inspect with detail=2 to get full source code.
-     * Triggers registered onViewSource callbacks.
      *
      * @param {number} [pos] - Position (defaults to cursor)
      * @returns {Promise<{found: boolean, name?: string, sourceCode?: string, file?: string, ...}|null>}
      */
-    async viewSource(pos) {
+    async getSourceInfo(pos) {
       const position = pos ?? view.state.selection.main.head;
       const content = this.getContent();
       const cell = getCellAtCursor(content, position);
@@ -2003,7 +2961,19 @@ function create(target, options = {}) {
       if (!provider) return null;
 
       const offset = position - cell.codeStart;
-      const result = await provider.inspect(cell.code, offset, cell.language, { detail: 2 });
+      return provider.inspect(cell.code, offset, cell.language, { detail: 2 });
+    },
+
+    /**
+     * View source code for symbol at cursor position.
+     * Calls inspect with detail=2 to get full source code.
+     * Triggers registered onViewSource callbacks.
+     *
+     * @param {number} [pos] - Position (defaults to cursor)
+     * @returns {Promise<{found: boolean, name?: string, sourceCode?: string, file?: string, ...}|null>}
+     */
+    async viewSource(pos) {
+      const result = await this.getSourceInfo(pos);
 
       // Trigger callbacks if we got a result
       if (result && result.found) {
@@ -2204,6 +3174,9 @@ function create(target, options = {}) {
 
     destroy() {
       this.execution.cancelAll();
+      if (this.linkedTables?.destroy) {
+        this.linkedTables.destroy();
+      }
       if (cellControls) {
         cellControls.destroy();
       }
@@ -2268,6 +3241,13 @@ function create(target, options = {}) {
   // Create execution manager
   api.execution = createExecutionManager(api, registry);
 
+  // Create linked-table action/job controller
+  api.linkedTables = createLinkedTableController({
+    editor: api,
+    projectRoot: linkedTableHostContext.projectRoot,
+    documentPath: linkedTableHostContext.documentPath,
+  });
+
   // Configure keymap now that api is ready
   // Merge user keybindings with defaults
   const userKeybindings = options.keymap || {};
@@ -2303,6 +3283,16 @@ function create(target, options = {}) {
     return { ...currentKeybindings };
   };
 
+  // Initialize section controls now that API exists
+  const applySectionControlsConfig = () => {
+    const options = reactiveConfig.sectionControls || {};
+    const extension = options.enabled === false ? [] : sectionControls(api, options);
+    view.dispatch({
+      effects: sectionControlsCompartment.reconfigure(extension),
+    });
+  };
+  applySectionControlsConfig();
+
   // Wire execution events to awareness (so execution badges work automatically)
   // This makes the runtime appear as a collaborator executing code
   if (awarenessSystem) {
@@ -2458,6 +3448,11 @@ function create(target, options = {}) {
   });
 
   reactiveConfig._subscribe(configHandler);
+  reactiveConfig._subscribe((event) => {
+    if (event.path[0] === 'sectionControls') {
+      applySectionControlsConfig();
+    }
+  });
 
   // =========================================================================
   // UPDATE DOCUMENT STATE
@@ -2490,6 +3485,21 @@ function create(target, options = {}) {
       stateManager.setDirty(true);
       updateDocumentState();
     }
+
+    if (update.docChanged || update.selectionSet) {
+      const payload = {
+        selection: update.state.selection.main,
+        block: getCurrentBlockTypeInfo(update.view),
+        formatting: getSelectionFormattingInfo(update.view),
+      };
+      selectionHandlers.forEach(fn => {
+        try {
+          fn(payload);
+        } catch (err) {
+          console.warn('[mrmd] selection change handler failed:', err);
+        }
+      });
+    }
   });
 
   // Add update listener extension
@@ -2996,22 +4006,6 @@ const cellControlsExports = {
 };
 // #endregion CELL_CONTROLS_EXPORTS
 
-// #region RUNTIME_CODELENS_EXPORTS
-const runtimeCodeLensExports = {
-  createExtensions: createRuntimeCodeLensExtensions,
-  rebuild: rebuildRuntimeCodeLens,
-  facet: runtimeCodeLensFacet,
-  plugin: runtimeCodeLensPlugin,
-  rebuildEffect: rebuildRuntimeCodeLensEffect,
-  injectStyles: injectRuntimeCodeLensStyles,
-  removeStyles: removeRuntimeCodeLensStyles,
-  findBlocks: findRuntimeBlocks,
-  findYamlConfigBlocks,
-  findSessionFrontmatter,
-  Widget: RuntimeCodeLensWidget,
-};
-// #endregion RUNTIME_CODELENS_EXPORTS
-
 // #region RUNTIME_LSP_EXPORTS
 const runtimeLspExports = {
   // Adapters
@@ -3039,6 +4033,16 @@ const markdownExports = {
   // Asset resolver facet (for Electron/desktop apps)
   assetResolverFacet,
 
+  // Mode facets
+  sourceModeFacet,
+  wysiwygModeFacet,
+  createInlineEditingExtensions,
+  createWysiwygExtensions,
+  toggleInlineFormat,
+  toggleInlineMark,
+  getSelectionFormattingState,
+  findFencedCodeAt,
+
   // Styles
   markdownStyles,
   injectMarkdownStyles,
@@ -3054,6 +4058,28 @@ const markdownExports = {
   isTableDelimiter,
   generateTableId,
   AlertTitleWidget,
+
+  // Page view pagination
+  pageViewPagination,
+};
+
+const documentTemplateExports = {
+  defaultDocumentTemplate,
+  documentTemplatePresets,
+  normalizeDocumentTemplate,
+  cloneDocumentTemplate,
+  createDocumentTemplateExtension,
+  compileDocumentTemplateCSS,
+  serializeDocumentTemplateToCss,
+  findDocumentTemplatePreset,
+  // Multi-format export
+  resolveFontForExport,
+  serializeDocumentTemplateToPandocMeta,
+  serializeDocumentTemplateToPandocYaml,
+  serializeDocumentTemplateToLatexPreamble,
+  serializeDocumentTemplateToHtml,
+  serializeDocumentTemplateToWordStyleMap,
+  buildPandocCommand,
 };
 // #endregion MARKDOWN_EXPORTS
 
@@ -3076,6 +4102,7 @@ const mrmd = {
   create,
   drive,
   runtime,
+  findInitialCursorPosition,
   yjs,
   codemirror,
   terminal,
@@ -3087,14 +4114,22 @@ const mrmd = {
   stateUtils: stateExports,
   // Cell controls (run buttons, queue, status)
   cellControls: cellControlsExports,
-  // Runtime CodeLens (inline session controls above yaml config blocks)
-  runtimeCodeLens: runtimeCodeLensExports,
   // Runtime LSP (hover, completions, variables)
   runtimeLsp: runtimeLspExports,
   // Wiki-link completion ([[internal-links]])
   wikiLink: wikiLinkExports,
+  // Linked tables
+  linkedTables,
   // Markdown rendering (blur→render, focus→source)
   markdown: markdownExports,
+  // Frontmatter utilities
+  frontmatter: {
+    parseFrontmatter,
+    readFrontmatterValue,
+    updateFrontmatterField,
+  },
+  // Document templates (semantic content styling)
+  documentTemplates: documentTemplateExports,
   // Shell (status bar, file management, studio layout)
   shell: shellModule,
   // AI Integration (decorations, state, widgets)
@@ -3134,11 +4169,11 @@ export {
   create,
   drive,
   runtime,
+  findInitialCursorPosition,
   yjs,
   codemirror,
   terminal,
   awarenessExports as awareness,
-  runtimeCodeLensExports as runtimeCodeLens,
   RuntimeRegistry,
   createRuntimeRegistry,
   createJavaScriptRuntime,
@@ -3222,23 +4257,26 @@ export {
   cellControlsExports,
   createCellControls,
   CellControlsSystem,
-  // Runtime CodeLens exports
-  runtimeCodeLensExports,
-  createRuntimeCodeLensExtensions,
-  rebuildRuntimeCodeLens,
-  runtimeCodeLensFacet,
-  runtimeCodeLensPlugin,
-  rebuildRuntimeCodeLensEffect,
-  injectRuntimeCodeLensStyles,
-  removeRuntimeCodeLensStyles,
-  findRuntimeBlocks,
-  findYamlConfigBlocks,
-  findSessionFrontmatter,
-  RuntimeCodeLensWidget,
   // Monitor coordination exports
   MonitorCoordination,
   EXECUTION_STATUS,
   createMonitorCoordination,
+  // Linked table exports
+  linkedTables as linkedTablesModule,
+  LINKED_TABLE_EVENT,
+  dispatchLinkedTableAction,
+  openLinkedTableWorkspace,
+  canImportLinkedTableFromHost,
+  normalizeLinkedTableBlockInsertion,
+  insertLinkedTableBlock,
+  importLinkedTableFromHost,
+  TableJobsClient,
+  TABLE_JOB_STATUS,
+  createTableJobsClient,
+  LinkedTableController,
+  createLinkedTableController,
+  createLinkedTableBlockAnchor,
+  resolveLinkedTableBlockAnchor,
   // Markdown rendering exports
   markdownExports,
   markdownRendering as markdown,
@@ -3256,6 +4294,33 @@ export {
   isTableDelimiter,
   generateTableId,
   AlertTitleWidget,
+  // Document template exports
+  documentTemplateExports,
+  defaultDocumentTemplate,
+  documentTemplatePresets,
+  normalizeDocumentTemplate,
+  cloneDocumentTemplate,
+  createDocumentTemplateExtension,
+  compileDocumentTemplateCSS,
+  serializeDocumentTemplateToCss,
+  findDocumentTemplatePreset,
+  resolveFontForExport,
+  serializeDocumentTemplateToPandocMeta,
+  serializeDocumentTemplateToPandocYaml,
+  serializeDocumentTemplateToLatexPreamble,
+  serializeDocumentTemplateToHtml,
+  serializeDocumentTemplateToWordStyleMap,
+  buildPandocCommand,
+  // Spellcheck exports
+  createSpellcheckExtensions,
+  // Grammar exports
+  createLanguageToolDiagnosticsExtension,
+  collectVisibleProseFragments,
+  forceLanguageToolRefresh,
+  refreshLanguageToolDiagnostics,
+  applyFirstLanguageToolSuggestion,
+  getLanguageToolSuggestionMenu,
+  applyLanguageToolSuggestionAt,
   // Wiki-link completion exports
   wikiLinkExports,
   projectFilesFacet,
@@ -3272,5 +4337,5 @@ export const { createStudio, OrchestratorClient, Drive, createDrive, ShellStateM
 
 // Document language detection and frontmatter updater
 export { getDocumentLanguages, getLanguageDisplay, isExecutableLanguage } from './document-languages.js';
-export { parseFrontmatter, updateFrontmatterSession, readFrontmatterSession, getEffectiveSessionConfig } from './frontmatter-updater.js';
+export { parseFrontmatter, readFrontmatterSession, getEffectiveSessionConfig, readFrontmatterValue, updateFrontmatterField } from './frontmatter-updater.js';
 // #endregion EXPORTS