@ifc-lite/viewer 1.29.0 → 1.30.0

package/src/hooks/ids/idsWorkerClient.ts

@@ -0,0 +1,136 @@
+/* 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/. */
+
+/**
+ * Main-thread client for the IDS validation worker.
+ *
+ * Spawns the worker per run (validation is infrequent and the worker
+ * re-parses the model, so a long-lived instance would only pin memory),
+ * streams progress back to the caller, and resolves with the report.
+ * The caller falls back to in-process validation when `isSupported()`
+ * is false or the worker rejects.
+ */
+
+import type {
+  IDSDocument,
+  IDSValidationReport,
+  ValidationProgress,
+} from '@ifc-lite/ids';
+import type {
+  IdsWorkerRequest,
+  IdsWorkerResponse,
+} from '@/workers/idsValidation.worker';
+
+export function idsWorkerSupported(): boolean {
+  return typeof Worker !== 'undefined';
+}
+
+export interface RunInWorkerArgs {
+  /** Raw IFC/STEP bytes from the loaded model's data store. */
+  source: Uint8Array;
+  document: IDSDocument;
+  schemaVersion: string;
+  modelId: string;
+  locale: 'en' | 'de' | 'fr';
+  includePassingEntities: boolean;
+  onProgress?: (progress: ValidationProgress) => void;
+}
+
+/**
+ * Hand the model bytes + parsed IDS document to the worker and resolve
+ * with the validation report. A SharedArrayBuffer-backed source is
+ * shared zero-copy; a plain ArrayBuffer is copied and transferred so
+ * the main-thread store is never detached.
+ */
+export function runValidationInWorker(
+  args: RunInWorkerArgs
+): Promise<IDSValidationReport> {
+  return new Promise((resolve, reject) => {
+    let worker: Worker;
+    try {
+      worker = new Worker(
+        new URL('../../workers/idsValidation.worker.ts', import.meta.url),
+        { type: 'module' }
+      );
+    } catch (err) {
+      reject(
+        new Error(
+          `Failed to spawn IDS worker: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      return;
+    }
+
+    const id = Date.now();
+    const { buffer, transfer } = prepareSource(args.source);
+
+    const settle = (fn: () => void) => {
+      worker.onmessage = null;
+      worker.onerror = null;
+      worker.onmessageerror = null;
+      worker.terminate();
+      fn();
+    };
+
+    worker.onmessage = (event: MessageEvent<IdsWorkerResponse>) => {
+      const msg = event.data;
+      if (!msg || msg.id !== id) return;
+      switch (msg.type) {
+        case 'progress':
+          args.onProgress?.(msg.progress);
+          return;
+        case 'complete':
+          settle(() => resolve(msg.report));
+          return;
+        case 'error':
+          settle(() => reject(new Error(msg.message)));
+          return;
+      }
+    };
+
+    worker.onerror = (event) => {
+      settle(() => reject(new Error(event.message || 'IDS worker crashed')));
+    };
+    worker.onmessageerror = () => {
+      settle(() => reject(new Error('IDS worker message deserialization failed')));
+    };
+
+    const request: IdsWorkerRequest = {
+      type: 'validate',
+      id,
+      source: buffer,
+      document: args.document,
+      schemaVersion: args.schemaVersion,
+      modelId: args.modelId,
+      locale: args.locale,
+      includePassingEntities: args.includePassingEntities,
+    };
+    worker.postMessage(request, transfer);
+  });
+}
+
+/**
+ * Resolve the exact source bytes into a worker-postable buffer.
+ * SharedArrayBuffer is shared by reference (zero copy); a plain
+ * ArrayBuffer (or a partial view) is copied into a fresh, transferable
+ * ArrayBuffer so the caller's store keeps its bytes.
+ */
+function prepareSource(source: Uint8Array): {
+  buffer: ArrayBuffer | SharedArrayBuffer;
+  transfer: Transferable[];
+} {
+  const sharedAvailable = typeof SharedArrayBuffer !== 'undefined';
+  if (
+    sharedAvailable &&
+    source.buffer instanceof SharedArrayBuffer &&
+    source.byteOffset === 0 &&
+    source.byteLength === source.buffer.byteLength
+  ) {
+    // Shared by reference — no copy, the worker only reads it.
+    return { buffer: source.buffer, transfer: [] };
+  }
+  // Copy the exact bytes; transfer the copy (never the original).
+  const copy = source.slice();
+  return { buffer: copy.buffer, transfer: [copy.buffer] };
+}

package/src/hooks/ingest/federationAlign.ts

@@ -17,7 +17,7 @@ import {
   type ProjectedCRS,
 } from '@ifc-lite/parser';
 import type { CoordinateInfo } from '@ifc-lite/geometry';
-import { useViewerStore, type FederatedModel } from '../../store.js';
+import { useViewerStore, type FederatedModel } from '../../store/index.js';
 import { getEffectiveGeoreference, getEffectiveHorizontalScale, hasStandardGeoreferencing, type GeorefMutationDataLike } from '../../lib/geo/effective-georef.js';
 import { resolveMapUnitToMetreScale } from '../../lib/geo/geo-scale.js';
 import { resolveProjection } from '../../lib/geo/reproject.js';

package/src/hooks/ingest/pointCloudIngest.ts

@@ -19,118 +19,42 @@ import {
   type StreamHandle,
 } from '@ifc-lite/pointcloud';
 import type { CoordinateInfo, GeometryResult, PointCloudAsset } from '@ifc-lite/geometry';
-import type { IfcDataStore } from '@ifc-lite/parser';
+import { createSyntheticDataStore, type IfcDataStore } from '@ifc-lite/parser';
 import type { SchemaVersion } from '../../store/types.js';
 import { createCoordinateInfo } from '../../utils/localParsingUtils.js';
 
 export type PointCloudFormat = 'las' | 'laz' | 'ply' | 'pcd' | 'e57' | 'pts' | 'xyz';
 
 /**
- * IfcTypeEnum.IfcGeographicElement — the closest IFC4 entity for a scan
- * is `IfcGeographicElement`. We hard-code the enum value (58) here so
- * we don't pull `@ifc-lite/data` into the viewer ingest path.
- */
-const IFC_GEOGRAPHIC_ELEMENT_ENUM = 58;
-
-/**
- * Synthetic IfcDataStore for a point-cloud-only model. Picking a point
- * sets the synthetic expressId as the selected entity, which then runs
- * through the regular property/hover/properties-panel pipeline. That
- * pipeline calls `entities.getTypeName / getName / getGlobalId` and
- * `properties.getForEntity` — without those methods, picking crashes
- * with "getTypeName is not a function". We give it just enough shape
- * to round-trip the single synthetic entity.
+ * Synthetic IfcDataStore for a point-cloud-only model. Picking a point sets
+ * the synthetic expressId as the selected entity, which then runs through the
+ * regular property/hover/properties-panel pipeline. That pipeline calls
+ * `entities.getTypeName / getName / getGlobalId` and `properties.getForEntity`
+ * — `createSyntheticDataStore` builds a real single-row entity table (plus the
+ * lazy `getEntity` / `getProperties` accessors) so every member of the
+ * `IfcDataStore` contract is present and compiler-enforced — no `as unknown as`
+ * shims that silently drop an accessor and crash picking at runtime (#1004).
+ *
+ * `IfcGeographicElement` is the closest IFC4 entity for a real-world scan; the
+ * entity table derives its enum (58) from the type name itself.
  */
 function emptyDataStore(
   buffer: ArrayBuffer,
   expressId: number,
   fileName: string,
 ): IfcDataStore {
-  const expressIds = new Uint32Array([expressId]);
-  const empty32 = new Uint32Array(0);
-  const empty8 = new Uint8Array(0);
-  const emptyI32 = new Int32Array(0);
-  const indexOf = (id: number) => (id === expressId ? 0 : -1);
-  const entities = {
-    count: 1,
-    expressId: expressIds,
-    typeEnum: new Uint16Array([IFC_GEOGRAPHIC_ELEMENT_ENUM]),
-    globalId: empty32,
-    name: empty32,
-    description: empty32,
-    objectType: empty32,
-    flags: new Uint8Array([0]),
-    containedInStorey: new Int32Array([-1]),
-    definedByType: new Int32Array([-1]),
-    geometryIndex: new Int32Array([-1]),
-    typeRanges: new Map(),
-    getGlobalId: (id: number) => (indexOf(id) >= 0 ? `pointcloud-${expressId}` : ''),
-    getName: (id: number) => (indexOf(id) >= 0 ? fileName : ''),
-    getDescription: () => '',
-    getObjectType: () => '',
-    getTypeName: (id: number) => (indexOf(id) >= 0 ? 'IfcGeographicElement' : 'Unknown'),
-    hasGeometry: (id: number) => indexOf(id) >= 0,
-    getByType: () => [expressId],
-    getTypeEnum: (id: number) =>
-      indexOf(id) >= 0 ? IFC_GEOGRAPHIC_ELEMENT_ENUM : 9999, // 9999 = Unknown
-    getExpressIdByGlobalId: (gid: string) =>
-      gid === `pointcloud-${expressId}` ? expressId : -1,
-    getGlobalIdMap: () => new Map([[`pointcloud-${expressId}`, expressId]]),
-  };
-  const properties = {
-    count: 0,
-    entityId: empty32, psetName: empty32, psetGlobalId: empty32,
-    propName: empty32, propType: empty8,
-    valueString: empty32, valueReal: new Float64Array(0),
-    valueInt: emptyI32, valueBool: empty8, unitId: emptyI32,
-    entityIndex: new Map<number, number[]>(),
-    psetIndex: new Map<number, number[]>(),
-    propIndex: new Map<number, number[]>(),
-    getForEntity: () => [],
-    getPropertyValue: () => null,
-    findByProperty: () => [],
-  };
-  const quantities = {
-    count: 0,
-    entityId: empty32, qsetName: empty32, qsetGlobalId: empty32,
-    quantityName: empty32, quantityType: empty8,
-    valueReal: new Float64Array(0), unitId: emptyI32,
-    entityIndex: new Map<number, number[]>(),
-    qsetIndex: new Map<number, number[]>(),
-    getForEntity: () => [],
-  };
-  const relationships = {
-    count: 0,
-    relType: empty8, relatingId: empty32, relatedId: empty32,
-    byRelating: new Map<number, number[]>(),
-    byRelated: new Map<number, number[]>(),
-    getOutgoing: () => [],
-    getIncoming: () => [],
-    getRelated: () => [],
-    getRelating: () => [],
-  };
-  const byId = new Map<number, unknown>([[expressId, { expressId }]]);
-  return {
+  return createSyntheticDataStore({
+    schemaVersion: 'IFC4',
     fileSize: buffer.byteLength,
-    schemaVersion: 'IFC4' as const,
     entityCount: 1,
-    parseTime: 0,
-    source: new Uint8Array(0),
-    entityIndex: {
-      byId: byId as unknown as IfcDataStore['entityIndex']['byId'],
-      byType: new Map([['IFCGEOGRAPHICELEMENT', [expressId]]]),
-    },
-    strings: {
-      get: () => '',
-      getId: () => 0,
-      count: 0,
-    } as unknown as IfcDataStore['strings'],
-    entities: entities as unknown as IfcDataStore['entities'],
-    properties: properties as unknown as IfcDataStore['properties'],
-    quantities: quantities as unknown as IfcDataStore['quantities'],
-    relationships: relationships as unknown as IfcDataStore['relationships'],
-    spatialHierarchy: undefined,
-  } as unknown as IfcDataStore;
+    entities: [{
+      expressId,
+      type: 'IfcGeographicElement',
+      globalId: `pointcloud-${expressId}`,
+      name: fileName,
+      hasGeometry: true,
+    }],
+  });
 }
 
 export interface PointCloudIngestResult {

package/src/hooks/ingest/viewerModelIngest.ts

@@ -2,7 +2,7 @@
  * 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 { parseIfcx, type IfcDataStore, type PointCloudExtraction } from '@ifc-lite/parser';
+import { parseIfcx, createSyntheticDataStore, type IfcDataStore, type PointCloudExtraction } from '@ifc-lite/parser';
 import { type GeometryResult, type MeshData, type PointCloudAsset } from '@ifc-lite/geometry';
 import { loadGLBToMeshData } from '@ifc-lite/cache';
 import type { SchemaVersion } from '../../store/types.js';
@@ -44,20 +44,15 @@ export function convertIfcxMeshes(rawMeshes: RawIfcxMesh[]): MeshData[] {
 }
 
 export function createMinimalGlbDataStore(buffer: ArrayBuffer, meshCount: number): IfcDataStore {
-  return {
+  // A GLB carries renderable meshes but no IFC entities. Build a typed,
+  // entity-less store via the shared factory so the full `IfcDataStore`
+  // contract (including the lazy `getEntity` / `getProperties` accessors the
+  // query path calls) is compiler-enforced instead of cast away (#1004).
+  return createSyntheticDataStore({
+    schemaVersion: 'IFC4',
     fileSize: buffer.byteLength,
-    schemaVersion: 'IFC4' as const,
     entityCount: meshCount,
-    parseTime: 0,
-    source: new Uint8Array(0),
-    entityIndex: { byId: new Map(), byType: new Map() },
-    strings: { getString: () => undefined, getStringId: () => undefined, count: 0 } as unknown as IfcDataStore['strings'],
-    entities: { count: 0, getId: () => 0, getType: () => 0, getName: () => undefined, getGlobalId: () => undefined } as unknown as IfcDataStore['entities'],
-    properties: { count: 0, getPropertiesForEntity: () => [], getPropertySetForEntity: () => [] } as unknown as IfcDataStore['properties'],
-    quantities: { count: 0, getQuantitiesForEntity: () => [] } as unknown as IfcDataStore['quantities'],
-    relationships: { count: 0, getRelationships: () => [], getRelated: () => [] } as unknown as IfcDataStore['relationships'],
-    spatialHierarchy: null as unknown as IfcDataStore['spatialHierarchy'],
-  } as unknown as IfcDataStore;
+  });
 }
 
 export function getMaxExpressId(dataStore: IfcDataStore, meshes: MeshData[]): number {

package/src/hooks/useAlignmentLines3D.ts

@@ -24,6 +24,7 @@ import { useViewerStore } from '@/store';
 import { useShallow } from 'zustand/react/shallow';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import { sourceKey } from './source-key.js';
+import { hasEntityType } from './has-entity-type.js';
 
 const EMPTY_F32 = new Float32Array(0);
 
@@ -42,6 +43,10 @@ function notifyCacheChange(): void {
 async function parseAlignmentLinesFor(store: IfcDataStore): Promise<Float32Array> {
   const source = store.source;
   if (!source || source.byteLength === 0) return EMPTY_F32;
+  // Most models (all buildings) have no alignments. Skip the full-source WASM
+  // scan — it copies the entire IFC source into the WASM heap on the main thread
+  // just to find none (~0.5s on a 170MB file).
+  if (!hasEntityType(store, 'IfcAlignment', 'IfcAlignmentCurve')) return EMPTY_F32;
   const processor = new GeometryProcessor();
   try {
     await processor.init();

package/src/hooks/useGridLines3D.ts

@@ -24,6 +24,7 @@ import { useViewerStore } from '@/store';
 import { useShallow } from 'zustand/react/shallow';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import { sourceKey } from './source-key.js';
+import { hasEntityType } from './has-entity-type.js';
 
 const EMPTY_F32 = new Float32Array(0);
 
@@ -42,6 +43,9 @@ function notifyCacheChange(): void {
 async function parseGridLinesFor(store: IfcDataStore): Promise<Float32Array> {
   const source = store.source;
   if (!source || source.byteLength === 0) return EMPTY_F32;
+  // Skip the full-source WASM scan when the model has no grid — it copies the
+  // entire IFC source into the WASM heap on the main thread just to find none.
+  if (!hasEntityType(store, 'IfcGridAxis', 'IfcGrid')) return EMPTY_F32;
   const processor = new GeometryProcessor();
   try {
     await processor.init();

package/src/hooks/useIDS.ts

@@ -38,6 +38,7 @@ import { getEntityBounds } from '@/utils/viewportUtils';
 import { getGlobalRenderer } from '@/hooks/useBCF';
 
 import { createDataAccessor } from './ids/idsDataAccessor';
+import { runValidationInWorker, idsWorkerSupported } from './ids/idsWorkerClient';
 import {
   DEFAULT_FAILED_COLOR,
   DEFAULT_PASSED_COLOR,
@@ -386,23 +387,85 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
     try {
       setIdsLoading(true);
       setIdsError(null);
+      // Paint a "starting" state immediately so the button shows work is
+      // underway before the first real progress event arrives.
+      setIdsProgress({
+        phase: 'filtering',
+        specificationIndex: 0,
+        totalSpecifications: document.specifications.length,
+        entitiesProcessed: 0,
+        totalEntities: 0,
+        percentage: 0,
+      });
 
-      // Create data accessor
-      const accessor = createDataAccessor(dataStore, modelId);
+      // Force the loading state to actually paint before spawning the
+      // worker and doing any heavy synchronous work, so the spinner +
+      // initial progress bar are guaranteed on screen immediately. Race
+      // the frame wait against a timer so a backgrounded tab (where
+      // requestAnimationFrame is paused) can't stall the run.
+      await new Promise<void>((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        };
+        requestAnimationFrame(() => requestAnimationFrame(done));
+        setTimeout(done, 200);
+      });
 
-      // Create model info
-      const modelInfo: IDSModelInfo = {
-        modelId,
-        schemaVersion: dataStore.schemaVersion || 'IFC4',
-        entityCount: dataStore.entityCount || accessor.getAllEntityIds().length,
+      const schemaVersion = dataStore.schemaVersion || 'IFC4';
+
+      // Progress events arrive far faster than React should re-render
+      // (per 100 entities / per spec); throttle store updates to ~8/s
+      // and always pass the terminal event.
+      let lastProgressUpdate = 0;
+      const onProgress = (p: ValidationProgress) => {
+        const now = performance.now();
+        if (p.phase === 'complete' || now - lastProgressUpdate >= 120) {
+          lastProgressUpdate = now;
+          setIdsProgress(p);
+        }
       };
 
-      // Run validation
-      const validationReport = await validateIDS(document, accessor, modelInfo, {
-        translator,
-        onProgress: setIdsProgress,
-        includePassingEntities: true,
-      });
+      let validationReport: IDSValidationReport | null = null;
+
+      // Preferred path: validate in a Web Worker so the whole run is off
+      // the main thread — the UI stays at full frame rate and progress
+      // actually paints. Every other heavy stage (parse, geometry)
+      // already runs in a worker; this brings validation in line. Falls
+      // back to in-process validation if the worker is unavailable or
+      // fails (e.g. no source bytes for non-STEP models).
+      const canUseWorker = idsWorkerSupported() && !!dataStore.source && dataStore.source.byteLength > 0;
+      if (canUseWorker) {
+        try {
+          validationReport = await runValidationInWorker({
+            source: dataStore.source!,
+            document,
+            schemaVersion,
+            modelId,
+            locale,
+            includePassingEntities: true,
+            onProgress,
+          });
+        } catch (workerErr) {
+          console.warn('[IDS] Worker validation failed; falling back to main thread.', workerErr);
+        }
+      }
+
+      if (!validationReport) {
+        const accessor = createDataAccessor(dataStore, modelId);
+        const modelInfo: IDSModelInfo = {
+          modelId,
+          schemaVersion,
+          entityCount: dataStore.entityCount || accessor.getAllEntityIds().length,
+        };
+        validationReport = await validateIDS(document, accessor, modelInfo, {
+          translator,
+          onProgress,
+          includePassingEntities: true,
+        });
+      }
 
       setIdsValidationReport(validationReport);
 
@@ -426,6 +489,7 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
     models,
     activeModelId,
     translator,
+    locale,
     setIdsLoading,
     setIdsError,
     setIdsProgress,

package/src/hooks/useIfcCache.ts

@@ -23,7 +23,7 @@ import { buildSpatialIndexGuarded } from '../utils/loadingUtils.js';
 import type { MeshData } from '@ifc-lite/geometry';
 
 import { useShallow } from 'zustand/react/shallow';
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '../store/index.js';
 import { getCached, setCached, deleteCached, type CacheResult } from '../services/cacheService.js';
 import { rebuildSpatialHierarchy, rebuildOnDemandMaps } from '../utils/spatialHierarchy.js';
 import { calculateStoreyHeights } from '../utils/localParsingUtils.js';

package/src/hooks/useIfcFederation.ts

@@ -12,7 +12,7 @@
 
 import { useCallback, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
-import { useViewerStore, type FederatedModel, type SchemaVersion } from '../store.js';
+import { useViewerStore, type FederatedModel, type SchemaVersion } from '../store/index.js';
 import {
   detectFormat,
   parseFederatedIfcx,

package/src/hooks/useIfcServer.ts

@@ -11,7 +11,7 @@
  */
 
 import { useCallback } from 'react';
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '../store/index.js';
 import type { MeshData, CoordinateInfo } from '@ifc-lite/geometry';
 import {
   IfcServerClient,

package/src/hooks/useModelSelection.ts

@@ -19,7 +19,7 @@
  */
 
 import { useEffect } from 'react';
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '../store/index.js';
 import { resolveEntityRef } from '../store/resolveEntityRef.js';
 
 export function useModelSelection() {

package/src/hooks/useSolarEnvironment.ts

@@ -0,0 +1,114 @@
+/* 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/. */
+
+/**
+ * Bridge the solar study to the WebGPU renderer's lighting environment.
+ *
+ * While the study is enabled and the model is georeferenced, this hook
+ * computes the sun's true direction for the studied instant at the site and
+ * publishes it (viewer/world space, Y-up) to `solarSunDirection` — Viewport
+ * folds it into `RenderOptions.environment`, so the WebGPU sun and sky track
+ * the same instant Cesium's clock is pinned to.
+ *
+ * It also publishes the panel readout (`solarSunInfo`) when the Cesium
+ * overlay is OFF — with Cesium on, CesiumOverlay's solar effect owns that
+ * write (it uses the terrain-clamped bridge origin).
+ */
+
+import { useEffect, useState } from 'react';
+import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+import type { CoordinateInfo } from '@ifc-lite/geometry';
+import { sunPosition, sunTimes, azimuthAltitudeToEnu } from '@ifc-lite/solar';
+import { useViewerStore } from '@/store';
+import { computeCesiumModelOrigin } from '@/lib/geo/cesium-bridge';
+import { enuToViewerDirection } from '@/lib/geo/solar-direction';
+
+export interface SolarEnvironmentGeoref {
+  mapConversion?: MapConversion;
+  projectedCRS?: ProjectedCRS;
+  coordinateInfo?: CoordinateInfo;
+  lengthUnitScale?: number;
+}
+
+interface SiteOrigin {
+  latitude: number;
+  longitude: number;
+}
+
+export function useSolarEnvironment(georef: SolarEnvironmentGeoref | null): void {
+  const solarEnabled = useViewerStore((s) => s.solarEnabled);
+  const solarDateMs = useViewerStore((s) => s.solarDateMs);
+  const cesiumEnabled = useViewerStore((s) => s.cesiumEnabled);
+  const setSolarSunDirection = useViewerStore((s) => s.setSolarSunDirection);
+  const setSolarSunInfo = useViewerStore((s) => s.setSolarSunInfo);
+
+  const [origin, setOrigin] = useState<SiteOrigin | null>(null);
+
+  const mapConversion = georef?.mapConversion;
+  const projectedCRS = georef?.projectedCRS;
+
+  // Resolve the site's lat/lon once per georeference (proj4 lookup is async).
+  useEffect(() => {
+    if (!solarEnabled || !mapConversion || !projectedCRS) {
+      setOrigin(null);
+      return;
+    }
+    let cancelled = false;
+    (async () => {
+      try {
+        const resolved = await computeCesiumModelOrigin(
+          mapConversion,
+          projectedCRS,
+          georef?.coordinateInfo,
+          georef?.lengthUnitScale ?? 1,
+        );
+        if (!cancelled) {
+          setOrigin(resolved ? { latitude: resolved.latitude, longitude: resolved.longitude } : null);
+        }
+      } catch {
+        if (!cancelled) setOrigin(null);
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [solarEnabled, mapConversion, projectedCRS, georef?.coordinateInfo, georef?.lengthUnitScale]);
+
+  // Publish the viewer-space sun direction for the studied instant.
+  useEffect(() => {
+    if (!solarEnabled || !origin) {
+      setSolarSunDirection(null);
+      return;
+    }
+    const date = new Date(solarDateMs);
+    const sp = sunPosition(date, origin.latitude, origin.longitude);
+    const enu = azimuthAltitudeToEnu(sp.azimuth, sp.altitude);
+    setSolarSunDirection(enuToViewerDirection(
+      enu,
+      mapConversion?.xAxisAbscissa ?? 1,
+      mapConversion?.xAxisOrdinate ?? 0,
+    ));
+
+    // Panel readout — only when CesiumOverlay isn't publishing it.
+    if (!cesiumEnabled) {
+      const times = sunTimes(date, origin.latitude, origin.longitude);
+      setSolarSunInfo({
+        latitude: origin.latitude,
+        longitude: origin.longitude,
+        azimuth: sp.azimuth,
+        altitude: sp.altitude,
+        sunriseMs: times.sunrise ? times.sunrise.getTime() : null,
+        sunsetMs: times.sunset ? times.sunset.getTime() : null,
+        solarNoonMs: times.solarNoon.getTime(),
+      });
+    }
+  }, [
+    solarEnabled,
+    solarDateMs,
+    origin,
+    cesiumEnabled,
+    mapConversion?.xAxisAbscissa,
+    mapConversion?.xAxisOrdinate,
+    setSolarSunDirection,
+    setSolarSunInfo,
+  ]);
+}