@agent-native/core 0.101.7 → 0.101.11

package/corpus/templates/content/shared/document-export.ts

@@ -1,3 +1,6 @@
+import { matchInlineMathAt } from "./inline-math.js";
+import { KATEX_STYLESHEET_URL, renderMathToHtml } from "./math-rendering.js";
+
 export type DocumentExportFormat = "pdf" | "markdown" | "html";
 
 export interface DocumentExportInput {
@@ -100,18 +103,37 @@ export function markdownWithTitle(
   return `${`# ${safeTitle}`}${body ? `\n\n${body}` : ""}\n`;
 }
 
-function inlineMarkdownToHtml(text: string): string {
+interface InlineExportToken {
+  marker: string;
+  html: string;
+  source: string;
+}
+
+function restoreTokenSources(
+  text: string,
+  tokens: InlineExportToken[],
+): string {
+  return tokens.reduce(
+    (restored, token) =>
+      restored.split(token.marker).join(escapeHtml(token.source)),
+    text,
+  );
+}
+
+function inlineMarkdownSegmentToHtml(
+  text: string,
+  tokens: InlineExportToken[],
+): string {
   return escapeHtml(text)
     .replace(
       /!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^&]*")?\)/g,
       (_m, alt, src) => {
-        return `<img src="${safeExportUrl(src, "image")}" alt="${alt}" />`;
+        return `<img src="${safeExportUrl(src, "image")}" alt="${restoreTokenSources(alt, tokens)}" />`;
       },
     )
     .replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_m, label, href) => {
       return `<a href="${safeExportUrl(href, "link")}">${label}</a>`;
     })
