@ifc-lite/viewer 1.21.0 → 1.22.1

package/src/lib/wall-opening-reassign.ts

@@ -0,0 +1,241 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * When a wall is split, openings hosted on it (doors, windows,
+ * generic voids) need to move to whichever half they geometrically
+ * belong to — otherwise both halves carry the same void
+ * relationship and the export double-counts.
+ *
+ * IFC structure:
+ *
+ *   IfcWall ──IfcRelVoidsElement──► IfcOpeningElement
+ *                                    │
+ *                                    └── (optional) IfcRelFillsElement
+ *                                          ──► IfcDoor / IfcWindow
+ *
+ * The opening has its own `ObjectPlacement` whose `PlacementRelTo`
+ * points back at the wall's placement (per IFC convention). Its
+ * `RelativePlacement.Location.Coordinates` are in wall-local 3D,
+ * with X = distance along the wall axis. That distance is what
+ * decides the half:
+ *
+ *   if local-X < splitDistance ─► left half (no offset)
+ *   else                       ─► right half (subtract splitDistance from local-X
+ *                                              + repoint PlacementRelTo)
+ *
+ * Doors/windows hosted in an opening (via IfcRelFillsElement) are
+ * positioned relative to the opening, so they move along with it
+ * without any extra work.
+ *
+ * Source-wall openings whose placement does NOT match this
+ * canonical shape (e.g. world-absolute openings, openings with
+ * non-Cartesian placements, source-buffer entities with mapped
+ * representations) are skipped with a returned `skippedReasons`
+ * tally so the caller can surface a warning toast.
+ */
+
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { IfcAttributeValue, MutablePropertyView, StoreEditor } from '@ifc-lite/mutations';
+import { asExpressIdRef, asCoordinateTriple, readAttributes, resolvePlacementChain } from './placement-core.js';
+
+export interface OpeningReassignSummary {
+  /** Openings successfully moved onto the left half. */
+  toLeft: number;
+  /** Openings successfully moved onto the right half. */
+  toRight: number;
+  /** Openings whose placement we couldn't interpret; left attached
+   * to the (tombstoned) source. */
+  skipped: number;
+  /** Diagnostic reasons for the skips — small enum so the UI can
+   * group them in a single toast rather than one per opening. */
+  skipReasons: Map<string, number>;
+}
+
+function bumpReason(map: Map<string, number>, reason: string): void {
+  map.set(reason, (map.get(reason) ?? 0) + 1);
+}
+
+/**
+ * Rewrite `IfcRelVoidsElement.RelatingBuildingElement` to a new
+ * wall id, preserving the reference's form (`#X` strings vs bare
+ * numbers — the StoreEditor exports either; we don't want to
+ * accidentally normalise overlay refs into numbers).
+ */
+function rewriteRelTarget(
+  raw: unknown,
+  newTargetId: number,
+): IfcAttributeValue {
+  if (typeof raw === 'string' && raw.startsWith('#')) {
+    return `#${newTargetId}` as IfcAttributeValue;
+  }
+  return newTargetId as IfcAttributeValue;
+}
+
+/**
+ * Walk every `IfcRelVoidsElement` whose RelatingBuildingElement is
+ * `sourceWallId`. For each one:
+ *
+ *   1. Resolve the opening's wall-local X coord (= distance along
+ *      the wall axis).
+ *   2. Decide left / right by comparison to `splitDistance`.
+ *   3. Rewrite the rel's RelatingBuildingElement (attr 4) to the
+ *      chosen half.
+ *   4. Rewrite the opening's IfcLocalPlacement.PlacementRelTo
+ *      (attr 0) to the chosen half's placement.
+ *   5. For right-half openings, subtract `splitDistance` from the
+ *      opening's local-X coordinate so its world position stays
+ *      the same after the placement reparent.
+ *
+ * The split distance is in metres along the source wall's axis,
+ * measured from the source's start (matches
+ * `computeWallSplitGeometry`'s `distance` parameter).
+ */
+export function reassignWallOpenings(
+  dataStore: IfcDataStore,
+  view: MutablePropertyView,
+  editor: StoreEditor,
+  sourceWallId: number,
+  leftWallId: number,
+  rightWallId: number,
+  splitDistance: number,
+  /** `IfcLocalPlacement` ids for the two halves — needed because
+   * the opening's `PlacementRelTo` must point at the half's
+   * placement, not the half's IfcWall entity. */
+  leftPlacementId: number,
+  rightPlacementId: number,
+): OpeningReassignSummary {
+  const summary: OpeningReassignSummary = {
+    toLeft: 0,
+    toRight: 0,
+    skipped: 0,
+    skipReasons: new Map(),
+  };
+
+  // Resolve the source wall's IfcLocalPlacement so we can verify
+  // each opening was actually placed relative to it. Openings with
+  // world-absolute placements (PlacementRelTo = null) or placements
+  // relative to some other entity must NOT be reassigned — silently
+  // rewriting their PlacementRelTo would teleport them.
+  const sourceChain = resolvePlacementChain(dataStore, view, editor, sourceWallId);
+  if (!sourceChain) {
+    summary.skipped++;
+    bumpReason(summary.skipReasons, 'source wall placement unresolvable');
+    return summary;
+  }
+  const sourceWallPlacementId = sourceChain.localPlacementId;
+
+  const relIds = dataStore.entityIndex.byType.get('IFCRELVOIDSELEMENT') ?? [];
+  for (const relId of relIds) {
+    const relAttrs = readAttributes(dataStore, view, editor, relId);
+    if (!relAttrs) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'unreadable rel');
+      continue;
+    }
+    // IfcRelVoidsElement attrs (IFC4): [GlobalId, OwnerHistory,
+    // Name, Description, RelatingBuildingElement, RelatedOpeningElement]
+    const relatingBuilding = asExpressIdRef(relAttrs[4]);
+    if (relatingBuilding !== sourceWallId) continue;
+    const openingId = asExpressIdRef(relAttrs[5]);
+    if (openingId === null) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'missing opening ref');
+      continue;
+    }
+
+    // Walk the opening's placement chain to its local-X coord.
+    const openingAttrs = readAttributes(dataStore, view, editor, openingId);
+    if (!openingAttrs) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'unreadable opening');
+      continue;
+    }
+    const localPlacementId = asExpressIdRef(openingAttrs[5]); // ObjectPlacement
+    if (localPlacementId === null) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'no ObjectPlacement');
+      continue;
+    }
+    const localPlacementAttrs = readAttributes(dataStore, view, editor, localPlacementId);
+    if (!localPlacementAttrs) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'unreadable IfcLocalPlacement');
+      continue;
+    }
+    // Verify the opening's PlacementRelTo points at THIS source
+    // wall. Openings placed absolutely (PlacementRelTo === null)
+    // or relative to some other entity must be left alone —
+    // rewriting their parent placement would teleport them.
+    const placementRelTo = asExpressIdRef(localPlacementAttrs[0]);
+    if (placementRelTo !== sourceWallPlacementId) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'opening not placed relative to source wall');
+      continue;
+    }
+    const relativePlacementId = asExpressIdRef(localPlacementAttrs[1]);
+    if (relativePlacementId === null) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'no RelativePlacement');
+      continue;
+    }
+    const axisAttrs = readAttributes(dataStore, view, editor, relativePlacementId);
+    if (!axisAttrs) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'unreadable IfcAxis2Placement3D');
+      continue;
+    }
+    const cartesianId = asExpressIdRef(axisAttrs[0]);
+    if (cartesianId === null) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'no Location');
+      continue;
+    }
+    const pointAttrs = readAttributes(dataStore, view, editor, cartesianId);
+    if (!pointAttrs) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'unreadable IfcCartesianPoint');
+      continue;
+    }
+    const coords = asCoordinateTriple(pointAttrs[0]);
+    if (!coords) {
+      summary.skipped++;
+      bumpReason(summary.skipReasons, 'invalid Coordinates');
+      continue;
+    }
+
+    const localX = coords[0];
+    const onLeft = localX < splitDistance;
+    if (onLeft) {
+      // Reassign to left half. Left's placement coincides with
+      // source's, so the opening's local coords don't change.
+      editor.setPositionalAttribute(relId, 4, rewriteRelTarget(relAttrs[4], leftWallId));
+      editor.setPositionalAttribute(
+        localPlacementId,
+        0,
+        rewriteRelTarget(localPlacementAttrs[0], leftPlacementId),
+      );
+      summary.toLeft++;
+    } else {
+      // Reassign to right half. Right's placement is offset along
+      // the wall axis by `splitDistance` — so the opening's local-X
+      // shifts by `-splitDistance` to keep its world position fixed.
+      editor.setPositionalAttribute(relId, 4, rewriteRelTarget(relAttrs[4], rightWallId));
+      editor.setPositionalAttribute(
+        localPlacementId,
+        0,
+        rewriteRelTarget(localPlacementAttrs[0], rightPlacementId),
+      );
+      const newCoords: [number, number, number] = [
+        localX - splitDistance,
+        coords[1],
+        coords[2],
+      ];
+      editor.setPositionalAttribute(cartesianId, 0, newCoords);
+      summary.toRight++;
+    }
+  }
+
+  return summary;
+}

