@ifc-lite/viewer 1.25.0 → 1.25.2

package/src/hooks/ingest/viewerModelIngest.ts

@@ -3,10 +3,12 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 import { IfcParser, parseIfcx, type IfcDataStore, type PointCloudExtraction } from '@ifc-lite/parser';
+import { WorkerParser } from '@ifc-lite/parser/browser';
 import { GeometryProcessor, GeometryQuality, type CoordinateInfo, type DynamicBatchConfig, type GeometryResult, type MeshData, type PointCloudAsset } 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';
+import { resolveDataStoreOrAbort } from './resolveDataStoreOrAbort.js';
 
 type RgbaColor = [number, number, number, number];
 
@@ -217,6 +219,18 @@ export async function parseStepBufferViewerModel(options: StepBufferIngestOption
 
   const parser = new IfcParser();
   const wasmApi = geometryProcessor.getApi();
+  const canShareSource = WorkerParser.isSupported();
+  const sharedSource = canShareSource ? new SharedArrayBuffer(options.buffer.byteLength) : null;
+  if (sharedSource) {
+    new Uint8Array(sharedSource).set(new Uint8Array(options.buffer));
+  }
+  const geometryWillEmitEntityIndex =
+    sharedSource !== null
+    && options.fileSizeMB >= 2
+    && typeof Worker !== 'undefined'
+    && typeof navigator !== 'undefined'
+    && (navigator.hardwareConcurrency ?? 1) > 1;
+  let workerParser: WorkerParser | null = null;
   const allMeshes: MeshData[] = [];
   const cumulativeColorUpdates = new Map<number, RgbaColor>();
   let finalCoordinateInfo: CoordinateInfo | null = null;
@@ -224,20 +238,40 @@ export async function parseStepBufferViewerModel(options: StepBufferIngestOption
   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));
-    },
-  });
+  const handleSpatialReady = (partialStore: IfcDataStore) => {
+    if (options.shouldAbort?.()) {
+      return;
+    }
+    options.onSpatialReady?.(normalizeDataStoreStoreys(partialStore));
+  };
+  const dataStorePromise = sharedSource
+    ? (() => {
+        workerParser = new WorkerParser();
+        return workerParser.parseColumnar(sharedSource, {
+          waitForEntityIndex: geometryWillEmitEntityIndex,
+          onSpatialReady: handleSpatialReady,
+        }).catch((error) => {
+          console.warn('[viewerModelIngest] Parser worker failed, falling back to main-thread parse:', error);
+          return parser.parseColumnar(options.buffer, {
+            wasmApi: wasmApi ?? undefined,
+            onSpatialReady: handleSpatialReady,
+          });
+        });
+      })()
+    : parser.parseColumnar(options.buffer, {
+        wasmApi: wasmApi ?? undefined,
+        onSpatialReady: handleSpatialReady,
+      });
 
