@ifc-lite/viewer 1.17.3 → 1.17.6

package/src/store/slices/chatSlice.ts

@@ -13,6 +13,7 @@ import { coerceModelForEntitlement, DEFAULT_FREE_MODEL } from '../../lib/llm/mod
 import { extractCodeBlocks } from '../../lib/llm/code-extractor.js';
 import type { ScriptDiagnostic } from '../../lib/llm/script-diagnostics.js';
 import { formatDiagnosticsForPrompt, getPrimaryRootCause, groupDiagnosticsByRootCause } from '../../lib/llm/script-diagnostics.js';
+import { hasAnyApiKey as hasAnyApiKeyAtInit } from '../../services/api-keys.js';
 
 const MODEL_STORAGE_KEY = 'ifc-lite-chat-model';
 const MESSAGES_STORAGE_KEY = 'ifc-lite-chat-messages';
@@ -43,11 +44,9 @@ export interface ChatSlice {
   chatPendingRepairRequest: ChatRepairRequest | null;
   /** Auto-captured viewport screenshot (base64 data URL) to include with next LLM message */
   chatViewportScreenshot: string | null;
-  /** Clerk JWT for authenticated API calls (null for anonymous/free tier) */
-  chatAuthToken: string | null;
-  /** Whether the current user has a pro subscription */
-  chatHasPro: boolean;
-  /** Usage info from the server: credits (pro) or request count (free) */
+  /** Whether the user has at least one BYOK API key configured */
+  chatHasByokKey: boolean;
+  /** Usage info from the proxy: request count for free tier */
   chatUsage: ChatUsage | null;
   /** User ID used to scope persisted model preference (null for anonymous). */
   chatStorageUserId: string | null;
@@ -78,18 +77,10 @@ export interface ChatSlice {
   sendErrorFeedback: (code: string, error: string) => void;
   /** Store a viewport screenshot to include with the next LLM message */
   setChatViewportScreenshot: (dataUrl: string | null) => void;
-  /** Set the Clerk auth token (called by ClerkProvider wrapper when user signs in) */
-  setChatAuthToken: (token: string | null) => void;
-  /** Set whether user has pro subscription (called by ClerkProvider wrapper) */
-  setChatHasPro: (hasPro: boolean) => void;
+  /** Set whether user has at least one BYOK API key configured */
+  setChatHasByokKey: (hasByokKey: boolean) => void;
   /** Update usage info from server response headers */
   setChatUsage: (usage: ChatUsage | null) => void;
-  /** Switch the active chat user/session context. */
-  switchChatUserContext: (
-    userId: string | null,
-    hasPro: boolean,
-    options?: { clearPersistedCurrent?: boolean; restoreMessages?: boolean },
-  ) => void;
 }
 
 export interface ChatUsage {
@@ -177,6 +168,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 +270,7 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   chatMessages: loadStoredMessages(null),
   chatStatus: 'idle',
   chatStreamingContent: '',
-  chatActiveModel: loadStoredModel(null),
+  chatActiveModel: loadValidStoredModel(null, hasAnyApiKeyAtInit()),
   chatAutoExecute: loadStoredAutoExecute(),
   chatError: null,
   chatAbortController: null,
@@ -283,8 +278,7 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   chatPendingPrompt: null,
   chatPendingRepairRequest: null,
   chatViewportScreenshot: null,
-  chatAuthToken: null,
-  chatHasPro: false,
+  chatHasByokKey: false,
   chatUsage: null,
   chatStorageUserId: null,
 
@@ -336,12 +330,15 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   setChatStreamingContent: (chatStreamingContent) => set({ chatStreamingContent }),
 
   setChatActiveModel: (chatActiveModel) => {
-    const nextModel = coerceModelForEntitlement(chatActiveModel, get().chatHasPro);
+    // Accept any model the user picks — the ChatPanel shows an inline key
+    // prompt if the selected BYOK model doesn't have a key yet, and guards
+    // the send path. Coercion only happens on init and when keys are removed
+    // (via setChatHasByokKey).
     try {
       const key = getModelStorageKey(get().chatStorageUserId);
-      localStorage.setItem(key, nextModel);
+      localStorage.setItem(key, chatActiveModel);
     } catch { /* ignore */ }
-    set({ chatActiveModel: nextModel });
+    set({ chatActiveModel });
   },
 
   setChatAutoExecute: (chatAutoExecute) => {
@@ -400,51 +397,17 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
 
   setChatViewportScreenshot: (chatViewportScreenshot) => set({ chatViewportScreenshot }),
 
-  setChatAuthToken: (chatAuthToken) => set({ chatAuthToken }),
-
-  setChatHasPro: (chatHasPro) => {
-    const nextModel = coerceModelForEntitlement(get().chatActiveModel, chatHasPro);
+  setChatHasByokKey: (chatHasByokKey) => {
+    const nextModel = coerceModelForEntitlement(get().chatActiveModel, chatHasByokKey);
     try {
       const key = getModelStorageKey(get().chatStorageUserId);
       localStorage.setItem(key, nextModel);
     } catch { /* ignore */ }
-    set({ chatHasPro, chatActiveModel: nextModel });
+    set({ chatHasByokKey, chatActiveModel: nextModel });
   },
 
   setChatUsage: (chatUsage) => set({ chatUsage }),
 
-  switchChatUserContext: (chatStorageUserId, chatHasPro, options) => {
-    const state = get();
-    state.chatAbortController?.abort();
-    if (options?.clearPersistedCurrent) {
-      try {
-        localStorage.removeItem(getMessagesStorageKey(state.chatStorageUserId));
-      } catch { /* ignore */ }
-    }
-    const restoredModel = coerceModelForEntitlement(
-      loadStoredModel(chatStorageUserId, state.chatActiveModel),
-      chatHasPro,
-    );
-    const restoredMessages = options?.restoreMessages === false
-      ? []
-      : loadStoredMessages(chatStorageUserId);
-    set({
-      chatStorageUserId,
-      chatHasPro,
-      chatActiveModel: restoredModel,
-      chatMessages: restoredMessages,
-      chatStatus: 'idle',
-      chatStreamingContent: '',
-      chatError: null,
-      chatAbortController: null,
-      chatAttachments: [],
-      chatPendingPrompt: null,
-      chatPendingRepairRequest: null,
-      chatViewportScreenshot: null,
-      chatUsage: null,
-    });
-  },
-
   sendErrorFeedback: (code, error) => {
     const feedbackMessage: ChatMessage = {
       id: crypto.randomUUID(),

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