@ifc-lite/viewer 1.16.0 → 1.17.0

package/src/hooks/useIfcLoader.ts

@@ -10,12 +10,12 @@
  * Extracted from useIfc.ts for better separation of concerns
  */
 
-import { useCallback } from 'react';
+import { useCallback, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { useViewerStore } from '../store.js';
 import { IfcParser, detectFormat, parseIfcx, type IfcDataStore } from '@ifc-lite/parser';
 import { GeometryProcessor, GeometryQuality, type MeshData, type CoordinateInfo } from '@ifc-lite/geometry';
-import { buildSpatialIndex } from '@ifc-lite/spatial';
+import { buildSpatialIndexGuarded } from '../utils/loadingUtils.js';
 import { type GeometryData, loadGLBToMeshData } from '@ifc-lite/cache';
 
 import { SERVER_URL, USE_SERVER, CACHE_SIZE_THRESHOLD, CACHE_MAX_SOURCE_SIZE, getDynamicBatchConfig } from '../utils/ifcConfig.js';
@@ -69,6 +69,10 @@ function computeFastFingerprint(buffer: ArrayBuffer): string {
  * Includes binary cache support for fast subsequent loads
  */
 export function useIfcLoader() {
+  // Guard against stale async writes when user loads a new file before previous completes.
+  // Incremented on each loadFile call; deferred callbacks check their captured session.
+  const loadSessionRef = useRef(0);
+
   const {
     setLoading,
     setError,
@@ -97,6 +101,7 @@ export function useIfcLoader() {
 
   const loadFile = useCallback(async (file: File) => {
     const { resetViewerState, clearAllModels } = useViewerStore.getState();
+    const currentSession = ++loadSessionRef.current;
 
     // Track total elapsed time for complete user experience
     const totalStartTime = performance.now();
@@ -243,8 +248,6 @@ export function useIfcLoader() {
 
           setProgress({ phase: 'Complete', percent: 100 });
 
-          const totalElapsedMs = performance.now() - totalStartTime;
-          console.log(`[useIfc] GLB loaded: ${meshes.length} meshes, ${stats.totalTriangles} triangles in ${totalElapsedMs.toFixed(0)}ms`);
           setLoading(false);
           return;
         } catch (err: unknown) {
@@ -267,8 +270,7 @@ export function useIfcLoader() {
         if (cacheResult) {
           const success = await loadFromCache(cacheResult, file.name, cacheKey);
           if (success) {
-            const totalElapsedMs = performance.now() - totalStartTime;
-            console.log(`[useIfc] TOTAL LOAD TIME (from cache): ${totalElapsedMs.toFixed(0)}ms (${(totalElapsedMs / 1000).toFixed(1)}s)`);
+            console.log(`[useIfc] TOTAL LOAD TIME (from cache): ${(performance.now() - totalStartTime).toFixed(0)}ms`);
             setLoading(false);
             return;
           }
@@ -279,10 +281,9 @@ export function useIfcLoader() {
       // Only for IFC4 STEP files (server doesn't support IFCX)
       if (format === 'ifc' && USE_SERVER && SERVER_URL && SERVER_URL !== '') {
         // Pass buffer directly - server uses File object for parsing, buffer is only for size checks
-        const serverSuccess = await loadFromServer(file, buffer);
+        const serverSuccess = await loadFromServer(file, buffer, () => loadSessionRef.current !== currentSession);
         if (serverSuccess) {
-          const totalElapsedMs = performance.now() - totalStartTime;
-          console.log(`[useIfc] TOTAL LOAD TIME (server): ${totalElapsedMs.toFixed(0)}ms (${(totalElapsedMs / 1000).toFixed(1)}s)`);
+          console.log(`[useIfc] TOTAL LOAD TIME (server): ${(performance.now() - totalStartTime).toFixed(0)}ms`);
           setLoading(false);
           return;
         }
@@ -300,9 +301,10 @@ export function useIfcLoader() {
       });
       await geometryProcessor.init();
 
-      // DEFER data model parsing - start it AFTER geometry streaming begins
-      // This ensures geometry gets first crack at the CPU for fast first frame
-      // Data model parsing is lower priority - UI can work without it initially
+      // Data model parsing runs IN PARALLEL with geometry streaming.
+      // Entity scanning uses a Web Worker (non-blocking, ~1.2s).
+      // Columnar parse uses time-sliced yielding (~2.3s, 60fps maintained).
+      // Neither depends on geometry output — both just need the raw buffer.
       let resolveDataStore: (dataStore: IfcDataStore) => void;
       let rejectDataStore: (err: unknown) => void;
       const dataStorePromise = new Promise<IfcDataStore>((resolve, reject) => {
@@ -311,13 +313,25 @@ export function useIfcLoader() {
       });
 
       const startDataModelParsing = () => {
-        // Use main thread - worker parsing disabled (IfcDataStore has closures that can't be serialized)
         const parser = new IfcParser();
+        // wasmApi as fallback if Web Worker unavailable
         const wasmApi = geometryProcessor.getApi();
         parser.parseColumnar(buffer, {
-          wasmApi, // Pass WASM API for 5-10x faster entity scanning
+          wasmApi,
+          // Emit spatial hierarchy EARLY — lets the panel render while
+          // property/association parsing continues (~0.5-1s earlier).
+          onSpatialReady: (partialStore) => {
+            if (loadSessionRef.current !== currentSession) return;
+            if (partialStore.spatialHierarchy && partialStore.spatialHierarchy.storeyHeights.size === 0 && partialStore.spatialHierarchy.storeyElevations.size > 1) {
+              const calculatedHeights = calculateStoreyHeights(partialStore.spatialHierarchy.storeyElevations);
+              for (const [storeyId, height] of calculatedHeights) {
+                partialStore.spatialHierarchy.storeyHeights.set(storeyId, height);
+              }
+            }
+            setIfcDataStore(partialStore);
+          },
         }).then(dataStore => {
-
+          if (loadSessionRef.current !== currentSession) return;
           // Calculate storey heights from elevation differences if not already populated
           if (dataStore.spatialHierarchy && dataStore.spatialHierarchy.storeyHeights.size === 0 && dataStore.spatialHierarchy.storeyElevations.size > 1) {
             const calculatedHeights = calculateStoreyHeights(dataStore.spatialHierarchy.storeyElevations);
@@ -326,6 +340,7 @@ export function useIfcLoader() {
             }
           }
 
+          // Update with full data (includes property/association maps)
           setIfcDataStore(dataStore);
           resolveDataStore(dataStore);
         }).catch(err => {
@@ -334,9 +349,10 @@ export function useIfcLoader() {
         });
       };
 
-      // Data model parsing is deferred to the 'complete' event (see below).
-      // Running it concurrently with geometry streaming steals main-thread cycles
-      // from the WASM↔JS bridge, adding ~1-2s to geometry completion time.
+      // Start data model parsing IMMEDIATELY — runs in parallel with geometry.
+      // Entity scan uses Web Worker (off main thread), columnar parse yields
+      // every ~4ms to maintain 60fps navigation during geometry streaming.
+      setTimeout(startDataModelParsing, 0);
 
       // Use adaptive processing: sync for small files, streaming for large files
       let estimatedTotal = 0;
@@ -352,11 +368,7 @@ export function useIfcLoader() {
       setGeometryResult(null);
 
       // Timing instrumentation
-      const processingStart = performance.now();
       let batchCount = 0;
-      let lastBatchTime = processingStart;
-      let totalWaitTime = 0; // Time waiting for WASM to yield batches
-      let totalProcessTime = 0; // Time processing batches in JS
       let firstGeometryTime = 0; // Time to first rendered geometry
       let modelOpenMs = 0;
       let lastTotalMeshes = 0;
@@ -377,7 +389,6 @@ export function useIfcLoader() {
           batchSize: dynamicBatchConfig, // Dynamic batches: small first, then large
         })) {
           const eventReceived = performance.now();
-          const waitTime = eventReceived - lastBatchTime;
 
           switch (event.type) {
             case 'start':
@@ -410,7 +421,6 @@ export function useIfcLoader() {
             }
             case 'batch': {
               batchCount++;
-              totalWaitTime += waitTime;
 
               // Track time to first geometry
               if (batchCount === 1) {
@@ -418,7 +428,6 @@ export function useIfcLoader() {
                 console.log(`[useIfc] Batch #1: ${event.meshes.length} meshes, wait: ${firstGeometryTime.toFixed(0)}ms`);
               }
 
-              const processStart = performance.now();
 
               // Collect meshes for BVH building (use loop to avoid stack overflow with large batches)
               for (let i = 0; i < event.meshes.length; i++) allMeshes.push(event.meshes[i]);
@@ -447,8 +456,6 @@ export function useIfcLoader() {
                 });
               }
 
-              const processTime = performance.now() - processStart;
-              totalProcessTime += processTime;
               break;
             }
             case 'complete':
@@ -460,11 +467,8 @@ export function useIfcLoader() {
 
               finalCoordinateInfo = event.coordinateInfo ?? null;
 
-              // PERF: Defer data model parsing to next macrotask so the browser
-              // can paint the streaming-complete state first. parseColumnar()
-              // synchronously calls scanEntitiesFast() which blocks the main
-              // thread for ~7s on large files (487MB → 8.4M entities).
-              setTimeout(startDataModelParsing, 0);
+              // Data model parsing already started in parallel (see above).
+              // No need to start it here — it runs concurrently with geometry.
 
               // Apply all accumulated color updates in a single store update
               // instead of one updateMeshColors() call per colorUpdate event.
@@ -482,31 +486,17 @@ export function useIfcLoader() {
 
               setProgress({ phase: 'Complete', percent: 100 });
               console.log(`[useIfc] Geometry streaming complete: ${batchCount} batches, ${lastTotalMeshes} meshes`);
-              console.log(`Total wait (WASM): ${totalWaitTime.toFixed(0)}ms`);
-              console.log(`Total process (JS): ${totalProcessTime.toFixed(0)}ms`);
 
               // Build spatial index and cache in background (non-blocking)
               // Wait for data model to complete first
               dataStorePromise.then(dataStore => {
-                // Build spatial index from meshes (in background)
-                if (allMeshes.length > 0) {
-                  const buildIndex = () => {
-                    try {
-                      const spatialIndex = buildSpatialIndex(allMeshes);
-                      dataStore.spatialIndex = spatialIndex;
-                      setIfcDataStore({ ...dataStore });
-                    } catch (err) {
-                      console.warn('[useIfc] Failed to build spatial index:', err);
-                    }
-                  };
-
-                  // Use requestIdleCallback if available (type assertion for optional browser API)
-                  if ('requestIdleCallback' in window) {
-                    (window as { requestIdleCallback: (cb: () => void, opts?: { timeout: number }) => void }).requestIdleCallback(buildIndex, { timeout: 2000 });
-                  } else {
-                    setTimeout(buildIndex, 100);
-                  }
-                }
+                // Guard: skip if user loaded a new file since this load started
+                if (loadSessionRef.current !== currentSession) return;
+                // Build spatial index from meshes in time-sliced chunks (non-blocking).
+                // Previously this was synchronous inside requestIdleCallback, blocking
+                // the main thread for seconds on 200K+ mesh models (190M+ float reads
+                // for bounds computation alone).
+                buildSpatialIndexGuarded(allMeshes, dataStore, setIfcDataStore);
 
                 // Cache the result in the background (files between 10 MB and 150 MB).
                 // Files above CACHE_MAX_SOURCE_SIZE are not cached because the
@@ -536,14 +526,15 @@ export function useIfcLoader() {
               break;
           }
 
-          lastBatchTime = performance.now();
         }
       } catch (err) {
+        if (loadSessionRef.current !== currentSession) return;
         console.error('[useIfc] Error in processing:', err);
         setError(err instanceof Error ? err.message : 'Unknown error during geometry processing');
       }
 
-      // Log developer-friendly summary with key metrics
+      if (loadSessionRef.current !== currentSession) return;
+
       const totalElapsedMs = performance.now() - totalStartTime;
       const totalVertices = allMeshes.reduce((sum, m) => sum + m.positions.length / 3, 0);
       console.log(
@@ -552,9 +543,9 @@ export function useIfcLoader() {
         `first: ${firstGeometryTime.toFixed(0)}ms, total: ${totalElapsedMs.toFixed(0)}ms`
       );
       console.log(`[useIfc] TOTAL LOAD TIME (local): ${totalElapsedMs.toFixed(0)}ms (${(totalElapsedMs / 1000).toFixed(1)}s)`);
-
       setLoading(false);
     } catch (err) {
+      if (loadSessionRef.current !== currentSession) return;
       setError(err instanceof Error ? err.message : 'Unknown error');
       setLoading(false);
     }

package/src/hooks/useIfcServer.ts

@@ -37,6 +37,7 @@ import {
 
 // Server data model conversion
 import { convertServerDataModel, type ServerParseResult } from '../utils/serverDataModel.js';
+import { buildSpatialIndexGuarded } from '../utils/loadingUtils.js';
 
 /** Convert server mesh data (snake_case) to viewer format (camelCase) */
 function convertServerMesh(m: ServerMeshData): MeshData {
@@ -125,7 +126,9 @@ export function useIfcServer() {
    */
   const loadFromServer = useCallback(async (
     file: File,
-    buffer: ArrayBuffer
+    buffer: ArrayBuffer,
+    /** Optional staleness check — returns true if this load has been superseded. */
+    isStale?: () => boolean,
   ): Promise<boolean> => {
     const { setProgress, setIfcDataStore, setGeometryResult } = useViewerStore.getState();
     try {
@@ -140,6 +143,7 @@ export function useIfcServer() {
         return false; // Silently fall back - caller handles logging
       }
 
+      if (isStale?.()) return false;
       setProgress({ phase: 'Processing on server (parallel)', percent: 15 });
 
       // Check if Parquet is supported (requires parquet-wasm)
@@ -397,6 +401,7 @@ export function useIfcServer() {
 
       // Start data model fetch in background - don't block rendering
       (async () => {
+        if (isStale?.()) return;
         setProgress({ phase: 'Fetching data model', percent: 85 });
         const dataModelStart = performance.now();
 
@@ -436,9 +441,12 @@ export function useIfcServer() {
             allMeshes
           );
 
+          if (isStale?.()) return;
           setIfcDataStore(dataStore);
           console.log('[useIfc] ✅ Property panel ready with server data model');
           console.log(`[useIfc] Data model loaded in ${(performance.now() - dataModelStart).toFixed(0)}ms (background)`);
+
+          buildSpatialIndexGuarded(allMeshes, dataStore, setIfcDataStore);
         } catch (err) {
           console.warn('[useIfc] Failed to decode data model:', err);
           console.log('[useIfc] ⚡ Skipping data model (decoding failed)');

package/src/hooks/useKeyboardShortcuts.ts

@@ -76,14 +76,6 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
       e.preventDefault();
       setActiveTool('select');
     }
-    if (key === 'p' && !ctrl && !shift) {
-      e.preventDefault();
-      setActiveTool('pan');
-    }
-    if (key === 'o' && !ctrl && !shift) {
-      e.preventDefault();
-      setActiveTool('orbit');
-    }
     if (key === 'c' && !ctrl && !shift) {
       e.preventDefault();
       setActiveTool('walk');
@@ -249,8 +241,6 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
 // Export shortcut definitions for UI display
 export const KEYBOARD_SHORTCUTS = [
   { key: 'V', description: 'Select tool', category: 'Tools' },
-  { key: 'P', description: 'Pan tool', category: 'Tools' },
-  { key: 'O', description: 'Orbit tool', category: 'Tools' },
   { key: 'C', description: 'Walk mode', category: 'Tools' },
   { key: 'M', description: 'Measure tool', category: 'Tools' },
   { key: 'X', description: 'Section tool', category: 'Tools' },

package/src/hooks/useLatestRef.ts

@@ -0,0 +1,24 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { useRef, useEffect, type MutableRefObject } from 'react';
+
+/**
+ * Keep a ref in sync with a value on every render.
+ *
+ * This replaces the common pattern of:
+ *   const fooRef = useRef(foo);
+ *   useEffect(() => { fooRef.current = foo; }, [foo]);
+ *
+ * The ref is updated synchronously during render (before effects),
+ * so event handlers and animation loops always see the latest value
+ * without needing to be re-created.
+ */
+export function useLatestRef<T>(value: T): MutableRefObject<T> {
+  const ref = useRef(value);
+  // Update synchronously during render — no useEffect needed.
+  // This is safe because we're only writing to a ref, not causing side effects.
+  ref.current = value;
+  return ref;
+}

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

@@ -369,7 +369,7 @@ export function createExportAdapter(store: StoreApi): ExportBackendMethods {
       return exporter.export(exportOptions).content;
     },
 
-    download(content: string, filename: string, mimeType?: string) {
+    download(content: string | Uint8Array, filename: string, mimeType?: string) {
       triggerDownload(content, filename, mimeType ?? 'text/plain');
       return undefined;
     },
@@ -377,7 +377,7 @@ export function createExportAdapter(store: StoreApi): ExportBackendMethods {
 }
 
 /** Trigger a browser file download */
-function triggerDownload(content: string, filename: string, mimeType: string): void {
+function triggerDownload(content: string | Uint8Array, filename: string, mimeType: string): void {
   if (typeof document === 'undefined') {
     throw new Error('download() requires a browser environment (document is unavailable)');
   }

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

@@ -15,6 +15,7 @@ export function createModelAdapter(store: StoreApi): ModelBackendMethods {
         result.push({
           id: model.id,
           name: model.name,
+          schema: model.schemaVersion,
           schemaVersion: model.schemaVersion,
           entityCount: model.ifcDataStore?.entities?.count ?? 0,
           fileSize: model.fileSize,

package/src/sdk/local-backend.ts

@@ -82,6 +82,7 @@ export class LocalBackend implements BimBackend {
                   model: {
                     id: model.id,
                     name: model.name,
+                    schema: model.schemaVersion,
                     schemaVersion: model.schemaVersion,
                     entityCount: model.ifcDataStore?.entities?.count ?? 0,
                     fileSize: model.fileSize,
@@ -96,6 +97,7 @@ export class LocalBackend implements BimBackend {
               model: {
                 id: LEGACY_MODEL_ID,
                 name: 'Model',
+                schema: state.ifcDataStore.schemaVersion ?? 'IFC4',
                 schemaVersion: state.ifcDataStore.schemaVersion ?? 'IFC4',
                 entityCount: state.ifcDataStore.entities?.count ?? 0,
                 fileSize: state.ifcDataStore.source?.byteLength ?? 0,

package/src/store/basketVisibleSet.ts

@@ -54,6 +54,15 @@ function digestModelEntityMap(map: Map<string, Set<number>>): string {
 
 function visibilityFingerprint(state: ViewerStateSnapshot): string {
   const tv = state.typeVisibility;
+
+  // Include per-model visible flag and geometry mesh count so the cache
+  // invalidates when model visibility is toggled or geometry finishes loading.
+  const modelParts: string[] = [];
+  for (const [modelId, model] of state.models) {
+    modelParts.push(`${modelId}:${model.visible ? 1 : 0}:${model.geometryResult?.meshes?.length ?? 0}`);
+  }
+  modelParts.sort();
+
   return [
     digestNumberSet(state.hiddenEntities),
     state.isolatedEntities ? digestNumberSet(state.isolatedEntities) : 'none',
@@ -61,10 +70,13 @@ function visibilityFingerprint(state: ViewerStateSnapshot): string {
     digestNumberSet(state.lensHiddenIds),
     digestModelEntityMap(state.hiddenEntitiesByModel),
     digestModelEntityMap(state.isolatedEntitiesByModel),
+    digestNumberSet(state.selectedStoreys),
     tv.spaces ? 1 : 0,
     tv.openings ? 1 : 0,
     tv.site ? 1 : 0,
     state.models.size,
+    modelParts.join(';'),
+    state.geometryResult?.meshes?.length ?? 0,
     state.activeBasketViewId ?? 'none',
   ].join(':');
 }

package/src/store/slices/bcfSlice.ts

@@ -35,6 +35,8 @@ export interface BCFSliceState {
   bcfError: string | null;
   /** Default author for new topics/comments */
   bcfAuthor: string;
+  /** Whether 3D overlay markers are shown in the viewport */
+  bcfOverlayVisible: boolean;
 }
 
 export interface BCFSlice extends BCFSliceState {
@@ -65,6 +67,8 @@ export interface BCFSlice extends BCFSliceState {
   setBcfLoading: (loading: boolean) => void;
   setBcfError: (error: string | null) => void;
   setBcfAuthor: (author: string) => void;
+  setBcfOverlayVisible: (visible: boolean) => void;
+  toggleBcfOverlay: () => void;
 
   // Utility getters
   getActiveTopic: () => BCFTopic | null;
@@ -102,6 +106,7 @@ export const createBcfSlice: StateCreator<BCFSlice, [], [], BCFSlice> = (set, ge
   bcfLoading: false,
   bcfError: null,
   bcfAuthor: getDefaultBcfAuthor(),
+  bcfOverlayVisible: false,
 
   // Project actions
   setBcfProject: (bcfProject) => set({
@@ -350,6 +355,10 @@ export const createBcfSlice: StateCreator<BCFSlice, [], [], BCFSlice> = (set, ge
     set({ bcfAuthor });
   },
 
+  setBcfOverlayVisible: (bcfOverlayVisible) => set({ bcfOverlayVisible }),
+
+  toggleBcfOverlay: () => set((state) => ({ bcfOverlayVisible: !state.bcfOverlayVisible })),
+
   // Utility getters
   getActiveTopic: () => {
     const state = get();

package/src/utils/loadingUtils.ts

@@ -0,0 +1,46 @@
+/* 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/. */
+
+/**
+ * Shared loading utilities used across all IFC loading hooks.
+ *
+ * Consolidates the guarded spatial-index build pattern that was
+ * duplicated across useIfcLoader, useIfcCache, useIfcServer, and
+ * useIfcFederation.
+ */
+
+import type { MeshData } from '@ifc-lite/geometry';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import { buildSpatialIndexAsync } from '@ifc-lite/spatial';
+import { useViewerStore } from '../store.js';
+
+/**
+ * Build a spatial index in the background (time-sliced, non-blocking)
+ * with a guard against stale loads.
+ *
+ * The guard captures the dataStore reference and compares it to the
+ * current store when the async build completes. If the store has been
+ * replaced (e.g. user loaded a new file), the result is discarded.
+ *
+ * @param meshes - Final mesh array with correct IDs and world-space positions
+ * @param dataStore - The IfcDataStore to attach the spatial index to
+ * @param setIfcDataStore - Store setter to trigger re-render
+ */
+export function buildSpatialIndexGuarded(
+  meshes: MeshData[],
+  dataStore: IfcDataStore,
+  setIfcDataStore: (store: IfcDataStore) => void,
+): void {
+  if (meshes.length === 0) return;
+
+  const capturedStore = dataStore;
+  buildSpatialIndexAsync(meshes).then(spatialIndex => {
+    const { ifcDataStore: currentStore } = useViewerStore.getState();
+    if (currentStore !== capturedStore) return;
+    capturedStore.spatialIndex = spatialIndex;
+    setIfcDataStore({ ...capturedStore });
+  }).catch(err => {
+    console.warn('[loadingUtils] Failed to build spatial index:', err);
+  });
+}

package/src/utils/serverDataModel.ts

@@ -32,7 +32,7 @@ import {
   type QuantitySet,
 } from '@ifc-lite/data';
 import { StringTable } from '@ifc-lite/data';
-import { buildSpatialIndex, type SpatialIndex } from '@ifc-lite/spatial';
+import type { SpatialIndex } from '@ifc-lite/spatial';
 
 // ============================================================================
 // Types
@@ -713,8 +713,9 @@ export function convertServerDataModel(
     },
   };
 
-  // Build spatial index
-  const spatialIndex = allMeshes.length > 0 ? buildSpatialIndex(allMeshes) : undefined;
+  // Spatial index is built asynchronously by the caller after this returns
+  // to avoid blocking the main thread for seconds on large models.
+  const spatialIndex: SpatialIndex | undefined = undefined;
 
   // Validate schemaVersion against allowed values
   const VALID_SCHEMA_VERSIONS = ['IFC2X3', 'IFC4', 'IFC4X3', 'IFC5'] as const;