@ifc-lite/viewer 1.27.0 → 1.28.0

package/src/lib/llm/script-edit-ops.ts

@@ -456,6 +456,29 @@ export function applyScriptEditOperations(params: {
     return { ok: true, content, selection, revision, appliedOpIds, changes, status: 'ok' };
   }
 
+  if (operations.length > 1 && operations.some((op) => op.type === 'replaceAll')) {
+    const diagnostic = createPatchDiagnostic(
+      'patch_semantic_error',
+      'A replaceAll edit must be the only operation in its batch; it cannot be combined with positional ops.',
+      'error',
+      {
+        failureKind: 'mixed_repair_scopes',
+        fixHint:
+          'Emit replaceAll on its own, or use only positional ops (insert/replaceRange/append) in one batch.',
+      },
+    );
+    return {
+      ok: false,
+      content: params.content,
+      selection: params.selection,
+      revision,
+      appliedOpIds: [],
+      status: 'semantic_error',
+      error: diagnostic.message,
+      diagnostic,
+    };
+  }
+
   if (params.intent === 'repair') {
     const metadataError = validateRepairBatchMetadata(operations);
     if (metadataError) {

package/src/lib/llm/stream-client.ts

@@ -139,7 +139,14 @@ export async function readSseStream(
         if (!line.startsWith('data: ')) continue;
         const data = line.slice(6);
         if (data === '[DONE]') continue;
-        try { onEvent(data); } catch { /* skip malformed */ }
+        try {
+          onEvent(data);
+        } catch (err) {
+          // Malformed JSON payloads are expected and skipped, but a genuine
+          // callback failure (onChunk/onUsageInfo/logCacheHit/fullText) would
+          // otherwise be silently dropped — surface it for diagnosability.
+          console.debug('[sse] skipped event', err);
+        }
       }
     }
   };

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, '""')}"`;

package/src/sdk/adapters/export-adapter.ts

