@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/components/viewer/bcf/BCFTopicDetail.tsx

@@ -215,12 +215,12 @@ export function BCFTopicDetail({
                           <img
                             src={vp.snapshot}
                             alt="Viewpoint"
-                            className="w-full aspect-video object-cover cursor-pointer hover:opacity-90 transition-opacity"
+                            className="w-full object-contain cursor-pointer hover:opacity-90 transition-opacity"
                             onClick={() => onActivateViewpoint(vp)}
                           />
                         ) : (
                           <div
-                            className="w-full aspect-video bg-muted flex items-center justify-center cursor-pointer hover:bg-muted/80 transition-colors"
+                            className="w-full aspect-video bg-muted flex items-center justify-center cursor-pointer hover:bg-muted/80 transition-colors min-h-[120px]"
                             onClick={() => onActivateViewpoint(vp)}
                           >
                             <Camera className="h-6 w-6 text-muted-foreground" />
@@ -294,7 +294,7 @@ export function BCFTopicDetail({
                         <img
                           src={associatedViewpoint.snapshot}
                           alt="Associated viewpoint"
-                          className="w-full h-16 object-cover"
+                          className="w-full max-h-24 object-contain bg-muted"
                         />
                       </div>
                     )}
@@ -327,7 +327,7 @@ export function BCFTopicDetail({
               <img
                 src={selectedViewpoint.snapshot}
                 alt="Selected viewpoint"
-                className="w-10 h-10 object-cover rounded"
+                className="w-12 h-10 object-contain rounded bg-muted"
               />
             )}
             <div className="flex-1 min-w-0">

package/src/components/viewer/chat/ModelSelector.tsx

@@ -4,11 +4,14 @@
 
 /**
  * ModelSelector — dropdown to pick the LLM model.
- * Free models available to everyone. Pro models show cost indicator and lock icon.
+ * Free models available to everyone via server proxy.
+ * BYOK models selectable always — greyed out with lock icon when key is missing,
+ * fully styled when key is configured. Selecting a locked model triggers the
+ * inline key prompt in ChatPanel.
  */
 
-import { useCallback } from 'react';
-import { Lock } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+import { Check, Key } from 'lucide-react';
 import {
   Select,
   SelectContent,
@@ -17,27 +20,43 @@ import {
   SelectValue,
 } from '@/components/ui/select';
 import { useViewerStore } from '@/store';
-import { FREE_MODELS, PRO_MODELS, getModelById } from '@/lib/llm/models';
-
-interface ModelSelectorProps {
-  /** Whether the user has a pro subscription */
-  hasPro?: boolean;
-}
+import { FREE_MODELS, getModelById, getByokModelsForSource } from '@/lib/llm/models';
+import type { LLMModel } from '@/lib/llm/types';
+import { hasAnthropicKey, hasOpenaiKey, subscribeApiKeys } from '@/services/api-keys';
 
 function formatContextWindow(tokens: number): string {
   if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(0)}M`;
   return `${(tokens / 1_000).toFixed(0)}K`;
 }
 
-export function ModelSelector({ hasPro = false }: ModelSelectorProps) {
+function CostBadge({ cost }: { cost?: LLMModel['cost'] }) {
+  if (!cost) return null;
+  const color = cost === '$$$' ? 'text-amber-500' : cost === '$$' ? 'text-blue-500' : 'text-emerald-500';
+  return <span className={`text-[10px] font-mono ${color}`}>{cost}</span>;
+}
+
+export function ModelSelector() {
   const activeModel = useViewerStore((s) => s.chatActiveModel);
   const setActiveModel = useViewerStore((s) => s.setChatActiveModel);
 
+  const [hasAnthropic, setHasAnthropic] = useState(hasAnthropicKey);
+  const [hasOpenai, setHasOpenai] = useState(hasOpenaiKey);
+
+  useEffect(() => {
+    const refresh = () => {
+      setHasAnthropic(hasAnthropicKey());
+      setHasOpenai(hasOpenaiKey());
+    };
+    return subscribeApiKeys(refresh);
+  }, []);
+
   const handleChange = useCallback((value: string) => {
     setActiveModel(value);
   }, [setActiveModel]);
 
   const current = getModelById(activeModel);
+  const anthropicModels = getByokModelsForSource('anthropic');
+  const openaiModels = getByokModelsForSource('openai');
 
   return (
     <Select value={activeModel} onValueChange={handleChange}>
@@ -45,57 +64,74 @@ export function ModelSelector({ hasPro = false }: ModelSelectorProps) {
         <SelectValue>
           <span className="truncate flex items-center gap-1">
             {current?.name ?? activeModel}
-            {current?.cost && (
-              <span className={`text-[10px] font-mono ${
-                current.cost === '$$$' ? 'text-amber-500' : current.cost === '$$' ? 'text-blue-500' : 'text-emerald-500'
-              }`}>
-                {current.cost}
-              </span>
-            )}
+            <CostBadge cost={current?.cost} />
           </span>
         </SelectValue>
       </SelectTrigger>
       <SelectContent>
         {/* Free tier */}
-        <div className="px-2 py-1 text-[10px] font-semibold text-muted-foreground uppercase tracking-wider">
-          Free
-        </div>
-        {FREE_MODELS.map((m) => (
-          <SelectItem key={m.id} value={m.id} className="text-xs">
-            <span className="flex items-center gap-1.5">
-              <span>{m.name}</span>
-              <span className="text-muted-foreground text-[10px]">{m.provider}</span>
-              <span className="text-muted-foreground/50 text-[10px]">{formatContextWindow(m.contextWindow)}</span>
-            </span>
-          </SelectItem>
-        ))}
+        {FREE_MODELS.length > 0 && (
+          <>
+            <div className="px-2 py-1 text-[10px] font-semibold text-muted-foreground uppercase tracking-wider">
+              Free
+            </div>
+            {FREE_MODELS.map((m) => (
+              <SelectItem key={m.id} value={m.id} className="text-xs">
+                <span className="flex items-center gap-1.5">
+                  <span>{m.name}</span>
+                  <span className="text-muted-foreground text-[10px]">{m.provider}</span>
+                  <span className="text-muted-foreground/50 text-[10px]">{formatContextWindow(m.contextWindow)}</span>
+                </span>
+              </SelectItem>
+            ))}
+          </>
+        )}
+
+        {/* Anthropic BYOK */}
+        {anthropicModels.length > 0 && (
+          <>
+            <div className="px-2 py-1 mt-1 text-[10px] font-semibold text-muted-foreground uppercase tracking-wider flex items-center gap-1">
+              Anthropic
+              {hasAnthropic
+                ? <Check className="h-2.5 w-2.5 text-emerald-500" />
+                : <Key className="h-2.5 w-2.5" />
+              }
+            </div>
+            {anthropicModels.map((m) => (
+              <SelectItem key={m.id} value={m.id} className={`text-xs ${!hasAnthropic ? 'opacity-50' : ''}`}>
+                <span className="flex items-center gap-1.5">
+                  <span>{m.name}</span>
+                  <CostBadge cost={m.cost} />
+                  <span className="text-muted-foreground/50 text-[10px]">{formatContextWindow(m.contextWindow)}</span>
+                  {!hasAnthropic && <Key className="h-3 w-3 text-muted-foreground/50" />}
+                </span>
+              </SelectItem>
+            ))}
+          </>
+        )}
 
-        {/* Pro tier */}
-        <div className="px-2 py-1 mt-1 text-[10px] font-semibold text-muted-foreground uppercase tracking-wider flex items-center gap-1">
-          Pro
-        </div>
-        {PRO_MODELS.map((m) => (
-          <SelectItem
-            key={m.id}
-            value={m.id}
-            disabled={!hasPro}
-            className="text-xs"
-          >
-            <span className="flex items-center gap-1.5">
-              <span>{m.name}</span>
-              <span className="text-muted-foreground text-[10px]">{m.provider}</span>
-              {m.cost && (
-                <span className={`text-[10px] font-mono ${
-                  m.cost === '$$$' ? 'text-amber-500' : m.cost === '$$' ? 'text-blue-500' : 'text-emerald-500'
-                }`}>
-                  {m.cost}
+        {/* OpenAI BYOK */}
+        {openaiModels.length > 0 && (
+          <>
+            <div className="px-2 py-1 mt-1 text-[10px] font-semibold text-muted-foreground uppercase tracking-wider flex items-center gap-1">
+              OpenAI
+              {hasOpenai
+                ? <Check className="h-2.5 w-2.5 text-emerald-500" />
+                : <Key className="h-2.5 w-2.5" />
+              }
+            </div>
+            {openaiModels.map((m) => (
+              <SelectItem key={m.id} value={m.id} className={`text-xs ${!hasOpenai ? 'opacity-50' : ''}`}>
+                <span className="flex items-center gap-1.5">
+                  <span>{m.name}</span>
+                  <CostBadge cost={m.cost} />
+                  <span className="text-muted-foreground/50 text-[10px]">{formatContextWindow(m.contextWindow)}</span>
+                  {!hasOpenai && <Key className="h-3 w-3 text-muted-foreground/50" />}
                 </span>
-              )}
-              <span className="text-muted-foreground/50 text-[10px]">{formatContextWindow(m.contextWindow)}</span>
-              {!hasPro && <Lock className="h-3 w-3 text-muted-foreground/50" />}
-            </span>
-          </SelectItem>
-        ))}
+              </SelectItem>
+            ))}
+          </>
+        )}
       </SelectContent>
     </Select>
   );

package/src/components/viewer/lists/ListPanel.tsx

@@ -67,34 +67,27 @@ export function ListPanel({ onClose }: ListPanelProps) {
 
   const importInputRef = React.useRef<HTMLInputElement>(null);
 
-  // Collect all available data providers for multi-model support
-  const allProviders = useMemo(() => {
-    const providers: ListDataProvider[] = [];
+  // Build the {modelId, provider} pairs in a single pass so the two
+  // arrays can never drift out of alignment (skipping a model without
+  // an ifcDataStore must not shift every later model's provider index).
+  const modelProviderPairs = useMemo(() => {
+    const pairs: Array<{ modelId: string; provider: ListDataProvider }> = [];
     if (models.size > 0) {
-      for (const [, model] of models) {
-        providers.push(createListDataProvider(model.ifcDataStore));
+      for (const [modelId, model] of models) {
+        // Skip native-metadata models — they don't have a parsed
+        // IfcDataStore, so the list provider can't query them.
+        if (!model.ifcDataStore) continue;
+        pairs.push({ modelId, provider: createListDataProvider(model.ifcDataStore) });
       }
     } else if (ifcDataStore) {
-      providers.push(createListDataProvider(ifcDataStore));
+      pairs.push({ modelId: 'default', provider: createListDataProvider(ifcDataStore) });
     }
-    return providers;
+    return pairs;
   }, [models, ifcDataStore]);
 
-  const hasData = allProviders.length > 0;
+  const allProviders = useMemo(() => modelProviderPairs.map((p) => p.provider), [modelProviderPairs]);
 
-  // Build a stable map of modelId → provider index for execution
-  const modelProviderPairs = useMemo(() => {
-    const pairs: Array<{ modelId: string; provider: ListDataProvider }> = [];
-    if (models.size > 0) {
-      let i = 0;
-      for (const [modelId] of models) {
-        pairs.push({ modelId, provider: allProviders[i++] });
-      }
-    } else if (allProviders.length > 0) {
-      pairs.push({ modelId: 'default', provider: allProviders[0] });
-    }
-    return pairs;
-  }, [models, allProviders]);
+  const hasData = allProviders.length > 0;
 
   const handleExecuteList = useCallback((definition: ListDefinition) => {
     if (!hasData) return;

package/src/components/viewer/properties/GeoreferencingPanel.tsx

@@ -16,6 +16,9 @@ import { useViewerStore } from '@/store';
 import type { CoordinateInfo, GeometryResult } from '@ifc-lite/geometry';
 import { EpsgLookupDialog, type EpsgResult } from './EpsgLookupDialog';
 import { LocationMap, type PickedPosition } from './LocationMap';
+import { mergeMapConversion, mergeProjectedCRS } from '@/lib/geo/effective-georef';
+import { useIfc } from '@/hooks/useIfc';
+import { toast } from '@/components/ui/toast';
 
 // ── Field-specific assistance data ─────────────────────────────────────
 
@@ -319,9 +322,11 @@ export interface GeoreferencingPanelProps {
   coordinateInfo?: CoordinateInfo;
   /** GeometryResult for KMZ export */
   geometryResult?: GeometryResult | null;
+  /** IFC project length unit → metres (e.g. 0.001 for mm models). Default 1. */
+  lengthUnitScale?: number;
 }
 
-export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVersion, coordinateInfo, geometryResult }: GeoreferencingPanelProps) {
+export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVersion, coordinateInfo, geometryResult, lengthUnitScale }: GeoreferencingPanelProps) {
   const georefMutations = useViewerStore(s => s.georefMutations);
   const setGeorefField = useViewerStore(s => s.setGeorefField);
   const setGeorefFields = useViewerStore(s => s.setGeorefFields);
@@ -330,10 +335,14 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
   const setCesiumTerrainClamp = useViewerStore(s => s.setCesiumTerrainClamp);
   const cesiumTerrainHeight = useViewerStore(s => s.cesiumTerrainHeight);
   const cesiumSourceModelId = useViewerStore(s => s.cesiumSourceModelId);
+  const models = useViewerStore(s => s.models);
+  const loading = useViewerStore(s => s.loading);
+  const { addModel, clearAllModels } = useIfc();
   // Only show terrain actions when this panel's model is the one backing the Cesium overlay
   const isActiveCesiumModel = !!modelId && modelId === cesiumSourceModelId;
   const [crsOpen, setCrsOpen] = useState(false);
   const [conversionOpen, setConversionOpen] = useState(false);
+  const [showReloadPrompt, setShowReloadPrompt] = useState(false);
 
   useViewerStore(s => s.mutationVersion);
 
@@ -341,37 +350,12 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
   const supportsStandardGeoreferencing = !schemaVersion?.toUpperCase().includes('2X3');
 
   const mergedCRS = useMemo((): ProjectedCRS | undefined => {
-    const base = georef?.projectedCRS;
-    const muts = mutations?.projectedCRS;
-    if (!base && !muts) return undefined;
-    return {
-      id: base?.id ?? 0,
-      name: muts?.name ?? base?.name ?? '',
-      description: muts?.description ?? base?.description,
-      geodeticDatum: muts?.geodeticDatum ?? base?.geodeticDatum,
-      verticalDatum: muts?.verticalDatum ?? base?.verticalDatum,
-      mapProjection: muts?.mapProjection ?? base?.mapProjection,
-      mapZone: muts?.mapZone ?? base?.mapZone,
-      mapUnit: muts?.mapUnit ?? base?.mapUnit,
-    };
-  }, [georef, mutations]);
+    return mergeProjectedCRS(georef?.projectedCRS, mutations?.projectedCRS, lengthUnitScale ?? 1);
+  }, [georef?.projectedCRS, mutations?.projectedCRS, lengthUnitScale]);
 
   const mergedConversion = useMemo((): MapConversion | undefined => {
-    const base = georef?.mapConversion;
-    const muts = mutations?.mapConversion;
-    if (!base && !muts) return undefined;
-    return {
-      id: base?.id ?? 0,
-      sourceCRS: base?.sourceCRS ?? 0,
-      targetCRS: base?.targetCRS ?? 0,
-      eastings: muts?.eastings ?? base?.eastings ?? 0,
-      northings: muts?.northings ?? base?.northings ?? 0,
-      orthogonalHeight: muts?.orthogonalHeight ?? base?.orthogonalHeight ?? 0,
-      xAxisAbscissa: muts?.xAxisAbscissa ?? base?.xAxisAbscissa,
-      xAxisOrdinate: muts?.xAxisOrdinate ?? base?.xAxisOrdinate,
-      scale: muts?.scale ?? base?.scale,
-    };
-  }, [georef, mutations]);
+    return mergeMapConversion(georef?.mapConversion, mutations?.mapConversion);
+  }, [georef?.mapConversion, mutations?.mapConversion]);
 
   const angleToGridNorth = useMemo(() => {
     return computeAngleToGridNorth(mergedConversion?.xAxisAbscissa, mergedConversion?.xAxisOrdinate);
@@ -399,22 +383,69 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
     return field in entityMuts;
   }, [mutations]);
 
+  const requestAlignmentReload = useCallback(() => {
+    if (models.size > 1) {
+      setShowReloadPrompt(true);
+    }
+  }, [models.size]);
+
+  const reloadModelsForAlignment = useCallback(async () => {
+    const state = useViewerStore.getState();
+    const snapshot = Array.from(state.models.values()).sort((a, b) => (a.loadedAt ?? 0) - (b.loadedAt ?? 0));
+    const missingSource = snapshot.find(model => !model.sourceFile);
+    if (snapshot.length < 2) {
+      setShowReloadPrompt(false);
+      return;
+    }
+    if (missingSource) {
+      toast.error(`Cannot reload ${missingSource.name}: source file is not available`);
+      return;
+    }
+
+    try {
+      clearAllModels();
+      for (const model of snapshot) {
+        const sourceFile = model.sourceFile;
+        if (!sourceFile) continue;
+        const reloadedModelId = await addModel(sourceFile, {
+          name: model.name,
+          modelId: model.id,
+          loadedAt: model.loadedAt,
+          visible: model.visible,
+          collapsed: model.collapsed,
+        });
+        if (!reloadedModelId) {
+          throw new Error(`Failed to reload ${model.name}`);
+        }
+        if (model.visible === false) {
+          useViewerStore.getState().setModelVisibility(model.id, false);
+        }
+      }
+      setShowReloadPrompt(false);
+      toast.success('Reloaded models for edited georeferencing');
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : 'Reload failed');
+    }
+  }, [addModel, clearAllModels]);
+
   const handleSave = useCallback((entity: 'projectedCRS' | 'mapConversion', field: string, value: string | number) => {
     if (!modelId || !setGeorefField) return;
     const oldValue = entity === 'projectedCRS'
-      ? georef?.projectedCRS?.[field as keyof ProjectedCRS]
-      : georef?.mapConversion?.[field as keyof MapConversion];
+      ? mergedCRS?.[field as keyof ProjectedCRS]
+      : mergedConversion?.[field as keyof MapConversion];
     setGeorefField(modelId, entity, field, value, oldValue as string | number | undefined);
-  }, [modelId, setGeorefField, georef]);
+    requestAlignmentReload();
+  }, [modelId, setGeorefField, mergedCRS, mergedConversion, requestAlignmentReload]);
 
   // Handle angle edit: compute and set both XAxisAbscissa and XAxisOrdinate
   const handleAngleChange = useCallback((abscissa: number, ordinate: number) => {
     if (!modelId || !setGeorefFields) return;
     setGeorefFields(modelId, 'mapConversion', [
-      { field: 'xAxisAbscissa', value: abscissa, oldValue: georef?.mapConversion?.xAxisAbscissa },
-      { field: 'xAxisOrdinate', value: ordinate, oldValue: georef?.mapConversion?.xAxisOrdinate },
+      { field: 'xAxisAbscissa', value: abscissa, oldValue: mergedConversion?.xAxisAbscissa },
+      { field: 'xAxisOrdinate', value: ordinate, oldValue: mergedConversion?.xAxisOrdinate },
     ]);
-  }, [modelId, setGeorefFields, georef]);
+    requestAlignmentReload();
+  }, [modelId, setGeorefFields, mergedConversion, requestAlignmentReload]);
 
   // Handle position picked from the map (reverse-projected easting/northing + optional terrain height)
   const handleApplyPosition = useCallback((position: PickedPosition) => {
@@ -432,35 +463,37 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
     }
     setGeorefFields(modelId, 'mapConversion', fields);
     setConversionOpen(true);
-  }, [modelId, setGeorefFields, mergedConversion]);
+    requestAlignmentReload();
+  }, [modelId, setGeorefFields, mergedConversion, requestAlignmentReload]);
 
   const initializeMapConversionDefaults = useCallback(() => {
     if (!modelId || !setGeorefFields) return;
     setGeorefFields(modelId, 'mapConversion', [
-      { field: 'eastings', value: georef?.mapConversion?.eastings ?? 0, oldValue: georef?.mapConversion?.eastings },
-      { field: 'northings', value: georef?.mapConversion?.northings ?? 0, oldValue: georef?.mapConversion?.northings },
-      { field: 'orthogonalHeight', value: georef?.mapConversion?.orthogonalHeight ?? 0, oldValue: georef?.mapConversion?.orthogonalHeight },
-      { field: 'xAxisAbscissa', value: georef?.mapConversion?.xAxisAbscissa ?? 1, oldValue: georef?.mapConversion?.xAxisAbscissa },
-      { field: 'xAxisOrdinate', value: georef?.mapConversion?.xAxisOrdinate ?? 0, oldValue: georef?.mapConversion?.xAxisOrdinate },
-      { field: 'scale', value: georef?.mapConversion?.scale ?? 1, oldValue: georef?.mapConversion?.scale },
+      { field: 'eastings', value: mergedConversion?.eastings ?? 0, oldValue: mergedConversion?.eastings },
+      { field: 'northings', value: mergedConversion?.northings ?? 0, oldValue: mergedConversion?.northings },
+      { field: 'orthogonalHeight', value: mergedConversion?.orthogonalHeight ?? 0, oldValue: mergedConversion?.orthogonalHeight },
+      { field: 'xAxisAbscissa', value: mergedConversion?.xAxisAbscissa ?? 1, oldValue: mergedConversion?.xAxisAbscissa },
+      { field: 'xAxisOrdinate', value: mergedConversion?.xAxisOrdinate ?? 0, oldValue: mergedConversion?.xAxisOrdinate },
+      { field: 'scale', value: mergedConversion?.scale ?? 1, oldValue: mergedConversion?.scale },
     ]);
     setConversionOpen(true);
-  }, [modelId, setGeorefFields, georef]);
+    requestAlignmentReload();
+  }, [modelId, setGeorefFields, mergedConversion, requestAlignmentReload]);
 
   const handleEpsgSelect = useCallback((result: EpsgResult) => {
     if (!modelId || !setGeorefFields) return;
     const epsgName = `EPSG:${result.code}`;
     const fieldUpdates: Array<{ field: string; value: string | number; oldValue?: string | number }> = [
-      { field: 'name', value: epsgName, oldValue: georef?.projectedCRS?.name },
+      { field: 'name', value: epsgName, oldValue: mergedCRS?.name },
     ];
     if (result.name) {
-      fieldUpdates.push({ field: 'description', value: result.name, oldValue: georef?.projectedCRS?.description });
+      fieldUpdates.push({ field: 'description', value: result.name, oldValue: mergedCRS?.description });
     }
     if (result.datum) {
-      fieldUpdates.push({ field: 'geodeticDatum', value: result.datum, oldValue: georef?.projectedCRS?.geodeticDatum });
+      fieldUpdates.push({ field: 'geodeticDatum', value: result.datum, oldValue: mergedCRS?.geodeticDatum });
     }
     if (result.projection) {
-      fieldUpdates.push({ field: 'mapProjection', value: result.projection, oldValue: georef?.projectedCRS?.mapProjection });
+      fieldUpdates.push({ field: 'mapProjection', value: result.projection, oldValue: mergedCRS?.mapProjection });
     }
     if (result.unit) {
       const unitUpper = result.unit.toUpperCase();
@@ -471,14 +504,15 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
           : unitUpper.includes('FOOT') || unitUpper.includes('FEET')
             ? 'FOOT'
             : result.unit;
-      fieldUpdates.push({ field: 'mapUnit', value: mapUnit, oldValue: georef?.projectedCRS?.mapUnit });
+      fieldUpdates.push({ field: 'mapUnit', value: mapUnit, oldValue: mergedCRS?.mapUnit });
     }
     setGeorefFields(modelId, 'projectedCRS', fieldUpdates);
-    if (!georef?.mapConversion && !mutations?.mapConversion) {
+    if (!mergedConversion && !mutations?.mapConversion) {
       initializeMapConversionDefaults();
     }
     setCrsOpen(true);
-  }, [modelId, setGeorefFields, georef, mutations, initializeMapConversionDefaults]);
+    requestAlignmentReload();
+  }, [modelId, setGeorefFields, mergedCRS, mergedConversion, mutations, initializeMapConversionDefaults, requestAlignmentReload]);
 
   const hasData = mergedCRS || mergedConversion;
   const editable = enableEditing && !!modelId && supportsStandardGeoreferencing;
@@ -513,6 +547,33 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
 
   return (
     <div>
+      {showReloadPrompt && (
+        <div className="mx-2 my-2 border border-teal-300 dark:border-teal-700 bg-teal-50 dark:bg-teal-950/40 px-2.5 py-2">
+          <div className="flex items-start gap-2">
+            <MapPin className="h-3.5 w-3.5 text-teal-600 dark:text-teal-400 shrink-0 mt-0.5" />
+            <div className="min-w-0 flex-1">
+              <p className="text-[10px] text-zinc-700 dark:text-zinc-300">
+                Georeference saved. Reload loaded models to recompute 3D alignment?
+              </p>
+              <div className="mt-1.5 flex items-center gap-2">
+                <button
+                  onClick={reloadModelsForAlignment}
+                  disabled={loading}
+                  className="px-2 py-0.5 text-[10px] font-medium text-white bg-teal-600 hover:bg-teal-700 disabled:opacity-50 disabled:cursor-not-allowed"
+                >
+                  Reload models
+                </button>
+                <button
+                  onClick={() => setShowReloadPrompt(false)}
+                  className="px-2 py-0.5 text-[10px] text-zinc-600 dark:text-zinc-300 hover:bg-zinc-200/60 dark:hover:bg-zinc-800"
+                >
+                  Later
+                </button>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
       {/* CRS summary — always visible */}
       <div className="px-2 py-1.5 flex items-center gap-2">
         <Globe className="h-3 w-3 text-teal-500 shrink-0" />
@@ -663,6 +724,7 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
         projectedCRS={mergedCRS}
         coordinateInfo={coordinateInfo}
         geometryResult={geometryResult}
+        lengthUnitScale={lengthUnitScale}
         editable={editable}
         onApplyPosition={editable ? handleApplyPosition : undefined}
       />

package/src/components/viewer/properties/LocationMap.tsx

@@ -49,6 +49,8 @@ export interface LocationMapProps {
   coordinateInfo?: CoordinateInfo;
   /** Geometry result for KMZ export (optional — KMZ button hidden if not provided) */
   geometryResult?: GeometryResult | null;
+  /** IFC project length unit → metres (e.g. 0.001 for mm models). Default 1 (metres). */
+  lengthUnitScale?: number;
   /** Whether the map is in edit mode (allows repositioning) */
   editable?: boolean;
   /** Called when the user applies a new position from the map */
@@ -138,7 +140,7 @@ function removeFootprintFromMap(map: InstanceType<typeof import('maplibre-gl').M
 
 export function LocationMap({
   mapConversion, projectedCRS, coordinateInfo, geometryResult,
-  editable, onApplyPosition,
+  lengthUnitScale = 1, editable, onApplyPosition,
 }: LocationMapProps) {
   const containerRef = useRef<HTMLDivElement>(null);
   const mapRef = useRef<InstanceType<typeof import('maplibre-gl').Map> | null>(null);
@@ -195,14 +197,14 @@ export function LocationMap({
 
     let cancelled = false;
 
-    computeFootprintGeoJSON(mapConversion, projectedCRS, coordinateInfo).then(fp => {
+    computeFootprintGeoJSON(mapConversion, projectedCRS, coordinateInfo, lengthUnitScale).then(fp => {
       if (cancelled) return;
       setFootprint(fp);
       footprintRef.current = fp;
     });
 
     return () => { cancelled = true; };
-  }, [mapConversion, projectedCRS, coordinateInfo]);
+  }, [mapConversion, projectedCRS, coordinateInfo, lengthUnitScale]);
 
   // Geocode search
   useEffect(() => {
@@ -234,7 +236,7 @@ export function LocationMap({
     setMapState('loading');
     setError(null);
 
-    reprojectToLatLon(mapConversion, projectedCRS, coordinateInfo).then(result => {
+    reprojectToLatLon(mapConversion, projectedCRS, coordinateInfo, lengthUnitScale).then(result => {
       if (cancelled) return;
       if (result) {
         setLatLon(result);
@@ -247,7 +249,7 @@ export function LocationMap({
     });
 
     return () => { cancelled = true; };
-  }, [mapConversion, projectedCRS, coordinateInfo]);
+  }, [mapConversion, projectedCRS, coordinateInfo, lengthUnitScale]);
 
   // When a picked position changes, reverse-project and query elevation
   useEffect(() => {
@@ -262,7 +264,7 @@ export function LocationMap({
 
     // Reverse-project to get IfcMapConversion eastings/northings
     // Accounts for model local geometry offset, rotation, and scale
-    reprojectFromLatLon(pickedLatLon, projectedCRS, mapConversion, coordinateInfo).then(coords => {
+    reprojectFromLatLon(pickedLatLon, projectedCRS, mapConversion, coordinateInfo, lengthUnitScale).then(coords => {
       if (!cancelled) setProjectedCoords(coords);
     });
 
@@ -276,7 +278,7 @@ export function LocationMap({
     });
 
     return () => { cancelled = true; };
-  }, [pickedLatLon, projectedCRS, mapConversion, coordinateInfo]);
+  }, [pickedLatLon, projectedCRS, mapConversion, coordinateInfo, lengthUnitScale]);
 
   // Place or move the picked marker on the map
   const updatePickedMarker = useCallback((pos: LatLon, maplibregl: typeof import('maplibre-gl')) => {

package/src/components/viewer/properties/ModelMetadataPanel.tsx

@@ -212,7 +212,7 @@ export function ModelMetadataPanel({ model }: { model: FederatedModel }) {
         </div>
 
         {/* Georeferencing */}
-        <GeoreferencingPanel georef={georef} modelId={model.id} enableEditing schemaVersion={model.schemaVersion} coordinateInfo={model.geometryResult?.coordinateInfo} geometryResult={model.geometryResult} />
+        <GeoreferencingPanel georef={georef} modelId={model.id} enableEditing schemaVersion={model.schemaVersion} coordinateInfo={model.geometryResult?.coordinateInfo} geometryResult={model.geometryResult} lengthUnitScale={unitInfo?.scale} />
 
         {/* IfcProject Data */}
         {projectData && (