@ifc-lite/viewer 1.26.0 → 1.27.0

package/src/lib/lists/export/model.ts

@@ -0,0 +1,111 @@
+/* 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/. */
+
+/**
+ * Normalised export model shared by the CSV / Excel / PDF writers. Built from
+ * the on-screen list view so every export honours the configured columns
+ * (order, labels, widths), the active grouping, and the summed columns —
+ * grouped sections with per-group count + subtotals, plus grand totals.
+ */
+
+import type { CellValue, ColumnDefinition, ListRow, ListGrouping } from '@ifc-lite/lists';
+
+export interface ExportColumn {
+  id: string;
+  label: string;
+  numeric: boolean;
+  summed: boolean;
+  /** Pixel width from the table (for proportional column sizing in exports). */
+  width: number;
+}
+
+export interface ExportGroup {
+  label: string;
+  count: number;
+  sums: Record<string, number>;
+  rows: CellValue[][];
+}
+
+export interface ExportModel {
+  title: string;
+  generatedAt: string;
+  columns: ExportColumn[];
+  /** Grouped sections (with member rows), or null when the list isn't grouped. */
+  groups: ExportGroup[] | null;
+  /** All rows in display order (flat) — used by writers that don't section. */
+  rows: CellValue[][];
+  groupColumnId: string | null;
+  sumColumnIds: string[];
+  totals: { count: number; sums: Record<string, number> };
+}
+
+export interface BuildModelInput {
+  title: string;
+  columns: ColumnDefinition[];
+  /** Rows already filtered + sorted exactly as shown on screen. */
+  rows: ListRow[];
+  grouping?: ListGrouping;
+  numericCols: boolean[];
+  columnWidths: number[];
+  generatedAt: string;
+}
+
+/** Format a cell for text-based exports (CSV/PDF). Excel keeps raw numbers. */
+export function displayCell(value: CellValue): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'boolean') return value ? 'Yes' : 'No';
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) return value.toLocaleString();
+    return value.toFixed(4).replace(/\.?0+$/, '');
+  }
+  return String(value);
+}
+
+export function buildExportModel(input: BuildModelInput): ExportModel {
+  const { columns, rows, grouping, numericCols, columnWidths, title, generatedAt } = input;
+  const sumColumnIds = grouping?.sumColumnIds ?? [];
+  const exportCols: ExportColumn[] = columns.map((c, i) => ({
+    id: c.id,
+    label: c.label ?? c.propertyName,
+    numeric: !!numericCols[i],
+    summed: sumColumnIds.includes(c.id),
+    width: columnWidths[i] ?? 120,
+  }));
+
+  const sumIdx = sumColumnIds
+    .map((id) => ({ id, idx: columns.findIndex((c) => c.id === id) }))
+    .filter((s) => s.idx >= 0);
+  const zeroSums = (): Record<string, number> => Object.fromEntries(sumIdx.map((s) => [s.id, 0]));
+  const addSums = (acc: Record<string, number>, values: CellValue[]) => {
+    for (const s of sumIdx) {
+      const v = values[s.idx];
+      if (typeof v === 'number' && Number.isFinite(v)) acc[s.id] += v;
+    }
+  };
+
+  const totals = { count: rows.length, sums: zeroSums() };
+  const flatRows: CellValue[][] = [];
+  for (const r of rows) { flatRows.push(r.values); addSums(totals.sums, r.values); }
+
+  const groupColumnId = grouping?.columnId && columns.some((c) => c.id === grouping.columnId)
+    ? grouping.columnId : null;
+
+  let groups: ExportGroup[] | null = null;
+  if (groupColumnId) {
+    const groupIdx = columns.findIndex((c) => c.id === groupColumnId);
+    const byKey = new Map<string, ExportGroup>();
+    for (const r of rows) {
+      const raw = r.values[groupIdx];
+      const label = raw === null || raw === undefined || raw === '' ? '(none)' : displayCell(raw);
+      let g = byKey.get(label);
+      if (!g) { g = { label, count: 0, sums: zeroSums(), rows: [] }; byKey.set(label, g); }
+      g.count++;
+      g.rows.push(r.values);
+      addSums(g.sums, r.values);
+    }
+    groups = Array.from(byKey.values()).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+  }
+
+  return { title, generatedAt, columns: exportCols, groups, rows: flatRows, groupColumnId, sumColumnIds, totals };
+}