package/src/main.tsx

@@ -11,6 +11,10 @@ import ReactDOM from 'react-dom/client';
 import { App } from './App';
 import './index.css';
 import 'maplibre-gl/dist/maplibre-gl.css';
+// Wire the placement-edit helpers' parser-backed source reader. Pure
+// side-effect import; keeps `@ifc-lite/parser` out of placement-edit
+// itself so its overlay-path logic stays unit-testable.
+import './lib/placement-edit.boot';
 
 ReactDOM.createRoot(document.getElementById('root')!).render(
   <React.StrictMode>

package/src/services/playground-model.ts

@@ -0,0 +1,55 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Per-tab persistence for the model the /mcp/playground chat uses.
+ *
+ * The playground driver calls Anthropic's `messages.create` with the native
+ * tools API, so the selected model must be Anthropic. We keep a separate
+ * preference from the viewer's `chatActiveModel` so the two pages can default
+ * differently — the viewer often runs on a free proxy model, while playground
+ * users have already opted into BYOK by being here.
+ */
+
+import { getByokModelsForSource } from '@/lib/llm/models';
+
+const STORAGE_KEY = 'ifc-lite:playground-model:v1';
+const CHANGED_EVENT = 'ifc-lite:playground-model-changed';
+
+/**
+ * Default fallback when nothing is in storage. Sonnet hits the sweet spot for
+ * tool-calling agentic loops — fast enough for 25 sequential tool calls,
+ * smart enough to pick the right tool. Opus 4.7 is better at planning but
+ * costs ~3x; Haiku is faster but more likely to mis-pick tools.
+ */
+const FALLBACK_MODEL = 'claude-sonnet-4-6';
+
+function isValidAnthropicModel(id: string): boolean {
+  return getByokModelsForSource('anthropic').some((m) => m.id === id);
+}
+
+export function getPlaygroundModel(): string {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored && isValidAnthropicModel(stored)) return stored;
+  } catch {
+    /* localStorage blocked / quota-exceeded — fall through to default */
+  }
+  return FALLBACK_MODEL;
+}
+
+export function setPlaygroundModel(modelId: string): void {
+  if (!isValidAnthropicModel(modelId)) return;
+  try {
+    localStorage.setItem(STORAGE_KEY, modelId);
+  } catch {
+    /* storage write failed — selection only lives for this tab session */
+  }
+  window.dispatchEvent(new Event(CHANGED_EVENT));
+}
+
+export function subscribePlaygroundModel(listener: () => void): () => void {
+  window.addEventListener(CHANGED_EVENT, listener);
+  return () => window.removeEventListener(CHANGED_EVENT, listener);
+}

