@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/store/slices/searchSlice.test.ts

@@ -0,0 +1,342 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { createStore, type StoreApi } from 'zustand/vanilla';
+import { createSearchSlice, type SearchSlice } from './searchSlice.js';
+import type { SearchResult } from '@/lib/search/tier0-scan';
+
+function makeResult(modelId: string, expressId: number, name: string): SearchResult {
+  return {
+    modelId,
+    expressId,
+    typeName: 'IfcWall',
+    name,
+    globalId: `g${String(expressId).padStart(21, 'x')}`,
+    description: '',
+    objectType: '',
+    matchField: 'name',
+    score: 100,
+  };
+}
+
+describe('searchSlice — vim cycle', () => {
+  let store: StoreApi<SearchSlice>;
+  const rs = (name: string, id: number): SearchResult => makeResult('m', id, name);
+
+  beforeEach(() => {
+    store = createStore<SearchSlice>((set, get, api) => createSearchSlice(set, get, api));
+  });
+
+  it('is inactive by default', () => {
+    assert.strictEqual(store.getState().searchVimCycle, null);
+  });
+
+  it('enters with a frozen results snapshot and clamped index', () => {
+    const results = [rs('a', 1), rs('b', 2), rs('c', 3)];
+    store.getState().enterVimCycle('wall', results, 1);
+    const cycle = store.getState().searchVimCycle;
+    assert.ok(cycle);
+    assert.strictEqual(cycle!.query, 'wall');
+    assert.strictEqual(cycle!.index, 1);
+    assert.strictEqual(cycle!.results, results, 'snapshot is the same reference');
+  });
+
+  it('clamps entry index into range', () => {
+    const results = [rs('a', 1), rs('b', 2)];
+    store.getState().enterVimCycle('w', results, 99);
+    assert.strictEqual(store.getState().searchVimCycle!.index, 1);
+
+    store.getState().enterVimCycle('w', results, -5);
+    assert.strictEqual(store.getState().searchVimCycle!.index, 0);
+  });
+
+  it('no-ops when called with an empty results list', () => {
+    store.getState().enterVimCycle('w', [], 0);
+    assert.strictEqual(store.getState().searchVimCycle, null);
+  });
+
+  it('step +1 advances; step -1 retreats; both wrap around', () => {
+    const results = [rs('a', 1), rs('b', 2), rs('c', 3)];
+    store.getState().enterVimCycle('w', results, 0);
+
+    store.getState().stepVimCycle(1);
+    assert.strictEqual(store.getState().searchVimCycle!.index, 1);
+    store.getState().stepVimCycle(1);
+    assert.strictEqual(store.getState().searchVimCycle!.index, 2);
+    store.getState().stepVimCycle(1);
+    assert.strictEqual(store.getState().searchVimCycle!.index, 0, 'wraps forward');
+
+    store.getState().stepVimCycle(-1);
+    assert.strictEqual(store.getState().searchVimCycle!.index, 2, 'wraps backward');
+  });
+
+  it('step creates a new cycle object (for React change detection)', () => {
+    const results = [rs('a', 1), rs('b', 2)];
+    store.getState().enterVimCycle('w', results, 0);
+    const first = store.getState().searchVimCycle;
+    store.getState().stepVimCycle(1);
+    const second = store.getState().searchVimCycle;
+    assert.notStrictEqual(first, second, 'new object reference per step');
+    assert.strictEqual(second!.results, first!.results, 'results snapshot is stable');
+  });
+
+  it('step is a no-op when inactive', () => {
+    store.getState().stepVimCycle(1);
+    assert.strictEqual(store.getState().searchVimCycle, null);
+  });
+
+  it('exits cleanly', () => {
+    const results = [rs('a', 1), rs('b', 2)];
+    store.getState().enterVimCycle('w', results, 0);
+    store.getState().exitVimCycle();
+    assert.strictEqual(store.getState().searchVimCycle, null);
+  });
+
+  it('typing breaks the cycle (setSearchQuery clears vimCycle)', () => {
+    const results = [rs('a', 1), rs('b', 2)];
+    store.getState().enterVimCycle('w', results, 0);
+    store.getState().setSearchQuery('door');
+    assert.strictEqual(store.getState().searchVimCycle, null);
+  });
+
+  it('resetSearch clears the cycle', () => {
+    const results = [rs('a', 1), rs('b', 2)];
+    store.getState().enterVimCycle('w', results, 0);
+    store.getState().resetSearch();
+    assert.strictEqual(store.getState().searchVimCycle, null);
+  });
+
+  it('closeSearch preserves the cycle (user can hit n/N after popover closes)', () => {
+    const results = [rs('a', 1), rs('b', 2)];
+    store.getState().enterVimCycle('w', results, 0);
+    store.getState().closeSearch();
+    assert.ok(store.getState().searchVimCycle, 'cycle still active after popover close');
+  });
+});
+
+describe('searchSlice — advanced modal state', () => {
+  let store: StoreApi<SearchSlice>;
+
+  beforeEach(() => {
+    store = createStore<SearchSlice>((set, get, api) => createSearchSlice(set, get, api));
+  });
+
+  it('modal is closed by default with "all" field filter and null model filter', () => {
+    const s = store.getState();
+    assert.strictEqual(s.searchModalOpen, false);
+    assert.strictEqual(s.searchFieldFilter, 'all');
+    assert.strictEqual(s.searchModelFilter, null);
+  });
+
+  it('setSearchModalOpen + toggleSearchModal flip the open flag', () => {
+    store.getState().setSearchModalOpen(true);
+    assert.strictEqual(store.getState().searchModalOpen, true);
+    store.getState().toggleSearchModal();
+    assert.strictEqual(store.getState().searchModalOpen, false);
+    store.getState().toggleSearchModal();
+    assert.strictEqual(store.getState().searchModalOpen, true);
+  });
+
+  it('setSearchFieldFilter updates the chip selection', () => {
+    store.getState().setSearchFieldFilter('name');
+    assert.strictEqual(store.getState().searchFieldFilter, 'name');
+    store.getState().setSearchFieldFilter('all');
+    assert.strictEqual(store.getState().searchFieldFilter, 'all');
+  });
+
+  it('toggleSearchModelFilter materialises the include set on first toggle', () => {
+    const available = ['m1', 'm2', 'm3'];
+    store.getState().toggleSearchModelFilter('m2', available);
+    const filter = store.getState().searchModelFilter;
+    assert.ok(filter);
+    assert.deepStrictEqual(Array.from(filter!).sort(), ['m1', 'm3']);
+  });
+
+  it('toggleSearchModelFilter re-including the last excluded model collapses back to null', () => {
+    const available = ['m1', 'm2'];
+    store.getState().toggleSearchModelFilter('m1', available);
+    // now filter is {m2}
+    store.getState().toggleSearchModelFilter('m1', available);
+    // user re-included m1 → all available included → collapse to null
+    assert.strictEqual(store.getState().searchModelFilter, null);
+  });
+
+  it('toggleSearchModelFilter successive toggles on different models', () => {
+    const available = ['a', 'b', 'c'];
+    store.getState().toggleSearchModelFilter('a', available);
+    store.getState().toggleSearchModelFilter('b', available);
+    const filter = store.getState().searchModelFilter;
+    assert.ok(filter);
+    assert.deepStrictEqual(Array.from(filter!).sort(), ['c']);
+  });
+
+  it('clearSearchModelFilter resets to null', () => {
+    const available = ['a', 'b', 'c'];
+    store.getState().toggleSearchModelFilter('a', available);
+    store.getState().clearSearchModelFilter();
+    assert.strictEqual(store.getState().searchModelFilter, null);
+  });
+});
+
+describe('searchSlice — filter rule actions', () => {
+  let store: StoreApi<SearchSlice>;
+
+  beforeEach(() => {
+    store = createStore<SearchSlice>((set, get, api) => createSearchSlice(set, get, api));
+  });
+
+  it('starts with the empty filter state', () => {
+    const s = store.getState();
+    assert.deepStrictEqual(s.searchFilter.rules, []);
+    assert.strictEqual(s.searchFilter.combinator, 'AND');
+    assert.strictEqual(s.searchFilter.limit, 500);
+    assert.strictEqual(s.searchFilterSchema.size, 0);
+    assert.strictEqual(s.searchFilterResult, null);
+    assert.strictEqual(s.searchFilterRunning, false);
+    assert.strictEqual(s.searchFilterError, null);
+  });
+
+  it('setFilterCombinator / setFilterLimit patch the filter state', () => {
+    store.getState().setFilterCombinator('OR');
+    assert.strictEqual(store.getState().searchFilter.combinator, 'OR');
+    store.getState().setFilterLimit(100);
+    assert.strictEqual(store.getState().searchFilter.limit, 100);
+  });
+
+  it('addFilterRule appends a rule', () => {
+    const r = { kind: 'ifcType' as const, values: ['IfcWall'], op: 'in' as const };
+    store.getState().addFilterRule(r);
+    const rules = store.getState().searchFilter.rules;
+    assert.strictEqual(rules.length, 1);
+    assert.deepStrictEqual(rules[0], r);
+  });
+
+  it('updateFilterRule replaces a rule at the given index', () => {
+    const r1 = { kind: 'ifcType' as const, values: ['IfcWall'], op: 'in' as const };
+    const r2 = { kind: 'ifcType' as const, values: ['IfcDoor'], op: 'in' as const };
+    store.getState().addFilterRule(r1);
+    store.getState().updateFilterRule(0, r2);
+    assert.deepStrictEqual(store.getState().searchFilter.rules[0], r2);
+  });
+
+  it('updateFilterRule is a no-op for out-of-range indices', () => {
+    const before = store.getState().searchFilter;
+    store.getState().updateFilterRule(5, {
+      kind: 'ifcType' as const, values: [], op: 'in' as const,
+    });
+    assert.strictEqual(store.getState().searchFilter, before);
+  });
+
+  it('removeFilterRule drops the rule at the given index', () => {
+    const r1 = { kind: 'ifcType' as const, values: ['IfcWall'], op: 'in' as const };
+    const r2 = { kind: 'name' as const, op: 'contains' as const, value: 'EXT' };
+    store.getState().addFilterRule(r1);
+    store.getState().addFilterRule(r2);
+    store.getState().removeFilterRule(0);
+    const rules = store.getState().searchFilter.rules;
+    assert.strictEqual(rules.length, 1);
+    assert.strictEqual(rules[0].kind, 'name');
+  });
+
+  it('removeFilterRule is a no-op for out-of-range indices', () => {
+    const before = store.getState().searchFilter;
+    store.getState().removeFilterRule(2);
+    assert.strictEqual(store.getState().searchFilter, before);
+  });
+
+  it('clearFilterRules empties rules but preserves combinator + limit', () => {
+    store.getState().setFilterCombinator('OR');
+    store.getState().setFilterLimit(123);
+    store.getState().addFilterRule({
+      kind: 'ifcType' as const, values: ['IfcWall'], op: 'in' as const,
+    });
+    store.getState().clearFilterRules();
+    const f = store.getState().searchFilter;
+    assert.deepStrictEqual(f.rules, []);
+    assert.strictEqual(f.combinator, 'OR');
+    assert.strictEqual(f.limit, 123);
+  });
+
+  it('setSearchFilter replaces the whole filter state', () => {
+    const next = {
+      rules: [{ kind: 'name' as const, op: 'eq' as const, value: 'X' }],
+      combinator: 'OR' as const,
+      limit: 42,
+    };
+    store.getState().setSearchFilter(next);
+    assert.strictEqual(store.getState().searchFilter, next);
+  });
+});
+
+describe('searchSlice — Filter run result/error pairing', () => {
+  let store: StoreApi<SearchSlice>;
+
+  beforeEach(() => {
+    store = createStore<SearchSlice>((set, get, api) => createSearchSlice(set, get, api));
+  });
+
+  it('setSearchFilterResult clears the prior error (success supersedes failure)', () => {
+    store.getState().setSearchFilterError('boom');
+    store.getState().setSearchFilterResult({ columns: ['a'], rows: [[1]], runMs: 5 });
+    assert.strictEqual(store.getState().searchFilterError, null);
+    assert.deepStrictEqual(store.getState().searchFilterResult?.columns, ['a']);
+  });
+
+  it('setSearchFilterError preserves the prior result (notebook semantics)', () => {
+    store.getState().setSearchFilterResult({ columns: ['a'], rows: [[1]], runMs: 5 });
+    store.getState().setSearchFilterError('boom');
+    // Error and result coexist — UI stacks the error above the last good
+    // result. Without this, debugging a failed run loses the previous
+    // table the user was reading.
+    assert.strictEqual(store.getState().searchFilterError, 'boom');
+    assert.deepStrictEqual(store.getState().searchFilterResult?.columns, ['a']);
+  });
+
+  it('callers can wipe both via explicit nulls', () => {
+    store.getState().setSearchFilterResult({ columns: ['a'], rows: [], runMs: 1 });
+    store.getState().setSearchFilterError('x');
+    store.getState().setSearchFilterResult(null);
+    store.getState().setSearchFilterError(null);
+    assert.strictEqual(store.getState().searchFilterError, null);
+    assert.strictEqual(store.getState().searchFilterResult, null);
+  });
+});
+
+describe('searchSlice — schema cache', () => {
+  let store: StoreApi<SearchSlice>;
+
+  beforeEach(() => {
+    store = createStore<SearchSlice>((set, get, api) => createSearchSlice(set, get, api));
+  });
+
+  it('setFilterSchema inserts a basic entry with null psetQto', () => {
+    store.getState().setFilterSchema('m1', { storeys: [['L1', 0]], ifcTypes: ['IfcWall'] });
+    const entry = store.getState().searchFilterSchema.get('m1');
+    assert.ok(entry);
+    assert.deepStrictEqual(entry!.basic.ifcTypes, ['IfcWall']);
+    assert.strictEqual(entry!.psetQto, null);
+  });
+
+  it('setFilterSchema preserves existing psetQto when re-setting basic', () => {
+    store.getState().setFilterSchema('m1', { storeys: [], ifcTypes: ['IfcWall'] });
+    store.getState().setFilterPsetQtoSchema('m1', { psets: [['Pset_X', ['P']]], qtos: [] });
+    store.getState().setFilterSchema('m1', { storeys: [], ifcTypes: ['IfcWall', 'IfcDoor'] });
+    const entry = store.getState().searchFilterSchema.get('m1');
+    assert.ok(entry?.psetQto);
+    assert.deepStrictEqual(entry!.psetQto!.psets, [['Pset_X', ['P']]]);
+  });
+
+  it('setFilterPsetQtoSchema is a no-op without a prior basic entry', () => {
+    store.getState().setFilterPsetQtoSchema('mX', { psets: [], qtos: [] });
+    assert.strictEqual(store.getState().searchFilterSchema.has('mX'), false);
+  });
+
+  it('removeFilterSchema drops the model entry', () => {
+    store.getState().setFilterSchema('m1', { storeys: [], ifcTypes: [] });
+    store.getState().removeFilterSchema('m1');
+    assert.strictEqual(store.getState().searchFilterSchema.has('m1'), false);
+  });
+});

