refactor(copilot): share the scaling-ratio harness between the two perf tests

Both complexity tests hand-rolled the same 15-line harness — build a repeated
tag mention, take the fastest of five runs at two input sizes, assert the
ratio — differing only in which function they timed. Changing the run count,
the sample sizes, or the threshold meant editing both in lockstep.

Extracted to `scalingRatioOver4x`, following the existing `*-test-helpers.ts`
convention in this tree. The rationale for asserting a ratio rather than a
wall-clock ceiling now lives in one place instead of being paraphrased twice.

Also drops a redundant disjunct in the opener scan: `nearestStart` and
`nearestTagName` are only ever assigned together, so `nearestStart === -1`
holds exactly when the name is empty. Testing the name alone is the same check
and is the one that narrows the union for `resolveTagAt`.

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

Author: j15z

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

@@ -2,6 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import { scalingRatioOver4x } from '@/app/workspace/[workspaceId]/home/components/message-content/components/scaling-test-helpers'
 import { sanitizeChatDisplayContent } from './chat-sanitize'
 
 describe('sanitizeChatDisplayContent', () => {
@@ -91,27 +92,9 @@ describe('sanitizeChatDisplayContent', () => {
     // is quadratic — 154ms for this input before the bound, on the main thread,
     // for every streamed chunk.
     //
-    // Asserted as a RATIO across a 4x input rather than a wall-clock ceiling. A
-    // fixed millisecond bound measures the machine as much as the algorithm: it
-    // fails on a loaded CI box, and set generously enough not to, it lets a
-    // genuine quadratic through at the single size it happens to sample.
-    // Quadratic costs ~16x for 4x the input; linear costs ~4x.
-    const build = (times: number) => 'The <workspace_resource> tag is used here. '.repeat(times)
-    const fastest = (content: string) => {
-      let best = Number.POSITIVE_INFINITY
-      for (let run = 0; run < 5; run++) {
-        const startedAt = performance.now()
-        sanitizeChatDisplayContent(content)
-        best = Math.min(best, performance.now() - startedAt)
-      }
-      return best
-    }
-
-    fastest(build(2_000))
-    const small = fastest(build(2_000))
-    const large = fastest(build(8_000))
-
-    expect(large / small).toBeLessThan(8)
+    // Asserted as a scaling ratio, not a wall-clock ceiling — see
+    // {@link scalingRatioOver4x} for why.
+    expect(scalingRatioOver4x((content) => sanitizeChatDisplayContent(content))).toBeLessThan(8)
   })
 
   it('still unwraps a real tag that carries a stray backtick on one side only', () => {

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

@@ -0,0 +1,39 @@
+/**
+ * Repeated mention of a tag name that never closes — the shape both the parser
+ * and the display sanitizer used to be quadratic on, because a scan allowed to
+ * cross an opener restarts from every opener.
+ */
+function buildRepeatedTagMentions(times: number): string {
+  return 'The <workspace_resource> tag is used here. '.repeat(times)
+}
+
+/** Fastest of five runs, so a single scheduling hiccup cannot skew the sample. */
+function fastest(run: (content: string) => void, content: string): number {
+  let best = Number.POSITIVE_INFINITY
+  for (let attempt = 0; attempt < 5; attempt++) {
+    const startedAt = performance.now()
+    run(content)
+    best = Math.min(best, performance.now() - startedAt)
+  }
+  return best
+}
+
+/**
+ * How much slower `run` gets when its input grows 4x.
+ *
+ * Complexity is asserted as a RATIO rather than a wall-clock ceiling. A fixed
+ * millisecond bound measures the machine as much as the algorithm: it fails on a
+ * loaded CI box, and set generously enough not to, it lets a genuine quadratic
+ * through at the single size it happens to sample. Quadratic costs ~16x for 4x
+ * the input; linear costs ~4x.
+ */
+export function scalingRatioOver4x(run: (content: string) => void): number {
+  // Warm up first — the JIT would otherwise charge the whole compile to the
+  // small sample and flatter the ratio.
+  fastest(run, buildRepeatedTagMentions(2_000))
+
+  const small = fastest(run, buildRepeatedTagMentions(2_000))
+  const large = fastest(run, buildRepeatedTagMentions(8_000))
+
+  return large / small
+}

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

@@ -14,6 +14,7 @@ vi.mock('@/lib/auth/auth-client', () => ({
   useSession: vi.fn(() => ({ data: null, isPending: false })),
 }))
 
+import { scalingRatioOver4x } from '@/app/workspace/[workspaceId]/home/components/message-content/components/scaling-test-helpers'
 import type {
   ContentSegment,
   IndexOfCache,
@@ -612,25 +613,9 @@ describe('parseSpecialTags with <question>', () => {
     // or `[` — the common case. Testing that before blanking avoids copying a
     // full window per opener per chunk: 43ms to 2ms on this input.
     //
-    // Asserted as a RATIO across a 4x input rather than a wall-clock ceiling, so
-    // the test pins the complexity instead of the speed of the machine running
-    // it. Quadratic costs ~16x for 4x the input; linear costs ~4x.
-    const build = (times: number) => 'The <workspace_resource> tag is used here. '.repeat(times)
-    const fastest = (content: string) => {
-      let best = Number.POSITIVE_INFINITY
-      for (let run = 0; run < 5; run++) {
-        const startedAt = performance.now()
-        parseSpecialTags(content, true)
-        best = Math.min(best, performance.now() - startedAt)
-      }
-      return best
-    }
-
-    fastest(build(2_000))
-    const small = fastest(build(2_000))
-    const large = fastest(build(8_000))
-
-    expect(large / small).toBeLessThan(8)
+    // Asserted as a scaling ratio, not a wall-clock ceiling — see
+    // {@link scalingRatioOver4x} for why.
+    expect(scalingRatioOver4x((content) => parseSpecialTags(content, true))).toBeLessThan(8)
   })
 
   it('does not let a late thinking close swallow content already on screen', () => {

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

@@ -1042,7 +1042,10 @@ export function parseSpecialTags(content: string, isStreaming: boolean): ParsedS
       }
     }
 
-    if (nearestStart === -1 || nearestTagName === '') {
+    // Only the name is tested: the two are assigned together above, so an empty
+    // name and a -1 start are the same state — and the name is the one that
+    // needs narrowing before resolveTagAt below.
+    if (nearestTagName === '') {
       let remaining = content.slice(cursor)
 
       if (isStreaming) {