@ifc-lite/viewer 1.10.0 → 1.11.0

package/src/hooks/useKeyboardShortcuts.ts

@@ -7,21 +7,20 @@
  */
 
 import { useEffect, useCallback } from 'react';
-import { useViewerStore, stringToEntityRef } from '@/store';
-import type { EntityRef } from '@/store';
+import { useViewerStore } from '@/store';
+import { resetVisibilityForHomeFromStore } from '@/store/homeView';
+import {
+  executeBasketIsolate,
+  executeBasketSet,
+  executeBasketAdd,
+  executeBasketRemove,
+  executeBasketSaveView,
+} from '@/store/basket/basketCommands';
 
 interface KeyboardShortcutsOptions {
   enabled?: boolean;
 }
 
-/** Clear multi-select state so subsequent operations use single-entity selectedEntity */
-function clearMultiSelect(): void {
-  const state = useViewerStore.getState();
-  if (state.selectedEntitiesSet.size > 0) {
-    useViewerStore.setState({ selectedEntitiesSet: new Set(), selectedEntityIds: new Set() });
-  }
-}
-
 /** Get all selected global IDs — multi-select if available, else single selectedEntityId */
 function getAllSelectedGlobalIds(): number[] {
   const state = useViewerStore.getState();
@@ -34,22 +33,6 @@ function getAllSelectedGlobalIds(): number[] {
   return [];
 }
 
-/** Get current selection as EntityRef[] — multi-select if available, else single */
-function getSelectionRefsFromStore(): EntityRef[] {
-  const state = useViewerStore.getState();
-  if (state.selectedEntitiesSet.size > 0) {
-    const refs: EntityRef[] = [];
-    for (const str of state.selectedEntitiesSet) {
-      refs.push(stringToEntityRef(str));
-    }
-    return refs;
-  }
-  if (state.selectedEntity) {
-    return [state.selectedEntity];
-  }
-  return [];
-}
-
 export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
   const { enabled = true } = options;
 
@@ -58,16 +41,8 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
   const activeTool = useViewerStore((s) => s.activeTool);
   const setActiveTool = useViewerStore((s) => s.setActiveTool);
   const hideEntities = useViewerStore((s) => s.hideEntities);
-  const showAll = useViewerStore((s) => s.showAll);
-  const clearStoreySelection = useViewerStore((s) => s.clearStoreySelection);
   const toggleTheme = useViewerStore((s) => s.toggleTheme);
-
-  // Basket actions
-  const setBasket = useViewerStore((s) => s.setBasket);
-  const addToBasket = useViewerStore((s) => s.addToBasket);
-  const removeFromBasket = useViewerStore((s) => s.removeFromBasket);
-  const clearBasket = useViewerStore((s) => s.clearBasket);
-  const showPinboard = useViewerStore((s) => s.showPinboard);
+  const toggleBasketPresentationVisible = useViewerStore((s) => s.toggleBasketPresentationVisible);
 
   // Measure tool specific actions
   const activeMeasurement = useViewerStore((s) => s.activeMeasurement);
@@ -117,45 +92,45 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
       setActiveTool('section');
     }
 
-    // Basket / Visibility controls
-    // I = Set basket (isolate selection as basket), or re-apply basket if no selection
+    // Basket controls (automatic context source)
+    // I = Isolate from current context
     if (key === 'i' && !ctrl && !shift) {
-      const state = useViewerStore.getState();
-      // If basket already exists and user hasn't explicitly multi-selected,
-      // re-apply the basket instead of replacing it with a stale single selection.
-      if (state.pinboardEntities.size > 0 && state.selectedEntitiesSet.size === 0) {
-        e.preventDefault();
-        showPinboard();
-      } else {
-        const refs = getSelectionRefsFromStore();
-        if (refs.length > 0) {
-          e.preventDefault();
-          setBasket(refs);
-          // Consume multi-select so subsequent − removes a single entity
-          clearMultiSelect();
-        }
-      }
+      e.preventDefault();
+      executeBasketIsolate();
     }
 
