@ifc-lite/viewer 1.25.1 → 1.26.0

package/src/lib/geo/effective-georef.test.ts

@@ -8,6 +8,7 @@ import assert from 'node:assert';
 import {
   detectScaleUnitMismatch,
   getEffectiveHorizontalScale,
+  hasStandardGeoreferencing,
   inferMapUnitScale,
   mergeMapConversion,
   mergeProjectedCRS,
@@ -237,4 +238,69 @@ describe('effective georeferencing', () => {
       assert.strictEqual(m!.effectiveScale, 2);
     });
   });
+
+  describe('hasStandardGeoreferencing (federation alignment gate)', () => {
+    // Federation affine alignment (extractModelGeoref → buildGeorefAlignmentTransform)
+    // gates on this predicate. A site-location-only georef must NOT qualify: it is
+    // EPSG:4326 lat/long degrees + a raw, un-unit-scaled IfcSite RefElevation, which
+    // the projected-CRS transform misreads as metres and flings the second federated
+    // model kilometres away. These tests lock that invariant.
+    const mapConversion: MapConversion = {
+      id: 1,
+      sourceCRS: 0,
+      targetCRS: 0,
+      eastings: 100,
+      northings: 200,
+      orthogonalHeight: 5,
+    };
+
+    it('rejects synthesised site-location georef even with a CRS name + map conversion', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'siteLocation',
+          projectedCRS: { id: 1, name: 'EPSG:4326' },
+          mapConversion,
+        }),
+        false,
+      );
+    });
+
+    it('accepts true IfcMapConversion + IfcProjectedCRS georef', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'mapConversion',
+          projectedCRS: { id: 1, name: 'EPSG:28992' },
+          mapConversion,
+        }),
+        true,
+      );
+    });
+
+    it('rejects georef missing a map conversion', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'mapConversion',
+          projectedCRS: { id: 1, name: 'EPSG:28992' },
+          mapConversion: undefined,
+        }),
+        false,
+      );
+    });
+
+    it('rejects georef missing a projected CRS name', () => {
+      assert.strictEqual(
+        hasStandardGeoreferencing({
+          source: 'mapConversion',
+          projectedCRS: { id: 1, name: '' },
+          mapConversion,
+        }),
+        false,
+      );
+    });
+
+    it('rejects null / undefined', () => {
+      assert.strictEqual(hasStandardGeoreferencing(null), false);
+      assert.strictEqual(hasStandardGeoreferencing(undefined), false);
+    });
+  });
 });

package/src/services/extensions/host.ts

@@ -436,6 +436,19 @@ export class ExtensionHostService {
     } catch (err) {
       console.warn('[ext-host] lens restore on switch failed:', err);
     }
+    // Restore the flavor's clash config (rule-set + detection settings) from the
+    // opaque settings.clash blob, mirroring the lens roundtrip above. Missing /
+    // malformed blobs deserialize to null and are skipped (no-op).
+    try {
+      const { deserializeClashConfig } = await import('@/lib/clash/persistence');
+      const config = deserializeClashConfig((target.settings as Record<string, unknown> | undefined)?.clash);
+      if (config) {
+        const { useViewerStore } = await import('@/store');
+        useViewerStore.getState().applyClashFlavorConfig(config);
+      }
+    } catch (err) {
+      console.warn('[ext-host] clash restore on switch failed:', err);
+    }
     this.emit();
   }
 

package/src/store/constants.ts

@@ -6,6 +6,8 @@
  * Store constants - extracted magic numbers for maintainability
  */
 
+import type { TypeVisibility } from './types.js';
+
 // ============================================================================
 // Camera Defaults
 // ============================================================================
@@ -159,6 +161,7 @@ export const TYPE_VISIBILITY_STORAGE_KEYS = {
   openings:       'ifc-lite-ifc-openings-visible',
   site:           'ifc-lite-ifc-site-visible',
   ifcAnnotations: 'ifc-lite-ifc-annotations-visible',
+  ifcGrid:        'ifc-lite-ifc-grid-visible',
 } as const;
 
 /** Legacy alias — kept until external callers migrate. */
