fix(file): accept open-ended repeats, count characters, classify lock waits

Three defects from review, none of which the tests caught:

`{n,}` was rejected. `readQuantifierAt` reports an unbounded maximum as
Infinity, and the repeat cap compared it directly, so every open-ended repeat
failed as "exceeds 1000" — a form the tool's own documentation offers. Only a
stated maximum is measured now, and the minimum always is, since that is what
an expansion unrolls.

Query bounds and literal runs were measured in UTF-16 units while claiming
characters, so two astral characters read as four and slipped a gate written
for three. Both now count characters, which is also what pg_trgm indexes.

`lock_timeout` was set without classifying what it raises. A wait on
conflicting DDL surfaced as an unclassified server error, and folding it in
with the timeout arm would have told the caller to fix a pattern that is
already correct. It now maps to a distinct error the caller is told to retry.

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

Author: icecrasher321

apps/sim/lib/workspace-files/application/search-workspace-file-content.ts

@@ -7,7 +7,10 @@ import {
   type FileSearchMode,
   FileSearchPatternError,
 } from '@/lib/workspace-files/search/pattern'
-import { searchWorkspaceFileIndex } from '@/lib/workspace-files/search/repository'
+import {
+  searchWorkspaceFileIndex,
+  WorkspaceFileSearchUnavailableError,
+} from '@/lib/workspace-files/search/repository'
 
 export interface SearchWorkspaceFileContentInput {
   workspaceId: string
@@ -46,6 +49,10 @@ export const searchWorkspaceFileContent = defineAuthorizedWorkspaceFileUseCase({
       if (error instanceof FileSearchPatternError) {
         throw new OrchestrationError('validation', error.message)
       }
+      /** Nothing is wrong with the query, so the caller is told to retry, not to rewrite it. */
+      if (error instanceof WorkspaceFileSearchUnavailableError) {
+        throw new OrchestrationError('locked', error.message)
+      }
       throw error
     }
   },

apps/sim/lib/workspace-files/search/pattern.test.ts

@@ -13,6 +13,13 @@ describe('compileFileSearchPattern', () => {
       expect(() => compileFileSearchPattern('a'.repeat(513), mode)).toThrow(/at most 512/)
       expect(() => compileFileSearchPattern('abc\0def', mode)).toThrow(/NUL/)
     })
+
+    /** Two astral characters occupy four UTF-16 units but are still two characters. */
+    it.each(['exact', 'regex'] as const)('bounds the query in characters in %s mode', (mode) => {
+      expect(() => compileFileSearchPattern('🙂🙂', mode)).toThrow(/at least 3 characters/)
+      expect(() => compileFileSearchPattern('🙂🙂🙂', mode)).not.toThrow()
+      expect(() => compileFileSearchPattern('🙂'.repeat(513), mode)).toThrow(/at most 512/)
+    })
   })
 
   describe('exact mode', () => {

apps/sim/lib/workspace-files/search/pattern.ts

@@ -173,12 +173,17 @@ export function compileFileSearchPattern(
   query: string,
   mode: FileSearchMode
 ): CompiledFileSearchPattern {
-  if (query.length < FILE_SEARCH_MIN_QUERY_LENGTH) {
+  /**
+   * Characters, not UTF-16 units: two astral characters occupy four units, and
+   * measuring those would admit a query shorter than the bound claims to allow.
+   */
+  const queryLength = [...query].length
+  if (queryLength < FILE_SEARCH_MIN_QUERY_LENGTH) {
     throw new FileSearchPatternError(
       `Search query must be at least ${FILE_SEARCH_MIN_QUERY_LENGTH} characters`
     )
   }
-  if (query.length > FILE_SEARCH_MAX_QUERY_LENGTH) {
+  if (queryLength > FILE_SEARCH_MAX_QUERY_LENGTH) {
     throw new FileSearchPatternError(
       `Search query must be at most ${FILE_SEARCH_MAX_QUERY_LENGTH} characters`
     )

apps/sim/lib/workspace-files/search/regex.test.ts

@@ -33,6 +33,12 @@ describe('analyzeFileSearchRegex', () => {
       expect(run('ab{2,4}cd')).toBe(3)
     })
 
+    it('measures a run in characters, not UTF-16 units', () => {
+      expect(run('🙂🙂needle')).toBe(8)
+      expect(run('🙂🙂')).toBe(2)
+      expect(run('東京都')).toBe(3)
+    })
+
     it('does not let a bounded repeat expand into a large intermediate', () => {
       expect(run('(?:(?:abc){1000}){1000}')).toBeGreaterThanOrEqual(3)
       expect(run('(?:(?:abc){1000}){1000}')).toBeLessThanOrEqual(512)
@@ -78,6 +84,7 @@ describe('analyzeFileSearchRegex', () => {
       ['*foo', /has no character to repeat/],
       ['foo{2,1}', /counts down/],
       ['a{1,5000}bcd', /exceeds 1000/],
+      ['a{5000,}bcd', /exceeds 1000/],
       ['foo{bar}', /Unescaped "\{"/],
     ])('rejects %s', (source, message) => {
       expect(() => analyzeFileSearchRegex(source)).toThrow(FileSearchPatternError)
@@ -100,6 +107,8 @@ describe('analyzeFileSearchRegex', () => {
       'status: [0-9]{3} failed',
       'cache.*?miss',
       'user_id=\\w+ token',
+      'error a{3,}bcd',
+      'error a{3,10}bcd',
     ])('accepts %s', (source) => {
       expect(() => analyzeFileSearchRegex(source)).not.toThrow()
     })

apps/sim/lib/workspace-files/search/regex.ts

@@ -75,6 +75,15 @@ const POSTGRES_ONLY_ESCAPES: Record<string, string> = {
   Z: '$',
 }
 
+/**
+ * A run is measured in characters, because that is what `pg_trgm` indexes. The
+ * parser walks UTF-16 units, so an astral character arrives as two surrogate
+ * atoms whose concatenation is one character — counting units would score it two.
+ */
+function runLength(text: string): number {
+  return [...text].length
+}
+
 function head(text: string): string {
   return text.length > FILE_SEARCH_PATTERN_LITERAL_CAP
     ? text.slice(0, FILE_SEARCH_PATTERN_LITERAL_CAP)
@@ -92,7 +101,7 @@ function literal(character: string): LiteralGuarantee {
     exact: character,
     prefix: character,
     suffix: character,
-    best: character.length,
+    best: runLength(character),
     zeroWidth: false,
   }
 }
@@ -108,7 +117,7 @@ function concatenate(left: LiteralGuarantee, right: LiteralGuarantee): LiteralGu
     exact: left.exact !== null && right.exact !== null ? head(left.exact + right.exact) : null,
     prefix: head(left.exact !== null ? left.exact + right.prefix : left.prefix),
     suffix: tail(right.exact !== null ? left.suffix + right.exact : right.suffix),
-    best: Math.max(left.best, right.best, joined.length),
+    best: Math.max(left.best, right.best, runLength(joined)),
     zeroWidth: left.zeroWidth && right.zeroWidth,
   }
 }
@@ -447,7 +456,16 @@ class FileSearchRegexParser {
         `Unescaped "{" at position ${this.index + 1} — write "\\{" to match a literal brace`
       )
     }
-    if (bounded.max > FILE_SEARCH_PATTERN_MAX_REPEAT) {
+    /**
+     * `{n,}` has no upper bound to cap — it is `+` with a floor, and both engines
+     * expand it the same way — so only a stated maximum is measured against the
+     * cap. The minimum is always measured, since that is what an expansion
+     * actually unrolls.
+     */
+    if (
+      bounded.min > FILE_SEARCH_PATTERN_MAX_REPEAT ||
+      (Number.isFinite(bounded.max) && bounded.max > FILE_SEARCH_PATTERN_MAX_REPEAT)
+    ) {
       throw new FileSearchPatternError(
         `Repeat count at position ${this.index + 1} exceeds ${FILE_SEARCH_PATTERN_MAX_REPEAT}`
       )

apps/sim/lib/workspace-files/search/repository.test.ts

@@ -8,7 +8,10 @@ import {
   compileFileSearchPattern,
   FileSearchPatternError,
 } from '@/lib/workspace-files/search/pattern'
-import { searchWorkspaceFileIndex } from '@/lib/workspace-files/search/repository'
+import {
+  searchWorkspaceFileIndex,
+  WorkspaceFileSearchUnavailableError,
+} from '@/lib/workspace-files/search/repository'
 
 /**
  * The shape a failed query really arrives in, captured from PostgreSQL 17
@@ -41,6 +44,20 @@ describe('searchWorkspaceFileIndex fault mapping', () => {
     await expect(search).rejects.toThrow(message)
   })
 
+  it('tells the caller to retry when the lock guard fires, not to fix the query', async () => {
+    dbChainMockFns.transaction.mockRejectedValueOnce(driverError('55P03'))
+
+    const search = searchWorkspaceFileIndex({
+      workspaceId: 'workspace-1',
+      pattern: compileFileSearchPattern('error \\d+', 'regex'),
+      maxResults: 50,
+    })
+
+    await expect(search).rejects.toBeInstanceOf(WorkspaceFileSearchUnavailableError)
+    await expect(search).rejects.not.toBeInstanceOf(FileSearchPatternError)
+    await expect(search).rejects.toThrow(/Try again shortly/)
+  })
+
   it('does not reinterpret an unrelated database fault', async () => {
     dbChainMockFns.transaction.mockRejectedValueOnce(driverError('23505'))
 
@@ -53,6 +70,18 @@ describe('searchWorkspaceFileIndex fault mapping', () => {
     ).rejects.not.toBeInstanceOf(FileSearchPatternError)
   })
 
+  it('leaves an unrelated fault unclassified for the surface to generalize', async () => {
+    dbChainMockFns.transaction.mockRejectedValueOnce(driverError('23505'))
+
+    await expect(
+      searchWorkspaceFileIndex({
+        workspaceId: 'workspace-1',
+        pattern: compileFileSearchPattern('needle', 'exact'),
+        maxResults: 50,
+      })
+    ).rejects.not.toBeInstanceOf(WorkspaceFileSearchUnavailableError)
+  })
+
   it('caps how long a search may hold its connection', async () => {
     await searchWorkspaceFileIndex({
       workspaceId: 'workspace-1',

apps/sim/lib/workspace-files/search/repository.ts

@@ -53,8 +53,21 @@ interface SearchWorkspaceFileIndexInput {
 }
 
 const QUERY_CANCELED = '57014'
+const LOCK_NOT_AVAILABLE = '55P03'
 const INVALID_REGULAR_EXPRESSION = '2201B'
 
+/**
+ * The search could not run, for a reason the caller did not cause and cannot fix
+ * by changing the query — distinct from {@link FileSearchPatternError}, so a
+ * surface reports "try again" rather than blaming the pattern.
+ */
+export class WorkspaceFileSearchUnavailableError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'WorkspaceFileSearchUnavailableError'
+  }
+}
+
 /**
  * Walks to the driver error. Drizzle wraps a failed query in a `DrizzleQueryError`
  * that carries no `code` of its own, so reading the top-level error alone finds
@@ -71,17 +84,23 @@ function sqlStateOf(error: unknown): string | undefined {
 }
 
 /**
- * Rewrites the two database faults a search pattern can cause into faults the
- * caller can act on.
+ * Rewrites the database faults this read can raise into faults a caller can act
+ * on, separating the two it causes from the one it merely waits on.
  *
  * `pg_trgm` only indexes a pattern it can extract trigrams from; a
  * punctuation-only, non-ASCII, or too-general one plans as a scan across every
  * workspace's segments, so {@link FILE_SEARCH_STATEMENT_TIMEOUT_MS} is what
- * stops one search holding a pooled connection. And PostgreSQL is the last of
+ * stops one search holding a pooled connection. PostgreSQL is also the last of
  * the engines a regex passes through, so a construct that slipped the pattern
  * analyzer and `RegExp` surfaces here rather than as an unexplained failure.
+ *
+ * {@link FILE_SEARCH_LOCK_TIMEOUT_MS} is different in kind: it fires while
+ * waiting on a conflicting lock — DDL against the segment tables — which no
+ * query can be rewritten to avoid. Without this arm it would reach the caller as
+ * an unclassified server error, and folding it in with the two above would tell
+ * them to fix a pattern that is already correct.
  */
-function asFileSearchPatternFault(error: unknown): FileSearchPatternError | null {
+function asFileSearchFault(error: unknown): Error | null {
   const sqlState = sqlStateOf(error)
   if (sqlState === QUERY_CANCELED) {
     return new FileSearchPatternError(
@@ -91,6 +110,11 @@ function asFileSearchPatternFault(error: unknown): FileSearchPatternError | null
   if (sqlState === INVALID_REGULAR_EXPRESSION) {
     return new FileSearchPatternError('Invalid search pattern.')
   }
+  if (sqlState === LOCK_NOT_AVAILABLE) {
+    return new WorkspaceFileSearchUnavailableError(
+      'Workspace file search is briefly unavailable while its index is being updated. Try again shortly.'
+    )
+  }
   return null
 }
 
@@ -345,7 +369,7 @@ export async function searchWorkspaceFileIndex({
     }
   } catch (error) {
     signal?.throwIfAborted()
-    const fault = asFileSearchPatternFault(error)
+    const fault = asFileSearchFault(error)
     if (fault) throw fault
     throw error
   }