@ifc-lite/viewer 1.25.1 → 1.25.2

package/src/components/viewer/MainToolbar.tsx

@@ -627,29 +627,42 @@ export function MainToolbar({ onShowShortcuts }: MainToolbarProps = {} as MainTo
     // eslint-disable-next-line react-hooks/exhaustive-deps -- meshLen is a stable proxy for geometryResult
   }, [models, meshLen]);
 
-  // IfcAnnotation has no body mesh, so it can't be detected via the mesh scan.
-  // Look up the entity table directly. byType keys are uppercase STEP names
-  // ('IFCANNOTATION') but cache loads sometimes preserve PascalCase too.
-  // Symbolic 2D overlays cover BOTH IfcAnnotation (text, dimensions, leader
-  // lines, filled regions) AND IfcGrid (axis lines + synthesized bubble +
-  // tag). Some files ship only grids (Snowdon Towers Structural is the
-  // canonical example — no IfcAnnotation at all), so the toggle must
-  // surface for either entity type or grid-only models get no way to hide
-  // the overlay.
-  const hasIfcAnnotations = useMemo(() => {
-    const has = (store: typeof ifcDataStore | undefined) => {
+  // IfcAnnotation / IfcGrid have no body mesh, so they can't be detected via
+  // the mesh scan. Look up the entity table directly. byType keys are
+  // uppercase STEP names but cache loads sometimes preserve PascalCase.
+  //
+  // Issue #862 split these into separate visibility toggles — files that
+  // ship only one of the two need only that menu entry. Some files ship
+  // only grids (Snowdon Towers Structural — no IfcAnnotation) so probing
+  // each independently is required.
+  const hasIfcEntities = useMemo(() => {
+    const probe = (store: typeof ifcDataStore | undefined) => {
       const byType = store?.entityIndex?.byType;
-      if (!byType) return false;
-      return (byType.get('IFCANNOTATION')?.length ?? 0) > 0
-        || (byType.get('IfcAnnotation')?.length ?? 0) > 0
-        || (byType.get('IFCGRID')?.length ?? 0) > 0
-        || (byType.get('IfcGrid')?.length ?? 0) > 0;
+      if (!byType) return { annotations: false, grid: false };
+      return {
+        annotations: (byType.get('IFCANNOTATION')?.length ?? 0) > 0
+          || (byType.get('IfcAnnotation')?.length ?? 0) > 0,
+        grid: (byType.get('IFCGRID')?.length ?? 0) > 0
+          || (byType.get('IfcGrid')?.length ?? 0) > 0,
+      };
     };
+    let annotations = false;
+    let grid = false;
     if (models.size > 0) {
-      for (const [, m] of models) if (has(m.ifcDataStore)) return true;
+      for (const [, m] of models) {
+        const p = probe(m.ifcDataStore);
+        annotations ||= p.annotations;
+        grid ||= p.grid;
+      }
+    } else {
+      const p = probe(ifcDataStore);
+      annotations = p.annotations;
+      grid = p.grid;
     }
-    return has(ifcDataStore);
+    return { annotations, grid };
   }, [models, ifcDataStore]);
+  const hasIfcAnnotations = hasIfcEntities.annotations;
+  const hasIfcGrid = hasIfcEntities.grid;
 
   const handleFileSelect = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
     const files = e.target.files;
@@ -1577,7 +1590,16 @@ export function MainToolbar({ onShowShortcuts }: MainToolbarProps = {} as MainTo
               onCheckedChange={() => toggleTypeVisibility('ifcAnnotations')}
             >
               <Pencil className="h-4 w-4 mr-2" style={{ color: '#e4b400' }} />
-              Show Annotations & Grids
+              Show Annotations
+            </DropdownMenuCheckboxItem>
+          )}
+          {hasIfcGrid && (
+            <DropdownMenuCheckboxItem
+              checked={typeVisibility.ifcGrid}
+              onCheckedChange={() => toggleTypeVisibility('ifcGrid')}
+            >
+              <Pencil className="h-4 w-4 mr-2" style={{ color: '#e4b400' }} />
+              Show Grids
             </DropdownMenuCheckboxItem>
           )}
 

package/src/components/viewer/Viewport.tsx

@@ -40,7 +40,11 @@ import { useGeometryStreaming } from './useGeometryStreaming.js';
 import { usePointCloudSync } from './usePointCloudSync.js';
 import { usePointCloudLifecycle } from './usePointCloudLifecycle.js';
 import { useRenderUpdates } from './useRenderUpdates.js';
-import { useSymbolicAnnotations, useSymbolicAnnotationsRichData } from '../../hooks/useSymbolicAnnotations.js';
+import {
+  useSymbolicAnnotations,
+  useSymbolicAnnotationsRichData,
+  type SectionClipForGrid,
+} from '../../hooks/useSymbolicAnnotations.js';
 
 interface ViewportProps {
   geometry: MeshData[] | null;
@@ -622,8 +626,19 @@ export function Viewport({
           calculateScale();
         },
         home: () => {
-          // Reset to isometric view
-          camera.zoomToFit(geometryBoundsRef.current.min, geometryBoundsRef.current.max, 500);
+          // Adaptive home: compact buildings get the historical SE isometric
+          // pose (1:1 with the old behaviour), linear infrastructure gets a
+          // side-on view at a distance where signals / referents are visible
+          // instead of receding to sub-pixel. The policy is computed from
+          // the current bbox shape so a federation that swaps from one
+          // building to a railway picks the right pose on Home press.
+          // See packages/renderer/src/camera-fit-policy.ts.
+          const canvas = rendererRef.current?.getCanvas();
+          const canvasShort = Math.min(canvas?.height ?? 0, canvas?.width ?? 0);
+          camera.fitBoundsAdaptive(
+            { min: geometryBoundsRef.current.min, max: geometryBoundsRef.current.max },
+            { animate: true, duration: 500, viewportShortPx: canvasShort > 0 ? canvasShort : undefined },
+          );
           calculateScale();
         },
         zoomIn: () => {
@@ -787,6 +802,11 @@ export function Viewport({
   // storey model shows all storeys' annotations layered correctly in 3D
   // (issue #653). Parsing is lazy and only runs while the toggle is on.
   const ifcAnnotationsVisible = useViewerStore((s) => s.typeVisibility.ifcAnnotations);
+  // Issue #862: IfcGrid is a separate toggle from IfcAnnotation. Default
+  // is on so existing users see no change; when the user disables it the
+  // grid axes + bubble tags drop out without affecting dimension/leader
+  // annotation rendering.
+  const ifcGridVisible = useViewerStore((s) => s.typeVisibility.ifcGrid);
   // For annotations whose storey can't be resolved (or whose authored
   // elevation is 0 because the storey Z lives on the placement instead),
   // lift to the middle of the model's vertical span so they don't end up
@@ -799,12 +819,37 @@ export function Viewport({
     if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) return 0;
     return (min + max) * 0.5;
   }, [coordinateInfo]);
+
+  // Issue #862: section-clip grid lines so dense-grid models stay
+  // readable when a horizontal cut is active. Use a 1.5 m band on each
+  // side of the cut so the cut storey's grids are visible but storeys
+  // 1.5 m+ away are hidden (matches typical residential floor heights).
+  // Only applies to the floor-plan axis (`'down'`) — vertical cuts
+  // don't clip grids since grid lines are inherently vertical.
+  const gridSectionClip = useMemo<SectionClipForGrid | undefined>(() => {
+    if (!sectionPlane.enabled || sectionPlane.axis !== 'down' || !sectionRange) {
+      return undefined;
+    }
+    const posWorld = sectionRange.min + (sectionPlane.position / 100) * (sectionRange.max - sectionRange.min);
+    const GRID_CLIP_HALF_BAND_M = 1.5;
+    return {
+      enabled: true,
+      posWorld,
+      viewDepth: GRID_CLIP_HALF_BAND_M,
+      axis: sectionPlane.axis,
+    };
+  }, [sectionPlane.enabled, sectionPlane.axis, sectionPlane.position, sectionRange]);
+
   const annotationVertices3D = useSymbolicAnnotations({
     enabled: ifcAnnotationsVisible,
+    gridEnabled: ifcGridVisible,
+    gridSectionClip,
     fallbackY: annotationFallbackY,
   });
   const { texts: annotationTexts3D, fills: annotationFills3D } = useSymbolicAnnotationsRichData({
     enabled: ifcAnnotationsVisible,
+    gridEnabled: ifcGridVisible,
+    gridSectionClip,
     fallbackY: annotationFallbackY,
   });
   useEffect(() => {

package/src/components/viewer/hierarchy/ifc-icons.ts

@@ -17,6 +17,20 @@ export const IFC_ICON_CODEPOINTS: Record<string, string> = {
   IfcBuilding: '\uea40',
   IfcBuildingStorey: '\ue8fe',
   IfcSpace: '\ueff4',
+  // IFC4.3 facility containers \u2014 same family as IfcBuilding (multi-storey
+  // spatial root) but `domain` carries the "campus / infrastructure
+  // facility" reading; IfcFacilityPart follows the storey-line icon for
+  // consistency. (Issue #860 \u2014 user reported no icon on IfcFacility.)
+  IfcFacility: '\ue7ee', // "domain"
+  IfcFacilityPart: '\ue8fe', // "layers" \u2014 mirrors IfcBuildingStorey
+  IfcBridge: '\uebbf', // "directions_railway" \u2014 civil bridge icon
+  IfcBridgePart: '\ue8fe',
+  IfcRoad: '\uebbe', // "route"
+  IfcRoadPart: '\ue8fe',
+  IfcRailway: '\ue570', // "train"
+  IfcRailwayPart: '\ue8fe',
+  IfcMarineFacility: '\ue532', // "directions_boat"
+  IfcMarineFacilityPart: '\ue8fe',
 
   // Structural
   IfcBeam: '\uf108',
@@ -80,6 +94,52 @@ export const IFC_ICON_CODEPOINTS: Record<string, string> = {
   IfcGeographicElement: '\uea99',
   IfcLinearElement: '\uebaa',
 
+  // IFC4.3 alignment / positioning. IfcAlignment shares the linear-element
+  // glyph because that's exactly what it is at the geometry level (a
+  // parameterised curve). IfcReferent is a station marker along that
+  // alignment (mileposts, kilometre posts) \u2014 pin glyph. IfcPositioningElement
+  // is the abstract base.
+  IfcAlignment: '\uebaa', // "polyline" / linear scale
+  IfcPositioningElement: '\ue55f', // "place"
+  IfcReferent: '\ue55f', // "place" \u2014 station marker
+
+  // IFC4.3 transportation signage & signals (rail/road). Same traffic-light
+  // glyph for both since the spec treats signals as the trackside subtype of
+  // signs.
+  IfcSign: '\ue9b2', // "traffic"
+  IfcSignal: '\ue9b2',
+
+  // IFC4.3 road / rail wearing surface. Pavement is the assembly, courses
+  // are its layers, kerbs sit at the edge.
+  IfcPavement: '\ue4f4', // "texture"
+  IfcCourse: '\ue8fe', // "layers"
+  IfcKerb: '\uf108', // "horizontal_rule"
+
+  // IFC4.3 earthworks. Cut/Fill share the geotechnical "terrain" glyph
+  // since they're shape-of-ground operations on the same domain.
+  IfcEarthworksElement: '\ue564',
+  IfcEarthworksFill: '\ue564',
+  IfcEarthworksCut: '\ue564',
+
+  // Geotechnical strata (IFC4.3) \u2014 issue #860. The abstract base plus the
+  // three concrete leaves (IfcSolidStratum / IfcVoidStratum / IfcWaterStratum)
+  // all share the `terrain` glyph. The geometry pipeline routes the leaves
+  // through IfcGeotechnicalStratum via legacy_entities.rs, so the icon map
+  // covers both the leaf names (when entries land in the spatial tree with
+  // their original type string) and the base.
+  IfcGeotechnicalAssembly: '\ue564',
+  IfcGeotechnicalElement: '\ue564',
+  IfcGeotechnicalStratum: '\ue564',
+  IfcSolidStratum: '\ue564',
+  IfcVoidStratum: '\ue564',
+  IfcWaterStratum: '\ue564',
+
+  // IFC4.3 marine / navigation / track / vehicle leaves.
+  IfcMooringDevice: '\uf1cd', // "anchor"
+  IfcNavigationElement: '\ue55d', // "navigation"
+  IfcTrackElement: '\ue260', // "linear_scale"
+  IfcVehicle: '\ue531', // "directions_car"
+
   // Proxy / generic fallback
   IfcProduct: '\ue047',
   IfcBuildingElementProxy: '\ue047',

package/src/components/viewer/useGeometryStreaming.ts

@@ -22,6 +22,13 @@ 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';
+import { toast } from '../ui/toast.js';
+
+// Session-scoped flag so the linear-infrastructure hint fires at most once
+// per page load (model swaps included). Stored at module scope rather than
+// in component state because federation re-mounts the streaming hook on
+// every model load — a useRef wouldn't survive.
+let linearFitHintShown = false;
 
 export interface UseGeometryStreamingParams {
   rendererRef: MutableRefObject<Renderer | null>;
@@ -109,6 +116,10 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
   const cameraFittedRef = useRef(false);
   const finalBoundsRefittedRef = useRef(false);
   const cameraSnapshotRef = useRef<{ px: number; py: number; pz: number; tx: number; ty: number; tz: number } | null>(null);
+  // Tracks which fit branch the post-load auto-fit took. Linear models get a
+  // one-time status-line hint via the viewer store; the home button can also
+  // mirror the same policy on re-press without re-deriving the bbox shape.
+  const lastFitPolicyKindRef = useRef<'compact' | 'linear' | null>(null);
   const prevIsStreamingRef = useRef(isStreaming);
   const lastContentVersionRef = useRef(geometryContentVersion ?? 0);
   const queuePumpTimerRef = useRef<ReturnType<typeof globalThis.setTimeout> | null>(null);
@@ -244,7 +255,24 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
         geometryBoundsRef.current = { ...DEFAULT_BOUNDS };
       }
     } else if (currentLength === lastLength) {
-      return; // No change
+      // No mesh-count change, so the queueMeshes / appendToBatches block
+      // below would be a no-op. But we MUST still reach the camera-fit
+      // block — the streaming-complete re-render (isStreaming flips
+      // false, geometry array length stays at the final mesh count)
+      // arrives here, and that's the FIRST render where path 2
+      // (`computeBounds(geometry)` fallback when shiftedBounds is empty)
+      // is allowed to fire. Pre-fix the early return short-circuited
+      // the camera fit entirely; the user reported 33 meshes streamed
+      // with the viewport stuck at the default ±100 m bounds (issue
+      // #859 / PR #871 deploy preview, `linear-placement-of-signal.ifc`).
+      //
+      // Skip only when the camera is already fitted or there's nothing
+      // to fit to.
+      if (cameraFittedRef.current || currentLength === 0) {
+        return;
+      }
+      // Otherwise fall through so the camera-fit block at the bottom of
+      // the effect gets a chance to run.
     }
 
     // Visibility toggle while NOT streaming — array rebuilt from scratch
@@ -302,26 +330,72 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     lastGeometryLengthRef.current = currentLength;
 
     // ── Fit camera ──
-    if (!cameraFittedRef.current && coordinateInfo?.shiftedBounds) {
-      const sb = coordinateInfo.shiftedBounds;
-      const maxSize = Math.max(sb.max.x - sb.min.x, sb.max.y - sb.min.y, sb.max.z - sb.min.z);
-      if (maxSize > 0 && Number.isFinite(maxSize)) {
-        renderer.getCamera().fitToBounds(sb.min, sb.max);
-        geometryBoundsRef.current = { min: { ...sb.min }, max: { ...sb.max } };
-        cameraFittedRef.current = true;
-        const pos = renderer.getCamera().getPosition();
-        const tgt = renderer.getCamera().getTarget();
-        cameraSnapshotRef.current = { px: pos.x, py: pos.y, pz: pos.z, tx: tgt.x, ty: tgt.y, tz: tgt.z };
+    //
+    // Pre-#871 the branching here was structured as
+    //   if (coordinateInfo?.shiftedBounds) { try to fit }
+    //   else if (geometry.length > 0) { fall back }
+    // but `coordinateInfo.shiftedBounds` is ALWAYS truthy — the wasm
+    // bridge ships a default `{ min: 0, max: 0 }` placeholder before
+    // any real bounds get computed. The outer `if` therefore won
+    // every time, the inner `maxSize > 0` failed, and the `else if`
+    // fallback NEVER fired. Result: the camera stayed at the default
+    // (0, 0, 0) framing while linearly-placed railway geometry sat at
+    // its MGA-territory world coords (~330, 123 after RTC), invisible
+    // to the user. Compute the size first so the branch reflects
+    // whether the data is actually usable, not just whether the
+    // property exists.
+    if (!cameraFittedRef.current) {
+      // The adaptive fit picks an SE-isometric pose for compact models
+      // (today's behaviour) but switches to a side-on-along-the-alignment
+      // pose for high-aspect-ratio bboxes (railway / road corridors).
+      // Without the switch, a 932 × 0.75 × 428 m alignment auto-fits to a
+      // ~1864 m distance where every 1 m signal projects to a sub-pixel
+      // dot — the user sees a blank viewport even though geometry is in
+      // the scene. See packages/renderer/src/camera-fit-policy.ts.
+      let fitted = false;
+      const sb = coordinateInfo?.shiftedBounds;
+      if (sb) {
+        const maxSize = Math.max(sb.max.x - sb.min.x, sb.max.y - sb.min.y, sb.max.z - sb.min.z);
+        if (maxSize > 0 && Number.isFinite(maxSize)) {
+          const canvas = renderer.getCanvas();
+          const canvasShort = Math.min(canvas?.height ?? 0, canvas?.width ?? 0);
+          const policy = renderer.getCamera().fitBoundsAdaptive(
+            { min: sb.min, max: sb.max },
+            { viewportShortPx: canvasShort > 0 ? canvasShort : undefined },
+          );
+          geometryBoundsRef.current = { min: { ...sb.min }, max: { ...sb.max } };
+          lastFitPolicyKindRef.current = policy.kind;
+          fitted = true;
+        }
+      }
+      if (!fitted && geometry.length > 0 && !isStreaming) {
+        const bounds = computeBounds(geometry);
+        if (bounds) {
+          const canvas = renderer.getCanvas();
+          const canvasShort = Math.min(canvas?.height ?? 0, canvas?.width ?? 0);
+          const policy = renderer.getCamera().fitBoundsAdaptive(
+            bounds,
+            { viewportShortPx: canvasShort > 0 ? canvasShort : undefined },
+          );
+          geometryBoundsRef.current = bounds;
+          lastFitPolicyKindRef.current = policy.kind;
+          fitted = true;
+        }
       }
-    } else if (!cameraFittedRef.current && geometry.length > 0 && !isStreaming) {
-      const bounds = computeBounds(geometry);
-      if (bounds) {
-        renderer.getCamera().fitToBounds(bounds.min, bounds.max);
-        geometryBoundsRef.current = bounds;
+      if (fitted) {
         cameraFittedRef.current = true;
         const pos = renderer.getCamera().getPosition();
         const tgt = renderer.getCamera().getTarget();
         cameraSnapshotRef.current = { px: pos.x, py: pos.y, pz: pos.z, tx: tgt.x, ty: tgt.y, tz: tgt.z };
+        // One-time hint for linear-infrastructure models. The side-on auto-fit
+        // shows a slice of the alignment at a useful zoom — but the FULL
+        // alignment is much longer than what fits on screen, so users need
+        // to know to pan / use Frame Selection to inspect remote stations.
+        // Hint is module-scoped so model swaps within one session don't spam.
+        if (lastFitPolicyKindRef.current === 'linear' && !linearFitHintShown) {
+          linearFitHintShown = true;
+          toast.info('Linear infrastructure — pan along the alignment, or select an element and press F to zoom in');
+        }
       }
     }
 
@@ -363,14 +437,35 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
             `finalize start geometryLength=${capturedGeometry?.length ?? 0} releaseAfterFinalize=${releaseGeometryAfterFinalize}`
           );
 
-          // Compute exact bounds and refit camera (fast ~15ms scan)
+          // Compute exact bounds and refit camera (fast ~15ms scan). Use
+          // the adaptive policy so linear-infrastructure models keep the
+          // side-on pose chosen by the early-fit branch — without this,
+          // the streaming-complete refit reverts to the legacy
+          // `fitToBounds` (SE isometric at `maxSize * 2`), undoing the
+          // useful close-in framing and putting the camera back at the
+          // sub-pixel distance for railway / road corridors.
           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);
+                const canvas = r.getCanvas();
+                const canvasShort = Math.min(canvas?.height ?? 0, canvas?.width ?? 0);
+                const policy = r.getCamera().fitBoundsAdaptive(
+                  exactBounds,
+                  { viewportShortPx: canvasShort > 0 ? canvasShort : undefined },
+                );
+                lastFitPolicyKindRef.current = policy.kind;
+                // Update the snapshot so a subsequent userMovedCamera check
+                // doesn't fire against the new pose's own delta.
+                const pos = r.getCamera().getPosition();
+                const tgt = r.getCamera().getTarget();
+                cameraSnapshotRef.current = { px: pos.x, py: pos.y, pz: pos.z, tx: tgt.x, ty: tgt.y, tz: tgt.z };
+                if (policy.kind === 'linear' && !linearFitHintShown) {
+                  linearFitHintShown = true;
+                  toast.info('Linear infrastructure — pan along the alignment, or select an element and press F to zoom in');
+                }
               }
               geometryBoundsRef.current = exactBounds;
               finalBoundsRefittedRef.current = true;

package/src/hooks/ingest/resolveDataStoreOrAbort.test.ts

@@ -0,0 +1,61 @@
+/* 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 { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+import { resolveDataStoreOrAbort } from './resolveDataStoreOrAbort.js';
+
+const isAbortError = (err: unknown): boolean =>
+  err instanceof DOMException && err.name === 'AbortError';
+
+describe('resolveDataStoreOrAbort', () => {
+  it('returns the parse result when not aborted', async () => {
+    const store = { id: 'store' };
+    const result = await resolveDataStoreOrAbort(Promise.resolve(store), { aborted: false });
+    assert.equal(result, store);
+  });
+
+  it('throws AbortError and terminates without awaiting a blocked parse', async () => {
+    let terminated = false;
+    // A promise that never settles — mirrors a worker parse blocked on
+    // waitForEntityIndex after the geometry loop was cancelled. The previous
+    // code awaited this directly and hung forever.
+    const neverSettles = new Promise<unknown>(() => {});
+
+    await assert.rejects(
+      resolveDataStoreOrAbort(neverSettles, {
+        aborted: true,
+        terminate: () => {
+          terminated = true;
+        },
+      }),
+      isAbortError,
+    );
+
+    assert.equal(terminated, true, 'the worker parser should be terminated on abort');
+  });
+
+  it('swallows the abandoned parse rejection on abort', async () => {
+    // A parse that rejects after we bail must not surface as an unhandled
+    // rejection (this test would fail the process if the .catch guard were
+    // removed from resolveDataStoreOrAbort).
+    const rejecting = Promise.reject(new Error('worker died after abort'));
+
+    await assert.rejects(
+      resolveDataStoreOrAbort(rejecting, { aborted: true }),
+      isAbortError,
+    );
+
+    // Give the swallowed rejection a tick to settle.
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  });
+
+  it('works without a terminate callback', async () => {
+    await assert.rejects(
+      resolveDataStoreOrAbort(new Promise<unknown>(() => {}), { aborted: true }),
+      isAbortError,
+    );
+  });
+});

package/src/hooks/ingest/resolveDataStoreOrAbort.ts

@@ -0,0 +1,28 @@
+/* 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/. */
+
+/**
+ * Resolve a parse promise, unless the load was cancelled.
+ *
+ * A worker parse started with `waitForEntityIndex` blocks until the streaming
+ * geometry pre-pass hands over the entity index. If the geometry loop is
+ * cancelled before that handoff, the index never arrives and the parse promise
+ * never settles — awaiting it would hang the whole ingest. On abort we instead
+ * terminate the worker, abandon (and swallow) the parse promise, and throw an
+ * `AbortError` so callers treat it as a clean cancellation (matching the
+ * federated loader's `err.name === 'AbortError'` convention).
+ */
+export async function resolveDataStoreOrAbort<T>(
+  parsePromise: Promise<T>,
+  opts: { aborted: boolean; terminate?: () => void },
+): Promise<T> {
+  if (opts.aborted) {
+    opts.terminate?.();
+    // Swallow the abandoned parse's eventual rejection so it doesn't surface
+    // as an unhandled rejection after we've already bailed out.
+    void parsePromise.catch(() => {});
+    throw new DOMException('Model load aborted', 'AbortError');
+  }
+  return parsePromise;
+}

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);
   }