@@ -178,25 +181,46 @@ function readPersistedBool(key: string, fallback: boolean): boolean {
 
 // Semantic defaults applied when no localStorage preference is set.
 // IfcSpace / IfcOpeningElement off — they cover walls and confuse novices
-// on first load. IfcSite + IfcAnnotation/IfcGrid on — both convey
-// design intent users expect to see by default.
-const SEMANTIC_DEFAULTS = {
+// on first load. IfcSite + IfcAnnotation + IfcGrid on — all three convey
+// design intent users expect to see by default. (Issue #862 split grid
+// into its own toggle so dense-grid models can hide grids without losing
+// dimensions/labels.) Exported so the "Reset" action in the visibility
+// menu can restore these without re-deriving them.
+export const TYPE_VISIBILITY_SEMANTIC_DEFAULTS: TypeVisibility = {
   spaces: false,
   openings: false,
   site: true,
   ifcAnnotations: true,
-} as const;
+  ifcGrid: true,
+};
 
-export const TYPE_VISIBILITY_DEFAULTS = {
-  /** IfcSpace visibility — persisted across reloads. */
-  SPACES:          readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.spaces, SEMANTIC_DEFAULTS.spaces),
-  /** IfcOpeningElement visibility — persisted across reloads. */
-  OPENINGS:        readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.openings, SEMANTIC_DEFAULTS.openings),
-  /** IfcSite visibility — persisted across reloads. */
-  SITE:            readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.site, SEMANTIC_DEFAULTS.site),
-  /** IfcAnnotation + IfcGrid visibility — persisted across reloads. */
-  IFC_ANNOTATIONS: readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.ifcAnnotations, SEMANTIC_DEFAULTS.ifcAnnotations),
-} as const;
+/**
+ * Resolve the full type-visibility preference set from localStorage.
+ *
+ * Read fresh on EVERY call — not captured once at module load. The store
+ * applies this both at boot (slice init) and on every new-file load
+ * (`resetViewerState`). A module-level constant would snapshot localStorage
+ * at first import and then go stale after the first in-session toggle, so
+ * loading a second model would silently revert the user's choices (e.g.
+ * "Show Annotations" flipping back on). Reading live keeps every toggle
+ * sticky across reloads AND across model swaps within a session.
+ */
+export function getPersistedTypeVisibility(): TypeVisibility {
+  return {
+    spaces:         readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.spaces, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.spaces),
+    openings:       readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.openings, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.openings),
+    site:           readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.site, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.site),
+    ifcAnnotations: readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.ifcAnnotations, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.ifcAnnotations),
+    // Issue #862. Migration: if the new grid key isn't set yet, fall back to
+    // the legacy combined `ifcAnnotations` preference so a user who turned
+    // the old "Annotations & Grids" toggle off keeps grids hidden after
+    // upgrade instead of grids silently reappearing (PR #868 review).
+    ifcGrid:        readPersistedBool(
+      TYPE_VISIBILITY_STORAGE_KEYS.ifcGrid,
+      readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.ifcAnnotations, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.ifcGrid),
+    ),
+  };
+}
 
 // ============================================================================
 // Data Defaults

package/src/store/index.ts

@@ -33,6 +33,7 @@ import { createExtensionsSlice, type ExtensionsSlice } from './slices/extensions
 import { createListSlice, type ListSlice } from './slices/listSlice.js';
 import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.js';
 import { createLensSlice, type LensSlice } from './slices/lensSlice.js';
+import { createClashSlice, type ClashSlice } from './slices/clashSlice.js';
 import { createScriptSlice, type ScriptSlice } from './slices/scriptSlice.js';
 import { createChatSlice, type ChatSlice } from './slices/chatSlice.js';
 import { createCesiumSlice, type CesiumSlice } from './slices/cesiumSlice.js';
@@ -49,7 +50,7 @@ import { createPointCloudSlice, type PointCloudSlice, POINT_CLOUD_DEFAULTS } fro
 import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
 // Import constants for reset function
