@ifc-lite/viewer 1.25.2 → 1.27.0

package/src/hooks/useIfcFederation.ts

@@ -40,7 +40,7 @@ import {
 } from './ingest/pointCloudIngest.js';
 import { getGlobalRenderer } from './useBCF.js';
 import { readNativeFile, type NativeFileHandle } from '../services/file-dialog.js';
-import { getEffectiveGeoreference, getEffectiveHorizontalScale, type GeorefMutationDataLike } from '../lib/geo/effective-georef.js';
+import { getEffectiveGeoreference, getEffectiveHorizontalScale, hasStandardGeoreferencing, type GeorefMutationDataLike } from '../lib/geo/effective-georef.js';
 import { resolveMapUnitToMetreScale } from '../lib/geo/geo-scale.js';
 import { resolveProjection } from '../lib/geo/reproject.js';
 import { toast } from '../components/ui/toast.js';
@@ -105,7 +105,21 @@ function extractModelGeoref(
   mutations?: GeorefMutationDataLike,
 ): ModelGeoref | null {
   const georef = getEffectiveGeoreference(dataStore, coordinateInfo, mutations);
-  if (!georef?.mapConversion || !georef.projectedCRS?.name) return null;
+  // Only TRUE georeferencing (real IfcMapConversion + IfcProjectedCRS) may drive
+  // federation alignment. A file with no IfcMapConversion gets a synthesised
+  // `source: 'siteLocation'` georef (EPSG:4326 from IfcSite RefLatitude/Longitude/
+  // Elevation) so it can still be pinned on the location map — but those are
+  // geographic degrees plus a raw, un-unit-scaled site elevation, not a projected
+  // metric frame. buildGeorefAlignmentTransform assumes projected eastings/
+  // northings/height in metres, so feeding it site data places the second model
+  // kilometres away: the BIMcollab ARC/STR pair share a site GUID but carry
+  // RefElevation 0 vs 20000 mm, and the height term lands ARC ~20 km below STR.
+  // Such models have no real georef relationship, so leave them in their own local
+  // frames where they overlay correctly. hasStandardGeoreferencing() excludes
+  // 'siteLocation' (see effective-georef.test.ts). (Regression from #658.)
+  if (!hasStandardGeoreferencing(georef) || !georef?.mapConversion || !georef.projectedCRS?.name) {
+    return null;
+  }
   return {
     mapConversion: georef.mapConversion,
     projectedCRS: georef.projectedCRS,

package/src/hooks/useIfcLoader.ts

@@ -55,6 +55,7 @@ import { useIfcCache, getCached } from './useIfcCache.js';
 import { useIfcServer } from './useIfcServer.js';
 
 import { getMaxExpressId, parseGlbViewerModel, parseIfcxViewerModel } from './ingest/viewerModelIngest.js';
+import { boundedIteratorReturn } from './ingest/streamCleanup.js';
 import { detectPointCloudFormat, ingestPointCloud } from './ingest/pointCloudIngest.js';
 import { getGlobalRenderer } from './useBCF.js';
 
@@ -2053,13 +2054,10 @@ export function useIfcLoader() {
         closeGeometryIterator = async () => {
           if (geometryIteratorClosed || typeof geometryIterator.return !== 'function') return;
           geometryIteratorClosed = true;
-          try {
-            // `AsyncIterator.return()` is signed as taking a value in
-            // current TS libs; callers conventionally pass `undefined`.
-            await geometryIterator.return(undefined);
-          } catch {
-            // Ignore iterator shutdown failures during recovery.
-          }
+          // Bound the shutdown: `return()` cannot interrupt a generator parked
+          // on a stalled worker await, so an unbounded await would re-wedge on
+          // the very stall the watchdog escaped. See boundedIteratorReturn.
+          await boundedIteratorReturn(geometryIterator);
         };
 
         while (true) {

package/src/lib/clash/persistence.ts

@@ -0,0 +1,308 @@
+/* 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/. */
+
+/**
+ * localStorage persistence for clash detection settings + the user's rule preset
+ * set. Mirrors the lens slice's "built-ins + overrides + custom" model and the
+ * scripts module's quota-safe `SaveResult`:
+ *
+ * - Presets: the built-in `CLASH_RULE_PRESETS` are always present (projected to
+ *   editable items with `enabled`/`builtin`); the user may toggle/edit them
+ *   (stored as overrides) and add custom presets. Only customs + modified
+ *   built-ins are persisted, so shipping a new built-in just works.
+ * - Settings: one flat JSON blob (mode/tolerance/clearance/clusterEpsilon/
+ *   reportTouch/groupBy), every numeric clamped to a sane range on load.
+ */
+
+import {
+  CLASH_RULE_PRESETS,
+  type ClashRulePreset,
+  type ClashMode,
+  type ClashSeverity,
+} from '@ifc-lite/clash';
+
+/** A built-in or user-defined clash rule preset, with editor/runtime flags. */
+export type ClashPreset = ClashRulePreset & { enabled: boolean; builtin: boolean };
+
+/** How the panel groups the flat clash list (display only). */
+export type ClashSettingsGroupBy = 'severity' | 'rule' | 'typePair';
+
+/** Global detection settings, persisted as one blob. */
+export interface ClashGlobalSettings {
+  mode: ClashMode;
+  tolerance: number;
+  clearance: number;
+  clusterEpsilon: number;
+  reportTouch: boolean;
+  groupBy: ClashSettingsGroupBy;
+}
+
+export type SaveResult =
+  | { ok: true }
+  | { ok: false; reason: 'quota' | 'serialize' | 'too_many'; message: string };
+
+const PRESETS_KEY = 'ifc-lite-clash-presets';
+const SETTINGS_KEY = 'ifc-lite-clash-settings';
+const SCHEMA_VERSION = 1;
+
+const MAX_PRESETS = 200;
+const MAX_NAME = 100;
+
+/** [min, max] clamps applied to settings numerics on load and on commit. */
+export const CLASH_BOUNDS = {
+  tolerance: [0, 1] as const,
+  clearance: [0, 5] as const,
+  clusterEpsilon: [0.01, 50] as const,
+};
+
+export const DEFAULT_CLASH_SETTINGS: ClashGlobalSettings = {
+  mode: 'hard',
+  tolerance: 0.002,
+  clearance: 0.05,
+  clusterEpsilon: 1.5,
+  reportTouch: false,
+  groupBy: 'severity',
+};
+
+const BUILTIN_PRESET_IDS = new Set(CLASH_RULE_PRESETS.map((p) => p.id));
+const SEVERITIES: ClashSeverity[] = ['critical', 'major', 'minor', 'info'];
+const GROUP_BYS: ClashSettingsGroupBy[] = ['severity', 'rule', 'typePair'];
+
+export function clampToBounds(value: unknown, [min, max]: readonly [number, number], fallback: number): number {
+  const n = typeof value === 'number' ? value : Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, n));
+}
+
+/** Trim + length-cap a preset name; null if empty (invalid). */
+export function validatePresetName(name: string): string | null {
+  const t = name.trim();
+  return t ? t.slice(0, MAX_NAME) : null;
+}
+
+/** Trim a selector; null if empty (invalid). An empty selector matches everything. */
+export function validateSelector(selector: string): string | null {
+  const t = selector.trim();
+  return t ? t : null;
+}
+
+function isValidStoredPreset(p: unknown): p is ClashPreset {
+  if (!p || typeof p !== 'object') return false;
+  const r = p as Record<string, unknown>;
+  return (
+    typeof r.id === 'string' && r.id.length > 0 &&
+    typeof r.name === 'string' && r.name.trim().length > 0 &&
+    typeof r.selectorA === 'string' && r.selectorA.trim().length > 0 &&
+    typeof r.selectorB === 'string' && r.selectorB.trim().length > 0 &&
+    typeof r.severity === 'string' && SEVERITIES.includes(r.severity as ClashSeverity)
+  );
+}
+
+/** Read stored presets, accepting the versioned wrapper or a legacy bare array. */
+function readStoredPresets(): ClashPreset[] {
+  try {
+    const raw = localStorage.getItem(PRESETS_KEY);
+    if (!raw) return [];
+    const parsed: unknown = JSON.parse(raw);
+    const list = Array.isArray(parsed)
+      ? parsed
+      : parsed && typeof parsed === 'object' && Array.isArray((parsed as { presets?: unknown }).presets)
+        ? (parsed as { presets: unknown[] }).presets
+        : [];
+    return list
+      .filter(isValidStoredPreset)
+      .map((p) => ({
+        id: p.id,
+        name: p.name,
+        description: typeof p.description === 'string' ? p.description : '',
+        severity: p.severity,
+        selectorA: p.selectorA,
+        selectorB: p.selectorB,
+        enabled: p.enabled !== false,
+        builtin: BUILTIN_PRESET_IDS.has(p.id),
+      }));
+  } catch {
+    return [];
+  }
+}
+
+/** The pristine built-in preset set, no overrides/customs — the "reset" target. */
+export function defaultPresets(): ClashPreset[] {
+  return CLASH_RULE_PRESETS.map((p) => ({ ...p, enabled: true, builtin: true }));
+}
+
+/**
+ * The full preset list shown to the user: every built-in (with any saved
+ * override applied) followed by custom presets. Built-ins are always present
+ * even if storage is empty or dropped them.
+ */
+/**
+ * Resolve a stored (customs + modified-built-ins) list into the full preset
+ * list: every built-in (with any override applied), then customs. Built-ins are
+ * always present, so a list from an older app version still picks up new ones.
+ */
+export function mergeStoredPresets(stored: ClashPreset[]): ClashPreset[] {
+  const overrides = new Map(stored.filter((p) => p.builtin).map((p) => [p.id, p]));
+  const builtins: ClashPreset[] = CLASH_RULE_PRESETS.map(
+    (p) => overrides.get(p.id) ?? { ...p, enabled: true, builtin: true },
+  );
+  const custom = stored.filter((p) => !p.builtin);
+  return [...builtins, ...custom];
+}
+
+export function buildInitialPresets(): ClashPreset[] {
+  return mergeStoredPresets(readStoredPresets());
+}
+
+function builtinDiffersFromDefault(p: ClashPreset): boolean {
+  const orig = CLASH_RULE_PRESETS.find((b) => b.id === p.id);
+  if (!orig) return true;
+  return (
+    !p.enabled ||
+    p.name !== orig.name ||
+    p.severity !== orig.severity ||
+    p.selectorA !== orig.selectorA ||
+    p.selectorB !== orig.selectorB ||
+    p.description !== orig.description
+  );
+}
+
+/** The minimal stored shape: customs + only the built-ins that differ from default. */
+export function presetsToStore(presets: ClashPreset[]): ClashPreset[] {
+  return [
+    ...presets.filter((p) => !p.builtin),
+    ...presets.filter((p) => p.builtin && builtinDiffersFromDefault(p)),
+  ];
+}
+
+/** Persist only custom presets + modified built-ins (quota-safe). */
+export function savePresets(presets: ClashPreset[]): SaveResult {
+  const custom = presets.filter((p) => !p.builtin);
+  if (custom.length > MAX_PRESETS) {
+    return { ok: false, reason: 'too_many', message: `Too many custom rules (max ${MAX_PRESETS}).` };
+  }
+  const toStore = presetsToStore(presets);
+  let payload: string;
+  try {
+    payload = JSON.stringify({ schemaVersion: SCHEMA_VERSION, presets: toStore });
+  } catch {
+    return { ok: false, reason: 'serialize', message: 'Could not serialize clash rules.' };
+  }
+  try {
+    localStorage.setItem(PRESETS_KEY, payload);
+    return { ok: true };
+  } catch {
+    return { ok: false, reason: 'quota', message: 'Browser storage is full — clash rules were not saved.' };
+  }
+}
+
+/** Coerce arbitrary input into valid, bounds-clamped settings (defaults on junk). */
+export function normalizeSettings(raw: unknown): ClashGlobalSettings {
+  const s = (raw && typeof raw === 'object' && 'settings' in raw
+    ? (raw as { settings: unknown }).settings
+    : raw) as Partial<ClashGlobalSettings> | null;
+  if (!s || typeof s !== 'object') return { ...DEFAULT_CLASH_SETTINGS };
+  return {
+    mode: s.mode === 'clearance' ? 'clearance' : 'hard',
+    tolerance: clampToBounds(s.tolerance, CLASH_BOUNDS.tolerance, DEFAULT_CLASH_SETTINGS.tolerance),
+    clearance: clampToBounds(s.clearance, CLASH_BOUNDS.clearance, DEFAULT_CLASH_SETTINGS.clearance),
+    clusterEpsilon: clampToBounds(s.clusterEpsilon, CLASH_BOUNDS.clusterEpsilon, DEFAULT_CLASH_SETTINGS.clusterEpsilon),
+    reportTouch: s.reportTouch === true,
+    groupBy: GROUP_BYS.includes(s.groupBy as ClashSettingsGroupBy) ? (s.groupBy as ClashSettingsGroupBy) : 'severity',
+  };
+}
+
+export function loadSettings(): ClashGlobalSettings {
+  try {
+    const raw = localStorage.getItem(SETTINGS_KEY);
+    if (!raw) return { ...DEFAULT_CLASH_SETTINGS };
+    return normalizeSettings(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_CLASH_SETTINGS };
+  }
+}
+
+export function saveSettings(settings: ClashGlobalSettings): SaveResult {
+  try {
+    localStorage.setItem(SETTINGS_KEY, JSON.stringify({ schemaVersion: SCHEMA_VERSION, settings }));
+    return { ok: true };
+  } catch {
+    return { ok: false, reason: 'quota', message: 'Browser storage is full — clash settings were not saved.' };
+  }
+}
+
+/** Download the user's presets (customs + modified built-ins) as a JSON file. */
+export function exportPresets(presets: ClashPreset[]): void {
+  const custom = presets.filter((p) => !p.builtin || builtinDiffersFromDefault(p));
+  const blob = new Blob([JSON.stringify({ schemaVersion: SCHEMA_VERSION, presets: custom }, null, 2)], {
+    type: 'application/json',
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = 'clash-rules.clash-presets.json';
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+/** Parse an exported file into custom presets (ids regenerated, `builtin` stripped). */
+export async function importPresets(file: File): Promise<ClashPreset[]> {
+  const text = await file.text();
+  const parsed: unknown = JSON.parse(text);
+  const list = Array.isArray(parsed)
+    ? parsed
+    : parsed && typeof parsed === 'object' && Array.isArray((parsed as { presets?: unknown }).presets)
+      ? (parsed as { presets: unknown[] }).presets
+      : [];
+  return list.filter(isValidStoredPreset).map((p) => ({
+    id: `custom-${crypto.randomUUID()}`,
+    name: p.name.slice(0, MAX_NAME),
+    description: typeof p.description === 'string' ? p.description : '',
+    severity: p.severity,
+    selectorA: p.selectorA,
+    selectorB: p.selectorB,
+    enabled: p.enabled !== false,
+    builtin: false,
+  }));
+}
+
+// ── Flavor integration ───────────────────────────────────────────────────────
+// Clash config rides inside a flavor's generic `settings.clash` blob, so each
+// flavor/profile carries its own rule-set + detection settings (and they travel
+// with flavor export/import). Serialize stores the minimal shape (customs +
+// modified built-ins + settings); deserialize rebuilds the full, validated state.
+
+/** Plain-JSON snapshot of clash config stored in a flavor. */
+export interface ClashFlavorConfig {
+  schemaVersion: number;
+  settings: ClashGlobalSettings;
+  /** Customs + modified built-ins only (built-ins are re-merged on restore). */
+  presets: ClashPreset[];
+}
+
+export function serializeClashConfig(presets: ClashPreset[], settings: ClashGlobalSettings): ClashFlavorConfig {
+  return { schemaVersion: SCHEMA_VERSION, settings: { ...settings }, presets: presetsToStore(presets) };
+}
+
+/**
+ * Rebuild clash state from a flavor blob: the full resolved preset list (defaults
+ * + the blob's overrides/customs) and bounds-clamped settings. Returns null when
+ * the blob is missing/garbage so the caller can skip the restore.
+ */
+export function deserializeClashConfig(blob: unknown): { presets: ClashPreset[]; settings: ClashGlobalSettings } | null {
+  if (!blob || typeof blob !== 'object') return null;
+  const b = blob as Partial<ClashFlavorConfig>;
+  const storedRaw = Array.isArray(b.presets) ? b.presets : [];
+  const stored = storedRaw.filter(isValidStoredPreset).map((p) => ({
+    id: p.id,
+    name: p.name,
+    description: typeof p.description === 'string' ? p.description : '',
+    severity: p.severity,
+    selectorA: p.selectorA,
+    selectorB: p.selectorB,
+    enabled: p.enabled !== false,
+    builtin: BUILTIN_PRESET_IDS.has(p.id),
+  }));
+  return { presets: mergeStoredPresets(stored), settings: normalizeSettings(b.settings) };
+}

package/src/lib/geo/effective-georef.test.ts

@@ -8,6 +8,7 @@ import assert from 'node:assert';
 import {
   detectScaleUnitMismatch,
   getEffectiveHorizontalScale,
+  hasStandardGeoreferencing,
   inferMapUnitScale,
   mergeMapConversion,
   mergeProjectedCRS,
@@ -237,4 +238,69 @@ describe('effective georeferencing', () => {
       assert.strictEqual(m!.effectiveScale, 2);
     });
   });
+
+  describe('hasStandardGeoreferencing (federation alignment gate)', () => {
+    // Federation affine alignment (extractModelGeoref → buildGeorefAlignmentTransform)
+    // gates on this predicate. A site-location-only georef must NOT qualify: it is
+    // EPSG:4326 lat/long degrees + a raw, un-unit-scaled IfcSite RefElevation, which
+    // the projected-CRS transform misreads as metres and flings the second federated
+    // model kilometres away. These tests lock that invariant.
+    const mapConversion: MapConversion = {
+      id: 1,
+      sourceCRS: 0,
+      targetCRS: 0,
+      eastings: 100,
+      northings: 200,
+      orthogonalHeight: 5,
+    };
+
+    it('rejects synthesised site-location georef even with a CRS name + map conversion', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'siteLocation',
+          projectedCRS: { id: 1, name: 'EPSG:4326' },
+          mapConversion,
+        }),
+        false,
+      );
+    });
+
+    it('accepts true IfcMapConversion + IfcProjectedCRS georef', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'mapConversion',
+          projectedCRS: { id: 1, name: 'EPSG:28992' },
+          mapConversion,
+        }),
+        true,
+      );
+    });
+
+    it('rejects georef missing a map conversion', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'mapConversion',
+          projectedCRS: { id: 1, name: 'EPSG:28992' },
+          mapConversion: undefined,
+        }),
+        false,
+      );
+    });
+
+    it('rejects georef missing a projected CRS name', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'mapConversion',
+          projectedCRS: { id: 1, name: '' },
+          mapConversion,
+        }),
+        false,
+      );
+    });
+
+    it('rejects null / undefined', () => {
+      assert.strictEqual(hasStandardGeoreferencing(null), false);
+      assert.strictEqual(hasStandardGeoreferencing(undefined), false);
+    });
+  });
 });

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