-    // + or = (with shift) = Add to basket
+    // = Set basket from active context
+    if (e.key === '=' && !ctrl && !shift) {
+      e.preventDefault();
+      executeBasketSet();
+    }
+
+    // + Add active context to basket
     if ((e.key === '+' || (e.key === '=' && shift)) && !ctrl) {
       e.preventDefault();
-      const refs = getSelectionRefsFromStore();
-      if (refs.length > 0) {
-        addToBasket(refs);
-        // Consume multi-select so subsequent − removes a single entity
-        clearMultiSelect();
-      }
+      executeBasketAdd();
     }
 
-    // - or _ = Remove from basket
+    // - Remove active context from basket
     if ((e.key === '-' || e.key === '_') && !ctrl) {
       e.preventDefault();
-      const refs = getSelectionRefsFromStore();
-      if (refs.length > 0) {
-        removeFromBasket(refs);
-        // Consume multi-select after removal
-        clearMultiSelect();
+      executeBasketRemove();
+    }
+
+    // D Toggle basket presentation dock
+    if (key === 'd' && !ctrl && !shift) {
+      e.preventDefault();
+      toggleBasketPresentationVisible();
+    }
+
+    // B Save current basket as presentation view with thumbnail
+    if (key === 'b' && !ctrl && !shift) {
+      const state = useViewerStore.getState();
+      if (state.pinboardEntities.size > 0) {
+        e.preventDefault();
+        executeBasketSaveView().catch((err) => {
+          console.error('[useKeyboardShortcuts] Failed to save basket view:', err);
+        });
       }
     }
 
@@ -163,7 +138,6 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
       e.preventDefault();
       const ids = getAllSelectedGlobalIds();
       hideEntities(ids);
-      clearMultiSelect();
     }
     // Space to hide — skip when focused on buttons/selects/links where Space has native behavior
     if (key === ' ' && !ctrl && !shift && selectedEntityId) {
@@ -172,13 +146,11 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
         e.preventDefault();
         const ids = getAllSelectedGlobalIds();
         hideEntities(ids);
-        clearMultiSelect();
       }
     }
     if (key === 'a' && !ctrl && !shift) {
       e.preventDefault();
-      showAll();             // Clear hiddenEntities + isolatedEntities (basket preserved)
-      clearStoreySelection(); // Also clear storey filtering
+      resetVisibilityForHomeFromStore();
     }
 
     // Measure tool shortcuts
@@ -213,9 +185,7 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
     if (key === 'escape') {
       e.preventDefault();
       setSelectedEntityId(null);
-      clearBasket();
-      showAll();
-      clearStoreySelection(); // Also clear storey filtering
+      resetVisibilityForHomeFromStore();
       setActiveTool('select');
     }
 
@@ -232,15 +202,9 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
     setSelectedEntityId,
     activeTool,
     setActiveTool,
-    setBasket,
-    addToBasket,
-    removeFromBasket,
-    clearBasket,
-    showPinboard,
     hideEntities,
-    showAll,
-    clearStoreySelection,
     toggleTheme,
+    toggleBasketPresentationVisible,
     activeMeasurement,
     cancelMeasurement,
     clearMeasurements,
