@ifc-lite/viewer 1.25.2 → 1.26.0

package/src/components/viewer/bcf/BCFOverlay.tsx

@@ -128,7 +128,7 @@ export function BCFOverlay() {
   const bcfProject = useViewerStore((s) => s.bcfProject);
   const activeTopicId = useViewerStore((s) => s.activeTopicId);
   const setActiveTopic = useViewerStore((s) => s.setActiveTopic);
-  const setBcfPanelVisible = useViewerStore((s) => s.setBcfPanelVisible);
+  const openWorkspacePanel = useViewerStore((s) => s.openWorkspacePanel);
   const models = useViewerStore((s) => s.models);
   const loading = useViewerStore((s) => s.loading);
   const ifcDataStore = useViewerStore((s) => s.ifcDataStore);
@@ -239,10 +239,11 @@ export function BCFOverlay() {
     if (!overlay) return;
     return overlay.onMarkerClick((topicGuid) => {
       setActiveTopic(topicGuid);
-      const panelVisible = useViewerStore.getState().bcfPanelVisible;
-      if (!panelVisible) setBcfPanelVisible(true);
+      // Open BCF exclusively so clicking a marker brings it to the front over any
+      // other right panel (e.g. clash), instead of leaving it behind.
+      openWorkspacePanel('bcf');
     });
-  }, [overlayReady, setActiveTopic, setBcfPanelVisible]);
+  }, [overlayReady, setActiveTopic, openWorkspacePanel]);
 
   return (
     <div

package/src/components/viewer/useGeometryStreaming.ts

@@ -46,6 +46,10 @@ export interface UseGeometryStreamingParams {
   geometryContentVersion?: number;
   coordinateInfo?: CoordinateInfo;
   isStreaming: boolean;
+  /** Number of loaded models. When this increases (a model was added to the
+   *  federation) the camera must refit to the new combined bounds — otherwise
+   *  it stays framed on the first model and the newly-added one is off-screen. */
+  modelCount?: number;
   geometryBoundsRef: MutableRefObject<{ min: { x: number; y: number; z: number }; max: { x: number; y: number; z: number } }>;
   pendingMeshColorUpdates: Map<number, [number, number, number, number]> | null;
   pendingColorUpdates: Map<number, [number, number, number, number]> | null;
@@ -95,6 +99,7 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     geometryContentVersion,
     coordinateInfo,
     isStreaming,
+    modelCount = 0,
     geometryBoundsRef,
     pendingMeshColorUpdates,
     pendingColorUpdates,
@@ -122,6 +127,7 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
   const lastFitPolicyKindRef = useRef<'compact' | 'linear' | null>(null);
   const prevIsStreamingRef = useRef(isStreaming);
   const lastContentVersionRef = useRef(geometryContentVersion ?? 0);
+  const prevModelCountRef = useRef(modelCount);
   const queuePumpTimerRef = useRef<ReturnType<typeof globalThis.setTimeout> | null>(null);
 
   // Only activate the timer-based queue pump when the tab is background-throttled
@@ -200,6 +206,20 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
       }
     }
 
+    // A model was added to the federation — refit the camera to the new
+    // combined bounds. Without this, `cameraFittedRef` stays true from the
+    // first model's fit, so the newly-added model renders off-screen and only
+    // its 2D grid overlay shows. Refit only on an INCREASE (a model added),
+    // and never mid-stream (the streaming first-fit + finalize refit handle
+    // the active model). The combined bounds come from the merged
+    // coordinateInfo (union of all visible models).
+    if (modelCount > prevModelCountRef.current && !isStreaming) {
+      traceGeometrySync(`model added (${prevModelCountRef.current}→${modelCount}) — refitting camera to combined bounds`);
+      cameraFittedRef.current = false;
+      finalBoundsRefittedRef.current = false;
+    }
+    prevModelCountRef.current = modelCount;
+
     // Read AFTER the optional reset above so the classification below reflects
     // the post-reset state (otherwise an in-place update gets misclassified as
     // "no change" and returns early at currentLength === lastLength).
@@ -400,7 +420,7 @@ export function useGeometryStreaming(params: UseGeometryStreamingParams): void {
     }
 
     renderer.requestRender();
