@ifc-lite/viewer 1.6.0 → 1.7.0

package/src/store/index.ts

@@ -27,6 +27,9 @@ import { createDrawing2DSlice, type Drawing2DSlice } from './slices/drawing2DSli
 import { createSheetSlice, type SheetSlice } from './slices/sheetSlice.js';
 import { createBcfSlice, type BCFSlice } from './slices/bcfSlice.js';
 import { createIdsSlice, type IDSSlice } from './slices/idsSlice.js';
+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 constants for reset function
 import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, TYPE_VISIBILITY_DEFAULTS } from './constants.js';
@@ -35,7 +38,7 @@ import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, TYPE_VISIBILITY_D
 export type * from './types.js';
 
 // Explicitly re-export multi-model types that need to be imported by name
-export type { EntityRef, SchemaVersion, FederatedModel, MeasurementConstraintEdge } from './types.js';
+export type { EntityRef, SchemaVersion, FederatedModel, MeasurementConstraintEdge, OrthogonalAxis } from './types.js';
 
 // Re-export utility functions for entity references
 export { entityRefToString, stringToEntityRef, entityRefEquals, isIfcxDataStore } from './types.js';
@@ -52,6 +55,15 @@ export type { BCFSlice, BCFSliceState } from './slices/bcfSlice.js';
 // Re-export IDS types
 export type { IDSSlice, IDSSliceState, IDSDisplayOptions, IDSFilterMode } from './slices/idsSlice.js';
 
+// Re-export List types
+export type { ListSlice } from './slices/listSlice.js';
+
+// Re-export Pinboard types
+export type { PinboardSlice } from './slices/pinboardSlice.js';
+
+// Re-export Lens types
+export type { LensSlice, Lens, LensRule, LensCriteria } from './slices/lensSlice.js';
+
 // Combined store type
 export type ViewerState = LoadingSlice &
   SelectionSlice &
@@ -67,7 +79,10 @@ export type ViewerState = LoadingSlice &
   Drawing2DSlice &
   SheetSlice &
   BCFSlice &
-  IDSSlice & {
+  IDSSlice &
+  ListSlice &
+  PinboardSlice &
+  LensSlice & {
     resetViewerState: () => void;
   };
 
@@ -91,6 +106,9 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
   ...createSheetSlice(...args),
   ...createBcfSlice(...args),
   ...createIdsSlice(...args),
+  ...createListSlice(...args),
+  ...createPinboardSlice(...args),
+  ...createLensSlice(...args),
 
   // Reset all viewer state when loading new file
   // Note: Does NOT clear models - use clearAllModels() for that
@@ -153,6 +171,7 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
         azimuth: CAMERA_DEFAULTS.AZIMUTH,
         elevation: CAMERA_DEFAULTS.ELEVATION,
       },
+      projectionMode: 'perspective' as const,
 
       // UI
       activeTool: UI_DEFAULTS.ACTIVE_TOOL,
@@ -209,6 +228,23 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       idsActiveSpecificationId: null,
       idsActiveEntityId: null,
       // Keep idsDocument, idsValidationReport, idsLocale - user's work
+
+      // Lists - reset result but keep definitions (user's saved lists)
+      listPanelVisible: false,
+      activeListId: null,
+      listResult: null,
+      listExecuting: false,
+
+      // Pinboard - clear pinned entities on new file
+      pinboardEntities: new Set<string>(),
+
+      // Lens - deactivate but keep saved lenses
+      activeLensId: null,
+      lensPanelVisible: false,
+      lensColorMap: new Map<number, string>(),
+      lensHiddenIds: new Set<number>(),
+      lensRuleCounts: new Map<string, number>(),
+      lensRuleEntityIds: new Map<string, number[]>(),
     });
   },
 }));

package/src/store/slices/cameraSlice.ts

@@ -7,19 +7,22 @@
  */
 
 import type { StateCreator } from 'zustand';
