@ifc-lite/viewer 1.17.6 → 1.19.0

package/src/lib/search/filter-schema.ts

@@ -0,0 +1,146 @@
+/* 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/. */
+
+/**
+ * Filter schema discovery.
+ *
+ * Mirrors the Rust `get_filter_schema` Tauri command — returns the set
+ * of distinct values available for each filter dimension in the active
+ * model so the chip UI can populate dropdowns instead of free-text
+ * inputs (the single largest UX gap in the existing visual builder).
+ *
+ * Cheap parts (storeys, ifcTypes) read straight from already-built
+ * indexes. Pset / Qto schema requires touching on-demand extractors,
+ * so it is split out as `discoverPropertyAndQuantitySchema` — the
+ * caller decides when to pay that cost (e.g. behind a "Show all
+ * properties" expander rather than on every modal open).
+ */
+
+import {
+  extractPropertiesOnDemand,
+  extractQuantitiesOnDemand,
+  type IfcDataStore,
+} from '@ifc-lite/parser';
+
+export interface FilterSchema {
+  /** [storeyName, elevationMeters | null] sorted by name. */
+  storeys: Array<[string, number | null]>;
+  /** Distinct IFC type names actually present (e.g. "IfcWall"). Sorted. */
+  ifcTypes: string[];
+}
+
+export interface PsetQtoSchema {
+  /** [setName, [propertyName, ...]] sorted. */
+  psets: Array<[string, string[]]>;
+  /** [setName, [[quantityName, unit], ...]] sorted. unit is "" when unknown. */
+  qtos: Array<[string, Array<[string, string]>]>;
+}
+
+/**
+ * Cheap pass — uses already-materialised indexes. Safe to call on every
+ * modal open / chip-edit.
+ */
+export function discoverFilterSchema(store: IfcDataStore): FilterSchema {
+  return {
+    storeys: collectStoreys(store),
+    ifcTypes: collectIfcTypes(store),
+  };
+}
+
+function collectStoreys(store: IfcDataStore): Array<[string, number | null]> {
+  const hierarchy = store.spatialHierarchy;
+  if (!hierarchy) return [];
+  const out: Array<[string, number | null]> = [];
+  // Iterate byStorey keys (== storey expressIds). Keep one entry per
+  // unique storey *name* — duplicates would confuse the chip dropdown
+  // even though the underlying storey IDs differ.
+  const seen = new Map<string, number | null>();
+  for (const storeyId of hierarchy.byStorey.keys()) {
+    const name = store.entities.getName(storeyId);
+    if (!name) continue;
+    if (seen.has(name)) continue;
+    const elevation = hierarchy.storeyElevations.get(storeyId) ?? null;
+    seen.set(name, elevation);
+  }
+  for (const [name, elev] of seen) out.push([name, elev]);
+  out.sort((a, b) => a[0].localeCompare(b[0]));
+  return out;
+}
+
+function collectIfcTypes(store: IfcDataStore): string[] {
+  const types = new Set<string>();
+  // entityIndex.byType maps the UPPERCASE STEP type name to expressIds.
+  // Resolve the canonical (PascalCase) form per-entity via getTypeName
+  // so the chip dropdown shows "IfcWall" rather than "IFCWALL".
+  for (const ids of store.entityIndex.byType.values()) {
+    if (ids.length === 0) continue;
+    const sample = ids[0];
+    const canonical = store.entities.getTypeName(sample);
+    if (canonical) types.add(canonical);
+  }
+  const out = Array.from(types);
+  out.sort();
+  return out;
+}
+
+/**
+ * Expensive pass — walks every entity that has an on-demand pset/qto
+ * map entry and extracts the set/property names. Run once per model
+ * lifetime (cache the result in the slice). For a 100K-entity model
+ * this is still ~milliseconds because we read the map keys, not values.
+ *
+ * For the value-extraction path (turning each property into a chip
+ * value dropdown) the caller should sample a bounded subset of
+ * entities — full enumeration is O(entities × props) and would defeat
+ * the on-demand laziness.
+ */
+export function discoverPropertyAndQuantitySchema(store: IfcDataStore): PsetQtoSchema {
+  const psetMap = new Map<string, Set<string>>();
+  const qtoMap = new Map<string, Map<string, string>>();
+
+  // Properties — iterate the on-demand map's element keys (already
+  // narrowed to entities that declare any pset). For each, extract
+  // names only; values are intentionally not collected here.
+  if (store.onDemandPropertyMap) {
+    for (const entityId of store.onDemandPropertyMap.keys()) {
+      const sets = extractPropertiesOnDemand(store, entityId);
+      for (const set of sets) {
+        let bucket = psetMap.get(set.name);
+        if (!bucket) { bucket = new Set(); psetMap.set(set.name, bucket); }
+        for (const p of set.properties) bucket.add(p.name);
+      }
+    }
+  }
+
+  if (store.onDemandQuantityMap) {
+    for (const entityId of store.onDemandQuantityMap.keys()) {
+      const sets = extractQuantitiesOnDemand(store, entityId);
+      for (const set of sets) {
+        let bucket = qtoMap.get(set.name);
+        if (!bucket) { bucket = new Map(); qtoMap.set(set.name, bucket); }
+        for (const q of set.quantities) {
+          // Unit isn't carried in the on-demand quantity row today —
+          // emit "" so the schema shape matches `filter.rs::FilterSchema`.
+          if (!bucket.has(q.name)) bucket.set(q.name, '');
+        }
+      }
+    }
+  }
+
+  const psets: Array<[string, string[]]> = Array.from(psetMap, ([set, props]) => [
+    set,
+    Array.from(props).sort(),
+  ]);
+  psets.sort((a, b) => a[0].localeCompare(b[0]));
+
+  const qtos: Array<[string, Array<[string, string]>]> = Array.from(qtoMap, ([set, qtys]) => [
+    set,
+    Array.from(qtys, ([name, unit]) => [name, unit] as [string, string]).sort((a, b) =>
+      a[0].localeCompare(b[0]),
+    ),
+  ]);
+  qtos.sort((a, b) => a[0].localeCompare(b[0]));
+
+  return { psets, qtos };
+}

