@ifc-lite/viewer 1.17.3 → 1.17.6

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/constants.ts

@@ -30,6 +30,24 @@ export const SECTION_PLANE_DEFAULTS = {
   ENABLED: true,
   /** Default flipped state */
   FLIPPED: false,
+  /** Default: render filled/hatched cap surfaces at the cut */
+  SHOW_CAP: true,
+  /** Default: draw polygon outlines on the cut surfaces */
+  SHOW_OUTLINES: true,
+} as const;
+
+/**
+ * Default cut-surface appearance. RGBA tuples are 0-1 per channel. Screen-space
+ * hatch settings are in pixels so the hatch stays readable at any zoom level.
+ */
+export const SECTION_CAP_DEFAULTS = {
+  FILL_COLOR:   [0.92, 0.88, 0.78, 1.0] as [number, number, number, number], // warm paper
+  STROKE_COLOR: [0.10, 0.10, 0.10, 1.0] as [number, number, number, number], // ink
+  PATTERN:      'diagonal' as const,
+  SPACING_PX:   8,
+  ANGLE_RAD:    Math.PI / 4,
+  WIDTH_PX:     1.0,
+  SECONDARY_ANGLE_RAD: -Math.PI / 4,
 } as const;
 
 // ============================================================================
@@ -52,10 +70,10 @@ export const EDGE_LOCK_DEFAULTS = {
 // ============================================================================
 
 /** Resolve the initial theme: localStorage override > system preference > dark fallback */
-function getInitialTheme(): 'light' | 'dark' {
+function getInitialTheme(): 'light' | 'dark' | 'colorful' {
   if (typeof window === 'undefined') return 'dark';
   const saved = localStorage.getItem('ifc-lite-theme');
-  if (saved === 'light' || saved === 'dark') return saved;
+  if (saved === 'light' || saved === 'dark' || saved === 'colorful') return saved;
   return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
 }
 

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
@@ -41,7 +43,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, OrthogonalAxis } from './types.js';
+export type { EntityRef, SchemaVersion, FederatedModel, MeasurementConstraintEdge, OrthogonalAxis, SectionCapStyle, SectionCapHatchId, SectionPlane, SectionPlaneAxis } from './types.js';
 
 // Re-export utility functions for entity references
 export { entityRefToString, stringToEntityRef, entityRefEquals, isIfcxDataStore } from './types.js';
@@ -76,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 &
@@ -97,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),
@@ -126,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
@@ -157,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,
 
@@ -178,12 +195,18 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
         cornerValence: 0,
       },
 
-      // Section plane
+      // Section plane: reset axis/position/enabled/flipped (those are
+      // model-relative and meaningless when switching files), but PRESERVE
+      // the user's cap appearance preferences (showCap, showOutlines,
+      // capStyle). Those round-trip to localStorage via the slice's
+      // persistence helpers; clobbering them here was the cause of "my
+      // hatch / colour resets to defaults every time I open a file".
       sectionPlane: {
-        axis: SECTION_PLANE_DEFAULTS.AXIS,
+        ...get().sectionPlane,
+        axis:     SECTION_PLANE_DEFAULTS.AXIS,
         position: SECTION_PLANE_DEFAULTS.POSITION,
-        enabled: SECTION_PLANE_DEFAULTS.ENABLED,
-        flipped: SECTION_PLANE_DEFAULTS.FLIPPED,
+        enabled:  SECTION_PLANE_DEFAULTS.ENABLED,
+        flipped:  SECTION_PLANE_DEFAULTS.FLIPPED,
       },
 
       // Camera
