fix(search): preserve infinite range overlap semantics

Author: icecrasher321

apps/sim/lib/workflows/search-replace/resources/resolvers.test.ts

@@ -218,13 +218,17 @@ describe('workflowSearchMatchMatchesQuery', () => {
         // the oracle has to defend inverted, empty and non-finite ends as well.
         const degenerate = random()
         const end =
-          degenerate > 0.97
+          degenerate > 0.98
             ? Number.NaN
-            : degenerate > 0.94
-              ? start - 1 - Math.floor(random() * 3)
-              : degenerate > 0.91
-                ? start
-                : start + 1 + Math.floor(random() * 8)
+            : degenerate > 0.96
+              ? Number.POSITIVE_INFINITY
+              : degenerate > 0.94
+                ? Number.NEGATIVE_INFINITY
+                : degenerate > 0.91
+                  ? start - 1 - Math.floor(random() * 3)
+                  : degenerate > 0.88
+                    ? start
+                    : start + 1 + Math.floor(random() * 8)
         const isSubBlockTarget = random() > 0.15
         return createMatch({
           id: `m-${index}`,
@@ -296,6 +300,28 @@ describe('workflowSearchMatchMatchesQuery', () => {
       expect(dedupeOverlappingWorkflowSearchMatches(matches)).toHaveLength(1)
     })
 
+    it('agrees when a positive-infinity range contains a later range', () => {
+      const matches = [
+        createMatch({
+          id: 'unbounded',
+          kind: 'workflow-reference',
+          range: { start: 0, end: Number.POSITIVE_INFINITY },
+        }),
+        createMatch({
+          id: 'inside',
+          kind: 'text',
+          range: { start: 1, end: 2 },
+        }),
+      ]
+
+      expect(dedupeOverlappingWorkflowSearchMatches(matches).map((match) => match.id)).toEqual(
+        referenceDedupe(matches).map((match) => match.id)
+      )
+      expect(dedupeOverlappingWorkflowSearchMatches(matches).map((match) => match.id)).toEqual([
+        'inside',
+      ])
+    })
+
     it.each([0, 1])('agrees on a %i-element input', (count) => {
       const matches = randomMatches(5, count)
 

apps/sim/lib/workflows/search-replace/resources/resolvers.ts

@@ -153,7 +153,7 @@ interface RangeMatchScopeBucket {
 }
 
 function widenScopeBucket(bucket: RangeMatchScopeBucket, end: number): void {
-  if (Number.isFinite(end)) bucket.maxEnd = Math.max(bucket.maxEnd, end)
+  if (!Number.isNaN(end)) bucket.maxEnd = Math.max(bucket.maxEnd, end)
 }
 
 /**
@@ -190,11 +190,11 @@ function widenScopeBucket(bucket: RangeMatchScopeBucket, end: number): void {
  * can still end further right than the one it evicts. Leaving `maxEnd` stale
  * there let the short-circuit skip genuine overlaps and leak duplicates.
  *
- * Only finite ends widen it. `Math.max` with a non-finite end would pin
- * `maxEnd` at `NaN`, and since every comparison against `NaN` is false that
- * would silently switch dedupe off for the rest of the scope. A non-finite
- * range cannot overlap anything anyway - `rangesOverlap` is false for it - so
- * skipping the widening matches what the unbucketed scan did.
+ * Only `NaN` ends are ignored. `Math.max` with `NaN` would pin `maxEnd` at
+ * `NaN`, and since every comparison against `NaN` is false that would silently
+ * switch dedupe off for the rest of the scope. A `NaN`-ended range cannot
+ * overlap anything anyway, while positive infinity is an unbounded end that
+ * can overlap later ranges and therefore must widen the high-water mark.
  */
 export function dedupeOverlappingWorkflowSearchMatches<T extends WorkflowSearchMatch>(
   matches: T[]
@@ -226,7 +226,7 @@ export function dedupeOverlappingWorkflowSearchMatches<T extends WorkflowSearchM
         } else {
           bucketsByScopeKey.set(scopeKey, {
             indices: [deduped.length],
-            maxEnd: Number.isFinite(matchRange.end) ? matchRange.end : Number.NEGATIVE_INFINITY,
+            maxEnd: Number.isNaN(matchRange.end) ? Number.NEGATIVE_INFINITY : matchRange.end,
           })
         }
       }