@ifc-lite/viewer 1.17.2 → 1.17.4

package/src/services/desktop-preferences.ts

@@ -0,0 +1,44 @@
+/* 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/. */
+
+export interface DesktopPreferences {
+  reopenLastModelOnLaunch: boolean;
+  restoreWorkspaceLayoutOnLaunch: boolean;
+}
+
+const STORAGE_KEY = 'ifc-lite:desktop-preferences:v1';
+const CHANGED_EVENT = 'ifc-lite:desktop-preferences-changed';
+
+const DEFAULT_PREFERENCES: DesktopPreferences = {
+  reopenLastModelOnLaunch: true,
+  restoreWorkspaceLayoutOnLaunch: true,
+};
+
+function sanitizePreferences(value: unknown): DesktopPreferences {
+  const parsed = (value && typeof value === 'object') ? value as Partial<DesktopPreferences> : {};
+  return {
+    reopenLastModelOnLaunch: parsed.reopenLastModelOnLaunch ?? DEFAULT_PREFERENCES.reopenLastModelOnLaunch,
+    restoreWorkspaceLayoutOnLaunch: parsed.restoreWorkspaceLayoutOnLaunch ?? DEFAULT_PREFERENCES.restoreWorkspaceLayoutOnLaunch,
+  };
+}
+
+export function getDesktopPreferences(): DesktopPreferences {
+  try {
+    return sanitizePreferences(JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}'));
+  } catch {
+    return { ...DEFAULT_PREFERENCES };
+  }
+}
+
+export function updateDesktopPreferences(updates: Partial<DesktopPreferences>): DesktopPreferences {
+  const next = { ...getDesktopPreferences(), ...updates };
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  window.dispatchEvent(new Event(CHANGED_EVENT));
+  return next;
+}
+
+export function subscribeDesktopPreferences(listener: () => void): () => void {
+  window.addEventListener(CHANGED_EVENT, listener);
+  return () => window.removeEventListener(CHANGED_EVENT, listener);
+}

package/src/services/file-dialog.ts

@@ -0,0 +1,147 @@
+/* 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/. */
+
+type InvokeFn = <T>(cmd: string, args?: Record<string, unknown>) => Promise<T>;
+
+export interface NativeFileHandle {
+  path: string;
+  name: string;
+  size: number;
+  modifiedMs?: number | null;
+}
+
+export interface GenericFileDialogOptions {
+  title?: string;
+  filters?: Array<{ name: string; extensions: string[] }>;
+}
+
+async function loadInvokeFromTauriModule(): Promise<InvokeFn | null> {
+  try {
+    const core = await import('@tauri-apps/api/core');
+    return typeof core.invoke === 'function' ? core.invoke as InvokeFn : null;
+  } catch {
+    return null;
+  }
+}
+
+async function loadDialogModule(): Promise<{
+  open: (options?: {
+    multiple?: boolean;
+    directory?: boolean;
+    filters?: Array<{ name: string; extensions: string[] }>;
+    title?: string;
+  }) => Promise<string | string[] | null>;
+} | null> {
+  try {
+    return await import('@tauri-apps/plugin-dialog');
+  } catch {
+    return null;
+  }
+}
+
+async function loadFsModule(): Promise<{
+  stat: (path: string) => Promise<{ size: number }>;
+} | null> {
+  try {
+    return await import('@tauri-apps/plugin-fs');
+  } catch {
+    return null;
+  }
+}
+
+async function getInvoke(): Promise<InvokeFn> {
+  const win = globalThis as unknown as { __TAURI_INTERNALS__?: { invoke: InvokeFn } };
+  if (win.__TAURI_INTERNALS__?.invoke) {
+    return win.__TAURI_INTERNALS__.invoke;
+  }
+  const moduleInvoke = await loadInvokeFromTauriModule();
+  if (moduleInvoke) {
+    return moduleInvoke;
+  }
+  throw new Error('Tauri API not available');
+}
+
+export async function openIfcFileDialog(): Promise<NativeFileHandle | null> {
+  try {
+    const invoke = await getInvoke();
+    return await invoke<NativeFileHandle | null>('open_ifc_file');
+  } catch {
+    // Expected in browser builds — fall through to plugin fallback, then browser file input.
+  }
+
+  try {
+    const dialog = await loadDialogModule();
+    const fs = await loadFsModule();
+    if (!dialog || !fs) {
+      return null;
+    }
+
+    const selected = await dialog.open({
+      multiple: false,
+      directory: false,
+      title: 'Open IFC File',
+      filters: [
+        { name: 'IFC Files', extensions: ['ifc', 'ifczip', 'ifcxml'] },
+        { name: 'All Files', extensions: ['*'] },
+      ],
+    });
+    if (!selected || Array.isArray(selected)) {
+      return null;
+    }
+
+    const metadata = await fs.stat(selected);
+    const normalizedPath = selected.toString();
+    const pathSegments = normalizedPath.split(/[\\/]/);
+    const name = pathSegments[pathSegments.length - 1] || 'unknown.ifc';
+
+    return {
+      path: normalizedPath,
+      name,
+      size: metadata.size,
+    };
+  } catch {
+    // No Tauri plugin available — caller falls back to browser <input type="file">.
+    return null;
+  }
+}
+
+export async function readNativeFile(path: string): Promise<Uint8Array> {
+  try {
+    const invoke = await getInvoke();
+    const bytes = await invoke<number[]>('read_native_file', { path });
+    return Uint8Array.from(bytes);
+  } catch (error) {
+    console.warn('[FileDialog] Falling back to plugin-fs read for native file:', error);
+    const fs = await import('@tauri-apps/plugin-fs');
+    return fs.readFile(path);
+  }
+}
+
+export async function openGenericFileDialog(options: GenericFileDialogOptions = {}): Promise<File | null> {
+  try {
+    const dialog = await loadDialogModule();
+    if (!dialog) {
+      return null;
+    }
+
+    const selected = await dialog.open({
+      multiple: false,
+      directory: false,
+      title: options.title,
+      filters: options.filters,
+    });
+    if (!selected || Array.isArray(selected)) {
+      return null;
+    }
+
+    const normalizedPath = selected.toString();
+    const bytes = await readNativeFile(normalizedPath);
+    const pathSegments = normalizedPath.split(/[\\/]/);
+    const name = pathSegments[pathSegments.length - 1] || 'document';
+    return new File([bytes], name, { type: 'application/octet-stream' });
+  } catch (error) {
+    console.warn('[FileDialog] Failed to open generic native file dialog:', error);
+    return null;
+  }
+}