@@ -206,6 +229,15 @@ export const useViewerStore = create<ViewerState>()((...args) => ({
       separationLinesIntensity: UI_DEFAULTS.SEPARATION_LINES_INTENSITY,
       separationLinesRadius: UI_DEFAULTS.SEPARATION_LINES_RADIUS,
 
+      // Cesium
+      cesiumAvailable: false,
+      cesiumEnabled: false,
+      cesiumTerrainHeight: null,
+      cesiumTerrainClamp: false,
+      cesiumSourceModelId: null,
+      cesiumTerrainClipY: null,
+      cesiumGlbLoaded: false,
+
       // Drawing 2D
       drawing2D: null,
       drawing2DStatus: 'idle' as const,
@@ -317,3 +349,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,127 @@
+/* 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
+  /** Whether a loaded model (or user mutations) provide enough georeferencing to place in Cesium. */
+  cesiumAvailable: boolean;
+  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
+  setCesiumAvailable: (available: boolean) => void;
+  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) => ({
+  cesiumAvailable: false,
+  cesiumEnabled: false,
+  cesiumDataSource: loadDataSource(),
+  cesiumIonToken: resolveIonToken(),
+  cesiumTerrainEnabled: true,
+  cesiumTerrainClamp: false,
+  cesiumTerrainHeight: null,
+  cesiumSourceModelId: null,
+  cesiumTerrainClipY: null,
+  cesiumGlbLoaded: false,
+
+  setCesiumAvailable: (available) => set({ cesiumAvailable: available }),
+  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.test.ts

@@ -8,7 +8,7 @@ import { buildErrorFeedbackContent } from './chatSlice.js';
 import { create } from 'zustand';
 import { createChatSlice, type ChatSlice } from './chatSlice.js';
 import { createPatchDiagnostic, createPreflightDiagnostic } from '../../lib/llm/script-diagnostics.js';
-import { DEFAULT_FREE_MODEL, DEFAULT_PRO_MODEL } from '../../lib/llm/models.js';
+import { DEFAULT_FREE_MODEL, DEFAULT_BYOK_MODEL } from '../../lib/llm/models.js';
 
 function withMockLocalStorage(fn: () => void) {
   const original = globalThis.localStorage;
@@ -217,52 +217,14 @@ test('clearChatMessages resets streaming state as well as persisted messages', (
   assert.deepEqual(useChatStore.getState().chatAttachments, []);
 });
 
-test('switchChatUserContext restores per-user history and coerces disallowed models', () => {
-  withMockLocalStorage(() => {
-    globalThis.localStorage.setItem('ifc-lite-chat-model:user-a', DEFAULT_PRO_MODEL.id);
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-a', JSON.stringify([
-      {
-        id: 'persisted-a',
-        role: 'user',
-        content: 'hello from A',
-        createdAt: 1,
-      },
-    ]));
-    globalThis.localStorage.setItem('ifc-lite-chat-model:user-b', DEFAULT_FREE_MODEL.id);
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-b', JSON.stringify([
-      {
-        id: 'persisted-b',
-        role: 'assistant',
-        content: 'hello from B',
-        createdAt: 2,
-      },
-    ]));
-
-    const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-    useChatStore.getState().switchChatUserContext('user-a', true, { restoreMessages: true });
-
-    assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_PRO_MODEL.id);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'persisted-a');
-
-    useChatStore.getState().switchChatUserContext('user-b', false, {
-      clearPersistedCurrent: true,
-      restoreMessages: true,
-    });
-
-    assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_FREE_MODEL.id);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'persisted-b');
-    assert.equal(globalThis.localStorage.getItem('ifc-lite-chat-messages:user-a'), null);
-  });
-});
-
-test('setChatHasPro falls back to a free model when entitlement is removed', () => {
+test('setChatHasByokKey falls back to a free model when keys are removed', () => {
   const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-  useChatStore.getState().setChatHasPro(true);
-  useChatStore.getState().setChatActiveModel(DEFAULT_PRO_MODEL.id);
+  useChatStore.getState().setChatHasByokKey(true);
+  useChatStore.getState().setChatActiveModel(DEFAULT_BYOK_MODEL.id);
 
-  useChatStore.getState().setChatHasPro(false);
+  useChatStore.getState().setChatHasByokKey(false);
 
-  assert.equal(useChatStore.getState().chatHasPro, false);
+  assert.equal(useChatStore.getState().chatHasByokKey, false);
   assert.equal(useChatStore.getState().chatActiveModel, DEFAULT_FREE_MODEL.id);
 });
 
@@ -291,35 +253,3 @@ test('removeChatAttachment only removes the targeted attachment id', () => {
   );
 });
 
-test('switchChatUserContext ignores malformed persisted messages', () => {
-  withMockLocalStorage(() => {
-    globalThis.localStorage.setItem('ifc-lite-chat-messages:user-a', JSON.stringify([
-      {
-        id: 'valid',
-        role: 'user',
-        content: 'hello',
-        createdAt: 1,
-        attachments: [
-          { id: 'att-1', name: 'ok.csv', type: 'text/csv', size: 20, textContent: 'a,b\n1,2' },
-          { name: 'missing-id.csv', type: 'text/csv', size: 20 },
-        ],
-      },
-      {
-        id: 123,
-        role: 'assistant',
-        content: 'bad',
-        createdAt: 2,
-      },
-    ]));
-
-    const useChatStore = create<ChatSlice>()((...args) => createChatSlice(...args));
-    useChatStore.getState().switchChatUserContext('user-a', false, { restoreMessages: true });
-
-    assert.equal(useChatStore.getState().chatMessages.length, 1);
-    assert.equal(useChatStore.getState().chatMessages[0]?.id, 'valid');
-    assert.deepEqual(
-      useChatStore.getState().chatMessages[0]?.attachments?.map((attachment) => attachment.id),
-      ['att-1'],
-    );
-  });
-});