package/src/lib/search/recent-searches.test.ts

@@ -0,0 +1,116 @@
+/* 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 {
+  loadRecentSearches,
+  pushRecentSearch,
+  clearRecentSearches,
+  __internal,
+} from './recent-searches.js';
+
+/** Minimal Storage surface that `recent-searches` actually calls. Keeping
+ *  it narrow (no `length`, `clear`, `key`) is fine — the safeStorage()
+ *  helper in the module under test only touches get/set/remove. We assign
+ *  it via `unknown` so we don't have to stub the full DOM Storage API. */
+interface MemoryStorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+class MemoryStorage implements MemoryStorageLike {
+  private store = new Map<string, string>();
+  getItem(key: string): string | null { return this.store.get(key) ?? null; }
+  setItem(key: string, value: string): void { this.store.set(key, value); }
+  removeItem(key: string): void { this.store.delete(key); }
+}
+
+const g = globalThis as { localStorage?: unknown };
+
+describe('recent-searches', () => {
+  beforeEach(() => {
+    g.localStorage = new MemoryStorage();
+  });
+
+  it('returns an empty list when nothing is stored', () => {
+    assert.deepStrictEqual(loadRecentSearches(), []);
+  });
+
+  it('records a committed query', () => {
+    pushRecentSearch('wall');
+    assert.deepStrictEqual(loadRecentSearches(), ['wall']);
+  });
+
+  it('ignores empty and whitespace-only queries', () => {
+    pushRecentSearch('');
+    pushRecentSearch('   ');
+    assert.deepStrictEqual(loadRecentSearches(), []);
+  });
+
+  it('trims queries before storing them', () => {
+    pushRecentSearch('   wall   ');
+    assert.deepStrictEqual(loadRecentSearches(), ['wall']);
+  });
+
+  it('move-to-front dedupes repeated queries', () => {
+    pushRecentSearch('wall');
+    pushRecentSearch('door');
+    pushRecentSearch('wall'); // move-to-front
+    assert.deepStrictEqual(loadRecentSearches(), ['wall', 'door']);
+  });
+
+  it('caps the list at MAX_ENTRIES', () => {
+    for (let i = 0; i < __internal.MAX_ENTRIES + 5; i++) {
+      pushRecentSearch(`q-${i}`);
+    }
+    const list = loadRecentSearches();
+    assert.strictEqual(list.length, __internal.MAX_ENTRIES);
+    // Most-recent-first: the last insert is at the head.
+    assert.strictEqual(list[0], `q-${__internal.MAX_ENTRIES + 4}`);
+  });
+
+  it('drops queries longer than MAX_QUERY_LEN', () => {
+    const huge = 'x'.repeat(__internal.MAX_QUERY_LEN + 1);
+    pushRecentSearch(huge);
+    assert.deepStrictEqual(loadRecentSearches(), []);
+  });
+
+  it('clears the list on demand', () => {
+    pushRecentSearch('wall');
+    pushRecentSearch('door');
+    clearRecentSearches();
+    assert.deepStrictEqual(loadRecentSearches(), []);
+  });
+
+  it('gracefully recovers from malformed storage payloads', () => {
+    (g.localStorage as MemoryStorageLike).setItem(__internal.STORAGE_KEY, '{not-an-array}');
+    assert.deepStrictEqual(loadRecentSearches(), []);
+    // Write should succeed after the malformed payload was auto-cleared.
+    pushRecentSearch('wall');
+    assert.deepStrictEqual(loadRecentSearches(), ['wall']);
+  });
+
+  it('returns an empty list when no localStorage is available', () => {
+    delete g.localStorage;
+    assert.deepStrictEqual(loadRecentSearches(), []);
+    // Writes are silent no-ops.
+    pushRecentSearch('wall');
+    assert.deepStrictEqual(loadRecentSearches(), []);
+  });
+
+  it('returns an empty list when storage writes throw (sandbox/quota)', () => {
+    const throwing: MemoryStorageLike = {
+      getItem: () => null,
+      setItem: () => {
+        throw new Error('QuotaExceeded');
+      },
+      removeItem: () => {},
+    };
+    g.localStorage = throwing;
+    // probe setItem will throw → safeStorage returns null → empty list.
+    assert.deepStrictEqual(loadRecentSearches(), []);
+  });
+});