@@ -108,7 +108,12 @@ export function resolveVisibilityFilterSets(
  * double-quotes, or newlines.
  */
 function escapeCsv(value: string, sep: string): string {
-  if (value.includes(sep) || value.includes('"') || value.includes('\n')) {
+  // Neutralize spreadsheet formula injection (CWE-1236): a leading
+  // =, +, -, @, TAB or CR makes a cell execute as a formula in Excel/
+  // LibreOffice/Sheets. IFC values are attacker-controllable, so prefix
+  // such cells with an apostrophe.
+  if (/^[=+\-@\t\r]/.test(value)) value = `'${value}`;
+  if (value.includes(sep) || value.includes('"') || value.includes('\n') || value.includes('\r')) {
     return `"${value.replace(/"/g, '""')}"`;
   }
   return value;

package/src/store/globalId.ts

@@ -44,23 +44,17 @@ export function fromGlobalIdFromModels(
   models: ReverseModelMapLike,
   globalId: number,
 ): EntityRef | undefined {
-  if (models.size <= 1) {
-    const firstModelId = models.keys().next().value;
-    if (firstModelId) {
-      return {
-        modelId: firstModelId,
-        expressId: globalId,
-      };
-    }
-    return {
-      modelId: 'legacy',
-      expressId: globalId,
-    };
+  // No models loaded — legacy single-store fallback (expressId === globalId).
+  if (models.size === 0) {
+    return { modelId: 'legacy', expressId: globalId };
   }
 
+  // Resolve through every model by its offset range, regardless of count.
+  // For a true single model with idOffset 0 this still yields expressId === globalId.
+  // The `>= 0` boundary matches the canonical resolveGlobalIdFromModels (modelSlice.ts).
   for (const [modelId, model] of models.entries()) {
     const localExpressId = globalId - model.idOffset;
-    if (localExpressId > 0 && localExpressId <= model.maxExpressId) {
+    if (localExpressId >= 0 && localExpressId <= model.maxExpressId) {
       return {
         modelId,
         expressId: localExpressId,
@@ -68,6 +62,14 @@ export function fromGlobalIdFromModels(
     }
   }
 
+  // Single-model graceful fallback: if exactly one model and the offset
+  // range check missed (e.g. overlay-allocated id above maxExpressId),
+  // still return that model with the offset-corrected id rather than undefined.
+  if (models.size === 1) {
+    const [modelId, model] = models.entries().next().value!;
+    return { modelId, expressId: globalId - model.idOffset };
+  }
+
   return undefined;
 }
 

package/src/store/index.ts

@@ -34,6 +34,7 @@ import { createListSlice, type ListSlice } from './slices/listSlice.js';
 import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.js';
 import { createLensSlice, type LensSlice } from './slices/lensSlice.js';
 import { createClashSlice, type ClashSlice } from './slices/clashSlice.js';
+import { createCompareSlice, type CompareSlice } from './slices/compareSlice.js';
 import { createScriptSlice, type ScriptSlice } from './slices/scriptSlice.js';
 import { createChatSlice, type ChatSlice } from './slices/chatSlice.js';
 import { createCesiumSlice, type CesiumSlice } from './slices/cesiumSlice.js';
@@ -85,6 +86,7 @@ export type { PinboardSlice } from './slices/pinboardSlice.js';
 
 // Re-export Lens types
 export type { LensSlice, Lens, LensRule, LensCriteria } from './slices/lensSlice.js';
+export type { CompareSlice, CompareResult } from './slices/compareSlice.js';
 
 // Re-export Script types
 export type { ScriptSlice } from './slices/scriptSlice.js';
@@ -131,6 +133,7 @@ export type ViewerState = LoadingSlice &
   PinboardSlice &
   LensSlice &
   ClashSlice &
+  CompareSlice &
   ScriptSlice &
   ChatSlice &
   CesiumSlice &
@@ -155,7 +158,7 @@ export type ViewerState = LoadingSlice &
      * the right panel. Routed through by the toolbar, command palette, and the
      * BCF overlay so every entry point behaves identically.
      */
-    openWorkspacePanel: (panel: 'bcf' | 'ids' | 'lens' | 'clash' | 'extensions') => void;
+    openWorkspacePanel: (panel: 'bcf' | 'ids' | 'lens' | 'clash' | 'compare' | 'extensions') => void;
   };
 
 /**
@@ -182,6 +185,7 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
   ...createPinboardSlice(...args),
   ...createLensSlice(...args),
   ...createClashSlice(...args),
+  ...createCompareSlice(...args),
   ...createScriptSlice(...args),
   ...createChatSlice(...args),
   ...createCesiumSlice(...args),
@@ -211,6 +215,8 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       // Selection (multi-model)
       selectedEntity: null,
       selectedEntitiesSet: new Set(),
+      selectedEntities: [],
+      selectedModelId: null,
 
       // Visibility (legacy)
       hiddenEntities: new Set(),
@@ -235,6 +241,14 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       pendingColorUpdates: null,
       pendingMeshColorUpdates: null,
 
+      // Compare (#924): drop any stale diff result — it references models by
+      // id and the loaded set is changing. Keep panel visibility + A/B/scope
+      // choices (UI prefs); the user re-runs against the new set.
+      compareResult: null,
+      compareSelectedKey: null,
+      compareRunning: false,
+      compareError: null,
+
       // Hover/Context
       hoverState: { entityId: null, screenX: 0, screenY: 0 },
       contextMenu: { isOpen: false, entityId: null, screenX: 0, screenY: 0 },
@@ -460,6 +474,7 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       idsPanelVisible: panel === 'ids',
       lensPanelVisible: panel === 'lens',
       clashPanelVisible: panel === 'clash',
+      comparePanelVisible: panel === 'compare',
       extensionsPanelVisible: panel === 'extensions',
       rightPanelCollapsed: false,
     });

package/src/store/slices/cesiumSlice.ts

@@ -108,8 +108,15 @@ const STORAGE_KEY_DATA_SOURCE = 'ifc-lite:cesium-data-source';
  * Default Cesium ion token provided at build time.
  * Set via VITE_CESIUM_ION_TOKEN in .env or CI environment.
  * This means users never need to configure a token manually.
+ *
+ * NOTE: `import.meta.env` is undefined under the Vitest/Node test runner (the
+ * Vite define plugin doesn't run there), so this module-top-level read would
+ * crash with "Cannot read properties of undefined" — every viewer test imports
+ * the store, which imports this slice. The optional chaining on `.env` keeps the
+ * read safe in that environment. `import.meta.env` is typed via vite-env.d.ts so
+ * no `as any` cast is needed. Do NOT drop the optional chaining.
  */
-const DEFAULT_ION_TOKEN: string = (import.meta as any).env?.VITE_CESIUM_ION_TOKEN ?? '';
+const DEFAULT_ION_TOKEN: string = import.meta.env?.VITE_CESIUM_ION_TOKEN ?? '';
 
 function loadFromStorage(key: string, fallback: string): string {
   try {

package/src/store/slices/compareSlice.ts

@@ -0,0 +1,96 @@
+/* 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-comparison panel state (issue #924). Holds the panel's UI state, the
+ * A/B model selection, the data-vs-geometry scope, and the last `@ifc-lite/diff`
+ * result. The orchestration (building per-entity fingerprints from each model's
+ * `IfcDataStore` + geometry hashes, running `diffModels`, applying the 3D
+ * colour/visibility overlay) lives in the `useCompare` hook — this slice is
+ * deliberately dumb, mirroring `clashSlice` + `useClash`.
+ */
+
+import type { StateCreator } from 'zustand';
+import type { DiffScope, ModelDiff } from '@ifc-lite/diff';
+import type { CompareRef } from '@/lib/compare/buildFingerprints';
+
+/** A completed comparison: the engine result plus the A/B context it ran on. */
+export interface CompareResult {
+  /** Federation model id chosen as the base (version A). */
+  baseModelId: string;
+  /** Federation model id chosen as the head (version B). */
+  headModelId: string;
+  /** Display name of the base model. */
+  baseName: string;
+  /** Display name of the head model. */
+  headName: string;
+  /** The scope the diff was computed with. */
+  scope: DiffScope;
+  /** True when a compared model carries no geometry hashes (loaded outside the
+   *  WASM mesh path), so geometry-scope changes can't be detected. */
+  geometryUnavailable: boolean;
+  /** The engine output — entries keyed by GlobalId, with per-entity refs. */
+  diff: ModelDiff<CompareRef>;
+}
+
+export interface CompareSlice {
+  comparePanelVisible: boolean;
+  /** Selected base (A) / head (B) federation model ids. */
+  compareBaseModelId: string | null;
+  compareHeadModelId: string | null;
+  /** What counts as a change: data, geometry, or both. */
+  compareScope: DiffScope;
+  /** Whether unchanged elements are drawn (ghosted) or hidden. */
+  compareShowUnchanged: boolean;
+  /** Last comparison result (null when idle / not yet run). */
+  compareResult: CompareResult | null;
+  compareRunning: boolean;
+  compareError: string | null;
+  /** GlobalId of the entry focused in the list (for highlight). */
+  compareSelectedKey: string | null;
+
+  setComparePanelVisible: (visible: boolean) => void;
+  toggleComparePanel: () => void;
+  setCompareBaseModelId: (id: string | null) => void;
+  setCompareHeadModelId: (id: string | null) => void;
+  setCompareScope: (scope: DiffScope) => void;
+  setCompareShowUnchanged: (show: boolean) => void;
+  setCompareResult: (result: CompareResult | null) => void;
+  setCompareRunning: (running: boolean) => void;
+  setCompareError: (error: string | null) => void;
+  setCompareSelectedKey: (key: string | null) => void;
+  /** Clear the run result + selection; keeps the A/B + scope choices. */
+  clearCompare: () => void;
+}
+
+export const createCompareSlice: StateCreator<CompareSlice, [], [], CompareSlice> = (set) => ({
+  comparePanelVisible: false,
+  compareBaseModelId: null,
+  compareHeadModelId: null,
+  compareScope: 'both',
+  compareShowUnchanged: false,
+  compareResult: null,
+  compareRunning: false,
+  compareError: null,
+  compareSelectedKey: null,
+
+  setComparePanelVisible: (comparePanelVisible) => set({ comparePanelVisible }),
+  toggleComparePanel: () => set((s) => ({ comparePanelVisible: !s.comparePanelVisible })),
+  setCompareBaseModelId: (compareBaseModelId) => set({ compareBaseModelId }),
+  setCompareHeadModelId: (compareHeadModelId) => set({ compareHeadModelId }),
+  setCompareScope: (compareScope) => set({ compareScope }),
+  setCompareShowUnchanged: (compareShowUnchanged) => set({ compareShowUnchanged }),
+  setCompareResult: (compareResult) => set({ compareResult }),
+  setCompareRunning: (compareRunning) => set({ compareRunning }),
+  setCompareError: (compareError) => set({ compareError }),
+  setCompareSelectedKey: (compareSelectedKey) => set({ compareSelectedKey }),
+
+  clearCompare: () =>
+    set({
+      compareResult: null,
+      compareRunning: false,
+      compareError: null,
+      compareSelectedKey: null,
+    }),
+});

package/src/store/slices/lensSlice.ts

@@ -98,6 +98,11 @@ export interface LensSlice {
   lensPanelVisible: boolean;
   /** Computed: globalId → hex color for entities matched by active lens */
   lensColorMap: Map<number, string>;
+  /** The exact RGBA overlay the active lens last pushed to the shared color
+   *  channel, or null when no lens is active. Lets another channel owner
+   *  (e.g. the compare overlay) hand control back to the lens on teardown
+   *  instead of clearing it. */
+  lensAppliedColors: Map<number, [number, number, number, number]> | null;
   /** Computed: globalIds to hide via lens rules */
   lensHiddenIds: Set<number>;
   /** Computed: ruleId → matched entity count for the active lens */
@@ -117,6 +122,7 @@ export interface LensSlice {
   toggleLensPanel: () => void;
   setLensPanelVisible: (visible: boolean) => void;
   setLensColorMap: (map: Map<number, string>) => void;
+  setLensAppliedColors: (map: Map<number, [number, number, number, number]> | null) => void;
   setLensHiddenIds: (ids: Set<number>) => void;
   setLensRuleCounts: (counts: Map<string, number>) => void;
   setLensRuleEntityIds: (ids: Map<string, number[]>) => void;
@@ -147,6 +153,7 @@ export const createLensSlice: StateCreator<LensSlice, [], [], LensSlice> = (set,
   activeLensId: null,
   lensPanelVisible: false,
   lensColorMap: new Map(),
+  lensAppliedColors: null,
   lensHiddenIds: new Set(),
   lensRuleCounts: new Map(),
   lensRuleEntityIds: new Map(),
@@ -183,6 +190,7 @@ export const createLensSlice: StateCreator<LensSlice, [], [], LensSlice> = (set,
   setLensPanelVisible: (lensPanelVisible) => set({ lensPanelVisible }),
 
   setLensColorMap: (lensColorMap) => set({ lensColorMap }),
+  setLensAppliedColors: (lensAppliedColors) => set({ lensAppliedColors }),
   setLensHiddenIds: (lensHiddenIds) => set({ lensHiddenIds }),
   setLensRuleCounts: (lensRuleCounts) => set({ lensRuleCounts }),
   setLensRuleEntityIds: (lensRuleEntityIds) => set({ lensRuleEntityIds }),

package/src/utils/acquireFileBuffer.test.ts

@@ -192,15 +192,23 @@ describe('acquireFileBuffer', () => {
       );
     }
 
-    // Sanity check: the IFC addModel path SHOULD still use acquireFileBuffer
-    // (STEP/IFC binary path benefits from SAB streaming).
+    // Sanity check: the IFC/STEP path still SAB-streams. addModel now delegates
+    // to the canonical loadFile (one load path), so the acquireFileBuffer SAB
+    // streaming lives there — assert addModel routes through loadFile, and that
+    // loadFile keeps acquireFileBuffer for the STEP/IFC binary path. (IFCX is
+    // still guarded above: its federation entry points stay on file.arrayBuffer.)
     const addModelStart = source.indexOf('const addModel = useCallback');
     assert.ok(addModelStart >= 0, 'expected addModel declaration');
     const addModelEnd = source.indexOf('}, [', addModelStart);
     const addModelBody = source.slice(addModelStart, addModelEnd);
     assert.ok(
-      addModelBody.includes('acquireFileBuffer'),
-      'addModel (IFC/STEP path) must keep using acquireFileBuffer() for SAB streaming',
+      addModelBody.includes('loadFile('),
+      'addModel must delegate to the canonical loadFile (one load path)',
+    );
+    const loaderSource = readFileSync(join(here, '..', 'hooks', 'useIfcLoader.ts'), 'utf8');
+    assert.ok(
+      loaderSource.includes('acquireFileBuffer'),
+      'loadFile (IFC/STEP path) must keep using acquireFileBuffer() for SAB streaming',
     );
   });
 

package/src/utils/desktopModelSnapshot.ts

@@ -346,13 +346,14 @@ export async function restoreDesktopMetadataSnapshot(
   };
   dataStore.spatialHierarchy = deserializeSpatialHierarchy(metadata.spatialHierarchy);
 
-  const { onDemandPropertyMap, onDemandQuantityMap } = rebuildOnDemandMaps(
+  const { onDemandPropertyMap, onDemandQuantityMap, onDemandMaterialMap } = rebuildOnDemandMaps(
     dataStore.entities,
     dataStore.relationships,
     dataStore.entityIndex,
   );
   dataStore.onDemandPropertyMap = onDemandPropertyMap;
   dataStore.onDemandQuantityMap = onDemandQuantityMap;
+  dataStore.onDemandMaterialMap = onDemandMaterialMap;
 
   return dataStore;
 }

package/src/utils/loadingUtils.ts

@@ -44,3 +44,35 @@ export function buildSpatialIndexGuarded(
     console.warn('[loadingUtils] Failed to build spatial index:', err);
   });
 }
+
+/**
+ * Build a spatial index for a specific (e.g. federated) model.
+ *
+ * Unlike {@link buildSpatialIndexGuarded}, this never touches the active-model
+ * slot: a federated model is usually not the active one, so guarding on / writing
+ * through `ifcDataStore` (`setIfcDataStore`) would either discard the index or
+ * mutate the wrong model. Instead it guards on the target model still holding the
+ * same store and publishes through `updateModel(modelId, ...)`.
+ *
+ * @param meshes - Final mesh array with correct IDs and world-space positions
+ * @param modelId - The federated model to attach the spatial index to
+ * @param dataStore - That model's IfcDataStore (mutated in place)
+ */
+export function buildSpatialIndexForModel(
+  meshes: MeshData[],
+  modelId: string,
+  dataStore: IfcDataStore,
+): void {
+  if (meshes.length === 0) return;
+
+  buildSpatialIndexAsync(meshes).then(spatialIndex => {
+    const state = useViewerStore.getState();
+    const model = state.models.get(modelId);
+    // Model removed, or its store was replaced since this build started.
+    if (!model || model.ifcDataStore !== dataStore) return;
+    dataStore.spatialIndex = spatialIndex;
+    state.updateModel(modelId, { ifcDataStore: dataStore });
+  }).catch(err => {
+    console.warn('[loadingUtils] Failed to build spatial index for model:', err);
+  });
+}

package/src/utils/spatialHierarchy.test.ts

@@ -11,7 +11,7 @@ import {
   RelationshipType,
   StringTable,
 } from '@ifc-lite/data';
-import { rebuildSpatialHierarchy } from './spatialHierarchy';
+import { rebuildSpatialHierarchy, rebuildOnDemandMaps } from './spatialHierarchy';
 
 describe('rebuildSpatialHierarchy', () => {
   it('preserves IFC4.3 facility-part trees during cache rebuilds', () => {
@@ -152,3 +152,55 @@ describe('rebuildSpatialHierarchy', () => {
     assert.equal(hierarchy.elementToStorey.get(6), 3);
   });
 });
+
+describe('rebuildOnDemandMaps', () => {
+  const makeEntityIndex = (byType: Map<string, number[]>) => ({
+    byId: { get: () => undefined, has: () => false, size: 0 },
+    byType,
+  });
+
+  it('rebuilds onDemandMaterialMap from AssociatesMaterial edges (cache parity)', () => {
+    const strings = new StringTable();
+    const entities = new EntityTableBuilder(2, strings);
+    entities.add(5, 'IFCBEAM', 'b0', 'Beam', '', '', true);
+    entities.add(10, 'IFCMATERIAL', 'm0', 'Concrete', '', '');
+
+    const builder = new RelationshipGraphBuilder();
+    // material(10) -> element(5) forward, matching the columnar parser.
+    builder.addEdge(10, 5, RelationshipType.AssociatesMaterial, 100);
+    // pset(20) -> element(5), so the property map still rebuilds too.
+    builder.addEdge(20, 5, RelationshipType.DefinesByProperties, 101);
+
+    const entityIndex = makeEntityIndex(new Map<string, number[]>([
+      ['IFCMATERIAL', [10]],
+      ['IFCPROPERTYSET', [20]],
+    ]));
+
+    const { onDemandMaterialMap, onDemandPropertyMap } = rebuildOnDemandMaps(
+      entities.build(),
+      builder.build(),
+      entityIndex,
+    );
+
+    assert.equal(onDemandMaterialMap.size, 1);
+    assert.equal(onDemandMaterialMap.get(5), 10);
+    assert.deepEqual(onDemandPropertyMap.get(5), [20]);
+  });
+
+  it('matches material definitions case-insensitively (mixed-case byType keys)', () => {
+    const strings = new StringTable();
+    const entities = new EntityTableBuilder(2, strings);
+    entities.add(5, 'IFCWALL', 'w0', 'Wall', '', '', true);
+    entities.add(40, 'IFCMATERIALLAYERSET', 'ls0', 'Buildup', '', '');
+
+    const builder = new RelationshipGraphBuilder();
+    builder.addEdge(40, 5, RelationshipType.AssociatesMaterial, 100);
+
+    const entityIndex = makeEntityIndex(new Map<string, number[]>([
+      ['IfcMaterialLayerSet', [40]], // mixed-case, as some cache writers emit
+    ]));
+
+    const { onDemandMaterialMap } = rebuildOnDemandMaps(entities.build(), builder.build(), entityIndex);
+    assert.equal(onDemandMaterialMap.get(5), 40);
+  });
+});

package/src/utils/spatialHierarchy.ts

@@ -208,8 +208,22 @@ export interface EntityIndex {
 export interface OnDemandMaps {
   onDemandPropertyMap: Map<number, number[]>;
   onDemandQuantityMap: Map<number, number[]>;
+  /** element/type expressId -> associated material definition expressId. */
+  onDemandMaterialMap: Map<number, number>;
 }
 
+/** IFC material *definition* classes that can be the RelatingMaterial of an
+ *  IfcRelAssociatesMaterial — the source nodes of AssociatesMaterial edges. */
+const MATERIAL_DEF_TYPES = new Set([
+  'IFCMATERIAL',
+  'IFCMATERIALLAYERSET',
+  'IFCMATERIALLAYERSETUSAGE',
+  'IFCMATERIALPROFILESET',
+  'IFCMATERIALPROFILESETUSAGE',
+  'IFCMATERIALCONSTITUENTSET',
+  'IFCMATERIALLIST',
+]);
+
 /**
  * Rebuild on-demand property/quantity maps from relationships and entity types
  * Uses FORWARD direction: pset -> elements (more efficient than inverse lookup)
@@ -228,6 +242,7 @@ export function rebuildOnDemandMaps(
 ): OnDemandMaps {
   const onDemandPropertyMap = new Map<number, number[]>();
   const onDemandQuantityMap = new Map<number, number[]>();
+  const onDemandMaterialMap = new Map<number, number>();
 
   // Use entityIndex.byType if available (needed for cache loads where entity table
   // doesn't include IfcPropertySet/IfcElementQuantity entities)
@@ -288,8 +303,33 @@ export function rebuildOnDemandMaps(
     }
   }
 
+  // Process material associations (FORWARD: material definition -> elements),
+  // mirroring the columnar parser's onDemandMaterialMap. Needed so cache-loaded
+  // models populate the Materials tab + per-material totals, which read this map
+  // (the relationship-graph fallback only covers single-element lookups, not the
+  // model-wide usage index). Requires entityIndex.byType to enumerate material
+  // definitions — the cached graph preserves AssociatesMaterial edges.
+  let materialDefCount = 0;
+  if (entityIndex?.byType) {
+    for (const [typeKey, ids] of entityIndex.byType) {
+      if (!MATERIAL_DEF_TYPES.has(typeKey.toUpperCase())) continue;
+      for (const materialId of ids) {
+        materialDefCount += 1;
+        const associated = relationships.getRelated(
+          materialId,
+          RelationshipType.AssociatesMaterial,
+          'forward'
+        );
+        for (const entityId of associated) {
+          // Last association wins, matching the columnar parser's `.set` build.
+          onDemandMaterialMap.set(entityId, materialId);
+        }
+      }
+    }
+  }
+
   console.log(
-    `[spatialHierarchy] Rebuilt on-demand maps: ${propertySets.length} psets, ${quantitySets.length} qsets -> ${onDemandPropertyMap.size} entities with properties, ${onDemandQuantityMap.size} with quantities`
+    `[spatialHierarchy] Rebuilt on-demand maps: ${propertySets.length} psets, ${quantitySets.length} qsets, ${materialDefCount} material defs -> ${onDemandPropertyMap.size} entities with properties, ${onDemandQuantityMap.size} with quantities, ${onDemandMaterialMap.size} with materials`
   );
-  return { onDemandPropertyMap, onDemandQuantityMap };
+  return { onDemandPropertyMap, onDemandQuantityMap, onDemandMaterialMap };
 }

package/src/vite-env.d.ts

@@ -17,6 +17,8 @@ interface ImportMetaEnv {
   readonly VITE_LLM_IMAGE_MODELS?: string;
   /** Comma-separated model IDs that support file attachment context */
   readonly VITE_LLM_FILE_ATTACHMENT_MODELS?: string;
+  /** Build-time default Cesium ion access token */
+  readonly VITE_CESIUM_ION_TOKEN?: string;
 }
 
 interface ImportMeta {