-  }, [geometry, geometryVersion, geometryContentVersion, coordinateInfo, isInitialized, isStreaming]);
+  }, [geometry, geometryVersion, geometryContentVersion, coordinateInfo, isInitialized, isStreaming, modelCount]);
 
   useEffect(() => {
     return () => {

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

@@ -0,0 +1,41 @@
+/* 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 { boundedIteratorReturn } from './streamCleanup.js';
+
+describe('boundedIteratorReturn', () => {
+  it('resolves promptly even when return() never settles (the stalled-worker case)', async () => {
+    // Mirrors a geometry generator parked on an unresolved await: its return()
+    // can never settle, so an unbounded await would re-wedge the caller.
+    const iterator = { return: () => new Promise<never>(() => { /* never settles */ }) };
+    const start = Date.now();
+    await boundedIteratorReturn(iterator, 50);
+    const elapsed = Date.now() - start;
+    assert.ok(elapsed < 1000, `expected bounded (<1000ms), took ${elapsed}ms`);
+  });
+
+  it('awaits a fast return() to completion (lets the generator finally run)', async () => {
+    let returned = false;
+    const iterator = {
+      return: async () => {
+        returned = true;
+        return { done: true, value: undefined };
+      },
+    };
+    await boundedIteratorReturn(iterator, 1000);
+    assert.strictEqual(returned, true);
+  });
+
+  it('swallows a rejecting return() without throwing', async () => {
+    const iterator = { return: () => Promise.reject(new Error('teardown blew up')) };
+    await assert.doesNotReject(() => boundedIteratorReturn(iterator, 1000));
+  });
+
+  it('is a no-op when the iterator has no return()', async () => {
+    await assert.doesNotReject(() => boundedIteratorReturn({}, 1000));
+  });
+});

package/src/hooks/ingest/streamCleanup.ts

@@ -0,0 +1,45 @@
+/* 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/. */
+
+/** How long to wait for an abandoned geometry iterator to shut down before
+ *  giving up on it. Generous enough for a healthy generator to run its
+ *  `finally` (freeing WASM handles, terminating workers), short enough that a
+ *  wedged one never holds the caller hostage. */
+export const GEOMETRY_ITERATOR_CLEANUP_MS = 2000;
+
+interface ClosableAsyncIterator {
+  return?: (value?: unknown) => Promise<unknown> | unknown;
+}
+
+/**
+ * Abandon an async iterator without letting its shutdown wedge the caller.
+ *
+ * `AsyncIterator.return()` cannot interrupt a generator parked on an unresolved
+ * `await` — e.g. the geometry drain loop suspended waiting on a worker that
+ * failed to instantiate ("Worker from an empty source") and therefore never
+ * resolves the promise. Awaiting `return()` unbounded would re-block on the
+ * exact stall the stream watchdog just escaped, swallowing the timeout error so
+ * the load hangs in cleanup instead of surfacing a recoverable failure. Racing
+ * it against a deadline guarantees the caller always proceeds; a healthy
+ * generator still resolves well within the deadline so its `finally` runs.
+ */
+export async function boundedIteratorReturn(
+  iterator: ClosableAsyncIterator,
+  cleanupMs: number = GEOMETRY_ITERATOR_CLEANUP_MS,
+): Promise<void> {
+  if (typeof iterator.return !== 'function') return;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  try {
+    await Promise.race([
+      Promise.resolve(iterator.return(undefined)).catch(() => {
+        /* cleanup — safe to ignore */
+      }),
+      new Promise<void>((resolve) => {
+        timer = setTimeout(resolve, cleanupMs);
+      }),
+    ]);
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+  }
+}

package/src/hooks/ingest/viewerModelIngest.ts

@@ -9,6 +9,7 @@ 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';
+import { watchedGeometryStream } from './watchedGeometryStream.js';
 
 type RgbaColor = [number, number, number, number];
 
@@ -264,7 +265,7 @@ export async function parseStepBufferViewerModel(options: StepBufferIngestOption
       });
 
   const geometryView = sharedSource ? new Uint8Array(sharedSource) : new Uint8Array(options.buffer);
