@ifc-lite/viewer 1.14.4 → 1.16.0

package/src/components/viewer/hierarchy/HierarchyNode.tsx

@@ -4,13 +4,7 @@
 
 import {
   ChevronRight,
-  Building2,
   Layers,
-  MapPin,
-  FolderKanban,
-  Square,
-  Box,
-  DoorOpen,
   Eye,
   EyeOff,
   FileBox,
@@ -20,21 +14,21 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip
 import { cn } from '@/lib/utils';
 import type { TreeNode } from './types';
 import { isSpatialContainer } from './types';
+import { IFC_ICON_CODEPOINTS, IFC_ICON_DEFAULT } from './ifc-icons';
 
-const TYPE_ICONS: Record<string, React.ElementType> = {
+/**
+ * Resolve the Material Symbols code point for a given IFC type string.
+ * Falls back to the generic product icon for unmapped classes.
+ */
+function getIfcIconCodepoint(ifcType: string | undefined): string {
+  if (!ifcType) return IFC_ICON_DEFAULT;
+  return IFC_ICON_CODEPOINTS[ifcType] ?? IFC_ICON_DEFAULT;
+}
+
+/** Lucide fallback icons for non-IFC node types */
+const NODE_TYPE_ICONS: Record<string, React.ElementType> = {
   'unified-storey': Layers,
   'model-header': FileBox,
-  'ifc-type': Building2,
-  IfcProject: FolderKanban,
-  IfcSite: MapPin,
-  IfcBuilding: Building2,
-  IfcBuildingStorey: Layers,
-  IfcSpace: Box,
-  IfcWall: Square,
-  IfcWallStandardCase: Square,
-  IfcDoor: DoorOpen,
-  element: Box,
-  default: Box,
 };
 
 export interface HierarchyNodeProps {
@@ -69,7 +63,9 @@ export function HierarchyNode({
   onModelHeaderClick,
 }: HierarchyNodeProps) {
   const resolvedType = node.ifcType || node.type;
-  const Icon = TYPE_ICONS[resolvedType] || TYPE_ICONS[node.type] || TYPE_ICONS.default;
+  // Use Lucide icon for non-IFC structural nodes, Material Symbols for IFC classes
+  const LucideIcon = NODE_TYPE_ICONS[node.type];
+  const iconCodepoint = getIfcIconCodepoint(resolvedType);
 
   // Model header nodes (for visibility control and expansion)
   if (node.type === 'model-header' && node.id.startsWith('model-')) {
@@ -259,7 +255,17 @@ export function HierarchyNode({
         {/* Type Icon */}
         <Tooltip>
           <TooltipTrigger asChild>
-            <Icon className="h-3.5 w-3.5 shrink-0 text-zinc-500 dark:text-zinc-400" />
+            {LucideIcon ? (
+              <LucideIcon className="h-3.5 w-3.5 shrink-0 text-zinc-500 dark:text-zinc-400" />
+            ) : (
+              <span
+                className="material-symbols-outlined shrink-0 leading-none text-zinc-500 dark:text-zinc-400"
+                style={{ fontSize: '14px' }}
+                aria-hidden="true"
+              >
+                {iconCodepoint}
+              </span>
+            )}
           </TooltipTrigger>
           <TooltipContent>
             <p className="text-xs">{resolvedType}</p>

package/src/components/viewer/hierarchy/ifc-icons.ts

@@ -0,0 +1,90 @@
+/* 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/. */
+
+/**
+ * IFC class to Material Symbols icon code point mapping.
+ * Based on https://github.com/AECgeeks/ifc-icons (MIT license).
+ *
+ * Values are Unicode code points for the Material Symbols Outlined font.
+ */
+export const IFC_ICON_CODEPOINTS: Record<string, string> = {
+  // Spatial / context
+  IfcContext: '\uf1c4',
+  IfcProject: '\uf1c4',
+  IfcProjectLibrary: '\uf1c4',
+  IfcSite: '\ue80b',
+  IfcBuilding: '\uea40',
+  IfcBuildingStorey: '\ue8fe',
+  IfcSpace: '\ueff4',
+
+  // Structural
+  IfcBeam: '\uf108',
+  IfcBeamStandardCase: '\uf108',
+  IfcColumn: '\ue233',
+  IfcColumnStandardCase: '\ue233',
+  IfcWall: '\ue3c0',
+  IfcWallStandardCase: '\ue3c0',
+  IfcWallElementedCase: '\ue3c0',
+  IfcSlab: '\ue229',
+  IfcSlabStandardCase: '\ue229',
+  IfcSlabElementedCase: '\ue229',
+  IfcRoof: '\uf201',
+  IfcFooting: '\uf200',
+  IfcPile: '\ue047',
+  IfcPlate: '\ue047',
+  IfcPlateStandardCase: '\ue047',
+  IfcMember: '\ue047',
+  IfcMemberStandardCase: '\ue047',
+
+  // Openings & access
+  IfcDoor: '\ueb4f',
+  IfcDoorStandardCase: '\ueb4f',
+  IfcWindow: '\uf088',
+  IfcWindowStandardCase: '\uf088',
+  IfcOpeningElement: '\ue3c6',
+  IfcOpeningStandardCase: '\ue3c6',
+  IfcCurtainWall: '\ue047',
+
+  // Vertical circulation
+  IfcStair: '\uf1a9',
+  IfcStairFlight: '\uf1a9',
+  IfcRamp: '\ue86b',
+  IfcRampFlight: '\ue86b',
+  IfcRailing: '\ue58f',
+
+  // Furnishing
+  IfcFurnishingElement: '\uea45',
+  IfcFurniture: '\uea45',
+  IfcSystemFurnitureElement: '\uea45',
+
+  // MEP terminals
+  IfcAirTerminal: '\uefd8',
+  IfcLamp: '\uf02a',
+  IfcLightFixture: '\uf02a',
+  IfcSanitaryTerminal: '\uea41',
+  IfcSpaceHeater: '\uf076',
+  IfcAudioVisualAppliance: '\ue333',
+  IfcSensor: '\ue51e',
+
+  // Assemblies & misc
+  IfcElementAssembly: '\ue9b0',
+  IfcTransportElement: '\uf1a0',
+  IfcGrid: '\uf015',
+  IfcPort: '\ue8c0',
+  IfcDistributionPort: '\ue8c0',
+  IfcAnnotation: '\ue3c9',
+
+  // Civil / geographic
+  IfcCivilElement: '\uea99',
+  IfcGeographicElement: '\uea99',
+  IfcLinearElement: '\uebaa',
+
+  // Proxy / generic fallback
+  IfcProduct: '\ue047',
+  IfcBuildingElementProxy: '\ue047',
+  IfcProxy: '\ue047',
+};
+
+/** Default code point for unmapped IFC classes (Material Symbols "widgets" / generic product) */
+export const IFC_ICON_DEFAULT = '\ue047';

package/src/hooks/useIfcCache.ts

@@ -16,7 +16,7 @@ import {
   type IfcDataStore as CacheDataStore,
   type GeometryData,
 } from '@ifc-lite/cache';
-import { SpatialHierarchyBuilder, StepTokenizer, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
+import { SpatialHierarchyBuilder, StepTokenizer, buildCompactEntityIndex, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
 import { buildSpatialIndex } from '@ifc-lite/spatial';
 import type { MeshData } from '@ifc-lite/geometry';
 
@@ -102,27 +102,27 @@ export function useIfcCache() {
 
         // Quick scan to rebuild entity index with byte offsets (needed for on-demand extraction)
         const tokenizer = new StepTokenizer(dataStore.source);
-        const entityIndex = {
-          byId: new Map<number, any>(),
-          byType: new Map<string, number[]>(),
-        };
+        const entityRefs: Array<{ expressId: number; type: string; byteOffset: number; byteLength: number; lineNumber: number }> = [];
+        const byType = new Map<string, number[]>();
 
         for (const ref of tokenizer.scanEntitiesFast()) {
-          entityIndex.byId.set(ref.expressId, {
+          entityRefs.push({
             expressId: ref.expressId,
             type: ref.type,
             byteOffset: ref.offset,
             byteLength: ref.length,
             lineNumber: ref.line,
           });
-          let typeList = entityIndex.byType.get(ref.type);
+          let typeList = byType.get(ref.type);
           if (!typeList) {
             typeList = [];
-            entityIndex.byType.set(ref.type, typeList);
+            byType.set(ref.type, typeList);
           }
           typeList.push(ref.expressId);
         }
-        dataStore.entityIndex = entityIndex;
+        // Use compact entity index (typed arrays) for lower memory usage
+        const compactByIdIndex = buildCompactEntityIndex(entityRefs);
+        dataStore.entityIndex = { byId: compactByIdIndex, byType };
 
         // Rebuild on-demand maps from relationships
         // Pass entityIndex which contains ALL entity types including IfcPropertySet/IfcElementQuantity

package/src/hooks/useKeyboardShortcuts.ts

@@ -6,7 +6,7 @@
  * Global keyboard shortcuts for the viewer
  */
 
-import { useEffect, useCallback } from 'react';
+import { useEffect, useCallback, useRef } from 'react';
 import { useViewerStore } from '@/store';
 import { resetVisibilityForHomeFromStore } from '@/store/homeView';
 import {
@@ -33,9 +33,14 @@ function getAllSelectedGlobalIds(): number[] {
   return [];
 }
 
+/** Double-escape threshold in milliseconds */
+const DOUBLE_ESCAPE_MS = 500;
+
 export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
   const { enabled = true } = options;
 
+  const lastEscapeRef = useRef<number>(0);
+
   const selectedEntityId = useViewerStore((s) => s.selectedEntityId);
   const setSelectedEntityId = useViewerStore((s) => s.setSelectedEntityId);
   const activeTool = useViewerStore((s) => s.activeTool);
@@ -181,9 +186,29 @@ export function useKeyboardShortcuts(options: KeyboardShortcutsOptions = {}) {
       }
     }
 
-    // Selection - Escape clears selection and switches to select tool
+    // Escape: first press clears selection/tool, double-press closes all panels
     if (key === 'escape') {
       e.preventDefault();
+      const now = Date.now();
+      const timeSinceLastEscape = now - lastEscapeRef.current;
+      lastEscapeRef.current = now;
+
+      if (timeSinceLastEscape < DOUBLE_ESCAPE_MS) {
+        // Double-escape: close all panels, return to starting view
+        const state = useViewerStore.getState();
+        state.setBcfPanelVisible(false);
+        state.setIdsPanelVisible(false);
+        state.setLensPanelVisible(false);
+        state.setScriptPanelVisible(false);
+        state.setListPanelVisible(false);
+        state.setDrawing2DPanelVisible(false);
+        state.setOverridesPanelVisible(false);
+        state.setChatPanelVisible(false);
+        state.setSheetPanelVisible(false);
+        state.setLeftPanelCollapsed(false);
+        state.setRightPanelCollapsed(false);
+      }
+
       setSelectedEntityId(null);
       resetVisibilityForHomeFromStore();
       setActiveTool('select');
@@ -246,6 +271,7 @@ export const KEYBOARD_SHORTCUTS = [
   { key: '1-6', description: 'Preset views', category: 'Camera' },
   { key: 'T', description: 'Toggle theme', category: 'UI' },
   { key: 'Esc', description: 'Reset all (clear selection, basket, isolation)', category: 'Selection' },
+  { key: 'Esc Esc', description: 'Close all panels (return to starting view)', category: 'UI' },
   { key: 'Ctrl+K', description: 'Command palette', category: 'UI' },
   { key: '?', description: 'Show info panel', category: 'Help' },
 ] as const;

package/src/sdk/adapters/visibility-adapter.ts

@@ -4,7 +4,84 @@
 
 import type { EntityRef, VisibilityBackendMethods } from '@ifc-lite/sdk';
 import type { StoreApi } from './types.js';
-import { getModelForRef } from './model-compat.js';
+import { getModelForRef, type ModelLike } from './model-compat.js';
+import { collectIfcBuildingStoreyElementsWithIfcSpace } from '../../store/basketVisibleSet.js';
+import { IfcTypeEnum, type SpatialNode } from '@ifc-lite/data';
+
+const SPATIAL_TYPES = new Set([
+  'IfcBuildingStorey',
+  'IfcBuilding',
+  'IfcSite',
+  'IfcProject',
+]);
+
+function findDescendantNode(root: SpatialNode, expressId: number): SpatialNode | null {
+  const stack: SpatialNode[] = [root];
+  while (stack.length > 0) {
+    const node = stack.pop()!;
+    if (node.expressId === expressId) return node;
+    for (const child of node.children) {
+      stack.push(child);
+    }
+  }
+  return null;
+}
+
+function collectDescendantStoreyIds(node: SpatialNode): number[] {
+  const storeyIds: number[] = [];
+  const stack: SpatialNode[] = [node];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (current.type === IfcTypeEnum.IfcBuildingStorey) {
+      storeyIds.push(current.expressId);
+    }
+    for (const child of current.children) {
+      stack.push(child);
+    }
+  }
+  return storeyIds;
+}
+
+/**
+ * If `ref` points to a spatial structure element (storey, building, etc.),
+ * expand it to the local expressIds of all contained elements.
+ * Otherwise return the original expressId as-is.
+ */
+function expandSpatialRef(ref: EntityRef, model: ModelLike): number[] {
+  const dataStore = model.ifcDataStore;
+  const typeName = dataStore.entities.getTypeName(ref.expressId) || '';
+  if (!SPATIAL_TYPES.has(typeName)) return [ref.expressId];
+
+  const hierarchy = dataStore.spatialHierarchy;
+  if (!hierarchy) return [ref.expressId];
+
+  if (typeName === 'IfcBuildingStorey') {
+    const ids = collectIfcBuildingStoreyElementsWithIfcSpace(hierarchy, ref.expressId);
+    return ids && ids.length > 0 ? ids : [ref.expressId];
+  }
+
+  // For higher-level containers (IfcBuilding, IfcSite, IfcProject),
+  // walk the spatial tree from ref.expressId to find descendant storeys only
+  const startNode = findDescendantNode(hierarchy.project, ref.expressId);
+  if (!startNode) return [ref.expressId];
+
+  const descendantStoreyIds = collectDescendantStoreyIds(startNode);
+
+  const allIds: number[] = [];
+  const seen = new Set<number>();
+  for (const storeyId of descendantStoreyIds) {
+    const storeyIds = collectIfcBuildingStoreyElementsWithIfcSpace(hierarchy, storeyId);
+    if (storeyIds) {
+      for (const id of storeyIds) {
+        if (!seen.has(id)) {
+          seen.add(id);
+          allIds.push(id);
+        }
+      }
+    }
+  }
+  return allIds.length > 0 ? allIds : [ref.expressId];
+}
 
 export function createVisibilityAdapter(store: StoreApi): VisibilityBackendMethods {
   return {
@@ -44,7 +121,10 @@ export function createVisibilityAdapter(store: StoreApi): VisibilityBackendMetho
       for (const ref of refs) {
         const model = getModelForRef(state, ref.modelId);
         if (model) {
-          globalIds.push(ref.expressId + model.idOffset);
+          const expanded = expandSpatialRef(ref, model);
+          for (const id of expanded) {
+            globalIds.push(id + model.idOffset);
+          }
         }
       }
       if (globalIds.length > 0) {

package/src/store/basketVisibleSet.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 { IfcTypeEnum, type SpatialNode } from '@ifc-lite/data';
+import { IfcTypeEnum, type SpatialNode, type SpatialHierarchy } from '@ifc-lite/data';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import type { EntityRef } from './types.js';
 import { entityRefToString, stringToEntityRef } from './types.js';
@@ -57,6 +57,7 @@ function visibilityFingerprint(state: ViewerStateSnapshot): string {
   return [
     digestNumberSet(state.hiddenEntities),
     state.isolatedEntities ? digestNumberSet(state.isolatedEntities) : 'none',
+    state.classFilter ? digestNumberSet(state.classFilter.ids) : 'none',
     digestNumberSet(state.lensHiddenIds),
     digestModelEntityMap(state.hiddenEntitiesByModel),
     digestModelEntityMap(state.isolatedEntitiesByModel),
@@ -273,6 +274,52 @@ function getExpandedSelectionRefs(state: ViewerStateSnapshot): EntityRef[] {
   return dedupeRefs(baseRefs.flatMap((ref) => expandRefToElements(state, ref)));
 }
 
+/**
+ * Collect all descendant IfcSpace expressIds from a spatial node.
+ */
+function collectDescendantSpaceIds(node: SpatialNode): number[] {
+  const spaceIds: number[] = [];
+  for (const child of node.children || []) {
+    if (child.type === IfcTypeEnum.IfcSpace) {
+      spaceIds.push(child.expressId);
+    }
+    // Recurse into all children (spaces can nest under other spatial nodes)
+    spaceIds.push(...collectDescendantSpaceIds(child));
+  }
+  return spaceIds;
+}
+
+/**
+ * Collect all element IDs for an IfcBuildingStorey, including elements
+ * contained in descendant IfcSpace nodes and the space geometry itself.
+ */
+export function collectIfcBuildingStoreyElementsWithIfcSpace(
+  hierarchy: SpatialHierarchy,
+  storeyId: number
+): number[] | null {
+  const storeyElements = hierarchy.byStorey.get(storeyId);
+  if (!storeyElements) return null;
+
+  const storeyNode = findSpatialNode(hierarchy.project, storeyId);
+  if (!storeyNode) return storeyElements;
+
+  const spaceIds = collectDescendantSpaceIds(storeyNode);
+  if (spaceIds.length === 0) return storeyElements;
+
+  // Combine storey elements + space expressIds + elements inside spaces
+  const combined = [...storeyElements];
+  for (const spaceId of spaceIds) {
+    combined.push(spaceId); // The space geometry itself
+    const spaceElements = hierarchy.bySpace.get(spaceId);
+    if (spaceElements) {
+      for (const elemId of spaceElements) {
+        combined.push(elemId);
+      }
+    }
+  }
+  return combined;
+}
+
 function computeStoreyIsolation(state: ViewerStateSnapshot): Set<number> | null {
   if (state.selectedStoreys.size === 0) return null;
 
@@ -284,7 +331,8 @@ function computeStoreyIsolation(state: ViewerStateSnapshot): Set<number> | null
       if (!hierarchy) continue;
       const offset = model.idOffset ?? 0;
       for (const storeyId of state.selectedStoreys) {
-        const storeyElementIds = hierarchy.byStorey.get(storeyId) || hierarchy.byStorey.get(storeyId - offset);
+        const localStoreyId = hierarchy.byStorey.has(storeyId) ? storeyId : storeyId - offset;
+        const storeyElementIds = collectIfcBuildingStoreyElementsWithIfcSpace(hierarchy, localStoreyId);
         if (!storeyElementIds) continue;
         for (const localId of storeyElementIds) {
           ids.add(localId + offset);
@@ -292,8 +340,9 @@ function computeStoreyIsolation(state: ViewerStateSnapshot): Set<number> | null
       }
     }
   } else if (state.ifcDataStore?.spatialHierarchy) {
+    const hierarchy = state.ifcDataStore.spatialHierarchy;
     for (const storeyId of state.selectedStoreys) {
-      const storeyElementIds = state.ifcDataStore.spatialHierarchy.byStorey.get(storeyId);
+      const storeyElementIds = collectIfcBuildingStoreyElementsWithIfcSpace(hierarchy, storeyId);
       if (!storeyElementIds) continue;
       for (const id of storeyElementIds) {
         ids.add(id);
@@ -345,7 +394,26 @@ function getVisibleGlobalIds(state: ViewerStateSnapshot): Set<number> {
     globalHidden.add(id);
   }
 
-  const globalIsolation = state.isolatedEntities ?? computeStoreyIsolation(state);
+  // Collect all active filter sets and intersect them
+  const filters: Set<number>[] = [];
+  const storeyIsolation = computeStoreyIsolation(state);
+  if (storeyIsolation !== null) filters.push(storeyIsolation);
+  if (state.classFilter !== null) filters.push(state.classFilter.ids);
+  if (state.isolatedEntities !== null) filters.push(state.isolatedEntities);
+
+  let globalIsolation: Set<number> | null = null;
+  if (filters.length === 1) {
+    globalIsolation = filters[0];
+  } else if (filters.length > 1) {
+    // Intersect all active filters — start from smallest for efficiency
+    const sorted = filters.sort((a, b) => a.size - b.size);
+    globalIsolation = new Set<number>();
+    for (const id of sorted[0]) {
+      if (sorted.every(s => s.has(id))) {
+        globalIsolation.add(id);
+      }
+    }
+  }
 
   const visible = new Set<number>();
   for (const candidate of candidates) {

package/src/store/index.ts

@@ -130,7 +130,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
   // Note: Does NOT clear models - use clearAllModels() for that
   resetViewerState: () => {
     invalidateVisibleBasketCache();
-    const [set] = args;
+    const [set, get] = args;
     set({
       // Selection (legacy)
       selectedEntityId: null,
@@ -144,6 +144,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       // Visibility (legacy)
       hiddenEntities: new Set(),
       isolatedEntities: null,
+      classFilter: null,
       typeVisibility: {
         spaces: TYPE_VISIBILITY_DEFAULTS.SPACES,
         openings: TYPE_VISIBILITY_DEFAULTS.OPENINGS,
@@ -303,6 +304,15 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       chatStreamingContent: '',
       chatError: null,
       chatAbortController: null,
+
+      // Mutations - clear all mutation state so stale changes don't carry over
+      mutationViews: new Map(),
+      changeSets: new Map(),
+      activeChangeSetId: null,
+      undoStacks: new Map(),
+      redoStacks: new Map(),
+      dirtyModels: new Set(),
+      mutationVersion: get().mutationVersion + 1,
     });
   },
 }));

package/src/store/slices/pinboardSlice.ts

@@ -53,7 +53,14 @@ export interface SaveBasketViewOptions {
   section?: BasketSectionSnapshot | null;
 }
 
-/** Cross-slice state that pinboard reads/writes via the combined store */
+/**
+ * Cross-slice state that pinboard reads/writes via the combined store.
+ *
+ * When the basket is non-empty, pinboard owns `isolatedEntities` and
+ * `hiddenEntities` — it is the isolation mechanism.  The visibility slice
+ * also writes these fields for non-basket isolation (direct UI isolation).
+ * They share the same state fields by design.
+ */
 interface PinboardCrossSliceState {
   isolatedEntities: Set<number> | null;
   hiddenEntities: Set<number>;
@@ -166,6 +173,35 @@ function entityKeysToRefs(keys: Iterable<string>): EntityRef[] {
   return refs;
 }
 
+/**
+ * Compute isolation + hidden state from basket entities, unhiding any newly added refs.
+ *
+ * This is the single source of truth for the "basket → visibility" sync that
+ * several pinboard actions need.  The incremental add/remove methods bypass
+ * this for performance and maintain their own logic.
+ */
+function computeBasketVisibility(
+  nextBasket: Set<string>,
+  models: Map<string, { idOffset: number }>,
+  currentHidden: Set<number>,
+  unhideRefs?: EntityRef[],
+): { isolatedEntities: Set<number> | null; hiddenEntities: Set<number> } {
+  if (nextBasket.size === 0) {
+    return { isolatedEntities: null, hiddenEntities: currentHidden };
+  }
+  const isolatedEntities = basketToGlobalIds(nextBasket, models);
+  if (!unhideRefs || unhideRefs.length === 0) {
+    return { isolatedEntities, hiddenEntities: currentHidden };
+  }
+  const hiddenEntities = new Set<number>(currentHidden);
+  for (const ref of unhideRefs) {
+    const model = models.get(ref.modelId);
+    const offset = model?.idOffset ?? 0;
+    hiddenEntities.delete(ref.expressId + offset);
+  }
+  return { isolatedEntities, hiddenEntities };
+}
+
 function createViewId(): string {
   if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
     return crypto.randomUUID();
@@ -218,18 +254,10 @@ export const createPinboardSlice: StateCreator<
       for (const ref of refs) {
         next.add(entityRefToString(ref));
       }
-      const isolatedEntities = basketToGlobalIds(next, state.models);
-      const hiddenEntities = new Set<number>(state.hiddenEntities);
-      // Unhide any entities being added to basket
-      for (const ref of refs) {
-        const model = state.models.get(ref.modelId);
-        const offset = model?.idOffset ?? 0;
-        hiddenEntities.delete(ref.expressId + offset);
-      }
+      const visibility = computeBasketVisibility(next, state.models, state.hiddenEntities, refs);
       return {
         pinboardEntities: next,
-        isolatedEntities,
-        hiddenEntities,
+        ...visibility,
         activeBasketViewId: null,
       };
     });
@@ -257,20 +285,9 @@ export const createPinboardSlice: StateCreator<
     for (const ref of refs) {
       next.add(entityRefToString(ref));
     }
-    if (next.size === 0) {
-      set({ pinboardEntities: next, isolatedEntities: null, activeBasketViewId: null });
-      return;
-    }
     const s = get();
-    const hiddenEntities = new Set<number>(s.hiddenEntities);
-    // Unhide basket entities
-    for (const ref of refs) {
-      const model = s.models.get(ref.modelId);
-      const offset = model?.idOffset ?? 0;
-      hiddenEntities.delete(ref.expressId + offset);
-    }
-    const isolatedEntities = basketToGlobalIds(next, s.models);
-    set({ pinboardEntities: next, isolatedEntities, hiddenEntities, activeBasketViewId: null });
+    const visibility = computeBasketVisibility(next, s.models, s.hiddenEntities, refs);
+    set({ pinboardEntities: next, ...visibility, activeBasketViewId: null });
   },
 
   clearPinboard: () => set({ pinboardEntities: new Set(), isolatedEntities: null, activeBasketViewId: null }),
@@ -311,15 +328,8 @@ export const createPinboardSlice: StateCreator<
       next.add(entityRefToString(ref));
     }
     const s = get();
-    const hiddenEntities = new Set<number>(s.hiddenEntities);
-    // Unhide basket entities
-    for (const ref of refs) {
-      const model = s.models.get(ref.modelId);
-      const offset = model?.idOffset ?? 0;
-      hiddenEntities.delete(ref.expressId + offset);
-    }
-    const isolatedEntities = basketToGlobalIds(next, s.models);
-    set({ pinboardEntities: next, isolatedEntities, hiddenEntities, activeBasketViewId: null });
+    const visibility = computeBasketVisibility(next, s.models, s.hiddenEntities, refs);
+    set({ pinboardEntities: next, ...visibility, activeBasketViewId: null });
   },
 
   /** + Add entities to basket and update isolation (incremental — avoids re-parsing all strings) */
@@ -410,20 +420,11 @@ export const createPinboardSlice: StateCreator<
     get().clearEntitySelection?.();
     set((current) => {
       const nextPinboard = new Set<string>(entityRefs);
-      if (nextPinboard.size === 0) {
-        return { pinboardEntities: new Set(), isolatedEntities: null, activeBasketViewId: viewId };
-      }
-
-      const hiddenEntities = new Set<number>(current.hiddenEntities);
       const refs = entityKeysToRefs(nextPinboard);
-      for (const ref of refs) {
-        hiddenEntities.delete(refToGlobalId(ref, current.models));
-      }
-
+      const visibility = computeBasketVisibility(nextPinboard, current.models, current.hiddenEntities, refs);
       return {
-        pinboardEntities: nextPinboard,
-        isolatedEntities: basketToGlobalIds(nextPinboard, current.models),
-        hiddenEntities,
+        pinboardEntities: nextPinboard.size === 0 ? new Set() : nextPinboard,
+        ...visibility,
         activeBasketViewId: viewId,
       };
     });