@ifc-lite/viewer 1.17.3 → 1.17.4

package/src/services/desktop-preferences.ts

@@ -0,0 +1,44 @@
+/* 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/. */
+
+export interface DesktopPreferences {
+  reopenLastModelOnLaunch: boolean;
+  restoreWorkspaceLayoutOnLaunch: boolean;
+}
+
+const STORAGE_KEY = 'ifc-lite:desktop-preferences:v1';
+const CHANGED_EVENT = 'ifc-lite:desktop-preferences-changed';
+
+const DEFAULT_PREFERENCES: DesktopPreferences = {
+  reopenLastModelOnLaunch: true,
+  restoreWorkspaceLayoutOnLaunch: true,
+};
+
+function sanitizePreferences(value: unknown): DesktopPreferences {
+  const parsed = (value && typeof value === 'object') ? value as Partial<DesktopPreferences> : {};
+  return {
+    reopenLastModelOnLaunch: parsed.reopenLastModelOnLaunch ?? DEFAULT_PREFERENCES.reopenLastModelOnLaunch,
+    restoreWorkspaceLayoutOnLaunch: parsed.restoreWorkspaceLayoutOnLaunch ?? DEFAULT_PREFERENCES.restoreWorkspaceLayoutOnLaunch,
+  };
+}
+
+export function getDesktopPreferences(): DesktopPreferences {
+  try {
+    return sanitizePreferences(JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}'));
+  } catch {
+    return { ...DEFAULT_PREFERENCES };
+  }
+}
+
+export function updateDesktopPreferences(updates: Partial<DesktopPreferences>): DesktopPreferences {
+  const next = { ...getDesktopPreferences(), ...updates };
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  window.dispatchEvent(new Event(CHANGED_EVENT));
+  return next;
+}
+
+export function subscribeDesktopPreferences(listener: () => void): () => void {
+  window.addEventListener(CHANGED_EVENT, listener);
+  return () => window.removeEventListener(CHANGED_EVENT, listener);
+}

package/src/services/file-dialog.ts