package/src/lib/search/recent-searches.ts

@@ -0,0 +1,93 @@
+/* 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/. */
+
+/**
+ * Recent searches — small localStorage-backed MRU list surfaced in the
+ * search popover when the field is focused with an empty query.
+ *
+ * Pure module — safe to import from tests (stubs a storage object when
+ * `window.localStorage` is not present). All entries are trimmed
+ * non-empty strings; exact-duplicate entries are moved to the front
+ * instead of appended, giving a natural MRU without bookkeeping.
+ */
+
+const STORAGE_KEY = 'ifc-lite:search:recents';
+const MAX_ENTRIES = 8;
+const MAX_QUERY_LEN = 200;
+
+interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+function safeStorage(): StorageLike | null {
+  try {
+    const ls = (globalThis as typeof globalThis & { localStorage?: StorageLike }).localStorage;
+    if (!ls) return null;
+    // Some environments (sandbox, private mode) throw on write — probe it.
+    const probe = `${STORAGE_KEY}:__probe__`;
+    ls.setItem(probe, '1');
+    ls.removeItem(probe);
+    return ls;
+  } catch {
+    return null;
+  }
+}
+
+/** Returns the MRU list, most-recent first. Always a fresh array. */
+export function loadRecentSearches(): string[] {
+  const ls = safeStorage();
+  if (!ls) return [];
+  const raw = ls.getItem(STORAGE_KEY);
+  if (!raw) return [];
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    const out: string[] = [];
+    for (const v of parsed) {
+      if (typeof v === 'string') {
+        const trimmed = v.trim();
+        if (trimmed.length > 0 && trimmed.length <= MAX_QUERY_LEN) out.push(trimmed);
+      }
+      if (out.length >= MAX_ENTRIES) break;
+    }
+    return out;
+  } catch {
+    // Malformed payload — drop it rather than letting it block future writes.
+    ls.removeItem(STORAGE_KEY);
+    return [];
+  }
+}
+
+/** Record a committed query. No-ops on empty/whitespace input. */
+export function pushRecentSearch(query: string): string[] {
+  const trimmed = query.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_QUERY_LEN) return loadRecentSearches();
+  const existing = loadRecentSearches();
+  // Move-to-front: remove any prior exact match, then prepend.
+  const deduped = existing.filter((q) => q !== trimmed);
+  const next = [trimmed, ...deduped].slice(0, MAX_ENTRIES);
+
+  const ls = safeStorage();
+  if (ls) {
+    try {
+      ls.setItem(STORAGE_KEY, JSON.stringify(next));
+    } catch {
+      // Quota exceeded or unexpected write failure — swallow; the next
+      // pushRecentSearch call may succeed once other storage is freed.
+    }
+  }
+  return next;
+}
+
+/** Wipe the list. Useful for privacy + the "Clear recents" UI affordance. */
+export function clearRecentSearches(): void {
+  const ls = safeStorage();
+  if (!ls) return;
+  ls.removeItem(STORAGE_KEY);
+}
+
+/** Exposed for tests. */
+export const __internal = { STORAGE_KEY, MAX_ENTRIES, MAX_QUERY_LEN };

