@ifc-lite/viewer 1.17.3 → 1.17.6

package/src/hooks/useIfcFederation.ts

@@ -13,19 +13,304 @@
 import { useCallback } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { useViewerStore, type FederatedModel, type SchemaVersion } from '../store.js';
-import { IfcParser, detectFormat, parseIfcx, parseFederatedIfcx, type IfcDataStore, type FederatedIfcxParseResult } from '@ifc-lite/parser';
-import { GeometryProcessor, GeometryQuality, type MeshData, type CoordinateInfo } from '@ifc-lite/geometry';
+import {
+  detectFormat,
+  parseFederatedIfcx,
+  type IfcDataStore,
+  type FederatedIfcxParseResult,
+  type MapConversion,
+  type ProjectedCRS,
+} from '@ifc-lite/parser';
+import type { CoordinateInfo, MeshData } from '@ifc-lite/geometry';
 import { IfcQuery } from '@ifc-lite/query';
 import { buildSpatialIndexGuarded } from '../utils/loadingUtils.js';
-import { loadGLBToMeshData } from '@ifc-lite/cache';
-
 import { getDynamicBatchConfig } from '../utils/ifcConfig.js';
+import { calculateMeshBounds, createCoordinateInfo } from '../utils/localParsingUtils.js';
 import {
-  calculateMeshBounds,
-  createCoordinateInfo,
-  calculateStoreyHeights,
-  normalizeColor,
-} from '../utils/localParsingUtils.js';
+  convertIfcxMeshes,
+  getMaxExpressId,
+  parseGlbViewerModel,
+  parseIfcxViewerModel,
+  parseStepBufferViewerModel,
+} from './ingest/viewerModelIngest.js';
+import { readNativeFile, type NativeFileHandle } from '../services/file-dialog.js';
+import { getEffectiveGeoreference, type GeorefMutationDataLike } from '../lib/geo/effective-georef.js';
+
+function isNativeFileHandle(file: File | NativeFileHandle): file is NativeFileHandle {
+  return typeof (file as NativeFileHandle).path === 'string';
+}
+
+function toExactArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes.buffer;
+  }
+  return bytes.slice().buffer;
+}
+
+type FederatedGeometryResult = NonNullable<FederatedModel['geometryResult']>;
+
+interface ModelGeoref {
+  mapConversion: MapConversion;
+  projectedCRS: ProjectedCRS;
+  lengthUnitScale: number;
+  coordinateInfo?: CoordinateInfo;
+}
+
+interface AffineTransform3D {
+  m00: number;
+  m01: number;
+  m02: number;
+  tx: number;
+  m10: number;
+  m11: number;
+  m12: number;
+  ty: number;
+  m20: number;
+  m21: number;
+  m22: number;
+  tz: number;
+}
+
+function getMapUnitScale(georef: ModelGeoref): number {
+  return georef.projectedCRS.mapUnitScale ?? georef.lengthUnitScale ?? 1;
+}
+
+function getAxis(conversion: MapConversion): { a: number; o: number; scale: number; denom: number } {
+  const a = conversion.xAxisAbscissa ?? 1;
+  const o = conversion.xAxisOrdinate ?? 0;
+  const scale = conversion.scale ?? 1;
+  const denom = Math.max(a * a + o * o, 1e-12);
+  return { a, o, scale, denom };
+}
+
+function extractModelGeoref(
+  dataStore: IfcDataStore,
+  coordinateInfo?: CoordinateInfo,
+  mutations?: GeorefMutationDataLike,
+): ModelGeoref | null {
+  const georef = getEffectiveGeoreference(dataStore, coordinateInfo, mutations);
+  if (!georef?.mapConversion || !georef.projectedCRS?.name) return null;
+  return {
+    mapConversion: georef.mapConversion,
+    projectedCRS: georef.projectedCRS,
+    lengthUnitScale: georef.lengthUnitScale,
+    coordinateInfo,
+  };
+}
+
+function crsKey(crs: ProjectedCRS): string {
+  return `${crs.name ?? ''}|${crs.geodeticDatum ?? ''}|${crs.mapProjection ?? ''}|${crs.mapZone ?? ''}`.toUpperCase();
+}
+
+function canAlignInSameProjectedCrs(a: ModelGeoref, b: ModelGeoref): boolean {
+  return crsKey(a.projectedCRS) === crsKey(b.projectedCRS);
+}
+
+function totalYupOffset(coordinateInfo?: CoordinateInfo): { x: number; y: number; z: number } {
+  const shift = coordinateInfo?.originShift ?? { x: 0, y: 0, z: 0 };
+  const rtc = coordinateInfo?.wasmRtcOffset;
+  const rtcYup = rtc ? { x: rtc.x, y: rtc.z, z: -rtc.y } : { x: 0, y: 0, z: 0 };
+  return {
+    x: shift.x + rtcYup.x,
+    y: shift.y + rtcYup.y,
+    z: shift.z + rtcYup.z,
+  };
+}
+
+function emptyBounds() {
+  return {
+    min: { x: Infinity, y: Infinity, z: Infinity },
+    max: { x: -Infinity, y: -Infinity, z: -Infinity },
+  };
+}
+
+function zeroBounds() {
+  return {
+    min: { x: 0, y: 0, z: 0 },
+    max: { x: 0, y: 0, z: 0 },
+  };
+}
+
+function updateBounds(bounds: ReturnType<typeof emptyBounds>, x: number, y: number, z: number): boolean {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return false;
+  bounds.min.x = Math.min(bounds.min.x, x);
+  bounds.min.y = Math.min(bounds.min.y, y);
+  bounds.min.z = Math.min(bounds.min.z, z);
+  bounds.max.x = Math.max(bounds.max.x, x);
+  bounds.max.y = Math.max(bounds.max.y, y);
+  bounds.max.z = Math.max(bounds.max.z, z);
+  return true;
+}
+
+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 refDenom = refAxis.scale * refAxis.denom;
+  if (Math.abs(refDenom) < 1e-12) return null;
+
+  const sourceMapUnitScale = getMapUnitScale(source);
+  const refMapUnitScale = getMapUnitScale(reference);
+  const sourceOffset = totalYupOffset(source.coordinateInfo);
+  const refOffset = totalYupOffset(reference.coordinateInfo);
+
+  const eVx = sourceAxis.scale * sourceAxis.a;
+  const eVz = sourceAxis.scale * sourceAxis.o;
+  const eC = sourceConv.eastings * sourceMapUnitScale
+    + sourceAxis.scale * (sourceAxis.a * sourceOffset.x + sourceAxis.o * sourceOffset.z)
+    - refConv.eastings * refMapUnitScale;
+
+  const nVx = sourceAxis.scale * sourceAxis.o;
+  const nVz = -sourceAxis.scale * sourceAxis.a;
+  const nC = sourceConv.northings * sourceMapUnitScale
+    + sourceAxis.scale * (sourceAxis.o * sourceOffset.x - sourceAxis.a * sourceOffset.z)
+    - refConv.northings * refMapUnitScale;
+
+  const hC = sourceConv.orthogonalHeight * sourceMapUnitScale
+    + sourceOffset.y
+    - refConv.orthogonalHeight * refMapUnitScale;
+
+  const invRefDenom = 1 / refDenom;
+  const xVx = (refAxis.a * eVx + refAxis.o * nVx) * invRefDenom;
+  const xVz = (refAxis.a * eVz + refAxis.o * nVz) * invRefDenom;
+  const xC = (refAxis.a * eC + refAxis.o * nC) * invRefDenom - refOffset.x;
+
+  const yVx = (-refAxis.o * eVx + refAxis.a * nVx) * invRefDenom;
+  const yVz = (-refAxis.o * eVz + refAxis.a * nVz) * invRefDenom;
+  const yC = (-refAxis.o * eC + refAxis.a * nC) * invRefDenom;
+
+  return {
+    m00: xVx,
+    m01: 0,
+    m02: xVz,
+    tx: xC,
+    m10: 0,
+    m11: 1,
+    m12: 0,
+    ty: hC - refOffset.y,
+    m20: -yVx,
+    m21: 0,
+    m22: -yVz,
+    tz: -yC - refOffset.z,
+  };
+}
+
+function isIdentityTransform(transform: AffineTransform3D): boolean {
+  const eps = 1e-7;
+  return Math.abs(transform.m00 - 1) < eps
+    && Math.abs(transform.m01) < eps
+    && Math.abs(transform.m02) < eps
+    && Math.abs(transform.tx) < eps
+    && Math.abs(transform.m10) < eps
+    && Math.abs(transform.m11 - 1) < eps
+    && Math.abs(transform.m12) < eps
+    && Math.abs(transform.ty) < eps
+    && Math.abs(transform.m20) < eps
+    && Math.abs(transform.m21) < eps
+    && Math.abs(transform.m22 - 1) < eps
+    && Math.abs(transform.tz) < eps;
+}
+
+function applyAlignmentTransformAndUpdateBounds(
+  geometry: FederatedGeometryResult,
+  transform: AffineTransform3D,
+  referenceInfo?: CoordinateInfo,
+): void {
+  const bounds = emptyBounds();
+  let found = false;
+
+  for (const mesh of geometry.meshes) {
+    const positions = mesh.positions;
+    for (let i = 0; i < positions.length; i += 3) {
+      const x = positions[i];
+      const y = positions[i + 1];
+      const z = positions[i + 2];
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
+        continue;
+      }
+
+      const alignedX = transform.m00 * x + transform.m01 * y + transform.m02 * z + transform.tx;
+      const alignedY = transform.m10 * x + transform.m11 * y + transform.m12 * z + transform.ty;
+      const alignedZ = transform.m20 * x + transform.m21 * y + transform.m22 * z + transform.tz;
+      positions[i] = alignedX;
+      positions[i + 1] = alignedY;
+      positions[i + 2] = alignedZ;
+      found = updateBounds(bounds, alignedX, alignedY, alignedZ) || found;
+    }
+
+    // Rotate normals by the transform's 3×3 linear part (translation omitted)
+    // and renormalize. CRS alignment is a rigid rotation, so the linear part
+    // itself is the correct transform for normals; degenerate results from
+    // zero-length or non-finite inputs are left in place.
+    const normals = mesh.normals;
+    if (normals && normals.length >= 3) {
+      for (let i = 0; i < normals.length; i += 3) {
+        const nx = normals[i];
+        const ny = normals[i + 1];
+        const nz = normals[i + 2];
+        if (!Number.isFinite(nx) || !Number.isFinite(ny) || !Number.isFinite(nz)) {
+          continue;
+        }
+        const rx = transform.m00 * nx + transform.m01 * ny + transform.m02 * nz;
+        const ry = transform.m10 * nx + transform.m11 * ny + transform.m12 * nz;
+        const rz = transform.m20 * nx + transform.m21 * ny + transform.m22 * nz;
+        const len = Math.sqrt(rx * rx + ry * ry + rz * rz);
+        if (!Number.isFinite(len) || len < 1e-12) {
+          continue;
+        }
+        normals[i] = rx / len;
+        normals[i + 1] = ry / len;
+        normals[i + 2] = rz / len;
+      }
+    }
+  }
+
+  geometry.coordinateInfo = {
+    originShift: referenceInfo?.originShift ?? { x: 0, y: 0, z: 0 },
+    originalBounds: found ? bounds : zeroBounds(),
+    shiftedBounds: found ? bounds : zeroBounds(),
+    hasLargeCoordinates: referenceInfo?.hasLargeCoordinates ?? false,
+    wasmRtcOffset: referenceInfo?.wasmRtcOffset,
+    buildingRotation: referenceInfo?.buildingRotation,
+  };
+}
+
+function alignGeometryToReferenceGeoref(
+  geometry: FederatedGeometryResult,
+  source: ModelGeoref,
+  reference: ModelGeoref,
+): boolean {
+  if (!canAlignInSameProjectedCrs(source, reference)) {
+    return false;
+  }
+
+  const transform = buildGeorefAlignmentTransform(source, reference);
+  if (!transform) {
+    return false;
+  }
+
+  if (!isIdentityTransform(transform)) {
+    applyAlignmentTransformAndUpdateBounds(geometry, transform, reference.coordinateInfo);
+  }
+  return true;
+}
+
+function findReferenceGeorefModel(): ModelGeoref | null {
+  const state = useViewerStore.getState();
+  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) {
+    if (!model.ifcDataStore || !model.geometryResult) continue;
+    const georef = extractModelGeoref(
+      model.ifcDataStore,
+      model.geometryResult.coordinateInfo,
+      state.georefMutations.get(modelId),
+    );
+    if (georef) return georef;
+  }
+  return null;
+}
 
 /**
  * Extended data store type for IFCX (IFC5) files.
@@ -43,41 +328,6 @@ export interface IfcxDataStore extends IfcDataStore {
   _layerInfo?: Array<{ id: string; name: string; meshCount: number }>;
 }
 
-/** Shape of raw meshes returned from IFCX parsers before conversion to MeshData */
-interface RawIfcxMesh {
-  expressId?: number;
-  express_id?: number;
-  id?: number;
-  positions: Float32Array | number[];
-  indices: Uint32Array | number[];
-  normals: Float32Array | number[];
-  color?: [number, number, number, number] | [number, number, number];
-  ifcType?: string;
-  ifc_type?: string;
-}
-
-/**
- * Convert raw IFCX parser meshes to viewer-compatible MeshData[].
- * Ensures typed arrays, normalizes colors, and filters out empty meshes.
- */
-function convertIfcxMeshes(rawMeshes: RawIfcxMesh[]): MeshData[] {
-  return rawMeshes.map((m) => {
-    const positions = m.positions instanceof Float32Array ? m.positions : new Float32Array(m.positions || []);
-    const indices = m.indices instanceof Uint32Array ? m.indices : new Uint32Array(m.indices || []);
-    const normals = m.normals instanceof Float32Array ? m.normals : new Float32Array(m.normals || []);
-    const color = normalizeColor(m.color);
-
-    return {
-      expressId: m.expressId ?? m.express_id ?? m.id ?? 0,
-      positions,
-      indices,
-      normals,
-      color,
-      ifcType: m.ifcType ?? m.ifc_type ?? 'IfcProduct',
-    };
-  }).filter((m) => m.positions.length > 0 && m.indices.length > 0);
-}
-
 /**
  * Hook providing multi-model federation operations
  * Includes addModel, removeModel, federated IFCX loading, overlay management,
@@ -122,12 +372,17 @@ export function useIfcFederation() {
    * Returns the model ID on success, null on failure
    */
   const addModel = useCallback(async (
-    file: File,
-    options?: { name?: string }
+    file: File | NativeFileHandle,
+    options?: {
+      name?: string;
+      modelId?: string;
+      loadedAt?: number;
+      visible?: boolean;
+      collapsed?: boolean;
+    }
   ): Promise<string | null> => {
-    const modelId = crypto.randomUUID();
-    const totalStartTime = performance.now();
-
+    const modelId = options?.modelId ?? crypto.randomUUID();
+    const addStart = performance.now();
     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.
@@ -167,11 +422,11 @@ export function useIfcFederation() {
           schemaVersion: 'IFC4',
           loadedAt: Date.now() - 1000,
           fileSize: 0,
+          sourceFile: undefined,
           idOffset: legacyOffset,
           maxExpressId: legacyMaxExpressId,
         };
         storeAddModel(legacyModel);
-        console.log(`[useIfc] Migrated legacy model "${legacyModel.name}" to federation (offset: ${legacyOffset}, maxId: ${legacyMaxExpressId})`);
       }
 
       setLoading(true);
@@ -179,180 +434,93 @@ export function useIfcFederation() {
       setProgress({ phase: 'Loading file', percent: 0 });
 
       // Read file from disk
-      const buffer = await file.arrayBuffer();
+      const buffer = isNativeFileHandle(file)
+        ? toExactArrayBuffer(await readNativeFile(file.path))
+        : await file.arrayBuffer();
       const fileSizeMB = buffer.byteLength / (1024 * 1024);
 
       // Detect file format
       const format = detectFormat(buffer);
 
       let parsedDataStore: IfcDataStore | null = null;
-      let parsedGeometry: { meshes: MeshData[]; totalVertices: number; totalTriangles: number; coordinateInfo: CoordinateInfo } | null = null;
+      let parsedGeometry: FederatedModel['geometryResult'] = null;
       let schemaVersion: SchemaVersion = 'IFC4';
 
-      // IFCX files must be parsed client-side
       if (format === 'ifcx') {
         setProgress({ phase: 'Parsing IFCX (client-side)', percent: 10 });
-
-        const ifcxResult = await parseIfcx(buffer, {
-          onProgress: (prog: { phase: string; percent: number }) => {
-            setProgress({ phase: `IFCX ${prog.phase}`, percent: 10 + (prog.percent * 0.8) });
-          },
-        });
-
-        // Convert IFCX meshes to viewer format
-        const meshes: MeshData[] = convertIfcxMeshes(ifcxResult.meshes);
-
-        // Check if this is an overlay-only IFCX file (no geometry)
-        if (meshes.length === 0 && ifcxResult.entityCount > 0) {
-          console.warn(`[useIfc] IFCX file "${file.name}" has no geometry - this is an overlay file.`);
-          setError(`"${file.name}" is an overlay file with no geometry. Please load it together with a base IFCX file (select all files at once for federated loading).`);
-          setLoading(false);
-          return null;
+        try {
+          const result = await parseIfcxViewerModel(buffer, setProgress);
+          parsedDataStore = result.dataStore;
+          parsedGeometry = result.geometryResult;
+          schemaVersion = result.schemaVersion;
+        } catch (error) {
+          if (error instanceof Error && error.message === 'overlay-only-ifcx') {
+            console.warn(`[useIfc] IFCX file "${file.name}" has no geometry - this is an overlay file.`);
+            setError(`"${file.name}" is an overlay file with no geometry. Please load it together with a base IFCX file (select all files at once for federated loading).`);
+            setLoading(false);
+            return null;
+          }
+          throw error;
         }
-
-        const { bounds, stats } = calculateMeshBounds(meshes);
-        const coordinateInfo = createCoordinateInfo(bounds);
-
-        parsedGeometry = {
-          meshes,
-          totalVertices: stats.totalVertices,
-          totalTriangles: stats.totalTriangles,
-          coordinateInfo,
-        };
-
-        parsedDataStore = {
-          fileSize: ifcxResult.fileSize,
-          schemaVersion: 'IFC5' as const,
-          entityCount: ifcxResult.entityCount,
-          parseTime: ifcxResult.parseTime,
-          source: new Uint8Array(buffer),
-          entityIndex: { byId: new Map(), byType: new Map() },
-          strings: ifcxResult.strings,
-          entities: ifcxResult.entities,
-          properties: ifcxResult.properties,
-          quantities: ifcxResult.quantities,
-          relationships: ifcxResult.relationships,
-          spatialHierarchy: ifcxResult.spatialHierarchy,
-        } as IfcxDataStore;
-
-        schemaVersion = 'IFC5';
-
       } else if (format === 'glb') {
-        // GLB files: parse directly to MeshData (geometry only, no IFC data model)
         setProgress({ phase: 'Parsing GLB', percent: 10 });
-
-        const meshes = loadGLBToMeshData(new Uint8Array(buffer));
-
-        if (meshes.length === 0) {
-          setError('GLB file contains no geometry');
-          setLoading(false);
-          return null;
-        }
-
-        const { bounds, stats } = calculateMeshBounds(meshes);
-        const coordinateInfo = createCoordinateInfo(bounds);
-
-        parsedGeometry = {
-          meshes,
-          totalVertices: stats.totalVertices,
-          totalTriangles: stats.totalTriangles,
-          coordinateInfo,
-        };
-
-        // Create a minimal data store for GLB (no IFC properties)
-        parsedDataStore = {
-          fileSize: buffer.byteLength,
-          schemaVersion: 'IFC4' as const,
-          entityCount: meshes.length,
-          parseTime: 0,
-          source: new Uint8Array(0),
-          entityIndex: { byId: new Map(), byType: new Map() },
-          strings: { getString: () => undefined, getStringId: () => undefined, count: 0 } as unknown as IfcDataStore['strings'],
-          entities: { count: 0, getId: () => 0, getType: () => 0, getName: () => undefined, getGlobalId: () => undefined } as unknown as IfcDataStore['entities'],
-          properties: { count: 0, getPropertiesForEntity: () => [], getPropertySetForEntity: () => [] } as unknown as IfcDataStore['properties'],
-          quantities: { count: 0, getQuantitiesForEntity: () => [] } as unknown as IfcDataStore['quantities'],
-          relationships: { count: 0, getRelationships: () => [], getRelated: () => [] } as unknown as IfcDataStore['relationships'],
-          spatialHierarchy: null as unknown as IfcDataStore['spatialHierarchy'],
-        } as unknown as IfcDataStore;
-
-        schemaVersion = 'IFC4'; // GLB doesn't have a schema version, use IFC4 as default
-
+        const result = await parseGlbViewerModel(buffer);
+        parsedDataStore = result.dataStore;
+        parsedGeometry = result.geometryResult;
+        schemaVersion = result.schemaVersion;
       } else {
-        // IFC4/IFC2X3 STEP format - use WASM parsing
         setProgress({ phase: 'Starting geometry streaming', percent: 10 });
 
-        const geometryProcessor = new GeometryProcessor({ quality: GeometryQuality.Balanced });
-        await geometryProcessor.init();
-
-        // Parse data model
-        const parser = new IfcParser();
-        const wasmApi = geometryProcessor.getApi();
-
-        const dataStorePromise = parser.parseColumnar(buffer, { wasmApi });
-
-        // Process geometry
-        const allMeshes: MeshData[] = [];
-        let finalCoordinateInfo: CoordinateInfo | null = null;
-        // Capture RTC offset from WASM for proper multi-model alignment
-        let capturedRtcOffset: { x: number; y: number; z: number } | null = null;
-
-        const dynamicBatchConfig = getDynamicBatchConfig(fileSizeMB);
-
-        for await (const event of geometryProcessor.processAdaptive(new Uint8Array(buffer), {
-          sizeThreshold: 2 * 1024 * 1024,
-          batchSize: dynamicBatchConfig,
-        })) {
-          switch (event.type) {
-            case 'batch': {
-              for (let i = 0; i < event.meshes.length; i++) allMeshes.push(event.meshes[i]);
-              finalCoordinateInfo = event.coordinateInfo ?? null;
-              const progressPercent = 10 + Math.min(80, (allMeshes.length / 1000) * 0.8);
-              setProgress({ phase: `Processing geometry (${allMeshes.length} meshes)`, percent: progressPercent });
-              break;
-            }
-            case 'rtcOffset': {
-              // Capture RTC offset from WASM for multi-model alignment
-              if (event.hasRtc) {
-                capturedRtcOffset = event.rtcOffset;
-              }
-              break;
-            }
-            case 'complete':
-              finalCoordinateInfo = event.coordinateInfo ?? null;
-              break;
-          }
-        }
-
-        parsedDataStore = await dataStorePromise;
-
-        // Calculate storey heights
-        if (parsedDataStore.spatialHierarchy && parsedDataStore.spatialHierarchy.storeyHeights.size === 0 && parsedDataStore.spatialHierarchy.storeyElevations.size > 1) {
-          const calculatedHeights = calculateStoreyHeights(parsedDataStore.spatialHierarchy.storeyElevations);
-          for (const [storeyId, height] of calculatedHeights) {
-            parsedDataStore.spatialHierarchy.storeyHeights.set(storeyId, height);
-          }
-        }
-
-        parsedGeometry = {
-          meshes: allMeshes,
-          totalVertices: allMeshes.reduce((sum, m) => sum + m.positions.length / 3, 0),
-          totalTriangles: allMeshes.reduce((sum, m) => sum + m.indices.length / 3, 0),
-          coordinateInfo: finalCoordinateInfo || createCoordinateInfo(calculateMeshBounds(allMeshes).bounds),
-        };
-
-        // Store captured RTC offset in coordinate info for multi-model alignment
-        if (parsedGeometry.coordinateInfo && capturedRtcOffset) {
-          parsedGeometry.coordinateInfo.wasmRtcOffset = capturedRtcOffset;
+        // For federated models: use the first model's RTC offset so all models
+        // share the same coordinate origin. This ensures pixel-perfect alignment
+        // without error-prone delta adjustments.
+        let sharedRtcOffset: { x: number; y: number; z: number } | undefined;
+        const existingModelsForRtc = Array.from(useViewerStore.getState().models.values()) as FederatedModel[];
+        if (existingModelsForRtc.length > 0) {
+          const sorted = [...existingModelsForRtc].sort((a, b) => (a.loadedAt ?? 0) - (b.loadedAt ?? 0));
+          sharedRtcOffset = sorted.find(
+            (model) => model.geometryResult?.coordinateInfo?.wasmRtcOffset != null,
+          )?.geometryResult?.coordinateInfo?.wasmRtcOffset;
         }
 
-        schemaVersion = parsedDataStore.schemaVersion === 'IFC4X3' ? 'IFC4X3' :
-          parsedDataStore.schemaVersion === 'IFC4' ? 'IFC4' : 'IFC2X3';
+        const result = await parseStepBufferViewerModel({
+          fileName: file.name,
+          buffer,
+          fileSizeMB,
+          getDynamicBatchSize: getDynamicBatchConfig,
+          onProgress: setProgress,
+          sharedRtcOffset,
+        });
+        parsedDataStore = result.dataStore;
+        parsedGeometry = result.geometryResult;
+        schemaVersion = result.schemaVersion;
       }
 
       if (!parsedDataStore || !parsedGeometry) {
         throw new Error('Failed to parse file');
       }
 
+      const referenceGeoref = findReferenceGeorefModel();
+      // 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
+      // are silently ignored.
+      const parsedGeorefMutations = useViewerStore.getState().georefMutations.get(modelId);
+      const parsedGeoref = extractModelGeoref(
+        parsedDataStore,
+        parsedGeometry.coordinateInfo,
+        parsedGeorefMutations,
+      );
+      if (referenceGeoref && parsedGeoref) {
+        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.`,
+          );
+        }
+      }
+
       // =========================================================================
       // FEDERATION REGISTRY: Transform expressIds to globally unique IDs
       // This is the BULLETPROOF fix for multi-model ID collisions
@@ -361,15 +529,7 @@ export function useIfcFederation() {
       // Step 1: Find max expressId in this model
       // IMPORTANT: Use ALL entities from data store, not just meshes
       // Spatial containers (IfcProject, IfcSite, etc.) don't have geometry but need valid globalId resolution
-      const maxExpressIdFromMeshes = parsedGeometry.meshes.reduce((max, m) => Math.max(max, m.expressId), 0);
-      // FIXED: Use iteration instead of spread to avoid stack overflow with large Maps
-      let maxExpressIdFromEntities = 0;
-      if (parsedDataStore.entityIndex?.byId) {
-        for (const key of parsedDataStore.entityIndex.byId.keys()) {
-          if (key > maxExpressIdFromEntities) maxExpressIdFromEntities = key;
-        }
-      }
-      const maxExpressId = Math.max(maxExpressIdFromMeshes, maxExpressIdFromEntities);
+      const maxExpressId = getMaxExpressId(parsedDataStore, parsedGeometry.meshes);
 
       // Step 2: Register with federation registry to get unique offset
       const idOffset = registerModelOffset(modelId, maxExpressId);
@@ -384,74 +544,10 @@ export function useIfcFederation() {
       }
 
       // =========================================================================
-      // COORDINATE ALIGNMENT: Align new model with existing models using RTC delta
-      // WASM applies per-model RTC offsets. To align models from the same project,
-      // we calculate the difference in RTC offsets and apply it to the new model.
-      //
-      // RTC offset is in IFC coordinates (Z-up). After Z-up to Y-up conversion:
-      // - IFC X → WebGL X
-      // - IFC Y → WebGL -Z
-      // - IFC Z → WebGL Y (vertical)
+      // COORDINATE ALIGNMENT: All federated models use the same shared RTC offset
+      // (passed to WASM during parsing above), so no post-processing vertex
+      // adjustment is needed. All models are already in the same coordinate space.
       // =========================================================================
-      const existingModels = Array.from(useViewerStore.getState().models.values()) as FederatedModel[];
-      if (existingModels.length > 0) {
-        const firstModel = existingModels[0];
-        const firstRtc = firstModel.geometryResult?.coordinateInfo?.wasmRtcOffset;
-        const newRtc = parsedGeometry.coordinateInfo?.wasmRtcOffset;
-
-        // If both models have RTC offsets, use RTC delta for precise alignment
-        if (firstRtc && newRtc) {
-          // Calculate what adjustment is needed to align new model with first model
-          // First model: pos = original - firstRtc
-          // New model: pos = original - newRtc
-          // To align: newPos + adjustment = firstPos (assuming same original)
-          // adjustment = firstRtc - newRtc (add back new's RTC, subtract first's RTC)
-          const adjustX = firstRtc.x - newRtc.x;  // IFC X adjustment
-          const adjustY = firstRtc.y - newRtc.y;  // IFC Y adjustment
-          const adjustZ = firstRtc.z - newRtc.z;  // IFC Z adjustment (vertical)
-
-          // Convert to WebGL coordinates:
-          // IFC X → WebGL X (no change)
-          // IFC Y → WebGL -Z (swap and negate)
-          // IFC Z → WebGL Y (vertical)
-          const webglAdjustX = adjustX;
-          const webglAdjustY = adjustZ;   // IFC Z is WebGL Y (vertical)
-          const webglAdjustZ = -adjustY;  // IFC Y is WebGL -Z
-
-          const hasSignificantAdjust = Math.abs(webglAdjustX) > 0.01 ||
-                                        Math.abs(webglAdjustY) > 0.01 ||
-                                        Math.abs(webglAdjustZ) > 0.01;
-
-          if (hasSignificantAdjust) {
-            console.log(`[useIfc] Aligning model "${file.name}" using RTC adjustment: X=${webglAdjustX.toFixed(2)}m, Y=${webglAdjustY.toFixed(2)}m, Z=${webglAdjustZ.toFixed(2)}m`);
-
-            // Apply adjustment to all mesh vertices
-            // SUBTRACT adjustment: if firstRtc > newRtc, first was shifted MORE,
-            // so new model needs to be shifted in same direction (subtract more)
-            for (const mesh of parsedGeometry.meshes) {
-              const positions = mesh.positions;
-              for (let i = 0; i < positions.length; i += 3) {
-                positions[i] -= webglAdjustX;
-                positions[i + 1] -= webglAdjustY;
-                positions[i + 2] -= webglAdjustZ;
-              }
-            }
-
-            // Update coordinate info bounds
-            if (parsedGeometry.coordinateInfo) {
-              parsedGeometry.coordinateInfo.shiftedBounds.min.x -= webglAdjustX;
-              parsedGeometry.coordinateInfo.shiftedBounds.max.x -= webglAdjustX;
-              parsedGeometry.coordinateInfo.shiftedBounds.min.y -= webglAdjustY;
-              parsedGeometry.coordinateInfo.shiftedBounds.max.y -= webglAdjustY;
-              parsedGeometry.coordinateInfo.shiftedBounds.min.z -= webglAdjustZ;
-              parsedGeometry.coordinateInfo.shiftedBounds.max.z -= webglAdjustZ;
-            }
-          }
-        } else {
-          // No RTC info - can't align reliably. This happens with old cache entries.
-          console.warn(`[useIfc] Cannot align "${file.name}" - missing RTC offset. Clear cache and reload.`);
-        }
-      }
 
       // Build spatial index AFTER ID offset + RTC alignment so it stores
       // correct globalIds and final world-space positions.
@@ -463,11 +559,12 @@ export function useIfcFederation() {
         name: options?.name ?? file.name,
         ifcDataStore: parsedDataStore,
         geometryResult: parsedGeometry,
-        visible: true,
-        collapsed: hasModels(), // Collapse if not first model
+        visible: options?.visible ?? true,
+        collapsed: options?.collapsed ?? hasModels(), // Collapse if not first model
         schemaVersion,
-        loadedAt: Date.now(),
+        loadedAt: options?.loadedAt ?? Date.now(),
         fileSize: buffer.byteLength,
+        sourceFile: file,
         idOffset,
         maxExpressId,
       };
@@ -481,9 +578,7 @@ export function useIfcFederation() {
 
       setProgress({ phase: 'Complete', percent: 100 });
       setLoading(false);
-
-      const totalElapsedMs = performance.now() - totalStartTime;
-      console.log(`[useIfc] ✓ Added model ${file.name} (${fileSizeMB.toFixed(1)}MB) | ${totalElapsedMs.toFixed(0)}ms`);
+      console.log(`[ifc-lite] Added model ${file.name} (${fileSizeMB.toFixed(1)}MB) in ${(performance.now() - addStart).toFixed(0)}ms`);
 
       return modelId;
 
@@ -519,7 +614,7 @@ export function useIfcFederation() {
    */
   const getQueryForModel = useCallback((modelId: string): IfcQuery | null => {
     const model = getModel(modelId);
-    if (!model) return null;
+    if (!model || !model.ifcDataStore) return null;
     return new IfcQuery(model.ifcDataStore);
   }, [getModel]);
 
@@ -684,10 +779,6 @@ export function useIfcFederation() {
         storeAddModel(layerModel);
       }
 
-      console.log(`[useIfc] Federated IFCX loaded: ${layers.length} layers, ${result.entityCount} entities, ${meshes.length} meshes`);
-      console.log(`[useIfc] Composition stats: ${result.compositionStats.inheritanceResolutions} inheritance resolutions, ${result.compositionStats.crossLayerReferences} cross-layer refs`);
-      console.log(`[useIfc] Layers in Models panel: ${layers.map((l: { name: string }) => l.name).join(', ')}`);
-
       setProgress({ phase: 'Complete', percent: 100 });
       setLoading(false);
     } catch (err: unknown) {
@@ -753,7 +844,6 @@ export function useIfcFederation() {
       ) as ArrayBuffer;
 
       existingBuffers = [{ buffer: sourceBuffer, name: modelName }];
-      console.log(`[useIfc] Converting single IFCX file "${modelName}" to federated mode`);
     } else {
       setError('Cannot add overlays: no IFCX model loaded');
       return;
@@ -774,9 +864,6 @@ export function useIfcFederation() {
     // Combine: existing layers + new overlays (new overlays are strongest = first in array)
     const allBuffers = [...newBuffers, ...existingBuffers];
 
-    console.log(`[useIfc] Re-composing federated IFCX with ${newBuffers.length} new overlay(s)`);
-    console.log(`[useIfc] Total layers: ${allBuffers.length} (${existingBuffers.length} existing + ${newBuffers.length} new)`);
-
     await loadFederatedIfcxFromBuffers(allBuffers, { resetState: false });
   }, [setError, loadFederatedIfcxFromBuffers]);