-import type { CameraRotation, CameraCallbacks } from '../types.js';
+import type { CameraRotation, CameraCallbacks, ProjectionMode } from '../types.js';
 import { CAMERA_DEFAULTS } from '../constants.js';
 
 export interface CameraSlice {
   // State
   cameraRotation: CameraRotation;
   cameraCallbacks: CameraCallbacks;
+  projectionMode: ProjectionMode;
   onCameraRotationChange: ((rotation: CameraRotation) => void) | null;
   onScaleChange: ((scale: number) => void) | null;
 
   // Actions
   setCameraRotation: (rotation: CameraRotation) => void;
   setCameraCallbacks: (callbacks: CameraCallbacks) => void;
+  setProjectionMode: (mode: ProjectionMode) => void;
+  toggleProjectionMode: () => void;
   setOnCameraRotationChange: (callback: ((rotation: CameraRotation) => void) | null) => void;
   updateCameraRotationRealtime: (rotation: CameraRotation) => void;
   setOnScaleChange: (callback: ((scale: number) => void) | null) => void;
@@ -33,12 +36,22 @@ export const createCameraSlice: StateCreator<CameraSlice, [], [], CameraSlice> =
     elevation: CAMERA_DEFAULTS.ELEVATION,
   },
   cameraCallbacks: {},
+  projectionMode: 'perspective',
   onCameraRotationChange: null,
   onScaleChange: null,
 
   // Actions
   setCameraRotation: (cameraRotation) => set({ cameraRotation }),
   setCameraCallbacks: (cameraCallbacks) => set({ cameraCallbacks }),
