@ifc-lite/viewer 1.28.0 → 1.28.1

package/src/hooks/useIfcLoader.ts

@@ -26,28 +26,17 @@ import {
   type GeometryResult,
 } from '@ifc-lite/geometry';
 import { acquireFileBuffer, type AcquiredBuffer } from '../utils/acquireFileBuffer.js';
-import initIfcLiteWasm, { IfcAPI } from '@ifc-lite/wasm';
 import { buildSpatialIndexGuarded, buildSpatialIndexForModel } from '../utils/loadingUtils.js';
 import { type GeometryData } from '@ifc-lite/cache';
 
-import { SERVER_URL, USE_SERVER, CACHE_SIZE_THRESHOLD, CACHE_MAX_SOURCE_SIZE, HUGE_NATIVE_FILE_THRESHOLD, getDynamicBatchConfig } from '../utils/ifcConfig.js';
+import { SERVER_URL, USE_SERVER, CACHE_SIZE_THRESHOLD, CACHE_MAX_SOURCE_SIZE, getDynamicBatchConfig } from '../utils/ifcConfig.js';
 import {
   calculateMeshBounds,
   createCoordinateInfo,
   getRenderIntervalMs,
   calculateStoreyHeights,
 } from '../utils/localParsingUtils.js';
-import { buildDesktopMetadataSnapshot, restoreDesktopMetadataSnapshot } from '../utils/desktopModelSnapshot.js';
-import { buildIfcDataStoreFromNativeMetadata } from '../utils/nativeSpatialDataStore.js';
 import { applyColorUpdatesToMeshes } from './meshColorUpdates.js';
-import { readNativeFile, type NativeFileHandle } from '../services/file-dialog.js';
-import {
-  bootstrapNativeMetadata,
-  persistNativeMetadataSnapshot,
-  restoreNativeMetadataSnapshot,
-} from '../services/desktop-native-metadata.js';
-import { finalizeActiveHarnessRun, getActiveHarnessRequest } from '../services/desktop-harness.js';
-import { logToDesktopTerminal } from '../services/desktop-logger.js';
 
 // Cache hook
 import { useIfcCache, getCached } from './useIfcCache.js';
@@ -116,25 +105,6 @@ function computeFastFingerprint(buffer: ArrayBuffer): string {
   return (hash >>> 0).toString(16);
 }
 