package/src/lib/lists/export/pdf.ts

@@ -0,0 +1,67 @@
+/* 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 type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel } from './model';
+
+/** Quality tabular PDF report: title + meta, dark header, grouped sections
+ *  (bold group rows carrying per-group count + subtotals), right-aligned
+ *  numerics, a grand-total foot, and page numbers. */
+export async function toPdf(model: ExportModel): Promise<Blob> {
+  const { jsPDF } = await import('jspdf');
+  const autoTable = (await import('jspdf-autotable')).default;
+
+  const landscape = model.columns.length > 5;
+  const doc = new jsPDF({ orientation: landscape ? 'landscape' : 'portrait', unit: 'pt', format: 'a4' });
+
+  doc.setFont('helvetica', 'bold'); doc.setFontSize(14);
+  doc.text(model.title || 'List', 40, 42);
+  doc.setFont('helvetica', 'normal'); doc.setFontSize(9); doc.setTextColor(130);
+  doc.text(`${model.totals.count.toLocaleString()} elements · ${model.generatedAt}`, 40, 58);
+  doc.setTextColor(0);
+
+  const head = [model.columns.map((c) => c.label)];
+  const cell = (vals: CellValue[], i: number) => displayCell(vals[i]);
+  const body: Array<Array<string | { content: string; styles: Record<string, unknown> }>> = [];
+
+  if (model.groups) {
+    for (const g of model.groups) {
+      body.push(model.columns.map((c, i) => ({
+        content: i === 0 ? `${g.label}  (${g.count})` : (c.summed ? displayCell(g.sums[c.id]) : ''),
+        styles: { fontStyle: 'bold', fillColor: [226, 232, 240] as unknown as number[] },
+      })));
+      for (const r of g.rows) body.push(model.columns.map((_, i) => cell(r, i)));
+    }
+  } else {
+    for (const r of model.rows) body.push(model.columns.map((_, i) => cell(r, i)));
+  }
+
+  const foot = model.sumColumnIds.length > 0
+    ? [model.columns.map((c, i) => (c.summed ? displayCell(model.totals.sums[c.id]) : (i === 0 ? `Total (${model.totals.count})` : '')))]
+    : undefined;
+
+  const columnStyles: Record<number, { halign: 'right' }> = {};
+  model.columns.forEach((c, i) => { if (c.numeric) columnStyles[i] = { halign: 'right' }; });
+
+  autoTable(doc, {
+    head,
+    body,
+    foot,
+    startY: 72,
+    margin: { left: 40, right: 40, top: 70, bottom: 40 },
+    styles: { fontSize: 8, cellPadding: 3, overflow: 'ellipsize', lineColor: [226, 232, 240], lineWidth: 0.5 },
+    headStyles: { fillColor: [51, 65, 85], textColor: 255, fontStyle: 'bold' },
+    footStyles: { fillColor: [241, 245, 249], textColor: 20, fontStyle: 'bold' },
+    columnStyles,
+    didDrawPage: () => {
+      doc.setFontSize(8); doc.setTextColor(150);
+      const w = doc.internal.pageSize.getWidth();
+      const h = doc.internal.pageSize.getHeight();
+      doc.text(`Page ${doc.getNumberOfPages()}`, w - 60, h - 20);
+      doc.setTextColor(0);
+    },
+  });
+
+  return doc.output('blob');
+}

package/src/lib/lists/export/xlsx.ts

