refactor(copilot): quality pass over the parser and its tests

Four changes from a reuse/simplification/efficiency/altitude review. No behaviour
change; 162 tests unchanged.

blankJsonStringLiterals returns the body untouched when it contains no quote. No
quote means no string literal, so the loop was copying the body to itself
character by character. unclosedTagCannotResolve had learned to short-circuit
before calling it; literalTextReason had not, and blanked unconditionally on
every already-rejected tag on every later chunk. Putting the guard inside the
helper fixes both callers at once.

inspectWithin and inspectFrom were near-duplicates added at different times. One
function with an optional start expresses both, and keeps the property the second
one existed for: slice once, already bounded, never `content.slice(bodyStart)`
first and bound after.

The frame-replay property was 1727ms — 95% of the file's test time — because it
parses every prefix, so message length multiplies into parse count, and the
fragment pool included a 6KB filler. Retraction happens AT a frame boundary, not
as a function of message size, so that property now draws from the short
fragments; the window-crossing filler still gets coverage from the properties
that parse each message once. 1727ms to 205ms, same seeds, same assertions. It
also now calls replayFrames instead of hand-rolling the stepping loop it already
had a helper for.

Deferred deliberately, each with a reason:

- Collapsing `prose-nested-marker` into `nested-marker`. Its own docstring names
  the simplification and defers it; it is a behaviour change and wants its own
  commit and test, which is the pattern the rest of this branch follows.
- Bounding hasSpecialTagMarker on the prose path. Costs tens of microseconds on
  a long reasoning body, but a marker past the bound would flip that body from
  released to suppressed — a retraction, which is the bug two commits back.
- Splitting the parser out of this `'use client'` file. The strongest structural
  finding: the file cannot be imported by server code, which is why the inbox
  executor carries its own thinking-strip regex. It is a mechanical move with no
  logic change and deserves its own PR, not commit 25 of this one.
- Generalising the backtick sanitizer past `workspace_resource`, and replacing it
  with parser-owned backtick consumption. Same reasoning: real, and not here.

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

Author: j15z

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.ts

@@ -823,11 +823,23 @@ describe('parser properties', () => {
 
   const pick = <T>(rng: () => number, xs: T[]): T => xs[Math.floor(rng() * xs.length)]
 
-  function buildLossless(rng: () => number): string {
+  function buildLossless(rng: () => number, pool = LOSSLESS_FRAGMENTS): string {
     const n = 1 + Math.floor(rng() * 5)
-    return Array.from({ length: n }, () => pick(rng, LOSSLESS_FRAGMENTS)).join('')
+    return Array.from({ length: n }, () => pick(rng, pool)).join('')
   }
 
+  /**
+   * The same shapes without the window-crossing filler.
+   *
+   * Frame replay parses every prefix, so message length multiplies into parse
+   * count — the filler fragment alone took that property to ~1M parses and 1.7s,
+   * 95% of this file's runtime. Retraction is a property of what happens AT a
+   * frame boundary, so it is exercised by the boundaries, not by message size.
+   * The scan window still gets its coverage from the other properties, which
+   * parse each message once.
+   */
+  const SHORT_FRAGMENTS = LOSSLESS_FRAGMENTS.filter((fragment) => fragment.length < 200)
+
   it('never loses a character of a message with nothing droppable in it', () => {
     // The headline guarantee. Only a well-formed payload that failed its shape
     // guard may be removed, and no fragment here is one.
@@ -876,22 +888,20 @@ describe('parser properties', () => {
 
     for (let seed = 1; seed <= 120; seed++) {
       const rng = makeRng(seed)
-      const raw = `${buildLossless(rng)}${pick(rng, VALID_TAGS)}${buildLossless(rng)}`
+      const raw = `${buildLossless(rng, SHORT_FRAGMENTS)}${pick(rng, VALID_TAGS)}${buildLossless(rng, SHORT_FRAGMENTS)}`
 
       let previousCards = 0
       let previousText = ''
-      for (let end = 1; end <= raw.length; end += 7) {
-        const view = visibleView(parseSpecialTags(raw.slice(0, end), true).segments)
-
-        expect(view.cardCount, `seed ${seed} at ${end}: card un-rendered`).toBeGreaterThanOrEqual(
+      for (const frame of replayFrames(raw, 7)) {
+        expect(frame.cardCount, `seed ${seed}: card un-rendered`).toBeGreaterThanOrEqual(
           previousCards
         )
 
         const stable = previousText.slice(0, Math.max(0, previousText.length - LONGEST_OPENER))
-        expect(view.text.startsWith(stable), `seed ${seed} at ${end}: text retracted`).toBe(true)
+        expect(frame.text.startsWith(stable), `seed ${seed}: text retracted`).toBe(true)
 
-        previousCards = view.cardCount
-        previousText = view.text
+        previousCards = frame.cardCount
+        previousText = frame.text
       }
     }
   })

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx

@@ -551,6 +551,11 @@ const MAX_UNCLOSED_BODY_SCAN = 4096
  * emitting one would shrink the output and shift every later offset left.
  */
 function blankJsonStringLiterals(body: string): string {
+  // With no quote there is no string literal, so the loop below would copy the
+  // body to itself character by character. Both callers reach here on bodies
+  // that are usually plain prose, and this runs per opener per streamed chunk.
+  if (!body.includes('"')) return body
+
   let out = ''
   let inString = false
   let escaped = false
@@ -810,24 +815,11 @@ interface InspectedBody {
   truncated: boolean
 }
 
-function inspectWithin(body: string): InspectedBody {
-  return body.length > MAX_UNCLOSED_BODY_SCAN
-    ? { text: body.slice(0, MAX_UNCLOSED_BODY_SCAN), truncated: true }
-    : { text: body, truncated: false }
-}
-
-/**
- * {@link inspectWithin} for a body that has not been cut out of the buffer yet.
- *
- * Slices once, already bounded. Taking `content.slice(bodyStart)` first and
- * bounding after copies the entire rest of the message — on every opener, on
- * every streamed chunk — and throws all but the window away.
- */
-function inspectFrom(content: string, bodyStart: number): InspectedBody {
-  const end = bodyStart + MAX_UNCLOSED_BODY_SCAN
-  return end < content.length
-    ? { text: content.slice(bodyStart, end), truncated: true }
-    : { text: content.slice(bodyStart), truncated: false }
+function inspectWithin(source: string, start = 0): InspectedBody {
+  const end = start + MAX_UNCLOSED_BODY_SCAN
+  return end < source.length
+    ? { text: source.slice(start, end), truncated: true }
+    : { text: start === 0 ? source : source.slice(start), truncated: false }
 }
 
 /**
@@ -972,7 +964,7 @@ function resolveTagAt(
   const closeIdx = memoizedIndexOf(closeCache, content, closeTag, bodyStart)
 
   if (closeIdx === -1) {
-    const inspected = inspectFrom(content, bodyStart)
+    const inspected = inspectWithin(content, bodyStart)
     if (isStreaming && !unclosedTagCannotResolve(tagName, inspected.text)) {
       return { outcome: 'pending' }
     }