@ifc-lite/viewer 1.28.1 → 1.30.0

package/src/main.tsx

@@ -6,6 +6,11 @@
  * Application entry point
  */
 
+// MUST be the first import: disables React 19.2's dev-mode component-render
+// Performance tracking before react-dom caches `supportsUserTiming`, so large-IFC
+// geometry/dataStore props don't blow its recursive prop-diff to a RangeError/OOM
+// (the load "stops halfway" stall). See disable-react-dev-perf-track.ts.
+import './disable-react-dev-perf-track';
 import React from 'react';
 import ReactDOM from 'react-dom/client';
 import { App } from './App';

package/src/store/index.ts

@@ -38,6 +38,8 @@ import { createCompareSlice, type CompareSlice } from './slices/compareSlice.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 { createSolarSlice, type SolarSlice } from './slices/solarSlice.js';
+import { createEnvironmentSlice, type EnvironmentSlice } from './slices/environmentSlice.js';
 import { createScheduleSlice, type ScheduleSlice } from './slices/scheduleSlice.js';
 import { createPlaybackSlice, type PlaybackSlice } from './slices/playbackSlice.js';
 import { createOverlaySlice, type OverlaySlice } from './slices/overlaySlice.js';
@@ -64,6 +66,7 @@ export { entityRefToString, stringToEntityRef, entityRefEquals, isIfcxDataStore
 // Re-export single source of truth for globalId → EntityRef resolution
 export { resolveEntityRef } from './resolveEntityRef.js';
 export { fromGlobalIdFromModels, toGlobalIdFromModels, toGlobalIdForRef } from './globalId.js';
+export type { ForwardModelMapLike } from './globalId.js';
 
 // Re-export Drawing2D types
 export type { Drawing2DState, Drawing2DStatus, Annotation2DTool, PolygonArea2DResult, TextAnnotation2D, CloudAnnotation2D, SelectedAnnotation2D } from './slices/drawing2DSlice.js';
@@ -105,6 +108,7 @@ export {
   computeScheduleRange,
   computeHiddenProductIds,
   computeActiveProductIds,
+  countGeneratedTasks,
   taskStartEpoch,
   taskFinishEpoch,
   parseIsoDate,
@@ -135,6 +139,8 @@ export type ViewerState = LoadingSlice &
   ScriptSlice &
   ChatSlice &
   CesiumSlice &
+  SolarSlice &
+  EnvironmentSlice &
   ScheduleSlice &
   PlaybackSlice &
   OverlaySlice &
@@ -186,6 +192,8 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
   ...createScriptSlice(...args),
   ...createChatSlice(...args),
   ...createCesiumSlice(...args),
+  ...createSolarSlice(...args),
+  ...createEnvironmentSlice(...args),
   ...createScheduleSlice(...args),
   ...createPlaybackSlice(...args),
   ...createOverlaySlice(...args),

package/src/store/slices/annotationsSlice.test.ts

@@ -36,23 +36,7 @@ describe('AnnotationsSlice', () => {
     state = createAnnotationsSlice(setState as never, () => state, {} as never);
   });
 
-  describe('initial state', () => {
-    it('starts with no annotations and no draft', () => {
-      assert.strictEqual(state.annotations.size, 0);
-      assert.strictEqual(state.draft, null);
-      assert.strictEqual(state.selectedAnnotationId, null);
-    });
-  });
-
   describe('beginDraft + commitDraft', () => {
-    it('opens a draft at the given world position', () => {
-      state.beginDraft({ x: 1, y: 2, z: 3 }, 42, 'arch');
-      assert.ok(state.draft);
-      assert.deepStrictEqual(state.draft!.position, { x: 1, y: 2, z: 3 });
-      assert.strictEqual(state.draft!.entityExpressId, 42);
-      assert.strictEqual(state.draft!.modelId, 'arch');
-    });
-
     it('commits the draft into a new annotation', () => {
       state.beginDraft({ x: 1, y: 2, z: 3 }, 42, 'arch');
       const id = state.commitDraft('Defect: chip in the corner');

package/src/store/slices/cesiumSlice.ts

@@ -19,7 +19,7 @@ import type { MapConversion } from '@ifc-lite/parser';
 
 import { clearTerrainElevationCache } from '@/lib/geo/terrain-elevation';
 
-export type CesiumDataSource = 'google-photorealistic';
+export type CesiumDataSource = 'google-photorealistic' | 'osm-buildings';
 
 export interface CesiumPlacementDraft {
   eastings: number;
@@ -133,8 +133,8 @@ function saveToStorage(key: string, value: string): void {
 }
 
 function loadDataSource(): CesiumDataSource {
-  // Only Google Photorealistic is supported; upgrade any stale stored value.
-  return 'google-photorealistic';
+  const stored = loadFromStorage(STORAGE_KEY_DATA_SOURCE, 'google-photorealistic');
+  return stored === 'osm-buildings' ? 'osm-buildings' : 'google-photorealistic';
 }
 
 /** Resolve the Cesium ion token: user override > build-time default */

package/src/store/slices/dataSlice.test.ts

@@ -53,46 +53,6 @@ describe('DataSlice', () => {
     state = { ...slice, activeModelId: null, models: new Map() };
   });
 
-  describe('initial state', () => {
-    it('should have null ifcDataStore', () => {
-      assert.strictEqual(state.ifcDataStore, null);
-    });
-
-    it('should have null geometryResult', () => {
-      assert.strictEqual(state.geometryResult, null);
-    });
-
-    it('should have null pendingColorUpdates', () => {
-      assert.strictEqual(state.pendingColorUpdates, null);
-    });
-
-    it('should have null pendingMeshColorUpdates', () => {
-      assert.strictEqual(state.pendingMeshColorUpdates, null);
-    });
-  });
-
-  describe('setIfcDataStore', () => {
-    it('should set the data store', () => {
-      const mockStore = { entityCount: 100 } as any;
-      state.setIfcDataStore(mockStore);
-      assert.strictEqual(state.ifcDataStore, mockStore);
-    });
-
-    it('should allow setting to null', () => {
-      state.setIfcDataStore({ entityCount: 100 } as any);
-      state.setIfcDataStore(null);
-      assert.strictEqual(state.ifcDataStore, null);
-    });
-  });
-
-  describe('setGeometryResult', () => {
-    it('should set the geometry result', () => {
-      const mockResult = { meshes: [], totalTriangles: 0, totalVertices: 0 } as any;
-      state.setGeometryResult(mockResult);
-      assert.strictEqual(state.geometryResult, mockResult);
-    });
-  });
-
   describe('appendGeometryBatch', () => {
     it('should create new geometry result when none exists', () => {
       const meshes = [createMockMesh(1), createMockMesh(2)];

package/src/store/slices/environmentSlice.ts

@@ -0,0 +1,101 @@
+/* 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/. */
+
+/**
+ * Environment (sky + lighting) state slice.
+ *
+ * Owns the user's lighting choices for BOTH rendering paths:
+ *   • WebGPU viewport — preset lighting + procedural sky pass, composed into
+ *     `RenderOptions.environment` by Viewport.
+ *   • Cesium geo mode — the same sky toggle drives `scene.skyAtmosphere` /
+ *     `scene.sun` / fog in CesiumOverlay, so "Sky" means the same thing in
+ *     whichever mode is active.
+ *
+ * Preset/sky/exposure choices persist in localStorage; panel visibility is
+ * session-only.
+ */
+
+import type { StateCreator } from 'zustand';
+import { isLightingPresetId, type LightingPresetId } from '@/lib/lighting-presets';
+
+export interface EnvironmentSlice {
+  /** Active lighting preset for the WebGPU viewport. */
+  envPreset: LightingPresetId;
+  /**
+   * Cesium geo mode: show the atmosphere, sun disc and fog. (Standalone the
+   * sky comes with the lighting preset — every preset except `default`
+   * enables it — so this flag only drives the world-context scene.)
+   */
+  envSkyEnabled: boolean;
+  /** User exposure trim, multiplied onto the preset exposure. 1 = neutral. */
+  envExposure: number;
+  /** Whether the Sun & Sky panel is open. */
+  envPanelOpen: boolean;
+
+  setEnvPreset: (preset: LightingPresetId) => void;
+  setEnvSkyEnabled: (enabled: boolean) => void;
+  setEnvExposure: (exposure: number) => void;
+  setEnvPanelOpen: (open: boolean) => void;
+  toggleEnvPanel: () => void;
+}
+
+const STORAGE_KEY = 'ifc-lite:environment';
+
+interface PersistedEnvironment {
+  preset?: string;
+  skyEnabled?: boolean;
+  exposure?: number;
+}
+
+function loadPersisted(): PersistedEnvironment {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return {};
+    const parsed: unknown = JSON.parse(raw);
+    return typeof parsed === 'object' && parsed !== null ? (parsed as PersistedEnvironment) : {};
+  } catch {
+    return {};
+  }
+}
+
+function persist(state: Pick<EnvironmentSlice, 'envPreset' | 'envSkyEnabled' | 'envExposure'>): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify({
+      preset: state.envPreset,
+      skyEnabled: state.envSkyEnabled,
+      exposure: state.envExposure,
+    } satisfies PersistedEnvironment));
+  } catch { /* storage unavailable */ }
+}
+
+function clampExposure(value: number): number {
+  if (!Number.isFinite(value)) return 1;
+  return Math.min(2, Math.max(0.4, value));
+}
+
+export const createEnvironmentSlice: StateCreator<EnvironmentSlice, [], [], EnvironmentSlice> = (set, get) => {
+  const stored = loadPersisted();
+  const initial = {
+    envPreset: (stored.preset && isLightingPresetId(stored.preset) ? stored.preset : 'default') as LightingPresetId,
+    envSkyEnabled: stored.skyEnabled === true,
+    envExposure: clampExposure(stored.exposure ?? 1),
+  };
+
+  const update = (patch: Partial<EnvironmentSlice>) => {
+    set(patch);
+    const s = get();
+    persist(s);
+  };
+
+  return {
+    ...initial,
+    envPanelOpen: false,
+
+    setEnvPreset: (preset) => update({ envPreset: preset }),
+    setEnvSkyEnabled: (enabled) => update({ envSkyEnabled: enabled }),
+    setEnvExposure: (exposure) => update({ envExposure: clampExposure(exposure) }),
+    setEnvPanelOpen: (open) => set({ envPanelOpen: open }),
+    toggleEnvPanel: () => set((s) => ({ envPanelOpen: !s.envPanelOpen })),
+  };
+};

package/src/store/slices/idsSlice.ts

@@ -257,7 +257,12 @@ export const createIdsSlice: StateCreator<IDSSlice, [], [], IDSSlice> = (set, ge
 
   setIdsLoading: (idsLoading) => set({ idsLoading }),
 
-  setIdsError: (idsError) => set({ idsError, idsLoading: false }),
+  // Setting an error ends the run; but CLEARING the error (idsError =
+  // null, e.g. at the start of a validation run) must NOT flip loading
+  // off — doing so kept the progress UI, which is gated on `loading`,
+  // hidden for the entire run even though progress was streaming in.
+  setIdsError: (idsError) =>
+    set(idsError !== null ? { idsError, idsLoading: false } : { idsError }),
 
   setIdsLocale: (idsLocale) => set({ idsLocale }),
 

package/src/store/slices/mutationSlice.ts

@@ -47,6 +47,7 @@ import { getEntityBounds } from '@/utils/viewportUtils';
 import { toGlobalIdFromModels } from '../globalId.js';
 import { buildElementMesh, type ElementMeshPayload } from './addElementMeshes.js';
 import type { AddElementType } from './addElementSlice.js';
+import type { TypeViewMode } from '../constants.js';
 import {
   resolvePlacementChain,
   resolveRotationState,
@@ -92,6 +93,23 @@ export const DUPLICATE_DEFAULT_DIRECTION: DuplicateDirection = '+X';
 /** Fallback step in metres when the source has no mesh in geometry. */
 const DUPLICATE_FALLBACK_STEP = 1;
 
+/**
+ * New occurrence geometry from an authoring action (add element, duplicate,
+ * split) is a class-0 mesh, which the 3D "Types" view deliberately hides. If
+ * the user is in Types view when they commit such an action, flip back to
+ * Model so the element they just created actually renders — otherwise the
+ * toast says "added" but nothing appears. No-op when already in Model view
+ * (so it never needlessly overwrites the persisted preference). Reads the
+ * live store via the cross-slice `get()`.
+ */
+function revealAddedGeometryInModelView(get: () => unknown): void {
+  const cross = get() as {
+    typeViewMode?: TypeViewMode;
+    setTypeViewMode?: (mode: TypeViewMode) => void;
+  };
+  if (cross.typeViewMode === 'types') cross.setTypeViewMode?.('model');
+}
+
 interface ViewerBox {
   /** Per-axis sizes in viewer scene coordinates. */
   size: { x: number; y: number; z: number };
@@ -921,6 +939,7 @@ function runInStoreElementBuilder(
         appendGeometryBatch?: (batch: MeshData[]) => void;
       };
       cross.appendGeometryBatch?.([mesh]);
+      revealAddedGeometryInModelView(get);
     }
   }
 
@@ -2104,6 +2123,7 @@ export const createMutationSlice: StateCreator<
         appendGeometryBatch?: (batch: MeshData[]) => void;
       };
       cross.appendGeometryBatch?.([columnMesh]);
+      revealAddedGeometryInModelView(get);
     }
 
     set((s) => {
@@ -2352,6 +2372,7 @@ export const createMutationSlice: StateCreator<
         appendGeometryBatch?: (batch: MeshData[]) => void;
       };
       cross.appendGeometryBatch?.(clonedMeshes);
+      revealAddedGeometryInModelView(get);
     }
 
     return { expressId: newId, globalId: newGlobalId };

package/src/store/slices/selectionSlice.test.ts

@@ -24,28 +24,7 @@ describe('SelectionSlice', () => {
     state = createSelectionSlice(setState, () => state, {} as any);
   });
 
-  describe('initial state', () => {
-    it('should have null selectedEntity', () => {
-      assert.strictEqual(state.selectedEntity, null);
-    });
-
-    it('should have empty selectedEntitiesSet', () => {
-      assert.strictEqual(state.selectedEntitiesSet.size, 0);
-    });
-
-    it('should have null selectedEntityId (legacy)', () => {
-      assert.strictEqual(state.selectedEntityId, null);
-    });
-  });
-
   describe('multi-model selection: setSelectedEntity', () => {
-    it('should set primary selection with model context', () => {
-      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
-      state.setSelectedEntity(ref);
-
-      assert.deepStrictEqual(state.selectedEntity, ref);
-    });
-
     it('should NOT update selectedEntityId (caller must use setSelectedEntityId for global ID)', () => {
       // NOTE: selectedEntityId holds the GLOBAL ID for renderer highlighting,
       // while selectedEntity.expressId holds the ORIGINAL express ID for property lookup.
@@ -56,15 +35,6 @@ describe('SelectionSlice', () => {
       // selectedEntityId should remain null - caller must set it separately with globalId
       assert.strictEqual(state.selectedEntityId, null);
     });
-
-    it('should allow clearing selection with null', () => {
-      const ref: EntityRef = { modelId: 'model-1', expressId: 123 };
-      state.setSelectedEntity(ref);
-      state.setSelectedEntity(null);
-
-      assert.strictEqual(state.selectedEntity, null);
-      assert.strictEqual(state.selectedEntityId, null);
-    });
   });
 
   describe('multi-model selection: addEntityToSelection', () => {
@@ -285,19 +255,6 @@ describe('SelectionSlice', () => {
     });
   });
 
-  describe('legacy selection: setSelectedEntityId', () => {
-    it('should set legacy selectedEntityId', () => {
-      state.setSelectedEntityId(123);
-      assert.strictEqual(state.selectedEntityId, 123);
-    });
-
-    it('should allow clearing with null', () => {
-      state.setSelectedEntityId(123);
-      state.setSelectedEntityId(null);
-      assert.strictEqual(state.selectedEntityId, null);
-    });
-  });
-
   describe('legacy selection: storey selection', () => {
     it('should toggle storey selection', () => {
       state.toggleStoreySelection(1);

package/src/store/slices/solarSlice.ts

@@ -0,0 +1,121 @@
+/* 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/. */
+
+/**
+ * Solar study state slice — drives the georeferenced 3D sun-path dome and
+ * shadow study rendered in the Cesium context overlay.
+ *
+ * The slice itself only owns *intent* (which instant to study, what to show).
+ * The heavy lifting — computing the sun direction, enabling Cesium's sun /
+ * shadows, and building the dome geometry — happens in CesiumOverlay, which
+ * reads this state and writes the resolved {@link SolarSunInfo} back here for
+ * the readout panel.
+ *
+ * Solar study requires Cesium (it renders the model + OSM context with mutual
+ * shadows), so the UI turns Cesium on when the study is enabled.
+ */
+
+import type { StateCreator } from 'zustand';
+
+/** Resolved solar readout for the currently studied instant + site. */
+export interface SolarSunInfo {
+  /** Site latitude in degrees (north positive), from the model georeference. */
+  latitude: number;
+  /** Site longitude in degrees (east positive). */
+  longitude: number;
+  /** Sun azimuth in degrees clockwise from true north. */
+  azimuth: number;
+  /** Sun altitude in degrees above the horizon (negative below). */
+  altitude: number;
+  /** Sunrise epoch ms, or null (polar night / midnight sun). */
+  sunriseMs: number | null;
+  /** Sunset epoch ms, or null. */
+  sunsetMs: number | null;
+  /** Solar-noon epoch ms. */
+  solarNoonMs: number;
+}
+
+/** Which dimension the animation sweep advances. */
+export type SolarSweepMode = 'day' | 'year';
+
+export interface SolarSlice {
+  /** Whether the sun-path / shadow study is active. */
+  solarEnabled: boolean;
+  /** Studied instant as epoch milliseconds (UTC). */
+  solarDateMs: number;
+  /** Draw the 3D sun-path dome (analemmas, day arc, graticule). */
+  solarShowSunPath: boolean;
+  /** Render real cast shadows (model ↔ OSM context) via Cesium. */
+  solarShowShadows: boolean;
+  /** Resolved sun position/times for the readout panel; null until computed. */
+  solarSunInfo: SolarSunInfo | null;
+  /**
+   * Unit vector toward the sun in viewer/world space (Y-up), derived from the
+   * studied instant + site georeference. Drives the WebGPU renderer's sun
+   * (lighting + procedural sky) so daylight reads identically with and
+   * without the Cesium context. Null when the study is off or the site is
+   * unknown.
+   */
+  solarSunDirection: [number, number, number] | null;
+  /**
+   * Display times in local solar time derived from the site longitude
+   * (15°/hour) instead of UTC. This is civil-timezone-agnostic on purpose —
+   * sun-path studies care about solar time, and a longitude offset needs no
+   * timezone database or DST rules.
+   */
+  solarUseLocalTime: boolean;
+  /** Whether the animation sweep is playing. */
+  solarPlaying: boolean;
+  /** Which dimension the sweep advances (time-of-day vs day-of-year). */
+  solarSweepMode: SolarSweepMode;
+
+  setSolarEnabled: (enabled: boolean) => void;
+  toggleSolar: () => void;
+  setSolarDateMs: (ms: number) => void;
+  setSolarShowSunPath: (show: boolean) => void;
+  setSolarShowShadows: (show: boolean) => void;
+  setSolarSunInfo: (info: SolarSunInfo | null) => void;
+  setSolarSunDirection: (dir: [number, number, number] | null) => void;
+  setSolarUseLocalTime: (use: boolean) => void;
+  setSolarPlaying: (playing: boolean) => void;
+  toggleSolarPlaying: () => void;
+  setSolarSweepMode: (mode: SolarSweepMode) => void;
+}
+
+/** Default studied instant: a bright equinox midday so the dome reads well. */
+function defaultSolarDateMs(): number {
+  return Date.UTC(new Date().getUTCFullYear(), 2, 20, 12, 0, 0);
+}
+
+export const createSolarSlice: StateCreator<SolarSlice, [], [], SolarSlice> = (set) => ({
+  solarEnabled: false,
+  solarDateMs: defaultSolarDateMs(),
+  solarShowSunPath: true,
+  solarShowShadows: true,
+  solarSunInfo: null,
+  solarSunDirection: null,
+  // Default to the site's local solar time (derived from longitude): for a
+  // sun-path study "9am" should mean 9am at the site, not UTC.
+  solarUseLocalTime: true,
+  solarPlaying: false,
+  solarSweepMode: 'day',
+
+  setSolarEnabled: (enabled) =>
+    set(enabled
+      ? { solarEnabled: true }
+      : { solarEnabled: false, solarSunInfo: null, solarSunDirection: null, solarPlaying: false }),
+  toggleSolar: () =>
+    set((s) => (s.solarEnabled
+      ? { solarEnabled: false, solarSunInfo: null, solarSunDirection: null, solarPlaying: false }
+      : { solarEnabled: true })),
+  setSolarDateMs: (ms) => set({ solarDateMs: ms }),
+  setSolarShowSunPath: (show) => set({ solarShowSunPath: show }),
+  setSolarShowShadows: (show) => set({ solarShowShadows: show }),
+  setSolarSunInfo: (info) => set({ solarSunInfo: info }),
+  setSolarSunDirection: (dir) => set({ solarSunDirection: dir }),
+  setSolarUseLocalTime: (use) => set({ solarUseLocalTime: use }),
+  setSolarPlaying: (playing) => set({ solarPlaying: playing }),
+  toggleSolarPlaying: () => set((s) => ({ solarPlaying: !s.solarPlaying })),
+  setSolarSweepMode: (mode) => set({ solarSweepMode: mode }),
+});

package/src/store/slices/uiSlice.ts

@@ -27,6 +27,7 @@ const AUTHORING_TOOLS: ReadonlySet<string> = new Set([
   'addElement',
   'cesium-placement',
   'split',
+  'spaceSketch',
 ]);
 
 /**

package/src/store/slices/visibilitySlice.test.ts

@@ -25,14 +25,6 @@ describe('VisibilitySlice', () => {
   });
 
   describe('initial state', () => {
-    it('should have empty hiddenEntitiesByModel', () => {
-      assert.strictEqual(state.hiddenEntitiesByModel.size, 0);
-    });
-
-    it('should have empty isolatedEntitiesByModel', () => {
-      assert.strictEqual(state.isolatedEntitiesByModel.size, 0);
-    });
-
     it('should initialise type visibility from persisted preferences', () => {
       const persisted = getPersistedTypeVisibility();
       assert.strictEqual(state.typeVisibility.spaces, persisted.spaces);
@@ -44,14 +36,6 @@ describe('VisibilitySlice', () => {
   });
 
   describe('multi-model visibility: hideEntityInModel', () => {
-    it('should hide entity in specific model', () => {
-      state.hideEntityInModel('model-1', 123);
-
-      const hidden = state.hiddenEntitiesByModel.get('model-1');
-      assert.ok(hidden);
-      assert.ok(hidden.has(123));
-    });
-
     it('should create new set for model if not exists', () => {
       state.hideEntityInModel('model-1', 100);
       state.hideEntityInModel('model-1', 200);
@@ -209,13 +193,6 @@ describe('VisibilitySlice', () => {
     });
   });
 
-  describe('legacy visibility: hideEntity', () => {
-    it('should hide entity', () => {
-      state.hideEntity(123);
-      assert.ok(state.hiddenEntities.has(123));
-    });
-  });
-
   describe('legacy visibility: showEntity', () => {
     it('should show hidden entity', () => {
       state.hideEntity(123);
@@ -286,28 +263,21 @@ describe('VisibilitySlice', () => {
   });
 
   describe('type visibility: toggleTypeVisibility', () => {
-    it('should toggle spaces visibility', () => {
-      const initial = state.typeVisibility.spaces;
-      state.toggleTypeVisibility('spaces');
-      assert.strictEqual(state.typeVisibility.spaces, !initial);
-    });
-
-    it('should toggle openings visibility', () => {
-      const initial = state.typeVisibility.openings;
-      state.toggleTypeVisibility('openings');
-      assert.strictEqual(state.typeVisibility.openings, !initial);
-    });
-
-    it('should toggle site visibility', () => {
-      const initial = state.typeVisibility.site;
-      state.toggleTypeVisibility('site');
-      assert.strictEqual(state.typeVisibility.site, !initial);
-    });
-
-    it('should toggle ifcAnnotations visibility', () => {
-      const initial = state.typeVisibility.ifcAnnotations;
-      state.toggleTypeVisibility('ifcAnnotations');
-      assert.strictEqual(state.typeVisibility.ifcAnnotations, !initial);
+    it('should toggle each type key independently', () => {
+      const keys = ['spaces', 'openings', 'site', 'ifcAnnotations', 'ifcGrid'] as const;
+      for (const key of keys) {
+        const before = { ...state.typeVisibility };
+        state.toggleTypeVisibility(key);
+        assert.strictEqual(state.typeVisibility[key], !before[key], `toggle ${key}`);
+        for (const other of keys) {
+          if (other === key) continue;
+          assert.strictEqual(
+            state.typeVisibility[other],
+            before[other],
+            `toggling ${key} must not change ${other}`,
+          );
+        }
+      }
     });
 
     it('resetTypeVisibility restores semantic defaults', () => {

package/src/store/slices/visibilitySlice.ts

@@ -30,6 +30,12 @@ export interface VisibilitySlice {
   /** 3D view mode for the Model/Types switch (#957 follow-up). 'model' shows
    *  placed occurrences (default); 'types' shows the type-library shapes. */
   typeViewMode: TypeViewMode;
+  /** True when the rendered geometry contains any type-library geometry
+   *  (geometryClass 1 = orphan type, 2 = instanced type) — i.e. the Model/Types
+   *  switch has something to reveal in "Types" mode. Derived from the merged
+   *  mesh set by ViewportContainer; most models carry only occurrence geometry
+   *  (class 0), so the switch stays hidden for them. */
+  hasTypeGeometry: boolean;
 
   // State (multi-model)
   /** Hidden entities per model */
@@ -58,6 +64,10 @@ export interface VisibilitySlice {
   resetTypeVisibility: () => void;
   /** Set the Model/Types 3D view mode (and persist). */
   setTypeViewMode: (mode: TypeViewMode) => void;
+  /** Set whether the current geometry contains type-library geometry — drives
+   *  whether the Model/Types switch renders at all. Runtime-only (not persisted);
+   *  re-derived from geometry on every load. */
+  setHasTypeGeometry: (value: boolean) => void;
   /** Set all hidden entities at once (for BCF viewpoint application) */
   setHiddenEntities: (ids: Set<number>) => void;
   /** Set all isolated entities at once (for BCF viewpoint with defaultVisibility=false) */
@@ -92,6 +102,8 @@ export const createVisibilitySlice: StateCreator<VisibilitySlice, [], [], Visibi
   // Read persisted toggles fresh so the user's choices survive reloads.
   typeVisibility: getPersistedTypeVisibility(),
   typeViewMode: getPersistedTypeViewMode(),
+  // Derived from geometry at load time — no model is open yet, so default false.
+  hasTypeGeometry: false,
 
   // Initial state (multi-model)
   hiddenEntitiesByModel: new Map(),
@@ -242,6 +254,14 @@ export const createVisibilitySlice: StateCreator<VisibilitySlice, [], [], Visibi
     return { typeViewMode: mode };
   }),
 
+  setHasTypeGeometry: (value) => set((state) => (
+    // Return the SAME state reference when unchanged — a fresh `{}` would still
+    // merge into a new state object and notify every subscriber (incl. the
+    // whole-state useSyncExternalStore in ViewportContainer). Same ref → Zustand
+    // skips the notification entirely.
+    state.hasTypeGeometry === value ? state : { hasTypeGeometry: value }
+  )),
+
   // Actions (multi-model)
   hideEntityInModel: (modelId, expressId) => set((state) => {
     const newMap = new Map(state.hiddenEntitiesByModel);

package/src/utils/loadingUtils.ts

@@ -13,7 +13,7 @@
 import type { MeshData } from '@ifc-lite/geometry';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import { buildSpatialIndexAsync } from '@ifc-lite/spatial';
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '../store/index.js';
 
 /**
  * Build a spatial index in the background (time-sliced, non-blocking)