@ifc-lite/viewer 1.21.0 → 1.22.1

package/src/hooks/useBCF.ts

@@ -33,7 +33,7 @@ import {
 
 interface UseBCFOptions {
   /** Ref to the WebGPU canvas for snapshot capture */
-  canvasRef?: React.RefObject<HTMLCanvasElement>;
+  canvasRef?: React.RefObject<HTMLCanvasElement | null>;
   /** Ref to the renderer for camera access */
   rendererRef?: React.RefObject<Renderer | null>;
 }
@@ -55,7 +55,7 @@ interface UseBCFResult {
   /** Capture a snapshot from the canvas */
   captureSnapshot: () => Promise<string | null>;
   /** Set the canvas ref for snapshot capture */
-  setCanvasRef: (ref: React.RefObject<HTMLCanvasElement>) => void;
+  setCanvasRef: (ref: React.RefObject<HTMLCanvasElement | null>) => void;
   /** Set the renderer ref for camera access */
   setRendererRef: (ref: React.RefObject<Renderer | null>) => void;
 }
@@ -64,13 +64,13 @@ interface UseBCFResult {
 // Canvas Reference Store (module-level for cross-component access)
 // ============================================================================
 
-let globalCanvasRef: React.RefObject<HTMLCanvasElement> | null = null;
+let globalCanvasRef: React.RefObject<HTMLCanvasElement | null> | null = null;
 let globalRendererRef: React.RefObject<Renderer | null> | null = null;
 
 /**
  * Set the global canvas reference (called by ViewportContainer)
  */
-export function setGlobalCanvasRef(ref: React.RefObject<HTMLCanvasElement>): void {
+export function setGlobalCanvasRef(ref: React.RefObject<HTMLCanvasElement | null>): void {
   globalCanvasRef = ref;
 }
 
@@ -101,7 +101,7 @@ export function clearGlobalRefs(): void {
 // ============================================================================
 
 export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
-  const localCanvasRef = useRef<React.RefObject<HTMLCanvasElement> | null>(
+  const localCanvasRef = useRef<React.RefObject<HTMLCanvasElement | null> | null>(
     options.canvasRef ?? null
   );
   const localRendererRef = useRef<React.RefObject<Renderer | null> | null>(
@@ -146,7 +146,7 @@ export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
   /**
    * Set the canvas ref for snapshot capture
    */
-  const setCanvasRef = useCallback((ref: React.RefObject<HTMLCanvasElement>) => {
+  const setCanvasRef = useCallback((ref: React.RefObject<HTMLCanvasElement | null>) => {
     localCanvasRef.current = ref;
   }, []);
 

package/src/hooks/useCameraTickSubscription.ts

@@ -0,0 +1,62 @@
+/* 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 { useEffect, useRef, useState } from 'react';
+import type { CameraViewpoint } from '@/store/types';
+
+type GetViewpoint = (() => CameraViewpoint | null) | undefined;
+
+/**
+ * Wake a React component on camera moves without subscribing to
+ * every camera tick. The three tool overlays (Gizmo, WallEndpoint,
+ * Split) all need to re-project anchor points whenever the viewport
+ * changes, but the camera tick is intentionally non-React (see
+ * `Viewport.tsx` `updateCameraRotationRealtime`) so a manual RAF
+ * loop is required.
+ *
+ * The hook:
+ *   - returns a `frameTick` integer that increments only when the
+ *     viewpoint signature changes (position, target, fov,
+ *     projectionMode, orthoSize). Include this in your dependency
+ *     arrays to force re-render on real camera motion.
+ *   - bails when `active` is false to keep idle overlays free of
+ *     per-frame work.
+ *
+ * Note: orthoSize + projectionMode are part of the signature so
+ * ortho-zoom-only changes (which leave position / target / fov
+ * untouched) still wake the subscriber.
+ */
+export function useCameraTickSubscription(
+  getViewpoint: GetViewpoint,
+  active: boolean,
+): number {
+  const [frameTick, setFrameTick] = useState(0);
+  const lastViewpointRef = useRef<string>('');
+  const rafRef = useRef<number | null>(null);
+
+  useEffect(() => {
+    if (!active) return;
+    let mounted = true;
+    const tick = () => {
+      if (!mounted) return;
+      const vp = getViewpoint?.();
+      if (vp) {
+        const sig = `${vp.position.x},${vp.position.y},${vp.position.z},${vp.target.x},${vp.target.y},${vp.target.z},${vp.fov},${vp.projectionMode},${vp.orthoSize ?? ''}`;
+        if (sig !== lastViewpointRef.current) {
+          lastViewpointRef.current = sig;
+          setFrameTick((n) => (n + 1) % 1_000_000);
+        }
+      }
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      mounted = false;
+      if (rafRef.current !== null) cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    };
+  }, [active, getViewpoint]);
+
+  return frameTick;
+}

package/src/hooks/useIfc.ts

@@ -81,6 +81,7 @@ export function useIfc() {
     addIfcxOverlays,
     findModelForEntity,
     resolveGlobalId,
+    realignFederation,
   } = useIfcFederation();
 
   // Memoize query to prevent recreation on every render
@@ -130,5 +131,8 @@ export function useIfc() {
     findModelForEntity,  // Find model by globalId
     resolveGlobalId,     // Convert globalId -> (modelId, originalExpressId)
     toGlobalId,          // Convert (modelId, expressId) -> globalId
+
+    // Federation alignment (cross-CRS reprojection + anchor management)
+    realignFederation,   // Re-bake every model's geometry against the current anchor
   };
 }

package/src/hooks/useIfcFederation.ts

@@ -41,6 +41,10 @@ import {
 import { getGlobalRenderer } from './useBCF.js';
 import { readNativeFile, type NativeFileHandle } from '../services/file-dialog.js';
 import { getEffectiveGeoreference, getEffectiveHorizontalScale, type GeorefMutationDataLike } from '../lib/geo/effective-georef.js';
+import { resolveMapUnitToMetreScale } from '../lib/geo/geo-scale.js';
+import { resolveProjection } from '../lib/geo/reproject.js';
+import { toast } from '../components/ui/toast.js';
+import proj4 from 'proj4';
 import { acquireFederationLoadSlot, releaseFederationLoadSlot } from './federationLoadGate.js';
 import { acquireFileBuffer } from '../utils/acquireFileBuffer.js';
 
@@ -80,7 +84,7 @@ interface AffineTransform3D {
 }
 
 function getMapUnitScale(georef: ModelGeoref): number {
-  return georef.projectedCRS.mapUnitScale ?? georef.lengthUnitScale ?? 1;
+  return resolveMapUnitToMetreScale(georef.projectedCRS.mapUnitScale, georef.lengthUnitScale ?? 1);
 }
 
 function getAxis(georef: ModelGeoref): { a: number; o: number; scale: number; denom: number } {
@@ -89,7 +93,7 @@ function getAxis(georef: ModelGeoref): { a: number; o: number; scale: number; de
   const o = conversion.xAxisOrdinate ?? 0;
   // 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 mapUnitScale = resolveMapUnitToMetreScale(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 };
@@ -288,28 +292,202 @@ function applyAlignmentTransformAndUpdateBounds(
   };
 }
 
-function alignGeometryToReferenceGeoref(
+/**
+ * Reproject every vertex from a source model's georeference into the reference
+ * model's viewer-space frame using proj4 between the two projected CRSs.
+ *
+ * Used for federated loads where models declare different IfcProjectedCRSs
+ * (e.g. EPSG:28992 + EPSG:7415 mixed RD/NAP Dutch sets, or EPSG:25831 UTM +
+ * EPSG:28992 mixed). The pipeline per vertex:
+ *
+ *   viewer(Yup)  ──(source RTC/shift, axis swap)──▶  IFC(Zup, source)
+ *   IFC(source)  ──(source MapConversion)──────────▶  source projected (eS,nS,hS)
+ *   projected    ──(proj4: srcDef → refDef)────────▶  reference projected (eR,nR)
+ *   projected    ──(reference MapConversion inverse)▶  IFC(Zup, reference)
+ *   IFC(ref)     ──(axis swap, reference RTC/shift)─▶  viewer(Yup, reference frame)
+ *
+ * Vertical: height passes through unchanged. Browser-side proj4 has no vertical
+ * datum transforms (no NTv2/gtx grids), so cross-CRS vertical mismatches are
+ * left for the user to resolve via the per-model orthogonalHeight editor.
+ *
+ * Normals are NOT rotated. Cross-CRS rotations between projected systems in the
+ * same locality are sub-degree, and recomputing per-vertex would require a
+ * Jacobian per mesh — acceptable trade-off for now, document if it bites.
+ */
+async function alignGeometryAcrossCrs(
   geometry: FederatedGeometryResult,
   source: ModelGeoref,
   reference: ModelGeoref,
-): boolean {
-  if (!canAlignInSameProjectedCrs(source, reference)) {
-    return false;
+): Promise<boolean> {
+  const sourceProjDef = await resolveProjection(source.projectedCRS);
+  const refProjDef = await resolveProjection(reference.projectedCRS);
+  if (!sourceProjDef || !refProjDef) return false;
+
+  const sourceMapUnitScale = getMapUnitScale(source);
+  const refMapUnitScale = getMapUnitScale(reference);
+  const sourceAxis = getAxis(source);
+  const refAxis = getAxis(reference);
+  const sourceOffset = totalYupOffset(source.coordinateInfo);
+  const refOffset = totalYupOffset(reference.coordinateInfo);
+
+  const refDenom = refAxis.scale * refAxis.denom;
+  if (Math.abs(refDenom) < 1e-12) return false;
+  const invRefDenom = 1 / refDenom;
+
+  const sourceConv = source.mapConversion;
+  const refConv = reference.mapConversion;
+
+  const bounds = emptyBounds();
+  let found = false;
+  let projFailures = 0;
+  let attempts = 0;
+  let firstProjError: unknown = null;
+
+  for (const mesh of geometry.meshes) {
+    const positions = mesh.positions;
+    for (let i = 0; i < positions.length; i += 3) {
+      const vx = positions[i];
+      const vy = positions[i + 1];
+      const vz = positions[i + 2];
+      if (!Number.isFinite(vx) || !Number.isFinite(vy) || !Number.isFinite(vz)) continue;
+
+      // viewer(Y-up, source-local) → world(Y-up) → IFC(Z-up, source)
+      const wx = vx + sourceOffset.x;
+      const wy = vy + sourceOffset.y;
+      const wz = vz + sourceOffset.z;
+      const ifcXs = wx;
+      const ifcYs = -wz;
+      const ifcZs = wy;
+
+      // IFC(source) → source projected (apply source MapConversion)
+      const eS = sourceConv.eastings * sourceMapUnitScale
+        + sourceAxis.scale * (sourceAxis.a * ifcXs - sourceAxis.o * ifcYs);
+      const nS = sourceConv.northings * sourceMapUnitScale
+        + sourceAxis.scale * (sourceAxis.o * ifcXs + sourceAxis.a * ifcYs);
+      const hS = sourceConv.orthogonalHeight * sourceMapUnitScale + ifcZs;
+
+      // source projected → reference projected via proj4
+      attempts += 1;
+      let eR: number;
+      let nR: number;
+      try {
+        const projected = proj4(sourceProjDef, refProjDef, [eS, nS]);
+        eR = projected[0];
+        nR = projected[1];
+      } catch (error) {
+        projFailures += 1;
+        if (firstProjError == null) firstProjError = error;
+        continue;
+      }
+      if (!Number.isFinite(eR) || !Number.isFinite(nR)) {
+        projFailures += 1;
+        continue;
+      }
+      // Height transformed under identity (no vertical datum hop in browser).
+      const hR = hS;
+
+      // reference projected → IFC(reference): invert reference MapConversion
+      const dE = eR - refConv.eastings * refMapUnitScale;
+      const dN = nR - refConv.northings * refMapUnitScale;
+      const ifcXr = invRefDenom * (refAxis.a * dE + refAxis.o * dN);
+      const ifcYr = invRefDenom * (-refAxis.o * dE + refAxis.a * dN);
+      const ifcZr = hR - refConv.orthogonalHeight * refMapUnitScale;
+
+      // IFC(Z-up, reference) → world(Y-up) → viewer(Y-up, reference-local)
+      const refWorldX = ifcXr;
+      const refWorldY = ifcZr;
+      const refWorldZ = -ifcYr;
+      const alignedX = refWorldX - refOffset.x;
+      const alignedY = refWorldY - refOffset.y;
+      const alignedZ = refWorldZ - refOffset.z;
+
+      positions[i] = alignedX;
+      positions[i + 1] = alignedY;
+      positions[i + 2] = alignedZ;
+      found = updateBounds(bounds, alignedX, alignedY, alignedZ) || found;
+    }
   }
 
-  const transform = buildGeorefAlignmentTransform(source, reference);
-  if (!transform) {
+  if (!found) {
+    console.warn(
+      `[ifc-lite] Cross-CRS alignment failed: ${projFailures}/${attempts} `
+      + `vertex transforms failed for ${source.projectedCRS.name} → ${reference.projectedCRS.name}; `
+      + 'no vertices were successfully reprojected. Leaving geometry untouched.',
+      firstProjError,
+    );
     return false;
   }
 
-  if (!isIdentityTransform(transform)) {
-    applyAlignmentTransformAndUpdateBounds(geometry, transform, reference.coordinateInfo);
+  geometry.coordinateInfo = {
+    originShift: reference.coordinateInfo?.originShift ?? { x: 0, y: 0, z: 0 },
+    originalBounds: bounds,
+    shiftedBounds: bounds,
+    hasLargeCoordinates: reference.coordinateInfo?.hasLargeCoordinates ?? false,
+    wasmRtcOffset: reference.coordinateInfo?.wasmRtcOffset,
+    buildingRotation: reference.coordinateInfo?.buildingRotation,
+  };
+
+  if (projFailures > 0) {
+    console.warn(
+      `[ifc-lite] Cross-CRS alignment: ${projFailures}/${attempts} vertex transforms `
+      + `failed from ${source.projectedCRS.name} to ${reference.projectedCRS.name}. `
+      + 'Those vertices are left at their original positions.',
+      firstProjError,
+    );
   }
   return true;
 }
 
-function findReferenceGeorefModel(): ModelGeoref | null {
+export type FederationAlignmentStatus = 'same-crs' | 'reprojected' | 'identity' | 'failed';
+
+/**
+ * Route alignment to the right strategy based on whether the source and
+ * reference share a projected CRS. Returns a status describing how the model
+ * was placed in the federation, suitable for surfacing in the UI.
+ */
+async function alignGeometryToReference(
+  geometry: FederatedGeometryResult,
+  source: ModelGeoref,
+  reference: ModelGeoref,
+): Promise<FederationAlignmentStatus> {
+  if (canAlignInSameProjectedCrs(source, reference)) {
+    const transform = buildGeorefAlignmentTransform(source, reference);
+    if (!transform) return 'failed';
+    if (isIdentityTransform(transform)) return 'identity';
+    applyAlignmentTransformAndUpdateBounds(geometry, transform, reference.coordinateInfo);
+    return 'same-crs';
+  }
+  const ok = await alignGeometryAcrossCrs(geometry, source, reference);
+  return ok ? 'reprojected' : 'failed';
+}
+
+/**
+ * Select the federation anchor model.
+ *
+ * Resolution order:
+ *   1. `anchorModelIdOverride` from the store, if it points to a loaded model
+ *      with a valid georeference.
+ *   2. Earliest `loadedAt` model with a valid georeference (the default — gives
+ *      a stable anchor across loads while letting the user override when they
+ *      want a different model to drive the world frame).
+ */
+function findReferenceGeorefModel(): { modelId: string; georef: ModelGeoref } | null {
   const state = useViewerStore.getState();
+  const override = state.anchorModelIdOverride;
+  if (override) {
+    const model = state.models.get(override) as FederatedModel | undefined;
+    if (model?.ifcDataStore && model.geometryResult) {
+      const georef = extractModelGeoref(
+        model.ifcDataStore,
+        model.geometryResult.coordinateInfo,
+        state.georefMutations.get(override),
+      );
+      if (georef) return { modelId: override, georef };
+    }
+    // Fall through if the override no longer resolves — keeps loads
+    // recoverable even if the user removed the anchor they had pinned.
+  }
+
   const modelEntries = Array.from(state.models.entries()) as Array<[string, FederatedModel]>;
   const sorted = [...modelEntries].sort(([, a], [, b]) => (a.loadedAt ?? 0) - (b.loadedAt ?? 0));
   for (const [modelId, model] of sorted) {
@@ -319,7 +497,7 @@ function findReferenceGeorefModel(): ModelGeoref | null {
       model.geometryResult.coordinateInfo,
       state.georefMutations.get(modelId),
     );
-    if (georef) return georef;
+    if (georef) return { modelId, georef };
   }
   return null;
 }
@@ -596,7 +774,8 @@ export function useIfcFederation() {
         throw new Error('Failed to parse file');
       }
 
-      const referenceGeoref = findReferenceGeorefModel();
+      const referenceSelection = findReferenceGeorefModel();
+      const referenceGeoref = referenceSelection?.georef ?? null;
       // Include any georef edits the user has already saved for this model so
       // that a reload after editing reflects the new placement. Without this,
       // extractModelGeoref reads only the raw parsed metadata and mutations
@@ -607,14 +786,42 @@ export function useIfcFederation() {
         parsedGeometry.coordinateInfo,
         parsedGeorefMutations,
       );
+      // Cache of pre-alignment vertex positions/normals for realignFederation().
+      // Only populated when alignment actually runs, so single-model loads pay
+      // no memory cost. See FederatedModel.preAlignmentPositions for rationale.
+      let preAlignmentPositions: Float32Array[] | undefined;
+      let preAlignmentNormals: (Float32Array | undefined)[] | undefined;
+      let preAlignmentCoordinateInfo: CoordinateInfo | undefined;
+      let federationAlignmentStatus: FederatedModel['federationAlignmentStatus'] = 'none';
+
       if (referenceGeoref && parsedGeoref) {
+        // referenceSelection.modelId !== modelId always holds — the anchor was
+        // already in the store before this addModel call.
         setProgress({ phase: 'Aligning georeferenced model', percent: 90 });
-        const aligned = alignGeometryToReferenceGeoref(parsedGeometry, parsedGeoref, referenceGeoref);
-        if (!aligned) {
-          console.warn(
-            `[ifc-lite] Skipped georeferenced federation alignment for "${file.name}" because CRS differs from the reference model.`,
+        preAlignmentPositions = parsedGeometry.meshes.map((mesh) => new Float32Array(mesh.positions));
+        preAlignmentNormals = parsedGeometry.meshes.map((mesh) =>
+          mesh.normals && mesh.normals.length > 0 ? new Float32Array(mesh.normals) : undefined,
+        );
+        preAlignmentCoordinateInfo = parsedGeometry.coordinateInfo;
+        const status = await alignGeometryToReference(parsedGeometry, parsedGeoref, referenceGeoref);
+        federationAlignmentStatus = status;
+        if (status === 'reprojected') {
+          toast.info(
+            `Reprojected "${file.name}" from ${parsedGeoref.projectedCRS.name} `
+            + `to ${referenceGeoref.projectedCRS.name} for federation alignment.`,
+          );
+        } else if (status === 'failed') {
+          toast.error(
+            `Could not align "${file.name}" with the federation anchor — `
+            + `${parsedGeoref.projectedCRS.name} → ${referenceGeoref.projectedCRS.name} `
+            + 'reprojection failed. The model is shown in its own local frame and may '
+            + 'appear at the wrong real-world position.',
           );
         }
+      } else if (parsedGeoref) {
+        // This load is itself the federation anchor (first georeferenced model
+        // in the federation, or the only one). Surface that to the UI.
+        federationAlignmentStatus = 'anchor';
       }
 
       // =========================================================================
@@ -687,14 +894,21 @@ export function useIfcFederation() {
         idOffset,
         maxExpressId,
         pointCloudHandleId,
+        preAlignmentPositions,
+        preAlignmentNormals,
+        preAlignmentCoordinateInfo,
+        federationAlignmentStatus,
       };
 
       // Add to store
       storeAddModel(federatedModel);
 
-      // Also set legacy single-model state for backward compatibility
-      setIfcDataStore(parsedDataStore);
-      setGeometryResult(parsedGeometry);
+      // Don't touch the legacy top-level setters for added models. When this
+      // is the first model, modelSlice.addModel already mirrored it into the
+      // top-level fields. When subsequent models are added, activeModelId
+      // stays on the first model — writing here would alias the new model's
+      // data into the active (first) model's per-model entry and cause both
+      // viewport slots to render the same mesh (issue #661).
 
       setProgress({ phase: 'Complete', percent: 100 });
       setLoading(false);
@@ -731,6 +945,139 @@ export function useIfcFederation() {
     }
   }, [setLoading, setError, setProgress, setIfcDataStore, setGeometryResult, storeAddModel, hasModels, registerModelOffset]);
 
+  /**
+   * Re-apply federation alignment using the currently selected anchor
+   * (`anchorModelIdOverride` from the store, falling back to earliest-loaded).
+   *
+   * Restores each non-anchor model's geometry from its `preAlignmentPositions`
+   * snapshot, then re-runs alignment against the new anchor. Skips models that
+   * have no snapshot — those were loaded standalone and would need a reload to
+   * participate in re-alignment. Updates `federationAlignmentStatus` on every
+   * touched model so the UI badges reflect the new state.
+   *
+   * Per user preference: this is an explicit operation, not auto-triggered by
+   * remove/reorder/anchor-change. Wire it to a "Re-align federation" button.
+   */
+  const realignFederation = useCallback(async (): Promise<void> => {
+    const state = useViewerStore.getState();
+    const allModels = Array.from(state.models.entries()) as Array<[string, FederatedModel]>;
+    if (allModels.length === 0) {
+      toast.info('No models loaded — nothing to re-align.');
+      return;
+    }
+
+    const referenceSelection = findReferenceGeorefModel();
+    if (!referenceSelection) {
+      toast.error('Cannot re-align: no model with valid georeferencing.');
+      return;
+    }
+    const { modelId: anchorModelId, georef: anchorGeoref } = referenceSelection;
+
+    let aligned = 0;
+    let reprojected = 0;
+    let skipped = 0;
+    let failed = 0;
+
+    const updateModel = state.updateModel;
+
+    for (const [modelId, model] of allModels) {
+      if (modelId === anchorModelId) {
+        if (model.federationAlignmentStatus !== 'anchor') {
+          updateModel(modelId, { federationAlignmentStatus: 'anchor' });
+        }
+        continue;
+      }
+      if (!model.geometryResult || !model.ifcDataStore) {
+        skipped += 1;
+        continue;
+      }
+
+      // Lazy-snapshot: a model that joined before federation existed (or as
+      // the original anchor of a previous federation) was never re-baked, so
+      // its current vertices ARE its pre-alignment positions. Take a snapshot
+      // before we mutate them so subsequent re-aligns can restore.
+      let snapshots = model.preAlignmentPositions;
+      let normalSnapshots = model.preAlignmentNormals;
+      let snapshotInfo = model.preAlignmentCoordinateInfo;
+      if (!snapshots || !snapshotInfo) {
+        snapshots = model.geometryResult.meshes.map((m) => new Float32Array(m.positions));
+        normalSnapshots = model.geometryResult.meshes.map((m) =>
+          m.normals && m.normals.length > 0 ? new Float32Array(m.normals) : undefined,
+        );
+        snapshotInfo = model.geometryResult.coordinateInfo;
+      }
+
+      // Restore vertices and normals to pre-alignment state. Normals must be
+      // restored too because applyAlignmentTransformAndUpdateBounds rotates
+      // them in place — without restoring, repeated re-aligns would compound
+      // rotations and drift lighting/shading.
+      const meshes = model.geometryResult.meshes;
+      const restoreCount = Math.min(meshes.length, snapshots.length);
+      for (let i = 0; i < restoreCount; i += 1) {
+        meshes[i].positions = new Float32Array(snapshots[i]);
+        if (normalSnapshots) {
+          const snap = normalSnapshots[i];
+          if (snap) {
+            meshes[i].normals = new Float32Array(snap);
+          }
+        }
+      }
+      model.geometryResult.coordinateInfo = {
+        ...snapshotInfo,
+        originalBounds: { ...snapshotInfo.originalBounds },
+        shiftedBounds: { ...snapshotInfo.shiftedBounds },
+      };
+
+      const parsedGeoref = extractModelGeoref(
+        model.ifcDataStore,
+        model.geometryResult.coordinateInfo,
+        state.georefMutations.get(modelId),
+      );
+      if (!parsedGeoref) {
+        updateModel(modelId, {
+          preAlignmentPositions: snapshots,
+          preAlignmentNormals: normalSnapshots,
+          preAlignmentCoordinateInfo: snapshotInfo,
+          federationAlignmentStatus: 'none',
+        });
+        skipped += 1;
+        continue;
+      }
+
+      const status = await alignGeometryToReference(model.geometryResult, parsedGeoref, anchorGeoref);
+      updateModel(modelId, {
+        preAlignmentPositions: snapshots,
+        preAlignmentNormals: normalSnapshots,
+        preAlignmentCoordinateInfo: snapshotInfo,
+        federationAlignmentStatus: status,
+      });
+      if (status === 'reprojected') reprojected += 1;
+      else if (status === 'failed') failed += 1;
+      else aligned += 1;
+    }
+
+    // Signal that mesh content was mutated in place — forces the merged-mesh
+    // cache in ViewportContainer to rebuild AND the streaming hook to clear
+    // the WebGPU scene and re-upload buffers. Without this, the success toast
+    // fires but the visible model doesn't move because the GPU still has the
+    // old vertex positions cached.
+    if (aligned + reprojected > 0) {
+      useViewerStore.getState().bumpGeometryContentVersion();
+    }
+
+    const messageParts: string[] = [];
+    if (aligned > 0) messageParts.push(`${aligned} aligned`);
+    if (reprojected > 0) messageParts.push(`${reprojected} reprojected`);
+    if (skipped > 0) messageParts.push(`${skipped} skipped`);
+    if (failed > 0) messageParts.push(`${failed} failed`);
+    const summary = messageParts.length > 0 ? messageParts.join(', ') : 'no changes needed';
+    if (failed > 0) {
+      toast.error(`Federation re-aligned against "${anchorGeoref.projectedCRS.name}": ${summary}.`);
+    } else {
+      toast.success(`Federation re-aligned against "${anchorGeoref.projectedCRS.name}": ${summary}.`);
+    }
+  }, []);
+
   /**
    * Remove a model from the federation
    */
@@ -1040,6 +1387,7 @@ export function useIfcFederation() {
     addIfcxOverlays,
     findModelForEntity,
     resolveGlobalId,
+    realignFederation,
   };
 }