@ifc-lite/viewer 1.29.0 → 1.30.0

package/src/lib/recent-files.ts

@@ -24,19 +24,11 @@ export interface RecentFileEntry {
   name: string;
   size: number;
   timestamp: number;
-  /** Native filesystem path (Tauri only) — enables direct re-open from disk. */
-  path?: string;
-  /** Last-modified epoch in ms when known (Tauri stat). */
-  modifiedMs?: number | null;
 }
 
-// Input shape for `recordRecentFiles` — accepts the optional native fields
-// so callers can persist a path / modifiedMs without lying about the type.
 export type RecentFileInput = {
   name: string;
   size: number;
-  path?: string;
-  modifiedMs?: number | null;
 };
 
 // ── localStorage (metadata) ─────────────────────────────────────────────
@@ -46,12 +38,10 @@ export function getRecentFiles(): RecentFileEntry[] {
   catch { return []; }
 }
 
-// Path-aware dedup key: when a native filesystem path is available it
-// uniquely identifies the file (so `A/model.ifc` and `B/model.ifc` are
-// kept separate); otherwise fall back to the name (browser uploads
-// don't expose paths).
-function recentKey(f: { name: string; path?: string }): string {
-  return f.path ? `path:${f.path}` : `name:${f.name}`;
+// Browser uploads don't expose filesystem paths, so the file name is the
+// dedup key.
+function recentKey(f: { name: string }): string {
+  return `name:${f.name}`;
 }
 
 export function recordRecentFiles(files: RecentFileInput[]) {
@@ -62,8 +52,6 @@ export function recordRecentFiles(files: RecentFileInput[]) {
       name: f.name,
       size: f.size,
       timestamp: Date.now(),
-      path: f.path,
-      modifiedMs: f.modifiedMs ?? null,
     }));
     localStorage.setItem(KEY, JSON.stringify([...entries, ...existing].slice(0, 10)));
   } catch (err) {
@@ -130,14 +118,6 @@ export async function cacheFileBlobs(files: File[]): Promise<void> {
 
 /** Retrieve a cached file blob and reconstruct a File object. */
 export async function getCachedFile(target: string | RecentFileEntry): Promise<File | null> {
-  // Path-bearing entries (Tauri filesystem) are uniquely keyed by path
-  // in the recents list, but the IndexedDB cache is name-keyed. A
-  // name-only hit could resolve `A/model.ifc` to the cached blob from
-  // `B/model.ifc`, opening the wrong file silently. Defer to the
-  // caller's native re-open path instead.
-  if (typeof target !== 'string' && target.path) {
-    return null;
-  }
   const name = typeof target === 'string' ? target : target.name;
   try {
     const db = await openDB();

package/src/lib/solar-time.ts

@@ -0,0 +1,55 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Display-frame time helpers for the solar study.
+ *
+ * The studied instant is always stored as an absolute UTC epoch. For display
+ * the UI defaults to *local solar time* derived from the site longitude
+ * (15°/hour) — civil-timezone-agnostic on purpose, since sun-path studies
+ * care about solar time and a longitude offset needs no timezone database or
+ * DST rules. The user can switch the readout to UTC.
+ */
+
+export const MS_PER_MIN = 60_000;
+export const MS_PER_DAY = 86_400_000;
+
+/** Longitude → display offset in minutes (local solar time), or 0 for UTC. */
+export function solarDisplayOffsetMinutes(useLocal: boolean, longitude: number | undefined): number {
+  if (!useLocal || longitude === undefined) return 0;
+  return Math.round((longitude / 15) * 60);
+}
+
+/** Epoch ms shifted into the display frame (UTC + offset). */
+export function toSolarDisplay(ms: number, offsetMin: number): Date {
+  return new Date(ms + offsetMin * MS_PER_MIN);
+}
+
+/** "YYYY-MM-DD" of the display-frame day for an instant. */
+export function toSolarDateInputValue(ms: number, offsetMin: number): string {
+  const d = toSolarDisplay(ms, offsetMin);
+  const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+  const dd = String(d.getUTCDate()).padStart(2, '0');
+  return `${d.getUTCFullYear()}-${mm}-${dd}`;
+}
+
+/** Minutes since midnight in the display frame. */
+export function solarMinutesOfDay(ms: number, offsetMin: number): number {
+  const d = toSolarDisplay(ms, offsetMin);
+  return d.getUTCHours() * 60 + d.getUTCMinutes();
+}
+
+/** Compose an absolute UTC epoch from a display-frame date string + minutes. */
+export function composeSolarMs(dateStr: string, minutes: number, offsetMin: number): number {
+  const [y, m, d] = dateStr.split('-').map(Number);
+  const displayMs = Date.UTC(y, (m ?? 1) - 1, d ?? 1, Math.floor(minutes / 60), minutes % 60, 0);
+  return displayMs - offsetMin * MS_PER_MIN;
+}
+
+/** Epoch ms → "HH:MM" in the display frame. */
+export function formatSolarTime(ms: number | null, offsetMin: number): string {
+  if (ms === null) return '—';
+  const d = toSolarDisplay(ms, offsetMin);
+  return `${String(d.getUTCHours()).padStart(2, '0')}:${String(d.getUTCMinutes()).padStart(2, '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/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/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/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)