package/src/lib/search/result-export.test.ts

@@ -0,0 +1,101 @@
+/* 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 } from 'node:test';
+import assert from 'node:assert';
+import { formatCsv, formatJson, __internal } from './result-export.js';
+
+const sample = {
+  columns: ['express_id', 'name', 'is_external', 'note'],
+  rows: [
+    [10, 'Wall A', true, 'plain'],
+    [20, 'Wall, "B"', false, 'has comma + quote'],
+    [30, 'Wall\nMulti', null, 'has newline'],
+  ],
+};
+
+describe('formatCsv', () => {
+  it('writes a header row plus a body that contains every row', () => {
+    const csv = formatCsv(sample);
+    // Header line is the first physical line — easy to assert on.
+    assert.ok(csv.startsWith('express_id,name,is_external,note\n'));
+    // Each row's first cell value should appear in the CSV body.
+    for (const row of sample.rows) {
+      assert.ok(csv.includes(String(row[0])), `CSV missing express_id ${row[0]}`);
+    }
+  });
+
+  it('quotes cells containing comma, quote, or newline', () => {
+    const csv = formatCsv(sample);
+    // Wall, "B" → wrapped in quotes with embedded "" escapes.
+    assert.ok(csv.includes('"Wall, ""B"""'));
+    // Newline cell wrapped — embedded \n stays literal inside the quotes.
+    assert.ok(csv.includes('"Wall\nMulti"'));
+  });
+
+  it('renders booleans as true / false and null as empty', () => {
+    const csv = formatCsv(sample);
+    // Row 1 uses no special chars → its full unquoted line is locatable.
+    assert.ok(csv.includes('10,Wall A,true,plain'));
+    // Null cell collapses to empty between two commas.
+    assert.ok(csv.includes(',,has newline'));
+  });
+
+  it('terminates with a newline (POSIX-friendly)', () => {
+    const csv = formatCsv({ columns: ['a'], rows: [['1']] });
+    assert.ok(csv.endsWith('\n'));
+  });
+
+  it('handles empty result sets (header only)', () => {
+    const csv = formatCsv({ columns: ['a', 'b'], rows: [] });
+    assert.strictEqual(csv, 'a,b\n');
+  });
+});
+
+describe('formatJson', () => {
+  it('produces an array of column→value objects', () => {
+    const json = formatJson(sample);
+    const parsed = JSON.parse(json);
+    assert.strictEqual(parsed.length, 3);
+    assert.strictEqual(parsed[0].express_id, '10');
+    assert.strictEqual(parsed[0].is_external, 'true');
+    assert.strictEqual(parsed[2].is_external, ''); // null → ''
+  });
+
+  it('is pretty-printed (multi-line, with indented keys)', () => {
+    const json = formatJson({ columns: ['a'], rows: [['1']] });
+    // Indent=2: the inner object lives at 4 spaces of indent inside the array.
+    assert.ok(json.includes('\n    "a"'));
+  });
+
+  it('handles empty result sets ("[]")', () => {
+    assert.strictEqual(formatJson({ columns: ['a'], rows: [] }), '[]');
+  });
+});
+
+describe('__internal helpers', () => {
+  it('cellToString covers booleans, bigint, numbers, and objects', () => {
+    assert.strictEqual(__internal.cellToString(null), '');
+    assert.strictEqual(__internal.cellToString(undefined), '');
+    assert.strictEqual(__internal.cellToString(true), 'true');
+    assert.strictEqual(__internal.cellToString(42n), '42');
+    assert.strictEqual(__internal.cellToString(3.14), '3.14');
+    assert.strictEqual(__internal.cellToString(NaN), '');
+    assert.strictEqual(__internal.cellToString({ a: 1 }), '{"a":1}');
+  });
+
+  it('escapeCsvCell wraps + escapes only when needed', () => {
+    assert.strictEqual(__internal.escapeCsvCell(''), '');
+    assert.strictEqual(__internal.escapeCsvCell('plain'), 'plain');
+    assert.strictEqual(__internal.escapeCsvCell('a,b'), '"a,b"');
+    assert.strictEqual(__internal.escapeCsvCell('a"b'), '"a""b"');
+    assert.strictEqual(__internal.escapeCsvCell('a\nb'), '"a\nb"');
+  });
+
+  it('sanitiseFilenameStem strips path-unsafe characters', () => {
+    assert.strictEqual(__internal.sanitiseFilenameStem('My Query.csv'), 'My_Query_csv');
+    assert.strictEqual(__internal.sanitiseFilenameStem('   '), 'query');
+    assert.strictEqual(__internal.sanitiseFilenameStem('weird/../path'), 'weird_path');
+  });
+});

package/src/lib/search/result-export.ts

@@ -0,0 +1,104 @@
+/* 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/. */
+
+/**
+ * Result-table export — pure formatters + a Blob download trigger.
+ *
+ * `formatCsv` and `formatJson` are pure (testable in node:test); the
+ * download helper is browser-only and DOM-touching, so we keep it in
+ * the same module but isolated from the formatters.
+ */
+
+export interface ExportResult {
+  columns: string[];
+  rows: unknown[][];
+}
+
+/** Cells DuckDB sometimes returns as Object / BigInt — normalise to a
+ *  string the spreadsheet / JSON consumers can actually read. */
+function cellToString(v: unknown): string {
+  if (v === null || v === undefined) return '';
+  if (typeof v === 'boolean') return v ? 'true' : 'false';
+  if (typeof v === 'bigint') return v.toString();
+  if (typeof v === 'number') return Number.isFinite(v) ? String(v) : '';
+  if (typeof v === 'string') return v;
+  // Fallback for Object / Date / Arrow row helpers — JSON.stringify is
+  // safe and round-trippable; CSV consumers see the JSON literal.
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+/** RFC-4180-style escaping: quote any cell containing comma, quote, or
+ *  newline; double-up embedded quotes inside the wrapped cell. */
+function escapeCsvCell(raw: string): string {
+  if (raw.length === 0) return '';
+  const needsQuotes = raw.includes(',') || raw.includes('"') || raw.includes('\n') || raw.includes('\r');
+  if (!needsQuotes) return raw;
+  return `"${raw.replace(/"/g, '""')}"`;
+}
+
+/** Serialize a result set to CSV (UTF-8). Trailing newline included. */
+export function formatCsv(result: ExportResult): string {
+  const lines: string[] = [];
+  lines.push(result.columns.map((c) => escapeCsvCell(c)).join(','));
+  for (const row of result.rows) {
+    const cells: string[] = [];
+    for (let i = 0; i < result.columns.length; i++) {
+      cells.push(escapeCsvCell(cellToString(row[i])));
+    }
+    lines.push(cells.join(','));
+  }
+  return lines.join('\n') + '\n';
+}
+
+/** Serialize a result set to a pretty-printed JSON array of objects.
+ *  bigint / Date / object cells are stringified through cellToString
+ *  for round-trip consistency with CSV export. */
+export function formatJson(result: ExportResult): string {
+  const out = result.rows.map((row) => {
+    const obj: Record<string, string> = {};
+    for (let i = 0; i < result.columns.length; i++) {
+      obj[result.columns[i]] = cellToString(row[i]);
+    }
+    return obj;
+  });
+  return JSON.stringify(out, null, 2);
+}
+
+/** Sanitise a stem for use as a download filename — strip path-unsafe
+ *  characters, fall back to `query`. */
+function sanitiseFilenameStem(stem: string): string {
+  const cleaned = stem.replace(/[^a-zA-Z0-9_\-]+/g, '_').replace(/^_+|_+$/g, '');
+  return cleaned.length > 0 ? cleaned.slice(0, 60) : 'query';
+}
+
+/** Build the `Blob` + temporary `<a>` download flow for a result. The
+ *  caller passes a "stem" that becomes the filename root (`stem.csv`).
+ *  Browser-only — does nothing useful when `document` is missing. */
+export function downloadResult(
+  result: ExportResult,
+  format: 'csv' | 'json',
+  filenameStem = 'ifc-query',
+): void {
+  if (typeof document === 'undefined' || typeof URL === 'undefined') return;
+
+  const content = format === 'csv' ? formatCsv(result) : formatJson(result);
+  const mime = format === 'csv' ? 'text/csv;charset=utf-8' : 'application/json;charset=utf-8';
+  const blob = new Blob([content], { type: mime });
+  const url = URL.createObjectURL(blob);
+
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = `${sanitiseFilenameStem(filenameStem)}.${format}`;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+
+/** Exposed for tests. */
+export const __internal = { escapeCsvCell, cellToString, sanitiseFilenameStem };

package/src/lib/search/saved-filters.test.ts

@@ -0,0 +1,118 @@
+/* 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 {
+  loadSavedFilters,
+  saveFilter,
+  deleteSavedFilter,
+  clearSavedFilters,
+  __internal,
+} from './saved-filters.js';
+import { Rule } from './filter-rules.js';
+
+interface MemoryStorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+class MemoryStorage implements MemoryStorageLike {
+  private store = new Map<string, string>();
+  getItem(key: string): string | null { return this.store.get(key) ?? null; }
+  setItem(key: string, value: string): void { this.store.set(key, value); }
+  removeItem(key: string): void { this.store.delete(key); }
+}
+
+const g = globalThis as { localStorage?: unknown };
+
+describe('saved-filters', () => {
+  beforeEach(() => {
+    g.localStorage = new MemoryStorage();
+  });
+
+  it('returns an empty list when nothing is stored', () => {
+    assert.deepStrictEqual(loadSavedFilters(), []);
+  });
+
+  it('saves a preset and reads it back sorted by name', () => {
+    saveFilter('Bravo', 'AND', [Rule.ifcType(['IfcWall'])]);
+    saveFilter('Alpha', 'OR', [Rule.name('contains', 'EXT')]);
+    const list = loadSavedFilters();
+    assert.deepStrictEqual(list.map((p) => p.name), ['Alpha', 'Bravo']);
+    assert.strictEqual(list[0].combinator, 'OR');
+    assert.strictEqual(list[1].combinator, 'AND');
+  });
+
+  it('overwrites an existing preset by case-insensitive name match', () => {
+    saveFilter('External Walls', 'AND', [Rule.ifcType(['IfcWall'])]);
+    saveFilter('external walls', 'OR', [Rule.ifcType(['IfcDoor'])]);
+    const list = loadSavedFilters();
+    assert.strictEqual(list.length, 1);
+    assert.strictEqual(list[0].combinator, 'OR');
+    assert.strictEqual(list[0].name, 'external walls');
+  });
+
+  it('drops empty / whitespace / over-length names', () => {
+    saveFilter('', 'AND', []);
+    saveFilter('   ', 'AND', []);
+    saveFilter('x'.repeat(__internal.MAX_NAME_LEN + 1), 'AND', []);
+    assert.deepStrictEqual(loadSavedFilters(), []);
+  });
+
+  it('takes a defensive copy of the rules array', () => {
+    const rules = [Rule.ifcType(['IfcWall'])];
+    saveFilter('Walls', 'AND', rules);
+    rules[0] = Rule.ifcType(['IfcDoor']);
+    const loaded = loadSavedFilters()[0];
+    // The mutation to the caller's array must not leak into storage.
+    const r = loaded.rules[0];
+    assert.strictEqual(r.kind, 'ifcType');
+    if (r.kind === 'ifcType') {
+      assert.deepStrictEqual(r.values, ['IfcWall']);
+    }
+  });
+
+  it('deleteSavedFilter removes the named preset', () => {
+    saveFilter('Walls', 'AND', [Rule.ifcType(['IfcWall'])]);
+    saveFilter('Doors', 'AND', [Rule.ifcType(['IfcDoor'])]);
+    deleteSavedFilter('walls');
+    const list = loadSavedFilters();
+    assert.deepStrictEqual(list.map((p) => p.name), ['Doors']);
+  });
+
+  it('deleteSavedFilter is a no-op for unknown names', () => {
+    saveFilter('Walls', 'AND', [Rule.ifcType(['IfcWall'])]);
+    deleteSavedFilter('Nope');
+    assert.strictEqual(loadSavedFilters().length, 1);
+  });
+
+  it('clearSavedFilters wipes the catalog', () => {
+    saveFilter('Walls', 'AND', [Rule.ifcType(['IfcWall'])]);
+    clearSavedFilters();
+    assert.deepStrictEqual(loadSavedFilters(), []);
+  });
+
+  it('drops malformed payloads in storage', () => {
+    (g.localStorage as MemoryStorage).setItem(__internal.STORAGE_KEY, '{not-json');
+    assert.deepStrictEqual(loadSavedFilters(), []);
+  });
+
+  it('rejects entries with unknown rule kinds while preserving valid ones', () => {
+    (g.localStorage as MemoryStorage).setItem(
+      __internal.STORAGE_KEY,
+      JSON.stringify([
+        { name: 'Mixed', combinator: 'AND', rules: [
+          { kind: 'ifcType', values: ['IfcWall'], op: 'in' },
+          { kind: 'unknown' },
+        ], updatedAt: 1 },
+      ]),
+    );
+    const list = loadSavedFilters();
+    assert.strictEqual(list.length, 1);
+    assert.strictEqual(list[0].rules.length, 1, 'invalid rule was filtered');
+    assert.strictEqual(list[0].rules[0].kind, 'ifcType');
+  });
+});