@ifc-lite/viewer 1.17.3 → 1.17.6

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/properties/GeoreferencingPanel.tsx

@@ -8,14 +8,17 @@
  */
 
 import { useState, useCallback, useMemo } from 'react';
-import { Globe, MapPin, PenLine, Check, X, Search, ChevronRight } from 'lucide-react';
+import { Globe, MapPin, PenLine, Check, X, Search, ChevronRight, Mountain } from 'lucide-react';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { Badge } from '@/components/ui/badge';
 import { computeAngleToGridNorth, type GeoreferenceInfo, type MapConversion, type ProjectedCRS } from '@ifc-lite/parser';
 import { useViewerStore } from '@/store';
 import type { CoordinateInfo, GeometryResult } from '@ifc-lite/geometry';
 import { EpsgLookupDialog, type EpsgResult } from './EpsgLookupDialog';
-import { LocationMap } from './LocationMap';
+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 ─────────────────────────────────────
 
@@ -71,9 +74,11 @@ interface GeorefRowProps {
   fieldEntity?: string;
   fieldName?: string;
   onSave?: (value: string | number) => void;
+  /** Extra inline content rendered after the value (e.g. terrain height button) */
+  children?: React.ReactNode;
 }
 
-function GeorefRow({ label, value, suffix, isComputed, isNumber, editable, isMutated, fieldEntity, fieldName, onSave }: GeorefRowProps) {
+function GeorefRow({ label, value, suffix, isComputed, isNumber, editable, isMutated, fieldEntity, fieldName, onSave, children }: GeorefRowProps) {
   const [editing, setEditing] = useState(false);
   const [editValue, setEditValue] = useState('');
 
@@ -214,6 +219,7 @@ function GeorefRow({ label, value, suffix, isComputed, isNumber, editable, isMut
             </>
           )}
         </div>
+        {children}
       </div>
     </div>
   );
@@ -316,14 +322,27 @@ 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);
+  const cesiumEnabled = useViewerStore(s => s.cesiumEnabled);
+  const terrainClamp = useViewerStore(s => s.cesiumTerrainClamp);
+  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);
 
@@ -331,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);
@@ -375,6 +369,13 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
     return 'm';
   }, [mergedCRS?.mapUnit]);
 
