Select dialog: a size or date filter with an empty name bar now selects matching files

Fixes the headline correctness bug: in the Select/Deselect dialog, a size filter like `≥ 1 MB` with an empty name pattern returned zero results. `buildMatchQuery()` returned `null` whenever the pattern was empty, so the JS matcher short-circuited to `[]` and the size/date chips were effectively decorative unless a glob was also typed.

Now an empty name bar WITH an active filter (size ≠ any or date ≠ any) runs as match-all: `buildMatchQuery` substitutes a glob `*`, and the size/date predicates narrow the set, so `≥ 1 MB` with no glob selects every file ≥ 1 MB. Empty pattern AND no filters still yields `null` (nothing to run). The new `hasActiveFilter()` predicate is the single "is there anything to run?" check, written so a future type filter slots in cleanly.

- The run path already re-fires correctly: the size/date popovers call `scheduleSearch` on edit, and the Enter / `runOnMount` paths have no empty-query gate. No change needed there.
- Search needed no change: its backend already match-alls on a null `namePattern` with size filters, and `buildSearchQuery` already builds `{ namePattern: null, minSize: X }` for an empty bar. Added a regression test proving the frontend doesn't block it.
- Tests (TDD red→green): a `SelectionDialog.svelte` test (empty bar + `≥ 1 MB` size popover pick → commit selects exactly the matching index) that failed red against the old null-gate; a `selection-matching` test pinning the match-all + size contract; a `search-state` regression test for the match-all `SearchQuery`.
- Docs: `selection-dialog/CLAUDE.md` § Match semantics now documents the filter-only behavior plus a gotcha against reintroducing the empty-pattern early-return.

Author: vdavid

apps/desktop/src/lib/search/search-state.test.ts

@@ -98,6 +98,20 @@ describe('buildSearchQuery', () => {
     expect(query.modifiedBefore).toBeNull()
   })
 
+  it('builds a match-all query from a size filter alone (empty pattern is not blocked)', () => {
+    // Regression for the filter-only fix: an empty name bar + a size filter must
+    // produce a match-all query (`namePattern: null`) carrying the size bound. The
+    // backend match-alls on a null pattern, so no frontend gate may drop this case.
+    clearSearchState()
+    setSizeFilter('gte')
+    setSizeValue('1')
+    setSizeUnit('MB')
+    const query = buildSearchQuery()
+    expect(query.namePattern).toBeNull()
+    expect(query.minSize).toBe(1024 * 1024)
+    expect(query.maxSize).toBeNull()
+  })
+
   it('includes the query text as namePattern when set', () => {
     clearSearchState()
     setQuery('*.pdf')

apps/desktop/src/lib/selection-dialog/CLAUDE.md

@@ -47,7 +47,13 @@ doesn't care which kind it's running against.
 
 Glob translation matches the Rust side: `*` → `.*`, `?` → `.`, regex metacharacters escaped, anchored with `^…$`. The JS
 regex engine is what does the matching (Selection has no Rust IPC for the match itself — it's microseconds in JS against
-a few hundred entries). Bad regex (`SyntaxError`) → `[]`. Empty pattern → `[]`.
+a few hundred entries). Bad regex (`SyntaxError`) → `[]`.
+
+**Empty pattern WITH an active filter → match-all on the name; empty pattern AND no filters → `[]`.** Filter-only
+queries are valid: `buildMatchQuery` substitutes a match-all glob `*` when the bar is empty but `hasActiveFilter()` is
+true, so `≥ 1 MB` with no glob selects every file ≥ 1 MB. Gotcha: don't reintroduce an empty-pattern early-return in
+`buildMatchQuery` that ignores the filters, or the size/date chips go decorative. The matcher's `compilePattern` still
+returns `null` on an empty pattern, so the wrapper, not the matcher, owns the substitution.
 
 ## Folder sampling
 

apps/desktop/src/lib/selection-dialog/SelectionDialog.svelte

@@ -152,11 +152,28 @@
         }
     }
 
+    /**
+     * Whether any non-pattern filter is active. When it is, a filter-only query
+     * (empty name bar) is still meaningful and runs as match-all on the name. Extend
+     * this predicate as new filters land (the M4 type filter slots in here) so
+     * `buildMatchQuery` stays the single source of truth for "is there anything to
+     * run?".
+     */
+    function hasActiveFilter(): boolean {
+        return selectionQueryState.getSizeFilter() !== 'any' || selectionQueryState.getDateFilter() !== 'any'
+    }
+
     /**
      * Builds a `SelectionMatchQuery` from current state. AI mode hands the pattern
      * via the hand-typed buffer for the kind the AI produced (filename buffer for
      * glob, regex buffer for regex). Filename mode reads from the bar; regex mode
      * reads from the bar.
+     *
+     * Filter-only queries are valid: an empty name pattern WITH an active size/date
+     * filter runs as match-all (glob `*`, which the matcher anchors to `.*`), so
+     * `≥ 1 MB` with no glob selects every file ≥ 1 MB. Only an empty pattern AND no
+     * filters yields `null` (genuinely nothing to do). Don't reintroduce an
+     * empty-pattern early-return that ignores the filters.
      */
     function buildMatchQuery(): SelectionMatchQuery | null {
         const m = selectionQueryState.getMode()
@@ -181,10 +198,17 @@
                 pattern = aiGlob
                 kind = 'glob'
             } else {
-                return null
+                pattern = ''
+                kind = 'glob'
             }
         }
