@ifc-lite/viewer 1.17.6 → 1.19.0

package/src/hooks/useIfcFederation.ts

@@ -33,6 +33,12 @@ import {
   parseIfcxViewerModel,
   parseStepBufferViewerModel,
 } from './ingest/viewerModelIngest.js';
+import {
+  detectPointCloudFormat,
+  ingestPointCloud,
+  type PointCloudFormat,
+} from './ingest/pointCloudIngest.js';
+import { getGlobalRenderer } from './useBCF.js';
 import { readNativeFile, type NativeFileHandle } from '../services/file-dialog.js';
 import { getEffectiveGeoreference, type GeorefMutationDataLike } from '../lib/geo/effective-georef.js';
 
@@ -439,14 +445,53 @@ export function useIfcFederation() {
         : await file.arrayBuffer();
       const fileSizeMB = buffer.byteLength / (1024 * 1024);
 
+      // Detect point cloud formats first — we never run them through
+      // detectFormat() (which is IFC-shaped) because they have their own
+      // streaming pipeline that bypasses geometryResult.meshes.
+      const pointCloudFormat = detectPointCloudFormat(file.name, buffer);
+
       // Detect file format
-      const format = detectFormat(buffer);
+      const format: ReturnType<typeof detectFormat> | PointCloudFormat =
+        pointCloudFormat ?? detectFormat(buffer);
 
       let parsedDataStore: IfcDataStore | null = null;
       let parsedGeometry: FederatedModel['geometryResult'] = null;
       let schemaVersion: SchemaVersion = 'IFC4';
-
-      if (format === 'ifcx') {
+      // Renderer handle for streamed point clouds; surviving model lifecycle
+      // depends on persisting it onto the FederatedModel record.
+      let pointCloudHandleId: number | undefined;
+
+      if (format === 'las' || format === 'laz' || format === 'ply' || format === 'pcd' || format === 'e57') {
+        const renderer = getGlobalRenderer();
+        if (!renderer) {
+          setError('Renderer not initialised — try again after the viewer mounts.');
+          setLoading(false);
+          return null;
+        }
+        setProgress({ phase: `Streaming ${format.toUpperCase()}`, percent: 5 });
+        const blob = isNativeFileHandle(file)
+          ? new Blob([buffer])
+          : (file as File);
+        const incCount = useViewerStore.getState().incrementPointCloudAssetCount;
+        const ingest = ingestPointCloud({
+          format,
+          blob,
+          fileName: file.name,
+          buffer,
+          renderer,
+          onProgress: setProgress,
+          onAssetCountDelta: incCount,
+        });
+        // ingest.done rejects on stream errors; ingestPointCloud's onError
+        // callback already calls removePointCloudAsset + incCount(-1), so
+        // the outer catch must NOT repeat that cleanup or the count goes
+        // negative when other point clouds are still loaded.
+        await ingest.done;
+        parsedDataStore = ingest.dataStore;
+        parsedGeometry = ingest.geometryResult;
+        schemaVersion = ingest.schemaVersion;
+        pointCloudHandleId = ingest.rendererHandle.id;
+      } else if (format === 'ifcx') {
         setProgress({ phase: 'Parsing IFCX (client-side)', percent: 10 });
         try {
           const result = await parseIfcxViewerModel(buffer, setProgress);
@@ -541,6 +586,29 @@ export function useIfcFederation() {
         for (const mesh of parsedGeometry.meshes) {
           mesh.expressId = mesh.expressId + idOffset;
         }
+        // Point clouds need the same offset so picking / isolation /
+        // property lookup resolve through the FederationRegistry's
+        // global ID space — otherwise two pointcloud models with the
+        // same local expressId collide.
+        for (const asset of parsedGeometry.pointClouds ?? []) {
+          asset.expressId = asset.expressId + idOffset;
+        }
+      }
+      // Streamed point cloud: the GPU asset was opened with a synthetic
+      // local expressId. After registerModelOffset() hands us an
+      // idOffset, the renderer needs to emit the post-offset globalId
+      // in picking + selection outputs — otherwise picks resolve to
+      // the local id and collide across federated models. The shader
+      // reads expressId from a per-asset uniform (`flags.x`) so this
+      // is just a metadata update; no GPU buffer rewrite.
+      if (idOffset > 0 && pointCloudHandleId !== undefined) {
+        const renderer = getGlobalRenderer();
+        if (renderer && parsedGeometry.pointClouds && parsedGeometry.pointClouds.length > 0) {
+          // Use the asset that's already had idOffset folded in above
+          // as the source of truth for the global id.
+          const asset = parsedGeometry.pointClouds[0];
+          renderer.relabelPointCloudAsset({ id: pointCloudHandleId }, asset.expressId);
+        }
       }
 
       // =========================================================================
@@ -567,6 +635,7 @@ export function useIfcFederation() {
         sourceFile: file,
         idOffset,
         maxExpressId,
+        pointCloudHandleId,
       };
 
       // Add to store

package/src/hooks/useIfcLoader.ts

@@ -46,6 +46,8 @@ import { useIfcCache, getCached } from './useIfcCache.js';
 import { useIfcServer } from './useIfcServer.js';
 
 import { getMaxExpressId, parseGlbViewerModel, parseIfcxViewerModel } from './ingest/viewerModelIngest.js';
+import { detectPointCloudFormat, ingestPointCloud } from './ingest/pointCloudIngest.js';
+import { getGlobalRenderer } from './useBCF.js';
 
 /**
  * Compute a fast content fingerprint from the first and last 4KB of a buffer.
@@ -253,7 +255,7 @@ export function useIfcLoader() {
         dataStore: IfcDataStore | null,
         geometryResult: { meshes: MeshData[]; totalVertices: number; totalTriangles: number; coordinateInfo: CoordinateInfo } | null,
         schemaVersion: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5',
-        patch?: { loadState?: 'pending' | 'streaming-geometry' | 'hydrating-metadata' | 'complete' | 'error'; cacheState?: 'none' | 'hit' | 'miss' | 'writing'; loadError?: string | null },
+        patch?: { loadState?: 'pending' | 'streaming-geometry' | 'hydrating-metadata' | 'complete' | 'error'; cacheState?: 'none' | 'hit' | 'miss' | 'writing'; loadError?: string | null; pointCloudHandleId?: number },
       ) => {
         let idOffset = 0;
         let maxExpressId = 0;
@@ -271,6 +273,7 @@ export function useIfcLoader() {
           loadState: patch?.loadState ?? 'complete',
           cacheState: patch?.cacheState ?? 'none',
           loadError: patch?.loadError ?? null,
+          pointCloudHandleId: patch?.pointCloudHandleId,
         });
       };
       const getSchemaVersion = (dataStore: IfcDataStore | null): 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5' => {
@@ -281,15 +284,23 @@ export function useIfcLoader() {
         return 'IFC2X3';
       };
 
+      // Native renderer streaming path is currently disabled — the
+      // `huge native file` block further down handles real desktop
+      // streaming. This branch is retained as a scaffold for the future
+      // always-on native renderer integration.
+      const NATIVE_RENDERER_PATH_ENABLED = false as boolean;
       if (
+        NATIVE_RENDERER_PATH_ENABLED &&
         isNativeFileHandle(file) &&
-        fileName.toLowerCase().endsWith('.ifc') &&
-        false
+        fileName.toLowerCase().endsWith('.ifc')
       ) {
+        // Re-narrow `file` for the body — TS occasionally drops the
+        // type-predicate result inside a dead branch.
+        const nativeFile: NativeFileHandle = file;
         const harnessRequest = getActiveHarnessRequest();
-        const nativeCacheKey = computeNativeCacheKey(file);
-        const shouldUseNativeCache = file.size >= CACHE_SIZE_THRESHOLD;
-        const hugeNativeMode = file.size >= HUGE_NATIVE_FILE_THRESHOLD;
+        const nativeCacheKey = computeNativeCacheKey(nativeFile);
+        const shouldUseNativeCache = nativeFile.size >= CACHE_SIZE_THRESHOLD;
+        const hugeNativeMode = nativeFile.size >= HUGE_NATIVE_FILE_THRESHOLD;
         let firstBatchWaitMs: number | null = null;
         let firstVisibleGeometryMs: number | null = null;
         let modelOpenMs: number | null = null;
@@ -312,7 +323,7 @@ export function useIfcLoader() {
         let nativeGeometryCacheHit = false;
         let nativeMetadataSnapshotHit = false;
         let nativeMetadataSource: 'snapshot' | 'ifc-parse' = 'ifc-parse';
-        let nativeMetadataStartGate: 'immediate' | 'afterInteractiveGeometry' | 'afterGeometryComplete' = 'immediate';
+        let nativeMetadataStartGate = 'immediate' as 'immediate' | 'afterInteractiveGeometry' | 'afterGeometryComplete';
         let finalCoordinateInfo: CoordinateInfo | null = null;
 
         console.log(`[useIfc] Native renderer load: ${fileName}, size: ${fileSizeMB.toFixed(2)}MB`);
@@ -727,7 +738,7 @@ export function useIfcLoader() {
         let fullNativeDataStore: IfcDataStore | null = null;
         let nativeLoadStage: 'open' | 'streamGeometry' | 'finalizeGeometry' | 'hydrateMetadata' | 'complete' = 'open';
         let nativeMetadataSource: 'snapshot' | 'ifc-parse' = 'ifc-parse';
-        let nativeMetadataStartGate: 'immediate' | 'afterInteractiveGeometry' | 'afterGeometryComplete' = 'immediate';
+        let nativeMetadataStartGate = 'immediate' as 'immediate' | 'afterInteractiveGeometry' | 'afterGeometryComplete';
 
         setGeometryResult(null);
 
@@ -1552,8 +1563,69 @@ export function useIfcLoader() {
       const fileReadMs = performance.now() - fileReadStart;
       console.log(`[useIfc] File: ${file.name}, size: ${fileSizeMB.toFixed(2)}MB, read in ${fileReadMs.toFixed(0)}ms`);
 
-      // Detect file format (IFCX/IFC5 vs IFC4 STEP vs GLB)
-      const format = detectFormat(buffer);
+      // Detect file format (IFCX/IFC5 vs IFC4 STEP vs GLB vs LAS/LAZ)
+      const pointCloudFormat = detectPointCloudFormat(file.name, buffer);
+      const format = pointCloudFormat ?? detectFormat(buffer);
+
+      // LAS / LAZ point clouds: stream chunks straight to the renderer.
+      // No on-disk cache, no server upload — the data goes worker → GPU.
+      if (format === 'las' || format === 'laz' || format === 'ply' || format === 'pcd' || format === 'e57') {
+        const renderer = getGlobalRenderer();
+        if (!renderer) {
+          setError('Renderer not initialised — try again after the viewer mounts.');
+          updateModel(primaryModelId, { loadState: 'error', loadError: 'renderer-missing' });
+          setLoading(false);
+          return;
+        }
+        setProgress({ phase: `Streaming ${format.toUpperCase()}`, percent: 5 });
+        setGeometryStreamingActive(false);
+        const blob = isNativeFileHandle(file) ? new Blob([buffer]) : (file as File);
+        const incCount = useViewerStore.getState().incrementPointCloudAssetCount;
+        const ingest = ingestPointCloud({
+          format,
+          blob,
+          fileName: file.name,
+          buffer,
+          renderer,
+          onProgress: setProgress,
+          onAssetCountDelta: incCount,
+        });
+        // ingestPointCloud's onError callback already runs renderer cleanup
+        // + incCount(-1); the outer catch must NOT repeat them or the
+        // pointCloudAssetCount will go negative.
+        try {
+          await ingest.done;
+        } catch (err) {
+          // Bail without touching store/UI state if a newer load
+          // session has already started — the more recent flow owns
+          // the spinner / model record now. Free the renderer handle
+          // so we don't leak the half-streamed asset.
+          if (loadSessionRef.current !== currentSession) {
+            renderer.removePointCloudAsset(ingest.rendererHandle);
+            return;
+          }
+          const message = err instanceof Error ? err.message : String(err);
+          updateModel(primaryModelId, { loadState: 'error', loadError: message });
+          setError(`${format.toUpperCase()} parsing failed: ${message}`);
+          setLoading(false);
+          return;
+        }
+        if (loadSessionRef.current !== currentSession) {
+          // A newer load already began. Drop our streamed asset and
+          // skip every store/UI mutation so we don't overwrite the
+          // newer model's state.
+          renderer.removePointCloudAsset(ingest.rendererHandle);
+          return;
+        }
+        setGeometryResult(ingest.geometryResult);
+        setIfcDataStore(ingest.dataStore);
+        finalizePrimaryModel(ingest.dataStore, ingest.geometryResult, ingest.schemaVersion, {
+          pointCloudHandleId: ingest.rendererHandle.id,
+        });
+        setProgress({ phase: 'Complete', percent: 100 });
+        setLoading(false);
+        return;
+      }
 
       // IFCX files must be parsed client-side (server only supports IFC4 STEP)
       if (format === 'ifcx') {
@@ -1638,8 +1710,10 @@ export function useIfcLoader() {
       }
 
       // Try server parsing first (enabled by default for multi-core performance)
-      // Only for IFC4 STEP files (server doesn't support IFCX)
-      if (format === 'ifc' && USE_SERVER && SERVER_URL && SERVER_URL !== '') {
+      // Only for IFC4 STEP files (server doesn't support IFCX). Native
+      // file handles (Tauri) don't have an HTTP-uploadable body, so skip
+      // the server path and fall through to the WASM loader.
+      if (format === 'ifc' && USE_SERVER && SERVER_URL && SERVER_URL !== '' && !isNativeFileHandle(file)) {
         // Pass buffer directly - server uses File object for parsing, buffer is only for size checks
         const serverSuccess = await loadFromServer(file, buffer, () => loadSessionRef.current !== currentSession);
         if (serverSuccess) {
@@ -1792,7 +1866,9 @@ export function useIfcLoader() {
           if (geometryIteratorClosed || typeof geometryIterator.return !== 'function') return;
           geometryIteratorClosed = true;
           try {
-            await geometryIterator.return();
+            // `AsyncIterator.return()` is signed as taking a value in
+            // current TS libs; callers conventionally pass `undefined`.
+            await geometryIterator.return(undefined);
           } catch {
             // Ignore iterator shutdown failures during recovery.
           }

package/src/hooks/useKeyboardShortcuts.ts

@@ -88,6 +88,10 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
       e.preventDefault();
       setActiveTool('section');
     }
+    if (key === 'p' && !ctrl && !shift) {
+      e.preventDefault();
+      setActiveTool('annotate');
+    }
 
     // Basket controls (automatic context source)
     // I = Isolate from current context
@@ -150,6 +154,26 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
       resetVisibilityForHomeFromStore();
     }
 
+    // Add-element tool shortcuts — Enter commits an in-progress slab
+    // polygon; Esc clears any pending points before falling through to
+    // the global Esc handler (which exits the tool).
+    if (activeTool === 'addElement') {
+      const state = useViewerStore.getState();
+      const polygonable = ['slab', 'roof', 'plate', 'space'].includes(state.addElementType);
+      if (key === 'enter' && polygonable && state.addElementSlabMode === 'polygon') {
+        e.preventDefault();
+        // Lazy import keeps this module out of the keyboard hook's
+        // synchronous bundle (the close handler pulls in toast).
+        import('@/components/viewer/selectionHandlers').then((mod) => mod.commitAddElementSlabPolygon());
+        return;
+      }
+      if (key === 'escape' && state.addElementPendingPoints.length > 0) {
+        e.preventDefault();
+        state.clearAddElementPending();
+        return;
+      }
+    }
+
     // Measure tool shortcuts
     if (activeTool === 'measure') {
       // Cancel active measurement with ESC
@@ -243,6 +267,7 @@ export const KEYBOARD_SHORTCUTS = [
   { key: 'V', description: 'Select tool', category: 'Tools' },
   { key: 'C', description: 'Walk mode', category: 'Tools' },
   { key: 'M', description: 'Measure tool', category: 'Tools' },
+  { key: 'P', description: 'Annotate tool — drop a pin with a note', category: 'Tools' },
   { key: 'X', description: 'Section tool', category: 'Tools' },
   { key: 'S', description: 'Toggle snapping (Measure tool)', category: 'Tools' },
   { key: 'Esc', description: 'Cancel measurement (Measure tool)', category: 'Tools' },

package/src/hooks/useSandbox.ts

@@ -165,7 +165,7 @@ export function useSandbox(config?: SandboxConfig) {
       // Create a fresh sandbox for every execution — full isolation
       const { createSandbox } = await import('@ifc-lite/sandbox');
       sandbox = await createSandbox(bim, {
-        permissions: { model: true, query: true, viewer: true, mutate: true, lens: true, export: true, files: true, ...config?.permissions },
+        permissions: { model: true, query: true, viewer: true, mutate: true, store: true, lens: true, export: true, files: true, ...config?.permissions },
         limits: { timeoutMs: 30_000, ...config?.limits },
       });
       activeSandboxRef.current = sandbox;

package/src/hooks/useSearchIndex.ts

@@ -0,0 +1,125 @@
+/* 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/. */
+
+/**
+ * useSearchIndex — lazy builder for the Tier-1 search index.
+ *
+ * Mount once near the root of the viewer shell (currently `SearchInline`,
+ * since it's always rendered once the toolbar is up). The hook watches
+ * the federated `models` map; for each model with a populated
+ * `ifcDataStore` that doesn't yet have a Tier-1 record, it spawns a
+ * chunked build. Models that disappear get their index record dropped.
+ *
+ * Load-perf guarantee: the build NEVER runs during the actual IFC load
+ * because `ifcDataStore` is non-null only after the parser reports the
+ * model is ready (`onSpatialReady` + geometry). The build itself yields
+ * to the event loop every `DEFAULT_CHUNK_SIZE` rows so a 4M-entity
+ * index doesn't hog the main thread.
+ */
+
+import { useEffect, useRef } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+import { useViewerStore } from '@/store';
+import { buildTier1Index } from '@/lib/search/tier1-index';
+
+export function useSearchIndex(): void {
+  const {
+    models,
+    searchIndexes,
+    setSearchIndexRecord,
+    removeSearchIndexRecord,
+    searchFilterSchema,
+    removeFilterSchema,
+  } = useViewerStore(
+    useShallow((s) => ({
+      models: s.models,
+      searchIndexes: s.searchIndexes,
+      setSearchIndexRecord: s.setSearchIndexRecord,
+      removeSearchIndexRecord: s.removeSearchIndexRecord,
+      searchFilterSchema: s.searchFilterSchema,
+      removeFilterSchema: s.removeFilterSchema,
+    })),
+  );
+
+  // One AbortController per in-flight build. Lets us cancel cleanly when a
+  // model is removed mid-build or when the component unmounts.
+  const controllersRef = useRef<Map<string, AbortController>>(new Map());
+
+  useEffect(() => {
+    const controllers = controllersRef.current;
+
+    // Drop records / abort builds for models that no longer exist.
+    for (const modelId of Array.from(searchIndexes.keys())) {
+      if (!models.has(modelId)) {
+        controllers.get(modelId)?.abort();
+        controllers.delete(modelId);
+        removeSearchIndexRecord(modelId);
+      }
+    }
+
+    // Drop the filter-schema cache for departed models too. Stale entries
+    // would surface in the chip dropdowns the next time a model with the
+    // same id loaded (e.g. user reopens a different file as model_0).
+    for (const modelId of Array.from(searchFilterSchema.keys())) {
+      if (!models.has(modelId)) removeFilterSchema(modelId);
+    }
+
+    // Kick off builds for models that are loaded but not yet indexed.
+    for (const [modelId, model] of models) {
+      if (!model.ifcDataStore) continue;
+      const existing = searchIndexes.get(modelId);
+      if (existing && existing.status !== 'pending') continue;
+      if (controllers.has(modelId)) continue;
+
+      const controller = new AbortController();
+      controllers.set(modelId, controller);
+
+      setSearchIndexRecord(modelId, { status: 'building', progress: 0 });
+
+      // Fire-and-forget — the build is cancellable via the controller, and
+      // the completion handlers update the store without needing a ref.
+      void buildTier1Index(modelId, model.ifcDataStore, {
+        signal: controller.signal,
+        onProgress: (done, total) => {
+          if (controller.signal.aborted) return;
+          const progress = total > 0 ? done / total : 1;
+          setSearchIndexRecord(modelId, { status: 'building', progress });
+        },
+      })
+        .then((index) => {
+          if (controller.signal.aborted) return;
+          controllers.delete(modelId);
+          setSearchIndexRecord(modelId, { status: 'ready', index, progress: 1 });
+        })
+        .catch((err: unknown) => {
+          controllers.delete(modelId);
+          if (err instanceof DOMException && err.name === 'AbortError') return;
+          const message = err instanceof Error ? err.message : String(err);
+          // Don't set a 'ready' record — Tier-0 fallback stays live.
+          console.warn(`[useSearchIndex] build failed for ${modelId}:`, message);
+          setSearchIndexRecord(modelId, { status: 'error', error: message });
+        });
+    }
+
+    // On unmount OR next effect pass, abort everything. The effect re-runs
+    // only when `models` / `searchIndexes` changes, so steady-state
+    // incurs no abort — the `controllers.has(modelId)` guard above makes
+    // re-entry idempotent.
+    return () => {
+      // Intentionally NOT aborting everything on every re-render — only
+      // models that went missing got aborted above. The real cleanup is
+      // the component-unmount pass below.
+    };
+  }, [models, searchIndexes, setSearchIndexRecord, removeSearchIndexRecord, searchFilterSchema, removeFilterSchema]);
+
+  // Abort any in-flight builds when the consumer unmounts. Separate effect
+  // so it only fires on unmount (no deps).
+  useEffect(() => {
+    const controllers = controllersRef.current;
+    return () => {
+      for (const c of controllers.values()) c.abort();
+      controllers.clear();
+    };
+  }, []);
+}

package/src/index.css

@@ -379,6 +379,43 @@ body {
   color: var(--color-primary) !important;
 }
 
+/* Raw STEP tab — terminal-flavoured dev affordance.
+   Compact (icon-only </>), separates visually from the three "human"
+   tabs with a left divider and a green active state that nods to a
+   shell cursor. Stays width-stable at narrow panel widths because
+   it explicitly opts out of `flex: 1` (uses an `auto`-ish width
+   driven by the </> glyph plus padding). */
+.properties-tab-trigger.raw-step-tab-trigger {
+  flex: 0 0 auto;
+  min-width: 2.25rem;
+  padding-left: 0.5rem;
+  padding-right: 0.5rem;
+  border-left: 1px solid var(--tabs-border);
+  letter-spacing: 0;
+  color: color-mix(in srgb, var(--tab-text) 70%, transparent) !important;
+}
+
+.properties-tab-trigger.raw-step-tab-trigger:hover {
+  background-color: color-mix(in srgb, #10b981 16%, var(--tabs-bg)) !important;
+  color: #047857 !important;
+}
+
+.dark .properties-tab-trigger.raw-step-tab-trigger:hover {
+  background-color: color-mix(in srgb, #10b981 22%, var(--tabs-bg)) !important;
+  color: #34d399 !important;
+}
+
+.properties-tab-trigger.raw-step-tab-trigger[data-state="active"] {
+  background-color: color-mix(in srgb, #10b981 14%, var(--tab-active-bg)) !important;
+  color: #047857 !important;
+  border-top-color: #10b981 !important;
+}
+
+.dark .properties-tab-trigger.raw-step-tab-trigger[data-state="active"] {
+  color: #34d399 !important;
+  border-top-color: #34d399 !important;
+}
+
 /* Quantity cards - cyan accent */
 .dark .border-blue-200,
 .dark .border-blue-800,
@@ -997,6 +1034,35 @@ body {
   cursor: not-allowed;
 }
 
+/* Annotation pin idle introduction — fires once on mount, then settles.
+   Driven by a `prefers-reduced-motion` guard so accessibility users
+   don't get hit by the pulse. */
+@keyframes annotation-pin-idle {
+  0% {
+    transform: scale(0.7);
+    box-shadow: 0 0 0 0 rgba(245, 158, 11, 0.55);
+  }
+  60% {
+    transform: scale(1.08);
+    box-shadow: 0 0 0 8px rgba(245, 158, 11, 0);
+  }
+  100% {
+    transform: scale(1);
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.35),
+      0 0 0 1px rgba(0, 0, 0, 0.15);
+  }
+}
+
+.annotation-pin-idle {
+  animation: annotation-pin-idle 360ms cubic-bezier(0.4, 0, 0.2, 1) forwards;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .annotation-pin-idle {
+    animation: none;
+  }
+}
+
 /* Loading skeleton animation */
 @keyframes skeleton-pulse {
   0%, 100% {

package/src/lib/llm/system-prompt.test.ts

@@ -91,6 +91,20 @@ test('system prompt includes selected entity IFC context when provided', () => {
   assert.match(prompt, /Selected entities: Tower: IfcCurtainWall "Facade Panel A", kind=occurrence, storey=Level 10@31.5m, psets=Pset_CurtainWallCommon, typePsets=Pset_CurtainWallTypeCommon, qsets=Qto_CurtainWallBaseQuantities, material=Aluminium, classifications=A-123 \| Tower: IfcWallType "Exterior Wall Type", kind=type, psets=Pset_WallCommon, classifications=A-WALL/);
 });
 
+test('system prompt includes the BIM.STORE cheat sheet and routing rule', () => {
+  const prompt = buildSystemPrompt();
+
+  // Section heading + the three method examples
+  assert.match(prompt, /## BIM\.STORE CHEAT SHEET/);
+  assert.match(prompt, /bim\.store\.setPositionalAttribute\(profile, 3, 0\.6\)/);
+  assert.match(prompt, /bim\.store\.addEntity\("arch"/);
+  assert.match(prompt, /bim\.store\.removeEntity\(unwantedRef\)/);
+
+  // Routing rule disambiguating store / mutate / create
+  assert.match(prompt, /bim\.store\.setPositionalAttribute\(entity, index, value\)`? for positional STEP-argument edits/);
+  assert.match(prompt, /Do NOT use `bim\.create` for these/);
+});
+
 test('system prompt includes method-specific create contract guidance', () => {
   const prompt = buildSystemPrompt();
   assert.match(prompt, /BIM\.CREATE CONTRACT CHEAT SHEET/);