package/src/store/index.ts

@@ -42,6 +42,8 @@ import { createOverlaySlice, type OverlaySlice } from './slices/overlaySlice.js'
 import { createSearchSlice, type SearchSlice } from './slices/searchSlice.js';
 import { createAnnotationsSlice, type AnnotationsSlice } from './slices/annotationsSlice.js';
 import { createAddElementSlice, type AddElementSlice } from './slices/addElementSlice.js';
+import { createSplitToolSlice, type SplitToolSlice } from './slices/splitToolSlice.js';
+import { createLevelDisplaySlice, type LevelDisplaySlice } from './slices/levelDisplaySlice.js';
 import { createPointCloudSlice, type PointCloudSlice, POINT_CLOUD_DEFAULTS } from './slices/pointCloudSlice.js';
 import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
@@ -90,7 +92,7 @@ export type { ChatSlice } from './slices/chatSlice.js';
 export type { DesktopEntitlementSlice } from './slices/desktopEntitlementSlice.js';
 
 // Re-export Cesium types
-export type { CesiumSlice, CesiumDataSource } from './slices/cesiumSlice.js';
+export type { CesiumSlice, CesiumDataSource, CesiumPlacementDraft } from './slices/cesiumSlice.js';
 
 // Re-export Schedule (4D) types + selectors
 export type { ScheduleSlice, ScheduleTimeRange, GanttTimeScale } from './slices/scheduleSlice.js';