-        if (!pattern.trim()) return null
+        if (!pattern.trim()) {
+            if (!hasActiveFilter()) return null
+            // Filter-only query: match every name, then let the size/date predicates
+            // narrow the set. A glob `*` translates to `.*` in the matcher.
+            pattern = '*'
+            kind = 'glob'
+        }
 
         const size = readSizePredicate()
         const date = readDatePredicate()

apps/desktop/src/lib/selection-dialog/SelectionDialog.svelte.test.ts

@@ -525,6 +525,53 @@ describe('SelectionDialog', () => {
     second.cleanup()
   })
 
+  it('matches on a size filter alone when the name bar is empty', async () => {
+    // The headline M2 fix: a `≥ 1 MB` size filter with an EMPTY name pattern must
+    // select every file ≥ 1 MB. Before the fix, `buildMatchQuery` returned null on
+    // an empty pattern and the matcher short-circuited to [], so filter-only queries
+    // silently selected nothing.
+    const matched: number[][] = []
+    const { overlay, cleanup } = await mountDialog({
+      entries: [
+        buildEntry('small.txt', { size: 1000 }),
+        buildEntry('big.bin', { size: 2_000_000 }),
+        buildEntry('tiny.log', { size: 50 }),
+      ],
+      onCommit: (idxs) => matched.push(idxs),
+    })
+
+    // Leave the bar empty. Configure a `≥ 1 MB` size filter via the popover.
+    const sizeChip = Array.from(overlay.querySelectorAll<HTMLButtonElement>('.filter-chip')).find((c) =>
+      c.textContent.trim().startsWith('Size'),
+    )
+    if (!sizeChip) throw new Error('size chip not found')
+    sizeChip.click()
+    await tick()
+    const sizePopover = document.querySelector('[aria-label="Size filter options"]')
+    if (!sizePopover) throw new Error('size popover did not open')
+    const radios = Array.from(sizePopover.querySelectorAll('button[role="radio"]'))
+    const gteCell = radios.find((b) => b.textContent.trim() === '≥')
+    const onePreset = radios.find((b) => b.textContent.trim() === '1')
+    if (!gteCell || !onePreset) throw new Error('size popover cells not found')
+    ;(gteCell as HTMLButtonElement).click()
+    await tick()
+    ;(onePreset as HTMLButtonElement).click()
+    await tick()
+    // The size pick schedules an auto-apply run; wait for the debounce to fire.
+    await new Promise((r) => setTimeout(r, 1100))
+    await tick()
+
+    // Commit selects exactly the 2 MB file's index. The committed set is the
+    // authoritative proof the filter-only run matched (virtual-scroll row rendering
+    // is unreliable under jsdom, so we assert on the matched indices, not the DOM).
+    dispatchKey(overlay, 'Enter')
+    await tick()
+    expect(matched).toHaveLength(1)
+    expect(matched[0]).toEqual([1])
+
+    cleanup()
+  })
+
   it('toggles caseSensitive via the FilterChips extras callback', async () => {
     // Mount and let the dialog's onMount complete, then toggle via the chip button.
     const { overlay, cleanup } = await mountDialog()

apps/desktop/src/lib/selection-dialog/selection-matching.test.ts

@@ -100,6 +100,26 @@ describe('matchEntries: size predicate', () => {
     expect(matchEntries(accessors, list.length, q)).toEqual([0, 1])
   })
 
+  it('match-all `*` + size predicate selects only files over the bound (filter-only contract)', () => {
+    // The contract M2's filter-only fix relies on: an empty name bar becomes a
+    // match-all glob `*`, and the size predicate alone picks the matching files.
+    // A folder snapshot of a 2 MB file + small files + a dir (null size) returns
+    // exactly the 2 MB file's index.
+    const names = ['notes.txt', 'photo.bin', 'subdir']
+    const fileSizes: (number | null)[] = [1000, 2_000_000, null] // last is a dir
+    const acc: MatchAccessors = {
+      getNameFor: (i) => names[i],
+      getSizeFor: (i) => fileSizes[i],
+    }
+    const q: SelectionMatchQuery = {
+      pattern: '*',
+      kind: 'glob',
+      caseSensitive: false,
+      size: { kind: 'gte', min: 1_048_576 },
+    }
+    expect(matchEntries(acc, names.length, q)).toEqual([1])
+  })
+
   it('drops entries with no size when a size predicate is set', () => {
     const q: SelectionMatchQuery = {
       pattern: '*',