@agent-native/core-corpus 0.216.0 → 0.218.0

package/corpus/templates/content/shared/database-item-layout.ts

@@ -1,6 +1,7 @@
 import type {
   ContentDatabaseItemLayout,
   ContentDatabaseItemLeadingKind,
+  ContentDatabaseItemLine2Source,
   ContentDatabaseItemTitleWeight,
 } from "./api";
 import {
@@ -25,6 +26,11 @@ export const CONTENT_DATABASE_ITEM_TITLE_WEIGHTS = [
 
 export const CONTENT_DATABASE_ITEM_LINE2_LINES = [1, 2, 3] as const;
 
+export const CONTENT_DATABASE_ITEM_LINE2_SOURCES = [
+  "property",
+  "page",
+] as const satisfies readonly ContentDatabaseItemLine2Source[];
+
 /** Most properties line 3 or the trailing slot may show. */
 export const MAX_ITEM_LAYOUT_META_PROPERTIES = 6;
 
@@ -92,7 +98,7 @@ export function itemLayoutLeadingCandidates<
   );
 }
 
-/** Text-like properties line 2 can show. The page body arrives separately. */
+/** Text-like properties line 2 can show. Page text is its own choice. */
 export function itemLayoutLine2Candidates<
   P extends ContentDatabaseItemLayoutPropertyLike,
 >(properties: readonly P[]): P[] {
@@ -135,6 +141,14 @@ function propertyIdList(value: unknown) {
   return ids;
 }
 
+/** Line 2 with a new property ID, unless it shows page text. */
+function withLine2PropertyId(
+  line2: ContentDatabaseItemLayout["line2"],
+  propertyId: string | null,
+): ContentDatabaseItemLayout["line2"] {
+  return line2.source === "page" ? line2 : { propertyId, lines: line2.lines };
+}
+
 function record(value: unknown): Record<string, unknown> {
   return value && typeof value === "object" && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -174,7 +188,10 @@ export function normalizeContentDatabaseItemLayout(
     )
       ? (raw.titleWeight as ContentDatabaseItemTitleWeight)
       : "medium",
-    line2: { propertyId: propertyIdOrNull(line2.propertyId), lines },
+    line2:
+      line2.source === "page"
+        ? { source: "page", propertyId: null, lines }
+        : { propertyId: propertyIdOrNull(line2.propertyId), lines },
     line3: propertyIdList(raw.line3),
     trailing: propertyIdList(raw.trailing),
   };
@@ -214,7 +231,8 @@ export function withSavedContentDatabaseItemLayout<
 export interface ResolvedContentDatabaseItemLayout<P> {
   leading: { kind: ContentDatabaseItemLeadingKind; property: P | null };
   titleWeight: ContentDatabaseItemTitleWeight;
-  line2: { property: P | null; lines: 1 | 2 | 3 };
+  /** `pageText` rows show the first lines of their page instead of a property. */
+  line2: { property: P | null; pageText: boolean; lines: 1 | 2 | 3 };
   line3: P[];
   trailing: P[];
 }
@@ -248,9 +266,11 @@ export function resolveContentDatabaseItemLayout<
       : (leadingCandidates[0] ?? null)
     : null;
   const line2Candidates = new Set(itemLayoutLine2Candidates(properties));
-  const line2Property = layout.line2.propertyId
-    ? (byId.get(layout.line2.propertyId) ?? null)
-    : null;
+  const pageText = layout.line2.source === "page";
+  const line2Property =
+    !pageText && layout.line2.propertyId
+      ? (byId.get(layout.line2.propertyId) ?? null)
+      : null;
   const meta = (ids: readonly string[]) =>
     ids.flatMap((id) => {
       const property = byId.get(id);
@@ -272,6 +292,7 @@ export function resolveContentDatabaseItemLayout<
         line2Property && line2Candidates.has(line2Property)
           ? line2Property
           : null,
+      pageText,
       lines: layout.line2.lines,
     },
     line3: meta(layout.line3),
@@ -353,10 +374,10 @@ export function pruneContentDatabaseItemLayout(
       propertyId: resolved.leading.property ? layout.leading.propertyId : null,
     },
     titleWeight: layout.titleWeight,
-    line2: {
-      propertyId: resolved.line2.property?.definition.id ?? null,
-      lines: layout.line2.lines,
-    },
+    line2: withLine2PropertyId(
+      layout.line2,
+      resolved.line2.property?.definition.id ?? null,
+    ),
     line3: ids(resolved.line3),
     trailing: ids(resolved.trailing),
   };
@@ -379,10 +400,7 @@ export function dropDeletedContentDatabaseItemLayoutReferences(
         ? { kind: "page_icon", propertyId: null }
         : layout.leading,
     titleWeight: layout.titleWeight,
-    line2: {
-      propertyId: kept(layout.line2.propertyId),
-      lines: layout.line2.lines,
-    },
+    line2: withLine2PropertyId(layout.line2, kept(layout.line2.propertyId)),
     line3: layout.line3.filter((id) => exists.has(id)),
     trailing: layout.trailing.filter((id) => exists.has(id)),
   };
@@ -444,13 +462,12 @@ export function savableContentDatabaseItemLayout(
     {
       leading: savedLeading ? layout.leading : showable.leading,
       titleWeight: layout.titleWeight,
-      line2: {
-        propertyId:
-          saved?.line2.propertyId === layout.line2.propertyId
-            ? layout.line2.propertyId
-            : showable.line2.propertyId,
-        lines: layout.line2.lines,
-      },
+      line2: withLine2PropertyId(
+        layout.line2,
+        saved?.line2.propertyId === layout.line2.propertyId
+          ? layout.line2.propertyId
+          : showable.line2.propertyId,
+      ),
       line3: meta("line3"),
       trailing: meta("trailing"),
     },
@@ -462,7 +479,7 @@ export function savableContentDatabaseItemLayout(
  * The layout someone starts editing from on a view with no saved layout. It
  * matches the default rows: page icon, title, and the first four properties.
  * Line 2 is the only slot that shows a Blocks field, so one of those goes
- * there. The page body itself has no slot yet.
+ * there.
  */
 export function startingContentDatabaseItemLayout(
   visibleProperties: readonly ContentDatabaseItemLayoutPropertyLike[],
@@ -482,6 +499,21 @@ export function startingContentDatabaseItemLayout(
   };
 }
 
+/**
+ * Whether any List view shows page text in line 2, so list reads carry each
+ * row's excerpt. Other collections never read page bodies for their rows.
+ */
+export function contentDatabaseViewsShowPageText(
+  views: readonly {
+    type: string;
+    itemLayout?: ContentDatabaseItemLayout | null;
+  }[],
+): boolean {
+  return views.some(
+    (view) => view.type === "list" && view.itemLayout?.line2.source === "page",
+  );
+}
+
 export interface ContentDatabaseItemLayoutPreset {
   id: ContentDatabaseItemLayoutPresetId;
   /** Null for Default, which keeps the view's default rows. */

package/corpus/templates/content/shared/document-intent-merge.ts

@@ -518,6 +518,18 @@ function mergePlainParagraph(
   };
 }
 
+/** The blocks `after` changed from `before`; none when the structure changed. */
+export function changedBlocksBetween(before: string, after: string): number[] {
+  if (before === after) return [];
+  const base = nfmToDoc(before).content;
+  const candidate = nfmToDoc(after).content;
+  return base.length === candidate.length
+    ? base.flatMap((block, index) =>
+        stableBlock(block) !== stableBlock(candidate[index]) ? [index] : [],
+      )
+    : [];
+}
+
 export function mergeDocumentBodyIntents(args: {
   authoredBaseContent: string;
   authoredCandidateContent: string;
@@ -530,18 +542,13 @@ export function mergeDocumentBodyIntents(args: {
     args.currentRevision === args.incoming.authoredBaseRevision &&
     args.currentContent === args.authoredBaseContent
   ) {
-    const base = nfmToDoc(args.authoredBaseContent).content;
-    const candidate = nfmToDoc(args.authoredCandidateContent).content;
-    const changedBlockIndexes =
-      base.length === candidate.length
-        ? base.flatMap((block, index) =>
-            stableBlock(block) !== stableBlock(candidate[index]) ? [index] : [],
-          )
-        : [];
     return {
       status: "resolved",
       content: args.authoredCandidateContent,
-      changedBlockIndexes,
+      changedBlockIndexes: changedBlocksBetween(
+        args.authoredBaseContent,
+        args.authoredCandidateContent,
+      ),
       displaced: false,
     };
   }

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

@@ -483,6 +483,9 @@ function diffTokens(text: string): string[] {
 // is no longer than either, as diff-match-patch's semantic cleanup does.
 // Equalities between replacements stay, so separate word swaps remain
 // separately reviewable, and a line never folds, so blocks stay separate.
+// The exception is a line the merged run begins or ends with: that is one
+// insertion (text plus a new paragraph) Myers aligned across the existing
+// separator, and it would otherwise split whenever another hunk exists.
 type ChangeRun = {
   deleted: string;
   inserted: string;
@@ -518,12 +521,17 @@ function foldShortEqualities(parts: DiffPart[]): DiffPart[] {
     const right = segments[index + 1];
     if (typeof equality !== "string" || typeof left !== "object") continue;
     if (typeof right !== "object") continue;
+    const insertions = left.ownDeleted === 0 && right.ownDeleted === 0;
     const oneSided =
-      (left.ownDeleted === 0 && right.ownDeleted === 0) ||
-      (left.ownInserted === 0 && right.ownInserted === 0);
+      insertions || (left.ownInserted === 0 && right.ownInserted === 0);
+    const merged = insertions
+      ? left.inserted + equality + right.inserted
+      : left.deleted + equality + right.deleted;
     if (
       !oneSided ||
-      equality.includes("\n") ||
+      (equality.includes("\n") &&
+        !merged.startsWith(equality) &&
+        !merged.endsWith(equality)) ||
       equality.length > Math.max(left.ownDeleted, left.ownInserted) ||
       equality.length > Math.max(right.ownDeleted, right.ownInserted)
     )
@@ -814,16 +822,24 @@ function wholeWordReplacements(
     const removed = operation.before.changedText;
     const inserted = operation.after.changedText;
     const lexicalChange = /[\p{L}\p{M}\p{N}]/u.test(removed + inserted);
+    // An edge that is a line break, as when a whole paragraph is deleted,
+    // sits beside the neighboring block's word without splitting it.
+    const lineEdge = (edge: (text: string) => boolean) =>
+      edge(removed) && (!inserted || edge(inserted));
+    const widensBefore =
+      isWordBefore(before, from) && !lineEdge((text) => text.startsWith("\n"));
+    const widensAfter =
+      isWordAt(before, to) && !lineEdge((text) => text.endsWith("\n"));
     let group = { from, to, members: [operation] };
     if (
       lexicalChange &&
       !/<br\/?\s*>/u.test(removed + inserted) &&
       (removed || !/\s/u.test(inserted)) &&
-      (isWordBefore(before, from) || isWordAt(before, to))
+      (widensBefore || widensAfter)
     ) {
-      while (isWordBefore(before, group.from))
+      while (widensBefore && isWordBefore(before, group.from))
         group.from -= characterBefore(before, group.from).length;
-      while (isWordAt(before, group.to))
+      while (widensAfter && isWordAt(before, group.to))
         group.to += characterAt(before, group.to).length;
     }
     // Two edits inside one word are one review decision.
@@ -1022,6 +1038,7 @@ export function markdownSuggestionOperationsForReplacements(input: {
     const [{ from, to }] = replacements;
     if (
       operations.length > 1 &&
+      !before.slice(from, to).includes("\n") &&
       operations.every(
         (operation) =>
           operation.anchor.from >= from && operation.anchor.to <= to,