@@ -136,6 +138,8 @@ export type ViewerState = LoadingSlice &
   SearchSlice &
   AnnotationsSlice &
   AddElementSlice &
+  SplitToolSlice &
+  LevelDisplaySlice &
   PointCloudSlice & {
     resetViewerState: () => void;
   };
@@ -173,6 +177,8 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
   ...createSearchSlice(...args),
   ...createAnnotationsSlice(...args),
   ...createAddElementSlice(...args),
+  ...createSplitToolSlice(...args),
+  ...createLevelDisplaySlice(...args),
   ...createPointCloudSlice(...args),
 
   // Reset all viewer state when loading new file
@@ -256,6 +262,7 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
 
       // UI
       activeTool: UI_DEFAULTS.ACTIVE_TOOL,
+      editEnabled: false,
       visualEnhancementsEnabled: UI_DEFAULTS.VISUAL_ENHANCEMENTS_ENABLED,
       edgeContrastEnabled: UI_DEFAULTS.EDGE_CONTRAST_ENABLED,
       edgeContrastIntensity: UI_DEFAULTS.EDGE_CONTRAST_INTENSITY,
@@ -271,13 +278,12 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       cesiumAvailable: false,
       cesiumEnabled: false,
       cesiumTerrainHeight: null,
-      // Default the clamp toggle ON so models authored at sea-level
-      // OrthogonalHeight don't load buried below the 3D-tiles terrain on
-      // first activation. Users can still uncheck it manually.
-      cesiumTerrainClamp: true,
       cesiumSourceModelId: null,
       cesiumTerrainClipY: null,
       cesiumGlbLoaded: false,
+      cesiumPlacementEditMode: false,
+      cesiumPlacementDraftModelId: null,
+      cesiumPlacementDraft: null,
 
       // Drawing 2D
       drawing2D: null,

package/src/store/slices/cesiumSlice.ts

@@ -15,11 +15,19 @@
  */
 
 import type { StateCreator } from 'zustand';
+import type { MapConversion } from '@ifc-lite/parser';
 