-import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, TYPE_VISIBILITY_DEFAULTS } from './constants.js';
+import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, getPersistedTypeVisibility } from './constants.js';
 
 // Re-export types for consumers
 export type * from './types.js';
@@ -129,6 +130,7 @@ export type ViewerState = LoadingSlice &
   ListSlice &
   PinboardSlice &
   LensSlice &
+  ClashSlice &
   ScriptSlice &
   ChatSlice &
   CesiumSlice &
@@ -144,6 +146,16 @@ export type ViewerState = LoadingSlice &
   PointCloudSlice &
   ExtensionsSlice & {
     resetViewerState: () => void;
+    /**
+     * Open one right-side analysis panel and close the others, so the chosen
+     * panel is always the topmost/active one. The right panel renders a single
+     * mutually-exclusive chain (lens → clash → ids → bcf → extensions), so
+     * leaving a sibling flag set would keep the higher-precedence panel on top
+     * (the cause of "I have to close clash before I see BCF"). Also un-collapses
+     * the right panel. Routed through by the toolbar, command palette, and the
+     * BCF overlay so every entry point behaves identically.
+     */
+    openWorkspacePanel: (panel: 'bcf' | 'ids' | 'lens' | 'clash' | 'extensions') => void;
   };
 
 /**
@@ -169,6 +181,7 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
   ...createListSlice(...args),
   ...createPinboardSlice(...args),
   ...createLensSlice(...args),
+  ...createClashSlice(...args),
   ...createScriptSlice(...args),
   ...createChatSlice(...args),
   ...createCesiumSlice(...args),
@@ -203,12 +216,9 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       hiddenEntities: new Set(),
       isolatedEntities: null,
       classFilter: null,
-      typeVisibility: {
-        spaces: TYPE_VISIBILITY_DEFAULTS.SPACES,
-        openings: TYPE_VISIBILITY_DEFAULTS.OPENINGS,
-        site: TYPE_VISIBILITY_DEFAULTS.SITE,
-        ifcAnnotations: TYPE_VISIBILITY_DEFAULTS.IFC_ANNOTATIONS,
-      },
+      // Re-read persisted toggles on every file load so a new model never
+      // reverts the user's visibility choices (e.g. "Show Annotations").
+      typeVisibility: getPersistedTypeVisibility(),
 
       // Visibility (multi-model)
       hiddenEntitiesByModel: new Map(),
@@ -442,6 +452,18 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       pointCloudFixedColor: [...POINT_CLOUD_DEFAULTS.pointCloudFixedColor] as [number, number, number, number],
     });
   },
+
+  openWorkspacePanel: (panel) => {
+    const [set] = args;
+    set({
+      bcfPanelVisible: panel === 'bcf',
+      idsPanelVisible: panel === 'ids',
+      lensPanelVisible: panel === 'lens',
+      clashPanelVisible: panel === 'clash',
+      extensionsPanelVisible: panel === 'extensions',
+      rightPanelCollapsed: false,
+    });
+  },
 }));
 
 const STORE_SINGLETON_KEY = '__ifc_lite_viewer_store__';

package/src/store/slices/clashSlice.ts

@@ -0,0 +1,251 @@
+/* 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/. */
+
+/**
+ * Clash detection panel state (Phase 1). Detection itself lives in
+ * `@ifc-lite/clash`; this slice holds the panel's UI state, the last result,
+ * and the user's persisted detection settings + rule presets (see
+ * `lib/clash/persistence.ts`, modeled on the lens slice). Orchestration
+ * (gathering elements, running the engine, applying colors / selection /
+ * camera, BCF export) lives in the `useClash` hook.
+ */
+
+import type { StateCreator } from 'zustand';
+import type { ClashResult, ClashGroup, ClashMode, ClashProgress } from '@ifc-lite/clash';
+import {
+  buildInitialPresets,
+  defaultPresets,
+  loadSettings,
+  savePresets,
+  saveSettings,
+  validatePresetName,
+  validateSelector,
+  CLASH_BOUNDS,
+  clampToBounds,
+  DEFAULT_CLASH_SETTINGS,
+  type ClashPreset,
+  type ClashGlobalSettings,
+  type ClashSettingsGroupBy,
+  type SaveResult,
+} from '@/lib/clash/persistence';
+
+export type ClashGroupBy = ClashSettingsGroupBy;
+export type { ClashPreset, ClashGlobalSettings, SaveResult };
+
+/** Fields a user supplies when adding a custom rule (id/flags filled in here). */
+export type NewClashPreset = {
+  name: string;
+  description?: string;
+  severity: ClashPreset['severity'];
+  selectorA: string;
+  selectorB: string;
+};
+
+export interface ClashSlice {
+  clashPanelVisible: boolean;
+  clashResult: ClashResult | null;
+  clashGroups: ClashGroup[] | null;
+  clashRunning: boolean;
+  clashError: string | null;
+  /** Live detection progress for the running rule (null when idle). */
+  clashProgress: ClashProgress | null;
+  /** Detection settings (persisted). */
+  clashMode: ClashMode;
+  clashTolerance: number;
+  clashClearance: number;
+  clashClusterEpsilon: number;
+  clashReportTouch: boolean;
+  /** How the result list is organized (persisted). */
+  clashGroupBy: ClashGroupBy;
+  /** Built-in + custom rule presets (persisted). */
+  clashPresets: ClashPreset[];
+  /** Currently focused clash id (for highlight in the list). */
+  clashSelectedId: string | null;
+
+  setClashPanelVisible: (visible: boolean) => void;
+  toggleClashPanel: () => void;
+  setClashResult: (result: ClashResult | null) => void;
+  setClashGroups: (groups: ClashGroup[] | null) => void;
+  setClashRunning: (running: boolean) => void;
+  setClashError: (error: string | null) => void;
+  setClashProgress: (progress: ClashProgress | null) => void;
+  setClashMode: (mode: ClashMode) => void;
+  setClashTolerance: (tolerance: number) => void;
+  setClashClearance: (clearance: number) => void;
+  setClashClusterEpsilon: (epsilon: number) => void;
+  setClashReportTouch: (reportTouch: boolean) => void;
+  setClashGroupBy: (groupBy: ClashGroupBy) => void;
+  resetClashSettings: () => void;
+  setClashSelectedId: (id: string | null) => void;
+  // Preset CRUD (persisted). create/update/import return a SaveResult so the UI
+  // can surface quota / cap failures; the rest are best-effort.
+  createClashPreset: (input: NewClashPreset) => SaveResult;
+  updateClashPreset: (id: string, patch: Partial<Omit<ClashPreset, 'id' | 'builtin'>>) => SaveResult;
+  deleteClashPreset: (id: string) => void;
+  setClashPresetEnabled: (id: string, enabled: boolean) => void;
+  resetClashPresets: () => void;
+  importClashPresets: (presets: ClashPreset[]) => SaveResult;
+  /**
+   * Replace the entire clash config (presets + detection settings) and persist.
+   * Used when activating a flavor/profile so each one carries its own rule-set.
+   */
+  applyClashFlavorConfig: (config: { presets: ClashPreset[]; settings: ClashGlobalSettings }) => void;
+  clearClash: () => void;
+}
+
+/** Build the persisted settings blob from current slice state. */
+function snapshotSettings(s: ClashSlice): ClashGlobalSettings {
+  return {
+    mode: s.clashMode,
+    tolerance: s.clashTolerance,
+    clearance: s.clashClearance,
+    clusterEpsilon: s.clashClusterEpsilon,
+    reportTouch: s.clashReportTouch,
+    groupBy: s.clashGroupBy,
+  };
+}
+
+export const createClashSlice: StateCreator<ClashSlice, [], [], ClashSlice> = (set, get) => {
+  const initial = loadSettings();
+  // Persist the current settings snapshot after a state change.
+  const persistSettings = () => saveSettings(snapshotSettings(get()));
+
+  return {
+    clashPanelVisible: false,
+    clashResult: null,
+    clashGroups: null,
+    clashRunning: false,
+    clashError: null,
+    clashProgress: null,
+    clashMode: initial.mode,
+    clashTolerance: initial.tolerance,
+    clashClearance: initial.clearance,
+    clashClusterEpsilon: initial.clusterEpsilon,
+    clashReportTouch: initial.reportTouch,
+    clashGroupBy: initial.groupBy,
+    clashPresets: buildInitialPresets(),
+    clashSelectedId: null,
+
+    setClashPanelVisible: (clashPanelVisible) => set({ clashPanelVisible }),
+    toggleClashPanel: () => set((s) => ({ clashPanelVisible: !s.clashPanelVisible })),
+    setClashResult: (clashResult) => set({ clashResult }),
+    setClashGroups: (clashGroups) => set({ clashGroups }),
+    setClashRunning: (clashRunning) => set({ clashRunning }),
+    setClashError: (clashError) => set({ clashError }),
+    setClashProgress: (clashProgress) => set({ clashProgress }),
+
+    setClashMode: (clashMode) => { set({ clashMode }); persistSettings(); },
+    setClashTolerance: (clashTolerance) => {
+      set({ clashTolerance: clampToBounds(clashTolerance, CLASH_BOUNDS.tolerance, DEFAULT_CLASH_SETTINGS.tolerance) });
+      persistSettings();
+    },
+    setClashClearance: (clashClearance) => {
+      set({ clashClearance: clampToBounds(clashClearance, CLASH_BOUNDS.clearance, DEFAULT_CLASH_SETTINGS.clearance) });
+      persistSettings();
+    },
+    setClashClusterEpsilon: (clashClusterEpsilon) => {
+      set({ clashClusterEpsilon: clampToBounds(clashClusterEpsilon, CLASH_BOUNDS.clusterEpsilon, DEFAULT_CLASH_SETTINGS.clusterEpsilon) });
+      persistSettings();
+    },
+    setClashReportTouch: (clashReportTouch) => { set({ clashReportTouch }); persistSettings(); },
+    setClashGroupBy: (clashGroupBy) => { set({ clashGroupBy }); persistSettings(); },
+    resetClashSettings: () => {
+      set({
+        clashMode: DEFAULT_CLASH_SETTINGS.mode,
+        clashTolerance: DEFAULT_CLASH_SETTINGS.tolerance,
+        clashClearance: DEFAULT_CLASH_SETTINGS.clearance,
+        clashClusterEpsilon: DEFAULT_CLASH_SETTINGS.clusterEpsilon,
+        clashReportTouch: DEFAULT_CLASH_SETTINGS.reportTouch,
+        clashGroupBy: DEFAULT_CLASH_SETTINGS.groupBy,
+      });
+      persistSettings();
+    },
+
+    setClashSelectedId: (clashSelectedId) => set({ clashSelectedId }),
+
+    createClashPreset: (input) => {
+      const name = validatePresetName(input.name);
+      const selectorA = validateSelector(input.selectorA);
+      const selectorB = validateSelector(input.selectorB);
+      if (!name || !selectorA || !selectorB) {
+        return { ok: false, reason: 'serialize', message: 'Name and both selectors are required.' };
+      }
+      const preset: ClashPreset = {
+        id: `custom-${crypto.randomUUID()}`,
+        name,
+        description: input.description?.trim() ?? '',
+        severity: input.severity,
+        selectorA,
+        selectorB,
+        enabled: true,
+        builtin: false,
+      };
+      const next = [...get().clashPresets, preset];
+      const result = savePresets(next);
+      if (result.ok) set({ clashPresets: next });
+      return result;
+    },
+
+    updateClashPreset: (id, patch) => {
+      const next = get().clashPresets.map((p) => (p.id === id ? { ...p, ...patch } : p));
+      const result = savePresets(next);
+      if (result.ok) set({ clashPresets: next });
+      return result;
+    },
+
+    deleteClashPreset: (id) => {
+      const target = get().clashPresets.find((p) => p.id === id);
+      if (!target || target.builtin) return; // built-ins are reset, never deleted
+      const next = get().clashPresets.filter((p) => p.id !== id);
+      savePresets(next);
+      set({ clashPresets: next });
+    },
+
+    setClashPresetEnabled: (id, enabled) => {
+      const next = get().clashPresets.map((p) => (p.id === id ? { ...p, enabled } : p));
+      savePresets(next);
+      set({ clashPresets: next });
+    },
+
+    resetClashPresets: () => {
+      const next = defaultPresets(); // drops all overrides + customs
+      savePresets(next);
+      set({ clashPresets: next });
+    },
+
+    importClashPresets: (presets) => {
+      const next = [...get().clashPresets, ...presets.filter((p) => !p.builtin)];
+      const result = savePresets(next);
+      if (result.ok) set({ clashPresets: next });
+      return result;
+    },
+
+    applyClashFlavorConfig: ({ presets, settings }) => {
+      set({
+        clashPresets: presets,
+        clashMode: settings.mode,
+        clashTolerance: settings.tolerance,
+        clashClearance: settings.clearance,
+        clashClusterEpsilon: settings.clusterEpsilon,
+        clashReportTouch: settings.reportTouch,
+        clashGroupBy: settings.groupBy,
+      });
+      // Persist so the activated flavor's config becomes the working set on reload.
+      savePresets(presets);
+      saveSettings(settings);
+    },
+
+    clearClash: () =>
+      // Keep presets + settings (workspace prefs, like saved lenses): only the
+      // run result/panel state is cleared.
+      set({
+        clashResult: null,
+        clashGroups: null,
+        clashRunning: false,
+        clashError: null,
+        clashProgress: null,
+        clashSelectedId: null,
+      }),
+  };
+};

