npm - @ifc-lite/viewer - Versions diffs - 1.19.1 → 1.21.0 - Mend

@ifc-lite/viewer 1.19.1 → 1.21.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (106) hide show

package/.turbo/turbo-build.log +59 -44
package/.turbo/turbo-typecheck.log +1 -1
package/CHANGELOG.md +488 -0
package/dist/assets/{basketViewActivator-CA2CTcVo.js → basketViewActivator-Bzw51jhm.js} +6 -6
package/dist/assets/decode-worker-t2EGKAxO.js +1708 -0
package/dist/assets/drawing-2d-Bjy8YPrg.js +257 -0
package/dist/assets/exporters-u0sz2Upj.js +259119 -0
package/dist/assets/geometry-controller.worker-NH8pZmrU.js +7 -0
package/dist/assets/geometry.worker-Bp4rW_R1.js +1 -0
package/dist/assets/ids-B7AXEv7h.js +4067 -0
package/dist/assets/ifc-lite-DfZHk36-.js +7 -0
package/dist/assets/ifc-lite_bg-DlKs5-yM.wasm +0 -0
package/dist/assets/ifc-lite_bg-PqmRe3Ph.wasm +0 -0
package/dist/assets/index-CSWgTe1s.css +1 -0
package/dist/assets/{index-D8Epw-e7.js → index-DVNSvEMh.js} +40146 -35823
package/dist/assets/laz-perf-Cvr_Lepg.js +1 -0
package/dist/assets/laz-perf-DnSyzVYH.wasm +0 -0
package/dist/assets/{native-bridge-DKmx1z95.js → native-bridge-BiD01jI9.js} +1 -1
package/dist/assets/parser.worker-Bnbrl6gy.js +182 -0
package/dist/assets/{sandbox-tccwm5Bo.js → sandbox-DPD1ROr0.js} +4 -4
package/dist/assets/{server-client-LoWPK1N2.js → server-client-DP8fMPY9.js} +1 -1
package/dist/assets/{wasm-bridge-BsJGgPMs.js → wasm-bridge-CErti6zX.js} +1 -1
package/dist/assets/workerHelpers-CBbWSJmd.js +36 -0
package/dist/index.html +8 -8
package/index.html +1 -1
package/package.json +10 -10
package/src/components/viewer/BasketPresentationDock.tsx +3 -0
package/src/components/viewer/CesiumOverlay.tsx +165 -120
package/src/components/viewer/DeviationPanel.tsx +172 -0
package/src/components/viewer/HierarchyPanel.tsx +29 -3
package/src/components/viewer/HoverTooltip.tsx +5 -0
package/src/components/viewer/IDSAuditSummary.tsx +389 -0
package/src/components/viewer/IDSPanel.tsx +80 -26
package/src/components/viewer/MainToolbar.tsx +60 -7
package/src/components/viewer/MergeLayersBanner.tsx +108 -0
package/src/components/viewer/MobileToolbar.tsx +326 -0
package/src/components/viewer/PointCloudClasses.tsx +111 -0
package/src/components/viewer/PointCloudLegend.tsx +119 -0
package/src/components/viewer/PointCloudPanel.tsx +52 -1
package/src/components/viewer/PropertiesPanel.tsx +37 -6
package/src/components/viewer/RectSelectionOverlay.tsx +48 -0
package/src/components/viewer/StatusBar.tsx +14 -0
package/src/components/viewer/ViewerLayout.tsx +288 -95
package/src/components/viewer/Viewport.tsx +86 -18
package/src/components/viewer/ViewportContainer.tsx +25 -11
package/src/components/viewer/ViewportOverlays.tsx +41 -26
package/src/components/viewer/mouseHandlerTypes.ts +22 -0
package/src/components/viewer/properties/GeoreferencingPanel.tsx +77 -8
package/src/components/viewer/properties/MaterialCard.tsx +2 -2
package/src/components/viewer/selectionHandlers.ts +41 -0
package/src/components/viewer/tools/SectionPanel.tsx +181 -24
package/src/components/viewer/tools/SectionVisualization.tsx +384 -3
package/src/components/viewer/useAnimationLoop.ts +22 -0
package/src/components/viewer/useMouseControls.ts +296 -3
package/src/components/viewer/usePointCloudSync.ts +8 -1
package/src/components/viewer/useRenderUpdates.ts +21 -1
package/src/components/viewer/useTouchControls.ts +100 -41
package/src/hooks/federationLoadGate.test.ts +90 -0
package/src/hooks/federationLoadGate.ts +127 -0
package/src/hooks/ids/idsDataAccessor.ts +11 -259
package/src/hooks/ingest/pointCloudIngest.ts +127 -16
package/src/hooks/useDrawingGeneration.ts +81 -8
package/src/hooks/useIDS.ts +90 -10
package/src/hooks/useIfcFederation.ts +94 -16
package/src/hooks/useIfcLoader.ts +289 -64
package/src/hooks/useViewerSelectors.ts +10 -0
package/src/lib/geo/cesium-bridge.ts +84 -67
package/src/lib/geo/clamp-anchor.test.ts +80 -0
package/src/lib/geo/clamp-anchor.ts +57 -0
package/src/lib/geo/effective-georef.test.ts +79 -1
package/src/lib/geo/effective-georef.ts +83 -0
package/src/lib/geo/reproject.ts +26 -13
package/src/lib/geo/terrain-elevation.ts +166 -0
package/src/lib/lens/adapter.ts +1 -1
package/src/lib/llm/context-builder.ts +1 -1
package/src/lib/perf/memoryAccounting.test.ts +92 -0
package/src/lib/perf/memoryAccounting.ts +235 -0
package/src/sdk/adapters/mutation-view.ts +1 -1
package/src/store/constants.ts +39 -2
package/src/store/index.ts +6 -1
package/src/store/slices/cesiumSlice.ts +1 -1
package/src/store/slices/idsSlice.ts +24 -0
package/src/store/slices/loadingSlice.ts +12 -0
package/src/store/slices/pointCloudSlice.ts +72 -1
package/src/store/slices/sectionSlice.test.ts +590 -1
package/src/store/slices/sectionSlice.ts +344 -17
package/src/store/slices/uiSlice.merge-layers.test.ts +217 -0
package/src/store/slices/uiSlice.ts +60 -2
package/src/store/types.ts +42 -0
package/src/store.ts +13 -0
package/src/utils/acquireFileBuffer.test.ts +231 -0
package/src/utils/acquireFileBuffer.ts +128 -0
package/src/utils/ifcConfig.ts +24 -0
package/src/utils/nativeSpatialDataStore.ts +20 -2
package/src/utils/spatialHierarchy.test.ts +116 -0
package/src/utils/spatialHierarchy.ts +23 -0
package/tailwind.config.js +5 -0
package/tsconfig.json +1 -0
package/vite.config.ts +6 -0
package/dist/assets/decode-worker-Collf_X_.js +0 -1320
package/dist/assets/drawing-2d-DoxKMqbO.js +0 -257
package/dist/assets/exporters-xbXqEDlO.js +0 -81590
package/dist/assets/geometry.worker-DQEZB2rB.js +0 -1
package/dist/assets/ids-2WdONLlu.js +0 -2033
package/dist/assets/ifc-lite_bg-4yUkDRD8.wasm +0 -0
package/dist/assets/index-BXeEKqJG.css +0 -1

