🌎 Fix dangling heading/blockquote/bold markers in translated docs (#61107)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: heiskr

src/languages/lib/correct-translation-content.ts

@@ -67,6 +67,17 @@ export function correctTranslatedContentStrings(
   content = content.replace(/^([ \t]*)\* ?\n[ \t]+/gm, '$1* ')
   content = content.replace(/^\|[ \t]*\n[ \t]+/gm, '| ')
 
+  // The same translator wrapping habit also strands heading markers
+  // (`#`/`##`/...), blockquote markers (`>`), and the opening `**` of a
+  // bold span on their own line, with the actual content pushed to the
+  // next line as deeply indented text. This breaks heading/blockquote/
+  // bold rendering and leaves Liquid tags and `[AUTOTITLE]` links
+  // unexpanded. Rejoin them. Fence- and frontmatter-aware so we don't
+  // disturb fenced markdown examples or YAML frontmatter.
+  // ~3k headings, ~1.6k blockquotes, ~3.5k bold-after-marker cases
+  // measured across all eight translated languages.
+  content = joinDanglingMarkers(content)
+
   // --- Per-language fixes (es, ja, pt, zh, ru, fr, ko, de) ---
 
   if (context.code === 'es') {
@@ -2042,3 +2053,113 @@ export function correctTranslatedContentStrings(
 
   return content
 }
+
+/**
+ * Rejoin marker lines that the translation pipeline split from their content.
+ *
+ * Translators sometimes leave a heading marker (`#`/`##`/...), blockquote
+ * marker (`>`), or the opening `**` of a bold span (immediately following a
+ * list/heading/blockquote/table marker) on its own line, with the rest of
+ * the content pushed to the next line as deeply indented text. This breaks
+ * rendering (empty headings, broken blockquotes, unrendered bold, unexpanded
+ * Liquid and `[AUTOTITLE]` links).
+ *
+ * Conservative thresholds:
+ * - Marker line has 0–3 leading spaces (CommonMark heading/blockquote rule).
+ * - Continuation line has 6+ leading spaces (avoids 4-space indented code).
+ * - Marker line contains *only* the marker (and optional trailing whitespace).
+ * - Skip fenced code blocks (``` and ~~~) and YAML frontmatter (`---`...`---`).
+ */
+function joinDanglingMarkers(content: string): string {
+  const lines = content.split('\n')
+  const out: string[] = []
+  let inFence = false
+  let fenceChar = ''
+  let fenceLen = 0
+  let inFrontmatter = lines[0] === '---'
+
+  // Marker-only line patterns (run only against non-fenced, non-frontmatter lines).
+  const headingOnly = /^([ \t]{0,3})(#{1,6})[ \t]*$/
+  const blockquoteOnly = /^([ \t]{0,3}>)[ \t]*$/
+  // Bold-open after a list/heading/blockquote/table marker (no other content).
+  const markerThenBoldOnly =
+    /^([ \t]{0,3}(?:[*+-]|\d+\.)[ \t]+|[ \t]{0,3}>[ \t]+|[ \t]{0,3}#{1,6}[ \t]+|\|[ \t]*)\*\*[ \t]*$/
+  // Continuation: 6+ leading spaces and at least one non-whitespace character.
+  const deepIndented = /^[ \t]{6,}(\S.*)$/
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    // YAML frontmatter close: `---` or `...` after the opening `---`.
+    if (inFrontmatter && i > 0 && (line === '---' || line === '...')) {
+      inFrontmatter = false
+      out.push(line)
+      continue
+    }
+
+    // While inside frontmatter, pass lines through verbatim. Crucially,
+    // do NOT run fence detection here — a frontmatter line starting with
+    // ``` or ~~~ (e.g. inside a multiline scalar) would otherwise toggle
+    // `inFence` and cause the rest of the document after frontmatter
+    // closes to be (mis-)treated as inside a fence.
+    if (inFrontmatter) {
+      out.push(line)
+      continue
+    }
+
+    // CommonMark fenced code block: 0–3 leading spaces, then 3+ ` or ~.
+    const fenceMatch = line.match(/^[ \t]{0,3}(`{3,}|~{3,})/)
+    if (fenceMatch) {
+      const marker = fenceMatch[1]
+      if (!inFence) {
+        inFence = true
+        fenceChar = marker[0]
+        fenceLen = marker.length
+      } else if (marker[0] === fenceChar && marker.length >= fenceLen) {
+        inFence = false
+        fenceChar = ''
+        fenceLen = 0
+      }
+      out.push(line)
+      continue
+    }
+
+    if (inFence) {
+      out.push(line)
+      continue
+    }
+
+    const next = i + 1 < lines.length ? lines[i + 1] : undefined
+    const nextDeep = next !== undefined ? next.match(deepIndented) : null
+    if (!nextDeep) {
+      out.push(line)
+      continue
+    }
+    const nextContent = nextDeep[1]
+
+    const heading = line.match(headingOnly)
+    if (heading) {
+      out.push(`${heading[1]}${heading[2]} ${nextContent}`)
+      i++
+      continue
+    }
+
+    const bq = line.match(blockquoteOnly)
+    if (bq) {
+      out.push(`${bq[1]} ${nextContent}`)
+      i++
+      continue
+    }
+
+    const boldOpen = line.match(markerThenBoldOnly)
+    if (boldOpen) {
+      out.push(`${boldOpen[1]}**${nextContent}`)
+      i++
+      continue
+    }
+
+    out.push(line)
+  }
+
+  return out.join('\n')
+}

src/languages/tests/correct-translation-content.ts

@@ -1597,6 +1597,132 @@ describe('correctTranslatedContentStrings', () => {
       // Valid table rows are not modified
       expect(fix('| a | b |\n| c | d |', 'es')).toBe('| a | b |\n| c | d |')
     })
+
+    test('rejoins dangling heading markers (all languages)', () => {
+      const broken = '### \n              {% data variables.product.github %} の使用'
+      const expected = '### {% data variables.product.github %} の使用'
+      for (const lang of ['ja', 'de', 'es', 'fr', 'ko', 'pt', 'ru', 'zh']) {
+        expect(fix(broken, lang)).toBe(expected)
+      }
+      // All heading levels
+      expect(fix('# \n              Title', 'ja')).toBe('# Title')
+      expect(fix('###### \n              Title', 'ja')).toBe('###### Title')
+      // 0–3 leading spaces are accepted
+      expect(fix('   ### \n              Title', 'ja')).toBe('   ### Title')
+      // Valid headings are not modified
+      expect(fix('### Already correct', 'ja')).toBe('### Already correct')
+      // 4-space indented heading-like text is not collapsed (looks like code)
+      expect(fix('    ###\n              code', 'ja')).toBe('    ###\n              code')
+      // Shallow next-line indent (<6) is not collapsed
+      expect(fix('### \n  Title', 'ja')).toBe('### \n  Title')
+    })
+
+    test('rejoins dangling blockquote markers (all languages)', () => {
+      const broken = '> \n              {% data variables.product.github %} は preview 中です。'
+      const expected = '> {% data variables.product.github %} は preview 中です。'
+      for (const lang of ['ja', 'de', 'es', 'fr', 'ko', 'pt', 'ru', 'zh']) {
+        expect(fix(broken, lang)).toBe(expected)
+      }
+      // 0–3 leading spaces are accepted
+      expect(fix('  > \n              Quote', 'ja')).toBe('  > Quote')
+      // Valid blockquotes are not modified
+      expect(fix('> Already correct', 'ja')).toBe('> Already correct')
+      expect(fix('>\n> Continued blockquote', 'ja')).toBe('>\n> Continued blockquote')
+    })
+
+    test('rejoins dangling bold-open after a marker (all languages)', () => {
+      const broken =
+        '* **\n              {% data variables.product.prodname_copilot_short %}へのアクセス**。 More text'
+      const expected =
+        '* **{% data variables.product.prodname_copilot_short %}へのアクセス**。 More text'
+      for (const lang of ['ja', 'de', 'es', 'fr', 'ko', 'pt', 'ru', 'zh']) {
+        expect(fix(broken, lang)).toBe(expected)
+      }
+      // Numbered list marker
+      expect(fix('1. **\n              Important**: text', 'ja')).toBe('1. **Important**: text')
+      // Heading marker
+      expect(fix('### **\n              Bold heading**', 'ja')).toBe('### **Bold heading**')
+      // Blockquote marker
+      expect(fix('> **\n              Quoted bold**', 'ja')).toBe('> **Quoted bold**')
+      // Table cell
+      expect(fix('| **\n              Cell bold** | x', 'ja')).toBe('| **Cell bold** | x')
+      // Bare `**` (no preceding marker) is not collapsed — could be a closing
+      // bold marker followed by legitimate indented continuation.
+      expect(fix('**\n              text', 'ja')).toBe('**\n              text')
+    })
+
+    test('does not modify content inside fenced code blocks', () => {
+      // Markdown example inside ```md fence should be preserved verbatim
+      const fenced = '```md\n### \n              Heading example\n```'
+      expect(fix(fenced, 'ja')).toBe(fenced)
+      // Tilde fences are also respected
+      const tilde = '~~~md\n> \n              Quote example\n~~~'
+      expect(fix(tilde, 'ja')).toBe(tilde)
+      // Bold-open inside code fence
+      const boldFenced = '```md\n* **\n              bold example**\n```'
+      expect(fix(boldFenced, 'ja')).toBe(boldFenced)
+    })
+
+    test('does not modify YAML frontmatter', () => {
+      // Multiline YAML scalars and indented values must not be joined
+      const fm = `---
+title: Example
+intro: >
+              Multiline
+              continued
+versions:
+  fpt: '*'
+---
+
+### 
+              Real heading after frontmatter`
+      const expected = `---
+title: Example
+intro: >
+              Multiline
+              continued
+versions:
+  fpt: '*'
+---
+
+### Real heading after frontmatter`
+      expect(fix(fm, 'ja')).toBe(expected)
+    })
+
+    test('frontmatter containing fence-like characters does not break body fence tracking', () => {
+      // A multiline scalar in frontmatter that includes ``` (or ~~~) must
+      // NOT toggle the body's fence-tracking state. After frontmatter
+      // closes, dangling markers in the body should still be rejoined.
+      const fm = `---
+title: Example
+intro: |
+  \`\`\`
+  fence-like text inside frontmatter
+  \`\`\`
+---
+
+### 
+              Real heading after frontmatter`
+      const expected = `---
+title: Example
+intro: |
+  \`\`\`
+  fence-like text inside frontmatter
+  \`\`\`
+---
+
+### Real heading after frontmatter`
+      expect(fix(fm, 'ja')).toBe(expected)
+    })
+
+    test('does not collapse nested-list indented code blocks', () => {
+      // A list item followed by blank line + 6-space-indented "code" should
+      // be left alone because the marker line itself is empty (not a
+      // bare `>`/`#`/`* **` form), and the previous content line is not
+      // a heading/blockquote/bold-open marker.
+      const nested = '1. Run this command:\n\n      gh auth login'
+      expect(fix(nested, 'ja')).toBe(nested)
+    })
   })
 
   // ─── EDGE CASES ────────────────────────────────────────────────────