package/src/services/tauri-core-stub.ts

@@ -0,0 +1,7 @@
+/* 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/. */
+
+export async function invoke(): Promise<never> {
+  throw new Error('Tauri core API is unavailable in the browser build');
+}

package/src/services/tauri-dialog-stub.ts

@@ -0,0 +1,7 @@
+/* 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/. */
+
+export async function open(): Promise<null> {
+  return null;
+}

package/src/services/tauri-fs-stub.ts

@@ -0,0 +1,7 @@
+/* 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/. */
+
+export async function readFile(_path: string): Promise<Uint8Array> {
+  throw new Error('Tauri file system API is unavailable in the browser benchmark build');
+}

package/src/store/basketVisibleSet.ts

@@ -14,6 +14,7 @@ import type { IfcDataStore } from '@ifc-lite/parser';
 import type { EntityRef } from './types.js';
 import { entityRefToString, stringToEntityRef } from './types.js';
 import { useViewerStore } from './index.js';
+import { toGlobalIdFromModels } from './globalId.js';
 
 type ViewerStateSnapshot = ReturnType<typeof useViewerStore.getState>;
 
@@ -159,9 +160,7 @@ function expandRefToElements(state: ViewerStateSnapshot, ref: EntityRef): Entity
 }
 
 function toGlobalId(modelId: string, expressId: number, state: ViewerStateSnapshot): number {
-  if (modelId === 'legacy') return expressId;
-  const model = state.models.get(modelId);
-  return expressId + (model?.idOffset ?? 0);
+  return toGlobalIdFromModels(state.models, modelId, expressId);
 }
 
 function globalIdToRef(state: ViewerStateSnapshot, globalId: number): EntityRef | null {
@@ -318,7 +317,7 @@ function computeStoreyIsolation(state: ViewerStateSnapshot): Set<number> | null
         const storeyElementIds = collectIfcBuildingStoreyElementsWithIfcSpace(hierarchy, localStoreyId);
         if (!storeyElementIds) continue;
         for (const localId of storeyElementIds) {
-          ids.add(localId + offset);
+          ids.add(toGlobalIdFromModels(state.models, model.id, localId));
         }
       }
     }

