fix(search): match a Note body as it renders, instead of rewriting the file

Replaces the serializer change with one that writes nothing.

The editor backslash-escapes every markdown-significant character in prose, so a
Note the reader sees as `{{TE_SERET}}` is stored as `{{TE\_SERET}}` and search —
which matches the stored value — could not find it. The previous approach undid
that escape in `postProcessSerializedMarkdown`, which meant re-deriving markdown
structure from the serialized string with regexes so it knew what was code. That
is a losing game: three review rounds, each finding another construct it did not
model (longer fences, then delimiter-prefixed lines, then quoted fences), and
each miss REWROTE somebody's code. `markdown-fidelity.ts` is back to staging,
byte for byte.

The escape is now undone on the matching side only. A field declares
`searchTextFormat: 'markdown'` (the Note body is the only one), and the indexer
matches it against `projectEscapedMarkdownForSearch(value)` — a total,
structure-free function that returns the rendered text plus an index back into
the source. Ranges stay in source coordinates, so replace still rewrites the
whole `\_` and never strands a backslash.

The asymmetry is the whole point: a matcher that de-escapes something a fence
would have kept literal changes only which text highlights, and no caller writes
it back. A rewriter making the identical mistake corrupts the file. So there is
nothing here that needs to know about fences at all.

Two consequences worth having: existing notes are searchable immediately rather
than after their next edit, and no stored byte changes, so no document the
editor has ever written can be affected.

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

@@ -18,63 +18,6 @@ const CODE_OR_PLAIN_LINK_REGEX =
   /(```[\s\S]*?```|~~~[\s\S]*?~~~|`[^`\n]+`)|\[([^\]]+)]\(([^)\s<>]+)\)/g
 const HTTP_URL_REGEX = /^https?:\/\/\S+$/i
 
-/**
- * Alternates an inline code span with a single underscore that has a letter or digit on both sides.
- *
- * CommonMark's intraword rule means such an underscore can neither open nor close emphasis, so the
- * serializer's backslash before it carries no meaning \u2014 it just writes `SB\_ACTION\_ROUTER\_SECRET`
- * into the document. That is ugly in the file, and it silently breaks workflow search, which matches
- * against the stored markdown rather than the rendered text: searching `SB_ACTION` finds nothing in
- * a note whose stored form has a backslash the reader never sees.
- *
- * Code is excluded because the serializer emits it verbatim: a `\_` inside a span is the author's own
- * backslash, not an escape this may drop. The span branch matches a backtick RUN and requires a run of
- * the same length to close it, per CommonMark \u2014 a fixed single-backtick pattern would read ``` ``a`b`` ```
- * as `` `a` `` plus loose text and rewrite the interior. Fenced blocks are handled a line at a time by
- * {@link unescapeIntrawordUnderscores}, which is the only way to honour a fence of any length.
- *
- * The flanking character is a capture group rather than a lookbehind: lookbehind only landed in
- * Safari 16.4, and an unsupported one throws when the pattern is constructed \u2014 taking the whole editor
- * module with it. The group is consumed and put back, and the lookahead is not, so runs like `A\_B\_C`
- * still match on every pair.
- */
-const CODE_SPAN_OR_INTRAWORD_ESCAPED_UNDERSCORE =
-  /(`+)((?:[^`]|(?!\1)`)*?)\1(?!`)|([\p{L}\p{N}])\\_(?=[\p{L}\p{N}])/gu
-
-/**
- * Drops the meaningless backslash before an intraword underscore, outside code.
- *
- * Fenced blocks are skipped a line at a time, tracking the opening delimiter the same way
- * {@link stripEmptyListItemLines} does: a fence is three OR MORE backticks or tildes and is closed
- * only by a run of the same character at least as long, so a `````` ```` `````-fenced block wrapping
- * ``` ``` ``` stays code throughout. Matching a fixed ``` pair instead would end the region early and
- * hand the rest of the author's code to the rewrite.
- */
-function unescapeIntrawordUnderscores(markdown: string): string {
-  const lines = markdown.split('\n')
-  let fence: string | null = null
-
-  for (let i = 0; i < lines.length; i++) {
-    if (fence) {
-      if (closesFence(lines[i], fence)) fence = null
-      continue
-    }
-
-    const delimiter = opensFence(lines[i])
-    if (delimiter) {
-      fence = delimiter
-      continue
-    }
-
-    lines[i] = lines[i].replace(
-      CODE_SPAN_OR_INTRAWORD_ESCAPED_UNDERSCORE,
-      (match, ticks, _span, flank) => (ticks === undefined ? `${flank}_` : match)
-    )
-  }
-
-  return lines.join('\n')
-}
-
 /**
  * Collapses an autolinked destination back to its bare form: our normalizing serializer rewrites a bare
  * URL or `<url>` autolink to `[url](url)` and a bare email to `[a@b.com](mailto:a@b.com)`, which churns
@@ -167,38 +110,6 @@ 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]*$/
-/**
- * Leading blockquote markers, which every line of a fence inside a quote or a `[!NOTE]` callout
- * carries. The serializer writes those (` > ```js `), so a walk that only recognises a bare fence
- * never enters code state there and rewrites the block's interior as prose.
- */
-const BLOCKQUOTE_PREFIX = /^[ \t]*(?:>[ \t]?)*/
-
-/** The line with any blockquote markers removed, so a quoted fence reads like a bare one. */
-function unquote(line: string): string {
-  return line.replace(BLOCKQUOTE_PREFIX, '')
-}
-
-/** The delimiter run that OPENS a fence on this line, quoted or not, or undefined. */
-function opensFence(line: string): string | undefined {
-  return unquote(line).match(FENCE_DELIMITER)?.[1]
-}
-
-/** Whether `line` closes a fence opened with `fence`: same character, and at least as long. */
-function closesFence(line: string, fence: string): boolean {
-  const delimiter = unquote(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]*/
 
@@ -224,12 +135,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 (closesFence(line, fence)) fence = null
+      if (delimiter && delimiter[0] === fence[0] && delimiter.length >= fence.length) fence = null
       continue
     }