-  for await (const event of geometryProcessor.processAdaptive(new Uint8Array(options.buffer), {
+  const geometryView = sharedSource ? new Uint8Array(sharedSource) : new Uint8Array(options.buffer);
+  for await (const event of geometryProcessor.processAdaptive(geometryView, {
     sizeThreshold: 2 * 1024 * 1024,
     batchSize: options.getDynamicBatchSize(options.fileSizeMB),
     sharedRtcOffset: options.sharedRtcOffset,
+    existingSab: sharedSource ?? undefined,
+    onEntityIndex: (ids, starts, lengths) => {
+      workerParser?.setEntityIndex(ids, starts, lengths);
+    },
   })) {
     if (options.shouldAbort?.()) {
       break;
@@ -282,7 +316,17 @@ export async function parseStepBufferViewerModel(options: StepBufferIngestOption
     }
   }
 
-  const dataStore = normalizeDataStoreStoreys(await dataStorePromise);
+  // If the load was cancelled, don't await dataStorePromise: a worker parse
+  // started with waitForEntityIndex blocks until the geometry pre-pass hands
+  // over the entity index, which never happens once the geometry loop has been
+  // aborted above. resolveDataStoreOrAbort terminates the worker and throws an
+  // AbortError instead of hanging here.
+  const dataStore = normalizeDataStoreStoreys(
+    await resolveDataStoreOrAbort(dataStorePromise, {
+      aborted: options.shouldAbort?.() ?? false,
+      terminate: () => workerParser?.terminate(),
+    }),
+  );
   if (!finalCoordinateInfo) {
     finalCoordinateInfo = createCoordinateInfo(calculateMeshBounds(allMeshes).bounds);
   }

package/src/hooks/useBCF.ts

@@ -13,13 +13,15 @@
 
 import { useCallback, useRef } from 'react';
 import { useViewerStore } from '@/store';
-import type { BCFViewpoint } from '@ifc-lite/bcf';
+import type { BCFTopic, BCFViewpoint } from '@ifc-lite/bcf';
 import {
   createViewpoint,
   extractViewpointState,
+  computeMarkerPositions,
   type ViewerCameraState,
   type ViewerSectionPlane,
   type ViewerBounds,
+  type OverlayBBox,
 } from '@ifc-lite/bcf';
 import type { Renderer } from '@ifc-lite/renderer';
 import {
@@ -52,6 +54,10 @@ interface UseBCFResult {
   createViewpointFromState: (options?: CreateViewpointOptions) => Promise<BCFViewpoint | null>;
   /** Apply a viewpoint to the viewer */
   applyViewpoint: (viewpoint: BCFViewpoint, animate?: boolean) => void;
+  /** Animate the camera to a BCF topic's 3D location (without changing selection/visibility) */
+  zoomToTopic: (topic: BCFTopic) => void;
+  /** Whether a topic has enough data to zoom to */
+  canZoomToTopic: (topic: BCFTopic) => boolean;
   /** Capture a snapshot from the canvas */
   captureSnapshot: () => Promise<string | null>;
   /** Set the canvas ref for snapshot capture */
@@ -96,6 +102,21 @@ export function clearGlobalRefs(): void {
   globalRendererRef = null;
 }
 
+/** Apply extracted BCF camera state without touching selection, visibility, or section plane. */
+function applyCameraState(
+  renderer: Renderer,
+  camera: NonNullable<ReturnType<typeof extractViewpointState>['camera']>,
+  animate: boolean,
+): void {
+  const rendererCamera = renderer.getCamera();
+  if (animate) {
+    rendererCamera.animateTo(camera.position, camera.target, 300);
+  } else {
+    rendererCamera.setPosition(camera.position.x, camera.position.y, camera.position.z);
+    rendererCamera.setTarget(camera.target.x, camera.target.y, camera.target.z);
+  }
+}
+
 // ============================================================================
 // Hook
 // ============================================================================
@@ -351,6 +372,28 @@ export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
     ]
   );
 
+  /** Restore only the viewpoint camera (used by zoom-to-topic fallback). */
+  const applyViewpointCamera = useCallback(
+    (viewpoint: BCFViewpoint, animate = true) => {
+      const renderer = getRenderer();
+      if (!renderer) {
+        console.warn('[useBCF] Cannot apply viewpoint camera: no renderer');
+        return;
+      }
+
+      const bounds = getBounds() ?? undefined;
+      const state = extractViewpointState(
+        viewpoint,
+        bounds,
+        renderer.getCamera().getDistance(),
+      );
+      if (state.camera) {
+        applyCameraState(renderer, state.camera, animate);
+      }
+    },
+    [getRenderer, getBounds],
+  );
+
   /**
    * Apply a viewpoint to the viewer
    */
@@ -372,22 +415,8 @@ export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
       );
       const { camera, sectionPlane: viewpointSectionPlane } = state;
 
-      // Apply camera
       if (camera) {
-        const rendererCamera = renderer.getCamera();
-
-        if (animate) {
-          // Animate to new position
-          rendererCamera.animateTo(
-            camera.position,
-            camera.target,
-            300 // 300ms animation
-          );
-        } else {
-          // Set immediately
-          rendererCamera.setPosition(camera.position.x, camera.position.y, camera.position.z);
-          rendererCamera.setTarget(camera.target.x, camera.target.y, camera.target.z);
-        }
+        applyCameraState(renderer, camera, animate);
       }
 
       // Apply section plane
@@ -482,9 +511,62 @@ export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
     ]
   );
 
+  const canZoomToTopic = useCallback((topic: BCFTopic): boolean => {
+    return topic.viewpoints.length > 0;
+  }, []);
+
+  const zoomToTopic = useCallback(
+    (topic: BCFTopic) => {
+      const renderer = getRenderer();
+      if (!renderer || topic.viewpoints.length === 0) return;
+
+      const boundsLookup = (ifcGuid: string): OverlayBBox | null => {
+        const result = globalIdToExpressId(ifcGuid);
+        if (!result) return null;
+        return renderer.getScene().getEntityBoundingBox(result.expressId);
+      };
+
+      const markers = computeMarkerPositions([topic], boundsLookup, {
+        targetDistance: renderer.getCamera().getDistance(),
+      });
+
+      if (markers.length > 0) {
+        const marker = markers[0];
+
+        if (marker.positionSource === 'component') {
+          for (let i = topic.viewpoints.length - 1; i >= 0; i--) {
+            const vp = topic.viewpoints[i];
+            const guids = [
+              ...(vp.components?.selection ?? []),
+              ...(vp.components?.visibility?.exceptions ?? []),
+            ];
+            for (const comp of guids) {
+              if (!comp.ifcGuid) continue;
+              const bbox = boundsLookup(comp.ifcGuid);
+              if (bbox) {
+                void renderer.getCamera().frameBounds(bbox.min, bbox.max);
+                return;
+              }
+            }
+          }
+        }
+
+        const point = marker.connectorAnchor ?? marker.position;
+        void renderer.getCamera().framePoint(point);
+        return;
+      }
+
+      // Fallback: camera from latest viewpoint only — preserve selection/visibility
+      applyViewpointCamera(topic.viewpoints[topic.viewpoints.length - 1], true);
+    },
+    [applyViewpointCamera, getRenderer, globalIdToExpressId],
+  );
+
   return {
     createViewpointFromState,
     applyViewpoint,
+    zoomToTopic,
+    canZoomToTopic,
     captureSnapshot,
     setCanvasRef,
     setRendererRef,

package/src/hooks/useDrawingGeneration.ts

@@ -32,6 +32,14 @@ export const AXIS_MAP: Record<'down' | 'front' | 'side', 'x' | 'y' | 'z'> = {
   side: 'x',
 };
 
+// Depth of the slab IN FRONT of the section plane (in shifted-world
+// metres) within which IFC annotation/grid primitives are kept. Beyond
+// the slab they're culled — matches a typical plan-view "view depth"
+// where dimensions for the next storey shouldn't bleed through. The
+// shifted-bounds coordinate system the centroids and `position` both
+// live in is already in metres (WASM applies `unit_scale` upstream).
+export const ANNOTATION_VIEW_DEPTH = 1.2;
+
 interface UseDrawingGenerationParams {
   geometryResult: GeometryResult | null | undefined;
   ifcDataStore: { source: Uint8Array } | null;
@@ -92,10 +100,28 @@ export function useDrawingGeneration({
   // Track if this is a regeneration (vs initial generation)
   const isRegeneratingRef = useRef(false);
 
+  // Symbolic lines carry the parent primitive's world-space centroid so the
+  // 2D Section filter below can cull them against the active cut plane —
+  // cardinal axis OR a face-picked custom plane. The drawing-2d package's
+  // DrawingLine has no per-line position slot; attaching the centroid as
+  // extra fields keeps the change local since the canvas ignores anything
+  // beyond DrawingLine's declared fields.
+  //
+  // Coordinate space matches the section cutter's input (shifted bounds):
+  // - worldX: read from the polyline's 2D x (already RTC-shifted by WASM)
+  // - worldZ: -(polyline 2D y) — WASM negates Z into the 2D y axis to
+  //   match section-cut output handedness, so flip back here
+  // - worldY: from the WASM `worldY` accessor (vertical elevation)
+  type SymbolicDrawingLine = DrawingLine & {
+    worldX?: number;
+    worldY?: number;
+    worldZ?: number;
+  };
+
   // Cache for symbolic representations - these don't change with section position
   // Only re-parse when model or display options change
   const symbolicCacheRef = useRef<{
-    lines: DrawingLine[];
+    lines: SymbolicDrawingLine[];
     entities: Set<number>;
     sourceId: string | null;
     useSymbolic: boolean;
@@ -120,7 +146,7 @@ export function useDrawingGeneration({
 
     // Parse symbolic representations if enabled (for hybrid mode)
     // OPTIMIZATION: Cache symbolic data - it doesn't change with section position
-    let symbolicLines: DrawingLine[] = [];
+    let symbolicLines: SymbolicDrawingLine[] = [];
     let entitiesWithSymbols = new Set<number>();
 
     // For multi-model: create cache key from model count and visible model IDs
@@ -167,6 +193,26 @@ export function useDrawingGeneration({
                 entitiesWithSymbols.add(poly.expressId);
                 const points = poly.points;
                 const pointCount = poly.pointCount;
+                // WASM exposes `worldY` on every symbolic primitive — the
+                // elevation of its parent placement (Z-up IFC, world-Y here).
+                // The .d.ts shipped with the @ifc-lite/wasm package lags
+                // behind the Rust source; read defensively so a stale build
+                // returns undefined instead of throwing.
+                const polyWorldY = (poly as unknown as { worldY?: number }).worldY;
+                // Centroid in shifted world coords — derived from the 2D
+                // points the WASM extractor already emits in section-cut
+                // space. point.x = world X (RTC-shifted); point.y =
+                // -world Z (negated to match cut-output handedness), so
+                // flip the sign back to recover world Z. Computed once
+                // per source polyline and shared across its segments.
+                let sumX = 0;
+                let sumY = 0;
+                for (let p = 0; p < pointCount; p++) {
+                  sumX += points[p * 2];
+                  sumY += points[p * 2 + 1];
+                }
+                const polyWorldX = pointCount > 0 ? sumX / pointCount : undefined;
+                const polyWorldZ = pointCount > 0 ? -sumY / pointCount : undefined;
 
                 for (let j = 0; j < pointCount - 1; j++) {
                   symbolicLines.push({
@@ -180,6 +226,9 @@ export function useDrawingGeneration({
                     ifcType: poly.ifcType,
                     modelIndex: symbolicModelIndex,
                     depth: 0,
+                    worldX: polyWorldX,
+                    worldY: polyWorldY,
+                    worldZ: polyWorldZ,
                   });
                 }
 
@@ -195,6 +244,9 @@ export function useDrawingGeneration({
                     ifcType: poly.ifcType,
                     modelIndex: symbolicModelIndex,
                     depth: 0,
+                    worldX: polyWorldX,
+                    worldY: polyWorldY,
+                    worldZ: polyWorldZ,
                   });
                 }
               }
@@ -206,6 +258,12 @@ export function useDrawingGeneration({
 
                 entitiesWithSymbols.add(circle.expressId);
                 const numSegments = circle.isFullCircle ? 32 : 16;
+                const circleWorldY = (circle as unknown as { worldY?: number }).worldY;
+                // Centre in shifted world coords. circle.centerX is
+                // already RTC-shifted X; circle.centerY carries the
+                // negated Z (see polyline note above) — flip to recover.
+                const circleWorldX = circle.centerX;
+                const circleWorldZ = -circle.centerY;
 
                 for (let j = 0; j < numSegments; j++) {
                   const t1 = j / numSegments;
@@ -230,6 +288,9 @@ export function useDrawingGeneration({
                     ifcType: circle.ifcType,
                     modelIndex: symbolicModelIndex,
                     depth: 0,
+                    worldX: circleWorldX,
+                    worldY: circleWorldY,
+                    worldZ: circleWorldZ,
                   });
                 }
               }
@@ -375,9 +436,94 @@ export function useDrawingGeneration({
           }
         }
 
+        // When the user toggles `sectionPlane.flipped` on a cardinal axis,
+        // the cutter negates the 2D U axis (see `projectTo2D` in
+        // @ifc-lite/drawing-2d/math.ts and `data[6] = flipU` in the GPU
+        // cutter). Symbolic primitives come out of WASM in the cutter's
+        // UNFLIPPED basis — for the plan ('y') case `(line.x = worldX − rtc,
+        // line.y = −worldY + rtc)` — so on a flipped section the cut
+        // polygons land at −X while the symbolic lines stay at +X. The
+        // result the user reported: annotations sitting NEXT TO the model
+        // as if they were mirrored across the model's centre, instead of
+        // staying with the cut. Mirror symbolic X here to match the cutter
+        // for cardinal flipped sections. Custom face-pick planes use
+        // `projectTo2DBasis` (no U flip), so leave them untouched —
+        // symbolic alignment on an arbitrary basis is a separate problem
+        // and out of scope for this fix.
+        const mirrorSymbolicX = sectionPlane.flipped && !sectionPlane.custom;
+        const orientedSymbolicLines: SymbolicDrawingLine[] = mirrorSymbolicX
+          ? symbolicLines.map((line) => ({
+              ...line,
+              line: {
+                start: { x: -line.line.start.x, y: line.line.start.y },
+                end:   { x: -line.line.end.x,   y: line.line.end.y   },
+              },
+            }))
+          : symbolicLines;
+
+        // Cull annotations to a thin view-depth slab IN FRONT of the cut.
+        //
+        // IfcAnnotation / IfcGridAxis polylines (dimensions, room tags, grid
+        // bubbles) live at a single elevation but have no body geometry —
+        // the `cutEntityIds.has(line.entityId)` filter below never matches
+        // them, so without this they render regardless of where the
+        // section sits.
+        //
+        // Reduce every cut mode (cardinal X/Y/Z + face-pick custom plane)
+        // to a single half-space test against a unit normal + signed
+        // distance. For cardinal axes the normal is the basis vector and
+        // distance is `position` (already in shifted-bounds coords, the
+        // same space the symbolic centroids land in). For custom planes
+        // the WASM cutter already uses `normal`/`distance` verbatim, so
+        // re-use both here for consistency with the cap.
+        //
+        // The kept window is `−ANNOTATION_VIEW_DEPTH ≤ signedDist ≤ 0` on
+        // the −normal side — the side BELOW a down-looking camera, where
+        // IFC dimensions live (authored at the storey's floor elevation,
+        // not at the cut height). This DIVERGES from
+        // `EdgeExtractor.filterEdgesByDepth`, which projects above the
+        // cut: annotations and projection edges are naturally on opposite
+        // sides of the cut plane. Flipped sections look at the same world
+        // from the opposite side, so the slab mirrors to
+        // `0 ≤ signedDist ≤ ANNOTATION_VIEW_DEPTH`.
+        //
+        // Anything on the wrong side of the cut, or farther than the view
+        // depth on the right side, is dropped — without the upper bound,
+        // dimensions from every storey beyond the cut stacked on top of
+        // each other because the half-space alone is unbounded along the
+        // camera axis.
+        //
+        // Annotations missing a recoverable centroid (older WASM build,
+        // or a degenerate polyline) are kept — over-rendering is preferable
+        // to silently dropping authored dimensions when the runtime can't
+        // classify them.
+        const cullNormal: [number, number, number] = sectionPlane.custom
+          ? sectionPlane.custom.normal
+          : axis === 'x' ? [1, 0, 0]
+          : axis === 'y' ? [0, 1, 0]
+          : [0, 0, 1];
+        const cullDistance = sectionPlane.custom ? sectionPlane.custom.distance : position;
+        const annotationCulled = orientedSymbolicLines.filter((line) => {
+          const isAnnotationLike = line.ifcType === 'IfcAnnotation' || line.ifcType === 'IfcGridAxis';
+          if (!isAnnotationLike) return true;
+          const wx = line.worldX;
+          const wy = line.worldY;
+          const wz = line.worldZ;
+          if (wx === undefined || wy === undefined || wz === undefined) return true;
+          const signedDist =
+            wx * cullNormal[0] +
+            wy * cullNormal[1] +
+            wz * cullNormal[2] -
+            cullDistance;
+          if (sectionPlane.flipped) {
+            return signedDist >= 0 && signedDist <= ANNOTATION_VIEW_DEPTH;
+          }
+          return signedDist <= 0 && signedDist >= -ANNOTATION_VIEW_DEPTH;
+        });
+
         // Only include symbolic lines for entities that are ACTUALLY being cut
         // This filters out symbols from other floors/levels not intersected by the section plane
-        const relevantSymbolicLines = symbolicLines.filter(line =>
+        const relevantSymbolicLines = annotationCulled.filter(line =>
           line.entityId !== undefined && cutEntityIds.has(line.entityId)
         );
 

package/src/hooks/useIfcCache.ts

@@ -13,10 +13,11 @@ import { useCallback } from 'react';
 import {
   BinaryCacheWriter,
   BinaryCacheReader,
+  type CachedEntityIndexColumns,
   type IfcDataStore as CacheDataStore,
   type GeometryData,
 } from '@ifc-lite/cache';
-import { SpatialHierarchyBuilder, StepTokenizer, CompactEntityIndexBuilder, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
+import { SpatialHierarchyBuilder, StepTokenizer, CompactEntityIndex, CompactEntityIndexBuilder, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
 import { buildSpatialIndexGuarded } from '../utils/loadingUtils.js';
 import type { MeshData } from '@ifc-lite/geometry';
 
@@ -30,6 +31,27 @@ import { calculateStoreyHeights } from '../utils/localParsingUtils.js';
 export type { CacheResult } from '../services/cacheService.js';
 export { getCached, setCached, deleteCached } from '../services/cacheService.js';
 
+function buildEntityIndexFromCachedColumns(columns: CachedEntityIndexColumns): IfcDataStore['entityIndex'] {
+  const byId = new CompactEntityIndex(
+    columns.ids,
+    columns.byteOffsets,
+    columns.byteLengths,
+    columns.typeIndices,
+    columns.typeNames,
+  );
+  const byType = new Map<string, number[]>();
+  for (let i = 0; i < columns.ids.length; i++) {
+    const type = columns.typeNames[columns.typeIndices[i]];
+    let ids = byType.get(type);
+    if (!ids) {
+      ids = [];
+      byType.set(type, ids);
+    }
+    ids.push(columns.ids[i]);
+  }
+  return { byId, byType };
+}
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -107,25 +129,28 @@ export function useIfcCache() {
       if (cacheResult.sourceBuffer) {
         dataStore.source = new Uint8Array(cacheResult.sourceBuffer);
 
-        // Quick scan to rebuild entity index with byte offsets (needed for on-demand extraction).
-        // Uses CompactEntityIndexBuilder to fill typed arrays directly during the scan,
-        // avoiding a temporary array of 4.4M+ objects (~350MB for large files).
-        const tokenizer = new StepTokenizer(dataStore.source);
-        const estimatedCount = dataStore.entities?.count ?? 100_000;
-        const indexBuilder = new CompactEntityIndexBuilder(estimatedCount);
-        const byType = new Map<string, number[]>();
-
-        for (const ref of tokenizer.scanEntitiesFast()) {
-          indexBuilder.add(ref.expressId, ref.type, ref.offset, ref.length);
-          let typeList = byType.get(ref.type);
-          if (!typeList) {
-            typeList = [];
-            byType.set(ref.type, typeList);
+        if (result.entityIndex) {
+          dataStore.entityIndex = buildEntityIndexFromCachedColumns(result.entityIndex);
+        } else {
+          // Backward compatibility for v3 caches: rebuild byte offsets from the
+          // source once, then future v4 writes persist this section.
+          const tokenizer = new StepTokenizer(dataStore.source);
+          const estimatedCount = dataStore.entities?.count ?? 100_000;
+          const indexBuilder = new CompactEntityIndexBuilder(estimatedCount);
+          const byType = new Map<string, number[]>();
+
+          for (const ref of tokenizer.scanEntitiesFast()) {
+            indexBuilder.add(ref.expressId, ref.type, ref.offset, ref.length);
+            let typeList = byType.get(ref.type);
+            if (!typeList) {
+              typeList = [];
+              byType.set(ref.type, typeList);
+            }
+            typeList.push(ref.expressId);
           }
-          typeList.push(ref.expressId);
+          const compactByIdIndex = indexBuilder.build();
+          dataStore.entityIndex = { byId: compactByIdIndex, byType };
         }
-        const compactByIdIndex = indexBuilder.build();
-        dataStore.entityIndex = { byId: compactByIdIndex, byType };
 
         // Rebuild on-demand maps from relationships
         // Pass entityIndex which contains ALL entity types including IfcPropertySet/IfcElementQuantity
@@ -254,6 +279,7 @@ export function useIfcCache() {
         quantities: dataStore.quantities,
         relationships: dataStore.relationships,
         spatialHierarchy: dataStore.spatialHierarchy,
+        entityIndex: dataStore.entityIndex,
       };
 
       console.log('[useIfcCache] Writing cache buffer...');

package/src/hooks/useIfcLoader.ts

@@ -1905,7 +1905,7 @@ export function useIfcLoader() {
         // risking corruption.
         const parserWasmApi = isNativeFileHandle(file) ? undefined : geometryProcessor.getApi();
         return new IfcParser().parseColumnar(buffer, {
-          wasmApi: parserWasmApi,
+          wasmApi: parserWasmApi ?? undefined,
           onSpatialReady: onPartialDataStore,
         });
       };
@@ -2032,34 +2032,12 @@ 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);
-        // Phase 2 of single-controller-rayon-design.md — opt-in via
-        // localStorage so we can A/B compare against the N-worker
-        // baseline without rolling out for everyone. Users (and the
-        // benchmark harness) flip this with:
-        //   localStorage.setItem('ifc-lite:single-controller', '1')
-        // and reload. Set to anything else (or unset) for the legacy
-        // N-worker path. Safe: if the threaded WASM bundle fails to
-        // load (no COI, Safari, etc.) the controller worker falls back
-        // to per-task serial execution within the controller itself
-        // (par_iter without an initialized pool).
-        const useSingleController = (() => {
-          try {
-            return typeof localStorage !== 'undefined'
-              && localStorage.getItem('ifc-lite:single-controller') === '1';
-          } catch {
-            return false;
-          }
-        })();
-        if (useSingleController) {
-          console.log('[useIfc] single-controller path enabled (Phase 2)');
-        }
         const geometryEvents = shouldUseDesktopStableWasmGeometry
           ? geometryProcessor.processStreaming(geometryView, undefined, dynamicBatchConfig)
           : geometryProcessor.processAdaptive(geometryView, {
               sizeThreshold: 2 * 1024 * 1024, // 2MB threshold
               batchSize: dynamicBatchConfig, // Dynamic batches: small first, then large
               existingSab: sharedSource ?? undefined,
-              useSingleController,
               // Hand the streaming pre-pass's entity index to the parser
               // worker so it skips a duplicate ~10 s WASM scan. Safe even
               // when the parser falls back to main-thread (instance is