package/src/store/slices/searchSlice.ts

@@ -0,0 +1,341 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Search state slice.
+ *
+ * Two surfaces — both backed by the same per-model Tier-1 indexes:
+ *   1. Inline toolbar field (Tier-0/Tier-1 fuzzy text scan).
+ *   2. Advanced modal with two tabs:
+ *        - Search: same Tier-0/Tier-1 scan, virtualised + chip filters
+ *          (matchField, model include).
+ *        - Filter: chip-based structured rules over the unified
+ *          `FilterRule[]` shape, evaluated by the in-memory path-B
+ *          evaluator. No DuckDB — Builder + run is the whole UI.
+ *
+ * The path-B evaluator is the only run path; the previous DuckDB
+ * editor / SQL emitter / Run SQL button were removed once it became
+ * clear the in-memory engine handles 4M-entity models with the index
+ * prefilter + cheap-first ordering + chunked yielding pattern.
+ */
+
+import type { StateCreator } from 'zustand';
+import type { Tier1Index } from '@/lib/search/tier1-index';
+import type { SearchResult, MatchField } from '@/lib/search/tier0-scan';
+import type { FilterRule, Combinator } from '@/lib/search/filter-rules';
+import type { FilterSchema, PsetQtoSchema } from '@/lib/search/filter-schema';
+
+/** Index lifecycle state for a single model. */
+export type Tier1IndexStatus = 'pending' | 'building' | 'ready' | 'error';
+
+export interface Tier1IndexRecord {
+  status: Tier1IndexStatus;
+  /** Only present when status === 'ready'. */
+  index?: Tier1Index;
+  /** Progress in [0, 1] while status === 'building'. */
+  progress?: number;
+  /** Diagnostic message when status === 'error'. */
+  error?: string;
+}
+
+/**
+ * Vim-style search cycle — enters on Enter-commit from the inline field.
+ * While active, `n` / `N` step through the frozen result list, framing
+ * each match, and a small hint badge is shown near the search field.
+ * Any typing, Esc, or clicking elsewhere exits the cycle.
+ */
+export interface SearchVimCycleState {
+  /** The query string at the moment of commit (shown in the hint). */
+  query: string;
+  /** Frozen snapshot of results at commit; stable for the cycle's lifetime. */
+  results: SearchResult[];
+  /** 0-based index of the currently selected result. */
+  index: number;
+}
+
+/**
+ * Chip filter for the advanced modal — narrows results to rows whose
+ * `matchField` equals the selected value, or 'all' for no restriction.
+ */
+export type SearchFieldFilter = MatchField | 'all';
+
+/**
+ * Tabular result from a Filter run. Flat snapshot so the modal can
+ * re-render rows without holding live evaluator state.
+ */
+export interface SearchFilterResult {
+  columns: string[];
+  rows: unknown[][];
+  runMs: number;
+}
+
+/**
+ * Unified filter state — chip rules + AND/OR + result cap. Drives the
+ * path-B evaluator in `lib/search/filter-evaluate.ts`.
+ */
+export interface SearchFilterStateValue {
+  rules: FilterRule[];
+  combinator: Combinator;
+  /** Result cap. `0` = no cap (evaluator's internal default applies). */
+  limit: number;
+}
+
+export function emptyFilterState(): SearchFilterStateValue {
+  return { rules: [], combinator: 'AND', limit: 500 };
+}
+
+/**
+ * Per-model filter-schema cache for chip dropdowns. Populated on demand
+ * when the modal opens; cleared when a model is removed.
+ */
+export interface FilterSchemaCacheEntry {
+  /** Cheap pass — storeys + ifcTypes. Always populated when entry exists. */
+  basic: FilterSchema;
+  /** Expensive pass — pset / qto names. Lazy; null until first request. */
+  psetQto: PsetQtoSchema | null;
+}
+
+export interface SearchSlice {
+  /** Current input value (debounced consumers may stage their own copy). */
+  searchQuery: string;
+  /** Popover open below the inline field. */
+  searchOpen: boolean;
+  /** Currently highlighted result index in the popover (arrow-key nav). */
+  searchHighlightIndex: number;
+  /** Per-model Tier-1 index lifecycle (modelId → record). */
+  searchIndexes: Map<string, Tier1IndexRecord>;
+  /** Active vim-style cycle, or null when not cycling. */
+  searchVimCycle: SearchVimCycleState | null;
+  /** Advanced search modal (⌘⇧F) is open. */
+  searchModalOpen: boolean;
+  /** Field chip filter active inside the modal. Defaults to 'all'. */
+  searchFieldFilter: SearchFieldFilter;
+  /** Per-modelId include filter inside the modal. `null` means all models included. */
+  searchModelFilter: Set<string> | null;
+
+  /** Latest Filter run result (or null on fresh tab open / error). */
+  searchFilterResult: SearchFilterResult | null;
+  /** Whether a Filter run is currently in flight. */
+  searchFilterRunning: boolean;
+  /** Latest Filter error message — set when the evaluator throws. */
+  searchFilterError: string | null;
+  /** Filter rule state — chip rules, combinator, limit. */
+  searchFilter: SearchFilterStateValue;
+  /** Per-model filter-schema cache (lazy). */
+  searchFilterSchema: Map<string, FilterSchemaCacheEntry>;
+
+  setSearchQuery: (query: string) => void;
+  setSearchOpen: (open: boolean) => void;
+  setSearchHighlightIndex: (index: number) => void;
+  /** Convenience: close popover and reset highlight (preserves query). */
+  closeSearch: () => void;
+  /** Convenience: clear query and close popover. */
+  resetSearch: () => void;
+
+  /** Replace (or insert) the index record for a model. */
+  setSearchIndexRecord: (modelId: string, record: Tier1IndexRecord) => void;
+  /** Drop the index record for a model (called when a model is removed). */
+  removeSearchIndexRecord: (modelId: string) => void;
+
+  /** Enter vim cycle mode with a frozen result snapshot at `index`. */
+  enterVimCycle: (query: string, results: SearchResult[], index: number) => void;
+  /** Exit vim cycle mode (no-op when inactive). */
+  exitVimCycle: () => void;
+  /** Advance the cycle by +1 / -1, wrapping around. */
+  stepVimCycle: (delta: 1 | -1) => void;
+
+  setSearchModalOpen: (open: boolean) => void;
+  toggleSearchModal: () => void;
+  setSearchFieldFilter: (filter: SearchFieldFilter) => void;
+  /** Toggle a model in/out of the include filter. If the filter is null,
+   *  the first toggle materialises it as "all models except this one". */
+  toggleSearchModelFilter: (modelId: string, availableModelIds: readonly string[]) => void;
+  /** Clear model filter (null → all models included). */
+  clearSearchModelFilter: () => void;
+
+  // ── Filter run state ──────────────────────────────────────────────
+  setSearchFilterRunning: (running: boolean) => void;
+  /** Successful run — sets the result and clears any prior error
+   *  (the new run supersedes the old failure). */
+  setSearchFilterResult: (result: SearchFilterResult | null) => void;
+  /** Error path — keeps the prior result visible while showing the
+   *  error above it (notebook-style pairing). */
+  setSearchFilterError: (error: string | null) => void;
+
+  // ── Filter-rule actions ───────────────────────────────────────────
+  /** Replace the whole filter state — used by Reset and preset loading. */
+  setSearchFilter: (state: SearchFilterStateValue) => void;
+  setFilterCombinator: (combinator: Combinator) => void;
+  setFilterLimit: (limit: number) => void;
+  addFilterRule: (rule: FilterRule) => void;
+  updateFilterRule: (index: number, rule: FilterRule) => void;
+  removeFilterRule: (index: number) => void;
+  /** Drop every rule but keep combinator + limit. */
+  clearFilterRules: () => void;
+
+  // ── Schema cache actions ──────────────────────────────────────────
+  setFilterSchema: (modelId: string, basic: FilterSchema) => void;
+  setFilterPsetQtoSchema: (modelId: string, psetQto: PsetQtoSchema) => void;
+  removeFilterSchema: (modelId: string) => void;
+}
+
+export const createSearchSlice: StateCreator<SearchSlice, [], [], SearchSlice> = (set) => ({
+  searchQuery: '',
+  searchOpen: false,
+  searchHighlightIndex: 0,
+  searchIndexes: new Map(),
+  searchVimCycle: null,
+  searchModalOpen: false,
+  searchFieldFilter: 'all',
+  searchModelFilter: null,
+  searchFilterResult: null,
+  searchFilterRunning: false,
+  searchFilterError: null,
+  searchFilter: emptyFilterState(),
+  searchFilterSchema: new Map(),
+
+  // Typing or programmatically changing the query breaks out of vim cycle —
+  // the user is re-searching, not stepping through a committed result list.
+  setSearchQuery: (searchQuery) => set({ searchQuery, searchHighlightIndex: 0, searchVimCycle: null }),
+  setSearchOpen: (searchOpen) => set({ searchOpen }),
+  setSearchHighlightIndex: (searchHighlightIndex) => set({ searchHighlightIndex }),
+
+  closeSearch: () => set({ searchOpen: false, searchHighlightIndex: 0 }),
+  resetSearch: () =>
+    set({ searchQuery: '', searchOpen: false, searchHighlightIndex: 0, searchVimCycle: null }),
+
+  setSearchIndexRecord: (modelId, record) =>
+    set((state) => {
+      const next = new Map(state.searchIndexes);
+      next.set(modelId, record);
+      return { searchIndexes: next };
+    }),
+
+  removeSearchIndexRecord: (modelId) =>
+    set((state) => {
+      if (!state.searchIndexes.has(modelId)) return {};
+      const next = new Map(state.searchIndexes);
+      next.delete(modelId);
+      return { searchIndexes: next };
+    }),
+
+  enterVimCycle: (query, results, index) => {
+    if (results.length === 0) return;
+    const clamped = Math.max(0, Math.min(index, results.length - 1));
+    set({ searchVimCycle: { query, results, index: clamped } });
+  },
+
+  exitVimCycle: () => set({ searchVimCycle: null }),
+
+  stepVimCycle: (delta) =>
+    set((state) => {
+      const cycle = state.searchVimCycle;
+      if (!cycle || cycle.results.length === 0) return {};
+      const len = cycle.results.length;
+      const next = (cycle.index + delta + len) % len;
+      return { searchVimCycle: { ...cycle, index: next } };
+    }),
+
+  setSearchModalOpen: (searchModalOpen) => set({ searchModalOpen }),
+  toggleSearchModal: () => set((state) => ({ searchModalOpen: !state.searchModalOpen })),
+  setSearchFieldFilter: (searchFieldFilter) => set({ searchFieldFilter }),
+
+  toggleSearchModelFilter: (modelId, availableModelIds) =>
+    set((state) => {
+      const current = state.searchModelFilter;
+      // First toggle from the "all included" null state materialises an
+      // explicit set containing every OTHER model — checking the box that
+      // was "on by default" and unchecking it feels the same to the user.
+      if (current === null) {
+        const next = new Set(availableModelIds);
+        next.delete(modelId);
+        return { searchModelFilter: next };
+      }
+      const next = new Set(current);
+      if (next.has(modelId)) next.delete(modelId);
+      else next.add(modelId);
+      // If the user has re-included every available model, collapse back
+      // to null so the "all included" default re-applies when a new model
+      // loads later.
+      let allIncluded = true;
+      for (const id of availableModelIds) {
+        if (!next.has(id)) { allIncluded = false; break; }
+      }
+      return { searchModelFilter: allIncluded ? null : next };
+    }),
+
+  clearSearchModelFilter: () => set({ searchModelFilter: null }),
+
+  setSearchFilterRunning: (searchFilterRunning) => set({ searchFilterRunning }),
+  // Notebook-style pairing: a successful run clears the prior error
+  // (new result supersedes failure) but an error keeps the prior result
+  // on screen so the user doesn't lose their last good table while
+  // debugging.
+  setSearchFilterResult: (searchFilterResult) => set({ searchFilterResult, searchFilterError: null }),
+  setSearchFilterError: (searchFilterError) => set({ searchFilterError }),
+
+  setSearchFilter: (searchFilter) => set({ searchFilter }),
+
+  setFilterCombinator: (combinator) =>
+    set((state) => ({ searchFilter: { ...state.searchFilter, combinator } })),
+
+  setFilterLimit: (limit) =>
+    set((state) => ({ searchFilter: { ...state.searchFilter, limit } })),
+
+  addFilterRule: (rule) =>
+    set((state) => ({
+      searchFilter: {
+        ...state.searchFilter,
+        rules: [...state.searchFilter.rules, rule],
+      },
+    })),
+
+  updateFilterRule: (index, rule) =>
+    set((state) => {
+      const rules = state.searchFilter.rules;
+      if (index < 0 || index >= rules.length) return {};
+      const next = rules.slice();
+      next[index] = rule;
+      return { searchFilter: { ...state.searchFilter, rules: next } };
+    }),
+
+  removeFilterRule: (index) =>
+    set((state) => {
+      const rules = state.searchFilter.rules;
+      if (index < 0 || index >= rules.length) return {};
+      const next = rules.slice();
+      next.splice(index, 1);
+      return { searchFilter: { ...state.searchFilter, rules: next } };
+    }),
+
+  clearFilterRules: () =>
+    set((state) => ({ searchFilter: { ...state.searchFilter, rules: [] } })),
+
+  setFilterSchema: (modelId, basic) =>
+    set((state) => {
+      const next = new Map(state.searchFilterSchema);
+      const existing = next.get(modelId);
+      next.set(modelId, { basic, psetQto: existing?.psetQto ?? null });
+      return { searchFilterSchema: next };
+    }),
+
+  setFilterPsetQtoSchema: (modelId, psetQto) =>
+    set((state) => {
+      const next = new Map(state.searchFilterSchema);
+      const existing = next.get(modelId);
+      // Only meaningful once a basic schema has been set — the modal
+      // calls discoverFilterSchema first then queues the heavy pass.
+      if (!existing) return {};
+      next.set(modelId, { basic: existing.basic, psetQto });
+      return { searchFilterSchema: next };
+    }),
+
+  removeFilterSchema: (modelId) =>
+    set((state) => {
+      if (!state.searchFilterSchema.has(modelId)) return {};
+      const next = new Map(state.searchFilterSchema);
+      next.delete(modelId);
+      return { searchFilterSchema: next };
+    }),
+});