@agent-native/core-corpus 0.214.0 → 0.217.0

package/corpus/templates/content/shared/og-description.ts

@@ -7,7 +7,12 @@ function stripFrontmatter(markdown: string): string {
 }
 
 function stripFencedCode(markdown: string): string {
-  return markdown.replace(/(?:^|\n)(```|~~~)[\s\S]*?(?:\n\1[ \t]*|$)/g, "\n");
+  // A closing fence is at least as long as the opening one and has nothing
+  // after it, so a line like ```js inside the block doesn't close it.
+  return markdown.replace(
+    /(?:^|\n) {0,3}((`|~)\2{2,})[\s\S]*?(?:\n {0,3}\1\2*[ \t]*(?=\n|$)|$)/g,
+    "\n",
+  );
 }
 
 function decodeCommonEntities(text: string): string {
@@ -22,9 +27,10 @@ function decodeCommonEntities(text: string): string {
 
 function normalizeForComparison(text: string): string {
   return stripMarkdownForPreview(text)
+    .normalize("NFC")
     .toLowerCase()
     .replace(/&/g, "and")
-    .replace(/[^a-z0-9]+/g, " ")
+    .replace(/[^\p{L}\p{M}\p{N}]+/gu, " ")
     .trim();
 }
 
@@ -39,11 +45,19 @@ function isHeadingBlock(block: string): boolean {
   if (/^#{1,6}\s+\S/.test(trimmed)) return true;
   if (/^<h[1-6]\b/i.test(trimmed)) return true;
 
+  // Lines of paragraph text underlined with `=` or `-`. Under a list, quote
+  // or table, a `---` is a divider instead.
   const lines = trimmed.split("\n");
   return (
-    lines.length === 2 &&
-    lines[0].trim().length > 0 &&
-    /^\s*(=+|-+)\s*$/.test(lines[1])
+    lines.length >= 2 &&
+    /^\s*(=+|-+)\s*$/.test(lines[lines.length - 1]) &&
+    lines
+      .slice(0, -1)
+      .every(
+        (line) =>
+          line.trim().length > 0 &&
+          !/^\s{0,3}(?:(?:[-+*]|\d+[.)])(?:\s|$)|>|\|)/.test(line),
+      )
   );
 }
 
@@ -52,41 +66,51 @@ function isDividerBlock(block: string): boolean {
 }
 
 export function stripMarkdownForPreview(markdown: string): string {
-  return decodeCommonEntities(markdown)
-    .replace(/<[^>\n]+\/>/g, " ")
-    .replace(/<\/?[^>\n]+>/g, " ")
-    .replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1")
-    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
-    .replace(/\[([^\]]+)\]\[[^\]]*\]/g, "$1")
-    .replace(/`([^`]+)`/g, "$1")
-    .replace(/^#{1,6}\s+/gm, "")
-    .replace(/\s+#+\s*$/gm, "")
-    .replace(/^\s{0,3}>\s?/gm, "")
-    .replace(/^\s*[-+*]\s+\[[ xX]\]\s+/gm, "")
-    .replace(/^\s*[-+*]\s+/gm, "")
-    .replace(/^\s*\d+[.)]\s+/gm, "")
-    .replace(/^\s*\|?(?:\s*:?-{3,}:?\s*\|)+\s*$/gm, " ")
-    .replace(/\|/g, " ")
-    .replace(/\*\*([^*\n]+)\*\*/g, "$1")
-    .replace(/__([^_\n]+)__/g, "$1")
-    .replace(/\*([^*\n]+)\*/g, "$1")
-    .replace(/_([^_\n]+)_/g, "$1")
-    .replace(/~~([^~\n]+)~~/g, "$1")
-    .replace(/\\([\\`*_[\]{}()#+\-.!|>])/g, "$1")
-    .replace(/\s+/g, " ")
-    .trim();
+  return (
+    decodeCommonEntities(markdown)
+      .replace(/<[^>\n]+\/>/g, " ")
+      .replace(/<\/?[^>\n]+>/g, " ")
+      .replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1")
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+      .replace(/\[([^\]]+)\]\[[^\]]*\]/g, "$1")
+      .replace(/`([^`]+)`/g, "$1")
+      .replace(/^#{1,6}\s+/gm, "")
+      .replace(/\s+#+\s*$/gm, "")
+      .replace(/^\s{0,3}>\s?/gm, "")
+      .replace(/^\s*[-+*]\s+\[[ xX]\]\s+/gm, "")
+      .replace(/^\s*[-+*]\s+/gm, "")
+      .replace(/^\s*\d+[.)]\s+/gm, "")
+      .replace(/^\s*\|?(?:\s*:?-{3,}:?\s*\|)+\s*$/gm, " ")
+      // Heading underlines and dividers that share a block with text.
+      .replace(/^[ \t]{0,3}(?:=+|-+)[ \t]*$/gm, " ")
+      .replace(/\|/g, " ")
+      .replace(/\*\*([^*\n]+)\*\*/g, "$1")
+      .replace(/__([^_\n]+)__/g, "$1")
+      .replace(/\*([^*\n]+)\*/g, "$1")
+      .replace(/_([^_\n]+)_/g, "$1")
+      .replace(/~~([^~\n]+)~~/g, "$1")
+      .replace(/\\([\\`*_[\]{}()#+\-.!|>])/g, "$1")
+      .replace(/\s+/g, " ")
+      .trim()
+  );
 }
 
-function truncateDescription(text: string, maxLength: number): string {
-  if (text.length <= maxLength) return text;
-
+/** Ends text with "...", shortening it at a word so the whole fits. */
+function withEllipsis(text: string, maxLength: number): string {
   const hardLimit = Math.max(20, maxLength - 3);
-  const prefix = text.slice(0, hardLimit);
-  const wordBoundary = prefix.lastIndexOf(" ");
-  const truncated =
-    wordBoundary > hardLimit * 0.6 ? prefix.slice(0, wordBoundary) : prefix;
+  let kept = text;
+  if (kept.length > hardLimit) {
+    const prefix = kept.slice(0, hardLimit);
+    const wordBoundary = prefix.lastIndexOf(" ");
+    kept =
+      wordBoundary > hardLimit * 0.6 ? prefix.slice(0, wordBoundary) : prefix;
+  }
+
+  return `${kept.replace(/[.,;:!?\s-]+$/g, "")}...`;
+}
 
-  return `${truncated.replace(/[.,;:!?\s-]+$/g, "")}...`;
+function truncateDescription(text: string, maxLength: number): string {
+  return text.length <= maxLength ? text : withEllipsis(text, maxLength);
 }
 
 export function buildPublicDocumentDescription({
@@ -126,3 +150,201 @@ export function buildPublicDocumentDescription({
     ? truncateDescription(fallback, maxLength)
     : DEFAULT_DESCRIPTION;
 }
+
+/** A line frontmatter holds: a key, list item, indented value, comment or blank. */
+/** A frontmatter key and its colon. A quoted key can hold colons. */
+const FRONTMATTER_KEY_SOURCE = String.raw`(?:"[^"\n]*"|'[^'\n]*'|[^\s#:-][^:\n]*):(?=\s|$)`;
+const FRONTMATTER_KEY = new RegExp(`^${FRONTMATTER_KEY_SOURCE}`);
+const FRONTMATTER_LINE = new RegExp(
+  String.raw`^(?:[ \t]*(?:#.*)?|[ \t]+\S.*|-(?:[ \t].*)?|${FRONTMATTER_KEY_SOURCE}.*)$`,
+);
+const FRONTMATTER_START = new RegExp(
+  String.raw`^---[ \t]*\n(?:#|${FRONTMATTER_KEY_SOURCE})`,
+);
+// A key cut before its colon: one word, or a quoted name.
+const FRONTMATTER_KEY_START = /^(?:"[^"\n]*|'[^'\n]*|[^\s#:-][^\s:]*)$/;
+// A key written the way frontmatter keys are: one word that doesn't start
+// with a capital, or a quoted name. A label like `Note:` starts prose.
+const CONVENTIONAL_FRONTMATTER_KEY =
+  /^(?:"[^"\n]*"|'[^'\n]*'|[^\s\p{Lu}#:"'-][^\s:]*):(?=\s|$)/u;
+
+/**
+ * The markdown after its frontmatter, or null when a prefix ends inside it.
+ * Frontmatter opens with `---` and a key or comment, and holds only YAML lines,
+ * at least one a key, up to a closing `---`. A divider at the top of a page is
+ * followed by a blank line or by text that isn't YAML.
+ */
+function stripExcerptFrontmatter(
+  markdown: string,
+  truncated: boolean,
+): string | null {
+  if (!FRONTMATTER_START.test(markdown)) return markdown;
+  const lines = markdown.split("\n");
+  let hasKey = false;
+  for (let index = 1; index < lines.length; index++) {
+    const line = lines[index];
+    if (/^---[ \t]*$/.test(line)) {
+      return hasKey ? lines.slice(index + 1).join("\n") : markdown;
+    }
+    if (FRONTMATTER_KEY.test(line)) hasKey = true;
+    // A prefix's last line may be cut short. After a whole line, it counts if
+    // it could still begin a YAML line. Cut as the first line, it counts only
+    // with a conventional key, so a long `Note: …` paragraph after a top
+    // divider stays page text while a long `description:` stays hidden.
+    if (truncated && index === lines.length - 1) {
+      const couldBeYaml =
+        index > 1
+          ? FRONTMATTER_LINE.test(line) || FRONTMATTER_KEY_START.test(line)
+          : CONVENTIONAL_FRONTMATTER_KEY.test(line);
+      if (!couldBeYaml) return markdown;
+      break;
+    }
+    if (!FRONTMATTER_LINE.test(line)) return markdown;
+  }
+  // A prefix that has shown only YAML lines may end inside the frontmatter,
+  // even before its first key.
+  return truncated ? null : markdown;
+}
+
+/**
+ * Drops opening markers with no partner after them, like the `**` of a bold
+ * run a cut split. Closed spans keep their text, markers and all.
+ */
+function dropUnclosedMarkers(markdown: string): string {
+  return markdown.replace(
+    /(^|\s)(\*{1,3}|_{1,3}|~~|`+)(?=[\p{L}\p{M}\p{N}])/gu,
+    (match, space: string, marker: string, offset: number) =>
+      markdown.slice(offset + match.length).includes(marker) ? match : space,
+  );
+}
+
+const DEFAULT_EXCERPT_LENGTH = 300;
+/** Scripts written without spaces between words. */
+const SPACELESS_SCRIPT =
+  /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}]/u;
+
+/**
+ * Plain text from the start of a page body, for a list row. Images, code,
+ * dividers and a first paragraph that repeats the title drop out, and
+ * headings only count when the page has no other text. `truncated` means the
+ * markdown is only the body's first part, so it may end partway through;
+ * `nextCharacter`, when known, tells whether its last word goes on.
+ */
+export function buildDocumentExcerpt({
+  content,
+  title,
+  truncated = false,
+  nextCharacter,
+  maxLength = DEFAULT_EXCERPT_LENGTH,
+}: {
+  content?: string | null;
+  title?: string | null;
+  truncated?: boolean;
+  nextCharacter?: string;
+  maxLength?: number;
+}): string {
+  const body = stripExcerptFrontmatter(
+    content?.replace(/\r\n?/g, "\n") ?? "",
+    truncated,
+  );
+  // A prefix that ends inside the frontmatter has no body text yet.
+  if (body === null) return "";
+  let markdown = body;
+  if (truncated) {
+    // Drop an image or tag the cut leaves open. A link it leaves open keeps
+    // its text, and when the cut falls in its address, that text is whole.
+    let linkTextEnded = false;
+    markdown = markdown
+      .replace(/!\[[^\]\n]*(?:\]\([^)\n]*)?$/, "")
+      .replace(/<[A-Za-z/!][^>\n]*$/, "")
+      .replace(
+        /\[([^\]\n]*)(\]\([^)\n]*)?$/,
+        (_match, text: string, address?: string) => {
+          linkTextEnded = address !== undefined;
+          return text;
+        },
+      );
+    // Drop a word the cut splits, with any markup or punctuation in front of
+    // it. A cut right after punctuation or closing markup ends a whole word,
+    // an apostrophe after the cut means the word goes on, and text in a
+    // script written without spaces has no word to finish.
+    const lastWord = /\s(\S*[\p{L}\p{M}\p{N}'’])$/u.exec(markdown)?.[1];
+    const wordGoesOn =
+      nextCharacter === undefined || /[\p{L}\p{M}\p{N}'’]/u.test(nextCharacter);
+    if (
+      lastWord &&
+      wordGoesOn &&
+      !linkTextEnded &&
+      !SPACELESS_SCRIPT.test(lastWord)
+    ) {
+      markdown = markdown.slice(0, -lastWord.length);
+    }
+    // Then markup or an opening bracket or quote left with nothing after it.
+    markdown = markdown.replace(/(^|\s)[*_~`(["'“‘]+$/u, "$1");
+  }
+  const blocks = stripFencedCode(markdown)
+    // Headings and dividers stand alone even without blank lines around them.
+    // A line of `=` or `-` right under a line of text underlines it as a
+    // heading, so it stays with that line.
+    .replace(/^ {0,3}#{1,6}[ \t].*$/gm, "\n$&\n")
+    .replace(/(?<=\S[^\n]*\n) {0,3}(?:=+|-+)[ \t]*$/gm, "$&\n")
+    .replace(/^ {0,3}(?:(?:\*[ \t]*){3,}|(?:_[ \t]*){3,})$/gm, "\n")
+    .replace(/(^|\n\n)[ \t]{0,3}(?:[-*_][ \t]*){3,}(?=\n|$)/g, "$1\n")
+    .split(/\n{2,}/);
+  const paragraphs: string[] = [];
+  const headings: string[] = [];
+  let length = 0;
+  for (const [index, block] of blocks.entries()) {
+    if (length > maxLength) break;
+    if (!block.trim() || isDividerBlock(block)) continue;
+    // The cut can only leave markup open in the last block.
+    const source =
+      truncated && index === blocks.length - 1
+        ? dropUnclosedMarkers(block)
+        : block;
+    const text = stripMarkdownForPreview(
+      source.replace(/!\[[^\]]*\]\([^)]*\)/g, " "),
+    );
+    if (!text) continue;
+    if (isHeadingBlock(block)) {
+      headings.push(text);
+    } else if (paragraphs.length > 0 || !isTitleRepeat(text, title ?? "")) {
+      paragraphs.push(text);
+      length += text.length + 1;
+    }
+  }
+  const text = (paragraphs.length > 0 ? paragraphs : headings).join(" ");
+  if (text.length > maxLength) return truncateDescription(text, maxLength);
+  return truncated && text ? withEllipsis(text, maxLength) : text;
+}
+
+/**
+ * How much of a page body a list row's excerpt reads: enough markdown for
+ * three lines of text once links and formatting are stripped.
+ */
+export const EXCERPT_SOURCE_CHARS = 1000;
+
+/**
+ * A list row's excerpt, from only the first `EXCERPT_SOURCE_CHARS` characters
+ * of the page body. A whole body and a list read's prefix, which takes one
+ * character more to tell a longer body from one that fits, give the same text.
+ */
+export function buildListRowExcerpt({
+  content,
+  title,
+}: {
+  content?: string | null;
+  title?: string | null;
+}): string {
+  // Count characters the way the database does, not UTF-16 units. No
+  // character takes more than two units.
+  const characters = Array.from(
+    (content ?? "").slice(0, 2 * (EXCERPT_SOURCE_CHARS + 1)),
+  );
+  return buildDocumentExcerpt({
+    content: characters.slice(0, EXCERPT_SOURCE_CHARS).join(""),
+    title,
+    truncated: characters.length > EXCERPT_SOURCE_CHARS,
+    nextCharacter: characters[EXCERPT_SOURCE_CHARS],
+  });
+}

package/corpus/templates/content/shared/suggestion-diff.ts

@@ -973,6 +973,19 @@ export function markdownSuggestionOperationsForFindReplaceEdits(input: {
   );
 }
 
+/**
+ * The summary suggest-document-edit records when the agent gives none. The
+ * comments sidebar compares against it so it never shows this as a reason.
+ */
+export function findReplaceSuggestionSummary(
+  find: string,
+  replace: string,
+): string {
+  return replace
+    ? `Replace "${find.slice(0, 80)}" with "${replace.slice(0, 80)}"`
+    : `Delete "${find.slice(0, 80)}"`;
+}
+
 /** A one-line review label for a single operation's change. */
 export function markdownSuggestionOperationSummary(
   operation: MarkdownSuggestionOperation,

package/corpus/templates/content/shared/suggestion-formatting.ts

@@ -1,7 +1,10 @@
 import {
   canonicalizeNfm,
   docToNfm,
+  longestRun,
+  nfmContextualSpellings,
   nfmToDoc,
+  pushAll,
   serializeInlineTextNodeWithOffsets,
   type PMNode,
 } from "./nfm";
@@ -12,6 +15,8 @@ type TextRun = {
   markValues: PMNode["marks"];
   serialized: string;
   textOffsets: number[];
+  /** L7 bridge: offsets past a reopened delimiter, each a text boundary. */
+  reopened?: Map<number, number>;
   from: number;
   to: number;
   sourceFrom: number;
@@ -19,6 +24,10 @@ type TextRun = {
   nonTextBefore: boolean;
   verbatim?: boolean;
   emptyCell?: boolean;
+  /** The writer puts a `\` before this run, which belongs to the syntax gap. */
+  escapedBlockMarker?: boolean;
+  /** Its placeholder starts with a digit, as the run's bytes do. */
+  digitLead?: boolean;
 };
 type TextRange = { from: number; to: number };
 
@@ -55,20 +64,41 @@ function withoutMarks(node: PMNode): PMNode {
 }
 
 function longestBacktickRun(text: string): number {
-  return Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length));
+  return longestRun(text, /`+/g);
 }
 
-function formattingRuns(
-  source: string,
-  anchorEmptyCells = false,
-): {
+type FormattingRuns = {
   runs: TextRun[];
   nonTextAfter: boolean;
   restored: string;
   spans: Array<Record<SourceSide, SourceSpan>>;
   emptyCells: Array<{ sourceOffset: number; textOffset: number }>;
-} | null {
+};
+
+// Every suggestion on a Page maps its range through the same Page source, so
+// recent results are kept rather than reparsing the Page per suggestion.
+const recentFormattingRuns = new Map<string, FormattingRuns | null>();
+
+function formattingRuns(
+  source: string,
+  anchorEmptyCells = false,
+): FormattingRuns | null {
+  const key = `${anchorEmptyCells ? 1 : 0}${source}`;
+  if (recentFormattingRuns.has(key))
+    return recentFormattingRuns.get(key) as FormattingRuns | null;
+  const mapped = computeFormattingRuns(source, anchorEmptyCells);
+  if (recentFormattingRuns.size >= 8)
+    recentFormattingRuns.delete(recentFormattingRuns.keys().next().value!);
+  recentFormattingRuns.set(key, mapped);
+  return mapped;
+}
+
+function computeFormattingRuns(
+  source: string,
+  anchorEmptyCells: boolean,
+): FormattingRuns | null {
   const doc = nfmToDoc(source);
+  const spellings = nfmContextualSpellings(doc);
   let markerPrefix = "suggestiontextboundary";
   while (source.includes(markerPrefix)) markerPrefix += "z";
   const runs: TextRun[] = [];
@@ -140,15 +170,20 @@ function formattingRuns(
     }
     if (node.type === "text" && node.text) {
       const index = runs.length;
-      const marker = `${markerPrefix}${index}x`;
       const serialized = serializeInlineTextNodeWithOffsets(
         node,
+        spellings.escapedUnderscores.has(node),
+        spellings.escapedTrailingBang.has(node),
         position === 0,
       );
       if (!serialized) {
         nonTextPending = true;
         return node;
       }
+      // Inline math before a digit is written in another form, so the
+      // placeholder after it must start with a digit too.
+      const digitLead = /^\d/.test(serialized.source);
+      const marker = `${digitLead ? "0" : ""}${markerPrefix}${index}x`;
       runs.push({
         text: node.text,
         marks: JSON.stringify(node.marks ?? []),
@@ -160,6 +195,8 @@ function formattingRuns(
         sourceFrom: -1,
         sourceTo: -1,
         nonTextBefore: nonTextPending,
+        escapedBlockMarker: spellings.escapedBlockMarker.has(node),
+        digitLead,
       });
       nonTextPending = false;
       offset += node.text.length;
@@ -183,17 +220,19 @@ function formattingRuns(
   let delta = 0;
   const markers: string[] = [];
   const restored = withPlaceholders.replace(
-    new RegExp(`${markerPrefix}(\\d+)\`*x`, "g"),
-    (token, rawIndex: string, position: number) => {
+    new RegExp(`(0?)${markerPrefix}(\\d+)\`*x`, "g"),
+    (token, lead: string, rawIndex: string, position: number) => {
       const index = Number(rawIndex);
       const run = runs[index]!;
       markers[index] = token;
+      if (Boolean(lead) !== Boolean(run.digitLead)) unmappable = true;
       if (run.verbatim && !resolveVerbatimRun(run, withPlaceholders, position))
         unmappable = true;
-      run.sourceFrom = position + delta;
+      const escape = run.escapedBlockMarker ? "\\" : "";
+      run.sourceFrom = position + delta + escape.length;
       run.sourceTo = run.sourceFrom + run.serialized.length;
-      delta += run.serialized.length - token.length;
-      return run.serialized;
+      delta += escape.length + run.serialized.length - token.length;
+      return escape + run.serialized;
     },
   );
   if (unmappable || runs.some((run) => run.sourceFrom < 0)) return null;
@@ -220,12 +259,16 @@ function formattingRuns(
         from: run.sourceFrom,
         to: run.sourceTo,
         textOffsets: run.textOffsets,
+        reopened: run.reopened, // L7 bridge
       },
     })),
   };
 }
 
-type SourceSpan = TextRange & { textOffsets: number[] };
+type SourceSpan = TextRange & {
+  textOffsets: number[];
+  reopened?: Map<number, number>; // L7 bridge
+};
 type SourceSide = "canonical" | "stored";
 
 export type SuggestionSourceAlignment = {
@@ -266,6 +309,30 @@ function sourceAlignment(source: string): SuggestionSourceAlignment | null {
       map: (offset) => (inside(offset, source) ? offset : null),
       atTextEdge: (offset) => inside(offset, source),
     };
+  // L7 bridge: canonical Markdown drops the editor's trailing empty paragraph,
+  // which a stored page may still hold on its last line; that line has no
+  // image.
+  const lastLine = source.trimEnd().lastIndexOf("\n");
+  const kept = source.slice(0, lastLine).replace(/\r$/, "");
+  if (
+    lastLine >= 0 &&
+    canonicalizeNfm(source.slice(lastLine)) === "<empty-block/>" &&
+    canonicalizeNfm(kept) === canonical
+  ) {
+    const alignment = sourceAlignment(kept);
+    return (
+      alignment && {
+        canonical,
+        map: (offset, from) =>
+          from === "stored" && offset > kept.length
+            ? null
+            : alignment.map(offset, from),
+        atTextEdge: (offset, from) =>
+          !(from === "stored" && offset > kept.length) &&
+          alignment.atTextEdge(offset, from),
+      }
+    );
+  }
   const mapped = formattingRuns(source, true) ?? formattingRuns(source, false);
   if (!mapped || mapped.restored !== canonical) return null;
   const texts = { canonical, stored: source };
@@ -312,7 +379,11 @@ function sourceAlignment(source: string): SuggestionSourceAlignment | null {
           if (offset === own.from) return other.from;
           if (offset === own.to) return other.to;
           const index = own.textOffsets.indexOf(offset - own.from);
-          return index < 0 ? null : other.from + other.textOffsets[index]!;
+          const boundary =
+            index < 0 ? own.reopened?.get(offset - own.from) : index; // L7 bridge
+          return boundary === undefined
+            ? null
+            : other.from + other.textOffsets[boundary]!;
         }
         previous = { canonical: span.canonical.to, stored: span.stored.to };
       }
@@ -340,6 +411,8 @@ function normalizedSourceGap(source: string, from: number, to: number): string {
 
 const TABLE_TAG = /<\/?(?:table|tr|td|th)\b[^>]*>/;
 
+const ASCII_PUNCTUATION = /^[!-/:-@[-`{-~]$/; // L7 bridge
+
 // Canonical NFM writes a stored pipe table as an HTML table. Both reduce to
 // "|" between cells and a newline between rows, with or without the stored
 // rows' optional outer pipes; the final reparse proves the cells.
@@ -376,6 +449,17 @@ function mapStoredSourceRuns(
     }
     return true;
   };
+  // L7 bridge: agents spell emphasis with underscores where the writer uses
+  // stars; the final parse check proves the delimiters pair up the same way.
+  const matchesDelimiters = (token: string, position: number) => {
+    for (let index = 0; index < token.length; index += 1) {
+      if (remainingWork-- <= 0) return false;
+      const stored = source[position + index];
+      if (stored !== token[index] && !(token[index] === "*" && stored === "_"))
+        return false;
+    }
+    return true;
+  };
   const gapMatches = (
     from: number,
     to: number,
@@ -445,6 +529,10 @@ function mapStoredSourceRuns(
     }
     const prefix = run.serialized.slice(0, run.textOffsets[0]);
     const suffix = run.serialized.slice(run.textOffsets[run.text.length]);
+    // L7 bridge: adjacent runs with the same formatting read as one, so the
+    // stored source may close and reopen the run's delimiters between two
+    // characters.
+    const reopen = prefix && suffix ? suffix + prefix : "";
     const tokens = run.text
       .split("")
       .map((_character, characterIndex) =>
@@ -456,9 +544,10 @@ function mapStoredSourceRuns(
     let found = false;
     for (let start = cursor; start < source.length; start += 1) {
       if (remainingWork < 0) return false;
-      if (!matches(prefix, start)) continue;
+      if (!matchesDelimiters(prefix, start)) continue; // L7 bridge
       let position = start + prefix.length;
       const textOffsets = [prefix.length];
+      let reopened: Map<number, number> | undefined; // L7 bridge
       let valid = true;
       for (
         let characterIndex = 0;
@@ -467,9 +556,35 @@ function mapStoredSourceRuns(
       ) {
         const token = tokens[characterIndex]!;
         const character = run.text[characterIndex]!;
+        // L7 bridge
+        if (
+          characterIndex > 0 &&
+          reopen &&
+          !matches(token, position) &&
+          matchesDelimiters(reopen, position)
+        ) {
+          position += reopen.length;
+          // The boundary before this character sits on both sides of the
+          // reopened delimiters.
+          (reopened ??= new Map()).set(position - start, characterIndex);
+        }
         if (matches(token, position)) position += token.length;
-        // Inline math is an atom, so a dollar in a parsed text run is literal.
-        else if (token === "\\$" && matches("$", position)) position += 1;
+        else if (
+          ASCII_PUNCTUATION.test(character) &&
+          // Emphasis must match as delimiters, not as escaped literal text.
+          !"*_~".includes(character) &&
+          token === `\\${character}` &&
+          matches(character, position)
+        )
+          position += 1;
+        // L7 bridge: a backslash before any punctuation reads as that
+        // punctuation.
+        else if (
+          ASCII_PUNCTUATION.test(character) &&
+          token === character &&
+          matches(`\\${character}`, position)
+        )
+          position += 2;
         else if (character === "\n" && token.startsWith("\n")) {
           const indent = token.slice(1);
           if (matches(`\r\n${indent}`, position)) position += 2 + indent.length;
@@ -486,7 +601,7 @@ function mapStoredSourceRuns(
         if (!valid) break;
         textOffsets.push(position - start);
       }
-      if (!valid || !matches(suffix, position)) continue;
+      if (!valid || !matchesDelimiters(suffix, position)) continue; // L7 bridge
       position += suffix.length;
       if (!gapMatches(cursor, start, canonicalCursor, run.sourceFrom))
         return false;
@@ -496,6 +611,7 @@ function mapStoredSourceRuns(
       run.sourceFrom = start;
       run.sourceTo = position;
       run.textOffsets = textOffsets;
+      run.reopened = reopened; // L7 bridge
       found = true;
       break;
     }
@@ -595,7 +711,7 @@ export function suggestionFormattingSourceSlice(
   const appendStructuralGap = (gapFrom: number, gapTo: number) => {
     const gapParts = structuralGapParts(source, gapFrom, gapTo);
     if (!gapParts) return false;
-    parts.push(...gapParts);
+    pushAll(parts, gapParts);
     return true;
   };
   for (const run of mapped.runs) {
@@ -613,7 +729,7 @@ export function suggestionFormattingSourceSlice(
       for (let index = 0; index <= run.text.length; index += 1) {
         if (textBoundarySourceOffset(run, index) === offset) return index;
       }
-      return null;
+      return run.reopened?.get(offset - run.sourceFrom) ?? null; // L7 bridge
     };
     const start = textIndex(overlapFrom);
     const end = textIndex(overlapTo);
@@ -835,6 +951,13 @@ export function suggestionFormattingSourceRange(
             affinity: preferredAffinity,
           });
       }
+      // L7 bridge
+      const reopened = run.reopened?.get(offset - run.sourceFrom);
+      if (reopened !== undefined)
+        candidates.push({
+          offset: run.from + reopened,
+          affinity: preferredAffinity,
+        });
     }
     for (const gap of gaps) {
       if (offset < gap.sourceFrom || offset > gap.sourceTo) continue;