fix(rich-markdown-editor): escape leading block markers in paragraph serialization

A paragraph beginning with #, -, +, 1., 1), or a bare --- serialized unescaped, so it
silently re-parsed into a heading / list / thematic break on the next load (reachable
via type-a-marker then undo). The upstream serializer escapes inline delimiters (* _ `
[ ] ~, so * bullets and > quotes already round-trip) but not these block-starting
markers. BlockSafeParagraph wraps the paragraph renderer with a leading-marker guard;
escaping is idempotent (parsing consumes the backslash) and never over-escapes non-markers
like #hashtag or -5.

Author: waleedlatif1

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

@@ -1,6 +1,7 @@
 import type { Extensions, JSONContent, MarkdownRendererHelpers, Node } from '@tiptap/core'
 import { Code } from '@tiptap/extension-code'
 import { TaskItem, TaskList } from '@tiptap/extension-list'
+import { Paragraph } from '@tiptap/extension-paragraph'
 import {
   renderTableToMarkdown,
   Table,
@@ -57,6 +58,32 @@ const PipeSafeTable = Table.extend({
       .replace(/\n+$/, ''),
 })
 
+/**
+ * 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.
+ */
+function escapeLeadingBlockMarker(text: string): string {
+  if (/^(#{1,6}([ \t]|$)|[-+][ \t]|-(?:[ \t]*-){2,}[ \t]*$)/.test(text)) {
+    return `\\${text}`
+  }
+  const ordered = /^(\d{1,9})([.)][ \t])/.exec(text)
+  return ordered ? `${ordered[1]}\\${text.slice(ordered[1].length)}` : text
+}
+
+/**
+ * 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.
+ */
+const BlockSafeParagraph = Paragraph.extend({
+  renderMarkdown: (node: JSONContent, h: MarkdownRendererHelpers) =>
+    escapeLeadingBlockMarker(h.renderChildren(node.content ?? [])),
+})
+
 /**
  * Node-view variants the live editor injects in place of the headless defaults — the code-block
  * language picker, the resizable image, and the mention chip. The mention chip pulls the block registry
@@ -92,7 +119,9 @@ export function createMarkdownContentExtensions(nodeViews: ContentNodeViews = {}
       underline: false,
       codeBlock: false,
       code: false,
+      paragraph: false,
     }),
+    BlockSafeParagraph,
     InlineCode,
     codeBlock,
     (nodeViews.image ?? MarkdownImage).configure({ allowBase64: true }),

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

@@ -330,3 +330,53 @@ describe('link href sanitization — dangerous schemes from file content are neu
     expect(hrefs).toContain('mailto:x@y.com')
   })
 })
+
+describe('paragraph leading block-marker escaping', () => {
+  /** Serialize a doc whose first paragraph literally starts with `text`, then re-parse its first node. */
+  function serializeParagraph(text: string): {
+    md: string
+    reparsedType: string
+    idempotent: boolean
+  } {
+    editor = new Editor({ extensions: createMarkdownContentExtensions() })
+    editor.commands.setContent(
+      { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text }] }] },
+      { contentType: 'json' }
+    )
+    const md = postProcessSerializedMarkdown(editor.getMarkdown())
+    editor.commands.setContent(md, { contentType: 'markdown' })
+    const reparsedType = editor.getJSON().content?.[0]?.type ?? ''
+    const idempotent = postProcessSerializedMarkdown(editor.getMarkdown()) === md
+    editor.destroy()
+    editor = null
+    return { md, reparsedType, idempotent }
+  }
+
+  it.each([
+    ['# note', '\\# note'],
+    ['###### note', '\\###### note'],
+    ['#', '\\#'],
+    ['- item', '\\- item'],
+    ['+ item', '\\+ item'],
+    ['1. step', '1\\. step'],
+    ['1) step', '1\\) step'],
+    ['---', '\\---'],
+    ['- - -', '\\- - -'],
+  ])('escapes a paragraph starting with %j so it stays a paragraph', (text, expectedMd) => {
+    const { md, reparsedType, idempotent } = serializeParagraph(text)
+    expect(md.trim()).toBe(expectedMd)
+    expect(reparsedType).toBe('paragraph')
+    expect(idempotent).toBe(true)
+  })
+
+  it.each([
+    ['#hashtag'], // no space after # → not a heading
+    ['-5 degrees'], // no space after - → not a bullet
+    ['plain text'],
+  ])('does not over-escape %j', (text) => {
+    const { md, reparsedType, idempotent } = serializeParagraph(text)
+    expect(md.trim()).toBe(text)
+    expect(reparsedType).toBe('paragraph')
+    expect(idempotent).toBe(true)
+  })
+})