package/src/store/slices/uiSlice.ts CHANGED Viewed

@@ -7,11 +7,23 @@
  */
 import type { StateCreator } from 'zustand';
-import { UI_DEFAULTS } from '../constants.js';
+import { MERGE_LAYERS_STORAGE_KEY, UI_DEFAULTS } from '../constants.js';
 import type { ContactShadingQuality, SeparationLinesQuality } from '@ifc-lite/renderer';
+import type { FederatedModel } from '../types.js';
+import type { GeometryResult } from '@ifc-lite/geometry';
 export type ThemeMode = 'light' | 'dark' | 'colorful';
+/**
+ * Cross-slice surface UISlice reaches into via the combined Zustand
+ * `get()` to decide whether toggling a load-time setting needs a
+ * reload (only meaningful while a model is in scope).
+ */
+export interface UICrossSliceState {
+  models: Map<string, FederatedModel>;
+  geometryResult: GeometryResult | null;
+}
 export interface UISlice {
   // State
   leftPanelCollapsed: boolean;
@@ -30,6 +42,15 @@ export interface UISlice {
   separationLinesQuality: SeparationLinesQuality;
   separationLinesIntensity: number;
   separationLinesRadius: number;
+  /**
+   * Issue #540 — "Merge Multilayer Walls" load-time toggle. Reading
+   * this on next file load is what the WASM bridge actually uses;
+   * flipping it while a model is in scope sets
+   * `mergeLayersPendingReload` so the UI can prompt the user.
+   */
+  mergeLayers: boolean;
+  /** True after the user flipped `mergeLayers` while a model was loaded. */
+  mergeLayersPendingReload: boolean;
   // Actions
   setLeftPanelCollapsed: (collapsed: boolean) => void;
@@ -51,6 +72,10 @@ export interface UISlice {
   setSeparationLinesQuality: (quality: SeparationLinesQuality) => void;
   setSeparationLinesIntensity: (intensity: number) => void;
   setSeparationLinesRadius: (radius: number) => void;
+  /** Update the merge-layers toggle and persist to localStorage. */
+  setMergeLayers: (v: boolean) => void;
+  /** Acknowledge the reload banner without performing a reload. */
+  clearMergeLayersPendingReload: () => void;
 }
 /** Apply the correct CSS classes on <html> for the given theme */
@@ -60,7 +85,18 @@ function applyThemeClasses(theme: ThemeMode) {
   el.classList.toggle('colorful', theme === 'colorful');
 }
-export const createUISlice: StateCreator<UISlice, [], [], UISlice> = (set, get) => ({
+/**
+ * Returns true when any geometry is loaded — federated model map has
+ * entries OR the legacy single-model `geometryResult` is non-null with
+ * at least one mesh. Centralised here so the merge-layers toggle has
+ * a single source of truth for "is a model loaded?".
+ */
+function hasLoadedModel(state: UICrossSliceState): boolean {
+  if (state.models.size > 0) return true;
+  return (state.geometryResult?.meshes.length ?? 0) > 0;
+}
+export const createUISlice: StateCreator<UISlice & UICrossSliceState, [], [], UISlice> = (set, get) => ({
   // Initial state
   leftPanelCollapsed: false,
   rightPanelCollapsed: false,
@@ -78,6 +114,8 @@ export const createUISlice: StateCreator<UISlice, [], [], UISlice> = (set, get)
   separationLinesQuality: UI_DEFAULTS.SEPARATION_LINES_QUALITY,
   separationLinesIntensity: UI_DEFAULTS.SEPARATION_LINES_INTENSITY,
   separationLinesRadius: UI_DEFAULTS.SEPARATION_LINES_RADIUS,
+  mergeLayers: UI_DEFAULTS.MERGE_LAYERS,
+  mergeLayersPendingReload: false,
   // Actions
   setLeftPanelCollapsed: (leftPanelCollapsed) => set({ leftPanelCollapsed }),
@@ -121,4 +159,24 @@ export const createUISlice: StateCreator<UISlice, [], [], UISlice> = (set, get)
   setSeparationLinesQuality: (separationLinesQuality) => set({ separationLinesQuality }),
   setSeparationLinesIntensity: (separationLinesIntensity) => set({ separationLinesIntensity }),
   setSeparationLinesRadius: (separationLinesRadius) => set({ separationLinesRadius }),
+  setMergeLayers: (next) => {
+    const current = get();
+    if (current.mergeLayers === next) return;
+    // Persist eagerly so the next page-load picks the same value up
+    // through `getInitialMergeLayers` (constants.ts). Wrap in
+    // try/catch — Safari private mode / locked storage throws.
+    try {
+      localStorage.setItem(MERGE_LAYERS_STORAGE_KEY, String(next));
+    } catch {
+      /* storage unavailable — accept the in-memory toggle silently */
+    }
+    // Only ask the user to reload if a model is currently in scope.
+    // Toggling the setting on an empty viewer simply changes the
+    // future load behaviour with no visible effect.
+    const pending = hasLoadedModel(current);
+    set({ mergeLayers: next, mergeLayersPendingReload: pending });
+  },
+  clearMergeLayersPendingReload: () => set({ mergeLayersPendingReload: false }),
 });

package/src/store/types.ts CHANGED Viewed

@@ -92,6 +92,33 @@ export type SectionPlaneAxis = 'down' | 'front' | 'side';
 export type { HatchPatternId as SectionCapHatchId, SectionCapStyle } from '@ifc-lite/renderer';
 import type { SectionCapStyle } from '@ifc-lite/renderer';
+/**
+ * Custom (face-picked) plane override. When present, the renderer uses
+ * `normal` + `distance` directly and ignores `axis` / `position`. The
+ * cardinal `axis` / `position` / `flipped` fields are still kept in sync
+ * (nearest-cardinal for axis, percentage along it for position) so any
+ * downstream reader that pre-dates custom planes (drawings export, BCF
+ * snapshots, view controls) still gets a sensible projection rather than
+ * crashing or emitting empty data.
+ *
+ * Tangent + bitangent are derived once at pick time from `normal` via the
+ * deterministic `planeBasis` helper so the cap shader and cutter share
+ * exactly one orientation — without this the cap-hatch can rotate when
+ * the renderer re-derives the basis on every frame.
+ */
+export interface CustomSectionPlane {
+  /** Unit world-space normal. */
+  normal: [number, number, number];
+  /** Signed plane offset in world units: `dot(pointOnPlane, normal)`. */
+  distance: number;
+  /** World-space hit point at pick time (anchors the slider re-mapping). */
+  pickedAt: [number, number, number];
+  /** First in-plane axis, deterministic from `normal`. */
+  tangent: [number, number, number];
+  /** Second in-plane axis, deterministic from `normal`. */
+  bitangent: [number, number, number];
+}
 export interface SectionPlane {
   axis: SectionPlaneAxis;
   /** 0-100 percentage of model bounds */
@@ -110,6 +137,13 @@ export interface SectionPlane {
   showOutlines: boolean;
   /** User-defined colour + hatch for the cut surface. */
   capStyle: SectionCapStyle;
+  /**
+   * Optional arbitrary-normal override populated by face-pick. When set,
+   * the renderer cuts on this plane verbatim; cardinal `axis` / `position`
+   * are kept in sync as the closest cardinal projection (see
+   * `CustomSectionPlane`).
+   */
+  custom?: CustomSectionPlane;
 }
 // ============================================================================
@@ -120,6 +154,14 @@ export interface HoverState {
   entityId: number | null;
   screenX: number;
   screenY: number;
+  /**
+   * World-space hit position from the GPU pick (depth readback +
+   * inverse view-projection). Unset when the picker couldn't recover
+   * one (e.g. `pointCount === 0` clear, or the pick fell on the
+   * background). Useful for point-cloud hover tooltips where the
+   * synthetic entity has no surface property to display.
+   */
+  worldXYZ?: { x: number; y: number; z: number };
 }
 export interface ContextMenuState {

package/src/store.ts CHANGED Viewed

@@ -51,6 +51,19 @@ export { resolveEntityRef } from './store/resolveEntityRef.js';
 export { toGlobalIdFromModels, fromGlobalIdFromModels, toGlobalIdForRef } from './store/globalId.js';
 export type { ForwardModelMapLike } from './store/globalId.js';
+// Re-export custom-section-plane geometry helper (issue #243): projects
+// `pickedAt` onto the live cut plane so visuals (cap basis origin, 3D
+// drag gizmo) follow `distance` instead of staying anchored at the
+// original face-pick location.
+export { customPlaneCenter } from './store/slices/sectionSlice.js';
+// Re-export last-used section mode persistence (issue #243 follow-up):
+// `SectionPanel` reads this on mount to restore either the user's
+// previous cardinal cut (axis + position + flipped) or to rearm pick
+// mode for first-time users / users whose last action was a face pick.
+export { loadLastSectionMode } from './store/slices/sectionSlice.js';
+export type { LastSectionMode } from './store/slices/sectionSlice.js';
 // Re-export Schedule (4D) types + helpers
 export type { ScheduleSlice, ScheduleTimeRange, GanttTimeScale } from './store/slices/scheduleSlice.js';
 export {

package/src/utils/acquireFileBuffer.test.ts ADDED Viewed

@@ -0,0 +1,231 @@
+/* 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 assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+// NOTE: We deliberately avoid importing from `./acquireFileBuffer` directly,
+// because that module pulls in `./ifcConfig`, which references
+// `import.meta.env.*` (Vite-only). Instead, we shadow the threshold dependency
+// by re-implementing the public surface against a thin re-export. The
+// production `acquireFileBuffer()` simply calls `__acquireFileBufferWithThreshold`
+// with `STREAM_SAB_THRESHOLD`; tests bypass `STREAM_SAB_THRESHOLD` with a
+// kilobyte-sized injected threshold so the streaming branch is exercised
+// without multi-hundred-MB allocations.
+//
+// Importing the inner function directly would still trigger the ifcConfig
+// side-effect, so we use Node's loader hook indirection: import via a tiny
+// module-relative path that is re-exported from acquireFileBuffer.ts itself.
+import { __acquireFileBufferWithThreshold } from './acquireFileBuffer';
+function bytes(n: number, fill: (i: number) => number = (i) => i & 0xff): Uint8Array<ArrayBuffer> {
+  // Allocate via ArrayBuffer explicitly so the resulting Uint8Array satisfies
+  // `Uint8Array<ArrayBuffer>`. Default `new Uint8Array(n)` infers
+  // `ArrayBufferLike`, which TS 5.7+'s tightened DOM lib rejects as a BlobPart.
+  const ab = new ArrayBuffer(n);
+  const u = new Uint8Array(ab);
+  for (let i = 0; i < n; i++) u[i] = fill(i);
+  return u;
+}
+function viewsEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+const TEST_THRESHOLD = 4 * 1024; // 4 KB — small enough to exercise streaming cheaply.
+describe('acquireFileBuffer', () => {
+  it('returns ArrayBuffer for small files (below the streaming threshold)', async () => {
+    const data = bytes(1024);
+    const file = new File([data], 'small.bin');
+    const acquired = await __acquireFileBufferWithThreshold(file, TEST_THRESHOLD);
+    assert.equal(acquired.isShared, false);
+    assert.equal(acquired.buffer.byteLength, data.byteLength);
+    assert.equal(acquired.view.byteLength, data.byteLength);
+    assert.ok(viewsEqual(acquired.view, data), 'bytes round-trip');
+    assert.ok(acquired.buffer instanceof ArrayBuffer, 'small files keep ArrayBuffer path');
+  });
+  it('returns empty buffer for zero-size file', async () => {
+    const file = new File([], 'empty.bin');
+    const acquired = await __acquireFileBufferWithThreshold(file, TEST_THRESHOLD);
+    assert.equal(acquired.buffer.byteLength, 0);
+    assert.equal(acquired.view.byteLength, 0);
+    assert.equal(acquired.isShared, false);
+  });
+  it('streams large files (≥ threshold) into SharedArrayBuffer with byte-identical contents', async () => {
+    // Compose a Blob whose total size sits above the test threshold using a
+    // handful of small chunks so the read loop iterates more than once. The
+    // pattern is `(offset & 0xff)` so we can verify byte-identity without
+    // keeping a parallel copy.
+    const target = TEST_THRESHOLD + 4096;
+    const chunkSize = 1024;
+    const chunks: Uint8Array<ArrayBuffer>[] = [];
+    let written = 0;
+    while (written < target) {
+      const remaining = target - written;
+      const size = Math.min(chunkSize, remaining);
+      const chunk = new Uint8Array(new ArrayBuffer(size));
+      for (let i = 0; i < size; i++) chunk[i] = (written + i) & 0xff;
+      chunks.push(chunk);
+      written += size;
+    }
+    const file = new File(chunks, 'large.bin');
+    assert.equal(file.size, target);
+    const acquired = await __acquireFileBufferWithThreshold(file, TEST_THRESHOLD);
+    assert.equal(acquired.buffer.byteLength, target);
+    assert.equal(acquired.view.byteLength, target);
+    // Spot-check at start, chunk boundaries, middle, and end. Full scan adds
+    // no coverage if any byte is correct (the streaming copy either works
+    // for all bytes or fails immediately on misalignment).
+    for (const offset of [0, 1, chunkSize - 1, chunkSize, chunkSize + 1, Math.floor(target / 2), target - 2, target - 1]) {
+      assert.equal(acquired.view[offset], offset & 0xff, `byte at offset ${offset}`);
+    }
+    // SAB iff the runtime supports it. Node 22 gives us SAB and an undefined
+    // `crossOriginIsolated`, so we expect the streaming path to engage.
+    if (typeof SharedArrayBuffer !== 'undefined') {
+      assert.equal(acquired.isShared, true);
+      assert.ok(
+        acquired.buffer instanceof SharedArrayBuffer,
+        'large files use SharedArrayBuffer when supported',
+      );
+    }
+  });
+  it('rejects when the underlying stream errors', async () => {
+    const fakeFile = {
+      name: 'broken.bin',
+      size: TEST_THRESHOLD + 1,
+      stream(): ReadableStream<Uint8Array> {
+        return new ReadableStream<Uint8Array>({
+          start(controller) {
+            controller.error(new Error('synthetic stream failure'));
+          },
+        });
+      },
+      arrayBuffer(): Promise<ArrayBuffer> {
+        return Promise.reject(new Error('arrayBuffer not used in this test'));
+      },
+    } as unknown as File;
+    await assert.rejects(
+      __acquireFileBufferWithThreshold(fakeFile, TEST_THRESHOLD),
+      /synthetic stream failure/,
+    );
+  });
+  it('falls back to arrayBuffer() when SharedArrayBuffer is unavailable', async () => {
+    const originalSAB = (globalThis as { SharedArrayBuffer?: unknown }).SharedArrayBuffer;
+    try {
+      (globalThis as { SharedArrayBuffer?: unknown }).SharedArrayBuffer = undefined;
+      const data = bytes(1024);
+      const file = new File([data], 'no-sab.bin');
+      // Force the size check to think this is a large file while keeping the
+      // actual buffer small — verifies the fallback branch fires before any
+      // SAB allocation is attempted.
+      Object.defineProperty(file, 'size', { value: TEST_THRESHOLD + 1 });
+      const acquired = await __acquireFileBufferWithThreshold(file, TEST_THRESHOLD);
+      assert.equal(acquired.isShared, false);
+      assert.ok(acquired.buffer instanceof ArrayBuffer, 'fallback returns ArrayBuffer');
+    } finally {
+      (globalThis as { SharedArrayBuffer?: unknown }).SharedArrayBuffer = originalSAB;
+    }
+  });
+  it('IFCX federation call sites do NOT use SAB streaming (memory regression guard for #647)', () => {
+    // IFCX is JSON. The federation parser path is:
+    //   parseFederatedIfcx → safeUtf8Decode(new Uint8Array(buffer)) → JSON.parse
+    // safeUtf8Decode must copy SAB-backed views into a scratch buffer in
+    // Chromium/Firefox (cross-thread JS string decoding cannot read SAB
+    // directly) and retains that scratch. Net peak with SAB streaming:
+    //   SAB (file.size) + scratch copy (file.size) + JSON string (~file.size)
+    //   + retained scratch — strictly worse than the plain ArrayBuffer path.
+    //
+    // This is a source-level guard: it ensures the two IFCX entry points in
+    // useIfcFederation.ts (loadFederatedIfcx + addIfcxOverlays) stay on
+    // file.arrayBuffer() and don't accidentally regress back to
+    // acquireFileBuffer(). The IFC/STEP path (addModel) keeps SAB streaming.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const sourcePath = join(here, '..', 'hooks', 'useIfcFederation.ts');
+    const source = readFileSync(sourcePath, 'utf8');
+    // Find the loadFederatedIfcx and addIfcxOverlays function bodies and
+    // assert each one reads files via file.arrayBuffer(), not acquireFileBuffer.
+    const ifcxFnNames = ['loadFederatedIfcx', 'addIfcxOverlays'];
+    for (const fnName of ifcxFnNames) {
+      // Match the const declaration through the closing `}, [` of useCallback.
+      const startMarker = `const ${fnName} = useCallback`;
+      const startIdx = source.indexOf(startMarker);
+      assert.ok(startIdx >= 0, `expected ${fnName} declaration in useIfcFederation.ts`);
+      // End at the next useCallback dependency-array opener that closes this fn.
+      // We look for the first `}, [` after `startIdx`.
+      const endIdx = source.indexOf('}, [', startIdx);
+      assert.ok(endIdx > startIdx, `expected end of ${fnName} useCallback`);
+      const body = source.slice(startIdx, endIdx);
+      assert.ok(
+        body.includes('file.arrayBuffer()'),
+        `${fnName} must read files via file.arrayBuffer() (IFCX JSON path)`,
+      );
+      assert.ok(
+        !body.includes('acquireFileBuffer'),
+        `${fnName} must NOT use acquireFileBuffer() — SAB streaming worsens peak memory for IFCX/JSON (see PR #647 regression).`,
+      );
+    }
+    // Sanity check: the IFC addModel path SHOULD still use acquireFileBuffer
+    // (STEP/IFC binary path benefits from SAB streaming).
+    const addModelStart = source.indexOf('const addModel = useCallback');
+    assert.ok(addModelStart >= 0, 'expected addModel declaration');
+    const addModelEnd = source.indexOf('}, [', addModelStart);
+    const addModelBody = source.slice(addModelStart, addModelEnd);
+    assert.ok(
+      addModelBody.includes('acquireFileBuffer'),
+      'addModel (IFC/STEP path) must keep using acquireFileBuffer() for SAB streaming',
+    );
+  });
+  it('falls back to arrayBuffer() when crossOriginIsolated is explicitly false', async () => {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'crossOriginIsolated');
+    try {
+      Object.defineProperty(globalThis, 'crossOriginIsolated', {
+        configurable: true,
+        get: () => false,
+      });
+      const data = bytes(64);
+      const file = new File([data], 'no-coi.bin');
+      Object.defineProperty(file, 'size', { value: TEST_THRESHOLD + 1 });
+      const acquired = await __acquireFileBufferWithThreshold(file, TEST_THRESHOLD);
+      assert.equal(acquired.isShared, false);
+      assert.ok(acquired.buffer instanceof ArrayBuffer);
+    } finally {
+      if (originalDescriptor) {
+        Object.defineProperty(globalThis, 'crossOriginIsolated', originalDescriptor);
+      } else {
+        delete (globalThis as { crossOriginIsolated?: boolean }).crossOriginIsolated;
+      }
+    }
+  });
+});

package/src/utils/acquireFileBuffer.ts ADDED Viewed

@@ -0,0 +1,128 @@
+/* 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/. */
+/**
+ * Reads a `File` into a single buffer, streaming directly into a
+ * `SharedArrayBuffer` for files above `STREAM_SAB_THRESHOLD`. Avoids the
+ * doubled peak memory of `await file.arrayBuffer()` followed by a SAB
+ * allocation+copy inside the geometry pipeline (issue #600).
+ *
+ * The returned `view` is suitable for every downstream consumer: parser,
+ * fingerprinter, format detector, geometry processor. Each downstream uses
+ * `new Uint8Array(buffer)` or works on the view directly, both of which
+ * accept SAB-backed views.
+ *
+ * Cache writes (`saveToCache`) and server uploads do their own copy via
+ * structured clone or `Blob`, so SAB ownership doesn't leak into IndexedDB
+ * or `fetch`.
+ */
+// `STREAM_SAB_THRESHOLD` lives in `ifcConfig`, but importing that module
+// eagerly drags in `import.meta.env.*` (Vite-only) and breaks Node-based
+// unit tests. We dereference it lazily inside the public `acquireFileBuffer`
+// wrapper so the test entry point (`__acquireFileBufferWithThreshold`) can
+// run without ever loading `ifcConfig`.
+export interface AcquiredBuffer {
+  /**
+   * Underlying buffer. Either a `SharedArrayBuffer` (large files when SAB is
+   * supported) or an `ArrayBuffer` (small files, or environments without
+   * cross-origin isolation).
+   */
+  buffer: ArrayBuffer | SharedArrayBuffer;
+  /** Zero-copy view over `buffer`. Pass this to consumers expecting bytes. */
+  view: Uint8Array;
+  /** Whether the underlying buffer is a SharedArrayBuffer. */
+  isShared: boolean;
+}
+function sharedArrayBufferAvailable(): boolean {
+  if (typeof SharedArrayBuffer === 'undefined') return false;
+  // `crossOriginIsolated` is the canonical gate; some early implementations
+  // lack the global, hence the `?? true` permissiveness — if SAB *exists* in
+  // scope the environment is generally COI-enabled.
+  const coi = (globalThis as { crossOriginIsolated?: boolean }).crossOriginIsolated;
+  return coi !== false;
+}
+/**
+ * Internal entry point that accepts an injected threshold. Production code
+ * should call `acquireFileBuffer` (which uses `STREAM_SAB_THRESHOLD` from
+ * `ifcConfig`). Tests use this overload so they can exercise the streaming
+ * branch without allocating a multi-hundred-MB buffer.
+ */
+export async function __acquireFileBufferWithThreshold(
+  file: File,
+  threshold: number,
+): Promise<AcquiredBuffer> {
+  const useSharedStream =
+    file.size >= threshold
+    && sharedArrayBufferAvailable()
+    && typeof file.stream === 'function';
+  if (!useSharedStream) {
+    const buffer = await file.arrayBuffer();
+    return {
+      buffer,
+      view: new Uint8Array(buffer),
+      isShared: false,
+    };
+  }
+  const sab = new SharedArrayBuffer(file.size);
+  const view = new Uint8Array(sab);
+  const reader = (file.stream() as ReadableStream<Uint8Array>).getReader();
+  let offset = 0;
+  try {
+    // Stream chunks from the File directly into the SAB. No intermediate
+    // ArrayBuffer means peak memory is ~`fileSize` instead of `2 × fileSize`
+    // at this entry point.
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (offset + value.byteLength > sab.byteLength) {
+        // Defensive: file grew while reading (rare, but possible on local
+        // disks with active writes). Truncate to the SAB size we promised.
+        view.set(value.subarray(0, sab.byteLength - offset), offset);
+        offset = sab.byteLength;
+        break;
+      }
+      view.set(value, offset);
+      offset += value.byteLength;
+    }
+  } finally {
+    // releaseLock can throw if the reader is already closed/released by the
+    // platform after a stream error. The lock is gone either way, so cleanup
+    // is safe to swallow here. (CR feedback on #627.)
+    try { reader.releaseLock(); } catch { /* cleanup — safe to ignore */ }
+  }
+  // Validate we read the expected number of bytes. A short read indicates
+  // the file shrank mid-load; surface it loudly so callers don't silently
+  // process a truncated buffer.
+  if (offset !== sab.byteLength) {
+    throw new Error(
+      `acquireFileBuffer: short read for ${file.name} (got ${offset} of ${sab.byteLength} bytes)`,
+    );
+  }
+  return {
+    buffer: sab,
+    view,
+    isShared: true,
+  };
+}
+/**
+ * Reads `file` into an in-memory buffer. Streams chunks into a pre-sized
+ * `SharedArrayBuffer` for files ≥ `STREAM_SAB_THRESHOLD` when SAB is
+ * available, otherwise falls back to `await file.arrayBuffer()`.
+ */
+export async function acquireFileBuffer(file: File): Promise<AcquiredBuffer> {
+  // Lazy import keeps Node-based test runs out of the Vite `import.meta.env`
+  // path that `ifcConfig` evaluates at module-load time.
+  const { STREAM_SAB_THRESHOLD } = await import('./ifcConfig.js');
+  return __acquireFileBufferWithThreshold(file, STREAM_SAB_THRESHOLD);
+}

package/src/utils/ifcConfig.ts CHANGED Viewed

@@ -49,6 +49,30 @@ export const CACHE_MAX_SOURCE_SIZE = 150 * 1024 * 1024;
 /** Route desktop IFCs above this threshold through the bounded-memory path. */
 export const HUGE_NATIVE_FILE_THRESHOLD = 128 * 1024 * 1024;
+/**
+ * File size at which the browser-File-API entry path streams directly into a
+ * `SharedArrayBuffer` instead of going through `await file.arrayBuffer()`.
+ *
+ * Below this threshold, the doubled peak (ArrayBuffer + SAB) is small enough
+ * that the simpler one-shot read is preferable. Above it, the streaming path
+ * shaves ~`fileSize` MB from peak memory and avoids hitting V8's per-buffer
+ * allocation limits on huge files. (Issue #600.)
+ */
+export const STREAM_SAB_THRESHOLD = 256 * 1024 * 1024;
+/**
+ * File size at which the browser parser worker defers indexing of property
+ * atoms (`IFCPROPERTYSINGLEVALUE`, `IFCPROPERTYENUMERATEDVALUE`, etc.) until
+ * a property panel actually opens.
+ *
+ * On a 14 M-entity, 986 MB file roughly 3.4 M of those entities are
+ * property atoms. Skipping them in the primary `compactByIdIndex` shaves
+ * ~4 s off the parse path; the deferred index is built on-demand in
+ * ~50 ms when the first property panel hydrates. Mirrors the desktop
+ * `hugeNativeMode` gate.
+ */
+export const HUGE_BROWSER_FILE_THRESHOLD = 500 * 1024 * 1024;
 /** File size thresholds for various optimizations */
 export const THRESHOLDS = {
   /** Use streaming Parquet above this (150MB) */

package/src/utils/nativeSpatialDataStore.ts CHANGED Viewed

@@ -166,10 +166,28 @@ export function buildIfcDataStoreFromNativeMetadata(snapshot: NativeMetadataSnap
     const elements = node.elements.map((summary) => {
       entityLookup.addSummary(summary);
       if (nextStoreyId !== null) {
-        elementToStorey.set(summary.expressId, nextStoreyId);
+        // Direct storey containment wins — only set if absent. Mirrors the
+        // descendant-walk path in `spatialHierarchy.ts` where direct
+        // IfcRelContainedInSpatialStructure entries take precedence over
+        // inherited aggregate-descendant assignments.
+        if (!elementToStorey.has(summary.expressId)) {
+          elementToStorey.set(summary.expressId, nextStoreyId);
+        }
+        // NOTE: aggregate descendants of an element (e.g. IfcBuildingElementPart
+        // children of an IfcWall) are NOT represented locally in the native
+        // metadata snapshot — `NativeMetadataSpatialNode.children` only contains
+        // spatial sub-nodes and `node.elements` is a flat list of
+        // directly-contained elements (no `children` field on
+        // `NativeMetadataEntitySummary`). They are fetched lazily through
+        // `getNativeMetadataChildren`. The aggregate-descendant-walk fix that
+        // `spatialHierarchy.ts` performs via `relationships.getRelated` cannot
+        // be replicated here without an additional native bootstrap payload
+        // change (see issue #540 follow-up).
       }
       if (nextSpaceId !== null) {
-        elementToSpace.set(summary.expressId, nextSpaceId);
+        if (!elementToSpace.has(summary.expressId)) {
+          elementToSpace.set(summary.expressId, nextSpaceId);
+        }
       }
       return summary.expressId;
     });