-export type CesiumDataSource =
-  | 'osm-buildings'        // Cesium OSM Buildings (free via Cesium ion)
-  | 'bing-aerial'          // Bing Maps aerial imagery draped on terrain
-  | 'google-photorealistic'; // Google Photorealistic 3D Tiles (requires API key)
+import { clearTerrainElevationCache } from '@/lib/geo/terrain-elevation';
+
+export type CesiumDataSource = 'google-photorealistic';
+
+export interface CesiumPlacementDraft {
+  eastings: number;
+  northings: number;
+  orthogonalHeight: number;
+  xAxisAbscissa: number;
+  xAxisOrdinate: number;
+}
 
 export interface CesiumSlice {
   // State
@@ -31,16 +39,42 @@ export interface CesiumSlice {
   cesiumIonToken: string;
   /** Terrain enabled (Cesium World Terrain). */
   cesiumTerrainEnabled: boolean;
-  /** Clamp model to terrain height at its geodetic position. */
-  cesiumTerrainClamp: boolean;
   /** Terrain height at model position (queried from Cesium, meters). null = not yet queried. */
   cesiumTerrainHeight: number | null;
+  /** Human-readable source label for the sampled terrain height. */
+  cesiumTerrainSource: string | null;
   /** Model ID that the Cesium overlay is currently displaying. */
   cesiumSourceModelId: string | null;
+  /**
+   * User-selected federation anchor model.
+   *
+   * When multiple georeferenced models are loaded, federation alignment rebakes
+   * every other model's geometry into this model's viewer-space frame so they
+   * land in the right relative real-world positions. The Cesium bridge also
+   * uses this model's IfcMapConversion to anchor the viewer→ECEF transform.
+   *
+   * `null` selects the default anchor (earliest `loadedAt` with a valid georef).
+   * Setting an override fires a `RECOMPUTE_FEDERATION_ALIGNMENT` re-bake.
+   */
+  anchorModelIdOverride: string | null;
+  /**
+   * When true, the viewport renders a small XYZ triad + label at each loaded
+   * model's true IFC (0,0,0) point — useful for debugging federation
+   * alignment. Origin positions are derived from each model's IfcMapConversion
+   * and the anchor's MapConversion, so the markers stay correct after re-aligns
+   * and across cross-CRS reprojections.
+   */
+  showModelBasepoints: boolean;
   /** Terrain clip Y position in viewer space. When set, fragments below this Y are discarded. */
   cesiumTerrainClipY: number | null;
   /** Whether the GLB model has been loaded into Cesium (hides WebGPU overlay). */
   cesiumGlbLoaded: boolean;
+  /** Whether the direct placement editor is active. */
+  cesiumPlacementEditMode: boolean;
+  /** Source model currently associated with the placement draft. */
+  cesiumPlacementDraftModelId: string | null;
+  /** Preview placement values shown in Cesium before applying to IFC georeference. */
+  cesiumPlacementDraft: CesiumPlacementDraft | null;
 
   // Actions
   setCesiumAvailable: (available: boolean) => void;
@@ -49,11 +83,22 @@ export interface CesiumSlice {
   setCesiumDataSource: (source: CesiumDataSource) => void;
   setCesiumIonToken: (token: string) => void;
   setCesiumTerrainEnabled: (enabled: boolean) => void;
-  setCesiumTerrainClamp: (clamp: boolean) => void;
   setCesiumTerrainHeight: (height: number | null) => void;
+  setCesiumTerrainSource: (source: string | null) => void;
   setCesiumSourceModelId: (modelId: string | null) => void;
+  setAnchorModelIdOverride: (modelId: string | null) => void;
+  setShowModelBasepoints: (show: boolean) => void;
+  toggleShowModelBasepoints: () => void;
   setCesiumTerrainClipY: (y: number | null) => void;
   setCesiumGlbLoaded: (loaded: boolean) => void;
+  setCesiumPlacementEditMode: (enabled: boolean) => void;
+  toggleCesiumPlacementEditMode: () => void;
+  beginCesiumPlacementDraft: (
+    modelId: string,
+    conversion: Pick<MapConversion, 'eastings' | 'northings' | 'orthogonalHeight' | 'xAxisAbscissa' | 'xAxisOrdinate'>,
+  ) => void;
+  updateCesiumPlacementDraft: (values: Partial<CesiumPlacementDraft>) => void;
+  resetCesiumPlacementDraft: () => void;
 }
 
 const STORAGE_KEY_ION_TOKEN = 'ifc-lite:cesium-ion-token';
@@ -80,13 +125,9 @@ function saveToStorage(key: string, value: string): void {
   } catch { /* storage unavailable */ }
 }
 
-const VALID_DATA_SOURCES = new Set<CesiumDataSource>(['osm-buildings', 'bing-aerial', 'google-photorealistic']);
-
 function loadDataSource(): CesiumDataSource {
-  const stored = loadFromStorage(STORAGE_KEY_DATA_SOURCE, '');
-  return VALID_DATA_SOURCES.has(stored as CesiumDataSource)
-    ? (stored as CesiumDataSource)
-    : 'google-photorealistic';
+  // Only Google Photorealistic is supported; upgrade any stale stored value.
+  return 'google-photorealistic';
 }
 
 /** Resolve the Cesium ion token: user override > build-time default */
@@ -95,33 +136,126 @@ function resolveIonToken(): string {
   return userToken || DEFAULT_ION_TOKEN;
 }
 
-export const createCesiumSlice: StateCreator<CesiumSlice, [], [], CesiumSlice> = (set) => ({
+/**
+ * Cross-slice surface CesiumSlice writes into. `editEnabled` lives on
+ * UISlice — turning on the placement editor implies global edit mode,
+ * so the slice writes it directly here to keep the toolbar pill in
+ * sync atomically.
+ */
+export interface CesiumCrossSliceState {
+  editEnabled: boolean;
+}
+
+export const createCesiumSlice: StateCreator<CesiumSlice & CesiumCrossSliceState, [], [], CesiumSlice> = (set) => ({
   cesiumAvailable: false,
   cesiumEnabled: false,
   cesiumDataSource: loadDataSource(),
   cesiumIonToken: resolveIonToken(),
   cesiumTerrainEnabled: true,
-  cesiumTerrainClamp: true,
   cesiumTerrainHeight: null,
+  cesiumTerrainSource: null,
   cesiumSourceModelId: null,
+  anchorModelIdOverride: null,
+  showModelBasepoints: false,
   cesiumTerrainClipY: null,
   cesiumGlbLoaded: false,
+  cesiumPlacementEditMode: false,
+  cesiumPlacementDraftModelId: null,
+  cesiumPlacementDraft: null,
 
   setCesiumAvailable: (available) => set({ cesiumAvailable: available }),
   setCesiumEnabled: (enabled) => set({ cesiumEnabled: enabled }),
-  toggleCesium: () => set((s) => ({ cesiumEnabled: !s.cesiumEnabled })),
+  toggleCesium: () => set((s) => ({
+    cesiumEnabled: !s.cesiumEnabled,
+    ...(s.cesiumEnabled
+      ? {
+          cesiumPlacementEditMode: false,
+          cesiumPlacementDraftModelId: null,
+          cesiumPlacementDraft: null,
+        }
+      : {}),
+  })),
   setCesiumDataSource: (source) => {
+    clearTerrainElevationCache();
     saveToStorage(STORAGE_KEY_DATA_SOURCE, source);
-    set({ cesiumDataSource: source });
+    set({
+      cesiumDataSource: source,
+      cesiumTerrainHeight: null,
+      cesiumTerrainSource: null,
+      cesiumTerrainClipY: null,
+    });
   },
   setCesiumIonToken: (token) => {
+    clearTerrainElevationCache();
     saveToStorage(STORAGE_KEY_ION_TOKEN, token);
-    set({ cesiumIonToken: token || DEFAULT_ION_TOKEN });
+    set({
+      cesiumIonToken: token || DEFAULT_ION_TOKEN,
+      cesiumTerrainHeight: null,
+      cesiumTerrainSource: null,
+      cesiumTerrainClipY: null,
+    });
+  },
+  setCesiumTerrainEnabled: (enabled) => {
+    clearTerrainElevationCache();
+    set({
+      cesiumTerrainEnabled: enabled,
+      cesiumTerrainHeight: null,
+      cesiumTerrainSource: null,
+      cesiumTerrainClipY: null,
+    });
   },
-  setCesiumTerrainEnabled: (enabled) => set({ cesiumTerrainEnabled: enabled }),
-  setCesiumTerrainClamp: (clamp) => set({ cesiumTerrainClamp: clamp }),
   setCesiumTerrainHeight: (height) => set({ cesiumTerrainHeight: height }),
+  setCesiumTerrainSource: (source) => set({ cesiumTerrainSource: source }),
   setCesiumSourceModelId: (modelId) => set({ cesiumSourceModelId: modelId }),
+  setAnchorModelIdOverride: (modelId) => set({ anchorModelIdOverride: modelId }),
+  setShowModelBasepoints: (show) => set({ showModelBasepoints: show }),
+  toggleShowModelBasepoints: () => set((s) => ({ showModelBasepoints: !s.showModelBasepoints })),
   setCesiumTerrainClipY: (y) => set({ cesiumTerrainClipY: y }),
   setCesiumGlbLoaded: (loaded) => set({ cesiumGlbLoaded: loaded }),
+  setCesiumPlacementEditMode: (enabled) => set(
+    // Turning the placement editor on implies global edit mode — keeps
+    // the toolbar pill in sync so the user can't end up "moving the
+    // georef" while the rest of the UI claims it's read-only. Turning
+    // it off does *not* exit global edit; other sub-tools (properties,
+    // geometry) may still be in use — but we DO clear the placement
+    // draft so callers exiting via the setter don't leave stale draft
+    // state behind (matches the toggle's disable branch).
+    enabled
+      ? { cesiumPlacementEditMode: true, editEnabled: true }
+      : {
+          cesiumPlacementEditMode: false,
+          cesiumPlacementDraftModelId: null,
+          cesiumPlacementDraft: null,
+        },
+  ),
+  toggleCesiumPlacementEditMode: () => set((s) => (
+    s.cesiumPlacementEditMode
+      ? {
+          cesiumPlacementEditMode: false,
+          cesiumPlacementDraftModelId: null,
+          cesiumPlacementDraft: null,
+        }
+      : { cesiumPlacementEditMode: true, editEnabled: true }
+  )),
+  beginCesiumPlacementDraft: (modelId, conversion) => set({
+    cesiumPlacementDraftModelId: modelId,
+    cesiumPlacementDraft: {
+      eastings: conversion.eastings,
+      northings: conversion.northings,
+      orthogonalHeight: conversion.orthogonalHeight,
+      // IFC MapConversion's x-axis cos/sin pair is optional in the schema.
+      // When absent, the convention is "no rotation": cos=1, sin=0.
+      xAxisAbscissa: conversion.xAxisAbscissa ?? 1,
+      xAxisOrdinate: conversion.xAxisOrdinate ?? 0,
+    },
+  }),
+  updateCesiumPlacementDraft: (values) => set((state) => ({
+    cesiumPlacementDraft: state.cesiumPlacementDraft
+      ? { ...state.cesiumPlacementDraft, ...values }
+      : null,
+  })),
+  resetCesiumPlacementDraft: () => set({
+    cesiumPlacementDraftModelId: null,
+    cesiumPlacementDraft: null,
+  }),
 });