+  // Convert meters to map units (Cesium always returns meters)
+  const metersToMapUnit = useCallback((meters: number): number => {
+    if (mapUnitSuffix === 'ftUS') return meters / 0.3048006096;
+    if (mapUnitSuffix === 'ft') return meters / 0.3048;
+    return meters; // already meters
+  }, [mapUnitSuffix]);
+
   const isMutated = useCallback((entity: 'projectedCRS' | 'mapConversion', field: string): boolean => {
     if (!mutations) return false;
     const entityMuts = mutations[entity];
@@ -382,50 +383,117 @@ 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) => {
+    if (!modelId || !setGeorefFields) return;
+    const fields: Array<{ field: string; value: number; oldValue?: number }> = [
+      { field: 'eastings', value: position.easting, oldValue: mergedConversion?.eastings },
+      { field: 'northings', value: position.northing, oldValue: mergedConversion?.northings },
+    ];
+    if (position.terrainHeight !== null) {
+      fields.push({
+        field: 'orthogonalHeight',
+        value: Math.round(position.terrainHeight * 10) / 10,
+        oldValue: mergedConversion?.orthogonalHeight,
+      });
+    }
+    setGeorefFields(modelId, 'mapConversion', fields);
+    setConversionOpen(true);
+    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();
@@ -436,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;
@@ -478,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" />
@@ -561,7 +657,9 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
               <GeorefRow label="Type" value="IfcMapConversion" />
               <GeorefRow label="Eastings" value={mergedConversion.eastings} suffix={mapUnitSuffix} isNumber editable={editable} isMutated={isMutated('mapConversion', 'eastings')} fieldEntity="mapConversion" fieldName="eastings" onSave={v => handleSave('mapConversion', 'eastings', v)} />
               <GeorefRow label="Northings" value={mergedConversion.northings} suffix={mapUnitSuffix} isNumber editable={editable} isMutated={isMutated('mapConversion', 'northings')} fieldEntity="mapConversion" fieldName="northings" onSave={v => handleSave('mapConversion', 'northings', v)} />
-              <GeorefRow label="OrthogonalHeight" value={mergedConversion.orthogonalHeight} suffix={mapUnitSuffix} isNumber editable={editable} isMutated={isMutated('mapConversion', 'orthogonalHeight')} fieldEntity="mapConversion" fieldName="orthogonalHeight" onSave={v => handleSave('mapConversion', 'orthogonalHeight', v)} />
+              <GeorefRow label="OrthogonalHeight" value={mergedConversion.orthogonalHeight} suffix={mapUnitSuffix} isNumber editable={editable} isMutated={isMutated('mapConversion', 'orthogonalHeight')} fieldEntity="mapConversion" fieldName="orthogonalHeight" onSave={v => handleSave('mapConversion', 'orthogonalHeight', v)}>
+                <TerrainHeightButton modelId={modelId} editable={editable} onApply={(h) => handleSave('mapConversion', 'orthogonalHeight', Math.round(metersToMapUnit(h) * 100) / 100)} />
+              </GeorefRow>
               <GeorefRow label="XAxisAbscissa" value={mergedConversion.xAxisAbscissa} isNumber editable={editable} isMutated={isMutated('mapConversion', 'xAxisAbscissa')} fieldEntity="mapConversion" fieldName="xAxisAbscissa" onSave={v => handleSave('mapConversion', 'xAxisAbscissa', v)} />
               <GeorefRow label="XAxisOrdinate" value={mergedConversion.xAxisOrdinate} isNumber editable={editable} isMutated={isMutated('mapConversion', 'xAxisOrdinate')} fieldEntity="mapConversion" fieldName="xAxisOrdinate" onSave={v => handleSave('mapConversion', 'xAxisOrdinate', v)} />
               <AngleRow angle={angleToGridNorth} editable={editable} onAngleChange={handleAngleChange} />
@@ -584,8 +682,84 @@ export function GeoreferencingPanel({ georef, modelId, enableEditing, schemaVers
         </div>
       )}
 
+      {/* Terrain clamp toggle — only when Cesium overlay is active */}
+      {cesiumEnabled && isActiveCesiumModel && mergedConversion && (
+        <div className="px-3 py-1.5 border-t border-zinc-100 dark:border-zinc-900 space-y-1">
+          <div className="flex items-center gap-2">
+            <Mountain className="h-3 w-3 text-teal-500 shrink-0" />
+            <label className="flex items-center gap-1.5 cursor-pointer flex-1">
+              <input
+                type="checkbox"
+                checked={terrainClamp}
+                onChange={(e) => setCesiumTerrainClamp(e.target.checked)}
+                className="accent-teal-500 h-3 w-3"
+              />
+              <span className="text-[10px] text-zinc-600 dark:text-zinc-400">Clamp to terrain</span>
+            </label>
+            {cesiumTerrainHeight !== null ? (
+              <span className="text-[9px] font-mono text-teal-500">
+                {cesiumTerrainHeight.toFixed(1)} m
+              </span>
+            ) : (
+              <span className="text-[9px] font-mono text-zinc-400">querying...</span>
+            )}
+          </div>
+          {cesiumTerrainHeight !== null && editable && modelId && (
+            <div className="flex items-center gap-1 ml-5">
+              <button
+                onClick={() => handleSave('mapConversion', 'orthogonalHeight', Math.round(metersToMapUnit(cesiumTerrainHeight) * 100) / 100)}
+                className="text-[9px] text-teal-500 hover:text-teal-700 dark:hover:text-teal-300 transition-colors flex items-center gap-0.5"
+              >
+                <Mountain className="h-2.5 w-2.5" />
+                Set OrthogonalHeight to {cesiumTerrainHeight.toFixed(1)} m
+              </button>
+            </div>
+          )}
+        </div>
+      )}
+
       {/* Location minimap */}
-      <LocationMap mapConversion={mergedConversion} projectedCRS={mergedCRS} coordinateInfo={coordinateInfo} geometryResult={geometryResult} />
+      <LocationMap
+        mapConversion={mergedConversion}
+        projectedCRS={mergedCRS}
+        coordinateInfo={coordinateInfo}
+        geometryResult={geometryResult}
+        lengthUnitScale={lengthUnitScale}
+        editable={editable}
+        onApplyPosition={editable ? handleApplyPosition : undefined}
+      />
     </div>
   );
 }
+
+/** Small button to apply Cesium terrain height to OrthogonalHeight field */
+function TerrainHeightButton({ modelId, editable, onApply }: {
+  modelId?: string;
+  editable?: boolean;
+  onApply: (height: number) => void;
+}) {
+  const cesiumEnabled = useViewerStore(s => s.cesiumEnabled);
+  const terrainHeight = useViewerStore(s => s.cesiumTerrainHeight);
+  const sourceModelId = useViewerStore(s => s.cesiumSourceModelId);
+
+  // Only show when this panel's model is the active Cesium model
+  if (!cesiumEnabled || terrainHeight === null || !editable || !modelId || modelId !== sourceModelId) return null;
+
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <button
+          onClick={(e) => {
+            e.stopPropagation();
+            onApply(terrainHeight);
+          }}
+          className="flex items-center gap-0.5 text-[9px] text-teal-500 hover:text-teal-700 dark:hover:text-teal-300 transition-colors mt-0.5"
+        >
+          <Mountain className="h-2.5 w-2.5" />
+          <span>{terrainHeight.toFixed(1)} m</span>
+        </button>
+      </TooltipTrigger>
+      <TooltipContent>Set OrthogonalHeight to Cesium terrain elevation ({terrainHeight.toFixed(1)} m)</TooltipContent>
+    </Tooltip>
+  );
+}