@astryxdesign/core 0.6.1 → 0.6.2-canary.023c3e4

package/dist/Markdown/parser.js

@@ -2,17 +2,33 @@
 
 /**
  * @file parser.ts
- * @input Markdown string
- * @output Array of MarkdownNode AST nodes; heading slug helpers
- *   (inlineText, slugify, uniqueSlug) shared by Markdown rendering and
- *   Outline's parseOutlineFromMarkdown
- * @position Core parser; consumed by Markdown.tsx and Outline
+ * @input Markdown string, released parse options, and optional ordered plugins
+ * @output Canonical MDAST-aligned nodes for public/server consumers plus unchanged
+ *   released parser-node projections; shared heading slug helpers
+ * @position Core parser and compatibility boundary; consumed by public parser entry,
+ *   Markdown, and Outline
  */
 
+import { getMarkdownAstLegacyCodeLanguage, markMarkdownAstLegacyCodeLanguage } from "./ast.js";
+import { applyMarkdownTransforms, freezeMarkdownPluginData, isMarkdownPluginData, prepareMarkdownPlugins, reportMarkdownPluginFailure } from "./plugins/protocol.js";
+import { isSafeMarkdownParserUrl } from "./url.js";
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
+/** Nodes returned by default and legacy parser calls. */
+
+/** The additional inline node returned only when parsing with `math: true`. */
+
+/** Nodes returned by an explicitly math-enabled inline parse. */
+
+/** Blocks returned by default and legacy parser calls. */
+
+/** The additional block returned only when parsing with `math: true`. */
+
+/** Blocks returned by an explicitly math-enabled block parse. */
+
 /**
  * Where a block sits in the source string handed to `parseMarkdown`:
  * `source.slice(start, end)` is the block, and `end` excludes the block's
@@ -23,6 +39,240 @@
  * optional fields without breaking anyone.
  */
 
+function projectRange(position) {
+  const start = position?.start.offset;
+  const end = position?.end.offset;
+  return start == null || end == null ? {} : {
+    range: {
+      start,
+      end
+    }
+  };
+}
+
+/**
+ * Canonical nodes always carry Core-authored positions; the released block
+ * shape exposes them as `range` only when the caller passed `sourceRanges`,
+ * so this projection stays byte-for-byte what it has always returned.
+ *
+ * An extension node is the one kind the projection passes through instead of
+ * rebuilding field by field, so it is the one kind that could carry a
+ * canonical `position` out into released output. Strip it unless the caller
+ * asked for provenance, in which case the node keeps exactly the `position`
+ * it has always exposed.
+ */
+function projectExtensionNode(node, withRanges) {
+  if (withRanges || node.position === undefined) {
+    return node;
+  }
+  const {
+    position: _canonicalPosition,
+    ...released
+  } = node;
+  return released;
+}
+function projectInlineNode(node, cache, withRanges) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  let projected;
+  switch (node.type) {
+    case 'text':
+      projected = {
+        type: 'text',
+        content: node.value
+      };
+      break;
+    case 'strong':
+      projected = {
+        type: 'bold',
+        children: node.children.map(child => projectInlineNode(child, cache, withRanges))
+      };
+      break;
+    case 'emphasis':
+      projected = {
+        type: 'italic',
+        children: node.children.map(child => projectInlineNode(child, cache, withRanges))
+      };
+      break;
+    case 'delete':
+      projected = {
+        type: 'strikethrough',
+        children: node.children.map(child => projectInlineNode(child, cache, withRanges))
+      };
+      break;
+    case 'inlineCode':
+      projected = {
+        type: 'code',
+        content: node.value
+      };
+      break;
+    case 'inlineMath':
+      projected = {
+        type: 'math',
+        value: node.value
+      };
+      break;
+    case 'link':
+      projected = {
+        type: 'link',
+        href: node.url,
+        children: node.children.map(child => projectInlineNode(child, cache, withRanges))
+      };
+      break;
+    case 'image':
+      projected = {
+        type: 'image',
+        src: node.url,
+        alt: node.alt
+      };
+      break;
+    case 'citation':
+      projected = {
+        type: 'citation',
+        sourceId: node.sourceId
+      };
+      break;
+    case 'break':
+      projected = {
+        type: 'break'
+      };
+      break;
+    case 'extension':
+      projected = projectExtensionNode(node, withRanges);
+      break;
+  }
+  cache.set(node, projected);
+  return projected;
+}
+function projectTableCell(node, cache, withRanges) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  const projected = {
+    children: node.children.map(child => projectInlineNode(child, cache, withRanges))
+  };
+  cache.set(node, projected);
+  return projected;
+}
+function projectListItem(node, cache, withRanges) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  const projected = {
+    checked: node.checked,
+    children: node.children.map(child => projectBlockNode(child, cache, withRanges))
+  };
+  cache.set(node, projected);
+  return projected;
+}
+function projectBlockNode(node, cache, withRanges) {
+  const cached = cache.get(node);
+  if (cached != null) {
+    return cached;
+  }
+  const metadata = withRanges ? projectRange(node.position) : {};
+  let projected;
+  switch (node.type) {
+    case 'heading':
+      projected = {
+        type: 'heading',
+        level: node.depth,
+        children: node.children.map(child => projectInlineNode(child, cache, withRanges)),
+        ...metadata
+      };
+      break;
+    case 'paragraph':
+      projected = {
+        type: 'paragraph',
+        children: node.children.map(child => projectInlineNode(child, cache, withRanges)),
+        ...metadata
+      };
+      break;
+    case 'code':
+      projected = {
+        type: 'codeblock',
+        language: getMarkdownAstLegacyCodeLanguage(node) ?? 'plaintext',
+        content: node.value,
+        ...metadata
+      };
+      break;
+    case 'math':
+      projected = {
+        type: 'math',
+        value: node.value,
+        ...metadata
+      };
+      break;
+    case 'blockquote':
+      projected = {
+        type: 'blockquote',
+        children: node.children.map(child => projectBlockNode(child, cache, withRanges)),
+        ...metadata
+      };
+      break;
+    case 'list':
+      projected = {
+        type: 'list',
+        ordered: node.ordered,
+        start: node.start,
+        delimiter: node.delimiter,
+        loose: node.spread,
+        items: node.children.map(item => projectListItem(item, cache, withRanges)),
+        ...metadata
+      };
+      break;
+    case 'table':
+      {
+        const [header = {
+          type: 'tableRow',
+          children: []
+        }, ...rows] = node.children;
+        projected = {
+          type: 'table',
+          headers: header.children.map(cell => projectTableCell(cell, cache, withRanges)),
+          alignments: [...node.align],
+          rows: rows.map(row => row.children.map(cell => projectTableCell(cell, cache, withRanges))),
+          ...metadata
+        };
+        break;
+      }
+    case 'thematicBreak':
+      projected = {
+        type: 'hr',
+        ...metadata
+      };
+      break;
+    case 'image':
+      projected = {
+        type: 'image',
+        alt: node.alt,
+        src: node.url,
+        ...metadata
+      };
+      break;
+    case 'extension':
+      projected = projectExtensionNode(node, withRanges);
+      break;
+  }
+  cache.set(node, projected);
+  return projected;
+}
+function projectInlineNodes(nodes, withRanges, cache = new WeakMap()) {
+  return nodes.map(node => projectInlineNode(node, cache, withRanges));
+}
+function projectMarkdownRoot(root, withRanges, cache = new WeakMap()) {
+  return root.children.map(node => projectBlockNode(node, cache, withRanges));
+}
+
+/** Whether a caller asked for the released `range` field on its blocks. */
+function wantsLegacyRanges(arg) {
+  return arg != null && typeof arg.has !== 'function' && arg.sourceRanges === true;
+}
+
 // ---------------------------------------------------------------------------
 // Parse options
 // ---------------------------------------------------------------------------
@@ -35,13 +285,45 @@
  * `ReadonlySet<string>` shape as the second argument.
  */
 
