@ifc-lite/viewer 1.26.0 → 1.27.0

package/src/components/viewer/lists/list-table-utils.ts

@@ -0,0 +1,123 @@
+/* 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/. */
+
+/**
+ * Pure helpers for the Lists results table — value formatting, comparison,
+ * numeric-column detection, content-aware column widths, and the grouping /
+ * aggregation that powers the in-table (settings-free) grouped view.
+ */
+
+import type { CellValue, ColumnDefinition, ListRow, ListGrouping } from '@ifc-lite/lists';
+
+export function formatCellValue(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 compareCells(a: CellValue, b: CellValue): number {
+  if (a === null && b === null) return 0;
+  if (a === null) return -1;
+  if (b === null) return 1;
+  if (typeof a === 'number' && typeof b === 'number') return a - b;
+  return String(a).localeCompare(String(b));
+}
+
+/** A column is numeric (summable) when every sampled non-empty value is a
+ *  finite number and at least one such value exists. */
+export function detectNumericColumns(columns: ColumnDefinition[], rows: ListRow[]): boolean[] {
+  const sample = rows.slice(0, 120);
+  return columns.map((_, i) => {
+    let sawNumber = false;
+    for (const r of sample) {
+      const v = r.values[i];
+      if (v === null || v === undefined || v === '') continue;
+      if (typeof v === 'number' && Number.isFinite(v)) { sawNumber = true; continue; }
+      return false;
+    }
+    return sawNumber;
+  });
+}
+
+/** Content-aware default width: fits the header + the widest sampled value
+ *  (≈7px/char), clamped to a readable range. */
+export function autoColumnWidth(label: string, rows: ListRow[], colIdx: number): number {
+  let maxLen = label.length;
+  const sample = rows.slice(0, 200);
+  for (const r of sample) {
+    const v = r.values[colIdx];
+    if (v === null || v === undefined) continue;
+    const len = (typeof v === 'number' ? formatCellValue(v) : String(v)).length;
+    if (len > maxLen) maxLen = len;
+  }
+  return Math.max(80, Math.min(460, maxLen * 7 + 34));
+}
+
+export type DisplayItem =
+  | { kind: 'group'; key: string; label: string; count: number; sums: Record<string, number> }
+  | { kind: 'row'; row: ListRow };
+
+export interface Totals { count: number; sums: Record<string, number> }
+export interface GroupedView { items: DisplayItem[]; groupCount: number; totals: Totals }
+
+function sumIndices(columns: ColumnDefinition[], sumColumnIds: string[]) {
+  return sumColumnIds
+    .map((id) => ({ id, idx: columns.findIndex((c) => c.id === id) }))
+    .filter((s) => s.idx >= 0);
+}
+
+/** Bucket already-filtered/sorted rows by the group-by column, accumulate
+ *  per-group + grand count/sums, and flatten into a virtualizable list
+ *  (group header followed by its rows when the group is expanded). */
+export function buildGroupedView(
+  rows: ListRow[],
+  columns: ColumnDefinition[],
+  grouping: ListGrouping,
+  expanded: Set<string>,
+): GroupedView {
+  const groupIdx = columns.findIndex((c) => c.id === grouping.columnId);
+  const sums = sumIndices(columns, grouping.sumColumnIds);
+  const zero = (): Record<string, number> => Object.fromEntries(sums.map((s) => [s.id, 0]));
+
+  const totals: Totals = { count: rows.length, sums: zero() };
+  const byKey = new Map<string, { key: string; label: string; count: number; sums: Record<string, number>; rows: ListRow[] }>();
+
+  for (const row of rows) {
+    const raw = groupIdx >= 0 ? row.values[groupIdx] : null;
+    const label = raw === null || raw === undefined || raw === '' ? '(none)' : formatCellValue(raw);
+    let g = byKey.get(label);
+    if (!g) { g = { key: label, label, count: 0, sums: zero(), rows: [] }; byKey.set(label, g); }
+    g.count++;
+    g.rows.push(row);
+    for (const s of sums) {
+      const v = row.values[s.idx];
+      if (typeof v === 'number' && Number.isFinite(v)) { g.sums[s.id] += v; totals.sums[s.id] += v; }
+    }
+  }
+
+  const groups = Array.from(byKey.values()).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+  const items: DisplayItem[] = [];
+  for (const g of groups) {
+    items.push({ kind: 'group', key: g.key, label: g.label, count: g.count, sums: g.sums });
+    if (expanded.has(g.key)) for (const r of g.rows) items.push({ kind: 'row', row: r });
+  }
+  return { items, groupCount: groups.length, totals };
+}
+
+/** Grand totals for the flat (ungrouped) view when sum columns are active. */
+export function flatTotals(rows: ListRow[], columns: ColumnDefinition[], sumColumnIds: string[]): Totals {
+  const sums = sumIndices(columns, sumColumnIds);
+  const acc: Record<string, number> = Object.fromEntries(sums.map((s) => [s.id, 0]));
+  for (const r of rows) {
+    for (const s of sums) {
+      const v = r.values[s.idx];
+      if (typeof v === 'number' && Number.isFinite(v)) acc[s.id] += v;
+    }
+  }
+  return { count: rows.length, sums: acc };
+}

package/src/generated/mcp-catalog.json

@@ -25,6 +25,10 @@
     { "name": "geometry_volume",     "category": "Geometry",   "scope": "read",   "description": "Net/gross volume in m³ for a single entity or a type aggregate.", "inputSchema": { "type": "object", "required": ["global_id"] } },
     { "name": "geometry_area",       "category": "Geometry",   "scope": "read",   "description": "Surface area for an entity (front/side/footprint depending on what the IFC carries).", "inputSchema": { "type": "object", "required": ["global_id"] } },
 
+    { "name": "clash_check",         "category": "Clash",      "scope": "read",   "description": "Find clashes in a single model — the DEFAULT for any 'find/run clashes' request. Omit BOTH a and b to check every element vs every other (all clashes in the model). Give a TYPE selector for a to self-clash within a group, or both a and b for a pairwise check (a=\"IfcDuct*\", b=\"IfcWall*\"). Meshes the model in-browser; returns a summary plus the worst clashes by penetration depth.", "inputSchema": { "type": "object", "properties": { "a": { "type": "string", "description": "Type selector for set A. Defaults to \"*\" (all elements). e.g. \"IfcDuct*|IfcPipe*\", \"!IfcSpace\"." }, "b": { "type": "string", "description": "Type selector for set B. OMIT for a self-clash within A (every element vs every other in the group)." }, "mode": { "type": "string", "enum": ["hard", "clearance"] }, "tolerance": { "type": "number", "description": "Touching band (m). Defaults to the engine tolerance." }, "clearance": { "type": "number", "description": "Required gap (m) for mode=\"clearance\"." }, "model_id": { "type": "string", "description": "Optional; defaults to the only loaded model." } } } },
+    { "name": "clash_matrix",        "category": "Clash",      "scope": "read",   "description": "Run the standard discipline clash matrix (MEP×STR, HVAC×ARCH, ...) — INTER-discipline pairs ONLY. Returns NOTHING on a single-discipline or architectural model (no cross-discipline pairs exist to test). For a general 'find all clashes' request use clash_check instead; use this only when the user explicitly asks for the discipline matrix. Returns per-rule and per-severity breakdowns plus a sample of the worst clashes.", "inputSchema": { "type": "object", "properties": { "mode": { "type": "string", "enum": ["hard", "clearance"] }, "clearance": { "type": "number", "description": "Required gap (m) applied to every matrix rule when mode=\"clearance\". Without it a clearance matrix reports nothing." }, "model_id": { "type": "string", "description": "Optional; defaults to the only loaded model." } } } },
+    { "name": "clash_bcf_export",    "category": "Clash",      "scope": "export", "description": "Turn the last clash run (clash_check / clash_matrix) into a rich .bcfzip: one BCF topic per clash group, each with a framed 3D viewpoint, the clashing elements as components, and severity/status/distance metadata. Runs a default all-vs-all clash_check first if you haven't clashed yet. Use THIS for 'create/export BCF from clashes' — not bcf_topic_create. (Snapshots are omitted: the inline viewer can't render frames headlessly; BCF viewpoints are valid without an image.)", "inputSchema": { "type": "object", "properties": { "group_by": { "type": "string", "enum": ["cluster", "rule", "typePair", "element"], "description": "How clashes collapse into topics. Default \"cluster\" (spatially-near clashes merge into one topic)." }, "cluster_epsilon": { "type": "number", "description": "Cluster radius (m) for group_by=\"cluster\". Default 1.5." }, "status": { "type": "string", "description": "BCF topic status, e.g. \"Open\"." }, "max_topics": { "type": "integer", "description": "Cap the number of topics. Default 1000." }, "file_path": { "type": "string", "description": "Output .bcfzip name." } } } },
+
     { "name": "model_audit",         "category": "Validation", "scope": "read",   "description": "Out-of-the-box health score + a list of issues (missing GlobalIds, broken refs, orphan entities).", "inputSchema": { "type": "object" } },
     { "name": "ids_validate",        "category": "Validation", "scope": "read",   "description": "Run a buildingSMART IDS spec against the loaded model. Per-spec pass/fail with offending entities.", "inputSchema": { "type": "object", "required": ["ids_path"], "properties": { "ids_path": { "type": "string" } } } },
     { "name": "ids_explain",         "category": "Validation", "scope": "read",   "description": "Parse + summarize an IDS file in plain language — what each spec asks for, in what order.", "inputSchema": { "type": "object", "required": ["ids_path"] } },

package/src/hooks/source-key.ts

@@ -0,0 +1,35 @@
+/* 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 { IfcDataStore } from '@ifc-lite/parser';
+
+// Per-source-object memo so the full-content hash runs only once per loaded
+// buffer (the same Uint8Array instance is reused across re-renders).
+const SOURCE_KEY_CACHE = new WeakMap<Uint8Array, string>();
+
+/**
+ * Stable per-source cache key — a **full-content** FNV-1a hash (not sampled
+ * byte windows), so two distinct IFC binaries can't collide and reuse the wrong
+ * cache entry (which would render another model's overlay). The O(n) hash is
+ * memoised per source object via a WeakMap, so it runs once per loaded buffer.
+ *
+ * Shared by the per-source overlay hooks (alignment + grid lines) so they stay
+ * in lockstep — see #967 review (CodeRabbit aliasing finding applied to both).
+ */
+export function sourceKey(store: IfcDataStore | null | undefined): string | null {
+  const source = store?.source;
+  if (!source || source.byteLength === 0) return null;
+
+  const cached = SOURCE_KEY_CACHE.get(source);
+  if (cached) return cached;
+
+  let h = 0x811c9dc5;
+  for (let i = 0; i < source.length; i++) {
+    h ^= source[i];
+    h = Math.imul(h, 0x01000193);
+  }
+  const key = `b${source.byteLength}-${(h >>> 0).toString(16)}`;
+  SOURCE_KEY_CACHE.set(source, key);
+  return key;
+}

package/src/hooks/useAlignmentLines3D.ts

@@ -23,35 +23,10 @@ import { GeometryProcessor } from '@ifc-lite/geometry';
 import { useViewerStore } from '@/store';
 import { useShallow } from 'zustand/react/shallow';
 import type { IfcDataStore } from '@ifc-lite/parser';
+import { sourceKey } from './source-key.js';
 
 const EMPTY_F32 = new Float32Array(0);
 
-/**
- * Stable per-source cache key — FNV-1a over head/mid/tail byte windows folded
- * with the length, so two structurally distinct sources can't alias even when
- * they share an exact byte length (a real risk in federated views). Identical
- * scheme to `useSymbolicAnnotations`' `sourceKey`.
- */
-function sourceKey(store: IfcDataStore | null | undefined): string | null {
-  const source = store?.source;
-  if (!source || source.byteLength === 0) return null;
-  const len = source.byteLength;
-  const sampleLen = Math.min(32, len);
-  const head = source.subarray(0, sampleLen);
-  const tail = source.subarray(len - sampleLen, len);
-  const midOffset = Math.max(0, Math.floor(len / 2) - Math.floor(sampleLen / 2));
-  const mid = source.subarray(midOffset, Math.min(midOffset + sampleLen, len));
-  const hashOne = (bytes: Uint8Array): string => {
-    let h = 0x811c9dc5;
-    for (let i = 0; i < bytes.length; i++) {
-      h ^= bytes[i];
-      h = Math.imul(h, 0x01000193);
-    }
-    return (h >>> 0).toString(16);
-  };
-  return `b${len}-${hashOne(head)}-${hashOne(mid)}-${hashOne(tail)}`;
-}
-
 // ─── Shared parse cache ──────────────────────────────────────────────────────
 // One WASM walk per model source; cached so re-renders (and federated views
 // that share a source) don't re-parse.

package/src/hooks/useGridLines3D.ts

@@ -0,0 +1,140 @@
+/* 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/. */
+
+/**
+ * Extraction of IfcGrid / IfcGridAxis centerlines for the 3D viewport
+ * (issue #967, follow-up to #945/#966).
+ *
+ * IfcGrid carries its axes as IfcGridAxis curves (not a `Representation`), so
+ * they never produce a mesh in the streaming batch mesher. The WASM
+ * `parseGridLines` API resolves every axis through the same placement +
+ * unit-scale + RTC pipeline as the meshes and returns a flat 3D line-list in
+ * renderer Y-up world space, which we feed to `renderer.uploadGridLines3D`.
+ * This mirrors `useAlignmentLines3D`.
+ *
+ * Unlike alignment (always-on), grids are gated by the `ifcGrid` type-visibility
+ * toggle — but the parse itself is unconditional and cached; the Viewport only
+ * uploads/clears based on the toggle.
+ */
+
+import { useEffect, useMemo, useState } from 'react';
+import { GeometryProcessor } from '@ifc-lite/geometry';
+import { useViewerStore } from '@/store';
+import { useShallow } from 'zustand/react/shallow';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import { sourceKey } from './source-key.js';
+
+const EMPTY_F32 = new Float32Array(0);
+
+// ─── Shared parse cache ──────────────────────────────────────────────────────
+// One WASM walk per model source; cached so re-renders (and federated views
+// that share a source) don't re-parse.
+const PARSE_CACHE = new Map<string, Float32Array>();
+const PARSE_INFLIGHT = new Map<string, Promise<void>>();
+
+type CacheListener = () => void;
+const CACHE_LISTENERS = new Set<CacheListener>();
+function notifyCacheChange(): void {
+  for (const fn of CACHE_LISTENERS) fn();
+}
+
+async function parseGridLinesFor(store: IfcDataStore): Promise<Float32Array> {
+  const source = store.source;
+  if (!source || source.byteLength === 0) return EMPTY_F32;
+  const processor = new GeometryProcessor();
+  try {
+    await processor.init();
+    const verts = processor.parseGridLines(source);
+    return verts && verts.length > 0 ? verts : EMPTY_F32;
+  } finally {
+    processor.dispose();
+  }
+}
+
+function ensureParseFor(stores: IfcDataStore[]): void {
+  for (const store of stores) {
+    const key = sourceKey(store);
+    if (!key) continue;
+    if (PARSE_CACHE.has(key)) continue;
+    if (PARSE_INFLIGHT.has(key)) continue;
+
+    const promise = (async () => {
+      try {
+        const verts = await parseGridLinesFor(store);
+        PARSE_CACHE.set(key, verts);
+        notifyCacheChange();
+      } catch (error) {
+        // Cache empty on failure so we don't retry a doomed parse every tick.
+        // eslint-disable-next-line no-console
+        console.warn('[useGridLines3D] parse failed:', error);
+        PARSE_CACHE.set(key, EMPTY_F32);
+        notifyCacheChange();
+      } finally {
+        PARSE_INFLIGHT.delete(key);
+      }
+    })();
+    PARSE_INFLIGHT.set(key, promise);
+  }
+}
+
+/** Read the active store set from the viewer store. Federation-aware. */
+function useActiveStores(): IfcDataStore[] {
+  const { models, ifcDataStore } = useViewerStore(
+    useShallow((s) => ({ models: s.models, ifcDataStore: s.ifcDataStore })),
+  );
+  return useMemo(() => {
+    const out: IfcDataStore[] = [];
+    if (models.size > 0) {
+      for (const [, m] of models) if (m.ifcDataStore) out.push(m.ifcDataStore);
+    } else if (ifcDataStore) {
+      out.push(ifcDataStore);
+    }
+    return out;
+  }, [models, ifcDataStore]);
+}
+
+/**
+ * Sample every loaded model's IfcGridAxis lines into a single flat
+ * `[x0,y0,z0, x1,y1,z1, …]` line-list in renderer world space (Y-up,
+ * RTC-subtracted, metres). Returns a stable empty array when no model carries a
+ * grid. Parsing is unconditional + cached; the Viewport gates rendering on the
+ * `ifcGrid` type-visibility toggle.
+ */
+export function useGridLines3D(): Float32Array {
+  const stores = useActiveStores();
+  const [version, setVersion] = useState(0);
+
+  useEffect(() => {
+    ensureParseFor(stores);
+    const listener: CacheListener = () => setVersion((v) => v + 1);
+    CACHE_LISTENERS.add(listener);
+    return () => {
+      CACHE_LISTENERS.delete(listener);
+    };
+  }, [stores]);
+
+  return useMemo(() => {
+    void version; // depend on parse-completion ticks
+    const arrays: Float32Array[] = [];
+    let total = 0;
+    for (const store of stores) {
+      const key = sourceKey(store);
+      if (!key) continue;
+      const cached = PARSE_CACHE.get(key);
+      if (cached && cached.length > 0) {
+        arrays.push(cached);
+        total += cached.length;
+      }
+    }
+    if (total === 0) return EMPTY_F32;
+    if (arrays.length === 1) return arrays[0];
+    const merged = new Float32Array(total);
+    let offset = 0;
+    for (const a of arrays) {
+      merged.set(a, offset);
+      offset += a.length;
+    }
+    return merged;
+  }, [stores, version]);
+}

package/src/lib/length-unit-scale.ts

@@ -0,0 +1,41 @@
+/* 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/. */
+
+/**
+ * Model length-unit → metres scale, memoised per `IfcDataStore`.
+ *
+ * The viewer's render + authoring space is **metres**: the geometry
+ * pipeline bakes the file's length-unit scale into tessellated vertices,
+ * raycast hit-points come back in metres, and `spatialHierarchy.
+ * storeyElevations` are pre-scaled. But raw coordinate reads straight off
+ * the STEP model — split footprints, placement chains — arrive in the
+ * file's **native** units (e.g. millimetres). Multiply those by this
+ * factor to bring them into the same metre space as everything else.
+ *
+ * Returns `1` when the scale can't be determined (already-metres models,
+ * or bounded-geometry mode having released the source buffer) — the
+ * safe identity that leaves native-unit reads untouched.
+ */
+
+import { extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
+
+const scaleCache = new WeakMap<IfcDataStore, number>();
+
+export function getModelLengthUnitScale(dataStore: IfcDataStore | null | undefined): number {
+  if (!dataStore) return 1;
+  const cached = scaleCache.get(dataStore);
+  if (cached !== undefined) return cached;
+
+  // The columnar parser stashes the scale on the store; the wasm fast
+  // path does not, so fall back to extracting it from the source bytes.
+  let scale = typeof dataStore.lengthUnitScale === 'number' ? dataStore.lengthUnitScale : undefined;
+  if (scale === undefined || !Number.isFinite(scale) || scale <= 0) {
+    if (!dataStore.source?.length || !dataStore.entityIndex) return 1;
+    scale = extractLengthUnitScale(dataStore.source, dataStore.entityIndex);
+  }
+  if (!Number.isFinite(scale) || scale <= 0) scale = 1;
+
+  scaleCache.set(dataStore, scale);
+  return scale;
+}

package/src/lib/lists/adapter.ts

@@ -11,10 +11,31 @@
  * and Tag which are not stored during the fast initial parse.
  */
 
-import type { IfcDataStore } from '@ifc-lite/parser';
-import { extractPropertiesOnDemand, extractQuantitiesOnDemand, extractEntityAttributesOnDemand } from '@ifc-lite/parser';
+import type { IfcDataStore, MaterialInfo } from '@ifc-lite/parser';
+import {
+  extractPropertiesOnDemand,
+  extractQuantitiesOnDemand,
+  extractEntityAttributesOnDemand,
+  extractMaterialsOnDemand,
+  extractClassificationsOnDemand,
+} from '@ifc-lite/parser';
 import type { PropertySet, QuantitySet } from '@ifc-lite/data';
-import type { ListDataProvider } from '@ifc-lite/lists';
+import { ENTITY_ATTRIBUTES } from '@ifc-lite/lists';
+import type { ListDataProvider, ListClassificationRef, DiscoveredColumns } from '@ifc-lite/lists';
+
+/** Collect every material-name string an element exposes — top-level
+ *  material plus layer / constituent / profile names and list members. */
+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;
+}
 
 /**
  * Create a ListDataProvider backed by an IfcDataStore.
@@ -26,6 +47,10 @@ export function createListDataProvider(store: IfcDataStore): ListDataProvider {
   // but are needed for list display. Cache avoids re-parsing per column.
   const attrCache = new Map<number, { description: string; objectType: string; tag: string }>();
 
+  // Lazily materialised list of every non-empty express id — used for
+  // class-less list targeting. Cached because the provider outlives a run.
+  let allIdsCache: number[] | null = null;
+
   function getOnDemandAttrs(id: number): { description: string; objectType: string; tag: string } {
     const cached = attrCache.get(id);
     if (cached) return cached;
@@ -42,6 +67,23 @@ export function createListDataProvider(store: IfcDataStore): ListDataProvider {
     return empty;
   }
 
+  // Complete column discovery is cached — the provider outlives a builder
+  // open, and the scan touches every entity that declares a pset/qto.
+  let columnsCache: DiscoveredColumns | null = null;
+
+  const usesOnDemandProps = !!store.onDemandPropertyMap && store.source?.length > 0;
+  const usesOnDemandQtos = !!store.onDemandQuantityMap && store.source?.length > 0;
+
+  function getPropertySetsFor(entityId: number): PropertySet[] {
+    if (usesOnDemandProps) return extractPropertiesOnDemand(store, entityId) as PropertySet[];
+    return store.properties?.getForEntity(entityId) ?? [];
+  }
+
+  function getQuantitySetsFor(entityId: number): QuantitySet[] {
+    if (usesOnDemandQtos) return extractQuantitiesOnDemand(store, entityId) as QuantitySet[];
+    return store.quantities?.getForEntity(entityId) ?? [];
+  }
+
   return {
     getEntitiesByType: (type) => store.entities.getByType(type),
 
@@ -52,18 +94,101 @@ export function createListDataProvider(store: IfcDataStore): ListDataProvider {
     getEntityTag: (id) => getOnDemandAttrs(id).tag,
     getEntityTypeName: (id) => store.entities.getTypeName(id),
 
-    getPropertySets(entityId: number): PropertySet[] {
-      if (store.onDemandPropertyMap && store.source?.length > 0) {
-        return extractPropertiesOnDemand(store, entityId) as PropertySet[];
+    getPropertySets: getPropertySetsFor,
+    getQuantitySets: getQuantitySetsFor,
+
+    getAllEntityIds(): number[] {
+      if (allIdsCache) return allIdsCache;
+      // Restrict "all elements" to geometry-bearing (selectable) products.
+      // The raw expressId column also holds relationships, property sets,
+      // materials, classifications and other non-element records — a
+      // class-less list should not surface those as rows.
+      const ids: number[] = [];
+      const col = store.entities.expressId;
+      for (let i = 0; i < col.length; i++) {
+        const id = col[i];
+        if (id && store.entities.hasGeometry(id)) ids.push(id);
       }
-      return store.properties?.getForEntity(entityId) ?? [];
+      allIdsCache = ids;
+      return ids;
+    },
+
+    getMaterialNames(entityId: number): string[] {
+      return materialNamesOf(extractMaterialsOnDemand(store, entityId));
+    },
+
+    getClassifications(entityId: number): ListClassificationRef[] {
+      return extractClassificationsOnDemand(store, entityId).map((c) => ({
+        system: c.system,
+        code: c.identification,
+        name: c.name,
+      }));
     },
 
-    getQuantitySets(entityId: number): QuantitySet[] {
-      if (store.onDemandQuantityMap && store.source?.length > 0) {
-        return extractQuantitiesOnDemand(store, entityId) as QuantitySet[];
+    getStoreyName(entityId: number): string {
+      const hierarchy = store.spatialHierarchy;
+      if (!hierarchy) return '';
+      const storeyId = hierarchy.elementToStorey.get(entityId);
+      if (!storeyId) return '';
+      return store.entities.getName(storeyId) || '';
+    },
+
+    discoverAllColumns(): DiscoveredColumns {
+      if (columnsCache) return columnsCache;
+
+      const properties = new Map<string, Set<string>>();
+      const quantities = new Map<string, Set<string>>();
+
+      const ingestProps = (id: number) => {
+        for (const set of getPropertySetsFor(id)) {
+          if (!set.name) continue;
+          let bucket = properties.get(set.name);
+          if (!bucket) { bucket = new Set(); properties.set(set.name, bucket); }
+          for (const p of set.properties) if (p.name) bucket.add(p.name);
+        }
+      };
+      const ingestQtos = (id: number) => {
+        for (const set of getQuantitySetsFor(id)) {
+          if (!set.name) continue;
+          let bucket = quantities.get(set.name);
+          if (!bucket) { bucket = new Set(); quantities.set(set.name, bucket); }
+          for (const q of set.quantities) if (q.name) bucket.add(q.name);
+        }
+      };
+
+      // On-demand path: scan exactly the entities that declare a pset/qto —
+      // the minimal complete set (every distinct set/property in the model).
+      if (usesOnDemandProps && store.onDemandPropertyMap) {
+        for (const id of store.onDemandPropertyMap.keys()) ingestProps(id);
+      }
+      if (usesOnDemandQtos && store.onDemandQuantityMap) {
+        for (const id of store.onDemandQuantityMap.keys()) ingestQtos(id);
       }
-      return store.quantities?.getForEntity(entityId) ?? [];
+      // Table path (e.g. server-loaded models): scan the entity column using
+      // the pre-built tables. Capped so it can't run away on huge models.
+      if (!usesOnDemandProps || !usesOnDemandQtos) {
+        const col = store.entities.expressId;
+        const CAP = 100_000;
+        for (let i = 0, seen = 0; i < col.length && seen < CAP; i++) {
+          const id = col[i];
+          if (!id) continue;
+          seen++;
+          if (!usesOnDemandProps) ingestProps(id);
+          if (!usesOnDemandQtos) ingestQtos(id);
+        }
+      }
+
+      const toSorted = (m: Map<string, Set<string>>) => {
+        const out = new Map<string, string[]>();
+        for (const [k, s] of m) out.set(k, Array.from(s).sort());
+        return out;
+      };
+      columnsCache = {
+        attributes: [...ENTITY_ATTRIBUTES],
+        properties: toSorted(properties),
+        quantities: toSorted(quantities),
+      };
+      return columnsCache;
     },
   };
 }

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

@@ -0,0 +1,47 @@
+/* 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';
+
+function esc(s: string, delim: string): string {
+  return /["\r\n]/.test(s) || s.includes(delim) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+/**
+ * CSV faithful to the configured columns. When grouped, a leading "Group"
+ * column preserves the grouping as data (so it stays re-importable), rows are
+ * ordered by group, and a TOTAL row carries the grand count + sums.
+ */
+export function toCsv(model: ExportModel, delimiter = ','): string {
+  const grouped = model.groups !== null;
+  const header = [...(grouped ? ['Group'] : []), ...model.columns.map((c) => c.label)];
+  const lines = [header.map((h) => esc(h, delimiter)).join(delimiter)];
+
+  const line = (groupLabel: string | null, values: CellValue[]) => {
+    const cells = grouped ? [esc(groupLabel ?? '', delimiter)] : [];
+    for (let i = 0; i < model.columns.length; i++) cells.push(esc(displayCell(values[i]), delimiter));
+    return cells.join(delimiter);
+  };
+
+  if (grouped && model.groups) {
+    for (const g of model.groups) for (const r of g.rows) lines.push(line(g.label, r));
+  } else {
+    for (const r of model.rows) lines.push(line(null, r));
+  }
+
+  if (model.sumColumnIds.length > 0) {
+    const totalLabel = `TOTAL (${model.totals.count})`;
+    const cells = grouped ? [esc(totalLabel, delimiter)] : [];
+    for (let i = 0; i < model.columns.length; i++) {
+      const c = model.columns[i];
+      if (c.summed) cells.push(esc(displayCell(model.totals.sums[c.id]), delimiter));
+      else if (!grouped && i === 0) cells.push(esc(totalLabel, delimiter));
+      else cells.push('');
+    }
+    lines.push(cells.join(delimiter));
+  }
+
+  return lines.join('\r\n');
+}

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

@@ -0,0 +1,49 @@
+/* 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/. */
+
+/**
+ * List results export — CSV / Excel / PDF, all driven by one normalised model
+ * (columns, grouping, sums, totals). Excel and PDF writers (and their heavy
+ * libs) are lazy-loaded so they never touch the initial bundle.
+ */
+
+import { toCsv } from './csv';
+import type { ExportModel } from './model';
+
+export type ExportFormat = 'csv' | 'xlsx' | 'pdf';
+
+export const EXPORT_LABELS: Record<ExportFormat, string> = {
+  csv: 'CSV (.csv)',
+  xlsx: 'Excel (.xlsx)',
+  pdf: 'PDF (.pdf)',
+};
+
+function slug(s: string): string {
+  return (s || 'list').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'list';
+}
+
+function download(blob: Blob, filename: string): void {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  a.click();
+  setTimeout(() => URL.revokeObjectURL(url), 1500);
+}
+
+export async function exportList(format: ExportFormat, model: ExportModel): Promise<void> {
+  const name = slug(model.title);
+  if (format === 'csv') {
+    download(new Blob([toCsv(model)], { type: 'text/csv;charset=utf-8;' }), `${name}.csv`);
+  } else if (format === 'xlsx') {
+    const { toXlsx } = await import('./xlsx');
+    download(await toXlsx(model), `${name}.xlsx`);
+  } else {
+    const { toPdf } = await import('./pdf');
+    download(await toPdf(model), `${name}.pdf`);
+  }
+}
+
+export { buildExportModel } from './model';
+export type { ExportModel } from './model';