diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 62762c3..a15da08 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -39,9 +39,7 @@
       "Bash(git rm *)",
       "Bash(git show *)"
     ],
-    "deny": [
-      "Write(supabase/migrations/*)"
-    ],
+    "deny": ["Write(supabase/migrations/*)"],
     "defaultMode": "acceptEdits"
   }
 }
diff --git a/src/app/filter_builder.tsx b/src/app/filter_builder.tsx
index 159cdee..404eefe 100644
--- a/src/app/filter_builder.tsx
+++ b/src/app/filter_builder.tsx
@@ -4,10 +4,10 @@ import { MapListStore } from 'app/map_list_presenter';
 import {
   SIMPLE_FIELDS,
   SimpleField,
-  getFieldValue,
+  compileSimpleFilter,
+  filterToSimpleValues,
   isSimpleFilter,
-  setFieldValue,
-  toSimpleFilter,
+  simpleFieldKey,
 } from 'app/filter_modes';
 import { X } from 'lucide-react';
 import { action } from 'mobx';
@@ -56,8 +56,6 @@ const FIELD_LABELS: Record<FilterableField, string> = {
 // dedicated UI land (next PR); today the column is never populated, so the field would match nothing.
 const ALL_FIELDS = filterableFields.filter((f) => f !== 'tags');
 
-const simpleFieldKey = (simpleField: SimpleField) => `${simpleField.field}:${simpleField.op}`;
-
 // Derive each simple field's label from the shared field/op labels so they can't drift; date slots
 // read as "Uploaded before/after" rather than the bare field label.
 const simpleFieldLabel = (simpleField: SimpleField) =>
@@ -70,12 +68,16 @@ const simpleInputType = (simpleField: SimpleField) => {
   if (kind === 'date') {
     return 'date';
   }
-  if (kind === 'number' || kind === 'countable') {
+  if (kind === 'number') {
     return 'number';
   }
+  // `countable` (Difficulties) stays a text input so comma-separated values like "1, 2" can be typed.
   return 'text';
 };
 
+const simpleFieldPlaceholder = (simpleField: SimpleField) =>
+  simpleField.field === 'difficulties' ? 'e.g. 1, 2' : undefined;
+
 export const FilterBuilder = observer((props: { store: MapListStore; onSearch: () => void }) => {
   const { store, onSearch } = props;
   return (
@@ -118,7 +120,7 @@ export const ActiveFilterPills = observer(
 
     const active = SIMPLE_FIELDS.map((simpleField) => ({
       simpleField,
-      value: getFieldValue(store.filter, simpleField),
+      value: store.simpleValues.get(simpleFieldKey(simpleField)) ?? '',
     })).filter(({ value }) => value.trim() !== '');
     if (active.length === 0) {
       return null;
@@ -130,7 +132,7 @@ export const ActiveFilterPills = observer(
             key={simpleFieldKey(simpleField)}
             label={`${simpleFieldLabel(simpleField)}: ${value}`}
             onRemove={action(() => {
-              store.filter = setFieldValue(store.filter, simpleField, '');
+              store.simpleValues.delete(simpleFieldKey(simpleField));
               onSearch();
             })}
           />
@@ -156,8 +158,10 @@ const Pill = (props: { label: string; onRemove: () => void }) => (
 
 const SimpleBuilder = observer((props: { store: MapListStore; onSearch: () => void }) => {
   const { store, onSearch } = props;
+  // Unidirectional: the textboxes own their raw strings in `simpleValues`; only user input writes
+  // them, and they're compiled to the AST only on search (see `MapListStore.activeFilter`).
   const setField = action((simpleField: SimpleField, value: string) => {
-    store.filter = setFieldValue(store.filter, simpleField, value);
+    store.simpleValues.set(simpleFieldKey(simpleField), value);
   });
   return (
     <div className={styles.simple}>
@@ -167,7 +171,8 @@ const SimpleBuilder = observer((props: { store: MapListStore; onSearch: () => vo
           label={simpleFieldLabel(simpleField)}
           error={undefined}
           inputType={simpleInputType(simpleField)}
-          value={getFieldValue(store.filter, simpleField)}
+          placeholder={simpleFieldPlaceholder(simpleField)}
+          value={store.simpleValues.get(simpleFieldKey(simpleField)) ?? ''}
           onChange={(v) => setField(simpleField, v)}
           onSubmit={onSearch}
         />
@@ -398,22 +403,23 @@ const ToggleButton = (props: {
 
 const ModeSwitch = observer((props: { store: MapListStore }) => {
   const { store } = props;
-  // Simple and advanced edit the same AST, so switching to advanced needs no conversion.
   const toAdvanced = action(() => {
+    // Hand the compiled simple filter to advanced mode so the AST it edits matches what was active.
+    store.filter = compileSimpleFilter(store.simpleValues);
     store.filterMode = 'advanced';
   });
   const toSimple = action(() => {
-    if (isSimpleFilter(store.filter)) {
-      store.filterMode = 'simple';
-      return;
-    }
-    const ok = window.confirm(
-      'Switching to simple filters will discard the parts of your filter that simple mode cannot represent. Continue?'
-    );
-    if (ok) {
-      store.filter = toSimpleFilter(store.filter);
-      store.filterMode = 'simple';
+    if (!isSimpleFilter(store.filter)) {
+      const ok = window.confirm(
+        'Switching to simple filters will discard the parts of your filter that simple mode cannot represent. Continue?'
+      );
+      if (!ok) {
+        return;
+      }
     }
+    store.simpleValues = filterToSimpleValues(store.filter);
+    store.filter = undefined;
+    store.filterMode = 'simple';
   });
   return (
     <button
diff --git a/src/app/filter_modes.ts b/src/app/filter_modes.ts
index 9fe56b9..267eaa0 100644
--- a/src/app/filter_modes.ts
+++ b/src/app/filter_modes.ts
@@ -1,132 +1,165 @@
 import { CmpNode, FILTER_FIELDS, FilterNode, FilterOp, FilterableField } from 'schema/map_filter';
 
 /**
- * Simple and advanced filtering differ only in the UI: both edit the same {@link FilterNode}. Simple
- * mode is a constrained editor over a flat `and` of cmps with pre-selected fields, each
- * {@link SimpleField} fixes a `(field, op)` pair so the user only supplies a value. The helpers here
- * read and write those fields on the shared AST.
+ * Simple and advanced filtering differ in their edit model. Advanced mode edits the shared
+ * {@link FilterNode} AST directly. Simple mode is a constrained editor: each {@link SimpleField}
+ * fixes a `(field, op)` pair and owns a raw string the user types, compiled to the AST only on
+ * search ({@link compileSimpleFilter}). A `multi` field treats its value as a comma-separated list
+ * of independent terms OR'd together (e.g. mapper `Foo,Bar`, difficulties `1,2`); comma support is a
+ * property of the field, not the operator (so `description`, also `contains`, stays single-valued).
  */
-export type SimpleField = { field: FilterableField; op: FilterOp };
+export type SimpleField = { field: FilterableField; op: FilterOp; multi?: boolean };
 
 export const SIMPLE_FIELDS: SimpleField[] = [
-  { field: 'artist', op: 'contains' },
-  { field: 'author', op: 'contains' },
+  { field: 'artist', op: 'contains', multi: true },
+  { field: 'author', op: 'contains', multi: true },
   { field: 'description', op: 'contains' },
-  { field: 'difficulties', op: 'count' },
+  { field: 'difficulties', op: 'count', multi: true },
   { field: 'submissionDate', op: 'after' },
   { field: 'submissionDate', op: 'before' },
 ];
 
-const matches = (node: CmpNode, simpleField: SimpleField) =>
-  node.field === simpleField.field && node.op === simpleField.op;
+export const simpleFieldKey = (sf: SimpleField) => `${sf.field}:${sf.op}`;
+
+const matches = (node: CmpNode, sf: SimpleField) => node.field === sf.field && node.op === sf.op;
 
 const simpleFieldOf = (node: CmpNode) => SIMPLE_FIELDS.find((sf) => matches(node, sf));
 
-// The cmp children of a simple-shaped filter (a flat `and`, a bare cmp, or empty/undefined).
-function simpleCmps(filter: FilterNode | undefined): CmpNode[] {
-  if (filter == null) {
-    return [];
+// A simple "slot" is the node holding one field's value: a bare cmp, or - for a `multi` field whose
+// value lists several comma terms - an `or` of cmps that all share the slot's (field, op).
+function slotCmps(node: FilterNode): CmpNode[] | undefined {
+  if (node.type === 'cmp') {
+    return [node];
+  }
+  if (
+    node.type === 'or' &&
+    node.children.length > 0 &&
+    node.children.every((c) => c.type === 'cmp')
+  ) {
+    return node.children as CmpNode[];
+  }
+  return undefined;
+}
+
+// The simple field a slot represents, iff all its cmps share one simple (field, op). An `or` slot is
+// only valid for a `multi` field, since single-valued fields never compile to an OR.
+function slotSimpleField(node: FilterNode): SimpleField | undefined {
+  const cmps = slotCmps(node);
+  if (cmps == null) {
+    return undefined;
   }
-  if (filter.type === 'cmp') {
-    return [filter];
+  const sf = simpleFieldOf(cmps[0]);
+  if (sf == null || !cmps.every((c) => matches(c, sf))) {
+    return undefined;
   }
-  if (filter.type === 'and') {
-    return filter.children.filter((c): c is CmpNode => c.type === 'cmp');
+  if (node.type === 'or' && !sf.multi) {
+    return undefined;
   }
-  return [];
+  return sf;
+}
+
+// The top-level slots of a simple-shaped filter (a flat `and`, a bare slot, or empty/undefined).
+function simpleSlots(filter: FilterNode | undefined): FilterNode[] {
+  if (filter == null) {
+    return [];
+  }
+  return filter.type === 'and' ? filter.children : [filter];
 }
 
 /**
- * True if the node fits simple mode: empty, a bare cmp, or a flat `and` whose children are all
- * distinct simple fields. Anything else (OR/NOT/nesting, other fields/operators, duplicates) needs
- * advanced mode.
+ * True if the node fits simple mode: empty, or a flat `and` (or a bare slot) whose children are all
+ * distinct simple slots - a cmp, or an `or` of comma terms for a `multi` field. Anything else (NOT,
+ * nesting, other fields/operators, duplicate fields) needs advanced mode.
  */
 export function isSimpleFilter(node: FilterNode | undefined): boolean {
   if (node == null) {
     return true;
   }
-  if (node.type !== 'cmp' && node.type !== 'and') {
-    return false;
-  }
-  const children: FilterNode[] = node.type === 'cmp' ? [node] : node.children;
   const seen = new Set<SimpleField>();
-  for (const child of children) {
-    if (child.type !== 'cmp') {
-      return false;
-    }
-    const simpleField = simpleFieldOf(child);
-    if (simpleField == null || seen.has(simpleField)) {
+  for (const slot of simpleSlots(node)) {
+    const sf = slotSimpleField(slot);
+    if (sf == null || seen.has(sf)) {
       return false;
     }
-    seen.add(simpleField);
+    seen.add(sf);
   }
   return true;
 }
 
-export function getFieldValue(filter: FilterNode | undefined, simpleField: SimpleField): string {
-  const cmp = simpleCmps(filter).find((c) => matches(c, simpleField));
-  return cmp == null ? '' : String(cmp.value);
-}
-
 /**
- * Immutably sets (or, for a blank value, clears) a simple field on the filter, returning the rebuilt
- * flat `and`, or undefined when no fields remain. Other fields keep their position.
+ * Compiles the raw simple-field strings into the {@link FilterNode} AST sent to the backend, API and
+ * URL. Run only on search: each field splits on commas when `multi`, trims terms, drops empties,
+ * coerces numeric/countable terms (dropping non-numbers), and is omitted entirely when nothing valid
+ * remains. Several terms become an `or`, a single term a bare cmp. Returns undefined when empty, so
+ * an untouched or all-blank builder behaves like no filter.
  */
-export function setFieldValue(
-  filter: FilterNode | undefined,
-  simpleField: SimpleField,
-  value: string
-): FilterNode | undefined {
-  const children = [...simpleCmps(filter)];
-  const idx = children.findIndex((c) => matches(c, simpleField));
-  if (value.trim() === '') {
-    if (idx >= 0) {
-      children.splice(idx, 1);
-    }
-  } else {
-    // Numeric kinds carry a `number` in the AST; the simple-mode widget hands us its raw string, so
-    // coerce here (the field's blank state was already handled above).
-    const kind = FILTER_FIELDS[simpleField.field].kind;
-    const coerced = kind === 'number' || kind === 'countable' ? Number(value) : value;
-    const cmp: CmpNode = {
-      type: 'cmp',
-      field: simpleField.field,
-      op: simpleField.op,
-      value: coerced,
-    };
-    if (idx >= 0) {
-      children[idx] = cmp;
-    } else {
-      children.push(cmp);
+export function compileSimpleFilter(values: ReadonlyMap<string, string>): FilterNode | undefined {
+  const children: FilterNode[] = [];
+  for (const sf of SIMPLE_FIELDS) {
+    const node = compileSlot(sf, values.get(simpleFieldKey(sf)) ?? '');
+    if (node != null) {
+      children.push(node);
     }
   }
   return children.length === 0 ? undefined : { type: 'and', children };
 }
 
+function compileSlot(sf: SimpleField, raw: string): FilterNode | undefined {
+  const kind = FILTER_FIELDS[sf.field].kind;
+  const numeric = kind === 'number' || kind === 'countable';
+  const terms = sf.multi ? raw.split(',') : [raw];
+  const cmps: CmpNode[] = [];
+  for (const term of terms) {
+    const trimmed = term.trim();
+    if (trimmed === '') {
+      continue;
+    }
+    let value: string | number = trimmed;
+    if (numeric) {
+      const n = Number(trimmed);
+      // The difficulties widget is a text input, so it can hold non-numeric junk; drop those terms.
+      if (!Number.isFinite(n)) {
+        continue;
+      }
+      value = n;
+    }
+    cmps.push({ type: 'cmp', field: sf.field, op: sf.op, value });
+  }
+  if (cmps.length === 0) {
+    return undefined;
+  }
+  return cmps.length === 1 ? cmps[0] : { type: 'or', children: cmps };
+}
+
 /**
- * Best-effort reduction of an arbitrary tree to its simple-representable parts, used when the user
- * switches advanced → simple and accepts discarding the incompatible parts. Keeps the first cmp per
- * simple field; `not` subtrees are dropped since a negated clause has no simple form.
+ * Decompiles a filter back into raw simple-field strings, for URL rehydration and the
+ * advanced -> simple switch. Recognized slots become their field's value (joining a `multi` field's
+ * OR terms with commas); the first occurrence per field wins and anything not simple-representable is
+ * dropped, matching the switch's discard prompt.
  */
-export function toSimpleFilter(node: FilterNode | undefined): FilterNode | undefined {
-  const children: CmpNode[] = [];
-  const seen = new Set<SimpleField>();
+export function filterToSimpleValues(node: FilterNode | undefined): Map<string, string> {
+  const values = new Map<string, string>();
   const visit = (n: FilterNode) => {
-    if (n.type === 'cmp') {
-      const simpleField = simpleFieldOf(n);
-      if (simpleField != null && !seen.has(simpleField)) {
-        seen.add(simpleField);
-        children.push({ ...n });
+    const sf = slotSimpleField(n);
+    if (sf != null) {
+      const key = simpleFieldKey(sf);
+      if (!values.has(key)) {
+        values.set(
+          key,
+          slotCmps(n)!
+            .map((c) => String(c.value))
+            .join(',')
+        );
       }
       return;
     }
-    if (n.type === 'not') {
-      return;
+    // Not a recognized slot: salvage simple cmps from inside groups; drop cmps/NOT we can't represent.
+    if (n.type === 'and' || n.type === 'or') {
+      n.children.forEach(visit);
     }
-    n.children.forEach(visit);
   };
-  if (node) {
+  if (node != null) {
     visit(node);
   }
-  return children.length === 0 ? undefined : { type: 'and', children };
+  return values;
 }
diff --git a/src/app/map_list_presenter.ts b/src/app/map_list_presenter.ts
index 5cfe884..5a7d58c 100644
--- a/src/app/map_list_presenter.ts
+++ b/src/app/map_list_presenter.ts
@@ -1,5 +1,5 @@
 import { Api } from 'app/api/api';
-import { isSimpleFilter } from 'app/filter_modes';
+import { compileSimpleFilter, filterToSimpleValues, isSimpleFilter } from 'app/filter_modes';
 import { checkExists } from 'base/preconditions';
 import { action, computed, observable, runInAction } from 'mobx';
 import { FilterNode, normalizeFilter } from 'schema/map_filter';
@@ -23,9 +23,14 @@ export class MapListStore {
   @observable accessor hasMore = true;
   @observable accessor loadingMore = false;
 
-  /* Filtering. Simple and advanced modes edit this one AST; they differ only in the UI. */
+  /*
+   * Filtering. Simple mode owns a raw string per field in `simpleValues`, compiled to the AST only
+   * on search (see `activeFilter`). Advanced mode edits `filter` (the AST) directly. The two never
+   * share a live edit target.
+   */
   @observable accessor filtersExpanded = false;
   @observable accessor filterMode: FilterMode = 'simple';
+  @observable accessor simpleValues = new Map<string, string>();
   @observable accessor filter: FilterNode | undefined = undefined;
 
   constructor(
@@ -37,15 +42,22 @@ export class MapListStore {
     if (initialFilter == null) {
       return;
     }
-    this.filter = initialFilter;
-    // Open simple mode if the rehydrated filter fits its shape; otherwise advanced.
-    this.filterMode = isSimpleFilter(initialFilter) ? 'simple' : 'advanced';
     this.filtersExpanded = true;
+    // Open simple mode if the rehydrated filter fits its shape (seeding the raw fields); else advanced.
+    if (isSimpleFilter(initialFilter)) {
+      this.simpleValues = filterToSimpleValues(initialFilter);
+      this.filterMode = 'simple';
+    } else {
+      this.filter = initialFilter;
+      this.filterMode = 'advanced';
+    }
   }
 
-  /** The filter as sent to the backend, API and URL: trimmed, with incomplete leaves and empty groups dropped. */
+  /** The filter as sent to the backend, API and URL: simple mode compiles its raw fields; advanced trims its AST. */
   @computed get activeFilter(): FilterNode | undefined {
-    return normalizeFilter(this.filter);
+    return this.filterMode === 'simple'
+      ? compileSimpleFilter(this.simpleValues)
+      : normalizeFilter(this.filter);
   }
 }
 
diff --git a/src/app/tests/filter_modes.unit.test.ts b/src/app/tests/filter_modes.unit.test.ts
index 0851525..9355f8d 100644
--- a/src/app/tests/filter_modes.unit.test.ts
+++ b/src/app/tests/filter_modes.unit.test.ts
@@ -1,16 +1,20 @@
 import { FilterNode } from 'schema/map_filter';
 import {
   SimpleField,
-  getFieldValue,
+  compileSimpleFilter,
+  filterToSimpleValues,
   isSimpleFilter,
-  setFieldValue,
-  toSimpleFilter,
+  simpleFieldKey,
 } from 'app/filter_modes';
 
-const artist: SimpleField = { field: 'artist', op: 'contains' };
-const author: SimpleField = { field: 'author', op: 'contains' };
+const artist: SimpleField = { field: 'artist', op: 'contains', multi: true };
+const author: SimpleField = { field: 'author', op: 'contains', multi: true };
+const description: SimpleField = { field: 'description', op: 'contains' };
+const difficulties: SimpleField = { field: 'difficulties', op: 'count', multi: true };
 const after: SimpleField = { field: 'submissionDate', op: 'after' };
-const difficulties: SimpleField = { field: 'difficulties', op: 'count' };
+
+const values = (entries: [SimpleField, string][]) =>
+  new Map(entries.map(([sf, value]) => [simpleFieldKey(sf), value]));
 
 describe('isSimpleFilter', () => {
   it('treats an empty filter as simple', () => {
@@ -35,11 +39,43 @@ describe('isSimpleFilter', () => {
     ).toBe(true);
   });
 
-  it('rejects OR and NOT nodes', () => {
+  it('accepts an OR of comma terms for a multi field', () => {
+    expect(
+      isSimpleFilter({
+        type: 'and',
+        children: [
+          {
+            type: 'or',
+            children: [
+              { type: 'cmp', field: 'author', op: 'contains', value: 'Foo' },
+              { type: 'cmp', field: 'author', op: 'contains', value: 'Bar' },
+            ],
+          },
+        ],
+      })
+    ).toBe(true);
+  });
+
+  it('rejects an OR for a non-multi field', () => {
     expect(
       isSimpleFilter({
         type: 'or',
-        children: [{ type: 'cmp', field: 'artist', op: 'contains', value: 'a' }],
+        children: [
+          { type: 'cmp', field: 'description', op: 'contains', value: 'a' },
+          { type: 'cmp', field: 'description', op: 'contains', value: 'b' },
+        ],
+      })
+    ).toBe(false);
+  });
+
+  it('rejects an OR mixing fields, and NOT nodes', () => {
+    expect(
+      isSimpleFilter({
+        type: 'or',
+        children: [
+          { type: 'cmp', field: 'artist', op: 'contains', value: 'a' },
+          { type: 'cmp', field: 'author', op: 'contains', value: 'b' },
+        ],
       })
     ).toBe(false);
     expect(
@@ -89,91 +125,132 @@ describe('isSimpleFilter', () => {
   });
 });
 
-describe('getFieldValue / setFieldValue', () => {
-  it('returns an empty string for an absent field', () => {
-    expect(getFieldValue(undefined, artist)).toBe('');
+describe('compileSimpleFilter', () => {
+  it('returns undefined for empty / all-blank fields', () => {
+    expect(compileSimpleFilter(new Map())).toBeUndefined();
+    expect(compileSimpleFilter(values([[artist, '   ']]))).toBeUndefined();
   });
 
-  it('adds a field, building a flat and', () => {
-    const filter = setFieldValue(undefined, artist, 'Smash');
-    expect(filter).toEqual({
+  it('compiles a single term to a bare cmp', () => {
+    expect(compileSimpleFilter(values([[artist, 'Smash']]))).toEqual({
       type: 'and',
       children: [{ type: 'cmp', field: 'artist', op: 'contains', value: 'Smash' }],
     });
-    expect(getFieldValue(filter, artist)).toBe('Smash');
   });
 
-  it('updates an existing field in place without touching others', () => {
-    let filter = setFieldValue(undefined, artist, 'Smash');
-    filter = setFieldValue(filter, after, '2021-01-01');
-    filter = setFieldValue(filter, artist, 'Mouth');
-    expect(filter).toEqual({
+  it('expands a multi text field on commas into an OR, trimming and dropping blanks', () => {
+    expect(compileSimpleFilter(values([[author, 'Foo, , Bar']]))).toEqual({
       type: 'and',
       children: [
-        { type: 'cmp', field: 'artist', op: 'contains', value: 'Mouth' },
-        { type: 'cmp', field: 'submissionDate', op: 'after', value: '2021-01-01' },
+        {
+          type: 'or',
+          children: [
+            { type: 'cmp', field: 'author', op: 'contains', value: 'Foo' },
+            { type: 'cmp', field: 'author', op: 'contains', value: 'Bar' },
+          ],
+        },
       ],
     });
   });
 
-  it('coerces a numeric simple field value to a number in the AST', () => {
-    const filter = setFieldValue(undefined, difficulties, '4');
-    expect(filter).toEqual({
+  it('does not split a non-multi field (comma is literal)', () => {
+    expect(compileSimpleFilter(values([[description, 'a,b']]))).toEqual({
       type: 'and',
-      children: [{ type: 'cmp', field: 'difficulties', op: 'count', value: 4 }],
+      children: [{ type: 'cmp', field: 'description', op: 'contains', value: 'a,b' }],
     });
-    // Reads back as a string for display in the widget.
-    expect(getFieldValue(filter, difficulties)).toBe('4');
   });
 
-  it('clears a field when set to blank, and drops the filter when none remain', () => {
-    let filter = setFieldValue(undefined, artist, 'Smash');
-    filter = setFieldValue(filter, author, 'anon');
-    filter = setFieldValue(filter, artist, '   ');
-    expect(filter).toEqual({
+  it('expands and coerces a multi countable field, dropping non-numeric terms', () => {
+    expect(compileSimpleFilter(values([[difficulties, '1, x, 2']]))).toEqual({
       type: 'and',
-      children: [{ type: 'cmp', field: 'author', op: 'contains', value: 'anon' }],
+      children: [
+        {
+          type: 'or',
+          children: [
+            { type: 'cmp', field: 'difficulties', op: 'count', value: 1 },
+            { type: 'cmp', field: 'difficulties', op: 'count', value: 2 },
+          ],
+        },
+      ],
     });
-    expect(setFieldValue(filter, author, '')).toBeUndefined();
   });
-});
 
-describe('toSimpleFilter', () => {
-  it('collects simple-representable cmps from an OR tree, dropping the rest', () => {
-    const node: FilterNode = {
-      type: 'or',
-      children: [
-        { type: 'cmp', field: 'artist', op: 'contains', value: 'Smash' },
-        { type: 'cmp', field: 'downloadCount', op: 'gte', value: 3 },
-        { type: 'not', child: { type: 'cmp', field: 'author', op: 'contains', value: 'anon' } },
-      ],
-    };
-    // artist is kept; downloadCount (not a slot) and the negated author clause are dropped.
-    expect(toSimpleFilter(node)).toEqual({
+  it('coerces a single countable term to a number', () => {
+    expect(compileSimpleFilter(values([[difficulties, '4']]))).toEqual({
       type: 'and',
-      children: [{ type: 'cmp', field: 'artist', op: 'contains', value: 'Smash' }],
+      children: [{ type: 'cmp', field: 'difficulties', op: 'count', value: 4 }],
     });
   });
 
-  it('keeps the first occurrence per slot', () => {
-    const node: FilterNode = {
+  it('drops a field entirely when no term is valid', () => {
+    expect(compileSimpleFilter(values([[difficulties, 'x, y']]))).toBeUndefined();
+  });
+
+  it('combines several fields into a flat and', () => {
+    expect(
+      compileSimpleFilter(
+        values([
+          [artist, 'Smash'],
+          [after, '2021-01-01'],
+        ])
+      )
+    ).toEqual({
       type: 'and',
       children: [
-        { type: 'cmp', field: 'artist', op: 'contains', value: 'first' },
-        { type: 'cmp', field: 'artist', op: 'contains', value: 'second' },
+        { type: 'cmp', field: 'artist', op: 'contains', value: 'Smash' },
+        { type: 'cmp', field: 'submissionDate', op: 'after', value: '2021-01-01' },
       ],
-    };
-    expect(toSimpleFilter(node)).toEqual({
-      type: 'and',
-      children: [{ type: 'cmp', field: 'artist', op: 'contains', value: 'first' }],
     });
   });
+});
+
+describe('filterToSimpleValues', () => {
+  it('returns an empty map for an empty filter', () => {
+    expect(filterToSimpleValues(undefined)).toEqual(new Map());
+  });
+
+  it('reads a bare cmp slot', () => {
+    expect(
+      filterToSimpleValues({ type: 'cmp', field: 'artist', op: 'contains', value: 'Smash' })
+    ).toEqual(values([[artist, 'Smash']]));
+  });
 
-  it('returns undefined when nothing is representable', () => {
+  it('joins a multi field OR slot with commas', () => {
+    expect(
+      filterToSimpleValues({
+        type: 'and',
+        children: [
+          {
+            type: 'or',
+            children: [
+              { type: 'cmp', field: 'author', op: 'contains', value: 'Foo' },
+              { type: 'cmp', field: 'author', op: 'contains', value: 'Bar' },
+            ],
+          },
+        ],
+      })
+    ).toEqual(values([[author, 'Foo,Bar']]));
+  });
+
+  it('round-trips a compiled multi filter back to its raw values', () => {
+    const raw = values([
+      [author, 'Foo,Bar'],
+      [difficulties, '1,2'],
+    ]);
+    const compiled = compileSimpleFilter(raw);
+    expect(filterToSimpleValues(compiled)).toEqual(raw);
+  });
+
+  it('salvages simple cmps from an advanced tree, dropping the rest and keeping the first per field', () => {
     const node: FilterNode = {
-      type: 'not',
-      child: { type: 'cmp', field: 'artist', op: 'contains', value: 'a' },
+      type: 'or',
+      children: [
+        { type: 'cmp', field: 'artist', op: 'contains', value: 'first' },
+        { type: 'cmp', field: 'artist', op: 'contains', value: 'second' },
+        { type: 'cmp', field: 'downloadCount', op: 'gte', value: 3 },
+        { type: 'not', child: { type: 'cmp', field: 'author', op: 'contains', value: 'anon' } },
+      ],
     };
-    expect(toSimpleFilter(node)).toBeUndefined();
+    expect(filterToSimpleValues(node)).toEqual(values([[artist, 'first']]));
   });
 });
diff --git a/src/services/zapatos/custom/index.d.ts b/src/services/zapatos/custom/index.d.ts
index 88d8fc4..e098079 100644
--- a/src/services/zapatos/custom/index.d.ts
+++ b/src/services/zapatos/custom/index.d.ts
@@ -8,4 +8,4 @@ Released under the MIT licence: see LICENCE file
 */
 
 // this empty declaration appears to fix relative imports in other custom type files
-declare module 'zapatos/custom' { }
+declare module 'zapatos/custom' {}
diff --git a/src/ui/base/textbox/textbox.module.css b/src/ui/base/textbox/textbox.module.css
index 1972698..9c1ea04 100644
--- a/src/ui/base/textbox/textbox.module.css
+++ b/src/ui/base/textbox/textbox.module.css
@@ -1,6 +1,9 @@
 .container {
     display: flex;
     flex-direction: column;
+    /* Allow the box to shrink within flex/grid parents (search row, filter grid) instead of forcing
+       its intrinsic width and overflowing. */
+    min-width: 0;
 }
 
 .textboxBorder {
@@ -23,6 +26,8 @@
 
 .textbox {
     flex: 1;
+    /* Without this the native input's intrinsic width keeps it from shrinking, overflowing the box. */
+    min-width: 0;
     border: none;
     outline: none;
     padding: calc(var(--gridBaseline) * 0.5) var(--gridBaseline);