package/src/store/slices/visibilitySlice.test.ts

@@ -5,7 +5,7 @@
 import { describe, it, beforeEach } from 'node:test';
 import assert from 'node:assert';
 import { createVisibilitySlice, type VisibilitySlice } from './visibilitySlice.js';
-import { TYPE_VISIBILITY_DEFAULTS } from '../constants.js';
+import { getPersistedTypeVisibility } from '../constants.js';
 
 describe('VisibilitySlice', () => {
   let state: VisibilitySlice;
@@ -33,10 +33,13 @@ describe('VisibilitySlice', () => {
       assert.strictEqual(state.isolatedEntitiesByModel.size, 0);
     });
 
-    it('should have default type visibility', () => {
-      assert.strictEqual(state.typeVisibility.spaces, TYPE_VISIBILITY_DEFAULTS.SPACES);
-      assert.strictEqual(state.typeVisibility.openings, TYPE_VISIBILITY_DEFAULTS.OPENINGS);
-      assert.strictEqual(state.typeVisibility.site, TYPE_VISIBILITY_DEFAULTS.SITE);
+    it('should initialise type visibility from persisted preferences', () => {
+      const persisted = getPersistedTypeVisibility();
+      assert.strictEqual(state.typeVisibility.spaces, persisted.spaces);
+      assert.strictEqual(state.typeVisibility.openings, persisted.openings);
+      assert.strictEqual(state.typeVisibility.site, persisted.site);
+      assert.strictEqual(state.typeVisibility.ifcAnnotations, persisted.ifcAnnotations);
+      assert.strictEqual(state.typeVisibility.ifcGrid, persisted.ifcGrid);
     });
   });
 
@@ -306,5 +309,20 @@ describe('VisibilitySlice', () => {
       state.toggleTypeVisibility('ifcAnnotations');
       assert.strictEqual(state.typeVisibility.ifcAnnotations, !initial);
     });
+
+    it('resetTypeVisibility restores semantic defaults', () => {
+      // Flip everything away from defaults first.
+      state.toggleTypeVisibility('spaces');   // false -> true
+      state.toggleTypeVisibility('site');     // true  -> false
+      state.toggleTypeVisibility('ifcGrid');  // true  -> false
+      state.resetTypeVisibility();
+      assert.deepStrictEqual(state.typeVisibility, {
+        spaces: false,
+        openings: false,
+        site: true,
+        ifcAnnotations: true,
+        ifcGrid: true,
+      });
+    });
   });
 });