-const EMPTY_OPTS = {
-  sourceIds: undefined,
-  autolink: undefined
-};
-function resolveOptions(arg) {
+/** Options for default and legacy parser results. */
+
+/**
+ * Options that explicitly parse `$…$` and `$$…$$` into math-enabled result
+ * unions. Keeping this separate prevents a legacy `ParseOptions` annotation
+ * from silently widening an exhaustive node switch.
+ */
+
+/**
+ * Every resolved options object is built here, so all of them share one key
+ * set in one order — and therefore one hidden class. The parser reads these
+ * fields in its hottest loops; letting an omitted-options parse and an
+ * options-bag parse produce differently-shaped objects makes those reads
+ * polymorphic in any process that does both, which is exactly what a caller
+ * comparing an empty pipeline against a configured one does.
+ */
+function makeResolvedOptions(fields) {
+  return {
+    sourceIds: fields.sourceIds,
+    autolink: fields.autolink,
+    math: fields.math,
+    sourceRanges: fields.sourceRanges,
+    astPositions: fields.astPositions ?? true,
+    plugins: fields.plugins,
+    isFinal: fields.isFinal,
+    allowBlockSyntax: fields.allowBlockSyntax ?? true,
+    baseOffset: fields.baseOffset,
+    linkDefs: fields.linkDefs
+  };
+}
+const EMPTY_OPTS = makeResolvedOptions({
+  isFinal: true
+});
+const EMPTY_INCREMENTAL_OPTS = makeResolvedOptions({
+  isFinal: false
+});
+function resolveOptions(arg, incremental = false) {
   if (arg == null) {
-    return EMPTY_OPTS;
+    return incremental ? EMPTY_INCREMENTAL_OPTS : EMPTY_OPTS;
   }
   // Duck-type the legacy `ReadonlySet<string>` form: any object whose
   // `.has` is callable is treated as the legacy sourceIds set. This is
@@ -49,17 +331,20 @@ function resolveOptions(arg) {
   // or polyfilled `ReadonlySet` implementations as a `ParseOptions` bag
   // and silently lose citation resolution.
   if (typeof arg.has === 'function') {
-    return {
+    return makeResolvedOptions({
       sourceIds: arg,
-      autolink: undefined
-    };
+      isFinal: !incremental
+    });
   }
   const opts = arg;
-  return {
+  return makeResolvedOptions({
     sourceIds: opts.sourceIds,
     autolink: opts.autolink,
-    sourceRanges: opts.sourceRanges
-  };
+    math: opts.math === true ? true : undefined,
+    sourceRanges: opts.sourceRanges,
+    plugins: opts.plugins != null && opts.plugins.length > 0 ? prepareMarkdownPlugins(opts.plugins) : undefined,
+    isFinal: incremental ? opts.isFinal === true : true
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -83,6 +368,106 @@ const LINK_TITLE_ONLY_RE = /^ {0,3}(?:"[^"\n]*"|'[^'\n]*'|\([^()\n]*\))[ \t]*$/;
 function normalizeLinkLabel(label) {
   return label.trim().replace(/\s+/g, ' ').toLowerCase();
 }
+function stripBlockquoteMarkers(line) {
+  let content = line.endsWith('\r') ? line.slice(0, -1) : line;
+  let quoteDepth = 0;
+  while (true) {
+    const marker = /^ {0,3}> ?/.exec(content);
+    if (marker == null) {
+      return {
+        content,
+        quoteDepth
+      };
+    }
+    content = content.slice(marker[0].length);
+    quoteDepth++;
+  }
+}
+function stripExactBlockquoteDepth(line, quoteDepth) {
+  let content = line;
+  for (let depth = 0; depth < quoteDepth; depth++) {
+    const marker = /^ {0,3}> ?/.exec(content);
+    if (marker == null) {
+      return null;
+    }
+    content = content.slice(marker[0].length);
+  }
+  return content;
+}
+
+/**
+ * Recognize a standalone display-math marker at the current container boundary.
+ * A list opener carries its base indent so an indented continuation marker can
+ * close it; blockquotes must keep the same quote depth.
+ */
+function displayMathContainer(line) {
+  const outer = stripBlockquoteMarkers(line);
+  const listMarker = /^( {0,9})(?:[-*+]|\d+[.)]) +(.*)$/.exec(outer.content);
+  if (listMarker != null) {
+    const taskMarker = /^\[[ xX]\] +(.*)$/.exec(listMarker[2]);
+    const inner = stripBlockquoteMarkers(taskMarker?.[1] ?? listMarker[2]);
+    return inner.content.trim() === '$$' ? {
+      outerQuoteDepth: outer.quoteDepth,
+      listBaseIndent: listMarker[1].length,
+      innerQuoteDepth: inner.quoteDepth
+    } : null;
+  }
+  return outer.content.trim() === '$$' ? {
+    outerQuoteDepth: outer.quoteDepth,
+    listBaseIndent: null,
+    innerQuoteDepth: 0
+  } : null;
+}
+function displayMathLineState(line, container) {
+  const outerContent = stripExactBlockquoteDepth(line, container.outerQuoteDepth);
+  if (outerContent == null) {
+    return 'outside';
+  }
+  if (container.listBaseIndent == null) {
+    // A deeper quote starts a different container. It cannot close or continue
+    // the math expression owned by the shallower quote.
+    if (/^ {0,3}> ?/.test(outerContent)) {
+      return 'outside';
+    }
+    return outerContent.trim() === '$$' ? 'close' : 'inside';
+  }
+  const continuationIndent = outerContent.length - outerContent.trimStart().length;
+  if (continuationIndent <= container.listBaseIndent) {
+    return 'outside';
+  }
+  const innerContent = stripExactBlockquoteDepth(outerContent.trimStart(), container.innerQuoteDepth);
+  if (innerContent == null || /^ {0,3}> ?/.test(innerContent)) {
+    return 'outside';
+  }
+  return innerContent.trim() === '$$' ? 'close' : 'inside';
+}
+
+/** Match a complete `$$…$$` display-math block without consuming partial input. */
+function matchDisplayMathBlock(lines, lineIndex) {
+  const trimmed = lines[lineIndex].trim();
+  if (trimmed.length > 4 && trimmed.startsWith('$$') && trimmed.endsWith('$$')) {
+    const value = trimmed.slice(2, -2);
+    return value.trim() === '' ? null : {
+      value,
+      nextIndex: lineIndex + 1,
+      endLine: lineIndex
+    };
+  }
+  if (trimmed !== '$$') {
+    return null;
+  }
+  for (let index = lineIndex + 1; index < lines.length; index++) {
+    if (lines[index].trim() === '$$') {
+      const value = lines.slice(lineIndex + 1, index).join('\n');
+      return value.trim() === '' ? null : {
+        value,
+        nextIndex: index + 1,
+        endLine: index
+      };
+    }
+  }
+  return null;
+}
 function matchLinkDefinition(line) {
   const match = LINK_DEFINITION_RE.exec(line);
   if (match == null) {
@@ -121,7 +506,7 @@ function matchLinkDefinition(line) {
  * where every definition is global. Separating a footer definition block with
  * a blank line — the usual form — always works.
  */
-function extractLinkDefinitions(input) {
+function extractLinkDefinitions(input, math = false) {
   const lines = input.split('\n');
   const defs = new Map();
   const keep = new Array(lines.length).fill(true);
@@ -141,6 +526,16 @@ function extractLinkDefinitions(input) {
       }
       continue;
     }
+    if (math) {
+      const displayMath = matchDisplayMathBlock(lines, index);
+      if (displayMath != null) {
+        // Math is opaque Markdown content: definition-shaped TeX must not leak
+        // into the document-wide link-definition map.
+        index = displayMath.endLine;
+        atBoundary = true;
+        continue;
+      }
+    }
     const fenceMatch = line.match(/^(`{3,}|~{3,})/);
     if (fenceMatch) {
       inFence = true;
@@ -193,6 +588,11 @@ function extractLinkDefinitions(input) {
   };
 }
 
+/** Order-independent signature of a citation-source set, for cache checks. */
+function sourceIdsSignature(sourceIds) {
+  return sourceIds == null || sourceIds.size === 0 ? '' : [...sourceIds].sort().join('\u0000');
+}
+
 /** Order-independent signature of a link-definition set, for cache checks. */
 function linkDefsSignature(defs) {
   if (defs.size === 0) {
@@ -207,6 +607,12 @@ function linkDefsSignature(defs) {
  * Returns the node plus the index just past the reference, or null when it is
  * not a resolvable reference (caller falls through to literal handling).
  */
+function protectedInlineOptions(opts) {
+  return opts.plugins == null ? opts : {
+    ...opts,
+    plugins: undefined
+  };
+}
 function matchReferenceLink(text, start, linkDefs, opts) {
   const textClose = text.indexOf(']', start + 1);
   if (textClose === -1) {
@@ -223,12 +629,12 @@ function matchReferenceLink(text, start, linkDefs, opts) {
       // matches nothing.
       const label = rawLabel === '' ? linkText : rawLabel;
       const href = linkDefs.get(normalizeLinkLabel(label));
-      if (href != null && isSafeUrl(href)) {
+      if (href != null && isSafeMarkdownParserUrl(href)) {
         return {
           node: {
             type: 'link',
-            href,
-            children: parseInlineImpl(linkText, opts)
+            url: href,
+            children: parseInlineImpl(linkText, protectedInlineOptions(opts))
           },
           end: labelClose + 1
         };
@@ -242,14 +648,14 @@ function matchReferenceLink(text, start, linkDefs, opts) {
     return null;
   }
   const href = linkDefs.get(normalizeLinkLabel(linkText));
-  if (href == null || !isSafeUrl(href)) {
+  if (href == null || !isSafeMarkdownParserUrl(href)) {
     return null;
   }
   return {
     node: {
       type: 'link',
-      href,
-      children: parseInlineImpl(linkText, opts)
+      url: href,
+      children: parseInlineImpl(linkText, protectedInlineOptions(opts))
     },
     end: textClose + 1
   };
@@ -268,11 +674,11 @@ function matchReferenceImage(text, start, linkDefs) {
       const rawLabel = text.slice(altClose + 2, labelClose);
       const label = rawLabel === '' ? alt : rawLabel;
       const src = linkDefs.get(normalizeLinkLabel(label));
-      if (src != null && isSafeUrl(src)) {
+      if (src != null && isSafeMarkdownParserUrl(src)) {
         return {
           node: {
             type: 'image',
-            src,
+            url: src,
             alt
           },
           end: labelClose + 1
@@ -285,13 +691,13 @@ function matchReferenceImage(text, start, linkDefs) {
     return null;
   }
   const src = linkDefs.get(normalizeLinkLabel(alt));
-  if (src == null || !isSafeUrl(src)) {
+  if (src == null || !isSafeMarkdownParserUrl(src)) {
     return null;
   }
   return {
     node: {
       type: 'image',
-      src,
+      url: src,
       alt
     },
     end: altClose + 1
@@ -324,27 +730,50 @@ function isWordChar(ch) {
   return /\w/.test(ch);
 }
 
-// ---------------------------------------------------------------------------
-// URL scheme sanitization
-// ---------------------------------------------------------------------------
+/** True when the character at `index` is preceded by an odd backslash run. */
+function isEscaped(text, index) {
+  let backslashes = 0;
+  for (let i = index - 1; i >= 0 && text[i] === '\\'; i--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 1;
+}
 
 /**
- * Reject URLs with dangerous schemes (javascript:, vbscript:, data:) that
- * could execute arbitrary code when rendered as link hrefs or image srcs.
- * Returns true if the URL is safe to use, false otherwise.
+ * Find the closing delimiter for `$…$` math on the same line.
+ *
+ * The whitespace and numeric-edge rules mirror common dollar-math parsers:
+ * whitespace cannot hug the delimiters, a digit cannot sit immediately before
+ * the opener or after the closer, and `$$` is reserved for display math. The
+ * numeric guard prevents ordinary prose such as "$20 and $30" from becoming a
+ * formula even in a math-enabled document.
  */
-function isSafeUrl(url) {
-  // Trim and collapse whitespace/control chars that browsers tolerate but
-  // could bypass a naive prefix check (e.g. "java\nscript:alert(1)").
-  // eslint-disable-next-line no-control-regex -- control chars are the bypass
-  const normalized = url.replace(/[\x00-\x1f\x7f]/g, '').trim();
-  const lower = normalized.toLowerCase();
-  if (lower.startsWith('javascript:') || lower.startsWith('vbscript:') || lower.startsWith('data:text/html')) {
-    return false;
+function isInlineMathStart(text, index) {
+  return text[index] === '$' && text[index - 1] !== '$' && text[index + 1] !== '$' && text[index + 1] != null && !/\s/.test(text[index + 1]) && !/\d/.test(text[index - 1] ?? '') && !isEscaped(text, index);
+}
+function findInlineMathEnd(text, start) {
+  if (!isInlineMathStart(text, start)) {
+    return -1;
   }
-  return true;
+  for (let index = start + 1; index < text.length; index++) {
+    if (text[index] === '\n') {
+      return -1;
+    }
+    if (text[index] !== '$' || isEscaped(text, index)) {
+      continue;
+    }
+    // An unescaped dollar ends this candidate: it either forms a valid closer
+    // or makes the whole span literal. Never skip over one and pair with a
+    // later dollar, which would swallow currency or another expression.
+    if (text[index - 1] === '$' || text[index + 1] === '$' || /\s/.test(text[index - 1]) || /\d/.test(text[index + 1] ?? '')) {
+      return -1;
+    }
+    return index;
+  }
+  return -1;
 }
 
+// ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Inline parser
 // ---------------------------------------------------------------------------
@@ -395,8 +824,137 @@ function matchBracketCitation(text, i, opts) {
     end: closeIndex + 1
   };
 }
+function currentLineStart(source, offset) {
+  return source.lastIndexOf('\n', offset - 1) + 1;
+}
+function matchExtensionSyntax(source, offset, context, opts) {
+  const byFirstCharacter = context === 'inline' ? opts.plugins?.inlineByFirstCharacter : opts.allowBlockSyntax === false ? undefined : opts.plugins?.blockByFirstCharacter;
+  const candidates = byFirstCharacter?.get(source[offset]);
+  if (candidates == null) {
+    return {
+      status: 'none'
+    };
+  }
+  const seen = new Set();
+  for (const candidate of candidates) {
+    if (seen.has(candidate)) {
+      continue;
+    }
+    seen.add(candidate);
+    let fullPrefix = false;
+    for (const prefix of candidate.contribution.startsWith) {
+      if (source.startsWith(prefix, offset)) {
+        fullPrefix = true;
+        break;
+      }
+      if (!opts.isFinal) {
+        const remaining = source.slice(offset);
+        if (remaining.length < prefix.length && prefix.startsWith(remaining)) {
+          return {
+            status: 'defer'
+          };
+        }
+      }
+    }
+    if (!fullPrefix) {
+      continue;
+    }
+    const end = Math.min(source.length, offset + candidate.contribution.maxSpan);
+    let result;
+    try {
+      result = candidate.contribution.tokenize({
+        source: end === source.length ? source : source.slice(0, end),
+        offset,
+        end,
+        isFinal: opts.isFinal,
+        context,
+        lineStart: currentLineStart(source, offset),
+        column: offset - currentLineStart(source, offset)
+      });
+    } catch (error) {
+      reportMarkdownPluginFailure(candidate.pluginName, 'syntax', error);
+      continue;
+    }
+    if (result == null || typeof result !== 'object' || typeof result.then === 'function') {
+      reportMarkdownPluginFailure(candidate.pluginName, 'syntax', new TypeError('Tokenizer returned an invalid result'));
+      continue;
+    }
+    if (result.status === 'no-match') {
+      continue;
+    }
+    if (result.status === 'defer') {
+      return !opts.isFinal && end === source.length && source.length - offset < candidate.contribution.maxSpan ? {
+        status: 'defer'
+      } : {
+        status: 'none'
+      };
+    }
+    if (result.status !== 'match' || !Number.isInteger(result.end) || result.end <= offset || result.end > end || result.node.type !== 'extension' || result.node.plugin !== candidate.pluginName || result.node.display !== context || result.node.name.trim() === '' || !isMarkdownPluginData(result.node.data) || !opts.plugins?.renderers.has(`${candidate.pluginName}\0${result.node.name}`)) {
+      reportMarkdownPluginFailure(candidate.pluginName, 'syntax', new TypeError('Tokenizer returned an invalid extension node'));
+      continue;
+    }
+    const rawNode = result.node;
+    const {
+      source: _ignoredSource,
+      position: _ignoredPosition,
+      ...safeNode
+    } = rawNode;
+    const absoluteStart = (opts.baseOffset ?? 0) + offset;
+    const absoluteEnd = (opts.baseOffset ?? 0) + result.end;
+    return {
+      status: 'match',
+      end: result.end,
+      node: Object.freeze({
+        ...safeNode,
+        data: freezeMarkdownPluginData(result.node.data),
+        source: source.slice(offset, result.end),
+        ...(opts.sourceRanges && context === 'block' ? {
+          position: Object.freeze({
+            start: Object.freeze({
+              offset: absoluteStart
+            }),
+            end: Object.freeze({
+              offset: absoluteEnd
+            })
+          })
+        } : null)
+      })
+    };
+  }
+  return {
+    status: 'none'
+  };
+}
 export function parseInline(text, arg) {
-  return parseInlineEntry(text, resolveOptions(arg));
+  return projectInlineNodes(parseInlineAstRuntime(text, arg), wantsLegacyRanges(arg));
+}
+
+/**
+ * Parse inline Markdown into the canonical immutable Astryx AST.
+ *
+ * Unlike `parseInline`, this returns MDAST-aligned node names and fields. Math
+ * nodes are present only when `math: true`, and plugin extension nodes are
+ * inferred from the ordered `plugins` tuple.
+ */
+
+export function parseInlineAst(text, arg) {
+  return parseInlineAstRuntime(text, arg);
+}
+function parseInlineAstRuntime(text, arg) {
+  const opts = resolveOptions(arg);
+  const nodes = parseInlineEntry(text, opts);
+  if ((opts.plugins?.transforms.length ?? 0) === 0) {
+    return nodes;
+  }
+  const transformed = applyMarkdownTransforms({
+    type: 'root',
+    children: [{
+      type: 'paragraph',
+      children: nodes
+    }]
+  }, opts.plugins, text, opts.isFinal, 'inline');
+  const paragraph = transformed.children[0];
+  return paragraph?.type === 'paragraph' ? [...paragraph.children] : nodes;
 }
 
 /**
@@ -406,7 +964,7 @@ export function parseInline(text, arg) {
  * wrapper and call `parseInlineImpl` directly so the transform runs only on
  * the outermost block's inline tree — letting `transformAutolinks` decide
  * which subtrees to descend into (text, bold, italic, strikethrough) and
- * which to skip (link, code, image, citation, break).
+ * which to skip (link, code, math, image, citation, break).
  */
 function parseInlineEntry(text, opts) {
   const nodes = parseInlineImpl(text, opts);
@@ -414,13 +972,18 @@ function parseInlineEntry(text, opts) {
 }
 function parseInlineImpl(text, opts) {
   const nodes = [];
+  // Only a plugin that actually contributes INLINE syntax may cost anything
+  // per source position. A transform-only list contributes none, so it takes
+  // the same path as an omitted or empty one: no candidate probe per
+  // position, and no map lookup per character in the plain-text scan below.
+  const inlineExtensionStarts = opts.plugins != null && opts.plugins.inlineByFirstCharacter.size > 0 ? opts.plugins.inlineByFirstCharacter : undefined;
   let i = 0;
   while (i < text.length) {
     // --- Escape ---
     if (text[i] === '\\' && i + 1 < text.length) {
       nodes.push({
         type: 'text',
-        content: text[i + 1]
+        value: text[i + 1]
       });
       i += 2;
       continue;
@@ -433,14 +996,27 @@ function parseInlineImpl(text, opts) {
       const closeIndex = text.indexOf('`'.repeat(tickCount), openIndex);
       if (closeIndex !== -1) {
         nodes.push({
-          type: 'code',
-          content: text.slice(openIndex, closeIndex)
+          type: 'inlineCode',
+          value: text.slice(openIndex, closeIndex)
         });
         i = closeIndex + tickCount;
         continue;
       }
     }
 
+    // --- Inline math (opt-in; code takes precedence) ---
+    if (opts.math && text[i] === '$') {
+      const closeIndex = findInlineMathEnd(text, i);
+      if (closeIndex !== -1) {
+        nodes.push({
+          type: 'inlineMath',
+          value: text.slice(i + 1, closeIndex)
+        });
+        i = closeIndex + 1;
+        continue;
+      }
+    }
+
     // --- Citation: fullwidth 【id】 ---
     {
       const citation = matchFullwidthCitation(text, i, opts);
@@ -461,16 +1037,16 @@ function parseInlineImpl(text, opts) {
         const srcClose = findClosingParen(text, altClose + 2);
         if (srcClose !== -1) {
           const src = text.slice(altClose + 2, srcClose);
-          if (!isSafeUrl(src)) {
+          if (!isSafeMarkdownParserUrl(src)) {
             // Dangerous scheme — emit as plain text.
             nodes.push({
               type: 'text',
-              content: text.slice(i, srcClose + 1)
+              value: text.slice(i, srcClose + 1)
             });
           } else {
             nodes.push({
               type: 'image',
-              src,
+              url: src,
               alt: text.slice(i + 2, altClose)
             });
           }
@@ -510,17 +1086,17 @@ function parseInlineImpl(text, opts) {
         const urlClose = findClosingParen(text, textClose + 2);
         if (urlClose !== -1) {
           const href = text.slice(textClose + 2, urlClose);
-          if (!isSafeUrl(href)) {
+          if (!isSafeMarkdownParserUrl(href)) {
             // Dangerous scheme — emit as plain text instead of a link.
             nodes.push({
               type: 'text',
-              content: text.slice(i, urlClose + 1)
+              value: text.slice(i, urlClose + 1)
             });
           } else {
             nodes.push({
               type: 'link',
-              href,
-              children: parseInlineImpl(text.slice(i + 1, textClose), opts)
+              url: href,
+              children: parseInlineImpl(text.slice(i + 1, textClose), protectedInlineOptions(opts))
             });
           }
           i = urlClose + 1;
@@ -549,9 +1125,9 @@ function parseInlineImpl(text, opts) {
         const closeIndex = text.indexOf(marker, i + 3);
         if (closeIndex !== -1 && (!isUnderscore || !isWordChar(text[closeIndex + 3]))) {
           nodes.push({
-            type: 'bold',
+            type: 'strong',
             children: [{
-              type: 'italic',
+              type: 'emphasis',
               children: parseInlineImpl(text.slice(i + 3, closeIndex), opts)
             }]
           });
@@ -571,7 +1147,7 @@ function parseInlineImpl(text, opts) {
         const closeIndex = text.indexOf(marker, i + 2);
         if (closeIndex !== -1 && (!isUnderscore || !isWordChar(text[closeIndex + 2]))) {
           nodes.push({
-            type: 'bold',
+            type: 'strong',
             children: parseInlineImpl(text.slice(i + 2, closeIndex), opts)
           });
           i = closeIndex + 2;
@@ -585,7 +1161,7 @@ function parseInlineImpl(text, opts) {
       const closeIndex = text.indexOf('~~', i + 2);
       if (closeIndex !== -1) {
         nodes.push({
-          type: 'strikethrough',
+          type: 'delete',
           children: parseInlineImpl(text.slice(i + 2, closeIndex), opts)
         });
         i = closeIndex + 2;
@@ -602,7 +1178,7 @@ function parseInlineImpl(text, opts) {
         const closeIndex = text.indexOf(text[i], i + 1);
         if (closeIndex !== -1 && closeIndex > i + 1 && (!isUnderscore || !isWordChar(text[closeIndex + 1]))) {
           nodes.push({
-            type: 'italic',
+            type: 'emphasis',
             children: parseInlineImpl(text.slice(i + 1, closeIndex), opts)
           });
           i = closeIndex + 1;
@@ -611,9 +1187,22 @@ function parseInlineImpl(text, opts) {
       }
     }
 
+    // --- Extension syntax (built-ins and protected contexts win) ---
+    if (inlineExtensionStarts !== undefined) {
+      const extension = matchExtensionSyntax(text, i, 'inline', opts);
+      if (extension.status === 'match') {
+        nodes.push(extension.node);
+        i = extension.end;
+        continue;
+      }
+      if (extension.status === 'defer') {
+        break;
+      }
+    }
+
     // --- Plain text (with line-break detection) ---
     let end = i + 1;
-    while (end < text.length && !'*_~`[!\\\n\u3010'.includes(text[end])) {
+    while (end < text.length && !'*_~`[!\\\n\u3010'.includes(text[end]) && !(opts.math && text[end] === '$') && (inlineExtensionStarts === undefined || !inlineExtensionStarts.has(text[end]))) {
       end++;
     }
     const content = text.slice(i, end);
@@ -625,11 +1214,14 @@ function parseInlineImpl(text, opts) {
         if (trimmed.length > 0) {
           const last = nodes[nodes.length - 1];
           if (last?.type === 'text') {
-            last.content += trimmed;
+            nodes[nodes.length - 1] = {
+              ...last,
+              value: last.value + trimmed
+            };
           } else {
             nodes.push({
               type: 'text',
-              content: trimmed
+              value: trimmed
             });
           }
         }
@@ -642,11 +1234,14 @@ function parseInlineImpl(text, opts) {
     }
     const last = nodes[nodes.length - 1];
     if (last?.type === 'text') {
-      last.content += content;
+      nodes[nodes.length - 1] = {
+        ...last,
+        value: last.value + content
+      };
     } else {
       nodes.push({
         type: 'text',
-        content
+        value: content
       });
     }
     i = end;
@@ -750,7 +1345,7 @@ function scanAutolinksInText(text) {
     while ((m = re.exec(text)) !== null) {
       const url = m[1];
       // Skip dangerous URL schemes (javascript:, vbscript:, data:text/html)
-      if (!isSafeUrl(url)) {
+      if (!isSafeMarkdownParserUrl(url)) {
         continue;
       }
       matches.push({
@@ -875,7 +1470,7 @@ function splitTextOnAutolinks(content) {
   if (matches.length === 0) {
     return [{
       type: 'text',
-      content
+      value: content
     }];
   }
   const out = [];
@@ -884,15 +1479,15 @@ function splitTextOnAutolinks(content) {
     if (m.start > cursor) {
       out.push({
         type: 'text',
-        content: content.slice(cursor, m.start)
+        value: content.slice(cursor, m.start)
       });
     }
     out.push({
       type: 'link',
-      href: m.href,
+      url: m.href,
       children: [{
         type: 'text',
-        content: m.display
+        value: m.display
       }]
     });
     cursor = m.end;
@@ -900,7 +1495,7 @@ function splitTextOnAutolinks(content) {
   if (cursor < content.length) {
     out.push({
       type: 'text',
-      content: content.slice(cursor)
+      value: content.slice(cursor)
     });
   }
   return out;
@@ -918,16 +1513,19 @@ function transformAutolinks(nodes) {
   const out = [];
   for (const node of nodes) {
     if (node.type === 'text') {
-      const split = splitTextOnAutolinks(node.content);
+      const split = splitTextOnAutolinks(node.value);
       for (const seg of split) {
         const last = out[out.length - 1];
         if (seg.type === 'text' && last?.type === 'text') {
-          last.content += seg.content;
+          out[out.length - 1] = {
+            ...last,
+            value: last.value + seg.value
+          };
         } else {
           out.push(seg);
         }
       }
-    } else if (node.type === 'bold' || node.type === 'italic' || node.type === 'strikethrough') {
+    } else if (node.type === 'strong' || node.type === 'emphasis' || node.type === 'delete') {
       out.push({
         ...node,
         children: transformAutolinks(node.children)
@@ -1012,10 +1610,19 @@ function isTableSeparator(line) {
  * offset into it would not address the document.
  */
 function nested(opts) {
-  return opts.sourceRanges ? {
+  const nestedOptions = opts.allowBlockSyntax === false ? opts : {
     ...opts,
-    sourceRanges: false
-  } : opts;
+    allowBlockSyntax: false
+  };
+  return nestedOptions.sourceRanges || nestedOptions.astPositions ? {
+    ...nestedOptions,
+    sourceRanges: false,
+    astPositions: false
+  } : nestedOptions;
+}
+function blockExtensionColumn(line) {
+  const indentation = line.length - line.trimStart().length;
+  return indentation <= 3 ? indentation : null;
 }
 
 /**
@@ -1083,6 +1690,7 @@ function splitTableRow(line) {
 }
 function parseTable(lines, lineIndex, opts) {
   const headers = splitTableRow(lines[lineIndex]).map(cell => ({
+    type: 'tableCell',
     children: parseInlineEntry(cell, opts)
   }));
   const alignments = splitTableRow(lines[lineIndex + 1]).map(cell => {
@@ -1094,17 +1702,24 @@ function parseTable(lines, lineIndex, opts) {
   const rows = [];
   let rowIndex = lineIndex + 2;
   while (rowIndex < lines.length && lines[rowIndex].includes('|') && lines[rowIndex].trim() !== '') {
-    rows.push(splitTableRow(lines[rowIndex]).map(cell => ({
-      children: parseInlineEntry(cell, opts)
-    })));
+    rows.push({
+      type: 'tableRow',
+      children: splitTableRow(lines[rowIndex]).map(cell => ({
+        type: 'tableCell',
+        children: parseInlineEntry(cell, opts)
+      }))
+    });
     rowIndex++;
   }
+  const header = {
+    type: 'tableRow',
+    children: headers
+  };
   return {
     node: {
       type: 'table',
-      headers,
-      alignments,
-      rows
+      align: alignments,
+      children: [header, ...rows]
     },
     nextIndex: rowIndex
   };
@@ -1147,6 +1762,7 @@ function parseList(lines, startIndex, ordered, opts) {
       itemText += '\n' + deindented.join('\n');
     }
     items.push({
+      type: 'listItem',
       checked,
       children: parseMarkdownImpl(itemText, nested(opts))
     });
@@ -1163,15 +1779,16 @@ function parseList(lines, startIndex, ordered, opts) {
       index = lookahead;
     }
   }
+  const node = {
+    type: 'list',
+    ordered,
+    start,
+    delimiter: ordered ? delim : undefined,
+    spread: loose || undefined,
+    children: items
+  };
   return {
-    node: {
-      type: 'list',
-      ordered,
-      start,
-      delimiter: ordered ? delim : undefined,
-      loose: loose || undefined,
-      items
-    },
+    node,
     nextIndex: index
   };
 }
@@ -1181,7 +1798,33 @@ function parseList(lines, startIndex, ordered, opts) {
 // ---------------------------------------------------------------------------
 
 export function parseMarkdown(input, arg) {
-  return parseMarkdownImpl(input, resolveOptions(arg));
+  return projectMarkdownRoot(parseMarkdownAstInternal(input, arg, true), wantsLegacyRanges(arg));
+}
+
+/**
+ * Parse block Markdown into the canonical immutable Astryx AST.
+ *
+ * Unlike `parseMarkdown`, this returns the MDAST-aligned root used by Markdown,
+ * transforms, and Outline. Math nodes are present only when `math: true`, and
+ * plugin extension nodes are inferred from the ordered `plugins` tuple.
+ */
+
+export function parseMarkdownAst(input, arg) {
+  return parseMarkdownAstInternal(input, arg, true);
+}
+
+/** @internal Full-parse entry point with streaming finality for Outline. */
+export function parseMarkdownAstInternal(input, arg, isFinal) {
+  const resolved = resolveOptions(arg);
+  const opts = isFinal ? resolved : {
+    ...resolved,
+    isFinal: false
+  };
+  const root = {
+    type: 'root',
+    children: parseMarkdownImpl(input, opts)
+  };
+  return applyMarkdownTransforms(root, opts.plugins, input, opts.isFinal, 'block');
 }
 function parseMarkdownImpl(input, baseOpts) {
   // Collect this input's link reference definitions and strip their lines,
@@ -1195,7 +1838,7 @@ function parseMarkdownImpl(input, baseOpts) {
     defs,
     cleaned,
     lineMap
-  } = extractLinkDefinitions(input);
+  } = extractLinkDefinitions(input, baseOpts.math);
   const inherited = baseOpts.linkDefs;
   let linkDefs;
   if (defs.size === 0) {
@@ -1210,14 +1853,26 @@ function parseMarkdownImpl(input, baseOpts) {
     linkDefs
   } : baseOpts;
   const lines = cleaned.split('\n');
+  const hasBlockExtensionSyntax = opts.allowBlockSyntax !== false && (opts.plugins?.blockByFirstCharacter.size ?? 0) > 0;
+  // Derived from the already-split lines rather than a second character
+  // scan: every line contributes its own length plus the newline it ended on.
+  const lineOffsets = [0];
+  if (opts.astPositions === true || hasBlockExtensionSyntax) {
+    let offset = 0;
+    for (let index = 0; index < lines.length; index++) {
+      offset += lines[index].length + 1;
+      lineOffsets.push(offset);
+    }
+  }
+  const blockExtensionMatches = new Map();
   const blocks = [];
   // The line each block started on, parallel to `blocks`. Only collected when
   // ranges were asked for; a block's end is resolved after the loop, since the
   // branch that produced it has already moved `index` past whatever it read.
-  const blockStartLines = opts.sourceRanges ? [] : null;
+  const blockStartLines = opts.astPositions === true ? [] : null;
   // Set only by a block that consumes blank lines as content, where the
   // positional end derivation would trim them away.
-  const blockEndLines = opts.sourceRanges ? [] : null;
+  const blockEndLines = opts.astPositions === true ? [] : null;
   let blockStartLine = 0;
   const pushBlock = (node, endLine) => {
     blocks.push(node);
@@ -1234,10 +1889,13 @@ function parseMarkdownImpl(input, baseOpts) {
     }
 
     // --- Fenced code block ---
-    const fenceMatch = line.match(/^(`{3,}|~{3,})(\w*)/);
+    const fenceMatch = line.match(/^(`{3,}|~{3,})/);
     if (fenceMatch) {
       const fence = fenceMatch[1];
-      const language = fenceMatch[2] || 'plaintext';
+      const info = line.slice(fence.length);
+      const language = info.match(/^(\S+)/)?.[1] ?? null;
+      const legacyLanguage = info.match(/^(\w*)/)?.[1] || null;
+      const meta = language == null ? undefined : info.slice(language.length).trim() || undefined;
       const codeLines = [];
       index++;
       while (index < lines.length && !lines[index].startsWith(fence)) {
@@ -1248,20 +1906,36 @@ function parseMarkdownImpl(input, baseOpts) {
       // A fence owns its blank lines, and an unterminated one (mid-stream)
       // can end on them, so it states its own end rather than letting the
       // positional derivation trim them off.
-      pushBlock({
-        type: 'codeblock',
-        language,
-        content: codeLines.join('\n')
-      }, Math.min(index, lines.length) - 1);
+      pushBlock(markMarkdownAstLegacyCodeLanguage({
+        type: 'code',
+        lang: language,
+        ...(meta == null ? {} : {
+          meta
+        }),
+        value: codeLines.join('\n')
+      }, legacyLanguage), Math.min(index, lines.length) - 1);
       continue;
     }
 
+    // --- Display math (opt-in; fenced code takes precedence) ---
+    if (opts.math) {
+      const displayMath = matchDisplayMathBlock(lines, index);
+      if (displayMath != null) {
+        pushBlock({
+          type: 'math',
+          value: displayMath.value
+        }, displayMath.endLine);
+        index = displayMath.nextIndex;
+        continue;
+      }
+    }
+
     // --- Heading ---
     const headingMatch = line.match(/^(#{1,6}) +(.*)/);
     if (headingMatch) {
       pushBlock({
         type: 'heading',
-        level: headingMatch[1].length,
+        depth: headingMatch[1].length,
         children: parseInlineEntry(headingMatch[2], opts)
       });
       index++;
@@ -1271,7 +1945,7 @@ function parseMarkdownImpl(input, baseOpts) {
     // --- HR (must precede list check to handle `- - -`, `* * *`, `_ _ _`) ---
     if (isHorizontalRule(line)) {
       pushBlock({
-        type: 'hr'
+        type: 'thematicBreak'
       });
       index++;
       continue;
@@ -1281,11 +1955,11 @@ function parseMarkdownImpl(input, baseOpts) {
     // An unsafe src falls through to the paragraph path and renders as
     // literal text, the same rule the inline image path applies.
     const imageMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)/);
-    if (imageMatch && line.trim() === imageMatch[0] && isSafeUrl(imageMatch[2])) {
+    if (imageMatch && line.trim() === imageMatch[0] && isSafeMarkdownParserUrl(imageMatch[2])) {
       pushBlock({
         type: 'image',
         alt: imageMatch[1],
-        src: imageMatch[2]
+        url: imageMatch[2]
       });
       index++;
       continue;
@@ -1329,11 +2003,52 @@ function parseMarkdownImpl(input, baseOpts) {
       continue;
     }
 
+    // --- Extension block syntax (built-in blocks take precedence) ---
+    if (hasBlockExtensionSyntax) {
+      const extensionColumn = blockExtensionColumn(line);
+      const extensionOffset = extensionColumn == null ? lineOffsets[index] : lineOffsets[index] + extensionColumn;
+      const extension = blockExtensionMatches.get(extensionOffset) ?? (extensionColumn == null ? {
+        status: 'none'
+      } : matchExtensionSyntax(cleaned, extensionOffset, 'block', opts));
+      blockExtensionMatches.delete(extensionOffset);
+      if (extension.status === 'match') {
+        const consumedEnd = extension.end;
+        const consumed = cleaned.slice(lineOffsets[index], consumedEnd);
+        if (consumedEnd < cleaned.length && cleaned[consumedEnd] !== '\n' && cleaned[consumedEnd - 1] !== '\n') {
+          reportMarkdownPluginFailure(extension.node.plugin, 'syntax', new TypeError('Block syntax must consume complete lines'));
+        } else {
+          const newlineCount = consumed.split('\n').length - 1;
+          const consumedLines = Math.max(1, newlineCount + (consumed.endsWith('\n') ? 0 : 1));
+          pushBlock(extension.node, index + consumedLines - 1);
+          index += consumedLines;
+          continue;
+        }
+      }
+      if (extension.status === 'defer') {
+        break;
+      }
+    }
+
     // --- Paragraph ---
     const paraLines = [line];
     index++;
-    while (index < lines.length && !isBlockStart(lines[index]) && lines[index].trim() !== '') {
-      paraLines.push(lines[index]);
+    while (index < lines.length) {
+      const nextLine = lines[index];
+      if (isBlockStart(nextLine) || opts.math && matchDisplayMathBlock(lines, index) != null || nextLine.trim() === '') {
+        break;
+      }
+      if (hasBlockExtensionSyntax) {
+        const extensionColumn = blockExtensionColumn(nextLine);
+        if (extensionColumn != null) {
+          const extensionOffset = lineOffsets[index] + extensionColumn;
+          const extension = matchExtensionSyntax(cleaned, extensionOffset, 'block', opts);
+          if (extension.status !== 'none') {
+            blockExtensionMatches.set(extensionOffset, extension);
+            break;
+          }
+        }
+      }
+      paraLines.push(nextLine);
       index++;
     }
     pushBlock({
@@ -1385,9 +2100,13 @@ function stampSourceRanges(blocks, blockStartLines, blockEndLines, lines, lineMa
     const end = lineStart(endLine) + lines[endLine].length;
     blocks[i] = {
       ...blocks[i],
-      range: {
-        start: lineStart(startLine),
-        end
+      position: {
+        start: {
+          offset: lineStart(startLine)
+        },
+        end: {
+          offset: end
+        }
       }
     };
   }
@@ -1401,13 +2120,18 @@ const incrementalCaches = new WeakMap();
 function makeIncrementalCache(state) {
   const {
     defs
-  } = extractLinkDefinitions(state.settledText);
+  } = extractLinkDefinitions(state.settledText, state.math);
   const cache = {
     settledEnd: state.settledText.length,
     settledLinkDefs: new Map(defs),
     tailLinkDefs: new Map(),
     linkDefs: defs,
     linkDefsKey: linkDefsSignature(defs),
+    settledAstBlocks: [],
+    settledRevision: 0,
+    projectedRevision: -1,
+    projectedSettledBlocks: [],
+    projectionCache: new WeakMap(),
     work: {
       splitCharacters: 0,
       boundaryLines: 0,
@@ -1418,6 +2142,11 @@ function makeIncrementalCache(state) {
   incrementalCaches.set(state, cache);
   return cache;
 }
+
+/**
+ * Create an incremental parser cache. Use the `<true>` type argument with
+ * `MathParseOptions` so the cache and returned nodes share the math contract.
+ */
 export function createIncrementalState() {
   const state = {
     prevInput: '',
@@ -1456,33 +2185,70 @@ export function getIncrementalParseWork(state) {
  * the boundary to -1 even though the content before the fence opened cannot be
  * changed by anything typed inside it.
  */
-function findSettledBoundary(lines) {
+function findSettledBoundary(lines, math = false) {
   let inFence = false;
   let fenceMarker = '';
+  let mathContainer = null;
+  let suppressMathUntilBoundary = false;
   let lastBoundary = -1;
   let boundaryBeforeFence = -1;
+  let boundaryBeforeMath = -1;
   for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
     const line = lines[lineIndex];
-
-    // Fence open / close — match the specific marker character and length
-    const fenceMatch = line.match(/^(`{3,}|~{3,})/);
-    if (fenceMatch) {
-      if (!inFence) {
-        inFence = true;
-        fenceMarker = fenceMatch[1];
-        boundaryBeforeFence = lastBoundary;
-      } else if (fenceMatch[1].startsWith(fenceMarker[0]) && fenceMatch[1].length >= fenceMarker.length) {
+    if (inFence) {
+      const fenceMatch = line.match(/^(`{3,}|~{3,})/);
+      if (fenceMatch && fenceMatch[1].startsWith(fenceMarker[0]) && fenceMatch[1].length >= fenceMarker.length) {
         inFence = false;
         fenceMarker = '';
       }
+      continue;
+    }
+    if (mathContainer != null) {
+      const state = displayMathLineState(line, mathContainer);
+      if (state === 'close') {
+        mathContainer = null;
+        continue;
+      }
+      if (state === 'inside') {
+        continue;
+      }
+      // The list item or blockquote ended before a closer arrived. The parser
+      // treats that unmatched opener literally, so resume ordinary boundary
+      // detection on this first line outside the container.
+      mathContainer = null;
+      suppressMathUntilBoundary = true;
+    }
+
+    // A complete same-line `$$…$$` expression never changes boundary state.
+    // A standalone marker may belong to the top level, a blockquote, or one
+    // list item; remember that container so its continuation marker closes the
+    // same expression instead of opening a new one.
+    if (math && !suppressMathUntilBoundary) {
+      const container = displayMathContainer(line);
+      if (container != null) {
+        mathContainer = container;
+        boundaryBeforeMath = lastBoundary;
+        continue;
+      }
     }
-    if (!inFence && line.trim() === '' && lineIndex > 0 && lineIndex < lines.length - 1) {
-      lastBoundary = lineIndex;
+    const fenceMatch = line.match(/^(`{3,}|~{3,})/);
+    if (fenceMatch) {
+      inFence = true;
+      fenceMarker = fenceMatch[1];
+      boundaryBeforeFence = lastBoundary;
+      continue;
+    }
+    if (line.trim() === '') {
+      suppressMathUntilBoundary = false;
+      if (lineIndex > 0 && lineIndex < lines.length - 1) {
+        lastBoundary = lineIndex;
+      }
     }
   }
   return {
-    boundary: inFence ? boundaryBeforeFence : lastBoundary,
-    openFence: inFence
+    boundary: inFence ? boundaryBeforeFence : mathContainer != null ? boundaryBeforeMath : lastBoundary,
+    openFence: inFence,
+    openMath: mathContainer != null
   };
 }
 
@@ -1490,10 +2256,45 @@ function findSettledBoundary(lines) {
  * Strip trailing incomplete inline syntax that appears during streaming.
  * Only affects the tail of the last line — safe to apply to the full string.
  */
-export function trimStreamingArtifacts(input) {
-  const lastNL = input.lastIndexOf('\n');
-  const prefix = lastNL === -1 ? '' : input.slice(0, lastNL + 1);
-  let tail = lastNL === -1 ? input : input.slice(lastNL + 1);
+export function trimStreamingArtifacts(input, options) {
+  // First remove an incomplete display expression as one structural unit. This
+  // full-input scan distinguishes a terminal nested closer from a new opener;
+  // looking only at the final `$$` line cannot.
+  const displayTrimmed = options?.math ? trimOpenDisplayMath(input) : input;
+  const lastNL = displayTrimmed.lastIndexOf('\n');
+  const prefix = lastNL === -1 ? '' : displayTrimmed.slice(0, lastNL + 1);
+  let tail = lastNL === -1 ? displayTrimmed : displayTrimmed.slice(lastNL + 1);
+  if (options?.math) {
+    // Hold an unmatched inline opener so raw TeX syntax does not flash while
+    // streaming. If another unescaped dollar is already present but fails the
+    // closing-boundary rule, keep both literal (the currency case).
+    for (let index = 0; index < tail.length; index++) {
+      if (tail[index] === '$' && tail[index + 1] == null && tail[index - 1] !== '$' && !/\d/.test(tail[index - 1] ?? '') && !isEscaped(tail, index)) {
+        tail = tail.slice(0, index);
+        break;
+      }
+      if (!isInlineMathStart(tail, index)) {
+        continue;
+      }
+      const close = findInlineMathEnd(tail, index);
+      if (close !== -1) {
+        index = close;
+        continue;
+      }
+      let laterDollar = -1;
+      for (let next = index + 1; next < tail.length; next++) {
+        if (tail[next] === '$' && !isEscaped(tail, next)) {
+          laterDollar = next;
+          break;
+        }
+      }
+      if (laterDollar === -1) {
+        tail = tail.slice(0, index);
+        break;
+      }
+      index = laterDollar;
+    }
+  }
 
   // Scan backwards for unclosed syntax markers — no regex to avoid ReDoS
   // Find the last unclosed [ or ![ (link/image start)
@@ -1650,6 +2451,54 @@ export function trimStreamingArtifacts(input) {
  * Once a table is established (header + separator exist), new data rows
  * render immediately — no suppression.
  */
+function trimOpenDisplayMath(text) {
+  const lines = text.split('\n');
+  let inFence = false;
+  let fenceMarker = '';
+  let mathContainer = null;
+  let suppressMathUntilBoundary = false;
+  let mathStartLine = -1;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (inFence) {
+      const fence = line.match(/^(`{3,}|~{3,})/);
+      if (fence != null && fence[1].startsWith(fenceMarker[0]) && fence[1].length >= fenceMarker.length) {
+        inFence = false;
+        fenceMarker = '';
+      }
+      continue;
+    }
+    if (mathContainer != null) {
+      const state = displayMathLineState(line, mathContainer);
+      if (state === 'close') {
+        mathContainer = null;
+        mathStartLine = -1;
+        continue;
+      }
+      if (state === 'inside') {
+        continue;
+      }
+      mathContainer = null;
+      mathStartLine = -1;
+      suppressMathUntilBoundary = true;
+    }
+    if (line.trim() === '') {
+      suppressMathUntilBoundary = false;
+    }
+    const fence = line.match(/^(`{3,}|~{3,})/);
+    if (fence != null) {
+      inFence = true;
+      fenceMarker = fence[1];
+      continue;
+    }
+    const container = suppressMathUntilBoundary ? null : displayMathContainer(line);
+    if (container != null) {
+      mathContainer = container;
+      mathStartLine = index;
+    }
+  }
+  return mathContainer != null && mathStartLine >= 0 ? lines.slice(0, mathStartLine).join('\n').trimEnd() : text;
+}
 function trimUnsettledStructural(text) {
   const lines = text.split('\n');
 
@@ -1715,7 +2564,7 @@ function trimUnsettledStructural(text) {
  * rather than into the slice.
  */
 function atOffset(opts, offset) {
-  return opts.sourceRanges ? {
+  return opts.astPositions === true ? {
     ...opts,
     baseOffset: offset
   } : opts;
@@ -1740,14 +2589,13 @@ function mergeSettledBlocks(prev, delta) {
       ordered: prevLast.ordered,
       start: prevLast.start,
       delimiter: prevLast.delimiter,
-      loose: true,
-      items: [...prevLast.items, ...deltaFirst.items],
-      // One list now, so one range: from where the first half started to
-      // where the second half ended.
-      ...(prevLast.range != null && deltaFirst.range != null ? {
-        range: {
-          start: prevLast.range.start,
-          end: deltaFirst.range.end
+      spread: true,
+      children: [...prevLast.children, ...deltaFirst.children],
+      // One list now, so one position spans both halves.
+      ...(prevLast.position != null && deltaFirst.position != null ? {
+        position: {
+          start: prevLast.position.start,
+          end: deltaFirst.position.end
         }
       } : null)
     };
@@ -1759,11 +2607,11 @@ function mergeSettledBlocks(prev, delta) {
 /** Append a newly-settled slice without copying the already-settled prefix. */
 function appendSettledBlocks(prev, delta) {
   if (delta.length === 0) {
-    return;
+    return false;
   }
   if (prev.length === 0) {
     prev.push(...delta);
-    return;
+    return false;
   }
   const prevLast = prev[prev.length - 1];
   const deltaFirst = delta[0];
@@ -1773,19 +2621,20 @@ function appendSettledBlocks(prev, delta) {
       ordered: prevLast.ordered,
       start: prevLast.start,
       delimiter: prevLast.delimiter,
-      loose: true,
-      items: [...prevLast.items, ...deltaFirst.items],
-      ...(prevLast.range != null && deltaFirst.range != null ? {
-        range: {
-          start: prevLast.range.start,
-          end: deltaFirst.range.end
+      spread: true,
+      children: [...prevLast.children, ...deltaFirst.children],
+      ...(prevLast.position != null && deltaFirst.position != null ? {
+        position: {
+          start: prevLast.position.start,
+          end: deltaFirst.position.end
         }
       } : null)
     };
     prev.push(...delta.slice(1));
-    return;
+    return true;
   }
   prev.push(...delta);
+  return false;
 }
 function sameUnsettledDefinitions(previous, next, settled) {
   for (const [label, destination] of previous) {
@@ -1806,11 +2655,19 @@ function resetIncrementalCache(state, cache) {
   state.settledBlocks = [];
   state.settledUpTo = 0;
   state.linkDefsKey = undefined;
+  state.sourceIdsKey = undefined;
+  state.pluginSyntaxIdentity = undefined;
+  state.math = undefined;
   cache.settledEnd = 0;
   cache.settledLinkDefs.clear();
   cache.tailLinkDefs = new Map();
   cache.linkDefs = new Map();
   cache.linkDefsKey = '';
+  cache.settledAstBlocks = [];
+  cache.settledRevision++;
+  cache.projectedRevision = -1;
+  cache.projectedSettledBlocks = [];
+  cache.projectionCache = new WeakMap();
   cache.work = {
     splitCharacters: 0,
     boundaryLines: 0,
@@ -1832,23 +2689,47 @@ function resetIncrementalCache(state, cache) {
  */
 
 export function parseMarkdownIncremental(input, state, arg) {
-  const opts = resolveOptions(arg);
+  const withRanges = wantsLegacyRanges(arg);
+  const root = parseMarkdownAstIncremental(input, state, arg);
   const cache = incrementalCaches.get(state) ?? makeIncrementalCache(state);
-  let reparseSettled = false;
+  const projected = projectMarkdownRoot(root, withRanges, cache.projectionCache);
+  if (cache.projectedRevision !== cache.settledRevision) {
+    cache.projectedSettledBlocks = cache.settledAstBlocks.map(block => projectBlockNode(block, cache.projectionCache, withRanges));
+    cache.projectedRevision = cache.settledRevision;
+  }
+  state.settledBlocks = cache.projectedSettledBlocks;
+  return projected;
+}
 
-  // Invalidate cache when the autolink or sourceRanges option flips — cached
+/** @internal Canonical incremental parse used by Markdown rendering. */
+export function parseMarkdownAstIncremental(input, state, arg) {
+  const opts = resolveOptions(arg, true);
+  const root = {
+    type: 'root',
+    children: parseMarkdownIncrementalAstBlocks(input, state, opts)
+  };
+  return applyMarkdownTransforms(root, opts.plugins, input, opts.isFinal, 'block');
+}
+function parseMarkdownIncrementalAstBlocks(input, state, opts) {
+  const cache = incrementalCaches.get(state) ?? makeIncrementalCache(state);
+  let reparseSettled = false;
+  const nextSourceIdsKey = sourceIdsSignature(opts.sourceIds);
+  const nextPluginSyntaxIdentity = opts.plugins?.syntaxIdentity ?? '';
+  // Invalidate cache when an option that changes parsed nodes flips — cached
   // settled blocks were parsed with the previous setting and would otherwise
   // be reused unchanged.
-  if (state.autolink !== opts.autolink || Boolean(state.sourceRanges) !== Boolean(opts.sourceRanges)) {
+  if (state.autolink !== opts.autolink || state.math !== opts.math || Boolean(state.sourceRanges) !== Boolean(opts.sourceRanges) || state.sourceIdsKey !== nextSourceIdsKey || state.pluginSyntaxIdentity !== nextPluginSyntaxIdentity) {
     reparseSettled = true;
     state.autolink = opts.autolink;
+    state.math = opts.math;
     state.sourceRanges = opts.sourceRanges;
+    state.sourceIdsKey = nextSourceIdsKey;
+    state.pluginSyntaxIdentity = nextPluginSyntaxIdentity;
   }
   if (input === '') {
     resetIncrementalCache(state, cache);
     return [];
   }
-
   // The settled prefix is only reusable while the input still contains it
   // verbatim. Lengths alone cannot tell: a same-length or longer replacement
   // (new args after reusing a state) disagrees with the prefix without ever
@@ -1860,7 +2741,10 @@ export function parseMarkdownIncremental(input, state, arg) {
   if (state.settledText.length !== cache.settledEnd || !input.startsWith(state.settledText)) {
     resetIncrementalCache(state, cache);
     state.autolink = opts.autolink;
+    state.math = opts.math;
     state.sourceRanges = opts.sourceRanges;
+    state.sourceIdsKey = nextSourceIdsKey;
+    state.pluginSyntaxIdentity = nextPluginSyntaxIdentity;
   }
 
   // The recurring parse costs are confined to the mutable suffix: splitting,
@@ -1871,8 +2755,9 @@ export function parseMarkdownIncremental(input, state, arg) {
   const tailLines = tailRaw.split('\n');
   const {
     boundary,
-    openFence
-  } = findSettledBoundary(tailLines);
+    openFence,
+    openMath
+  } = findSettledBoundary(tailLines, opts.math);
   const settledDelta = boundary >= 0 ? tailLines.slice(0, boundary).join('\n') : '';
   const nextSettledEnd = oldSettledEnd + settledDelta.length;
   const unsettledInput = input.slice(nextSettledEnd);
@@ -1885,7 +2770,7 @@ export function parseMarkdownIncremental(input, state, arg) {
   if (settledDelta !== '') {
     const {
       defs: deltaDefs
-    } = extractLinkDefinitions(settledDelta);
+    } = extractLinkDefinitions(settledDelta, opts.math);
     for (const [label, destination] of deltaDefs) {
       if (!cache.settledLinkDefs.has(label)) {
         cache.settledLinkDefs.set(label, destination);
@@ -1897,7 +2782,7 @@ export function parseMarkdownIncremental(input, state, arg) {
   }
   const {
     defs: tailLinkDefs
-  } = extractLinkDefinitions(unsettledInput);
+  } = extractLinkDefinitions(unsettledInput, opts.math);
   if (!sameUnsettledDefinitions(cache.tailLinkDefs, tailLinkDefs, cache.settledLinkDefs)) {
     definitionsChanged = true;
   }
@@ -1921,27 +2806,47 @@ export function parseMarkdownIncremental(input, state, arg) {
     }
     cache.settledEnd = nextSettledEnd;
   }
-  const unsettledRaw = unsettledInput.trim();
+  const trimmedUnsettledInput = unsettledInput.trim();
+  // String#trim removes the CR that belongs to the final content line of a
+  // CRLF snapshot along with trailing blank lines. Keep that one byte so
+  // source ranges and delimiter content remain identical to a full parse.
+  const unsettledRaw = trimmedUnsettledInput !== '' && /\r(?:\n[\s]*)?$/.test(unsettledInput) ? `${trimmedUnsettledInput}\r` : trimmedUnsettledInput;
   // Structural trimming holds back lines that look like an incomplete list or
   // table, which inside a fence is ordinary code: a TypeScript union or a `- `
   // would disappear from the code block as it streams.
-  const unsettledText = openFence ? unsettledRaw : trimUnsettledStructural(unsettledRaw);
+  const unsettledText = openFence ? unsettledRaw : openMath ? trimOpenDisplayMath(unsettledRaw) : trimUnsettledStructural(unsettledRaw);
+  const legacyRanges = opts.sourceRanges === true;
   let parsedSettledBlocks = 0;
   if (reparseSettled) {
-    state.settledBlocks = state.settledText ? parseMarkdownImpl(state.settledText, parseOpts) : [];
-    parsedSettledBlocks = state.settledBlocks.length;
+    cache.settledAstBlocks = state.settledText ? parseMarkdownImpl(state.settledText, parseOpts) : [];
+    parsedSettledBlocks = cache.settledAstBlocks.length;
+    cache.settledRevision++;
+    cache.projectedSettledBlocks = cache.settledAstBlocks.map(block => projectBlockNode(block, cache.projectionCache, legacyRanges));
+    cache.projectedRevision = cache.settledRevision;
   } else if (settledDelta !== '') {
     const deltaBlocks = parseMarkdownImpl(settledDelta, atOffset(parseOpts, oldSettledEnd));
-    appendSettledBlocks(state.settledBlocks, deltaBlocks);
+    const mergeIndex = cache.settledAstBlocks.length - 1;
+    const mergedList = appendSettledBlocks(cache.settledAstBlocks, deltaBlocks);
     parsedSettledBlocks = deltaBlocks.length;
+    cache.settledRevision++;
+    const projectedDelta = deltaBlocks.map(block => projectBlockNode(block, cache.projectionCache, legacyRanges));
+    if (mergedList) {
+      const canonicalMerged = cache.settledAstBlocks[mergeIndex];
+      const projectedMerged = projectBlockNode(canonicalMerged, cache.projectionCache, legacyRanges);
+      cache.projectedSettledBlocks[mergeIndex] = projectedMerged;
+      cache.projectedSettledBlocks.push(...projectedDelta.slice(1));
+    } else {
+      cache.projectedSettledBlocks.push(...projectedDelta);
+    }
+    cache.projectedRevision = cache.settledRevision;
   }
 
   // The unsettled tail is trimmed before parsing, so its offset in the
   // document is where that trimmed text actually starts — not the boundary,
-  // which is a line index. If it somehow can't be located, parse it without
-  // ranges rather than report wrong ones. Only worth searching for when
-  // ranges were asked for: this runs on every streamed chunk.
-  const unsettledStart = unsettledText && opts.sourceRanges ? input.indexOf(unsettledText, cache.settledEnd) : -1;
+  // which is a line index. If it somehow cannot be located, parse it without
+  // positions rather than report wrong ones. The search starts at the
+  // settled end, so it scans the tail and never the prefix.
+  const unsettledStart = unsettledText && opts.astPositions === true ? input.indexOf(unsettledText, cache.settledEnd) : -1;
   const unsettledBlocks = unsettledText ? parseMarkdownImpl(unsettledText, unsettledStart >= 0 ? atOffset(parseOpts, unsettledStart) : nested(parseOpts)) : [];
   state.prevInput = input;
 
@@ -1956,7 +2861,7 @@ export function parseMarkdownIncremental(input, state, arg) {
     definitionCharacters: settledDelta.length + unsettledInput.length,
     renderedBlocks: parsedSettledBlocks + unsettledBlocks.length
   };
-  return mergeSettledBlocks(state.settledBlocks, unsettledBlocks);
+  return mergeSettledBlocks(cache.settledAstBlocks, unsettledBlocks);
 }
 
 // ---------------------------------------------------------------------------
@@ -1967,27 +2872,6 @@ export function parseMarkdownIncremental(input, state, arg) {
 // derives its item ids from the same functions, so outline hash links always
 // resolve to a rendered heading by construction.
 
-/** Flatten inline nodes into their plain text content. */
-export function inlineText(nodes) {
-  return nodes.map(node => {
-    switch (node.type) {
-      case 'text':
-      case 'code':
-        return node.content;
-      case 'bold':
-      case 'italic':
-      case 'strikethrough':
-      case 'link':
-        return inlineText(node.children);
-      case 'image':
-        return node.alt;
-      case 'citation':
-      case 'break':
-        return '';
-    }
-  }).join('');
-}
-
 /** Turn heading text into a URL-safe slug (lowercase, hyphen-separated). */
 export function slugify(value) {
   return value.trim().toLowerCase().replace(/['"]/g, '').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');