@ifc-lite/viewer 1.17.2 → 1.17.4

package/src/store/slices/dataSlice.ts

@@ -9,12 +9,28 @@
 import type { StateCreator } from 'zustand';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import type { GeometryResult, CoordinateInfo } from '@ifc-lite/geometry';
+import type { FederatedModel } from '../types.js';
 import { DATA_DEFAULTS } from '../constants.js';
 
+/**
+ * Cross-slice state that dataSlice reads/writes via the combined store.
+ *
+ * Data updaters sync `ifcDataStore` / `geometryResult` into the per-model
+ * entry inside the ModelSlice `models` map so that federation stays
+ * consistent.  The types below describe the minimal ModelSlice surface
+ * that dataSlice accesses through the merged Zustand state.
+ */
+interface DataCrossSliceState {
+  activeModelId: string | null;
+  models: Map<string, FederatedModel>;
+}
+
 export interface DataSlice {
   // State
   ifcDataStore: IfcDataStore | null;
   geometryResult: GeometryResult | null;
+  geometryUpdateTick: number;
+  boundedGeometryMode: boolean;
   /** Transient overlay colors (lens/IDS/sdk overlays). */
   pendingColorUpdates: Map<number, [number, number, number, number]> | null;
   /** Persistent mesh color updates (IFC deferred style/material colors). */
@@ -23,7 +39,9 @@ export interface DataSlice {
   // Actions
   setIfcDataStore: (result: IfcDataStore | null) => void;
   setGeometryResult: (result: GeometryResult | null) => void;
+  setBoundedGeometryMode: (enabled: boolean) => void;
   appendGeometryBatch: (meshes: GeometryResult['meshes'], coordinateInfo?: CoordinateInfo) => void;
+  releaseGeometryMemory: () => void;
   /** Persist mesh color changes in geometryResult (used for IFC style/material updates). */
   updateMeshColors: (updates: Map<number, [number, number, number, number]>) => void;
   /** Set pending color updates for the renderer without cloning mesh data.
@@ -49,17 +67,53 @@ const getDefaultCoordinateInfo = (): CoordinateInfo => ({
   hasLargeCoordinates: DATA_DEFAULTS.HAS_LARGE_COORDINATES,
 });
 
-export const createDataSlice: StateCreator<DataSlice, [], [], DataSlice> = (set) => ({
+const EMPTY_POSITIONS = new Float32Array(0);
+const EMPTY_NORMALS = new Float32Array(0);
+const EMPTY_INDICES = new Uint32Array(0);
+
+export const createDataSlice: StateCreator<DataSlice & DataCrossSliceState, [], [], DataSlice> = (set, get) => ({
   // Initial state
   ifcDataStore: null,
   geometryResult: null,
+  geometryUpdateTick: 0,
+  boundedGeometryMode: false,
   pendingColorUpdates: null,
   pendingMeshColorUpdates: null,
 
   // Actions
-  setIfcDataStore: (ifcDataStore) => set({ ifcDataStore }),
+  setIfcDataStore: (ifcDataStore) => set((state) => {
+    const modelId = state.activeModelId;
+    if (!modelId) {
+      return { ifcDataStore };
+    }
+
+    const model = state.models.get(modelId);
+    if (!model) {
+      return { ifcDataStore };
+    }
+
+    const models = new Map(state.models);
+    models.set(modelId, { ...model, ifcDataStore });
+    return { ifcDataStore, models };
+  }),
 
-  setGeometryResult: (geometryResult) => set({ geometryResult }),
+  setGeometryResult: (geometryResult) => set((state) => {
+    const modelId = state.activeModelId;
+    if (!modelId) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+
+    const model = state.models.get(modelId);
+    if (!model) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+
+    const models = new Map(state.models);
+    models.set(modelId, { ...model, geometryResult });
+    return { geometryResult, models, geometryUpdateTick: state.geometryUpdateTick + 1 };
+  }),
+
+  setBoundedGeometryMode: (boundedGeometryMode) => set({ boundedGeometryMode }),
 
   appendGeometryBatch: (meshes, coordinateInfo) => set((state) => {
     // Incremental totals: O(batch_size) instead of O(total_accumulated) .reduce()
@@ -71,33 +125,81 @@ export const createDataSlice: StateCreator<DataSlice, [], [], DataSlice> = (set)
     }
 
     if (!state.geometryResult) {
-      return {
-        geometryResult: {
-          meshes: meshes.slice(),
-          totalTriangles: batchTriangles,
-          totalVertices: batchVertices,
-          coordinateInfo: coordinateInfo || getDefaultCoordinateInfo(),
-        },
+      const geometryResult = {
+        meshes: meshes.slice(),
+        totalTriangles: batchTriangles,
+        totalVertices: batchVertices,
+        coordinateInfo: coordinateInfo || getDefaultCoordinateInfo(),
       };
+      const modelId = state.activeModelId;
+      if (!modelId) {
+        return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+      }
+      const model = state.models.get(modelId);
+      if (!model) {
+        return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+      }
+      const models = new Map(state.models);
+      models.set(modelId, { ...model, geometryResult });
+      return { geometryResult, models, geometryUpdateTick: state.geometryUpdateTick + 1 };
     }
 
-    // PERF FIX: Push into existing array — O(batch_size) instead of O(total).
-    // The old [...old, ...new] spread copied ALL accumulated meshes every batch,
-    // causing O(N²) total work (e.g., 176K meshes × 350 batches = 31M copies).
-    // Zustand detects changes via the new geometryResult object reference below.
-    const existing = state.geometryResult.meshes;
+    // Mutate the existing array in-place (O(batch) per append) instead of
+    // .concat() (O(total) per append) to avoid O(N²) for large files.
+    // The new geometryResult object reference below is sufficient for
+    // Zustand/React change detection — array identity doesn't need to change.
+    const existingMeshes = state.geometryResult.meshes;
     for (let i = 0; i < meshes.length; i++) {
-      existing.push(meshes[i]);
+      existingMeshes.push(meshes[i]);
     }
 
-    return {
-      geometryResult: {
-        ...state.geometryResult,
-        totalTriangles: state.geometryResult.totalTriangles + batchTriangles,
-        totalVertices: state.geometryResult.totalVertices + batchVertices,
-        coordinateInfo: coordinateInfo || state.geometryResult.coordinateInfo,
-      },
+    const geometryResult = {
+      ...state.geometryResult,
+      meshes: existingMeshes,
+      totalTriangles: state.geometryResult.totalTriangles + batchTriangles,
+      totalVertices: state.geometryResult.totalVertices + batchVertices,
+      coordinateInfo: coordinateInfo || state.geometryResult.coordinateInfo,
+    };
+    const modelId = state.activeModelId;
+    if (!modelId) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+    const model = state.models.get(modelId);
+    if (!model) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+    const models = new Map(state.models);
+    models.set(modelId, { ...model, geometryResult });
+    return { geometryResult, models, geometryUpdateTick: state.geometryUpdateTick + 1 };
+  }),
+
+  releaseGeometryMemory: () => set((state) => {
+    if (!state.geometryResult || !state.boundedGeometryMode) {
+      return {};
+    }
+
+    const meshes = state.geometryResult.meshes;
+    for (let i = 0; i < meshes.length; i++) {
+      meshes[i].positions = EMPTY_POSITIONS;
+      meshes[i].normals = EMPTY_NORMALS;
+      meshes[i].indices = EMPTY_INDICES;
+    }
+
+    const geometryResult = {
+      ...state.geometryResult,
+      meshes,
     };
+    const modelId = state.activeModelId;
+    if (!modelId) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+    const model = state.models.get(modelId);
+    if (!model) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+    const models = new Map(state.models);
+    models.set(modelId, { ...model, geometryResult });
+    return { geometryResult, models, geometryUpdateTick: state.geometryUpdateTick + 1 };
   }),
 
   updateMeshColors: (updates) => set((state) => {
@@ -136,11 +238,20 @@ export const createDataSlice: StateCreator<DataSlice, [], [], DataSlice> = (set)
 
   updateCoordinateInfo: (coordinateInfo) => set((state) => {
     if (!state.geometryResult) return {};
-    return {
-      geometryResult: {
-        ...state.geometryResult,
-        coordinateInfo,
-      },
+    const geometryResult = {
+      ...state.geometryResult,
+      coordinateInfo,
     };
+    const modelId = state.activeModelId;
+    if (!modelId) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+    const model = state.models.get(modelId);
+    if (!model) {
+      return { geometryResult, geometryUpdateTick: state.geometryUpdateTick + 1 };
+    }
+    const models = new Map(state.models);
+    models.set(modelId, { ...model, geometryResult });
+    return { geometryResult, models, geometryUpdateTick: state.geometryUpdateTick + 1 };
   }),
 });

package/src/store/slices/desktopEntitlementSlice.ts

@@ -0,0 +1,86 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { StateCreator } from 'zustand';
+import {
+  getDefaultDesktopEntitlement,
+  type DesktopEntitlement,
+  type DesktopEntitlementSource,
+  type DesktopEntitlementStatus,
+} from '@/lib/desktop-product';
+
+const STORAGE_KEY = 'ifc-lite:desktop-entitlement:v1';
+
+function sanitizeTimestamp(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function parseStoredEntitlement(raw: string | null): DesktopEntitlement {
+  if (!raw) {
+    return getDefaultDesktopEntitlement();
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<DesktopEntitlement> | null;
+    const fallback = getDefaultDesktopEntitlement();
+    return {
+      tier: parsed?.tier === 'pro' ? 'pro' : 'free',
+      status: isEntitlementStatus(parsed?.status) ? parsed.status : fallback.status,
+      source: isEntitlementSource(parsed?.source) ? parsed.source : fallback.source,
+      userId: typeof parsed?.userId === 'string' ? parsed.userId : null,
+      validatedAt: sanitizeTimestamp(parsed?.validatedAt),
+      graceUntil: sanitizeTimestamp(parsed?.graceUntil),
+      trialEndsAt: sanitizeTimestamp(parsed?.trialEndsAt),
+    };
+  } catch {
+    return getDefaultDesktopEntitlement();
+  }
+}
+
+function isEntitlementStatus(value: unknown): value is DesktopEntitlementStatus {
+  return value === 'anonymous'
+    || value === 'signed_out'
+    || value === 'active'
+    || value === 'trial'
+    || value === 'expired'
+    || value === 'grace_offline';
+}
+
+function isEntitlementSource(value: unknown): value is DesktopEntitlementSource {
+  return value === 'anonymous' || value === 'clerk_claims' || value === 'cached';
+}
+
+function persistEntitlement(entitlement: DesktopEntitlement): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(entitlement));
+  } catch {
+    // ignore storage failures
+  }
+}
+
+export interface DesktopEntitlementSlice {
+  desktopEntitlement: DesktopEntitlement;
+  setDesktopEntitlement: (entitlement: DesktopEntitlement) => void;
+  clearDesktopEntitlement: () => void;
+}
+
+export const createDesktopEntitlementSlice: StateCreator<
+  DesktopEntitlementSlice,
+  [],
+  [],
+  DesktopEntitlementSlice
+> = (set) => ({
+  desktopEntitlement: parseStoredEntitlement(typeof localStorage === 'undefined' ? null : localStorage.getItem(STORAGE_KEY)),
+
+  setDesktopEntitlement: (desktopEntitlement) => {
+    persistEntitlement(desktopEntitlement);
+    set({ desktopEntitlement });
+  },
+
+  clearDesktopEntitlement: () => {
+    const next = getDefaultDesktopEntitlement();
+    persistEntitlement(next);
+    set({ desktopEntitlement: next });
+  },
+});

package/src/store/slices/loadingSlice.ts

@@ -11,23 +11,35 @@ import type { StateCreator } from 'zustand';
 export interface LoadingSlice {
   // State
   loading: boolean;
-  progress: { phase: string; percent: number } | null;
+  geometryStreamingActive: boolean;
+  progress: { phase: string; percent: number; indeterminate?: boolean } | null;
+  geometryProgress: { phase: string; percent: number; indeterminate?: boolean } | null;
+  metadataProgress: { phase: string; percent: number; indeterminate?: boolean } | null;
   error: string | null;
 
   // Actions
   setLoading: (loading: boolean) => void;
-  setProgress: (progress: { phase: string; percent: number } | null) => void;
+  setGeometryStreamingActive: (active: boolean) => void;
+  setProgress: (progress: { phase: string; percent: number; indeterminate?: boolean } | null) => void;
+  setGeometryProgress: (progress: { phase: string; percent: number; indeterminate?: boolean } | null) => void;
+  setMetadataProgress: (progress: { phase: string; percent: number; indeterminate?: boolean } | null) => void;
   setError: (error: string | null) => void;
 }
 
 export const createLoadingSlice: StateCreator<LoadingSlice, [], [], LoadingSlice> = (set) => ({
   // Initial state
   loading: false,
+  geometryStreamingActive: false,
   progress: null,
+  geometryProgress: null,
+  metadataProgress: null,
   error: null,
 
   // Actions
   setLoading: (loading) => set({ loading }),
+  setGeometryStreamingActive: (geometryStreamingActive) => set({ geometryStreamingActive }),
   setProgress: (progress) => set({ progress }),
+  setGeometryProgress: (geometryProgress) => set({ geometryProgress }),
+  setMetadataProgress: (metadataProgress) => set({ metadataProgress }),
   setError: (error) => set({ error }),
 });

package/src/store/slices/modelSlice.ts

@@ -25,6 +25,10 @@ export interface ModelSlice {
   // Actions
   /** Add a new model to the federation */
   addModel: (model: FederatedModel) => void;
+  /** Add or merge a model in place */
+  upsertModel: (model: FederatedModel) => void;
+  /** Update an existing model with partial fields */
+  updateModel: (modelId: string, patch: Partial<FederatedModel>) => void;
   /** Remove a model from the federation */
   removeModel: (modelId: string) => void;
   /** Clear all models */
@@ -81,7 +85,12 @@ export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (s
     // If first model, make it active
     // If adding more models, collapse all existing by default
     if (state.models.size === 0) {
-      return { models: newModels, activeModelId: model.id };
+      return {
+        models: newModels,
+        activeModelId: model.id,
+        ifcDataStore: model.ifcDataStore ?? null,
+        geometryResult: model.geometryResult ?? null,
+      };
     } else {
       // Collapse existing models when adding new ones
       for (const [id, m] of newModels) {
@@ -93,6 +102,36 @@ export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (s
     }
   }),
 
+  upsertModel: (model) => set((state) => {
+    const newModels = new Map(state.models);
+    const existing = newModels.get(model.id);
+    newModels.set(model.id, existing ? { ...existing, ...model } : model);
+    const activeModelId = state.activeModelId ?? model.id;
+    const activeModel = newModels.get(activeModelId) ?? null;
+
+    return {
+      models: newModels,
+      activeModelId,
+      ifcDataStore: activeModel?.ifcDataStore ?? null,
+      geometryResult: activeModel?.geometryResult ?? null,
+    };
+  }),
+
+  updateModel: (modelId, patch) => set((state) => {
+    const model = state.models.get(modelId);
+    if (!model) return {};
+
+    const updatedModel = { ...model, ...patch };
+    const newModels = new Map(state.models);
+    newModels.set(modelId, updatedModel);
+
+    return {
+      models: newModels,
+      ifcDataStore: state.activeModelId === modelId ? updatedModel.ifcDataStore : state.ifcDataStore,
+      geometryResult: state.activeModelId === modelId ? updatedModel.geometryResult : state.geometryResult,
+    };
+  }),
+
   removeModel: (modelId) => set((state) => {
     const newModels = new Map(state.models);
     newModels.delete(modelId);
@@ -107,7 +146,14 @@ export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (s
       newActiveId = remaining.length > 0 ? remaining[0] : null;
     }
 
-    return { models: newModels, activeModelId: newActiveId };
+    const activeModel = newActiveId ? newModels.get(newActiveId) : null;
+
+    return {
+      models: newModels,
+      activeModelId: newActiveId,
+      ifcDataStore: activeModel?.ifcDataStore ?? null,
+      geometryResult: activeModel?.geometryResult ?? null,
+    };
   }),
 
   clearAllModels: () => {
@@ -116,10 +162,19 @@ export const createModelSlice: StateCreator<ModelSlice, [], [], ModelSlice> = (s
     return set({
       models: new Map(),
       activeModelId: null,
+      ifcDataStore: null,
+      geometryResult: null,
     });
   },
 
-  setActiveModel: (modelId) => set({ activeModelId: modelId }),
+  setActiveModel: (modelId) => set((state) => {
+    const activeModel = modelId ? state.models.get(modelId) : null;
+    return {
+      activeModelId: modelId,
+      ifcDataStore: activeModel?.ifcDataStore ?? null,
+      geometryResult: activeModel?.geometryResult ?? null,
+    };
+  }),
 
   setModelVisibility: (modelId, visible) => set((state) => {
     const model = state.models.get(modelId);

package/src/store/slices/mutationSlice.ts

@@ -11,6 +11,13 @@ import type { ViewerState } from '../index.js';
 import type { MutablePropertyView } from '@ifc-lite/mutations';
 import type { Mutation, ChangeSet, PropertyValue } from '@ifc-lite/mutations';
 import { PropertyValueType, QuantityType } from '@ifc-lite/data';
+import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+
+/** Tracks georeferencing field mutations per model */
+export interface GeorefMutationData {
+  projectedCRS?: Partial<ProjectedCRS>;
+  mapConversion?: Partial<MapConversion>;
+}
 
 export interface MutationSlice {
   // State
@@ -28,6 +35,26 @@ export interface MutationSlice {
   dirtyModels: Set<string>;
   /** Version counter to trigger re-renders when mutations change */
   mutationVersion: number;
+  /** Georeferencing mutations per model */
+  georefMutations: Map<string, GeorefMutationData>;
+
+  // Actions - Georeferencing Mutations
+  /** Set a georeferencing field value */
+  setGeorefField: (
+    modelId: string,
+    entity: 'projectedCRS' | 'mapConversion',
+    field: string,
+    value: string | number,
+    oldValue?: string | number
+  ) => void;
+  /** Set multiple georeferencing field values atomically */
+  setGeorefFields: (
+    modelId: string,
+    entity: 'projectedCRS' | 'mapConversion',
+    fields: Array<{ field: string; value: string | number; oldValue?: string | number }>
+  ) => void;
+  /** Get merged georef mutations for a model */
+  getGeorefMutations: (modelId: string) => GeorefMutationData | undefined;
 
   // Actions - Mutation View Management
   /** Get or create mutation view for a model */
@@ -154,6 +181,60 @@ export const createMutationSlice: StateCreator<
   redoStacks: new Map(),
   dirtyModels: new Set(),
   mutationVersion: 0,
+  georefMutations: new Map(),
+
+  // Georeferencing Mutations
+  setGeorefField: (modelId, entity, field, value, oldValue) => {
+    get().setGeorefFields(modelId, entity, [{ field, value, oldValue }]);
+  },
+
+  setGeorefFields: (modelId, entity, fields) => {
+    if (fields.length === 0) return;
+    set((state) => {
+      const newGeorefMuts = new Map(state.georefMutations);
+      const modelMuts = { ...(newGeorefMuts.get(modelId) || {}) };
+      const entityMuts = { ...(modelMuts[entity] || {}) } as Record<string, unknown>;
+      for (const entry of fields) {
+        entityMuts[entry.field] = entry.value;
+      }
+      newGeorefMuts.set(modelId, { ...modelMuts, [entity]: entityMuts });
+
+      // Track undo
+      const newUndoStacks = new Map(state.undoStacks);
+      const stack = newUndoStacks.get(modelId) || [];
+      const nextMutations: Mutation[] = fields.map(entry => ({
+        id: `mut_georef_${entity}_${entry.field}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+        type: 'UPDATE_ATTRIBUTE',
+        timestamp: Date.now(),
+        modelId,
+        entityId: 0, // georef entities don't map to a specific element
+        attributeName: `georef.${entity}.${entry.field}`,
+        oldValue: entry.oldValue,
+        newValue: entry.value,
+        propName: entry.field,
+        psetName: entity,
+      }));
+      newUndoStacks.set(modelId, [...stack, ...nextMutations]);
+
+      const newRedoStacks = new Map(state.redoStacks);
+      newRedoStacks.set(modelId, []);
+
+      const newDirty = new Set(state.dirtyModels);
+      newDirty.add(modelId);
+
+      return {
+        georefMutations: newGeorefMuts,
+        undoStacks: newUndoStacks,
+        redoStacks: newRedoStacks,
+        dirtyModels: newDirty,
+        mutationVersion: state.mutationVersion + 1,
+      };
+    });
+  },
+
+  getGeorefMutations: (modelId) => {
+    return get().georefMutations.get(modelId);
+  },
 
   // Mutation View Management
   getMutationView: (modelId) => {
@@ -388,6 +469,48 @@ export const createMutationSlice: StateCreator<
     if (undoStack.length === 0) return;
 
     const mutation = undoStack[undoStack.length - 1];
+
+    // Handle georef mutations directly on georefMutations map
+    if (mutation.type === 'UPDATE_ATTRIBUTE' && mutation.attributeName?.startsWith('georef.')) {
+      const parts = mutation.attributeName.split('.');
+      const entity = parts[1] as 'projectedCRS' | 'mapConversion';
+      const field = parts[2];
+      set((s) => {
+        const newGeorefMuts = new Map(s.georefMutations);
+        const modelMuts = { ...(newGeorefMuts.get(modelId) || {}) };
+        const entityMuts = { ...(modelMuts[entity] || {}) } as Record<string, unknown>;
+        if (mutation.oldValue !== undefined && mutation.oldValue !== null) {
+          entityMuts[field] = mutation.oldValue;
+        } else {
+          delete entityMuts[field];
+        }
+        if (Object.keys(entityMuts).length === 0) {
+          delete modelMuts[entity];
+        } else {
+          modelMuts[entity] = entityMuts as typeof modelMuts[typeof entity];
+        }
+        if (Object.keys(modelMuts).length === 0) {
+          newGeorefMuts.delete(modelId);
+        } else {
+          newGeorefMuts.set(modelId, modelMuts);
+        }
+
+        const newUndoStacks = new Map(s.undoStacks);
+        newUndoStacks.set(modelId, undoStack.slice(0, -1));
+        const newRedoStacks = new Map(s.redoStacks);
+        const redoStack = newRedoStacks.get(modelId) || [];
+        newRedoStacks.set(modelId, [...redoStack, mutation]);
+
+        return {
+          georefMutations: newGeorefMuts,
+          undoStacks: newUndoStacks,
+          redoStacks: newRedoStacks,
+          mutationVersion: s.mutationVersion + 1,
+        };
+      });
+      return;
+    }
+
     const view = state.mutationViews.get(modelId);
     if (!view) return;
 
@@ -465,6 +588,48 @@ export const createMutationSlice: StateCreator<
     if (redoStack.length === 0) return;
 
     const mutation = redoStack[redoStack.length - 1];
+
+    // Handle georef mutations directly
+    if (mutation.type === 'UPDATE_ATTRIBUTE' && mutation.attributeName?.startsWith('georef.')) {
+      const parts = mutation.attributeName.split('.');
+      const entity = parts[1] as 'projectedCRS' | 'mapConversion';
+      const field = parts[2];
+      set((s) => {
+        const newGeorefMuts = new Map(s.georefMutations);
+        const modelMuts = { ...(newGeorefMuts.get(modelId) || {}) };
+        const entityMuts = { ...(modelMuts[entity] || {}) } as Record<string, unknown>;
+        if (mutation.newValue !== undefined && mutation.newValue !== null) {
+          entityMuts[field] = mutation.newValue;
+        } else {
+          delete entityMuts[field];
+        }
+        if (Object.keys(entityMuts).length === 0) {
+          delete modelMuts[entity];
+        } else {
+          modelMuts[entity] = entityMuts as typeof modelMuts[typeof entity];
+        }
+        if (Object.keys(modelMuts).length === 0) {
+          newGeorefMuts.delete(modelId);
+        } else {
+          newGeorefMuts.set(modelId, modelMuts);
+        }
+
+        const newRedoStacks = new Map(s.redoStacks);
+        newRedoStacks.set(modelId, redoStack.slice(0, -1));
+        const newUndoStacks = new Map(s.undoStacks);
+        const undoStack = newUndoStacks.get(modelId) || [];
+        newUndoStacks.set(modelId, [...undoStack, mutation]);
+
+        return {
+          georefMutations: newGeorefMuts,
+          undoStacks: newUndoStacks,
+          redoStacks: newRedoStacks,
+          mutationVersion: s.mutationVersion + 1,
+        };
+      });
+      return;
+    }
+
     const view = state.mutationViews.get(modelId);
     if (!view) return;
 
@@ -606,6 +771,14 @@ export const createMutationSlice: StateCreator<
     for (const view of get().mutationViews.values()) {
       count += view.getModifiedEntityCount();
     }
+    // Include models with georef-only edits
+    for (const [modelId, gm] of get().georefMutations) {
+      const hasGeoref = (gm.projectedCRS && Object.keys(gm.projectedCRS).length > 0)
+        || (gm.mapConversion && Object.keys(gm.mapConversion).length > 0);
+      if (hasGeoref && !get().mutationViews.has(modelId)) {
+        count += 1; // count the model as having modifications
+      }
+    }
     return count;
   },
 
@@ -626,10 +799,14 @@ export const createMutationSlice: StateCreator<
       const newDirty = new Set(state.dirtyModels);
       newDirty.delete(modelId);
 
+      const newGeorefMuts = new Map(state.georefMutations);
+      newGeorefMuts.delete(modelId);
+
       return {
         undoStacks: newUndoStacks,
         redoStacks: newRedoStacks,
         dirtyModels: newDirty,
+        georefMutations: newGeorefMuts,
         mutationVersion: state.mutationVersion + 1,
       };
     });
@@ -644,6 +821,7 @@ export const createMutationSlice: StateCreator<
       undoStacks: new Map(),
       redoStacks: new Map(),
       dirtyModels: new Set(),
+      georefMutations: new Map(),
       mutationVersion: state.mutationVersion + 1,
     }));
   },