diff --git a/jbrowse/src/client/JBrowse/VariantSearch/components/FilterForm.tsx b/jbrowse/src/client/JBrowse/VariantSearch/components/FilterForm.tsx
index f24b2e857..6a8346ea0 100644
--- a/jbrowse/src/client/JBrowse/VariantSearch/components/FilterForm.tsx
+++ b/jbrowse/src/client/JBrowse/VariantSearch/components/FilterForm.tsx
@@ -9,7 +9,8 @@ import FormControl from '@mui/material/FormControl';
 import InputLabel from '@mui/material/InputLabel';
 import CardActions from '@mui/material/CardActions';
 import Card from '@mui/material/Card';
-import { FieldModel, Filter, getOperatorsForField, searchStringToInitialFilters } from '../../utils';
+import { FieldModel, Filter, searchStringToInitialFilters } from '../../utils';
+import { OperatorKey, OperatorRegistry } from '../operators';
 import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown';
 import { Box, Menu } from '@mui/material';
 import { styled } from '@mui/material/styles';
@@ -77,19 +78,22 @@ const SubmitAndExternal = styled('div')(({ theme }) => ({
 
 const FilterForm = (props: FilterFormProps ) => {
     const { handleQuery, setFilters, handleClose, fieldTypeInfo, allowedGroupNames, promotedFilters } = props
-    const [filters, localSetFilters] = useState<Filter[]>(searchStringToInitialFilters(fieldTypeInfo.map((x) => x.name)));
+    const initial = searchStringToInitialFilters(fieldTypeInfo.map(x => x.name))
+    const [filters, localSetFilters] = useState<Filter[]>(
+        initial.length ? initial : [ new Filter('', OperatorKey.None, '') ]
+    )
     const [highlightedInputs, setHighlightedInputs] = useState<{ [index: number]: { field: boolean, operator: boolean, value: boolean } }>({});
     const [commonFilterMenuOpen, setCommonFilterMenuOpen] = useState<boolean>(false)
     const buttonRef = React.useRef(null);
 
     const handleAddFilter = () => {
-        localSetFilters([...filters, new Filter()]);
+        localSetFilters([...filters, new Filter('', OperatorKey.None, '')]);
     };
 
     const handleRemoveFilter = (index) => {
         // If it's the last filter, just reset its values to default empty values
         if (filters.length === 1) {
-            localSetFilters([new Filter()]);
+            localSetFilters([new Filter('', OperatorKey.None, '')]);
         } else {
             // Otherwise, remove the filter normally
             localSetFilters(
@@ -100,64 +104,81 @@ const FilterForm = (props: FilterFormProps ) => {
         }
     };
 
-    const handleFilterChange = (index, key, value) => {
-        const newFilters = filters.map((filter, i) => {
-            if (i === index) {
-                const updatedFilter = Object.assign(new Filter(), { ...filter, [key]: value });
-
-                if (key === "operator") {
-                    if (value === "is empty" || value === "is not empty") {
-                        updatedFilter.value = '';
-                    }
-
-                    if (value === "equals one of" || filter.operator === "equals one of") {
-                        updatedFilter.value = ''; 
-                    }
-                }
+    const handleFilterChange = (
+      index: number,
+      key: 'field' | 'operator' | 'value',
+      value: any
+    ) => {
+      const newFilters = filters.map((filter, i) => {
+        if (i !== index) return filter;
+
+        const updatedFilter = Object.assign(
+          new Filter('', OperatorKey.None, ''),
+          { ...filter, [key]: value }
+        );
+
+        if (key === 'field') {
+          const fieldInfo = fieldTypeInfo.find(f => f.name === value);
+          const defaultOp = fieldInfo?.getDefaultOperator() ?? OperatorRegistry[OperatorKey.None];
+          updatedFilter.operator = defaultOp;
+          updatedFilter.value = '';
+        }
+        else if (key === 'operator') {
+          updatedFilter.operator = OperatorRegistry[value as OperatorKey];
+          updatedFilter.value = '';
+        }
 
-                return updatedFilter;
-            }
-            return filter;
-        });
+        return updatedFilter;
+      });
 
-        localSetFilters(newFilters);
+      localSetFilters(newFilters);
     };
 
+
     const handleSubmit = (event) => {
-        event.preventDefault();
-        const highlightedInputs = {};
-
-        filters.forEach((filter, index) => {
-            highlightedInputs[index] = { field: false, operator: false, value: false };
-
-            filter.field = filter.field ?? '';
-            filter.operator = filter.operator ?? '';
-            filter.value = filter.value ?? '';
-
-            if (filter.field === '') {
-                highlightedInputs[index].field = true;
-            }
-
-            if (filter.operator === '') {
-                highlightedInputs[index].operator = true;
-            }
-
-            if (filter.operator === 'is empty' || filter.operator === 'is not empty') {
-                filter.value = '';
-            } else if (filter.value === '') {
-                highlightedInputs[index].value = true;
-            }
-        });
-
-        const isSingleEmptyFilter = filters.length === 1 && !filters[0].field && !filters[0].operator && !filters[0].value;
-
-        setHighlightedInputs(highlightedInputs);
-        if (isSingleEmptyFilter || !Object.values(highlightedInputs).some(v => (v as any).field || (v as any).operator || (v as any).value)) {
-            handleQuery(filters);
-            setFilters(filters);
-            handleClose();
+      event.preventDefault()
+      const highlighted: Record<number, { field: boolean; operator: boolean; value: boolean }> = {}
+
+      filters.forEach((filter, i) => {
+        highlighted[i] = { field: false, operator: false, value: false }
+
+        filter.field = filter.field ?? ''
+        filter.value = filter.value ?? ''
+
+        if (!filter.field) {
+          highlighted[i].field = true
         }
-    };
+
+        if (!filter.operator.key) {
+          highlighted[i].operator = true
+        }
+
+        if (
+          filter.operator.key === OperatorKey.IsEmpty ||
+          filter.operator.key === OperatorKey.IsNotEmpty
+        ) {
+          filter.value = ''
+        } else if (!filter.value) {
+          highlighted[i].value = true
+        }
+      })
+
+      const isSingleEmpty =
+        filters.length === 1 &&
+        !filters[0].field &&
+        !filters[0].operator.key &&
+        !filters[0].value
+
+      setHighlightedInputs(highlighted)
+      if (
+        isSingleEmpty ||
+        !Object.values(highlighted).some(v => v.field || v.operator || v.value)
+      ) {
+        handleQuery(filters)
+        setFilters(filters)
+        handleClose?.()
+      }
+    }
 
     const handleMenuClose = () => {
         setCommonFilterMenuOpen(false)
@@ -241,34 +262,33 @@ const FilterForm = (props: FilterFormProps ) => {
                                     />
                                 </FormControlMinWidth>
 
-                                <FormControlMinWidth sx={ highlightedInputs[index]?.operator ? highlightedSx : null } >
-                                    <InputLabel id="operator-label">Operator</InputLabel>
-                                    <Select
-                                        labelId="operator-label"
-                                        label="Operator"
-                                        value={filter.operator}
-                                        onChange={(event) =>
-                                            handleFilterChange(index, "operator", event.target.value)
-                                        }
-                                    >
-                                        <MenuItem value="None" style={{ display: 'none' }}>
-                                            <em>None</em>
-                                        </MenuItem>
-
-                                        {getOperatorsForField(fieldTypeInfo.find(obj => obj.name === filter.field)) ? (
-                                            getOperatorsForField(fieldTypeInfo.find(obj => obj.name === filter.field)).map((operator) => (
-                                                <MenuItem key={operator} value={operator}>
-                                                    {operator}
-                                                </MenuItem>
-                                            ))
-                                        ) : (
-                                            <MenuItem></MenuItem>
-                                        )}
-
-                                    </Select>
+                                <FormControlMinWidth sx={highlightedInputs[index]?.operator ? highlightedSx : null}>
+                                  <InputLabel id="operator-label">Operator</InputLabel>
+                                  <Select
+                                    labelId="operator-label"
+                                    label="Operator"
+                                    value={filter.operator.key}
+                                    onChange={event =>
+                                      handleFilterChange(index, "operator", event.target.value as OperatorKey)
+                                    }
+                                  >
+                                    <MenuItem value={OperatorKey.None}>
+                                      <em>None</em>
+                                    </MenuItem>
+                                    {(() => {
+                                      const ops = fieldTypeInfo.find(f => f.name === filter.field)?.getOperators() ?? [];
+                                      return ops.length > 0
+                                        ? ops.map(op => (
+                                            <MenuItem key={op.key} value={op.key}>
+                                              {op.label}
+                                            </MenuItem>
+                                          ))
+                                        : <MenuItem />;
+                                    })()}
+                                  </Select>
                                 </FormControlMinWidth>
 
-                                {filter.operator === "equals one of" ? (
+                                {filter.operator.key === OperatorKey.EqualsOneOf ? (
                                     <FormControlMinWidth sx={ highlightedInputs[index]?.value ? highlightedSx : null } >
                                         <InputLabel id="value-select-label">Value</InputLabel>
                                         <Select
@@ -288,13 +308,14 @@ const FilterForm = (props: FilterFormProps ) => {
                                 ) : fieldTypeInfo.find(obj => obj.name === filter.field)?.allowableValues?.length > 1 ? (
                                     <FormControlMinWidth sx={ highlightedInputs[index]?.value ? highlightedSx : null } >
                                         <AsyncSelect
+                                            key={`async-${index}-${filter.operator.key}`}
                                             id={`value-select-${index}`}
                                             inputId={`value-select-${index}`}
                                             aria-labelledby={`value-select-${index}`}
                                             noOptionsMessage={() => 'Type to search...'}
                                             menuPortalTarget={document.body}
                                             menuPosition={'fixed'}
-                                            isDisabled={filter.operator === "is empty" || filter.operator === "is not empty"}
+                                            isDisabled={filter.operator.key === OperatorKey.IsEmpty || filter.operator.key === OperatorKey.IsNotEmpty}
                                             menuShouldBlockScroll={true}
                                             // See here: https://stackoverflow.com/questions/77625507/my-react-project-with-react-18-2-0-version-and-react-select-5-4-0-v
                                             styles={{ menuPortal: (base: any) => ({ ...base, zIndex: 9999 }) }}
@@ -309,8 +330,16 @@ const FilterForm = (props: FilterFormProps ) => {
                                                     .map(value => ({label: value, value}))
                                                 );
                                             }}
-                                            onChange={(selected) => handleFilterChange(index, "value", selected?.length > 0 ? selected.map(s => s.value).join(',') : undefined)}
-                                            value={filter.value ? filter.value.split(',').map(value => ({label: value, value})) : undefined}
+                                            onChange={(selected) => {
+                                                const arr = Array.isArray(selected) ? selected : [selected].filter(Boolean)
+                                                const val = arr.map(s => s.value).join(',')
+                                                handleFilterChange(index, 'value', val)
+                                            }}
+                                            value={
+                                                filter.value
+                                                  ? (filter.value as string).split(',').map(v => ({ label: v, value: v }))
+                                                  : null
+                                              }
                                         />
                                     </FormControlMinWidth>
                                 ) : fieldTypeInfo.find(obj => obj.name === filter.field)?.allowableValues?.length > 0 ? (
@@ -321,7 +350,7 @@ const FilterForm = (props: FilterFormProps ) => {
                                             label="Value"
                                             id={`value-select-${index}`}
                                             value={filter.value}
-                                            disabled={filter.operator === "is empty" || filter.operator === "is not empty"}
+                                            disabled={filter.operator.key === OperatorKey.IsEmpty || filter.operator.key === OperatorKey.IsNotEmpty}
                                             onChange={(event) =>
                                                 handleFilterChange(index, "value", event.target.value)
                                             }
@@ -340,7 +369,7 @@ const FilterForm = (props: FilterFormProps ) => {
                                         sx={ highlightedInputs[index]?.value ? highlightedSx : null }
                                         variant="outlined"
                                         value={filter.value}
-                                        disabled={filter.operator === "is empty" || filter.operator === "is not empty"}
+                                        disabled={filter.operator.key === OperatorKey.IsEmpty || filter.operator.key === OperatorKey.IsNotEmpty}
                                         onChange={(event) =>
                                             handleFilterChange(index, 'value', event.target.value)
                                         }
diff --git a/jbrowse/src/client/JBrowse/VariantSearch/components/VariantTableWidget.tsx b/jbrowse/src/client/JBrowse/VariantSearch/components/VariantTableWidget.tsx
index e3c711e78..8b5b799b4 100644
--- a/jbrowse/src/client/JBrowse/VariantSearch/components/VariantTableWidget.tsx
+++ b/jbrowse/src/client/JBrowse/VariantSearch/components/VariantTableWidget.tsx
@@ -13,6 +13,7 @@ import {
     GridToolbarExport
 } from '@mui/x-data-grid';
 import SearchIcon from '@mui/icons-material/Search';
+import { OperatorKey } from '../operators'
 import LinkIcon from '@mui/icons-material/Link';
 import DownloadIcon from '@mui/icons-material/Download'
 import { ActionURL } from '@labkey/api';
@@ -25,6 +26,7 @@ import { NoAssemblyRegion } from '@jbrowse/core/util/types';
 import { toArray } from 'rxjs/operators';
 import {
     createEncodedFilterString,
+    buildLuceneQuery,
     fetchFieldTypeInfo,
     fetchLuceneQuery,
     FieldModel,
@@ -78,7 +80,7 @@ const VariantTableWidget = observer(props => {
         const { page = pageSizeModel.page, pageSize = pageSizeModel.pageSize } = pageQueryModel;
         const { field = "genomicPosition", sort = false } = sortQueryModel[0] ?? {};
 
-        const encodedSearchString = createEncodedFilterString(passedFilters, false);
+        const encodedSearchString = createEncodedFilterString(passedFilters);
         const currentUrl = new URL(window.location.href);
         currentUrl.searchParams.set("searchString", encodedSearchString);
         currentUrl.searchParams.set("page", page.toString());
@@ -98,7 +100,7 @@ const VariantTableWidget = observer(props => {
     const handleExport = () => {
         const currentUrl = new URL(window.location.href);
 
-        const searchString = createEncodedFilterString(filters, true);
+        const searchString = encodeURIComponent(buildLuceneQuery(filters));
         const sortField = sortModel[0]?.field ?? 'genomicPosition';
         const sortDirection = sortModel[0]?.sort ?? false;
 
@@ -552,14 +554,14 @@ const VariantTableWidget = observer(props => {
             <div style={{ marginBottom: "10px", display: "flex", alignItems: "center" }}>
                 <div style={{ flex: 1 }}>
                     {filters.map((filter, index) => {
-                        if ((filter as any).field && ((filter as any).operator === "is empty" || (filter as any).operator === "is not empty") && !(filter as any).value) {
+                        if ((filter as any).field && ((filter as any).operator.key === OperatorKey.IsEmpty || (filter as any).operator.key === OperatorKey.IsNotEmpty) && !(filter as any).value) {
                             return (
                                 <Button
                                     key={index}
                                     onClick={() => setFilterModalOpen(true)}
                                     style={{ border: "1px solid gray", margin: "5px" }}
                                 >
-                                    {`${(filter as any).field} ${(filter as any).operator}`}
+                                    {`${(filter as any).field} ${(filter as any).operator.key}`}
                                 </Button>
                             );
                         }
@@ -577,7 +579,7 @@ const VariantTableWidget = observer(props => {
                                 key={index}
                                 onClick={() => setFilterModalOpen(true)}
                                 style={{ border: "1px solid gray", margin: "5px" }}                            >
-                                {`${(filter as any).field} ${(filter as any).operator} ${(filter as any).value}`}
+                                {`${(filter as any).field} ${(filter as any).operator.key} ${(filter as any).value}`}
                             </Button>
                         );
                     })}
diff --git a/jbrowse/src/client/JBrowse/VariantSearch/operators.ts b/jbrowse/src/client/JBrowse/VariantSearch/operators.ts
new file mode 100644
index 000000000..928f502de
--- /dev/null
+++ b/jbrowse/src/client/JBrowse/VariantSearch/operators.ts
@@ -0,0 +1,185 @@
+export enum OperatorKey {
+  Equals             = 'equals',
+  NotEquals          = 'does not equal',
+  Contains           = 'contains',
+  NotContains        = 'does not contain',
+  StartsWith         = 'starts with',
+  EndsWith           = 'ends with',
+  IsEmpty            = 'is empty',
+  IsNotEmpty         = 'is not empty',
+  NumericEq          = '=',
+  NumericNeq         = '!=',
+  NumericGt          = '>',
+  NumericGte         = '>=',
+  NumericLt          = '<',
+  NumericLte         = '<=',
+  IsIn             = 'is in',
+  IsNotIn          = 'is not in',
+  IsInAllOf        = 'is in all of',
+  IsInAnyOf        = 'is in any of',
+  IsNotInAnyOf     = 'is not in any of',
+  IsNotInOneOf     = 'is not in one of',
+  EqualsOneOf        = 'equals one of',
+  None              = ''
+}
+
+export type Value = string | number
+
+export interface Operator<T extends Value = Value> {
+  key: OperatorKey
+  label: string
+  generateLucene(field: string, value: T): string
+}
+
+function fuzzyNumRange(field: string, raw: string | number) {
+  const floatValue = parseFloat(String(raw))
+  const intValue   = parseInt(String(raw), 10)
+
+  if (floatValue === intValue) {
+    return `[${intValue} TO ${intValue}]`
+  }
+
+  return `[${floatValue - 0.000001} TO ${floatValue + 0.000001}]`
+}
+
+function fuzzyGtRange(f: string, raw: string | number) {
+  const floatValue = parseFloat(String(raw))
+  const intValue   = parseInt(String(raw), 10)
+  if (floatValue !== intValue) {
+    return `${f}:[${floatValue + 0.000001} TO *]`
+  }
+  return `${f}:{${intValue} TO *]`
+}
+
+function fuzzyLtRange(f: string, raw: string | number) {
+  const floatValue = parseFloat(String(raw))
+  const intValue   = parseInt(String(raw), 10)
+  if (floatValue !== intValue) {
+    return `${f}:[* TO ${floatValue - 0.000001}]`
+  }
+  return `${f}:[* TO ${intValue}}`
+}
+
+export const OperatorRegistry: Record<OperatorKey, Operator> = {
+  [OperatorKey.Equals]: {
+    key: OperatorKey.Equals,
+    label: 'Equals',
+    generateLucene: (f, v: string) => `${f}:${v}`,
+  },
+  [OperatorKey.NotEquals]: {
+    key: OperatorKey.NotEquals,
+    label: 'Does Not Equal',
+    generateLucene: (f, v: string) => `*:* -${f}:${v}`,
+  },
+  [OperatorKey.Contains]: {
+    key: OperatorKey.Contains,
+    label: 'Contains',
+    generateLucene: (f, v: string) => `${f}:*${v}*`,
+  },
+  [OperatorKey.NotContains]: {
+    key: OperatorKey.NotContains,
+    label: 'Does Not Contain',
+    generateLucene: (f, v: string) => `*:* -${f}:*${v}*`,
+  },
+  [OperatorKey.StartsWith]: {
+    key: OperatorKey.StartsWith,
+    label: 'Starts With',
+    generateLucene: (f, v: string) => `${f}:${v}*`,
+  },
+  [OperatorKey.EndsWith]: {
+    key: OperatorKey.EndsWith,
+    label: 'Ends With',
+    generateLucene: (f, v: string) => `${f}:*${v}`,
+  },
+  [OperatorKey.IsEmpty]: {
+    key: OperatorKey.IsEmpty,
+    label: 'Is Empty',
+    generateLucene: (f) => `*:* -${f}:*`,
+  },
+  [OperatorKey.IsNotEmpty]: {
+    key: OperatorKey.IsNotEmpty,
+    label: 'Is Not Empty',
+    generateLucene: (f) => `${f}:*`,
+  },
+  [OperatorKey.NumericEq]: {
+    key: OperatorKey.NumericEq,
+    label: '=',
+    generateLucene: (f, v: number) =>
+      Number.isInteger(v) ? `${f}:[${v} TO ${v}]` : `${f}:${fuzzyNumRange(f, v)}`,
+  },
+  [OperatorKey.NumericNeq]: {
+    key: OperatorKey.NumericNeq,
+    label: '!=',
+    generateLucene: (f, v: number) => {
+      if (Number.isInteger(v)) {
+        return `*:* -${f}:[${v} TO ${v}]`
+      }
+      const range = fuzzyNumRange(f, v)
+      return `*:* -${f}:${range}`
+    },
+  },
+  [OperatorKey.NumericGt]: {
+    key: OperatorKey.NumericGt,
+    label: '>',
+    generateLucene: fuzzyGtRange,
+  },
+  [OperatorKey.NumericGte]: {
+    key: OperatorKey.NumericGte,
+    label: '>=',
+    generateLucene: (f, v: number) => `${f}:[${v} TO *]`,
+  },
+  [OperatorKey.NumericLt]: {
+    key: OperatorKey.NumericLt,
+    label: '<',
+    generateLucene: fuzzyLtRange,
+  },
+  [OperatorKey.NumericLte]: {
+    key: OperatorKey.NumericLte,
+    label: '<=',
+    generateLucene: (f, v: number) => `${f}:[* TO ${v}]`,
+  },
+  [OperatorKey.EqualsOneOf]: {
+    key: OperatorKey.EqualsOneOf,
+    label: 'Equals One Of',
+    generateLucene: (f, v: string) => `${f}:~${v}~`,
+  },
+ [OperatorKey.IsIn]: {
+    key: OperatorKey.IsIn,
+    label: 'Is In',
+    generateLucene: (f, v: string) => `${f}:${v}`,
+  },
+  [OperatorKey.IsNotIn]: {
+    key: OperatorKey.IsNotIn,
+    label: 'Is Not In',
+    generateLucene: (f, v: string) => `*:* -${f}:${v}`,
+  },
+  [OperatorKey.IsInAllOf]: {
+    key: OperatorKey.IsInAllOf,
+    label: 'Is In All Of',
+    generateLucene: (f, v: string) =>
+      v.split(',').map(val => `+${f}:${val}`).join(' '),
+  },
+  [OperatorKey.IsInAnyOf]: {
+    key: OperatorKey.IsInAnyOf,
+    label: 'Is In Any Of',
+    generateLucene: (f, v: string) =>
+      v.split(',').map(val => `${f}:${val}`).join(' OR '),
+  },
+  [OperatorKey.IsNotInAnyOf]: {
+    key: OperatorKey.IsNotInAnyOf,
+    label: 'Is Not In Any Of',
+    generateLucene: (f, v: string) =>
+      v.split(',').map(val => `*:* -${f}:${val}`).join(' AND '),
+  },
+  [OperatorKey.IsNotInOneOf]: {
+    key: OperatorKey.IsNotInOneOf,
+    label: 'Is Not In One Of',
+    generateLucene: (f, v: string) =>
+      v.split(',').map(val => `*:* -${f}:${val}`).join(' OR '),
+  },
+  [OperatorKey.None]: {
+    key: OperatorKey.None,
+    label: '',
+    generateLucene: () => ''
+  }
+}
\ No newline at end of file
diff --git a/jbrowse/src/client/JBrowse/utils.ts b/jbrowse/src/client/JBrowse/utils.ts
index 0cbe2d0cd..75fa6a195 100644
--- a/jbrowse/src/client/JBrowse/utils.ts
+++ b/jbrowse/src/client/JBrowse/utils.ts
@@ -12,6 +12,7 @@ import {
 } from '@mui/x-data-grid';
 import { ParsedLocString, parseLocString } from '@jbrowse/core/util';
 import { VcfFeature } from '@jbrowse/plugin-variants';
+import { Operator, OperatorKey, OperatorRegistry, Value } from './VariantSearch/operators'
 
 export function arrayMax(array) {
     return Array.isArray(array) ? Math.max(...array) : array
@@ -239,7 +240,7 @@ export function navigateToSearch(sessionId, locString, trackId, isValidRefNameFo
         const start = parsedLocString.start;
         const end = parsedLocString.end;
 
-        searchString = serializeLocationToLuceneQuery(contig, start, end)
+        searchString = serializeLocationToEncodedSearchString(contig, start, end)
     }
 
     window.location.href = ActionURL.buildURL("jbrowse", "variantSearch.view", null, {session: sessionId, location: locString, trackId: trackId, activeTracks: trackId, sampleFilters: sampleFilterURL, infoFilters: infoFilterURL, searchString: searchString})
@@ -317,106 +318,14 @@ export function getGenotypeURL(trackId, contig, start, end) {
     return ActionURL.buildURL("jbrowse", "genotypeTable.view", null, {trackId: trackId, chr: contig, start: start, stop: end})
 }
 
-export function serializeLocationToLuceneQuery(contig, start, end) {
+export function serializeLocationToEncodedSearchString(contig, start, end) {
     const filters = [
-        {field: "contig", operator: "equals", value: contig.toString()},
-        {field: "start", operator: ">=", value: start.toString()},
-        {field: "end", operator: "<=", value: end.toString()}
+        new Filter("contig", OperatorKey.Equals, contig.toString()),
+        new Filter("start", OperatorKey.NumericGte, start.toString()),
+        new Filter("end", OperatorKey.NumericLte, end.toString())
     ]
 
-    return createEncodedFilterString(filters, false)
-}
-
-function generateLuceneString(field, operator, value) {
-  let luceneQueryString = '';
-
-  if (field === 'variableSamples' && operator == "equals one of") {
-    return `variableSamples:~${value}~`;
-  }
-  let intValue = parseInt(value);
-  let floatValue = parseFloat(value);
-
-  // Generate Lucene query string based on operator and type of value
-  switch (operator) {
-    case '=': // Exact match for numeric fields
-        luceneQueryString = floatValue !== intValue 
-            ? `${field}:[${Number(value) - 0.000001} TO ${Number(value) + 0.000001}]`
-            : `${field}:[${value} TO ${value}]`;
-        break;
-    case '!=': // Not equal to, for numeric fields
-        luceneQueryString = floatValue !== intValue 
-            ? `${field}:[* TO ${Number(value) - 0.000001}] OR ${field}:[${Number(value) + 0.000001} TO *]` 
-            : `${field}:[* TO ${value}} OR ${field}:{${value} TO *]`;
-        break;
-    case '>': // Greater than for numeric fields
-        luceneQueryString = floatValue !== intValue 
-            ? `${field}:[${Number(value) + 0.000001} TO *]`
-            : `${field}:{${value} TO *]`;
-        break;
-    case '>=': // Greater than or equal to for numeric fields
-        luceneQueryString = `${field}:[${value} TO *]`;
-        break;
-    case '<': // Less than for numeric fields
-        luceneQueryString = floatValue !== intValue 
-            ? `${field}:[* TO ${Number(value) - 0.000001}]`
-            : `${field}:[* TO ${value}}`;
-        break;
-    case '<=': // Less than or equal to for numeric fields
-        luceneQueryString = `${field}:[* TO ${value}]`;
-        break;
-    case 'equals': // Exact match for string fields
-        luceneQueryString = `${field}:${value}`;
-        break;
-    case 'contains': // Substring search for string fields
-        luceneQueryString = `${field}:*${value}*`;
-        break;
-    case 'does not equal': // Not equal to for string fields
-        luceneQueryString = `*:* -${field}:${value}`;
-        break;
-    case 'does not contain': // Does not contain for string fields
-        luceneQueryString = `*:* -${field}:*${value}*`;
-        break;
-    case 'starts with': // Starts with for string fields
-        luceneQueryString = `${field}:${value}*`;
-        break;
-    case 'ends with': // Ends with for string fields
-        luceneQueryString = `${field}:*${value}`;
-        break;
-    case 'is empty': // Field is empty
-        luceneQueryString = `*:* -${field}:*`;
-        break;
-    case 'is not empty': // Field is not empty
-        luceneQueryString = `${field}:*`;
-        break;
-    case 'variable in': // Variable in for multi-valued fields
-        luceneQueryString = `${field}:${value}`;
-        break;
-    case 'not variable in': // Not variable in for multi-valued fields
-        luceneQueryString = `*:* -${field}:${value}`;
-        break;
-    default:
-        // Operators that require multiple values
-        const values = value.split(',');
-
-        switch (operator) {
-        case 'variable in all of': // Variable in all of the provided values
-            luceneQueryString = values.map(v => `+${field}:${v}`).join(' ');
-            break;
-        case 'variable in any of': // Variable in any of the provided values
-            luceneQueryString = values.map(v => `${field}:${v}`).join(' OR ');
-            break;
-        case 'not variable in any of': // Not variable in any of the provided values
-            luceneQueryString = values.map(v => `*:* -${field}:${v}`).join(' AND ');
-            break;
-        case 'not variable in one of': // Not variable in one of the provided values
-            luceneQueryString = values.map(v => `*:* -${field}:${v}`).join(' OR ');
-            break;
-        default:
-            throw new Error(`Invalid operator: ${operator}`);
-        }
-    }
-
-  return luceneQueryString;
+    return createEncodedFilterString(filters)
 }
 
 export async function fetchLuceneQuery(filters, sessionId, trackGUID, offset, pageSize, sortField, sortReverseString, successCallback, failureCallback) {
@@ -439,6 +348,9 @@ export async function fetchLuceneQuery(filters, sessionId, trackGUID, offset, pa
         return
     }
 
+    const lucene = buildLuceneQuery(filters)
+    const encoded = encodeURIComponent(lucene)
+
     let sortReverse;
     if(sortReverseString == "asc") {
         sortReverse = true
@@ -457,7 +369,7 @@ export async function fetchLuceneQuery(filters, sessionId, trackGUID, offset, pa
             failureCallback("There was an error: " + res.status + "\n Status Body: " + res.responseText + "\n Session ID:" + sessionId)
         },
         params: {
-            "searchString": createEncodedFilterString(filters, true),
+            "searchString": encoded,
             "sessionId": sessionId,
             "trackId": trackGUID,
             "offset": offset,
@@ -468,23 +380,6 @@ export async function fetchLuceneQuery(filters, sessionId, trackGUID, offset, pa
     });
 }
 
-export function createEncodedFilterString(filters: Array<{field: string; operator: string; value: string}>, lucenify: boolean) {
-    let ret: any = []
-
-    if(!filters || filters.length == 0 || (filters.length == 1 && filters[0].field == "" && filters[0].operator == "" && filters[0].value == "")) {
-        return "all"
-    }
-
-    if(lucenify) {
-        ret = filters.map(val => generateLuceneString(val.field, val.operator, val.value));
-    } else {
-        ret = filters.map(val => val.field + "," + val.operator + "," + val.value)
-    }
-    const concatenatedString = ret.join('&');
-
-    return encodeURIComponent(concatenatedString.replace(/\+/g, "%2B"));
-}
-
 export class FieldModel {
     name: string
     label: string
@@ -501,6 +396,7 @@ export class FieldModel {
     url: string
     flex: number
     supportsFilter: boolean = true
+    defaultOperator: string
 
     getLabel(): string {
         return this.label ?? this.name
@@ -525,6 +421,58 @@ export class FieldModel {
         return muiFieldType
     }
 
+    getOperators(): Operator[] {
+        if (this.name === 'variableSamples') {
+          return [
+            OperatorKey.EqualsOneOf,
+            OperatorKey.IsIn,
+            OperatorKey.IsNotIn,
+            OperatorKey.IsInAllOf,
+            OperatorKey.IsInAnyOf,
+            OperatorKey.IsNotInAnyOf,
+            OperatorKey.IsNotInOneOf,
+            OperatorKey.IsEmpty,
+            OperatorKey.IsNotEmpty,
+          ].map(k => OperatorRegistry[k])
+        }
+
+        switch (this.type) {
+          case 'String':
+          case 'Flag':
+          case 'Character':
+          case 'Impact':
+            return [
+              OperatorKey.Equals,
+              OperatorKey.NotEquals,
+              OperatorKey.Contains,
+              OperatorKey.NotContains,
+              OperatorKey.StartsWith,
+              OperatorKey.EndsWith,
+              OperatorKey.IsEmpty,
+              OperatorKey.IsNotEmpty,
+            ].map(k => OperatorRegistry[k])
+
+          case 'Float':
+          case 'Integer':
+            return [
+              OperatorKey.NumericEq,
+              OperatorKey.NumericNeq,
+              OperatorKey.NumericGt,
+              OperatorKey.NumericGte,
+              OperatorKey.NumericLt,
+              OperatorKey.NumericLte,
+            ].map(k => OperatorRegistry[k])
+
+          default:
+            return []
+        }
+    }
+
+    getDefaultOperator(): Operator | undefined {
+        if (this.defaultOperator && this.defaultOperator != "") return OperatorRegistry[this.defaultOperator]
+        return this.getOperators()[0]
+    }
+
     toGridColDef(): GridColDef {
         let gridCol: GridColDef = {
             field: this.name,
@@ -562,6 +510,19 @@ export class FieldModel {
     }
 }
 
+export function createEncodedFilterString(filters: Filter[]): string {
+    if (!filters.length || filters.every(f => f.isEmpty())) return 'all'
+    return encodeURIComponent(filters.map(f => f.encode()).join('&'))
+}
+
+export function buildLuceneQuery(filters: Filter[]): string {
+  if (!filters.length || filters.every(f => f.isEmpty())) return 'all'
+  return filters
+      .filter(f => !f.isEmpty())
+      .map(f => f.toLucene())
+      .join('&')
+}
+
 export async function fetchFieldTypeInfo(sessionId: string, trackId: string, successCallback: (fields: FieldModel[], groups: string[], promotedFilters: Map<string, Filter[]>) => void, failureCallback) {
     if (!sessionId || !trackId) {
         console.error("Cannot fetch field type info: sessionId or trackId not provided")
@@ -601,46 +562,45 @@ export function truncateToValidGUID(str: string) {
     return str;
 }
 
-export declare type FilterType = {
-    field: string,
-    value: any,
-    operator: string
-}
+export class Filter {
+  field: string
+  operator: Operator
+  value: Value
 
-export class Filter implements FilterType {
-    field: string = ""
-    value: any = ""
-    operator: string = ""
-
-    encode(): string {
-        return [this.field, this.operator, this.value].join(',')
-    }
+  constructor(field: string, operatorKey: OperatorKey, value: Value) {
+    this.field = field
+    this.operator = OperatorRegistry[operatorKey]
+    this.value = value
+  }
 
-    isEmpty(): boolean {
-        return !!this.field
-    }
+  encode(): string {
+    return [this.field, this.operator.key, this.value].join(',')
+  }
 
-    static fromString(str: string): Filter[] {
-        const decodedSearchString = decodeURIComponent(str)
-        const searchStringsArray = decodedSearchString.split("&").filter((x) => x !== "all")
+  toLucene(): string {
+    return this.operator.generateLucene(this.field, this.value as any)
+  }
 
-        return searchStringsArray.map((item) => {
-            const parts = item.split(",");
-            const field = parts[0];
-            const operator = parts[1];
-            const value = parts.slice(2).join(",");
-            return Object.assign(new Filter(), { field: field, operator: operator, value: value })
-        })
-    }
+  isEmpty(): boolean {
+    return this.field === ''
+  }
 
-    static deduplicate(filters: Filter[]): Filter[] {
-        const filterMap = {}
-        filters.forEach((f) => {
-            filterMap[f.encode()] = f
-        })
+  static fromString(str: string): Filter[] {
+    const decoded = decodeURIComponent(str)
+    return decoded
+      .split('&')
+      .filter(x => x !== 'all')
+      .map(item => {
+        const [field, opKey, ...valParts] = item.split(',')
+        const value = valParts.join(',')
+        return new Filter(field, opKey as OperatorKey, isNaN(Number(value)) ? value : Number(value))
+      })
+  }
 
-        return Object.keys(filterMap).map((key) => filterMap[key])
-    }
+  static deduplicate(filters: Filter[]): Filter[] {
+    const map = new Map(filters.map(f => [f.encode(), f]))
+    return Array.from(map.values())
+  }
 }
 
 export function searchStringToInitialFilters(knownFieldNames: string[]) : Filter[] {
@@ -651,49 +611,9 @@ export function searchStringToInitialFilters(knownFieldNames: string[]) : Filter
         return Filter.fromString(searchString).filter(({ field }) => knownFieldNames.includes(field))
     }
 
-    return [new Filter()]
+    return []
 }
 
-export function getOperatorsForField(fieldObj: FieldModel): string[] {
-    const stringOperators = ["equals", "does not equal", "contains", "does not contain", "starts with", "ends with", "is empty", "is not empty"];
-    const variableSamplesType = ["equals one of", "variable in", "not variable in", "variable in all of", "variable in any of", "not variable in any of", "not variable in one of", "is empty", "is not empty"];
-    const numericOperators = ["=", "!=", ">", ">=", "<", "<="];
-    const noneOperators = [];
-
-    // This can occur for the blank placeholder field:
-    if (!fieldObj) {
-        return[]
-    }
-
-    const field = fieldObj.name;
-    const type = fieldObj.type;
-
-    let allowedOperators;
-    switch (type) {
-        case 'Flag':
-        case 'String':
-        case 'Character':
-            allowedOperators = stringOperators;
-            break;
-        case 'Float':
-        case 'Integer':
-            allowedOperators = numericOperators;
-            break;
-        case 'Impact':
-            allowedOperators = stringOperators;
-            break;
-        case 'None':
-        default:
-            allowedOperators = noneOperators;
-            break;
-    }
-
-    if (field === "variableSamples") {
-        return variableSamplesType
-    }
-
-    return allowedOperators
-}
 
 export const multiValueComparator: GridComparatorFn = (v1, v2) => {
     return arrayMax(parseCellValue(v1)) - arrayMax(parseCellValue(v2))
diff --git a/jbrowse/test/src/org/labkey/test/tests/external/labModules/JBrowseTest.java b/jbrowse/test/src/org/labkey/test/tests/external/labModules/JBrowseTest.java
index 8ef002a10..9ee4094ac 100644
--- a/jbrowse/test/src/org/labkey/test/tests/external/labModules/JBrowseTest.java
+++ b/jbrowse/test/src/org/labkey/test/tests/external/labModules/JBrowseTest.java
@@ -1617,7 +1617,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "equals one of")).click();
+        waitForElement(Locator.tagWithText("li", "Equals One Of")).click();
         waitForElement(Locator.tagWithId("div", "value-select-0")).click();
         waitForElement(Locator.tagWithText("li", "!TestGroup!")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
@@ -1629,87 +1629,87 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "variable in")).click();
+        waitForElement(Locator.tagWithText("li", "Is In")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m00001");
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys(Keys.ENTER);
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "0.553"));
-        clearFilterDialog("variableSamples variable in m00001");
+        clearFilterDialog("variableSamples is in m00001");
 
         // VariableSamples not variable in m05710
         waitAndClick(Locator.tagWithText("button", "Search"));
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "not variable in")).click();
+        waitForElement(Locator.tagWithText("li", "Is Not In")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m05710");
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys(Keys.ENTER);
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElementToDisappear(Locator.tagWithText("span", "3.277E-4"));
-        clearFilterDialog("variableSamples not variable in m05710");
+        clearFilterDialog("variableSamples is not in m05710");
 
         // VariableSamples li usage + variable in all of
         waitAndClick(Locator.tagWithText("button", "Search"));
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "variable in all of")).click();
+        waitForElement(Locator.tagWithText("li", "Is In All Of")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m000");
         waitForElement(Locator.tagWithText("div", "m00005")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m000");
         waitForElement(Locator.tagWithText("div", "m00004")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "0.3"));
-        clearFilterDialog("variableSamples variable in all of m00005,m00004");
+        clearFilterDialog("variableSamples is in all of m00005,m00004");
 
         // VariableSamples variable in any of m00004,m00007
         waitAndClick(Locator.tagWithText("button", "Search"));
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "variable in any of")).click();
+        waitForElement(Locator.tagWithText("li", "Is In Any Of")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m000");
         waitForElement(Locator.tagWithText("div", "m00004")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m000");
         waitForElement(Locator.tagWithText("div", "m00007")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "2"));
-        clearFilterDialog("variableSamples variable in any of m00004,m00007");
+        clearFilterDialog("variableSamples is in any of m00004,m00007");
 
         // VariableSamples not variable in any of m00005,m00004
         waitAndClick(Locator.tagWithText("button", "Search"));
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "not variable in any of")).click();
+        waitForElement(Locator.tagWithText("li", "Is Not In Any Of")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m000");
         waitForElement(Locator.tagWithText("div", "m00005")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m000");
         waitForElement(Locator.tagWithText("div", "m00004")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElementToDisappear(Locator.tagWithText("span", "2"));
-        clearFilterDialog("variableSamples not variable in any of m00005,m00004");
+        clearFilterDialog("variableSamples is not in any of m00005,m00004");
 
         // VariableSamples not variable in one of m03660,m00001
         waitAndClick(Locator.tagWithText("button", "Search"));
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "not variable in one of")).click();
+        waitForElement(Locator.tagWithText("li", "Is Not In One Of")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m036");
         waitForElement(Locator.tagWithText("div", "m03660")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("m000");
         waitForElement(Locator.tagWithText("div", "m00001")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElementToDisappear(Locator.tagWithText("span", "609"));
-        clearFilterDialog("variableSamples not variable in one of m03660,m00001");
+        clearFilterDialog("variableSamples is not in one of m03660,m00001");
 
         // samples with variant isEmpty
         waitAndClick(Locator.tagWithText("button", "Search"));
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Samples With Variant"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "is empty")).click();
+        waitForElement(Locator.tagWithText("li", "Is Empty")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElementToDisappear(Locator.tagWithText("span", "2"));
         clearFilterDialog("variableSamples is empty");
@@ -1786,7 +1786,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Ref Allele"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "equals")).click();
+        waitForElement(Locator.tagWithText("li", "Equals")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("GAAAA");
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "4506"));
@@ -1798,7 +1798,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Impact on Protein Coding"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "equals")).click();
+        waitForElement(Locator.tagWithText("li", "Equals")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("HI");
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys(Keys.ENTER);
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
@@ -1811,7 +1811,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Ref Allele"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "does not equal")).click();
+        waitForElement(Locator.tagWithText("li", "Does Not Equal")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("A");
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "711"));
@@ -1823,7 +1823,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Alt Allele"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "contains")).click();
+        waitForElement(Locator.tagWithText("li", "Contains")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("TT");
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "22559"));
@@ -1835,7 +1835,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Alt Allele"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "does not contain")).click();
+        waitForElement(Locator.tagWithText("li", "Does Not Contain")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("T");
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElementToDisappear(Locator.tagWithText("span", "2"));
@@ -1847,7 +1847,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Ref Allele"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "starts with")).click();
+        waitForElement(Locator.tagWithText("li", "Starts With")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("GA");
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "14716"));
@@ -1859,7 +1859,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Ref Allele"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "ends with")).click();
+        waitForElement(Locator.tagWithText("li", "Ends With")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("AAA");
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "4506"));
@@ -1870,7 +1870,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Alt Allele"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "is empty")).click();
+        waitForElement(Locator.tagWithText("li", "Is Empty")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "18235"));
         clearFilterDialog("alt is empty");
@@ -1880,7 +1880,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Impact on Protein Coding"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "is not empty")).click();
+        waitForElement(Locator.tagWithText("li", "Is Not Empty")).click();
         waitAndClick(Locator.tagWithClass("button", "filter-form-select-button"));
         waitForElement(Locator.tagWithText("span", "914"));
         clearFilterDialog("IMPACT is not empty");
@@ -1890,7 +1890,7 @@ private void testLuceneSearchUI(String sessionId)
         waitForElement(Locator.tagWithAttribute("input", "aria-labelledby", "field-label")).click();
         waitForElement(Locator.tagWithAttribute("div", "role", "listbox").child(Locator.tagWithText("div", "Impact on Protein Coding"))).click();
         waitForElement(Locator.tagWithAttribute("div", "aria-labelledby", "operator-label")).click();
-        waitForElement(Locator.tagWithText("li", "equals")).click();
+        waitForElement(Locator.tagWithText("li", "Equals")).click();
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("HI");
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys(Keys.ENTER);
         waitForElement(Locator.tagWithId("input", "value-select-0")).sendKeys("MO");