-    .replace(/`([^`]+)`/g, "<code>$1</code>")
     .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
     .replace(/__([^_]+)__/g, "<strong>$1</strong>")
     .replace(/~~([^~]+)~~/g, "<s>$1</s>")
@@ -119,24 +141,229 @@ function inlineMarkdownToHtml(text: string): string {
     .replace(/(^|[^_])_([^_]+)_/g, "$1<em>$2</em>");
 }
 
-function listItemsToHtml(lines: string[], ordered: boolean): string {
-  const items = lines
-    .map((line) => {
-      const text = ordered
-        ? line.replace(/^\s*\d+[.)]\s+/, "")
-        : line.replace(/^\s*[-*+]\s+/, "");
-      const task = text.match(/^\[( |x|X)\]\s+(.*)$/);
+function isEscapedDelimiter(text: string, index: number): boolean {
+  let backslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 1;
+}
+
+function mathErrorHtml(
+  source: string,
+  error: string,
+  displayMode: boolean,
+): string {
+  const className = displayMode
+    ? "math-error math-error-block"
+    : "math-error math-error-inline";
+  const tagName = displayMode ? "pre" : "code";
+  return `<${tagName} class="${className}" title="${escapeHtml(error)}">${escapeHtml(source)}</${tagName}>`;
+}
+
+function inlineMarkdownToHtml(text: string): string {
+  const tokens: InlineExportToken[] = [];
+  let markerStart = "\uE000agent-native-inline-";
+  while (text.includes(markerStart)) markerStart += "-";
+
+  const protectedText: string[] = [];
+  let cursor = 0;
+
+  while (cursor < text.length) {
+    if (text.startsWith("$`", cursor) && isEscapedDelimiter(text, cursor)) {
+      const close = text.indexOf("`$", cursor + 2);
+      if (close !== -1) {
+        protectedText.push(text.slice(cursor, close + 2));
+        cursor = close + 2;
+        continue;
+      }
+    }
+
+    if (text[cursor] === "$") {
+      const inlineMath = matchInlineMathAt(text, cursor);
+      if (inlineMath) {
+        const { latex } = inlineMath;
+        const source = text.slice(cursor, inlineMath.to);
+        const math = renderMathToHtml(latex, false);
+        const marker = `${markerStart}${tokens.length}\uE001`;
+        tokens.push({
+          marker,
+          source,
+          html: math.ok
+            ? `<span class="math-inline">${math.html}</span>`
+            : mathErrorHtml(source, math.error, false),
+        });
+        protectedText.push(marker);
+        cursor = inlineMath.to;
+        continue;
+      }
+    }
+
+    if (text[cursor] === "`" && !isEscapedDelimiter(text, cursor)) {
+      let delimiterLength = 1;
+      while (text[cursor + delimiterLength] === "`") delimiterLength++;
+      const delimiter = "`".repeat(delimiterLength);
+      let close = text.indexOf(delimiter, cursor + delimiterLength);
+      while (
+        close !== -1 &&
+        (text[close - 1] === "`" || text[close + delimiterLength] === "`")
+      ) {
+        close = text.indexOf(delimiter, close + delimiterLength);
+      }
+
+      if (close !== -1) {
+        const source = text.slice(cursor, close + delimiterLength);
+        let code = text
+          .slice(cursor + delimiterLength, close)
+          .replace(/\r?\n/g, " ");
+        if (
+          code.startsWith(" ") &&
+          code.endsWith(" ") &&
+          code.trim().length > 0
+        ) {
+          code = code.slice(1, -1);
+        }
+        const marker = `${markerStart}${tokens.length}\uE001`;
+        tokens.push({
+          marker,
+          source,
+          html: `<code>${escapeHtml(code)}</code>`,
+        });
+        protectedText.push(marker);
+        cursor = close + delimiterLength;
+        continue;
+      }
+    }
+
+    protectedText.push(text[cursor]);
+    cursor++;
+  }
+
+  return tokens.reduce(
+    (html, token) => html.split(token.marker).join(token.html),
+    inlineMarkdownSegmentToHtml(protectedText.join(""), tokens),
+  );
+}
+
+function listItemsToHtml(items: string[][], ordered: boolean): string {
+  const renderedItems = items
+    .map((lines) => {
+      const task = lines[0].match(/^\[( |x|X)\]\s+(.*)$/);
       if (task) {
         const checked = task[1].toLowerCase() === "x";
         return `<li class="task"><input type="checkbox" disabled${
           checked ? " checked" : ""
-        } /> <span>${inlineMarkdownToHtml(task[2])}</span></li>`;
+        } /> <span>${inlineMarkdownToHtml(task[2])}</span>${
+          lines.length > 1 ? markdownToHtml(lines.slice(1).join("\n")) : ""
+        }</li>`;
       }
-      return `<li>${inlineMarkdownToHtml(text)}</li>`;
+      return lines.length === 1
+        ? `<li>${inlineMarkdownToHtml(lines[0])}</li>`
+        : `<li>${markdownToHtml(lines.join("\n"))}</li>`;
     })
     .join("\n");
 
-  return ordered ? `<ol>\n${items}\n</ol>` : `<ul>\n${items}\n</ul>`;
+  return ordered
+    ? `<ol>\n${renderedItems}\n</ol>`
+    : `<ul>\n${renderedItems}\n</ul>`;
+}
+
+interface ListMarkerMatch {
+  baseIndent: number;
+  contentIndent: number;
+  content: string;
+}
+
+function indentationWidth(value: string): number {
+  let width = 0;
+  for (const character of value) {
+    width += character === "\t" ? 4 - (width % 4) : 1;
+  }
+  return width;
+}
+
+function matchListMarker(
+  line: string,
+  ordered: boolean,
+): ListMarkerMatch | null {
+  const match = line.match(
+    ordered
+      ? /^([ \t]*)(?:\d+[.)])([ \t]+)(.*)$/
+      : /^([ \t]*)(?:[-*+])([ \t]+)(.*)$/,
+  );
+  if (!match) return null;
+  const contentStart = match[0].length - match[3].length;
+  return {
+    baseIndent: indentationWidth(match[1]),
+    contentIndent: indentationWidth(line.slice(0, contentStart)),
+    content: match[3],
+  };
+}
+
+function leadingIndentWidth(line: string): number {
+  return indentationWidth(line.match(/^[ \t]*/)?.[0] ?? "");
+}
+
+function stripLeadingIndent(line: string, targetWidth: number): string {
+  let width = 0;
+  let index = 0;
+  while (index < line.length && width < targetWidth) {
+    const character = line[index];
+    if (character !== " " && character !== "\t") break;
+    width += character === "\t" ? 4 - (width % 4) : 1;
+    index++;
+  }
+  return line.slice(index);
+}
+
+function collectListItems(
+  lines: string[],
+  start: number,
+  ordered: boolean,
+): { items: string[][]; nextIndex: number } {
+  const firstMarker = matchListMarker(lines[start], ordered);
+  if (!firstMarker) return { items: [], nextIndex: start };
+
+  const baseIndent = firstMarker.baseIndent;
+  const items: string[][] = [];
+  let index = start;
+
+  while (index < lines.length) {
+    const itemMarker = matchListMarker(lines[index], ordered);
+    if (!itemMarker || itemMarker.baseIndent !== baseIndent) break;
+
+    const item = [itemMarker.content];
+    index++;
+
+    while (index < lines.length) {
+      const nextMarker = matchListMarker(lines[index], ordered);
+      if (nextMarker?.baseIndent === baseIndent) break;
+      if (leadingIndentWidth(lines[index]) >= itemMarker.contentIndent) {
+        item.push(stripLeadingIndent(lines[index], itemMarker.contentIndent));
+        index++;
+        continue;
+      }
+      if (!lines[index].trim()) {
+        let nextContent = index + 1;
+        while (nextContent < lines.length && !lines[nextContent].trim()) {
+          nextContent++;
+        }
+        if (
+          nextContent < lines.length &&
+          leadingIndentWidth(lines[nextContent]) >= itemMarker.contentIndent
+        ) {
+          item.push("");
+          index++;
+          continue;
+        }
+      }
+      break;
+    }
+
+    items.push(item);
+  }
+
+  return { items, nextIndex: index };
 }
 
 function isEmptyBlockLine(trimmed: string): boolean {
@@ -163,6 +390,42 @@ function markdownToHtml(markdown: string): string {
       continue;
     }
 
+    if (trimmed === "$$") {
+      const source = [line];
+      const latex: string[] = [];
+      index++;
+      while (index < lines.length && lines[index].trim() !== "$$") {
+        source.push(lines[index]);
+        latex.push(lines[index]);
+        index++;
+      }
+
+      const closed = index < lines.length;
+      if (closed) {
+        source.push(lines[index]);
+        index++;
+      }
+
+      if (!closed) {
+        blocks.push(
+          mathErrorHtml(
+            source.join("\n"),
+            "This block equation is missing its closing delimiter.",
+            true,
+          ),
+        );
+        continue;
+      }
+
+      const math = renderMathToHtml(latex.join("\n"), true);
+      blocks.push(
+        math.ok
+          ? `<div class="math-block">${math.html}</div>`
+          : mathErrorHtml(source.join("\n"), math.error, true),
+      );
+      continue;
+    }
+
     const codeFence = trimmed.match(/^```(\w+)?/);
     if (codeFence) {
       const code: string[] = [];
@@ -208,22 +471,16 @@ function markdownToHtml(markdown: string): string {
     }
 
     if (/^\s*[-*+]\s+/.test(line)) {
-      const items: string[] = [];
-      while (index < lines.length && /^\s*[-*+]\s+/.test(lines[index])) {
-        items.push(lines[index]);
-        index++;
-      }
-      blocks.push(listItemsToHtml(items, false));
+      const list = collectListItems(lines, index, false);
+      index = list.nextIndex;
+      blocks.push(listItemsToHtml(list.items, false));
       continue;
     }
 
     if (/^\s*\d+[.)]\s+/.test(line)) {
-      const items: string[] = [];
-      while (index < lines.length && /^\s*\d+[.)]\s+/.test(lines[index])) {
-        items.push(lines[index]);
-        index++;
-      }
-      blocks.push(listItemsToHtml(items, true));
+      const list = collectListItems(lines, index, true);
+      index = list.nextIndex;
+      blocks.push(listItemsToHtml(list.items, true));
       continue;
     }
 
@@ -233,6 +490,7 @@ function markdownToHtml(markdown: string): string {
       index < lines.length &&
       lines[index].trim() &&
       !isEmptyBlockLine(lines[index].trim()) &&
+      lines[index].trim() !== "$$" &&
       !/^(#{1,6})\s+/.test(lines[index].trim()) &&
       !/^```/.test(lines[index].trim()) &&
       !/^>\s?/.test(lines[index].trim()) &&
@@ -273,6 +531,7 @@ function buildHtmlDocument(input: {
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <title>${escapeHtml(input.title)}</title>
+  <link rel="stylesheet" href="${KATEX_STYLESHEET_URL}" crossorigin="anonymous" />
   <style>
     :root { color-scheme: light; }
     body {
@@ -329,6 +588,18 @@ function buildHtmlDocument(input: {
       border-radius: 4px;
       padding: 0.12rem 0.3rem;
     }
+    .math-inline { display: inline-block; max-width: 100%; vertical-align: -0.08em; }
+    .math-block { max-width: 100%; margin: 18px 0; overflow-x: auto; padding: 4px 0; }
+    .math-error {
+      border: 1px solid #fecaca;
+      border-radius: 6px;
+      background: #fef2f2;
+      color: #262626;
+      font-family: "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      white-space: pre-wrap;
+    }
+    .math-error-inline { padding: 0.05rem 0.25rem; font-size: 0.9em; }
+    .math-error-block { overflow-wrap: anywhere; padding: 12px 14px; }
     a { color: #2563eb; }
     img {
       display: block;

package/corpus/templates/content/shared/inline-math.ts

@@ -0,0 +1,128 @@
+export const MAX_INLINE_MATH_LENGTH = 1_000;
+
+export type InlineMathSyntax = "plain" | "github";
+
+export interface InlineMathMatch {
+  from: number;
+  to: number;
+  latex: string;
+  syntax: InlineMathSyntax;
+}
+
+export function isEscapedInlineDelimiter(text: string, index: number): boolean {
+  let backslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor--) {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+
+function matchGithubInlineMath(
+  text: string,
+  start: number,
+): InlineMathMatch | null {
+  if (!text.startsWith("$`", start)) return null;
+
+  const close = text.indexOf("`$", start + 2);
+  if (close === -1 || close - (start + 2) > MAX_INLINE_MATH_LENGTH) {
+    return null;
+  }
+
+  return {
+    from: start,
+    to: close + 2,
+    latex: text.slice(start + 2, close),
+    syntax: "github",
+  };
+}
+
+function matchPlainInlineMath(
+  text: string,
+  start: number,
+): InlineMathMatch | null {
+  if (
+    text[start] !== "$" ||
+    text[start + 1] === "$" ||
+    text[start + 1] === "`" ||
+    !text[start + 1] ||
+    /\s/.test(text[start + 1])
+  ) {
+    return null;
+  }
+
+  const searchLimit = Math.min(text.length, start + MAX_INLINE_MATH_LENGTH + 2);
+  for (let close = start + 1; close < searchLimit; close++) {
+    const char = text[close];
+    if (char === "\n" || char === "\r") return null;
+    if (
+      char !== "$" ||
+      isEscapedInlineDelimiter(text, close) ||
+      text[close - 1] === "$" ||
+      text[close + 1] === "$" ||
+      /\s/.test(text[close - 1]) ||
+      /\d/.test(text[close + 1] || "")
+    ) {
+      continue;
+    }
+
+    return {
+      from: start,
+      to: close + 1,
+      latex: text.slice(start + 1, close),
+      syntax: "plain",
+    };
+  }
+
+  return null;
+}
+
+export function matchInlineMathAt(
+  text: string,
+  start: number,
+): InlineMathMatch | null {
+  if (text[start] !== "$" || isEscapedInlineDelimiter(text, start)) {
+    return null;
+  }
+
+  return (
+    matchGithubInlineMath(text, start) ?? matchPlainInlineMath(text, start)
+  );
+}
+
+export function findTrailingPlainInlineMath(
+  text: string,
+): InlineMathMatch | null {
+  if (!text.endsWith("$") || text.endsWith("$$")) return null;
+
+  for (let start = text.length - 2; start >= 0; start--) {
+    if (text[start] !== "$") continue;
+    const match = matchInlineMathAt(text, start);
+    if (
+      match?.syntax === "plain" &&
+      match.to === text.length &&
+      !hasUnclosedCodeSpan(text.slice(0, start))
+    ) {
+      return match;
+    }
+  }
+
+  return null;
+}
+
+function hasUnclosedCodeSpan(text: string): boolean {
+  let openRun = 0;
+
+  for (let cursor = 0; cursor < text.length; cursor++) {
+    if (text[cursor] !== "`" || isEscapedInlineDelimiter(text, cursor)) {
+      continue;
+    }
+
+    let run = 1;
+    while (text[cursor + run] === "`") run += 1;
+    if (openRun === 0) openRun = run;
+    else if (openRun === run) openRun = 0;
+    cursor += run - 1;
+  }
+
+  return openRun !== 0;
+}

package/corpus/templates/content/shared/math-rendering.ts

@@ -0,0 +1,50 @@
+import katex, { type KatexOptions } from "katex";
+
+export const KATEX_VERSION = "0.17.0";
+export const KATEX_STYLESHEET_URL = `https://cdn.jsdelivr.net/npm/katex@${KATEX_VERSION}/dist/katex.min.css`;
+
+export interface MathRenderSuccess {
+  ok: true;
+  html: string;
+}
+
+export interface MathRenderFailure {
+  ok: false;
+  error: string;
+}
+
+export type MathRenderResult = MathRenderSuccess | MathRenderFailure;
+
+export function mathRenderOptions(displayMode: boolean): KatexOptions {
+  return {
+    displayMode,
+    maxExpand: 1_000,
+    output: "htmlAndMathml",
+    strict: "warn",
+    throwOnError: true,
+    trust: false,
+  };
+}
+
+export function mathRenderErrorMessage(error: unknown): string {
+  if (error instanceof Error && error.message.trim()) return error.message;
+  return "This equation could not be rendered.";
+}
+
+export function renderMathToHtml(
+  latex: string,
+  displayMode: boolean,
+): MathRenderResult {
+  if (!latex.trim()) {
+    return { ok: false, error: "This equation is empty." };
+  }
+
+  try {
+    return {
+      ok: true,
+      html: katex.renderToString(latex, mathRenderOptions(displayMode)),
+    };
+  } catch (error) {
+    return { ok: false, error: mathRenderErrorMessage(error) };
+  }
+}

package/corpus/templates/content/shared/nfm.ts

@@ -41,6 +41,7 @@
  * exposing simple string props for the editor preview layer.
  */
 
+import { matchInlineMathAt } from "./inline-math.js";
 import { isRegistryBlockTag, registryBlockSpecByTag } from "./nfm-registry.js";
 
 // ── Shared PM JSON types ────────────────────────────────────────────
@@ -115,7 +116,7 @@ function unescapeInlineText(text: string): string {
 // paragraph instead of being reparsed as that block type. These are matched
 // against the raw (untrimmed) text because the corresponding block parsers
 // (heading/list/task) also match against the untrimmed dedented line.
-const LEADING_BLOCK_MARKER = /^(#{1,4} |[-*+] |\d+[.)] |\[[ xX]\] )/;
+const LEADING_BLOCK_MARKER = /^(#{1,6} |[-*+] |\d+[.)] |\[[ xX]\] )/;
 
 // Divider lookalikes ("---", "***", "___", 3+ repeats) — matched separately
 // because the divider parser trims the line before testing
@@ -279,7 +280,7 @@ function serializeInlineAtom(node: PMNode): string {
     attrs = {};
   }
   if (tagName === "math") {
-    return "$`" + (label || attrs.latex || "") + "`$";
+    return "$" + (label || attrs.latex || "") + "$";
   }
   const attrEntries = Object.entries(attrs).filter(([k]) => k !== "latex");
   const attrStr = serializeAttrs(attrEntries);
@@ -446,19 +447,21 @@ function parseInline(input: string): PMNode[] {
       continue;
     }
 
-    // Inline math $`...`$
-    if (ch === "$" && input[i + 1] === "`") {
-      const close = input.indexOf("`$", i + 2);
-      if (close !== -1) {
-        flush();
-        const latex = input.slice(i + 2, close);
-        out.push({
-          type: "notionInlineAtom",
-          attrs: { tagName: "math", attrsJson: "{}", label: latex },
-        });
-        i = close + 2;
-        continue;
-      }
+    // Canonical inline math is $...$; GitHub's $`...`$ form remains a
+    // backwards-compatible input alias and canonicalizes on the next write.
+    const inlineMath = ch === "$" ? matchInlineMathAt(input, i) : null;
+    if (inlineMath) {
+      flush();
+      out.push({
+        type: "notionInlineAtom",
+        attrs: {
+          tagName: "math",
+          attrsJson: "{}",
+          label: inlineMath.latex,
+        },
+      });
+      i = inlineMath.to;
+      continue;
     }
 
     // Inline code `...` — CommonMark-style variable-length delimiter: the
@@ -865,7 +868,7 @@ function serializeBlock(node: PMNode, indent: number): string[] {
       ];
     }
     case "heading": {
-      const level = Math.min(4, Math.max(1, Number(node.attrs?.level) || 1));
+      const level = Math.min(6, Math.max(1, Number(node.attrs?.level) || 1));
       const inline = serializeInline(node.content);
       return [
         indentStr(ind) +
@@ -1480,7 +1483,7 @@ function parseSingleBlock(
   // Heading (possibly a toggle heading)
   const headingMatch = dedent.match(/^(#{1,6})\s+(.*)$/);
   if (headingMatch) {
-    const level = Math.min(4, headingMatch[1].length);
+    const level = headingMatch[1].length;
     const { text, toggle, color } = splitBlockAttrs(headingMatch[2]);
     if (toggle) {
       const childRes = parseBlockSequence(lines, start + 1, indent + 1);

package/corpus/templates/content/vite.config.ts

@@ -413,7 +413,6 @@ const cloudflareSsrStubs =
         "@xterm/addon-fit",
         "@xterm/addon-web-links",
         "@xterm/xterm",
-        "katex",
         "lowlight",
         "prettier",
         "react-markdown",