+  setProjectionMode: (projectionMode) => {
+    get().cameraCallbacks.setProjectionMode?.(projectionMode);
+    set({ projectionMode });
+  },
+  toggleProjectionMode: () => {
+    const newMode = get().projectionMode === 'perspective' ? 'orthographic' : 'perspective';
+    get().cameraCallbacks.setProjectionMode?.(newMode);
+    set({ projectionMode: newMode });
+  },
   setOnCameraRotationChange: (onCameraRotationChange) => set({ onCameraRotationChange }),
 
   updateCameraRotationRealtime: (rotation) => {

package/src/store/slices/dataSlice.ts

@@ -22,6 +22,10 @@ export interface DataSlice {
   setGeometryResult: (result: GeometryResult | null) => void;
   appendGeometryBatch: (meshes: GeometryResult['meshes'], coordinateInfo?: CoordinateInfo) => void;
   updateMeshColors: (updates: Map<number, [number, number, number, number]>) => void;
+  /** Set pending color updates for the renderer without cloning mesh data.
+   *  Use this for transient overlays (lens, IDS) where the source-of-truth
+   *  mesh colors should remain unchanged. */
+  setPendingColorUpdates: (updates: Map<number, [number, number, number, number]>) => void;
   clearPendingColorUpdates: () => void;
   updateCoordinateInfo: (coordinateInfo: CoordinateInfo) => void;
 }
@@ -79,9 +83,16 @@ export const createDataSlice: StateCreator<DataSlice, [], [], DataSlice> = (set)
   }),
 
   updateMeshColors: (updates) => set((state) => {
-    if (!state.geometryResult) return {};
     // Clone the Map to prevent external mutation of pendingColorUpdates
     const clonedUpdates = new Map(updates);
+
+    if (!state.geometryResult) {
+      // Federation mode: no local geometryResult (geometry lives in models Map).
+      // Still set pendingColorUpdates so useGeometryStreaming applies to the WebGPU scene.
+      return { pendingColorUpdates: clonedUpdates };
+    }
+
+    // Legacy/single mode: update both the data model and pending color updates
     const updatedMeshes = state.geometryResult.meshes.map(mesh => {
       const newColor = clonedUpdates.get(mesh.expressId);
       if (newColor) {
@@ -98,6 +109,8 @@ export const createDataSlice: StateCreator<DataSlice, [], [], DataSlice> = (set)
     };
   }),
 
+  setPendingColorUpdates: (updates) => set({ pendingColorUpdates: new Map(updates) }),
+
   clearPendingColorUpdates: () => set({ pendingColorUpdates: null }),
 
   updateCoordinateInfo: (coordinateInfo) => set((state) => {

package/src/store/slices/lensSlice.ts

@@ -0,0 +1,184 @@
+/* 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/. */
+
+/**
+ * Lens state slice
+ *
+ * Rule-based 3D filtering and coloring system.
+ * Types, constants, presets, and evaluation logic live in @ifc-lite/lens.
+ * This slice manages Zustand state, CRUD actions, and localStorage persistence.
+ */
+
+import type { StateCreator } from 'zustand';
+import type { Lens, LensRule, LensCriteria } from '@ifc-lite/lens';
+import { BUILTIN_LENSES } from '@ifc-lite/lens';
+
+// Re-export types so existing consumer imports from this file still work
+export type { Lens, LensRule, LensCriteria };
+
+// Re-export constants for consumers that import from this file
+export { COMMON_IFC_CLASSES, COMMON_IFC_TYPES, LENS_PALETTE } from '@ifc-lite/lens';
+
+/** localStorage key for persisting custom lenses */
+const STORAGE_KEY = 'ifc-lite-custom-lenses';
+
+/** Built-in lens IDs — used to detect overrides */
+const BUILTIN_IDS = new Set(BUILTIN_LENSES.map(l => l.id));
+
+/**
+ * Load saved lenses from localStorage.
+ * Returns both custom lenses and built-in overrides (user edits to builtin lenses).
+ * Built-in overrides replace the default builtin when merging in initial state.
+ */
+function loadSavedLenses(): { custom: Lens[]; builtinOverrides: Map<string, Lens> } {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return { custom: [], builtinOverrides: new Map() };
+    const parsed = JSON.parse(raw) as Lens[];
+    if (!Array.isArray(parsed)) return { custom: [], builtinOverrides: new Map() };
+    const valid = parsed.filter(l => l.id && l.name && Array.isArray(l.rules));
+    const builtinOverrides = new Map<string, Lens>();
+    const custom: Lens[] = [];
+    for (const l of valid) {
+      if (BUILTIN_IDS.has(l.id)) {
+        builtinOverrides.set(l.id, { ...l, builtin: true });
+      } else {
+        custom.push(l);
+      }
+    }
+    return { custom, builtinOverrides };
+  } catch {
+    return { custom: [], builtinOverrides: new Map() };
+  }
+}
+
+/**
+ * Persist lenses to localStorage.
+ * Saves custom lenses + any built-in lenses the user has edited (overrides).
+ */
+function saveLenses(lenses: Lens[]): void {
+  try {
+    // Save non-builtin custom lenses
+    const custom = lenses.filter(l => !l.builtin);
+    // Also save built-in lenses that differ from their defaults (user overrides)
+    const builtinOverrides = lenses.filter(l => {
+      if (!l.builtin) return false;
+      const original = BUILTIN_LENSES.find(b => b.id === l.id);
+      if (!original) return false;
+      // Quick check: has the user changed the rules or name?
+      return l.name !== original.name ||
+        JSON.stringify(l.rules) !== JSON.stringify(original.rules);
+    });
+    localStorage.setItem(STORAGE_KEY, JSON.stringify([...custom, ...builtinOverrides]));
+  } catch {
+    // quota exceeded or unavailable — silently ignore
+  }
+}
+
+/** Build initial lens list: builtins (with overrides applied) + custom */
+function buildInitialLenses(): Lens[] {
+  const { custom, builtinOverrides } = loadSavedLenses();
+  const builtins = BUILTIN_LENSES.map(l =>
+    builtinOverrides.has(l.id) ? builtinOverrides.get(l.id)! : { ...l },
+  );
+  return [...builtins, ...custom];
+}
+
+export interface LensSlice {
+  // State
+  savedLenses: Lens[];
+  activeLensId: string | null;
+  lensPanelVisible: boolean;
+  /** Computed: globalId → hex color for entities matched by active lens */
+  lensColorMap: Map<number, string>;
+  /** Computed: globalIds to hide via lens rules */
+  lensHiddenIds: Set<number>;
+  /** Computed: ruleId → matched entity count for the active lens */
+  lensRuleCounts: Map<string, number>;
+  /** Computed: ruleId → matched entity global IDs for the active lens */
+  lensRuleEntityIds: Map<string, number[]>;
+
+  // Actions
+  createLens: (lens: Lens) => void;
+  updateLens: (id: string, patch: Partial<Lens>) => void;
+  deleteLens: (id: string) => void;
+  setActiveLens: (id: string | null) => void;
+  toggleLensPanel: () => void;
+  setLensPanelVisible: (visible: boolean) => void;
+  setLensColorMap: (map: Map<number, string>) => void;
+  setLensHiddenIds: (ids: Set<number>) => void;
+  setLensRuleCounts: (counts: Map<string, number>) => void;
+  setLensRuleEntityIds: (ids: Map<string, number[]>) => void;
+  /** Get the active lens configuration */
+  getActiveLens: () => Lens | null;
+  /** Import lenses from parsed JSON array */
+  importLenses: (lenses: Lens[]) => void;
+  /** Export all lenses (builtins + custom) as serializable array */
+  exportLenses: () => Lens[];
+}
+
+export const createLensSlice: StateCreator<LensSlice, [], [], LensSlice> = (set, get) => ({
+  // Initial state — builtins (with user overrides applied) + custom lenses
+  savedLenses: buildInitialLenses(),
+  activeLensId: null,
+  lensPanelVisible: false,
+  lensColorMap: new Map(),
+  lensHiddenIds: new Set(),
+  lensRuleCounts: new Map(),
+  lensRuleEntityIds: new Map(),
+
+  // Actions
+  createLens: (lens) => set((state) => {
+    const next = [...state.savedLenses, lens];
+    saveLenses(next);
+    return { savedLenses: next };
+  }),
+
+  updateLens: (id, patch) => set((state) => {
+    const next = state.savedLenses.map(l => l.id === id ? { ...l, ...patch } : l);
+    saveLenses(next);
+    return { savedLenses: next };
+  }),
+
+  deleteLens: (id) => set((state) => {
+    const lens = state.savedLenses.find(l => l.id === id);
+    if (lens?.builtin) return {};
+    const next = state.savedLenses.filter(l => l.id !== id);
+    saveLenses(next);
+    return {
+      savedLenses: next,
+      activeLensId: state.activeLensId === id ? null : state.activeLensId,
+    };
+  }),
+
+  setActiveLens: (activeLensId) => set({ activeLensId }),
+
+  toggleLensPanel: () => set((state) => ({ lensPanelVisible: !state.lensPanelVisible })),
+  setLensPanelVisible: (lensPanelVisible) => set({ lensPanelVisible }),
+
+  setLensColorMap: (lensColorMap) => set({ lensColorMap }),
+  setLensHiddenIds: (lensHiddenIds) => set({ lensHiddenIds }),
+  setLensRuleCounts: (lensRuleCounts) => set({ lensRuleCounts }),
+  setLensRuleEntityIds: (lensRuleEntityIds) => set({ lensRuleEntityIds }),
+
+  getActiveLens: () => {
+    const { savedLenses, activeLensId } = get();
+    return savedLenses.find(l => l.id === activeLensId) ?? null;
+  },
+
+  importLenses: (lenses) => set((state) => {
+    // Merge: skip duplicates by id, strip builtin flag from imports
+    const existingIds = new Set(state.savedLenses.map(l => l.id));
+    const newLenses = lenses
+      .filter(l => l.id && l.name && Array.isArray(l.rules) && !existingIds.has(l.id))
+      .map(l => ({ ...l, builtin: false }));
+    const next = [...state.savedLenses, ...newLenses];
+    saveLenses(next);
+    return { savedLenses: next };
+  }),
+
+  exportLenses: () => {
+    return get().savedLenses.map(({ id, name, rules }) => ({ id, name, rules }));
+  },
+});

package/src/store/slices/listSlice.ts

@@ -0,0 +1,74 @@
+/* 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/. */
+
+/**
+ * List state slice - configurable property tables from IFC data
+ */
+
+import type { StateCreator } from 'zustand';
+import type { ListDefinition, ListResult } from '@ifc-lite/lists';
+import { loadListDefinitions, saveListDefinitions } from '../../lib/lists/persistence.js';
+
+export interface ListSlice {
+  // State
+  listDefinitions: ListDefinition[];
+  activeListId: string | null;
+  listResult: ListResult | null;
+  listPanelVisible: boolean;
+  listExecuting: boolean;
+
+  // Actions
+  setListDefinitions: (definitions: ListDefinition[]) => void;
+  addListDefinition: (definition: ListDefinition) => void;
+  updateListDefinition: (id: string, updates: Partial<ListDefinition>) => void;
+  deleteListDefinition: (id: string) => void;
+  setActiveListId: (id: string | null) => void;
+  setListResult: (result: ListResult | null) => void;
+  setListPanelVisible: (visible: boolean) => void;
+  toggleListPanel: () => void;
+  setListExecuting: (executing: boolean) => void;
+}
+
+export const createListSlice: StateCreator<ListSlice, [], [], ListSlice> = (set, get) => ({
+  // Initial state - load saved definitions
+  listDefinitions: loadListDefinitions(),
+  activeListId: null,
+  listResult: null,
+  listPanelVisible: false,
+  listExecuting: false,
+
+  // Actions
+  setListDefinitions: (listDefinitions) => {
+    set({ listDefinitions });
+    saveListDefinitions(listDefinitions);
+  },
+
+  addListDefinition: (definition) => {
+    const updated = [...get().listDefinitions, definition];
+    set({ listDefinitions: updated });
+    saveListDefinitions(updated);
+  },
+
+  updateListDefinition: (id, updates) => {
+    const updated = get().listDefinitions.map(d =>
+      d.id === id ? { ...d, ...updates, updatedAt: Date.now() } : d
+    );
+    set({ listDefinitions: updated });
+    saveListDefinitions(updated);
+  },
+
+  deleteListDefinition: (id) => {
+    const updated = get().listDefinitions.filter(d => d.id !== id);
+    const activeListId = get().activeListId === id ? null : get().activeListId;
+    const listResult = get().activeListId === id ? null : get().listResult;
+    set({ listDefinitions: updated, activeListId, listResult });
+    saveListDefinitions(updated);
+  },
+
+  setActiveListId: (activeListId) => set({ activeListId }),
+  setListResult: (listResult) => set({ listResult }),
+  setListPanelVisible: (listPanelVisible) => set({ listPanelVisible }),
+  toggleListPanel: () => set((state) => ({ listPanelVisible: !state.listPanelVisible })),
+  setListExecuting: (listExecuting) => set({ listExecuting }),
+});

package/src/store/slices/pinboardSlice.ts

@@ -0,0 +1,114 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Pinboard state slice
+ *
+ * Persistent selection basket for tracking components across sessions.
+ * Users can pin entities, then isolate/show the pinned set.
+ */
+
+import type { StateCreator } from 'zustand';
+import type { EntityRef } from '../types.js';
+import { entityRefToString, stringToEntityRef } from '../types.js';
+
+/** Minimal interface for accessing isolation + models from the combined store */
+interface CombinedStoreAccess {
+  isolateEntities?: (ids: number[]) => void;
+  models?: Map<string, { idOffset: number }>;
+}
+
+export interface PinboardSlice {
+  // State
+  /** Serialized EntityRef strings for O(1) membership check */
+  pinboardEntities: Set<string>;
+
+  // Actions
+  /** Add entities to pinboard */
+  addToPinboard: (refs: EntityRef[]) => void;
+  /** Remove entities from pinboard */
+  removeFromPinboard: (refs: EntityRef[]) => void;
+  /** Replace pinboard contents */
+  setPinboard: (refs: EntityRef[]) => void;
+  /** Clear pinboard */
+  clearPinboard: () => void;
+  /** Isolate pinboard entities (show only pinned) */
+  showPinboard: () => void;
+  /** Check if entity is pinned */
+  isInPinboard: (ref: EntityRef) => boolean;
+  /** Get pinboard count */
+  getPinboardCount: () => number;
+  /** Get all pinboard entities as EntityRef array */
+  getPinboardEntities: () => EntityRef[];
+}
+
+export const createPinboardSlice: StateCreator<PinboardSlice, [], [], PinboardSlice> = (set, get) => ({
+  // Initial state
+  pinboardEntities: new Set(),
+
+  // Actions
+  addToPinboard: (refs) => {
+    set((state) => {
+      const next = new Set(state.pinboardEntities);
+      for (const ref of refs) {
+        next.add(entityRefToString(ref));
+      }
+      return { pinboardEntities: next };
+    });
+  },
+
+  removeFromPinboard: (refs) => {
+    set((state) => {
+      const next = new Set(state.pinboardEntities);
+      for (const ref of refs) {
+        next.delete(entityRefToString(ref));
+      }
+      return { pinboardEntities: next };
+    });
+  },
+
+  setPinboard: (refs) => {
+    const next = new Set<string>();
+    for (const ref of refs) {
+      next.add(entityRefToString(ref));
+    }
+    set({ pinboardEntities: next });
+  },
+
+  clearPinboard: () => set({ pinboardEntities: new Set() }),
+
+  showPinboard: () => {
+    const entities = get().getPinboardEntities();
+    if (entities.length === 0) return;
+
+    // Access combined store methods via typed interface
+    const store = get() as unknown as CombinedStoreAccess;
+    if (!store.isolateEntities) return;
+
+    // Convert EntityRef to global IDs for isolation
+    const globalIds: number[] = [];
+    for (const ref of entities) {
+      if (store.models) {
+        const model = store.models.get(ref.modelId);
+        const offset = model?.idOffset ?? 0;
+        globalIds.push(ref.expressId + offset);
+      } else {
+        globalIds.push(ref.expressId);
+      }
+    }
+    store.isolateEntities(globalIds);
+  },
+
+  isInPinboard: (ref) => get().pinboardEntities.has(entityRefToString(ref)),
+
+  getPinboardCount: () => get().pinboardEntities.size,
+
+  getPinboardEntities: () => {
+    const result: EntityRef[] = [];
+    for (const str of get().pinboardEntities) {
+      result.push(stringToEntityRef(str));
+    }
+    return result;
+  },
+});

package/src/store/types.ts

@@ -149,6 +149,8 @@ export interface CameraRotation {
   elevation: number;
 }
 
+export type ProjectionMode = 'perspective' | 'orthographic';
+
 export interface CameraCallbacks {
   setPresetView?: (view: 'top' | 'bottom' | 'front' | 'back' | 'left' | 'right') => void;
   fitAll?: () => void;
@@ -158,6 +160,9 @@ export interface CameraCallbacks {
   frameSelection?: () => void;
   orbit?: (deltaX: number, deltaY: number) => void;
   projectToScreen?: (worldPos: { x: number; y: number; z: number }) => { x: number; y: number } | null;
+  setProjectionMode?: (mode: ProjectionMode) => void;
+  toggleProjectionMode?: () => void;
+  getProjectionMode?: () => ProjectionMode;
 }
 
 // ============================================================================

package/src/utils/ifcConfig.ts

@@ -13,11 +13,24 @@ import type { DynamicBatchConfig } from '@ifc-lite/geometry';
 // Server Configuration
 // ============================================================================
 
-/** IFC server URL - only set via environment variable, no default (pure client-side by default) */
+/** IFC server URL - set via environment variable for server-side IFC processing */
 export const SERVER_URL = import.meta.env.VITE_IFC_SERVER_URL || import.meta.env.VITE_SERVER_URL || '';
 
-/** Enable server parsing - only if server URL is explicitly configured */
-export const USE_SERVER = SERVER_URL !== '' && import.meta.env.VITE_USE_SERVER !== 'false';
+/**
+ * Enable server-side IFC parsing (disabled by default — uses client-side WASM).
+ *
+ * The server URL may be present for other features (e.g. superset integration)
+ * without intending to route normal IFC loading through it.
+ *
+ * To enable server-side IFC processing for development:
+ *   1. Set VITE_IFC_SERVER_URL (or VITE_SERVER_URL) to the server endpoint
+ *   2. Set VITE_USE_SERVER=true
+ *
+ * Example .env:
+ *   VITE_IFC_SERVER_URL=https://ifc-server.example.com
+ *   VITE_USE_SERVER=true
+ */
+export const USE_SERVER = SERVER_URL !== '' && import.meta.env.VITE_USE_SERVER === 'true';
 
 // ============================================================================
 // File Size Thresholds (in bytes unless noted)