@@ -0,0 +1,147 @@
+/* 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/. */
+
+type InvokeFn = <T>(cmd: string, args?: Record<string, unknown>) => Promise<T>;
+
+export interface NativeFileHandle {
+  path: string;
+  name: string;
+  size: number;
+  modifiedMs?: number | null;
+}
+
+export interface GenericFileDialogOptions {
+  title?: string;
+  filters?: Array<{ name: string; extensions: string[] }>;
+}
+
+async function loadInvokeFromTauriModule(): Promise<InvokeFn | null> {
+  try {
+    const core = await import('@tauri-apps/api/core');
+    return typeof core.invoke === 'function' ? core.invoke as InvokeFn : null;
+  } catch {
+    return null;
+  }
+}
+
+async function loadDialogModule(): Promise<{
+  open: (options?: {
+    multiple?: boolean;
+    directory?: boolean;
+    filters?: Array<{ name: string; extensions: string[] }>;
+    title?: string;
+  }) => Promise<string | string[] | null>;
+} | null> {
+  try {
+    return await import('@tauri-apps/plugin-dialog');
+  } catch {
+    return null;
+  }
+}
+
+async function loadFsModule(): Promise<{
+  stat: (path: string) => Promise<{ size: number }>;
+} | null> {
+  try {
+    return await import('@tauri-apps/plugin-fs');
+  } catch {
+    return null;
+  }
+}
+
+async function getInvoke(): Promise<InvokeFn> {
+  const win = globalThis as unknown as { __TAURI_INTERNALS__?: { invoke: InvokeFn } };
+  if (win.__TAURI_INTERNALS__?.invoke) {
+    return win.__TAURI_INTERNALS__.invoke;
+  }
+  const moduleInvoke = await loadInvokeFromTauriModule();
+  if (moduleInvoke) {
+    return moduleInvoke;
+  }
+  throw new Error('Tauri API not available');
+}
+
+export async function openIfcFileDialog(): Promise<NativeFileHandle | null> {
+  try {
+    const invoke = await getInvoke();
+    return await invoke<NativeFileHandle | null>('open_ifc_file');
+  } catch {
+    // Expected in browser builds — fall through to plugin fallback, then browser file input.
+  }
+
+  try {
+    const dialog = await loadDialogModule();
+    const fs = await loadFsModule();
+    if (!dialog || !fs) {
+      return null;
+    }
+
+    const selected = await dialog.open({
+      multiple: false,
+      directory: false,
+      title: 'Open IFC File',
+      filters: [
+        { name: 'IFC Files', extensions: ['ifc', 'ifczip', 'ifcxml'] },
+        { name: 'All Files', extensions: ['*'] },
+      ],
+    });
+    if (!selected || Array.isArray(selected)) {
+      return null;
+    }
+
+    const metadata = await fs.stat(selected);
+    const normalizedPath = selected.toString();
+    const pathSegments = normalizedPath.split(/[\\/]/);
+    const name = pathSegments[pathSegments.length - 1] || 'unknown.ifc';
+
+    return {
+      path: normalizedPath,
+      name,
+      size: metadata.size,
+    };
+  } catch {
+    // No Tauri plugin available — caller falls back to browser <input type="file">.
+    return null;
+  }
+}
+
+export async function readNativeFile(path: string): Promise<Uint8Array> {
+  try {
+    const invoke = await getInvoke();
+    const bytes = await invoke<number[]>('read_native_file', { path });
+    return Uint8Array.from(bytes);
+  } catch (error) {
+    console.warn('[FileDialog] Falling back to plugin-fs read for native file:', error);
+    const fs = await import('@tauri-apps/plugin-fs');
+    return fs.readFile(path);
+  }
+}
+
+export async function openGenericFileDialog(options: GenericFileDialogOptions = {}): Promise<File | null> {
+  try {
+    const dialog = await loadDialogModule();
+    if (!dialog) {
+      return null;
+    }
+
+    const selected = await dialog.open({
+      multiple: false,
+      directory: false,
+      title: options.title,
+      filters: options.filters,
+    });
+    if (!selected || Array.isArray(selected)) {
+      return null;
+    }
+
+    const normalizedPath = selected.toString();
+    const bytes = await readNativeFile(normalizedPath);
+    const pathSegments = normalizedPath.split(/[\\/]/);
+    const name = pathSegments[pathSegments.length - 1] || 'document';
+    return new File([bytes], name, { type: 'application/octet-stream' });
+  } catch (error) {
+    console.warn('[FileDialog] Failed to open generic native file dialog:', error);
+    return null;
+  }
+}

package/src/services/tauri-core-stub.ts

@@ -0,0 +1,7 @@
+/* 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/. */
+
+export async function invoke(): Promise<never> {
+  throw new Error('Tauri core API is unavailable in the browser build');
+}

package/src/services/tauri-dialog-stub.ts

@@ -0,0 +1,7 @@
+/* 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/. */
+
+export async function open(): Promise<null> {
+  return null;
+}

package/src/services/tauri-fs-stub.ts

@@ -0,0 +1,7 @@
+/* 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/. */
+
+export async function readFile(_path: string): Promise<Uint8Array> {
+  throw new Error('Tauri file system API is unavailable in the browser benchmark build');
+}

package/src/store/index.ts

@@ -32,6 +32,8 @@ import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.
 import { createLensSlice, type LensSlice } from './slices/lensSlice.js';
 import { createScriptSlice, type ScriptSlice } from './slices/scriptSlice.js';
 import { createChatSlice, type ChatSlice } from './slices/chatSlice.js';
+import { createCesiumSlice, type CesiumSlice } from './slices/cesiumSlice.js';
+import { createDesktopEntitlementSlice, type DesktopEntitlementSlice } from './slices/desktopEntitlementSlice.js';
 import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
 // Import constants for reset function
@@ -76,6 +78,10 @@ export type { ScriptSlice } from './slices/scriptSlice.js';
 
 // Re-export Chat types
 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';
 
 // Combined store type
 export type ViewerState = LoadingSlice &