@@ -268,12 +232,15 @@ export const KEYBOARD_SHORTCUTS = [
   { key: 'S', description: 'Toggle snapping (Measure tool)', category: 'Tools' },
   { key: 'Esc', description: 'Cancel measurement (Measure tool)', category: 'Tools' },
   { key: 'Ctrl+C', description: 'Clear measurements (Measure tool)', category: 'Tools' },
-  { key: 'I', description: 'Set basket (isolate selection)', category: 'Visibility' },
-  { key: '+', description: 'Add selection to basket', category: 'Visibility' },
-  { key: '−', description: 'Remove selection from basket', category: 'Visibility' },
+  { key: 'I', description: 'Isolate (set basket from current context)', category: 'Visibility' },
+  { key: '=', description: 'Set basket from current context', category: 'Visibility' },
+  { key: '+', description: 'Add current context to basket', category: 'Visibility' },
+  { key: '−', description: 'Remove current context from basket', category: 'Visibility' },
+  { key: 'D', description: 'Toggle basket presentation dock', category: 'Visibility' },
+  { key: 'B', description: 'Save basket as presentation view', category: 'Visibility' },
   { key: 'Del / Space', description: 'Hide selection', category: 'Visibility' },
-  { key: 'A', description: 'Show all (clear filters, keep basket)', category: 'Visibility' },
-  { key: 'H', description: 'Home (Isometric view)', category: 'Camera' },
+  { key: 'A', description: 'Show all (clear filters and basket)', category: 'Visibility' },
+  { key: 'H', description: 'Home (isometric + reset visibility)', category: 'Camera' },
   { key: 'Z', description: 'Fit all (zoom extents)', category: 'Camera' },
   { key: 'F', description: 'Frame selection', category: 'Camera' },
   { key: '1-6', description: 'Preset views', category: 'Camera' },

package/src/store/basket/basketCommands.ts

@@ -0,0 +1,81 @@
+/* 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/. */
+
+import type { EntityRef } from '../types.js';
+import { useViewerStore } from '../index.js';
+import { saveBasketViewWithThumbnailFromStore } from '../basketSave.js';
+import {
+  getSmartBasketInputFromStore,
+  isBasketIsolationActiveFromStore,
+} from '../basketVisibleSet.js';
+
+type BasketViewSource = 'selection' | 'visible' | 'hierarchy' | 'manual';
+
+/**
+ * Resolve basket refs: smart input first, optional context entity as fallback.
+ */
+function getBasketRefs(contextEntityRef?: EntityRef | null): EntityRef[] {
+  const { refs } = getSmartBasketInputFromStore();
+  if (refs.length > 0) return refs;
+  if (contextEntityRef) return [contextEntityRef];
+  return [];
+}
+
+export function executeBasketSet(contextEntityRef?: EntityRef | null): void {
+  const refs = getBasketRefs(contextEntityRef);
+  if (refs.length > 0) {
+    useViewerStore.getState().setBasket(refs);
+  }
+}
+
+/**
+ * Isolate: set basket from context if refs available, else re-show existing basket.
+ */
+export function executeBasketIsolate(contextEntityRef?: EntityRef | null): void {
+  const refs = getBasketRefs(contextEntityRef);
+  if (refs.length > 0) {
+    useViewerStore.getState().setBasket(refs);
+    return;
+  }
+  const state = useViewerStore.getState();
+  if (state.pinboardEntities.size > 0) {
+    state.showPinboard();
+  }
+}
+
+export function executeBasketAdd(contextEntityRef?: EntityRef | null): void {
+  const refs = getBasketRefs(contextEntityRef);
+  if (refs.length > 0) {
+    useViewerStore.getState().addToBasket(refs);
+  }
+}
+
+export function executeBasketRemove(contextEntityRef?: EntityRef | null): void {
+  const refs = getBasketRefs(contextEntityRef);
+  if (refs.length > 0) {
+    useViewerStore.getState().removeFromBasket(refs);
+  }
+}
+
+export function executeBasketToggleVisibility(): void {
+  const state = useViewerStore.getState();
+  if (state.pinboardEntities.size === 0) return;
+  if (isBasketIsolationActiveFromStore()) {
+    state.clearIsolation();
+  } else {
+    state.showPinboard();
+  }
+}
+
+export async function executeBasketSaveView(source: BasketViewSource = 'manual'): Promise<string | null> {
+  const state = useViewerStore.getState();
+  if (state.pinboardEntities.size === 0) return null;
+  const id = await saveBasketViewWithThumbnailFromStore(source);
+  state.setBasketPresentationVisible(true);
+  return id;
+}
+
+export function executeBasketClear(): void {
+  useViewerStore.getState().clearBasket();
+}

package/src/store/basket/basketViewActivator.ts

@@ -0,0 +1,54 @@
+/* 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/. */
+
+import { useViewerStore } from '../index.js';
+
+const DEFAULT_TRANSITION_MS = 700;
+
+/**
+ * Coordinator for activating a saved basket view.
+ * Owns camera + section + drawing side effects; delegates entity/isolation to pinboard.
+ */
+export function activateBasketViewFromStore(viewId: string): void {
+  const state = useViewerStore.getState();
+  const view = state.basketViews.find((v) => v.id === viewId);
+  if (!view) return;
+
+  // Basket activation must never restore or keep 2D profile overlays.
+  // Basket views should only affect 3D model geometry visibility/sectioning.
+  state.setDrawing2D(null);
+  state.setDrawing2DPanelVisible(false);
+  state.updateDrawing2DDisplayOptions({ show3DOverlay: false });
+
+  state.clearEntitySelection();
+  state.restoreBasketEntities(view.entityRefs, viewId);
+
+  if (view.viewpoint) {
+    const transitionMs = view.transitionMs ?? DEFAULT_TRANSITION_MS;
+    state.cameraCallbacks.applyViewpoint?.(view.viewpoint, true, transitionMs);
+  }
+
+  if (view.section) {
+    const sectionSnapshot = view.section;
+    useViewerStore.setState({
+      sectionPlane: { ...sectionSnapshot.plane },
+      drawing2DPanelVisible: false,
+    });
+    if (sectionSnapshot.plane.enabled) {
+      if (state.activeTool !== 'section') {
+        state.setSuppressNextSection2DPanelAutoOpen(true);
+      }
+      state.setActiveTool('section');
+    } else if (state.activeTool === 'section') {
+      state.setActiveTool('select');
+    }
+  } else {
+    // This view has no section snapshot: ensure previously active cutting is cleared.
+    const current = useViewerStore.getState().sectionPlane;
+    useViewerStore.setState({ sectionPlane: { ...current, enabled: false } });
+    if (state.activeTool === 'section') {
+      state.setActiveTool('select');
+    }
+  }
+}

package/src/store/basketSave.ts

@@ -0,0 +1,122 @@
+/* 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/. */
+
+import { useViewerStore } from './index.js';
+import { getGlobalRenderer } from '../hooks/useBCF.js';
+
+type BasketViewSource = 'selection' | 'visible' | 'hierarchy' | 'manual';
+
+interface SelectionSnapshot {
+  selectedEntityId: number | null;
+  selectedEntityIds: Set<number>;
+  selectedEntity: ReturnType<typeof useViewerStore.getState>['selectedEntity'];
+  selectedEntitiesSet: Set<string>;
+  selectedEntities: ReturnType<typeof useViewerStore.getState>['selectedEntities'];
+  selectedModelId: string | null;
+}
+
+function hasSelection(snapshot: SelectionSnapshot): boolean {
+  return (
+    snapshot.selectedEntityId !== null ||
+    snapshot.selectedEntityIds.size > 0 ||
+    snapshot.selectedEntity !== null ||
+    snapshot.selectedEntitiesSet.size > 0 ||
+    snapshot.selectedEntities.length > 0
+  );
+}
+
+function snapshotSelectionState(): SelectionSnapshot {
+  const state = useViewerStore.getState();
+  return {
+    selectedEntityId: state.selectedEntityId,
+    selectedEntityIds: new Set(state.selectedEntityIds),
+    selectedEntity: state.selectedEntity ? { ...state.selectedEntity } : null,
+    selectedEntitiesSet: new Set(state.selectedEntitiesSet),
+    selectedEntities: state.selectedEntities.map((ref) => ({ ...ref })),
+    selectedModelId: state.selectedModelId,
+  };
+}
+
+function restoreSelectionState(snapshot: SelectionSnapshot): void {
+  useViewerStore.setState({
+    selectedEntityId: snapshot.selectedEntityId,
+    selectedEntityIds: new Set(snapshot.selectedEntityIds),
+    selectedEntity: snapshot.selectedEntity ? { ...snapshot.selectedEntity } : null,
+    selectedEntitiesSet: new Set(snapshot.selectedEntitiesSet),
+    selectedEntities: snapshot.selectedEntities.map((ref) => ({ ...ref })),
+    selectedModelId: snapshot.selectedModelId,
+  });
+}
+
+async function captureCanvasThumbnail(): Promise<string | null> {
+  const src = document.querySelector('canvas[data-viewport="main"]') as HTMLCanvasElement | null;
+  if (!src) return null;
+
+  // Ensure submitted GPU work is complete before sampling the canvas.
+  const renderer = getGlobalRenderer();
+  const device = renderer?.getGPUDevice();
+  if (device) {
+    await device.queue.onSubmittedWorkDone();
+  }
+
+  await new Promise<void>((resolve) =>
+    requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
+  );
+
+  try {
+    // Capture from the WebGPU canvas first (reliable), then downscale.
+    const fullFrameDataUrl = src.toDataURL('image/png');
+
+    const thumb = document.createElement('canvas');
+    thumb.width = 320;
+    thumb.height = 180;
+    const ctx = thumb.getContext('2d');
+    if (!ctx) return fullFrameDataUrl;
+
+    // Preserve viewport aspect ratio while filling thumbnail bounds (crop, no stretch).
+    ctx.fillStyle = '#0f0f12';
+    ctx.fillRect(0, 0, thumb.width, thumb.height);
+
+    const img = new Image();
+    await new Promise<void>((resolve, reject) => {
+      img.onload = () => resolve();
+      img.onerror = () => reject(new Error('Failed to decode snapshot image'));
+      img.src = fullFrameDataUrl;
+    });
+
+    const srcW = img.naturalWidth || src.width || src.clientWidth;
+    const srcH = img.naturalHeight || src.height || src.clientHeight;
+    if (srcW <= 0 || srcH <= 0) return null;
+
+    const scale = Math.max(thumb.width / srcW, thumb.height / srcH);
+    const drawW = Math.round(srcW * scale);
+    const drawH = Math.round(srcH * scale);
+    const offsetX = Math.floor((thumb.width - drawW) / 2);
+    const offsetY = Math.floor((thumb.height - drawH) / 2);
+    ctx.drawImage(img, offsetX, offsetY, drawW, drawH);
+    return thumb.toDataURL('image/jpeg', 0.75);
+  } catch {
+    return null;
+  }
+}
+
+export async function saveBasketViewWithThumbnailFromStore(
+  source: BasketViewSource = 'manual',
+): Promise<string | null> {
+  const before = snapshotSelectionState();
+  const hadSelection = hasSelection(before);
+
+  if (hadSelection) {
+    useViewerStore.getState().clearEntitySelection();
+  }
+
+  try {
+    const thumbnailDataUrl = await captureCanvasThumbnail();
+    return useViewerStore.getState().saveCurrentBasketView({ source, thumbnailDataUrl });
+  } finally {
+    if (hadSelection) {
+      restoreSelectionState(before);
+    }
+  }
+}

package/src/store/basketVisibleSet.test.ts

@@ -0,0 +1,161 @@
+/* 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/. */
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { useViewerStore } from './index.js';
+import {
+  getSmartBasketInputFromStore,
+  getBasketSelectionRefsFromStore,
+  getVisibleBasketEntityRefsFromStore,
+  isBasketIsolationActiveFromStore,
+  invalidateVisibleBasketCache,
+} from './basketVisibleSet.js';
+import { entityRefToString } from './types.js';
+
+describe('basketVisibleSet', () => {
+  beforeEach(() => {
+    invalidateVisibleBasketCache();
+    useViewerStore.getState().resetViewerState();
+  });
+
+  describe('source priority', () => {
+    it('returns selection refs when selectedEntitiesSet has items', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(['legacy:100', 'legacy:200']),
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.strictEqual(result.source, 'selection');
+      assert.strictEqual(result.refs.length, 2);
+      assert.ok(result.refs.some((r) => entityRefToString(r) === 'legacy:100'));
+      assert.ok(result.refs.some((r) => entityRefToString(r) === 'legacy:200'));
+    });
+
+    it('returns hierarchy refs when hierarchyBasketSelection has items and no selection', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+        selectedEntityIds: new Set(),
+        hierarchyBasketSelection: new Set(['legacy:300']),
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.strictEqual(result.source, 'hierarchy');
+      assert.ok(result.refs.length >= 1);
+    });
+
+    it('returns visible refs when only geometry is available', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+        selectedEntityIds: new Set(),
+        hierarchyBasketSelection: new Set(),
+        geometryResult: {
+          meshes: [
+            { expressId: 1, ifcType: 'IfcWall' },
+            { expressId: 2, ifcType: 'IfcSlab' },
+          ],
+        } as any,
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.ok(result.source === 'visible' || result.source === 'empty');
+      if (result.source === 'visible') {
+        assert.ok(result.refs.length >= 1);
+      }
+    });
+
+    it('returns empty when no source has refs', () => {
+      useViewerStore.setState({
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+        selectedEntityIds: new Set(),
+        hierarchyBasketSelection: new Set(),
+        geometryResult: null,
+      });
+
+      const result = getSmartBasketInputFromStore();
+      assert.strictEqual(result.source, 'empty');
+      assert.strictEqual(result.refs.length, 0);
+    });
+  });
+
+  describe('isBasketIsolationActiveFromStore', () => {
+    it('returns true when isolated equals basket', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(['legacy:100', 'legacy:200']),
+        isolatedEntities: new Set([100, 200]),
+        models: new Map(),
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), true);
+    });
+
+    it('returns false when pinboard is empty', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(),
+        isolatedEntities: new Set([100]),
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), false);
+    });
+
+    it('returns false when isolated is null', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(['legacy:100']),
+        isolatedEntities: null,
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), false);
+    });
+
+    it('returns false when isolated size differs from basket', () => {
+      useViewerStore.setState({
+        pinboardEntities: new Set(['legacy:100', 'legacy:200']),
+        isolatedEntities: new Set([100]),
+      });
+
+      assert.strictEqual(isBasketIsolationActiveFromStore(), false);
+    });
+  });
+
+  describe('visibility cache', () => {
+    it('invalidateVisibleBasketCache clears cache', () => {
+      useViewerStore.setState({
+        geometryResult: { meshes: [{ expressId: 1, ifcType: 'IfcWall' }] } as any,
+      });
+
+      const first = getVisibleBasketEntityRefsFromStore();
+      invalidateVisibleBasketCache();
+      const second = getVisibleBasketEntityRefsFromStore();
+
+      assert.deepStrictEqual(first, second);
+    });
+
+    it('returns consistent result on repeated calls with same state', () => {
+      useViewerStore.setState({
+        geometryResult: { meshes: [{ expressId: 1, ifcType: 'IfcWall' }] } as any,
+      });
+
+      const a = getVisibleBasketEntityRefsFromStore();
+      const b = getVisibleBasketEntityRefsFromStore();
+
+      assert.deepStrictEqual(a, b);
+    });
+  });
+
+  describe('federation: unresolved globalId in multi-model', () => {
+    it('getBasketSelectionRefsFromStore returns array when models exist', () => {
+      useViewerStore.setState({
+        selectedEntityIds: new Set([99999]),
+        selectedEntitiesSet: new Set(),
+        selectedEntity: null,
+      });
+
+      const refs = getBasketSelectionRefsFromStore();
+      assert.ok(Array.isArray(refs));
+    });
+  });
+});