fix(rich-markdown-editor): strip leading paragraph indent; keep empty paragraphs  -free

A paragraph beginning with a 4-space/tab indent re-parsed as an indented code block on the
next load. Leading whitespace never renders in a paragraph (CommonMark strips up to three
leading spaces; four or more become code), so BlockSafeParagraph now strips it — lossless
and idempotent. Composes with the existing leading-marker escaping (e.g. '   # x' → '\# x').

Also locks in that consecutive empty paragraphs serialize via blank lines rather than the
upstream ' ' marker: replacing StarterKit's Paragraph already dropped the   path,
and the round-trip preserves the empty-paragraph count without tripping the read-only
safety gate (which flags   as a stable-loss pattern). Added tests for both.

Author: waleedlatif1

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

@@ -59,29 +59,36 @@ const PipeSafeTable = Table.extend({
 })
 
 /**
- * Backslash-escapes a leading block marker so paragraph text like `# note`, `- item`, `1. step`, or a
- * bare `---` serializes as a paragraph rather than re-parsing into a heading / list / thematic break on
- * the next load. The upstream serializer escapes inline delimiters (`* _ \` [ ] ~`, so `*` bullets and
- * `>` quotes already round-trip) but not these block-starting markers. Escaping is idempotent: parsing
- * consumes the backslash, so the stored ProseMirror text never carries it and re-serialization is stable.
+ * Guards a paragraph's serialized text so its leading characters don't re-parse it into a different
+ * block on the next load:
+ *
+ * - **Leading whitespace** is stripped. It never renders in a paragraph (CommonMark strips up to three
+ *   leading spaces, and four or more would re-parse the paragraph as an indented code block), so
+ *   removing it is lossless and makes the round-trip idempotent.
+ * - **A leading block marker** (`#`, `-`, `+`, `1.`, `1)`, or a bare `---`) is backslash-escaped so the
+ *   paragraph doesn't become a heading / list / thematic break. The upstream serializer escapes inline
+ *   delimiters (`* _ \` [ ] ~`, so `*` bullets and `>` quotes already round-trip) but not these
+ *   block-starting markers. Escaping is idempotent: parsing consumes the backslash, so the stored
+ *   ProseMirror text never carries it and re-serialization is stable.
  */
-function escapeLeadingBlockMarker(text: string): string {
-  if (/^(#{1,6}([ \t]|$)|[-+][ \t]|-(?:[ \t]*-){2,}[ \t]*$)/.test(text)) {
-    return `\\${text}`
+function guardParagraphLeading(text: string): string {
+  const stripped = text.replace(/^[ \t]+/, '')
+  if (/^(#{1,6}([ \t]|$)|[-+][ \t]|-(?:[ \t]*-){2,}[ \t]*$)/.test(stripped)) {
+    return `\\${stripped}`
   }
-  const ordered = /^(\d{1,9})([.)][ \t])/.exec(text)
-  return ordered ? `${ordered[1]}\\${text.slice(ordered[1].length)}` : text
+  const ordered = /^(\d{1,9})([.)][ \t])/.exec(stripped)
+  return ordered ? `${ordered[1]}\\${stripped.slice(ordered[1].length)}` : stripped
 }
 
 /**
- * Paragraph that escapes a leading block marker on serialize (see {@link escapeLeadingBlockMarker}) —
- * otherwise a paragraph beginning with `#`/`-`/`+`/`1.`/`1)`/`---` silently becomes that block on the
- * next load. Block separators are owned by the parent joiner, so a paragraph renders as just its inline
- * children; this override wraps that with the leading-marker guard.
+ * Paragraph that guards its leading characters on serialize (see {@link guardParagraphLeading}) —
+ * otherwise a paragraph beginning with a block marker or an indent silently becomes a heading / list /
+ * thematic break / code block on the next load. Block separators are owned by the parent joiner, so a
+ * paragraph renders as just its inline children; this override wraps that with the leading guard.
  */
 const BlockSafeParagraph = Paragraph.extend({
   renderMarkdown: (node: JSONContent, h: MarkdownRendererHelpers) =>
-    escapeLeadingBlockMarker(h.renderChildren(node.content ?? [])),
+    guardParagraphLeading(h.renderChildren(node.content ?? [])),
 })
 
 /**

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

@@ -331,7 +331,7 @@ describe('link href sanitization — dangerous schemes from file content are neu
   })
 })
 
-describe('paragraph leading block-marker escaping', () => {
+describe('paragraph leading guard (marker escaping + indent stripping)', () => {
   /** Serialize a doc whose first paragraph literally starts with `text`, then re-parse its first node. */
   function serializeParagraph(text: string): {
     md: string
@@ -379,4 +379,58 @@ describe('paragraph leading block-marker escaping', () => {
     expect(reparsedType).toBe('paragraph')
     expect(idempotent).toBe(true)
   })
+
+  it.each([
+    ['    four spaces', 'four spaces'],
+    ['\ttab indent', 'tab indent'],
+    ['        eight spaces', 'eight spaces'],
+    ['   # indented marker', '\\# indented marker'],
+  ])(
+    'strips leading indent so %j stays a paragraph instead of an indented code block',
+    (text, expectedMd) => {
+      const { md, reparsedType, idempotent } = serializeParagraph(text)
+      expect(md.trim()).toBe(expectedMd)
+      expect(reparsedType).toBe('paragraph')
+      expect(idempotent).toBe(true)
+    }
+  )
+})
+
+describe('consecutive empty paragraphs', () => {
+  /** Doc with `a`, then `count` empty paragraphs, then `b`; serialized and round-tripped. */
+  function serializeEmpties(count: number) {
+    editor = new Editor({ extensions: createMarkdownContentExtensions() })
+    const emptyParas = Array.from({ length: count }, () => ({ type: 'paragraph', content: [] }))
+    editor.commands.setContent(
+      {
+        type: 'doc',
+        content: [
+          { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
+          ...emptyParas,
+          { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
+        ],
+      },
+      { contentType: 'json' }
+    )
+    const md = postProcessSerializedMarkdown(editor.getMarkdown())
+    editor.commands.setContent(md, { contentType: 'markdown' })
+    const emptyCount = (editor.getJSON().content ?? []).filter(
+      (n) => n.type === 'paragraph' && !n.content?.length
+    ).length
+    const idempotent = postProcessSerializedMarkdown(editor.getMarkdown()) === md
+    editor.destroy()
+    editor = null
+    return { md, emptyCount, idempotent }
+  }
+
+  it.each([[1], [2], [3], [4]])(
+    'preserves %i empty paragraph(s) via blank lines (no  , idempotent, no read-only trigger)',
+    (count) => {
+      const { md, emptyCount, idempotent } = serializeEmpties(count)
+      expect(md).not.toContain(' ')
+      expect(md).not.toContain(String.fromCharCode(0x00a0))
+      expect(emptyCount).toBe(count)
+      expect(idempotent).toBe(true)
+    }
+  )
 })