fix(markdown): close a fence only on a bare delimiter run

A closing fence carries nothing but its delimiter run; a line that merely
starts with one is content. The guard matched the prefix alone, so an interior
line like ` ````example ` inside a same-length fence ended the block, and every
cleanup below then processed the author's remaining code as prose — dropping
the backslashes from their `a\_b`.

Both fence walks in this file shared that flaw, so both now go through one
`closesFence`, which requires the run to be followed by nothing but whitespace.
Strictly more conservative: a fence stays open longer, so more content is left
verbatim.

Scope, stated plainly: the serializer always opens a block with one more
delimiter than the longest run inside it, so its own output cannot reach this
shape today, and `postProcessSerializedMarkdown` only ever sees serializer
output. This is a correctness fix that removes an unstated coupling to that
choice, not a live corruption path. The tests therefore exercise
`postProcessSerializedMarkdown` directly — a round-trip test of the same input
would pass either way, which is exactly the vacuous check worth avoiding.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/markdown-fidelity.ts

@@ -55,12 +55,12 @@ function unescapeIntrawordUnderscores(markdown: string): string {
   let fence: string | null = null
 
   for (let i = 0; i < lines.length; i++) {
-    const delimiter = lines[i].match(FENCE_DELIMITER)?.[1]
-
     if (fence) {
-      if (delimiter && delimiter[0] === fence[0] && delimiter.length >= fence.length) fence = null
+      if (closesFence(lines[i], fence)) fence = null
       continue
     }
+
+    const delimiter = lines[i].match(FENCE_DELIMITER)?.[1]
     if (delimiter) {
       fence = delimiter
       continue
@@ -167,6 +167,22 @@ export function normalizeLinkHref(href: string): string {
 const EMPTY_LIST_ITEM_LINE = /^([ \t]*)(?:[-*+]|\d+[.)])[ \t]*$/
 /** A fenced code-block delimiter (``` or ~~~), used to leave code interiors untouched. */
 const FENCE_DELIMITER = /^[ \t]*(`{3,}|~{3,})/
+/**
+ * A line carrying nothing but a delimiter run — the only thing that CLOSES a fence.
+ *
+ * An OPENING fence may be followed by an info string (` ```python `), so opening is matched with
+ * {@link FENCE_DELIMITER}; a closing one may be followed only by whitespace. Treating any
+ * delimiter-prefixed line as a close ends the block at an interior line like ` ```example ` inside
+ * a `````` ```` ``````-fence, and every cleanup below then processes the rest of the author's code
+ * as prose.
+ */
+const CLOSING_FENCE = /^[ \t]*(`{3,}|~{3,})[ \t]*$/
+
+/** Whether `line` closes a fence opened with `fence`: same character, and at least as long. */
+function closesFence(line: string, fence: string): boolean {
+  const delimiter = line.match(CLOSING_FENCE)?.[1]
+  return Boolean(delimiter && delimiter[0] === fence[0] && delimiter.length >= fence.length)
+}
 /** Leading indentation of a line, used to detect whether an empty list item has indented children. */
 const LEADING_INDENT = /^[ \t]*/
 
@@ -192,12 +208,12 @@ function stripEmptyListItemLines(markdown: string): string {
   let fence: string | null = null
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i]
-    const delimiter = line.match(FENCE_DELIMITER)?.[1]
     if (fence) {
       kept.push(line)
-      if (delimiter && delimiter[0] === fence[0] && delimiter.length >= fence.length) fence = null
+      if (closesFence(line, fence)) fence = null
       continue
     }
+    const delimiter = line.match(FENCE_DELIMITER)?.[1]
     if (delimiter) {
       fence = delimiter
       kept.push(line)

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/round-trip.test.ts

@@ -98,6 +98,32 @@ describe('markdown-fidelity utils', () => {
     expect(postProcessSerializedMarkdown('> \\[!NOTE\\]\n> hi')).toBe('> [!NOTE]\n> hi')
   })
 
+  /*
+   * A closing fence carries nothing but its delimiter run; a line that merely STARTS with one is
+   * content. Matching the prefix alone ends the block at an interior line like ` ````example `,
+   * after which the rest of the author's code is cleaned up as prose and its backslashes vanish.
+   *
+   * Exercised directly rather than through `roundTrip` on purpose: the serializer always opens a
+   * block with one more delimiter than the longest run inside it, so its own output cannot reach
+   * this shape and a round-trip test of it would pass either way. Relying on that choice staying
+   * true is an unstated coupling — this keeps the guard honest on any input.
+   */
+  it('does not close a fence on a delimiter-prefixed content line', () => {
+    const input = '````\nx = a\\_b\n````example\ny = c\\_d\n````\n'
+    expect(postProcessSerializedMarkdown(input)).toBe(input)
+  })
+
+  it('does not close a tilde fence on a delimiter-prefixed content line', () => {
+    const input = '~~~~\n~~~~note\ny = c\\_d\n~~~~\n'
+    expect(postProcessSerializedMarkdown(input)).toBe(input)
+  })
+
+  it('still closes a fence on a bare delimiter run with trailing spaces', () => {
+    expect(postProcessSerializedMarkdown('````\nx = a\\_b\n````  \ny = c\\_d\n')).toBe(
+      '````\nx = a\\_b\n````  \ny = c_d\n'
+    )
+  })
+
   it('restores escaped callout markers in nested blockquotes', () => {
     expect(postProcessSerializedMarkdown('> > \\[!WARNING\\]\n> > hi')).toBe(
       '> > [!WARNING]\n> > hi'