-function toExactArrayBuffer(bytes: Uint8Array): ArrayBuffer {
-  if (
-    bytes.buffer instanceof ArrayBuffer &&
-    bytes.byteOffset === 0 &&
-    bytes.byteLength === bytes.buffer.byteLength
-  ) {
-    return bytes.buffer;
-  }
-  return bytes.slice().buffer;
-}
-
-function yieldToUiThread(): Promise<void> {
-  return new Promise<void>((resolve) => {
-    const channel = new MessageChannel();
-    channel.port1.onmessage = () => resolve();
-    channel.port2.postMessage(null);
-  });
-}
-
 /**
  * Size-aware first-batch watchdog. Delegates to the package-level helper so
  * the formula stays unit-tested in `@ifc-lite/geometry`. Subsequent-batch
@@ -154,41 +124,6 @@ function getGeometryStreamWatchdogMs(
   });
 }
 
-function countNativeSpatialNodes(
-  node: { children?: Array<{ children?: unknown[] }> } | null | undefined,
-): number {
-  if (!node) return 0;
-  const children = Array.isArray(node.children) ? node.children : [];
-  let total = 1;
-  for (let i = 0; i < children.length; i += 1) {
-    total += countNativeSpatialNodes(children[i] as { children?: Array<{ children?: unknown[] }> });
-  }
-  return total;
-}
-
-function computeNativeCacheKey(file: NativeFileHandle): string {
-  const encodedPath = new TextEncoder().encode(file.path);
-  const pathHash = computeFastFingerprint(toExactArrayBuffer(encodedPath));
-  return `native-ifc-${file.size}-${file.modifiedMs ?? 0}-${pathHash}-v1`;
-}
-
-function isNativeFileHandle(file: File | NativeFileHandle): file is NativeFileHandle {
-  return typeof (file as NativeFileHandle).path === 'string';
-}
-
-let metadataScanApiPromise: Promise<IfcAPI> | null = null;
-
-async function getMetadataScanApi(): Promise<IfcAPI> {
-  if (!metadataScanApiPromise) {
-    metadataScanApiPromise = (async () => {
-      await initIfcLiteWasm();
-      return new IfcAPI();
-    })();
-  }
-  return metadataScanApiPromise;
-}
-
-const ENABLE_HUGE_TIME_FLUSH = import.meta.env.VITE_IFC_ENABLE_HUGE_TIME_FLUSH === 'true';
 
 /**
  * Hook providing file loading operations for single-model path
@@ -240,7 +175,7 @@ export function useIfcLoader() {
   const { loadFromServer } = useIfcServer();
 
   const loadFile = useCallback(async (
-    file: File | NativeFileHandle,
+    file: File,
     target: LoadTarget = { kind: 'primary' },
   ) => {
     const { resetViewerState, clearAllModels } = useViewerStore.getState();
@@ -305,7 +240,6 @@ export function useIfcLoader() {
           geometryLoadState: 'pending',
           metadataLoadState: 'idle',
           interactiveReady: false,
-          nativeMetadata: null,
           cacheState: 'none',
           loadError: null,
         });
@@ -434,949 +368,13 @@ export function useIfcLoader() {
       };
 
 
-      // Desktop native streaming path is reserved for truly large IFC files.
-      // Mid-size files are more stable on the shared WASM/web loader and still
-      // provide full viewer parity without the native streaming complexity.
-      // PRIMARY only: the native path paints the active slot and isn't target-
-      // aware, so a federated huge .ifc routes through the awaited WASM stream
-      // (which gates active-model writes) instead — matching the former
-      // federated path, which always used the WASM ingest regardless of size.
-      if (
-        target.kind === 'primary'
-        && isNativeFileHandle(file)
-        && fileName.toLowerCase().endsWith('.ifc')
-        && file.size >= HUGE_NATIVE_FILE_THRESHOLD
-      ) {
-        const harnessRequest = getActiveHarnessRequest();
-        const nativeCacheKey = computeNativeCacheKey(file);
-        const shouldUseNativeCache = file.size >= CACHE_SIZE_THRESHOLD;
-        const hugeNativeMode = file.size >= HUGE_NATIVE_FILE_THRESHOLD;
-        const retainAllMeshes = !hugeNativeMode;
-        console.log(`[useIfc] Native path load: ${fileName}, size: ${fileSizeMB.toFixed(2)}MB`);
-        void logToDesktopTerminal(
-          'info',
-          `[useIfc] Native path load start: ${fileName} (${fileSizeMB.toFixed(2)} MB) path=${file.path} hugeMode=${hugeNativeMode ? 'yes' : 'no'}`
-        );
-        setBoundedGeometryMode(hugeNativeMode);
-        setGeometryStreamingActive(true);
-        setIfcDataStore(null);
-        setProgress({ phase: 'Starting native geometry streaming', percent: 10 });
-
-        // Snapshot the user's "Merge Multilayer Walls" preference once
-        // at load time — flipping the toggle mid-stream cannot affect
-        // an in-flight WASM pipeline, the reload banner handles that.
-        const mergeLayersAtLoad = useViewerStore.getState().mergeLayers;
-        const geometryProcessor = new GeometryProcessor({
-          quality: GeometryQuality.Balanced,
-          preferNative: true,
-          mergeLayers: mergeLayersAtLoad,
-        });
-
-        let estimatedTotal = 0;
-        let totalMeshes = 0;
-        let totalVertices = 0;
-        let totalTriangles = 0;
-        const allMeshes: MeshData[] = [];
-        let finalCoordinateInfo: CoordinateInfo | null = null;
-        let batchCount = 0;
-        let modelOpenMs: number | null = null;
-        let firstGeometryTime = 0;
-        let firstAppendGeometryBatchMs: number | null = null;
-        let firstVisibleGeometryMs: number | null = null;
-        let jsFirstChunkReceivedMs: number | null = null;
-        let lastTotalMeshes = 0;
-        let pendingMeshes: MeshData[] = [];
-        let loggedFirstAppendStoreState = false;
-        let lastRenderTime = 0;
-        let streamCompleteMs: number | null = null;
-        let metadataStartMs: number | null = null;
-        let metadataReadCompleteMs: number | null = null;
-        let metadataParseStartMs: number | null = null;
-        let spatialReadyMs: number | null = null;
-        let metadataCompleteMs: number | null = null;
-        let metadataFailedMs: number | null = null;
-        let metadataReadDurationMs: number | null = null;
-        let metadataBufferCopyDurationMs: number | null = null;
-        let metadataParseDurationMs: number | null = null;
-        let metadataParsingPromise: Promise<void> | null = null;
-        let metadataStallWatchId: ReturnType<typeof globalThis.setInterval> | null = null;
-        let lastMetadataActivityTime = 0;
-        let currentMetadataActivity = 'idle';
-        let firstNativeBatchTelemetry: {
-          batchSequence: number;
-          payloadKind: string;
-          meshCount: number;
-          positionsLen: number;
-          normalsLen: number;
-          indicesLen: number;
-          chunkReadyTimeMs: number;
-          packTimeMs: number;
-          emittedTimeMs: number;
-          emitTimeMs: number;
-          jsReceivedTimeMs?: number;
-        } | null = null;
-        let nativeStats: {
-          parseTimeMs?: number;
-          entityScanTimeMs?: number;
-          lookupTimeMs?: number;
-          preprocessTimeMs?: number;
-          geometryTimeMs?: number;
-          totalTimeMs?: number;
-          firstChunkReadyTimeMs?: number;
-          firstChunkPackTimeMs?: number;
-          firstChunkEmittedTimeMs?: number;
-          firstChunkEmitTimeMs?: number;
-        } | null = null;
-        const RENDER_INTERVAL_MS = getRenderIntervalMs(fileSizeMB);
-        const NATIVE_PENDING_MESH_THRESHOLD =
-          fileSizeMB > 768 ? 8192 :
-          fileSizeMB > 512 ? 6144 :
-          fileSizeMB > 256 ? 4096 :
-          fileSizeMB > 100 ? 2048 :
-          512;
-        const HUGE_NATIVE_APPEND_CHUNK_SIZE = fileSizeMB > 768 ? 2048 : hugeNativeMode ? 1536 : 0;
-        const HUGE_NATIVE_APPEND_YIELD_THRESHOLD = fileSizeMB > 768 ? 8192 : 6144;
-        const HUGE_NATIVE_APPEND_YIELD_BUDGET_MS = 10;
-        let metadataParsingStarted = false;
-        let geometryCompleted = false;
-        let fullNativeDataStore: IfcDataStore | null = null;
-        let nativeLoadStage: 'open' | 'streamGeometry' | 'finalizeGeometry' | 'hydrateMetadata' | 'complete' = 'open';
-        let nativeMetadataSource: 'snapshot' | 'ifc-parse' = 'ifc-parse';
-        let nativeMetadataStartGate = 'immediate' as 'immediate' | 'afterInteractiveGeometry' | 'afterGeometryComplete';
-
-        setGeometryResult(null);
-
-        const maybeBuildNativeSpatialIndex = () => {
-          if (
-            !retainAllMeshes ||
-            !geometryCompleted ||
-            !fullNativeDataStore ||
-            allMeshes.length === 0 ||
-            hugeNativeMode ||
-            loadSessionRef.current !== currentSession
-          ) {
-            return;
-          }
-          buildSpatialIndexGuarded(allMeshes, fullNativeDataStore, setIfcDataStore);
-        };
-
-        const flushPendingNativeMeshes = async (
-          coordinateInfo: CoordinateInfo | null | undefined,
-          totalMeshesSoFar: number,
-        ) => {
-          if (pendingMeshes.length === 0) {
-            return;
-          }
-
-          if (firstAppendGeometryBatchMs === null) {
-            firstAppendGeometryBatchMs = performance.now() - totalStartTime;
-            void logToDesktopTerminal(
-              'info',
-              `[useIfc] Native first appendGeometryBatch for ${fileName}: ${firstAppendGeometryBatchMs.toFixed(0)}ms`
-            );
-          }
-
-          void totalMeshesSoFar;
-
-          const appendMeshesToStore = (meshesToAppend: MeshData[]) => {
-            const appendGeometryBatchToStore = getViewerStoreApi().getState().appendGeometryBatch;
-            if (hugeNativeMode) {
-              flushSync(() => {
-                appendGeometryBatchToStore(meshesToAppend, coordinateInfo ?? undefined);
-              });
-              return;
-            }
-            appendGeometryBatchToStore(meshesToAppend, coordinateInfo ?? undefined);
-          };
-
-          if (!hugeNativeMode || HUGE_NATIVE_APPEND_CHUNK_SIZE <= 0 || pendingMeshes.length <= HUGE_NATIVE_APPEND_CHUNK_SIZE) {
-            appendMeshesToStore(pendingMeshes);
-            if (!loggedFirstAppendStoreState) {
-              const stateAfterAppend = useViewerStore.getState();
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Store after append for ${fileName}: activeModelId=${stateAfterAppend.activeModelId ?? 'null'} legacyMeshes=${stateAfterAppend.geometryResult?.meshes.length ?? 0} modelMeshes=${stateAfterAppend.models.get(modelId)?.geometryResult?.meshes.length ?? 0} geometryTick=${stateAfterAppend.geometryUpdateTick}`
-              );
-              loggedFirstAppendStoreState = true;
-            }
-            if (hugeNativeMode) {
-              await yieldToUiThread();
-              if (typeof requestAnimationFrame === 'function') {
-                await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-              }
-            }
-            pendingMeshes = [];
-            markFirstVisibleGeometry();
-            return;
-          }
-
-          let appendedSinceYield = 0;
-          let appendWindowStart = performance.now();
-          while (pendingMeshes.length > 0) {
-            const chunk = pendingMeshes.splice(0, HUGE_NATIVE_APPEND_CHUNK_SIZE);
-            appendMeshesToStore(chunk);
-            if (!loggedFirstAppendStoreState) {
-              const stateAfterAppend = useViewerStore.getState();
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Store after append for ${fileName}: activeModelId=${stateAfterAppend.activeModelId ?? 'null'} legacyMeshes=${stateAfterAppend.geometryResult?.meshes.length ?? 0} modelMeshes=${stateAfterAppend.models.get(modelId)?.geometryResult?.meshes.length ?? 0} geometryTick=${stateAfterAppend.geometryUpdateTick}`
-              );
-              loggedFirstAppendStoreState = true;
-            }
-            appendedSinceYield += chunk.length;
-            markFirstVisibleGeometry();
-            if (pendingMeshes.length === 0) {
-              break;
-            }
-
-            const shouldYield =
-              appendedSinceYield >= HUGE_NATIVE_APPEND_YIELD_THRESHOLD ||
-              performance.now() - appendWindowStart >= HUGE_NATIVE_APPEND_YIELD_BUDGET_MS;
-            if (shouldYield) {
-              await yieldToUiThread();
-              if (typeof requestAnimationFrame === 'function') {
-                await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-              }
-              appendedSinceYield = 0;
-              appendWindowStart = performance.now();
-            }
-          }
-        };
-
-        const markFirstVisibleGeometry = () => {
-          if (firstVisibleGeometryMs !== null) return;
-          requestAnimationFrame(() => {
-            if (firstVisibleGeometryMs !== null || loadSessionRef.current !== currentSession) return;
-            firstVisibleGeometryMs = performance.now() - totalStartTime;
-            void logToDesktopTerminal(
-              'info',
-              `[useIfc] Native first visible geometry for ${fileName}: ${firstVisibleGeometryMs.toFixed(0)}ms`
-            );
-          });
-        };
-
-        const finalizeNativeDataStore = (dataStore: 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);
-            }
-          }
-          fullNativeDataStore = dataStore;
-          setIfcDataStore(dataStore);
-          if (geometryCompleted) {
-            nativeLoadStage = 'complete';
-          }
-          void finalizeModel(
-            dataStore,
-            useViewerStore.getState().geometryResult,
-            getSchemaVersion(dataStore),
-            {
-              loadState: geometryCompleted ? 'complete' : 'hydrating-metadata',
-              cacheState: nativeGeometryCacheHit ? 'hit' : shouldUseNativeCache ? 'writing' : 'none',
-            },
-          );
-          updateModel(modelId, {
-            geometryLoadState: geometryCompleted ? 'complete' : 'interactive',
-            metadataLoadState: 'complete',
-            interactiveReady: true,
-          });
-          maybeBuildNativeSpatialIndex();
-        };
-
-        const hydrateNativeSpatialDataStore = (
-          nativeMetadata: NonNullable<Awaited<ReturnType<typeof restoreNativeMetadataSnapshot>>>,
-        ) => {
-          const spatialDataStore = buildIfcDataStoreFromNativeMetadata(nativeMetadata);
-          if (!spatialDataStore) {
-            return;
-          }
-          if (spatialDataStore.spatialHierarchy && spatialDataStore.spatialHierarchy.storeyHeights.size === 0 && spatialDataStore.spatialHierarchy.storeyElevations.size > 1) {
-            const calculatedHeights = calculateStoreyHeights(spatialDataStore.spatialHierarchy.storeyElevations);
-            for (const [storeyId, height] of calculatedHeights) {
-              spatialDataStore.spatialHierarchy.storeyHeights.set(storeyId, height);
-            }
-          }
-          const state = useViewerStore.getState();
-          const currentGeometryResult =
-            state.models.get(modelId)?.geometryResult ??
-            state.geometryResult;
-          setIfcDataStore(spatialDataStore);
-          void finalizeModel(
-            spatialDataStore,
-            currentGeometryResult,
-            nativeMetadata.schemaVersion,
-            {
-              loadState: geometryCompleted ? 'complete' : 'hydrating-metadata',
-              cacheState: nativeGeometryCacheHit ? 'hit' : shouldUseNativeCache ? 'writing' : 'none',
-            },
-          );
-        };
-
-        let nativeMetadataSnapshotHit = false;
-        let metadataSnapshotWritePromise: Promise<void> | null = null;
-
-        const queueNativeMetadataSnapshotWrite = (
-          dataStore: IfcDataStore,
-          sourceBuffer: ArrayBuffer,
-        ) => {
-          metadataSnapshotWritePromise = (async () => {
-            await new Promise<void>((resolve) => {
-              const channel = new MessageChannel();
-              channel.port1.onmessage = () => resolve();
-              channel.port2.postMessage(null);
-            });
-            if (typeof requestAnimationFrame === 'function') {
-              await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-            }
-            await writeNativeMetadataSnapshot(dataStore, sourceBuffer);
-          })();
-        };
-
-        const writeNativeMetadataSnapshot = async (
-          dataStore: IfcDataStore,
-          sourceBuffer: ArrayBuffer,
-        ): Promise<void> => {
-          if (!shouldUseNativeCache || !nativeCacheKey) return;
-          try {
-            const { setNativeModelSnapshot } = await import('../services/desktop-cache.js');
-            const snapshotBuffer = await buildDesktopMetadataSnapshot(dataStore, sourceBuffer);
-            await setNativeModelSnapshot(nativeCacheKey, snapshotBuffer);
-          } catch (error) {
-            console.warn('[useIfc] Failed to persist native metadata snapshot:', error);
-            void logToDesktopTerminal(
-              'warn',
-              `[useIfc] Native metadata snapshot write failed for ${fileName}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        };
-
-        const noteMetadataActivity = (activity: string) => {
-          currentMetadataActivity = activity;
-          lastMetadataActivityTime = performance.now();
-        };
-
-        const stopMetadataStallWatch = () => {
-          if (metadataStallWatchId !== null) {
-            globalThis.clearInterval(metadataStallWatchId);
-            metadataStallWatchId = null;
-          }
-        };
-
-        const startMetadataStallWatch = () => {
-          stopMetadataStallWatch();
-          noteMetadataActivity('starting');
-          metadataStallWatchId = globalThis.setInterval(() => {
-            if (loadSessionRef.current !== currentSession) {
-              stopMetadataStallWatch();
-              return;
-            }
-            const idleForMs = performance.now() - lastMetadataActivityTime;
-            if (idleForMs < 8000) return;
-            lastMetadataActivityTime = performance.now();
-            void logToDesktopTerminal(
-              'warn',
-              `[useIfc] Metadata stall watch for ${fileName}: stage=${nativeLoadStage} idle=${idleForMs.toFixed(0)}ms phase=${currentMetadataActivity} batches=${batchCount} meshes=${lastTotalMeshes} geometryCompleted=${geometryCompleted}`
-            );
-          }, 5000);
-        };
-
-        const startNativeMetadataParsing = (): Promise<void> | null => {
-          if (metadataParsingStarted) return metadataParsingPromise;
-          metadataParsingStarted = true;
-          nativeLoadStage = 'hydrateMetadata';
-          const metadataStartTime = performance.now();
-          metadataStartMs = metadataStartTime - totalStartTime;
-          let lastMetadataProgressPhase = '';
-          let lastMetadataProgressPercent = -1;
-          startMetadataStallWatch();
-          setMetadataProgress({ phase: 'Bootstrapping metadata', percent: 5, indeterminate: hugeNativeMode });
-          updateModel(modelId, {
-            loadState: 'hydrating-metadata',
-            metadataLoadState: 'bootstrapping',
-          });
-          void logToDesktopTerminal(
-            'info',
-            `[useIfc] Native metadata parse start for ${fileName} source=${nativeMetadataSource} gate=${nativeMetadataStartGate}`
-          );
-
-          const metadataReadStartTime = performance.now();
-          let parseStartTime = 0;
-          metadataParsingPromise = (async () => {
-            if (hugeNativeMode) {
-              noteMetadataActivity('native bootstrap');
-              metadataParseStartMs = performance.now() - totalStartTime;
-              parseStartTime = performance.now();
-              if (nativeMetadataSnapshotHit) {
-                const restoredSnapshot = await restoreNativeMetadataSnapshot(nativeCacheKey);
-                if (restoredSnapshot && loadSessionRef.current === currentSession) {
-                  try {
-                    spatialReadyMs = performance.now() - totalStartTime;
-                    hydrateNativeSpatialDataStore(restoredSnapshot);
-                    updateModel(modelId, {
-                      nativeMetadata: restoredSnapshot,
-                      schemaVersion: restoredSnapshot.schemaVersion,
-                      metadataLoadState: 'spatial-ready',
-                      interactiveReady: true,
-                    });
-                    setMetadataProgress({ phase: 'Restored metadata sidecar', percent: 70 });
-                  } catch (error) {
-                    nativeMetadataSnapshotHit = false;
-                    nativeMetadataSource = 'ifc-parse';
-                    void logToDesktopTerminal(
-                      'warn',
-                      `[useIfc] Native metadata snapshot restore incompatible for ${fileName}, continuing with live bootstrap: ${error instanceof Error ? error.message : String(error)}`
-                    );
-                  }
-                }
-              }
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Awaiting native metadata bootstrap for ${fileName}`
-              );
-              const nativeMetadata = await bootstrapNativeMetadata(file.path, nativeCacheKey);
-              if (loadSessionRef.current !== currentSession) {
-                return null;
-              }
-              const spatialNodeCount = countNativeSpatialNodes(nativeMetadata.spatialTree);
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Native metadata bootstrap resolved for ${fileName}: elapsed=${(performance.now() - parseStartTime).toFixed(0)}ms hasTree=${nativeMetadata.spatialTree ? 'yes' : 'no'} spatialNodes=${spatialNodeCount}`
-              );
-              metadataReadCompleteMs = performance.now() - totalStartTime;
-              metadataReadDurationMs = metadataReadCompleteMs - metadataStartMs;
-              spatialReadyMs = performance.now() - totalStartTime;
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Applying native metadata to store for ${fileName}`
-              );
-              hydrateNativeSpatialDataStore(nativeMetadata);
-              updateModel(modelId, {
-                nativeMetadata,
-                schemaVersion: nativeMetadata.schemaVersion,
-                metadataLoadState: 'spatial-ready',
-                interactiveReady: true,
-              });
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Native metadata store update complete for ${fileName}`
-              );
-              setMetadataProgress({ phase: 'Spatial tree ready', percent: 70 });
-              if (!nativeMetadataSnapshotHit) {
-                void persistNativeMetadataSnapshot(nativeMetadata);
-              }
-              metadataCompleteMs = performance.now() - totalStartTime;
-              metadataParseDurationMs = performance.now() - parseStartTime;
-              updateModel(modelId, {
-                loadState: geometryCompleted ? 'complete' : 'hydrating-metadata',
-                metadataLoadState: 'lazy',
-              });
-              setMetadataProgress({ phase: 'Metadata ready on demand', percent: 100 });
-              return null;
-            }
-
-            if (nativeGeometryCacheHit && nativeMetadataSnapshotHit) {
-              try {
-                const { getNativeModelSnapshot } = await import('../services/desktop-cache.js');
-                const snapshotBuffer = await getNativeModelSnapshot(nativeCacheKey);
-                if (!snapshotBuffer) {
-                  throw new Error(`missing-native-metadata-snapshot:${nativeCacheKey}`);
-                }
-                metadataReadCompleteMs = performance.now() - totalStartTime;
-                metadataReadDurationMs = performance.now() - metadataReadStartTime;
-                metadataParseStartMs = performance.now() - totalStartTime;
-                parseStartTime = performance.now();
-                noteMetadataActivity('snapshot hydrate');
-                if (spatialReadyMs === null) {
-                  spatialReadyMs = performance.now() - totalStartTime;
-                }
-                setMetadataProgress({ phase: 'Restoring cached metadata', percent: 80 });
-                return restoreDesktopMetadataSnapshot(snapshotBuffer);
-              } catch (error) {
-                nativeMetadataSnapshotHit = false;
-                nativeMetadataSource = 'ifc-parse';
-                void logToDesktopTerminal(
-                  'warn',
-                  `[useIfc] Native metadata snapshot hydration failed for ${fileName}, falling back to IFC parse: ${error instanceof Error ? error.message : String(error)}`
-                );
-              }
-            }
-
-            const bytes = await readNativeFile(file.path);
-              if (loadSessionRef.current !== currentSession) {
-                return null;
-              }
-              metadataReadCompleteMs = performance.now() - totalStartTime;
-              metadataReadDurationMs = performance.now() - metadataReadStartTime;
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Native metadata file read complete for ${fileName}: ${metadataReadDurationMs.toFixed(0)}ms`
-              );
-              const copyStartTime = performance.now();
-              const metadataBuffer = toExactArrayBuffer(bytes);
-              metadataBufferCopyDurationMs = performance.now() - copyStartTime;
-              metadataParseStartMs = performance.now() - totalStartTime;
-              parseStartTime = performance.now();
-              noteMetadataActivity('parse setup');
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Native metadata buffer copy complete for ${fileName}: ${metadataBufferCopyDurationMs.toFixed(0)}ms`
-              );
-
-              const parser = new IfcParser();
-              const wasmApi = hugeNativeMode ? await getMetadataScanApi() : undefined;
-              const dataStore = await parser.parseColumnar(metadataBuffer, {
-                wasmApi,
-                yieldIntervalMs: hugeNativeMode ? 32 : undefined,
-                deferPropertyAtomIndex: hugeNativeMode,
-                disableWorkerScan: false,
-                onProgress: (progress) => {
-                  if (!hugeNativeMode) return;
-                  noteMetadataActivity(`progress:${progress.phase}:${Math.round(progress.percent)}`);
-                  const roundedPercent = Math.round(progress.percent);
-                  const shouldLog =
-                    progress.phase !== lastMetadataProgressPhase ||
-                    roundedPercent >= lastMetadataProgressPercent + 5 ||
-                    roundedPercent === 100;
-                  if (!shouldLog) return;
-                  setMetadataProgress({
-                    phase: `Metadata ${progress.phase}`,
-                    percent: roundedPercent,
-                    indeterminate: false,
-                  });
-                  lastMetadataProgressPhase = progress.phase;
-                  lastMetadataProgressPercent = roundedPercent;
-                  void logToDesktopTerminal(
-                    'info',
-                    `[useIfc] Native metadata progress for ${fileName}: ${progress.phase} ${roundedPercent}%`
-                  );
-                },
-                onSpatialReady: (partialStore) => {
-                  if (loadSessionRef.current !== currentSession) return;
-                  noteMetadataActivity('spatial ready');
-                  if (spatialReadyMs === null) {
-                    spatialReadyMs = performance.now() - totalStartTime;
-                  }
-                  setMetadataProgress({ phase: 'Spatial tree ready', percent: 70 });
-                  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);
-                  void logToDesktopTerminal(
-                    'info',
-                    `[useIfc] Native spatial tree ready for ${fileName} at ${(performance.now() - totalStartTime).toFixed(0)}ms`
-                  );
-                },
-                onDiagnostic: (message) => {
-                  noteMetadataActivity(`diag:${message}`);
-                  void logToDesktopTerminal('info', `[useIfc][diag] ${fileName}: ${message}`);
-                },
-              });
-              queueNativeMetadataSnapshotWrite(dataStore, metadataBuffer);
-              return dataStore;
-            })()
-            .then((dataStore) => {
-              stopMetadataStallWatch();
-              if (loadSessionRef.current !== currentSession || !dataStore) return;
-              metadataCompleteMs = performance.now() - totalStartTime;
-              metadataParseDurationMs = parseStartTime > 0 ? performance.now() - parseStartTime : null;
-              setMetadataProgress({ phase: 'Metadata ready', percent: 100 });
-              finalizeNativeDataStore(dataStore);
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Native metadata parse complete for ${fileName}: total=${(performance.now() - metadataStartTime).toFixed(0)}ms read=${metadataReadDurationMs?.toFixed(0) ?? 'n/a'}ms copy=${metadataBufferCopyDurationMs?.toFixed(0) ?? 'n/a'}ms parse=${metadataParseDurationMs?.toFixed(0) ?? 'n/a'}ms`
-              );
-            })
-            .catch((error) => {
-              if (loadSessionRef.current !== currentSession) return;
-              stopMetadataStallWatch();
-              metadataFailedMs = performance.now() - totalStartTime;
-              console.warn('[useIfc] Native metadata parsing failed:', error);
-              updateModel(modelId, {
-                loadState: 'error',
-                metadataLoadState: 'error',
-                loadError: error instanceof Error ? error.message : String(error),
-              });
-              setMetadataProgress({ phase: 'Metadata failed', percent: 100 });
-              void logToDesktopTerminal(
-                'warn',
-                `[useIfc] Native metadata parse failed for ${fileName}: ${error instanceof Error ? error.message : String(error)}`
-              );
-            });
-          return metadataParsingPromise;
-        };
-
-        const HUGE_NATIVE_METADATA_START_BATCH = 20;
-        let metadataStartQueued = false;
-        const queueNativeMetadataStart = (reason: string) => {
-          if (metadataParsingStarted || metadataStartQueued) return;
-          metadataStartQueued = true;
-          void logToDesktopTerminal('info', `[useIfc] Queueing metadata hydration for ${fileName} after ${reason}`);
-          metadataStartQueued = false;
-          if (loadSessionRef.current !== currentSession || metadataParsingStarted) return;
-          void logToDesktopTerminal('info', `[useIfc] Starting metadata hydration after ${reason} for ${fileName}`);
-          startNativeMetadataParsing();
-        };
-
-        let nativeGeometryCacheHit = false;
-        if (shouldUseNativeCache) {
-          const { hasNativeGeometryCache, hasNativeModelSnapshot } = await import('../services/desktop-cache.js');
-          setProgress({ phase: 'Checking cache', percent: 5 });
-          setGeometryProgress({ phase: 'Checking geometry cache', percent: 5 });
-          nativeGeometryCacheHit = await hasNativeGeometryCache(nativeCacheKey);
-          nativeMetadataSnapshotHit = nativeGeometryCacheHit
-            ? await hasNativeModelSnapshot(nativeCacheKey)
-            : false;
-          nativeMetadataSource = nativeMetadataSnapshotHit ? 'snapshot' : 'ifc-parse';
-          nativeMetadataStartGate = 'immediate';
-          updateModel(modelId, { cacheState: nativeGeometryCacheHit ? 'hit' : 'miss' });
-          void logToDesktopTerminal(
-            'info',
-            nativeGeometryCacheHit
-              ? `[useIfc] Native geometry cache hit for ${fileName}`
-              : `[useIfc] Native geometry cache miss for ${fileName}`
-          );
-          if (nativeMetadataStartGate === 'immediate') {
-            startNativeMetadataParsing();
-          } else {
-            void logToDesktopTerminal(
-              'info',
-              nativeMetadataStartGate === 'afterInteractiveGeometry'
-                ? `[useIfc] Deferring metadata hydration until geometry batch ${HUGE_NATIVE_METADATA_START_BATCH} for ${fileName}`
-                : `[useIfc] Deferring metadata hydration until geometry complete for ${fileName}`
-            );
-          }
-        }
-
-        if (!shouldUseNativeCache) {
-          if (nativeMetadataStartGate === 'immediate') {
-            startNativeMetadataParsing();
-          } else {
-            void logToDesktopTerminal(
-              'info',
-              `[useIfc] Deferring metadata hydration until geometry complete for ${fileName}`
-            );
-          }
-        }
-        await geometryProcessor.init();
-        void logToDesktopTerminal('info', `[useIfc] GeometryProcessor.init complete for ${fileName}`);
-
-        const nativeStream = nativeGeometryCacheHit
-          ? geometryProcessor.processStreamingCache(nativeCacheKey)
-          : geometryProcessor.processStreamingPath(
-              file.path,
-              file.size,
-              shouldUseNativeCache ? nativeCacheKey : undefined,
-            );
-
-        for await (const event of nativeStream) {
-          const eventReceived = performance.now();
-
-          switch (event.type) {
-            case 'start':
-              estimatedTotal = event.totalEstimate;
-              void logToDesktopTerminal('info', `[useIfc] Native stream start for ${fileName}: estimate=${Math.round(estimatedTotal)}`);
-              break;
-            case 'model-open':
-              nativeLoadStage = 'streamGeometry';
-              setProgress({ phase: 'Processing geometry (native precompute)', percent: 50, indeterminate: true });
-              setGeometryProgress({ phase: 'Opening native geometry stream', percent: 10, indeterminate: true });
-              modelOpenMs = performance.now() - totalStartTime;
-              console.log(`[useIfc] Native model opened at ${modelOpenMs.toFixed(0)}ms`);
-              void logToDesktopTerminal('info', `[useIfc] Native model opened for ${fileName} at ${modelOpenMs.toFixed(0)}ms`);
-              break;
-            case 'batch': {
-              batchCount++;
-
-              if (batchCount === 1) {
-                firstGeometryTime = performance.now() - totalStartTime;
-                jsFirstChunkReceivedMs = event.nativeTelemetry?.jsReceivedTimeMs ?? firstGeometryTime;
-                firstNativeBatchTelemetry = event.nativeTelemetry ?? null;
-                updateModel(modelId, {
-                  geometryLoadState: 'interactive',
-                  interactiveReady: true,
-                });
-                console.log(`[useIfc] Native batch #1: ${event.meshes.length} meshes, wait: ${firstGeometryTime.toFixed(0)}ms`);
-                void logToDesktopTerminal('info', `[useIfc] Native first batch for ${fileName}: meshes=${event.meshes.length}, wait=${firstGeometryTime.toFixed(0)}ms`);
-                if (event.nativeTelemetry) {
-                  const transferLagMs = (event.nativeTelemetry.jsReceivedTimeMs ?? 0) - event.nativeTelemetry.emittedTimeMs;
-                  void logToDesktopTerminal(
-                    'info',
-                    `[useIfc] Native first batch transport for ${fileName}: rustReady=${event.nativeTelemetry.chunkReadyTimeMs.toFixed(0)}ms pack=${event.nativeTelemetry.packTimeMs.toFixed(0)}ms emit=${event.nativeTelemetry.emitTimeMs.toFixed(0)}ms rustEmitted=${event.nativeTelemetry.emittedTimeMs.toFixed(0)}ms jsReceived=${(event.nativeTelemetry.jsReceivedTimeMs ?? 0).toFixed(0)}ms transfer=${transferLagMs.toFixed(0)}ms`
-                  );
-                }
-              } else if (batchCount % 20 === 0) {
-                void logToDesktopTerminal('info', `[useIfc] Native batch milestone for ${fileName}: batch=${batchCount}, totalMeshes=${event.totalSoFar}`);
-              }
-
-              for (let i = 0; i < event.meshes.length; i++) {
-                const mesh = event.meshes[i];
-                if (retainAllMeshes) {
-                  allMeshes.push(mesh);
-                }
-                totalVertices += mesh.positions.length / 3;
-                totalTriangles += mesh.indices.length / 3;
-              }
-              finalCoordinateInfo = event.coordinateInfo ?? null;
-              totalMeshes = event.totalSoFar;
-              lastTotalMeshes = event.totalSoFar;
-
-              for (let i = 0; i < event.meshes.length; i++) pendingMeshes.push(event.meshes[i]);
-
-              if (
-                nativeMetadataStartGate === 'afterInteractiveGeometry' &&
-                !metadataParsingStarted &&
-                batchCount >= HUGE_NATIVE_METADATA_START_BATCH &&
-                firstAppendGeometryBatchMs !== null
-              ) {
-                queueNativeMetadataStart(`geometry batch ${batchCount}`);
-              }
-
-              const timeSinceLastRender = eventReceived - lastRenderTime;
-              const allowTimeBasedFlush = !hugeNativeMode || ENABLE_HUGE_TIME_FLUSH;
-              const shouldRender =
-                batchCount === 1 ||
-                pendingMeshes.length >= NATIVE_PENDING_MESH_THRESHOLD ||
-                (allowTimeBasedFlush && timeSinceLastRender >= RENDER_INTERVAL_MS);
-
-              if (shouldRender && pendingMeshes.length > 0) {
-                await flushPendingNativeMeshes(event.coordinateInfo, totalMeshes);
-                lastRenderTime = eventReceived;
-
-                const progressPercent = 50 + Math.min(45, (totalMeshes / Math.max(estimatedTotal / 10, totalMeshes || 1)) * 45);
-                setProgress({
-                  phase: `Rendering geometry (${totalMeshes} meshes)`,
-                  percent: progressPercent,
-                  indeterminate: false,
-                });
-                setGeometryProgress({
-                  phase: `Rendering geometry (${totalMeshes} meshes)`,
-                  percent: Math.min(99, progressPercent),
-                  indeterminate: false,
-                });
-              }
-              break;
-            }
-            case 'complete':
-              nativeLoadStage = 'finalizeGeometry';
-              geometryCompleted = true;
-              streamCompleteMs = performance.now() - totalStartTime;
-              if (pendingMeshes.length > 0) {
-                await flushPendingNativeMeshes(event.coordinateInfo, lastTotalMeshes);
-              }
-
-              finalCoordinateInfo = event.coordinateInfo;
-              updateCoordinateInfo(finalCoordinateInfo);
-              maybeBuildNativeSpatialIndex();
-              if (nativeMetadataStartGate === 'afterGeometryComplete' && !metadataParsingStarted) {
-                queueNativeMetadataStart('geometry complete');
-              }
-              setProgress({
-                phase: hugeNativeMode ? 'Geometry ready, hydrating metadata' : 'Complete',
-                percent: 100,
-              });
-              setGeometryProgress({
-                phase: 'Geometry interactive',
-                percent: 100,
-              });
-              setMetadataProgress(
-                hugeNativeMode
-                  ? { phase: 'Preparing metadata', percent: nativeMetadataStartGate === 'afterGeometryComplete' ? 5 : 0, indeterminate: false }
-                  : { phase: 'Metadata complete', percent: 100 }
-              );
-              updateModel(modelId, {
-                loadState: hugeNativeMode ? 'hydrating-metadata' : 'complete',
-                geometryLoadState: 'complete',
-                metadataLoadState: hugeNativeMode ? 'bootstrapping' : 'complete',
-                interactiveReady: true,
-                cacheState: nativeGeometryCacheHit ? 'hit' : shouldUseNativeCache ? 'writing' : 'none',
-              });
-              console.log(`[useIfc] Native geometry streaming complete: ${batchCount} batches, ${lastTotalMeshes} meshes`);
-              void logToDesktopTerminal(
-                'info',
-                `[useIfc] Native stream complete for ${fileName}: stage=${nativeLoadStage} batches=${batchCount}, meshes=${lastTotalMeshes}`
-              );
-              await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-              if (loadSessionRef.current === currentSession) {
-                setGeometryStreamingActive(false);
-              }
-              break;
-          }
-        }
-
-        nativeStats = geometryProcessor.getLastNativeStats();
-
-        const totalElapsedMs = performance.now() - totalStartTime;
-        console.log(
-          `[useIfc] ✓ ${fileName} (${fileSizeMB.toFixed(1)}MB) → ` +
-          `${lastTotalMeshes} meshes, ${(totalVertices / 1000).toFixed(0)}k vertices | ` +
-          `first: ${firstGeometryTime.toFixed(0)}ms, total: ${totalElapsedMs.toFixed(0)}ms`
-        );
-        if (nativeStats) {
-          void logToDesktopTerminal(
-            'info',
-            `[useIfc] Native timings for ${fileName}: scan=${nativeStats.entityScanTimeMs ?? 0}ms lookup=${nativeStats.lookupTimeMs ?? 0}ms preprocess=${nativeStats.preprocessTimeMs ?? 0}ms parse=${nativeStats.parseTimeMs ?? 0}ms geometry=${nativeStats.geometryTimeMs ?? 0}ms total=${nativeStats.totalTimeMs ?? 0}ms`
-          );
-        }
-        if (!metadataParsingStarted) {
-          console.warn('[useIfc] Native large-file mode completed without metadata parsing');
-          void logToDesktopTerminal('warn', `[useIfc] Native large-file mode completed without metadata parsing for ${fileName}`);
-        }
-        if (harnessRequest?.waitForMetadataCompletion) {
-          if (!metadataParsingStarted) {
-            startNativeMetadataParsing();
-          }
-          if (metadataParsingPromise) {
-            await metadataParsingPromise;
-          }
-          if (metadataSnapshotWritePromise) {
-            await metadataSnapshotWritePromise;
-          }
-        }
-        if (firstVisibleGeometryMs === null && firstAppendGeometryBatchMs !== null) {
-          await new Promise<void>((resolve) => {
-            const fallbackTimer = globalThis.setTimeout(() => {
-              if (firstVisibleGeometryMs === null && loadSessionRef.current === currentSession) {
-                firstVisibleGeometryMs = firstAppendGeometryBatchMs;
-              }
-              resolve();
-            }, 250);
-            requestAnimationFrame(() => {
-              globalThis.clearTimeout(fallbackTimer);
-              if (firstVisibleGeometryMs === null && loadSessionRef.current === currentSession) {
-                firstVisibleGeometryMs = performance.now() - totalStartTime;
-              }
-              resolve();
-            });
-          });
-        }
-        if (hugeNativeMode) {
-          setLoading(false);
-        }
-        const telemetryElapsedMs = performance.now() - totalStartTime;
-        await finalizeActiveHarnessRun({
-          schemaVersion: 1,
-          source: 'desktop-native',
-          mode: harnessRequest ? 'startup-harness' : 'manual',
-          success: true,
-          runLabel: harnessRequest?.runLabel,
-          cache: {
-            key: nativeCacheKey,
-            hit: nativeGeometryCacheHit,
-            manifestMeshCount: null,
-            manifestShardCount: null,
-          },
-          file: {
-            path: file.path,
-            name: file.name,
-            sizeBytes: file.size,
-            sizeMB: fileSizeMB,
-          },
-          timings: {
-            modelOpenMs,
-            firstBatchWaitMs: firstGeometryTime || null,
-            firstAppendGeometryBatchMs,
-            firstVisibleGeometryMs,
-            streamCompleteMs,
-            totalWallClockMs: telemetryElapsedMs,
-            metadataStartMs,
-            metadataReadCompleteMs,
-            metadataParseStartMs,
-            spatialReadyMs,
-            metadataCompleteMs,
-            metadataFailedMs,
-            metadataReadDurationMs,
-            metadataBufferCopyDurationMs,
-            metadataParseDurationMs,
-          },
-          batches: {
-            estimatedTotal,
-            totalBatches: batchCount,
-            totalMeshes: lastTotalMeshes,
-            firstBatchMeshes: firstNativeBatchTelemetry?.meshCount ?? null,
-            firstPayloadKind: firstNativeBatchTelemetry?.payloadKind ?? null,
-          },
-          nativeStats: nativeStats
-            ? {
-                parseTimeMs: nativeStats.parseTimeMs ?? null,
-                entityScanTimeMs: nativeStats.entityScanTimeMs ?? null,
-                lookupTimeMs: nativeStats.lookupTimeMs ?? null,
-                preprocessTimeMs: nativeStats.preprocessTimeMs ?? null,
-                geometryTimeMs: nativeStats.geometryTimeMs ?? null,
-                totalTimeMs: nativeStats.totalTimeMs ?? null,
-                firstChunkReadyTimeMs: nativeStats.firstChunkReadyTimeMs ?? null,
-                firstChunkPackTimeMs: nativeStats.firstChunkPackTimeMs ?? null,
-                firstChunkEmittedTimeMs: nativeStats.firstChunkEmittedTimeMs ?? null,
-                firstChunkEmitTimeMs: nativeStats.firstChunkEmitTimeMs ?? null,
-              }
-            : null,
-          metadata: {
-            started: metadataParsingStarted,
-            metadataStartMs,
-            metadataReadCompleteMs,
-            metadataParseStartMs,
-            spatialReadyMs,
-            metadataCompleteMs,
-            metadataFailedMs,
-            metadataReadDurationMs,
-            metadataBufferCopyDurationMs,
-            metadataParseDurationMs,
-          },
-          firstBatchTelemetry: firstNativeBatchTelemetry
-            ? {
-                batchSequence: firstNativeBatchTelemetry.batchSequence,
-                payloadKind: firstNativeBatchTelemetry.payloadKind,
-                meshCount: firstNativeBatchTelemetry.meshCount,
-                positionsLen: firstNativeBatchTelemetry.positionsLen,
-                normalsLen: firstNativeBatchTelemetry.normalsLen,
-                indicesLen: firstNativeBatchTelemetry.indicesLen,
-                rustChunkReadyMs: firstNativeBatchTelemetry.chunkReadyTimeMs,
-                rustPackMs: firstNativeBatchTelemetry.packTimeMs,
-                rustEmittedMs: firstNativeBatchTelemetry.emittedTimeMs,
-                rustEmitMs: firstNativeBatchTelemetry.emitTimeMs,
-                jsReceivedMs: jsFirstChunkReceivedMs,
-                transportToJsMs:
-                  jsFirstChunkReceivedMs !== null
-                    ? jsFirstChunkReceivedMs - firstNativeBatchTelemetry.emittedTimeMs
-                    : null,
-                appendAfterReceiveMs:
-                  jsFirstChunkReceivedMs !== null && firstAppendGeometryBatchMs !== null
-                    ? firstAppendGeometryBatchMs - jsFirstChunkReceivedMs
-                    : null,
-                visibleAfterAppendMs:
-                  firstVisibleGeometryMs !== null && firstAppendGeometryBatchMs !== null
-                    ? firstVisibleGeometryMs - firstAppendGeometryBatchMs
-                    : null,
-              }
-            : null,
-        });
-        if (!hugeNativeMode) {
-          setLoading(false);
-        }
-        return;
-      }
 
       // Read file from disk. The browser path streams files ≥
       // STREAM_SAB_THRESHOLD directly into a SharedArrayBuffer, which avoids
       // a doubled-peak ArrayBuffer + SAB allocation when the geometry
-      // pipeline copies into its own SAB. The native path still reads via
-      // Tauri's Rust IPC because it bounds memory differently. (#600)
+      // pipeline copies into its own SAB. (#600)
       const fileReadStart = performance.now();
-      let acquired: AcquiredBuffer;
-      if (isNativeFileHandle(file)) {
-        const nativeBytes = await readNativeFile(file.path);
-        const nativeBuffer = toExactArrayBuffer(nativeBytes);
-        acquired = {
-          buffer: nativeBuffer,
-          view: new Uint8Array(nativeBuffer),
-          isShared: false,
-        };
-      } else {
-        acquired = await acquireFileBuffer(file as File);
-      }
+      const acquired: AcquiredBuffer = await acquireFileBuffer(file);
       // `buffer` retains its previous semantics (ArrayBuffer-shaped) for
       // every downstream consumer. When `acquired.isShared` is true the
       // backing store is a SharedArrayBuffer; downstream code only ever
@@ -1403,7 +401,7 @@ export function useIfcLoader() {
         }
         setProgress({ phase: `Streaming ${format.toUpperCase()}`, percent: 5 });
         setGeometryStreamingActive(false);
-        const blob = isNativeFileHandle(file) ? new Blob([buffer]) : (file as File);
+        const blob = file;
         const incCount = useViewerStore.getState().incrementPointCloudAssetCount;
         const ingest = ingestPointCloud({
           format,
@@ -1594,7 +592,7 @@ export function useIfcLoader() {
       // Only for IFC4 STEP files (server doesn't support IFCX). Native
       // file handles (Tauri) don't have an HTTP-uploadable body, so skip
       // the server path and fall through to the WASM loader.
-      if (target.kind === 'primary' && format === 'ifc' && USE_SERVER && SERVER_URL && SERVER_URL !== '' && !isNativeFileHandle(file)) {
+      if (target.kind === 'primary' && 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, () => loadSessionRef.current !== currentSession);
         if (serverSuccess) {
@@ -1616,11 +614,6 @@ export function useIfcLoader() {
         setGeometryStreamingActive(true);
       }
 
-      const shouldUseDesktopStableWasmGeometry =
-        isNativeFileHandle(file)
-        && fileName.toLowerCase().endsWith('.ifc')
-        && file.size < HUGE_NATIVE_FILE_THRESHOLD;
-
       // Initialize geometry processor first (WASM init is fast if already loaded)
       const mergeLayersAtLoad = useViewerStore.getState().mergeLayers;
       const geometryProcessor = new GeometryProcessor({
@@ -1645,7 +638,7 @@ export function useIfcLoader() {
       // available, AND TextDecoder accepts SAB-backed views (Firefox fails
       // the third check; we skip the worker path entirely there so the
       // SAB allocation isn't wasted).
-      const useParserWorker = WorkerParser.isSupported() && !isNativeFileHandle(file);
+      const useParserWorker = WorkerParser.isSupported();
       let sharedSource: SharedArrayBuffer | null = null;
       if (useParserWorker) {
         if (acquired.isShared && acquired.buffer instanceof SharedArrayBuffer) {
@@ -1715,7 +708,7 @@ export function useIfcLoader() {
         // Same `wasmApi` heuristic as before — desktop loads cannot share
         // the geometry processor's WASM instance with the parser without
         // risking corruption.
-        const parserWasmApi = isNativeFileHandle(file) ? undefined : geometryProcessor.getApi();
+        const parserWasmApi = geometryProcessor.getApi();
         return new IfcParser().parseColumnar(buffer, {
           wasmApi: parserWasmApi ?? undefined,
           onSpatialReady: onPartialDataStore,
@@ -1736,7 +729,6 @@ export function useIfcLoader() {
       const ADAPTIVE_SYNC_THRESHOLD_MB = 2;
       const geometryWillEmitEntityIndex =
         useParserWorker
-        && !shouldUseDesktopStableWasmGeometry
         && fileSizeMB >= ADAPTIVE_SYNC_THRESHOLD_MB;
 
       const startDataModelParsing = () => {
@@ -1852,9 +844,7 @@ export function useIfcLoader() {
         // When the parser worker is in use, hand the geometry workers the
         // same SAB so we don't pay the file-bytes copy twice.
         const geometryView = sharedSource ? new Uint8Array(sharedSource) : new Uint8Array(buffer);
-        const geometryEvents = shouldUseDesktopStableWasmGeometry
-          ? geometryProcessor.processStreaming(geometryView, undefined, dynamicBatchConfig)
-          : geometryProcessor.processAdaptive(geometryView, {
+        const geometryEvents = geometryProcessor.processAdaptive(geometryView, {
               sizeThreshold: 2 * 1024 * 1024, // 2MB threshold
               batchSize: dynamicBatchConfig, // Dynamic batches: small first, then large
               existingSab: sharedSource ?? undefined,
@@ -1884,7 +874,7 @@ export function useIfcLoader() {
 
         while (true) {
           const watchdogMs = getGeometryStreamWatchdogMs(
-            shouldUseDesktopStableWasmGeometry,
+            false,
             batchCount,
             fileSizeMB,
           );
@@ -2191,37 +1181,6 @@ export function useIfcLoader() {
         loadState: 'error',
         loadError: err instanceof Error ? err.message : String(err),
       });
-      if (isNativeFileHandle(file)) {
-        const harnessRequest = getActiveHarnessRequest();
-        await finalizeActiveHarnessRun({
-          schemaVersion: 1,
-          source: 'desktop-native',
-          mode: harnessRequest ? 'startup-harness' : 'manual',
-          success: false,
-          runLabel: harnessRequest?.runLabel,
-          cache: {
-            key: computeNativeCacheKey(file),
-            hit: null,
-            manifestMeshCount: null,
-            manifestShardCount: null,
-          },
-          file: {
-            path: file.path,
-            name: file.name,
-            sizeBytes: file.size,
-            sizeMB: file.size / (1024 * 1024),
-          },
-          timings: {
-            totalWallClockMs: performance.now() - totalStartTime,
-          },
-          batches: {},
-          nativeStats: null,
-          metadata: null,
-          firstBatchTelemetry: null,
-          error: err instanceof Error ? err.message : String(err),
-        });
-      }
-      void logToDesktopTerminal('error', `[useIfc] Load failed: ${err instanceof Error ? err.message : String(err)}`);
       setError(err instanceof Error ? err.message : 'Unknown error');
       setLoading(false);
       setGeometryStreamingActive(false);