@ifc-lite/viewer 1.19.0 → 1.21.0

package/src/hooks/useIDS.ts

@@ -16,6 +16,7 @@
 import { useCallback, useMemo, useEffect, useRef, useState } from 'react';
 import { useViewerStore } from '@/store';
 import type {
+  IDSAuditReport,
   IDSDocument,
   IDSValidationReport,
   IDSModelInfo,
@@ -23,6 +24,8 @@ import type {
   ValidationProgress,
 } from '@ifc-lite/ids';
 import {
+  auditIDSDocument,
+  IDSParseError,
   parseIDS,
   validateIDS,
   createTranslationService,
@@ -61,6 +64,15 @@ export interface UseIDSResult {
   // State
   /** Loaded IDS document */
   document: IDSDocument | null;
+  /**
+   * Audit report for the loaded IDS document — flags authoring issues
+   * surfaced by the document auditor (invalid IFC entities, malformed
+   * restrictions, missing required attributes, …). `null` when no
+   * document is loaded or the audit is still in flight.
+   */
+  auditReport: IDSAuditReport | null;
+  /** True while the document auditor is running. */
+  auditing: boolean;
   /** Validation report */
   report: IDSValidationReport | null;
   /** Loading state */
@@ -176,6 +188,8 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
 
   // IDS store state
   const document = useViewerStore((s) => s.idsDocument);
+  const auditReport = useViewerStore((s) => s.idsAuditReport);
+  const auditing = useViewerStore((s) => s.idsAuditing);
   const report = useViewerStore((s) => s.idsValidationReport);
   const loading = useViewerStore((s) => s.idsLoading);
   const progress = useViewerStore((s) => s.idsProgress);
@@ -190,6 +204,8 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
   // IDS store actions
   const setIdsDocument = useViewerStore((s) => s.setIdsDocument);
   const clearIdsDocument = useViewerStore((s) => s.clearIdsDocument);
+  const setIdsAuditReport = useViewerStore((s) => s.setIdsAuditReport);
+  const setIdsAuditing = useViewerStore((s) => s.setIdsAuditing);
   const setIdsValidationReport = useViewerStore((s) => s.setIdsValidationReport);
   const clearIdsValidationReport = useViewerStore((s) => s.clearIdsValidationReport);
   const setIdsProgress = useViewerStore((s) => s.setIdsProgress);
@@ -249,22 +265,84 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
   // ============================================================================
 
   const loadIDS = useCallback((xmlContent: string) => {
+    setIdsLoading(true);
+    setIdsError(null);
+    setIdsAuditing(true);
+    // Clear the previous audit/document up front so a re-load with a
+    // malformed file doesn't show stale issues from the previous one.
+    setIdsAuditReport(null);
+
+    // Try to parse synchronously so the panel switches into "document
+    // loaded" mode immediately. Capture any parse error but DON'T early-
+    // return — the auditor's permissive shim has its own parser and can
+    // still surface structured `E_PARSE_XML` / `E_XSD_*` issues even
+    // when the strict parser threw.
+    let parsed: IDSDocument | null = null;
+    let parseErrorMessage: string | null = null;
     try {
-      setIdsLoading(true);
-      setIdsError(null);
-
-      const doc = parseIDS(xmlContent);
-      setIdsDocument(doc);
-
-      console.info(`[IDS] Loaded: "${doc.info.title}" (${doc.specifications.length} specifications)`);
+      parsed = parseIDS(xmlContent);
+      setIdsDocument(parsed);
+      console.info(
+        `[IDS] Loaded: "${parsed.info.title}" (${parsed.specifications.length} specifications)`
+      );
     } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to parse IDS file';
-      setIdsError(message);
+      // Drop any previously-loaded document so the panel shows the
+      // empty state with the new audit, not the stale prior content.
+      setIdsDocument(null);
+      // Preserve the underlying detail (e.g. xmldom's
+      // "unexpected token at line N column M") instead of just the
+      // top-level "Invalid XML format" — that's the actionable bit.
+      if (err instanceof IDSParseError) {
+        parseErrorMessage = err.details
+          ? `${err.message}: ${err.details}`
+          : err.message;
+      } else {
+        parseErrorMessage =
+          err instanceof Error ? err.message : 'Failed to parse IDS file';
+      }
       console.error('[IDS] Parse error:', err);
     } finally {
       setIdsLoading(false);
     }
-  }, [setIdsDocument, setIdsLoading, setIdsError]);
+
+    // Always run the audit, even on parse failure. The permissive
+    // shim handles malformed XML gracefully and produces a single
+    // `E_PARSE_XML` issue plus whatever else it can salvage.
+    void auditIDSDocument(xmlContent)
+      .then((report) => {
+        setIdsAuditReport(report);
+        // If parse failed but the audit succeeded with no errors,
+        // something is internally inconsistent — keep the parse error
+        // visible. If the audit also reported errors (almost always the
+        // case on parse failure), the panel will surface those rich
+        // issues alongside / instead of the bare error string.
+        if (parseErrorMessage && report.issues.length === 0) {
+          setIdsError(parseErrorMessage);
+        } else if (parseErrorMessage) {
+          // Audit has structured issues — clear the bare-string error
+          // so the panel relies on the audit summary as the source of
+          // truth (it carries the same information in richer form).
+          setIdsError(null);
+        }
+        if (report.status === 'error') {
+          console.warn(
+            `[IDS] Audit found ${
+              report.issues.filter((i) => i.severity === 'error').length
+            } error(s) in the IDS document`
+          );
+        }
+      })
+      .catch((auditErr) => {
+        // Audit itself crashed — non-fatal but unusual. Clear the audit
+        // and fall back to whatever parse error we collected.
+        console.error('[IDS] Audit failed:', auditErr);
+        setIdsAuditReport(null);
+        if (parseErrorMessage) setIdsError(parseErrorMessage);
+      })
+      .finally(() => {
+        setIdsAuditing(false);
+      });
+  }, [setIdsDocument, setIdsLoading, setIdsError, setIdsAuditReport, setIdsAuditing]);
 
   const loadIDSFile = useCallback(async (file: File) => {
     try {
@@ -830,6 +908,8 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
   return {
     // State
     document,
+    auditReport,
+    auditing,
     report,
     loading,
     progress,

package/src/hooks/useIfcFederation.ts

@@ -10,7 +10,7 @@
  * Extracted from useIfc.ts for better separation of concerns
  */
 
-import { useCallback } from 'react';
+import { useCallback, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { useViewerStore, type FederatedModel, type SchemaVersion } from '../store.js';
 import {
@@ -40,7 +40,9 @@ import {
 } from './ingest/pointCloudIngest.js';
 import { getGlobalRenderer } from './useBCF.js';
 import { readNativeFile, type NativeFileHandle } from '../services/file-dialog.js';
-import { getEffectiveGeoreference, type GeorefMutationDataLike } from '../lib/geo/effective-georef.js';
+import { getEffectiveGeoreference, getEffectiveHorizontalScale, type GeorefMutationDataLike } from '../lib/geo/effective-georef.js';
+import { acquireFederationLoadSlot, releaseFederationLoadSlot } from './federationLoadGate.js';
+import { acquireFileBuffer } from '../utils/acquireFileBuffer.js';
 
 function isNativeFileHandle(file: File | NativeFileHandle): file is NativeFileHandle {
   return typeof (file as NativeFileHandle).path === 'string';
@@ -81,10 +83,14 @@ function getMapUnitScale(georef: ModelGeoref): number {
   return georef.projectedCRS.mapUnitScale ?? georef.lengthUnitScale ?? 1;
 }
 
-function getAxis(conversion: MapConversion): { a: number; o: number; scale: number; denom: number } {
+function getAxis(georef: ModelGeoref): { a: number; o: number; scale: number; denom: number } {
+  const conversion = georef.mapConversion;
   const a = conversion.xAxisAbscissa ?? 1;
   const o = conversion.xAxisOrdinate ?? 0;
-  const scale = conversion.scale ?? 1;
+  // Use the effective horizontal scale: viewer geometry is already in metres,
+  // so applying IfcMapConversion.Scale raw would double-scale — see issue #595.
+  const mapUnitScale = georef.projectedCRS.mapUnitScale ?? georef.lengthUnitScale ?? 1;
+  const scale = getEffectiveHorizontalScale(conversion.scale, mapUnitScale, georef.lengthUnitScale ?? 1);
   const denom = Math.max(a * a + o * o, 1e-12);
   return { a, o, scale, denom };
 }
@@ -151,8 +157,8 @@ function updateBounds(bounds: ReturnType<typeof emptyBounds>, x: number, y: numb
 function buildGeorefAlignmentTransform(source: ModelGeoref, reference: ModelGeoref): AffineTransform3D | null {
   const sourceConv = source.mapConversion;
   const refConv = reference.mapConversion;
-  const sourceAxis = getAxis(sourceConv);
-  const refAxis = getAxis(refConv);
+  const sourceAxis = getAxis(source);
+  const refAxis = getAxis(reference);
   const refDenom = refAxis.scale * refAxis.denom;
   if (Math.abs(refDenom) < 1e-12) return null;
 
@@ -372,6 +378,13 @@ export function useIfcFederation() {
     findModelForGlobalId: s.findModelForGlobalId,
   })));
 
+  // Per-call ownership token. Each addModel() bumps this; state writes
+  // (loading/error/progress) in the catch block must compare back to
+  // their captured value before mutating, so a cancelled load A doesn't
+  // overwrite progress for a newer load B that started after A's abort.
+  // Mirrors the same pattern in useIfcLoader.ts.
+  const loadSessionRef = useRef(0);
+
   /**
    * Add a model to the federation (multi-model support)
    * Uses FederationRegistry to assign unique ID offsets - BULLETPROOF against ID collisions
@@ -389,6 +402,16 @@ export function useIfcFederation() {
   ): Promise<string | null> => {
     const modelId = options?.modelId ?? crypto.randomUUID();
     const addStart = performance.now();
+    // Bump the per-call ownership token first so that any error path
+    // (including the load gate) can compare against this captured value
+    // before mutating shared loading/error/progress state.
+    const currentSession = ++loadSessionRef.current;
+    // Memory-aware load gate: if a previous federation load is still in
+    // flight on this tab and admitting this one would exceed the device
+    // memory budget, wait until headroom frees. Single-file loads never
+    // wait. See `federationLoadGate.ts` for the budget formula. (#600)
+    const fileSizeForGateMB = (typeof (file as File).size === 'number' ? (file as File).size : 0) / (1024 * 1024);
+    const gateSlot = await acquireFederationLoadSlot(fileSizeForGateMB);
     try {
       // IMPORTANT: Before adding a new model, check if there's a legacy model
       // (loaded via loadFile) that's not in the Map yet. If so, migrate it first.
@@ -439,10 +462,24 @@ export function useIfcFederation() {
       setError(null);
       setProgress({ phase: 'Loading file', percent: 0 });
 
-      // Read file from disk
-      const buffer = isNativeFileHandle(file)
-        ? toExactArrayBuffer(await readNativeFile(file.path))
-        : await file.arrayBuffer();
+      // Read file from disk. The browser path streams files above
+      // `STREAM_SAB_THRESHOLD` directly into a SharedArrayBuffer, eliminating
+      // the doubled peak (ArrayBuffer + SAB) of `await file.arrayBuffer()`
+      // when the geometry pipeline copies into its own SAB. The native path
+      // still reads via Tauri's Rust IPC because it bounds memory differently.
+      // (#600)
+      let buffer: ArrayBuffer;
+      if (isNativeFileHandle(file)) {
+        buffer = toExactArrayBuffer(await readNativeFile(file.path));
+      } else {
+        // The cast preserves the previous ArrayBuffer-shaped contract for
+        // every downstream consumer. When the underlying store is a SAB,
+        // downstream code only ever reads bytes via `new Uint8Array(buffer)`
+        // / `new DataView(buffer)`, both of which work on either backing
+        // store. The cast is purely type-system; runtime is identical.
+        const acquired = await acquireFileBuffer(file as File);
+        buffer = acquired.buffer as ArrayBuffer;
+      }
       const fileSizeMB = buffer.byteLength / (1024 * 1024);
 
       // Detect point cloud formats first — we never run them through
@@ -461,7 +498,7 @@ export function useIfcFederation() {
       // depends on persisting it onto the FederatedModel record.
       let pointCloudHandleId: number | undefined;
 
-      if (format === 'las' || format === 'laz' || format === 'ply' || format === 'pcd' || format === 'e57') {
+      if (format === 'las' || format === 'laz' || format === 'ply' || format === 'pcd' || format === 'e57' || format === 'pts' || format === 'xyz') {
         const renderer = getGlobalRenderer();
         if (!renderer) {
           setError('Renderer not initialised — try again after the viewer mounts.');
@@ -482,11 +519,25 @@ export function useIfcFederation() {
           onProgress: setProgress,
           onAssetCountDelta: incCount,
         });
+        // Expose cancellation while the stream is in-flight. Capture
+        // the canceller as a named ref so the cleanup can verify the
+        // store still points at us before clearing — a second
+        // addModel() that began before this one settles must not lose
+        // its Cancel button to our finally block.
+        const { setActiveStreamCanceller } = useViewerStore.getState();
+        const cancelStream = () => ingest.streamHandle.cancel();
+        setActiveStreamCanceller(cancelStream);
         // ingest.done rejects on stream errors; ingestPointCloud's onError
         // callback already calls removePointCloudAsset + incCount(-1), so
         // the outer catch must NOT repeat that cleanup or the count goes
         // negative when other point clouds are still loaded.
-        await ingest.done;
+        try {
+          await ingest.done;
+        } finally {
+          if (useViewerStore.getState().activeStreamCanceller === cancelStream) {
+            setActiveStreamCanceller(null);
+          }
+        }
         parsedDataStore = ingest.dataStore;
         parsedGeometry = ingest.geometryResult;
         schemaVersion = ingest.schemaVersion;
@@ -652,10 +703,31 @@ export function useIfcFederation() {
       return modelId;
 
     } catch (err) {
+      // Only mutate shared loading/error/progress state if our session
+      // is still the active one. A second addModel() that started after
+      // we were cancelled has already taken over the spinner — we must
+      // not overwrite it with our "Cancelled" state.
+      const isCurrent = loadSessionRef.current === currentSession;
+      // User-initiated cancel surfaces as an AbortError. Map it to a
+      // benign "Cancelled" state so the federated path matches the
+      // single-model loader rather than reporting a parse failure.
+      if (err instanceof DOMException && err.name === 'AbortError') {
+        console.log('[useIfc] addModel cancelled by user');
+        if (isCurrent) {
+          setError(null);
+          setProgress({ phase: 'Cancelled', percent: 0 });
+          setLoading(false);
+        }
+        return null;
+      }
       console.error('[useIfc] addModel failed:', err);
-      setError(err instanceof Error ? err.message : 'Unknown error');
-      setLoading(false);
+      if (isCurrent) {
+        setError(err instanceof Error ? err.message : 'Unknown error');
+        setLoading(false);
+      }
       return null;
+    } finally {
+      releaseFederationLoadSlot(gateSlot);
     }
   }, [setLoading, setError, setProgress, setIfcDataStore, setGeometryResult, storeAddModel, hasModels, registerModelOffset]);
 
@@ -864,7 +936,10 @@ export function useIfcFederation() {
       return;
     }
 
-    // Check that all files are IFCX format and read buffers
+    // Check that all files are IFCX format and read buffers.
+    // IFCX is JSON; SAB streaming would force a SAB→scratch copy in
+    // safeUtf8Decode + retain the scratch (net worse peak than ArrayBuffer).
+    // Keep on file.arrayBuffer().
     const buffers: Array<{ buffer: ArrayBuffer; name: string }> = [];
     for (const file of files) {
       const buffer = await file.arrayBuffer();
@@ -918,7 +993,10 @@ export function useIfcFederation() {
       return;
     }
 
-    // Read new overlay buffers
+    // Read new overlay buffers.
+    // IFCX is JSON; SAB streaming would force a SAB→scratch copy in
+    // safeUtf8Decode + retain the scratch (net worse peak than ArrayBuffer).
+    // Keep on file.arrayBuffer().
     const newBuffers: Array<{ buffer: ArrayBuffer; name: string }> = [];
     for (const file of files) {
       const buffer = await file.arrayBuffer();