@ifc-lite/viewer 1.26.0 → 1.28.0

package/src/store/slices/listSlice.ts

@@ -17,6 +17,9 @@ export interface ListSlice {
   listResult: ListResult | null;
   listPanelVisible: boolean;
   listExecuting: boolean;
+  /** A list definition handed off from elsewhere (e.g. "Create list" in the
+   *  search filter) for the ListPanel to open straight into the builder. */
+  pendingListDraft: ListDefinition | null;
 
   // Actions
   setListDefinitions: (definitions: ListDefinition[]) => void;
@@ -28,6 +31,7 @@ export interface ListSlice {
   setListPanelVisible: (visible: boolean) => void;
   toggleListPanel: () => void;
   setListExecuting: (executing: boolean) => void;
+  setPendingListDraft: (definition: ListDefinition | null) => void;
 }
 
 export const createListSlice: StateCreator<ListSlice, [], [], ListSlice> = (set, get) => ({
@@ -37,6 +41,7 @@ export const createListSlice: StateCreator<ListSlice, [], [], ListSlice> = (set,
   listResult: null,
   listPanelVisible: false,
   listExecuting: false,
+  pendingListDraft: null,
 
   // Actions
   setListDefinitions: (listDefinitions) => {
@@ -71,4 +76,5 @@ export const createListSlice: StateCreator<ListSlice, [], [], ListSlice> = (set,
   setListPanelVisible: (listPanelVisible) => set({ listPanelVisible }),
   toggleListPanel: () => set((state) => ({ listPanelVisible: !state.listPanelVisible })),
   setListExecuting: (listExecuting) => set({ listExecuting }),
+  setPendingListDraft: (pendingListDraft) => set({ pendingListDraft }),
 });

package/src/store/slices/mutationSlice.ts

@@ -69,6 +69,7 @@ import {
   computeSlabSplitGeometry,
   type SlabLikeType,
 } from '@/lib/slab-edit.js';
+import { getModelLengthUnitScale } from '@/lib/length-unit-scale.js';
 import type { Point2D } from '@/lib/polygon-clip.js';
 
 /**
@@ -676,7 +677,9 @@ function generateChangeSetId(): string {
  */
 function getOrCreateStoreEditor(
   get: () => ViewerState,
-  set: (partial: Partial<ViewerState>) => void,
+  // Editors are cached in-place on the (non-reactive) `storeEditors`
+  // Map below, so the Zustand setter is intentionally unused here.
+  _set: (partial: Partial<ViewerState>) => void,
   modelId: string,
 ): StoreEditor | null {
   const state = get();
@@ -691,9 +694,14 @@ function getOrCreateStoreEditor(
   if (!dataStore) return null;
 
   const editor = new StoreEditor(dataStore, view);
-  const next = new Map(state.storeEditors);
-  next.set(modelId, editor);
-  set({ storeEditors: next });
+  // `storeEditors` is an internal, non-reactive cache (no component
+  // subscribes to it). Mutate the existing Map in place rather than
+  // `set({...})` — the read functions (readSlabFootprint, etc.) call
+  // this during render via GeometryEditCard's `splittable` memo, and a
+  // reactive `set()` there triggers React's "cannot update a component
+  // while rendering a different component" warning. In-place caching
+  // keeps the editor memoised without scheduling a render-phase update.
+  state.storeEditors.set(modelId, editor);
   return editor;
 }
 
@@ -1862,7 +1870,7 @@ export const createMutationSlice: StateCreator<
     if (!editor) return null;
     const dataStore = get().models.get(modelId)?.ifcDataStore;
     if (!dataStore) return null;
-    const chain = resolveSlabEditChain(dataStore, view, editor, expressId);
+    const chain = resolveSlabEditChain(dataStore, view, editor, expressId, getModelLengthUnitScale(dataStore));
     if (!chain) return null;
     const storeyId = dataStore.spatialHierarchy?.elementToStorey.get(expressId);
     const storeyElevation =
@@ -1883,7 +1891,7 @@ export const createMutationSlice: StateCreator<
     const { view, editor, dataStore, storeyExpressId } = ctx;
     const state = get();
 
-    const chain = resolveSlabEditChain(dataStore, view, editor, expressId);
+    const chain = resolveSlabEditChain(dataStore, view, editor, expressId, getModelLengthUnitScale(dataStore));
     if (!chain) {
       return {
         ok: false,

package/src/store/slices/searchSlice.ts

@@ -24,7 +24,7 @@ import type { StateCreator } from 'zustand';
 import type { Tier1Index } from '@/lib/search/tier1-index';
 import type { SearchResult, MatchField } from '@/lib/search/tier0-scan';
 import type { FilterRule, Combinator } from '@/lib/search/filter-rules';
-import type { FilterSchema, PsetQtoSchema } from '@/lib/search/filter-schema';
+import type { FilterSchema, PsetQtoSchema, FilterValueSchema } from '@/lib/search/filter-schema';
 
 /** Index lifecycle state for a single model. */
 export type Tier1IndexStatus = 'pending' | 'building' | 'ready' | 'error';
@@ -60,6 +60,10 @@ export interface SearchVimCycleState {
  */
 export type SearchFieldFilter = MatchField | 'all';
 
+/** Which tab the advanced modal renders. Lets callers (e.g. the inline
+ *  filter button) open straight to the Filter builder. */
+export type SearchModalTab = 'search' | 'filter';
+
 /**
  * Tabular result from a Filter run. Flat snapshot so the modal can
  * re-render rows without holding live evaluator state.
@@ -94,6 +98,9 @@ export interface FilterSchemaCacheEntry {
   basic: FilterSchema;
   /** Expensive pass — pset / qto names. Lazy; null until first request. */
   psetQto: PsetQtoSchema | null;
+  /** Expensive pass — distinct material / classification / property values
+   *  for chip value suggestions. Lazy; null until first request. */
+  values: FilterValueSchema | null;
 }
 
 export interface SearchSlice {
@@ -109,6 +116,8 @@ export interface SearchSlice {
   searchVimCycle: SearchVimCycleState | null;
   /** Advanced search modal (⌘⇧F) is open. */
   searchModalOpen: boolean;
+  /** Which tab the advanced modal shows. Remembered across opens. */
+  searchModalTab: SearchModalTab;
   /** Field chip filter active inside the modal. Defaults to 'all'. */
   searchFieldFilter: SearchFieldFilter;
   /** Per-modelId include filter inside the modal. `null` means all models included. */
@@ -147,6 +156,7 @@ export interface SearchSlice {
 
   setSearchModalOpen: (open: boolean) => void;
   toggleSearchModal: () => void;
+  setSearchModalTab: (tab: SearchModalTab) => void;
   setSearchFieldFilter: (filter: SearchFieldFilter) => void;
   /** Toggle a model in/out of the include filter. If the filter is null,
    *  the first toggle materialises it as "all models except this one". */
@@ -177,6 +187,7 @@ export interface SearchSlice {
   // ── Schema cache actions ──────────────────────────────────────────
   setFilterSchema: (modelId: string, basic: FilterSchema) => void;
   setFilterPsetQtoSchema: (modelId: string, psetQto: PsetQtoSchema) => void;
+  setFilterValueSchema: (modelId: string, values: FilterValueSchema) => void;
   removeFilterSchema: (modelId: string) => void;
 }
 
@@ -187,6 +198,7 @@ export const createSearchSlice: StateCreator<SearchSlice, [], [], SearchSlice> =
   searchIndexes: new Map(),
   searchVimCycle: null,
   searchModalOpen: false,
+  searchModalTab: 'search',
   searchFieldFilter: 'all',
   searchModelFilter: null,
   searchFilterResult: null,
@@ -239,6 +251,7 @@ export const createSearchSlice: StateCreator<SearchSlice, [], [], SearchSlice> =
 
   setSearchModalOpen: (searchModalOpen) => set({ searchModalOpen }),
   toggleSearchModal: () => set((state) => ({ searchModalOpen: !state.searchModalOpen })),
+  setSearchModalTab: (searchModalTab) => set({ searchModalTab }),
   setSearchFieldFilter: (searchFieldFilter) => set({ searchFieldFilter }),
 
   toggleSearchModelFilter: (modelId, availableModelIds) =>
@@ -316,7 +329,11 @@ export const createSearchSlice: StateCreator<SearchSlice, [], [], SearchSlice> =
     set((state) => {
       const next = new Map(state.searchFilterSchema);
       const existing = next.get(modelId);
-      next.set(modelId, { basic, psetQto: existing?.psetQto ?? null });
+      next.set(modelId, {
+        basic,
+        psetQto: existing?.psetQto ?? null,
+        values: existing?.values ?? null,
+      });
       return { searchFilterSchema: next };
     }),
 
@@ -327,7 +344,16 @@ export const createSearchSlice: StateCreator<SearchSlice, [], [], SearchSlice> =
       // Only meaningful once a basic schema has been set — the modal
       // calls discoverFilterSchema first then queues the heavy pass.
       if (!existing) return {};
-      next.set(modelId, { basic: existing.basic, psetQto });
+      next.set(modelId, { ...existing, psetQto });
+      return { searchFilterSchema: next };
+    }),
+
+  setFilterValueSchema: (modelId, values) =>
+    set((state) => {
+      const next = new Map(state.searchFilterSchema);
+      const existing = next.get(modelId);
+      if (!existing) return {};
+      next.set(modelId, { ...existing, values });
       return { searchFilterSchema: next };
     }),
 

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/nativeSpatialDataStore.ts

@@ -267,5 +267,11 @@ export function buildIfcDataStoreFromNativeMetadata(snapshot: NativeMetadataSnap
     quantities: undefined as unknown as IfcDataStore['quantities'],
     relationships: undefined as unknown as IfcDataStore['relationships'],
     spatialHierarchy: hierarchy,
+    // Native spatial snapshots are metadata-only (no source buffer / property
+    // or quantity tables), so the IfcStoreBase accessors return empties.
+    getEntity: () => null,
+    getEntitiesByType: () => [],
+    getProperties: () => [],
+    getQuantities: () => [],
   } as IfcDataStore;
 }

package/src/utils/serverDataModel.test.ts

@@ -38,6 +38,9 @@ describe('convertServerDataModel', () => {
         { rel_type: 'IFCRELAGGREGATES', relating_id: 2, related_id: 3 },
         { rel_type: 'IFCRELCONTAINEDINSPATIALSTRUCTURE', relating_id: 3, related_id: 4 },
       ],
+      classifications: [],
+      materials: [],
+      documents: [],
       spatialHierarchy: {
         nodes: [
           {
@@ -101,6 +104,9 @@ describe('convertServerDataModel', () => {
         { rel_type: 'IFCRELNESTS', relating_id: 1, related_id: 2 },
         { rel_type: 'IFCRELASSOCIATESDOCUMENT', relating_id: 3, related_id: 2 },
       ],
+      classifications: [],
+      materials: [],
+      documents: [],
       spatialHierarchy: {
         nodes: [
           {

package/src/utils/serverDataModel.ts

@@ -711,5 +711,12 @@ export function convertServerDataModel(
     relationships,
     spatialHierarchy,
     spatialIndex,
+    // IfcStoreBase accessors: server-parsed models carry pre-built property/
+    // quantity tables but no source buffer, so entity extraction is unavailable
+    // (the `entities` table remains the primary path for basic attributes).
+    getEntity: () => null,
+    getEntitiesByType: () => [],
+    getProperties: (expressId: number) => properties.getForEntity(expressId),
+    getQuantities: (expressId: number) => quantities.getForEntity(expressId),
   };
 }

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 {

package/dist/assets/deflate-Cnx0il6E.js

@@ -1 +0,0 @@
-import{i as r}from"./pako.esm-Cram60i4.js";import{B as o}from"./geotiff-A5UjhI6L.js";import"./sandbox-CsRXlgCO.js";import"./lens-PYsLu_MA.js";import"./__vite-browser-external-B1O5LaIO.js";class d extends o{decodeBlock(e){return r(new Uint8Array(e)).buffer}}export{d as default};