@ifc-lite/viewer 1.17.2 → 1.17.4

package/src/services/bsdd.ts

@@ -99,6 +99,40 @@ async function fetchJson<T>(url: string): Promise<T> {
   return res.json() as Promise<T>;
 }
 
+interface BsddSearchApiResult {
+  uri?: string;
+  code?: string;
+  referenceCode?: string;
+  name?: string;
+  definition?: string | null;
+  dictionaryUri?: string;
+}
+
+function matchesIfcType(candidate: BsddSearchApiResult, ifcType: string): boolean {
+  return candidate.code === ifcType
+    || candidate.referenceCode === ifcType
+    || candidate.name === ifcType;
+}
+
+async function resolveFallbackClassUri(ifcType: string): Promise<string | null> {
+  try {
+    const raw = await fetchJson<{ classes?: BsddSearchApiResult[] }>(
+      `${BSDD_API}/api/Class/Search/v1?SearchText=${encodeURIComponent(ifcType)}&RelatedIfcEntities=${encodeURIComponent(ifcType)}`,
+    );
+    const classes = raw.classes ?? [];
+    if (classes.length === 0) return null;
+
+    const preferred = classes.find((entry) => entry.dictionaryUri === IFC_DICTIONARY_URI && matchesIfcType(entry, ifcType))
+      ?? classes.find((entry) => matchesIfcType(entry, ifcType))
+      ?? classes.find((entry) => entry.dictionaryUri === IFC_DICTIONARY_URI)
+      ?? classes[0];
+
+    return preferred?.uri ?? null;
+  } catch {
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -128,15 +162,30 @@ export function ifcClassUri(ifcType: string): string {
 export async function fetchClassInfo(
   ifcType: string,
 ): Promise<BsddClassInfo | null> {
-  const uri = ifcClassUri(ifcType);
+  const defaultUri = ifcClassUri(ifcType);
+  let uri = defaultUri;
   const cached = getCached(uri);
   if (cached) return cached;
 
   try {
     // Parameter names must be PascalCase per the bSDD OpenAPI spec
-    const raw = await fetchJson<Record<string, unknown>>(
-      `${BSDD_API}/api/Class/v1?Uri=${encodeURIComponent(uri)}&IncludeClassProperties=true&IncludeClassRelations=true`,
-    );
+    let raw: Record<string, unknown>;
+    try {
+      raw = await fetchJson<Record<string, unknown>>(
+        `${BSDD_API}/api/Class/v1?Uri=${encodeURIComponent(uri)}&IncludeClassProperties=true&IncludeClassRelations=true`,
+      );
+    } catch {
+      const fallbackUri = await resolveFallbackClassUri(ifcType);
+      if (!fallbackUri || fallbackUri === uri) {
+        throw new Error('bSDD class lookup failed');
+      }
+      uri = fallbackUri;
+      const fallbackCached = getCached(uri);
+      if (fallbackCached) return fallbackCached;
+      raw = await fetchJson<Record<string, unknown>>(
+        `${BSDD_API}/api/Class/v1?Uri=${encodeURIComponent(uri)}&IncludeClassProperties=true&IncludeClassRelations=true`,
+      );
+    }
 
     let info = mapClassResponse(raw, true);
 

package/src/services/cacheService.ts

@@ -71,7 +71,7 @@ let cacheService: ICacheService | null = null;
 export async function getCacheService(): Promise<ICacheService> {
   if (cacheService) return cacheService;
 
-  if (isTauri) {
+  if (isTauri()) {
     // Desktop: Use Tauri native filesystem
     const mod = await import('./desktop-cache.js');
     cacheService = {

package/src/services/desktop-cache.ts

@@ -141,3 +141,46 @@ export async function hasCached(key: string): Promise<boolean> {
   const data = await getCached(key);
   return data !== null;
 }
+
+export async function hasNativeGeometryCache(key: string): Promise<boolean> {
+  try {
+    const inv = await getInvoke();
+    return await inv<boolean>('has_native_geometry_cache', { cacheKey: key });
+  } catch (error) {
+    console.warn('[DesktopCache] Failed to check native geometry cache:', error);
+    return false;
+  }
+}
+
+export async function getNativeModelSnapshot(key: string): Promise<ArrayBuffer | null> {
+  try {
+    const inv = await getInvoke();
+    const data = await inv<number[] | null>('get_native_model_snapshot', { cacheKey: key });
+    return data ? new Uint8Array(data).buffer : null;
+  } catch (error) {
+    console.warn('[DesktopCache] Failed to read native model snapshot:', error);
+    return null;
+  }
+}
+
+export async function setNativeModelSnapshot(key: string, buffer: ArrayBuffer): Promise<void> {
+  try {
+    const inv = await getInvoke();
+    await inv('set_native_model_snapshot', {
+      cacheKey: key,
+      data: Array.from(new Uint8Array(buffer)),
+    });
+  } catch (error) {
+    console.warn('[DesktopCache] Failed to write native model snapshot:', error);
+  }
+}
+
+export async function hasNativeModelSnapshot(key: string): Promise<boolean> {
+  try {
+    const inv = await getInvoke();
+    return await inv<boolean>('has_native_model_snapshot', { cacheKey: key });
+  } catch (error) {
+    console.warn('[DesktopCache] Failed to check native model snapshot:', error);
+    return false;
+  }
+}

package/src/services/desktop-export.ts

@@ -0,0 +1,77 @@
+/* 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 { IfcParser, type IfcDataStore } from '@ifc-lite/parser';
+import { getViewerStoreApi } from '@/store';
+import { toast } from '@/components/ui/toast';
+import { readNativeFile } from '@/services/file-dialog';
+
+const exportHydrationByModel = new Map<string, Promise<IfcDataStore | null>>();
+
+function isDesktopRuntime(): boolean {
+  const win = globalThis as Window & { __TAURI_INTERNALS__?: { invoke?: unknown } };
+  return typeof win.__TAURI_INTERNALS__?.invoke === 'function';
+}
+
+function hasFullStepSource(dataStore: IfcDataStore | null | undefined): dataStore is IfcDataStore {
+  return Boolean(dataStore?.source?.length && dataStore.entityIndex?.byId?.size);
+}
+
+function toExactArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  if (
+    bytes.buffer instanceof ArrayBuffer
+    && bytes.byteOffset === 0
+    && bytes.byteLength === bytes.buffer.byteLength
+  ) {
+    return bytes.buffer;
+  }
+  return bytes.slice().buffer;
+}
+
+export async function ensureModelExportReady(modelId: string): Promise<IfcDataStore | null> {
+  const store = getViewerStoreApi();
+  const state = store.getState();
+
+  if (modelId === '__legacy__') {
+    return state.ifcDataStore;
+  }
+
+  const model = state.models.get(modelId);
+  if (!model) {
+    return null;
+  }
+
+  if (hasFullStepSource(model.ifcDataStore)) {
+    return model.ifcDataStore;
+  }
+
+  if (!isDesktopRuntime() || !model.nativeMetadata?.filePath) {
+    return model.ifcDataStore;
+  }
+
+  const pending = exportHydrationByModel.get(modelId);
+  if (pending) {
+    return pending;
+  }
+
+  const hydrationPromise = (async () => {
+    toast.info(`Preparing ${model.name} for IFC export...`);
+    const bytes = await readNativeFile(model.nativeMetadata!.filePath);
+    const parser = new IfcParser();
+    const hydratedStore = await parser.parseColumnar(toExactArrayBuffer(bytes));
+
+    store.getState().updateModel(modelId, {
+      ifcDataStore: hydratedStore,
+      schemaVersion: hydratedStore.schemaVersion,
+      metadataLoadState: 'complete',
+    });
+
+    return hydratedStore;
+  })().finally(() => {
+    exportHydrationByModel.delete(modelId);
+  });
+
+  exportHydrationByModel.set(modelId, hydrationPromise);
+  return hydrationPromise;
+}

package/src/services/desktop-harness.ts

@@ -0,0 +1,196 @@
+/* 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 { NativeFileHandle } from './file-dialog.js';
+
+type InvokeFn = <T>(cmd: string, args?: Record<string, unknown>) => Promise<T>;
+
+interface TauriInternals {
+  invoke: InvokeFn;
+}
+
+export interface DesktopHarnessRequest {
+  file: NativeFileHandle;
+  replaceFile?: NativeFileHandle;
+  telemetryOutputPath?: string;
+  runLabel?: string;
+  exitAfterTelemetry: boolean;
+  waitForMetadataCompletion: boolean;
+}
+
+export interface DesktopTelemetryReport {
+  schemaVersion: number;
+  source: 'desktop-native';
+  mode: 'startup-harness' | 'manual';
+  success: boolean;
+  runLabel?: string;
+  cache?: {
+    key?: string | null;
+    hit?: boolean | null;
+    manifestMeshCount?: number | null;
+    manifestShardCount?: number | null;
+  } | null;
+  file: {
+    path: string;
+    name: string;
+    sizeBytes: number;
+    sizeMB: number;
+  };
+  timings: Record<string, number | null>;
+  batches: Record<string, number | string | null>;
+  nativeStats?: Record<string, number | null> | null;
+  metadata?: Record<string, number | boolean | null> | null;
+  firstBatchTelemetry?: Record<string, number | string | null> | null;
+  error?: string;
+}
+
+let activeHarnessRequest: DesktopHarnessRequest | null = null;
+let startupHarnessRequestPromise: Promise<DesktopHarnessRequest | null> | null = null;
+const STORAGE_KEY = 'ifc-lite:desktop-harness-request';
+const CLAIMED_KEY = 'ifc-lite:desktop-harness-claimed';
+
+function getInvoke(): InvokeFn | null {
+  const win = globalThis as unknown as { __TAURI_INTERNALS__?: TauriInternals };
+  return win.__TAURI_INTERNALS__?.invoke ?? null;
+}
+
+async function consumeStartupHarnessRequest(): Promise<DesktopHarnessRequest | null> {
+  const invoke = getInvoke();
+  if (!invoke) {
+    return null;
+  }
+
+  try {
+    return await invoke<DesktopHarnessRequest | null>('consume_startup_harness_request');
+  } catch (error) {
+    console.warn('[DesktopHarness] Failed to consume startup harness request:', error);
+    return null;
+  }
+}
+
+function getHarnessRequestFingerprint(request: DesktopHarnessRequest): string {
+  return JSON.stringify({
+    path: request.file.path,
+    replacePath: request.replaceFile?.path ?? null,
+    telemetryOutputPath: request.telemetryOutputPath ?? null,
+    runLabel: request.runLabel ?? null,
+    exitAfterTelemetry: request.exitAfterTelemetry,
+    waitForMetadataCompletion: request.waitForMetadataCompletion,
+  });
+}
+
+function getClaimedFingerprint(): string | null {
+  try {
+    return sessionStorage.getItem(CLAIMED_KEY);
+  } catch {
+    return null;
+  }
+}
+
+function setClaimedFingerprint(fingerprint: string | null): void {
+  try {
+    if (fingerprint) {
+      sessionStorage.setItem(CLAIMED_KEY, fingerprint);
+    } else {
+      sessionStorage.removeItem(CLAIMED_KEY);
+    }
+  } catch {
+    // Ignore storage issues.
+  }
+}
+
+export function setActiveHarnessRequest(request: DesktopHarnessRequest | null): void {
+  activeHarnessRequest = request;
+  try {
+    if (request) {
+      sessionStorage.setItem(STORAGE_KEY, JSON.stringify(request));
+      if (getClaimedFingerprint() !== getHarnessRequestFingerprint(request)) {
+        setClaimedFingerprint(null);
+      }
+    } else {
+      sessionStorage.removeItem(STORAGE_KEY);
+    }
+  } catch {
+    // Ignore storage issues in non-browser or restricted contexts.
+  }
+}
+
+export function getActiveHarnessRequest(): DesktopHarnessRequest | null {
+  if (!activeHarnessRequest) {
+    try {
+      const raw = sessionStorage.getItem(STORAGE_KEY);
+      if (raw) {
+        activeHarnessRequest = JSON.parse(raw) as DesktopHarnessRequest;
+      }
+    } catch {
+      // Ignore storage parse failures and fall back to in-memory state.
+    }
+  }
+  return activeHarnessRequest;
+}
+
+export async function getStartupHarnessRequest(): Promise<DesktopHarnessRequest | null> {
+  const existing = getActiveHarnessRequest();
+  if (existing) {
+    return existing;
+  }
+
+  if (!startupHarnessRequestPromise) {
+    startupHarnessRequestPromise = consumeStartupHarnessRequest().then((request) => {
+      if (request) {
+        setActiveHarnessRequest(request);
+      }
+      return request;
+    });
+  }
+
+  return await startupHarnessRequestPromise;
+}
+
+export function tryClaimStartupHarnessRequest(request: DesktopHarnessRequest): boolean {
+  const active = getActiveHarnessRequest();
+  if (!active) {
+    return false;
+  }
+
+  const requestFingerprint = getHarnessRequestFingerprint(request);
+  if (getHarnessRequestFingerprint(active) !== requestFingerprint) {
+    return false;
+  }
+
+  if (getClaimedFingerprint() === requestFingerprint) {
+    return false;
+  }
+
+  setClaimedFingerprint(requestFingerprint);
+  return true;
+}
+
+export function clearActiveHarnessRequest(): void {
+  activeHarnessRequest = null;
+  startupHarnessRequestPromise = null;
+  try {
+    sessionStorage.removeItem(STORAGE_KEY);
+  } catch {
+    // Ignore storage issues.
+  }
+  setClaimedFingerprint(null);
+}
+
+export async function finalizeActiveHarnessRun(report: DesktopTelemetryReport): Promise<string | null> {
+  const invoke = getInvoke();
+  const request = getActiveHarnessRequest();
+  clearActiveHarnessRequest();
+
+  if (!invoke || !request) {
+    return null;
+  }
+
+  try {
+    return await invoke<string>('write_desktop_telemetry', { report });
+  } catch (error) {
+    console.warn('[DesktopHarness] Failed to write desktop telemetry:', error);
+    return null;
+  }
+}

package/src/services/desktop-logger.ts

@@ -0,0 +1,20 @@
+/* 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>;
+
+type LogLevel = 'info' | 'warn' | 'error';
+
+export async function logToDesktopTerminal(level: LogLevel, message: string): Promise<void> {
+  const win = globalThis as unknown as { __TAURI_INTERNALS__?: { invoke: InvokeFn } };
+  if (!win.__TAURI_INTERNALS__?.invoke) {
+    return;
+  }
+
+  try {
+    await win.__TAURI_INTERNALS__.invoke('frontend_debug_log', { level, message });
+  } catch {
+    // Debug logging should never break app behavior.
+  }
+}

package/src/services/desktop-native-metadata.ts

@@ -0,0 +1,207 @@
+/* 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 {
+  NativeMetadataEntityDetails,
+  NativeMetadataEntitySummary,
+  NativeMetadataSnapshot,
+} from '@/store/types';
+import type { MetadataBootstrapPayload } from '@ifc-lite/geometry';
+import { getNativeModelSnapshot, setNativeModelSnapshot } from './desktop-cache';
+
+type InvokeFn = <T>(cmd: string, args?: Record<string, unknown>) => Promise<T>;
+
+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 core = await import('@tauri-apps/api/core');
+  return core.invoke as InvokeFn;
+}
+
+interface NativeMetadataBootstrapPayload {
+  cacheKey: string;
+  schemaVersion: string;
+  entityCount: number;
+  spatialTree: NativeMetadataSnapshot['spatialTree'];
+}
+
+function toSchemaVersion(schemaVersion: string): NativeMetadataSnapshot['schemaVersion'] {
+  if (schemaVersion === 'IFC4X3' || schemaVersion === 'IFC4' || schemaVersion === 'IFC5') {
+    return schemaVersion;
+  }
+  return 'IFC2X3';
+}
+
+export function nativeMetadataSnapshotFromBootstrap(
+  path: string,
+  payload: MetadataBootstrapPayload
+): NativeMetadataSnapshot {
+  return {
+    mode: 'desktop-lazy',
+    cacheKey: payload.cacheKey,
+    filePath: path,
+    schemaVersion: toSchemaVersion(payload.schemaVersion),
+    entityCount: payload.entityCount,
+    spatialTree: payload.spatialTree ?? null,
+  };
+}
+
+export async function bootstrapNativeMetadata(path: string, cacheKey: string): Promise<NativeMetadataSnapshot> {
+  const invoke = await getInvoke();
+  const result = await invoke<NativeMetadataBootstrapPayload>('bootstrap_native_metadata', {
+    path,
+    cacheKey,
+  });
+  return {
+    mode: 'desktop-lazy',
+    cacheKey: result.cacheKey,
+    filePath: path,
+    schemaVersion: toSchemaVersion(result.schemaVersion),
+    entityCount: result.entityCount,
+    spatialTree: result.spatialTree ?? null,
+  };
+}
+
+export async function restoreNativeMetadataSnapshot(cacheKey: string): Promise<NativeMetadataSnapshot | null> {
+  const buffer = await getNativeModelSnapshot(cacheKey);
+  if (!buffer) return null;
+  try {
+    const payload = JSON.parse(new TextDecoder().decode(new Uint8Array(buffer))) as NativeMetadataSnapshot;
+    if (payload?.mode !== 'desktop-lazy' || payload.cacheKey !== cacheKey) {
+      return null;
+    }
+    return {
+      ...payload,
+      schemaVersion: toSchemaVersion(payload.schemaVersion),
+      spatialTree: payload.spatialTree ?? null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function persistNativeMetadataSnapshot(snapshot: NativeMetadataSnapshot): Promise<void> {
+  const bytes = new TextEncoder().encode(JSON.stringify(snapshot));
+  await setNativeModelSnapshot(snapshot.cacheKey, bytes.buffer);
+}
+
+export async function getNativeMetadataChildren(cacheKey: string, expressId: number): Promise<NativeMetadataEntitySummary[]> {
+  const invoke = await getInvoke();
+  const result = await invoke<Array<{
+    expressId: number;
+    typeName: string;
+    name: string;
+    globalId?: string | null;
+    kind: 'spatial' | 'element';
+    hasChildren: boolean;
+    elementCount?: number;
+    elevation?: number | null;
+  }>>('get_native_metadata_children', {
+    cacheKey,
+    expressId,
+  });
+  return result.map((entry) => ({
+    expressId: entry.expressId,
+    type: entry.typeName,
+    name: entry.name,
+    globalId: entry.globalId ?? undefined,
+    kind: entry.kind,
+    hasChildren: entry.hasChildren,
+    elementCount: entry.elementCount,
+    elevation: entry.elevation ?? undefined,
+  }));
+}
+
+export async function getNativeEntityDetails(cacheKey: string, expressId: number): Promise<NativeMetadataEntityDetails> {
+  const invoke = await getInvoke();
+  const result = await invoke<{
+    summary: {
+      expressId: number;
+      typeName: string;
+      name: string;
+      globalId?: string | null;
+      kind: 'spatial' | 'element';
+      hasChildren: boolean;
+      elementCount?: number;
+      elevation?: number | null;
+    };
+    typeSummary?: {
+      expressId: number;
+      typeName: string;
+      name: string;
+      globalId?: string | null;
+      kind: 'spatial' | 'element';
+      hasChildren: boolean;
+      elementCount?: number;
+      elevation?: number | null;
+    } | null;
+    spatial?: {
+      storeyId?: number | null;
+      storeyName?: string | null;
+      elevation?: number | null;
+      height?: number | null;
+    } | null;
+    properties: NativeMetadataEntityDetails['properties'];
+    quantities: NativeMetadataEntityDetails['quantities'];
+  }>('get_native_entity_details', {
+    cacheKey,
+    expressId,
+  });
+
+  const mapSummary = (entry: NonNullable<typeof result['summary']>): NativeMetadataEntitySummary => ({
+    expressId: entry.expressId,
+    type: entry.typeName,
+    name: entry.name,
+    globalId: entry.globalId ?? undefined,
+    kind: entry.kind,
+    hasChildren: entry.hasChildren,
+    elementCount: entry.elementCount,
+    elevation: entry.elevation ?? undefined,
+  });
+
+  return {
+    summary: mapSummary(result.summary),
+    typeSummary: result.typeSummary ? mapSummary(result.typeSummary) : null,
+    spatial: result.spatial
+      ? {
+          storeyId: result.spatial.storeyId ?? null,
+          storeyName: result.spatial.storeyName ?? null,
+          elevation: result.spatial.elevation ?? null,
+          height: result.spatial.height ?? null,
+        }
+      : null,
+    properties: result.properties,
+    quantities: result.quantities,
+  };
+}
+
+export async function searchNativeMetadataEntities(cacheKey: string, query: string, limit = 100): Promise<NativeMetadataEntitySummary[]> {
+  const invoke = await getInvoke();
+  const result = await invoke<Array<{
+    expressId: number;
+    typeName: string;
+    name: string;
+    globalId?: string | null;
+    kind: 'spatial' | 'element';
+    hasChildren: boolean;
+    elementCount?: number;
+    elevation?: number | null;
+  }>>('search_native_metadata_entities', {
+    cacheKey,
+    query,
+    limit,
+  });
+  return result.map((entry) => ({
+    expressId: entry.expressId,
+    type: entry.typeName,
+    name: entry.name,
+    globalId: entry.globalId ?? undefined,
+    kind: entry.kind,
+    hasChildren: entry.hasChildren,
+    elementCount: entry.elementCount,
+    elevation: entry.elevation ?? undefined,
+  }));
+}

package/src/services/desktop-panel-actions.ts

@@ -0,0 +1,43 @@
+/* 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 type DesktopPanelActionType =
+  | 'bcf-import'
+  | 'bcf-export'
+  | 'ids-open'
+  | 'ids-run-validation';
+
+interface DesktopPanelAction {
+  id: number;
+  type: DesktopPanelActionType;
+}
+
+type DesktopPanelActionListener = () => void;
+
+let nextActionId = 1;
+const pendingActions: DesktopPanelAction[] = [];
+const listeners = new Set<DesktopPanelActionListener>();
+
+export function requestDesktopPanelAction(type: DesktopPanelActionType): void {
+  pendingActions.push({ id: nextActionId++, type });
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+export function claimNextDesktopPanelAction(type: DesktopPanelActionType): DesktopPanelAction | null {
+  const index = pendingActions.findIndex((action) => action.type === type);
+  if (index < 0) {
+    return null;
+  }
+  const [action] = pendingActions.splice(index, 1);
+  return action ?? null;
+}
+
+export function subscribeDesktopPanelActions(listener: DesktopPanelActionListener): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}