@@ -97,14 +103,16 @@ export type ViewerState = LoadingSlice &
   PinboardSlice &
   LensSlice &
   ScriptSlice &
-  ChatSlice & {
+  ChatSlice &
+  CesiumSlice &
+  DesktopEntitlementSlice & {
     resetViewerState: () => void;
   };
 
 /**
  * Main viewer store combining all slices
  */
-export const useViewerStore = create<ViewerState>()((...args) => ({
+const createViewerStore = () => create<ViewerState>()((...args) => ({
   // Spread all slices
   ...createLoadingSlice(...args),
   ...createSelectionSlice(...args),
@@ -126,6 +134,8 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
   ...createLensSlice(...args),
   ...createScriptSlice(...args),
   ...createChatSlice(...args),
+  ...createCesiumSlice(...args),
+  ...createDesktopEntitlementSlice(...args),
 
   // Reset all viewer state when loading new file
   // Note: Does NOT clear models - use clearAllModels() for that
@@ -157,6 +167,13 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       isolatedEntitiesByModel: new Map(),
 
       // Data
+      loading: false,
+      geometryStreamingActive: false,
+      geometryUpdateTick: 0,
+      progress: null,
+      geometryProgress: null,
+      metadataProgress: null,
+      error: null,
       pendingColorUpdates: null,
       pendingMeshColorUpdates: null,
 
@@ -206,6 +223,14 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       separationLinesIntensity: UI_DEFAULTS.SEPARATION_LINES_INTENSITY,
       separationLinesRadius: UI_DEFAULTS.SEPARATION_LINES_RADIUS,
 
+      // Cesium
+      cesiumEnabled: false,
+      cesiumTerrainHeight: null,
+      cesiumTerrainClamp: false,
+      cesiumSourceModelId: null,
+      cesiumTerrainClipY: null,
+      cesiumGlbLoaded: false,
+
       // Drawing 2D
       drawing2D: null,
       drawing2DStatus: 'idle' as const,
@@ -317,3 +342,16 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
     });
   },
 }));
+
+const STORE_SINGLETON_KEY = '__ifc_lite_viewer_store__';
+const globalStoreRegistry = globalThis as typeof globalThis & {
+  [STORE_SINGLETON_KEY]?: ReturnType<typeof createViewerStore>;
+};
+
+export function getViewerStoreApi() {
+  return globalStoreRegistry[STORE_SINGLETON_KEY] ?? (
+    globalStoreRegistry[STORE_SINGLETON_KEY] = createViewerStore()
+  );
+}
+
+export const useViewerStore = getViewerStoreApi();

package/src/store/slices/cesiumSlice.ts

@@ -0,0 +1,122 @@
+/* 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/. */
+
+/**
+ * Cesium 3D Tiles overlay state slice.
+ *
+ * Manages the enabled/disabled state, selected data source, and Cesium ion
+ * access token for the optional real-world 3D context overlay.
+ *
+ * Token resolution:
+ *   1. User-provided override in localStorage
+ *   2. Build-time default token via VITE_CESIUM_ION_TOKEN env var
+ *   → Users never need to configure anything; the app ships with a working token.
+ */
+
+import type { StateCreator } from 'zustand';
+
+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)
+
+export interface CesiumSlice {
+  // State
+  cesiumEnabled: boolean;
+  cesiumDataSource: CesiumDataSource;
+  /** Resolved Cesium ion access token (user override or build-time default). */
+  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;
+  /** Model ID that the Cesium overlay is currently displaying. */
+  cesiumSourceModelId: string | null;
+  /** 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;
+
+  // Actions
+  setCesiumEnabled: (enabled: boolean) => void;
+  toggleCesium: () => void;
+  setCesiumDataSource: (source: CesiumDataSource) => void;
+  setCesiumIonToken: (token: string) => void;
+  setCesiumTerrainEnabled: (enabled: boolean) => void;
+  setCesiumTerrainClamp: (clamp: boolean) => void;
+  setCesiumTerrainHeight: (height: number | null) => void;
+  setCesiumSourceModelId: (modelId: string | null) => void;
+  setCesiumTerrainClipY: (y: number | null) => void;
+  setCesiumGlbLoaded: (loaded: boolean) => void;
+}
+
+const STORAGE_KEY_ION_TOKEN = 'ifc-lite:cesium-ion-token';
+const STORAGE_KEY_DATA_SOURCE = 'ifc-lite:cesium-data-source';
+
+/**
+ * Default Cesium ion token provided at build time.
+ * Set via VITE_CESIUM_ION_TOKEN in .env or CI environment.
+ * This means users never need to configure a token manually.
+ */
+const DEFAULT_ION_TOKEN: string = (import.meta as any).env?.VITE_CESIUM_ION_TOKEN ?? '';
+
+function loadFromStorage(key: string, fallback: string): string {
+  try {
+    return localStorage.getItem(key) ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function saveToStorage(key: string, value: string): void {
+  try {
+    localStorage.setItem(key, value);
+  } 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';
+}
+
+/** Resolve the Cesium ion token: user override > build-time default */
+function resolveIonToken(): string {
+  const userToken = loadFromStorage(STORAGE_KEY_ION_TOKEN, '');
+  return userToken || DEFAULT_ION_TOKEN;
+}
+
+export const createCesiumSlice: StateCreator<CesiumSlice, [], [], CesiumSlice> = (set) => ({
+  cesiumEnabled: false,
+  cesiumDataSource: loadDataSource(),
+  cesiumIonToken: resolveIonToken(),
+  cesiumTerrainEnabled: true,
+  cesiumTerrainClamp: false,
+  cesiumTerrainHeight: null,
+  cesiumSourceModelId: null,
+  cesiumTerrainClipY: null,
+  cesiumGlbLoaded: false,
+
+  setCesiumEnabled: (enabled) => set({ cesiumEnabled: enabled }),
+  toggleCesium: () => set((s) => ({ cesiumEnabled: !s.cesiumEnabled })),
+  setCesiumDataSource: (source) => {
+    saveToStorage(STORAGE_KEY_DATA_SOURCE, source);
+    set({ cesiumDataSource: source });
+  },
+  setCesiumIonToken: (token) => {
+    saveToStorage(STORAGE_KEY_ION_TOKEN, token);
+    set({ cesiumIonToken: token || DEFAULT_ION_TOKEN });
+  },
+  setCesiumTerrainEnabled: (enabled) => set({ cesiumTerrainEnabled: enabled }),
+  setCesiumTerrainClamp: (clamp) => set({ cesiumTerrainClamp: clamp }),
+  setCesiumTerrainHeight: (height) => set({ cesiumTerrainHeight: height }),
+  setCesiumSourceModelId: (modelId) => set({ cesiumSourceModelId: modelId }),
+  setCesiumTerrainClipY: (y) => set({ cesiumTerrainClipY: y }),
+  setCesiumGlbLoaded: (loaded) => set({ cesiumGlbLoaded: loaded }),
+});

package/src/store/slices/chatSlice.ts

@@ -177,6 +177,10 @@ function loadStoredModel(userId: string | null, fallback?: string): string {
   }
 }
 
+function loadValidStoredModel(userId: string | null, hasPro: boolean, fallback?: string): string {
+  return coerceModelForEntitlement(loadStoredModel(userId, fallback), hasPro);
+}
+
 function loadStoredAutoExecute(): boolean {
   try {
     const val = localStorage.getItem(AUTO_EXEC_STORAGE_KEY);
@@ -275,7 +279,7 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   chatMessages: loadStoredMessages(null),
   chatStatus: 'idle',
   chatStreamingContent: '',
-  chatActiveModel: loadStoredModel(null),
+  chatActiveModel: loadValidStoredModel(null, false),
   chatAutoExecute: loadStoredAutoExecute(),
   chatError: null,
   chatAbortController: null,

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 };
   }),
 });