package/src/store/slices/visibilitySlice.ts

@@ -11,7 +11,7 @@
 
 import type { StateCreator } from 'zustand';
 import type { TypeVisibility, EntityRef } from '../types.js';
-import { TYPE_VISIBILITY_DEFAULTS, TYPE_VISIBILITY_STORAGE_KEYS } from '../constants.js';
+import { getPersistedTypeVisibility, TYPE_VISIBILITY_STORAGE_KEYS, TYPE_VISIBILITY_SEMANTIC_DEFAULTS } from '../constants.js';
 
 export interface VisibilitySlice {
   // State (legacy - single model)
@@ -43,7 +43,9 @@ export interface VisibilitySlice {
   clearAllFilters: () => void;
   showAll: () => void;
   isEntityVisible: (id: number) => boolean;
-  toggleTypeVisibility: (type: 'spaces' | 'openings' | 'site' | 'ifcAnnotations') => void;
+  toggleTypeVisibility: (type: 'spaces' | 'openings' | 'site' | 'ifcAnnotations' | 'ifcGrid') => void;
+  /** Restore every type-visibility toggle to its semantic default (and persist). */
+  resetTypeVisibility: () => void;
   /** Set all hidden entities at once (for BCF viewpoint application) */
   setHiddenEntities: (ids: Set<number>) => void;
   /** Set all isolated entities at once (for BCF viewpoint with defaultVisibility=false) */
@@ -75,12 +77,8 @@ export const createVisibilitySlice: StateCreator<VisibilitySlice, [], [], Visibi
   hiddenEntities: new Set(),
   isolatedEntities: null,
   classFilter: null,
-  typeVisibility: {
-    spaces: TYPE_VISIBILITY_DEFAULTS.SPACES,
-    openings: TYPE_VISIBILITY_DEFAULTS.OPENINGS,
-    site: TYPE_VISIBILITY_DEFAULTS.SITE,
-    ifcAnnotations: TYPE_VISIBILITY_DEFAULTS.IFC_ANNOTATIONS,
-  },
+  // Read persisted toggles fresh so the user's choices survive reloads.
+  typeVisibility: getPersistedTypeVisibility(),
 
   // Initial state (multi-model)
   hiddenEntitiesByModel: new Map(),
@@ -210,6 +208,19 @@ export const createVisibilitySlice: StateCreator<VisibilitySlice, [], [], Visibi
     };
   }),
 
