Size filter: honor a 0 bound and add a one-click = (equals) comparator

Two fixes to the shared Search + Select size filter (`query-ui/filter-chips`):

- **`0` is now a usable bound.** `deriveSizeChip` gated on `minNumeric > 0`, so picking `0` (find empty files) read as "off" and the chip showed nothing. The guard is now `>= 0` across the `gte` / `lte` and `between` branches; an empty input is still `NaN` and stays unconfigured. So "= 0 B" / "≥ 0 B" render as real filters.
- **New `=` comparator.** Adds `eq` to the `SizeFilter` union and a `=` cell to the size popover (single-bound, like `≥` / `≤`), so "size = 0" and "= 5 MB" are one click instead of an unobvious `between x x`.

`eq` is a UI/chip-summary concern only: it never reaches the matcher's `SizePredicate` or any Rust type. Below the chip it's modeled as `between` with `sizeMin == sizeMax` (the matcher's `between` already matches exactly one value):
- `applySizeQuery` pins both `minSize` and `maxSize`.
- `readSizeFilters` emits `{ sizeMin: x, sizeMax: x }`; `SelectionDialog.readSizePredicate` returns `{ kind: 'between', min: x, max: x }`.
- `applyHistoryFilters` rehydrates a stored `size_min == size_max` as `eq` (not `between`) by deliberate decision: the two match the same set and `= x` is the friendlier label, so a stored `between 5–5` returns as `= 5`. No `HistoryFilters` Rust change.
- `applySizeFromAi` sets `eq` when an AI translation returns `min == max`, so a future "size = 0" AI result reads "= 0 B".

Also `bytesToSize` now returns raw bytes for sub-kilobyte bounds ("= 0 B", "512 B") instead of a fractional "0.5 KB".

Tests (real red→green): `filter-chip-state` (zero bound + eq summaries), `selection-matching` (eq == between-min==max matches exactly one value), `query-filter-state` (eq history round-trip persists as min==max, restores as eq), `apply-ai-filters` (min==max → eq), `FilterChips` (the `=` cell renders, selects, single-bound).

Author: vdavid

apps/desktop/src/lib/query-ui/apply-ai-filters.test.ts

@@ -34,6 +34,24 @@ describe('applySizeFromAi', () => {
     expect(state.getSizeValueMax()).toBe('1')
     expect(state.getSizeUnitMax()).toBe('GB')
   })
+
+  // When the AI returns min == max, that's an exact-size match: set the `eq` comparator so
+  // the chip reads "= N" rather than "between N and N".
+  it('sets an eq filter when min == max (so "size = 5 MB" reads as = not between)', () => {
+    const state = createQueryFilterState({ defaultMode: 'filename' })
+    expect(applySizeFromAi(state, 5 * 1024 * 1024, 5 * 1024 * 1024)).toBe(true)
+    expect(state.getSizeFilter()).toBe('eq')
+    expect(state.getSizeValue()).toBe('5')
+    expect(state.getSizeUnit()).toBe('MB')
+  })
+
+  it('sets an eq 0 B filter when the AI returns min == max == 0 (find empty files)', () => {
+    const state = createQueryFilterState({ defaultMode: 'filename' })
+    expect(applySizeFromAi(state, 0, 0)).toBe(true)
+    expect(state.getSizeFilter()).toBe('eq')
+    expect(state.getSizeValue()).toBe('0')
+    expect(state.getSizeUnit()).toBe('B')
+  })
 })
 
 describe('applyDateFromAi', () => {

apps/desktop/src/lib/query-ui/apply-ai-filters.ts

@@ -17,7 +17,14 @@ import { bytesToSize, type QueryFilterState } from './query-filter-state.svelte'
  */
 export function applySizeFromAi(state: QueryFilterState, min: number | null, max: number | null): boolean {
   if (min == null && max == null) return false
-  if (min != null && max != null) {
+  if (min != null && max != null && min === max) {
+    // Exact size (for example "size = 0" → find empty files): set `eq` so the chip reads
+    // "= N" instead of "between N and N". `eq` is a UI label only (see `SizeFilter`).
+    state.setSizeFilter('eq')
+    const exact = bytesToSize(min)
+    state.setSizeValue(exact.value)
+    state.setSizeUnit(exact.unit)
+  } else if (min != null && max != null) {
     state.setSizeFilter('between')
     const lo = bytesToSize(min)
     const hi = bytesToSize(max)

apps/desktop/src/lib/query-ui/filter-chips/CLAUDE.md

@@ -86,7 +86,8 @@ popover children).
 
 **Size popover** (`SizeFilterPopover.svelte`):
 
-- Col 1: `any`, `≥`, `≤`, `between` (one selected at a time).
+- Col 1: `any`, `≥`, `≤`, `=`, `between` (one selected at a time). `=` is single-bound (like `≥` / `≤`): it shows only
+  cols 2 + 3, never the upper-bound cols.
 - Col 2: `0`, `1`, `5`, `10`, `20`, `50`, `100`, `200`, `500`, `Custom…`. Disabled when col 1 = `any`. Selecting
   `Custom…` reveals an inline `<input type="number">`.
 - Col 3: unit. The "byte(s)" cell label flips based on the selected value. The "kB/KB" cell follows
@@ -150,7 +151,16 @@ Clicking × clears the pattern only; the AI transparency strip stays put.
 ## Gotchas
 
 **Gotcha**: `parseSizeToBytes('0', unit)` is `0`, not `undefined`. The list-style grid lets the user explicitly pick 0
-as a lower or upper bound, so the helper honors it.
+as a lower or upper bound, so the helper honors it. `deriveSizeChip` likewise treats a `0` bound as configured (the
+guard is `>= 0`, not `> 0`); an empty input stays unconfigured because `parseFloat('')` is `NaN`. So "= 0 B" / "≥ 0 B"
+render as real filters.
+
+**Gotcha**: `=` (the `eq` comparator) is a UI/chip-summary concern ONLY, never reaching the matcher's `SizePredicate` or
+any Rust type. Below the chip it's `between` with `sizeMin == sizeMax`: `applySizeQuery` pins both bounds,
+`readSizeFilters` emits `{ sizeMin: x, sizeMax: x }`, and `applyHistoryFilters` rehydrates a stored
+`size_min == size_max` as `eq` (not `between`) by deliberate decision (the two are identical; `= x` is the friendlier
+label, so a stored `between 5–5` returns as `= 5`). `applySizeFromAi` sets `eq` when the AI returns `min == max`. Don't
+add an `eq` kind to `SizePredicate` / `HistoryFilters`.
 
 **Gotcha**: Size unit is `'B' | 'KB' | 'MB' | 'GB'`. The "byte(s)" cell is selectable from the unit column manually; the
 AI translator's `bytesToDisplaySize` still produces `KB | MB | GB`.

apps/desktop/src/lib/query-ui/filter-chips/FilterChips.svelte.test.ts

@@ -396,9 +396,9 @@ describe('SearchFilterChips: scope popover behavior', () => {
     expect(grid).not.toBeNull()
     const cols = grid?.querySelectorAll('.list-col')
     expect(cols?.length).toBe(3) // comparator, lower value, lower unit
-    // Comparator col exposes all 4 options.
+    // Comparator col exposes all 5 options (any / ≥ / ≤ / = / between).
     const compCells = cols?.[0].querySelectorAll('.list-cell')
-    expect(compCells?.length).toBe(4)
+    expect(compCells?.length).toBe(5)
     // Selected comparator is `>=`.
     const selected = grid?.querySelectorAll('.list-cell.is-selected')
     expect(selected?.length).toBeGreaterThanOrEqual(2) // gte + value '5' + unit 'MB'
@@ -471,6 +471,32 @@ describe('SearchFilterChips: scope popover behavior', () => {
     })
   })
 
+  it('Size popover: the `=` (eq) comparator renders, selects, and is single-bound', async () => {
+    clearSearchState()
+    // Render with `eq` already chosen (the prop drives the popover's render).
+    const { target, cleanup } = mountChips(baseProps({ sizeFilter: 'eq', sizeValue: '0', sizeUnit: 'B' }))
+    await tick()
+    findChip(target, 'Size')?.click()
+    await tick()
+    // The `=` comparator cell exists and reads as selected (the prop drives `is-selected`).
+    const compCells = document.querySelectorAll<HTMLButtonElement>('.list-col:nth-child(1) .list-cell')
+    const eqCell = [...compCells].find((b) => b.textContent.trim() === '=')
+    expect(eqCell).not.toBeUndefined()
+    expect(eqCell?.getAttribute('aria-checked')).toBe('true')
+    // `eq` is single-bound: only comparator + lower value + lower unit columns, no upper bound.
+    const cols = document.querySelectorAll('.list-grid .list-col')
+    expect(cols.length).toBe(3)
+    // Clicking the `=` cell writes `eq` to the shared state.
+    eqCell?.click()
+    await tick()
+    const { getSizeFilter } = await import('$lib/search/search-state.svelte')
+    expect(getSizeFilter()).toBe('eq')
+    cleanup()
+    document.querySelectorAll('.filter-chip-popover').forEach((el) => {
+      el.remove()
+    })
+  })
+
   it('R3 U5: clicking a Modified preset while `any` auto-promotes the comparator to `after`', async () => {
     clearSearchState()
     const { target, cleanup } = mountChips(baseProps({ dateFilter: 'any' }))

apps/desktop/src/lib/query-ui/filter-chips/SizeFilterPopover.svelte

@@ -64,6 +64,7 @@
         { value: 'any', label: 'any' },
         { value: 'gte', label: '≥' },
         { value: 'lte', label: '≤' },
+        { value: 'eq', label: '=' },
         { value: 'between', label: 'between' },
     ]
 

apps/desktop/src/lib/query-ui/filter-chips/filter-chip-state.test.ts

@@ -21,8 +21,20 @@ describe('deriveSizeChip', () => {
     expect(deriveSizeChip('gte', '', 'MB', '', 'MB')).toEqual({ configured: false, summary: '' })
   })
 
-  it('returns default when value is zero (treated as "no value yet")', () => {
-    expect(deriveSizeChip('gte', '0', 'MB', '', 'MB')).toEqual({ configured: false, summary: '' })
+  it('treats a zero bound as a real value, not "off" (gte 0)', () => {
+    // `0` is a valid bound (find empty files). Only an empty input (NaN) stays unconfigured.
+    expect(deriveSizeChip('gte', '0', 'B', '', 'B')).toEqual({ configured: true, summary: '> 0 B' })
+  })
+
+  it('treats a zero bound as a real value (lte 0)', () => {
+    expect(deriveSizeChip('lte', '0', 'B', '', 'B')).toEqual({ configured: true, summary: '< 0 B' })
+  })
+
+  it('treats a zero bound as a real value in a between range', () => {
+    expect(deriveSizeChip('between', '0', 'B', '5', 'MB')).toEqual({
+      configured: true,
+      summary: '0 B – 5 MB',
+    })
   })
 
   it('formats a gte filter as "> N UNIT"', () => {
@@ -77,6 +89,28 @@ describe('deriveSizeChip', () => {
   it('format defaults to binary when omitted (back-compat)', () => {
     expect(deriveSizeChip('gte', '100', 'KB', '', 'KB').summary).toBe('> 100 KB')
   })
+
+  it('formats an eq filter as "= N UNIT"', () => {
+    expect(deriveSizeChip('eq', '5', 'MB', '', 'MB')).toEqual({
+      configured: true,
+      summary: '= 5 MB',
+    })
+  })
+
+  it('formats "= 0 B" (find empty files, the headline eq use case)', () => {
+    expect(deriveSizeChip('eq', '0', 'B', '', 'B')).toEqual({
+      configured: true,
+      summary: '= 0 B',
+    })
+  })
+
+  it('eq stays unconfigured until the user types a value', () => {
+    expect(deriveSizeChip('eq', '', 'MB', '', 'MB')).toEqual({ configured: false, summary: '' })
+  })
+
+  it('eq respects the SI / binary kB label', () => {
+    expect(deriveSizeChip('eq', '100', 'KB', '', 'KB', 'si').summary).toBe('= 100 kB')
+  })
 })
 
 describe('deriveDateChip', () => {

apps/desktop/src/lib/query-ui/filter-chips/filter-chip-state.ts

@@ -48,19 +48,22 @@ export function deriveSizeChip(
 
   // A configured filter requires at least the first value (or both, for "between"). The chip
   // stays unconfigured if the user changed the comparator to "gte" but hasn't typed a number yet.
+  // `0` is a real bound (find empty files), so we accept `>= 0`; an empty input is `NaN` and
+  // stays unconfigured.
   const minNumeric = parseFloat(sizeValue)
-  const minOk = !isNaN(minNumeric) && minNumeric > 0
-  if (sizeFilter === 'gte') {
-    if (!minOk) return { configured: false, summary: '' }
-    return { configured: true, summary: `> ${sizeValue.trim()} ${unitLabel}` }
-  }
-  if (sizeFilter === 'lte') {
+  const minOk = !isNaN(minNumeric) && minNumeric >= 0
+
+  // The three single-bound comparators differ only by their prefix glyph.
+  const singleBoundPrefix: Partial<Record<SizeFilter, string>> = { gte: '>', lte: '<', eq: '=' }
+  const prefix = singleBoundPrefix[sizeFilter]
+  if (prefix !== undefined) {
     if (!minOk) return { configured: false, summary: '' }
-    return { configured: true, summary: `< ${sizeValue.trim()} ${unitLabel}` }
+    return { configured: true, summary: `${prefix} ${sizeValue.trim()} ${unitLabel}` }
   }
+
   // between
   const maxNumeric = parseFloat(sizeValueMax)
-  const maxOk = !isNaN(maxNumeric) && maxNumeric > 0
+  const maxOk = !isNaN(maxNumeric) && maxNumeric >= 0
   if (!minOk && !maxOk) return { configured: false, summary: '' }
   if (minOk && !maxOk) return { configured: true, summary: `> ${sizeValue.trim()} ${unitLabel}` }
   if (!minOk && maxOk) return { configured: true, summary: `< ${sizeValueMax.trim()} ${unitMaxLabel}` }

apps/desktop/src/lib/query-ui/query-filter-state.svelte.ts

@@ -22,7 +22,13 @@
 import type { SearchResultEntry, PatternType, SearchQuery, HistoryFilters } from '$lib/tauri-commands'
 export type { PatternType }
 
-export type SizeFilter = 'any' | 'gte' | 'lte' | 'between'
+/**
+ * `eq` is a UI/chip-summary concern only: it round-trips through the matcher and history as
+ * `between` with `sizeMin == sizeMax` (the matcher's `between` already matches exactly one
+ * value). No `SizePredicate` or Rust `HistoryFilters` change carries it. See `applySizeQuery`,
+ * `readSizeFilters`, and `applyHistoryFilters` (which rehydrates `size_min == size_max` as `eq`).
+ */
+export type SizeFilter = 'any' | 'gte' | 'lte' | 'eq' | 'between'
 export type DateFilter = 'any' | 'after' | 'before' | 'between'
 /**
  * Size unit. `B` (bytes) was added in round 2 (D10) so the list-style popover can let the
@@ -101,6 +107,10 @@ export function bytesToSize(bytes: number): { value: string; unit: SizeUnit } {
   if (bytes >= 1024 * 1024) {
     return { value: String(Math.round((bytes / (1024 * 1024)) * 100) / 100), unit: 'MB' }
   }
+  // Sub-kilobyte bounds read as raw bytes ("= 0 B", "512 B") rather than a fractional "0.5 KB".
+  if (bytes < 1024) {
+    return { value: String(bytes), unit: 'B' }
+  }
   return { value: String(Math.round((bytes / 1024) * 100) / 100), unit: 'KB' }
 }
 
@@ -272,6 +282,10 @@ export function createQueryFilterState(options: CreateQueryFilterStateOptions =
       q.minSize = minBytes
     } else if (sizeFilter === 'lte' && minBytes !== undefined) {
       q.maxSize = minBytes
+    } else if (sizeFilter === 'eq' && minBytes !== undefined) {
+      // Exact match: pin both bounds to the same value (the engine's min..max range collapses).
+      q.minSize = minBytes
+      q.maxSize = minBytes
     } else if (sizeFilter === 'between') {
       if (minBytes !== undefined) q.minSize = minBytes
       const maxBytes = parseSizeToBytes(sizeValueMax, sizeUnitMax)
@@ -328,7 +342,14 @@ export function createQueryFilterState(options: CreateQueryFilterStateOptions =
 
     if (!filters) return
 
-    if (filters.sizeMin != null && filters.sizeMax != null) {
+    if (filters.sizeMin != null && filters.sizeMax != null && filters.sizeMin === filters.sizeMax) {
+      // `between x x` and `eq x` match exactly the same set; rehydrate the friendlier `= x`
+      // label (deliberate: there's no stored comparator kind, so we always collapse to eq).
+      sizeFilter = 'eq'
+      const exact = bytesToSize(filters.sizeMin)
+      sizeValue = exact.value
+      sizeUnit = exact.unit
+    } else if (filters.sizeMin != null && filters.sizeMax != null) {
       sizeFilter = 'between'
       const min = bytesToSize(filters.sizeMin)
       const max = bytesToSize(filters.sizeMax)
@@ -366,6 +387,9 @@ export function createQueryFilterState(options: CreateQueryFilterStateOptions =
     const minBytes = parseSizeToBytes(sizeValue, sizeUnit)
     if (sizeFilter === 'gte') return minBytes !== undefined ? { sizeMin: minBytes } : {}
     if (sizeFilter === 'lte') return minBytes !== undefined ? { sizeMax: minBytes } : {}
+    // `eq` persists as `size_min == size_max`; it rehydrates as `eq` (not `between`) in
+    // `applyHistoryFilters` by deliberate decision.
+    if (sizeFilter === 'eq') return minBytes !== undefined ? { sizeMin: minBytes, sizeMax: minBytes } : {}
     const maxBytes = parseSizeToBytes(sizeValueMax, sizeUnitMax)
     const out: { sizeMin?: number; sizeMax?: number } = {}
     if (minBytes !== undefined) out.sizeMin = minBytes

apps/desktop/src/lib/query-ui/query-filter-state.test.ts

@@ -230,6 +230,40 @@ describe('createQueryFilterState: history filters round-trip', () => {
     expect(s.getSizeFilter()).toBe('any')
     expect(s.getSizeValue()).toBe('')
   })
+
+  // `eq` persists as `size_min == size_max` (no Rust comparator field) and, by deliberate
+  // decision, ALWAYS rehydrates as `eq` (not `between`): the two are semantically identical
+  // and `= x` is the friendlier label.
+  it('round-trips an eq filter (persists as min==max, restores as eq)', () => {
+    const s = createQueryFilterState()
+    s.setSizeFilter('eq')
+    s.setSizeValue('5')
+    s.setSizeUnit('MB')
+    const filters = s.readHistoryFilters()
+    expect(filters).toEqual({ sizeMin: 5 * 1024 * 1024, sizeMax: 5 * 1024 * 1024 })
+
+    const fresh = createQueryFilterState()
+    fresh.applyHistoryFilters(filters)
+    expect(fresh.getSizeFilter()).toBe('eq')
+    expect(fresh.getSizeValue()).toBe('5')
+    expect(fresh.getSizeUnit()).toBe('MB')
+    expect(fresh.getSizeValueMax()).toBe('')
+  })
+
+  it('round-trips eq 0 B (find empty files)', () => {
+    const s = createQueryFilterState()
+    s.setSizeFilter('eq')
+    s.setSizeValue('0')
+    s.setSizeUnit('B')
+    const filters = s.readHistoryFilters()
+    expect(filters).toEqual({ sizeMin: 0, sizeMax: 0 })
+
+    const fresh = createQueryFilterState()
+    fresh.applyHistoryFilters(filters)
+    expect(fresh.getSizeFilter()).toBe('eq')
+    expect(fresh.getSizeValue()).toBe('0')
+    expect(fresh.getSizeUnit()).toBe('B')
+  })
 })
 
 describe('createQueryFilterState: factory isolation', () => {

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

@@ -228,7 +228,9 @@
         const hf = selectionQueryState.readHistoryFilters()
         if (f === 'gte') return hf.sizeMin != null ? { kind: 'gte', min: hf.sizeMin } : undefined
         if (f === 'lte') return hf.sizeMax != null ? { kind: 'lte', max: hf.sizeMax } : undefined
-        // between
+        // `between` and `eq` both land here: `eq` reads back as `sizeMin == sizeMax`, and the
+        // matcher's `between` matches exactly one value when the bounds coincide. There's no
+        // separate `eq` predicate kind by design (see `SizeFilter`).
         return { kind: 'between', min: hf.sizeMin ?? undefined, max: hf.sizeMax ?? undefined }
     }