package/src/store/globalId.ts

@@ -0,0 +1,79 @@
+/* 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, FederatedModel } from './types.js';
+
+type ForwardModelMapLike = ReadonlyMap<string, { idOffset?: number }>;
+type ReverseModelMapLike = ReadonlyMap<string, Pick<FederatedModel, 'idOffset' | 'maxExpressId'>>;
+
+/**
+ * Convert a local expressId to the renderer/global ID space.
+ *
+ * This is the viewer-level single source of truth for modelId + expressId →
+ * globalId conversion outside Zustand hooks. It preserves single-model legacy
+ * behavior by falling back to the original expressId when no federated model
+ * entry exists.
+ */
+export function toGlobalIdFromModels(
+  models: ForwardModelMapLike,
+  modelId: string,
+  expressId: number,
+): number {
+  if (modelId === 'legacy' || modelId === 'default' || modelId === '__legacy__') {
+    return expressId;
+  }
+
+  const model = models.get(modelId);
+  if (!model) {
+    return expressId;
+  }
+
+  return expressId + (model.idOffset ?? 0);
+}
+
+/**
+ * Resolve a renderer/global ID back to the source model and local expressId.
+ *
+ * This mirrors toGlobalIdFromModels and preserves legacy single-model behavior.
+ */
+export function fromGlobalIdFromModels(
+  models: ReverseModelMapLike,
+  globalId: number,
+): EntityRef | undefined {
+  if (models.size <= 1) {
+    const firstModelId = models.keys().next().value;
+    if (firstModelId) {
+      return {
+        modelId: firstModelId,
+        expressId: globalId,
+      };
+    }
+    return {
+      modelId: 'legacy',
+      expressId: globalId,
+    };
+  }
+
+  for (const [modelId, model] of models.entries()) {
+    const localExpressId = globalId - model.idOffset;
+    if (localExpressId > 0 && localExpressId <= model.maxExpressId) {
+      return {
+        modelId,
+        expressId: localExpressId,
+      };
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Convert an EntityRef to the renderer/global ID space.
+ */
+export function toGlobalIdForRef(
+  models: ForwardModelMapLike,
+  ref: EntityRef,
+): number {
+  return toGlobalIdFromModels(models, ref.modelId, ref.expressId);
+}

package/src/store/index.ts

@@ -32,6 +32,8 @@ import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.
 import { createLensSlice, type LensSlice } from './slices/lensSlice.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';
+import { createDesktopEntitlementSlice, type DesktopEntitlementSlice } from './slices/desktopEntitlementSlice.js';
 import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
 // Import constants for reset function
@@ -48,6 +50,7 @@ export { entityRefToString, stringToEntityRef, entityRefEquals, isIfcxDataStore
 
 // Re-export single source of truth for globalId → EntityRef resolution
 export { resolveEntityRef } from './resolveEntityRef.js';
+export { fromGlobalIdFromModels, toGlobalIdFromModels, toGlobalIdForRef } from './globalId.js';
 
 // Re-export Drawing2D types
 export type { Drawing2DState, Drawing2DStatus, Annotation2DTool, PolygonArea2DResult, TextAnnotation2D, CloudAnnotation2D, SelectedAnnotation2D } from './slices/drawing2DSlice.js';
@@ -75,6 +78,10 @@ export type { ScriptSlice } from './slices/scriptSlice.js';
 
 // Re-export Chat types
 export type { ChatSlice } from './slices/chatSlice.js';
+export type { DesktopEntitlementSlice } from './slices/desktopEntitlementSlice.js';
+
+// Re-export Cesium types
+export type { CesiumSlice, CesiumDataSource } from './slices/cesiumSlice.js';
 
 // Combined store type
 export type ViewerState = LoadingSlice &
@@ -96,14 +103,16 @@ export type ViewerState = LoadingSlice &
   PinboardSlice &
   LensSlice &
   ScriptSlice &
-  ChatSlice & {
+  ChatSlice &
+  CesiumSlice &
+  DesktopEntitlementSlice & {
     resetViewerState: () => void;
   };
 
 /**
  * Main viewer store combining all slices
  */
-export const useViewerStore = create<ViewerState>()((...args) => ({
+const createViewerStore = () => create<ViewerState>()((...args) => ({
   // Spread all slices
   ...createLoadingSlice(...args),
   ...createSelectionSlice(...args),
@@ -125,6 +134,8 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
   ...createLensSlice(...args),
   ...createScriptSlice(...args),
   ...createChatSlice(...args),
+  ...createCesiumSlice(...args),
+  ...createDesktopEntitlementSlice(...args),
 
   // Reset all viewer state when loading new file
   // Note: Does NOT clear models - use clearAllModels() for that
@@ -156,6 +167,13 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       isolatedEntitiesByModel: new Map(),
 
       // Data
+      loading: false,
+      geometryStreamingActive: false,
+      geometryUpdateTick: 0,
+      progress: null,
+      geometryProgress: null,
+      metadataProgress: null,
+      error: null,
       pendingColorUpdates: null,
       pendingMeshColorUpdates: null,
 
@@ -205,6 +223,14 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       separationLinesIntensity: UI_DEFAULTS.SEPARATION_LINES_INTENSITY,
       separationLinesRadius: UI_DEFAULTS.SEPARATION_LINES_RADIUS,
 
+      // Cesium
+      cesiumEnabled: false,
+      cesiumTerrainHeight: null,
+      cesiumTerrainClamp: false,
+      cesiumSourceModelId: null,
+      cesiumTerrainClipY: null,
+      cesiumGlbLoaded: false,
+
       // Drawing 2D
       drawing2D: null,
       drawing2DStatus: 'idle' as const,
@@ -316,3 +342,16 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
     });
   },
 }));
+
+const STORE_SINGLETON_KEY = '__ifc_lite_viewer_store__';
+const globalStoreRegistry = globalThis as typeof globalThis & {
+  [STORE_SINGLETON_KEY]?: ReturnType<typeof createViewerStore>;
+};
+
+export function getViewerStoreApi() {
+  return globalStoreRegistry[STORE_SINGLETON_KEY] ?? (
+    globalStoreRegistry[STORE_SINGLETON_KEY] = createViewerStore()
+  );
+}
+
+export const useViewerStore = getViewerStoreApi();

package/src/store/slices/cesiumSlice.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/. */
+
+/**
+ * Cesium 3D Tiles overlay state slice.
+ *
+ * Manages the enabled/disabled state, selected data source, and Cesium ion
+ * access token for the optional real-world 3D context overlay.
+ *
+ * Token resolution:
+ *   1. User-provided override in localStorage
+ *   2. Build-time default token via VITE_CESIUM_ION_TOKEN env var
+ *   → Users never need to configure anything; the app ships with a working token.
+ */
+
+import type { StateCreator } from 'zustand';
+
+export type CesiumDataSource =
+  | 'osm-buildings'        // Cesium OSM Buildings (free via Cesium ion)
+  | 'bing-aerial'          // Bing Maps aerial imagery draped on terrain
+  | 'google-photorealistic'; // Google Photorealistic 3D Tiles (requires API key)
+
+export interface CesiumSlice {
+  // State
+  cesiumEnabled: boolean;
+  cesiumDataSource: CesiumDataSource;
+  /** Resolved Cesium ion access token (user override or build-time default). */
+  cesiumIonToken: string;
+  /** Terrain enabled (Cesium World Terrain). */
+  cesiumTerrainEnabled: boolean;
+  /** Clamp model to terrain height at its geodetic position. */
+  cesiumTerrainClamp: boolean;
+  /** Terrain height at model position (queried from Cesium, meters). null = not yet queried. */
+  cesiumTerrainHeight: number | null;
+  /** Model ID that the Cesium overlay is currently displaying. */
+  cesiumSourceModelId: string | null;
+  /** Terrain clip Y position in viewer space. When set, fragments below this Y are discarded. */
+  cesiumTerrainClipY: number | null;
+  /** Whether the GLB model has been loaded into Cesium (hides WebGPU overlay). */
+  cesiumGlbLoaded: boolean;
+
+  // Actions
+  setCesiumEnabled: (enabled: boolean) => void;
+  toggleCesium: () => void;
+  setCesiumDataSource: (source: CesiumDataSource) => void;
+  setCesiumIonToken: (token: string) => void;
+  setCesiumTerrainEnabled: (enabled: boolean) => void;
+  setCesiumTerrainClamp: (clamp: boolean) => void;
+  setCesiumTerrainHeight: (height: number | null) => void;
+  setCesiumSourceModelId: (modelId: string | null) => void;
+  setCesiumTerrainClipY: (y: number | null) => void;
+  setCesiumGlbLoaded: (loaded: boolean) => void;
+}
+
+const STORAGE_KEY_ION_TOKEN = 'ifc-lite:cesium-ion-token';
+const STORAGE_KEY_DATA_SOURCE = 'ifc-lite:cesium-data-source';
+
+/**
+ * Default Cesium ion token provided at build time.
+ * Set via VITE_CESIUM_ION_TOKEN in .env or CI environment.
+ * This means users never need to configure a token manually.
+ */
+const DEFAULT_ION_TOKEN: string = (import.meta as any).env?.VITE_CESIUM_ION_TOKEN ?? '';
+
+function loadFromStorage(key: string, fallback: string): string {
+  try {
+    return localStorage.getItem(key) ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function saveToStorage(key: string, value: string): void {
+  try {
+    localStorage.setItem(key, value);
+  } catch { /* storage unavailable */ }
+}
+
+const VALID_DATA_SOURCES = new Set<CesiumDataSource>(['osm-buildings', 'bing-aerial', 'google-photorealistic']);
+
+function loadDataSource(): CesiumDataSource {
+  const stored = loadFromStorage(STORAGE_KEY_DATA_SOURCE, '');
+  return VALID_DATA_SOURCES.has(stored as CesiumDataSource)
+    ? (stored as CesiumDataSource)
+    : 'google-photorealistic';
+}
+
+/** Resolve the Cesium ion token: user override > build-time default */
+function resolveIonToken(): string {
+  const userToken = loadFromStorage(STORAGE_KEY_ION_TOKEN, '');
+  return userToken || DEFAULT_ION_TOKEN;
+}
+
+export const createCesiumSlice: StateCreator<CesiumSlice, [], [], CesiumSlice> = (set) => ({
+  cesiumEnabled: false,
+  cesiumDataSource: loadDataSource(),
+  cesiumIonToken: resolveIonToken(),
+  cesiumTerrainEnabled: true,
+  cesiumTerrainClamp: false,
+  cesiumTerrainHeight: null,
+  cesiumSourceModelId: null,
+  cesiumTerrainClipY: null,
+  cesiumGlbLoaded: false,
+
+  setCesiumEnabled: (enabled) => set({ cesiumEnabled: enabled }),
+  toggleCesium: () => set((s) => ({ cesiumEnabled: !s.cesiumEnabled })),
+  setCesiumDataSource: (source) => {
+    saveToStorage(STORAGE_KEY_DATA_SOURCE, source);
+    set({ cesiumDataSource: source });
+  },
+  setCesiumIonToken: (token) => {
+    saveToStorage(STORAGE_KEY_ION_TOKEN, token);
+    set({ cesiumIonToken: token || DEFAULT_ION_TOKEN });
+  },
+  setCesiumTerrainEnabled: (enabled) => set({ cesiumTerrainEnabled: enabled }),
+  setCesiumTerrainClamp: (clamp) => set({ cesiumTerrainClamp: clamp }),
+  setCesiumTerrainHeight: (height) => set({ cesiumTerrainHeight: height }),
+  setCesiumSourceModelId: (modelId) => set({ cesiumSourceModelId: modelId }),
+  setCesiumTerrainClipY: (y) => set({ cesiumTerrainClipY: y }),
+  setCesiumGlbLoaded: (loaded) => set({ cesiumGlbLoaded: loaded }),
+});

package/src/store/slices/chatSlice.ts

@@ -177,6 +177,10 @@ function loadStoredModel(userId: string | null, fallback?: string): string {
   }
 }
 
+function loadValidStoredModel(userId: string | null, hasPro: boolean, fallback?: string): string {
+  return coerceModelForEntitlement(loadStoredModel(userId, fallback), hasPro);
+}
+
 function loadStoredAutoExecute(): boolean {
   try {
     const val = localStorage.getItem(AUTO_EXEC_STORAGE_KEY);
@@ -275,7 +279,7 @@ export const createChatSlice: StateCreator<ChatSlice, [], [], ChatSlice> = (set,
   chatMessages: loadStoredMessages(null),
   chatStatus: 'idle',
   chatStreamingContent: '',
-  chatActiveModel: loadStoredModel(null),
+  chatActiveModel: loadValidStoredModel(null, false),
   chatAutoExecute: loadStoredAutoExecute(),
   chatError: null,
   chatAbortController: null,