+  resetTypeVisibility: () => set(() => {
+    // Restore semantic defaults and persist them per-key (same storage
+    // pattern as toggleTypeVisibility) so the reset survives reloads.
+    if (typeof window !== 'undefined') {
+      (Object.keys(TYPE_VISIBILITY_STORAGE_KEYS) as (keyof typeof TYPE_VISIBILITY_STORAGE_KEYS)[])
+        .forEach((key) => {
+          try { localStorage.setItem(TYPE_VISIBILITY_STORAGE_KEYS[key], String(TYPE_VISIBILITY_SEMANTIC_DEFAULTS[key])); }
+          catch { /* private-mode storage rejection — non-fatal */ }
+        });
+    }
+    return { typeVisibility: { ...TYPE_VISIBILITY_SEMANTIC_DEFAULTS } };
+  }),
+
   // Actions (multi-model)
   hideEntityInModel: (modelId, expressId) => set((state) => {
     const newMap = new Map(state.hiddenEntitiesByModel);

package/src/store/types.ts

@@ -199,6 +199,15 @@ export interface TypeVisibility {
   site: boolean;
   /** IfcAnnotation (2D symbolic curves) - on by default when present */
   ifcAnnotations: boolean;
+  /**
+   * IfcGrid axis lines + bubble tags — split from `ifcAnnotations`
+   * (issue #862). Default true to match the legacy combined behaviour;
+   * users with dense grids that obscure components can hide grids while
+   * keeping annotations on. Unlike `ifcAnnotations`, grids are also
+   * section-clipped when a 3D section plane is active so each storey's
+   * grid lines only show for storeys near the cut.
+   */
+  ifcGrid: boolean;
 }
 
 // ============================================================================