@ifc-lite/viewer 1.25.1 → 1.26.0

package/src/hooks/ingest/viewerModelIngest.ts

@@ -3,10 +3,13 @@
  * 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';
+import { watchedGeometryStream } from './watchedGeometryStream.js';
 
 type RgbaColor = [number, number, number, number];
 
@@ -217,6 +220,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,65 +239,116 @@ 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);
+  const geometryStream = geometryProcessor.processAdaptive(geometryView, {
     sizeThreshold: 2 * 1024 * 1024,
     batchSize: options.getDynamicBatchSize(options.fileSizeMB),
     sharedRtcOffset: options.sharedRtcOffset,
-  })) {
-    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;
+    existingSab: sharedSource ?? undefined,
+    onEntityIndex: (ids, starts, lengths) => {
+      workerParser?.setEntityIndex(ids, starts, lengths);
+    },
+  });
+  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;
   }
 
-  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/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]);
+}