@ifc-lite/viewer 1.27.0 → 1.28.1

package/src/store/slices/drawing2DSlice.ts

@@ -98,6 +98,13 @@ export interface Drawing2DState {
      * to the IfcAnnotation text feature).
      */
     showIfcAnnotations: boolean;
+    /**
+     * Construction projection (issue #979): project geometry beyond the cut
+     * as reference lines — thin solid for the visible floor side, dashed for
+     * overhead elements (beams, roofs, eaves). Plan ('down') sections only.
+     * Off by default; the section view stays cut-only until enabled.
+     */
+    showConstructionProjection: boolean;
   };
   /** Available graphic override presets */
   graphicOverridePresets: GraphicOverridePreset[];
@@ -244,6 +251,7 @@ const getDefaultDisplayOptions = (): Drawing2DState['drawing2DDisplayOptions'] =
   scale: 100, // 1:100 default
   useSymbolicRepresentations: false, // Default to section cut (Body geometry)
   showIfcAnnotations: true, // Mirror the 3D Class Visibility default
+  showConstructionProjection: false, // Optional reference projection (issue #979), off by default
 });
 
 const getDefaultState = (): Drawing2DState => ({

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/store/slices/visibilitySlice.ts

@@ -11,7 +11,14 @@
 
 import type { StateCreator } from 'zustand';
 import type { TypeVisibility, EntityRef } from '../types.js';
-import { getPersistedTypeVisibility, TYPE_VISIBILITY_STORAGE_KEYS, TYPE_VISIBILITY_SEMANTIC_DEFAULTS } from '../constants.js';
+import {
+  getPersistedTypeVisibility,
+  TYPE_VISIBILITY_STORAGE_KEYS,
+  TYPE_VISIBILITY_SEMANTIC_DEFAULTS,
+  getPersistedTypeViewMode,
+  TYPE_VIEW_MODE_STORAGE_KEY,
+  type TypeViewMode,
+} from '../constants.js';
 
 export interface VisibilitySlice {
   // State (legacy - single model)
@@ -20,6 +27,9 @@ export interface VisibilitySlice {
   /** Class-level filter (from Class tab type-group clicks) — independent of isolatedEntities */
   classFilter: { ids: Set<number>; label: string } | null;
   typeVisibility: TypeVisibility;
+  /** 3D view mode for the Model/Types switch (#957 follow-up). 'model' shows
+   *  placed occurrences (default); 'types' shows the type-library shapes. */
+  typeViewMode: TypeViewMode;
 
   // State (multi-model)
   /** Hidden entities per model */
@@ -46,6 +56,8 @@ export interface VisibilitySlice {
   toggleTypeVisibility: (type: 'spaces' | 'openings' | 'site' | 'ifcAnnotations' | 'ifcGrid') => void;
   /** Restore every type-visibility toggle to its semantic default (and persist). */
   resetTypeVisibility: () => void;
+  /** Set the Model/Types 3D view mode (and persist). */
+  setTypeViewMode: (mode: TypeViewMode) => void;
   /** Set all hidden entities at once (for BCF viewpoint application) */
   setHiddenEntities: (ids: Set<number>) => void;
   /** Set all isolated entities at once (for BCF viewpoint with defaultVisibility=false) */
@@ -79,6 +91,7 @@ export const createVisibilitySlice: StateCreator<VisibilitySlice, [], [], Visibi
   classFilter: null,
   // Read persisted toggles fresh so the user's choices survive reloads.
   typeVisibility: getPersistedTypeVisibility(),
+  typeViewMode: getPersistedTypeViewMode(),
 
   // Initial state (multi-model)
   hiddenEntitiesByModel: new Map(),
@@ -221,6 +234,14 @@ export const createVisibilitySlice: StateCreator<VisibilitySlice, [], [], Visibi
     return { typeVisibility: { ...TYPE_VISIBILITY_SEMANTIC_DEFAULTS } };
   }),
 
+  setTypeViewMode: (mode) => set(() => {
+    if (typeof window !== 'undefined') {
+      try { localStorage.setItem(TYPE_VIEW_MODE_STORAGE_KEY, mode); }
+      catch { /* private-mode storage rejection — non-fatal */ }
+    }
+    return { typeViewMode: mode };
+  }),
+
   // Actions (multi-model)
   hideEntityInModel: (modelId, expressId) => set((state) => {
     const newMap = new Map(state.hiddenEntitiesByModel);

package/src/store/types.ts

@@ -298,75 +298,7 @@ export type MetadataLoadState =
   | 'complete'
   | 'error';
 
-export interface NativeMetadataProperty {
-  name: string;
-  value: string | number | boolean | null;
-  type?: number;
-}
-
-export interface NativeMetadataPropertySet {
-  name: string;
-  globalId?: string;
-  properties: NativeMetadataProperty[];
-}
-
-export interface NativeMetadataQuantity {
-  name: string;
-  value: number;
-  type?: number;
-}
-
-export interface NativeMetadataQuantitySet {
-  name: string;
-  quantities: NativeMetadataQuantity[];
-}
-
-export interface NativeMetadataEntitySummary {
-  expressId: number;
-  type: string;
-  name: string;
-  globalId?: string | null;
-  kind: 'spatial' | 'element';
-  hasChildren: boolean;
-  elementCount?: number;
-  elevation?: number | null;
-}
-
-export interface NativeMetadataSpatialNode extends NativeMetadataEntitySummary {
-  children: NativeMetadataSpatialNode[];
-  elements: NativeMetadataEntitySummary[];
-}
-
-export interface NativeMetadataSpatialInfo {
-  storeyId?: number | null;
-  storeyName?: string | null;
-  elevation?: number | null;
-  height?: number | null;
-}
-
-export interface NativeMetadataEntityDetails {
-  summary: NativeMetadataEntitySummary;
-  typeSummary?: NativeMetadataEntitySummary | null;
-  spatial?: NativeMetadataSpatialInfo | null;
-  properties: NativeMetadataPropertySet[];
-  quantities: NativeMetadataQuantitySet[];
-}
-
-export interface NativeMetadataSnapshot {
-  mode: 'desktop-lazy';
-  cacheKey: string;
-  filePath: string;
-  schemaVersion: SchemaVersion;
-  entityCount: number;
-  spatialTree: NativeMetadataSpatialNode | null;
-}
-
-export type ModelSourceFile = File | {
-  path: string;
-  name: string;
-  size: number;
-  modifiedMs?: number | null;
-};
+export type ModelSourceFile = File;
 
 /** Complete model container for federation */
 export interface FederatedModel {
@@ -406,8 +338,6 @@ export interface FederatedModel {
   metadataLoadState?: MetadataLoadState;
   /** True once the model is visibly interactive in the viewport. */
   interactiveReady?: boolean;
-  /** Optional sparse desktop metadata snapshot for huge native loads. */
-  nativeMetadata?: NativeMetadataSnapshot | null;
   /** Cache state for the current load session. */
   cacheState?: 'none' | 'hit' | 'miss' | 'writing';
   /** Optional load error for this model. */

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

@@ -46,9 +46,6 @@ export const CACHE_SIZE_THRESHOLD = 10 * 1024 * 1024;
  *  and including it would make the IndexedDB write prohibitively large. */
 export const CACHE_MAX_SOURCE_SIZE = 150 * 1024 * 1024;
 
-/** Route desktop IFCs above this threshold through the bounded-memory path. */
-export const HUGE_NATIVE_FILE_THRESHOLD = 128 * 1024 * 1024;
-
 /**
  * File size at which the browser-File-API entry path streams directly into a
  * `SharedArrayBuffer` instead of going through `await file.arrayBuffer()`.
@@ -87,15 +84,6 @@ export const THRESHOLDS = {
   CACHE_MIN_MB: 10,
 } as const;
 
-// ============================================================================
-// Platform Detection
-// ============================================================================
-
-/** Detect if running in Tauri (desktop) environment */
-export function isTauri(): boolean {
-  return typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
-}
-
 // ============================================================================
 // Dynamic Batch Configuration
 // ============================================================================

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 {

package/vite.config.ts

@@ -267,9 +267,6 @@ export default defineConfig({
       '@ifc-lite/encoding': path.resolve(__dirname, '../../packages/encoding/src'),
       '@ifc-lite/ids': path.resolve(__dirname, '../../packages/ids/src'),
       '@ifc-lite/lists': path.resolve(__dirname, '../../packages/lists/src'),
-      '@tauri-apps/api/core': path.resolve(__dirname, './src/services/tauri-core-stub.ts'),
-      '@tauri-apps/plugin-dialog': path.resolve(__dirname, './src/services/tauri-dialog-stub.ts'),
-      '@tauri-apps/plugin-fs': path.resolve(__dirname, './src/services/tauri-fs-stub.ts'),
     },
   },
   server: {
@@ -301,6 +298,12 @@ export default defineConfig({
     target: 'esnext',
     chunkSizeWarningLimit: 6000,
     rollupOptions: {
+      // @ifc-lite/geometry's NativeBridge does a dynamic `import('@tauri-apps/api/event')`
+      // (under isTauri(), never reached on web). Rollup still resolves it
+      // statically, so externalize it to prevent a build failure. ifc-lite no
+      // longer ships a desktop app; downstream desktop builders supply
+      // @tauri-apps in their own host layer.
+      external: ['@tauri-apps/api/event'],
       output: {
         manualChunks(id) {
           if (id.includes('/packages/sandbox/')) return 'sandbox';

package/DESKTOP_CONTRACT_VERSION

@@ -1 +0,0 @@
-2