@ifc-lite/viewer 1.26.0 → 1.28.0

package/src/lib/search/filter-evaluate.test.ts

@@ -256,6 +256,87 @@ describe('matchQuantityRule', () => {
   });
 });
 
+describe('materialNamesOf', () => {
+  it('collects top-level, layer, constituent, profile, and list names', () => {
+    const names = __internal.materialNamesOf({
+      type: 'MaterialLayerSet',
+      name: 'Wall Buildup',
+      layers: [
+        { materialName: 'Concrete C30/37' },
+        { materialName: 'Rigid Insulation', name: 'Insulation Layer' },
+      ],
+      materials: [{ name: 'Steel S355' }],
+    });
+    assert.deepStrictEqual(names, [
+      'Wall Buildup',
+      'Concrete C30/37',
+      'Rigid Insulation',
+      'Insulation Layer',
+      'Steel S355',
+    ]);
+  });
+  it('returns [] for a null MaterialInfo (no association)', () => {
+    assert.deepStrictEqual(__internal.materialNamesOf(null), []);
+  });
+});
+
+describe('matchClassificationRule', () => {
+  const refs = [
+    { system: 'Uniclass 2015', identification: 'Pr_60_10_32', name: 'External wall' },
+    { system: 'OmniClass', identification: '23-13 11 11', name: 'Walls' },
+  ];
+  it('isSet / isNotSet check presence, optionally scoped by system', () => {
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'isSet', ''), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('OmniClass', 'isSet', ''), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('SfB', 'isSet', ''), refs), false);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('SfB', 'isNotSet', ''), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'isNotSet', ''), []), true);
+  });
+  it('value ops match code (identification) OR name', () => {
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'contains', 'Pr_60'), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'contains', 'external'), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'eq', 'Pr_60_10_32'), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'contains', 'Ss_'), refs), false);
+  });
+  it('system scope excludes refs from other systems', () => {
+    // Pr_60 only exists in the Uniclass ref — scoping to OmniClass misses it.
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('OmniClass', 'contains', 'Pr_60'), refs), false);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('OmniClass', 'contains', '23-13'), refs), true);
+  });
+});
+
+describe('elevationOf + elevation rule', () => {
+  function withHierarchy(store: IfcDataStore): IfcDataStore {
+    // elementToStorey: 10,20 → storey 100 (z=0); 30 → storey 200 (z=3.5).
+    // 40 is unplaced (no storey) → elevation null → never matches.
+    (store as unknown as { spatialHierarchy: unknown }).spatialHierarchy = {
+      elementToStorey: new Map<number, number>([[10, 100], [20, 100], [30, 200]]),
+      storeyElevations: new Map<number, number>([[100, 0], [200, 3.5]]),
+    };
+    return store;
+  }
+
+  it('resolves elevation from the element’s storey, null when unplaced', () => {
+    const store = withHierarchy(buildStore(rows));
+    assert.strictEqual(__internal.elevationOf(store, 10), 0);
+    assert.strictEqual(__internal.elevationOf(store, 30), 3.5);
+    assert.strictEqual(__internal.elevationOf(store, 40), null);
+  });
+
+  it('elevation > 3 matches only elements on the high storey', () => {
+    const store = withHierarchy(buildStore(rows));
+    const out = evaluateFilterRules('m1', store, [Rule.elevation('gt', 3)], 'AND');
+    assert.deepStrictEqual(out.map((r) => r.expressId), [30]);
+  });
+
+  it('elevation rule excludes unplaced elements even with lte', () => {
+    const store = withHierarchy(buildStore(rows));
+    const out = evaluateFilterRules('m1', store, [Rule.elevation('lte', 100)], 'AND');
+    // 10, 20 (z=0) and 30 (z=3.5) qualify; 40 (unplaced) is excluded.
+    assert.deepStrictEqual(out.map((r) => r.expressId).sort(), [10, 20, 30]);
+  });
+});
+
 describe('evaluateFilterRulesFederated — per-model candidate narrowing', () => {
   it('candidateExpressIdsByModel narrows each model independently', async () => {
     const a = buildStore(rows);

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

@@ -37,21 +37,36 @@
 import {
   extractPropertiesOnDemand,
   extractQuantitiesOnDemand,
+  extractMaterialsOnDemand,
+  extractClassificationsOnDemand,
   type IfcDataStore,
+  type ClassificationInfo,
 } from '@ifc-lite/parser';
 
 import {
   combineRuleResults,
   setOpMatches,
   stringOpMatches,
+  matchStringAnyNone,
   numericOpMatches,
-  valueOpMatches,
   type Combinator,
   type FilterRule,
-  type PropertyRule,
-  type QuantityRule,
 } from './filter-rules.js';
 
+import {
+  flattenPsets,
+  flattenQtys,
+  stringifyValue,
+  matchPropertyRule,
+  matchQuantityRule,
+  defaultStoreyName,
+  materialNamesOf,
+  matchClassificationRule,
+  elevationOf,
+  type PsetRows,
+  type QtyRows,
+} from './filter-match.js';
+
 /** A single matched element. Mirrors the Rust `FilteredElement` shape. */
 export interface FilteredElement {
   modelId: string;
@@ -108,6 +123,8 @@ export function evaluateFilterRules(
     options,
     hasPropertyRule: orderedRules.some((r) => r.kind === 'property'),
     hasQuantityRule: orderedRules.some((r) => r.kind === 'quantity'),
+    hasMaterialRule: orderedRules.some((r) => r.kind === 'material'),
+    hasClassificationRule: orderedRules.some((r) => r.kind === 'classification'),
   };
 
   for (const expressId of iterIds) {
@@ -210,6 +227,8 @@ export async function evaluateFilterRulesFederated(
       options,
       hasPropertyRule: orderedRules.some((r) => r.kind === 'property'),
       hasQuantityRule: orderedRules.some((r) => r.kind === 'quantity'),
+      hasMaterialRule: orderedRules.some((r) => r.kind === 'material'),
+      hasClassificationRule: orderedRules.some((r) => r.kind === 'classification'),
     };
 
     // Walk the per-model iter in chunkSize-sized strides, yielding the
@@ -340,12 +359,17 @@ const RULE_COST: Record<FilterRule['kind'], number> = {
   ifcType:        0,
   // Pre-built reverse-map lookup.
   storey:         1,
+  // Pre-built reverse-map lookup (elementToStorey → storeyElevations).
+  elevation:      1,
   // String-table indirection.
   name:           2,
   predefinedType: 2,
   // Source-buffer parse (the AGENTS.md §2 hot path).
   property:       10,
   quantity:       10,
+  // Relationship-graph walk + on-demand resolve — as costly as a pset parse.
+  material:       10,
+  classification: 10,
 };
 
 export function orderRulesByCost(rules: readonly FilterRule[]): FilterRule[] {
@@ -365,6 +389,8 @@ interface EvalContext {
   options: EvaluateOptions;
   hasPropertyRule: boolean;
   hasQuantityRule: boolean;
+  hasMaterialRule: boolean;
+  hasClassificationRule: boolean;
 }
 
 function evaluateOneEntity(
@@ -379,6 +405,8 @@ function evaluateOneEntity(
   // parse entirely.
   let psetCache: PsetRows | null = null;
   let qtyCache: QtyRows | null = null;
+  let matCache: string[] | null = null;
+  let classCache: readonly ClassificationInfo[] | null = null;
   const psetsFor = (): PsetRows => {
     if (!psetCache) psetCache = flattenPsets(extractPropertiesOnDemand(ctx.store, expressId));
     return psetCache;
@@ -387,6 +415,14 @@ function evaluateOneEntity(
     if (!qtyCache) qtyCache = flattenQtys(extractQuantitiesOnDemand(ctx.store, expressId));
     return qtyCache;
   };
+  const matNamesFor = (): string[] => {
+    if (!matCache) matCache = materialNamesOf(extractMaterialsOnDemand(ctx.store, expressId));
+    return matCache;
+  };
+  const classFor = (): readonly ClassificationInfo[] => {
+    if (!classCache) classCache = extractClassificationsOnDemand(ctx.store, expressId);
+    return classCache;
+  };
 
   const ruleResults: boolean[] = [];
   for (const rule of orderedRules) {
@@ -396,6 +432,8 @@ function evaluateOneEntity(
       expressId,
       ctx.hasPropertyRule ? psetsFor : null,
       ctx.hasQuantityRule ? qtysFor : null,
+      ctx.hasMaterialRule ? matNamesFor : null,
+      ctx.hasClassificationRule ? classFor : null,
     );
     ruleResults.push(result);
     if (combinator === 'AND' && !result) return false;
@@ -410,6 +448,8 @@ function evaluateRule(
   expressId: number,
   psetsFor: (() => PsetRows) | null,
   qtysFor: (() => QtyRows) | null,
+  matNamesFor: (() => string[]) | null,
+  classFor: (() => readonly ClassificationInfo[]) | null,
 ): boolean {
   switch (rule.kind) {
     case 'storey': {
@@ -435,6 +475,19 @@ function evaluateRule(
       if (!qtysFor) return false;
       return matchQuantityRule(rule, qtysFor());
     }
+    case 'material': {
+      if (!matNamesFor) return false;
+      return matchStringAnyNone(rule.op, matNamesFor(), rule.value);
+    }
+    case 'classification': {
+      if (!classFor) return false;
+      return matchClassificationRule(rule, classFor());
+    }
+    case 'elevation': {
+      const elev = elevationOf(ctx.store, expressId);
+      if (elev === null) return false;
+      return numericOpMatches(rule.op, elev, rule.value);
+    }
   }
 }
 
@@ -513,90 +566,6 @@ function yieldToEventLoop(): Promise<void> {
   });
 }
 
-// ── Pset / Qto matching ──────────────────────────────────────────────────────
-
-interface PsetRow { setName: string; propertyName: string; value: string }
-type PsetRows = ReadonlyArray<PsetRow>;
-
-interface QtyRow { setName: string; quantityName: string; value: number }
-type QtyRows = ReadonlyArray<QtyRow>;
-
-function flattenPsets(
-  psets: ReturnType<typeof extractPropertiesOnDemand>,
-): PsetRows {
-  const out: PsetRow[] = [];
-  for (const set of psets) {
-    for (const p of set.properties) {
-      out.push({
-        setName: set.name,
-        propertyName: p.name,
-        // Stringify everything — `valueOpMatches` re-parses numeric ops
-        // from this representation. Booleans render as "true"/"false"
-        // which matches the chip UI's lowercased input convention.
-        value: stringifyValue(p.value),
-      });
-    }
-  }
-  return out;
-}
-
-function flattenQtys(
-  qtos: ReturnType<typeof extractQuantitiesOnDemand>,
-): QtyRows {
-  const out: QtyRow[] = [];
-  for (const set of qtos) {
-    for (const q of set.quantities) {
-      out.push({ setName: set.name, quantityName: q.name, value: q.value });
-    }
-  }
-  return out;
-}
-
-function stringifyValue(value: unknown): string {
-  if (value === null || value === undefined) return '';
-  if (typeof value === 'boolean') return value ? 'true' : 'false';
-  if (typeof value === 'number') return String(value);
-  return String(value);
-}
-
-function matchPropertyRule(rule: PropertyRule, rows: PsetRows): boolean {
-  // isSet / isNotSet are presence checks against (setName, propertyName).
-  if (rule.op === 'isSet' || rule.op === 'isNotSet') {
-    const present = rows.some(
-      (r) =>
-        r.setName.toLowerCase() === rule.setName.toLowerCase() &&
-        r.propertyName.toLowerCase() === rule.propertyName.toLowerCase(),
-    );
-    return rule.op === 'isSet' ? present : !present;
-  }
-
-  return rows.some(
-    (r) =>
-      r.setName.toLowerCase() === rule.setName.toLowerCase() &&
-      r.propertyName.toLowerCase() === rule.propertyName.toLowerCase() &&
-      valueOpMatches(rule.op, r.value, rule.value),
-  );
-}
-
-function matchQuantityRule(rule: QuantityRule, rows: QtyRows): boolean {
-  return rows.some(
-    (r) =>
-      r.setName.toLowerCase() === rule.setName.toLowerCase() &&
-      r.quantityName.toLowerCase() === rule.quantityName.toLowerCase() &&
-      numericOpMatches(rule.op, r.value, rule.value),
-  );
-}
-
-// ── Storey lookup fallback ────────────────────────────────────────────────────
-
-function defaultStoreyName(store: IfcDataStore, expressId: number): string {
-  const hierarchy = store.spatialHierarchy;
-  if (!hierarchy) return '';
-  const storeyId = hierarchy.elementToStorey.get(expressId);
-  if (!storeyId) return '';
-  return store.entities.getName(storeyId);
-}
-
 // ── Exposed for tests ────────────────────────────────────────────────────────
 
 export const __internal = {
@@ -605,6 +574,9 @@ export const __internal = {
   stringifyValue,
   matchPropertyRule,
   matchQuantityRule,
+  materialNamesOf,
+  matchClassificationRule,
+  elevationOf,
   orderRulesByCost,
   selectIterationSource,
 };

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

@@ -0,0 +1,167 @@
+/* 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/. */
+
+/**
+ * Per-rule value resolution + matching for the path-B evaluator.
+ *
+ * Split out of `filter-evaluate.ts` (which keeps the iteration /
+ * orchestration logic) to stay under the module size cap. These helpers
+ * are pure given their inputs, which is what makes them unit-testable in
+ * `filter-evaluate.test.ts` via the evaluator's `__internal` re-export.
+ */
+
+import {
+  extractPropertiesOnDemand,
+  extractQuantitiesOnDemand,
+  type IfcDataStore,
+  type MaterialInfo,
+  type ClassificationInfo,
+} from '@ifc-lite/parser';
+
+import {
+  valueOpMatches,
+  numericOpMatches,
+  matchStringAnyNone,
+  type PropertyRule,
+  type QuantityRule,
+  type ClassificationRule,
+} from './filter-rules.js';
+
+// ── Pset / Qto matching ──────────────────────────────────────────────────────
+
+export interface PsetRow { setName: string; propertyName: string; value: string }
+export type PsetRows = ReadonlyArray<PsetRow>;
+
+export interface QtyRow { setName: string; quantityName: string; value: number }
+export type QtyRows = ReadonlyArray<QtyRow>;
+
+export function flattenPsets(
+  psets: ReturnType<typeof extractPropertiesOnDemand>,
+): PsetRows {
+  const out: PsetRow[] = [];
+  for (const set of psets) {
+    for (const p of set.properties) {
+      out.push({
+        setName: set.name,
+        propertyName: p.name,
+        // Stringify everything — `valueOpMatches` re-parses numeric ops
+        // from this representation. Booleans render as "true"/"false"
+        // which matches the chip UI's lowercased input convention.
+        value: stringifyValue(p.value),
+      });
+    }
+  }
+  return out;
+}
+
+export function flattenQtys(
+  qtos: ReturnType<typeof extractQuantitiesOnDemand>,
+): QtyRows {
+  const out: QtyRow[] = [];
+  for (const set of qtos) {
+    for (const q of set.quantities) {
+      out.push({ setName: set.name, quantityName: q.name, value: q.value });
+    }
+  }
+  return out;
+}
+
+export function stringifyValue(value: unknown): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  return String(value);
+}
+
+export function matchPropertyRule(rule: PropertyRule, rows: PsetRows): boolean {
+  // isSet / isNotSet are presence checks against (setName, propertyName).
+  if (rule.op === 'isSet' || rule.op === 'isNotSet') {
+    const present = rows.some(
+      (r) =>
+        r.setName.toLowerCase() === rule.setName.toLowerCase() &&
+        r.propertyName.toLowerCase() === rule.propertyName.toLowerCase(),
+    );
+    return rule.op === 'isSet' ? present : !present;
+  }
+
+  return rows.some(
+    (r) =>
+      r.setName.toLowerCase() === rule.setName.toLowerCase() &&
+      r.propertyName.toLowerCase() === rule.propertyName.toLowerCase() &&
+      valueOpMatches(rule.op, r.value, rule.value),
+  );
+}
+
+export function matchQuantityRule(rule: QuantityRule, rows: QtyRows): boolean {
+  return rows.some(
+    (r) =>
+      r.setName.toLowerCase() === rule.setName.toLowerCase() &&
+      r.quantityName.toLowerCase() === rule.quantityName.toLowerCase() &&
+      numericOpMatches(rule.op, r.value, rule.value),
+  );
+}
+
+// ── Storey lookup fallback ────────────────────────────────────────────────────
+
+export function defaultStoreyName(store: IfcDataStore, expressId: number): string {
+  const hierarchy = store.spatialHierarchy;
+  if (!hierarchy) return '';
+  const storeyId = hierarchy.elementToStorey.get(expressId);
+  if (!storeyId) return '';
+  return store.entities.getName(storeyId);
+}
+
+// ── Material / classification / elevation resolution ─────────────────────────
+
+/** Collect every material-name string an element exposes — top-level
+ *  material, plus layer / constituent / profile names and list members.
+ *  Used by the multi-valued `material` rule matcher. */
+export function materialNamesOf(info: MaterialInfo | null): string[] {
+  if (!info) return [];
+  const names: string[] = [];
+  const push = (s: string | undefined) => { if (s) names.push(s); };
+  push(info.name);
+  for (const l of info.layers ?? []) { push(l.materialName); push(l.name); }
+  for (const c of info.constituents ?? []) { push(c.materialName); push(c.name); }
+  for (const p of info.profiles ?? []) { push(p.materialName); push(p.name); }
+  for (const m of info.materials ?? []) push(m.name);
+  return names;
+}
+
+/** Match a classification rule against an element's classification refs.
+ *  `system` (when set) scopes to one classification system; value ops
+ *  match a ref's code (identification) OR name. */
+export function matchClassificationRule(
+  rule: ClassificationRule,
+  refs: readonly ClassificationInfo[],
+): boolean {
+  const sys = rule.system?.trim().toLowerCase();
+  const scoped = sys
+    ? refs.filter((r) => (r.system ?? '').toLowerCase() === sys)
+    : refs;
+
+  if (rule.op === 'isSet') return scoped.length > 0;
+  if (rule.op === 'isNotSet') return scoped.length === 0;
+
+  // Value ops — match against identification (code) and name of each ref.
+  const candidates: string[] = [];
+  for (const r of scoped) {
+    if (r.identification) candidates.push(r.identification);
+    if (r.name) candidates.push(r.name);
+  }
+  // rule.op is now eq | ne | contains | notContains — a StringOp subset.
+  return matchStringAnyNone(rule.op, candidates, rule.value);
+}
+
+/** Element elevation in metres, derived from its building storey's
+ *  elevation. Returns null when the element isn't placed in the spatial
+ *  hierarchy (so an elevation rule simply doesn't match it). */
+export function elevationOf(store: IfcDataStore, expressId: number): number | null {
+  const hierarchy = store.spatialHierarchy;
+  if (!hierarchy) return null;
+  const storeyId = hierarchy.elementToStorey.get(expressId);
+  if (!storeyId) return null;
+  const elev = hierarchy.storeyElevations.get(storeyId);
+  return typeof elev === 'number' ? elev : null;
+}

package/src/lib/search/filter-rules.test.ts

@@ -7,6 +7,7 @@ import assert from 'node:assert';
 import {
   setOpMatches,
   stringOpMatches,
+  matchStringAnyNone,
   numericOpMatches,
   valueOpMatches,
   combineRuleResults,
@@ -46,6 +47,27 @@ describe('stringOpMatches', () => {
   });
 });
 
+describe('matchStringAnyNone', () => {
+  const layers = ['Concrete C30/37', 'Rigid Insulation', 'Gypsum Board'];
+  it('positive ops match if ANY candidate satisfies them', () => {
+    assert.strictEqual(matchStringAnyNone('contains', layers, 'insulation'), true);
+    assert.strictEqual(matchStringAnyNone('eq', layers, 'gypsum board'), true);
+    assert.strictEqual(matchStringAnyNone('startsWith', layers, 'concrete'), true);
+    assert.strictEqual(matchStringAnyNone('contains', layers, 'timber'), false);
+  });
+  it('negative ops match only if NO candidate violates them', () => {
+    assert.strictEqual(matchStringAnyNone('notContains', layers, 'timber'), true);
+    assert.strictEqual(matchStringAnyNone('notContains', layers, 'concrete'), false);
+    assert.strictEqual(matchStringAnyNone('ne', layers, 'steel'), true);
+    assert.strictEqual(matchStringAnyNone('ne', layers, 'gypsum board'), false);
+  });
+  it('an empty candidate set never matches — including negative ops', () => {
+    assert.strictEqual(matchStringAnyNone('contains', [], 'concrete'), false);
+    assert.strictEqual(matchStringAnyNone('notContains', [], 'concrete'), false);
+    assert.strictEqual(matchStringAnyNone('ne', [], 'concrete'), false);
+  });
+});
+
 describe('numericOpMatches', () => {
   it('eq uses 1e-9 epsilon (matches Rust impl)', () => {
     assert.strictEqual(numericOpMatches('eq', 1.0 + 1e-12, 1.0), true);
@@ -101,6 +123,9 @@ describe('isFilterRule / parseFilterRules', () => {
     assert.strictEqual(isFilterRule(Rule.name('contains', 'wall')), true);
     assert.strictEqual(isFilterRule(Rule.property('Pset_X', 'P', 'eq', 'v')), true);
     assert.strictEqual(isFilterRule(Rule.quantity('Qto_X', 'Q', 'gt', 1)), true);
+    assert.strictEqual(isFilterRule(Rule.material('contains', 'Concrete')), true);
+    assert.strictEqual(isFilterRule(Rule.classification('Uniclass', 'contains', 'Pr_')), true);
+    assert.strictEqual(isFilterRule(Rule.elevation('gt', 3)), true);
   });
   it('rejects unknown kinds and non-objects', () => {
     assert.strictEqual(isFilterRule({ kind: 'bogus' }), false);

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

@@ -37,6 +37,11 @@ export type ValueOp =
   | 'isSet'
   | 'isNotSet';
 
+/** Classification value+presence ops. A classification is matched against
+ *  its code / name string, so this is the StringOp comparison subset plus
+ *  presence — numeric ops don't apply. */
+export type ClassificationOp = 'eq' | 'ne' | 'contains' | 'notContains' | 'isSet' | 'isNotSet';
+
 /** Top-level rule combinator. */
 export type Combinator = 'AND' | 'OR';
 
@@ -83,13 +88,47 @@ export interface QuantityRule {
   value: number;
 }
 
+/** Match against an element's material name(s) — top-level material,
+ *  layer / constituent / profile names, and list members. Multi-valued:
+ *  the evaluator matches if ANY name satisfies a positive op, or NONE
+ *  violates a negative op (ne / notContains). */
+export interface MaterialRule {
+  kind: 'material';
+  op: StringOp;
+  value: string;
+}
+
+/** Match against an element's classification references (e.g. Uniclass,
+ *  OmniClass). `system` optionally scopes to one classification system;
+ *  the value matches a reference's code (identification) OR name. */
+export interface ClassificationRule {
+  kind: 'classification';
+  /** Optional system scope (e.g. "Uniclass 2015"). Empty = any system. */
+  system?: string;
+  op: ClassificationOp;
+  /** Matched against identification (code) OR name. Ignored for isSet/isNotSet. */
+  value: string;
+}
+
+/** Match against an element's elevation in metres — derived from the
+ *  elevation of the building storey the element belongs to. */
+export interface ElevationRule {
+  kind: 'elevation';
+  op: NumericOp;
+  /** Threshold in metres. */
+  value: number;
+}
+
 export type FilterRule =
   | StoreyRule
   | IfcTypeRule
   | PredefinedTypeRule
   | NameRule
   | PropertyRule
-  | QuantityRule;
+  | QuantityRule
+  | MaterialRule
+  | ClassificationRule
+  | ElevationRule;
 
 // ── Pure op helpers (ported verbatim from filter.rs) ──────────────────────────
 
@@ -110,6 +149,33 @@ export function stringOpMatches(op: StringOp, candidate: string, value: string):
   }
 }
 
+/**
+ * Match a StringOp against a *set* of candidate strings — used for
+ * multi-valued dimensions (an element's material names, a classification's
+ * code+name pair). Positive ops (eq / contains / startsWith) match if ANY
+ * candidate satisfies them; negative ops (ne / notContains) match only if
+ * NO candidate violates them. An empty candidate set never matches: an
+ * element with no materials/classifications shouldn't satisfy a filter on
+ * that dimension (including the negative ops).
+ */
+export function matchStringAnyNone(
+  op: StringOp,
+  candidates: readonly string[],
+  value: string,
+): boolean {
+  if (candidates.length === 0) return false;
+  switch (op) {
+    case 'eq':
+    case 'contains':
+    case 'startsWith':
+      return candidates.some((c) => stringOpMatches(op, c, value));
+    case 'ne':
+      return candidates.every((c) => stringOpMatches('eq', c, value) === false);
+    case 'notContains':
+      return candidates.every((c) => stringOpMatches('contains', c, value) === false);
+  }
+}
+
 export function numericOpMatches(op: NumericOp, candidate: number, value: number): boolean {
   // The Rust side uses 1e-9 as the epsilon for eq/ne. Match it here for
   // IDS-style parity — IFC quantities are stored as IFC4 IfcReal so the
@@ -175,6 +241,10 @@ export const Rule = {
     ({ kind: 'property', setName, propertyName, op, value }),
   quantity: (setName: string, quantityName: string, op: NumericOp, value: number): QuantityRule =>
     ({ kind: 'quantity', setName, quantityName, op, value }),
+  material: (op: StringOp, value: string): MaterialRule => ({ kind: 'material', op, value }),
+  classification: (system: string, op: ClassificationOp, value: string): ClassificationRule =>
+    ({ kind: 'classification', system: system || undefined, op, value }),
+  elevation: (op: NumericOp, value: number): ElevationRule => ({ kind: 'elevation', op, value }),
 } as const;
 
 // ── JSON guards ──────────────────────────────────────────────────────────────
@@ -188,7 +258,10 @@ export function isFilterRule(value: unknown): value is FilterRule {
     kind === 'predefinedType' ||
     kind === 'name' ||
     kind === 'property' ||
-    kind === 'quantity'
+    kind === 'quantity' ||
+    kind === 'material' ||
+    kind === 'classification' ||
+    kind === 'elevation'
   );
 }
 

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

@@ -33,9 +33,15 @@ function cellToString(v: unknown): string {
 }
 
 /** RFC-4180-style escaping: quote any cell containing comma, quote, or
- *  newline; double-up embedded quotes inside the wrapped cell. */
+ *  newline; double-up embedded quotes inside the wrapped cell. Also
+ *  neutralises spreadsheet formula triggers (CWE-1236) so user/model-
+ *  controlled cell values are treated as text on open. */
 function escapeCsvCell(raw: string): string {
   if (raw.length === 0) return '';
+  // CWE-1236: neutralise spreadsheet formula triggers in the leading
+  // position. Prefixing first ensures the needsQuotes check below still
+  // wraps values that also contain comma/quote/newline.
+  if (/^[=+\-@\t\r]/.test(raw)) raw = `'${raw}`;
   const needsQuotes = raw.includes(',') || raw.includes('"') || raw.includes('\n') || raw.includes('\r');
   if (!needsQuotes) return raw;
   return `"${raw.replace(/"/g, '""')}"`;