@ifc-lite/viewer 1.28.1 → 1.30.0

package/src/hooks/useDrawingGeneration.ts

@@ -18,6 +18,8 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 import {
   Drawing2DGenerator,
   createSectionConfig,
+  currentFloorBands,
+  storeyFloorsFromMeshes,
   type Drawing2D,
   type DrawingLine,
   type SectionConfig,
@@ -25,6 +27,7 @@ import {
   type MeshOutline2D,
 } from '@ifc-lite/drawing-2d';
 import { GeometryProcessor, type GeometryResult } from '@ifc-lite/geometry';
+import type { SpatialHierarchy } from '@ifc-lite/data';
 import * as IfcWasm from '@ifc-lite/wasm';
 import { customPlaneCenter } from '@/store';
 
@@ -64,9 +67,22 @@ export const AXIS_MAP: Record<'down' | 'front' | 'side', 'x' | 'y' | 'z'> = {
 // live in is already in metres (WASM applies `unit_scale` upstream).
 export const ANNOTATION_VIEW_DEPTH = 1.2;
 
+// View depth BEHIND a vertical (front/side) section cut within which
+// construction projection is drawn, as a fraction of the model extent along the
+// cut axis (issue #979 follow-up). A vertical section has no "storey" to scope
+// to, so it projects a bounded slab behind the cut — near geometry solid,
+// occluded/far dashed (hidden-line pass) — and culls the cut-away front half
+// and anything past this depth. Half the model depth is a sensible default;
+// tune here if sections feel too deep or too shallow.
+export const SECTION_VIEW_DEPTH_FRACTION = 0.5;
+
 interface UseDrawingGenerationParams {
   geometryResult: GeometryResult | null | undefined;
-  ifcDataStore: { source: Uint8Array } | null;
+  // `spatialHierarchy` (optional — absent on cache-reopened models) backs the
+  // current-floor projection scoping (issue #979 follow-up). The runtime
+  // already passes the full DataStore from `useIfc()`, so this is a pure type
+  // widen, not new prop threading.
+  ifcDataStore: { source: Uint8Array; spatialHierarchy?: SpatialHierarchy } | null;
   /**
    * Section plane state. `custom` is the optional face-pick override
    * (issue #243); when set the cutter cuts on that arbitrary plane and
@@ -162,6 +178,15 @@ export function useDrawingGeneration({
     sourceId: string | null;
   } | null>(null);
 
+  // Cache for per-storey floor levels used to scope construction projection to
+  // the current floor (issue #979 follow-up). Derived from mesh-Y, so it only
+  // changes when the model/visibility set changes — keyed on the same
+  // `modelCacheKey` as the profile cache.
+  const storeyFloorsCacheRef = useRef<{
+    floors: number[];
+    sourceId: string | null;
+  } | null>(null);
+
   // Generate drawing when panel opens
   const generateDrawing = useCallback(async (isRegenerate = false) => {
     if (!geometryResult?.meshes || geometryResult.meshes.length === 0) {
@@ -376,21 +401,27 @@ export function useDrawingGeneration({
       }
     }
 
-    // Construction projection is plan-only (issue #979): the cut must be the
-    // cardinal 'down' axis and not a face-picked custom plane. The UI disables
-    // the toggle off-plan, but the persisted flag can stay true when the user
-    // switches axis — so gate generation here too, otherwise front/side/custom
-    // sections keep emitting projection the user can't turn off.
-    const projectionSupported = sectionPlane.axis === 'down' && !sectionPlane.custom;
+    // Construction projection runs on any CARDINAL cut (plan 'down' + vertical
+    // 'front'/'side'), but NOT a face-picked custom plane (the band classifier
+    // and outline binding are cardinal-only). Plan and section use different
+    // boundaries: plan scopes to the current storey; a vertical section has no
+    // "storey", so it projects a bounded view depth behind the cut (see the
+    // band computation below). The UI gates the toggle to the same set; the
+    // persisted flag can survive a switch to a custom plane, so gate here too.
+    const projectionSupported = !sectionPlane.custom;
     const projectionOn = projectionSupported && displayOptions.showConstructionProjection;
 
     // ── Construction projection profiles (issue #979) ────────────────────────
     // Extract extruded-area-solid profiles for the clean projection path. Only
-    // when projection is on; cached per model since they don't move with the
-    // section. Single-model (modelIndex 0) for now, mirroring the symbolic
-    // path's federation limitation.
+    // for PLAN cuts: the profile projector draws a solid's base footprint, which
+    // is the plan representation but collapses to a base edge on a vertical
+    // section — so front/side cuts use the mesh-silhouette/outline path instead
+    // (profiles stay empty → every mesh silhouettes). Cached per model since
+    // they don't move with the section. Single-model (modelIndex 0) for now,
+    // mirroring the symbolic path's federation limitation.
+    const profilesNeeded = projectionOn && sectionPlane.axis === 'down';
     let profiles: ProfileEntry[] = [];
-    if (projectionOn && ifcDataStore?.source) {
+    if (profilesNeeded && ifcDataStore?.source) {
       const pcache = profileCacheRef.current;
       if (pcache && pcache.sourceId === modelCacheKey) {
         profiles = pcache.profiles;
@@ -461,8 +492,10 @@ export function useDrawingGeneration({
           profiles = [];
         }
       }
-    } else if (profileCacheRef.current) {
-      // Toggle off: drop the cache so a re-enable re-extracts cleanly.
+    } else if (!projectionOn && profileCacheRef.current) {
+      // Projection fully off: drop the cache so a re-enable re-extracts cleanly.
+      // A plan↔section switch (projection still on) keeps the cache so flipping
+      // back to a plan reuses the extracted profiles.
       profileCacheRef.current = null;
     }
 
@@ -484,16 +517,78 @@ export function useDrawingGeneration({
       // Calculate max depth as half the model extent
       const maxDepth = (axisMax - axisMin) * 0.5;
 
-      // Construction-projection bands (issue #979). Project the full model
-      // extent on each side of the cut and let the band classifier split by
-      // side (below → solid, above → dashed). Full extent makes single-storey
-      // models with an overhead roof (e.g. AC20) "just work"; multi-storey
-      // bleed is naturally scoped when the user isolates a storey (the meshes
-      // are already filtered to it below). Flip-invariant: the classifier
-      // applies the flip sign itself. Floor at 1mm so a degenerate zero-extent
-      // model (or a storey collapsed to a single slab) doesn't yield 0-width
-      // bands that cull every element sitting on the plane.
+      // Construction-projection bands (issue #979 + current-floor follow-up).
+      // Project geometry on each side of the cut and let the band classifier
+      // split it (below → solid, above → dashed). `fullExtent` (the whole model
+      // height) is the baseline; for a multi-storey model on a plan cut the
+      // bands are instead clamped to the storey the cut sits in, so other
+      // floors don't bleed onto the plan (e.g. a roof two levels up — the
+      // reported bug). Flip-invariant: the classifier applies the flip sign
+      // itself. Floor at 1mm so a degenerate zero-extent model (or a storey
+      // collapsed to a single slab) doesn't yield 0-width bands that cull every
+      // element sitting on the plane.
       const fullExtent = Math.max(axisMax - axisMin, 1e-3);
+      let belowDepth = fullExtent;
+      let aboveDepth = fullExtent;
+
+      // Auto-scope to the current floor only when it's safe and meaningful:
+      // a plan ('down') cut with projection on, a single model (storey ids are
+      // LOCAL express ids — federation would mismatch global mesh ids), no
+      // active manual isolation or storey selection (those already scope the
+      // set and the user's explicit choice wins), spatial-hierarchy data
+      // present (absent on cache-reopened models), and at most ONE building.
+      // A single IFC can hold several IfcBuildings with staggered storey
+      // elevations; flattening all their storey minima into one band mis-scopes
+      // (a cut on building B's ground floor capped by building A's upper
+      // storey), so multi-building models fall back to full extent too.
+      // Otherwise keep the shipped full-extent behavior so single-storey /
+      // cache-loaded / federated / multi-building models don't regress.
+      const sh = ifcDataStore?.spatialHierarchy;
+      const canScopeFloor =
+        projectionOn &&
+        sectionPlane.axis === 'down' &&
+        !sectionPlane.custom &&
+        models.size <= 1 &&
+        combinedIsolatedIds === null &&
+        !(computedIsolatedIds && computedIsolatedIds.size > 0) &&
+        sh !== undefined &&
+        sh.byBuilding.size <= 1;
+      if (canScopeFloor && sh) {
+        const cached = storeyFloorsCacheRef.current;
+        const floors =
+          cached && cached.sourceId === modelCacheKey
+            ? cached.floors
+            : storeyFloorsFromMeshes(geometryResult.meshes, sh.elementToStorey);
+        if (!cached || cached.sourceId !== modelCacheKey) {
+          storeyFloorsCacheRef.current = { floors, sourceId: modelCacheKey };
+        }
+        // Need ≥2 storeys to scope: with 0/1 storey there is no "other floor"
+        // to exclude, and full extent keeps an overhead roof projecting.
+        if (floors.length >= 2) {
+          // `currentFloorBands` returns GEOMETRIC depths — `below` toward the
+          // floor, `above` toward the ceiling. The band classifier reads them
+          // in FLIP-ADJUSTED depth space (d<0 = `below` slot), so on a flipped
+          // plan cut (looking up — a reflected-ceiling-plan style view) the
+          // floor/ceiling map to the opposite slots and the magnitudes must be
+          // swapped. The shipped full-extent bands were symmetric so this never
+          // mattered before; the asymmetric storey bands make flip significant.
+          const bands = currentFloorBands(floors, position, axisMin, axisMax);
+          belowDepth = sectionPlane.flipped ? bands.above : bands.below;
+          aboveDepth = sectionPlane.flipped ? bands.below : bands.above;
+        }
+      }
+
+      // Vertical section (front/side): storeys don't bound it. Project a
+      // bounded view depth BEHIND the cut and cull the cut-away front half +
+      // anything past that depth. "Behind" is always the `below` (d<0) band:
+      // the band classifier's flip and the view direction's flip cancel, so
+      // this is flip-invariant (no swap needed). Near geometry draws solid;
+      // the hidden-line pass dashes occluded/far parts. (Profiles aren't
+      // extracted off-plan, so this geometry comes from the mesh silhouette.)
+      if (projectionOn && !sectionPlane.custom && sectionPlane.axis !== 'down') {
+        belowDepth = Math.max((axisMax - axisMin) * SECTION_VIEW_DEPTH_FRACTION, 1e-3);
+        aboveDepth = 1e-3; // cull the half in front of the cut
+      }
 
       // Adjust progress to account for symbolic parsing phase (0-20%)
       const progressOffset = symbolicLines.length > 0 ? 20 : 0;
@@ -505,8 +600,8 @@ export function useDrawingGeneration({
       // Create section config
       const config: SectionConfig = createSectionConfig(axis, position, {
         projectionDepth: maxDepth,
-        projectionBelowDepth: fullExtent,
-        projectionAboveDepth: fullExtent,
+        projectionBelowDepth: belowDepth,
+        projectionAboveDepth: aboveDepth,
         includeHiddenLines: displayOptions.showHiddenLines,
         scale: displayOptions.scale,
       });

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

package/src/hooks/useSolarSweep.ts

@@ -0,0 +1,66 @@
+/* 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 sweep animation — advances the studied instant while playing.
+ *
+ * Lives at the viewport level (not inside the panel) so collapsing or
+ * closing the Sun & Sky panel doesn't stop a running sweep.
+ *
+ * Reads/writes the store imperatively each tick to avoid stale closures,
+ * and wraps within the current day (day sweep) or year (year sweep) so the
+ * animation loops cleanly.
+ */
+
+import { useEffect, useRef } from 'react';
+import { useViewerStore } from '@/store';
+import { solarDisplayOffsetMinutes, MS_PER_MIN, MS_PER_DAY } from '@/lib/solar-time';
+
+/** Wall-clock cadence for the animation sweep. */
+const TICK_MS = 80;
+/** Per-tick advance: 8 minutes of solar time (day) or 2 days (year). */
+const DAY_STEP_MIN = 8;
+const YEAR_STEP_DAYS = 2;
+
+export function useSolarSweep(): void {
+  const enabled = useViewerStore((s) => s.solarEnabled);
+  const playing = useViewerStore((s) => s.solarPlaying);
+  const sweepMode = useViewerStore((s) => s.solarSweepMode);
+
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  useEffect(() => {
+    if (!enabled || !playing) return;
+    intervalRef.current = setInterval(() => {
+      const store = useViewerStore.getState();
+      const current = store.solarDateMs;
+      let next: number;
+      if (store.solarSweepMode === 'day') {
+        // Wrap in the same display frame the slider edits in, so the day seam
+        // lands at displayed midnight (not UTC midnight) and the date doesn't
+        // flip mid-sweep when site/local time is active.
+        const offsetMin = solarDisplayOffsetMinutes(store.solarUseLocalTime, store.solarSunInfo?.longitude);
+        const displayMs = current + offsetMin * MS_PER_MIN;
+        const disp = new Date(displayMs);
+        const dayStart = Date.UTC(disp.getUTCFullYear(), disp.getUTCMonth(), disp.getUTCDate());
+        const minutes = (displayMs - dayStart) / MS_PER_MIN;
+        const nextMinutes = (minutes + DAY_STEP_MIN) % 1440;
+        next = dayStart + nextMinutes * MS_PER_MIN - offsetMin * MS_PER_MIN;
+      } else {
+        const d = new Date(current);
+        const yearStart = Date.UTC(d.getUTCFullYear(), 0, 1);
+        const dayOfYear = Math.floor((current - yearStart) / MS_PER_DAY);
+        const isLeap = (d.getUTCFullYear() % 4 === 0 && d.getUTCFullYear() % 100 !== 0) || d.getUTCFullYear() % 400 === 0;
+        const daysInYear = isLeap ? 366 : 365;
+        const timeOfDay = current - (yearStart + dayOfYear * MS_PER_DAY);
+        const nextDay = (dayOfYear + YEAR_STEP_DAYS) % daysInYear;
+        next = yearStart + nextDay * MS_PER_DAY + timeOfDay;
+      }
+      store.setSolarDateMs(next);
+    }, TICK_MS);
+    return () => {
+      if (intervalRef.current !== null) clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    };
+  }, [enabled, playing, sweepMode]);
+}

package/src/hooks/useSymbolicAnnotations.ts

@@ -19,6 +19,7 @@ import { decodeIfcString } from '@ifc-lite/encoding';
 import { useViewerStore } from '@/store';
 import { useShallow } from 'zustand/react/shallow';
 import type { IfcDataStore } from '@ifc-lite/parser';
+import { hasEntityType } from './has-entity-type.js';
 
 /** Lines belonging to a single storey, ready to feed into the section overlay. */
 export interface AnnotationsForStorey {
@@ -240,6 +241,15 @@ async function parseAnnotations(
     if (debugEnabled()) console.log('[annotations] skip: missing/empty source');
     return result;
   }
+  // Skip the full-source WASM scan only when the model has neither IfcAnnotation
+  // nor IfcGridAxis — this parse path ALSO feeds the grid buckets (gridByStorey /
+  // gridLoose*), so gating on IfcAnnotation alone would drop grid-only models.
+  // The scan copies the entire IFC source into the WASM heap on the main thread,
+  // so skipping it when there is nothing to find still matters.
+  if (!hasEntityType(store, 'IfcAnnotation', 'IfcGridAxis')) {
+    if (debugEnabled()) console.log('[annotations] skip: no IfcAnnotation/IfcGridAxis entities');
+    return result;
+  }
 
   const hierarchy = store.spatialHierarchy;
   const elementToStorey = hierarchy?.elementToStorey;

package/src/hooks/useViewerSelectors.ts

@@ -8,7 +8,7 @@
  * Extracted from Viewport.tsx for reusability
  */
 
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '../store/index.js';
 
 /**
  * Selection-related store state and actions