@@ -0,0 +1,83 @@
+/* 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 type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel, type ExportColumn } from './model';
+
+const XLSX_MIME = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+const NUM_FMT = '#,##0.####';
+
+/** px → Excel column-width units (≈ 7px per char). */
+const excelWidth = (px: number): number => Math.max(8, Math.min(80, Math.round(px / 7)));
+
+/** Excel keeps real numbers (so the recipient can re-aggregate); other types
+ *  fall back to the same display string the table shows. */
+function cellValue(v: CellValue, c: ExportColumn): string | number | null {
+  if (v === null || v === undefined) return null;
+  if (c.numeric && typeof v === 'number' && Number.isFinite(v)) return v;
+  return displayCell(v);
+}
+
+export async function toXlsx(model: ExportModel): Promise<Blob> {
+  const ExcelJS = (await import('exceljs')).default;
+  const wb = new ExcelJS.Workbook();
+  wb.creator = 'IFC-Lite';
+  const ws = wb.addWorksheet((model.title || 'List').slice(0, 31), {
+    views: [{ state: 'frozen', ySplit: 4 }],
+  });
+
+  const cols = model.columns;
+  const ncol = cols.length;
+
+  // Title + meta.
+  ws.addRow([model.title || 'List']);
+  ws.mergeCells(1, 1, 1, ncol);
+  ws.getCell(1, 1).font = { bold: true, size: 14 };
+  ws.addRow([`${model.totals.count.toLocaleString()} elements · ${model.generatedAt}`]);
+  ws.mergeCells(2, 1, 2, ncol);
+  ws.getCell(2, 1).font = { italic: true, size: 9, color: { argb: 'FF94A3B8' } };
+  ws.addRow([]);
+
+  // Header.
+  const header = ws.addRow(cols.map((c) => c.label));
+  header.font = { bold: true, color: { argb: 'FFFFFFFF' } };
+  header.eachCell((cell) => {
+    cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF334155' } };
+    cell.alignment = { vertical: 'middle' };
+  });
+
+  // Column widths + numeric formatting/alignment.
+  cols.forEach((c, i) => {
+    const col = ws.getColumn(i + 1);
+    col.width = excelWidth(c.width);
+    if (c.numeric) { col.numFmt = NUM_FMT; col.alignment = { horizontal: 'right' }; }
+  });
+
+  const addDataRow = (values: CellValue[], outline?: number) => {
+    const r = ws.addRow(cols.map((c, i) => cellValue(values[i], c)));
+    if (outline) r.outlineLevel = outline;
+  };
+
+  if (model.groups) {
+    for (const g of model.groups) {
+      const gr = ws.addRow(cols.map((c, i) => (i === 0 ? `${g.label} (${g.count})` : (c.summed ? g.sums[c.id] : null))));
+      gr.font = { bold: true };
+      gr.eachCell((cell) => { cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFE2E8F0' } }; });
+      for (const row of g.rows) addDataRow(row, 1);
+    }
+    ws.properties.outlineLevelRow = 1;
+  } else {
+    for (const row of model.rows) addDataRow(row);
+  }
+
+  // Grand total.
+  if (model.sumColumnIds.length > 0) {
+    const tr = ws.addRow(cols.map((c, i) => (c.summed ? model.totals.sums[c.id] : (i === 0 ? `Total (${model.totals.count})` : null))));
+    tr.font = { bold: true };
+    tr.eachCell((cell) => { cell.border = { top: { style: 'double', color: { argb: 'FF334155' } } }; });
+  }
+
+  const buf = await wb.xlsx.writeBuffer();
+  return new Blob([buf], { type: XLSX_MIME });
+}

package/src/lib/lists/index.ts

@@ -14,10 +14,12 @@ export type {
   ConditionOperator,
   DiscoveredColumns,
   EntityAttribute,
+  ListGrouping,
 } from '@ifc-lite/lists';
 export {
   ENTITY_ATTRIBUTES,
   executeList,
+  summariseListRows,
   listResultToCSV,
   discoverColumns,
   LIST_PRESETS,

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,
 };