@ifc-lite/viewer 1.17.3 → 1.17.4

package/src/components/viewer/useGeometryStreaming.ts

@@ -21,6 +21,7 @@
 import { useEffect, useRef, type MutableRefObject } from 'react';
 import type { Renderer } from '@ifc-lite/renderer';
 import type { MeshData, CoordinateInfo } from '@ifc-lite/geometry';
+import { logToDesktopTerminal } from '@/services/desktop-logger';
 
 export interface UseGeometryStreamingParams {
   rendererRef: MutableRefObject<Renderer | null>;
@@ -37,6 +38,8 @@ export interface UseGeometryStreamingParams {
   clearPendingMeshColorUpdates: () => void;
   clearPendingColorUpdates: () => void;
   clearColorRef: MutableRefObject<[number, number, number, number]>;
+  releaseGeometryAfterFinalize?: boolean;
+  onGeometryReleased?: () => void;
 }
 
 // Default bounds used when geometry is cleared
@@ -47,6 +50,11 @@ const DEFAULT_BOUNDS = {
 
 const MAX_VALID_COORD = 10000;
 
+function traceGeometrySync(message: string): void {
+  console.log(`[GeomSync] ${message}`);
+  void logToDesktopTerminal('info', `[GeomSync] ${message}`);
+}
+
 export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
   const {
     rendererRef,
@@ -61,6 +69,8 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     clearPendingMeshColorUpdates,
     clearPendingColorUpdates,
     clearColorRef,
+    releaseGeometryAfterFinalize = false,
+    onGeometryReleased,
   } = params;
 
   // ─── Tracking refs ───────────────────────────────────────────────────
@@ -71,6 +81,33 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
   const finalBoundsRefittedRef = useRef(false);
   const cameraSnapshotRef = useRef<{ px: number; py: number; pz: number; tx: number; ty: number; tz: number } | null>(null);
   const prevIsStreamingRef = useRef(isStreaming);
+  const queuePumpTimerRef = useRef<ReturnType<typeof globalThis.setTimeout> | null>(null);
+
+  // Only activate the timer-based queue pump when the tab is background-throttled
+  // (rAF stops firing). In the foreground, the animation loop already drains the
+  // queue every frame — a parallel setTimeout(0) pump doubles the GPU work and
+  // hurts Chrome (Dawn) where each buffer op is an IPC round-trip.
+  const ensureQueuePump = () => {
+    if (queuePumpTimerRef.current !== null) return;
+    if (!globalThis.document?.hidden) return; // rAF is active — let the animation loop drain
+    queuePumpTimerRef.current = globalThis.setTimeout(() => {
+      queuePumpTimerRef.current = null;
+      const renderer = rendererRef.current;
+      if (!renderer || !isInitialized) return;
+      const device = renderer.getGPUDevice();
+      const pipeline = renderer.getPipeline();
+      const scene = renderer.getScene();
+      if (!device || !pipeline || !scene.hasQueuedMeshes()) return;
+      const flushed = scene.flushPending(device, pipeline);
+      if (flushed) {
+        renderer.clearCaches();
+        renderer.requestRender();
+      }
+      if (scene.hasQueuedMeshes()) {
+        ensureQueuePump();
+      }
+    }, 0);
+  };
 
   // ─── Main geometry effect ────────────────────────────────────────────
   // Runs on every geometry change (new file, incremental batch, visibility toggle).
@@ -81,6 +118,7 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     // Geometry cleared/null — reset so next load is fresh
     if (!geometry) {
       if (lastGeometryLengthRef.current > 0 || lastGeometryRef.current !== null) {
+        traceGeometrySync(`geometry cleared lastLength=${lastGeometryLengthRef.current}`);
         lastGeometryLengthRef.current = 0;
         lastGeometryRef.current = null;
         processedMeshIdsRef.current.clear();
@@ -121,7 +159,9 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     }
 
     if (isNewFile) {
+      traceGeometrySync(`new file currentLength=${currentLength} lastLength=${lastLength} releaseAfterFinalize=${releaseGeometryAfterFinalize}`);
       scene.clear();
+      scene.setEphemeralStreamingMode(releaseGeometryAfterFinalize);
       processedMeshIdsRef.current.clear();
       cameraFittedRef.current = false;
       finalBoundsRefittedRef.current = false;
@@ -132,14 +172,18 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
       geometryBoundsRef.current = { ...DEFAULT_BOUNDS };
     } else if (!isIncremental && currentLength !== lastLength) {
       if (currentLength < lastLength) {
+        traceGeometrySync(`geometry rebuilt after shrink currentLength=${currentLength} lastLength=${lastLength}`);
         // Length decreased (model hidden) — rebuild scene, keep camera
         scene.clear();
+        scene.setEphemeralStreamingMode(releaseGeometryAfterFinalize);
         processedMeshIdsRef.current.clear();
         lastGeometryLengthRef.current = 0;
         lastGeometryRef.current = geometry;
       } else {
+        traceGeometrySync(`geometry rebuilt after replace currentLength=${currentLength} lastLength=${lastLength} releaseAfterFinalize=${releaseGeometryAfterFinalize}`);
         // New file while another was open — full reset
         scene.clear();
+        scene.setEphemeralStreamingMode(releaseGeometryAfterFinalize);
         processedMeshIdsRef.current.clear();
         cameraFittedRef.current = false;
         finalBoundsRefittedRef.current = false;
@@ -193,6 +237,10 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
         if (isStreaming) {
           // Queue for the animation loop — zero GPU work here.
           scene.queueMeshes(newMeshes);
+          // Desktop benchmark windows can become background-throttled, which
+          // stalls requestAnimationFrame-based draining. Keep a timer-based
+          // pump active so large native loads still finish offscreen.
+          ensureQueuePump();
         } else {
           // Non-streaming: process immediately (visibility toggles, etc.)
           scene.appendToBatches(newMeshes, device, pipeline, false);
@@ -230,66 +278,105 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     renderer.requestRender();
   }, [geometry, geometryVersion, coordinateInfo, isInitialized, isStreaming]);
 
+  useEffect(() => {
+    return () => {
+      if (queuePumpTimerRef.current !== null) {
+        globalThis.clearTimeout(queuePumpTimerRef.current);
+        queuePumpTimerRef.current = null;
+      }
+    };
+  }, []);
+
   // ─── Streaming complete: finalize + bounds refit ─────────────────────
   useEffect(() => {
     const renderer = rendererRef.current;
     if (!renderer || !isInitialized) return;
 
     if (prevIsStreamingRef.current && !isStreaming) {
-      // Flush any remaining queued meshes synchronously before finalize
-      const device = renderer.getGPUDevice();
-      const pipeline = renderer.getPipeline();
       const scene = renderer.getScene();
-      if (device && pipeline && scene.hasQueuedMeshes()) {
-        scene.flushPending(device, pipeline);
-      }
-
+      traceGeometrySync(
+        `stream transition complete geometryLength=${geometry?.length ?? 0} queued=${scene.hasQueuedMeshes()} batches=${scene.getBatchedMeshes().length}`
+      );
       renderer.requestRender();
 
-      // Defer heavy work so the browser processes pending input events first.
-      // Streaming fragments keep rendering until proper batches replace them.
       const capturedGeometry = geometry;
-      const timer = setTimeout(() => {
-        const r = rendererRef.current;
-        if (!r) return;
-
-        console.log('[GeomStream] Streaming ended — starting finalize');
-
-        // Compute exact bounds and refit camera (fast ~15ms scan)
-        if (cameraFittedRef.current && !finalBoundsRefittedRef.current && capturedGeometry && capturedGeometry.length > 0) {
-          const t0 = performance.now();
-          const exactBounds = computeBounds(capturedGeometry);
-          console.log(`[GeomStream] computeBounds: ${(performance.now() - t0).toFixed(0)}ms`);
-          if (exactBounds) {
-            if (!userMovedCamera(r, cameraSnapshotRef.current)) {
-              r.getCamera().fitToBounds(exactBounds.min, exactBounds.max);
+      let timeoutId: ReturnType<typeof globalThis.setTimeout> | null = null;
+      let rafId: number | null = null;
+
+      const startFinalize = () => {
+        timeoutId = globalThis.setTimeout(() => {
+          const r = rendererRef.current;
+          if (!r) return;
+
+          console.log('[GeomStream] Streaming ended — starting finalize');
+          traceGeometrySync(
+            `finalize start geometryLength=${capturedGeometry?.length ?? 0} releaseAfterFinalize=${releaseGeometryAfterFinalize}`
+          );
+
+          // Compute exact bounds and refit camera (fast ~15ms scan)
+          if (cameraFittedRef.current && !finalBoundsRefittedRef.current && capturedGeometry && capturedGeometry.length > 0) {
+            const t0 = performance.now();
+            const exactBounds = computeBounds(capturedGeometry);
+            console.log(`[GeomStream] computeBounds: ${(performance.now() - t0).toFixed(0)}ms`);
+            if (exactBounds) {
+              if (!userMovedCamera(r, cameraSnapshotRef.current)) {
+                r.getCamera().fitToBounds(exactBounds.min, exactBounds.max);
+              }
+              geometryBoundsRef.current = exactBounds;
+              finalBoundsRefittedRef.current = true;
             }
-            geometryBoundsRef.current = exactBounds;
-            finalBoundsRefittedRef.current = true;
           }
-        }
 
-        // Time-sliced finalize: rebuild proper batches in ~8ms chunks
-        const dev = r.getGPUDevice();
-        const pipe = r.getPipeline();
-        if (dev && pipe) {
-          const t0 = performance.now();
-          r.getScene().finalizeStreamingAsync(dev, pipe).then(() => {
-            const batchCount = r.getScene().getBatchedMeshes().length;
-            let totalIdx = 0;
-            for (const b of r.getScene().getBatchedMeshes()) totalIdx += b.indexCount;
-            console.log(`[GeomStream] finalizeStreamingAsync complete: ${(performance.now() - t0).toFixed(0)}ms → ${batchCount} consolidated batches, ${(totalIdx / 3 / 1e6).toFixed(1)}M triangles`);
+          // Time-sliced finalize: rebuild proper batches in ~8ms chunks
+          if (releaseGeometryAfterFinalize) {
+            r.getScene().finishEphemeralStreaming();
+            onGeometryReleased?.();
             r.clearCaches();
             r.requestRender();
-          });
+            traceGeometrySync(`ephemeral finalize complete batches=${r.getScene().getBatchedMeshes().length}`);
+            return;
+          }
+
+          const dev = r.getGPUDevice();
+          const pipe = r.getPipeline();
+          if (dev && pipe) {
+            const t0 = performance.now();
+            r.getScene().finalizeStreamingAsync(dev, pipe).then(() => {
+              const batchCount = r.getScene().getBatchedMeshes().length;
+              let totalIdx = 0;
+              for (const b of r.getScene().getBatchedMeshes()) totalIdx += b.indexCount;
+              console.log(`[GeomStream] finalizeStreamingAsync complete: ${(performance.now() - t0).toFixed(0)}ms → ${batchCount} consolidated batches, ${(totalIdx / 3 / 1e6).toFixed(1)}M triangles`);
+              traceGeometrySync(
+                `finalize complete elapsed=${(performance.now() - t0).toFixed(0)}ms batches=${batchCount} queued=${r.getScene().hasQueuedMeshes()}`
+              );
+              r.clearCaches();
+              r.requestRender();
+            });
+          }
+        }, 0);
+      };
+
+      const waitForQueueDrain = () => {
+        const currentRenderer = rendererRef.current;
+        if (!currentRenderer) return;
+        if (!currentRenderer.getScene().hasQueuedMeshes()) {
+          startFinalize();
+          return;
         }
-      }, 0);
+        currentRenderer.requestRender();
+        rafId = requestAnimationFrame(waitForQueueDrain);
+      };
+
+      waitForQueueDrain();
 
       prevIsStreamingRef.current = isStreaming;
-      return () => clearTimeout(timer);
+      return () => {
+        if (timeoutId !== null) globalThis.clearTimeout(timeoutId);
+        if (rafId !== null) cancelAnimationFrame(rafId);
+      };
     }
     prevIsStreamingRef.current = isStreaming;
-  }, [isStreaming, isInitialized]);
+  }, [isStreaming, isInitialized, releaseGeometryAfterFinalize, onGeometryReleased]);
 
   // ─── Mesh color updates (style/material deferred colors) ─────────────
   useEffect(() => {

package/src/components/viewer/useMouseControls.ts

@@ -129,6 +129,8 @@ export interface UseMouseControlsParams {
   RENDER_THROTTLE_MS_SMALL: number;
   RENDER_THROTTLE_MS_LARGE: number;
   RENDER_THROTTLE_MS_HUGE: number;
+  /** When true, wheel zoom uses unrestricted pure-dolly mode (Cesium) */
+  fastZoomRef: MutableRefObject<boolean>;
 }
 
 export function useMouseControls(params: UseMouseControlsParams): void {
@@ -476,7 +478,8 @@ export function useMouseControls(params: UseMouseControlsParams): void {
       const rect = canvas.getBoundingClientRect();
       const mouseX = e.clientX - rect.left;
       const mouseY = e.clientY - rect.top;
-      camera.zoom(e.deltaY, false, mouseX, mouseY, canvas.width, canvas.height);
+      const fastZoom = e.shiftKey || params.fastZoomRef.current;
+      camera.zoom(e.deltaY, false, mouseX, mouseY, canvas.width, canvas.height, fastZoom);
 
       isInteractingRef.current = true;
       renderer.requestRender();

package/src/hooks/ingest/viewerModelIngest.ts

@@ -0,0 +1,275 @@
+/* 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 { IfcParser, parseIfcx, type IfcDataStore } from '@ifc-lite/parser';
+import { GeometryProcessor, GeometryQuality, type CoordinateInfo, type GeometryResult, type MeshData } from '@ifc-lite/geometry';
+import { loadGLBToMeshData } from '@ifc-lite/cache';
+import type { SchemaVersion } from '../../store/types.js';
+import { calculateMeshBounds, calculateStoreyHeights, createCoordinateInfo, normalizeColor } from '../../utils/localParsingUtils.js';
+
+type RgbaColor = [number, number, number, number];
+
+interface RawIfcxMesh {
+  expressId?: number;
+  express_id?: number;
+  id?: number;
+  positions: Float32Array | number[];
+  indices: Uint32Array | number[];
+  normals: Float32Array | number[];
+  color?: [number, number, number, number] | [number, number, number];
+  ifcType?: string;
+  ifc_type?: string;
+}
+
+export interface ViewerModelPayload {
+  dataStore: IfcDataStore;
+  geometryResult: GeometryResult;
+  schemaVersion: SchemaVersion;
+}
+
+export interface StepBatchEvent {
+  batchIndex: number;
+  estimatedTotal: number;
+  totalSoFar: number;
+  meshes: MeshData[];
+  coordinateInfo?: CoordinateInfo | null;
+}
+
+export interface StepRtcOffsetEvent {
+  rtcOffset: { x: number; y: number; z: number };
+}
+
+export interface StepBufferIngestOptions {
+  fileName: string;
+  buffer: ArrayBuffer;
+  fileSizeMB: number;
+  getDynamicBatchSize: (fileSizeMB: number) => number | { initial: number; subsequent: number };
+  onProgress?: (progress: { phase: string; percent: number }) => void;
+  onBatch?: (event: StepBatchEvent) => void;
+  onColorUpdate?: (updates: Map<number, RgbaColor>) => void;
+  onSpatialReady?: (dataStore: IfcDataStore) => void;
+  onRtcOffset?: (event: StepRtcOffsetEvent) => void;
+  shouldAbort?: () => boolean;
+}
+
+export interface StepBufferIngestResult extends ViewerModelPayload {
+  allMeshes: MeshData[];
+  cumulativeColorUpdates: Map<number, RgbaColor>;
+}
+
+export function convertIfcxMeshes(rawMeshes: RawIfcxMesh[]): MeshData[] {
+  return rawMeshes.map((mesh) => {
+    const positions = mesh.positions instanceof Float32Array ? mesh.positions : new Float32Array(mesh.positions || []);
+    const indices = mesh.indices instanceof Uint32Array ? mesh.indices : new Uint32Array(mesh.indices || []);
+    const normals = mesh.normals instanceof Float32Array ? mesh.normals : new Float32Array(mesh.normals || []);
+
+    return {
+      expressId: mesh.expressId ?? mesh.express_id ?? mesh.id ?? 0,
+      positions,
+      indices,
+      normals,
+      color: normalizeColor(mesh.color),
+      ifcType: mesh.ifcType ?? mesh.ifc_type ?? 'IfcProduct',
+    };
+  }).filter((mesh) => mesh.positions.length > 0 && mesh.indices.length > 0);
+}
+
+export function createMinimalGlbDataStore(buffer: ArrayBuffer, meshCount: number): IfcDataStore {
+  return {
+    fileSize: buffer.byteLength,
+    schemaVersion: 'IFC4' as const,
+    entityCount: meshCount,
+    parseTime: 0,
+    source: new Uint8Array(0),
+    entityIndex: { byId: new Map(), byType: new Map() },
+    strings: { getString: () => undefined, getStringId: () => undefined, count: 0 } as unknown as IfcDataStore['strings'],
+    entities: { count: 0, getId: () => 0, getType: () => 0, getName: () => undefined, getGlobalId: () => undefined } as unknown as IfcDataStore['entities'],
+    properties: { count: 0, getPropertiesForEntity: () => [], getPropertySetForEntity: () => [] } as unknown as IfcDataStore['properties'],
+    quantities: { count: 0, getQuantitiesForEntity: () => [] } as unknown as IfcDataStore['quantities'],
+    relationships: { count: 0, getRelationships: () => [], getRelated: () => [] } as unknown as IfcDataStore['relationships'],
+    spatialHierarchy: null as unknown as IfcDataStore['spatialHierarchy'],
+  } as unknown as IfcDataStore;
+}
+
+export function normalizeDataStoreStoreys(dataStore: IfcDataStore): IfcDataStore {
+  if (dataStore.spatialHierarchy && dataStore.spatialHierarchy.storeyHeights.size === 0 && dataStore.spatialHierarchy.storeyElevations.size > 1) {
+    const calculatedHeights = calculateStoreyHeights(dataStore.spatialHierarchy.storeyElevations);
+    for (const [storeyId, height] of calculatedHeights) {
+      dataStore.spatialHierarchy.storeyHeights.set(storeyId, height);
+    }
+  }
+  return dataStore;
+}
+
+export function getMaxExpressId(dataStore: IfcDataStore, meshes: MeshData[]): number {
+  const maxExpressIdFromMeshes = meshes.reduce((max, mesh) => Math.max(max, mesh.expressId), 0);
+  let maxExpressIdFromEntities = 0;
+  if (dataStore.entityIndex?.byId) {
+    for (const key of dataStore.entityIndex.byId.keys()) {
+      if (key > maxExpressIdFromEntities) {
+        maxExpressIdFromEntities = key;
+      }
+    }
+  }
+  return Math.max(maxExpressIdFromMeshes, maxExpressIdFromEntities);
+}
+
+export async function parseIfcxViewerModel(
+  buffer: ArrayBuffer,
+  onProgress?: (progress: { phase: string; percent: number }) => void,
+): Promise<ViewerModelPayload> {
+  const ifcxResult = await parseIfcx(buffer, {
+    onProgress: (progress) => {
+      onProgress?.({
+        phase: `IFCX ${progress.phase}`,
+        percent: 10 + (progress.percent * 0.8),
+      });
+    },
+  });
+
+  const meshes = convertIfcxMeshes(ifcxResult.meshes);
+  if (meshes.length === 0 && ifcxResult.entityCount > 0) {
+    throw new Error('overlay-only-ifcx');
+  }
+
+  const { bounds, stats } = calculateMeshBounds(meshes);
+  return {
+    dataStore: {
+      fileSize: ifcxResult.fileSize,
+      schemaVersion: 'IFC5' as const,
+      entityCount: ifcxResult.entityCount,
+      parseTime: ifcxResult.parseTime,
+      source: new Uint8Array(buffer),
+      entityIndex: { byId: new Map(), byType: new Map() },
+      strings: ifcxResult.strings,
+      entities: ifcxResult.entities,
+      properties: ifcxResult.properties,
+      quantities: ifcxResult.quantities,
+      relationships: ifcxResult.relationships,
+      spatialHierarchy: ifcxResult.spatialHierarchy,
+    } as unknown as IfcDataStore,
+    geometryResult: {
+      meshes,
+      totalVertices: stats.totalVertices,
+      totalTriangles: stats.totalTriangles,
+      coordinateInfo: createCoordinateInfo(bounds),
+    },
+    schemaVersion: 'IFC5',
+  };
+}
+
+export async function parseGlbViewerModel(buffer: ArrayBuffer): Promise<ViewerModelPayload> {
+  const meshes = loadGLBToMeshData(new Uint8Array(buffer));
+  if (meshes.length === 0) {
+    throw new Error('glb-empty');
+  }
+
+  const { bounds, stats } = calculateMeshBounds(meshes);
+  return {
+    dataStore: createMinimalGlbDataStore(buffer, meshes.length),
+    geometryResult: {
+      meshes,
+      totalVertices: stats.totalVertices,
+      totalTriangles: stats.totalTriangles,
+      coordinateInfo: createCoordinateInfo(bounds),
+    },
+    schemaVersion: 'IFC4',
+  };
+}
+
+export async function parseStepBufferViewerModel(options: StepBufferIngestOptions): Promise<StepBufferIngestResult> {
+  const geometryProcessor = new GeometryProcessor({ quality: GeometryQuality.Balanced });
+  await geometryProcessor.init();
+
+  const parser = new IfcParser();
+  const wasmApi = geometryProcessor.getApi();
+  const allMeshes: MeshData[] = [];
+  const cumulativeColorUpdates = new Map<number, RgbaColor>();
+  let finalCoordinateInfo: CoordinateInfo | null = null;
+  let batchIndex = 0;
+  let estimatedTotal = 0;
+  let capturedRtcOffset: { x: number; y: number; z: number } | null = null;
+
+  const dataStorePromise = parser.parseColumnar(options.buffer, {
+    wasmApi,
+    onSpatialReady: (partialStore) => {
+      if (options.shouldAbort?.()) {
+        return;
+      }
+      options.onSpatialReady?.(normalizeDataStoreStoreys(partialStore));
+    },
+  });
+
+  for await (const event of geometryProcessor.processAdaptive(new Uint8Array(options.buffer), {
+    sizeThreshold: 2 * 1024 * 1024,
+    batchSize: options.getDynamicBatchSize(options.fileSizeMB),
+  })) {
+    if (options.shouldAbort?.()) {
+      break;
+    }
+    switch (event.type) {
+      case 'start':
+        estimatedTotal = event.totalEstimate;
+        break;
+      case 'colorUpdate':
+        for (const [expressId, color] of event.updates) {
+          cumulativeColorUpdates.set(expressId, color);
+        }
+        options.onColorUpdate?.(event.updates);
+        break;
+      case 'rtcOffset':
+        if (event.hasRtc) {
+          capturedRtcOffset = event.rtcOffset;
+          options.onRtcOffset?.({ rtcOffset: event.rtcOffset });
+        }
+        break;
+      case 'batch':
+        batchIndex += 1;
+        for (let i = 0; i < event.meshes.length; i++) {
+          allMeshes.push(event.meshes[i]);
+        }
+        finalCoordinateInfo = event.coordinateInfo ?? null;
+        options.onBatch?.({
+          batchIndex,
+          estimatedTotal,
+          totalSoFar: event.totalSoFar,
+          meshes: event.meshes,
+          coordinateInfo: event.coordinateInfo ?? null,
+        });
+        options.onProgress?.({
+          phase: `Processing geometry (${event.totalSoFar} meshes)`,
+          percent: 10 + Math.min(80, (allMeshes.length / 1000) * 0.8),
+        });
+        break;
+      case 'complete':
+        finalCoordinateInfo = event.coordinateInfo ?? null;
+        break;
+    }
+  }
+
+  const dataStore = normalizeDataStoreStoreys(await dataStorePromise);
+  if (!finalCoordinateInfo) {
+    finalCoordinateInfo = createCoordinateInfo(calculateMeshBounds(allMeshes).bounds);
+  }
+  if (capturedRtcOffset) {
+    finalCoordinateInfo.wasmRtcOffset = capturedRtcOffset;
+  }
+
+  return {
+    dataStore,
+    geometryResult: {
+      meshes: allMeshes,
+      totalVertices: allMeshes.reduce((sum, mesh) => sum + mesh.positions.length / 3, 0),
+      totalTriangles: allMeshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0),
+      coordinateInfo: finalCoordinateInfo,
+    },
+    schemaVersion: dataStore.schemaVersion === 'IFC4X3'
+      ? 'IFC4X3'
+      : dataStore.schemaVersion === 'IFC4'
+        ? 'IFC4'
+        : 'IFC2X3',
+    allMeshes,
+    cumulativeColorUpdates,
+  };
+}

package/src/hooks/useIDS.ts

@@ -793,7 +793,7 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
     const url = URL.createObjectURL(blob);
     const a = globalThis.document.createElement('a');
     a.href = url;
-    a.download = `ids-report-${new Date().toISOString().split('T')[0]}.bcf`;
+    a.download = `ids-report-${new Date().toISOString().split('T')[0]}.bcfzip`;
     a.click();
     URL.revokeObjectURL(url);
 

package/src/hooks/useIfc.ts

@@ -14,7 +14,7 @@
 
 import { useMemo, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '@/store';
 import { IfcQuery } from '@ifc-lite/query';
 import type { IfcDataStore } from '@ifc-lite/parser';
 
@@ -26,6 +26,8 @@ export function useIfc() {
   const {
     loading,
     progress,
+    geometryProgress,
+    metadataProgress,
     error,
     ifcDataStore,
     geometryResult,
@@ -45,6 +47,8 @@ export function useIfc() {
   } = useViewerStore(useShallow((s) => ({
     loading: s.loading,
     progress: s.progress,
+    geometryProgress: s.geometryProgress,
+    metadataProgress: s.metadataProgress,
     error: s.error,
     ifcDataStore: s.ifcDataStore,
     geometryResult: s.geometryResult,
@@ -94,6 +98,8 @@ export function useIfc() {
     // Legacy single-model API (backward compatibility)
     loading,
     progress,
+    geometryProgress,
+    metadataProgress,
     error,
     ifcDataStore,
     geometryResult,