-    const delimiter = opensFence(line)
     if (delimiter) {
       fence = delimiter
       kept.push(line)
@@ -260,8 +171,7 @@ function stripEmptyListItemLines(markdown: string): string {
 /**
  * Cleans up serializer output: drops empty list-item marker lines that would otherwise corrupt on
  * round-trip ({@link stripEmptyListItemLines}), restores callout markers the serializer
- * backslash-escapes (`> \[!NOTE\]` → `> [!NOTE]`), drops the equally unnecessary escape on an
- * intraword underscore ({@link unescapeIntrawordUnderscores}), and collapses trailing blank lines to a single
+ * backslash-escapes (`> \[!NOTE\]` → `> [!NOTE]`), and collapses trailing blank lines to a single
  * newline. Interior blank runs are NOT collapsed here — blank lines inside a fenced code block (or a
  * verbatim raw-markdown-snippet) are significant, and a global collapse would corrupt them. An interior
  * run between top-level blocks is significant too: it is how an empty paragraph is written, and
@@ -274,8 +184,6 @@ function stripEmptyListItemLines(markdown: string): string {
  */
 export function postProcessSerializedMarkdown(markdown: string): string {
   return collapseAutolinkedUrls(
-    unescapeIntrawordUnderscores(
-      stripEmptyListItemLines(markdown).replace(ESCAPED_CALLOUT_REGEX, '$1[!$2]')
-    )
+    stripEmptyListItemLines(markdown).replace(ESCAPED_CALLOUT_REGEX, '$1[!$2]')
   ).replace(/\n+$/, '\n')
 }

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

@@ -98,32 +98,6 @@ 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'
@@ -201,13 +175,6 @@ describe('editor markdown round-trip', () => {
     'highlight nested in bold': '**bold ==mark== here**',
     'highlight in list': '- ==a== item',
     'highlight with interior equals': 'x ==a=b== y',
-    'intraword underscores': 'SB_ACTION_ROUTER_SECRET',
-    'env token with underscores': '{{TE_SERET}} and {{OPENAI_API_KEY}}',
-    'underscore emphasis': 'an _italic_ word',
-    'underscore bold': 'a __bold__ word',
-    'mixed underscores': '_em_ then SNAKE_CASE_NAME then _em again_',
-    'escaped underscore in code': '```py\nx = a\\_b\n```',
-    'escaped underscore in inline code': 'call `a\\_b` here',
   }
 
   for (const [name, input] of Object.entries(cases)) {
@@ -237,63 +204,6 @@ describe('editor markdown round-trip', () => {
     expect(roundTrip('> [!NOTE]\n> Heads up')).toContain('[!NOTE]')
   })
 
-  /*
-   * The serializer escapes every underscore, but CommonMark's intraword rule means one flanked by
-   * letters or digits can neither open nor close emphasis. The escape is therefore invisible to a
-   * reader and load-bearing for nobody — while workflow search matches the STORED markdown, so a
-   * stray backslash made `SB_ACTION` unfindable in a note that plainly showed it.
-   */
-  it('writes an intraword underscore without a backslash', () => {
-    expect(roundTrip('SB_ACTION_ROUTER_SECRET')).toBe('SB_ACTION_ROUTER_SECRET')
-    expect(roundTrip('{{TE_SERET}}')).toBe('{{TE_SERET}}')
-  })
-
-  /* Emphasis itself normalises to asterisks, which is pre-existing and fine. What must survive
-     is the distinction: a literal underscore pair keeps its escape, so re-parsing cannot turn
-     the user's text into emphasis. */
-  it('still escapes an underscore that would open or close emphasis', () => {
-    expect(roundTrip('an _italic_ word')).toBe('an *italic* word')
-    expect(roundTrip('literal \\_not emphasis\\_ here')).toContain('\\_')
-  })
-
-  /* Code is emitted verbatim, so a backslash inside it is the author's own character and not an
-     escape to drop. Unescaping blind would silently rewrite people's code. */
-  it('leaves a backslash-underscore inside code alone', () => {
-    expect(roundTrip('```py\nx = a\\_b\n```')).toContain('a\\_b')
-    expect(roundTrip('call `a\\_b` here')).toContain('a\\_b')
-  })
-
-  /* A fence is three OR MORE delimiters, closed only by a run at least as long, and an inline span
-     opens and closes on backtick runs of equal length. Recognising just the shortest form ends the
-     code region early and hands the rest of the author's code to the rewrite. */
-  it('leaves code alone in a longer fence', () => {
-    expect(roundTrip('````\nx = a\\_b\n```\nstill code y = c\\_d\n````')).toContain('a\\_b')
-    expect(roundTrip('````\nx = a\\_b\n```\nstill code y = c\\_d\n````')).toContain('c\\_d')
-  })
-
-  it('leaves code alone in a tilde fence', () => {
-    expect(roundTrip('~~~~\nx = a\\_b\n~~~~')).toContain('a\\_b')
-  })
-
-  it('leaves code alone in a multi-backtick inline span', () => {
-    expect(roundTrip('call ``a\\_b`c`` here')).toContain('a\\_b')
-  })
-
-  /* Unlike the fence-length cases, this one is reachable: the serializer really does write a
-     quoted fence as ` > ```js `, so a walk that only recognises a bare fence never enters code
-     state and rewrites the block's interior as prose. */
-  it('leaves code alone inside a blockquoted fence', () => {
-    expect(roundTrip('> ```js\n> x = a\\_b\n> ```')).toContain('a\\_b')
-  })
-
-  it('leaves code alone inside a callout fence', () => {
-    expect(roundTrip('> [!NOTE]\n> ```js\n> x = a\\_b\n> ```')).toContain('a\\_b')
-  })
-
-  it('still unescapes prose inside a blockquote', () => {
-    expect(roundTrip('> SB_ACTION_ROUTER_SECRET')).toContain('SB_ACTION_ROUTER_SECRET')
-  })
-
   it('preserves an image url (does not drop the src)', () => {
     const out = roundTrip('![alt](https://example.com/i.png)')
     expect(out).toContain('![alt](https://example.com/i.png)')

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/note-block/note-block.tsx

@@ -4,6 +4,7 @@ import {
   countNoteSearchOccurrencesBefore,
   DEFAULT_NOTE_COLOR,
   estimateNoteBlockHeight,
+  forEachNoteSourceOccurrence,
   getNoteStringValue,
   isNoteColor,
   NoteBlockView,
@@ -171,9 +172,15 @@ export const NoteBlock = memo(function NoteBlock({
       }
     }
 
-    return content.toLowerCase().includes(query.toLowerCase())
-      ? { query, occurrenceIndex: 0 }
-      : null
+    /* Asked through the same scan that will do the marking, rather than a local
+       `includes`: a bare comparison skips the whitespace fold, so a query the
+       indexer matched across a newline or a non-breaking space would read as
+       absent here and the card would paint nothing while the panel counted it. */
+    let occurs = false
+    forEachNoteSourceOccurrence(content, query, () => {
+      occurs = true
+    })
+    return occurs ? { query, occurrenceIndex: 0 } : null
   }, [content, isSearchTargetBlock, searchTarget])
 
   /**
@@ -240,8 +247,16 @@ export const NoteBlock = memo(function NoteBlock({
   const searchExpandedRef = useRef(false)
   const hasSearchMatch = searchHighlight !== null || nameSearchRange !== null
   useEffect(() => {
+    /* Losing edit rights already force-collapses the card during render. Drop the latch with it,
+       or regaining them would hit the early return below and leave a deep match clipped in the
+       compact body until the active match moved. */
+    if (!canEditNote) {
+      searchExpandedRef.current = false
+      return
+    }
+
     if (hasSearchMatch) {
-      if (searchExpandedRef.current || isExpandedRef.current || !canEditNote) return
+      if (searchExpandedRef.current || isExpandedRef.current) return
       searchExpandedRef.current = true
       setIsExpanded(true)
       return

apps/sim/blocks/blocks/note.ts

@@ -15,6 +15,7 @@ export const NoteBlock: BlockConfig = {
     {
       id: 'content',
       type: 'long-input',
+      searchTextFormat: 'markdown',
       rows: 8,
       placeholder: 'Add context or instructions for collaborators...',
       description: 'Write your note using Markdown. YouTube links will display as embedded videos.',

apps/sim/blocks/types.ts

@@ -269,6 +269,19 @@ export interface SubBlockConfig {
   type: SubBlockType
   mode?: 'basic' | 'advanced' | 'both' | 'trigger' | 'trigger-advanced' // Default is 'both' if not specified. 'trigger' means only shown in trigger mode. 'trigger-advanced' is the advanced side of a trigger field — either a canonical pair member or a standalone field shown under the block-level advanced toggle
   canonicalParamId?: string
+  /**
+   * Declares that the stored value is markdown, so workflow search matches it
+   * against the text it RENDERS as rather than its source.
+   *
+   * The rich-text editor backslash-escapes every markdown-significant character
+   * in prose, so a Note body the reader sees as `SB_ACTION` is stored as
+   * `SB\_ACTION` and would otherwise be unfindable by what is on screen. Ranges
+   * stay in source coordinates, so replace still rewrites the escaped span.
+   *
+   * Omit for every ordinary field: a code or plain-text value is searched as
+   * stored, where a backslash is the author's own character.
+   */
+  searchTextFormat?: 'markdown'
   /** Controls parameter visibility in agent/tool-input context */
   paramVisibility?: 'user-or-llm' | 'user-only' | 'llm-only' | 'hidden'
   /**