-  for await (const event of geometryProcessor.processAdaptive(geometryView, {
+  const geometryStream = geometryProcessor.processAdaptive(geometryView, {
     sizeThreshold: 2 * 1024 * 1024,
     batchSize: options.getDynamicBatchSize(options.fileSizeMB),
     sharedRtcOffset: options.sharedRtcOffset,
@@ -272,48 +273,69 @@ export async function parseStepBufferViewerModel(options: StepBufferIngestOption
     onEntityIndex: (ids, starts, lengths) => {
       workerParser?.setEntityIndex(ids, starts, lengths);
     },
-  })) {
-    if (options.shouldAbort?.()) {
-      break;
-    }
-    switch (event.type) {
-      case 'start':
-        estimatedTotal = event.totalEstimate;
-        break;
-      case 'colorUpdate':
-        for (const [expressId, color] of event.updates) {
-          cumulativeColorUpdates.set(expressId, color);
-        }
-        options.onColorUpdate?.(event.updates);
-        break;
-      case 'rtcOffset':
-        if (event.hasRtc) {
-          capturedRtcOffset = event.rtcOffset;
-          options.onRtcOffset?.({ rtcOffset: event.rtcOffset });
-        }
-        break;
-      case 'batch':
-        batchIndex += 1;
-        for (let i = 0; i < event.meshes.length; i++) {
-          allMeshes.push(event.meshes[i]);
-        }
-        finalCoordinateInfo = event.coordinateInfo ?? null;
-        options.onBatch?.({
-          batchIndex,
-          estimatedTotal,
-          totalSoFar: event.totalSoFar,
-          meshes: event.meshes,
-          coordinateInfo: event.coordinateInfo ?? null,
-        });
-        options.onProgress?.({
-          phase: `Processing geometry (${event.totalSoFar} meshes)`,
-          percent: 10 + Math.min(80, (allMeshes.length / 1000) * 0.8),
-        });
-        break;
-      case 'complete':
-        finalCoordinateInfo = event.coordinateInfo ?? null;
-        break;
+  });
+  let lastTotalMeshes = 0;
+  // The federated/added-model path was missing the size-aware stream watchdog
+  // the single-model loader has, so a geometry worker that failed to spawn would
+  // hang the load forever on "Processing geometry (N meshes)" instead of
+  // surfacing a recoverable error. watchedGeometryStream re-yields each event
+  // under that watchdog and bounds iterator teardown on every exit path.
+  try {
+    for await (const event of watchedGeometryStream(geometryStream, {
+      fileName: options.fileName,
+      fileSizeMB: options.fileSizeMB,
+      shouldAbort: options.shouldAbort,
+      getBatchCount: () => batchIndex,
+      getLastTotalMeshes: () => lastTotalMeshes,
+    })) {
+      switch (event.type) {
+        case 'start':
+          estimatedTotal = event.totalEstimate;
+          break;
+        case 'colorUpdate':
+          for (const [expressId, color] of event.updates) {
+            cumulativeColorUpdates.set(expressId, color);
+          }
+          options.onColorUpdate?.(event.updates);
+          break;
+        case 'rtcOffset':
+          if (event.hasRtc) {
+            capturedRtcOffset = event.rtcOffset;
+            options.onRtcOffset?.({ rtcOffset: event.rtcOffset });
+          }
+          break;
+        case 'batch':
+          batchIndex += 1;
+          for (let i = 0; i < event.meshes.length; i++) {
+            allMeshes.push(event.meshes[i]);
+          }
+          finalCoordinateInfo = event.coordinateInfo ?? null;
+          lastTotalMeshes = event.totalSoFar;
+          options.onBatch?.({
+            batchIndex,
+            estimatedTotal,
+            totalSoFar: event.totalSoFar,
+            meshes: event.meshes,
+            coordinateInfo: event.coordinateInfo ?? null,
+          });
+          options.onProgress?.({
+            phase: `Processing geometry (${event.totalSoFar} meshes)`,
+            percent: 10 + Math.min(80, (allMeshes.length / 1000) * 0.8),
+          });
+          break;
+        case 'complete':
+          finalCoordinateInfo = event.coordinateInfo ?? null;
+          break;
+      }
     }
+  } catch (err) {
+    // Watchdog stall (or other stream error): the parser worker may be
+    // blocked in `waitForEntityIndex`, which only the geometry pre-pass would
+    // unblock. Terminate it here so it doesn't leak — the normal path below
+    // still awaits it via resolveDataStoreOrAbort. watchedGeometryStream's
+    // finally has already bounded teardown of the geometry iterator itself.
+    workerParser?.terminate();
+    throw err;
   }
 
   // If the load was cancelled, don't await dataStorePromise: a worker parse

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

@@ -0,0 +1,78 @@
+/* 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 { watchedGeometryStream } from './watchedGeometryStream.js';
+
+/** Build a controllable async source that records when return() is called. */
+function makeSource<T>(values: T[]): { source: AsyncIterable<T>; returned: () => boolean } {
+  let didReturn = false;
+  const source: AsyncIterable<T> = {
+    [Symbol.asyncIterator]() {
+      let i = 0;
+      return {
+        next: async () => (i < values.length
+          ? { done: false, value: values[i++] }
+          : { done: true, value: undefined as unknown as T }),
+        return: async () => {
+          didReturn = true;
+          return { done: true, value: undefined as unknown as T };
+        },
+      };
+    },
+  };
+  return { source, returned: () => didReturn };
+}
+
+const baseOpts = {
+  fileName: 'test.ifc',
+  fileSizeMB: 1,
+  getBatchCount: () => 0,
+  getLastTotalMeshes: () => 0,
+  cleanupMs: 50,
+};
+
+describe('watchedGeometryStream', () => {
+  it('re-yields every event in order then completes', async () => {
+    const { source } = makeSource([1, 2, 3]);
+    const seen: number[] = [];
+    for await (const v of watchedGeometryStream(source, baseOpts)) seen.push(v);
+    assert.deepStrictEqual(seen, [1, 2, 3]);
+  });
+
+  it('stops early when shouldAbort() turns true', async () => {
+    const { source } = makeSource([1, 2, 3, 4]);
+    const seen: number[] = [];
+    let calls = 0;
+    for await (const v of watchedGeometryStream(source, {
+      ...baseOpts,
+      // Abort after the second event has been consumed.
+      shouldAbort: () => (++calls > 2),
+    })) {
+      seen.push(v);
+    }
+    assert.deepStrictEqual(seen, [1, 2]);
+  });
+
+  it('tears down the underlying iterator on normal completion', async () => {
+    const { source, returned } = makeSource([1]);
+    let count = 0;
+    for await (const v of watchedGeometryStream(source, baseOpts)) count += v;
+    assert.strictEqual(count, 1);
+    assert.strictEqual(returned(), true);
+  });
+
+  it('tears down the underlying iterator when the consumer breaks early', async () => {
+    const { source, returned } = makeSource([1, 2, 3]);
+    const seen: number[] = [];
+    for await (const v of watchedGeometryStream(source, baseOpts)) {
+      seen.push(v);
+      break;
+    }
+    assert.deepStrictEqual(seen, [1]);
+    assert.strictEqual(returned(), true);
+  });
+});

package/src/hooks/ingest/watchedGeometryStream.ts

@@ -0,0 +1,76 @@
+/* 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 { getGeometryStreamWatchdogMs } from '@ifc-lite/geometry';
+import { boundedIteratorReturn } from './streamCleanup.js';
+
+export interface WatchedGeometryStreamOptions {
+  /** File name, for the stall error message. */
+  fileName: string;
+  /** File size in MB, feeds the size-aware watchdog deadline. */
+  fileSizeMB: number;
+  /** Abort the stream cooperatively (e.g. user cancelled the load). */
+  shouldAbort?: () => boolean;
+  /** Current batch index — feeds the size-aware watchdog deadline. */
+  getBatchCount: () => number;
+  /** Meshes rendered so far, for the stall error message. */
+  getLastTotalMeshes: () => number;
+  /** Override the abandon-cleanup deadline (mostly for tests). */
+  cleanupMs?: number;
+}
+
+/**
+ * Drive a geometry stream under a size-aware watchdog, re-yielding every event.
+ *
+ * The parallel pipeline only ends once EVERY spawned geometry worker reports
+ * `complete`; if the browser fails to instantiate a worker (the "Attempting to
+ * create a Worker from an empty source" warning) that worker never reports
+ * `ready`/`complete` and never fires `onerror`, so the underlying generator can
+ * wedge forever, stranding the load on "Processing geometry (N meshes)". Racing
+ * each `next()` against a deadline converts that silent wedge into a thrown,
+ * recoverable error. On ANY exit — normal completion, abort, consumer `break`,
+ * or a watchdog throw — the `finally` bounds the underlying iterator's shutdown
+ * so cleanup (the generator's own `finally`: freeing WASM handles, tearing down
+ * workers) runs without re-blocking on the very stall the watchdog just escaped.
+ *
+ * Generic over the event type so the consumer keeps full type-narrowing in its
+ * own `switch`.
+ */
+export async function* watchedGeometryStream<T>(
+  source: AsyncIterable<T>,
+  options: WatchedGeometryStreamOptions,
+): AsyncGenerator<T> {
+  const iterator = source[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      const watchdogMs = getGeometryStreamWatchdogMs({
+        desktopStableWasm: false,
+        batchCount: options.getBatchCount(),
+        fileSizeMB: options.fileSizeMB,
+      });
+      let watchdogId: ReturnType<typeof setTimeout> | null = null;
+      let result: IteratorResult<T>;
+      try {
+        result = await Promise.race([
+          iterator.next(),
+          new Promise<never>((_, reject) => {
+            watchdogId = setTimeout(() => {
+              reject(new Error(
+                `Geometry stream stalled after ${watchdogMs}ms while loading ${options.fileName}. `
+                + `Last rendered meshes: ${options.getLastTotalMeshes()}. A geometry worker likely failed to start.`,
+              ));
+            }, watchdogMs);
+          }),
+        ]);
+      } finally {
+        if (watchdogId !== null) clearTimeout(watchdogId);
+      }
+      if (result.done) return;
+      if (options.shouldAbort?.()) return;
+      yield result.value;
+    }
+  } finally {
+    await boundedIteratorReturn(iterator, options.cleanupMs);
+  }
+}

package/src/hooks/useAlignmentLines3D.ts

@@ -0,0 +1,164 @@
+/* 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/. */
+
+/**
+ * Always-on extraction of IfcAlignment centerlines for the 3D viewport.
+ *
+ * IfcAlignment carries its geometry in the `Axis` curve (an IfcAlignmentCurve
+ * or IfcPolyline), not a `Representation`, so it never produces a mesh in the
+ * streaming batch mesher. Instead of rendering it as a triangulated ribbon —
+ * which reads as a thin solid strip — the WASM `parseAlignmentLines` API
+ * samples the directrix into a flat 3D line-list in renderer Y-up world space,
+ * which we feed to `renderer.uploadAlignmentLines3D`. This matches how IfcGrid
+ * axes and IfcAnnotation curves render as thin lines.
+ *
+ * Unlike annotations there is no visibility toggle: alignment lines render
+ * whenever a loaded model has alignments. The parse runs once per model source
+ * and is cached module-globally, so federated views share one parse per source.
+ */
+
+import { useEffect, useMemo, useState } from 'react';
+import { GeometryProcessor } from '@ifc-lite/geometry';
+import { useViewerStore } from '@/store';
+import { useShallow } from 'zustand/react/shallow';
+import type { IfcDataStore } from '@ifc-lite/parser';
+
+const EMPTY_F32 = new Float32Array(0);
+
+/**
+ * Stable per-source cache key — FNV-1a over head/mid/tail byte windows folded
+ * with the length, so two structurally distinct sources can't alias even when
+ * they share an exact byte length (a real risk in federated views). Identical
+ * scheme to `useSymbolicAnnotations`' `sourceKey`.
+ */
+function sourceKey(store: IfcDataStore | null | undefined): string | null {
+  const source = store?.source;
+  if (!source || source.byteLength === 0) return null;
+  const len = source.byteLength;
+  const sampleLen = Math.min(32, len);
+  const head = source.subarray(0, sampleLen);
+  const tail = source.subarray(len - sampleLen, len);
+  const midOffset = Math.max(0, Math.floor(len / 2) - Math.floor(sampleLen / 2));
+  const mid = source.subarray(midOffset, Math.min(midOffset + sampleLen, len));
+  const hashOne = (bytes: Uint8Array): string => {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < bytes.length; i++) {
+      h ^= bytes[i];
+      h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16);
+  };
+  return `b${len}-${hashOne(head)}-${hashOne(mid)}-${hashOne(tail)}`;
+}
+
+// ─── Shared parse cache ──────────────────────────────────────────────────────
+// One WASM walk per model source; cached so re-renders (and federated views
+// that share a source) don't re-parse.
+const PARSE_CACHE = new Map<string, Float32Array>();
+const PARSE_INFLIGHT = new Map<string, Promise<void>>();
+
+type CacheListener = () => void;
+const CACHE_LISTENERS = new Set<CacheListener>();
+function notifyCacheChange(): void {
+  for (const fn of CACHE_LISTENERS) fn();
+}
+
+async function parseAlignmentLinesFor(store: IfcDataStore): Promise<Float32Array> {
+  const source = store.source;
+  if (!source || source.byteLength === 0) return EMPTY_F32;
+  const processor = new GeometryProcessor();
+  try {
+    await processor.init();
+    const verts = processor.parseAlignmentLines(source);
+    return verts && verts.length > 0 ? verts : EMPTY_F32;
+  } finally {
+    processor.dispose();
+  }
+}
+
+function ensureParseFor(stores: IfcDataStore[]): void {
+  for (const store of stores) {
+    const key = sourceKey(store);
+    if (!key) continue;
+    if (PARSE_CACHE.has(key)) continue;
+    if (PARSE_INFLIGHT.has(key)) continue;
+
+    const promise = (async () => {
+      try {
+        const verts = await parseAlignmentLinesFor(store);
+        PARSE_CACHE.set(key, verts);
+        notifyCacheChange();
+      } catch (error) {
+        // Cache empty on failure so we don't retry a doomed parse every tick.
+        // eslint-disable-next-line no-console
+        console.warn('[useAlignmentLines3D] parse failed:', error);
+        PARSE_CACHE.set(key, EMPTY_F32);
+        notifyCacheChange();
+      } finally {
+        PARSE_INFLIGHT.delete(key);
+      }
+    })();
+    PARSE_INFLIGHT.set(key, promise);
+  }
+}
+
+/** Read the active store set from the viewer store. Federation-aware. */
+function useActiveStores(): IfcDataStore[] {
+  const { models, ifcDataStore } = useViewerStore(
+    useShallow((s) => ({ models: s.models, ifcDataStore: s.ifcDataStore })),
+  );
+  return useMemo(() => {
+    const out: IfcDataStore[] = [];
+    if (models.size > 0) {
+      for (const [, m] of models) if (m.ifcDataStore) out.push(m.ifcDataStore);
+    } else if (ifcDataStore) {
+      out.push(ifcDataStore);
+    }
+    return out;
+  }, [models, ifcDataStore]);
+}
+
+/**
+ * Sample every loaded model's IfcAlignment centerlines into a single flat
+ * `[x0,y0,z0, x1,y1,z1, …]` line-list in renderer world space (Y-up,
+ * RTC-subtracted, metres). Returns a stable empty array when no model carries
+ * an alignment. Always parses (no toggle) — see the file header.
+ */
+export function useAlignmentLines3D(): Float32Array {
+  const stores = useActiveStores();
+  const [version, setVersion] = useState(0);
+
+  useEffect(() => {
+    ensureParseFor(stores);
+    const listener: CacheListener = () => setVersion((v) => v + 1);
+    CACHE_LISTENERS.add(listener);
+    return () => {
+      CACHE_LISTENERS.delete(listener);
+    };
+  }, [stores]);
+
+  return useMemo(() => {
+    void version; // depend on parse-completion ticks
+    const arrays: Float32Array[] = [];
+    let total = 0;
+    for (const store of stores) {
+      const key = sourceKey(store);
+      if (!key) continue;
+      const cached = PARSE_CACHE.get(key);
+      if (cached && cached.length > 0) {
+        arrays.push(cached);
+        total += cached.length;
+      }
+    }
+    if (total === 0) return EMPTY_F32;
+    if (arrays.length === 1) return arrays[0];
+    const merged = new Float32Array(total);
+    let offset = 0;
+    for (const a of arrays) {
+      merged.set(a, offset);
+      offset += a.length;
+    }
+    return merged;
+  }, [stores, version]);
+}